News · 2026-10-31

Nesformer compiles a Nintendo processor into Qwen weights instead of training it on games

Developer Drew Breunig published nesformer, a project that compiles a Nintendo Entertainment System CPU and memory into a Qwen3.5-compatible model checkpoint without training. The model emits an execution trace while a separate program draws the screen, demonstrating a precise form of computation inside neural-network machinery rather than a model that learned to imitate game footage.

Key facts

• The repository and its Show Hacker News post were checked as October 31 publications in the dossier.
• The author reports 933 MB of expanded weights stored in bf16, a 16-bit number format, compressed into a 3.3 MB weights archive.
• Published runs are 150–290 times slower than the original console; CPU execution is documented and a GPU VRAM requirement is unstated.
• The primary source is Breunig’s nesformer repository, with his build account in the linked discussion.

The wording in the repository is unusually helpful: “Nobody trained these weights; a compiler computed every one.” That sentence prevents a familiar demonstration from being misread as evidence that a language model discovered how a console works by watching it.

A compiler translates a known program into another executable form. Here, the known program is a model of the console’s 6502 processor, including its registers, flags, work memory, and cartridge program. Instead of compiling those operations into ordinary machine instructions, the project places them into model parameters and a recurrent internal state.

The key technique comes from Qwenputer, the upstream project Breunig credits. Qwen3.5’s Gated DeltaNet component maintains state matrices that can be updated and read. Carefully chosen keys and queries turn rows of those matrices into addressable memory locations. In plain terms, part of the model becomes a deliberately wired filing cabinet: one operation puts a value in a known drawer and another retrieves it.

The CPU then advances through a tokenized execution log. Each record describes a processor operation rather than an ordinary word in a conversation. Autoregressive generation supplies the next record from the current machine state. The checkpoint is compatible with the model architecture, but its useful behavior has been constructed rather than acquired through examples.

The division of labor is central. The console CPU and cartridge execution live in the model’s weights and state. The surrounding Python program handles graphics rendering, controllers, timing events, and input-output responses. Saying that the entire Nintendo console is inside the weights would erase those host responsibilities. Saying that a normal external emulator performs all the CPU execution would erase what the project actually demonstrates.

The author supplies several kinds of tests. The reference processor was compared with established instruction traces and another emulator, and the compiled circuit was checked against reference token positions. Free-running examples also produced matching saved frames in the tested cases: the dossier records all 300 saved Thwaite frames and all 210 saved Full Game frames matching the reference output. Those are author-reported results, rather than an independent compatibility certification.

The scope is deliberately narrow. Nesformer supports NROM, a basic cartridge layout, and official processor instructions. Bank-switching cartridges are unsupported. Graphics effects that depend on changes within a scanline are absent, some sprite behavior is approximate, and the system produces no sound. Matching a set of test traces is meaningful evidence of fidelity within that scope; it does not establish that every commercial game will work.

Performance supplies the clearest reality check. The project is far slower than a conventional console emulator and slower than the original hardware. The README’s example of ten seconds of game time takes around 25 minutes in the author’s setup. It is a demonstration of expressiveness and compilation, not an efficient route to playing games.

Download size and runtime memory should also remain separate. The 3.3 MB compressed weights archive expands to the author’s stated 933 MB of weights stored in the 16-bit bf16 format because most entries are zero and compress well. That compression does not establish a 3.3 MB runtime footprint. The documented CPU path means readers need not infer a GPU requirement; the repository does not state a minimum or recommended GPU VRAM capacity. Runtime state and implementation overhead remain additional considerations.

In his Show Hacker News post, Breunig says Claude Opus 5.5 produced the code and weights from two prompts, beginning with feasibility investigation and building on Qwenputer and existing console tests. That is the creator’s account of AI assistance, not an independent audit of the work or a controlled measurement of agent productivity. Community reaction mixed enthusiasm for the construction with criticism of its inefficiency.

The broader value is conceptual precision. A neural architecture can execute a hand-constructed program without learning that program from data. That is different from a world model predicting what a screen should look like, and different from program synthesis, which concerns producing a program from a specification. Nesformer combines these worlds in an inspectable artifact while leaving the boundary between construction, execution, and learning visible.

Primary source, verified: read the paper →

Ground Truth. (2026, October 31). Nesformer compiles a Nintendo processor into Qwen weights instead of training it on games. Ground Truth. https://groundtruth.day/news/nesformer-6502-compiled-qwen-weights.html

@misc{groundtruth:nesformer-6502-compiled-qwen-weights,
  title  = {Nesformer compiles a Nintendo processor into Qwen weights instead of training it on games},
  author = {{Ground Truth}},
  year   = {2026},
  month  = {oct},
  url    = {https://groundtruth.day/news/nesformer-6502-compiled-qwen-weights.html}
}

Topics: open-source · neural-computation · qwen · program-synthesis · agents · games