Lesson 0 — Welcome to Inside Reth

Question

This course is one of three Intermediate courses (Revm / Reth / Alloy). Reth is the canonical Rust Ethereum full node; this course walks Staged Sync + ExEx + SDK — the three load-bearing internals.

Principle (minimum model)

3 Intermediate courses. Revm / Reth (this) / Alloy source reading. Take in any order; Reth depends on Revm + Alloy types.
Three topic chains. Staged Sync (10 pipelined stages) / ExEx (Execution Extension API for indexers and observers) / SDK (NodeBuilder + 6 components for custom L1s).
Each topic = buildup → walkthrough → quiz → drill. Plus a Rust lifetimes/Arc/dyn lesson + a Testing lesson + a what-comes-next lesson + final quiz.
Reading approach. Open paradigmxyz/reth in another tab; verify every claim against source.
Prerequisites. The Revm or Alloy source-reading course completed; intermediate Rust; light Ethereum primitives.

Worked example + steps

Welcome to Inside Reth — how this course works

This course is one of three independent Intermediate-tier source-reading courses:

Revm — inside the EVM engine (recommended first if you haven't done it)
Reth (you are here) — Staged Sync, ExEx, the Reth SDK
Alloy — Provider, Network, Signer

These three are independent, but several lessons here assume comfort with the Database trait and Revm execution model from the Revm course. If those concepts feel shaky, do the Revm course first.

📋 First time at the Intermediate tier? Read the lesson on how the source-reading courses work, at the end of the bridge course, before starting. It explains the editorial style (Predict prompts, Quiz gates, the build-up → walkthrough → quiz → drill chain shape) and pacing — applies to all three Intermediate courses, so you only read it once.

What this course teaches

You'll read the paradigmxyz/reth source line by line: the Stage trait and the 10-stage sync pipeline, ExEx (Execution Extensions) for in-process indexers / MEV / risk engines, and the Reth SDK for composing your own App-chain. Three topic chains, each with build-up + walkthrough + quiz + drill.

By the end, you'll have read enough Reth internals to ship a node-speed indexer or a custom App-chain.

Prerequisites

Revm internals (if you haven't done the Revm course):

The Database trait surface and how Revm reads state through it
How Stage and Database interact during ExecutionStage

Block-level Ethereum (covered in the bridge course):

Block structure (header / body / receipts), reorgs as a normal phenomenon
What sender recovery, transaction body decoding, and receipts contain

Intermediate Rust (also the bridge course; there's a Rust lesson on lifetimes, Box, Arc and dyn Trait inside this course for self-checking):

Generics with trait bounds, ?Sized, dyn Trait vs impl Trait
Arc<T>, Mutex<T>, RwLock<T> — when to use each
async / Future / Stream basics
auto_impl macros and procedural attributes

Shaky on Revm? Do the Revm course first. The Stage trait and the SDK both reference Revm types directly.

Setup — do this once

Before lesson 1, have these ready in another window:

paradigmxyz/reth cloned — git clone https://github.com/paradigmxyz/reth
bluealloy/revm cloned — git clone https://github.com/bluealloy/revm (cross-referenced during ExEx and SDK lessons)
A working cargo toolchain — rustc --version should print something modern
cargo-expand — cargo install cargo-expand (procedural macros across both repos)
A second monitor or split terminal — you'll be cross-referencing source while you read

The "Find in repo" prompts only work if you actually have the repos open. Close that loop before starting.

You're ready

Scroll back to the course detail and start with the lesson that builds the Stage trait.

After this course: head to the Alloy course if you haven't yet — or move on to Expert for the procedural-macro and zkVM-integration deep dives.

Summary (3 lines)

This course = one of three Intermediate courses. Three topic chains: Staged Sync + ExEx + SDK.
Each = buildup → walkthrough → quiz → drill. Plus Rust + Testing + Bridge lessons. Verify against paradigmxyz/reth source.
Prerequisites: the Revm or Alloy course + intermediate Rust.