The Cost of General-Purpose VMs in a High-Frequency World

Solana's core thesis is that a single, optimized state machine eliminates cross-shard latency and composability breaks. It's a bet on hardware, not fragmentation.

• Sealevel parallel runtime processes thousands of independent transactions concurrently.
• Native fee markets per compute unit prevent network-wide congestion from a single app.
• ~400ms block times with sub-second finality create a continuous execution environment.

Monad attacks EVM inefficiency at the client level, keeping bytecode compatibility while overhauling the execution and storage stack.

• Monadic state with async execution and deferred writes decouples execution from I/O bottlenecks.
• Pipelined consensus overlaps validation, execution, and storage updates.
• Targets 10,000+ TPS and 1-second block times without breaking existing smart contracts.

Fuel is a purpose-built VM for high-throughput transactions, designed to be the fastest execution layer for a modular stack (e.g., Celestia, EigenDA).

• UTXO-based parallel execution with strict state access lists enables deterministic concurrency.
• FuelVM is a minimal, register-based VM that reduces opcode overhead vs. stack-based EVM.
• Sway language and Forc toolchain provide a Rust-like dev experience optimized for the architecture.

EVM opcodes are priced for worst-case scenarios, forcing simple swaps to subsidize complex DeFi logic. This creates a bloated base cost for all transactions.

• A SLOAD (storage read) costs ~2,100 gas, a CALL ~700 gas, regardless of context.
• This static pricing fails to account for actual hardware resource consumption (CPU vs. I/O).
• The result is high, unpredictable fees during congestion, making HFT and micro-transactions economically impossible.

Projects like dYdX v4 (Cosmos SDK) and Aevo (OP Stack) escape the general-purpose tax by controlling their entire stack.

• They can strip unused opcodes and optimize the VM precisely for order-book matching or options pricing.
• Sovereign or shared sequencing allows for custom block times and fee models (e.g., maker/taker fees).
• This trades off interoperability overhead for deterministic, sub-cent transaction costs.

Sei V2 is deploying a high-performance, parallelized EVM environment as a layer within its existing Cosmos-based chain.

• EVM bytecode compatibility via Geth, but with Sei's parallel processing and optimistic block processing.
• Native frontrunning protection (FBA) and central limit order book primitives are built into the chain.
• Aims for 80-90% reduction in gas costs versus Ethereum L1 for identical operations.

Every operation, from a simple add to a keccak256 hash, has a fixed gas cost that doesn't reflect real-world hardware execution variance. This creates massive overhead for compute-heavy tasks.

• Inefficient Pricing: A storage write costs ~20k gas, but real I/O cost is negligible on modern SSDs.
• Wasted Cycles: The sequential execution model prevents parallelization of independent transactions.

Bypass the general-purpose VM entirely by building a sovereign VM optimized for a single application's logic, compiled to a minimal instruction set.

• Native Performance: Execute application logic directly on metal, not through a VM interpreter.
• Parallel Execution: Architect state models (e.g., UTXO) that allow non-conflicting txns to process simultaneously.
• Cost Control: Developers pay only for the ops they use, eliminating the 'EVM tax'.

Retain EVM bytecode compatibility but overhaul the execution layer to process transactions in parallel, using optimistic concurrency control.

• Backwards Compatibility: All existing Solidity tooling and contracts work without modification.
• State Access Pruning: Analyze dependencies to schedule non-conflicting transactions concurrently.
• Horizontal Scaling: Throughput scales with cores, not clock speed.

Eliminate the interpretive overhead by using Berkeley Packet Filter (BPF) as a lightweight, deterministic runtime. Programs are compiled to native instructions ahead of time.

• Minimal Runtime: BPF is a register-based, single-pass verifier, not a full VM.
• Hardware-Like Pricing: Compute units map directly to CPU cycles, creating predictable, low-cost execution.
• Consequence: Requires a new toolchain and forfeits EVM network effects for raw performance.

Decouple execution from consensus and settlement. Deploy ephemeral, app-specific rollups that spin up optimized VMs only when needed, then settle to a base layer.

• Flexible VMs: Choose WASM, EVM, or a custom VM per application cycle.
• Cost Amortization: Pay for heavy compute only during peak demand, not 24/7.
• Shared Security: Leverage restaked ETH or a base layer for security, freeing capital for execution.

The future is a multi-VM landscape. High-frequency apps will migrate to parallel EVMs for compatibility or app-specific chains for maximum performance. The general-purpose L1 becomes a settlement and liquidity hub, not a compute platform.

• Action: Audit your stack for VM-bound operations.
• Benchmark: Model costs on an app-chain vs. a shared L2.
• Architect: Design for parallel execution from day one.