A working RISC-V CPU now runs inside a language model's weights — no silicon, no sandbox, no external runtime

The video is thirteen seconds long and shows almost nothing a casual viewer would recognize as a computer. A demo window, a grid labeled as CPU and RAM, and a prompt: work out −2,241,842 × 8,077. There is no voiceover, no music, no spinning 3D render. What makes it travel is the claim behind the window: the arithmetic is not being done by a calculator app, a Python sandbox, or a tool server. It is being done by a processor that lives inside the language model itself — compiled into its weights, running in its forward passes, with the model’s own memory layers acting as RAM.

It was posted to r/LocalLLaMA on the morning of October 28 by u/LatentSpacer, with a short body — “This might have implications for tool calling and computer use” — and links to the write-up, the Hugging Face model, and a live demo. By the time the thread was read for this article it had gathered about 429 upvotes and 68 comments. The reaction is best described as delighted skepticism: nobody in the top comments says the thing is fake, but several immediately ask what it is actually for.

How you compile a computer into weights#

Qwenputer is the work of Divyansh Agrawal, and the write-up is unusually explicit about the trick. Qwen 3.5’s architecture uses Gated DeltaNet — a linear recurrent layer — for three of every four attention layers. Each such head keeps a state matrix that updates by a delta rule. Agrawal’s insight is that with the gate pinned to 1 and the write strength pinned to 1, and with one-hot keys that point at exactly one row of the state, those layers stop behaving like fuzzy memory and start behaving like exact, addressable RAM: every write overwrites exactly one row, every query reads back exactly one value, and the state stays the same size no matter how long the conversation runs.

Once RAM exists, a CPU is a compiler problem rather than a training problem. No training is involved at all: a compiler describes the processor as a circuit — read this register, add these two numbers, jump if zero — and turns each step into transformer machinery, with attention heads doing lookups, feed-forward units doing arithmetic, and DeltaNet heads holding the RAM. The result is a 32-bit RISC-V core implementing the RV32IM instruction set plus the Zba extension and a small unit for big-number arithmetic, occupying 11 layers placed in front of Qwen’s own 32. The model’s original weights are untouched; the computer weights are added on top, in extra dimensions and layers. Each CPU instruction becomes a few generated tokens — an address token, a value token, a step token — so while Qwen is generating, the CPU is literally running.

What it can actually do#

The write-up’s evidence is stronger than the usual demo reel. The CPU passes the official RISC-V test suite, its programs match QEMU, and it ran 18 million instructions free-running — with no reference machine correcting it between steps — without a single error. It runs C and MicroPython code inside the forward passes, and the author replayed about 230,000 of its output positions against a reference machine and found zero mismatches. On arithmetic benchmarks, the in-model CPU lifts Qwen 3.5 4B from guesswork to exactness: on the NUPA long-integer set it goes from 48.6% to 100%, the same as handing the model a Python tool, and on DeepMind’s division and multiplication sets it lands within a few points of the tool-assisted scores while the base model trails far behind. Bolting the computer on does not change how the model talks, either — its ordinary text stays within noise of the base model.

There is even a filesystem, in an experimental branch: internal put, append, get, list, and delete operations backed by the same DeltaNet state, holding up to 512 files or roughly 53,000 tokens of text, persistent across conversations if the state is saved and reloaded. In the author’s test it recalled facts that changed between chats 90% of the time, against 30% for pasting old chats back in. The whole stack is open: code on GitHub, models on Hugging Face and ModelScope, and a live demo anyone can poke at. One honest caveat from the write-up itself: the write-up is dated October 22. What is new today is the Reddit wave around it, not the project.

What the thread thinks#

The top comment, from u/-dysangel-, quotes the post’s own framing and then punctures it gently: the model still has to initiate the computation through a tool call, so it is “a fun idea” but unclear when it would beat simply making a normal tool call. The creator, posting as u/RevealIndividual7567, confirmed the mechanics in the thread: the demonstrated version piggybacks on the tool-use format that models are already trained on, the actual computation happens completely inside the forward passes with no external runtime, and a zero-call method is “more or less finished” but was not the demonstrated path. The original poster added that this is a first prototype and invited readers to imagine models trained from the ground up with a Turing-complete machine inside.

Other top comments land in the same register. One compares it to building processors from blocks in Minecraft — cool, and proof of deep understanding of gate and register logic, but “not exactly useful.” Another calls it “a compiler with extra steps.” A third warns against using “a computer emulated in weights run on software for any real application.” None of this is a debunk: the CPU is real, the tests pass, the code is public. It is a scope correction, and an unusually good-natured one. The thread agrees the demo is genuine and disagrees, politely, about whether genuineness is enough.

What to watch#

Three things will decide whether Qwenputer is a curiosity or a direction. First, the zero-call method: if the CPU can be invoked without borrowing the tool-call format, the “compiler with extra steps” objection loses much of its force. Second, speed: every instruction currently costs a few decoded tokens, so a big calculation takes seconds rather than milliseconds, and the batched executor runs about 3,200 CPU tokens a second on an L4 — fine for a demo, nowhere near a runtime. Third, the safety angle the author flags as the deeper point: exact control over a model’s recurrent layers could yield an in-weight monitor the model itself cannot switch off, or answer keys for interpretability — uses where the computer inside the model matters precisely because it is not a separate tool the model can evade.

For now, the fair summary is the thread’s own: a real computer, compiled into weights, demonstrated honestly, with its limits stated by its creator and its usefulness still to be shown. That is a rarer combination than it sounds.

Sources: the original post by u/LatentSpacer on r/LocalLLaMA (October 28, 2026); Divyansh Agrawal’s Qwenputer write-up (October 22, 2026); the Qwenputer model on Hugging Face; and the qwenputer repository on GitHub. The editorial illustrations are AI-generated.