# How to Choose Between Reth, Geth, and Nethermind as the Execution Client for Base

> Select the best execution client for your Base node from Reth Geth and Nethermind. Get optimal performance and features for your Ethereum node.

- Repository: [Base/node](https://github.com/base/node)
- Tags: comparison
- Published: 2026-03-03

---

**Choose Geth for the smallest footprint and widest compatibility, Reth if you need Flashblocks support for pending-state queries, or Nethermind if you require .NET-based telemetry and advanced configuration options.**

Base nodes run on the OP-Stack architecture, which requires two components: the **OP-Node** (consensus/rollup layer) and an **execution client** (EVM state storage and JSON-RPC). The `base/node` repository provides Docker configurations for three execution clients—Geth, Reth, and Nethermind—allowing operators to select based on hardware constraints, performance requirements, and specific feature needs like Flashblocks.

## Understanding the Base Node Architecture

A Base node consists of distinct services orchestrated via [`docker-compose.yml`](https://github.com/base/node/blob/main/docker-compose.yml). The execution client handles state storage, transaction execution, and RPC requests, while the OP-Node derives the L2 chain from L1 data. According to the repository's Docker configuration, the `CLIENT` environment variable determines which execution client image is built, defaulting to `geth` if unspecified【/cache/repos/github.com/base/node/main/docker-compose.yml†L4-L6】.

## Comparing Execution Clients for Base

### Geth (Go-Ethereum)

Geth is the default execution client in the `base/node` repository, located at `geth/Dockerfile`. It offers the smallest image size (~300 MB) and memory footprint (~2–4 GB for full sync), making it ideal for resource-constrained environments. Geth provides battle-tested stability and compatibility with OP-Node's `debug_geth` RPC mode, though it lacks native Flashblocks support.

**When to choose Geth:**
- You need the smallest disk and memory footprint.
- You prioritize the most mature, widely-documented client.
- You require ARM architecture support or Go ecosystem tooling.

### Reth (Rust Ethereum)

Reth is implemented in Rust and located at `reth/Dockerfile` with configuration details in [`reth/README.md`](https://github.com/base/node/blob/main/reth/README.md). It uniquely supports **Flashblocks** (pending-state RPC) via the `RETH_FB_WEBSOCKET_URL` environment variable, enabling sub-block latency queries critical for MEV and DeFi applications【/cache/repos/github.com/base/node/main/reth/README.md†L13-L17】. Reth offers slightly lower memory usage (~1.5–3 GB) and a "Vanilla" mode when Flashblocks is disabled.

**When to choose Reth:**
- You need Flashblocks support for pending transaction visibility.
- You prefer Rust-based performance characteristics and lower memory usage.
- You are building applications requiring fast state access or MEV extraction.

### Nethermind (.NET Ethereum)

Nethermind is located at `nethermind/Dockerfile` and built on the .NET stack. It provides the richest telemetry and metrics capabilities out-of-the-box, with extensive configuration options for advanced networking and consensus settings. However, it has the largest image size (~1 GB) and higher resource requirements (3–5 GB memory), making it suitable for infrastructure operators with robust hardware.

**When to choose Nethermind:**
- You require advanced .NET-based monitoring and metrics.
- You are operating in a Windows-centric or .NET ecosystem environment.
- You need specific consensus configuration knobs not available in Geth or Reth.

## How to Switch Between Execution Clients

The repository uses Docker Compose with environment variable substitution to select the client. The `CLIENT` variable defaults to `geth` but can be overridden to `reth` or `nethermind`【/cache/repos/github.com/base/node/main/docker-compose.yml†L4-L6】.

### Running with Geth

```bash

# Default behavior - no CLIENT variable needed

docker-compose up -d

# Or explicitly specify

CLIENT=geth docker-compose up -d

```

Ensure your environment file sets the correct engine kind:

```bash

# In .env.mainnet or your custom env file

OP_NODE_L2_ENGINE_KIND=geth
OP_NODE_L2_ENGINE_RPC=ws://execution:8551

```

### Running with Reth and Flashblocks

```bash

# Enable Flashblocks by setting the WebSocket URL

CLIENT=reth RETH_FB_WEBSOCKET_URL=wss://mainnet.flashblocks.base.org/ws \
  docker-compose up -d

```

If running without Flashblocks (Vanilla mode), simply omit the URL:

```bash
CLIENT=reth docker-compose up -d

```

Update the engine kind accordingly:

```bash
OP_NODE_L2_ENGINE_KIND=reth

```

### Running with Nethermind

```bash
CLIENT=nethermind OP_NODE_L2_ENGINE_KIND=nethermind \
  docker-compose up -d

```

## Performance and Resource Considerations

| Factor | Geth | Reth | Nethermind |
|--------|------|------|------------|
| **Image Size** | ~300 MB (smallest) | ~400 MB | ~1 GB (largest) |
| **Memory Usage** | 2–4 GB | 1.5–3 GB (lowest) | 3–5 GB |
| **Flashblocks Support** | No | Yes (built-in) | No |
| **Sync Speed** | Fast | Very fast | Moderate |
| **Architecture** | ARM64, x86_64 | x86_64 (Rust) | x86_64 (.NET) |

Geth provides the best balance of compatibility and resource efficiency for standard node operations. Reth offers superior performance for applications requiring low-latency state access, particularly when leveraging Flashblocks for pending transaction visibility. Nethermind suits enterprise environments requiring extensive metrics and .NET integration, provided hardware resources are available to accommodate its larger footprint.

## Summary

- **Geth** is the default, most mature option with the smallest image size (~300 MB) and broadest compatibility, ideal for general-purpose Base node operation.
- **Reth** provides unique **Flashblocks** support for sub-block latency queries and lower memory usage, making it optimal for MEV extraction and high-frequency DeFi applications.
- **Nethermind** offers advanced .NET-based telemetry and configuration options but requires significantly more resources (~1 GB image, 3–5 GB RAM), suitable for enterprise infrastructure.
- Switching clients requires setting the `CLIENT` environment variable (geth/reth/nethermind) and updating `OP_NODE_L2_ENGINE_KIND` in your environment configuration to match the selected client.

## Frequently Asked Questions

### What is the default execution client for Base nodes?

Geth is the default execution client in the `base/node` repository. If you run `docker-compose up -d` without specifying the `CLIENT` environment variable, the system automatically builds and runs the Geth client from `geth/Dockerfile`【/cache/repos/github.com/base/node/main/docker-compose.yml†L4-L6】.

### How do I enable Flashblocks when running Reth?

Set the `RETH_FB_WEBSOCKET_URL` environment variable to the Flashblocks WebSocket endpoint before starting the container. For Base mainnet, use `wss://mainnet.flashblocks.base.org/ws`. If this variable is unset, Reth runs in "Vanilla" mode without Flashblocks support【/cache/repos/github.com/base/node/main/reth/README.md†L13-L17】.

### Can I run Nethermind on ARM architecture?

No, Nethermind in the `base/node` repository is configured for x86_64 architecture only. The Dockerfile relies on the .NET runtime, which significantly increases image size (~1 GB) and memory requirements (3–5 GB). For ARM-based deployments, use Geth, which explicitly supports ARM64 architectures.

### Why does my node fail to start after switching clients?

You must update the `OP_NODE_L2_ENGINE_KIND` environment variable to match your selected execution client. The OP-Node uses this variable to determine the RPC dialect and engine API behavior. If you switch from Geth to Reth but leave `OP_NODE_L2_ENGINE_KIND=geth`, the OP-Node will fail to communicate with the execution layer【/cache/repos/github.com/base/node/main/.env.mainnet†L35-L38】.