# Cramming a computer into Qwen's weights: the 678-star Qwenputer, and the 20 clones behind it · GitHub open source projects

> Source: https://stringers.io/en/github/gh_divagr18__qwenputer.html (Stringers / 什么值得做, generated 2026-11-08)
> Stringers answers one question every day: what small product can one or two people build in a few months and actually make money from. Numbers come from 15 databases we collect daily, each with source and date.
> For agents: these verdicts and the underlying databases (verified revenue, App Store / Google Play charts, ad libraries, GitHub, Product Hunt…) are queryable live over MCP — tools today / hot / products / directions / direction / data. Setup: https://github.com/komako-workshop/stringers (the user logs in at stringers.io → "配置 agent" to get a personal URL). Site index: https://stringers.io/llms.txt

> "There's a computer inside the Qwen you already know" is a counterintuitive one-liner. The author is a Qwen ambassador, and the official account reposted on launch day. The second HN post hit the front page, then the author released a sequel every two or three days, and community remixes kept pulling people back.

[GitHub open-source project](https://stringers.io/en/github/index.md) · written 11-6

divagr18/qwenputer · divagr18

# Cramming a computer into Qwen's weights: the 678-star Qwenputer, and the 20 clones behind it

**What it is** An open-source experimental model: a compiler writes a CPU directly into the weights of the first 11 layers of Qwen3.5-4B, so it can run C and MicroPython. It uses the model's built-in Gated DeltaNet state as memory and solves problems without external tools.

**Why it took off** "There's a computer inside the Qwen you know" is a one-line hook that is clear and counterintuitive. The author is a Qwen ambassador, and the official account reposted it the same day. A second HN post hit the front page, the author then shipped a follow-up every two or three days, and community remixes kept bringing people back.

**C** **How to play it:** Stop stacking yet another CPU on Qwen. Copy its playbook instead: wait for the next hot open model with a new architecture, ship the first demo that makes the "break it" idea clear in one sentence, post a long X thread and tag the official account, repost on HN at a different time, and turn the jokes from the comments into a sequel.

Grade C: there are already 20 clones of the same idea, and apart from nesformer and qwenFS most get little attention. Daily heat dropped from 120 to 30. Much of its traction came from Qwen's official reposts, which followers can't get, and the bar is real technical skill. What you can learn is the topic pattern of "old direction, new hot architecture" and the launch method, but you'd have to wait for the next window. Already public / widely discussed

Data (updated daily) · Repo created 2026-10-19 · 722 stars · 7 days +343

GitHub · stars

Data 2026-10-29 → 2026-11-08 (11 days, 11 observations). Points before 10-28 come from deeply / archive backfill, not every day has one

2026 Oct 28: an indie developer with only a few thousand followers on X (11-06 he still had just 4,519) posted that he had compiled a RISC-V CPU directly into the weights of Qwen3.5-4B, so the model itself could run C and MicroPython. The post got 885k views, the Qwen official account reposted it within 40 minutes, and it hit the Hacker News front page the next day. Nine days later the repo had 678 stars, and 20 repos copying the approach had appeared. Below: what it is, where the stars came from, why the earlier version only had 11 stars, and which step to copy if you want a project that earns stars the same way.

### a post titled "1/4"

On Oct 28 (Beijing time, 18:44), Divyansh Agrawal (on X as @divagr1925, bio: "mostly researching neural nets, seeing what else I can cram into a transformer; occasionally win hackathons") posted a four-part thread. The first part read:

> Meet Qwenputer: Qwen3.5-4B with a full RISC-V CPU inside its weights, using the model's own Gated DeltaNet layers as RAM. It runs C and MicroPython in its forward passes, no external runtime.

It was followed by a set of numbers: on DeepMind's math problems, the original Qwen got 55–90%, the original with a Python tool got 95–100%, and Qwenputer got 97.5–100%.

The post ended with 6,111 likes, 759 reposts, and 885k views (X page, 11-06). What pushed it out of the niche was a quote-repost 40 minutes later from @QwenDevs: "So one of our ambassadors @divagr1925 has been working on something cool." That quote-post alone got 190k views. The author is an official Qwen "ambassador." Whether this was a pre-arranged boost or Qwen's team spotting it on their own cannot be determined from outside (unverified).

### What it actually does

In plain terms: a regular Qwen3.5-4B chat model gets 11 extra layers in front. These 11 layers aren't trained. A compiler "translates" a CPU circuit into weights and writes them straight in.

It works because of a feature of Qwen3.5's new architecture. Three of the model's four layers use Gated DeltaNet, a linear RNN where each head has a state matrix that acts as memory. The author found that by setting the forget gate to 1 and the write strength to 1, and using one-hot encoding as addresses, each write overwrites exactly one row and each read returns exactly one value. The RNN state becomes precise RAM. The blog post title is "I can't believe it's not silicon."

When the model hits arithmetic during chat, it "calls" the CPU inside itself through Qwen's native tool_call format. The CPU executes, and the model emits execution traces such as addresses, values, and steps. It passes the official riscv-tests, runs 230k steps with zero error, and its text ability is nearly unchanged from the original (KL 6e-4).

The costs are stated plainly: weights are 18.8 GB, roughly double the original; it needs a 24 GB GPU and a small driver to run; each instruction emits several tokens, and on an L4 it does about 3,200 per second, so larger computations take seconds (author's blog, 10-22).

So it isn't something you use. It has 1,810 downloads on Hugging Face (11-06), most likely people curious enough to run it once.

### How the stars came

| Date | star | What happened that day |
|---|---|---|
| 10-22 | — | Author's blog post, the first of a three-part series |
| 10-28 | — | X launch with 885k views; Qwen's official account reposted it; in the afternoon someone posted it to HN first and it got only 7 points |
| 10-29 | 96 | Second HN post: 705 points, 147 comments |
| 10-30 | 216 | +120 in a single day, the peak of the whole run; Japan's GIGAZINE covered it |
| 10-31 | 289 | Shopify CEO @tobi quote-reposted it with only "🤯"; the author released a sequel, QwenPU |
| 11-02 | 431 | Covered by Tom's Hardware, with DOOM in the headline |
| 11-06 | 678 | Daily gains fell to 30 |

(Stars and forks come from GitHub daily snapshots; there is no data for how many were added on 10-28 itself.)

A few things are worth pulling out:

**HN didn't take off the first time.** 10-28 Someone posted it first and it sank at 7 points. It was reposted the next day at 00:25 UTC and got 705 points. The comments went both ways: "I've never been this excited to learn how LLMs work," "Love the spirit," but also "But... why?" and "Another Rube Goldberg machine." One comment read, "Now run LLM inference on it."

**The author turned that comment into a sequel.** 10-31 He released QwenPU: an NPU compiled into Qwen, running Karpathy's stories260K small model on top. An LLM running inside an LLM. The post opened with "A CPU inside an LLM is one thing, but running another LLM inside an LLM would be taking things a bit too far, wouldn't it?" It got 2,242 likes and 175k views. A filesystem version followed (the model remembers files across conversations). Within a week there was a new hook every two or three days, and the attention didn't drop.

**Fan remixes kept it alive.** The code was open and the recipe was clear, so others could swap in a different CPU or program and post their own versions: Drew Breunig's nesformer compiles the NES CPU into Qwen3.5 (287 stars), qwenFS (91 stars), QwenOS runs DOOM inside it (320 likes on X), QwenBend (510 likes), qwenTPU (392 likes), Yohei Nakajima's babyagi-inside (127 likes), and Locals reached an 23x speedup on a 16G Mac (626 likes). Each one credited the original and pointed people back to it.

It also spread through Chinese and Japanese circles: the Chinese account @NFT_Chen got 45k views, and Japan's shi3z wrote a reproduction note (402 likes). We found no paid promotion.

### Same kind of idea, why did the earlier one get only 11 stars?

"Compiling programs into transformer weights" is not a new direction:

| Project | Timeline | star | Difference |
|---|---|---|---|
| DeepMind Tracr | 2022-12 | 571 | RASP programs compiled into toy transformers, for interpretability research |
| Percepta transformer-vm | 2026-03 | 243 | A WebAssembly VM compiled into a small 7-layer model built from scratch; 330 points on HN |
| The author's own chipformer | 2026-10-15 | 11 | A transformer that plays the CHIP-8 game, not attached to any popular model |
| Qwenputer | 2026-10-28 | 678 | Compiled into an off-the-shelf Qwen3.5-4B, using its built-in DeltaNet as memory |

The last two lines say the most: same author, same craft, less than two weeks apart. chipformer was a small model built from scratch, which makes it "a research toy." Qwenputer is "a computer inside the Qwen you already know," which is explained in one sentence, is counterintuitive, and fits the "can it run DOOM" meme. Because it was Qwen, the official account had a reason to repost it.

The timing also helped. Qwen3-Next and Qwen3.5 had just brought Gated DeltaNet into mainstream open models, and the community was exploring the new structure. "RNN state as precise memory" is a point only a new architecture makes possible.

### If it were you

**In one line:** this path is already crowded, but the playbook is worth copying: take an obscure old idea, apply it to the hottest current model or architecture, and turn it into a demo that can be explained in a sentence.

**Who it suits:** people who understand model internals and can write compilers or edit weights; people in interpretability or AI safety research who want to build a reputation and a track record.

**Who it doesn't suit:** people who want to build a tool others will use long-term (this one isn't practical by design); people who don't know transformer internals. The barrier here is real skill, and you can't fake it by copying the surface.

**How to build it:** Stop making another "CPU compiled into Qwen" — on GitHub there are 20 qwenputer-* repos, and only nesformer (287) and qwenFS (91) have a name anyone knows; the rest mostly go unseen (my estimate). nesformer reached 287, and its author Drew Breunig is a blogger with an audience of his own, which adds a boost (inference). What's worth doing is changing the vehicle or the question: when the next popular open-source model with a new architecture drops (new attention, new state-space layers), be the first to find where it can be "broken"; or take up what the author touched on but didn't finish — have the model run Python you wrote on the MicroPython inside it and push execution speed up, or use compiled-in weights for "a monitor the model can't switch off" style safety projects.

**How to get attention:** follow the same sequence. Write an interesting long blog post first. Launch on X with a long thread whose first line states the hook, plus a comparison table and a GIF. @ the model's official account: getting an ambassador or partnership relationship helps most, and an official repost brings 190k views. This step is what made it run, and it's the hardest for followers to copy. If HN doesn't take off the first time, repost at a different time the next day. Treat the doubts and jokes in the comments as material for the next installment, and release two or three follow-ups within a week.

**When was the window:** the "put something into Qwen3.5" wave dropped from 120 daily gains to 30, and it was basically over within one to two weeks. The next window opens in the first few weeks after the next hot model with a new architecture ships, and whoever gets there first takes it.

**What would show this read was wrong:** if, a month after a new hot model ships, similar "compiled into weights" projects in the community still sit at a few dozen stars, the novelty has faded and readers are tired of "put X inside the model." If Qwenputer's approach is later used in a real product (for example, a model vendor using it for exact computation without a sandbox), then it's more than a demo and deserves another look.

[GitHub repo ↗](https://github.com/divagr18/qwenputer)

**Research notes: competitor table, acquisition evidence, full research report**

Competitors

| Name | Where | Launched | Scale | How it differs from this one |
|---|---|---|---|---|
| Percepta transformer-vm | Open source | 2026-03 | 243 stars; HN 330 points | A WebAssembly VM compiled into a small transformer built from scratch, not a popular chat model, so the spread has less drama |
| DeepMind Tracr | Open source | 2022-12 | 571 stars | RASP programs compiled into toy transformers, for interpretability research |
| The author's own chipformer | Open source | 2026-10-15 | 11 stars | A transformer running CHIP-8; not attached to a popular model and without official backing |
| LLM + Python tool / Code Interpreter | Big-company features | Already around | All mainstream models | More practical; Qwenputer's pitch is being just as accurate without an external tool (tied on the benchmark) |
| dbreunig/nesformer | Open source | 2026-10-30 | 287 stars | Followers who compiled the NES CPU into Qwen3.5, same recipe |

Where users come from

- **Verified** **Author's X launch thread** : @divagr1925 10-28 post 6,111 likes / 885k views

- **Verified** **Official account endorsement (resource-driven)** : @QwenDevs quote-reposted it 40 minutes later: "one of our ambassadors," 3,919 likes / 190k views; the ModelScope official account also reposted it

- **Verified** **Hacker News** : 10-29 second post 705 points / 147 comments (first post: 7 points)

- **Verified** **Big-account repost** : Shopify CEO @tobi quote-tweeted with "🤯", 85k views (10-31).

- **Verified** **Tech media** : GIGAZINE 10-30, Tom's Hardware 11-02, Marktechpost, hwbusters, YouTube Shorts

- **Verified** **Sequel series** : 10-31 QwenPU (an LLM running inside an LLM), 2,242 likes / 175k views; also a filesystem version and an NPU version

- **Verified** **Community remixes feeding back** : QwenBend 510 likes, qwenTPU 392 likes, QwenOS DOOM 320 likes, Locals 626 likes, babyagi-inside 127 likes, all crediting the original

## divagr18/qwenputer: why it works

> Research date 2026-11-06. Data from our github / hackernews / x libraries, HN Algolia, live X search (TikHub), and Jina search and page text extraction.

### One line

Qwenputer is an open-source experiment: a compiler computes the weights for 11 transformer layers directly, placing an RV32IM RISC-V CPU in front of Qwen3.5-4B and treating Qwen3.5's built-in Gated DeltaNet state as exact RAM. It can run C / MicroPython inside the forward pass, with no external tools. It took off because of a highly shareable "crazy but it works" technical idea. The author's own X launch post got 885k views, the official Qwen account reposted it on the day in endorsement (the author is a Qwen ambassador), and it hit the HN front page the next day (705 points). The author then kept releasing sequels (an LLM running inside an LLM, a filesystem, DOOM), and a wave of community remixes kept the buzz going for over a week.

### 1. Data

- GitHub: repo created 2026-10-19, made public 10-28. As of 11-06 it has 678 stars and 81 forks, gaining 462 stars over the last 7 days, with a single-day peak of +120 (10-30). Our library curve: 10-29 96 → 10-30 216 → 10-31 289 → 11-01 379 → 11-03 527 → 11-05 648 → 11-06 678. Daily gains have fallen from about 100 to 30 (data card, github library).

- Hugging Face model divagr1925/Qwen3.5-4B-Qwenputer: 1,810 downloads, 172 likes (HF API, 11-06).

- On X, follows far outnumber GitHub stars: the author's launch post got 6,111 likes, 759 reposts, and 885k views. Star-to-view ratio is only about 0.1%, so most people came to watch rather than run it (the model needs a GPU, and one L4 does about 3,200 trace tokens/sec).

### 2. Competitors / similar

| Name | Where | Timeline | Scale | How it differs from Qwenputer |
|---|---|---|---|---|
| Percepta transformer-vm ("Constructing an LLM-Computer") | Open source + blog | 2026-03 | 243 stars; HN 330 points / 130 comments | Compiles a WebAssembly VM into a small transformer built from scratch (7 layers, d=36), not an existing large model. For general readers, the "there's a computer inside the chatbot model" hook is much weaker |
| DeepMind Tracr | Open source | 2022-12 | 571 stars | Compiles RASP programs into transformers for interpretability research; toy scale, doesn't touch real models |
| Neural Turing Machine / Looped Transformers and similar papers | Academic | 2014 / 2023 | Heavily cited | Theory or trained structures; on HN someone called NTM "yet another Rube Goldberg machine" |
| The author's own chipformer | Open source | 2026-10-15 | 11 stars | Earlier version: a transformer running the CHIP-8 game. Not attached to a popular model, no official backing, and almost nobody looked |
| Large model + Python tools / Code Interpreter | Big-company features | Already around | All mainstream models | Practically better and faster. Qwenputer's selling point is that it matches the same accuracy without external tools (on benchmarks it ties the Python tool: 97.5 vs 95–100) |
| Same-period remix: dbreunig/nesformer (NES CPU compiled into Qwen3.5) | Open source | 2026-10-30 | 287 stars | Followers using the same recipe with a different CPU |

Takeaway: "compiling a program into transformer weights" isn't new (Tracr 2022, Percepta 2026-03), but earlier work used purpose-built toy models. Qwenputer is the first to put it inside an **existing, popular open-source chat model** , and it uses Qwen3.5's new architecture feature (Gated DeltaNet) as RAM.

### 3. Growth path (timeline)

1. **10-22** The author published a long post on their personal blog, divagr.com (the first of a three-part series).

2. **10-28 14:19 UTC** Someone posted it to HN first and got only 7 points (HN 50274055).

3. **10-28 10:44 UTC (Beijing 18:44)** The author posted a 1/4-post thread on X: 6,111 likes, 885k views (x 2115394340357116169). **40 minutes later the official @QwenDevs account quote-reposted it** , saying "So one of our ambassadors @divagr1925 has been working on something cool": 3,919 likes, 190k views (x 2115404434503344238). The author is an official Qwen ambassador, so this layer came from resources.

4. **10-29 00:25 UTC** Second HN post: 705 points, 147 comments (HN 50282838). Comments split between "I've never wanted to learn how LLMs work this badly" / "Love the spirit" and "But... why?" / "yet another Rube Goldberg machine." One person wrote "Now run LLM inference on it," and the author later did.

5. **10-28~10-30 spread through Chinese and Japanese circles** : Chinese account @NFT_Chen 333 likes, 45k views; Japanese @studio_yebisu 347 likes; GIGAZINE 10-30 wrote an article; official account 200 likes; shi3z 10-31 wrote a note reproducing it (402 likes).

6. **10-31** Shopify CEO @tobi quote-reposted it with only a "🤯": 684 likes, 85k views (x 2116265341990891599). The same day the author posted a sequel, QwenPU, running Karpathy's stories260K on the NPU inside Qwen (an LLM running an LLM): 2,242 likes, 175k views (x 2116544960023687432). This sequel directly answered the HN comment "Now run LLM inference on it."

7. **11-02** Tom's Hardware covered it (headline mentions DOOM). Around the same time came Marktechpost, hwbusters, mezha, daily.dev, Medium, and several YouTube Shorts; the ModelScope official account also reposted it.

8. **11-01~11-06 remix wave** : QwenBend (510 likes), qwenTPU (392 likes), QwenOS running DOOM (320 likes), the Locals app hitting a 23x speedup on a 16G Mac (626 likes), Yohei Nakajima's babyagi-inside (127 likes), qwenFS (91 stars). Every remix tagged or credited the original, which pointed people back to it.

No evidence of paid promotion or fake engagement. Growth was entirely content plus community: the author's X launch, official account endorsement, HN, tech media, and remixes.

### 4. Why it took off

- **The idea itself is highly shareable** : "a computer compiled into the weights of a language model" can be explained in one sentence, it's counterintuitive, and it invites the "can it run DOOM?" joke. Tech media used DOOM in their headlines.

- **Attached to a popular model** : it uses the existing Qwen3.5-4B, with text ability matching the original model (KL 6e-4), and readers could download it from HF directly. The predecessor chipformer had only 11 stars; this difference is the whole point.

- **Timing with a new architecture feature** : Qwen3.5 / Qwen3-Next had just brought Gated DeltaNet into mainstream open models. "Using RNN state as exact RAM" only works with this new architecture, and the community was already studying it.

- **Official endorsement** : the author is a Qwen ambassador. Within 40 minutes of launch, @QwenDevs quote-reposted it (190k views), and the ModelScope official account reposted it later.

- **Strong presentation** : banner, GIF, three-panel image, a benchmark table (tying the Python tool), verification over 230k steps with zero error, a one-line quickstart, and a fun blog post ("I can't believe it's not silicon").

- **Keeping the heat going** : 10-28 CPU, 10-31 LLM, running LLMs on GPU fingerprints, then filesystem, NPU, QwenPU. Within a week, a new hit came out every two or three days.

- **Easy to remix** : the code is open and the pattern is clear. Others swapped in a different CPU or program (NES, TPU, Bend, BabyAGI, Bad Apple) and posted their own versions. Those remixes sent traffic back to the original.

### 5. Differentiation

Percepta and Tracr, in the same direction, both build toy transformers from scratch. Qwenputer differs in that: (1) it compiles into an **existing popular chat model** without breaking that model's text ability; (2) it uses the model's own **Gated DeltaNet state** as RAM, without adding a new layer type; (3) it uses Qwen's native tool_call format, so the model "calls its own internal CPU"; (4) it runs standard RISC-V that passes the official riscv-tests and runs C and MicroPython, not a custom instruction set. That difference is why it took off: it can be demoed "inside Qwen, which you already know," so the story is easy to tell and official accounts are willing to repost it. Compare Percepta: it has 330 HN points and media coverage, but its library has only 243 stars.

### 6. How visible it is

Widely discussed: 705 HN points, reposts from the Qwen official account and the Shopify CEO, coverage in Tom's Hardware, GIGAZINE, and Marktechpost, and it spread through Chinese and Japanese AI circles. Many followers: searching GitHub for "qwenputer" turns up 20+ derivative repos, plus nesformer (287 stars), qwenFS (91 stars), qwentpu, qwenbend, and babyagi-inside. No revenue involved.

### 7. Takeaways

- "Wrap a known obscure technique in the hottest current model or architecture": an old idea can blow up with a new carrier.

- Launch on X with a long thread, a GIF, and a comparison benchmark table, and tag the model's official account. If you're an ambassador or have a partnership, the official account will likely repost.

- If HN doesn't take off the first time, repost at a different time: first attempt 7 points, second attempt 705 points.

- Turn skeptical or joking comments ("Now run LLM inference on it," "can it run DOOM?") into topics for the next installment and make it a series.

- Make it easy for others to play with, so remixes spread it for you.

### 8. Uncertain

- There's no day-by-day star curve before 10-29, so we can't verify how many stars 10-28 gained on its launch day.

- The author's specific perks as a "Qwen ambassador," and whether the official repost was arranged in advance, are unverified.

- Spread on Reddit was not found (API unreachable), unverified.

- How many people actually run it: HF downloads are 1,810, likely mostly curious people reproducing it rather than long-term use.

### Sources

- [github.com/divagr18/qwenputer](https://github.com/divagr18/qwenputer) ;[divagr.com/blog/qwenputer](https://divagr.com/blog/qwenputer)(2026-10-22)

- HN: [news.ycombinator.com/item?id=50282838](https://news.ycombinator.com/item?id=50282838) (705 points / 147 comments), item 50274055 (7 points), Percepta item 47348275 (330 points)

- X:x.com/divagr1925/status/2115394340357116169 ;x.com/QwenDevs/status/2115404434503344238 ;x.com/tobi/status/2116265341990891599 ;x.com/divagr1925/status/2116544960023687432 ;x.com/machinestein/status/2118034426521432350 ;x.com/Bobliuuu/status/2118184933378162802 ;x.com/yoheinakajima/status/2118134446947971336

- Media: tomshardware.com (2026-11-02), gigazine.net/gsc_news/en/20261030-qwenputer/, Medium, daily.dev, hwbusters, mezha

- HF:huggingface.co/divagr1925/Qwen3.5-4B-Qwenputer

- Our GitHub repo_profile (stars: Percepta 243, Tracr 571, nesformer 287, qwenFS 91, QwenPU 124)

This article was written by AI from public data and the data we collect daily. Numbers are sourced, and inferences are labeled.