Robotics: Zero to Autonomy

Robotics you can touch.

22 courses from Linux to autonomy — every concept runs live in your browser. Not a video course: simulations you drag, code you break, C++ our servers compile.

Start the pathTry a lesson

Decorative two-link robot arm following the cursor with live inverse kinematics.

live inverse kinematics — move your cursor. it can't leave the dashed ring; that's lesson one.

courses
22
courses
lessons
345
lessons
questions
1,000+
questions
of path
374 h
of path

Every concept runs.

These aren't screenshots — they're the actual lesson widgets, running now, with the lessons' own parameters. Thirteen of them live across the curriculum.

loading simulation…

Deterministic isn't predictable — meet the passive dynamics your controllers will tame.

From Robot Dynamics & Control · module 2 →
loading simulation…

Drag Kp and watch it ring. Gravity is the opponent; the I-term is the closer.

From Robot Dynamics & Control · module 3 →
loading simulation…

A belief with error bars, updated live. Disturb it and watch it recover.

From Kalman Filters · module 2 →

Real code, really graded.

Python executes in your browser. C++ compiles on our servers and comes back with GCC's honest opinion.

Python · runs in your browser (Pyodide)

diff_drive.pyRuns in your browser
import math

# Two wheel speeds in, one motion out — the diff-drive forward map.
b, r = 0.3, 0.05          # wheelbase, wheel radius (m)
wl, wr = 8.0, 10.0        # wheel speeds (rad/s) — try changing these

v = r * (wl + wr) / 2     # forward speed
w = r * (wr - wl) / b     # turn rate
print(f"v = {v:.2f} m/s, \u03c9 = {w:.2f} rad/s")
print(f"turn radius R = v/\u03c9 = {v / w:.2f} m")

Press Run — this executes right here, no account needed. Every Python block in every lesson is editable and re-runnable, just like this one.

C++ · compiled on our servers (GCC)

clamp_cmd.cppCompiled on the server
#include <algorithm>
#include <iostream>

int main() {
    double v, v_max = 0.25;            // m/s — the robot's contract
    while (std::cin >> v)
        std::cout << std::clamp(v, -v_max, v_max) << '\n';
}

✓ Accepted — 3/3 test cases (1 hidden)

g++ (GCC 14.1.0) · cpu 0.002 s · 1.1 MB

A replay of a real graded run. Inside the course, C++ blocks compile on our Judge0 servers — graded exercises included, with hidden test cases like a real interview.

One path, six phases.

Robotics: Zero to Autonomy — the complete guided path from zero to robotics developer: Linux and Python through ROS 2 navigation, perception, manipulation, and control, ending in an autonomous robot capstone.

  1. 01

    Developer foundations

    • Linux for Robotics
    • Python 3 for Robotics
    • Git & GitHub
    • Docker for Robotics

    Toolchain ready — You can drive Linux, write Python, use Git, and run the course robot environment in Docker. Time to meet ROS 2.

  2. 02

    ROS 2 core

    • Maths for Robotics
    • Robot Operating System (ROS 2) Basics
    • ROS 2 TF
    • ROS 2 URDF for Robot Modeling
    • Gazebo Sim

    First simulated robot — You modeled a robot and drove it in simulation. Everything from here builds on this robot.

  3. 03

    Professional ROS 2

    • Modern C++
    • ROS 2 Advanced

    Production-grade ROS 2 — You write ROS 2 the way robotics companies do. Now make the robot actually do things: navigate, see, grasp.

  4. 04

    Mobile robotics

    • Kinematics of Mobile Robots
    • Path Planning Algorithms
    • ROS 2 Navigation
    • Kalman Filters
    • SLAM: Mapping and Localization
    • ROS 2 Navigation Advanced

    Autonomous navigation — Your robot maps, localizes, and navigates on its own — and you understand the estimation math underneath.

  5. 05

    Perception, manipulation & control

    • ROS 2 Perception
    • Arm Kinematics
    • ROS 2 Manipulation
    • Robot Dynamics and Control
    • ROS 2 Control

    Full-stack robotics developer — Perception, planning, manipulation, control — the complete stack. One project left.

  6. 06

    Capstone

    Fetch-and-deliver robot. In simulation: a mobile manipulator autonomously navigates to a table, visually identifies a target object, picks it, and delivers it to a goal zone. Touches every course: Nav2, perception, MoveIt, TF, URDF, Docker, Git.

Already know some of it? Test out of what you already know — 13 placement gates let you skip courses you can pass at 80%.

Capstone · 25 hours

Fetch-and-deliver robot

In simulation: a mobile manipulator autonomously navigates to a table, visually identifies a target object, picks it, and delivers it to a goal zone. Touches every course: Nav2, perception, MoveIt, TF, URDF, Docker, Git. You finish with a repo and a demo video employers can actually watch — and the Certified Robotics Developer — Zero to Autonomy Program, verifiable by code.

The terminal is waiting.

Start the pathTry a lesson