> For the complete Linea documentation index, see [llms.txt](/llms.txt). > Agents can fetch this page as Markdown at [https://docs.linea.build/protocol/architecture/nodes.md](https://docs.linea.build/protocol/architecture/nodes.md). # Nodes Every [Lineth](/protocol/reference/zero-knowledge-glossary#lineth)**Lineth** (Formerly the Linea Stack) The open-source ZK-rollup stack, codebase, and technical protocol that's the foundation of Linea Mainnet. Operators can deploy this stack to launch their own Ethereum-compatible L2 or L3 networks. node runs a consensus client, [Maru](/protocol/reference/repos#maru), which orders blocks and propagates them to peers, and one or more execution clients, which execute transactions and maintain EVM state. Maru communicates with its execution clients over the standard Ethereum [Engine API](https://github.com/ethereum/execution-apis/blob/main/src/engine/common.md). Any node can also expose [JSON-RPC](/protocol/architecture/rpc-services) to serve applications, users, or internal services, either publicly or only within the operator's network. ## Consensus client: Maru [Maru](/protocol/reference/repos#maru) implements [QBFT](/protocol/reference/zero-knowledge-glossary#quorum-byzantine-fault-tolerance-qbft)**Quorum Byzantine Fault Tolerance (QBFT)** The Byzantine-fault-tolerant consensus algorithm that Maru implements to let a set of Maru validators produce and finalize blocks. A QBFT validator set requires at least `3f+1` validators to tolerate up to `f` faulty validators. consensus and runs on every node, in one of two roles: - **Maru validator:** Proposes and votes on blocks as part of the QBFT validator set. Maru requests a payload from its dedicated Linea Besu execution client, then signs and broadcasts the resulting block. - **Maru non-validator:** Receives blocks from peers and imports them into its execution clients, without proposing or voting. In both roles, Maru manages validator sets, provides P2P block propagation, and exposes API endpoints for monitoring and control. A single Maru consensus client can drive more than one execution client. Alongside the execution client it uses for block building or import, either Maru role can drive additional [follower execution clients](/protocol/reference/zero-knowledge-glossary#follower-execution-client)**Follower execution client** An execution client that a Maru consensus client drives through its `follower-engine-apis` configuration. A follower execution client imports and executes the blocks Maru gives it, but never proposes them, so it doesn't need sequencer plugins and can be any Ethereum execution client. It doesn't run its own Maru instance, and it may or may not serve JSON-RPC. Both Maru validators and Maru non-validators can drive follower execution clients., configured under [`follower-engine-apis`](/reference/component-configuration/linea-maru-options#maru). A follower execution client doesn't run its own Maru instance. For Maru TOML configuration keys, see the [Maru options](/reference/component-configuration/linea-maru-options). ## Execution client: Linea Besu Any Ethereum execution client that implements the Engine API can serve as a Lineth execution client and integrate with Maru, including Linea Besu, Besu, Geth, Erigon, and Nethermind. This promotes client diversity and compatibility with existing Ethereum node tooling and infrastructure. [Linea Besu](/protocol/reference/repos#linea-besu-upstream) is a distribution of [Besu](https://docs.besu-eth.org/) that bundles several Lineth-specific plugins with preset startup profiles. These plugins implement the protocol functions that a standard Ethereum client doesn't provide: trace generation for the [prover](/protocol/reference/zero-knowledge-glossary#prover)**Prover** The Lineth component that generates ZK proofs of state transitions, handling proof-generation requests from the coordinator and Linea Besu. The prover produces three types of proofs (execution, compression, and aggregation) and combines them into a zk-SNARK that the finalization layer verifies. Provers may be scaled horizontally to meet throughput requirements., Lineth block-building rules, [state manager](/protocol/reference/zero-knowledge-glossary#state-manager)**State manager** The Lineth component that maintains the network's state representation for proof generation and recovery. It consists of a Besu node with the Shomei plugin and a Shomei node that uses sparse Merkle trees to track state changes block by block, generate Merkle proofs for state transitions, and serve `linea_getProof` RPC requests. integration, and the `linea_` RPC namespace. Each Maru validator requires a dedicated Linea Besu execution client with [sequencer](/protocol/reference/zero-knowledge-glossary#sequencer)**Sequencer** The set of Linea Besu plugins responsible for ordering, building, and executing blocks in a way that allows the subsequent ZK proof to be made, including the tracer. The sequencer is a plugin set rather than a standalone process; a node that runs it alongside a Maru validator is a sequencer node. plugins. A Maru validator paired with such a client is a [sequencer node](/protocol/reference/zero-knowledge-glossary#sequencer-node)**Sequencer node** A node that pairs a Maru validator with a Linea Besu execution client running the sequencer plugins. This pairing is what produces canonical blocks: Maru handles consensus, and Linea Besu orders, builds, and executes the block. Some materials use "validator" and "sequencer" interchangeably. Here, the validator is the Maru process, the sequencer is the Linea Besu plugin set, and the sequencer node is the two together., and that pairing is what produces canonical blocks. During block building, the sequencer generates [traces](/protocol/reference/zero-knowledge-glossary#tracer)**Tracer** The Linea Besu plugin, part of the sequencer, that generates the execution traces the prover needs to create zero-knowledge proofs. The tracer provides trace counts for batch-size calculations and produces conflated trace files as prover input. to ensure blocks remain within prover limits. Execution clients that generate prover input traces must also use Linea Besu. Nodes that only import blocks or serve standard Ethereum JSON-RPC can run any Ethereum execution client. This makes the two layers separately configurable, but not symmetrically scalable. Because every validator needs its own Linea Besu, adding validators also means adding execution clients. Follower execution clients can be added independently, without adding more Maru nodes. For the full plugin set and its configuration, see the [Linea Besu plugin reference](/reference/component-configuration/linea-besu-plugin-options).