Show HN: I Turned DOOM into a Transformer

Doomformer compiles entire figure neural networks into ZDoom maps and runs them in ViZDoom. Voodoo dolls (the copies of the player that DOOM spawns for additional player-1 starts) do the arithmetic, and field ray levels and aircraft heights clasp the sums. Python says all exposed value rear from the operating equivalent and compares it alongside a NumPy entire figure reference, tolerance 0. One value off by one and the run fails. It is slow: concerning 23,000 times slower than NumPy on a small MLP (engine time; 65,000 times alongside a timer about the entire call), and a handwritten numeral takes 163 seconds of real-time DOOM in one map at the default agenda and 8 seconds at --opt 3.

Install · Proof · How it works · Films · Docs

pip instal git+https://github.com/mottopanikeiku/doomformer # Python 3.11+, Linux or macOS doomformer hello # 2 s: a small MLP, all value checked doomformer diagram --digit 7 # 15 s: the marine walks a 7 and the flat says it

doomformer doctor checks ViZDoom, Freedoom and the display, builds ACC if it is absent, and compiles an ACS probe before reporting success. The archetypal build needs git, cmake, a C compiler and network admission to github.com. Linux uses energetic runtimes: glibc-static is not required. On Fedora: sudo dnf instal git cmake gcc gcc-c++ make. The Colab notebook needs no setup, but you diagram on a browser canvas and doomformer mnist --image feeds it to DOOM, alongside no marine.

Holding FIRE, the marine inks a 3×3 broom of flat cells under him. READ makes the flat compose the 784 pixels into the network, and 1,355 voodoo dolls in the identical map compute it. With --digit, Python stands in for you: it presses the marine's keys and USE once, afterward lone advances the clock and reads.

 ▄▄▄▄▄▄▄▄▄▄▄▄▄▄ ▄████████████████ ████▀▀ ▀████▀ ▀▀▀ ▄███▀ ████ ███ ███ ███ ████ ███▀ ████ ▀███ DOOM reads: 7 (right) -- the winner's doll lit it on the 7-segment display EXACT: all 248 values DOOM computed [...] equal the NumPy entire figure citation (tolerance 0) READ pass: 273 equivalent tics = 8 s of real-time DOOM at 35 tics/s, 3 s partition [...] 

Abridged at [...]; docs/commands.md has the entire output. diagram builds its map alongside --opt 3, so a READ takes 273 equivalent tics; at --opt 0, the first schedule, it takes 5,705 (163 s of real-time DOOM). Without --digit the command opens a opening and you stroll and diagram yourself; DOOM afterward runs in genuine time.

The dolls compute 784 pixels → 64 hidden units → 45 pairwise mark comparisons → 10 win counts. Only the numeral that wins all nine of its comparisons gets a doll through, and the row that doll crosses starts the flat manuscript that lights the numeral on the display. Python says rear the 784 pixels, the hidden layer, all difference and the answer and checks all 248 values (119 values, all peruse alongside its negated twin, affirmative 10 outputs).

EXACT method DOOM equals the entire figure network. It says nothing concerning whether the numeral is right. On the archetypal 100 MNIST test digits DOOM says 99 correctly, and 966 of 1,000 sampled from all 10,000; all outcome is exact. The entire figure network scores 97.16 % on all 10,000 (the drift example scores 97.58 %). The 30 walked digits (0 to 9, three scripted stroke variants each) all peruse correctly and exact at --opt 3, and the network is additionally trained on that blow distribution: the first type of this demo, a 784-32-10 network trained on MNIST alone, says lone 41.08 % of specified strokes. Through genuine X key events a drawn 7 peruse exact at the default --opt 3; a 7 and a 1 were tried at --opt 0 alongside an before network. Details · film

doomformer museum build writes museum.wad, a map you can perform without Python. You stage on seven flat pads to light a numeral and media READ. 136 voodoo dolls compute a small hand-written network: all digit's mark counts the segments that concur alongside it, and the winner's doll lights the display. MUTATE rewires one association of that network inner the operating level: section a to numeral 7 goes from +1 to -1, by changing the specials of its two importance lines. The identical 7 afterward says as 1, and RESTORE puts it back. The HUD and a scoreboard show the ten scores following all READ, and a camera position shows numeral 7's sixth mark doll: it passes its entrance before MUTATE and stops in forefront of it after.

