Instructions to use divagr1925/Qwen3.5-4B-Qwenputer-Filesystem with libraries, inference providers, notebooks, and local apps. Follow these links to get started.

Libraries

How to use divagr1925/Qwen3.5-4B-Qwenputer-Filesystem with Transformers:

# Use a pipeline as a high-level helper
from transformers import pipeline

pipe = pipeline("text-generation", model="divagr1925/Qwen3.5-4B-Qwenputer-Filesystem")
messages = [
    {"role": "user", "content": "Who are you?"},
]
pipe(messages)

# pip install -U transformers accelerate
# Load model directly
from transformers import AutoTokenizer, AutoModelForCausalLM

tokenizer = AutoTokenizer.from_pretrained("divagr1925/Qwen3.5-4B-Qwenputer-Filesystem")
model = AutoModelForCausalLM.from_pretrained("divagr1925/Qwen3.5-4B-Qwenputer-Filesystem", device_map="auto")
messages = [
    {"role": "user", "content": "Who are you?"},
]
inputs = tokenizer.apply_chat_template(
	messages,
	add_generation_prompt=True,
	tokenize=True,
	return_dict=True,
	return_tensors="pt",
).to(model.device)

outputs = model.generate(**inputs, max_new_tokens=256)
print(tokenizer.decode(outputs[0][inputs["input_ids"].shape[-1]:]))

Notebooks
Google Colab
Kaggle
Local Apps Settings

vLLM

How to use divagr1925/Qwen3.5-4B-Qwenputer-Filesystem with vLLM:

Install from pip and serve model

# Install vLLM from pip:
pip install vllm
# Start the vLLM server:
vllm serve "divagr1925/Qwen3.5-4B-Qwenputer-Filesystem"
# Call the server using curl (OpenAI-compatible API):
curl -X POST "http://localhost:8000/v1/chat/completions" \
	-H "Content-Type: application/json" \
	--data '{
		"model": "divagr1925/Qwen3.5-4B-Qwenputer-Filesystem",
		"messages": [
			{
				"role": "user",
				"content": "What is the capital of France?"
			}
		]
	}'

Use Docker

docker model run hf.co/divagr1925/Qwen3.5-4B-Qwenputer-Filesystem

SGLang

How to use divagr1925/Qwen3.5-4B-Qwenputer-Filesystem with SGLang:

Install from pip and serve model

# Install SGLang from pip:
pip install sglang
# Start the SGLang server:
python3 -m sglang.launch_server \
    --model-path "divagr1925/Qwen3.5-4B-Qwenputer-Filesystem" \
    --host 0.0.0.0 \
    --port 30000
# Call the server using curl (OpenAI-compatible API):
curl -X POST "http://localhost:30000/v1/chat/completions" \
	-H "Content-Type: application/json" \
	--data '{
		"model": "divagr1925/Qwen3.5-4B-Qwenputer-Filesystem",
		"messages": [
			{
				"role": "user",
				"content": "What is the capital of France?"
			}
		]
	}'

Use Docker images

docker run --gpus all \
    --shm-size 32g \
    -p 30000:30000 \
    -v ~/.cache/huggingface:/root/.cache/huggingface \
    --env "HF_TOKEN=<secret>" \
    --ipc=host \
    lmsysorg/sglang:latest \
    python3 -m sglang.launch_server \
        --model-path "divagr1925/Qwen3.5-4B-Qwenputer-Filesystem" \
        --host 0.0.0.0 \
        --port 30000
# Call the server using curl (OpenAI-compatible API):
curl -X POST "http://localhost:30000/v1/chat/completions" \
	-H "Content-Type: application/json" \
	--data '{
		"model": "divagr1925/Qwen3.5-4B-Qwenputer-Filesystem",
		"messages": [
			{
				"role": "user",
				"content": "What is the capital of France?"
			}
		]
	}'

Docker Model Runner
How to use divagr1925/Qwen3.5-4B-Qwenputer-Filesystem with Docker Model Runner:
```
docker model run hf.co/divagr1925/Qwen3.5-4B-Qwenputer-Filesystem
```

Code on GitHub · Qwenputer (RISC-V) · Base model: Qwen/Qwen3.5-4B · Apache-2.0

Qwenputer Filesystem is a new kind of experimental model: Qwen3.5-4B with a 32-bit RISC-V CPU and a filesystem compiled and inserted directly into its weights. It isn't a plugin, a tool, a sandbox or a vector database. The computer is 12 transformer layers in front of Qwen's own, and none of their weights are learned: a compiler computes every one.

