Back to projects

ESPBoy — A Twin-ESP32 Gaming Console

A handheld retro-style gaming device built around two ESP32s talking over ESP-NOW — with a live web audience that could vote to throw obstacles at the player mid-game.

Step 01 · Demo

The ESPBoy in action

The ESPBoy is a pair of ESP32-based devices we built for the UMIEEE UMake 2026 competition — a handheld retro-style gaming console (the "game" device) and a separate wireless controller. The two boards talk to each other over the ESP-NOW protocol, and the game device also hosts a live web interface so anyone on the network can spectate and meddle with the player in real time.

The project took first place at UMake 2026. The sections that follow walk through the hardware, the games we built for it, the wireless link between the two boards, and the live spectator-voting feature.

ESP32
×2 — game + controller
C / C++
Arduino framework
ESP-NOW
Peer-to-peer link
Async Web Server
Hosted on the game ESP32
HTML / CSS / JS
Spectator UI

Step 02 · Hardware

Two devices, one ecosystem

We called the platform the ESPBoy. It's split into two physical devices: one runs the game and drives the display, and the other is a dedicated controller that the player holds. Both devices are powered by ESP32 boards and communicate wirelessly, so there are no cables between them.

Device 1

Game Console

The handheld game device — built around an ESP32 driving dual 8×8 LED matrices for the display. It runs the game loop, renders the play field, and broadcasts the live state to the web spectator interface.

  • ESP32 microcontroller
  • Dual 8×8 LED matrices as the screen
  • Two pre-loaded games: Tetris and Snake
  • Hosts the spectator web server
Device 2

Wireless Controller

A separate hand-held controller, also ESP32-based. It captures the player's directional inputs and beams them to the game console over ESP-NOW with very low latency — no Wi-Fi access point or pairing required.

  • ESP32 microcontroller
  • Directional + action buttons
  • Sends input events over ESP-NOW
  • Battery-friendly — only transmits on input change

Step 03 · Games

Tetris and Snake on an 8×8 grid

The first version of the ESPBoy shipped with two classic games pre-loaded: Tetris and Snake. Both are rendered on the dual 8×8 LED matrices, so the gameplay had to be tuned for an extremely low-resolution display — every pixel counts when you've only got 128 of them.

Tetris

Classic falling-blocks gameplay scaled to the matrix. Pieces fall from the top, the player rotates and slides them, and full rows clear and shift the stack down.

Snake

Steer the snake around the grid, eat the apple, grow longer, and avoid hitting your own tail or the walls. Speed ramps up as the snake grows.

Game state on-device

The full game loop — input handling, physics/collision, rendering — runs on the game ESP32. The controller is dumb: it just sends raw input events.

Optimized for 8×8

Tile shapes, collision boxes, and motion timing were tuned specifically for the matrix display so the games still feel readable at a 16×8 effective resolution.

Step 04 · Wireless Communication

ESP-NOW between the controller and the game

The controller and the game console talk to each other over ESP-NOW — Espressif's connectionless peer-to-peer protocol built on top of the same radio as Wi-Fi. Unlike standard Wi-Fi it doesn't need an access point, doesn't need a handshake, and has dramatically lower latency, which is exactly what a game controller wants.

Controller ESP32
Reads buttons
ESP-NOW ~<5 ms
Game ESP32
Updates game state

When the player presses a button, the controller packages the input as a small struct and sends it directly to the game's MAC address. The game receives it through an ESP-NOW callback, decodes it, and applies it to the next game tick.

Because ESP-NOW is connectionless, the two boards can come up in any order and immediately start talking — no pairing screen, no Wi-Fi credentials. That made the device feel more like a real toy than a hobby project.

Step 05 · Live Spectator Voting

Let the audience mess with the player

The most fun feature on the ESPBoy isn't the games themselves — it's what we built on top of them. The game ESP32 also runs a small web server that anyone on the local network can connect to. Spectators see a live view of the play field through their phone or laptop browser, and while they're watching they get a button: vote to throw an obstacle at the player.

Spectators (web)
Phones / laptops
HTTP vote Wi-Fi
Game ESP32
Tallies + spawns obstacle

When enough viewers vote, the game injects a fresh obstacle into the active round — a new wall in Snake, an inconvenient block in Tetris — forcing the player to react and adapt on the fly. Watching is no longer passive; the audience is part of the difficulty curve.

Async web server on the ESP32

Serves the spectator HTML/JS, streams game state, and accepts vote requests — all from the same chip running the game loop.

Multi-viewer support

A small reverse-proxy pattern in front of the device lets many spectators connect at once without overwhelming the embedded server.

Real-time obstacle injection

Votes get tallied in a short window; once threshold is met, the game spawns an obstacle directly into the current round.

Player vs. crowd dynamic

The crowd becomes an adversary — turning what would be a single-player retro game into a chaotic shared experience.

Step 1 of 5