Navigate

Quick find

Find what you need

Esc
Qualified boundedEvidence pinned

ERAIS / exact software execution

Doom, recompiled into neural computation.

This is not a controller playing Doom. The game's computational execution is the experiment. A qualified build runs through ERAIS-derived computation, restores from one portable capsule, and reproduces the reference frame byte-for-byte.

28.6 s · 854×534 web encode · neural gameplay and audioFreedoom Phase 1 · CPU-only
1,024,000exact framebuffer bytes at tic 100
93verified program objects in the capsule
1.63 sclean-directory capsule restore
34.81tics/s in the paced Win32 run under Wine

What is different here

The game itself is the neural workload.

The earlier Doom AI experiment asks how a controller plays the game. Neural Doom asks a different question: can the game's own computation be represented through qualified ERAIS circuits and still produce the same pixels and audio?

The build covers game logic, renderer, video conversion, sound, music and integer softfloat. The qualification compares its output with the native reference at named game tics, across maps, monsters, menus, save/load and audio.

Two different demonstrations

Doom AIExperimental controllers play the game.
Neural DoomThe game's computation runs through ERAIS-derived execution.
Shared evidenceNeither claim substitutes for the other.
Explore the controller spectator

Exactness / the frame is the oracle

Same output, not a similar-looking result.

The tic-100 frame is compared as raw bytes. A single difference is a failure. This is the same frame used by the Windows and capsule receipts.

Exact Neural Doom tic-100 framebuffer
Exact tic-100 framebuffer
SHA-256b145dd81258fc1a7c5f2ebd49b3a27ae063b2d63e0be5c8a0b1038ebdedbc9b4

The frame is 1,024,000 bytes of 640×400 RGBA. The expected and actual SHA-256 values are identical.

Exactness receipt

Frame tic100
Framebuffer bytes1,024,000
Frame matchexact
WAD reconstructedyes
WAD SHA-256 verifiedyes
Restored executable dependenciesnone
Open the public evidence JSON

The framebuffer is not a screenshot comparison. The harness writes the game's own buffer and hashes it after the qualified tic.

Portable capsule / separate machine

One artifact carried the program and its data.

The capsule is not a folder of build outputs. It carries the verified object cache and the int8 asset bank. A standalone restorer checks every object, reconstructs the WAD, verifies CRC32 and SHA-256, links the program and runs the exact frame.

  1. 01
    Start with two files

    Only the 11.09 MB capsule and the standalone restorer were present in the clean working directory.

  2. 02
    Verify before executing

    Every program object is hashed. The manifest object set must match exactly; extras and missing objects fail.

  3. 03
    Reconstruct the data

    The 7,031-page bank decodes to the 28,795,076-byte Freedoom WAD. CRC32 and SHA-256 must agree.

  4. 04
    Link, run and compare

    The restorer links the object cache, executes the game and checks the tic-100 frame.

Restore record

Capsule11,093,317 bytes
Objects93
Restore time1.63 s
Restored executable653,432 bytes
Dynamic dependenciesnone
Network usedno

The restored executable was 653,432 bytes and reported no DT_NEEDED entries.

This is a verified object-cache capsule with a DoomGeneric create/tick ABI. It is a real restoration milestone, not a universal IR or bytecode capsule.

Win32 frontend / Wine-qualified

A visible window, keyboard input and audio.

The Windows build uses a native GDI window and a waveOut sink. Under Wine it opened a 640×400 window, accepted Escape, opened the audio device and produced the same exact frame.

Neural Doom running in a native Win32 GDI window under Wine
Win32 GDI window under Wine
SHA-256d0b5e699a38e1982cac07615c34e613fe0d3c48ed69ebbfe12d0002efe86230c

Captured from the paced 640×400 window. The game frame itself is the exact tic-100 reference.

Run record

HostAMD Ryzen 5 5500
Runtimewine-9.0 on Ubuntu 24.04.5 LTS
Window640x400
Pacing70 tics / 2.011 s
Rate34.81 tics/s
Audioopen, 72 blocks
InputEscape opened the Freedoom menu

Wine-qualified, not a native Windows kernel test. Native Windows hardware remains a separate qualification target.

Performance / same workload

Faster in the recorded Phase 1 comparison.

The qualified ERAIS build measured 0.224ms/tick against 0.251 ms/tick for the matched native C reference.

Interleaved Phase 1 qualification on the recorded host; not a universal performance claim.

ImplementationMedian
ERAIS Phase 1 AOT0.224 ms/tick
Matched native C0.251 ms/tick

This is not a universal speed claim. The workload, host and qualification profile are part of the result.

Claims and limitations

What this establishes.

  • verified

    The qualified build reproduced the tic-100 framebuffer byte-for-byte.

    ND-EXACT-FRAME
  • verified

    One 11.09 MB object-cache capsule restored the program and asset bank on a separate machine in 1.63 s.

    ND-CAPSULE
  • wine qualified

    A visible Win32 GDI window and waveOut sink ran 70 tics in 2.011 s under Wine.

    ND-WINDOWS
  • limitation

    This is a verified object-cache capsule with a DoomGeneric ABI, not a universal IR or bytecode format.

    ND-SCOPE

Known boundaries

  • The capsule is a Doom-specific verified object cache, not a universal program format.
  • The Windows frontend is Wine-qualified; native Windows hardware is not independently qualified.
  • The capsule and executable derive from GPL-2.0 DoomGeneric; public binary distribution requires a compliance route.
  • The phase-1 performance comparison is workload-specific and does not establish a universal speed advantage.