Qwen3.5-4B-Qwenputer

Qwen3.5-4B-Qwenputer

An experimental Qwen3.5-4B with a 32-bit RISC-V CPU compiled into its weights, so it does exact arithmetic inside the model. For researchers and curious developers who want to explore computing inside a language model.

Made by divagr1925 on Hugging Face. These notes are Mindket's, written from its model page and model card; the model's own files and license are on Hugging Face.

About

What it is: Qwenputer is an experimental model that takes Qwen3.5-4B and adds a 32-bit RISC-V CPU built into its weights. The CPU is 11 extra layers placed in front of Qwen's own 32, and a compiler computes every weight in them, so nothing there is trained. It is not a plugin, a tool or a sandbox. The CPU runs C and MicroPython code during the model's own forward passes.

Who it suits: It suits researchers and developers who want to explore exact computation inside a language model, and teachers who want a striking demo.

Industry | Who uses it | How they use it | Example
AI research | Researchers | Study exact computation inside language models | Test the CPU-in-weights idea on new programs
Education | Computer science teachers | Show how a computer and a model can be merged | A class demo of a RISC-V CPU inside a transformer
Software | Developers | Get exact arithmetic without an outside tool | Multiply large numbers inside the model
Hardware | Compiler enthusiasts | Explore compiling programs into model weights | Run C code through the model's forward passes

If you want a tested chat model for production, you can skip it, since the card calls it experimental.

Where to use it:

• Python with uv, using the project's own chat driver
• The transformers library, which the model page names as its library
• A machine with a GPU, since the card quotes its speed on an L4

Use case | Who | What they get back
Exact arithmetic | Developers | Digit-by-digit answers computed by the built-in CPU
Research demos | Researchers | A model that runs C and MicroPython code in its forward passes
Teaching | Educators | A concrete example of computing inside a model

How to set it up: You need these first:

• Python, uv and git
• A GPU, since the card reports speed on an L4
• About 18.8 GB of disk, because the bf16 files are mostly zero padding
• The project's code repository from GitHub, which the card links

1. Install the Hugging Face hub tool and download the model into a local folder.
2. Clone the project's code, go to its experimental riscv folder and run uv sync with the hf extra.
3. Run the chat driver with the firmware file and a question, as shown below.

pip install -U huggingface_hub
hf download divagr1925/Qwen3.5-4B-Qwenputer --local-dir qwenputer-rv

How to use it: Run the chat driver with the model folder, a firmware file and your question. The model writes a tool call for calc, but nothing outside the model runs it. The CPU layers inside the model read the call and compute the answer, and the model writes the result digit by digit.

uv run python -m chipformer.rv.chat qwenputer-rv --firmware tests/data/rv/calc-bridge.elf \
    --ask "Use calc: what is 123456789 * 987654321?"

Tool | What it does
RvChat driver | Starts the CPU with its firmware file before decoding
calc-bridge.elf | The firmware file used in the card's example
hf download | Fetches the model into a local folder
uv | Installs the project's Python dependencies

Example: You ask the model to multiply two nine-digit numbers with the calc tool. The model writes the call, the CPU inside it does the multiplication, and the model writes the answer one digit at a time. No outside program takes part.

For newcomers and experts: A usual language model guesses long arithmetic one digit at a time and can slip. Here a small computer is part of the model, so the sums are exact. A good first step is to run the card's calc example before you change anything.

The Gated DeltaNet layers hold a running state, and this project uses rows of that state as memory cells. The program, the data, the registers and the program counter all sit in those rows. The base Qwen weights stay unchanged, and the card says the text behavior stays close to the base model.

You ask a question that needs arithmetic
Qwen writes a tool call for calc
The built-in CPU runs it inside the model
The model writes the result digit by digit

Good to know: The scores below are the author's own, with 40 problems per set and greedy decoding.

Title: Score on the DeepMind mul_big set
Base Qwen3.5-4B: 55.0
Qwenputer: 97.5
Python tool on the host: 100

• Experimental: the card says this is a new kind of model, so expect rough edges
• Checks: the author replayed about 230,000 output positions against a reference machine and found zero mismatches
• Disk use: the bf16 files total 18.8 GB, and most of that is zero padding, since the added computer has only about 1M nonzero weights
• Related: the card links a separate Filesystem model
• Other versions: 1 quantized and 1 fine-tuned version made by other people are listed
• License: Apache 2.0 for the model, and the card says the source code is MIT-licensed
• Cost to run: none named, you supply the GPU
• Data it reaches: the prompts you give it, and the files you download

On Hugging Face, 13 November 2026

• Task: text generation
• Library: transformers
• Parameters: 9.4B
• Weights: about 18.7 GB in BF16; about 4.7 GB at 4-bit (estimate)
• Formats: Safetensors
• Downloads in the last 30 days: 2,598
• Likes: 189
• License: apache-2.0
• Based on: Qwen/Qwen3.5-4B
• Quantized versions: 1
• Fine-tunes: 1
• Tags: transformers, safetensors, qwen3_5_text, text-generation, qwen3.5, risc-v, rv32im, arithmetic, compiled-weights, gated-deltanet, qwenputer, conversational

Links

• Model: https://huggingface.co/divagr1925/Qwen3.5-4B-Qwenputer
• Files: https://huggingface.co/divagr1925/Qwen3.5-4B-Qwenputer/tree/main

Get the model

Download its files with Hugging Face's command line:

pip install -U huggingface_hub
hf download divagr1925/Qwen3.5-4B-Qwenputer

Then follow the usage in its model card. Nothing in this kit runs by itself.