SLAM

Imagine dropping a robot into a room it has never seen. Your task: let it navigate safely without giving it a blueprint. To navigate, the robot needs a map of its surroundings. But to build that map, it needs to know where it is. And to know where it is, it needs — a map.

This circular dependency is called the SLAM problem: Simultaneous Localization And Mapping. It is not a paradox but a hard computational challenge: solve both halves together, from nothing, using only noisy sensor readings.

Every time a self-driving car merges onto a highway, a vacuum robot recharges itself, or a Mars rover avoids a boulder, something close to SLAM is running underneath. The insight that drove it from science-fiction to real products is one of the great stories in modern robotics.

Below is a simplified SLAM simulation. A robot (triangle) moves through a room with four landmark beacons (circles). Its sensors measure the distance to each beacon, but with random noise — the readings are never exact.

<!-- {{c_html_intro}} -->
<div class="slam-wrap">
  <canvas id="slam-canvas" width="360" height="300"></canvas>
  <div class="info-panel">
    <div class="info-row"><span class="dot true-dot"></span> {{label_true_pos}}</div>
    <div class="info-row"><span class="dot est-dot"></span> {{label_est_pos}}</div>
    <div class="info-row"><span class="dot lm-dot"></span> {{label_landmark}}</div>
  </div>
  <div class="status" id="status">{{status_ready}}</div>
  <div class="btns">
    <button id="btn-step" type="button">{{btn_step}}</button>
    <button id="btn-run" type="button">{{btn_run}}</button>
    <button id="btn-reset" type="button" class="ghost">{{btn_reset}}</button>
  </div>
</div>

/* {{c_css_intro}} */
* { box-sizing: border-box; margin: 0; padding: 0; }
body { font-family: system-ui, sans-serif; color: #222; }
.slam-wrap { display: flex; flex-direction: column; align-items: flex-start; gap: .5rem; padding: .4rem 0; }
canvas { border: 1px solid #cdd9e3; border-radius: 8px; background: #f4f7fa; display: block; }
.info-panel { display: flex; gap: 1rem; font-size: .82rem; color: #555; flex-wrap: wrap; }
.info-row { display: flex; align-items: center; gap: .3rem; }
.dot { width: 12px; height: 12px; border-radius: 50%; display: inline-block; }
.true-dot { background: #2a9d5c; }
.est-dot  { background: #1d6fa0; }
.lm-dot   { background: #e07b00; border: 2px solid #e07b00; border-radius: 50%; }
.status { font-size: .9rem; font-weight: 600; min-height: 1.3em; color: #333; }
.btns { display: flex; gap: .5rem; flex-wrap: wrap; }
button { font: 600 14px system-ui, sans-serif; padding: .4rem .85rem;
         border: 1px solid #1d3557; background: #1d3557; color: #fff;
         border-radius: 8px; cursor: pointer; }
button.ghost { background: #fff; color: #1d3557; }
button:disabled { opacity: .45; cursor: not-allowed; }

// Code not found

Press Step to move the robot one step. Its estimated position (blue) drifts from the true position (green) because sensor noise accumulates. Each landmark observation partially corrects both the position estimate and the landmark map. Press Run to animate the full loop, or Reset to start over. Notice how the estimated trail tightens around the true path as more observations come in — that is SLAM's core loop at work.

SLAM was considered nearly intractable for a long time. The difficulty is not the algorithm itself — it is the cost of maintaining uncertainty.

• Extended Kalman Filter (EKF) SLAM (Smith, Self & Cheeseman, 1986) was the first principled solution. It keeps a joint probability distribution over the robot pose and every landmark position. Updating it after each sensor reading costs $O(n^2)$ time and $O(n^2)$ memory in the number of landmarks $n$. With thousands of landmarks a room-sized map already hits hard limits.
• Particle filters (FastSLAM, Montemerlo et al., 2002) represent uncertainty as a cloud of weighted hypotheses. Each particle carries its own map. The cost per step drops to $O(n \log n)$ per particle, but you need enough particles to cover the hypothesis space — still expensive outdoors.
• Graph-based (pose-graph) SLAM reformulates the problem as a sparse least-squares optimization. Poses become nodes, sensor readings become edges. Modern solvers (g2o, iSAM2) exploit sparsity to achieve near-linear time, making large-scale real-time SLAM practical.
• Loop closure is the hardest sub-problem: recognizing that a place already visited has been seen before, and correcting a drift that may have accumulated over hundreds of meters. A single missed or false loop closure can fold the map onto itself.

The journey from $O(n^2)$ EKF-SLAM to real-time graph SLAM mirrors a pattern seen across algorithms: finding and exploiting the sparse structure hidden in a problem that looks dense. It connects naturally to ideas in Bayesian inference and dynamic shortest paths.

Any agent that moves through an unknown environment and needs to know where it is uses something from SLAM's toolbox:

• Self-driving vehicles: LiDAR-based SLAM builds and updates a 3-D map of the road in real time, centimeter by centimeter, while simultaneously tracking the car's pose inside it.
• Warehouse and logistics robots: systems like Amazon's Kiva robots navigate dynamic environments without fixed infrastructure, relying on visual or laser SLAM to replan routes on the fly.
• Surgical robotics: laparoscopic cameras feed SLAM-like algorithms that track tissue deformation and tool position inside the body without external trackers.
• Augmented and mixed reality: headsets (HoloLens, Quest) run visual-inertial SLAM at hundreds of frames per second so virtual objects stay anchored in real space as you move.
• Planetary exploration: the Mars rovers Curiosity and Perseverance use on-board SLAM variants because the 20-minute radio delay makes remote piloting impossible — the rover must understand its own location.

Wherever a machine needs to act in a space it has never seen and cannot be manually mapped in advance, SLAM — or one of its descendants — is the enabling technology.

SLAM is a lesson in living with uncertainty. The robot does not need a perfect map to move, nor a perfect position to map. It needs a disciplined way to track how wrong each estimate might be — and to update both estimates together whenever a new sensor reading arrives.

That shift from "find the exact answer" to "maintain a well-calibrated distribution over answers" is the same move that powers modern Bayesian inference. Pair it with the sparse-graph insight that cut the cost from quadratic to near-linear, and you have a problem that once seemed unsolvable running in real time on a rolling suitcase in a shopping mall.

The next time a robot vacuum finds its dock in the dark, remember: it solved a chicken-and-egg problem in milliseconds, thousands of times over, and got home anyway.