Why Parallel Execution is the Only Path Forward

EVM's sequential processing is the root of congestion. It forces all transactions into a single queue, wasting idle compute and creating artificial scarcity.

• Wasted Resources: >90% of validator CPU sits idle during block processing.
• Predictable Congestion: Network activity above ~15 TPS causes gas wars and failed transactions.
• Economic Friction: High, volatile fees price out entire classes of applications (e.g., gaming, microtransactions).

Solana's Sealevel runtime demonstrated that massive parallel execution is viable, achieving ~5,000 TPS for simple payments. It validated the core thesis but exposed new challenges.

• Throughput Benchmark: Proved 100x+ gains over Ethereum L1 are possible.
• Architectural Debt: Requires aggressive hardware, suffers from stochastic liveness during congestion.
• Developer Friction: The model is rigid, forcing all state into a global ledger, complicating execution.

Move-based chains introduced a more elegant paradigm: data-centric parallelism. Transactions are parallelized by declaring access to specific state (e.g., coins, objects), not by guessing.

• Deterministic Speed: 160k TPS in theoretical benchmarks for independent transactions.
• Safer Concurrency: The Move language prevents data races at compile time, a major improvement over ad-hoc locking.
• Scalable State: The object model allows horizontal sharding, a path Solana's monolithic state lacks.

The battle for the parallel EVM is the defining L2 narrative of 2024. These projects aim to retrofit parallelism onto Ethereum's security, creating a superior execution layer.

• Monad: 10,000+ TPS target via parallel execution, asynchronous I/O, and a novel state database (MonadDB).
• Neon EVM: Solana-style parallelism as an Ethereum L2, offering devs a familiar EVM on a parallel engine.
• Eclipse: A modular rollup allowing any VM (SVM, MoveVM) to settle on Ethereum, commoditizing execution.

Parallel execution fundamentally changes the MEV supply chain. Faster blocks and more complex state access create new opportunities and risks for searchers and builders.

• New Frontiers: JIT (Just-In-Time) Auctions and parallel block building emerge, as seen in Flashbots SUAVE research.
• Arbitrage Complexity: Thousands of pools can be scanned simultaneously, increasing competition and potentially compressing margins.
• Solver Dominance: Projects like CowSwap and UniswapX that use off-chain solvers may integrate parallel on-chain settlement for optimal routing.

Parallel execution isn't an optimization; it's a prerequisite for applications requiring real-time interaction and predictable, low cost. The market will bifurcate.

• Winners: High-frequency DeFi, fully on-chain games (Parallel TCG, Dark Forest), and decentralized social feeds.
• Losers: Chains that remain sequential will be relegated to high-value, low-frequency settlements only.
• Endgame: A multi-chain ecosystem where parallel EVMs and specialized VMs (Move, SVM) compete on an Ethereum security blanket.

Solana's core innovation is architecting the blockchain as a single global state machine optimized for parallel hardware. It treats the network as a GPU, not a CPU.

• Sealevel VM schedules non-conflicting transactions across all cores simultaneously.
• Local Fee Markets prevent network-wide congestion from a single hot contract.
• Pipelining processes validation, banking, and consensus in parallel stages.

These Diem successors use the Move language and explicit data ownership to enable aggressive parallelization by default.

• Move's resource types make data dependencies statically analyzable for the runtime.
• Sui's object model treats most assets as independent, allowing parallel execution of >90% of transactions.
• Block-STM (Aptos) uses software transactional memory to optimistically parallelize and re-execute conflicts.

Ethereum's monolithic execution is its greatest constraint. The scaling roadmap now runs through parallelized L2s.

• Monad uses parallel execution and deferred state writes to decouple execution from consensus.
• Sei V2 brings the first parallelized EVM to a high-throughput L1, aiming for millisecond finality.
• Neon EVM on Solana demonstrates that parallel execution environments can be bolted onto existing ecosystems.

Ethereum's single-threaded EVM creates artificial scarcity, capping throughput and inflating fees during demand spikes.

• Diamond Hands Effect: A single popular NFT mint or DeFi launch can congest the entire network.
• Wasted Cycles: Idle CPU cores while transactions queue sequentially.
• Economic Inefficiency: Users overpay for security they don't need due to non-existent resource isolation.

True parallelism requires the runtime to know in advance what data a transaction will touch. This is the key technical hurdle.

• Explicit Dependency Declaration: Transactions state their read/write sets upfront (Sui, Fuel).
• Static Analysis: The VM infers dependencies from the bytecode (Aptos Block-STM, Solana).
• Conflict Detection & Resolution: Optimistic execution with rollback for the minority of conflicting transactions.

The next generation of infrastructure is being built assuming parallel execution, unlocking new application designs.

• Firedancer: Jump Trading's Solana client built for bare-metal performance on modern datacenter hardware.
• Eclipse & SVM Rollups: Bringing Solana's parallel runtime to any settlement layer as a customizable L2.
• Modular Parallel Chains: Execution layers like Movement Labs' M2 are building parallel Move VM environments for Ethereum.

EVM's single-threaded execution creates artificial scarcity, capping throughput and inflating costs during congestion. This is a fundamental architectural flaw, not a temporary scaling issue.

• Gas wars during NFT mints or DeFi liquidations cause 100x+ fee spikes.
• Theoretical max of ~30 TPS creates a hard ceiling for adoption.
• Every transaction, from a Uniswap swap to a simple transfer, waits in the same global queue.

These Move-based chains treat state as independent objects, enabling deterministic parallelization. Transactions that touch disjoint state execute simultaneously.

• Block-STM (Aptos) uses software transactional memory for optimistic parallel execution, achieving 10k-160k TPS in benchmarks.
• Narwhal & Bullshark (Sui) DAG-based mempool separates dissemination from consensus, enabling sub-second finality.
• The key is declaring dependencies upfront, moving beyond the EVM's serialized global state.

Solana's parallelization is implicit; the runtime (Sealevel) dynamically schedules transactions that don't conflict. It bets on Moore's Law and cheap hardware to scale.

• Requires validators with high-end SSDs and 128GB+ RAM, centralizing hardware requirements.
• Achieves 2k-5k real TPS but is bottlenecked by network bandwidth and block propagation.
• Demonstrates that parallel execution alone isn't enough—data availability and consensus are the next bottlenecks.

These projects retrofit parallel execution onto the EVM, aiming for maximal compatibility with a 10-100x performance lift. They solve the hardest problem: parallelizing a stateful, sequential virtual machine.

• Monad uses asynchronous execution and a custom state database (MonadDB) to pipeline EVM execution, targeting 10k TPS.
• Fuel employs a UTXO-like model with strict state access lists, enabling parallel validation for its optimistic rollup.
• The goal: Ethereum's ecosystem with Aptos-level throughput.

Parallel execution introduces new complexity for synchronous composability—the ability of one transaction to depend on the immediate outcome of another within the same block.

• Aptos/Sui models require explicit dependency chains, breaking "flash loan" style atomic bundles.
• Solana preserves some atomicity for transactions sharing accounts, but at the cost of potential congestion.
• The future is asynchronous composability, where protocols like UniswapX and Across use intents and solvers, moving complexity off-chain.

For any new L1 or high-performance L2, a parallel execution engine is no longer an innovation—it's a prerequisite. The battle shifts to the quality of the state model, virtual machine efficiency, and data availability layer.

• Winners will offer <$0.01 average fees and sub-2s finality for mainstream applications.
• The Move VM (Aptos, Sui) is arguably superior for parallel design, but the EVM's liquidity (Monad, Fuel) is an immense gravitational force.
• The era of waiting for your transaction is over.