ethereum-optimism · stdevMac · Mar 31, 2025 · Mar 31, 2025 · Mar 31, 2025 · Mar 31, 2025
@@ -20,12 +20,12 @@ is_imported_content: 'false'
 
 # Node architecture
 
-This page reviews node architecture for  all nodes running on the Superchain network. All OP Mainnet nodes are composed of two core software services, the Rollup Node and the Execution Client.
+This page reviews node architecture for all nodes running on the Superchain network. All OP Mainnet nodes are composed of two core software services, the Rollup Node and the Execution Client.
 OP Mainnet also optionally supports a third component, Legacy Geth, that can serve stateful queries for blocks and transactions created before the [Bedrock Upgrade](https://web.archive.org/web/20230608050602/https://blog.oplabs.co/introducing-optimism-bedrock/).
 
 ## Node flow diagram
 The following diagram shows how the Rollup Node, Execution Client, and Legacy Geth components work together to form a complete node running on the Superchain network.
-This diagram uses the `op-node` and `op-geth` implementations of the Rollup Node and Execution Client respectively, but the same architecture generally applies to other implementations as well.
+This diagram uses the `op-node` implementation of the Rollup Node and shows the general architecture that applies to all execution client implementations.
 
 ![OP Mainnet node architecture diagram.](/img/guides/node-operators/node-arch.svg)
 
@@ -39,6 +39,16 @@ The Execution Client is responsible for executing the block payloads it receives
 The Execution Client exposes the standard JSON-RPC API that Ethereum developers are familiar with, and can be used to query blockchain data and submit transactions to the network.
 The Execution Client is largely analogous to an [execution client](https://ethereum.org/en/developers/docs/nodes-and-clients/#what-are-nodes-and-clients) in Ethereum.
 
+The OP Stack supports multiple execution client implementations:
+
+### op-geth
+
+`op-geth` is the original execution client for the OP Stack, based on the Go Ethereum (Geth) implementation. It has been modified to support the specific requirements of OP Stack chains.
+
+### Nethermind
+
+Nethermind is a high-performance execution client implementation written in C#. The Nethermind client has been adapted to support OP Stack chains, providing an alternative execution client option for node operators.
+
 ## Legacy Geth
 
 OP Mainnet underwent a large database migration as part of the [Bedrock Upgrade](https://web.archive.org/web/20230608050602/https://blog.oplabs.co/introducing-optimism-bedrock/) in 2023.
@@ -51,6 +61,6 @@ Legacy Geth is **not** required and is typically only necessary if you want to m
 
 ## Next steps
 
-*   To get your node up and running, start with the [run a node from docker](/operators/node-operators/tutorials/node-from-docker) or [build a node from source](/operators/node-operators/tutorials/node-from-source) tutorial.
+*   To get your node up and running, start with the [run a node from docker](/operators/node-operators/tutorials/node-from-docker) or [build a node from source](/operators/node-operators/tutorials/node-from-source) tutorial. These guides include instructions for both op-geth and Nethermind execution clients.
 *   If you've already got your node up and running, check out the [Node Metrics and Monitoring Guide](./management/metrics) to learn how to keep tabs on your node and make sure it keeps running smoothly.
 *   If you run into any problems, please visit the [Node Troubleshooting Guide](./management/troubleshooting) for help.
@@ -20,15 +20,36 @@ is_imported_content: 'false'
 import { Callout } from 'nextra/components'
 import { Tabs } from 'nextra/components'
 
-# Execution layer configuration options (op-geth)
+# Execution layer configuration options
 
 <Callout type="info">
-You can configure your node using the command line options below (also called flags). 
+You can configure your node using the command line options (also called flags). 
 There are also sub-commands, which can be used to invoke functionality such as the console or blockchain import/export.
 </Callout>
 
-This page list all configuration options for `op-geth`. `op-geth` implements the Execution-Layer, with minimal changes for a secure Ethereum-equivalent application environment. 
-The following are options from [v1.101308.0](https://github.com/ethereum-optimism/op-geth/releases/tag/v1.101308.0)
+<Tabs items={['op-geth', 'Nethermind']}>
+  <Tabs.Tab>
+    ## op-geth Configuration
+
+    This section lists all configuration options for `op-geth`. `op-geth` implements the Execution-Layer, with minimal changes for a secure Ethereum-equivalent application environment. 
+    The following are options from [v1.101308.0](https://github.com/ethereum-optimism/op-geth/releases/tag/v1.101308.0)
+  </Tabs.Tab>
+  <Tabs.Tab>
+    ## Nethermind Configuration
+
+    Nethermind provides a simpler configuration approach for OP Stack networks. To run Nethermind on an OP Stack network, you can use the `--network` flag followed by the network name:
+
+    ```bash
+    # For OP Mainnet
+    nethermind --network op-mainnet
+
+    # For OP Sepolia
+    nethermind --network op-sepolia
+    ```
+
+    For detailed Nethermind configuration options, please refer to the [Nethermind documentation](https://docs.nethermind.io/nethermind/ethereum-client/configuration).
+  </Tabs.Tab>
+</Tabs>
 
 Please note that the executable is still named `geth` to maintain a [minimal diff](https://op-geth.optimism.io/).
 

@@ -1004,10 +1004,24 @@ Sample success output:
 todo: add Sample success output
 ```
 
-## op-geth
+## Execution Clients
 
+The OP Stack supports multiple execution client implementations. Each client implements the Execution-Layer with minimal changes for a secure Ethereum-equivalent application environment.
 
-`op-geth` implements the Execution-Layer, with minimal changes for a secure Ethereum-equivalent application environment.
+<Tabs items={['op-geth', 'Nethermind']}>
+  <Tabs.Tab>
+    ### op-geth
+
+    `op-geth` is the original execution client for the OP Stack, based on the Go Ethereum (Geth) implementation.
+
+    The execution engine's RPC interface is identical to [the upstream Geth RPC interface](https://geth.ethereum.org/docs/interacting-with-geth/rpc). The responses are nearly identical too, except we also include the L1 gas usage and price information.
+  </Tabs.Tab>
+  <Tabs.Tab>
+    ### Nethermind
 
-The execution engine's RPC interface is identical to [the upstream Geth RPC interface](https://geth.ethereum.org/docs/interacting-with-geth/rpc). The responses are nearly identical too, except we also include the L1 gas usage and price information.
+    Nethermind is a high-performance execution client implementation written in C#. The Nethermind client has been adapted to support OP Stack chains, providing an alternative execution client option for node operators.
+
+    The execution engine's RPC interface is identical to [the upstream Nethermind RPC interface](https://docs.nethermind.io/interacting/json-rpc-server/). The responses are nearly identical too, except we also include the L1 gas usage and price information.
+  </Tabs.Tab>
+</Tabs>
 
@@ -25,33 +25,46 @@ import { Callout } from 'nextra/components'
 This page gives information on the off chain node software release information.
 
 <Callout type="info">
-  Our latest releases, notes, and changelogs can be found on GitHub. `op-node` releases can be found [here](https://github.com/ethereum-optimism/optimism/releases)
-  and `op-geth` releases can be found [here](https://github.com/ethereum-optimism/op-geth/releases).
+  Our latest releases, notes, and changelogs can be found on GitHub.
 </Callout>
 
-## Production releases
+## Components
 
-Chain and node operators should always run the latest production releases of the OP Stack's off-chain components. Production releases are always tags, versioned as `<component-name>/v<semver>`. For example, an `op-node` release might be versioned as `op-node/v1.7.5`. Tags of the form `v<semver>`, such as `v1.7.6`, indicate releases of all Go code only and DO NOT include smart contracts. This naming scheme is required by Golang. In the above list, these `v<semver>` releases contain all `op-*` components and exclude all `contracts-*` components.
+### Rollup Node (op-node)
 
-`op-geth` embeds upstream geth's version inside its own version as follows: `vMAJOR.GETH_MAJOR GETH_MINOR GETH_PATCH.PATCH`. Basically, geth's version is our minor version. For example, if geth is at `v1.12.0`, the corresponding `op-geth` version would be `v1.101200.0`. Note that we pad out to three characters for the geth minor version and two characters for the geth patch version. Since we cannot left-pad with zeroes, the geth major version is not padded.
+The rollup node (`op-node`) coordinates the execution of the OP Stack chain. Chain operators should always run the latest production release.
 
-### Docker images
+- **GitHub Releases**: [optimism/releases](https://github.com/ethereum-optimism/optimism/releases)
+- **Docker Images**: [ethereumoptimism/op-node](https://hub.docker.com/r/ethereumoptimism/op-node/tags)
+- **Version Format**: `v<semver>` (e.g., `v1.9.1`)
 
-To make it easier to find and use our Docker images, each release entry below provides links to the corresponding Docker images:
+### Execution Clients
 
-*   **op-node**: Docker images can be found [here](https://hub.docker.com/r/ethereumoptimism/op-node/tags).
-*   **op-geth**: Docker images can be found [here](https://hub.docker.com/r/ethereumoptimism/op-geth/tags).
+The execution client processes transactions and maintains the state of the chain. The OP Stack supports multiple execution client implementations:
 
-### Example Docker image tags
+#### op-geth
 
-We follow a consistent tagging convention to make it easier to find the right image. Here are some examples:
+- **GitHub Releases**: [op-geth/releases](https://github.com/ethereum-optimism/op-geth/releases)
+- **Docker Images**: [ethereumoptimism/op-geth](https://hub.docker.com/r/ethereumoptimism/op-geth/tags)
+- **Version Format**: `vMAJOR.GETH_MAJOR GETH_MINOR GETH_PATCH.PATCH`
+  - Example: For Geth v1.12.0, the op-geth version would be `v1.101200.0`
+  - The version includes three characters for minor version and two for patch
 
-*   `optimism/op-node:<version>`
-*   `optimism/op-geth:<version>`
+#### Nethermind
 
-## Release entries
+- **GitHub Releases**: [nethermind/releases](https://github.com/NethermindEth/nethermind/releases)
+- **Docker Images**: [nethermind/nethermind](https://hub.docker.com/r/nethermind/nethermind/tags)
+- **Version Format**: `MAJOR.MINOR.PATCH`
+  - Example: For Nethermind 1.31.6, the version would be `1.31.6`
+  - Follows standard semantic versioning with MAJOR.MINOR.PATCH format
 
-| Network    | op-node                                                                     | op-geth                                                                              |
-| ---------- | --------------------------------------------------------------------------- | ------------------------------------------------------------------------------------ |
-| OP Mainnet | [v1.9.1](https://github.com/ethereum-optimism/optimism/releases/tag/v1.9.1) | [v1.101408.0](https://github.com/ethereum-optimism/op-geth/releases/tag/v1.101408.0) |
-| OP Sepolia | [v1.9.1](https://github.com/ethereum-optimism/optimism/releases/tag/v1.9.1) | [v1.101408.0](https://github.com/ethereum-optimism/op-geth/releases/tag/v1.101408.0) |
+## Current Network Versions
+
+| Network    | Component | Client    | Version     | Release |
+| ---------- | --------- | --------- | ----------- | ------- |
+| OP Mainnet | op-node   | -         | v1.9.1      | [Release Notes](https://github.com/ethereum-optimism/optimism/releases/tag/v1.9.1) |
+| OP Mainnet | -         | op-geth   | v1.101408.0 | [Release Notes](https://github.com/ethereum-optimism/op-geth/releases/tag/v1.101408.0) |
+| OP Mainnet | -         | Nethermind| v1.31.6     | [Release Notes](https://github.com/NethermindEth/nethermind/releases/tag/1.31.6) |
+| OP Sepolia | op-node   | -         | v1.9.1      | [Release Notes](https://github.com/ethereum-optimism/optimism/releases/tag/v1.9.1) |
+| OP Sepolia | -         | op-geth   | v1.101408.0 | [Release Notes](https://github.com/ethereum-optimism/op-geth/releases/tag/v1.101408.0) |
+| OP Sepolia | -         | Nethermind| v1.31.6     | [Release Notes](https://github.com/NethermindEth/nethermind/releases/tag/1.31.6) |
@@ -27,6 +27,10 @@ This tutorial will walk you through the process of using [`simple-optimism-node`
 `simple-optimism-node` also provides useful tools like a monitoring dashboard and health checking software.
 Although less flexible than [running a node from source](/operators/node-operators/tutorials/node-from-source) or building your own Docker setup, this is a great way to quickly get started with OP Mainnet.
 
+<Callout type="info">
+  By default, `simple-optimism-node` uses op-geth as the execution client. Support for Nethermind as an alternative execution client is also available.
+</Callout>
+
 ## What's included
 
 `simple-optimism-node` includes all the basic components to run an OP Mainnet or OP Sepolia node.
@@ -76,6 +80,11 @@ Configuration for `simple-optimism-node` is handled through environment variable
   *   `full` (Full node) - A Full node contains a few recent blocks without historical states.
   *   `archive` (Archive node) - An Archive node stores the complete history of the blockchain, including historical states.
 
+  **EXECUTION_CLIENT** - Choose which execution client to use:
+
+  *   `op-geth` - The original execution client for OP Stack (default if not specified)
+  *   `nethermind` - Alternative high-performance execution client written in C#
+
   **OP_NODE__RPC_ENDPOINT** - Specify the endpoint for the RPC of Layer 1 (e.g., Ethereum mainnet). For instance, you can use the free plan of Alchemy for the Ethereum mainnet.
 
   **OP_NODE__L1_BEACON** - Specify the beacon endpoint of Layer 1. You can use [QuickNode for the beacon endpoint](https://www.quicknode.com). For example: `https://xxx-xxx-xxx.quiknode.pro/db55a3908ba7e4e5756319ffd71ec270b09a7dce`.
@@ -104,6 +113,8 @@ The following command will start the node in the background.
 docker compose up -d --build
 ```
 
+The node will start with the execution client you specified in your `.env` file. If you didn't specify an execution client, op-geth will be used by default.
+
 ## Upgrade the node
 
 Pull the latest updates from GitHub, Docker Hub and rebuild the container.