Smashcat started by porting Manic Miner, the ZX Spectrum platformer, to an Arduino Uno. That port has since become a general game engine. According to Hackaday's October 26, 2026 write-up, the engine now runs Manic Miner, Scramble, Space Invaders and Pac-Man. The project's GitHub repository names the newest title as Pac-Man Championship Edition.
The interesting part is how it works. The engine has no framebuffer. It produces each line of the picture at the moment the display needs it, a technique usually called "racing the beam," and outputs composite video. The hardware needed is about as small as hardware gets: two resistors for video and a few more parts for sound.
What the engine does
The GitHub README says the engine is for the original Arduino UNO with the ATmega328P microcontroller and will not work on any other Arduino version. It lists these features:
- Video: composite output using 2 resistors
- Resolution: effective 256x256, with no framebuffer ("racing the beam")
- Background: scrolling tilemap
- Sprites: up to 9 sprites of 16x16, with up to 7 on a single scanline
- Collision: pixel-perfect collision detection for 1 sprite
- Frame rate: fixed at 50 fps
The Hackaday.io project page, posted by Scott Porter and created on 10/12/2026, adds a few things. It says the engine supports 256x256 scrolling tilemaps, split-screen scrolling in any direction and two-channel PWM audio, all at a locked 50 FPS. Hackaday's article also describes the audio as two PWM channels. It adds that an NES controller can be connected if you want one.
The per-scanline sprite limit matters for anyone designing a game. Nine sprites can be on screen in total, but no more than seven can share one horizontal line. Check a game idea against both limits early.
Why the crystal matters
The engine has one hard hardware requirement. Hackaday reports that the locked 50 FPS output works only on a real Uno with a crystal oscillator. Some replica boards lack a timekeeping source accurate enough to reproduce the video signal; the README says cheaper "Arduino compatible" boards that use resonators instead of crystals caused extreme jitter in the image for the author. They can't keep accurate enough timing for the video signal. The README makes a related point when it says the engine targets the original UNO with the ATmega328P only.
If you have a drawer full of cheap clones, check the clock source on each board before you flash the engine. A board that runs ordinary sketches without trouble may still be too imprecise for timing-critical video.
What you need to build
The minimum build is small. The Hackaday.io page lists a couple of resistors for video, some buttons, and resistors plus a transistor for a speaker. Hackaday describes the display side as "a few resistors" to connect a monitor, with the NES controller optional.
If you would rather not breadboard it, the repository includes a PCB design for a UNO shield. Per the README, the shield has buttons, composite output, a speaker driver and a footprint for an NES controller port. The repository includes production files for JLCPCB assembly. The author estimates a cost of about GBP 4 per board, including delivery to the UK, when ordering 20 assembled boards from JLCPCB (the NES port and header pins are not included). That is the author's estimate from the README, not a quote and not a product for sale. The Hackaday.io page also has the PCB production files, shield design files and a schematic attached.
The games
The README lists four games:
- Manic Miner: all 20 levels
- Scramble
- Space Invaders
- Pac-Man Championship Edition
Pac-Man Championship Edition is the main subject of the Hackaday.io page. Porter writes that the game needed heavy memory management to make the scrolling mazes work. On a microcontroller this small, memory is the tightest constraint, and a scrolling, constantly changing maze is far more demanding than a fixed single screen.
Each game is also a demonstration of the engine. Between them they cover scrolling playfields, many moving sprites, single-screen action and a full level set ported from an existing game.
Try it without hardware
Both Hackaday and the Hackaday.io page mention a WebAssembly version, so you can see the engine run in a browser before you order parts or check your boards for crystals. That is useful for checking whether a game idea fits the sprite and scanline limits before you commit to building anything.
What It Means for Makers
Who it is for: the main audience is people who own a genuine, crystal-clocked Arduino UNO with an ATmega328P and want to see how far it can be pushed. That includes retro-gaming hobbyists, embedded developers interested in cycle-counted video generation, and educators who want a concrete example of real-time constraints.
What it enables: composite video, a scrolling 256x256 playfield, up to nine 16x16 sprites, pixel-perfect collision for one sprite, two-channel PWM sound and a locked 50 fps, all from an Uno and a few resistors and other small parts with no framebuffer. The sources show that a standard UNO can do it on its own, within the stated limits.
What it doesn't cover: the sources say clearly that resonator-clocked replica boards can't produce the video signal reliably. The engine targets the original UNO with the ATmega328P only. Don't expect it to work on other boards that carry the Arduino name.
Price and availability: the engine, games, UNO shield PCB design and JLCPCB production files are published now in the Smashcat/UNO_Manic_Miner repository, which had 62 commits when we checked. There is no commercial product, pre-order or crowdfunding campaign. The only cost the sources give is the author's estimate of about GBP 4 per board for 20 assembled shields from JLCPCB, as stated in the README. A WebAssembly version lets you try the engine in a browser first.
