CuEVM: Scaling Smart Contract Execution on GPUs

Nhut-Minh Ho, Tien Tuan Anh Dinh, Quang Trung Ta, Fredrik Svantes, Xiaokui Xiao, Beng Chin OoiarXiv 2026 · arXiv

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.
Fig. 1: Overview of CuEVM

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

Abstract

Smart contracts on Ethereum blockchain process transactions worth billions of US dollars daily. They run on top of Ethereum Virtual Machine (EVM) which executes transactions sequentially. This execution model creates a performance bottleneck, especially for new blockchain workloads with large numbers of transactions, such as security testing. We present CuEVM, a GPU-native and semantically complete EVM execution engine that treats transaction execution as a massively parallel data processing problem. It employs novel data structures and GPU-aware scheduling to accelerate execution. Unlike prior works that transpile the contract and rely on a host CPU for many operations, CuEVM supports complete EVM semantics natively on the GPU. It passes 100% of the Ethereum VMTests and 96.2% of the full execution-test suite. On a single commodity GPU, CuEVM executes over 8 million ERC-20 transfers per second, outperforming existing baselines by up to two orders of magnitude. We build a smart contract fuzzer, called CuEVM-fuzz, on top of CuEVM. The fuzzer achieves over a million end-to-end executions per second, up to 23x and 4.8x higher than the state-of-the-art CPU-based and GPU-based baselines, respectively.
BibTeX
@misc{ho2026cuevm,
  author = {Nhut-Minh Ho and Tien Tuan Anh Dinh and Quang Trung Ta and Fredrik Svantes and Xiaokui Xiao and Beng Chin Ooi},
  title = {{CuEVM: Scaling Smart Contract Execution on GPUs}},
  year = {2026},
  eprint = {2611.14916},
  archivePrefix = {arXiv},
  url = {https://arxiv.org/abs/2611.14916},
}
Figure