Recommended Free Tools
Some links on this page are affiliate links: if you buy through them we may earn a commission, at no extra cost to you.
Yes—the Hackaday feature published May 25, 2021 presents a real, small shoot-’em-up project and a video walkthrough. But “30-minute course” describes the video’s scope, not a guaranteed build time. The game uses Seeed’s ArduPy environment on a Wio Terminal, so its code is not a drop-in MicroPython game for a Raspberry Pi Pico or any other board.
What the game does
The project, invasion-ardupy-game, is a compact retro shooter. You move a ship, fire at enemies, avoid or manage screen boundaries, and track a score. The Wio Terminal’s physical controls provide input, and its built-in buzzer adds sound. Start and halt controls are part of the program; the halt button is also a practical debugging escape route.
This is a small playable demonstration, not a general-purpose game engine. Its value is that the source makes a recognizable game out of a few fundamentals: coordinates, sprites, input, state, collisions, rendering, scoring, and audiovisual feedback.
What’s actually slowing this PC down?
Pick the symptom - the matching free tool is one click away.
Why it works as a short game-development lesson
A simple 2D game is organized around a loop: read input, update positions, check for collisions, update game state, draw the scene, then repeat. The walkthrough’s educational advantage is its incremental presentation of features, rather than just handing viewers a finished code file. Beginners can connect each new behavior—movement, firing, enemy hits, score changes—to the code responsible for it.
#1 Best Overall
- The Raspberry Pi Pico is a beginner-friendly microcontroller board that uses MicroPython to give you a taste of the Internet of Things and microcontrollers. The RP2040 is a well-designed microprocessor that can be utilized in almost any Internet of Things project. It has enough power to complete the task quickly.
- 【Raspberry Pi RP2040 Microcontroller】Raspberry Pi Pico features Dual-core ARM Cortex M0+ processor, flexible clock running up to 133 MHz. With 264KB of SRAM, and 2MB of on-board Flash memory.Supports up to 16 MB of off chip flash memory via a dedicated QSPI bus
- 【Multiple Software Support】Pico has rich and complete software support, it comes with a complete Rasberry Pi official C/C++ SDK, Micropython SDK.The programming and burning of Pico need to be carried out on the computer. Supported operating systems and computers include:Raspberry Pie with Raspberry Pi OS,Other platforms equipped with Debian based Linux system Computer with MacOS, Computers with Windows, etc.
- 【Rich Hardware Interface】Raspberry Pi Pico has 30 GPIO pins, 4 pins for analog signal input and 26 × multi-function GPIO pins, 2 × SPI, 2 × I2C, 2 × UART, 3 × 12-bit ADC, 16 × controllable PWM channels.USB 1.1 supported by host and device, The installation mode can be flexibly selected by users to facilitate welding with other development boards.
- 【Build Project in Tiny Size】Only 2.1cm*5.1cm ( as small as your thumb). Pico has been designed to use either soldered 0.1" pin-headers or can be used as a surface-mountable 'module'.
- Read controls: Poll the directional switch and buttons through board-specific pin objects.
- Update objects: Move the player, bullets, and enemies using their positions and dimensions.
- Test collisions: Compare object bounds to determine whether a projectile overlaps an enemy.
- Change state: Remove or reset hit objects and update the score or game status.
- Redraw: Render the updated scene, then continue the loop.
For rectangular objects, the basic overlap test is that each object’s horizontal and vertical ranges intersect. For example, a player is left of an enemy’s right edge, right of its left edge, above its bottom edge, and below its top edge. That simple idea underpins many early arcade games. The project’s small scope makes it easier to see how the rule connects to sprites and scoring.
The board and software matter
The headline’s “MicroPython” shorthand can obscure an important compatibility detail: this particular code uses ArduPy, Seeed’s Arduino/MicroPython integration, on the Wio Terminal. Its imports include LCD, Sprite, Map, and Pin. The first three, along with the board’s named pin mappings, are not a generic graphics and hardware API available on every MicroPython port.
Rank #2
- Raspberry Pi Pico: A tiny, fast, and versatile board built using dual-core Arm Cortex-M0+ processor (Comes with pinout card and stickers)
- Detailed Tutorial: Provides step-by-step guide with MicroPython, C and Processing (Java) Code (The download link can be found on the product box) (No paper tutorial)
- Example Projects: Each project has schematics, wiring diagrams, complete code and detailed explanations (Need extra items)
- Easy to Use: Just connect the board to your computer (installed IDE) with the USB cable to program it
- Get Support: Our technical support team is always ready to answer your questions
| Part | Original project |
|---|---|
| Board | Seeed Studio Wio Terminal |
| Runtime/API layer | ArduPy |
| Display | Integrated 320×240 LCD |
| Controls | Five-way switch and buttons |
| Sound | Integrated buzzer |
| Source | main.py |
The Wio Terminal is based on an ATSAMD51P19 microcontroller and includes the screen, controls, and buzzer the game needs. That integration is the convenience: no separate display, joystick, buttons, or speaker are required for the core project. The board also has other features—such as an IMU, microphone, microSD slot, and wireless hardware—but they are not requirements for this game. Seeed’s Wio Terminal documentation describes the hardware and setup context.
Quick wins for a faster PC:
Scan for outdated or missing drivers - takes under a minuteDriver Scan →Clear out junk files and repair common Windows errorsFree Scan →Fix the driver behind crashes, sound loss and screen glitchesFind Drivers →What to look for in the source
The source creates separate sprite objects for the ship, bullet, enemy, and score display. It defines a 21×21 ship, a 1×4 bullet, and a 16×12 enemy, with a resize factor of 2. Storing small pixel patterns as numeric color arrays and enlarging them is a straightforward way to keep sprite data compact while making it visible on a small screen.
Rank #3
- Latest Version: Higher core clock speed, double memory, more powerful Arm cores, optional RISC-V cores (compared to the 1 series) (This W version has onboard wireless LAN and Bluetooth)
- Switchable Cores: Allows users to choose between dual industry-standard Arm Cortex-M33 cores and dual open-hardware Hazard3 cores
- Compatibility: Delivers a significant performance boost, while retaining software- and hardware-compatible with the 1 series
- Detailed Tutorial: Provides step-by-step guide with MicroPython, C and Processing (Java) Code (The download link can be found on the product box) (No paper tutorial)
- Example Projects: Each project has schematics, wiring diagrams, complete code and detailed explanations (Need extra items)
Input is polled from Wio Terminal pins rather than delivered as desktop-style keyboard events. The code maps the five-way switch and buttons to pins, then checks their values while the game runs. Button polarity can vary by board and configuration: do not assume that a returned 1 always means pressed. If controls behave backwards, inspect the actual pin values and the source’s expected logic before changing movement code.
The main file is useful to study as a complete example, but reading all of it at once is less helpful than tracing one feature through the loop. Follow a bullet from the fire input, through movement and collision checks, to the score update. Then do the same for an enemy or the start/halt controls. The halt control’s sys.exit() behavior is a small but useful example of adding a development escape hatch to a program running on hardware.
Rank #4
- This breakout board is specially made for Raspberry Pi Pico, with additional pin headers, which are fully compatible with the board
- The product needs to be soldered by itself, and the pico can be inserted after successful welding
- The breakout board is gold-plated on both sides and holes are plated, and the material of the PCB board is excellent
- The breakout board is equipped with Raspberry Pi pico, which is convenient for users to develop and integrate flexibly
- Note: The package does not include Raspberry Pi pico. This product needs to be soldered and assembled by yourself
Can you reproduce it today?
The hardware and the software have different current-status signals. The Wio Terminal product page showed the board in stock at $33 when checked on August 18, 2026; price, inventory, shipping, taxes, and regional availability may change. Seeed’s documentation lists a computer and USB Type-C cable among the basic setup needs. The ArduPy repository, however, was archived on February 21, 2022. Its source remains available, but archived software should be treated as a historical platform, not a promise of frictionless installation on current computers.
For an exact reproduction, use the Wio Terminal and original repository, then follow the setup instructions available for the ArduPy workflow. Confirm that the computer recognizes the board, transfer main.py using the supported workflow, and check LCD initialization, movement, firing, collisions, score changes, and buzzer output in turn. If the current toolchain will not install or recognize the board, that may be a legacy-environment problem rather than a bug in the game logic.
Best Value
- RPi Pico 2 W Microcontroller Board (pre-soldered header (color-coded)), Based on Official RP2350 Chip, Dual-core & Dual-architecture Design. Upgraded hardware from Pico 2 with wireless communication, onboard antenna, features 2.4GHz 802.11n WIFI and Bluetooth 5.2.
- Adopts unique dual-core and dual-architecture design: dual-core Arm Cortex-M33 processor and dual-core Hazard3 RISC-V processor, flexible clock running up to 150 MHz.
- Onboard Infineon CYW43439 wireless chip, supports WIFI 4 wireless and Bluetooth 5.2.
- 520KB of SRAM, and 4MB of on-board Flash memory.
- Castellated module allows soldering direct to carrier boards. USB 1.1 with device and host support. Low-power sleep and dormant modes. Drag-and-drop programming using mass storage over USB.
The game does not need wireless connectivity. Seeed’s documentation notes that wireless support in the software context it describes is limited to Arduino, but that limitation does not affect the game’s local display, controls, or sound.
Independent reader supportYour contribution helps us test, update, and keep practical guides available for everyone.Why the original code will not run unchanged on a Pico
Stock MicroPython on a Raspberry Pi Pico does not automatically provide the Wio-specific LCD, Sprite, or Map interfaces used here. Even where a machine.Pin class exists, the display driver, pin assignments, controls, graphics routines, and sound implementation differ. A Pico version is a port, not a matter of copying main.py.
A port needs a supported display and its connection (often SPI or I²C), physical controls, a new GPIO map, and either a graphics library or custom drawing code. It must replace the Wio sprite and display APIs, and adapt buzzer output and file transfer. Raspberry Pi’s MicroPython setup guide explains the Pico workflow: hold BOOTSEL while connecting the board, copy the correct UF2 firmware to the mounted drive, then access the MicroPython REPL over USB serial. That is the Pico firmware-install path, not an installation method for ArduPy on the Wio Terminal. The official Pico firmware page showed MicroPython v1.28.0 dated April 6, 2026; a current firmware release does not make this board-specific game portable.
Which route makes sense?
- Choose the Wio Terminal if you want the closest match to the original project, an integrated screen and controls, and are willing to work with archived software tooling.
- Use a Pico or Pico 2 you already own if your goal is current MicroPython learning and you are happy to add hardware and rewrite the board-specific layer.
- Skip the hardware purchase if you mainly want to understand game-loop logic. The source and video can still teach those concepts without a physical build.
The Wio’s integrated components may make the complete device more convenient than a bare microcontroller board, but buying it solely on the assumption that a currently maintained ArduPy course environment is ready to go would be a poor fit. Hardware being listed for sale and the original software stack being actively maintained are separate questions.
Common troubleshooting clues
- Missing
LCDorSpriteimports: Check that you are using the intended ArduPy/Wio environment. A generic MicroPython interpreter is not sufficient. - Board not detected or upload fails: Check the USB connection and the board-specific setup workflow. If an archived dependency no longer installs cleanly, distinguish that from errors in the game itself.
- Blank or misinitialized display: Verify the runtime and display initialization before debugging sprites or collisions.
- Controls move in reverse or do not respond: Inspect pin readings and button polarity; do not assume active-high behavior.
- Visible sprites do not seem to collide: Compare the object coordinates and collision bounds with the sprite’s scaled dimensions. A visual resize factor and the logical hitbox may not be identical.
- Game feels sluggish: A loop must balance input polling, movement, collision checks, redraw work, and sound. Avoid assuming a frame rate; assess responsiveness on the actual board and runtime.
In short, the “30-minute course” is a useful compact guided overview of embedded 2D game structure, not a timed beginner build guarantee. The concepts remain approachable; the exact reproduction is constrained by ArduPy’s archived status, and a modern MicroPython board requires a genuine port.
Quick Recap
Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.
