Loading…
Product Visit
Visit tomorrow's products today
Learn embodied AI by building a robot brain from scratch. No robot required.
Learn embodied AI by building a robot brain from scratch. No robot required.
Read it online · Play in your browser · Newsletter: Physical AI Weekly
zero2robot is a 43-chapter course (across six phases) that teaches robot learning the way you'd read a textbook, except every page is a single runnable file you study line by line and run yourself. You start from a bare simulation loop and build up, one chapter at a time, to a vision-language-action policy you train, evaluate, export, and drive in your browser, then on to the from-scratch practitioner's stack and a real-arm graduation. No framework to excavate, no black boxes.
zero2robot is free and open, and it always will be.
bc.py, act.py, diffusion.py, ppo.py, …),
≤450 lines, no clever abstractions. The code is the product. You read every line.--smoke for a fast
deterministic pass, --seed everywhere, --out for artifacts. GPU owners get optional
Scale Labs; nobody is ever gated behind hardware.The buildable curriculum arc is complete: 43 chapters across six phases are built, finalized, and re-verified end to end (Phase 0 foundations through HIL-SERL post-training, the Phase 5 practitioner's stack, and the real-arm graduation). The interactive textbook is live at zero2robot.com and the MuJoCo-WASM playground at play.zero2robot.com; you can also run everything locally (below).
What is honestly not finished, and is not claimed done: some GPU and Scale-Lab
wall-clock cells are still unmeasured (they read TBD, never a guess). Wall-clock times in
chapter prose are measured on real hardware (curriculum/common/wallclock.csv), never
estimated.
git clone https://github.com/kaushikb11/zero2robot.git cd zero2robot uv sync # or: uv venv --python 3.11 .venv && uv pip install -e ".[dev,export]" # Chapter 0.1 — the simulation loop (instant, CPU) .venv/bin/python curriculum/phase0_foundations/ch0.1_sim_loop/sim_loop.py --smoke # Generate demos (deterministic, offline), then Chapter 1.1 — behavior cloning .venv/bin/python curriculum/common/envs/pusht/gen_demos.py --episodes 100 --seed 0 --out outputs/pusht-demos --no-video .venv/bin/python curriculum/phase1_imitation/ch1.1_bc/bc.py --smoke
Every artifact accepts --smoke, --seed, and --out. The demo datasets are
regenerated locally from seeded generators (no download needed); see
datasets/datasets.yaml and
python scripts/fetch_datasets.py --check.
Run the interactive textbook locally:
cd site && npm install && npm run dev # renders chapters from curriculum/**/prose
Check your work on any chapter's exercises (instant, offline, no accounts):
python -m grader.check 1.1 # runs that chapter's public exercise checks
The main line is 0 → 1 → 2 → 4 (post-training) → 5 (practitioner + graduation): a complete "empty file → real robot" journey on its own. Phase 3 is an optional Depth interlude, off the main line: self-contained electives you take when the itch strikes, never a wall before the payoff (Phase 4 requires nothing from it).
| Phase | Chapters | What you build |
|---|---|---|
| 0: Foundations | 0.0–0.5 (6) | A quickstart on-ramp (train a tiny BC policy first, understand it later), then the simulation loop, MJCF scenes, spatial transforms, browser teleop → your first LeRobot dataset, reading episodes with rerun. |
| 1: The Imitation Spine | 1.1–1.9 (9) | Behavior cloning, data curation, ACT (action chunking), diffusion & flow-matching policies, a real eval harness, and a from-scratch tiny VLA (data + training). |
| 2: The RL Spine | 2.1–2.8 (8) | PPO and SAC from a blank file, 4096-robot MJX parallelism, reward design, quadruped locomotion, sim-to-real intuition labs, and a ROS-shaped runtime, without ROS. |
| 3: Depth (optional interlude) | 3.1–3.9 (9) | Dreamer-style world models, a physics engine built from scratch (dynamics → constraints → contact), your engine vs MuJoCo, datasets at scale, reading the frontier, and sampling-based MPC (CEM/MPPI) that plans through the engine you built. Off the main line. Take it when the itch strikes. |
| 4: Post-Training | 4.2, 4.3 + primer (3 built) | Take a trained policy and make it reliable: DAgger corrections on your own policy's failures, an offline-RL primer (BC vs AWAC), and HIL-SERL post-training. |
| 5: The Practitioner's Stack | 5.1–5.8 (8) + graduation | Perception from scratch (a ViT, then contrastive vision-language), the production two-tower VLA shape and a FAST action tokenizer, LoRA and INT8 quantization by hand, and the real-arm teleop → record → train → deploy loop, plus a "go build" graduation bridge to your first real robot. |
Minimum viable paths (see curriculum/): a 20-hour core (0.1–0.5, 1.1–1.4, 1.6, 1.9)
or the completionist run of all 43 built chapters (the 34-chapter core at
~118 learner-hours, plus Phase 5's practitioner arcs).
curriculum/: the chapters. This is the product. Start at phase0_foundations/ch0.1_sim_loop/.site/: the interactive textbook (renders chapter prose + code + live demos).playground/: the MuJoCo-WASM browser playground and teleop UI.grader/: the exercise auto-checker (python -m grader.check).notebooks/: generated Colab variants of chapter code (regenerated, never hand-edited).datasets/, checkpoints/: pointers/manifests only; artifacts live on the
Hugging Face Hub. No binaries in git.ARCHITECTURE.md: the repo map, the doctrine, and the CI gates.CONTRIBUTING.md: how the pieces fit and what a PR must pass.
