.svg){kind=icon}
.svg)
.svg)
.svg)
.svg)
.svg)
.svg){kind=icon}
.svg)
.svg)
.svg)
.svg)
The Nethermind Client Team builds and maintains the Nethermind Ethereum execution client, supporting protocol upgrades and production-scale performance.
Now hiring!
•
.png)
Updated in April 2026
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 as of April 2026: foundational work complete, Zisk integration done, and mainnet blocks running through execution and validation. What remains is 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 off. We 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.
Building on the witness, we built a Stateless Executor, a CLI tool that replays blocks using only the witness file, without touching disk or network. 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:
dotnet run --project tools/StatelessExecution -- --block path/to/block.json --witness path/to/witness.json
Constraints: At this stage, the witness and the executor are 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:
Nethermind’s minimal binary is now integrated 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 gives sequencers and Ethereum-compatible chains confidence that our roadmap is grounded in working code.
Zisk integration is complete. Nethermind is now running mainnet blocks through the pipeline, with execution and validation confirmed. End-to-end proof generation is the active next step.
Nethermind’s zkVM path is built around RISC-V, the architecture used by most modern zkVMs. With RISC-V64 support complete, the focus is on maintaining compatibility with this standard and ensuring smooth integration across proving environments such as Zisk, RISC0, and SP1.
As the ecosystem evolves, Nethermind will align with the dominant RISC-V targets used in production zkVMs, prioritizing stability, performance, and compatibility over supporting multiple instruction set variants.
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 riscv64 and other zkVM environments, 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, RISC-V64 compilation, and Zisk integration complete with mainnet blocks running through execution and validation. 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 update reflects how much ground has been covered since this article was first published. 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.
This article was originally published September 2025 and updated April 2026 to reflect current milestone status.
The Leading Engineers of Blockchain Infrastructure
Nethermind © 2026
.svg)