Ethereum clients

The single most common surprise for anybody running their first node: there is no such thing as “an Ethereum client” any more. Since the Merge a node is two processes that must both be running, both be synced, and be able to talk to each other.

The execution client

Holds the state, runs the EVM, keeps the transaction pool, and serves the JSON-RPC that your application calls. When somebody says “my node” and means an endpoint, this is the half they mean.

The consensus client

Follows the beacon chain, decides which block is the head, and tells the execution client what to execute. It serves the Beacon API, which is a different API on a different port and answers a different set of questions — validator duties, finality, attestations.

You can mix any execution client with any consensus client. That is the whole point of having a specified protocol between them, and it is what makes the diversity argument in why the client mix matters actionable rather than theoretical.

Five are in meaningful production use. They are written in five different languages by five different teams, which is not a coincidence or a waste — it is the mechanism by which a bug in one is not a bug in the others.

Geth — Go

The original and still the most deployed. Everything is tested against it first, every tool assumes it, and every unusual behaviour you find in another client will be compared to what Geth does. The safe boring choice, with the caveat that being the most deployed client is itself the risk.

Nethermind — C# / .NET

The most deployed alternative, with a large operator base and a strong plugin and metrics story. Frequently the first client people move to when they decide their Geth share is a liability.

Erigon — Go

A re-architecture rather than a fork in spirit: different database layout, staged sync, and dramatically smaller archive storage than the naive approach. If you want full historical state without a storage budget that looks like a mistake, this is the usual answer.

Reth — Rust

The newest of the five and the most modular — it is as much a library for building node-shaped things as it is a node. Its arrival is the most interesting thing to happen to execution-client diversity in years, and it is already serving public endpoints measured here.

Besu — Java

Apache-licensed and JVM-based, which is exactly why it turns up in enterprise and permissioned settings where those two properties are procurement requirements rather than preferences.

Six, again in five languages. If you are running a node to serve RPC rather than to validate, this half is infrastructure you keep alive rather than software you interact with — but it decides whether your execution client knows where the head is, which is to say whether your RPC answers are current at all.

• Lighthouse — Rust, by Sigma Prime.
• Prysm — Go, by Offchain Labs.
• Teku — Java, by Consensys.
• Nimbus — Nim, by Status; the one designed to be comfortable on small hardware.
• Lodestar — TypeScript, by ChainSafe; the one that makes the protocol legible to the JavaScript ecosystem.
• Grandine — Rust; the newest of the six.

Any of them will follow the chain for you. The practical differences for an RPC operator are resource footprint, how good the checkpoint-sync story is, and how the metrics look — all covered in running an Ethereum node.

Every endpoint measured here is asked web3_clientVersion on every cycle, because it is a cheap method worth measuring for its own sake. Its answers used to be validated and thrown away. You can ask any endpoint the same question in one line:

curl -s https://ethereum-rpc.publicnode.com \
  -H 'content-type: application/json' \
  -d '{"jsonrpc":"2.0","id":1,"method":"web3_clientVersion","params":[]}'

{"jsonrpc":"2.0","id":1,"result":"Geth/v1.17.1-stable-16783c16/linux-amd64/go1.25.7"}

Doing it continuously produces the one client census that counts the population a developer is actually standing in: not nodes on the peer-to-peer network, and not validators producing blocks, but the endpoints that answer application traffic.

The pattern worth noticing is the split. Some endpoints name a client and a version; others name their own service. The second group is not being evasive — for a gateway in front of a heterogeneous pool, “you are talking to us” is the only honest answer, and it is also the answer that tells you the node behind it is not something you get to depend on.