A RISC-V Computer Is Packed into the Model Weights, with Its Own DeltaNet Layers as Memory

Divyansh Agrawal (X account @divagr1925) has released Qwenputer: an experimental model that compiles a 32-bit RISC-V CPU into the weights of Qwen3.5-4B. The CPU occupies 11 transformer layers, inserted before Qwen's own 32 layers; the weights of these layers are not trained but computed by a compiler. The model uses its own Gated DeltaNet states as RAM and can run C and MicroPython during the forward pass without relying on an external runtime.

The model card is direct: it does not take the plugin, tool, or sandbox route. The CPU is a combination of RV32IM + Zba + a bignum coprocessor and can pass the official riscv-tests. The model architecture is still stock Qwen3_5ForCausalLM, with only the config changed. The hidden dimension is expanded from Qwen's 2560 to 3968, and 230,324 trace tokens are added to the vocabulary. The Hugging Face page lists 9B parameters, 18.8GB in bf16, most of which is zero padding; the computer portion has about 1 million non-zero weights. The author says it is exact under bf16.

The key is Gated DeltaNet. In Qwen3.5, 3 out of every 4 layers use Gated DeltaNet, and the author turns these layers into RAM: use a one-hot key to select an address and overwrite a row, then use a one-hot query to read it back. When gate and write strength are set to 1, a single row can be exactly overwritten and read back, the state size is fixed, and it does not grow as the chat gets longer. The CPU's registers, memory, and program counter are placed in the DeltaNet heads.

The execution method also bypasses common tool calling. Qwen writes a <tool_call> block for calc just as it normally calls a tool, but there is no external executor to take over outside the model. The computer layers read this call, run it on the RISC-V CPU, and the model itself writes out <tool_response> bit by bit. On an L4 with a Triton executor, the author reaches about 3,200 trace tokens per second. Every token still comes from the weights.

The filesystem is also packed into the GDN state. Save the state after a chat, and when it is loaded next time, the files are still there. The author's figures are about 90% recall after changing facts, versus about 30% for pasting the old chat back into context.

Benchmark results are as follows, greedy decoding, 40 questions per group:

On NUPA, Qwenputer gets 100%, base Qwen is 48.6%, tying with external Python. The author also replayed about 230,000 computer output positions and compared them against a reference machine model, with zero discrepancies; Qwen's text behavior has a KL of 6e-4 versus base, with a noise floor of 5e-4.

The project has already released an online demo, Hugging Face weights, ModelScope weights, filesystem model, code, and a blog post. There is also an easily overlooked limitation in the model card: most of the 18.8GB bf16 model is zero padding, and the CPU itself has only about 1 million non-zero weights; speed is measured in trace tokens and cannot be directly equated to the end-to-end latency of external Python.

Some netizens marveled in reposts that now even computers can be downloaded. That wording is a bit exaggerated, but Qwenputer packs compute units and model weights into the same forward pass, which indeed pushes the boundary between model, runtime, and tools one step further.