First principles to skilled user, hands-on.
Self-guided courses in Physical AI. You don't watch. You build, simulate, and tune real systems from the first minute.
Anatomy — fly, balance, grasp, drive, soft, swim
Six machines, taken apart three ways each — a drone that pushes air down, a humanoid that will not fall over, a hand that holds by geometry, a rover that rolls but never sideways, a soft hand that computes with its own body, and a fish that moves through water. Every lesson withholds its answer until you guess, then proves it live: real learned policies, every number computed by an open core so the page cannot lie. One format, the ways a body meets the world — our pedagogy, and the reach of Physical AI.
Open the series →Vision-Language-Action literacy
The incumbent path of embodied AI in one loop — perceive, ground, act. A live demo you drive, plus how to read a VLA: action chunking, why data is the bottleneck, and the one thing it never gives you — a guarantee before the action commits.
Open the primer →The Ferromotion Textbook
The ideas that make machines move, one per chapter — actuation, coordination, safety, manipulation, learning, perception, planning, locomotion, and data-driven modeling. Every chapter drives the same Rust library the Institute's tools are built on, and re-derives its central result live: no videos, no precomputed plots, and each chapter checks its own headline against an analytic answer or a physical invariant.
Open the textbook →Where to start.
Every lesson opens with something to do.
Exploring Intelligence: The Matching Principle
One idea, carried from a 1928 antenna to a theory of mind. A wave meets a boundary and whatever does not match comes back — and that same geometry reappears as lost channel capacity, as a bandwidth budget you cannot overspend, as the heat of erasing a bit, as a robot's contact chattering against a wall, and finally as surprise. You start with no prerequisites and finish by writing one function that reproduces every answer you earned along the way. The Smith Chart Navigator and the passivity disk are your instruments throughout.
14 lessons →
Physics-Informed Physical AI
The physical world will not be solved by data alone: action-labeled data is scarce, and a black-box net that has never heard of energy or momentum extrapolates dangerously. This course teaches the alternative — inject the physics you already know into a learner, at one of three places: the data (guided), the loss (informed), or the architecture (encoded). You build every method on-device in the browser, driving the real ferromotion Rust library compiled to WebAssembly: reverse-mode autodiff, physics-informed neural nets, Lagrangian and Hamiltonian nets, Neural ODEs, structure-preserving integrators, equation discovery, and differentiable control. Physics → AI → Physical AI, one runnable rung at a time.
24 lessons →
The Energy-First Turn: Computing as a Function of Energy
Electricity, not transistors, is now what schedules the next model. This course teaches you to price computing in joules and to tell an honest energy claim from a flattering one: where the joules actually go, why data movement rather than arithmetic is the bill, which substrates escape it, and what evidence would count as proof. You leave able to audit an efficiency claim rather than repeat it, and to tell a claim a cleverer algorithm can destroy from one it cannot.
5 lessons →Energy First Architecture
The physics-first thesis, built in the browser: one scalar energy a body descends to act — and the same energy is the proof it will not diverge. Descend it to control, read its decrease as the certificate, get that certificate for free by structuring the energy as a port-Hamiltonian (at any number of joints, where a box proof cannot), and gate a task policy so it verifies before it commits. No bolted-on verifier; one energy, and the proof is the objective. This is an active research line, not ours alone (co-learned port-Hamiltonian models with passivity-based safety certificates, arXiv 2604.26172 and 2512.24493, and physics-driven world models like PH-Dreamer); what you build here is the open, on-device, readable version of it.
4 lessons →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.
13 lessons →
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.
14 lessons →
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.
15 lessons →
AI + Uncrewed Aircraft
Autonomy for drones, sim-first and NDAA-clean: build the whole stack — control, perception, estimation, planning, and the multi-agent swarm, where the code you write is the code that flies the aircraft — on-device, so the boundary is the aircraft's own, and staying aloft under wind and GPS-loss is viability held under disturbance.
10 lessons →Silicon for Physical AI
Design the silicon that runs Physical AI — from a single NAND gate to an edge-AI accelerator, then out to a real chip. Logic, synthesis, timing, quantization, AI-assisted design, and the economics of getting made, with TinyTapeout as the real-fab capstone.
11 lessons →
Rust for Physical AI
A language, not a syntax tour. You learn Rust by writing the firmware that drives a 3D rover: every lesson compiles real no_std Rust to WebAssembly and runs it as the live control loop. When the borrow checker rejects a bug, you watch it reject the bug before the robot could ever make it. Ownership and memory safety without a garbage collector, the type system as a modelling tool, zero-cost abstraction, and the one-binary seam from browser sim to bare metal — the substrate (Ferric) that makes the boundary the robot's own, on-device, no cloud: the reasons Physical AI is being written in Rust.
8 lessons →
Embodied AI Design: Humanoids for Work and Play
Design an embodied AI end to end, the body and the behavior, for the two arenas pulling humanoids into the world: work and play. You size a joint in real MuJoCo, build a walking gait, transfer it from simulation with domain randomization, build the foundation-model stack that turns pixels into actions (the priors, not the guarantee — what makes each action safe is the certificate it commits under, and its economy is joules per viability-second), give motion style through dance and martial-arts form, and probe how a robot learns by playing. Grounded in the 2026 reality of humanoids on real lines and in real homes, it closes on the question the field is actually asking: how a robot amplifies people instead of replacing them.
17 lessons →Robot Learning: From Demonstrations to a Released Policy
Teach a robot to reach by showing it, not programming it. You turn demonstrations into data, clone the behavior with a linear policy and then a small neural network trained by gradient descent, learn the honest test that separates generalizing from memorizing, and finish by running the Institute's released checkpoint — the exact forward pass — before watching the real weights drive the arm live. Every lesson runs on your device.
11 lessons →Vision-Language-Action: Build a Policy You Can Talk To
Build a vision-language-action policy from the ground up — because to judge the incumbent path of embodied AI, you must first build it. You make vision that turns pixels into places, language that grounds open-vocabulary instructions, and an action head that joins them; you prove it obeys words rather than memorizing a target; and you meet the honest costs a VLA pays a body — it is data-hungry, it fails out of distribution, and it carries no guarantee before it acts — plus the two problems we hit shipping our own: compositional order, and why motion needs more than one frame. Build the incumbent, know exactly what it costs, then see the physics-first inversion in the Energy First Architecture course, where one energy is the controller and its own proof.
7 lessons →Physical AI for Space Logistics and Transportation
Space logistics is a velocity budget you compose and a chain of maneuvers an autonomy stack flies. Compute the rocket-equation wall and pay it down with infrastructure; propagate relative motion with Clohessy-Wiltshire and solve a two-impulse rendezvous; estimate a tumbling target with a Kalman filter; and seat a part by force, not position. Every bench runs the real math behind the Charlot Lab's orbital-logistics instruments.
6 lessons →
World Models: Learn a Simulator You Can Imagine In
Build a world model, a learned simulator that predicts what happens next, from the ground up. You fit the smallest one to a real system, roll it forward to imagine the future and watch error compound, make it nonlinear and latent the way Dreamer and DIAMOND do, then plan with it and finally play a pixel-space world the way Genie 3 does. It ends where the 2026 frontier actually is: Meta's V-JEPA 2 (physics learned from a million hours of video, then robot control from a little real data) and NVIDIA's Cosmos world-foundation models, the same imagine-then-act loop the Institute's own runs live and on-device. And it meets that frontier's honest limits: benchmarks like PhysicsMind show today's world models lean on superficial cues and routinely violate balance, torque, and inertia, which is why structured, physics-grounded models (port-Hamiltonian dynamics, PH-Dreamer) are the live research direction; and a rollout's score is not proof it is safe to run for real, which is why runtime verification of an imagined plan, before you commit it, is being built now, ours included.
7 lessons →Dendritic Computation: Learning Without Forgetting
The unit at the base of deep learning is a single weighted sum — and a real neuron is not. Build the dendritic unit from the ground up: see why one point neuron can't solve XOR but a dendritic one can, watch a standard network catastrophically forget a task while a context-gated dendritic network keeps it, and recognize the same dendritic gating hiding inside attention and mixture-of-experts. It ends on the honest question — if the richer unit is better, why did the point neuron win? — and its answer: the hardware lottery. Grounded in Beniaguev 2021, Poirazi & Mel, Numenta's Active Dendrites, Chavlis & Poirazi 2025, and Hooker 2020.
6 lessons →Agentic Physical AI: The Open Skill Layer
Build the open, cross-vendor skill layer that turns any policy into a robot skill: it installs, checks the body's declared capabilities against what the skill needs, and holds every action inside a runtime envelope on-device. You implement capability negotiation, the runtime envelope, policy-agnostic skills, LeRobot composition, and a safe MCP tool — then author and ship your own. The runtime clamp is the floor, not the guarantee — a box constraint bolted around the policy; the guarantee that matters is a certificate on the action's own energy, baked in (see Energy First Architecture).
6 lessons →Connection Systems: From a Snap to a Policy
The bridge from a maker's snap-together kit to a learned policy on real hardware. Build the sense-think-act loop in code, read a sensor over a real bus, watch a block graph become a policy that out-learns your hand rule, switch a magnet that holds for free — the energy a body already has can be the guarantee, the seed of the certificate idea — and clone an expert from its own demonstrations.
5 lessons →Perception to Policy: From a Sensor to a VLA
The ladder from a raw sensor to a vision-language-action policy, one rung at a time, with a model you train on-device at every step: turn a sensor stream into features, train a kilobyte classifier, wire perception into a decision, clone a policy from demonstrations, hit the generalization wall and see what a VLA adds, learn a world model and plan a policy inside it, then learn a reward model to judge and improve any behaviour. The bridge nobody teaches whole.
7 lessons →Frontiers in Physical AI: Ternary
The multiply is the enemy. Three states {−1,0,+1} delete it — and with it the binary tax of multiplier arrays, the data-movement wall, and leading-edge fabs. Backed by information theory, arithmetic, and material science, this course builds the case in code: the trit is the optimal atom, a ternary policy matches full precision, and multiply-free silicon runs on a mature, sovereign node. Ternary is the bridge from the binary world to post–von-Neumann computing — and the only way forward for embodied AI at the edge.
10 lessons →The spine is physics-first.
Two paths run through these courses. The spine starts at the principle and ends at a body that proves its own action safe before it commits. The other — the data-first stack the field is racing on — you build in full, precisely so you can feel where it offers no guarantee before commit: the gap the spine closes.
The physics-first spine
Exploring Intelligence
Start at the principle, not the model: intelligence as impedance matching — a wave meets a boundary and only the mismatch returns. The physics-first lens the rest of the spine is built on.
Physics-Informed Physical AI
The physical world will not be solved by data alone. Put the physics into the loss and the model — energy, conservation, constraints — so the network cannot learn what the world forbids.
The Energy-First Turn
Electricity, not transistors, is what schedules the next model. Price computing in joules, find out why data movement rather than arithmetic is the bill, and learn to audit an efficiency claim instead of repeating it.
Energy First Architecture
The culmination: one scalar energy a body descends to act — and the same energy is a machine-checked proof it won't diverge, before the action commits. The controller is its own certificate.
The incumbent path — built as a foil
Robot Learning
Turn demonstrations into a released policy — behavior cloning, an episode-held-out split, and a checkpoint you ship.
Vision-Language-Action
Build a policy you can talk to — vision to a place, open-vocabulary language, and action.
World Models
Learn a simulator it can imagine in — predict, roll out, plan by imagination, and play a world model.
Learn it here. Do it for real there.
Every course hands off to a live playground. Generate and train a robot, pilot an embodied AI, coordinate a fleet, or take a design toward real silicon and real parts.
Forge
Generate a robot from a description, then teach it to walk, on-device.
Taught in Embodied AI, Programming, Design & Simulation
The Pilot
Drive an embodied AI, a rover or a biped, with a controller you steer.
Taught in Programming, Rust, Embodied AI
The Arena
Code-to-compete: put your control code on the board and race it.
Taught in Programming, Rust
Digital Twin Lab
A live, deterministic multi-domain fleet you can record and replay.
Taught in Design & Simulation, AI + UAS
Bayou Air Corridor
A drone-airspace operations twin over real Houston geography.
Taught in AI + UAS
The Printed Humanoid
A fully-3D-printed humanoid body, manufacturing Physical AI for real.
Taught in Manufacturing
Learn by running real code.
A live Python notebook. This is the Bench every lesson is built on. Launch it, edit any cell, re-run.
Warm-up: Hovering a quadrotor
Size the thrust to hover, then close an altitude-hold loop, and tune it yourself.