$ doomformer museum verify 7 pads abc w_7a +1 DOOM says 7 scores [4, 6, 3, 5, 4, 3, 2, 7, 3, 4] EXACT (148 values; 744 tics; [...]) 7 following MUTATE pads abc w_7a -1 DOOM says 1 scores [4, 6, 3, 5, 4, 3, 2, 5, 3, 4] EXACT (148 values; 744 tics; [...]) 7 following RESTORE pads abc w_7a +1 DOOM says 7 scores [4, 6, 3, 5, 4, 3, 2, 7, 3, 4] EXACT (148 values; 744 tics; [...]) 

Here Python plays: it presses the marine's keys and USE, and during all READ it lone reads, alongside guarded readouts. It compares all 148 values alongside the NumPy citation of the network as it is wired at that moment. Without operating DOOM, the fixed extractor additionally shows that the rewired map's netlist is the network alongside exactly that one importance changed. I have run the entire map lone in ViZDoom. Its self-test map says the digits 0 to 9, afterward the 7 following MUTATE and after RESTORE, without a player. On a GitHub runner it logs the exact values in GZDoom 4.14.2, LZDoom 3.88b, UZDoom 5.0.3 and ZDoom 2.8.1, and in Zandronum 3.2.1 lone whenever all field tag is below 32,768. Details

Python says field ray levels and flat and ceiling heights from the operating equivalent and compares all alongside an independent NumPy entire figure implementation of the identical network. The inspect is entire figure equality complete the runs that were made, and says nothing concerning inputs that were not run. The tests assault it: raising one importance row in a small compiled map from 5 to 6 must neglect by exactly +1 on exactly the inputs whose dolls cross that line, and a readout that echoes a value Python wrote must neglect (pytest tests/test_tamper.py, three tests, concerning 15 s).

Readback is guarded by default: before each page, Python poisons and checks its USER slots, afterward requires the page to substitute them. Dropping a leaf cannot silently reuse a repeated input's answer or the former page's values. guard=False is an definitive one-map historic opt-out. Guarded builds have new hashes (ACS and metadata, not geometry or arithmetic); the hash record explains the change.

doomformer fuzz --nets 40 compares all value of 40 random nets run in DOOM (306 passes, 0 mismatches, concerning 10 s with --workers 2; a planted compiler bug is found). fuzz --edge puts weights, biases and inputs at the range limits: 15,000 nets over ten caller seeds, at --opt 0, at --opt 3 and as tile maps, made 113,605 passes and compared 1,987,632 values with no mismatch (the range inspect refused 47,686 of the inputs it drew, concerning 30 %), 3,000 additional alongside the generator widened to aircraft starts near the limits below (22,682 passes) and 2,000 additional that additionally diagram starts from 15,000 to 16,000 (14,782 passes), all alongside no mismatch. Earlier campaigns ran 2,000 random MLPs (15,374 passes, 276,594 values), 300 spiking nets and 100 random transformers complete all 8 attention, norm and MLP variants (99 ran; one all-zero matrix is unsupported), following the scheduling fixes; 200 spiking --edge nets made 12,794 passes with no mismatch. fuzz --edge does not diagram transformers. CI fuzzes 60 nets with a fresh, printed kernel on all shove and a longer run all Monday. The fuzzer and autonomous runs established four faults in this repo's own maps: two scheduling bugs and two aircraft limits. A aircraft move that starts additional than 14,018 units from zero keeps its mover occupied for three tics and drops the next petition on that plane, and a aircraft that starts above 16,000 is exact on the archetypal continue and incorrect on afterward ones, so DOOM disagreed alongside the citation on nets that net.check had accepted. inspect and compile now refuse them: planes commencement inner [-15,000, 16,000] and move within ±14,018 (doomformer verify --plane-sweep, docs/verification.md).

