Start a project
Studio render of the Zappit Racer: a light grey 3D-printed body with teal headlights glowing through its light windows, and the IR turret seated in the roof, its translucent cover lit from inside by the charge LEDs.

Rendered from our PCB & CAD files

Zappit Racer Working prototype

Palm-sized combat racing, built from the circuit board up.

A palm-sized racer whose circuit board is its chassis. Clip on the IR turret and it fights: weapons charge, fire and spin a rival out. Coloured zones on a 3D-printed track trigger spinouts, refuels and lap times, and an app runs the race.

Build something like this Inside the lab
Type
Hardware lab prototype
Our role
Electronics, mechanical design, firmware, app and backend
Platforms
ESP32-H2 hardware · Flutter app · Xano backend
Status
Working prototype
weapons, each with its own recharge time and hit penalty
4
from flat to a full charge over USB-C, measured on the car
110 min
to send one IR shot, tagged with the attacker and weapon
24 ms
lap on the 41-piece Circuit One track
6.1 m

The challenge

Most RC toys stop at “drive it around”. We wanted a platform for real games: cars that know where they are on the track, can shoot each other and keep score — small enough to race on a tabletop, and simple enough to build a whole grid of them.

What we built

We started from StuckAtPrototype’s open-source Micro Racer, a car whose PCB doubles as its chassis, and turned it into a combat racing system: a colour-sensor board that reads the track, a plug-in IR turret, a modular 3D-printed circuit, a reworked handheld controller, game firmware and a multiplayer app.

  1. 01

    Pair

    Cars are found over Bluetooth LE and claimed into your garage in the app.

  2. 02

    Lobby

    A host opens a lobby and friends join with a code — up to four cars on the grid.

  3. 03

    Race

    The colour sensor reads the track: green counts laps, red spins you out, blue pit plates refuel.

  4. 04

    Fight

    Turrets charge, fire when full and spin a hit rival out. Laps and hits feed the leaderboard.

Combat

Four weapons. One rule: charge, then fire.

The turret’s LEDs fill as it charges, and it fires when full — kicking the shooter back. A hit spins the target out and locks its motors; the weapon decides how hard.

WeaponRechargeOn a hit
Rapid Fire1 sA jolt, 1 s stun
EMP Cannon6 sDead stop, 6 s stun
Laser Blaster10 s1 s spin-out
Bazooka10 sBig spin, 3 s stun

Capabilities

What makes Zappit Racer different.

  • The car is the circuit board

    An ESP32-H2 board doubles as the chassis: four motor drivers, USB-C charging and five addressable LEDs on a 36 × 50 mm, four-layer PCB.

  • IR combat turret

    A plug-in board with an IR transmitter, a 38 kHz receiver, five LEDs and a buzzer — driven by the car’s own processor, so there’s no second chip.

  • Track-aware sensing

    A colour sensor under the car reads the road: red spins you out, green is the lap line, and fuel runs down lap by lap until you refuel on the blue pit plates.

  • Modular race track

    Circuit One: 41 printed road pieces with dovetail joints, kerbs and walls, making a 6.1 m lap.

  • App-run races

    A Flutter app pairs over Bluetooth, opens lobbies that friends join with a code, and runs four-car races with lap times, hits and leaderboards.

  • Handheld controller

    The Thumbtroller: a thumb-joystick remote on its own ESP32-H2, reworked with a fire button and pivot controls.

  • Fails safe

    Drive commands carry a dead-man timer. If the app or the link drops, the car stops on its own within 300 ms.

  • Designed to be printed

    Chassis, turret housings and track pieces are modelled parametrically in FreeCAD and print-tested on real printers.

Inside the product

Render from above and behind two Zappit Racers on the 3D-printed track: the chasing car sits in its start-grid slot at the green start line, its turret showing green fire lights; the car ahead shows red hit lights on a red spinout strip, with the red and white kerb along the infield.
Combat on Circuit One — the chasing car fires (green) from the start line, and the car ahead is hit (red) on a spinout strip.
Exploded render of the Zappit Racer: the translucent turret cover, turret board and turret base at the top, then the light grey body shell, the green main board, and the white chassis with motors, wheels and the colour-sensor board underneath.
Exploded view — turret, body shell, main board, printed chassis, motors and the colour-sensor board underneath.
Close-up render of the main board: the ESP32-H2 module, passive components and a status LED glowing beside it.
The main board — one ESP32-H2 runs driving, sensing, weapons and Bluetooth.

The app

Race night, in your pocket.

  • App home screen: the connected car, race statistics and a Start a race button.

    Garage

  • Lobby screen: a four-digit join code, nearby cars found over Bluetooth and the drivers in the lobby.

    Lobby

  • Live race screen in landscape: a joystick, the current lap time, hits and shots, the race order and a large Fire button.

    Live race

  • Race complete screen: a podium with three drivers, your finishing position and best lap.

    Results

  • Leaderboard screen: weekly rankings with points, wins and best lap times.

    Leaderboard

Engineering

Under the hood.

  • C
  • ESP-IDF
  • FreeRTOS
  • Bluetooth LE
  • KiCad
  • FreeCAD
  • Flutter
  • Xano

Hardware is where AI-first meets real constraints: no agent can reflow a solder joint. Our engineers owned the boards, bring-up and testing on real track, while AI-assisted development sped up the firmware, the app, the backend and the parametric scripts that generate the track.

  • Firmware in C on ESP-IDF 5.3 and FreeRTOS, with the NimBLE stack. Each car is a Bluetooth LE peripheral that accepts several connections and takes firmware updates over the air.

  • Weapon logic lives on the car. The turret board is passive: the main ESP32-H2 drives its LEDs, IR transmitter, receiver and buzzer through a single 6-pin connector.

  • Every shot is an NEC-style IR packet carrying the attacker, team and weapon, protected by a CRC and on the air for about 24 ms.

  • Colour classification is tuned against real OPT4060 sensor readings on printed track, and magnets set into the lap and spinout strips give a second check through a Hall sensor, so one pass over the line counts as one lap.

  • Boards are designed in KiCad, panelised for pick-and-place assembly with fiducials and tooling holes, and costed against real supplier pricing.

  • The app resends drive commands every 100 ms against a 300 ms dead-man timer, and a Xano backend handles accounts, garages, lobbies, lap and hit events and leaderboards.

Have a product like this in mind?

We’ll bring the same AI-first process and senior engineering to your idea.

Start a project Explore our work