# CuEVM: Scaling Smart Contract Execution on GPUs

Crypto.world

> GPU-native EVM passing the full VMTests makes mass contract fuzzing and replay practical on one commodity card, removing the CPU-emulation bottleneck for security tooling.

**arXiv**: 2611.14916

**Published**: 2026-11-11

**Authors**: Nhut-Minh Ho, Tien Tuan Anh Dinh, Quang Trung Ta, Fredrik Svantes, Xiaokui Xiao, Beng Chin Ooi

## AI summary

## Overview

- **Research area:** Blockchain systems and database-style execution engines — specifically GPU-accelerated execution of the Ethereum Virtual Machine (EVM), with smart-contract fuzzing as the driving workload. Published under arXiv category Distributed, Parallel, and Cluster Computing.
- **Technical level:** Advanced. The paper assumes familiarity with EVM semantics (opcodes, call contexts, world state, gas, rollbacks), CUDA execution/threading and memory-coalescing concepts, and coverage-guided fuzzing internals.
- **Scope (1 sentence):** The paper presents CuEVM, a GPU-native, semantically complete EVM engine that executes batches of independent transaction sequences in parallel across GPU threads, plus CuEVM-fuzz, a fuzzer built on top of it.

## What This Paper Is About

The EVM executes transactions one at a time, even when they are independent, which limits throughput for workloads that need to run enormous numbers of transactions — security testing (fuzzing), transaction simulation, MEV search, and block re-execution. Prior GPU work, MAU, transpiles contract bytecode to PTX and supports only a subset of EVM semantics, failing more than 80% of the official Ethereum tests and falling back to a sequential CPU reference EVM. The paper's goal is a semantically complete EVM that runs entirely on GPUs, with data structures and scheduling designed to hide GPU memory latency and minimize CPU–GPU data movement.

## Key Contributions

1. **CuEVM**, described as the first GPU-native EVM fully adhering to the EVM specification (Yellow Paper). It supports complete EVM semantics natively on the GPU — including all opcodes, sub-calls, precompiled contracts, contract creation, and rollbacks — and passes 100% of the Ethereum VMTests and 96.2% of the full execution-test suite. Code is released at https://github.com/sbip-sg/CuEVM.
2. **A columnar memory layout and GPU-aware transaction scheduler** that reduce memory-access latency and thread divergence: fixed-size call-context fields and dynamic-size structures are stored column-major across EVM instances so warps issue coalesced memory requests, and call depth is flattened into per-instance buffers with `base_ptr`/`offset`/`dyn_ptr`/`size` bookkeeping rather than materializing an N × depth × k tensor. Microbenchmarks report up to 8.3 million independent ERC-20 transfers per second.
3. **CuEVM-fuzz**, described as the first GPU-native fuzzer that migrates the entire fuzzing loop to GPUs (mutator, coverage tracker, and bug oracles resident on the device), reaching up to 1.1 million end-to-end fuzzing executions per second.
4. **An additional use case: attack imitation / rescue-transaction search**, where CuEVM supports efficient searching for transactions that could front-run an attacker after an on-chain incident is detected.

## Main Findings

- **Contract test compliance:** CuEVM passes 100% of the Ethereum VMTests and 96.2% of the full execution-test suite, in contrast to MAU, which the paper states fails more than 80% of the official Ethereum tests and must fall back to a host CPU reference EVM.
- **Raw execution throughput:** On a single commodity GPU, CuEVM executes over 8 million ERC-20 transfers per second (8.3 million in the contributions list), outperforming existing baselines by up to two orders of magnitude.
- **Fuzzing throughput:** CuEVM-fuzz achieves over a million end-to-end executions per second, measured at up to 1.1 million on an Nvidia RTX 5000 Ada — up to 23× higher than the state-of-the-art CPU-based baseline and 4.8× higher than the state-of-the-art GPU-based baseline.
- **Speed of CVE detection:** CuEVM-fuzz detects existing CVEs 300× faster than Smartian, a state-of-the-art fuzzer.
- **Bug-finding quality on a benchmark set:** On 500 large smart contracts collected from Etherscan, it identifies 1.75× more integer overflow bugs and 2× more leaking-ether bugs than Smartian, and 1.67× more reentrancy bugs than ItyFuzz.
- **Real-world deployment results:** In testing on 20,000 popular contracts on Ethereum and Binance Smart Chain, CuEVM-fuzz detects 115 projects with high-risk bugs. The introduction also refers to these as "115 recent real-world contracts."
- **Incident-response case study (Ronin Bridge):** The bridge was exploited for over 12 million USD in August 2024. Using CuEVM, researchers found transaction parameters within one second that could have extracted 9,000 USD more than the recorded transaction; the relevant `quantity` parameter sits at bytes 324–356 of the transaction data, bounded by the 4,000 ETH daily limit.
- **Design trade-off identified:** Because a warp executes one instruction at a time across 32 threads, control-flow divergence is the dominant performance risk, which is why CuEVM exposes a scheduling interface so the host can group similar transactions into the same warp. This is finer-grained than MAU's approach of forcing an entire kernel of thousands of threads to execute a single function.
- **Communication cost:** CuEVM exchanges data with the host only at batch boundaries — once per direction per iteration — instead of per transaction.

Note on scope of evidence: the provided paper content is truncated partway through Section VI (it ends inside the description of Algorithm 2). The detailed experimental setup of Section VII (hardware configuration beyond the RTX 5000 Ada mention, full baseline descriptions, ablation results, and per-benchmark tables) is therefore not reported in the available text.

## Methodology in Plain English

The core idea is to treat transaction execution as a large data-processing job rather than a sequence of one-off computations.

