mrkeyoor.comAsk

dbreunig/nesformertested 18 Nov 2026commit 26b1b05

nesformer review

Our sandbox installed nesformer in 16 seconds and completed the recorded build and test steps, making the repository practical to investigate.

  • README install 3 s
  • README snippet failed
6/6tests passed
  • 371.4 MB on disk
  • 4 dependencies
AI Toolsevaluationupdated 19 Nov 2026
+1 / 2dstars / 7d

Nesformer compiles an NES CPU into Qwen-compatible model weights, with the game program and memory held in model state. A separate host draws the picture and supplies controller input and timing. It lets you inspect processor execution through a model architecture.

Verdict

Our sandbox installed nesformer in 16 seconds and completed the recorded build and test steps, making the repository practical to investigate. Use it if you want to study compiler-written weights and CPU traces. Skip it if you want ordinary NES gameplay: independent runs show long waits, and the implementation is limited to a subset of console behavior.

nesformer infographic: inspect processor execution through a model architecture, plus our test result and who it suits
Tested 18 November 2026: the README snippet failed. Before that: 6 of 6 source tests passed; uv install took 3 s.

We ran it

Lab card: what happened when we ran nesformer
Lab card from our sandbox run
Install✓ · 16s42 packages · 411 MB
Build✓ · 1s
Tests✓ · 187s6 passed · 0 failed · 4 skipped of 6 (pytest)
Known vulns0(pip-audit)
Repo41 files~4,596 lines of source · 7.8 MB · 0 CI workflows · tests dir

Answers from our run

Does nesformer build from source?

Dependencies installed in 16 seconds (42 packages), and the build succeeded in 1 seconds. We cloned commit 26b1b05 into a clean Debian container with 3 CPUs and no project-specific setup.

Do nesformer's tests pass?

Yes. The project's own test command finished in 187 seconds and reported 6 passed, 0 failed, 4 skipped (pytest).

Does nesformer have known vulnerabilities in its dependencies?

pip-audit found none in the dependency tree at the time of our run.

Who should not use nesformer?

Players seeking an interactive NES emulator: independent runs advance far more slowly than console time.

What are the alternatives to nesformer?

Qwenputer, py65. Our sandbox installed nesformer in 16 seconds and completed the recorded build and test steps, making the repository practical to investigate.

Setup4/5In our 2026-11-18 run it installed as the README says in 3 s; the README gave no task we could run as written.Editor’s note: The recorded install and build succeeded, but conflicting test counts and absent raw runtime logs limit the setup assessment.
Docs4/5The README has an install section (“Quick start”) and a usage section (“Commands”); we did not run its quickstart ourselves.Editor’s note: The English README explains commands and file layout, but its execution-mode labels conflict and the full py65 harness is missing from the independent account.
Community3/5Last push on 2026-10-30 and 296 stars.Editor’s note: The packet contains independent short runs and one badge suggestion; this sample cannot establish support capacity or adoption.
Maturity1/5No tagged GitHub release, repository created 2026-10-30 and its test suite passed in our sandbox (6 of 6 passed).Editor’s note: Short trace comparisons and a reported matching rebuild support a bounded experiment; broad console compatibility and cross-machine behavior lack measured coverage.

How we score

Discussed on

  1. hnShow HN: A working Nintendo in ~1GB of Qwen weights298 points

Who it’s for

Researchers who want to inspect compiler-written weights and persistent model state.
Emulator developers interested in comparing CPU traces against a separate reference.
Python users willing to run short scripted experiments and examine their output.

Who it’s NOT for

Players seeking an interactive NES emulator: independent runs advance far more slowly than console time.
Users needing bank-switching cartridges, sound or support for unofficial opcodes: the documented implementation excludes them.
Teams requiring a reproduced full game-code conformance result: the independent py65 account covers a smaller diagnostic run with synthetic I/O.

Setup reality

Our November 18, 2026 run at 26b1b05 installed successfully in 16 seconds, recorded 42 dependencies and 411 MB on disk, and built in 1 second. The test step succeeded in 187 seconds, but its summary conflicts: 6 passed, 0 failed, 4 skipped of 6. pip-audit reported 0 known vulnerabilities.

The README documents local Python commands, local weights and ROM files, without a hosted-model credential. It asks for Python 3.11 or newer and explains where the weights directory belongs. The bundled ROMs retain their own licenses.

The recorded sandbox had 3 CPUs and 8 GB RAM. Its image label does not establish the actual runtime version. Successful repository checks do not measure gameplay speed; independent reports make the wait the main practical obstacle.

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.

Alternatives

ProjectWhat it isPick it when
QwenputerThe compiler predecessor explores CHIP-8 and RISC-V execution in model weights.Pick this instead when the earlier compiled-machine design is your research target.
py65Python tools for simulating 6502-based systems, used in the independent CPU comparison.Pick this instead when you need a CPU reference rather than a model-checkpoint experiment.

What people are saying

  1. [velocity-scout] dbreunig/nesformer
  2. [hackernews] A Working Nintendo in ~1GB of Qwen Weights

Sources

  1. Nesformer project and English README
  2. Independent checkpoint rebuild and CPU comparison
  3. CodeBridge short execution check
  4. Author demonstration and community posts
  5. r/emulation discussion
  6. NESformer video explanation transcript
  7. Freshweights checkpoint description
  8. Nohumans review and comparisons

More ai tools reviews