Ask a robot to fetch a cup and you hand it four problems at once: what's a cup, where am I, how do I get there, and how hard should I grip. Robotics is where software meets the physical world. A robot runs a loop that never really ends: sense the world, figure out where you are, plan a move, execute it. Then do it all again before anything drifts. Each step of that loop is its own field, and this page walks through them in order.
The hard part isn't any single algorithm, it's that the real world is noisy: sensors lie a little, wheels slip, and the gap between simulation and reality bites everyone often enough to have earned its own name, the sim-to-real gap.
A robot is blind until you give it sensors: cameras for what things are, LIDAR for where things are, IMUs for how it's moving. None of them is trustworthy alone, so sensor fusion stitches them into a single picture the robot can trust, and point clouds give all that 3D data a shape algorithms can work with.
Knowing where you are sounds simple until you try it with noisy sensors. Filters handle the noise: the Kalman family tracks a best guess and how confident it is, particle filters keep many guesses alive at once, and SLAM solves the chicken-and-egg problem of building a map while locating yourself inside it. Occupancy grids are where the map ends up.
Once a robot knows where it is, it has to decide how to move. Graph search like A* finds the shortest path through a known space, sampling methods like RRT handle spaces too big to search, trajectory optimization smooths a path into something that respects physics, and behavior trees decide what the robot should even be doing.
A plan does nothing until the motors execute it. Control is the layer that turns a plan into torque: PID keeps every joint chasing its target, kinematics maps between joint angles and where the hand actually is, and force control decides how hard to push, which matters the moment a robot touches anything. Underneath it all, actuators decide what's physically possible.
The newest layer of the stack. Robots train in simulation because the real world is slow, expensive, and breaks things, then cross the sim-to-real gap. Imitation learning skips the math entirely: drive the robot through the task yourself and let the demonstrations do the teaching. ROS 2 is the plumbing that ties the whole stack together.
Here is the whole path, tier by tier, following the sense-plan-act loop. Each topic will get its own page soon, but until then, use this as the map.
The loop opens with its eyes: raw light, laser returns, and acceleration become a scene the rest of the stack can reason about. Garbage here poisons everything downstream.
Cameras, LIDAR, and IMUs: what each sees and what each misses.
Turning camera pixels into objects a robot can act on.
Combines unreliable sensors into one trustworthy picture.
Millions of 3D points, and the structures that make them searchable.
Perception tells the robot what's around it, not where it stands. Pinning that down through noise is hard enough that half this tier is just managing uncertainty.
Tracks a best estimate through noise, with a confidence to match.
Thousands of guesses that converge on where the robot really is.
Builds the map and finds yourself in it, at the same time.
The world as a grid of cells: occupied, free, or unknown.
With a map and a position, movement becomes a search problem. The catch is that real spaces are continuous, cluttered, and far too big to search exhaustively.
A* and Dijkstra: the shortest way through a known map.
RRT and friends: finding a path when the space is too big to search.
Turns a jagged path into motion a real robot can follow.
How a robot decides which job to do right now.
A trajectory is just numbers until the joints follow it. This tier is the feedback machinery that keeps reality tracking the plan, millisecond by millisecond.
The three-term loop that keeps every joint on target.
The math between joint angles and where the hand ends up.
Controlling how hard to push, not just where to go.
Motors, gears, and torque: what the hardware will actually do.
The classical stack ends where the math gets too messy to write by hand. Learning fills that last stretch: practice in simulation, imitate a human, and keep whatever survives contact with reality.
Train in a world that's free to break, thousands of times faster.
Getting what worked in simulation to survive reality.
Show the robot the motion and let it learn the rest.
The middleware that wires sensors, planners, and motors together.