papyDeck — A little console you can open

papyDeck

Firmware
Hardware
Documentation
Contact

V1 alpha — running on the bench since August 2026
A little console you can open
papyDeck plays like an arcade machine and opens like a text editor. Every game on it is a Lua script you can read, change, and rewrite — including the ones somebody else wrote.

Open the simulator ↗
See the board
Read the specification

640×480at 60 Hz over HDMI
3 000sprite pixels per scanline
6Cortex-M33 cores
60 mmsquare board

The game is the source
There is no locked cartridge and no compiled blob. A game is a folder on the micro-SD
card: a main.lua, its art, and nothing else. Change a number, save, and the game
runs differently on the next frame.
The virtual machine is sandboxed — no filesystem, no OS calls, no arbitrary loading —
so a bad script gives you an error message with a line number instead of a dead
console. The same core also runs in a browser simulator, bit for bit: what you see there
is what the board shows — open it above, read a tutorial’s source, change a number and
run it again.

-- A sprite that follows the D-pad. That is the whole program.
gfx.bundle() -- the game's art, from its folder
local ship = gfx.id("game/ship")
local x, y = 320, 240

function _update()
local p = pad.get() -- any gamepad
if p & pad.LEFT ~= 0 then x = x - 2 end
if p & pad.RIGHT ~= 0 then x = x + 2 end
if p & pad.UP ~= 0 then y = y - 2 end
if p & pad.DOWN ~= 0 then y = y + 2 end
end

function _draw()
gfx.sprite(ship, x, y)
end

See it run
Two games, each recorded twice: in the browser simulator, then on the board itself over
HDMI. Same Lua, same art, same engine — that is the whole point of the simulator, and the
only honest way to show it is side by side. Sound is on.

In the simulator
▶ shmup
youtube.com ↗

In the simulator
▶ platformer
youtube.com ↗

On the console
▶ shmup
youtube.com ↗

On the console
▶ platformer
youtube.com ↗

Write your own
Lua on board, a sandboxed VM, and errors that print a line number instead of taking the console down. No toolchain, no cross-compiler, no cable: write it, copy the folder to the card, play.

Play what others wrote
Games are plain folders. The console lists the published games, fetches one over Wi-Fi onto its card, and you can open the source right after — see exactly how the trick was done.

Open by licence, public soon
Hardware under CERN-OHL-P, firmware under MIT: the licences are chosen and their notices are already in the tree. The repositories are still private while the V1 board lands — when they open, the schematic, the board and every line of firmware are yours to read, fork and manufacture.

Real arcade guts
Three genlocked RP2350B, six cores, 3 000 opaque sprite-pixels per scanline measured on the board — roughly twice a Neo Geo — plus a scrolling tile background, over plain HDMI, with no tearing by construction.

Where the project stands
The V1 alpha board arrived on 26 August 2026 and has been on the bench since. Running
today: HDMI out from the three genlocked chips, sprites and a scrolling tile background,
games loaded from the micro-SD card, Bluetooth gamepads, Wi-Fi, published games downloaded
straight onto the card from the console’s own menu, four-channel music and sampled effects
out of the headphone jack, and the console updating its own four firmwares over the air.
A browser simulator runs the same core as the board, with tutorials you can read and
clone. Still open: HDMI audio, the verified leaderboard, and the V1 board itself — a
voltage supervisor and a secure element are going on it.
Nothing here is for sale, and there is no release date. The pages below are the honest
version: measured figures, decisions with their reasons, and the parts that are still open.

Firmware
Software architecture, the protocol between the cores, porting notes.

Hardware
The board, its design decisions, the 3D model.

papyDeck — built with Zola, published from a private repository.

papyDeck is presented as a unique console designed to function simultaneously as an arcade machine and a text editor, centered around a novel programming paradigm where games are implemented as readable and modifiable Lua scripts. The core concept revolves around the idea that games reside not as compiled binaries but as simple folders containing a main.lua file and associated art, allowing users to directly interact with and rewrite the source code of the games.

The hardware specifications detail a system built around six Cortex-M33 cores situated on a 60 mm square board, supporting a resolution of 640 by 480 pixels at 60 Hertz output via HDMI. The visual fidelity is enhanced by a feature involving 3000 sprite pixels per scanline and a scrolling tile background, which is inherently integrated into the hardware construction to eliminate screen tearing.

The underlying virtual machine environment for papyDeck is deliberately sandboxed, which restricts access to the filesystem and arbitrary operating system calls. This security measure ensures that if a script encounters an error, it reports a line number rather than causing a system failure, thereby providing structured feedback to the user. Furthermore, the architecture supports a browser simulator that operates on the same core as the physical board, allowing users the ability to examine tutorials, modify source code, and immediately test changes.

The system is designed to facilitate both consumption and creation of software. Users can play existing published games, such as shmup and platformer, directly on the console. Simultaneously, the system enables users to develop their own content by allowing direct execution of Lua scripts on the board without requiring traditional toolchains or cross-compilers. Published games are stored as folders on a micro-SD card, which the console can access, and the console features a capability to download these published games over Wi-Fi directly onto the card.

The design integrates sophisticated input and media handling. The system supports input from Bluetooth gamepads, and it incorporates four-channel music and sampled effects delivered through the headphone jack. The functionality extends to over-the-air updates, where the console can update its own four firmwares remotely. The project is based on open principles, with the hardware licensed under CERN-OHL-P and the firmware under the MIT license, emphasizing transparency and potential for others to examine, fork, and manufacture the board and its software. The project is currently in an alpha stage, with ongoing work focused on developing the firmware, refining the software architecture, and specifying the hardware design.