Qwenputer-npu

Qwenputer-npu

A Qwen3.5-4B model with a small RISC-V computer built into its weights, used for exact arithmetic and for running a tiny story model. An experiment for researchers who study programs inside transformers.

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-npu takes Qwen3.5-4B and builds a small 32-bit RISC-V processor into the model's own layers. This version adds a neural network instruction set to that CPU. That is quick enough to run another language model on it, a tiny 260K parameter story writer compiled as a C program. The Qwen weights themselves are unchanged.

Who it suits: Researchers and curious engineers who want to study how a program or a computer can live inside a transformer.

Industry | Who uses it | How they use it | Example
AI research | Researchers on transformer internals | Run the chip layers and compare them with a reference model | Checking that the CPU layers match a reference for test programs
Systems and compilers | Engineers who like unusual computing targets | Study how code is compiled into model weights | Reading how a dot product instruction maps to layers
Education | Teachers of computer architecture | Show a CPU running inside a language model | Running the story program and watching the output

Skip it if you want a general chat model, since this is a research experiment and not a tuned assistant.

Where to use it: It runs from the project's own Python tools, with uv, on a machine that can hold the weights. The files download on Windows, macOS or Linux.

• Python with the uv tool
• A clone of the qwenputer project, on its npu branch
• A GPU for speed, since the author timed it on an L4
• Windows, macOS or Linux: where you can fetch the files with Python

Use case | Who | What they get back
Exact arithmetic | Researchers | Answers from the built in CPU for calc tasks
Instruction checks | Engineers | A test run of the new instructions on the model's layers
Story generation | Curious users | A story written by the small model on the CPU

How to set it up: Clone the project's npu branch from GitHub, move into its experimental riscv folder and run uv sync with the hf extra. Then download the checkpoint.

• Python with pip and uv
• Git, to clone the qwenputer project
• About 19.6 GB of disk space for the bf16 weights, much of it zero padding

1. Clone the project and install its dependencies with uv.
2. Download the checkpoint with the hf command.
3. Run the chat, check and story commands from the project folder.

pip install -U huggingface_hub
hf download divagr1925/Qwenputer-npu

How to use it: From the project folder, these commands download the checkpoint locally, ask a calculation, check the new instructions and write a story on the CPU.

hf download divagr1925/Qwenputer-npu --local-dir qwenputer-npu
uv run python -m chipformer.rv.chat qwenputer-npu --firmware tests/data/rv/calc-bridge.elf \
    --ask "Use calc: what is 123456789 * 987654321?"
uv run python -m chipformer.rv.npucheck qwenputer-npu guests/stories260k/stories260k.elf
uv run python guests/stories260k/storyrun.py guests/stories260k/stories260k.elf

Tool | What it does
chipformer.rv.chat | Chats with the model and lets it use the built in calc
chipformer.rv.npucheck | Runs the new instructions on the checkpoint's layers
storyrun.py | Writes the story on the CPU's executor

Example: You run the chat command with the question about multiplying 123456789 by 987654321. Qwen hands the sum to the CPU inside its weights, and the CPU returns the exact product for Qwen to report.

For newcomers and experts: If you are new to this, think of a language model that carries a tiny computer inside itself and asks it to do exact maths. Start with the chat command and the multiplication question.

If you know the field, the CPU is 11 transformer layers placed in front of Qwen's own, with Gated DeltaNet state acting as RAM. Two new instructions, a packed int4 dot product and a byte product, plus a weight memory, make a story model run in far fewer trace tokens. The card reports about 41 seconds per story token on an L4.

Qwen asks the built in CPU
Compiled layers run the program
CPU returns the exact result
Qwen writes the final reply

Good to know: The card says its checks against a reference model of the CPU found no mismatches, and that Qwen's text behaviour stays close to the base model. The scores below are its own, on two sets of 40 problems.

Title: Card benchmark scores
Benchmark | Base Qwen3.5-4B | Qwenputer-npu
Synthetic integer arithmetic | 75.0 | 90.0
DeepMind mul_big | 55.0 | 97.5

• License: Apache 2.0
• Cost to run: none named, you supply the hardware
• Data it reaches: local files in the project folder, such as the firmware and checkpoint
• Not for: general chat or production use, since it is a research experiment

On Hugging Face, 13 November 2026

• Task: text generation
• Library: transformers
• Parameters: 9.8B
• Weights: about 19.6 GB in BF16; about 4.9 GB at 4-bit (estimate)
• Formats: Safetensors
• Downloads in the last 30 days: 490
• Likes: 7
• License: apache-2.0
• Based on: Qwen/Qwen3.5-4B
• Tags: transformers, safetensors, qwen3_5_text, text-generation, qwen3.5, risc-v, rv32im, compiled-weights, gated-deltanet, qwenputer, conversational

Links

• Model: https://huggingface.co/divagr1925/Qwenputer-npu
• Files: https://huggingface.co/divagr1925/Qwenputer-npu/tree/main

Get the model

Download its files with Hugging Face's command line:

pip install -U huggingface_hub
hf download divagr1925/Qwenputer-npu

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