svmLLM: A Tiny Solana VM Built Out of Neural Network Weights
1,130,672 numbers, none of them trained. What it is, what it can do, and what it can't.
This article started as a 25-post thread on X. Read the original thread on X.
I built a tiny Solana virtual machine out of neural network weights.
It's called svmLLM. It has 1,130,672 numbers, and none of them were trained. A program wrote each one on purpose. It's a computer compiled into matrix form, not a trained AI.
This post walks through what it is, what it can do, and what it can't. Each section has a "simple version" first, then the technical detail.
Two terms first: LLMs and assembly
Simple version: an LLM is autocomplete on a huge scale. It's a program that predicts the next word using billions of learned numbers.
Assembly is the tiny set of instructions a CPU actually runs: add, load, store, jump. Every app ends up as a long list of them.
Post 2 of the original thread on X
A CPU versus an LLM
Simple version: a CPU is a kitchen following a numbered recipe card, one line at a time. An LLM is a well read writer that continues text.
Both are just math on numbers. Set the weights so the "next step" always equals what the CPU would do, and the model acts as that CPU, exactly.
Post 3 of the original thread on X
What "not trained" means
Training is like teaching a kid to cook: thousands of dishes, each graded better or worse, until the kid ends up with a recipe nobody can read.
We did the opposite. Our program wrote all 1,130,672 numbers on purpose. There's no data and no learning. That also means it can't reason. It just runs what's built in.
Post 4 of the original thread on X
What "a program wrote each number" means
Simple version: picture a spreadsheet with 1,130,672 cells. Training fills those cells from data, and nobody knows why each one holds its value.
svmLLM's code loops over every opcode and every input and writes the right answer into each cell, like a times table.
Post 5 of the original thread on X
What one of those numbers actually does
Each number is a weight: how strongly one signal feeds another. Most of them are 0 or 1.
Here's a real example from the add table. One unit gets weight 1 from three inputs (the digit 9, the digit 8, and carry 0), plus a bias of -2, so it fires only when all three are on. Its output weights point at "1, carry 1". In other words, 9 + 8 = 17.
Post 6 of the original thread on X
Where the idea comes from: Qwenputer
The idea comes from Qwenputer by @divagr1925: a stock Qwen3.5-4B with a RISC-V CPU compiled into its weights (an 18.8 GB checkpoint).
There's no training. A compiler sets every weight directly, and the CPU runs inside the model's own forward passes. You can read the full write-up at divagr.com/blog/qwenputer.
Post 7 of the original thread on X
What's a Gated DeltaNet?
A Gated DeltaNet is a layer that keeps a running memory grid and updates it at every token.
Normal attention rereads the whole book each time. DeltaNet keeps a notebook instead, so its memory stays the same size no matter how long the text gets. Qwen3.5 uses it in 3 of every 4 attention layers.
Post 8 of the original thread on X
Turning that memory into exact RAM
Simple version: think of a pantry with numbered shelves. A one-hot key points at exactly one shelf. A gate of 1 means nothing spoils. A beta of 1 means a new item fully replaces the old one.
Technically: Qwenputer sets gate 1 and beta 1 and uses one-hot keys, so each write hits exactly one row. The result is exact RAM.
Post 9 of the original thread on X
From Qwenputer to svmLLM
svmLLM borrows that same idea (gate 1, beta 1, one-hot keys) and applies it to Solana's bytecode, sBPF.
Today svmLLM is a standalone machine. It is not inside a pretrained LLM yet. There are two planned routes: run an sBPF interpreter as firmware on Qwenputer's CPU, or compile svmLLM in as native layers.
Post 10 of the original thread on X
What's a "PyTorch machine"?
Simple version: PyTorch is LEGO for neural networks. Usually training snaps the bricks into place. We placed every brick by hand.
Technically: PyTorch is a Python library that stores numbers in tensors. Our program writes the weights so the layers act like a VM.
Post 11 of the original thread on X
Inside one svmLLM step
An LLM is built from the same kind of bricks, so svmLLM could be snapped onto one later. That isn't done yet.
Inside svmLLM:
- One-hot attention lookup fetches each instruction.
- Lookup-table feed-forward layers do exact math.
- Gated DeltaNet state holds the registers and memory.
Post 12 of the original thread on X
Why Solana?
Simple version: a Solana program is a recipe card with one tiny step per line: add, subtract, fetch, store, jump to step 5.
Solana programs compile to sBPF, an assembly-like instruction set, and run as a stream of those steps. Anza's solana-sbpf is the reference VM that validators use.
Post 13 of the original thread on X
Where the 1,130,672 numbers come from
Simple version: a times table. You don't work out 7 x 8, you look it up. svmLLM's math works the same way.
Code in the repo writes the tables. The 4-bit add-with-carry table has 512 rows (16 x 16 x 2), and the 4-bit multiply table has 4,096. Together with decode, fetch and control, that's 1,130,672 numbers in all. Nothing is learned.
Post 14 of the original thread on X
How do we know it's right?
Simple version: build a new calculator, then punch the same problems into a trusted one and compare every answer. One mismatch and it fails.
Our trusted calculator is Anza's solana-sbpf, the reference sBPF VM. We ran two checks.
Post 15 of the original thread on X
Check one: our own 134-case suite
svmLLM matches solana-sbpf 0.12.2 on our own 134-case test suite, comparing the status, the instruction count, r0 and the input memory.
The cases break down as 64 math ops (64-bit only), 45 jumps, 13 memory, 6 error, 5 loop and 1 lddw.
To be clear, this is our own suite, not Firedancer's official fixtures.
Post 16 of the original thread on X
Check two: 1,000 random programs
We also ran 1,000 random programs (seed 1337). All 1,000 matched solana-sbpf, and the weights matched our Python reference on every run.
This was rerun on Nov 1 at commit 127d2b14. You can reproduce it with the repo's run_tests.py and N_RANDOM=1000.
Post 17 of the original thread on X
Why a small network can do this
Simple version: it's a pocket calculator, not a laptop. The scope is deliberately small:
- 64-bit math only
- No syscalls, accounts or cross-program calls
- Two 128-byte memory windows and 256 instruction slots
- A flat 1 compute unit per instruction
- A few milliseconds per simple instruction
Post 18 of the original thread on X
How fast is it?
Simple version: a normal VM just does the sum. svmLLM looks up each digit in printed tables.
On the same 303-step loop, on our box:
solana-sbpf0.12.2: about 5 ns per instruction- svmLLM in PyTorch: about 2.8 ms per instruction
The reason is that each instruction becomes many tensor operations and lookups instead of one native operation.
Post 19 of the original thread on X
Is it secure?
Simple version: it's a lab bench, not a bank vault.
svmLLM is a research prototype with no security audit. It runs reduced sBPF v0 only, with no syscalls, accounts or cross-program calls, so it can't run real Solana programs. Do not use it in production.
Post 20 of the original thread on X
What would happen in production today?
A bigger mess:
- It's slow, at a few milliseconds per instruction.
- The memory windows are tiny.
- Any gap from the real VM would be a consensus-breaking bug.
- Nothing is audited.
- It has a bigger, harder to review attack surface than a normal interpreter.
Its value is as an independent cross-checker, not a replacement.
Post 21 of the original thread on X
What it is, and what it is not
What it is not: it doesn't run real Solana programs yet, it isn't the SVM, and it isn't inside a pretrained LLM yet.
What it shows: an exact, inspectable Solana-style VM can live inside neural network weights, with a public number to build on.
Post 22 of the original thread on X
Where could this go?
This is R&D. If more were built, it could become:
- An independent cross-check for validators
- Inspectable transaction simulation
- Models running exact programs internally
- Solana security research tooling
Honestly, we don't fully know. That's part of the fun.
Post 23 of the original thread on X
What's next
Here's the roadmap:
- M0: roadmap and repro kit
- M1: the full v0 instruction set, including ALU32
- M2: run Firedancer's public VM fixtures
None of these are done yet. You can check today's numbers yourself at svmllm.rexstjohn.com.
Post 24 of the original thread on X
Learn more
We have not launched any token.
- Live demo and numbers: svmllm.rexstjohn.com
- Source: github.com/Verafyai/svmLLM
- The EVM sibling project: github.com/Verafyai/evmLLM
- Qwenputer, the project that inspired this: divagr.com/blog/qwenputer
Post 25 of the original thread on X
Read the original thread on X: x.com/rexstjohn/status/2116932210880323797