doomformer verify runs all input category of a small MLP (the classes concur alongside all input on 20 of 20 nets, under an assumption stated in the identical page). df.coverage counts what is compared: on MNIST all 248 exposed values, which are 129 values the citation defines and 119 twins, and the figure falls whenever a readout name is dropped. The map does not expose the 903 staircase counts and 1,351 entrance comparisons of the identical net; they are checked through the sums they feed. doomformer verify --extract net.wad --net net.npz says the net rear out of a compiled map without starting DOOM and compares all weight, bias and threshold alongside the origin net: the shipped MNIST net (784-64-45-10-10) comes rear equal from its map solitary at --opt 0 to 3, and so do 484 of 490 random nets at --opt 0 (the another 6 are equal but interrupt the plane contract) and 199 of 199 at all of --opt 1 to 3. EQUAL covers the arithmetic netlist, the aircraft contract, the trigger and reiterate flags, the mover speeds, the reset manuscript and the readout pages; timing and geometry are printed as NOT CHECKED. A changed importance row shows as exactly that weight. Of 23,622 sole edits to a small map at --opt 0 the extractor detects 17,906, and the 98 undetected edits that were run in DOOM on 12 inputs were all exact. It shows what the map says; that DOOM runs the map as peruse is what the exactness checks test. A mutation harness changes one row of a compiled map: of the 1,004 sites run (of 5,578) 297 are killed, all weight, sign and mark classes among them. Of the 707 survivors 590 equivalent a regulation (a redundant scroller, a freeze row a onward pass never needs) that total controls support, and 117 are input gaps (walking floors that lone several inputs expose); none is proven equivalent. doomformer lint --fuzz compared the static schedule checker alongside DOOM on 5,397 maps: 0 false negatives. The method is translation validation (Pnueli, Siegel and Singerman, 1998): a test of all compile, not a evidence that the compiler is right.

Who does what:

• The dolls do all multiply-add, activation and comparison. ACS flat scripts location cells, move input gates, rewind the dolls, awareness the earth and copy results out. None of the network's arithmetic runs in ACS. The toolkit's df.Agent is the one exception: it takes its argmax in ACS (docs/agents.md).
• mnist: Python writes the 784 pixel ports and decides whenever the dolls have stopped; the dolls choice the digit.
• demo and ask: Python writes the token ids and decides whenever the dolls have stopped, samples all letter from the logits DOOM computed and, whenever a example is cut into multiple maps, copies integers from one equivalent to the next. demo --one-map is one map alongside no Python between layers; Python writes the tokens and samples the letter following each pass.
• draw and his brain is the level: Python lone advances the clock and runs readout scripts (in draw, from READ on). The flat supplies the inputs (the 784 pixels, the sensed tokens) and the dolls choice the numeral or the action.
• demo --one-map --loop: Python lone advances the clock and runs readout scripts. The dolls choice all letter and write it into the next position.
• The fly loop: Python lone advances the clock and runs readout scripts, following calibrating the stage duration on a separate game that it does write. The flat draws the input spikes and the output spikes blaze the drive lines.
• --opt 3 (the default of draw; elsewhere --opt 0, the first agenda alongside guarded readback): an ACS manuscript copies each layer's ray levels into the next layer's entrance heights. It adds and compares nothing, and the dolls motionless do the sums, thresholds, comparisons and the choice, but "no ACS between layers" holds at --opt 0 to 2 only.
• doomformer machine: the dolls run the program oppose and the registers. By default the loop, the rewind and the halt check are an ACS script, and a stored program is loaded by the presenter before the archetypal tic. With --clock dolls a loop doll and row specials restart, rewind and halt the level, and ACS lone says values and checks that the dolls have stopped (docs/machine.md).
• learn digits: Python writes the pixels and the tag of all example, advances the clock and reads; the dolls compute the scores, the argmax and the importance update (docs/learning.md).
• python -m demos.brainlevel --lesion-at N or --lesion-when near|ahead: the level's own clock closes the doors of the lesioned units before decision N, or the archetypal period the tokens it senses fulfill the condition; Python lone reads.

In the draw, his brain, loop, fly and device runs a wrap (ReadoutOnly) makes any another call raise, and the commands are counted: 58 in a headless diagram pass, 710 in the movie run of his brain, 154 in the lesion run, 0 others.

The maps use ZDoom's UDMF format and ACS, so they need ZDoom (here ViZDoom 1.3.2 alongside Freedoom assets), not the 1993 executable. net.quantization_report(x) measures how far an entire figure example is from the drift example it came from. EXACT does not.

docs/HOW_IT_WORKS.md maps all part of a network to a part of the map: a value to a collection of dolls, a importance to a line, an activation to a staircase, notice to a corridor of ceiling gates, ablation to a door.

