A CPU Was Stuffed into Qwen’s Weights, and It Even Runs Another LLM

There is now a RISC-V CPU inside the weights of Qwen3.5-4B. div (fp32) released Qwenputer and QwenPU on X. The former compiles a complete CPU into the weights; the latter goes further and lets another small LLM run inside the model as a C program.

First, the results. QwenPU lets Andrej Karpathy’s stories260K generate stories inside Qwen3.5-4B. stories260K is the 260K-parameter Llama from llama2.c and is itself just a C program. div (fp32) compiled the NPU and vector unit into Qwen’s weights to do matrix multiplication, softmax, and attention, with every step bit-for-bit identical to the reference implementation. There are no external tools; the LLM weights live in Qwen’s own memory.

Qwenputer is the earlier layer. It stuffs a complete RISC-V CPU into Qwen3.5-4B’s weights, uses the model’s own Gated DeltaNet layers as RAM, and runs C and MicroPython during the forward pass without needing an external runtime. The author gave benchmarks in the tweet: on DeepMind math problems, base Qwen3.5-4B scores between 55% and 90%, base plus Python tools scores between 95% and 100%, and Qwenputer scores between 97.5% and 100%. On NUPA, Qwenputer gets 100% while the base is 48.6%, essentially matching Qwen plus Python.

The key mechanism is not complicated, but it is hardcore. Three out of every four layers in Qwen3.5 use Gated DeltaNet. The author uses one-hot keys to select memory addresses and sets the gate and write strength to 1, so a single slot can be overwritten and then read back exactly. As the chat gets longer, this memory stays a fixed size. The author also built a filesystem inside this GDN state: save the state at the end of one chat, load it into the next chat, and the files are still there. For facts that have been changed, recall accuracy is about 90%; pasting old chat history back in gives about 30%.

QwenPU’s vector unit adds matrix-vector multiplication, elementwise operations, and attention to the CPU, letting the entire neural network run as a program inside the model’s own forward pass. The new weights are not learned through training; they are computed by a compiler. That sentence is worth pausing on: this is not fine-tuning a model to be better at problems; it is compiling a computational structure into the weights.

The cost comparison for running stories260K is as follows:

The vector unit has 16 64-word registers, 384 int8 lanes, and reads 64 lanes at a time. Weight memory is 4,152 row chunks; each chunk has 64 int4 weights and one row scale. It reads two rows at a time to guarantee exact byte reads. The K/V cache has 32 positions. Instructions include VMAT, VQ, VEW, VMATR, VEXP, VRED, VGET, and VPUT. Each op first uses a few config tokens to carry operands, then streams out results, and every token is an exact step in the compiled layer.

On speed, the GPU executor runs about 3,300 trace tokens per second on an L4, which is about 16 seconds per story token. Qwenputer NPU is 41 seconds. That number is not fast, but the direction is clear: a model’s forward pass is no longer just computing the next token; it can execute a program inside itself.

The limitations are direct too. QwenPU’s checkpoint is 26.7GB in bf16, most of it zero padding. Fully loading it requires a 40GB or larger GPU. The story demo and checks run the computer layer separately and can run on a 24GB GPU. The author says he is shrinking the hidden size and still optimizing. The author was sick while writing this, so the full write-up is not finished yet.

In community reactions, some call it inceptionLLM, some call it Qwewception, and some say it is like running Minecraft on a redstone computer inside Minecraft. Others ask how this differs from MoE. MoE routes tokens to different experts; QwenPU stuffs a CPU, vector unit, and program state into the weights and DeltaNet state and executes an instruction stream. The two are not on the same level.

The code and weights are already out:

• GitHub: https://github.com/divagr18/QwenPU
• Hugging Face: https://huggingface.co/divagr1925/QwenPU
• ModelScope: https://modelscope.ai/models/Spartan1925/QwenPU
• Qwenputer demo: https://modelscope.ai/studios/Spartan1925/Qwenputer
• Author’s write-up: https://divagr.com/blog/qwenputer

Stuffing a CPU into LLM weights sounds like a joke. div (fp32) turned it into something runnable, inspectable, and not exactly small.