Imagine you're a kid drawing a flip-book: you sketch the next page based on the current one and whatever the stick figure 'decides' to do, then you flip to it and repeat. Now imagine the stick figure has its own brain and is choosing actions based on what you drew. Neither of you ever looks at the real world — you're both operating entirely inside the flip-book. That's what's running on a $6 chip here: one network draws the next frame, another network picks the next action, and the real game never executes at inference time. The committed claim: a looped transformer world model with 26k–131k parameters can learn five simple games (Breakout, Doom-lite, Flappy Bird, Pong, Pac-Man lite) well enough that a reinforcement learning agent can be trained entirely inside the dream, and both networks fit on a Raspberry Pi Pico 2W's RP2350 with no external memory or compute. The world model hits 83.6%–100% exact-frame accuracy at 2 loops across the five games, and the stream-AC agent learns meaningful policies from scratch on-chip. The architecture choice is the load-bearing decision. Instead of stacking N distinct transformer layers — the standard approach that eats memory linearly — this project uses a single transformer block applied 1–4 times with shared weights. Input is re-added before each pass, and every intermediate output is supervised against the target frame. This is the looped transformer idea: you pay for one block's worth of parameters but get depth-like refinement through iteration. The Doom-lite animation is the killer demo — after one pass the model hallucinates an enemy that isn't there; by pass four it's corrected to zero wrong cells. On the Pico, two loops strike the speed/accuracy tradeoff, running on core 1 while core 0 handles USB and display. The decoding scheme deserves attention because it solves a problem that naive next-token prediction can't: physical constraints. Background cells decode independently, but singleton objects (the ball, the player) are placed via a single global argmax over all (cell, token) pairs, guaranteeing exactly one of each. This single trick took Breakout exact-frame accuracy from 91.6% to 99.7%. Pac-Man sprites get a further stamp-from-state rule for their 2×2 bodies. These are hand-crafted inductive biases — not learned — and they're the kind of domain-specific engineering that makes the whole thing work at this parameter budget. The integrity story is honest but self-contained. Every game is implemented in numpy, so the authors can run the real rules against every dreamed frame and check cell-by-cell. They report both held-out exact-frame accuracy and a harder in-dream check where an agent drives the world model into states the training data never covered. Pac-Man is the weak point: 742 wrong game states in 5,000 dreamed steps, because the 48×48 frame and two shortest-path ghosts push the 131k-param model to its limit. The authors also document the exploit cycle honestly — agents trained only in the dream score 210 in the dream but 28 in the real game (max 56), exactly the 'cheating the dream' failure mode that Ha & Schmidhuber predicted. Iterative collect-and-fine-tune rounds close each exploit. The RL agent uses Stream AC(λ), a single-transition online actor-critic with eligibility traces and no replay buffer — chosen because it fits the on-chip memory constraint. Hand-crafted feature vectors (ball position, ghost distances, etc.) replace raw pixel input. This is pragmatic but limits generality: each new game needs a custom observation function. The agent reaches 45.6 on Breakout (max 56) and learns meaningful Doom-lite and Pac-Man policies, though the Doom-lite training curve suggests it's still climbing at 500k steps. What makes this project interesting isn't the individual techniques — looped transformers, world models, stream RL are all published ideas — but the integration proof: all of it running simultaneously on 520 KB of SRAM with int8 quantization, verified bit-for-bit between Python and Rust. The quantization-aware training starts after 3–4k float warmup steps and the Rust firmware reproduces the Python integer spec exactly, confirmed by cargo tests. This is engineering as research artifact: the constraint is the contribution.
