SLAM

SLAM is the technique a robot uses to build a map of an unfamiliar place — while figuring out where it is on that map. Both at the same time. The letters stand for Simultaneous Localization And Mapping.

The blindfolded warehouse problem

Imagine being dropped into a dark warehouse, blindfolded, with nothing but a flashlight and a sketchpad. Every step you take, you mark on the pad what you can see in the flashlight beam. After a while, you have a real map of the warehouse — and you know exactly where you are on it. You did both at once. That's SLAM.

This is harder than it sounds, because if your steps are even slightly off (say you thought you walked exactly one metre but actually walked 1.05 metres), errors pile up. Walk for 100 metres and you might be 5 metres off. After a long enough walk, the map you've drawn no longer matches reality.

How robots do it

Real robots use sensors instead of flashlights. The three most common ones for SLAM are:

Lidar — a laser that spins around 360°, measuring distance to every wall and object up to 30+ metres away. Very accurate. Used by most self-driving cars, vacuum robots, and warehouse robots.

Cameras — using one or two cameras and tracking visual features (a corner of a doorway, a unique pattern on a wall). Cheaper, but harder to compute. Tesla famously uses cameras only.

Depth cameras — like Microsoft's Kinect or Intel's RealSense. They give you a 3D point cloud directly, which makes SLAM easier than with regular cameras.

The robot's computer takes thousands of sensor readings per second and runs an algorithm — usually a particle filter, a Kalman filter, or a graph-optimization technique — that keeps the map and the position consistent.

Loop closure: the magic step

The biggest moment in any SLAM run is loop closure — when the robot recognizes "wait, I've been here before." At that instant, all the small errors that built up over the journey can be corrected at once. The map snaps into shape. Modern SLAM systems are mostly about how well they detect and use loop closures.

Where SLAM matters

Anywhere a robot needs to move around a place it doesn't already have a perfect map of. Your Roomba runs SLAM every time it cleans. A Mars rover uses SLAM because there's no GPS on Mars. A surgical robot uses a kind of SLAM inside the body. Even some AR headsets (Apple Vision Pro, Meta Quest) run SLAM continuously, because they need to know exactly where you are in your room to overlay digital objects.

What's hard about it

SLAM works beautifully when the world stays still. As soon as people walk around, or chairs get moved, or lighting changes drastically — the robot can get confused. The current research frontier is dynamic SLAM (handling moving things) and lifelong SLAM (keeping a useful map of a place that changes over months and years).

Front-end and back-end: how a SLAM system is actually built

Every modern SLAM system splits into two halves.

The front-end turns raw sensor data into geometric constraints. It extracts features (lidar scan segments, camera keypoints like ORB), matches them frame-to-frame to estimate motion (odometry), and — critically — decides data association: which observation corresponds to which real-world landmark. Bad data association is the single biggest cause of SLAM failure; one wrong match can warp the whole map.

The back-end takes those constraints and finds the poses and landmark positions that best fit all of them at once. This is where the real estimation lives, and there are two dominant families:

• Filtering (EKF-SLAM, FastSLAM). Keep one running estimate of the state — the robot pose plus every landmark — and update it with each measurement. The classic problem: a full Kalman filter over N landmarks costs O(N²) per step, so it doesn't scale to large maps. FastSLAM uses a particle filter to sidestep this.
• Graph-based / smoothing (pose-graph optimization, factor graphs). Treat every pose and landmark as a node and every measurement as an edge (a constraint) in a graph, then solve one big nonlinear least-squares problem: minimize the total mismatch across all edges. This is what essentially all production systems use today, because it's more accurate and handles loop closures cleanly.

The math, in one line

Graph SLAM minimizes the sum of squared constraint errors:

X* = argmin  Σ ‖ f(xᵢ, xⱼ) ⊖ zᵢⱼ ‖²_Σ
        X    i,j

xᵢ are the unknown poses/landmarks, zᵢⱼ is a measured relative transform between them, f(·) predicts that measurement from the current estimate, and Σ weights each constraint by its uncertainty. Solvers (Gauss-Newton, Levenberg-Marquardt) exploit the fact that this matrix is sparse — each pose only touches a few others — which is why a graph with 100,000 poses can still be optimized in real time. Libraries: g2o, GTSAM, Ceres.

Loop closure, more precisely

Detecting "I've been here before" is a place-recognition problem, usually solved with a bag-of-visual-words model (DBoW2) for cameras or scan-context descriptors for lidar. When a candidate loop is found, the system adds one edge between the current pose and the old one; the back-end then redistributes the accumulated drift across the whole loop. Because a false loop closure is catastrophic, systems add a geometric verification step (RANSAC) before trusting one.

Systems you'll actually meet

• slam_toolbox — the default 2D lidar SLAM in ROS2 Nav2; graph-based, supports lifelong mapping.
• Cartographer (Google) — real-time 2D/3D lidar SLAM with submap-based loop closure.
• ORB-SLAM3 — the reference visual/visual-inertial SLAM; feature-based, excellent loop closing.
• LIO-SAM / FAST-LIO2 — tightly-coupled lidar-inertial odometry for drones and cars.

How SLAM quality is measured

Two standard metrics compare the estimated trajectory against ground truth: ATE (Absolute Trajectory Error — global consistency after alignment) and RPE (Relative Pose Error — local drift over short segments). Benchmarks like KITTI, EuRoC, and TUM-RGBD are how papers prove a new method is actually better.

Check your understanding

1. Why does classic EKF-SLAM struggle in large environments? The covariance matrix couples every landmark, so each update is O(N²) in the number of landmarks — cost explodes as the map grows. Graph/particle methods avoid the full dense covariance.

2. What is "data association" and why is it the front-end's hardest job? Deciding which current observation matches which previously-seen landmark. A single wrong match injects a false constraint that the back-end faithfully bakes into the map, corrupting it.

3. After a loop closure, why does the whole map improve, not just the current pose? The closure adds a constraint linking now to a much earlier pose; the back-end re-optimizes the entire graph, spreading the correction backward across every pose in the loop.

---

Curious how a lidar actually measures distance with light? Read Lidar.