Introduction

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.

Try It

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.

<!-- SLAM demo — robot navigates a room with 4 landmark beacons, sensor readings are noisy -->
<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> True path</div>
    <div class="info-row"><span class="dot est-dot"></span> Estimated path</div>
    <div class="info-row"><span class="dot lm-dot"></span> Landmark (true ○ / estimated ●)</div>
  </div>
  <div class="status" id="status">Press Step or Run to start the simulation.</div>
  <div class="btns">
    <button id="btn-step" type="button">Step</button>
    <button id="btn-run" type="button">Run</button>
    <button id="btn-reset" type="button" class="ghost">Reset</button>
  </div>
</div>

/* Layout and colors for the SLAM demo canvas and controls */
* { 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; }

const i18nFmt = (s, v) => s.replace(/%(\w+)%/g, (_, k) => String(v[k] ?? ''));
/* Simplified EKF-style SLAM — motion model + range-only observation update */

/* Simulation constants */
const W = 360, H = 300;
const SCALE = 60; /* pixels per world unit */
const NOISE_MOVE = 0.08; /* motion noise sigma (world units) */
const NOISE_OBS  = 0.18; /* observation noise sigma (world units) */
const MAX_STEPS  = 20;

/* True landmark positions (never given to the robot directly) */
const LANDMARKS_TRUE = [
  { x: 1.0, y: 1.0 },
  { x: 5.0, y: 1.0 },
  { x: 5.0, y: 4.0 },
  { x: 1.0, y: 4.0 }
];

/* Planned waypoints the robot follows (its true trajectory) */
const WAYPOINTS = [
  { x: 1.5, y: 1.5 }, { x: 3.0, y: 1.5 }, { x: 4.5, y: 1.5 },
  { x: 4.5, y: 2.5 }, { x: 4.5, y: 3.5 }, { x: 3.0, y: 3.5 },
  { x: 1.5, y: 3.5 }, { x: 1.5, y: 2.5 }, { x: 1.5, y: 1.5 },
  { x: 3.0, y: 2.5 }, { x: 4.0, y: 2.0 }, { x: 2.0, y: 2.0 },
  { x: 3.0, y: 3.0 }, { x: 3.0, y: 2.5 }, { x: 2.0, y: 3.0 },
  { x: 4.0, y: 3.0 }, { x: 3.0, y: 2.0 }, { x: 3.0, y: 2.5 },
  { x: 1.8, y: 2.0 }, { x: 3.0, y: 1.8 }
];

/* Box-Muller transform for Gaussian noise */
function randGauss(sigma) {
  let u = 0, v = 0;
  while (!u) u = Math.random();
  while (!v) v = Math.random();
  return sigma * Math.sqrt(-2 * Math.log(u)) * Math.cos(2 * Math.PI * v);
}

/* Euclidean distance helper */
function dist(a, b) { return Math.sqrt((a.x - b.x) ** 2 + (a.y - b.y) ** 2); }

/* Simulation state variables */
let step, truePos, estPos, truePath, estPath, lmEst, running, rafId;

function initState() {
  step     = 0;
  truePos  = { x: WAYPOINTS[0].x, y: WAYPOINTS[0].y };
  estPos   = { x: WAYPOINTS[0].x + randGauss(0.05), y: WAYPOINTS[0].y + randGauss(0.05) };
  truePath = [{ ...truePos }];
  estPath  = [{ ...estPos }];
  /* Landmark estimates start with large uncertainty */
  lmEst    = LANDMARKS_TRUE.map(lm => ({
    x: lm.x + randGauss(0.4),
    y: lm.y + randGauss(0.4)
  }));
  running  = false;
  rafId    = null;
}

