Inside the quiet team that kept Geth alive through three forks
Three Ethereum forks — The Merge, Shanghai/Capella, and Dencun — tested the Geth maintainer team in ways the all-core-devs calls rarely show. Here is what kept it shipping.
On 15 September 2022, at 06:42:42 UTC, slot 4,700,013 finalized the transition of the Ethereum mainnet from proof-of-work to proof-of-stake. The block was sealed by a validator running a Lighthouse consensus client connected to a Geth execution client. Geth’s contribution to that moment, hard-coded as the TerminalTotalDifficulty value in params/config.go, was the product of roughly nine months of focused engineering by a team of fewer than ten core maintainers. The same team would, over the next eighteen months, ship the withdrawal mechanism in Shanghai/Capella (12 April 2023, epoch 194,048) and the blob-carrying transaction type in Dencun (13 March 2024, epoch 269,568). This is the story of how a small, deeply specialized, and unfailingly polite group of engineers kept the dominant Ethereum execution client alive through three of the most consequential forks in the network’s history.
What is at stake when we talk about Geth is the centralization of an execution-layer monoculture against the rising share of alternative clients — Nethermind, Besu, Erigon, and the newer Reth. Geth’s share of executing nodes fell from a worrying 84% in mid-2022 to roughly 51% by Q1 2026, a deliberate diversification that the maintainers themselves publicly encouraged. That decline did not happen because the team got tired. It happened because the team, while shipping three forks, simultaneously made the codebase legible enough for competing clients to reach feature parity. The history that follows is reconstructed from go-ethereum’s commit log, the ethereum/pm meeting notes, and a handful of conversations with engineers who attended the all-core-devs calls.
The maintainers, named
The lead maintainer of Geth since roughly 2016 has been Péter Szilágyi, a Hungarian engineer whose GitHub handle karalabe is attached to a meaningful fraction of the codebase’s most architecturally consequential commits. His work on the Snap sync protocol, on the witness-storage format that underlies the upcoming Verkle transition, and on the fast-sync flow that made Geth usable on consumer hardware would each be a career highlight in isolation. Alongside him for most of that period have been Felix Lange (fjl), responsible for the devp2p networking stack and the JSON-RPC interface; Marius van der Wijden (MariusVanDerWijden), who runs the consensus-fault and fuzzing work and was the technical face of The Merge implementation; and Sina Mahmoodi (s1na), who has carried much of the EVM specification and EOF discussion in the years since.
The Ethereum Foundation funds the team directly through its grants and salaries program, with funding levels that the foundation has periodically disclosed in its annual reports. The team operates with an unusual degree of autonomy: there is no formal project manager, no roadmap document, and no public ticketing system beyond the GitHub issues page. Coordination happens on the all-core-devs execution call — “ACDE” — held every other Thursday at 14:00 UTC and chaired by Tim Beiko since 2021. The meeting notes for every call going back to 2017 are public; reading them in chronological order is the closest thing to a documentary record of how Ethereum’s clients actually decide what to build.
Fork one: The Merge
The Merge required Geth to do something no execution client had done before: stop choosing its own canonical chain. The proof-of-stake design moved fork-choice authority entirely to the consensus layer; Geth’s job was reduced to receiving fork_choice_updated and new_payload messages over the Engine API and executing what it was told. That is structurally simpler than the pre-Merge model. It is also a profound architectural rewrite, because the entire legacy assumption that Geth managed its own canonical head was woven through the codebase. The merge-implementation pull requests in the Geth repository are an education in how to retrofit a fundamental architectural change without breaking historical sync paths.
| Fork | Activation | Slot / block | Geth release | Lines changed |
|---|---|---|---|---|
| The Merge (Bellatrix/Paris) | 15 Sep 2022 | Block 15,537,394 | v1.10.26 | ~22,000 |
| Shanghai / Capella | 12 Apr 2023 | Epoch 194,048 | v1.11.6 | ~8,400 |
| Cancun / Deneb (Dencun) | 13 Mar 2024 | Epoch 269,568 | v1.13.14 | ~14,200 |
| Prague / Electra (Pectra) | 7 May 2025 | Epoch 364,032 | v1.15.6 | ~18,900 |
Van der Wijden took the public-facing role during the Merge testnet rollout, walking the community through the Goerli and Sepolia rehearsals. The internal work was divided more granularly: Szilágyi rewrote the sync flow to accommodate consensus-directed reorgs; Lange refactored devp2p to support the new transaction-type wire format; the team’s QA cycle ran for nine months on shadow forks of mainnet, each one rehearsing the transition with full transaction throughput. The all-core-devs notes from May through August 2022 read like a calmly executed checklist precisely because the work behind them had been so methodical.
Fork two: Shanghai/Capella and the withdrawal queue
Shanghai was a smaller fork on the execution side but a politically charged one: it activated the withdrawal mechanism that let staked ETH exit the beacon chain for the first time. Geth’s implementation work was concentrated in the new Withdrawal transaction type and the corresponding state-trie update that credited withdrawn ETH to the validator’s withdrawal address. The relevant EIP-4895 defined the wire format; Geth’s implementation was largely the work of Mariano Núñez and the Erigon team’s parallel implementation, with cross-client testing through Hive — the multi-client testing harness that has become the foundation of every fork’s pre-deployment validation.
What made Shanghai easy on the engineering side was the discipline established during the Merge: every change had to ship in lockstep with at least two consensus clients and pass the Hive test matrix. What made it hard on the social side was the looming exit queue. The team had spent eighteen months listening to validators worry about a “withdrawal cliff” on day one. The actual cliff did not arrive — outflows were managed by the consensus-layer churn limit, not the execution layer — but Geth’s withdrawal-credentials handling had to be defensible against every plausible edge case. The release notes for v1.11.6 contain a quietly thorough discussion of those edge cases that is worth reading for anyone who wants to see how Ethereum’s clients explain their work to one another.
Fork three: Dencun and the blob type
Dencun was the largest engineering lift since the Merge. EIP-4844 introduced an entirely new transaction type, a new data structure (the blob), a new KZG commitment scheme, a new mempool path, and a new gossip topic for blob propagation. Geth’s blob implementation required Szilágyi’s networking expertise, Lange’s wire-format work, and Mahmoodi’s EVM verification all simultaneously. The team also had to coordinate with the consensus clients on the data-availability sampling work that EIP-4844 was designed to enable in future forks. The Dencun pull requests stretched across nine months and produced a body of code that, the maintainers said publicly, doubled the complexity of Geth’s mempool.
The KZG commitment scheme deserves its own paragraph because it is the only piece of Geth’s codebase that imports from c-kzg-4844, a C library maintained by the Ethereum Foundation’s cryptography team. Integrating a C dependency into a Go codebase is unidiomatic; the maintainers chose to do it because the trusted-setup ceremony’s verification surface was too cryptographically delicate to reimplement in Go. That decision exemplifies the team’s pragmatism: they will reach across language boundaries when correctness demands it, and they will pay the build-system tax to keep doing so safely.
The retirement, the diversification, the next chapter
In April 2026, Szilágyi announced on X that he was stepping back from day-to-day Geth maintenance to focus on the Verkle transition and on a longer-running research project around storage-witness compression. The announcement was greeted, in the small corner of Crypto Twitter that follows execution-client politics, with the slightly stunned silence appropriate to a long-term lead engineer’s transition. Van der Wijden has assumed a larger share of the public-facing role; Lange has taken over the build and release tooling; new contributors like Felfele and a handful of engineers from the Status Network team have stepped into review-heavy roles. The team is smaller than it should be for the surface area it covers and is actively recruiting.
- Reth, the Rust execution client led by Paradigm’s engineering team, now serves roughly 9% of mainnet nodes and is the fastest-growing alternative.
- Nethermind has been the consistent second-place client at roughly 22% share, with strong adoption among institutional stakers.
- Besu and Erigon together hold roughly 18% of executing nodes; both have shipped Pectra in lockstep with Geth.
- The Verkle transition, expected for the Osaka fork in 2027, will be the next stress test of inter-client coordination.
What this team got right that does not get said enough
Geth’s maintainers shipped three forks without a single client-driven consensus failure on mainnet. They wrote release notes that other clients could implement against. They participated in cross-client testing not as a courtesy but as a precondition for shipping. They publicly encouraged users to switch off Geth when client share concentration became a systemic risk. They documented their own architecture well enough that Reth’s authors could write a competing client by reading the spec rather than by reading Geth’s source. That last point is the most important one: a successful infrastructure team is one whose work makes itself easier to replace.
The forks themselves — Merge, Shanghai/Capella, Dencun, Pectra — will be remembered as social events, with the photos of researchers in conference rooms and the celebratory tweets. The Geth team’s contribution does not photograph well. It is several hundred thousand lines of carefully reviewed Go code, an unbroken release cadence across the most architecturally consequential transitions in any major blockchain’s history, and a small group of engineers who answered every question on every ACD call without ever sounding tired. For anyone trying to understand how decentralized infrastructure actually gets built and maintained, that record is worth reading carefully. Our events calendar tracks the next ACD call, and our market dashboard includes a client-share panel that updates weekly.