doomformer, a project from developer alp (GitHub: mottopanikeiku), compiles an integer neural network directly into a DOOM map and runs it inside the actual 1993 engine — not an emulation of it, not a shader pass dressed up to look like DOOM, the real level geometry doing real arithmetic. The project is MIT-licensed, has 53 GitHub stars, and ships with a command-line tool anyone can install and run.
The trick is a 30-year-old DOOM mapping exploit called a “voodoo doll.” Every extra player start in a map spawns a copy of the player that rides conveyor belts and triggers every line it crosses, independent of what the real player is doing. doomformer treats a voodoo doll as a unit of computation: a number becomes a crowd of dolls riding a conveyor; an activation function becomes a staircase the dolls climb, where each step only lets a doll past if its value clears a threshold (which gives ReLU, rounding, and carrying, among other arithmetic primitives, for free); a weight becomes a line the dolls cross, and each crossing changes a light level or a floor height somewhere in the map. When the dolls stop moving, Python reads the final light levels and floor heights back out of the map state and compares every one against a NumPy integer reference — with zero tolerance for error. Across 20,000 fuzzed test networks, there have been zero mismatches.
The flagship demo is a working MNIST digit classifier, running inside the game. One map puts 1,355 voodoo dolls to work computing a quantized neural network. The player inks a digit onto the floor by walking a drawing interface, presses a button to trigger the “READ,” and 273 game tics later (about eight seconds) the winning digit’s doll crosses a trigger line, lighting up the correct answer. The floating-point version of the underlying model scores 97.58% on MNIST; the quantized, DOOM-compiled version has read 30 of 30 scripted test digits exactly right. There’s also a museum.wad that runs without Python involved at all — 136 dolls compute a small network from floor-pad inputs alone, and a “mutate” command rewires one connection live, mid-run, so a digit that previously read as a 7 starts reading as a 1.
A second map goes further: it puts a DOOM marine’s decision-making inside the level he’s standing in. 1,345 voodoo dolls sense the nearest demon and pick an action — turn, fire, move — with the level script only advancing the clock and reading results, never driving the logic itself. It’s explicitly not meant to be playable in real time: one decision takes 22 seconds of game time, and with demons left active and aggressive, the marine dies in 5.5 seconds without landing a kill. The project’s own site calls this one a “time-lapse,” framing the slowness as the point rather than a limitation to apologize for.
Why this matters beyond the novelty: it’s a translation-validation project as much as an art project — every single computed value is checked, exactly, against a trusted reference, every time. That rigor is unusual for esoteric-computing work, which more often settles for “it mostly works” or a demo video as proof. doomformer instead ships a test harness that would catch a single off-by-one error across tens of thousands of runs, which is a genuinely different register of craft than most “we made a computer out of X” projects bother with.
Related Reading
- doomformer — GitHub repository (mottopanikeiku/doomformer)
- doomformer project site, with demo videos of the MNIST map and the marine-brain map
- doomformer: neural networks computed inside DOOM maps — Adafruit Blog coverage
- Write Your First ComfyUI Custom Node — our tutorial on building unconventional computing pipelines
- MesoCraft Brings Node-Based Procedural Modeling to the Browser — our coverage of another playful compute substrate