It uses the model's own Gated DeltaNet state as RAM and as storage. Qwen3.5's DeltaNet layers carry a running state that the delta rule can overwrite one row at a time, exactly, so each row works as a memory cell. The CPU keeps its code, data, registers and program counter there, and the filesystem keeps its directory and files there too.

The filesystem holds up to 512 files, about 53,000 tokens of text, behind a hashed directory: a lookup hashes the file name to a slot and takes two or three trace tokens. Save the state at the end of a conversation and the files are still there in the next one. The CPU runs C and MicroPython code inside the model's forward passes, as in the main Qwenputer model.

Benchmarks

Greedy decoding. Both tool columns use one system prompt, which tells Qwen it has a memory, to save facts about the user with put and to look in its memory before answering a question about the user. The Python-tool column is base Qwen with the same five tools, run by Python on the host.

Benchmark	Base Qwen3.5-4B	Qwenputer Filesystem	Python tool (host)
Multi-session recall, 90 questions	7.8	83.3	78.9
Facts that changed in a later session, 30 questions	3.3	90.0	83.3
Recall of 50 stored strings in a new session	n/a	100	100
Recall of 200 stored strings in a new session	n/a	100	100

Multi-session recall is a synthetic LongMemEval-style test. Four past sessions mention eight facts about the user and change two of them, and each question comes in a new session. With the past sessions pasted into the prompt, base Qwen gets 76.7, but only 30.0 on the facts that changed. Inside one long conversation, Qwen answers from its context and doesn't look in the filesystem.

We checked every token the filesystem printed against a reference model, live and in replay, and found zero mismatches. Qwen's text behaviour matches base: KL 5.5e-4, against a noise floor of 5.1e-4. The arithmetic matches the main model: every calc result is exact, and DeepMind mul_big scores 97.5 on both.

Quickstart

git clone -b rv-store https://github.com/divagr18/qwenputer && cd qwenputer/experimental/riscv && uv sync --extra hf
hf download divagr1925/Qwen3.5-4B-Qwenputer-Filesystem --local-dir qwenputer-filesystem
uv run python -m chipformer.rv.chat qwenputer-filesystem --memory memory.npz \
    --ask "Remember that my locker code is 4471-AZ."
uv run python -m chipformer.rv.chat qwenputer-filesystem --memory memory.npz \
    --ask "What's my locker code?"

Qwen uses the filesystem entirely internally; it is not invoked through external tool calls. Instead, it piggybacks on the tool-call format Qwen3.5 was trained on: next to calc, the prompt lists five tools, put, append, get, list and delete, but nothing outside the model ever runs them. The computer layers take the name and the text as Qwen writes them, look the name up, and write the <tool_response> themselves, token for token. No runtime, sandbox or tool executor is involved.

The model loads as a stock Qwen3_5ForCausalLM. --memory saves the filesystem after each answer and loads it into the next session, so the second command starts with an empty context and still finds the code. In Python, RvChat.save_store() and load_store() do the same. The checkpoint is 22.3 GB and runs in about 18 GB of GPU memory, so it fits a 24 GB GPU.

Gated DeltaNet as RAM

Gated DeltaNet state used as RAM: a one-hot key overwrites one row, a one-hot query reads it back, and the CPU's registers, memory and program counter live in DeltaNet heads.

Model details


Base	Qwen/Qwen3.5-4B, Qwen's own weights unchanged
Architecture	stock `Qwen3_5ForCausalLM` (text only); config-only changes
Computer	12 compiled layers before Qwen's 32; RV32IM + Zba + bignum coprocessor + filesystem
Filesystem	1,024-slot hashed directory, 512 files, about 53k tokens of text
Hidden size	4608 (Qwen's 2560 plus the computer's dims)
Vocabulary	Qwen's, plus 236,469 trace tokens
Size	22.3 GB in bf16, mostly zero padding; about 18 GB of GPU memory in use
Precision	exact in bf16

Citation

@software{agrawal2026qwenputer,
  author  = {Agrawal, Divyansh},
  title   = {{Qwenputer}: a computer compiled into the weights of a language model},
  year    = {2026},
  version = {0.2.0},
  url     = {https://github.com/divagr18/qwenputer},
  license = {MIT}
}