Today we are proud to unveil ZKsync Airbender, a high-performance, general-purpose ZK prover designed to meet the real-world demands of interoperability, decentralization, and scalability without compromise.

Airbender isn’t just fast. It’s the fastest open-source RISC-V zkVM we have seen. In benchmark tests, Airbender outperforms other leading systems by wide margins. It has achieved:

• sub-second proofs for ZKsync blocks, and ~3 second proofs using a single commodity GPU

• ~4-6x faster speedup than the closest contender.

• the fastest proofs on a single H100 (21.8 million cycles per second for base layer, 8.5 million cycles per second end to end)

• the ability to prove Ethereum blocks on average in under 35 seconds using just a single (!) GPU (vs existing set ups that use 50-160 GPUs for proofs in 12 seconds, depending on the size of the blocks).

• Airbender can also prove Ethereum blocks in 17 seconds without recursion, which tells us that real-time proving on a single GPU is in the realm of possibility.

These performance gains are more than just numbers. They unlock a future where chains coordinate and settle in real time, developers can build client-side apps with local proof generation, and entire ecosystems benefit from faster, cheaper, and more decentralized infrastructure.

World’s fastest open-source RISC-V zkVM

Airbender is fast, and we’ve got the numbers to back it up.

We tested Airbender against two leading zkVM proving systems, RiscZero and SP1 (Turbo), using a standardized Fibonacci program to ensure apples-to-apples comparison. Benchmarks were run on both NVIDIA L4 and H100 GPUs, and we measured performance across two stages:

• Base Proving: the first round of proof generation

• STARK Recursion: followup rounds where base proofs are aggregated into one or a small number of final proofs.

Here’s how Airbender stacks up (the higher the MHz, the faster the system):

What these numbers show:

• Airbender is the fastest base layer prover on both powerful (H100) GPUs and smaller, economical (L4) GPUs. On H100 it achieves 21.8 MHz (millions of cycles proven per second), compared to 3.45 MHz for SP1 Turbo and 1.1 MHz for RiscZero.

• Airbender is the fastest end to end prover (including recursion): 2.5-4X faster than SP1 Turbo and 8.5-11X faster than RiscZero.

You can reproduce these benchmarks yourself here. These are early results—and we’re just getting started. There are likely to be even more improvements in the coming weeks.

Near Real-time Ethereum Proofs on a Single (!) GPU

By leveraging ZKsync Airbender and ZKsync OS (our new EVM execution environment), we were able to prove execution of an average Ethereum block in ~17 seconds using just a single H100 with ZKsync OS storage model before recursion and ~35 seconds end-to-end (with recursion). These benchmarks can be reproduced here.

That is a major breakthrough that paves the path for home-proving Ethereum.

Existing alternatives require massive hardware to achieve comparable results. For example, in Succinct’s Real Time Proving announcement, SP1 Hypercube took ~12 seconds to prove Ethereum blocks, but required 50-160 GPUs (Nvidia 4090s, roughly equivalent to H100).

Airbender achieves comparable performance with a fraction of the hardware. More efficient proving doesn’t just mean lower costs. It’s what enables the future we are building toward: a decentralized network of chains that coordinate, settle, and interoperate in real time.

It’s worth noting that SP1 used a different execution environment and storage model, so this isn’t an apples-to-apples comparison of zkVMs. But that’s exactly our point: our performance stems from the strength of the full system, from zkVM to engine to proving architecture. Airbender’s efficiency is a product of deep integration across the ZKsync stack. In the end, what matters isn’t just raw benchmarks, but what a system can actually do. ZKsync can deliver near real-time block proving with consumer-grade hardware. That’s the breakthrough.

Sub-Second Block Proofs for ZKsync Chains and Beyond

All new ZKsync Chains will use Airbender as a proof system moving forward, replacing the current Boojum prover. Chains like Abstract, Sophon, GRVT, Lens, and Memento will be able to migrate to Airbender and leverage its speed and efficiency. Airbender reduces proving costs to just $0.0001 per transfer, already more than 10x cheaper than Boojum, bringing meaningful savings and performance gains to apps across the Elastic Network.