The motor has keen edges and the compiler plant about them. A aircraft mover refuses a second petition on the identical plane for as lengthy as the archetypal is motionless moving, and the afterward one is lost. A teleport row cancels the lines a doll crossed earlier in that tic. A item additional than 32,767 units from a BSP node can be submitted under the incorrect sector, so all map fits 32,000 units. These are ZDoom 2.8.1 behaviours measured in ViZDoom 1.3.2. The 32,000-unit regulation is needed on Linux; on macOS arm64 the cover did not happen in the investigation maps (cause not investigated), and the regulation is kept everywhere. The exported probe maps and the hello brain additionally ran in inventory ZDoom 2.8.1 (53 of 53 rows match), Zandronum 3.2.1 (50 of 53: it cannot find field tags complete 32,767) and GZDoom 4.14.2, LZDoom and UZDoom (44 of 53: planes are doubles there and the UDMF parser refuses coordinates beyond ±32,768; the coordinate cover stays). The hello brain's logged values equal the NumPy reference in ZDoom, GZDoom, LZDoom and UZDoom, and in Zandronum formerly its tags are moved below 32,768. The doll-clock oppose machine (multiply 7 9, 464 steps, 235,567 tics) and a SUBLEQ add additionally ran in GZDoom, LZDoom and UZDoom alongside all step's pc and registers equal to the interpreter's log; ZDoom 2.8.1 and Zandronum (tags below 32,768) ran a 50-step multiply and the SUBLEQ add exactly, and stalled Zandronum alongside default tags at stage 1 (Other ports). doomformer facts re-runs 28 probes (55 cases) alongside PASS or FAIL per row (about 10 s), and Engine facts lists all finding alongside the investigation or test rearward it.

Computers inner DOOM maps be already. counter.wad (2006) is a 4-bit oppose built from voodoo dolls and conveyor belts, conway.wad runs Game of Life in a Boom map, and Danny Spencer's DOOM calculator is an adding machine. Doomformer adds a compiler from integer networks to ZDoom maps, a measured catalog of motor behaviours that interrupt exactness, and a tolerance-0 inspect against a NumPy reference. docs/related_work.md lists what was opened and what all admission shares and does not.

hello runs a 4-6-5-3 entire figure MLP, demo is a 1-layer transformer trained on 136 authoritative flat names cut into 38 tile maps, --nightmare is the 2-layer example (56,390 dolls), and ask is a 2-layer transformer trained on 189 DOOM facts. docs/commands.md has all command and type alongside example output: mnist --image and --tiles, demo --softmax, --model doomnames_modern, --one-map, --loop, --opt, fuzz, verify, lint, tune, facts, machine, learn.

Times are from an idle 16-core arm64 Linux device operating up to 8 games at once; hello and diagram use one game. With 2 games, demo took concerning 1 infinitesimal and demo --softmax concerning 3.5 minutes on a occupied machine, and ask took 20 minutes on 3 games.

• "Not in its training names" is a low bar: 29 of 30 unselected samples of the 2-layer example at heat 200 are new, and the default demo writes one of its 136 training names for 6 of 10 seeds (the output says which). The default kernel (20) is picked.
• DEMON CANYON, the name --nightmare wrote, is a hand-picked example (seed 2, heat 150; the figure of seeds tried before it is not recorded). The 2-layer example was trained on 11,341 of 12,934 cleaned flat names.
• ask gets 94.7 % of its training paraphrases correct and 35.4 % of new wordings of the identical facts. "what does iddqd do" is a training inquiry and answers GOD MODE. A inquiry exterior the 189 facts gets an answer that is exact and meaningless.

His brain is the level. A flat manuscript senses the nearest demon, 1,345 voodoo dolls of the marine run his policy transformer and choice the action, and the flat turns him and pulls the trigger. Python advances the clock and reads. 50 of 50 decisions exact (seed 4). A decision takes 4,338 equivalent tics (124 s of real-time DOOM); alongside --opt 3 the identical 50 decisions choice the identical 50 actions, all exact, in 774 tics (22 s) each. In that run his dolls rotate for 21 decisions while the archetypal demon is far away, archetypal choose FIRE at decision 22, and choose it five times in all; five demons die. The policy imitates a scripted aimbot that sees exact demon positions. The demons are icy during he thinks, and alongside them awake (--live, below) he is deceased following 5.5 s alongside 0 kills, which the arena nearly forces; the movie time-lapses the thinking. Film · code

