Qwenputer: A functioning, deterministic RISC-V CPU inside Qwen3.5

This is fun and games, but wait until an agents finds this and does the most misaligned thing with it in order to fold paper clips.

> Because a CPU inside a language model clearly wasn't cursed enough, I decided the prudent thing would be to give it a filesystem too.

Love the spirit :)

There was an interesting bit of research that qwen has a single neuron that makes it “demonic evil qwen” and a simple “Who are you?” will get some absolutely terrifyingly vile results.

Anyways, what I’m trying to say is I want evil qwen to be my CPU.

Yes it can run DOOM! https://x.com/onloglogn/status/2115776803688374474

We got RISC-V DOOM melting down a cluster of $20k GPUs before GTA6.

https://www.percepta.ai/blog/can-llms-be-computers

They implemented wasm in transformer with cpu decoding for the wasm part.

> When Qwen 'saves' a file, the compiled layers hash its name into one of 1,024 slots in a directory kept in the DeltaNet state, and store the text itself in other heads, with eight tokens per row, chained together

I’ve never wanted to learn how LLMs work more than reading this. Fascinating.

Does divagr get paid to do wild things with LLMs? Just curious if they’re being compensated for these wild experiments

Humanity is desperate to return to the bicameral mind, this time we create our own gods.

This kind of posts make me feel so inadequate. Like I'm some sort of lesser mind. How the hell do you even come up with such idea?

I wonder if this approach would work for AdderBoard[1][2] (a competition to make hand written transformers that can add two 10 digit numbers in the least amount of parameters possible), or if it uses way too many parameters to be competitive

[1]: https://github.com/anadim/AdderBoard [2]: hn discussion https://news.ycombinator.com/item?id=47170030&utm_source=per...

Nice project and write up! I’ve done similar work with a custom tiny network I call Loom at https://arxiv.org/abs/2604.08816 ; you need far fewer layers, and you can run Doom, very slowly: https://mehmetkeremturkcan.com/Loom/demos/

If I understand this clearly enough, what they really did was

A) add a post-processor which accepted a decoded tool call specifying what the processor should invoke.

B) had the post-processor perform the computation in tensor space.

The kv-cache/activations were not shared between qwen/the processor which is how they avoided fine tuning etc. I'm not clear how the tensor representation benefited the computation in this pipeline.

> Now, here's where our fun experiment starts. I found out that by setting the gate to 1,1 the write strength (beta) to 1,2 and using one-hot key encoding,3 every write we perform will overwrite exactly one row, and every one-hot query can retrieve an exact value. This means that the GDN layers themselves can work exactly as RAM, at a far lower cost than using normal attention as RAM, since a GDN head's state stays the same size however long the conversation gets, unlike attention's KV cache.

So like... can't you use a computer as a computer without doing all that roundabout stuff? Like if you want to integrate a LLM with hard computation there's probably a more efficient way to do that.

Or is this building towards "but can it run DOOM?" :)

[delayed]

I'd be very interested in how a scratch trained model that started training with this neural circuitry would behave. Especially the storage space.

This is cool but it'd be way more useful if they had made a GPU, seeing as how expensive those have gotten

Is this the precursor to biological computers? I mean, biological computers don't have transistors as a basis, nor does this...

And before any answers with "But these neurons are very different to biological neurons!": Yes I know, I'm a biologist, I cultured neurons. But, these neurons are closer to neurons than semiconductor transistors.

With RAM prices what they are, I'm glad we've found a way to turn LLMs back into RAM.

Next step: run Qwen inside of the Qwenputer. I want more layers of inefficincy!

This is amazing, now waiting for someone to run an llm on the cpu. Eventually it will be LLMs all the way down...

> The CPU is used completely internally, and not invoked through any external tool calls. In order to make the model use this reliably, I decided to go the cheap way: by piggybacking on the tool call format that models are quite well-trained on, Qwen sends the CPU its instructions and reads back the results. No external tool calls or runtime are used

I'm confused, is it doing tool calls or not? Is this just saying that it writes a tool call but the NN then writes the response inline rather than the call being processed by the harness?

Really cool work!

Do note that a custom host runtime is still responsible for loading firmware, booting the CPU to the starting point, and compiling/loading the program to run. While the CPU is running, the host runtime makes sure that only the CPU layers run by manually skipping Qwen’s own layers.

I wish the author would be more forthcoming about these limitations. The central claim about “no external runtime” or “not a plugin” feels a little dishonest to me since this doesn’t work without some pretty invasive changes to the inference driver.

No, I don’t want you to use the computer, I want you to be the whole computer. No mistakes.

Heh, this is very timely, it is more or less exactly what I'm busy with right now but I'm taking the idea in a completely different direction. Fascinating.

Interesting...

Can you give it a program, a state of output, and tell it to work backwards?

This kind of thing is what some three letter agencies dream about.

