.svg){kind=icon}
Now hiring!
•
•
.png)
TL;DR:
Zero-knowledge proofs have moved from the research lab to a production necessity. For Ethereum-compatible chains and L2 sequencers, they represent the next chapter of performance, modularity, and trustless verification. Nethermind Client already powers major production networks with industry-leading sync speed and stability. Now we are extending that proven foundation into ZK readiness, milestone by milestone.
With ZK proofs, validators no longer need to re-execute thousands of transactions. A small cryptographic proof is enough to confirm correctness. It is like moving from redoing every calculation by hand to instantly verifying the result with a mathematical guarantee.
Ethereum’s roadmap doubles down on this direction. Rollups gain faster finality, ironclad security guarantees, and no compromise on throughput. Node operators and sequencers can provide mathematical proof of correctness without relying on hardware trust.
For Nethermind, this is the natural evolution of our infrastructure, extending the reliability that powers major networks into the zero-knowledge future, one concrete milestone at a time.
When we say Nethermind is working toward being ZK-ready, we mean that our execution logic can compile into zkVMs such as Zisk, SP1, or RISC0 and from there generate proofs of execution. This ensures that the same engine processing Ethereum blocks today can also produce cryptographic proofs that blocks were executed correctly, without relying on trust in the operator’s hardware or database.
This ZK readiness builds on Nethermind's track record as a production-proven execution client. Our client has demonstrated reliability under real-world conditions across multiple L2s and infrastructure providers. ZK capabilities are the natural next chapter in that story of dependable infrastructure.
Nethermind’s current readiness at the time of publishing is best described as foundational work completed, final proving steps underway. Much of the engineering groundwork is done, and what remains are focused milestones to reach end-to-end proof generation.
What does this mean practically? If you're running a sequencer, your client is actively preparing for where the ecosystem is headed. And for teams building Ethereum-compatible chains, you can adopt infrastructure that grows with the protocol rather than scrambling to catch up later.
One of the biggest hurdles in this journey has been language and performance. Nethermind runs in .NET and C#, so making it work inside zkVMs required significant engineering effort. Compiling to RISC-V meant solving challenges in the .NET runtime, the custom C# compiler, and the surrounding toolchain.
That effort has already paid offWe added support for RISC-V64 with soft-float to ensure compatibility with zkVMs that do not provide hardware floating point support, patched Alpine Linux packages for compatibility, and confirmed execution through NativeAOT.
These are not shortcuts or experiments. They are concrete steps that prove Nethermind's architecture can operate inside a zkVM without sacrificing performance.
We are progressing milestone by milestone:
We introduced support for generating an Execution Witness, which captures all state accessed during block execution, including contract bytecode, storage slots, hashed keys, and block headers. Using this witness, blocks can be re-executed deterministically without access to the complete Ethereum state. Built on the same client that benchmarks fastest sync and throughput among Ethereum clients, the witness extends that performance story into the ZK world.
The feature is live in our feature branch, along with sample witness files for testing. For now, the witness is built for correctness and completeness rather than efficiency, but it lays the foundation for stateless validation.
On top of the Execution Witness, we built a Stateless Executor. This CLI tool replays blocks using only the witness file, without touching disk or network. It confirms that the witness contains everything needed for block validation. The executor lives in our feature branch and has already been tested to replay blocks successfully. This confirms that witness-based execution works in practice and gives us a solid foundation for the next step, generating zk proofs from these replays.
Example usage:
.svg)
.svg)
.svg)
.svg)
.svg)
.svg){kind=icon}
.svg)
.svg)
.svg)
.svg)
.svg)
.svg)
.svg)
.svg)
dotnet run --project tools/StatelessExecution -- --block path/to/block.json --witness path/to/witness.json
Constraints: At this stage, the executor is aimed at controlled replay and testing, not production workloads, but it demonstrates that stateless execution is possible today.
We created a Minimal EVM Binary designed to run Ethereum block processing with only the execution witness as input. This binary strips away everything non-essential — no networking, no consensus, no extra runtime features, leaving a lean target that is more efficient to prove inside a zkVM.
Repository:
.png)
To make Nethermind Client compatible with zkVM targets, we compiled it to RISC-V64. This was not straightforward: when we started, .NET did not fully support RISC-V64, so our team had to apply a series of fixes to both .NET and the custom C# compiler.
Performance is native on RISC-V64 thanks to the optimized NativeAOT compiler. For sequencers, this means execution speed will not be a bottleneck when relying on Nethermind for proof generation. We experimented with the "Zero" library for the smallest footprint, but its limitations required us to support a broader set of .NET standard classes. The result is still a compact, fully statically linked, zkVM-friendly binary that balances minimalism with practical support for real-world workloads.
Another challenge was ensuring compatibility with the musl standard library, which required additional patches. Since zkVM proving requires fully static binaries, this step was crucial. We also had to rebuild Alpine Linux packages without hard floating point support, which meant carefully patching out many modules, including parts of the C runtime.
The result is a fully static RISC-V64 binary, a key step toward generating proofs for Ethereum execution.
Repositories:
The next step is integrating Nethermind's minimal binary with Zisk, a zkVM environment built on RISC-V64. Zisk comes with its own input/output interface and requires custom linker scripts, so part of the work is making sure those scripts cooperate cleanly with both libc and Zisk's entrypoints and memory layout.
This integration will allow us to generate the first succinct proofs of block execution directly from Nethermind Client. We are close to that milestone, though some groundwork remains — including building a .NET runtime stripped of compressed and floating point instructions. There is no precise timeline yet, but once these steps are complete, we will be able to run and prove small blocks in Zisk.
Nethermind’s systematic, milestone-based approach shows steady progress toward ZK integration, with each step validated in production environments. This gives sequencers and Ethereum-compatible chains confidence that our roadmap is grounded in working code.
After completing RISC-V64 support, we plan to extend compilation to RISC-V32. Since the two architectures are similar, most of the groundwork is already in place on the .NET side. The main challenge will be re-creating the infrastructure: building an Alpine Linux rootfs for riscv32, upgrading and reusing .NET patches from earlier feasibility research work, and handling packaging, which can be difficult without direct upstream support.
This track is about broadening compatibility with zkVMs that rely on 32-bit environments.
A key next step is integration with RISC0 and SP1, two widely used zkVMs. This work will focus on building adapters so that Nethermind’s witness and executor output can connect cleanly with their proving systems.
While these are important milestones, they are not the end of the roadmap. Our long-term goal is to support any zkVM that emerges, across both riscv64 and riscv32, and potentially even custom instruction sets.
Nethermind’s work brings together proven sync and throughput benchmarks with a clear ZK roadmap. These milestones show steady engineering progress, not just isolated experiments. We now have witness data, an executor that proves it works in practice, compilation into RISC-V, and planned integration with multiple zkVMs. This stack demonstrates that Nethermind is not only solving the hard problems but also turning them into production-ready capabilities.
Reliability has always been our strongest signal to the market. Nethermind is already trusted by major validators and infrastructure providers, with sync speeds and throughput benchmarks that consistently outperform alternatives. Our client regularly processes millions of transactions daily across production networks, demonstrating the stability that ZK systems demand. ZK readiness builds directly on Nethermind’s existing performance, carrying that reliability forward into proof systems.
Ready to future-proof your infrastructure with ZK-ready execution? Here's how to get started:
Zero-knowledge readiness is not a single feature. It is a journey, and this blog shows how far along that journey Nethermind already is. We are extending a client that has proven itself across Ethereum mainnet and multiple L2s, making it compatible with the future of the protocol.
For sequencers and Ethereum-compatible chains, Nethermind builds directly on proven performance and reliability and carries that same stability forward into proof systems.
Nethermind delivers performance and stability in production today, with ZK readiness built into the roadmap. Adopting Nethermind means future-proofing your infrastructure while scaling with confidence.
.svg)
Building blocks for the decentralized future
Nethermind © 2025
.png)
.png)