- **Partitioned batches:** The host application produces a batch of N transaction sequences, each of up to M transactions. Each sequence runs in its own isolated copy of the world state on its own GPU thread, so sequences never interfere and no concurrency control is needed. Execution then proceeds as M kernel launches; the j-th kernel applies the j-th transaction of every sequence in parallel.
- **Data layout for the GPU:** GPU threads are fastest when adjacent threads read adjacent memory. So instead of storing each EVM instance's stack, memory, gas, and program counter together, CuEVM stores the same field of all instances contiguously (a struct-of-arrays or column-major layout). Preallocated buffers of k elements per instance are used, with fallback to dynamic allocation if a structure outgrows them.
- **Handling nested calls without exploding memory:** EVM calls can nest up to depth 1024. Rather than allocating a full depth dimension, each per-instance buffer is shared by nested calls at different offsets; a child call starts where the parent's data ends, and the child's region is cleared on return.
- **Cheap rollbacks:** Instead of snapshotting the world state at every call, all writes go directly to one world state and are appended to an undo log. On a revert, the log is replayed in reverse — so the cost is paid only on the rare revert. Storage values are tracked as current value, original value, and warm/cold status, which is required for correct gas accounting.
- **Missing pieces implemented from scratch:** Since CUDA has no native 256-bit integers, the authors built a 256-bit arithmetic library adapted from the Cooperative Groups Big Numbers (CGBN) library, extended for thread-level parallelism and finite-field arithmetic. All precompiled contracts of the EVM Shanghai version are implemented by adapting existing libraries and the Go Ethereum reference implementation.
- **Fuzzing loop on the GPU:** A lightweight CPU controller picks a batch from the corpus and, per iteration, (1) selects the next batch, (2) runs it on the GPU, and (3) rebuilds the interesting sequences on the host rather than copying them back. On the device, each thread mutates its next transaction with a type-aware AFL-style mutator (guided by ABI argument types and byte offsets so mutations don't trigger trivial reverts), applies the EVM transition function, and reports feedback. A 2^16-word coverage map packs an 8-bit branch distance in the high bits and a 24-bit hit count in the low bits, and updates use CUDA atomics and atomic maximum rather than locks, so thousands of threads can report without colliding. Bug oracles append findings to buffers via an atomic index.

## Why This Matters

**Impact on research:** The paper argues that semantic completeness, not just speed, is a prerequisite for GPU EVM execution — MAU's need to fall back to a CPU reference EVM reintroduces exactly the sequential bottleneck GPUs were meant to remove. It also shows that classic data-systems techniques (columnar storage, undo logging, batched data movement between host and device) transfer productively to blockchain execution, and it turns a security-testing workload into a benchmark for parallel execution engines.

**Real-world applications (from the paper):**

- **Smart contract fuzzing and vulnerability discovery:** detecting integer overflow, ether-leaking, and reentrancy bugs, and finding high-risk bugs in live projects across Ethereum and Binance Smart Chain.
- **Incident response / rescue transactions:** when an exploit is detected on-chain, searching in seconds for a transaction that front-runs the attacker and rescues the assets — illustrated by the Ronin Bridge case.
- **MEV search:** exploring transaction orderings to find the ones with the most extractable value, using CuEVM's fast batched execution.
- **Faster block validation:** parallel clients re-executing blocks to validate optimistic schedules, where independent transactions in a block can be executed concurrently instead of sequentially.

**Industry relevance:** Smart contracts process transactions worth billions of dollars daily, and DeFi applications on Ethereum have over 150 billion USD in total locked value. The authors include a co-author from the Ethereum Foundation, and the code is publicly released, which lowers the barrier for node operators, security firms, and tooling vendors to adopt GPU-accelerated execution.

## Future Directions

- **Handling mutable shared state generally:** The paper presents the engine for N partitions with read-only shared state and explicitly defers the handling of mutable shared state to the fuzzing use case. Generalizing cross-partition mutable state to other workloads remains open.
- **Beyond conflict-free workloads:** CuEVM is designed for conflict-free workloads with snapshot isolation per sequence and, in the fuzzing setting, no cross-transaction conflicts within a batch. Extending it to workloads with genuine inter-transaction dependencies — such as fully general parallel block validation — would need a concurrency-control mechanism.
- **Application-specific transfer reduction and compression:** The authors note that further reductions in CPU–GPU traffic beyond batch-boundary exchange require application-specific optimization and compression, and present such techniques only for fuzzing.
- **Broadening the use-case library:** The paper names MEV search and attack imitation as use cases and describes them at a high level; developing and evaluating host-side schedulers and input generators for each of them is a natural next step, since each application must supply its own GPU-aware adaptor to emit warp-friendly batches.
- **Scaling limits and dynamic allocation:** Performance is bounded mainly by device memory, and structures that exceed the preallocated k elements fall back to dynamic allocation at higher cost — the trade-off between preallocation sizing and flexibility is a concrete engineering question the design leaves configurable.

## Target Audience

Blockchain infrastructure engineers and researchers building execution clients, parallel transaction processing systems, or high-throughput testing tools; security researchers and auditors who run large-scale smart contract fuzzing campaigns; GPU/CUDA systems researchers interested in data-processing-style layouts for irregular control-flow workloads; and data-systems researchers following the crossover between database execution techniques and blockchain execution. Readers need comfort with EVM internals and CUDA concepts to benefit fully; the security-testing results alone are accessible to a broader smart-contract security audience.

## Authors’ 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…

[The full abstract on arXiv](https://arxiv.org/abs/2611.14916)

[Read the original paper](https://arxiv.org/abs/2611.14916)

---

Canonical: https://crypto.world/paper/cuevm-scaling-smart-contract-execution-on-gpus-2611.14916
