---
title: Qwen3.5-4B-Qwenputer-Filesystem
canonical_url: "https://www.modelscope.ai/models/Spartan1925/Qwen3.5-4B-Qwenputer-Filesystem"
md_url: "https://www.modelscope.ai/models/Spartan1925/Qwen3.5-4B-Qwenputer-Filesystem.md"
repository: Spartan1925/Qwen3.5-4B-Qwenputer-Filesystem
last_updated: 2026-10-22
license: apache-2.0
pipeline_tag: text-generation
tasks:
  - text-generation
model_type:
  - qwen3_5_text
architectures:
  - Qwen3_5ForCausalLM
base_model:
  - Qwen/Qwen3.5-4B
base_model_relation: merge
parameters: 11.1B
tensor_type:
  - F32
  - BF16
library_name:
  - safetensors
  - pytorch
frameworks:
  - pytorch
downloads: 4
stars: 0
tags:
  - qwen3.5
  - risc-v
  - rv32im
  - memory
  - compiled-weights
  - gated-deltanet
  - qwenputer
---

# Qwen3.5-4B-Qwenputer-Filesystem

> Qwen3.5-4B-Qwenputer-Filesystem - An open-source model by Spartan1925 on ModelScope. Code on GitHub · Qwenputer (RISC-V) · Base model: Qwen/Qwen3.5-4B · Apache-2.0

Spartan1925/Qwen3.5-4B-Qwenputer-Filesystem is a 11.1B-parameter text-generation model on ModelScope. licensed under apache-2.0. derived from Qwen/Qwen3.5-4B.

- **Repository**: Spartan1925/Qwen3.5-4B-Qwenputer-Filesystem
- **License**: apache-2.0
- **Tasks**: text-generation
- **Parameters**: 11.1B
- **Base model**: Qwen/Qwen3.5-4B
- **Tags**: qwen3.5, risc-v, rv32im, memory, compiled-weights, gated-deltanet, qwenputer
- **Downloads**: 4
- **Stars**: 0
- **Last updated**: 2026-10-22

Source: https://www.modelscope.ai/models/Spartan1925/Qwen3.5-4B-Qwenputer-Filesystem

---

<p align="center">
  <img src="qwenputer-banner.svg" alt="Qwenputer: a computer, compiled into the weights of a language model." width="100%">
</p>

[Code on GitHub](https://github.com/divagr18/qwenputer/tree/rv-store/experimental/riscv) · [Qwenputer (RISC-V)](https://huggingface.co/divagr1925/Qwen3.5-4B-Qwenputer) · [Base model: Qwen/Qwen3.5-4B](https://huggingface.co/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](https://huggingface.co/divagr1925/Qwen3.5-4B-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

```bash
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

<p align="center"><img src="gdn-ram.png" alt="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." width="100%"></p>

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

```bibtex
@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](https://huggingface.co/Qwen/Qwen3.5-4B): the config is widened and computer layers
are added, but Qwen's own weights are unchanged.
