Geth (Go Ethereum): the Ethereum execution client

What is Go Ethereum (Geth)?

Geth (Go Ethereum) is the Go-language implementation of the Ethereum protocol's execution layer, published as both a library and a set of CLI executables in the ethereum/go-ethereum repository. The main binary, geth, runs as a full, archive, or light node and talks to your code over JSON-RPC exposed on HTTP, WebSocket, or IPC transports.

Geth executables and what each one does

• ✓geth — the main CLI client; runs full (default), archive, or light node modes and exposes JSON-RPC over HTTP, WebSocket, or IPC.
• ✓abigen — turns a contract's ABI (and bytecode, if you have it) into a type-safe Go package, so you call contract methods like normal Go functions instead of hand-rolling ABI encoding.
• ✓evm — a standalone EVM you feed raw bytecode to for opcode-level debugging, e.g. `evm --code 60ff60ff --debug run`.
• ✓devp2p — pokes at the networking layer directly, without spinning up a full blockchain.
• ✓rlpdump — decodes Ethereum's RLP wire format into something you can actually read, e.g. `rlpdump --hex CE01...`.
• ✓Snap sync by default — `geth console` downloads state without replaying the entire chain's history, which the README calls very CPU intensive to do the long way.
• ✓Built-in JS console (via `geth console` or `geth attach`) that speaks web3 methods plus geth's own management APIs.
• ✓Config via TOML file (`geth --config file.toml`) instead of long flag lists, with `dumpconfig` to export what you're already running.

When to run your own Geth node

• •Backing a dApp with your own RPC endpoint instead of trusting a third-party provider's view of chain state.
• •Generating type-safe Go bindings from a contract ABI with abigen, so a Go backend can call a smart contract without writing raw calldata by hand.
• •Debugging EVM bytecode in isolation with the evm tool before it's wrapped in a full transaction.
• •Running a private or dev-mode network to test contracts in CI via the Simulated Backend or Dev Mode, without touching mainnet or a testnet.
• •Joining the Holesky test network to try contract deployments with play-Ether before touching real funds.

Building Geth from source

Building from source needs Go 1.23 or later plus a C compiler. Prerequisites aren't detailed further in the README itself — it defers to the external Installation Instructions page. Once those are installed, `make geth` builds just the geth binary, or `make all` builds the full set of executables (devp2p, abigen, evm, rlpdump). Prebuilt binary archives for stable releases and the unstable master branch are published at https://geth.ethereum.org/downloads/. There's also an official Docker image, ethereum/client-go, with an alpine tag for a slimmer build.

Running a Geth node — mainnet, testnet, and Docker

`geth console` starts a full node on mainnet in snap-sync mode (the default) and drops you into the built-in JS console; leave off `console` and attach later with `geth attach`. Swap in `geth --holesky console` for the Holesky test network — it uses its own bootnodes, network ID, and genesis state, and nests its data under a `holesky` subfolder so it can't collide with your mainnet data dir. For RPC access from outside the container, the Docker quick start is `docker run -d --name ethereum-node -v /Users/alice/ethereum:/root -p 8545:8545 -p 30303:30303 ethereum/client-go` — remember `--http.addr 0.0.0.0` if you want other containers or hosts to reach the RPC port, since geth binds to localhost only by default. For a private network, the README is blunt that since the Merge you can't just spin up geth nodes without a beacon chain too; it points to the Simulated Backend, Dev Mode, or Kurtosis depending on what you're testing.

Other Ethereum execution clients

Frequently asked questions about Geth

The problem it solves

Talking to Ethereum from your own code means picking between two default paths: trust a third-party JSON-RPC provider's black-box node, or stand up your own — and standing up your own has historically meant hand-rolling ABI encoding for every contract call and picking a node implementation with a maintained toolchain around it. Geth (Go Ethereum) is Go's answer to the second half of that: it bundles the node, a JS console for manual poking, and abigen to generate typed Go bindings so contract calls stay compile-checked instead of stringly-typed JSON blobs.

Who should try it — and who should skip

Reach for Geth if you're building anything that needs its own authoritative view of chain state — a dApp backend, an indexer, or a Go program using abigen-generated contract bindings — and you're comfortable running Go tooling and managing a beacon chain pairing. Skip it if you just need occasional read calls to Ethereum; a hosted RPC provider gets you there in five minutes instead of a multi-hundred-gigabyte sync.

Related repositories