1/ Yesterday, we were extremely excited to share that ARK Invest is partnering with @LayerZero_Core on their upcoming Layer 1 blockchain, Zero, and that @CathieDWood will be joining Zero’s advisory board.
A Big thread to understand what happened 🧵
2/ Crypto is in an existential infrastructure malaise right now, many feel L1s have stopped evolving and that each new chain is only marginally better than the last.
We believe Zero is a true 0-to-1 innovation and one of the most meaningful breakthroughs we’ve seen in years.
3/ We think Layer 1s are destined to continue evolving just like any other tech innovation platform we have seen over the past 50 years:
Personal Computers, Cell Phones, Chips, LLMs, none of these technologies plateaued after 5-10 years.
4/ Blockchains are certainly not different, and we believe Zero and the team have the ability to unlock many novel use-cases, attract millions of users, and onboard hundreds of institutions over the coming years.
5/The core bet here is very simple: Zero isn’t “another chain.” It’s a re-architecture of the 3 bottlenecks that have fundamentally capped blockchain usefulness:
• state storage / Merkleization
• execution parallelism under contention
• network bandwidth / propagation
6/ The EVM isn’t what fails to scale, state does. Today every balance or storage read walks a Merkle tree that’s stored inside a generic database (think RocksDB/LevelDB). That means many random SSD reads per lookup, heavy rewrite/compaction costs on updates, and Merkle work competing with execution. CPUs wait on storage.
7/QMDB fixes this at the root by making the storage layer itself Merkle-aware: state reads become ~1 SSD read, updates are O(1) I/O, Benchmark: ~2.28M state updates/sec → ~1M native transfers/sec.
8/It’s worth noting: @monad DB is one of the closest efforts in spirit, it makes the Merkle tree itself SSD-native and async, removing layers of indirection.
9/ Zero goes one step further:
• fewer total I/Os required in the first place
• Merkle work moved out of the disk path entirely
• tighter coupling with execution scheduling (FAFO
10/ Scaling isn’t just “make blocks bigger.” The real enemy is contention, too many transactions trying to touch the same popular accounts/contracts, which forces chains to process things one-by-one.
FAFO tackles this by ordering transactions before the block is finalized so the ones that don’t interfere with each other can run in parallel.
11/ In benchmarks, REVM + FAFO hits roughly ~1.1M simple transfers/sec and ~0.56M ERC20 transfers/sec on a single node, while still producing full cryptographic state commitments each block (made practical by QMDB).
12/ The big implication: you can push toward web-scale throughput without immediately defaulting to sharding, which often adds complexity, fragmentation, and new security assumptions.
13/The last bottleneck is bandwidth / propagation:
At high TPS, “broadcast full blocks + have every node re-execute” becomes the limiter. Zero uses ZK to decouple execution from verification, moving from homogeneous replication to a heterogeneous architecture.
14/ But validity proofs alone aren’t enough. You still need scalable data availability.
Zero solves this with SVID (Scalable Verifiable Information Dispersal), a high-throughput DA layer where validators don’t download full blocks, only cryptographic commitments and small data shares.
15/ Instead of ingesting 100% of block data, validators verify retrievability via commitments while downloading <1% of the payload.
This compresses network load dramatically and clears the final propagation bottleneck, enabling ~2M TPS per Zone.
16/ Zero’s stack is built for a world where apps increasingly want verifiable compute (ZK proofs) as a standard tool, not a PhD project.
The vApps framework proposes a unified SDK/DSL approach: modular verification, proof generation, and lifecycle plumbing so teams can focus on application logic.
17/ The key ideahere is to treat verifiable apps like modern systems engineering, service-oriented components (sequencer/executor/prover/verifiable DB) and clean interfaces, so “ZK + production” becomes repeatable.
18/ Ethereum’s roadmap is converging on a clear idea: the zkEVM.
Instead of every node re-executing everything, the future is verifying execution with proofs.
The challenge isn’t the math, it’s developer reality.
19/ ZeroOS tackles this head-on by moving the integration point to a language-agnostic layer.
That means verifiable apps can:
• use standard compilers & toolchains
• avoid fragile zk-specific forks
• link only the pieces they actually need
20/ Put together, Zero looks like a full-stack execution rethink aligned with Ethereum’s endgame:
• QMDB removes the Merkle/state bottleneck
• FAFO lets EVM execution fully use modern CPUs
• SVID removes propagation limits
• ZeroOS + vApps make zkEVM-style verifiability shippable today
21/ Zero scales horizontally via Atomicity Zones, concurrent execution environments functioning like processes on a multi-core CPU, rather than forcing the entire network through a single thread.
22/ What this enables:
• consumer-grade validation at serious scale
• high-frequency applications that remain fully verifiable
• richer light clients & stateless validation
• a credible path to internet-scale, trust-minimized apps
23/ Last but not least: the most important part here is the team. We’ve gotten to know Bryan and the LayerZero team over time, and what they’ve already achieved with LayerZero speaks for itself.
Building foundational infrastructure requires teams willing to swing hard at the opportunity. We’re confident this is that team.
24/ One last point, it is clear to us that Users, developers, institutions and investors are done with the same playbook: liquidity mining, retroactive airdrops, and mercenary incentives that burn treasuries, attract the wrong userbase, and deliver little lasting retention or real liquidity.
25/ Zero isn’t another PhD-grade L1 chasing benchmarks. The team has thoughtfully designed a go-to-market strategy focused on aligned incentives, real partnerships, and sustainable adoption over time, and that deeply resonated with us.
We’re proud to be involved and excited for Zero’s upcoming mainnet launch.
Share this Scrolly Tale with your friends.
A Scrolly Tale is a new way to read Twitter threads with a more visually immersive experience.
Discover more beautiful Scrolly Tales like this.