The algorithms that let machines sense the world, plan what to do, and act on it.
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. Every page in this path is one implementable piece of the stack, with worked numbers you can check by hand.
Everything in robotics stands on one skill: describing where things are and how they're turned. Rotation matrices do it with a multiply, Euler angles do it with three familiar dials and one famous failure, quaternions do it without that failure, and homogeneous transforms chain it all down an arm, joint by joint.
The geometry of arms. Forward kinematics turns joint angles into a hand position, inverse kinematics runs the same math backwards to answer where the joints should be to reach a target, and the Jacobian connects their speeds, right up until a singularity makes it lie.
A reachable pose isn't a plan. Trajectories decide how to get there smoothly, with polynomials in joint space and straight lines in tool space. Dynamics adds the physics: the torque it actually takes, and the inverted pendulum where control theory earns its keep.
The hardware layer, where the math meets metal. Motors trade speed for torque, gears multiply it, encoders count it, and PID loops keep it all on target. This is the tier where predicted numbers meet measured ones, and the gap between them is the lesson.
How a robot knows anything: cameras project the world onto pixels, IMUs feel motion, and odometry counts wheel turns while its error grows. Filters clean up the noise, with the Kalman family tracking a best guess and how confident it is. Then the robot moves: occupancy grids hold the map, RRT plans through it, and pure pursuit follows the result. For graph search on a known map, the A* and Dijkstra's pages already cover the algorithms robots use.
Here is the whole path, tier by tier, from the math every robot stands on to a robot that senses, plans, and moves. Every card is one algorithm or computation you will implement from scratch. Each topic gets its own page soon, but until then, use this as the map.
Five ways to write down a rotation, each fixing a problem the last one had. Skip this tier and every arm equation later reads like noise; learn it and they read like bookkeeping.
Rotate a point with one multiply, and undo it with a transpose.
Roll, pitch, and yaw: three familiar angles with one famous failure mode.
Any rotation is one axis and one angle. Rodrigues wrote down the formula.
Four numbers that rotate without gimbal lock, and blend smoothly between poses.
Rotation and translation in one 4x4 matrix you can chain down an arm.
One 2-link arm carries this whole tier. You'll compute where it reaches, solve for its joint angles both ways, and find the exact pose where the math breaks.
Joint angles in, hand position out. Pure trigonometry.
Four numbers per joint that describe any arm, no drawings required.
Where should the joints be to reach a target? The cosine rule answers twice.
The matrix that maps joint speeds to hand speed, and tells you when it lies.
When no formula exists: guess, measure the miss, and iterate until it shrinks.
Where the arm can reach, and the poses where it suddenly can't move.
Getting from A to B without jerking, and knowing what it costs in torque. Ends at the inverted pendulum, the benchmark every controls course balances sooner or later.
Cubic and quintic polynomials that start still, move smoothly, and stop still.
LERP for straight lines, SLERP for turning: motion the tool tip can follow.
The torque behind the motion: mass, gravity, and the equation of motion.
Balance a falling pole with a moving cart: the hello world of control.
Motors, gears, encoders, and the loops that command them. Every page here has two answers: the one the formula predicts and the one the bench measures.
Torque trades against speed along one straight line. Pick your point on it.
Kv, pole pairs, and why torque is just current with a constant attached.
Trade speed for torque with a ratio you can count on your fingers.
The load the motor actually feels shrinks with the square of the gear ratio.
Two offset square waves that count position and reveal direction.
Full voltage, switched fast enough that the motor only feels the average.
Add up the amps before the robot browns out mid-demo.
The three-term loop that keeps every joint on target.
A position loop commanding a velocity loop, each running at its own speed.
The mobile-robot stack in order: see, estimate, map, plan, follow. Noise is the villain of every page, and filters are how you beat it.
How a 3D point lands on a 2D pixel, and how to measure your lens's lies.
Two cameras, one disparity, and depth falls out of a ratio.
Gyros drift and accelerometers jitter. One blend constant fixes both.
Count wheel turns to track your pose, and watch the error quietly grow.
Tracks a best estimate through noise, with a confidence to match.
Thousands of guesses that converge on where the robot really is.
The Kalman filter, taught to survive curves by linearizing around its guess.
The world as a grid of cells: occupied, free, or unknown.
Grow a random tree until one branch touches the goal.
Chase a point a little ways down the path, and steering falls out of a circle.