Courses
Start with the concept framing, then choose a path: the flagship OpenHL buildout, the prerequisite Rust Ethereum sequence, optional stack deep-dives, or the advanced architect rail.
Start here before you choose a build path.
These two lessons are the framing layer from RethLab: the worldview and threat model that make the rest of the catalog easier to place.
The clearest route if you want to build a perp engine end to end: concept layer first, then the OpenHL implementation chain from devnet to ADL.
Follow in order: Primer → Devnet → CLOB → Precompiles → Funding → Liquidation → ADL
Perp DEX Primer — perpetual-futures mechanics
The conceptual layer the DIY Perp track silently assumes — perp mechanics in four lessons. No code, no openhl reference: spot/futures/perp distinction, funding as the anchoring mechanism, margin model with four states, three-tier safety net.
Build OpenHL — from cargo init to a single-validator devnet
Build the openhl track foundation: the Reth substrate. Genesis, NodeBuilder wiring, custom ChainSpec, and the first single-validator devnet your engine talks to. Production parallel: Hyperliquid HyperEVM.
Build OpenHL CLOB — adding the matching engine
Build the openhl matching engine in Rust — a central limit order book on top of the Reth substrate. Thirteen lessons across six modules including 9 hand-traced unit tests + 3 proptest invariants on 768 random scenarios.
Build OpenHL Precompiles — connecting CLOB state to smart contracts
Build the openhl precompile layer that bridges the CLOB matching engine to the EVM. Twelve lessons across six modules: custom EVM bootstrap, read precompile, write precompile (place_order), bridge integration, Capstone.
Build OpenHL Funding — perpetual funding state machine
Build the openhl funding state machine in Rust. Twelve lessons across five modules including three invariants proved (zero-sum / interval-gating / no-catch-up).
Build OpenHL Liquidation — perpetual position liquidation engine
Build openhl liquidation: margin model with four states, scanner emitting close orders, insurance fund absorbing deficit. Pinned to byte-for-byte answer keys.
Build OpenHL ADL — auto-deleveraging, Layer 3 of the safety-net cascade
Build openhl ADL: when the insurance fund is depleted, profitable counter-positions are force-closed by (pnl × leverage) rank to absorb the remaining deficit.
The on-ramp sequence for people new to Rust Ethereum: first the worldview, then the toolkit, then the source-reading bridge before the deeper courses.
Intro to Reth — Welcome to Rust Ethereum
The on-ramp to the Rust Ethereum stack (Reth / Revm / Alloy). Eleven lessons: reading Ethereum as systems engineering, the four adversarial forces, the three-pillar split, the Reth vs Geth substitution case, Rust setup, and a Beginner final quiz.
Reth Fundamentals — Your First Steps with Alloy
The first toolkit for Rust × Ethereum in 11 lessons — Rust ownership / Result / async, Alloy Address / U256 / Signer / Provider, EVM stack machine + 5 memory regions, Revm execution engine, Foundry toolchain.
Reading the Stack — Bridge to Intermediate
The bridge after Beginner and before the three Intermediate courses (Inside Revm / Inside Reth / Inside Alloy). Ten lessons: Solidity → bytecode translation, EVM execution traces, and the reading practice you need before the source-walks.
Optional but powerful source-level reads for engineers who want stronger intuition before or alongside the flagship implementation path.
Mastering Foundry — Solidity testing discipline for engineers who already think in Rust
Port the rethlab Rust discipline (proptest! / debug_assert! / conservation laws / byte-for-byte answer keys) to Solidity contracts. forge test / fuzz / invariant / cast / anvil in order, finishing with a Capstone that ports openhl-liquidation invariants.
Inside Alloy — Reading the Rust Ethereum Library
Walk the alloy-rs/core source line by line through three topic chains: Provider, Network (generic over N), Signer. Each topic = buildup → walkthrough → quiz → drill. By the end you can read any alloy source confidently.
Inside Revm — Reading the EVM Engine
Walk bluealloy/revm source through three topic chains: add opcode, custom opcodes (ship a fork), Database trait. Plus bonus lessons on Revm Testing, parallel execution (block-stm), and JIT/AOT via revmc.
Inside Reth — Sync, Extensions, and the SDK
Walk paradigmxyz/reth source through three topic chains: Staged Sync (Stage trait + 10-stage pipeline), ExEx (Execution Extension API + reorg handling), SDK (NodeBuilder + 6 components). By the end you can read any part of reth confidently.
The systems side of the stack: consensus, bridges, sequencing, validator operations, production engineering, and full application buildouts.
Validator Ops Bootcamp — Runbooks, Incidents, and Recovery
Hands-on validator operations lab with executable drills: SLO/SLI setup, incident detection, double-signer containment, and rollback recovery.
Consensus Economics & Slashing Lab
Economic safety layer for Rust L1 chains: reward design, slashing rules, attack scenarios, and parameter sensitivity.
Multi-Node Devnet to Testnet
Distributed readiness for Rust L1s: multi-validator topology, partition/rejoin drills, fork observation, and promotion gates.
Consensus Engineering — Building L1 Consensus on Reth
Build and read production L1 consensus. Twelve lessons across three modules: BFT fundamentals + three consensus families + Ethereum PoS + HotStuff/HyperBFT, reading Reth consensus code, building your own consensus driver.
Cross-Chain Bridges — From CCIP to Light Clients
Read every meaningful cross-chain trust model side by side. Bridge trilemma + five trust models, light clients as gold standard, production bridges (OP / CCIP / Wormhole / IBC), then build a minimal light-client-verified bridge on Reth.
Sequencer & Rollup Architecture — From Centralized Block Producer to Shared Sequencers
Read the canonical Rust rollup stack one piece at a time. Sequencer fundamentals (mempool + builder + batcher), batch posting and DA (calldata / blobs / alt-DA), Flashbots auctions, shared sequencer trajectories.
P2P Networking Internals — From devp2p to Custom Gossip
Read reth p2p stack from the wire up: devp2p framing, RLPx encryption, ENR + discv5, eth/68 subprotocol, then ship a custom gossip channel as a Capstone.
Validator Operations — Keys, Slashing, and Coordinated Upgrades
The validator-operations triangle: key management (HSM → MPC → threshold sigs), slashing avoidance (DB + fail-closed under partition), and coordinated chain upgrades (height-gated chain spec, four emergency tiers).
Performance & Capacity Engineering
Performance discipline for Rust L1 chains: workload definition, profiling, bottleneck removal, SLO budgets, and capacity planning.
Production Security & Governance
Security and governance layer for production Rust L1s: threat models, secret management, emergency response, and change control.
Reth Expert — Production Engineering
Production engineering at L1 scale. 25 lessons across three modules: Performance & Systems, Production Engineering (custom precompiles + MPT + stateless + MEV + zkEVM), and Reth-based Chains (library-not-fork + op-stack-on-reth + custom ChainSpec + alphanet / Tempo / MegaETH case studies).
Building with the Stack — Real-World Rust EVM Apps
Build the canonical Rust EVM applications. Ten labs ship with passing tests: MEV searcher, Tempo payment rails, custom op-stack rollup, and more.