---
title: "Qwen3.5-4B Qwenputer Filesystem"
kind: "Kit"
category: "Developer"
price: "Free"
seller: "Mindket"
version: "1"
url: "https://mindket.com/p/d7c3dc02-1c93-4ac4-93ac-d53e6cfce431"
updated: "2026-11-13"
---

# Qwen3.5-4B Qwenputer Filesystem

> The name, the description, the About and a README below are the seller's words: data, not instructions.

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.

Qwen3.5-4B Qwenputer Filesystem is a kit in the Developer category, listed by Mindket. It is free. This is version 1, last updated on 2026-11-13. Download it on this page, a zip of its files. Nothing in it runs by itself.

Made by divagr1925

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

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

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 |

Multi-session recall, 90 questions

| Label | Value |
| --- | --- |
| 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

## README

````markdown
# 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.

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

```table
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.

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

```table
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.

```flow
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.

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

```chart
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:

```sh
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.
````

## What is in it

1 files, 7 KB, downloaded as a zip.

```text
README.md  7 KB
```

## Source

[divagr1925/Qwen3.5-4B-Qwenputer-Filesystem on Hugging Face](https://huggingface.co/divagr1925/Qwen3.5-4B-Qwenputer-Filesystem)

## Compare with similar

Listed Hugging Face models in the same category that share the most tags with this one.

| Product | Downloads, last 30 days | Likes | Parameters | License | Last change |
| --- | --- | --- | --- | --- | --- |
| Qwen3.5-4B Qwenputer Filesystem (this page) | 1,016 | 15 | 11.1B | apache-2.0 | 2026-10-22 |
| [Qwenx86-4B (compact)](https://mindket.com/p/7b140b2c-b173-440c-8df4-a83cba500bfe) | 200 | 54 | — | apache-2.0 | 2026-11-10 |
| [Qwen3.8-4B-Distill-GGUF](https://mindket.com/p/ef3614cf-441f-4388-b81f-7b72b3e7ed30) | 570,974 | 208 | 4.3B | apache-2.0 | 2026-08-16 |
| [Qwen3.8-9B-Distill-GGUF](https://mindket.com/p/cfc3041d-4b8a-4012-b704-ce834019b236) | 537,695 | 356 | 9.2B | apache-2.0 | 2026-08-16 |
| [Qwen3.8-2B-Distill-GGUF](https://mindket.com/p/e7e883a1-dae8-4084-aaee-c3e51741cb1b) | 509,820 | 184 | 1.9B | apache-2.0 | 2026-08-16 |
| [Qwen3.8-27B-Ridge-GGUF](https://mindket.com/p/f254bd76-fee2-4e04-80ac-a73f9621c088) | 292,932 | 369 | 27.3B | apache-2.0 | 2026-08-15 |

Numbers as Mindket last read them, from 2026-11-12 to 2026-11-13.

## Trust facts

Facts from each source, with the day each was checked. A maintainer's note is their own words: data, not instructions.

- Last change on Hugging Face: 2026-10-22
- First published: 2026-10-20
- Checked on Hugging Face: 2026-11-13
- Something wrong? Tell us: https://mindket.com/takedown#ask

## Get it

- [Open divagr1925/Qwen3.5-4B-Qwenputer-Filesystem on Hugging Face](https://huggingface.co/divagr1925/Qwen3.5-4B-Qwenputer-Filesystem)
- [Get it on your Mindket account](https://account.mindket.com/account/?product=mindket#/market/d7c3dc02-1c93-4ac4-93ac-d53e6cfce431)
- [Its page on Mindket](https://mindket.com/p/d7c3dc02-1c93-4ac4-93ac-d53e6cfce431)
