A node is any computer or server that runs software to connect to the Ethereum network, including an execution client and consensus client. An Ethereum execution client is software that processes transactions, executes smart contracts, and maintains the blockchain’s current state. The consensus enables nodes to reach agreement using validated data from the execution client.
The Ethereum community maintains five major open-source execution clients: Nethermind, Geth (also known as Go-Ethereum), Reth, Besu, and Erigon.
Each one runs the same protocol, validates the same blocks, and serves the same JSON-RPC interface, but is built using different programming languages and different approaches. Ethereum maintains its decentralization in part due to the diverse set of clients.
Nethermind is the second-most popular execution client and the only major Ethereum execution client written in C# on the .NET runtime, enabling enterprise–grade speed and modular flexibility.
This article examines what an execution client does, what Nethermind is, and what separates Nethermind from the other five major clients, including how Nethermind utilizes zero-knowledge proofs.
What is an execution client?
An execution client is the software that processes transactions on Ethereum. It runs and maintains the blockchain state, validates new blocks, and serves data through JSON-RPC. Every Ethereum node operator runs one execution client paired with one consensus client. The consensus client handles the proof-of-stake consensus agreement algorithm, while the execution client handles all transaction logic.
The Ethereum community currently maintains and actively uses five core execution clients on the mainnet, with one in beta:
- Geth
- Nethermind
- Besu
- Erigon
- Reth
- EthereumJS (beta)
Each client varies in its programming language and data synchronization methods, including how it downloads, verifies, and updates to the latest blockchain data, as shown in this graph.
Geth is the most popular with a 36% market share, followed by Nethermind at 23%. The rest are further behind: Reth (13.9%), Besu (11.9%), and Erigon (4.5%).
Ethereum is decentralized in part by its client diversity. Client diversity reduces the risk of a single point of failure, as mentioned in the Ethereum documentation:
Multiple, independently developed and maintained clients exist because client diversity makes the network more resilient to attacks and bugs. Multiple clients are a strength unique to Ethereum – other blockchains rely on the infallibility of a single client.
Tomasz K. Stańczak, Founder of Nethermind, recently explained how AI agents need infrastructure that minimizes single points of failure, which is why Ethereum is a compelling choice for blockchain integration.
What is Nethermind?
Nethermind is an Ethereum execution client built in C# on the .NET runtime with an architecture that enables measurable performance gains over other clients.
Nethermind is the second-most popular execution client, with over 1,383 of 5,991 nodes using it.
Unlike most managed runtimes, a .NET runtime gives Nethermind access to low-level optimization tools normally associated with systems languages, enabling better, enterprise-grade performance.
In their open-source GigaGas benchmark, which reproduced identical Ethereum mainnet blocks across clients on the same hardware, Nethermind achieved a mean throughput of 697 million gas units per second (MGas/s), outperforming Geth, Besu, and Reth.
During stress tests that merged 100 consecutive mainnet blocks, Nethermind maintained a 2x to 10x throughput advantage, while Reth saw roughly 2x performance degradation. Nethermind maxed out at 1.08 gigagas per second (GGas/s), while others maxed out at 0.3-0.33 GGas/s.
Other benchmarks include processing 165,000 transactions per second in maximum-throughput tests, processing over 1 GigaGas per second on Base mainnet, and syncing to the chain tip in under 20 minutes.
Its default snapshot sync mode (generating state from relatively recent block and syncs from there to the head of the chain) syncs data 10x faster than a traditional fast sync (generating state by executing every block since genesis). A snapshot sync on Nethermind is the fastest among syncs on other execution clients.
Nethermind uses C# and .NET features that enhance performance and close any gaps with systems that use languages such as Rust or Go, for critical EVM features, such as:
- NativeAOT compilation Managed runtimes normally translate code into machine instructions while the program runs, which adds a delay. Nethermind uses a fork of NativeAOT, a .NET deployment model that compiles the entire C# codebase ahead of time into a standalone machine-code binary.
- Hardware intrinsics for accelerated bitwise operations. Bitwise operations are the low-level math that the EVM constantly performs on raw data bits, such as AND, OR, XOR, and shifts. Modern CPUs include specialized SIMD instructions that perform these operations on many bits in parallel rather than one at a time. Nethermind uses the .NET hardware intrinsics API across the client to call these CPU instructions directly, which makes heavy bitwise workloads run several times faster than they would in plain code.
Nethermind vs. other clients
Though clients operate similarly at a high level, they can choose to add unique features.
Compared to other clients, Nethermind differs in runtime, operator tooling, and extensibility model, prioritizing execution performance and operator experience.
Nethermind is the only major execution client built on .NET, while Geth and Erigon use Go, Besu uses Java, and Reth uses Rust. As mentioned earlier, the .NET runtime gives Nethermind direct access to a large enterprise development ecosystem and the C# language, which enables better performance. However, it does present engineering challenges that no other client faces, such as making .NET work in specialized environments like zkVMs.
Nethermind is the only execution client to launch a native browser interface for monitoring node-related data, including sync status and execution logs. Operators of other clients must set up and host their third-party data tools for similar data views.
Nethermind supports custom plugins, allowing node operators to extend the client with new features.
For example, a JSON-RPC handler plugin adds a custom RPC method that returns any data that the operator chooses to a production Nethermind node. In this case, operators can expose business-specific queries, custom analytics, or proprietary node behaviors directly from Nethermind without maintaining a fork, rebuilding from source, or running a separate service in front of the node.
Using zero-knowledge proofs in execution clients
Nethermind is the only execution client that extends a production client to use zero-knowledge proofs, enabling a validator to verify the correctness of an Ethereum block by checking a single cryptographic proof rather than re-executing all transactions.
In other words, it aims for the execution client to compile to a zkVM, an Ethereum virtual machine that executes smart contracts in a way compatible with zero-knowledge proof computation.
The Nethermind team describes the shift as moving from redoing every calculation by hand to instantly verifying the result with a mathematical guarantee, which results in faster, cheaper, and more trustworthy block verification across Ethereum.
Direct examples include:
- rollups achieving faster finality
- sequencers no longer needing to trust their hardware
Five milestones on the path to full ZK readiness are already complete:
- Execution Witness is a compact data file that the client produces for any block, containing every piece of state that block touched. With the witness, any computer can replay the block and arrive at the exact same result, without needing a copy of the full Ethereum state.
- Stateless Executor is a command-line tool that takes a block and its witness file and replays the block from scratch, without touching disk or network. It demonstrates that witness-based execution works in practice and is foundational to other technical upgrades for zk readiness.
- Minimal EVM Binary is a stripped-down version of Nethermind’s EVM that contains only the code needed to process a block from a witness. Networking, peer discovery, consensus logic, and every other runtime feature that a zkVM does not need have been removed. The smaller the binary, the cheaper and faster it is to prove inside a zkVM.
- RISC-V64 Compilation rebuilds the Nethermind client to run on RISC-V64, the instruction set used by most zkVMs. The result is a fully static, zkVM-friendly binary that runs at native speed through .NET’s NativeAOT compiler. The team also added soft-float support so the client works on zkVMs that lack hardware floating-point math, and extended beyond .NET’s minimal “Zero” library to a broader set of standard classes so real workloads function. For sequencers, this means execution speed will not be a bottleneck during proof generation.
- Zisk Integration connects the minimal EVM binary to Zisk, a zkVM built on RISC-V64, through custom linker scripts that wire the binary into Zisk’s entry points and memory layout. As of April 2026, Nethermind is running real Ethereum mainnet blocks through Zisk with execution and validation confirmed. The next step is producing the first end-to-end zero-knowledge proof of an Ethereum block from a production execution client.
Two milestones remain on the roadmap. RISC0 and SP1 integration will add adapters so Nethermind’s witness and executor outputs plug directly into the two most widely used zkVM proving systems in the industry.
Broader RISC-V compatibility will keep Nethermind aligned with whichever RISC-V targets dominate production zkVMs in the future, with the long-term goal of supporting any zkVM that emerges, including custom instruction sets.
Conclusion
The Ethereum community has five main execution clients, but Nethermind stands out, especially for teams seeking enterprise-grade performance and continuous technical advancements.
As the second most-popular Ethereum execution client, it has a reputation within the Ethereum community for its stellar performance, operator tooling, and customization.
It is the only major built on .NET and C#, meant to deliver performance that competes with systems languages like Rust and Go. This technical foundation is demonstrated by several critical benchmarks: Nethermind achieved a mean throughput of 697 million gas units per second, outperforming other execution clients like Geth, Besu, and Reth. In a 100-block stress test, Nethermind maintained a 2x to 10x throughput advantage.
The team also sets the standard for natively built tools compared to other execution clients. It is the only client that offers a native browser interface for monitoring data, allowing operators to view client status and logs without a third-party tool. It provides a custom plugin system that allows operators to develop custom tooling.
Most recently, Nethermind is leading the implementation of zero-knowledge proofs to verify Ethereum blocks instead of re-executing them. Using zk-proofs for Ethereum execution makes block verification faster, cheaper, and more trustworthy across Ethereum.
For teams prioritizing enterprise-grade performance, Nethermind is one of the strongest execution client choices.
Reliable Ethereum RPC infrastructure
Getting started with Ethereum on Chainstack is fast and straightforward. Developers can deploy a reliable Ethereum node within seconds through an intuitive Console — no complex setup or hardware management required.
Chainstack provides low-latency Ethereum RPC access, ensuring seamless connectivity for building, testing, and scaling DeFi, analytics, and trading applications. With Ethereum low-latency endpoints powered by global infrastructure, you can achieve lightning-fast response times and consistent performance across regions.
Start for free, connect your app to a reliable Ethereum RPC endpoint, and experience how easy it is to build and scale on Ethereum with Chainstack – one of the best RPC providers.
FAQ
An execution client is the software that processes transactions on Ethereum, maintains the blockchain state, validates new blocks, and serves data via JSON-RPC. Every Ethereum node operator runs one execution client paired with one consensus client.
The Ethereum community currently maintains and actively uses five core execution clients on the mainnet: Geth, Nethermind, Besu, Erigon, and Reth. EthereumJS is in beta.
Client diversity reduces the risk of a single point of failure and makes the network more resilient to attacks and bugs. Multiple, independently developed and maintained clients are a strength unique to Ethereum.
Nethermind is built in C# on the .NET runtime. It is the only major Ethereum execution client written in C# on the .NET runtime.
Yes. In Nethermind’s open-source GigaGas benchmark, which reproduced identical Ethereum mainnet blocks across clients on the same hardware, Nethermind outperformed Geth, Besu, and Reth and maintained a 2x to 10x throughput advantage under stress tests.
Nethermind is the only execution client that extends a production client to use zero-knowledge proofs. As of April 2026, Nethermind is running real Ethereum mainnet blocks through Zisk, with execution and validation confirmed; the next step is to produce the first end-to-end zero-knowledge proof of an Ethereum block from a production execution client.
Yes. Nethermind supports custom plugins, allowing node operators to extend the client with new features, including custom JSON-RPC methods, without maintaining a fork, rebuilding from source, or running a separate service in front of the node.
Nethermind supports the Ethereum mainnet and Ethereum-compatible chains.