A full game-engine workflow on a microcontroller usually means compromise: a bare graphics library on the device, and the scene layout, asset handling and iteration loop held together with scripts on the desktop. Deki takes a different route. It is a modular C++ 2D engine with a visual editor that looks and works like Unity, and its firmware target is the ESP32-S3. The project's GitHub organization describes it as "a modular C++ engine with a visual editor. Tiny enough for an MCU", and says it is free, Apache 2.0 licensed and "built by one person after work."

The organization lists 37 repositories. On the organization page, the most recently updated ones, including the editor and the runtime, show an update date of October 24, 2026, and the ones we saw carry the Apache-2.0 license. The documentation site is generated from the code and currently reports engine version 0.20.2. The repository pages we read list no GitHub releases, so the repositories and the docs site are the primary references for now. Rather than one downloadable versioned build, Deki is a set of actively pushed packages.

The runtime: a software rasterizer with providers underneath

The deki-engine README calls the runtime the core of Deki: "a C++23 2D engine for ESP32-S3 devices and desktop." The README lists these main parts:

  • a software rasterizer, rendering to RGB565 by default;
  • a component model driven by code generated from C++26 static reflection;
  • an asset system;
  • provider interfaces for display, input, render system, memory, filesystem, time and power.

The provider layer is what makes the engine portable. Display output, input, memory, the filesystem, timekeeping and power management all sit behind interfaces that separate packages implement, so the same engine code can run on an ESP32-S3 board or on a desktop. The docs list integration packages that implement this split, including deki-esp32-integration, deki-sdl3-integration and deki-lovyangfx-integration. The last is described on the docs site as a LovyanGFX display and touch panel integration. A summary of CNX Software's coverage adds that desktop builds run through SDL3 or headless.

The runtime repository shows 118 commits. The README says plainly that this is early software: "Status: 0.x. File formats and the reflection ABI are versioned and may still change before 1.0," and adds that every breaking change comes with a migration path.

The editor: hierarchy, inspector, play mode

The deki-editor repository is the busier of the two, with 318 commits, and it shows an update date of October 24, 2026. Its README calls the editor "Unity-shaped" and lists a hierarchy, inspector, scene view, asset browser, console, play mode and undo/redo. The engine runs inside the editor process, and the C++ components you write are compiled into a plugin DLL and hot-reloaded, so you can change component code without restarting the tool.

The repository says Windows (built with MinGW GCC 16) and Linux both build and run, and ESP32-S3 is the firmware target. Packages are listed in a registry, and a Package Manager panel adds, removes and updates them. The editor's src/ tree also lists an MCP server among its services. The README does not explain what that server exposes, and we are not guessing.

The toolchain catch: GCC 16 and -freflection

The biggest practical hurdle is the compiler. The editor README says GCC 16 with -freflection is required on every platform, because the component reflection is C++26 static reflection, generated at configure time. For Windows it points to MSYS2, and for Ubuntu a toolchain PPA. Anyone who wants to build the editor from source should expect to install a specific compiler first.

The project also warns about its ABI. A reflection-driven component model ties the serialized data layout to the compiler feature that produces it, which is presumably why the README says file formats and the reflection ABI "may still change before 1.0." The README promises a migration path for each breaking change, but expect to run migrations when projects move between 0.x releases.

Packages: more than sprites

The package table on the docs site shows the scope is wider than a 2D sprite blitter. It lists:

  • deki-2d: 11 components, covering sprites, text, animations, gradients, buttons and scrolling;
  • deki-3d: software-rasterised 3D as a render pass, with meshes, a perspective camera and .obj import;
  • deki-audio: audio playback with a MAX98357 (I2S) backend;
  • deki-ble and deki-wifi: Bluetooth Low Energy and WiFi interfaces;
  • deki-gps: a GPS interface with an NMEA-over-UART backend;
  • deki-imu: accelerometer and gyroscope with an LSM6DS3 backend;
  • deki-rtc: real-time clock with a DS3231 (I2C) backend;
  • deki-sdl3-integration, deki-esp32-integration and deki-lovyangfx-integration.

The named parts (a MAX98357 I2S amplifier, an LSM6DS3 IMU, a DS3231 RTC) are the ones the package descriptions on the docs site give. With them, the engine reaches into the board's audio, motion sensing and timekeeping as well as its display. The CNX summary describes the gameplay features as sprites, tilemaps, particles and state machines.

Boards and performance: secondhand for now

Two common questions, which boards and how fast, do not have first-party answers in the pages we read. A daily.dev summary of CNX Software's article, posted in late October 2026, says Deki runs at 60 FPS on the ESP32-S3. The same summary lists hardware packages for the LilyGO T-Deck Plus and the T-Display S3 AMOLED, with the Elecrow CrowPanel Advanced 7-inch ESP32-P4 coming. We could not match the 60 FPS figure or the board list to the repository pages or docs we read, so treat both as reported, not confirmed. The figure comes with no resolution, scene complexity or display interface, and those details decide whether 60 FPS on a software rasterizer is a lot or a little.

The same summary names the developer as Jairo Baldán, a game programmer from Spain. The GitHub organization itself says only that the project is built by one person.

What It Means for Makers

Deki is aimed at a fairly specific person: someone building a handheld, a badge, a dashboard or a small game on an ESP32-S3 display board, who wants a scene editor, an inspector and play-mode iteration rather than hand-placing sprites in code. It is also useful for embedded developers who want to run the same project on a desktop through SDL3 before flashing hardware. Educators may find a Unity-like workflow on a cheap MCU board a good teaching bridge, as long as they accept the toolchain requirements.

What it could replace is the usual mix of a display library, home-grown scene code and desktop mock-ups. Deki's integration package for LovyanGFX suggests it can build on top of an existing display stack rather than replacing it.

On price and availability: the project describes itself as free and Apache-2.0 licensed, and the source is on GitHub now, with the main repositories showing updates on October 24, 2026. The docs site shows engine 0.20.2. The repository pages list no GitHub releases, and the README says the software is at 0.x, with file formats and the reflection ABI subject to change before 1.0. Building the editor requires GCC 16 with -freflection. The supported-board list and the 60 FPS figure come from secondhand reporting. Check the repositories for your exact board before you buy hardware for it.

Sources