TL;DR
Get business pricing on tech for your team
- Business-only prices and quantity discounts
- Tax-exempt purchasing
- Multiple users, one account, clear invoices
The nesformer project compiles an NES 6502 CPU, 2 KB of work RAM and cartridge program data into a stock Qwen3.5 checkpoint without training. A host program supplies console functions outside the model; the project says bundled test games match a conventional 6502 emulator frame for frame. Runs are slow, and the documented support is limited to NROM games.
A GitHub project called nesformer has compiled the Nintendo Entertainment System’s 6502-based CPU, 2 KB of work RAM and cartridge program data into the weights of a stock Qwen3.5 model. Instead of running a conventional CPU emulator for each instruction, the system has the model generate the execution log token by token, while a separate host program handles graphics, controller input and interrupt timing.
The project report says the weights were computed by a compiler, not trained. It builds on Qwenputer, a project by Divyansh Agrawal that compiled CHIP-8 and then a RISC-V CPU into Qwen3.5-4B. Nesformer reuses Qwenputer’s compiler and its approach of using the model’s Gated DeltaNet state as machine memory. The project describes the result as a working NES implementation within a standard Qwen3.5 causal language-model checkpoint.
The model contains the 6502 core, including all 151 official opcodes, addressing modes, processor flags, stack and interrupt handling. It also holds the game’s program ROM, stored twice for instruction fetches and data reads, and represents work RAM, a scanline renderer and palette, controller state, and other console behavior. The report says that OAM DMA reads are supplied as tokens and that an NMI token injects the vertical-blank interrupt.
Not every console function is inside the weights. The host program draws the picture, reads the controller and fires the vblank interrupt; the APU registers are written but otherwise ignored. The project says its bundled test games produce frames that match a conventional 6502 emulator exactly. It includes a check command for comparing runs and says users can load their own supported ROM at startup without rebuilding the weights.
What Model-Based Emulation Shows
Nesformer is a demonstration of a language-model architecture being used as an executable state machine, rather than as a system that answers questions or generates ordinary prose. The model’s tokens represent CPU execution steps, and its internal state carries information needed for later steps. That makes the project relevant to researchers and developers exploring whether model components can implement precisely specified computation.
The result is also a bounded technical demonstration, not a practical replacement for an NES emulator. The report estimates that a frame takes one to six seconds after an initial compilation step of about 20 seconds. A 600-frame run—10 seconds of NES time—takes around 25 minutes, according to the project. The host still performs important console work, so the claim is not that the language model alone recreates every part of the hardware.
The frame-by-frame comparison claim matters because it offers a way to test whether generated execution stays aligned with a conventional implementation. But the stated evidence applies to the bundled test games; the material provided does not specify the full test procedure, results for a wider set of ROMs, or whether the performance and exact-match behavior hold across every compatible game.
Products Worth Considering
LG UltraGear 27-Inch QHD OLED Gaming Monitor, 240Hz, 0.03ms, G-SYNC Compatible, FreeSync Premium Pro, HDMI 2.1
DJI Osmo Mobile 7P Phone Gimbal with Mic Mini Transmitter, Infinity Black
DJI Mini 5 Pro Fly More Combo Plus with DJI RC 2
As an affiliate, we earn on qualifying purchases.
How Nesformer Runs Games
The project supports games using the NES NROM board, identified in the documentation as iNES mapper 0. Examples listed include Super Mario Bros., Donkey Kong and Excitebike. Users supply a compatible ROM; the project says it ships only three freely licensed test ROMs. Games using other boards stop with an error, according to its instructions.
To run it, users need Python 3.11 or newer, the project’s dependencies and separate downloads for the package and weights. Its command-line tools can run a game, compare model execution against a reference CPU, print the token stream, or build the checkpoint. A fast Numba engine is the default; the documentation also lists NumPy and a Transformers-based engine, noting that the latter requires Torch and runs at about 10 tokens per second.
The report presents nesformer as a continuation of Qwenputer’s compiler experiments, extending the approach from smaller or different computing systems to an NES CPU. The supplied source does not identify an independent review or peer-reviewed evaluation. Its implementation details and performance figures should therefore be read as project documentation, not as independently verified findings.
“Nobody trained these weights; a compiler computed every one.”
— The nesformer GitHub project
Limits of the Reported Tests
The project’s exact-frame match is reported for its bundled test games; the supplied material does not give independent verification, a detailed test dataset, or results across all NROM titles. It is also unclear how performance varies by game, hardware, or model-running setup beyond the project’s stated estimate of one to six seconds per frame.
Support is explicitly limited to NROM / mapper 0, and the APU is not fully implemented: its registers are written but otherwise ignored. The report does not establish compatibility with games that rely on other cartridge hardware or audio behavior. It also does not provide a general claim that every part of an NES is represented in the model; graphics output and several interactions remain in the host program.
Testing More Compatible ROMs
The project’s immediate next step for users is to run its check command against a supported ROM, which compares model execution with a reference CPU and stops at the first difference. Users can also trace generated token IDs or try other NROM games by supplying their own files. The project documentation does not announce a release schedule, broader mapper support or a planned independent evaluation.
Further evidence would clarify how widely the frame-matching result generalizes, how much the host contributes to overall behavior, and whether the slow run times can be reduced without changing output. Until such details are available, nesformer is best understood as a specific compiler-built demonstration for supported NES software, not a general-purpose console emulator.
Key Questions
Does the model run the entire NES by itself?
No. The project places the 6502 CPU and selected machine state in the model, but a host program draws the picture, reads controller input and fires the vblank interrupt. The APU registers are written but otherwise ignored.
Were the Qwen3.5 weights trained on game data?
The project says no training was used: a compiler computed the weights. It describes the model as generating the CPU execution log one token at a time.
Which NES games are supported?
The documented support is for games using the NROM board, or iNES mapper 0. The project lists Super Mario Bros., Donkey Kong and Excitebike as examples. Other cartridge boards are not supported, according to the documentation.
How fast does it run?
The project estimates one to six seconds per frame after an initial Numba compilation of about 20 seconds. It says a 600-frame run, representing 10 seconds of NES time, takes around 25 minutes.
Has the accuracy claim been independently verified?
The project says every frame for its bundled test games matches a conventional 6502 emulator. The supplied report does not cite an independent review or provide evidence covering every compatible game.
Source: github.com
