LayerZero’s FAFO Explained.

TLDR: blockchain performance problems are software engineering problems that can be solved with better designs.

When infrastructure works, it fades into the background. Nobody talks about the power grid when the lights work. And that’s the kind of future LayerZero is building for omnichain transactions, especially with the introduction of Fast Ahead-of-Formation Optimization (FAFO).

The Bottleneck

Blockchains are slow considering the hardware they run on. Current speeds look like this:

• Ethereum: 15–20 transactions per second
• Bitcoin: 7 TPS
• Solana: 3,000–4,000 TPS in practice (despite claims of 65,000 TPS theoretically)
• Polygon: ~7,000 TPS

Most blockchains process transactions one at a time, in order, like a supermarket with 20 checkout lanes where every customer queues behind the same cashier, just in case two people are buying the same cereal. A modern server has dozens of CPU cores that could theoretically run dozens of transactions simultaneously, but blockchain software typically uses just one.

One line, one cashier. That’s how blockchains still operate.

This is the data contention problem. When two transactions want to change the same account balance, they can’t run at the same time, one has to wait for the other to finish. Current systems assume everything conflicts with everything else, so they process everything sequentially.

But when you send ETH to your friend while someone else trades on Uniswap, these operations touch completely different parts of the blockchain. There’s no technical reason they can’t happen simultaneously.

Current Solutions

The industry has tried several approaches to solve this scalability bottleneck:

Sharding splits the blockchain into pieces so that different shards can process transactions in parallel. Ethereum 2.0 is doing this, and Aptos recently launched “Shardines,” claiming 1M TPS.

But sharding creates new problems where apps can’t easily access data from other shards, cross-shard transactions are expensive, and according to Aptos’s own data, efficiency drops 33% when you double the number of shards.

Layer 2 solutions like Arbitrum and Optimism process transactions off-chain and batch them. This works, but fragments everything. Your tokens might be on Ethereum, Arbitrum, or Polygon, and moving between them is slow and expensive.

Optimistic execution systems like Block-STM try to run transactions in parallel and fix conflicts afterward. These typically get 2–5x speedups but break down under high contention when lots of transactions conflict.

Fast Ahead-of-Formation Optimization (FAFO)

LayerZero’s FAFO solves this by figuring out which transactions can run together before executing them. Similar to the earlier grocery store analogy, it’s like looking at a grocery store line and grouping people who aren’t buying any of the same items so they can all check out simultaneously.

FAFO fixed the line. Everyone’s checking out at once.

The system works through four integrated components that form a cohesive pipeline:

ParaLyz analyzes each transaction to predict what data it will read and write. If you’re sending ETH, it knows you’ll modify your balance and the recipient’s balance. If you’re trading on Uniswap, it knows you’ll touch the token balances and pool reserves. While transactions sometimes do unexpected things, the prediction is fast and accurate enough to make good decisions.

ParaFramer takes this analysis and groups non-conflicting transactions into “frames” using Bloom filters (very fast lookup tables that can quickly check if two transactions might conflict).

The system uses 64 pairs of 2048-bit Bloom filters that fit in 32 KiB (half of L1 cache), allowing conflict detection using simple bit operations that CPUs can do in a single cycle. It greedily packs transactions into frames, and when a transaction conflicts with everything in current frames, it finalizes the largest frame and starts fresh.

ParaScheduler dispatches and executes the stream of transactions from ParaFramer across multiple CPU cores, identifying additional transaction-level parallelism in the process. Even within frames, some ordering matters, if transaction A writes a value that transaction B reads, B has to wait for A.

The system builds dependency graphs to track these relationships and executes transactions as soon as their dependencies are satisfied. When transactions whose actual read/write sets diverge from their approximations are discovered, they’re dropped and returned to the mempool for reprocessing.

FAFO processes transactions in a four-stage pipeline

Block Formation periodically synchronizes the execution threads, flushes storage, and inserts block headers into the stream of successfully executed transactions. Many high-speed systems skip cryptographic verification for performance, however, FAFO maintains full Merkle trees using QMDB, meaning light clients and zero-knowledge apps can still verify everything cryptographically. These blocks can then be settled to the underlying consensus layer.

The Numbers

According to the FAFO whitepaper, the system hits 1,121,732 TPS for ETH transfers and 565,956 TPS for ERC20 transfers on a 96-core server. That’s a different league entirely.

Image of @jvr0x’s comment on X

To put this in perspective: at peak capacity, FAFO could process every single transaction that currently happens on Ethereum, Bitcoin, and Solana combined and still have 99% capacity left over.

It’s enough throughput to handle Black Friday shopping volumes for the entire internet. According to Federal Reserve data, the US processes roughly 174 billion electronic payments annually. LayerZero’s FAFO could handle that in about 5 days.

The cost difference is equally stark. FAFO delivers this performance for $6,013 per month, versus $65,361 per month for equivalent sharded systems on AWS, a 91% cost reduction.

Even under extreme stress testing where 99% of transactions hit just 0.0001% of storage slots (a pathological worst case), the system maintained over 130 TPS worth of parallelism and 1.1 million total TPS.

For comparison, analysis of real Ethereum shows hotspots involve about 0.1% of storage slots, accounting for 62% of accesses, much less concentrated than their test scenario.

Conclusion

FAFO proves blockchain performance problems are software engineering problems that can be solved with better designs. The system scales linearly with CPU cores until it exhausts available parallelism in the workload, meaning it could theoretically scale up to around 130 cores before hitting diminishing returns on their benchmark.

Image of @radarblock’s comment on X

The techniques are open-source and applicable beyond LayerZero. Cache-efficient conflict detection, frame-based scheduling, and ahead-of-formation optimization could influence how other blockchain systems are built.

For LayerZero specifically, FAFO enables their omnichain vision of seamless interaction between blockchains without the current friction of bridges and long wait times. When you can process a million transactions per second while maintaining full cryptographic security, the performance versus decentralization trade-off stops being relevant.

The question now is how quickly the ecosystem will adopt solutions like FAFO that make scaling simply incredible.

Get Started With LayerZero

If you’d like to learn more or get started with the omnichain future:

• Check out the FAFO Whitepaper
• Check out the LayerZero website at layerzero.network
• Check out the docs at docs.layerzero.network
• Read more on Medium at medium.com/@LayerZero_Labs