/* One SLAM step — move then correct from observations */
function slamStep() {
  if (step >= MAX_STEPS - 1) { stopRun(); return; }
  step++;
  const wp = WAYPOINTS[step];

  /* Apply motion (true) + add noise to estimate */
  const dx = wp.x - truePos.x;
  const dy = wp.y - truePos.y;
  truePos = { x: wp.x, y: wp.y };
  estPos  = {
    x: estPos.x + dx + randGauss(NOISE_MOVE),
    y: estPos.y + dy + randGauss(NOISE_MOVE)
  };
  truePath.push({ ...truePos });
  estPath.push({ ...estPos });

  /* Observation update — each landmark reading corrects both pose and map */
  /* Range-only update: measured distance corrects landmark position and robot pose */
  LANDMARKS_TRUE.forEach((lm, i) => {
    const dTrue = dist(truePos, lm);
    const measuredDist = dTrue + randGauss(NOISE_OBS);
    const dEst  = dist(estPos, lmEst[i]);
    if (dEst < 0.01) return;
    /* simple scalar gain (full EKF would use Kalman gain matrix) */
    const gain = 0.3;
    const err  = measuredDist - dEst;
    const nx   = (lmEst[i].x - estPos.x) / dEst;
    const ny   = (lmEst[i].y - estPos.y) / dEst;
    lmEst[i].x += gain * err * nx;
    lmEst[i].y += gain * err * ny;
    estPos.x   -= gain * err * nx * 0.4;
    estPos.y   -= gain * err * ny * 0.4;
  });

  draw();
  const posErr = dist(truePos, estPos).toFixed(2);
  document.getElementById('status').textContent =
    i18nFmt('Step %n% / %total% — position error: %err% units', { n: step, total: MAX_STEPS - 1, err: posErr });
}

/* Canvas rendering helpers */
function toCanvas(p) { return { x: p.x * SCALE + 20, y: H - (p.y * SCALE + 20) }; }

function draw() {
  const canvas = document.getElementById('slam-canvas');
  const ctx = canvas.getContext('2d');
  ctx.clearRect(0, 0, W, H);

  /* Background grid */
  ctx.strokeStyle = '#dde4ec';
  ctx.lineWidth = 0.8;
  for (let gx = 0; gx <= 6; gx++) {
    const cx = gx * SCALE + 20;
    ctx.beginPath(); ctx.moveTo(cx, 0); ctx.lineTo(cx, H); ctx.stroke();
  }
  for (let gy = 0; gy <= 5; gy++) {
    const cy = H - (gy * SCALE + 20);
    ctx.beginPath(); ctx.moveTo(0, cy); ctx.lineTo(W, cy); ctx.stroke();
  }

  /* Draw ground-truth robot path (green solid) */
  if (truePath.length > 1) {
    ctx.strokeStyle = '#2a9d5c'; ctx.lineWidth = 1.8; ctx.setLineDash([]);
    ctx.beginPath();
    truePath.forEach((p, i) => {
      const c = toCanvas(p);
      i === 0 ? ctx.moveTo(c.x, c.y) : ctx.lineTo(c.x, c.y);
    });
    ctx.stroke();
  }

  /* Draw estimated robot path (blue dashed) */
  if (estPath.length > 1) {
    ctx.strokeStyle = '#1d6fa0'; ctx.lineWidth = 1.5; ctx.setLineDash([4, 3]);
    ctx.beginPath();
    estPath.forEach((p, i) => {
      const c = toCanvas(p);
      i === 0 ? ctx.moveTo(c.x, c.y) : ctx.lineTo(c.x, c.y);
    });
    ctx.stroke();
    ctx.setLineDash([]);
  }

  /* Draw true landmark positions (orange rings) */
  LANDMARKS_TRUE.forEach(lm => {
    const c = toCanvas(lm);
    ctx.beginPath(); ctx.arc(c.x, c.y, 7, 0, 2 * Math.PI);
    ctx.strokeStyle = '#e07b00'; ctx.lineWidth = 2; ctx.stroke();
  });

  /* Draw estimated landmark positions (faint orange fill) */
  lmEst.forEach(lm => {
    const c = toCanvas(lm);
    ctx.beginPath(); ctx.arc(c.x, c.y, 4, 0, 2 * Math.PI);
    ctx.fillStyle = 'rgba(224,123,0,0.35)'; ctx.fill();
  });

  /* Draw sensor lines from robot to landmarks */
  LANDMARKS_TRUE.forEach((lm, i) => {
    const ct = toCanvas(truePos);
    const cl = toCanvas(lm);
    ctx.strokeStyle = 'rgba(42,157,92,0.18)'; ctx.lineWidth = 1; ctx.setLineDash([2, 3]);
    ctx.beginPath(); ctx.moveTo(ct.x, ct.y); ctx.lineTo(cl.x, cl.y); ctx.stroke();
    const ce = toCanvas(estPos);
    const ce2 = toCanvas(lmEst[i]);
    ctx.strokeStyle = 'rgba(29,111,160,0.18)';
    ctx.beginPath(); ctx.moveTo(ce.x, ce.y); ctx.lineTo(ce2.x, ce2.y); ctx.stroke();
    ctx.setLineDash([]);
  });

  /* Draw true robot as green triangle */
  (function drawRobot(p, color) {
    const c = toCanvas(p);
    ctx.fillStyle = color;
    ctx.beginPath();
    ctx.moveTo(c.x, c.y - 9);
    ctx.lineTo(c.x - 6, c.y + 6);
    ctx.lineTo(c.x + 6, c.y + 6);
    ctx.closePath(); ctx.fill();
  })(truePos, '#2a9d5c');

  /* Draw estimated robot as blue triangle */
  (function drawRobot(p, color) {
    const c = toCanvas(p);
    ctx.fillStyle = color;
    ctx.beginPath();
    ctx.moveTo(c.x, c.y - 9);
    ctx.lineTo(c.x - 6, c.y + 6);
    ctx.lineTo(c.x + 6, c.y + 6);
    ctx.closePath(); ctx.fill();
  })(estPos, '#1d6fa0');
}

