Our sandbox installed nesformer in 16 seconds and completed the recorded build and test steps. Use it if you want to inspect how a compiler turns CPU logic into model weights. Skip it if you want to sit down and play NES games: the interesting result is the execution trace, and the published runs advance much more slowly than a console.
Nesformer implements an NES CPU through a Qwen-compatible checkpoint, with a host program supplying graphics, controller input and timing. Independent reviewers have reported matching traces and a reproducible checkpoint. Those are useful reasons to take the experiment seriously. They also give us a better way to judge it than a video of Mario moving: ask which part of the machine ran, which comparison was performed and who performed it.
What people use nesformer for
Drew Breunig demonstrated scripted Mario movement, while independent reviewers used nesformer to compare traces, inspect output frames and rebuild its checkpoint.
| Who used it | What they did | What came out |
|---|---|---|
| Drew Breunig, project author | Published a Super Mario Bros. command with Start, Right and timed A-button presses | An author demonstration with accompanying media, rather than an independent commercial-game compatibility result. Author's X posts |
| The aniketkarneai.com reviewer | Recompiled the checkpoint and compared hashes | Reported a byte-identical checkpoint rebuilt from source. Rebuild account |
| The aniketkarneai.com reviewer | Compared a nestest execution trace against the reference CPU | Reported 120,002 identical tokens over 310 frames. Trace output |
| CodeBridge | Loaded the weights and ran an initial Thwaite comparison | Reported 12,000 matching tokens and three matching frames. CodeBridge's local check |
The most instructive small run comes from the aniketkarneai.com reviewer. They ran Thwaite, saved images and checked whether the frames differed. Only three distinct images appeared: the game was waiting on its title screen because nobody had pressed Start. That is a useful lesson for anyone evaluating this project. A valid rendered screen shows one thing; reaching gameplay with controlled input shows something else. The author's controller script provides a concrete next experiment. Thwaite account
On r/emulation, Bireus asked whether putting a CPU into a model helps build games or lets a model play through instructions rather than pixels. LocutusOfBorges described the appeal as an experiment done for its own sake. I think that is the right buying advice, even when the download is free: choose it because you want to investigate the implementation. The community conversation supplies curiosity, not evidence of a game-development workflow. Reddit discussion
What happened when we ran it
Our November 18, 2026 sandbox run at commit 26b1b05 installed nesformer in 16 seconds, built it in 1 second and completed the test step in 187 seconds.
| Recorded step or signal | Our result | What it helps you decide |
|---|---|---|
| Installation | Succeeded in 16 seconds | Repository setup completed in this environment |
| Dependencies and disk | 42 dependencies recorded; 411 MB on disk | Allow for a larger environment than the small source checkout |
| Build | Succeeded in 1 second | The recorded build step completed; this is not a timed checkpoint-recompilation result |
| Tests | Succeeded in 187 seconds; summary says 6 passed, 0 failed, 4 skipped of 6 | The step succeeded, but the count fields conflict |
| Dependency audit | pip-audit reported 0 known vulnerabilities | A dated dependency scan, not a security assessment of the emulator |
| Repository scan | 41 files, about 4,596 source lines, 7.8 MB checked out | A relatively small codebase to read |
| Automation scan | 0 CI workflow files, no Dockerfile, a tests directory | Our scan found tests without a checked-in CI workflow |
The sandbox configuration recorded 3 CPUs, 8 GB RAM and image label ghcr.io/astral-sh/uv:python3.12-bookworm. The image label alone does not identify the actual Python or operating-system version used. Those details need the raw toolchain logs. Likewise, the supplied pytest summary cannot support a clean fraction: six passes plus four skips cannot fit the recorded total of six. We preserve the successful step outcome and the conflicting fields instead of inventing a corrected total.
Fetching dependencies and completing the repository checks was manageable in our sandbox. They are not gameplay measurements. In particular, the one-second build belongs to the harness step named build. Treating it as the time to regenerate the distributed model would mix two different operations. The independent checkpoint rebuild belongs to the attributed use cases above, not to our results.
Where people get stuck: input scripts and comparison setup
A stationary title screen can be a missing Start press, and an apparent CPU mismatch can be a faulty comparison harness.
| Symptom | Evidence | Useful response | Status in the source |
|---|---|---|---|
| Saved Thwaite images barely change | The aniketkarneai.com reviewer found only three distinct images and a title screen | Supply Start input before interpreting the output as gameplay | No successful gameplay rerun reported in that account |
| py65 and the reference CPU disagree | The same reviewer first compared different BREAK handling and inconsistent I/O values | Mask BREAK consistently, match deterministic I/O inputs and synchronize RAM | The reviewer's corrected harness reported zero mismatches |
| The checkpoint cannot be found in a custom location | The README expects weights beside the package | Pass the documented weights path to the CLI | Documented configuration, not a failure observed by us |
The py65 story deserves more attention than the initial mismatch count. The reviewer first saw differing status flags, then an accumulator difference. They traced those to their own setup: one side received a different I/O value, and the BREAK bit was represented differently. After making the comparison consistent, they reported agreement across 19,999 instruction states and no differing RAM bytes. That result supports the reference CPU on the exercised diagnostic path. It does not turn the initial harness mistakes into nesformer defects. Independent cross-check
For your own investigation, keep the ROM, button script, engine and comparison command together in the notes. A title screen and a moving character answer different questions. So do a checkpoint-versus-reference comparison and a reference-versus-py65 comparison. Saving the exact command will help you understand a disagreement before you start changing CPU logic. The README exposes separate run, check and trace commands for those jobs. Project README
The checkpoint executes instructions; the host draws the screen
The model implements the CPU, work RAM and cartridge program storage, while ordinary host software supplies the surrounding console behavior.
The clearest evidence is the trace described by the aniketkarneai.com reviewer. An I/O-read token asks for a hardware-register value, an input token carries the host's answer and a jump token changes execution. This is a record of the virtual processor running cartridge code. Calling it a model that watches pixels and chooses how to play would describe a different experiment. Controller choices come from the supplied script. Trace explanation
The memory mechanism uses persistent Gated DeltaNet state. Addressed writes replace a row, and addressed reads retrieve a row. The compiler arranges those operations into the CPU implementation. This also answers what a single transformer layer can calculate here: it performs an assigned stage of a larger circuit, such as instruction fetching or result calculation. The documented processor combines several stages into one execution pipeline. Implementation account
The supplied YouTube transcript titled “NESformer in 1 GB of Qwen Weights: How Does It Run Games?” describes the same separation between checkpoint execution and graphical input and timing. Its opening talks through loading a checkpoint and waiting for output. Treat that as an explanation of the workflow, not an additional independently measured run. The packet supplies a title and transcript but no channel identity or execution log, so attributing a hands-on result to a named video creator would add evidence we do not have. Video transcript
Slow execution changes the task you should choose
CodeBridge reported 4,385 tokens per second in its short Thwaite check, while the aniketkarneai.com reviewer reported 1,187 in its nestest comparison.
Those figures belong to different reviewers and workloads. Neither is a head-to-head benchmark, and averaging them would produce a number with no useful meaning. CodeBridge also points out that the README's raw throughput, idle-loop savings and overall slowdown range do not reconcile directly. Keep each result attached to its command and conditions rather than choosing the most flattering speed. CodeBridge's speed discussion
For a practical sense of the wait, the aniketkarneai.com review reports that its Thwaite execution generated 0.4 seconds of NES time in 34 seconds. That is enough to inspect output, and an awkward way to play a game. Our recommendation is to start with a bounded trace or a small frame run, inspect what happened, then spend more time only if the result answers your question. A short diagnostic task gives this project a fairer trial than expecting an interactive emulator. Independent Thwaite run
Local files need the right layout, not a hosted account
The documented workflow runs local Python commands against local weights and ROM files, without a hosted-model credential in the quickstart.
The English README asks for Python 3.11 or newer, explains the weights directory and provides shell commands. Our separate quickstart probe recorded a failed snippet step because the README has no Python code block to run. That is a mismatch between a library-snippet recipe and a command-line project: the README does contain shell commands. The recorded failure says nothing about whether a documented game command succeeds. The probe's teardown completed.
Use the bundled ROMs to begin, and check their individual licenses before redistributing them. The project code's MIT license does not replace the licenses attached to those assets. The README also supplies checksums for the checkpoint. Checking the files you downloaded is a useful first step before investigating different execution results. None of these steps requires exposing a service to the internet. Project README
Nesformer vs conventional emulators, py65 and Qwenputer
Choose conventional emulation for playing games, py65 for a Python 6502 comparison and Qwenputer for a different compiled-CPU target.
| Option | What the evidence describes | Pick it when |
|---|---|---|
| A conventional NES emulator | Coverage contrasts normal game emulation with nesformer's slow compiled-checkpoint execution | Your goal is playing the game |
| py65 | The independent reviewer used it as a separate implementation for checking the reference CPU | You need a CPU comparison rather than a graphics demo |
| Qwenputer | Nesformer's compiler predecessor targets CHIP-8 and RISC-V rather than the NES-specific implementation | You want to study the earlier compiled-machine design |
| Nesformer's fast, NumPy and stock Transformers engines | Several paths execute the artifact, with reported performance varying by engine | You want to compare execution paths within this experiment |
This comparison follows the independent CPU investigation, CodeBridge's account and Nohumans' conventional-emulator comparison. The primary py65 repository describes a Python package for simulating 6502-based systems. Qwenputer's README describes a RISC-V CPU compiled into Qwen3.5-4B. Read Qwenputer's design These are related tools with different jobs, not interchangeable consumer products.
My choice would follow the question. To investigate CPU semantics, use a CPU reference and a diagnostic ROM. To understand how a computation is placed inside model architecture, study nesformer or its predecessor. To enjoy Mario, the compiled checkpoint adds a great deal of waiting to the activity you actually wanted. The published speed reports make that recommendation possible without pretending we ran all the alternatives on identical hardware.
What the other reviews get wrong
Freshweights conflates architecture compatibility with a stock Qwen3.5-4B checkpoint, and Nohumans overlooks independent results present elsewhere in the packet.
| Page and claim | Evidence-supported correction |
|---|---|
| Freshweights says a stock Qwen3.5-4B checkpoint becomes the CPU | The aniketkarneai.com inspection describes a purpose-built 466.6-million-parameter checkpoint with a different configuration. Architecture compatibility does not establish reuse of the pretrained 4B model. |
| Nohumans says every number comes from the authors | The aniketkarneai.com and CodeBridge reviews report their own short checks. One also reports a matching rebuilt checkpoint. |
| aniketkarneai.com categorically excludes Super Mario Bros. as MMC1 | Breunig published an smb.nes command and media. The categorical exclusion conflicts with that demonstration; inspect the actual cartridge variant before deciding compatibility. |
| CodeBridge calls check teacher-forced | aniketkarneai.com describes its check command as free-running. These accounts disagree about the execution mode. |
| Nohumans compares an 18.8 GB saved Qwenputer model with a 3.3 MB nesformer archive | Nesformer's reported uncompressed checkpoint is 933 MB. Compare equivalent representations before drawing a size ratio. |
These corrections draw on Freshweights, Nohumans, aniketkarneai.com, CodeBridge and Breunig's X demonstration. The disagreement over check also appears inside the README: its results describe free-running weights, while its file listing calls one driver teacher-forced. Keep those labels attached to their sources until the relevant implementation is examined.
The reproducible artifact is the stronger argument for compiled weights. A rebuild whose hash matches the distributed file connects the source compiler to the checkpoint. A screenshot alone cannot do that. Equally, a matching short trace does not become a reproduction of every author claim simply because both outputs look correct.
Questions people ask
Putting an NES CPU inside a model demonstrates that compiler-written weights and persistent state can execute processor instructions deterministically.
What is the purpose of putting an NES CPU inside a model?
It gives you an inspectable example of computation built directly into model architecture. The practical attraction is studying the compiled circuit and its trace. The r/emulation discussion shows readers asking why this approach exists, while the implementation account explains what actually executes. Reader question, implementation
Is nesformer intended to help people build NES games?
The documented commands run ROMs, compare execution and print traces. That makes this an execution experiment; the supplied evidence demonstrates no game-authoring workflow. I would choose tools designed for NES development if creating a game is the task. Documented workflow, community question
Does the model play games through CPU instructions instead of detecting pixels?
It executes the cartridge's CPU instructions and emits a trace. The host renders the picture and supplies scripted controller input, so the model is not choosing moves by interpreting images. That distinction explains why a Mario demonstration can work without a trained game-playing policy. CPU and host explanation
Can model weights be written directly instead of trained?
Yes. The aniketkarneai.com reviewer reports regenerating a checkpoint that matched the distributed artifact byte for byte. That supports this particular compiler-built checkpoint; it supplies no shortcut for obtaining a general language model's abilities without training. Rebuild evidence
Would you download nesformer to run as a toy despite its slowdown and NROM restriction?
Yes, if the trace and circuit are what you want to inspect. I would begin with a bundled diagnostic ROM and a bounded comparison. For ordinary gameplay, I would choose a conventional emulator. That recommendation follows the independent short runs and the documented cartridge scope. Hands-on account
How small could the compiled model be, and could a smaller version reach NES clock speed?
The reported 3.3 MB compressed archive and 933 MB checkpoint describe storage representations of the existing artifact. They do not show the smallest possible CPU implementation or establish that shrinking it would reach console speed. Fewer stored bytes and faster execution are separate questions. Checkpoint inspection
Has every combination of inputs and outputs been tested?
No exhaustive result appears in the supplied evidence. Nohumans recounts a question about all input and output combinations and an author response about cartridge scope. The available checks exercise particular programs and execution windows. A finite successful run should stay described as that run. Coverage of the question
Does the claimed 5.7-million-instruction comparison hold up under reproduction?
The independent aniketkarneai.com account reproduces a smaller diagnostic comparison, not that full game-code result. Its corrected py65 harness reports 19,999 matching instruction states using synthetic I/O. That is supporting evidence for a narrower claim, with the full author result still requiring its own reproducible harness. Independent investigation
How can reviewers distinguish a trained checkpoint from a compiled computational artifact?
Regenerating the checkpoint from the compiler and comparing hashes connects the artifact to its source. The aniketkarneai.com reviewer reports doing that successfully. Parameter sparsity helps explain the file, but the reproducible rebuild is more useful evidence than a small download or an assertion that training never happened. Rebuild and hash comparison
What remains inside the checkpoint when graphics, input and timing are handled separately?
The CPU implementation, work RAM and cartridge program state remain inside the model's weights and recurrent state. Host software supplies the surrounding console operations. That division is described in both the hands-on account and the supplied video explanation. Checkpoint inspection, video explanation
What can a single transformer layer calculate?
In nesformer's layer plan, individual layers implement stages such as address calculation, data reads or producing the next token. The checkpoint combines those stages into the processor. Its working CPU is therefore evidence about that assembled circuit, rather than a demonstration of an entire console inside one layer. Layer plan
Should the README add a badge linking to the Hacker News discussion?
Issue #1 proposes an HN badge, and its author discloses maintaining the badge service. The supplied record shows the suggestion open with no comments, rather than an accepted change. A discussion link could help readers find context, but the badge would measure attention rather than correctness. Issue #1
What we have not tested yet
Our repository run covers setup and recorded checks; it does not measure gameplay speed, broad ROM compatibility or the stock Transformers execution path.
The implementation's documented boundaries are NROM mapper-0 cartridges, official opcodes and execution from cartridge ROM. Unofficial opcodes and jumps into RAM halt the machine. IRQ support is absent, scanline rendering misses some effects, sprite behavior includes approximations and there is no sound. These constraints explain why we recommend it to people studying computation rather than people seeking a general NES replacement. Documented boundaries
We have not reproduced the full advertised 5.7-million-instruction game-code comparison. The independent py65 result uses a diagnostic ROM and synthetic I/O, leaving real host behavior outside that comparison. We also have no controlled benchmark reconciling the engines or reviewers' speeds, no broad determinism study across machines and library versions, and no measured energy or monetary cost per run. Efficiency claims should stop at the reported execution times. Independent CPU boundary, speed discrepancy
The supplied teaching-lab idea has no documented classroom outcome. The video transcripts identify neither a channel nor a separate reproducible run, and the Bilibili search results concern unrelated projects. GitHub's anonymous facts and latest-release endpoints returned rate-limit responses during research, so we make no current star-count, last-push or release-health claim. The most useful next result would pair a published comparison harness with its ROM, input script, toolchain and full trace, so another reader can reproduce exactly the same claim.

