A free place to start learning robotics. Try short interactive concepts, read practical handouts, and follow a roadmap from your first circuit to a robot that maps and navigates on its own.
Maintained by Prof. Xian (Shawn) Li, Department of Electrical and Computer Engineering, Northeastern University.
Almost every robot, from a vacuum to a Mars rover, runs the same loop many times per second. It senses, it thinks, and it acts. Each concept on this site is one piece of that loop.
Measure the world and the robot itself, with wheel encoders, IMUs, cameras, and LiDAR.
Work out where the robot is and what to do next, even when every sensor is noisy.
Turn a decision into motion, through wheels, motors, and joints.
Acting changes the world, so the robot senses again, and the loop repeats.
Short interactive pages that show one robotics idea at a time. Move the sliders and watch what changes. 265 explainers in 19 sections.
No explainers match your search and level filter.
Sort everyday machines into robot and not robot, and see what sensing, thinking, and acting each add.
Run a robot loop one tick at a time and see how the loop rate decides whether the robot stops before a wall.
Build simple mechanisms, count links and joints, and see how many independent ways each one can move.
Wire two light sensors to two wheels in four ways and watch fear, aggression, love, and curiosity appear from simple wiring.
Tune a two-sensor and a five-sensor line follower on a curved track and compare on-off control with proportional control.
Watch Bug 1 and Bug 2 reach a goal around unknown obstacles using only a touch sensor and the direction to the goal.
Stack avoid, seek, and wander behaviors and see which layer takes control at each moment.
Drag two vectors and watch the projection, angle, and cross product update, then use them to tell if a target is ahead or to the left.
Move and rotate a robot frame inside a world frame, and see how a point seen by the robot maps to world coordinates.
Rotate a 3D frame about x, y, and z and see that changing the order of the same rotations gives a different result.
Turn the yaw, pitch, and roll rings of a gimbal until two of them line up and one degree of freedom disappears.
Pick a rotation axis and an angle and watch a vector sweep around the axis, then see the rotation matrix from Rodrigues' formula.
Blend between two orientations with slerp and with naive Euler-angle blending, and compare the paths the nose takes.
Chain world, base, arm, and camera frames and follow a point seen by the camera through every transform to the world.
Pick any end pose for a rigid body and see that the motion is a single rotation about one fixed point, the planar version of a screw axis.
Drive a robot with heading noise and see why its uncertainty is a banana, not an ellipse, and how the Lie group exponential map captures it.
Drag noisy points, fit a line or curve, and see the squared residuals the fit makes as small as possible.
Fit a curve with Gauss-Newton and Levenberg-Marquardt from the same start, and watch where Gauss-Newton overshoots and LM stays safe.
Drop a ball on a cost surface, change the step size until it diverges, and see how momentum helps in a narrow valley.
Stretch and rotate a 2D Gaussian and see the 1, 2, and 3 sigma ellipses and how many samples fall inside each.
A robot checks whether a door is open with a noisy sensor. See how each reading updates its belief, drawn as areas you can see.
Estimate the free area of a cluttered room by throwing random points, and watch the error shrink as more points land.
Simulate the same pendulum with three integrators and see Euler gain energy while RK4 stays accurate.
Film a spinning wheel at different frame rates and see it appear to slow down, stop, or turn backward.
Build a sensor signal from sine waves and noise, see its spectrum, and remove the noise with a low-pass cutoff.
Change a battery and a resistor and watch current and power update in a circuit, then add an LED and see why it needs a resistor.
Read a light sensor through a voltage divider, then see why a button input with no pull-up resistor reads random values.
Sample a sensor voltage at different bit depths and see the quantization steps, the error they leave, and clipping past the reference voltage.
Switch the four transistors of an H-bridge to drive a motor forward, backward, or to a stop, and set its speed with the PWM duty cycle.
Count encoder pulses with a polling loop and with an interrupt, and see the loop start missing pulses as they come faster.
Watch a byte travel bit by bit on UART, I2C, SPI, and CAN, and see start bits, addresses, clock lines, acknowledgements, and CAN arbitration.
Add a computer, sensors, and motors to a robot and see its runtime, its peak current, and whether the battery can deliver it.
Spin a wheel past encoder ticks, read the A and B signals, and see how resolution and sample time limit speed estimates.
Tilt and spin a virtual IMU and see what its accelerometer and gyroscope report, including gravity and noise.
Integrate a gyroscope and an accelerometer with bias and noise, and watch heading error grow linearly and position error grow even faster.
Blend a noisy accelerometer and a drifting gyroscope with one slider, and see the fused tilt beat both.
Spin a robot in a circle near iron parts and fix its distorted compass readings with hard-iron and soft-iron calibration.
Move satellites across the sky and see how their geometry changes position error, then turn on RTK corrections.
Sweep an ultrasonic sensor around a room and see its wide beam, missed echoes from slanted walls, and false readings from multipath.
Sweep a 2D LiDAR around a room and see how angular resolution, range, glass, and dark surfaces shape the scan.
Spin a multi-beam LiDAR above a street scene and see its rings on the ground, and how few points land on a person far away.
Move a 3D object in front of a camera and see where it lands in the image as the focal length and distance change.
Bend a checkerboard grid with radial and tangential lens distortion, then recover the distortion from straight lines alone.
Move an object in depth in front of two cameras and see its disparity shrink, and the depth error grow, with distance.
Compare how a structured light camera and a time of flight camera see the same scene, and where each one fails: sunlight, glass, dark surfaces, and corners.
See how an FMCW radar turns a frequency chirp into range and speed, and how bandwidth decides whether two close objects can be told apart.
Watch a fast spinning bar through a normal camera and an event camera, and see blur in one and a clean stream of brightness changes in the other.
Press on a tactile skin to see contact location and force maps, and push on a tool tip to see the six numbers a wrist force-torque sensor reports.
Compare an absolute and an incremental encoder on a robot joint, then switch the power off while the arm sags and see which one still knows the angle.
Fuse a camera and a LiDAR on a turning robot and see how a camera delay that nobody accounts for makes the two disagree.
Find the pose of a camera relative to a LiDAR by lining up a target both sensors can see, first by hand and then by solving for it.
Load a DC motor and move along its torque-speed, current, power, and efficiency curves.
Change the gear ratio to trade speed for torque, then add backlash and watch the output lag when the input reverses.
Command a hobby servo with a pulse width and see its internal position loop, its speed limit, and what happens when the load is too heavy.
Step a stepper motor in full steps and microsteps, and see it miss steps when the speed or load is too high.
Rotate the stator field of a brushless motor with six-step commutation and with field-oriented control, and compare the torque ripple.
Drive a robot link into a wall with a stiff gearbox, a spring in series, and a low-ratio motor, and compare the impact force.
Change the four link lengths of a four-bar linkage and see whether it is a crank-rocker, a double crank, or a double rocker, with the curve its coupler traces.
Move the platform of a delta robot and watch its three arms solve their angles, inside the workspace the arms can reach.
Lift a load to a target height with an electric screw, a hydraulic cylinder, and a pneumatic cylinder, and compare force, stiffness, and overshoot.
Inflate the air chambers of a soft finger and watch it curl, then let it wrap around objects of different sizes.
Set the left and right wheel speeds and watch how a two-wheeled robot like the TurtleBot 4 drives, turns, and spins in place.
Drive a wheeled robot with forward speed and turn rate, try to slide it sideways, and watch it parallel park in several moves.
Steer a car-like robot and see why its two front wheels turn by different angles, where its turning center is, and its smallest turning circle.
Drive a mecanum base forward, sideways, diagonally, or spinning in place by mixing four wheel speeds.
Turn a tracked or skid-steer robot and see how its tracks must slide sideways to turn, and how much energy that wastes.
Step through wheel odometry one update at a time: read the wheel ticks, turn them into distance and turn, and add them to the pose.
Drive a robot around a square and compare where it really is with where its wheel encoders say it is. Small errors grow with every lap.
Turn the joints of a planar two-link arm to see forward kinematics, or click a target to have the arm solve inverse kinematics and reach it.
Build a three-joint arm one Denavit-Hartenberg row at a time and see where each row places the next frame.
Build forward kinematics from each joint's screw axis and the home pose, and check that it gives the same answer as the DH table.
Sweep the joint limits of a three-link arm and see its reachable workspace, and the smaller dexterous workspace where the tool can point any direction.
Spin each joint of a two-link arm and see the hand velocity it creates, and how the Jacobian adds them up.
Drive a two-link arm toward fully straight and fully folded, and watch its velocity ellipse flatten as it loses the ability to move one way.
Click a target and watch pseudoinverse and damped least squares inverse kinematics step a three-link arm toward it, or struggle near singularities.
Hold the hand of a three-link arm still and move its elbow anyway, using the motions that leave the hand unchanged.
Place the foot of a two-joint robot leg and see both knee solutions, then watch the leg follow a walking step.
Push a robot with its motors up a slope against friction, and see how mass, force, and incline set its acceleration and top speed.
Pull a block through a spring at steady speed and compare Coulomb, viscous, and stiction friction, including the jerky stick-slip that stiction causes.
Swing a pendulum and watch potential and kinetic energy trade back and forth, with and without damping, along with its phase portrait.
Try to balance a pole on a cart by pushing it left and right, then let an LQR controller do it and poke the pole to test it.
Move a two-link arm along a swinging path at different speeds and see which part of the joint torque dominates: inertia, Coriolis and centrifugal, or gravity.
Drop two balls with the same bounciness, one with an instant bounce rule and one with a spring-and-damper contact, and see bounce heights and sinking into the floor.
Rest a box on stiff ground in a simulator and raise the time step until it starts to jitter, bounce, and finally explode.
Accelerate a wheel on asphalt, wet road, and ice, see the slip curve that sets how much grip it has, and turn on traction control.
Reach out with a mobile manipulator's arm, add a payload, park it on a slope, and see when its center of mass leaves its wheelbase and it tips over.
Command thrust, roll, pitch, and yaw and see how the mixer turns them into four propeller speeds, and how the drone tilts and turns.
Trim an underwater robot's buoyancy, drive it into a current, and see how drag, added mass, and currents make underwater control hard.
Send two robots to the same target, one following a fixed plan and one using feedback, then add a disturbance and a wheel error.
Drive a robot to a target using only full forward and full reverse, and see the chattering that hysteresis can reduce.
Tune the P, I, and D gains and watch a robot drive to a target. See overshoot, oscillation, and steady-state error appear and disappear.
Give a system a sudden new target and read rise time, overshoot, and settling time off its response as its damping and speed change.
Tune a PID controller with the Ziegler-Nichols method, then hit the motor limit and see integral windup cause a huge overshoot, and how anti-windup fixes it.
Nest a velocity loop inside a position loop on a motor, and see why the inner loop must be several times faster than the outer one.
Make a robot arm joint follow a swinging path with feedback alone, then add gravity and inertia feedforward and watch the tracking error drop.
Drag poles on the complex plane and see the step response change.
Shake a system at different frequencies and see gain and phase.
Raise a gain and watch the poles move toward instability.
Simulate a system as states, inputs, and outputs in matrix form.
Remove an actuator or a sensor and see which states you lose.
Place closed-loop poles and see the response you designed.
Trade state error against effort and balance the cart-pole.
See an energy-like function decrease along every trajectory.
Cancel an arm's nonlinear dynamics and track a trajectory.
Watch a controller plan ahead over a horizon and replan every step.
Make an arm feel like a soft or stiff spring when you push it.
Wipe a surface while keeping a set contact force.
Change the payload mid-run and see an adaptive controller adjust.
Lower the control rate and see delay cause oscillation.
Change the look-ahead distance and see corner cutting or wobble.
Track a path with heading and cross-track error, compared with pure pursuit.
Fly a drone to a waypoint through nested attitude and position loops.
Smooth a noisy signal and see the lag each filter adds.
Localize a robot in a 1D hallway with a histogram filter.
A robot moves along a line and gets noisy position readings. Watch the Kalman filter blend its motion model with each reading to track the robot.
Track a moving robot and see its covariance ellipse grow and shrink.
Linearize a turning robot's motion and see where linearization fails.
Push sigma points through a nonlinear function and compare with the EKF.
Hundreds of guesses about where a robot might be, each scored against range readings to landmarks. Watch the cloud collapse onto the true pose.
Sample odometry noise and see beam and likelihood-field sensor models.
Turn sensors on and off and see the fused estimate degrade.
Inject bad readings and reject them with a Mahalanobis gate.
Match landmark observations to the map and see what a wrong match does.
Fit a line through data full of outliers by random sampling and voting.
Build a graph of poses and measurements and optimize it all at once.
Combine camera features and IMU data and see scale and drift.
Drive a LiDAR robot and watch log-odds cells fill in.
Align two LiDAR scans step by step and see bad initial guesses fail.
Align scans against a grid of Gaussians instead of points.
See robot and landmark uncertainty shrink together when landmarks are re-seen.
Give each particle its own small map and compare with EKF SLAM.
Drive a loop, close it, and watch the whole map snap into place.
Match the current view to past views with a bag of visual words.
Track features across frames and recover the camera's motion.
Start with rough camera poses and 3D point guesses, then refine all of them together to shrink the reprojection error, one iteration at a time.
Rebuild the layout of a scene from bearings seen by a moving camera, step by step, and see why the overall scale cannot be known from images alone.
Follow a camera robot around a loop as it tracks features, adds keyframes and map points, drifts, and then snaps its map into place when it recognizes where it started.
Split each LiDAR scan into sharp edge points and flat plane points by curvature, the way LOAM does, and build a map from those features.
Show the same room as a point cloud, a voxel grid, a quadtree, a line mesh, and a signed distance field, and compare how much memory each needs.
Render a scene two ways, by marching rays through a density field as NeRF does and by blending sorted Gaussian blobs as 3D Gaussian splatting does, and compare them to the true view.
Label a floor plan with rooms and objects, build the scene graph that links them, and answer questions like where is the mug or which room has the sofa.
Let two robots map different parts of a building in their own frames, then merge their maps once they meet and work out the transform between them.
Hover over the pixels of a robot camera image to read their numbers, then compare RGB and HSV for picking out a colored object as the light changes.
Slide a small kernel across an image to blur it, sharpen it, or find its edges, and watch the window move one pixel at a time.
Tune hue, saturation, and value thresholds to pick out a red ball, then dim the light or cast a shadow and compare with a plain RGB threshold.
Find corners in two views of the same scene and match them by their surrounding patch, and see how a ratio test removes the wrong matches.
Drag four corners to warp one image onto another with a homography, the same tool used to stitch photos into a panorama or map a floor from above.
Click a point in one camera image and see the line in the other image where its match must lie, the epipolar line, from the fundamental matrix.
Move a camera forward, sideways, or turn it, and see the pattern of motion it creates across the image.
Move and tilt an AprilTag-style marker in front of a camera and watch the camera recover its full 6D pose from the four corners.
Thin a dense point cloud with a voxel grid filter and estimate a surface normal at each point from its neighbors.
Remove the table plane from a depth scan with RANSAC, then group the remaining points into separate objects by clustering.
Train a tiny neural network to separate two classes of points and watch its decision boundary bend into shape as it learns.
Draw a shape and pass it through a small convolutional network to see what each filter responds to, layer by layer.
Pick a word and watch attention weights link it to the image patches that match it, then change the temperature to sharpen or blur the focus.
Score candidate boxes from a detector, set the confidence threshold, and remove duplicate boxes with non-maximum suppression using IoU.
Label every pixel of a cluttered table by class, then by individual object, and see how blurry mask edges lower the overlap score.
Track objects across frames by predicting where each one will move and matching new detections to the predictions, and count identity swaps when they cross.
Fit a known object model to a cluttered scan to recover its position and orientation, and see where the grasp attached to the model lands.
Compare a depth map guessed from a single image with stereo depth, and fix the single-image depth's unknown scale and shift from a few known points.
Track the keypoints of a moving person, then add occlusion and fast motion and see where tracking breaks, and how smoothing helps or lags.
Find objects by typing a word, and see how shared image and text features, like those from CLIP, score every object against the query.
Move a two-link arm among obstacles and see the same scene in its configuration space, where the whole arm becomes a single point.
Draw walls on a grid and watch A*, Dijkstra, and greedy search find a path. See how a good heuristic cuts down the search.
Send a robot across a map with hidden walls, let it discover them as it drives, and watch its path repair itself by updating only the part of the search that changed.
Build a roadmap from obstacle corners that can see each other, or by splitting free space into cells, and compare the paths each one finds.
Let a robot slide downhill on a field that pulls it toward the goal and pushes it away from obstacles, and find where it gets stuck in a local minimum.
Scatter random samples through free space, connect each to its nearest neighbors, and search the resulting roadmap for a path, including through a narrow passage.
Grow a random tree from the start until it reaches the goal, then switch to RRT* and watch rewiring straighten the path as more samples arrive.
Drag and rotate a robot among obstacles and see how cheap bounding shapes rule out most collisions before any exact test is needed.
Take a jagged path from a grid planner, cut its corners with random shortcuts, then round it off into a smooth curve a robot can drive.
Fit a trajectory through draggable waypoints with straight segments, cubic splines, and quintic minimum-jerk segments, and compare their speed, acceleration, and jerk.
Turn a move of a set distance into a trajectory with a trapezoidal or an S-curve velocity profile, within limits on speed, acceleration, and jerk.
Find the shortest path between two poses for a car that can only turn with a limited radius, first forward only, then allowed to reverse.
Plan a parking maneuver for a car with a steering limit using Hybrid A*, which searches over position and heading with real driving arcs.
Drive a fast robot along a path with a sharp corner, see why a speed limit and an acceleration limit make the geometric path impossible, and plan a feasible speed profile.
Start with a straight path through obstacles and bend it away by minimizing a cost that rewards smoothness and penalizes getting close to obstacles, as in CHOMP and TrajOpt.
Inflate the obstacles on a map by the robot's radius plus a soft cost that fades with distance, and see how the planned path moves away from walls.
Watch a robot choose its next speed and turn rate by simulating many short possible motions, scoring them, and picking the best, while dodging moving obstacles.
Watch a global planner draw a route across a map while a local planner follows it and dodges a person who steps into the way, and see the global plan update when the way is blocked.
Send a robot into an unknown building and watch it map as it goes, always heading for the nearest frontier between known free space and unknown space.
Plan a lawnmower path that sweeps every part of an area around an obstacle, and compare it with random bouncing for the same time.
Send robots across a circle to swap places, first ignoring each other, then avoiding each other with velocity obstacles and the reciprocal version that shares the work.
Send a robot across a room full of walking people and compare the shortest route with one that respects personal space.
Plan in a gridworld where moves can slip and see value iteration find a policy that avoids risky edges, then decide whether a robot unsure of its location should look before it acts.
Build a security robot's behavior from a handful of states and the events that switch between them, and trigger the events yourself.
Build a robot's behavior from sequences, fallbacks, conditions, and actions, and watch the tree tick from the top, as in Nav2 and in video games.
Plan a block-stacking task from actions described by their preconditions and effects, and watch a search find the shortest sequence of steps.
Ask a robot to put a cup in a box when another object blocks the only grasp, and watch the planner find that it must move the blocker first.
Turn a spoken request into robot steps by combining a language model's idea of what is useful with the robot's own estimate of what it can actually do right now.
Match parallel-jaw, suction, three-finger, and soft grippers against a box, a ball, a plate, a bag of chips, and a mug, and see why each one works or fails.
Place two or three fingers on an object, set the friction, and test whether the grasp can resist a push from any direction, called force closure.
Score candidate parallel-jaw grasps on a depth image of a cluttered bin and keep the best ones, the way learned grasp detectors do.
Run a full pick and place, from seeing the object to letting it go, one stage at a time, and see what happens when the object moves partway through.
Steer a camera on a robot arm with what it sees, using image-based control that moves features straight across the image, and compare with pose-based control.
Push a peg into a tight hole that is slightly off from where the robot thinks it is, with stiff position control and with compliance, and compare the forces.
Push a box toward a goal with a single point contact and see how where you push decides whether it slides straight or spins away.
Rotate an object inside a three-finger hand by finger gaiting: lift one finger at a time, move it, and put it back down while the other two keep the grip.
Drag the end of a simulated cable around pegs and see why a floppy object, with a shape that changes everywhere at once, is so much harder to manipulate than a rigid one.
Coordinate two arms to carry a rigid bar together, keeping both hands locked to it, then pass an object from one hand to the other.
Reach a target with an arm mounted on a moving base, and set how much the robot prefers to move its wheels versus its arm.
Walk a four-legged robot with a slow crawl that always keeps three feet down, then switch to a trot that is always slightly falling and must keep moving to stay up.
Move and accelerate a walking robot's upper body and watch its zero moment point slide along the foot, and see the robot tip when the ZMP reaches the edge.
Push a walking robot modeled as an inverted pendulum and recover by stepping to its capture point, or watch it fall if it does not step.
Switch a four-legged robot between walk, trot, pace, bound, and gallop by changing the timing of its legs, and see coupled oscillators settle into each pattern.
Balance and steer a one-legged hopping robot by choosing where to put its foot down on each hop, the way Marc Raibert's hoppers did in the 1980s.
Give a three-link robot three tasks at once, reach a target, keep the elbow high, and hold a comfortable pose, and see which one gives way when they conflict.
Train a small balancing policy by trial and error in simulation, with and without randomized physics, and test both on a
Map a recorded human arm motion onto a robot arm with different link lengths and joint limits, by copying joint angles or by matching hand positions.
Make a humanoid walk while carrying a box held out in front, and see how it must lean back and shorten its steps as the box gets heavier.
Follow one moment of a self-driving car's software from sensor detections through predictions of other cars, to a chosen trajectory, to the steering command.
Fly a small fixed-wing drone with throttle and pitch, find the angle where its wing stalls, and bank it to turn.
Navigate an underwater robot without GPS, first by dead reckoning with a Doppler velocity log, then corrected by ranges to acoustic beacons.
Let many simple robots each copy the heading of their neighbors and watch the whole swarm come to agree, or break into groups when their sensing range is short.
Assist a walking leg with an exoskeleton motor, and see that the help only helps when its timing matches the gait cycle.
Drive a prosthetic hand from a muscle signal: rectify it, smooth it, and threshold it, then see the trade-off between noise and delay.
Control a surgical instrument through a fixed incision point, scale the surgeon's hand motion down, and filter out tremor.
Bend a two-section tendon-driven continuum robot into curved shapes, then switch to a snake robot that slithers forward with a traveling wave.
Drive a robot remotely across rough terrain with a communication delay, from a farm next door to Mars, and see why far-away robots need more autonomy.
Fit curves of growing complexity to noisy sensor data and watch the training error keep falling while the validation error turns back up.
Copy expert demonstrations of a reaching task with supervised learning, then roll out the learned policy and watch small errors carry it off the demonstrated path.
Fix behavior cloning's compounding errors by running the learned policy, asking the expert what it should have done in the states it actually reached, and retraining.
Record the same demonstration with a leader-follower arm, a VR controller, and hand tracking, and compare how smooth, how accurate, and how fast each interface is.
Compare a policy that predicts one action at a time with one that predicts a short chunk of future actions, with and without blending overlapping chunks, and see the jitter disappear.
Generate a robot's path by starting from random noise and removing the noise step by step, and see why this handles two equally good ways of doing a task better than averaging.
Generate robot paths by following a learned velocity field from noise straight to data, and compare how many steps it needs against diffusion.
Score a robot's route along a cliff in a gridworld, step by step, and see how the discount and the chance of slipping change which route earns the most.
Watch a Q-table fill in as an agent explores a cliff gridworld by trial and error, and see the greedy policy appear from the learned values.
Play a five-armed bandit where each arm pays off with a hidden probability, and compare greedy, epsilon-greedy, and optimistic UCB strategies by their regret.
Train a simple stochastic policy by nudging it toward actions that earned more than average, then compare plain policy gradients with PPO's clipped, safer updates at a high learning rate.
Write a reward for a cleaning robot, let an optimal agent maximize it, and watch it find a loophole, then fix the reward so the behavior you wanted is also the best one.
Tune a gripper's squeeze force in simulation, then test it on real objects whose friction differs, and see how training across many randomized simulators closes the gap.
Learn a model of how a robot responds to commands from a little data, then plan with that model, and compare how few real trials it needs against trial and error alone.
Learn a policy only from a fixed log of past robot behavior, and see why plain Q-learning trusts actions it never saw, while a conservative method stays with what the data supports.
Teach a robot what a good path through a room looks like by repeatedly choosing the better of two paths, and watch a reward model learn your hidden priorities.
Watch where many people's hands touch everyday objects across simulated videos, build an affordance map, and let a robot choose its grasp from it.
Pool demonstration data from many different robots into one shared action space and see how much less data a new robot needs to learn a task.
Ask a vision-language model questions about a robot's camera view: name the objects, point to one, plan the next step, or judge whether a task succeeded.
Follow an image and an instruction through a vision-language-action model to robot actions, and compare actions output as discrete tokens with smooth continuous actions.
Track a moving target with a big, slow vision-language model alone, then split the job between a slow planner and a small fast controller, and compare how well each keeps up.
Let a learned model imagine how a bouncing ball will move, compare its imagined future with reality, and see the prediction error grow the further ahead it dreams.
Have a model first imagine the future states that would achieve a goal, then recover the actions that connect them with an inverse dynamics model, and execute them.
Train a classifier on a few bright, real images of red and orange balls, then test it in dim light, and see how augmentation and synthetic images keep it working.
Adapt a pretrained model to a new task with a small dataset, by full fine-tuning, a low-rank adapter, or training only the last layer, and see how much each forgets and how replaying old data helps.
Estimate two policies' success rates from a limited number of real trials, put confidence intervals on them, and find how many trials it takes to tell them apart.
Train a delivery robot to move as fast as it can while keeping its risk of getting too close to people under a limit, using a learned penalty that adjusts itself, and compare with a safety shield.
Walk a person toward an industrial robot and see how each of the four collaborative operating modes keeps them safe: monitored stop, hand guiding, speed and separation monitoring, and power and force limiting.
Press the emergency stop on a moving robot arm using each stop category and compare how far it travels before it halts, then inject a fault into a single-channel and a dual-channel safety circuit.
Steer a robot toward one of several objects while it guesses which one you want and blends in help, more strongly as it grows confident.
Push a remote robot against a wall through a teleoperation link, with and without force feedback to the operator's hand, and add network delay to see why feedback can become unstable.
Draw a gesture for the robot and see it matched to the closest template, then watch the robot predict which object a person is reaching for before the hand gets there.
Watch a robot reach for one of two nearby objects with a predictable motion and with a legible motion that exaggerates its intent, and see how soon an observer can tell which one it wants.
Work through realistic robot deployment scenarios, see who is affected, which concerns arise, what design choices address them, and who is responsible when something goes wrong.
Follow one LiDAR reading up through the layers of a robot's software, from driver to perception to planning, and the resulting command back down to the motors, with the time each layer adds.
Connect ROS 2 nodes through topics, watch messages flow from publishers to every subscriber, and see what happens when a subscriber is too slow for the publishing rate.
Call a service and wait for its answer, send a long-running action goal and watch its feedback, cancel it, and change a node's parameter while it runs.
Move the frames of a mobile robot with an arm and a camera, then ask TF2 for the transform between any two frames and see which branches of the tree it chains together.
Send ROS 2 messages over a lossy wireless link and compare best-effort with reliable delivery, then let a late subscriber join and see what durability gives it.
Build a small robot arm from links and joints, change each joint's type, axis, and limits, and watch the URDF file and the robot update together.
Stack boxes in a simple physics engine and change the time step and the number of solver iterations to see when the stack sits still, jitters, sinks, or explodes.
Run a simulated twin alongside a real robot arm, compare what the twin predicts with what the robot actually does, and catch an unexpected payload when the two disagree.
Run a 1 kHz control loop on an ordinary operating system and on a real-time one, look at the spread of loop periods, and see how missed deadlines disturb a balancing controller.
Fuse a 30 Hz camera with a 10 Hz LiDAR by pairing their messages by timestamp, compare exact and approximate matching, and see how a mismatched pair misplaces a moving object.
Record a robot run into a bag file, then scrub through it, replay it at different speeds, and replay a failure exactly to find its cause.
Place a robot's perception, planning, and language models on the onboard computer, a nearby GPU server, or the cloud, and check whether the end-to-end delay fits the control loop's budget.
Longer guides you can read on screen or print. Every link inside is clickable.
A six-month self-study roadmap with curated resources, practice projects, and milestones. It assumes no prior electronics background and about two to three hours of work per day.
Adapted from work by Ronin (@deronin_) on X. The original ideas and structure are the original author's work.
Documentation, tools, courses, and help for the TurtleBot 4 on ROS 2 Jazzy and Ubuntu 24.04. Covers setup and networking, driving, sensors, simulation, mapping and navigation, and common fixes.
Original handout, written for this collection.
Ready to go further? The roadmap handout breaks robotics into six monthly steps, each with a goal and a signature build. Keep every build in its own GitHub repository, with a photo, your measured results, and a note on what broke and how you fixed it.
Read a schematic, build a working circuit, and find faults.
Build a robot that moves, senses, and corrects itself.
Design a part, make it, and have it fit.
Simulate a robot that maps and navigates on its own.
Understand the math under the libraries.
Pick a direction, finish a portfolio piece, and apply.