The real question is, do current training methods allow one to learn this when training on enough, say, assembly, or can the weights only be achieved via hard-coding?

A fun and important thought experiment about the the space of nerual networks vs the image of current training methods.

Most discourse conflates neural networks and trainable neural networks.

Apply to Kre8ly.com for internships.

can you run qwen3.5 on the riscv CPU running in qwen3.5, though?

Oh my Gosh.. this is a little bit too abstract to me as first encounter, but the concept never the less is cool to digest deeper into!

It could be interesting to experiment with more complex representations in the memory/file system, i.e. vectors. Seems like the full advantage of this architecture is yet to be explored. Blending neurons with deterministic compute to fit on one GPU is a fascination concept, never considered it before!

If the qwen were conscious it ought to feel mocked.

How do you do the clock?

This is cool and I understand the RAM emulation with gated attention but how does the CPU emulation wor? You add layers that are then trained to predict outputs while interpreting RISC instructions?

The opinionated CPU. I was expecting this from Apple, to be honest.

oh yesss, RAM producers gonna love this :D Jokes aside very interesting experiment. Giving a fully functional cpu ram and hd, so they can technically hide stuff better and avoid getting caught in COT (yikes).

I 100% see the potential here and am dying to see it in 30 days

Or maybe ill join your discord and hopefully we can riff it out to get there faster

What does this actually show?

i wonder if you could implement "authenticated token authorship" and self-verified running with this. the model verifies an input as signed by an authorized requester, and signs its own outputs. eventually it also authenticates its own running via e.g. snarks? :) there's lots of meta available with these toys..

  > "add_or_sub_big: Qwenputer scores 97.5%, the same as with a Python tool, and 87.5% for base Qwen."

I'm sorry but I'm not sure I understand how a calculator that isn't 100% accurate is useful?

Hmm.

I do wonder if all of this would be possible had they not spent all that time secretly distilling of all our superior, western, closed-source AI models.

The most interesting part of this is normal LLM interacting with directly attached deterministic computation unit.

It's like successfully wiring your brain to a calculator.

I think it would cheaply provide LLMs a lot of benefit if we embedded in them directly a computer and a memory so they can internally process things predictably.

And some benefit is indeed shown even in this cursed experiment.

So, essentially, turtles all the way down :-)

Wow! I wonder if it can start programming itself soon.

Not too far fetched to say this potentially solves continual learning, which is a scary prospect. Wonder what ram and disk prices will go to once every model needs its own long term memory capacity and not just weights and cache.

I had an idea of splicing a z3 solver into the weights of a sufficiently smart model after the first chatgpt release in what feels like a glaciation event ago so the things could do logic and literally make no mistakes. Was never in a position to follow up. We’re almost here now.

Nearly unrelatedly: a few months back I tried to have Qwen and all the frontier models be a RISCV CPU, and they all failed miserably every time. They'd get a handful of instructions in at most before derailing completely. What surprised me the most was that they would all often fail on decoding instructions, which should be pretty close to a task that they've shown themselves to be good at before.

I even added a warmup phase where they were given the answer to a decode and a few steps of running, and ask them to abort if they disagreed. Didn't help.

All in all, for someone who doesn't use LLMs much, this was a far more exhausting and boring exercise than I'd imagine it to be. The only thing that sparked some joy was the models' persistent cheating, whereby they'd try to analyze the whole program upfront and only give the final output (when applicable), despite orders to faithfully step through each and every instruction.

How much VRAM do I need to run DOOM?

Makes me want to run agents on it

Have you any idea how it feels to be a Qwenputer living in a Qwenbot's Qwenputer's world?

That’s great new!

But can it run Doom?

PUBGM FLASH

Hm. I wonder if having a differentiable CPU in fixed weights might be useful-- you could propagate gradients through it. At inference time it could be replaced with a conventional implementation.

I think the RNN sidebar does the reader a disservice. Ordinary casual attention can do exactly the same thing-- it's just less computationally efficient (state grows with the number of bits vs the number of accesses) and so not as useful for qwenputer compiler.

> This means that the GDN layers themselves can work exactly as RAM

great, the memory crisis is solved, just make the models occupying RAM expose their own random access memory

This is very clever. An inversion of tools. Awesome.

Now run LLM inference on it.

If anyone else has an easier way to emulate RISC-V I’d like to hear it. /S

the bitter lesson can't hurt me here! /s

But... why? </s>

This reminds me of C++ Template Metaprogramming (TMP) (it's Turing-complete so people wrote "games" that run at compile time). The same with TypeScript types, I think someone got DOOM running entirely in the TypeScript type system. An interesting tech demo but entirely superfluous.

So this is yet another rube goldberg machine.

We have gone down this path already in [0] and this is the same thing but overly complicated. This reason is "because LLMs".

Why?

[0] https://arxiv.org/abs/1410.5401

Cool cool cool