Execution
The Fractal EVM runs independent transactions together. Conflicts are detected and re-executed. Cores do not take turns.
22Z · Fractal EVM
A chain that doesn't wait
for anything.
A full stack chain. Fractal EVM is the engine that runs the transactions. Blocks, ordering, state, and RPC are the rest of it.
195,000
Chain TPS, sustained
27 minutes · 31 January 2026
312 million
Transactions accepted
Zero rejections
1.18M
Engine TPS, sustained
128 vCPU, 256 GB · April 2026
100ms
Block time
Single confirmation
Chain
The whole chain. One engine.
22Z is the stack: blocks, ordering, state, execution, and a standard RPC. Fractal EVM is the engine inside it. Same bytecode. Transactions that do not touch run at once.
Finality
Blocks are produced in 100 milliseconds. One confirmation is the confirmation.
Compatibility
Solidity, Hardhat, Foundry, ethers, and viem. Existing contracts deploy without a rewrite.
Ordering
Deterministic sequencing. The order a block commits is the order it can be replayed.
State
Lock-free concurrent state. Adding cores widens throughput instead of spending it on contention.
Interface
Standard Ethereum JSON-RPC. Point a provider at the endpoint and keep the rest of the stack.
Architecture
The engine inside the chain.
Fractal EVM executes. 22Z is the chain around that engine: block production, ordering, state, and the interface a wallet already speaks. A traditional EVM runs one transaction, then the next. The state lock is the machine. On a large server, almost every core waits.
22Z removed that wait. Independent work proceeds together. Only a real conflict pays for a second pass. The gap is not a percentage. It is the difference between one lane and the width of the CPU.
Parallel by construction
Non-conflicting transactions execute at the same time. The engine was written for that, not patched onto a sequential loop.
Lock-free state
No mutex sitting between the cores and the state. Optimistic execution, then a precise redo where two transactions actually touch.
One confirmation
100 millisecond block production on the running chain. Finality is a block, not a committee of them.
Scales with the machine
The April 2026 engine run was one commodity server: 128 vCPU and 256 GB. More cores, more throughput.
Benchmarks
Two measurements. Both dated.
The chain number is a full node accepting signed transactions. The engine number is the Fractal EVM alone, on a larger server. They are not the same test.
22Z chain · 31 January 2026
195,000
sustained transactions per second
- Duration
- 27 minutes
- Accepted
- 312 million
- Rejections
- None
- Block time
- 100ms
- Hardware
- Single node
Sustained, not a peak. Zero rejections. The load generator reached its ceiling before the chain did.
Fractal EVM · April 2026
1.18M
sustained TPS
4.36M
burst TPS
- Hardware
- 128 vCPU, 256 GB
- Method
- Criterion, 100 samples per run
- Against Geth
- 87× a modified Geth
Execution only. This is the ceiling the chain is built on, not the January node run.
An earlier public one-hour run held 13,801 sustained TPS and 50 million+ transactions. The 31 January 2026 run replaces it as the chain figure.
Deploy
Not public yet. Servers are down.
The network is not public yet. Endpoints, chain add, and wallets stay off this site until the servers are up.
Zach@origin22.comDevelopers
Point the provider. Keep the code.
A transfer confirms in about the length of a block. No new toolchain, no new language, no migration.
Hardhat, Foundry, and RPCdeploy.ts
import { ethers } from 'ethers';
// Public RPC is not up yet.
const provider = new ethers.JsonRpcProvider(
process.env.RPC_URL
);
const contract = new ethers.Contract(address, abi, signer);
const tx = await contract.transfer(recipient, ethers.parseEther('1.0'));
const receipt = await tx.wait();Built different. Write to Zach.
If the work you are shipping actually cares about confirmation time, we should talk.
Per chaos ad astra.