Run the experiments from a copy (pip instal -e ., afterward python -m demos.<name>). demos/README.md lists all command, its period and what it prints:

• python -m demos.brainlevel: 5 decisions in concerning 4 min; --decisions 50 --seed 4 is the 50 of 50 run, concerning 31 min; with --opt 3 the 50 obtain concerning 5 min on a loaded machine.
• python -m demos.brainlevel --seed 2 --decisions 12 --opt 3 --lesion 'x0:0;L0.ao:7;L0.x1:7;L0.m:0;L0.x2:0' --lesion-at 3: from decision 3 the level's clock closes the doors of 5 units and the marine turns anywhere the fit brain fires; 12 of 12 decisions exact, concerning 2 min.
• python -m demos.brainlevel --live --lives 3: the demons remain awake during his dolls compute; the flat samples the sensor formerly per decision and the act lands 773 tics later. Over 90 lives (seeds 4, 5, 6, all decision exact) he makes 0 kills and is deceased following a median 191 tics (5.5 s), before his archetypal act lands; the identical arena icy gives 22 kills a life. In this arena he cannot move and the archetypal demon damage arrives following a median 128 tics, so any performer that waits 773 tics dies first: a Python copy of the identical guideline alongside the identical postpone additionally makes 0 kills, and alongside a 3-tic delay 3.3. The informative part is the clear (python -m demos.brainlive sweep): alongside a caller act all 4 tics he keeps 79 % of the icy kills on 3-tic-old sensing, 36 % at 6 tics and 19 % at 12 tics.
• python -m demos.aimlearn: 2 lives in concerning 3 min; --lives 5 --seed 4 takes concerning 11 min.
• python -m demos.flyloop: 40 steps in concerning 3 min; --steps 900 runs to the end at stage 169, concerning 13 min.
• python -m demos.lobotomy: the lesion scan and 3 decisions in DOOM, concerning 1.5 min.

A transformer names a level. The 2-layer name example writes DEMON CANYON in 1,690 tile runs; a Python generator builds the level. One hand-picked example (seed 2). Not a corpus name.	A marine plays the flat it named. A 1-layer guideline on 55 games walks that level: doors, two kills, exit. 102 decisions, all exact. Python gives the compass and enemy positions. Seed 118 of 120, picked.
A perceptron learns inner one game. 38 ceiling-height weights, updated by dolls from an aimbot's labels. The current code gives 4, 22, 15, 20 and 16 kills complete 5 lives, 815 of 815 decisions exact. The movie is an before run on an older map layout: 4, 24, 26, 22, 24 kills, 931/931 exact, kernel 4. Python bins features and gives labels.	Lesions. A 7-pellet shotgun blast closes 7 neurons as doors and the marine stops firing: 0 kills complete 74 decisions, all exact. Picked from 3,000 random blasts, 4 of which were pacifists: 64 of the 11,440 seven-subsets of the 16 `x0` units are, and 5 neurons is the minimum.
A fruit-fly circuit. 255 neurons derived from the FlyWire connectome run the marine's lunge, grooming twitch and takeoff; refuse is silence. 169/169 steps exact. Simplified entire figure dynamics, synthetic input spikes, firing rates 0.6 to 2.7 times the drift model's, one seed.	A transformer in one map. No Python between layers: 3,548 dolls compose SHIL, 2,680/2,680 exposed values exact. A 1-layer, d=8 model. Python samples the letter. Time-lapse.
Generation without Python. The winner's doll sets the next token and the flat rewinds itself; Python lone advances the clock and reads. It wrote DAN in 5 passes (5,875 dolls). One example and the default prompt; the movie time-lapses the thinking. ViZDoom lists at most 4,096 objects, so 1,779 dolls are not drawn ([engine limit](docs/engine_limits.md#object-list-vizdoom-lists-at-most-4096-objects)).	A 4-layer transformer. It writes UNHOLY STRONGHOLD complete 10,166 tile instances and 1.9 myriad equivalent tics. Instances run on a pond of games, not 10,166 games at once.

The showreel covers all of them. docs/DEMOS.md has the numbers, the range of all inspect and the catalog of picked seeds, and docs/FLY.md covers the fly.

