Most blockchains verify transactions one by one. IONA Protocol verifies thousands at once — inside the kernel, using recursive SNARKs.
I've been building IONA OS — a sovereign operating system written entirely in Rust — for the past 13 years.
But IONA OS is not just an operating system. It has a native L1 blockchain protocol integrated into the kernel itself.
And that blockchain protocol does something most others don't: it verifies transactions recursively, using Nova, a folding scheme that requires no trusted setup.
Here's how I built it — and why it matters.
What is Nova and why does it matter?
Most blockchains verify transactions one by one. Each transaction requires its own proof, its own verification, its own computational cost.
Nova is a folding scheme — a cryptographic technique that takes two proofs and "folds" them into one. This means you can verify thousands of transactions with the same cost as verifying a single one.
This is revolutionary for several reasons:
- Scalability: The cost of verification does not grow with the number of transactions.
- No trusted setup: Unlike earlier SNARKs (like Groth16), Nova does not require a trusted ceremony. There is no single point of failure.
- Recursive: A proof can be verified, and that verification can be folded into the next proof.
Nova is used in cutting‑edge projects like Zcash and Halo2. But I didn't want to just use Nova. I wanted to integrate it into the kernel itself.
What are Pallas and Vesta?
Pallas and Vesta are two elliptic curves that form a cryptographic cycle (also known as Pasta Curves).
A curve cycle is essential for recursive proofs:
- A proof on Pallas can be verified by a circuit on Vesta.
- A proof on Vesta can be verified by a circuit on Pallas.
This allows for unbounded recursion — you can keep folding proofs indefinitely, each time verifying the previous one.
These curves were specifically designed for this purpose. They are used in Zcash's Halo2 and other advanced cryptographic systems.
But in IONA OS, they are not a separate library. They are built into the kernel.
Why integrate Nova into the kernel?
Most blockchains run as separate daemons on top of an existing operating system. IONA Protocol does not.
It runs inside the kernel — in Ring 0, with direct access to hardware and to the rest of the operating system.
This integration gives me several unique advantages:
| Advantage | Why it matters |
|---|---|
| Performance | No context switching between kernel and userspace. Verification happens at the lowest possible level. |
| Security | The verification logic is part of the trusted computing base. It cannot be tampered with by userspace processes. |
| Integration | The proof system is directly connected to the mempool, the consensus engine, and the storage layer. |
| Sovereignty | No external dependencies. No third‑party libraries. Everything is written from scratch, in Rust. |
How it works in practice
The Nova implementation in IONA Protocol is not a separate module. It is woven into the blockchain subsystem.
Step 1: Transaction accumulation
Transactions are collected into blocks by the DAG consensus engine. But instead of verifying each transaction separately, the system accumulates them into a folded proof.
Step 2: Folding
Using the Nova folding scheme, the system folds the proofs of all transactions in the block into a single proof. This folding happens incrementally — as each transaction is added, its proof is folded into the existing proof.
Step 3: Verification
The final folded proof is verified once, at the kernel level. This verification is fast — it does not grow with the number of transactions.
Step 4: Commitment
The verified proof is committed to the blockchain. The state root is updated, and the block is finalised.
All of this happens inside the kernel, without any userspace involvement.
What this means for users
| Benefit | Explanation |
|---|---|
| Scalability | The protocol can handle thousands of transactions per second, because verification cost is constant. |
| Privacy | Recursive proofs enable private transactions (the sender, amount, and recipient can be hidden). |
| Trust | No trusted setup means no one needs to be trusted. The system is trustless from day one. |
| Performance | Kernel‑native verification is faster than any userspace implementation. |
What this means for the ecosystem
IONA Protocol is not just another L1. It is a kernel‑native, recursively verifiable blockchain.
- It scales without sacrificing security.
- It is private without requiring trusted parties.
- It is sovereign — it depends on no external libraries or services.
And it is launching on September 15, 2026, as part of IONA OS.
The code
You can find the Nova Pallas/Vesta implementation in the IONA OS repository:
github.com/Ionablokchain/Iona-OS
The code is written in Rust, runs in Ring 0, and is part of the IONA Protocol subsystem.
Final thoughts
Building Nova Pallas/Vesta into the kernel was one of the hardest things I've done.
But it's also one of the most rewarding.
Because now I have a blockchain protocol that can verify thousands of transactions with constant cost, without trusting anyone, and without leaving the kernel.
IONA OS launches on September 15, 2026.
Website: iona.zone
GitHub: github.com/Ionablokchain
13 years of research. Every line written from scratch. And it works.
