Qwenx86-4B (compact)

Qwenx86-4B (compact)

Runs a calculator, Python and a C compiler inside its own weights, using 13 extra layers placed ahead of Qwen3.5-4B. For researchers and tinkerers who study models that execute code.

Made by Quazim0t0 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: Qwenx86-4B (compact) adds a working 64-bit x86 computer to Qwen3.5-4B, built into the model weights by a compiler. Thirteen extra transformer layers sit ahead of Qwen's own, and a compiler computes every one of their weights, so nothing in them was learned. Qwen asks for a tool through its normal tool calls, and the computer inside the weights runs it.

Who it suits: It suits researchers and tinkerers who want to study how a language model can run real programs inside its own weights.

Industry | Who uses it | How they use it | Example
AI research | Model researchers | Study a computer built into a transformer | Read how the circuit became layers and compare it with Qwenputer
Systems and hardware | CPU and emulator hobbyists | Look at an x86 core running as network weights | Follow registers and flags in the debugger demo
Education | Teachers | Show how tools, memory and a CPU fit together | A class watches recorded tool calls step by step
Developer tools | Agent builders | Try a model that runs small programs without an outside sandbox | Ask it to compile and run a short C program

If you want a general chat model for everyday work, you can skip it.

Where to use it:

• The Qwenx86 Debugger Space on Hugging Face, which replays recorded tool calls
• A local machine with a GPU that has enough memory, as the compact checkpoint needs about 9 GB
• Windows, macOS or Linux with Python, for downloading the files
• A separate GGUF version, which the card links for other runtimes

Use case | Who | What they get back
Watching a recorded run | Learners | The conversation, registers, flags, code, RAM and machine output on a timeline
Running small programs | Researchers | C or Python code compiled and executed inside the weights
Keeping notes in chat | Tinkerers | A model that saves, reads, searches, lists and deletes notes on its own (v3)

How to set it up: You need these first:

• Python and pip
• A GPU that fits the compact checkpoint, about 9 GB of memory, so a 16 GB card works
• Disk space for a 4B-parameter model

1. Install the Hugging Face hub tool.
2. Download the model files.
3. Run the model with the project's compact loader, as the model card describes.

pip install -U huggingface_hub
hf download Quazim0t0/Qwenx86-4B-compact

How to use it: You chat with it like any Qwen model. When it needs a calculation, code or a lookup, it writes a tool call, and the x86 computer in the weights executes it. The card lists the built-in tools below.

Tool | What it does
calc | Calculator
python | Runs Python through a patched MicroPython from Qwenputer
c | Compiles C code with the qcc compiler
notes | A store for notes
science | Looks up physics and chemistry facts
python_doc | Looks up the Python documentation

Example: You ask it to write a small C function and run it. It writes the code and calls the c tool. The weights themselves build and run the program, and its output returns to the chat.

For newcomers and experts: Think of an ordinary chat model that also carries a tiny computer inside. A first small thing to try is the Debugger Space, where you can step through a recorded session without installing anything.

Under the hood, the circuit is a fork of the RV32 core from Qwenputer, with added x86 flag micro-ops, conditional jumps and a translator from x86-64 code to the core's 32-bit ops. The compiler turns the circuit into Qwen3.5 layers. The loader can verify blocks of up to 256 machine tokens per pass. The authors report 2,000 of 2,000 lockstep cases matching Unicorn.

Qwen writes a tool call
The bridge passes it to the x86 layers
The computer in the weights runs the tool
The result returns to the chat

Good to know: Version 2 adds memory features, and version 3 lets Qwen use them by itself. The new numbers below compare it with Qwenputer, the project it forks.

Title: Chip layers added ahead of the model
Qwenputer: 11
Qwenx86: 13

• Memory: a filesystem, a store of 1,000 facts, 50,000 tokens of word-for-word recall, JPEG images, a search index and exact 64-bit arithmetic
• Host code: the v2 memory features sit next to the model and need code on the host to drive them, whereas the x86 tools live wholly inside the weights
• RAM: the core has 64 KB, up from 32 KB in Qwenputer
• License: Apache 2.0, and the shared base code is reused under MIT
• Cost to run: none named, but you need a GPU with about 9 GB of memory
• Data it reaches: the notes, files and facts its memory features store

On Hugging Face, 13 November 2026

• Downloads in the last 30 days: 200
• Likes: 54
• License: apache-2.0
• Based on: Qwen/Qwen3.5-4B
• Quantized versions: 1
• Tags: qwen3_5_text, qwen3.5, computer-in-weights, x86, compiled-weights, tool-use

Links

• Model: https://huggingface.co/Quazim0t0/Qwenx86-4B-compact
• Files: https://huggingface.co/Quazim0t0/Qwenx86-4B-compact/tree/main

Get the model

Download its files with Hugging Face's command line:

pip install -U huggingface_hub
hf download Quazim0t0/Qwenx86-4B-compact

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