/* Run/pause/reset logic */
function stopRun() {
  running = false;
  if (rafId) { cancelAnimationFrame(rafId); rafId = null; }
  document.getElementById('btn-run').textContent = 'Run';
  document.getElementById('btn-step').disabled = (step >= MAX_STEPS - 1);
}

function runLoop() {
  if (!running) return;
  slamStep();
  if (step < MAX_STEPS - 1) {
    rafId = setTimeout(() => requestAnimationFrame(runLoop), 350);
  } else {
    stopRun();
    document.getElementById('status').textContent =
      i18nFmt('Done! Final position error: %err% units', { err: dist(truePos, estPos).toFixed(2) });
  }
}

document.getElementById('btn-step').addEventListener('click', () => {
  if (running) return;
  slamStep();
  if (step >= MAX_STEPS - 1)
    document.getElementById('btn-step').disabled = true;
});

document.getElementById('btn-run').addEventListener('click', () => {
  if (running) { stopRun(); return; }
  if (step >= MAX_STEPS - 1) return;
  running = true;
  document.getElementById('btn-run').textContent = 'Pause';
  runLoop();
});

document.getElementById('btn-reset').addEventListener('click', () => {
  stopRun();
  initState();
  draw();
  document.getElementById('status').textContent = 'Press Step or Run to start the simulation.';
  document.getElementById('btn-step').disabled = false;
  document.getElementById('btn-run').textContent = 'Run';
});

/* Initialize and draw initial scene */
initState();
draw();
Result
Console

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.

The Real Complexity

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(n2)O(n^2) time and O(n2)O(n^2) memory in the number of landmarks nn. 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(nlog⁡n)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(n2)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.

Where It Matters

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.

Conclusion

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.

Share this article

Pick a channel — or use your device's native share sheet.

Comments

Loading comments...

https://www.kipuhub.com/en/article/slam/Content licensed under CC BY-NC 4.0.