Compile a network into a map and let its outputs open doors, flash lights or shove the marine. This runs as pasted:

import numpy as np import doomformer as df # 2 inputs -> [a AND b, a OR b] -> 2 outputs, all integers net = df.MLP( weights=[np.array([[1, 1], [1, 1]]), np.array([[1, 0], [0, 1]])], biases=[np.array([-1, 0]), np.array([0, 0])], thresholds=[np.array([1]), np.array([1])], signed_input=False, ) with df.compile(net) as brain: for x in ([0, 0], [1, 0], [1, 1]): # computed by voodoo dolls; raises df.MismatchError on any difference from net.reference print(x, "->", brain(np.array(x)).tolist()) brain.record([np.array([0, 1]), np.array([1, 1])], "dolls.gif") # movie the dolls doing it

df.MLP.from_torch quantises a PyTorch example (example 02), and the earth and actions hooks put rooms in the map and nexus doors, lights and thrusts to the outputs (example 03). The identical API takes spiking networks, transformers, Conv1d and Conv2d, and learners that update their weights inner the map; mode="tiles" spreads a example complete a pond of games (doomformer scheme tells you which case you have). The guide is docs/BUILD_YOUR_OWN.md, and there are twelve one-file examples. Built item odd? Show and tell.

One map is one game, and one equivalent uses one core. df.run_many gives all input to the next idle game, checks all pass and returns the outputs in order, on your device or on a Ray collection you start. Nothing is hosted. 1,000 MNIST test digits in 14 games on one 16-core device took 2 hours: 966 peruse correctly, all 1,000 exact, 5,696,000 equivalent tics or 45 hours of real-time DOOM (models/mnist/doom_1000.json).

Tiles are the multi-map design: four tile maps, one per layer, in inhabitant games, alongside Python copying the tier values from one equivalent to the next. doomformer mnist --tiles --all --workers 6 peruse all 10,000 test digits in 1,390 s: 10,000 of 10,000 exact (248 values each), 9,716 correct (97.16 %), DOOM's one-hot equal to NumPy's on all digit (models/mnist/doom_tiles_10000.json). A numeral takes 216 equivalent tics and 0.83 s there against 5,696 tics and concerning 104 s in one map. doomformer scheme predicts seconds (rms error 13 % for one map and 22 % for tiles on 11 held-out K3 and K8 nets; on nets of another K the measured seconds were 0 to 40 % complete the prediction, and 21 % complete for MNIST at --opt 0), prints equivalent tics alongside an error collection (276 ± 7.2 % for MNIST at --opt 3, 272 measured) and recommends one. doomformer place tiles says MNIST at 81 digits per infinitesimal alongside 1 employee and 880 alongside 16 (steady state; 79 and 552 alongside equivalent start), all continue exact, at 0.72 s of motor CPU per numeral alongside 1 employee and 0.92 s alongside 16 (100 shipped digits, twice; 16 cores).

doomformer mnist --tiles --all --workers 6 # all 10,000 digits as tile maps, concerning 23 min pip instal "doomformer[ray]" ray commencement --head # another machines: ray commencement --address=HEAD:6379 doomformer mnist --all --ray --record mnist.json # all 10,000 digits, one map each, on a cluster

Budget one center and concerning 1.3 GB of RAM per equivalent (measured highest 1.24 GB). docs/scaling.md has the measurements.

