Every lesson is something you run.
No videos to watch. Each tile below opens a live bench in your browser (real MuJoCo physics, parametric CAD, embedded firmware, a virtual factory) that you edit, run, and are graded on. Pick one and start.
Design and Simulation of Devices
Model a Physical AI device in parametric CAD and prove it out in simulation before any hardware: geometry, mechanisms, dynamics, and the design→simulate→improve loop.
Code is the Clay: Primitives & Solids
Create a named solid of specified dimensions in real build123d and inspect it in the 3D viewer. Pass = the solid's bounding box matches the target within tolerance.
▶ Run the lab →Workplanes & Sketches: 2D Becomes 3D
Place a 2D sketch on a workplane and extrude it into a solid, then cut a feature through it. Pass = the resulting build123d Part has the target bounding box AND the target volume (the through-hole removes the right amount of material).
▶ Run the lab →Your First Parametric Part
Drive a real build123d part from named Python variables instead of magic literals, so one number reshapes the whole solid. Pass = result is a 60 x 40 x 8 mm plate with a centered 6 mm through-hole: bounding box within +/-0.1 mm AND volume within +/-1 mm3 of 18973.81 (box volume minus the drilled cylinder), proving the hole is really cut, not faked.
▶ Run the lab →Driven Dimensions & Relationships
Express a part's dimensions as formulas of a single driver parameter so derived dimensions stay consistent when the driver changes - verified by the bench measuring the real OpenCascade bounding box against an exact target.
▶ Run the lab →Constraints & Valid Ranges: A Part Family
Build a real parametric part that lands inside a fixed spec envelope: drive its dimensions so the solid's bounding box and material volume both fall within tolerance of the published datasheet, proving the part is a legal member of the family rather than an out-of-range variant.
▶ Run the lab →Locating Parts in Space
Position parts in a shared coordinate frame with Pos (and Rot when needed) so the combined assembly fills an exact envelope - placing one solid on top of another and grading the bounding box of the fused part within tolerance.
▶ Run the lab →Joints & Degrees of Freedom
Define a joint between two parts and correctly state and realize its allowed motion - revolute vs. prismatic - exposing exactly one intended degree of freedom and no others.
▶ Run the lab →A Mechanism That Moves
Compose joints into a linkage and sweep the input through its full range to confirm the output traces the target motion path with no self-collision.
▶ Run the lab →From CAD Body to Physics Body
Turn a geometric body into a physics body by giving it the right mass, then simulate on real MuJoCo until the spring-loaded part settles at the spec deflection (-0.10 m).
▶ Run the lab →Force Balance: Spring vs Gravity
Tune the spring stiffness so the spring force balances the load's weight at the target deflection, reading force equilibrium straight off a real simulation.
▶ Run the lab →Reading the Verdict: Did It Settle?
Learn that touching the target once is not passing: add damping so the device truly SETTLES (velocity → 0), and read the simulator's settle verdict correctly.
▶ Run the lab →The Improvement Loop: Measure → Tune → Re-Sim
Diagnose a failing device from sim telemetry and adjust the correct parameter(s) in the correct direction to bring it to spec, and prove the change was driven by the measured data, not by guessing.
▶ Run the lab →Capstone: Design, Simulate, Validate & Optimize a Device
Deliver a complete, multi-feature parametric part to an exact spec: a mounting bracket = base plate + cylindrical boss + through-hole. Build it in real build123d on the OpenCascade kernel, then validate it against the spec by reading its bounding box (60 x 40 x 20 mm) and its volume (~20607.4 mm^3). Geometry valid, spec compliant within tolerance.
▶ Run the lab →Programming Physical AI
One simulated differential-drive rover, commanded at three rising depths (visual blocks, Python scripting, and bare-metal MCU), re-solving the same tasks at each depth until you can choose the right level of abstraction for a physical-AI task and prove it.
The Embodied Loop
Wire a sense->decide->act loop that drives the rover forward and halts it within 0.25 m of the goal with no overshoot.
▶ Run the lab →React and Avoid
Build a reactive rule-based behavior using conditionals so the rover avoids an obstacle and still reaches the goal with zero collisions.
▶ Run the lab →Blocks Are Python
Read the Python generated by a block program and correctly predict the effect of editing a single generated line before running it.
▶ Run the lab →Reading the World
Write control(obs) that reads the rover's goal_bearing each step and steers toward the goal pad, turning the differential-drive wheels so the rover reaches the goal within tolerance instead of driving blind.
▶ Run the lab →The PID Loop
Write a proportional heading controller in Python control(obs) that eases the rover onto a goal pad within a tight 0.12 m tolerance, with no overshoot or weave.
▶ Run the lab →Plan With a State Machine
Design a finite-state controller in Python control(obs) that switches modes (SEEK far away, ARRIVE up close, AVOID near a wall) to drive the real MuJoCo rover onto the goal pad and settle within tolerance.
▶ Run the lab →Learn From Data
Train a simple classifier mapping sensor readings to a discrete action and run it on the rover, meeting held-out accuracy >= 0.85 and goal completion with zero collisions.
▶ Run the lab →Reinforcement Learning
Define a reward function and train an RL policy in-sim to convergence (smoothed reward >= 6.0) with a greedy rollout that reaches the goal safely and efficiently.
▶ Run the lab →Imitation and Sim-to-Real
Clone a demonstrated trajectory with behavioral cloning to RMSE <= 0.12 m and correctly explain why a sim-perfect policy can fail on real hardware.
▶ Run the lab →GPIO, Peripherals & the Control Loop
Write your first no_std Rust firmware: own the rover's peripherals, blink a GPIO LED, and drive the motors from the control loop to reach the goal.
▶ Run the lab →Timers, PWM & Proportional Drive
Use PWM motor channels and the millisecond clock to replace bang-bang control with a smooth proportional controller that settles in the pad without overshoot.
▶ Run the lab →Async Tasks & the Real-Time Loop
Structure firmware the Embassy way, with concurrent concerns on one real-time loop, by running a navigator AND a fixed-rate LED heartbeat off the millisecond clock, without blocking.
▶ Run the lab →Full Autonomy in Python
Combine perception and control into one robust control(obs) that reliably drives the differential-drive rover to the goal pad within tolerance on real MuJoCo physics, fixing a partial starter controller.
▶ Run the lab →Optimize the Critical Loop to the Metal
Re-implement the full autonomy control loop as no_std embedded Rust firmware against the rover HAL, with proportional steer-and-ease plus a non-blocking heartbeat, and prove it lands the rover inside a tight 0.12 m tolerance running directly on the metal.
▶ Run the lab →Manufacturing Physical AI
Take a part from a clean CAD model to a humming, optimized production line inside a browser-native virtual-factory twin: deciding how to make it, generating its process plan, taming tolerance and variation, balancing the line, and optimizing a whole factory against throughput, cost, and yield.
What "manufacturable" means
Given the sensor-mount CAD part, identify at least 3 manufacturability problems and state why each is a problem, each mapped to the correct defect class on a fixed grader seed.
▶ Run the lab →Choosing a material and a process
For the sensor-mount part and a stated requirement (strength, cost, count), select a material+process pairing and justify it against at least two alternatives, using the twin's estimated cost, time, and feasibility.
▶ Run the lab →Designing for the process (DFM)
Modify the part's geometry to remove ≥2 flagged DFM violations while preserving its functional dimensions, and verify the inspector now passes.
▶ Run the lab →From geometry to toolpath
Generate a valid roughing + finishing toolpath for a pocket and explain how tool diameter and stock define what the path can and cannot reach.
▶ Run the lab →Process parameters
Choose spindle speed, feed, and depth-of-cut that complete the cut with no overload and an acceptable surface-finish score, and state the trade-off each parameter drives.
▶ Run the lab →Sequencing a process plan
Order a multi-operation plan into a valid sequence, choosing setups, and justify why the order is forced by datums and the surfaces each operation creates.
▶ Run the lab →Tolerances: the band a part must live in
Assign tolerances to ≥2 critical dimensions and predict how tightening or loosening each changes cost and fit, reaching a functioning fit at the lowest cost.
▶ Run the lab →Where variation comes from
Run a batch, read the output distribution, identify which process parameter drives the spread, and reduce it.
▶ Run the lab →Tolerance stack-up
Predict whether a chain of toleranced parts will assemble using both worst-case and statistical (RSS) stacks, and state when each method applies.
▶ Run the lab →Assembly sequencing
Produce a feasible assembly order for a multi-part product and explain at least one constraint (access, fastening, fit) that forbids an alternative order.
▶ Run the lab →Throughput & the Bottleneck
Find a line's bottleneck (the station with the slowest per-machine cycle) and fix it so the line meets its throughput target.
▶ Run the lab →Balancing the Line
Balance a multi-station line so no single station dominates, including the SECOND bottleneck that appears once you fix the first, to hit a high throughput target.
▶ Run the lab →Yield, scrap & process capability
Compute a line's yield and process-capability index (Cp/Cpk) from a batch, and raise yield above a target by centering and/or narrowing the process.
▶ Run the lab →Optimizing Under Competing Targets
Hit the throughput target at MINIMUM cost. Every machine costs money, so add capacity only where it actually buys throughput (the bottleneck), staying within budget.
▶ Run the lab →Capstone: Run & Optimize a Virtual Factory
Take a full five-station line from below target to meeting both a throughput spec and a tight machine budget: the whole manufacturing toolkit (bottleneck, balancing, cost) at once.
▶ Run the lab →