Qwenputer Embeds a RISC-V CPU and Filesystem Inside an AI Model

Qwenputer turns an AI model into a small, self-contained computing environment. Divyansh Agrawal’s experimental version of Qwen 3.5 4B has a 32-bit RISC-V processor compiled into its weights, plus memory and a filesystem built from the model’s internal state. It can perform exact arithmetic and run C and MicroPython code without calling an external runtime or tool. It can even run DOOM, though the game runs very slowly.

The unusual part is how the processor gets there. Agrawal says the CPU is implemented in 11 transformer layers placed before Qwen’s own layers. Those added layers aren’t trained: a compiler calculates their weights. That makes Qwenputer different from an ordinary language model whose behavior comes from learned parameters. Here, a defined processor is encoded into those parameters so the model can send it instructions and read back the results.

Using model state as memory

Qwenputer uses Qwen’s Gated DeltaNet state as RAM. The approach of treating a model’s fast weights as memory has precedents, Agrawal says; the distinctive step here is adapting Qwen 3.5’s state to support the processor. In practical terms, the model has a place to hold working data while its embedded CPU executes programs.

This matters because language models can produce incorrect arithmetic even when the calculation is straightforward. Qwenputer delegates those operations to a processor, whose results are exact when the program runs correctly. It also gives the model a way to execute code rather than merely generate code for another system to run. C and MicroPython are supported, according to Agrawal.

The developer reports that the CPU passes the RISC-V test suite, produces program results matching QEMU, and has completed 18 million instructions in a continuous run without an error. Those results describe the processor’s behavior under the reported checks; they don’t establish how quickly it handles typical workloads. The DOOM demonstration makes that distinction visible: execution works, but performance is slow.

A filesystem that travels with the conversation

Agrawal added filesystem storage using the same DeltaNet state that provides RAM. The design has 1,024 slots and can hold as many as 512 files. Saving the model’s state at the end of a conversation preserves that storage, letting files persist between sessions when the saved state is reused.

That persistence makes Qwenputer more than a processor demonstration. Memory and files give programs somewhere to keep intermediate results and stored data, while the model supplies the interface for working with them. But the storage is tied to the model’s saved state, so this setup also makes state management part of the computing environment. The source doesn’t describe how the file limits affect larger workloads or how users should manage multiple saved states.

The cost of putting computation inside the model

These additions nearly double the size of the underlying Qwen 3.5 4B model, bringing Qwenputer to almost 19GB. Agrawal recommends a workstation with at least 24GB of VRAM for trying the current version. That memory requirement is a substantial practical constraint: the design may avoid external runtime calls, but it asks the host system to load a much larger model.

Speed is another open issue. The project’s creator is working to improve performance and make coding in Qwenputer easier. The available description doesn’t give timing comparisons against a conventional CPU or explain how much of the observed slowness comes from the model-based implementation. For now, the demonstration establishes that a processor can be represented this way; it doesn’t show that the approach is a practical replacement for ordinary execution environments.

An experiment with a useful technical question

Qwenputer appears designed to test what can fit inside a language model, rather than address a clearly defined production need. Its combination of compiled processor logic, model-state memory, and persistent files raises a useful engineering question: which parts of a computing stack can be represented inside model weights, and what resource costs follow?

For teams evaluating it, the immediate tradeoff is clear. Qwenputer offers exact execution and a contained environment, but its current size and slow performance limit its appeal for routine computing. The next meaningful signs of progress will be faster execution, a smoother way to write and run programs, and evidence about how the design behaves beyond demonstrations. Agrawal has made the project’s code available under the MIT license on GitHub, and the model can be downloaded from Hugging Face.