Zero introduces the first multi-core world computer, a fundamental departure from the single-threaded, homogeneous architectures that constrain current blockchains. By leveraging Zero-Knowledge (ZK) proofs to decouple execution from verification, Zero transitions the network from redundant replication to a heterogeneous architecture. This structural shift allows for two distinct validator classes: lightweight Block Validators capable of running on low-grade consumer hardware and optional higher performance Block Producers.
The system achieves a practical scaling roadmap of 2 million transactions per second (TPS) per Zone by resolving four primary bottlenecks. These solutions include QMDB for state storage, FAFO for parallel compute scheduling, Jolt Pro for real-time ZK proving, and SVID for high-throughput networking. Zero provides a unified, horizontally scalable environment where multiple Atomicity Zones function like concurrent processes on a modern CPU. The result is a decentralized infrastructure that can offer a credible alternative to centralized cloud providers.
What is a Blockchain?
To understand how Zero works, you must first understand blockchain fundamentals.
A blockchain is an ordered list of transactions grouped into blocks. Each block links to the previous one, the history stays secure and permanent. To find the current state of the network, the system runs these transactions against a specific set of rules. Every new block updates the state.
The state is cryptographically summarized into a verifiable state root (S) and stored in the blockchain. The state root allows you to verify information, like your account balance, without having to rerun the transactions.
What Makes a Blockchain Special?
None of this is inherently special compared to a database. What makes a blockchain unique is decentralization. Instead of a central authority, a diverse group of permissionless participants, also known as validators, agrees on the state. The larger the group, spread across jurisdiction and clients, the stronger the network will be.
They follow a consensus protocol to reach a supermajority agreement on each block. This ensures the network stays secure even if some validators try to attack it. A blockchain works because a large enough group can always agree on the truth, even if some members are broken or trying to cheat.
Principles of Blockchain
Satoshi Nakamoto created Bitcoin as a direct response to the 2008 financial crisis. That collapse proved that centralized banks and governments cannot be trusted with our collective security.
The goal was to replace systems built on trust with a decentralized system built on economic incentives. In this model, we don't need validators to be "good." We only need them to be rational. By assuming every actor will pursue their own economic self-interest, the system turns individual profit-seeking into the very force that secures the network.
These systems are defined by three core principles:
- Decentralization: No single point of failure exists.
- Permissionless: No one can stop you from participating in the protocol.
- Censorship-resistant: No single authority can block or reverse your transactions.
This shift gives power back to the individual through self-custody. When you hold your own private keys, your wealth belongs to you. Centralized actors lose the ability to seize, freeze, or gamble with your assets. It is the final break from an outdated system where your money is just a liability on a bank's balance sheet.
The Rise of Ethereum
These core principles led to other blockchains that wanted to offer more than just a store of value. This sparked the rise of Ethereum. Its goal was to build a credibly neutral and programmable world computer. This was the advent of a new, decentralized, and permissionless internet.
From the perspective of the validators, Ethereum runs only one application: the Ethereum Virtual Machine (EVM).
You can compare the EVM to an operating system like MacOS. When a computer runs MacOS, the hardware does not recognize the specific apps you use. It only runs the operating system and follows the instructions the OS provides. The EVM works the same way. It allows developers to launch apps by using smart contracts.
The first real success was finance. Developers built financial apps that functioned without banks. Naturally, people tried to build everything else too, including social media and games.
But they hit a wall. Running these apps on a blockchain was vastly more expensive than using traditional "Web2" services. As more people joined, the world computer couldn't keep up. Eventually, even the financial apps struggled to grow because the system was too slow and the fees were too high.
The dream of a decentralized internet was real, but the infrastructure wasn't ready to handle the scale. Why can’t it scale?
In Ethereum, validators take turns proposing new blocks. When a validator is chosen, they bundle transactions together to create a block. Then, the rest of the validators must agree on it.
The problem with Ethereum is that it isn't very efficient. To stay in sync and verify the state, every single validator in the network has to download and rerun every single transaction.
If you send a transaction, thousands of computers around the world all do the exact same math to confirm your account balance. This constant duplication of work creates a massive bottleneck. Because the network is only as fast as its weakest link, it cannot scale.
Principles aren’t Free
To stay decentralized, Ethereum must keep its hardware requirements moderate. This ensures that almost anyone can run a node from home. However, this creates a major bottleneck: the world computer can only move as fast as a single, low-power computer.
When too many people use the network at once, they have to compete for the limited space inside each block. This triggers a bidding war. Users must pay higher fees to use the blockchain.
This makes the network too expensive for anything except high-value trades. As the system becomes more popular, it actually becomes less useful for everyday apps like games or social media because their users can't afford the fees.
Because Ethereum chose to prioritize moderate hardware requirements, new competitors emerged to offer a higher-performance "world computer." Enter: Solana.
The Rise of Solana
Like Ethereum, Solana runs its own application called the Solana Virtual Machine (SVM). Solana massively increased the validator hardware requirements to boost performance. This allows the network to process thousands of transactions per second, but it comes at the cost of core principles.
By raising the bar for hardware, Solana made it much more expensive to participate. Solana's requirements are so high that only those with specialized, professional setups can afford to run a validator. This moves the system away from widespread decentralization and toward a smaller, more concentrated group of well-capitalized operators.
Homogeneity
The architectural flaw is the same among all blockchains. They are homogeneous. The common belief is that to be a world computer, every single node in the network must download, process, and come to consensus on every single transaction. To do that, every node must be identical. This increases costs dramatically as you tune the network for higher performance. Essentially, this architecture cannot scale without compromising core principles.
The Noble Lie
In 2020, Ethereum faced an existential threat. New blockchains were choosing performance over core principles. Ethereum's own plan to scale its Layer 1 (L1) through sharding was moving too slowly, and the network was losing its lead.
Unable to scale the L1 quickly, Ethereum shifted its strategy to an Layer 2-centric roadmap. These Layer 2s (L2s), or rollups, are centralized blockchains that post their data to the L1. Ethereum’s promise was that these systems would eventually inherit the decentralization and security of the L1.
But there is a fundamental flaw. The L2s can never give up control over block sequencing, smart contract logic, and feature roadmaps.
All blockchains evolve by validators reaching consensus to upgrade their application. However, an L2 cannot inherit the security of an L1 without losing this ability. To be truly secured by the L1, the L2 would need to relinquish their upgrade privileges, making their logic locked and immutable.
This creates a paradox that proves the Layer 2 promise was always a lie:
- If an L2 is locked and decentralized: It becomes a dead end. It cannot innovate or adapt, making it irrelevant compared to every other evolving network.
- If an L2 can be upgraded: It is centralized and controlled by a small group of people with the power to change the rules.
Ethereum tells us this lie to cope with a hard truth: they abandoned their principles to stay competitive. They stopped building the world computer. Instead, they pushed users away from a decentralized, permissionless, and censorship-resistant blockchain and into centralized, censorable blockchains and called it scaling.
This lie is what drove us to make Zero.
Compute, Storage and Network
It starts with the basics. Like any computer, a blockchain is limited by three things:
- Compute: Running code to turn inputs into outputs.
- Storage: Saving and retrieving the outputs.
- Network: Communicating with other computers and the internet.
To increase performance in any system, you have to make tradeoffs between these three areas.
Compression of Compute and Network
In a standard blockchain, every validator must download and run every transaction to ensure the data is correct. This is the replication problem. It doesn't just create a bottleneck; it increases costs and puts a massive burden on validators to download and process everything.
Zero Knowledge (ZK) proofs solve this. They allow you to mathematically verify that an output is correct without having to run the code yourself. Instead of every validator rerunning every transaction, they just verify a tiny proof and skip the work.
This means validators no longer need to replay history. In fact, they don't even need to download the raw data for every block, just a proof that the transactions exist. This realization that we could free up the replication of compute and network led us to the inevitable design of Zero.
The Shift from Homogeneous to Heterogeneous Architecture
Every decentralized blockchain starts with the same thing: a set of validators coming to consensus on blocks of transactions. Zero is no different.
In existing blockchains, every validator runs those transactions through a single application, for example the EVM. Zero conceptually does the same thing. We call Zero’s applications Atomicity Zones.
The difference in Zero is that validators download data and computation proofs instead of downloading and replaying every transaction. This drastically reduces the bandwidth and compute requirements for each validator.
For the first time in history, validators of a single blockchain do not have to replicate the same work. This is the structural breakthrough that unlocks a heterogeneous architecture.
Every other blockchain operates on a homogeneous design. In these systems, nodes are identical clones that download the same data and replay every transaction. While this keeps the chain in sync, it traps the network in a cycle of redundant manual labor.
If Zero utilized ZK proofs within that same homogeneous framework, it would be a failure of design. ZK proofs are verified in milliseconds, so every validator would complete their task instantly and then sit idle, wasting the resources they were forced to provision.
To capitalize on the ZK unlock, Zero bifurcates the network into two distinct functional classes: Block Producers and Block Validators.
- Block Producers take turns constructing blocks, executing state transitions, and generating the cryptographic proofs.
- Block Validators simply ingest block headers and verify the proofs.
This shift fundamentally alters the economic requirements of the network. In Ethereum, every single validator must possess the compute power to run the full VM. This massive redundancy forces the collective cost of maintaining a network of that scale to approximately $50 million annually.
Zero removes the requirement for every node to be cloned. By separating execution from verification, a network with the same throughput and decentralization as Ethereum can operate for less than $1 million. Decentralization at global scale doesn't come from making validators more powerful, it comes from making the validators do less.
Decentralization
Block Producers bundle transactions into blocks and generate proofs to boost performance. However, the validators have final authority over which blocks are accepted. This prevents any single block producer from acting as a gatekeeper and ensures that Atomicity Zones are censorship resistant.
Zero is secured by delegated proof of stake. ZRO stakers delegate their tokens to validators who run the network. To make sure everyone can participate, we’ve removed high minimum stake requirements and eliminated automatic consensus-layer slashing. This levels the playing field, removing the systematic economic hurdles that usually push out home validators in favor of giant staking pools.
The same logic applies to how the network is governed. Any major change, like a protocol upgrade or adding a new Zone, requires an on-chain vote by the stakers. This is why Zero is a single secure blockchain: there is no external council that upgrades Zones, it is fully owned by the decentralized governance layer. But we know that most people don't have the time to audit complex code or economic whitepapers. To solve this, Zero uses a Senator model.
- Expert Guidance: Senators are recognized experts in fields like cryptography and economics who are aligned with Zero's mission.
- Smart Delegation: As a staker, you can delegate your voting power to a Senator you trust, ensuring the network is guided by informed decisions.
- Non-custody: You never lose your voice. You can override a delegation and vote directly on any proposal, at any time.
This setup allows the network to benefit from elite expertise while keeping final authority where it belongs: with the stakeholders.
Single Core to Multi-Core
If Zero’s architecture can match Ethereum’s decentralization while using only a fraction of its resources, it opens up a major new opportunity. Essentially, Zero leaves massive amounts of network power and compute on the table.
Most blockchains are single-threaded. They act like an old computer with a single-core processor that can only run one app at a time. Because every node in the network must repeat every single instruction, the entire world computer is limited by the speed of that one core.
Zero breaks this constraint. Since we no longer waste resources on duplicated work, the network is free to run many applications in parallel. This allows the system to handle a massive volume of transactions at once without slowing down.
Think of it like the jump from a single-core to a multi-core processor. In the old model, if you wanted to run a new application, you had to compete with everyone else for the same limited cycles. Zero has the capacity to run hundreds of applications simultaneously across different Atomicity Zones.
By moving to a multi core architecture, we do not just scale a single application; we scale the entire ecosystem. Zero can run a high frequency exchange in one Zone, a social media protocol in another, and a private payments system in a third, all without them fighting for the same resources.
Four Performance Bottlenecks in Blockchains
Two and a half years ago, this was the architecture we set out to build with Zero. Our original goal was to create a blockchain as decentralized, permissionless, and censorship-resistant as Ethereum was, but with the performance of Solana. To get there, we had to solve the scaling bottlenecks that have plagued this industry from first principles.
Our journey started with a simultaneous attack on storage and ZK.
The Storage Breakthrough: QMDB
Beyond compute and network, state storage is one of the biggest bottlenecks for scaling. For years, the industry assumed blockchains had to use trie-based data structures. These structures are incredibly inefficient because they write the trie structure to disk, wasting the high-speed potential of modern SSDs.
We realized the solution was a fundamental shift in data architecture. Instead of following the legacy trie model, we moved to a log based, append-only structure designed specifically for the high speed IO of modern SSDs. We then layered verifiability directly on top of this optimized foundation.
The result is QMDB, the fastest verifiable database in the world. Its design is 92% theoretically optimal, allowing it to process 3 million updates per second.
This performance is not just a marginal improvement. It is 100x faster than existing blockchain state databases and 6x faster than Facebook’s RocksDB. We previously viewed Solana's throughput as the ceiling for what was possible, but QMDB proved that the storage is not the bottleneck, and the ceiling is high enough to support applications like NYSE with over 2 million transactions per second. That number became our goal for every remaining bottleneck in the system. By solving storage, Zero removed the first physical barrier to true global scale.
Compute: Raising the Ceiling with FAFO
Once QMDB reached 3 million updates per second, it became clear that the theoretical ceiling for throughput was significantly higher than industry standards suggested. With storage optimized, the primary bottleneck shifted to compute. Specifically, the network needed a method to process transactions without the scheduling conflicts inherent in traditional blockchain workloads.
Most blockchains process transactions serially. Even when tasks are unrelated, they are forced into a single-file line to prevent errors.This sequential requirement prevents the system from scaling, regardless of how much hardware is provided.
We invented FAFO (Fast Ahead of Formation Optimization) to resolve this. FAFO enables parallel execution, similar to Solana, but with a critical difference in our sophisticated scheduling algorithm and superior developer experience. While Solana requires the user or developer to manually specify which storage slots a transaction will touch, FAFO performs this analysis automatically. It identifies non-conflicting transactions and reorders them for parallel execution without shifting the burden onto the user.
While FAFO does not eliminate contention over storage hot spots, it isolates their performance impact. This ensures that a spike in demand for one specific application does not increase costs for others. Uncontested applications continue to access cheap block space regardless of congestion anywhere else.
The architectural shift is significant. FAFO enables performance 2,500x faster than the BNB chain, with a single node exceeding 1.2 million EVM transactions per second. By eliminating serial execution, the EVM finally scales.
ZK: Scaling with Jolt
While building QMDB, we also evaluated the Zero-Knowledge (ZK) landscape. We found that most existing zkVMs were reaching the end of their life cycles; they were built on aging architectures that could not meet our requirements for global scale. Among the options, we identified Jolt as an emerging and promising framework we believed to be capable of powering the world computer. Jolt's architecture is fundamentally simpler and more efficient than other proving systems. We assembled a team of world-class cryptographers to build on that foundation to create Jolt Pro which proves RISC-V at over 1.61GHz per cell and a clear roadmap to 4GHz by 2027.
To put that in perspective, 4GHz is equal to a single core on a modern high-end CPU. We can scale these cells infinitely and are limited only by the amount of GPUs in the datacenter.
Jolt Pro proves RISC-V around 100x faster than existing zkVMs. This leap is what finally makes real-time verifiable computation practical.
Network: The Final Bottleneck
Solving storage, compute, and ZK left us with one final barrier: fault tolerant block storage. Standard blockchains are bottlenecked because every validator must download every transaction. In our architecture, validators only need a transaction commitment and a small share of the transaction data. This is a tiny cryptographic fingerprint proving the data is retrievable, which is a dramatically smaller amount of information—less than 0.5% of the original block data for a 128 MiB block.
To scale these commitments, we created SVID (Scalable Verifiable Information Dispersal). It theoretically delivers a massive 10 GiB/s throughput, which is more than 1000x faster than PeerDAS. By ensuring validators only download the bare minimum, we cleared the final hurdle to achieving 2 million TPS per Zone.
The First Multi-Core World Computer
The leap in networking completes the architectural circle. By decoupling data availability from validation, SVID allows the network to handle massive loads without overwhelming individual nodes. Combined with QMDB for storage, FAFO for scheduling, and Jolt Pro for ZK proving, the network is no longer a bottleneck.
Two million transactions per second became our explicit goal for every component of the system. By hitting this target, Zero can support the most performant modern applications.
This architecture allows Zero to function as a decentralized multi core world computer. Crucially, Zones are not sovereign chains, Layer 2s, or rollups. Every Zone is owned by Zero and governed by the same unified protocol. Most blockchains, including Ethereum, are single threaded; they run on a single core. Zero runs on many. Each Zone is functionally equivalent to the single EVM that Ethereum runs, but we execute them simultaneously across multiple cores.
The result is a single blockchain that scales horizontally. Developers do not need to create their own Zones; they build applications on top of the Zones Zero provides. We have replaced the fragmented, one-size-fits-all model with a unified high performance system that treats multiple applications like concurrent processes on a single modern multi-core CPU.
Due to this massive cost reduction, Zero is not only an alternative to existing blockchains; it provides a credible alternative to centralized cloud providers like AWS. By stripping away the overhead of redundant replication, we have finally made decentralization viable on a global scale. Zero is the first truly scalable, multi-core world computer.