Airbender isn’t just for ZKsync Chains. Its open-source design and RISC-V zkVM make it suitable for proving any type of program. It unlocks a broader future for general-purpose, verifiable applications. Its design supports proving on ordinary consumer hardware, opening the door for new use cases in gaming, identity, and decentralized AI. We’re continuing to improve the developer experience and will share updates soon at @ZKsyncDevs on X.

Test Airbender Yourself!

We’ve released a fun app to showcase Airbender’s capabilities. It’s designed to highlight what this kind of performance means in practice: from submitting tx to full block proof verification on a ZKsync OS testnet.

While Airbender is still in beta and not production-ready yet, developers can start building with Airbender today. We are actively working on improving the developer experience, and would welcome feedback from any devs who try it out.

Whether you’re building private chains, ZK-native apps, or cross-chain infrastructure, Airbender offers a flexible zkVM and proving system purpose-built for fast, native interoperability. Its performance also unlocks new application design patterns, where chains can communicate in near real-time, and developers can coordinate logic across networks with trustless, low-latency execution.

Technical Deep Dive

What is ZKsync Airbender?

Those benchmarks are exciting, but let’s take a step back. What is Airbender?

Airbender is ZKsync’s new zkVM and proving system, designed to generate ZK proofs of RISC-V bytecode execution. It was built alongside ZKsync OS, our modular operating system for ZKsync Chains which is tailored to support a wide range of execution environments, including EVM, EraVM, and WASM. Put simply, Airbender and ZKsync OS bring more performance and more customizability for teams building in the Elastic Network.

The core proving engine is based on AIR constraints compiled into highly optimized DEEP STARK proofs over a Mersenne31 prime field. The system supports custom machine configurations, precompiled circuits (e.g. Blake2s/Blake3, big-integer arithmetic), and recursive proving modes.

This architecture allows developers and protocol operators to optimize for different use cases: decentralization, cost-efficiency, or proof compression.

Proving Architecture

Airbender’s performance, including the breakthrough to proving chains with a single GPU, is made possible by a set of carefully engineered components.

The proving pipeline follows a five-stage structure optimized for both flexibility and throughput:

1. Witness Commitment: Computes low-degree extensions (LDEs) and trace commitments.

2. Lookup & Memory Argument: Validates memory operations using lookup tables.

3. STARK Quotient Polynomial: Encodes circuit constraints via AIR polynomials.

4. DEEP Polynomial Construction: implements FRI batching to reduce proof size.

5. FRI IOPP: Generates the final proximity proof.

Execution Model

Airbender implements the RISC-V 32I+M instruction set, operating in a standard fetch-decode-execute loop. Bytecode is loaded via ROM and processed in chunks of ~4 million cycles. Prover performance can be scaled horizontally by stitching chunks together via memory arguments.

The system supports Kernel Mode for ZKsync OS system-level logic.

Design Considerations

• Hybrid CPU/GPU: Airbender supports proving with a CPU, a single GPU, or multiple GPUs. For the latter options, the CPU performs the RISC-V simulation and tracing, and then the GPU computes witness generation and the rest of the steps.

• RAM-Backed Registers: All 32-bit registers are implemented in RAM, simplifying the circuit and deferring register management to memory lookups.

• Mersenne31 Field Arithmetic: Fast arithmetic operations optimized for STARK performance.

• Custom Precompiles: Supports cryptographic operations and big integer math through a CSRRW-opcode-based delegation mechanism.

Acknowledgements

Thank you to the many cryptographers and engineers that have helped push this industry forward. Special thanks to RiscZero for pioneering RISC-V zkVMs, Starkware for STARKs including Circle STARKs, and Polygon for the Mersenne31 Prime and work on the Circle Group. More detailed acknowledgements can be found in the Airbender repository.