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
A project called nesformer compiles the NES 6502 CPU and a cartridge ROM into weights for a stock Qwen3.5 model; the weights are computed by a compiler, not trained. The model generates CPU execution one token at a time while host software handles parts of the console, and the project reports exact frame matches against a conventional emulator for its bundled test games.
A GitHub project called nesformer has compiled an NES processor, its 2 KB of work RAM and a cartridge program into the weights of a stock Qwen3.5 model, using a compiler rather than training. During a game, the model generates the CPU’s execution one token at a time, while a host program handles other console functions; the project reports that bundled test-game frames match a conventional 6502 emulator exactly.
The project represents the NES’s 6502 CPU core, 2 KB of working memory and a cartridge’s program ROM inside a standard Qwen3.5ForCausalLM checkpoint. According to its GitHub documentation, the CPU implementation covers all 151 official opcodes, addressing modes, processor flags, stack behavior, and BRK and NMI entry. The cartridge’s 32 KB of program ROM is stored twice, once for instruction fetches and once for data reads.
The model is not responsible for every part of the console. The host program draws the picture, reads controller input and triggers the vertical-blank interrupt. The model contains a scanline renderer and palette for the PPU, controller handling and APU registers, although audio writes are otherwise ignored. The documentation says OAM DMA reads are represented as tokens. In this setup, the model’s Gated DeltaNet state serves as machine memory, and each CPU token in the reported runs comes from the model.
Nesformer accepts games using the NROM board, or iNES mapper 0, including examples such as Super Mario Bros., Donkey Kong and Excitebike. The ROM is loaded into the machine state at startup, so the project says the same compiled weights can run different compatible games without rebuilding. The repository includes three freely licensed test ROMs; users must provide other game ROMs themselves.
A Language Model as CPU
The project offers a concrete demonstration of a different use for a language-model checkpoint: not answering prompts, but implementing a stateful computing machine. Its authors describe the model as predicting an execution log, with its internal DeltaNet state carrying the simulated machine’s memory. That makes nesformer relevant to researchers and developers interested in whether neural-network architectures can represent and execute structured programs.
The result should not be confused with a practical replacement for an emulator. The documented fast engine takes about one to six seconds per frame after an initial compilation step of roughly 20 seconds. At 60 frames per second in the original console, 600 frames—10 seconds of game time—can take around 25 minutes to generate. The project is therefore a computational demonstration, not a way to play NES games at their original speed.
Its verification claim also has a defined scope. The project says bundled test-game frames match a conventional 6502 emulator’s output exactly, and provides a check command that compares the model with a reference CPU. That is evidence about the tested runs, not proof that every possible ROM, console feature or input sequence works correctly.
Products Worth Considering
LG UltraGear 27-Inch QHD OLED Gaming Monitor, 240Hz, 0.03ms, G-SYNC Compatible, FreeSync Premium Pro, HDMI 2.1
Samsung 27 Odyssey OLED G5 (G50SF) QHD QD-OLED Gaming Monitor
DJI Osmo Mobile 8 Gimbal with Mic Mini Transmitter, Infinity Black
As an affiliate, we earn on qualifying purchases.
Built on Qwenputer’s Compiler
Nesformer builds on Qwenputer, a project by Divyansh Agrawal that compiled CHIP-8 and then a RISC-V CPU into Qwen3.5-4B. The NES project reuses Qwenputer’s compiler and its central technique: using the model’s Gated DeltaNet state as the simulated computer’s memory. The source describes the NES weights as compiler-generated; it does not describe a training run that taught the model to emulate the console.
The published workflow separates a generated checkpoint from the software that surrounds it. Users install the Python package and its dependencies, place the weights beside the package, and run a command with a ROM and optional button schedule. The tool can produce an animated GIF, save individual frames, trace generated tokens or compare execution against the reference CPU. An alternate Hugging Face engine is also listed, but the documentation describes it as much slower than the default fast engine.
Compatibility is constrained by the hardware included in the implementation. The supplied instructions specify mapper 0 games; ROMs using other cartridge boards stop with a limitation message. The source also lists console functions handled partly or wholly outside the model, including host-side display and controller input. These boundaries matter when describing what it means for a Nintendo to be “in” the weights.
“Nobody trained these weights; a compiler computed every one.”
— Nesformer project documentation
Limits of the Verification
The supplied material does not identify the Qwen3.5 checkpoint size or establish that the complete weights occupy exactly 1 GB. The phrase “~1GB” appears in the project headline, but the documentation provided here does not give a precise file-size measurement or say whether it refers to the whole checkpoint, a portion of it or a particular packaging choice.
The project reports exact frame agreement for its bundled test games, but the supplied description does not specify the full test coverage, the number of compared frames for each game or results across a broader set of compatible ROMs. It also does not establish compatibility with cartridge boards beyond mapper 0. The host-model division means that the claim is not that every component of an original NES is encoded in the weights: display, controller reading and interrupt timing involve host-side support, and audio is not fully implemented.
Performance figures are estimates in the project instructions and will depend on hardware and configuration. The source gives no broad hardware benchmark or comparison with conventional emulators. It also does not provide independent evaluation beyond the project’s own comparison tool and reported tests.
Testing More Compatible Games
The next practical step for users is to run the repository’s check command on supported mapper 0 ROMs and compare the generated execution with the reference CPU. The project provides run, check and trace modes, plus options to save frames and inspect token output. Its documentation advises expecting slow runs and says the first run compiles the engine with Numba.
Further evidence about the project’s reach would require published results across more compatible games, clearer details about the checkpoint’s actual disk size, and tests on different hardware and input sequences. The source material does not announce a release schedule, a performance upgrade or support for additional cartridge boards, so those remain open rather than confirmed plans.
Key Questions
What does nesformer put into Qwen3.5?
According to the project, a compiler places an NES 6502 CPU implementation, 2 KB of work RAM and a cartridge’s program ROM into a Qwen3.5 checkpoint. The model generates CPU execution tokens; host software handles other console tasks, including drawing and reading controller input.
Were the weights trained to emulate a Nintendo?
No training is described. The project says the weights were computed by a compiler, rather than learned through a training process.
Can it run any NES game?
No. The documented support is for games using NROM, or iNES mapper 0. The project names Super Mario Bros., Donkey Kong and Excitebike as examples; games using other boards are outside the stated support.
How fast does it run?
The project estimates one to six seconds per frame with its fast engine after an initial compilation that takes about 20 seconds. Its documentation estimates that 600 frames, or 10 seconds of NES time, can take roughly 25 minutes.
Has the emulator’s accuracy been independently confirmed?
The project reports exact frame matches against a conventional 6502 emulator for its bundled test games and provides a comparison command. The supplied source does not describe an independent evaluation or establish accuracy across all compatible games.
Source: github.com
