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.

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

Model details

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}
}

License

Apache-2.0. This is a modified version of Qwen/Qwen3.5-4B: the config is widened and computer layers are added, but Qwen's own weights are unchanged.