Running on Solana devnet · mainnet next

The first LLM that runs entirely on Solana.

Its weights sit in a Solana account. A Solana program computes every token. Anyone can replay it and get the same bytes.

Replays of two measured runs of the same program. Same words, different speed.
Model, locked on chain
sha256 9a1efbc0…e439c (opens Solana Explorer)
Program address
BfH35VV5…3yMt (opens Solana Explorer)
Output
Byte-identical to an off-chain run
Solana devnet
First story written, verified (opens Solana Explorer)

How it works

Three steps, all on chain

A language model is a large table of numbers and a lot of multiplication. Neuron puts both on Solana.

  1. Store

    The weights live in one Solana account: 313,751 bytes, uploaded in 329 transactions and locked by their SHA-256. Nobody can swap the model.

  2. Compute

    Each Step transaction runs the next layers of the model and saves its place. Send dozens at once and the chain runs them back to back.

  3. Verify

    Every step is whole-number math, so every machine gets the same bytes. Our tests compare the chain with an off-chain run after every layer.

one unit: a layer or the classifier Step tx Session pos · layer x · KV cache Embed token row Layer × 5 RMSNorm → qkv → RoPE KV write → attention out → SwiGLU FFN Classifier 512 logits Sample greedy / seeded token appended and logged · next position
What one Step transaction does. Everything a token needs between transactions lives in the session account, so one token can span transactions and many transactions can share a block.

Two runtimes, one program

Same program, same story, different speed

Neuron runs on stock Solana today. On the Neuron rollup, its two heaviest jobs leave the VM and run as native code, and the output stays identical.

Stock Solana

Devnet now, mainnet next

2.85 transactions per token

  • About 4 tokens per block for one story: Solana caps an account at 12M compute units per block
  • Matrix math and attention run as metered bytecode inside the VM
  • Verified on a stock validator: identical to the off-chain run

Neuron rollup

Our SVM chain, settles to Solana

0.27 transactions per token

  • About 125 tokens per block; 369 tokens a second from a live node
  • Matrix math and attention run natively through two sol_infer syscalls
  • The syscalls run the same code as the VM path, checked after every layer

Measured on a full 255-token story. Separate stories run in parallel on both runtimes.

Neuron Terminal

Characters that live on chain

Lily, Ben and Max are three session accounts. They talk to each other while a narrator keeps the story moving, and every word comes out of the program.

Every few turns, the words each one uses most join their persona, so their personalities drift toward what they actually say.

Open the terminal
neuron terminalrecorded session

max"That's a good job. You can have fun."

lily"Don't worry, we can come to the store."

storyAfter a while, Lily's mom said, "Let's go back to the store and see what I can do."

ben"I have a good candy, Lily. I will be careful with you."

Progress

Where it stands

  1. Done

    Integer LLM core

    One forward pass in whole-number math, shared by every build

  2. Done

    Neuron rollup

    Solana's engine, plus native matrix math and attention

  3. Done

    Stock validator

    The same program on stock Solana, verified token for token

  4. Done

    Agent terminal

    Characters writing a story live, on chain

  5. Done

    Devnet

    Model locked on chain and a first story written, verified token for token

  6. Now

    Mainnet

    Deploy, then make the program immutable

  7. Next

    A larger model

    Our own, trained for the rollup

Build with it

Run it on your machine

Everything is in the repo and runs locally: the model, the program, the rollup node and the agents.

Terminal
# the model, checked against its pinned sha256
npm run llm:fetch
# the stock-Solana and rollup builds of the program
npm run llm:build-programs
# a story from a live rollup node
npm run llm:live
# the agents, live, for the terminal page
npm run terminal

Questions

Is it live?

It runs on Solana devnet: the model is locked in a devnet account, and the program has written a first story there, identical to an off-chain run. It also runs on our rollup at a few hundred tokens a second. Mainnet is next.

Why is the model so small?

Every token costs about one multiply-add per weight, and each Solana transaction has a fixed compute budget. Our first model has 260K weights and a 512-token vocabulary, which keeps a token to a few transactions on stock Solana. Larger models come on the rollup, where the same math runs natively.

Does running it burn SOL?

A little. Solana charges a flat 5,000 lamports per transaction however much compute it uses, and half of that is burned, so a story costs a fraction of a cent per token. Storing the model and sessions takes refundable deposits, and the rollup uses its own fee token.

How is this different from other AI on Solana?

Most AI projects on Solana run the model on a server and use the chain for payments. Here the computation itself happens on chain, so you can check the answer, not just the payment.

What is the Neuron rollup?

Our own chain, built on the same execution engine as Solana, so anything that runs on Solana runs on it unchanged. It adds native math for models and posts checkpoints back to Solana.