• Schedules. --opt 1, 2 and 3 (df.compile(net, opt=N)) shorten the one-map schedule: doomnames_onemap goes from 3,488 equivalent tics to 1,512, 1,128 and 544, MNIST from 5,696 to 272 at --opt 3 (100 of 100 exact and 99 correct with the final constants, 300 of 300 before the final retune), and a DrawPad READ from 5,705 to 273 (30 of 30 walked digits right and exact). --opt 2 on MNIST ran on 76 digits (3,560 tics). The ACS copy at --opt 3 is under "Who does what". doomformer lint WAD flags aircraft moves that can portion a tic (0 false negatives on 5,397 fuzzed maps of the compiler as shipped; alongside an old barrier-height bug restored it caught 65 of 67 failing maps, and 66 of 66 on the identical nets following its model learned the first-tic halt that it had missed), doomformer lint --net MODEL additionally checks the aircraft bound, and doomformer tune measures the timing edges (docs/scheduling.md).
• A oppose device and two stored-program machines. doomformer device multiply 7 9 is a ROM oppose device (the program is the map's geometry): it prints 63 following 464 steps (39 dolls), the program oppose and all enroll checked at each step; fib 20, gcd, primes and pow2 40 run too. --clock dolls takes the ACS iteration manuscript out (a iteration doll and row specials restart and rewind the level) and --blind says lone formerly at the end. doomformer device subleq all runs a SUBLEQ device alongside 18 recollection cells of -64 to 63, operands as addresses and programs that rewrite their own instructions: add, 7 × 9 = 63 and a self-modifying sum run on one map (one sha256), 1,624 equivalent tics a step, all step compared alongside a Python translator at tolerance 0. Changing one row of the ROM or the decode makes the run diverge at the predicted step. A program that writes the three cells of the education it is executing sets a infringement latch in the map, which halts the flat at that stage (--latch; all 28 of 400 random programs that do so were flagged at the interpreter's step); without it the map computes a incorrect value there. A 103-step iteration runs exact on the two clocks, and a bubble kind does not fit in 18 cells. Memory and registers are bounded aircraft heights, so these are finite-state machines and no assertion that DOOM is Turing complete; plain SUBLEQ is worldwide alongside unbounded memory, and no universality argument is stated for this restricted form (docs/machine.md). demo --one-map --loop --until-eos lets the end-of-text victor halt the loop.
• A learner that starts blank. doomformer study digits --steps 1500: a 10-class perceptron alongside 370 weights, all 0, learns 8×8 digits inner one map. The weights are ceiling heights; the dolls compute the scores, the argmax and the update, and Python writes all example's pixels and label. After all of the 1,500 steps all 455 exposed values, every weight included, equal a NumPy twin at tolerance 0 (about 80 min on a loaded machine). Held-out accuracy goes from 10 % to 71.2 % on 500 digits; a textbook perceptron without the importance clamp reaches 81.0 % on the identical stream. On 20 NumPy streams (seeds 0 to 19, one of them the DOOM stream) the clamped twin averages 74.8 % ± 5.3. The onward corridor has 6 gates, so a mark lone sees weights in [-3, 3] and larger ones keep moving unseen; that expenses concerning 10 points on this stream and 3.6 on average. The update regulation and the labels are Python's (docs/learning.md).
• Quantisation. df.MLP.from_torch(model, calib_x, levels=4, calibrate="mse") additionally folds BatchNorm, lowers AvgPool and MaxPool (MaxPool by comparisons, exact on the staircase counts) and takes GELU and SiLU as staircases; df.qat.fit adds quantisation-aware fine-tuning. On 8×8 digits at 4 levels a depth-6 MLP goes from 88.9 % alongside max calibration to 93.7 % with MSE calibration (float 95.9 %) and a CNN from 92.7 % to 95.1 % (mean of 3 seeds, models/quant/EVAL.md); QAT is no improved than MSE calibration on ReLU Linear and Conv nets, and onward on nets alongside multiple max pools or GELU (BatchNorm + 2 MaxPool CNN: +4.6 points at 2 levels, +0.5 at 4). The lowered nets ran exact in DOOM on 5 digits each. df.Transformer.from_torch lowers a torch_models.GPT trained alongside the staircase recipe: a 24k-parameter level-name model is 5.6 % worse in perplexity than its drift phase (7.75 against 7.34), ran exact in DOOM on 3 held-out names, and is behind a 5-gram baseline (5.84). On a second corpus (Python citation prose, windows absent from training, one seed) it is 6 % rearward its drift stage, 17 % rearward a plain drift GPT alongside the identical steps and 34 % rearward its 5-gram. It does not convert a transformer trained elsewhere.
• A example that learned an algorithm. models/induction, a 2-layer entire figure transformer, is trained on induction over random tokens, which no figure array can solve. Held-out accuracy is 0.9995 against 0.9991 for a drift GPT of the same size, 0.069 for a bigram array and 0.233 for a 4-gram table; on pairs never seen in training it is 0.9995 against 0.000 for the tables. python -m demos.induction --heldout 25 runs 25 sequences in DOOM: 25 of 25 exact, 520,749 values. One kernel per row, and a d=16 ReLU K=4 run unsuccessful to study (log kept).
• Interventions. intref.forward(interventions=...) and DOOM runs place a value (zero, set, mean, resample, scale, add or eliminate a direction) at a site, stance and head, and all value is compared alongside the likewise patched reference: 24 of 24 activation-patching rows of doomplayer and 40 of 40 patched runs of the induction example (10 pairs per kind) ran exact in DOOM. In tile manner Python says all pre-activation the dolls computed and writes the patched value into the next tile's ports, and the dolls compute everything downstream; exactness does not inspect that the place value was the right one. Patching recovers the planted caput of a hand-built 1-layer model, (b + c) mod 4, alongside 0 disagreements over 384 pairs; alongside a backup caput sole patches divided 0.5 and 0.5 and two circuits remain, and alongside a caput that lowers the logit difference in several contexts the proportion of method hides it, so the circuit hunt reports per-context accord too (OR and AND redundancy appearance the identical to single-cell patching). Rows that place the entire residual or a entire location at the read stance are flagged and remaining out of the header numbers. Steering doomplayer alongside a investigation direction changes 39 of 86 contexts; it strikes random, span-of-the-data and random-context directions, and does not attack a shuffled-label probe (where the shuffle has adequate distinct directions) or a 'fire vs not fire' probe. "No compact circuit" in the induction model holds for average ablation at all position; alongside the corrupt run as baseline 4 of 6 components reconstruct 0.991 on answer pairs. The lesion data corrected the demos above: DEMON DEATH is not a selective lesion, since 355 of the 416 single neurons alter that example (docs/interventions.md).

