Some people get DOOM to play on a fridge. I got it to play on a neural net.

Not "an AI that imagines DOOM frames." Not a video model hallucinating something DOOM-ish. The actual 1993 DOOM — id Software's real, unmodified code, compiled to real x86 machine instructions — executed by a computer whose arithmetic and logic are neural networks, producing output bit-identical to a normal CPU. Every pixel. Every byte of memory. Exact.

The problem with neural networks (and why this should be possible)

Neural networks are approximators. They're brilliant at "close enough" — recognizing a cat, finishing your sentence. But a CPU lives or dies on perfection. If one addition out of a million comes back wrong by one bit, the program doesn't get slightly worse — it crashes, or corrupts a save, or draws garbage. 99.99% accurate arithmetic is 0% playable DOOM. So "run a real program on neural networks" sounds like a category error.

The trick that makes it possible is stolen from how chips are actually built:

1. Break the machine into tiny pieces — the way silicon engineers do. An 8-bit adder. A 1-bit shifter. An instruction decoder. Each piece is so small that you can list every single input it could ever see (an 8-bit adder with carry has exactly 131,072 possible inputs — a big number to a human, a tiny one to a computer).
2. Train a small neural network on the complete list. Not a sample — all of it.
3. Test it on the complete list. It passes only if it gets every single case right. 131,071 out of 131,072 is a fail. I retrain until N-of-N.
4. Wire the verified pieces together exactly like the chip wires its circuits: a 32-bit addition is four 8-bit neural adders passing a carry down the line; multiplication is shifted adds; division is repeated subtraction. Exact pieces, wired exactly, make an exact whole — forever, not just usually.

And when a piece is too big to enumerate? You never train it bigger — you decompose it further. Multiplication wouldn't train as one network, so it became a trivial "multiply a byte by one bit" network (512 cases) feeding an adder tree, which is literally how hardware multiplies. Every time I hit a wall in this project, the answer was more decomposition, never a bigger model.

How I got here

It started with a Game Boy. First one neural 8-bit adder, verified exact. Then a whole Game Boy CPU (512 instructions), a pixel pipeline, a memory system — every functional unit a verified network. The proof bar kept rising: the core passed the same test suites real emulator developers use (SingleStepTests: 512,000 randomized cases; Blargg's hardware-validated cpu_instrs: 11/11), and then a real cartridge game ran on it, with one full frame replayed entirely through the neural units — bit-identical to a conventional emulator, framebuffer and complete machine state.

• 13 neural units for the x86: 8-bit add/subtract slices carrying all five x86 arithmetic flags, the logic ops, 1-bit shift slices, the multiplier slice, and the instruction-decode tables. Each verified over its complete domain.
• An i386 core wiring them together, validated by differential fuzzing against QEMU — 194 instruction templates, 2,560 randomized full-machine states, total agreement.
• A tiny Linux (an ELF loader and ~30 system calls) so the machine could run real programs, with every clock deterministic so any run can be replayed bit-for-bit.
• DOOM itself, cross-compiled to i386, booting through its full init chain to the title screen in 20 million instructions.

The headline proof: I froze the machine at the title frame and ran the next frame — 5,952,699 instructions — twice. Once with conventional math. Once with every decode, add, shift, multiply, and divide computed by the neural networks. 102 minutes of neural inference later: the framebuffer was bit-identical, and so were all 128 MB of memory, every register, every flag. Not similar. Identical.

Then I made it playable. Neural inference is slow, so the same wiring diagram was ported to C — just the wiring; the neural units remain the machine's ground truth — running at 77 million instructions/second. That's the DOOM you can play above. And while you play, the original neural machine doesn't go away: sampled instructions are continuously re-executed by the neural units and compared against the live CPU. In a two-minute session, 57,110 out of 57,110 audits came back exact.

What this is actually for

• It's a proof about composition. "Neural networks are unreliable" is a statement about monoliths. Exhaustively verified small networks, composed the way hardware composes circuits, are components — and you can build arbitrarily large exact systems out of them. A Game Boy. An x86. DOOM.
• It's a proof about verification. Every claim on this page is checkable, and most of them you can re-run yourself, right here: the GPU button above re-verifies all 525,000+ unit cases from the shipped weights in seconds; the segment button re-executes real DOOM code neurally and hashes the result against the golden reference; the microscope shows you individual neural nets computing individual instructions.
• And the bug report says it all: across the entire project — two CPU architectures, thousands of composed units — the test suites found exactly one bug, and it was in hand-written glue code (two entries swapped in a lookup table a human typed). No verified neural unit was ever wrong. The discipline of "enumerate, train, verify everything, compose" did exactly what it promised.

Honest limits

The fully neural machine runs at ~1,000 instructions/second — the playable DOOM above uses the C wiring with the neural units as its continuously-audited specification, and the complete-frame neural proof is the offline 102-minute run. The audits sample the instruction stream rather than checking all 60 million per minute. There's no sound, and the machine implements the subset of a PC that DOOM needs (no floating point — DOOM never uses it). None of these caveats touch the central claim: every comparison ever made between this machine's neural units and ground truth — exhaustive, fuzzed, replayed, or sampled live — has come back exact.

Built brick by brick: one adder → a Game Boy → a real cartridge game → an x86 → DOOM. The weights, the DOOM binary, the snapshot, and every proof log ship with this Space.