TL;DR
CuEVM is the first GPU-native, semantically complete Ethereum Virtual Machine (EVM) engine, capable of executing millions of independent transactions in parallel. By moving the entire execution and fuzzing loop onto the GPU, it achieves up to a 23× speedup over state-of-the-art CPU fuzzers and can process over 8 million ERC-20 transfers per second on a single commodity GPU.
What Problem Does This Paper Address?
The Ethereum Virtual Machine (EVM) is fundamentally sequential. Even when transactions are completely independent, they are processed one after another. This creates a massive throughput bottleneck for modern blockchain applications that require high-volume transaction processing, such as:
- Security Fuzzing: Testing thousands of mutated transaction sequences to find bugs.
- MEV (Maximal Extractable Value) Search: Simulating various transaction orderings to find the most profitable ones.
- Incident Response: Quickly searching for "rescue transactions" to front-run attackers after a vulnerability is discovered.
Previous attempts to use GPUs for EVM execution relied on "transpilation" (converting EVM bytecode to GPU-friendly assembly), which often broke compatibility with complex features like external calls or contract creation. These tools frequently had to "fall back" to a slow CPU, negating the benefits of the GPU.
Methods
The authors introduce CuEVM, which implements the full EVM specification natively on NVIDIA GPUs using CUDA. Key technical innovations include:
-
Columnar Data Layout: To maximize GPU memory bandwidth, CuEVM uses a "struct-of-arrays" approach. Instead of storing one contract's entire state together, it stores the same field (e.g., the "gas" value) for thousands of different contract instances in contiguous memory. This enables coalesced memory access, where a single memory request can fetch data for 32 threads at once.
Fig. 2: Columnar data layout for coalesced memory access -
GPU-Aware Scheduling: To prevent "warp divergence" (where different threads in a group try to execute different instructions), the host application groups transactions that target the same contract function into the same GPU warp.
- Optimistic Rollback: Instead of taking expensive snapshots of the world state before every call, CuEVM applies writes directly and records them in an "undo log." If a transaction fails (reverts), it simply replays the log in reverse—a much faster operation for the common case where transactions succeed.
- CuEVM-fuzz: A specialized fuzzer built on CuEVM that keeps the entire fuzzing loop—mutation, execution, and coverage tracking—on the GPU to minimize the overhead of moving data between the CPU and GPU.
Datasets
The researchers evaluated CuEVM using a mix of standard benchmarks and real-world data:
- Ethereum VMTests: The official suite used to verify EVM correctness.
- DeFi Workloads: ERC-20 transfers and Uniswap V3 swaps to measure raw throughput.
- LabeledDataset: 77 contracts with known CVEs (Integer Overflow and Reentrancy).
- EtherScan500: The 500 largest/most popular contracts from Etherscan.
- RecentContract & PopularContract: Over 23,000 real-world contracts from Ethereum and Binance Smart Chain (BSC) for large-scale vulnerability scanning.
Key Insights and Ideas
- Native is Better than Transpiled: By implementing the EVM spec directly on the GPU, CuEVM passes 100% of core functionality tests, whereas previous transpilation-based tools like MAU failed over 80% of them.
- Memory Layout is Everything: The shift to a columnar layout was the primary driver for performance. Without it, the engine's throughput drops significantly because the GPU spends more time waiting for memory than executing code.
- The "Shared-Nothing" Advantage: For tasks like fuzzing, each GPU thread can act as an isolated EVM instance with its own private clone of the world state. This eliminates the need for complex concurrency control (locking), allowing for massive parallelism.
- Fuzzing as a Data Processing Problem: By treating a batch of fuzzing seeds as a parallel data stream, the authors show that security testing can be scaled like a database query.
Key Results
- Raw Throughput: CuEVM achieves 8.3 million TPS for ERC-20 transfers and 441,000 TPS for complex Uniswap swaps.
- Fuzzing Speed: CuEVM-fuzz performs up to 1.1 million end-to-end executions per second, outperforming the CPU-based Medusa by 23× and the GPU-based MAU by 4.8×.
- Bug Detection: In a scan of 20,000 popular contracts, it identified 115 projects with high-risk bugs. It found 1.75× more integer overflows than the state-of-the-art Smartian fuzzer.
- Incident Response: In a simulated rescue mission for the Ronin Bridge exploit, CuEVM found a more optimal "rescue" transaction (extracting $9,000 more than the attacker) in just one second.
Limitations and Future Work
- Conflict-Free Focus: CuEVM is currently optimized for "conflict-free" workloads where transactions are independent. It does not yet handle parallel execution of transactions that modify the same state (though the authors suggest this is a complementary problem solved by other research).
- Memory Constraints: The number of parallel transactions is limited by GPU VRAM. Very complex contracts with deep call stacks or large memory requirements can cause contention in the dynamic memory allocator.
- Future Directions: The authors plan to explore multi-GPU setups to further scale throughput and integrate more advanced mutation strategies into the GPU-native fuzzer.
Summary updated