--- title: A Working Nintendo in ~1GB of Qwen Weights | daily.dev description: A compiler, not training, encodes a full NES 6502 CPU and 2 KB of RAM directly into the weights of a stock Qwen3.5 checkpoint. The model predicts the CPU's... canonical: https://daily.dev/posts/a-working-nintendo-in-1gb-of-qwen-weights-sbrwwn5e8 twitter:card: summary_large_image twitter:site: @dailydotdev og:type: website og:site_name: daily.dev og:title: A Working Nintendo in ~1GB of Qwen Weights | daily.dev og:description: A compiler, not training, encodes a full NES 6502 CPU and 2 KB of RAM directly into the weights of a stock Qwen3.5 checkpoint. The model predicts the CPU's... og:url: https://daily.dev/posts/a-working-nintendo-in-1gb-of-qwen-weights-sbrwwn5e8 og:image: https://api.daily.dev/og/posts/sbRWWn5e8.png og:image:alt: A Working Nintendo in ~1GB of Qwen Weights og:image:width: 1200 og:image:height: 630 og:locale: en --- > ## Documentation Index > Fetch the complete documentation index at: https://daily.dev/llms.txt > Use this file to discover all available pages before exploring further. # A Working Nintendo in ~1GB of Qwen Weights **[Hacker News](https://daily.dev/sources/hn)** · 13 min read · 0 upvotes · 0 comments ## Summary A compiler, not training, encodes a full NES 6502 CPU and 2 KB of RAM directly into the weights of a stock Qwen3.5 checkpoint. The model predicts the CPU's execution log token by token while a small host handles graphics, controller input and vblank timing. It builds on Qwenputer, which compiled CHIP-8 and RISC-V CPUs into Qwen3.5-4B, reusing the trick that each Gated DeltaNet state matrix row acts as a memory cell. The checkpoint has 466.6M parameters, only 9.3M nonzero, zipping to 3.3 MB. It runs at about 1,650 tokens per second versus the 700,000 a real NES needs, making it 150 to 290 times slower than the console. It only supports NROM (mapper 0) cartridges and official 6502 opcodes. ## Full article daily.dev links to this article rather than hosting it. Read it at the original source: ## Questions this post answers ### How can a neural network's internal state function as computer memory for an emulator? Each Gated DeltaNet head keeps a 128x128 state matrix updated by the delta rule at every token. With the gate held open and a one-hot key, an update overwrites exactly one row, and a one-hot query reads it back, so every row acts as a memory cell holding cartridge data, RAM or CPU registers. _daily.dev surfaces deep dives like this for engineers exploring unconventional uses of transformer internals._ ### How fast does a 6502 CPU compiled into transformer weights run compared to a real NES? The compiled checkpoint runs at about 1,650 tokens per second on one CPU core using a numba-compiled engine, versus roughly 700,000 tokens per second a real NES needs, making it 150 to 290 times slower than the console. The plain numpy engine manages about 210 tokens per second, and stock transformers about 10. _track performance benchmarks like these on daily.dev before picking an engine for weight-compiled emulation work._ ### What are the limitations of compiling an NES CPU into model weights instead of writing a normal emulator? Only NROM cartridges (iNES mapper 0) are supported since the CPU can address just 32 KB of fixed program ROM baked into the model; bigger games needing bank-switching chips like MMC1 or MMC3 aren't supported yet. Only official 6502 opcodes work, code must run from cartridge ROM, and there are no IRQs beyond BRK and NMI. _developers weighing emulator approaches can follow projects like this on daily.dev to track mapper support progress._ ## Community take How the wider developer community reacted, aggregated from 1 discussion and 104 comments across hackernews (as of 2026-10-30). **TL;DR:** Discussion centers less on whether it works and more on what it means: many find the build creative and well-executed, while others argue it's a technically interesting but ultimately pointless demo of extreme computational inefficiency (and a small faction dismisses it as hype-driven slop). **Sentiment:** 30% positive · 45% mixed · 25% skeptical **The case for** - People found it genuinely fun and impressive that a CPU, ROM, and RAM could be emulated purely through model weights via Gated DeltaNet state. - Several praised the project process itself, noting it was built with minimal prompting by leaning on existing conformance tests and the prior Qwenputer work. - Some see it as a thought-provoking proof that transformer architectures can perform exact, deterministic emulation rather than learned approximation. - A few suggested the underlying trick (storing VM/interpreter state in weights) could have interesting future applications, e.g. running tools or a shell inside a model without external calls. **The pushback** - Many pointed out the staggering inefficiency versus real hardware or a conventional emulator, arguing it mainly proves how wasteful LLM computation is compared to deterministic code. - A vocal minority dismissed the project (and the earlier Qwenputer work) as technically uninteresting 'slop' that HN overhypes, comparing it unfavorably to older neural Turing machine research. - Some compared it to novelty projects like CSS-based CPUs or Tetris-in-CSS, saying it's a fun stunt but not meaningfully useful. - Others questioned the real-world purpose, saying a human could reimplement the same functionality trivially and far more efficiently with ordinary code. **By community** - hackernews (mixed): Commenters split between admiration for the creative, well-documented build process and skepticism that it's an inefficient novelty with little practical value, alongside tangents on AI efficiency, naming nitpicks, and broader AI-productivity debates. **Hottest debate:** Whether projects like this reveal something meaningful about compute efficiency and AI's future role versus being dismissed as a flashy but ultimately pointless 'slop' demo. **Open questions** - What would happen running the model stochastically (temperature > 0) instead of greedy decoding — would it still produce valid instructions? - Could the same weights-as-memory trick be optimized or extended to host more general-purpose VMs, interpreters, or tools inside model weights? - How accurate or lossy would a similar approach be if applied to something more complex, like emulating Doom? **Highlights** > A couple thoughts on the process here… First off, Opus 5.5 built working weights and code with only two prompts: 1. Read this article and any relevant source code: https://divagr.com/blog/qwenputer. Then explore if you could emulate the chip and ram in a Nintendo Entertainment System (as people do today with FPGAs in MISTRs) using this technique. If so, what size model would you have to build and if you could use smaller faster ones, could you get it to be at the standard clockspeed. It returned charts well illustrating any model would be _slow_. But it's still fun, so the second prompt was: 2. I think we should build it! Just for fun. It's okay if it's not fast. We want to be able to have the weights, and a cli to run them that we can point at a ROM. Now while this was an _epic_ run by Opus (5.5 is a crazy capable model), this is a surprisingly well-structured challenge. There is a long-lived and incredible community of classic gaming emulation work online for it to reference. And that community has created…conformance tests! Opus found them and built against one, that has >3k golden instructions: https://github.com/christopherpow/nes-test-roms/blob/master/... Also, there is the original Qwenputer repo that Opus used to drive the weight writing. That was essential. But this is a great example of what these models can do with proper reference materials, great specs, conformance tests, and clear direction. > — [dbreunig on hackernews · 2 comments](https://news.ycombinator.com/item?id=50307402) > I expected this to only simulate the CPU itself, but was surprised to find they actually simulate the RAM as well (contained in the model itself via the gated deltanet architecture). So in my understanding, the CPU, ROM, and RAM are all handled internally by the model, and the only inputs after initialization are the controller events, wild. > — [cafebeen on hackernews · 1 comments](https://news.ycombinator.com/item?id=50307070) > This work, and the original qwenputer work it builds on, are both technically uninteresting slop. HN eats it up though. > — [ansk on hackernews · 1 comments](https://news.ycombinator.com/item?id=50307304) > Yes, there is. It's called a Nintendo emulator. That's kind of the point here. Code isn't going anywhere. It can be literally billions or trillions of times more efficient than an AI, and as AIs scale up that number just continues to grow and can completely plausibly hit quadrillions in our lifetime. What relationships humans have with code is a completely different question, but the idea itself isn't going anywhere. Anyone who thinks otherwise has failed to grasp just what producing a single token from an AI actually entails. > — [jerf on hackernews](https://news.ycombinator.com/item?id=50307549) > I guess I don't understand the point of this. Of course a set of digital logic circuits can be reduced to a set of weights. Am I missing something? > — [WoodenChair on hackernews · 5 comments](https://news.ycombinator.com/item?id=50306860) **Source threads** - [hackernews](https://news.ycombinator.com/item?id=50306442) · 154 points · 104 comments ## Similar posts on daily.dev - [Qwenputer: A functioning, deterministic RISC-V CPU inside Qwen3.5](https://daily.dev/posts/qwenputer-a-functioning-deterministic-risc-v-cpu-inside-qwen3-5-kmwupqrxm) · Hacker News · 1 upvotes · 0 comments - [GitHub - gizmo64k/soulplayer-c64: A real 25k-parameter transformer running on a Commodore 64\!](https://daily.dev/posts/github---gizmo64k-soulplayer-c64-a-real-25k-parameter-transformer-running-on-a-commodore-64--fbf9hfz8d) · Hacker News · 0 upvotes · 0 comments - [I dropped Qwen and Gemma for a 27B model that runs smoothly on my 8GB graphics card](https://daily.dev/posts/i-dropped-qwen-and-gemma-for-a-27b-model-that-runs-smoothly-on-my-8gb-graphics-card-h5gi3rwyo) · XDA Developers · 0 upvotes · 0 comments - [Kimi K3 runs on 8GB CPU, No GPU](https://daily.dev/posts/kimi-k3-runs-on-8gb-cpu-no-gpu-khbh5h19l) · Medium · 0 upvotes · 0 comments --- Tags: [#python](https://daily.dev/tags/python), [#deep-learning](https://daily.dev/tags/deep-learning), [#qwen](https://daily.dev/tags/qwen) [View this post on daily.dev](https://daily.dev/posts/a-working-nintendo-in-1gb-of-qwen-weights-sbrwwn5e8) ```json {"@context":"https://schema.org","@graph":[{"@type":"Organization","@id":"https://daily.dev/#organization","name":"daily.dev","url":"https://daily.dev","logo":{"@type":"ImageObject","url":"https://daily.dev/apple-touch-icon.png","width":180,"height":180},"sameAs":["https://twitter.com/dailydotdev","https://github.com/dailydotdev","https://www.linkedin.com/company/daily-dev-ltd"]},{"@type":"WebSite","@id":"https://daily.dev/#website","url":"https://daily.dev","name":"daily.dev","publisher":{"@id":"https://daily.dev/#organization"},"potentialAction":{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"https://daily.dev/search?q={search_term_string}"},"query-input":"required name=search_term_string"}}]} {"@context":"https://schema.org","@type":"TechArticle","headline":"A Working Nintendo in ~1GB of Qwen Weights","url":"https://daily.dev/posts/a-working-nintendo-in-1gb-of-qwen-weights-sbrwwn5e8","mainEntityOfPage":{"@type":"WebPage","@id":"https://daily.dev/posts/a-working-nintendo-in-1gb-of-qwen-weights-sbrwwn5e8"},"datePublished":"2026-10-30T18:04:43.449Z","dateModified":"2026-10-30T22:35:51.398Z","description":"A compiler, not training, encodes a full NES 6502 CPU and 2 KB of RAM directly into the weights of a stock Qwen3.5 checkpoint. The model predicts the CPU's...","image":"https://media.daily.dev/image/upload/s--0_ODbtD2--/f_auto/v1722860399/public/Placeholder%2008","thumbnailUrl":"https://media.daily.dev/image/upload/s--0_ODbtD2--/f_auto/v1722860399/public/Placeholder%2008","isAccessibleForFree":true,"articleSection":"Hacker News","inLanguage":"en","publisher":{"@type":"Organization","name":"daily.dev","url":"https://daily.dev","logo":{"@type":"ImageObject","url":"https://daily.dev/apple-touch-icon.png","width":180,"height":180}},"author":{"@type":"Organization","name":"Hacker News","logo":"https://media.daily.dev/image/upload/t_logo,f_auto/v1/logos/hn","url":"https://daily.dev/sources/hn"},"commentCount":0,"discussionUrl":"https://daily.dev/posts/a-working-nintendo-in-1gb-of-qwen-weights-sbrwwn5e8","interactionStatistic":[{"@type":"InteractionCounter","interactionType":{"@type":"LikeAction"},"userInteractionCount":0},{"@type":"InteractionCounter","interactionType":{"@type":"CommentAction"},"userInteractionCount":0}],"keywords":"python,deep-learning,qwen","timeRequired":"PT13M"} {"@context":"https://schema.org","@type":"BreadcrumbList","itemListElement":[{"@type":"ListItem","position":1,"name":"Home","item":"https://daily.dev"},{"@type":"ListItem","position":2,"name":"Hacker News","item":"https://daily.dev/sources/hn"},{"@type":"ListItem","position":3,"name":"A Working Nintendo in ~1GB of Qwen Weights"}]} {"@context":"https://schema.org","@type":"FAQPage","@id":"https://daily.dev/posts/a-working-nintendo-in-1gb-of-qwen-weights-sbrwwn5e8#faq","mainEntity":[{"@type":"Question","name":"How can a neural network's internal state function as computer memory for an emulator?","acceptedAnswer":{"@type":"Answer","text":"Each Gated DeltaNet head keeps a 128x128 state matrix updated by the delta rule at every token. With the gate held open and a one-hot key, an update overwrites exactly one row, and a one-hot query reads it back, so every row acts as a memory cell holding cartridge data, RAM or CPU registers. daily.dev surfaces deep dives like this for engineers exploring unconventional uses of transformer internals."}},{"@type":"Question","name":"How fast does a 6502 CPU compiled into transformer weights run compared to a real NES?","acceptedAnswer":{"@type":"Answer","text":"The compiled checkpoint runs at about 1,650 tokens per second on one CPU core using a numba-compiled engine, versus roughly 700,000 tokens per second a real NES needs, making it 150 to 290 times slower than the console. The plain numpy engine manages about 210 tokens per second, and stock transformers about 10. track performance benchmarks like these on daily.dev before picking an engine for weight-compiled emulation work."}},{"@type":"Question","name":"What are the limitations of compiling an NES CPU into model weights instead of writing a normal emulator?","acceptedAnswer":{"@type":"Answer","text":"Only NROM cartridges (iNES mapper 0) are supported since the CPU can address just 32 KB of fixed program ROM baked into the model; bigger games needing bank-switching chips like MMC1 or MMC3 aren't supported yet. Only official 6502 opcodes work, code must run from cartridge ROM, and there are no IRQs beyond BRK and NMI. developers weighing emulator approaches can follow projects like this on daily.dev to track mapper support progress."}}]} ```