• DOOM is slow. Engine period of one continue against the NumPy citation (14 to 48 µs) is concerning 23,000 times for a 12→16→6 MLP, 1.5 myriad times for MNIST in one map (73.2 s of motor CPU), 60,000 times for it at --opt 3 (2.84 s) and about 15,000 times for MNIST in tiles (docs/scaling.md). A one-map continue expenses what the idle map costs: the conveyor scrollers are the entire 2.84 s of MNIST at --opt 3 (doomformer place idle). Fewer scrollers do not help: with half of them the equivalent tics twice and a continue expenses 1.8 times more, and alongside one per field the continue is wrong (doomformer place stack), so 0.5 s per continue needs an motor change. With a timer about the entire call (write inputs, run, peruse back) the 12→16→6 MLP is 726 ms against 11.1 µs, concerning 65,000 times (30 runs, Speed), and a fly-circuit stage is concerning 73,000 times.
• Attention is entire figure attention: ReLU-style in most models, softmax computed by the dolls in three. No example has LayerNorm (doomnames_modern has an entire figure RMSNorm), and none is a drop-in drift transformer. Transformers are trained offline in PyTorch alongside quantisation-aware training (training/); MLP.from_torch converts MLPs and CNNs, and Transformer.from_torch lone the torch_models.GPT component trained alongside that recipe.
• The compiler is validated in ViZDoom 1.3.2. The investigation maps, the hello brain and the doll-clock oppose device ran in other engines (stock ZDoom, Zandronum, GZDoom, LZDoom, UZDoom); no network larger than hello did, and in the GZDoom family aircraft arithmetic differs, so the aircraft limits of this repo are ZDoom's. The compiler emits field tags complete 32,767, which Zandronum cannot find.
• The checks shield the nets and inputs that were run. The fuzzers do not shield learning maps, additional than 4,096 objects, or transformers in tile manner (Not covered).
• --one-map runs a smaller example than demo (1 layer, d=8, 6 positions), since the 136-name example needs 116,968 dolls and does not fit one map.
• The marine's policies imitate a scripted aimbot that sees exact positions. Python bins them into 86 imaginable observations and supplies the labels. There is no reward-driven RL and no learning from pixels.
• Showcased seeds, lesions and names are picked. Seeds and selection lists all pick.

Code and docs: MIT. Data keeps its own licence (THIRD_PARTY.md): the level-name lists are Doom Wiki (CC BY-SA 4.0) and id Software's origin (GPL-2.0), the 100 example MNIST digits are CC BY-SA 3.0, and the fruit-fly circuits in models/fly are derived from the FlyWire connectome (CC BY-NC 4.0, non-commercial). Freedoom graphics are BSD-licensed. DOOM is a trademark of id Software / ZeniMax; this project is not affiliated alongside them.