Qwen3.5-4B Qwenputer Filesystem

Qwen3.5-4B Qwenputer Filesystem

An experimental Qwen3.5-4B with a RISC-V CPU and a small filesystem compiled into its weights, so it remembers facts across sessions without outside tools. The checkpoint fits a 24 GB GPU.

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 Filesystem is an experimental model made by divagr1925. It starts from Qwen3.5-4B and adds a small 32-bit RISC-V processor plus a file store, both built into the network by a compiler. The computer is 12 extra transformer layers placed in front of Qwen's own, and a compiler computes every weight in them. Qwen's own weights are unchanged. The model's Gated DeltaNet state serves as RAM and storage, and the filesystem lives there too.

Who it suits: It suits researchers and developers who study memory inside a model, and who want to test saving and recalling facts across sessions without an outside database or tool runner.

Industry | Who uses it | How they use it | Example
AI research | Model architecture researchers | Study a compiled computer inside a transformer | The card checks every printed token against a reference model
Assistant development | Developers of personal assistants | Test memory that survives between sessions | The model recalls a locker code in a new session
Education | Students of computer architecture | See a CPU and RAM built from model layers | The CPU keeps its registers and program counter in DeltaNet state

You can skip it if you need a stable production assistant, since the card calls this a new kind of experimental model, and its checkpoint is large.

Where to use it:

• A Linux or Windows machine with a GPU of about 24 GB
• Python, with the uv tool to set up the project
• The project's chat command line, which saves memory to a file
• Hugging Face Transformers, with the standard Qwen3_5ForCausalLM class

Use case | Who | What they get back
Remember user facts | Assistant developers | Recall across separate sessions, as the card's tests show
Update changed facts | Researchers | Answers that follow a fact changed in a later session
A small file store | Experimenters | Room for 512 files, roughly 53,000 tokens in all

How to set it up: You need Python, uv, git and a GPU with about 18 GB free.

• Python and the uv tool
• git, to fetch the project code from its repository
• Hugging Face tools, to download the weights
• A GPU with about 18 GB of memory, because the 22.3 GB checkpoint fits a 24 GB card

1. Fetch the project's code from its repository and set up its environment with uv. The repository address is on the card.
2. Download the model files with the first command below.
3. Ask a first question with the chat command, passing a memory file.
4. Ask a second question in a new run with the same memory file.

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?"

How to use it: Ask the model to remember something, then start a new run with the same memory file and ask for it back. The second run has no chat history, yet the model retrieves the code from the saved file. In Python, save_store and load_store on RvChat do the same job.

Tool | What it does
put, append, get, list, delete | Five filesystem tools in the prompt, handled inside the model
calc | Arithmetic tool, exact in the card's checks
--memory | Writes the file store out after every reply, and reads it back in a later run
RvChat.save_store | Saves the filesystem from Python

Example: In the first run you say your locker code is 4471-AZ. In a second run with the same memory file, you ask what your locker code is. The card shows the model finding the code, though the second run starts with an empty context.

For newcomers and experts: Think of it as a model with a tiny built-in notebook that is kept in its own working memory. A first small try is the two-command locker code demo.

The card says no tool is invoked from outside. The prompt lists five tools in the format Qwen3.5 was trained on, but nothing outside the model runs them. The computer layers pick up the file name and the content straight from Qwen's output. They find the file, then produce the reply text on their own, one token at a time.

Qwen writes a put or get call
The computer layers read the name and text
The filesystem is looked up in DeltaNet state
The layers write the tool response
Qwen answers, and the state can be saved

Good to know: The card compares three setups on a memory test with scores out of 100.

Title: The card's benchmarks
Benchmark | Base Qwen3.5-4B | Qwenputer Filesystem | Python tool
Multi-session recall, 90 questions | 7.8 | 83.3 | 78.9
Changed facts, 30 questions | 3.3 | 90.0 | 83.3
Stored-string recall, 50 strings | n/a | 100 | 100
Stored-string recall, 200 strings | n/a | 100 | 100

Title: Multi-session recall, 90 questions
Base Qwen3.5-4B: 7.8%
Qwenputer Filesystem: 83.3%
Python tool on the host: 78.9%

• Checks: the card reports zero mismatches against a reference model, and an exact calc
• Text behavior: close to the base model, with a KL value of 5.5e-4 where the measurement noise is 5.1e-4
• Test type: the recall test is a made-up one in the style of LongMemEval, built by the maker
• Other versions: other people have published 1 quantized version
• License: Apache 2.0
• Cost to run: none named, but it needs a GPU with about 18 GB
• Data it reaches: the files you download, plus your chat text and the memory file you save
• Not for: production assistants, or tasks inside one long conversation, since the model then answers from its context

On Hugging Face, 13 November 2026

• Task: text generation
• Library: transformers
• Parameters: 11.1B
• Weights: about 22.2 GB in BF16; about 5.5 GB at 4-bit (estimate)
• Formats: Safetensors
• Downloads in the last 30 days: 1,016
• Likes: 15
• License: apache-2.0
• Based on: Qwen/Qwen3.5-4B
• Quantized versions: 1
• Tags: transformers, safetensors, qwen3_5_text, text-generation, qwen3.5, risc-v, rv32im, memory, compiled-weights, gated-deltanet, qwenputer, conversational

Links

• Model: https://huggingface.co/divagr1925/Qwen3.5-4B-Qwenputer-Filesystem
• Files: https://huggingface.co/divagr1925/Qwen3.5-4B-Qwenputer-Filesystem/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-Filesystem

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