Pure Pursuit

Every self-driving car, warehouse robot, and autonomous lawn mower shares a humble ancestor: a 1992 report from Carnegie Mellon titled "Implementation of the Pure Pursuit Path Tracking Algorithm." The idea inside is disarmingly simple.

Imagine you are driving and you fix your eyes on a point some distance ahead on the road. You don't plan the whole journey — you just steer toward that point, let the car move, pick a new point ahead, and repeat. That loop, executed dozens of times per second, is Pure Pursuit.

The algorithm was formalized by R. Craig Coulter for the NavLab autonomous vehicles project. It belongs to the family of geometric controllers: no sensor fusion, no predictive model, no optimization — just Euclidean geometry applied repeatedly. A circle through the vehicle's current position and the look-ahead point determines the exact steering angle needed.

The one free parameter you choose is the look-ahead distance $L_d$. Small $L_d$ and the vehicle hugs tight corners but oscillates on straights. Large $L_d$ and motion is smooth but corners are cut. That single knob is where all the engineering judgement lives.

The car below follows a closed oval track using Pure Pursuit. The orange dot is the look-ahead point — the spot on the path one look-ahead distance ahead of the car. The car always steers toward it.

<!-- {{c_html_intro}} -->
<div class="controls">
  <label for="ld-slider">{{lbl_lookahead}}: <span id="ld-val">60</span>px</label>
  <input id="ld-slider" type="range" min="20" max="140" value="60" step="5">
  <button id="btn-reset" type="button">{{btn_reset}}</button>
</div>
<canvas id="track" width="480" height="320"></canvas>
<div class="status" id="status">{{status_running}}</div>

/* {{c_css_intro}} */
* { box-sizing: border-box; }
body { font-family: system-ui, sans-serif; margin: 0; color: #222; }
.controls {
  display: flex; align-items: center; gap: .7rem; flex-wrap: wrap;
  margin-bottom: .6rem; font-size: .9rem;
}
label { font-weight: 600; white-space: nowrap; }
input[type=range] { width: 130px; accent-color: #1d3557; cursor: pointer; }
button {
  font: 600 13px system-ui; padding: .35rem .8rem;
  border: 1px solid #1d3557; background: #1d3557;
  color: #fff; border-radius: 6px; cursor: pointer;
}
canvas {
  display: block; border-radius: 10px;
  border: 1px solid #cdd9e3; background: #f5f8fb;
  max-width: 100%;
}
.status {
  margin-top: .5rem; font-size: .9rem; font-weight: 600; color: #1d3557;
  min-height: 1.3em;
}

// Code not found

Drag the Look-ahead slider and watch what changes. A short look-ahead makes the car react sharply to every bend; a long one smooths the ride but clips the corners. The algorithm computes a circular arc from the car's position through the look-ahead point, and the curvature of that arc becomes the steering command.

Pure Pursuit's steering law comes from a single geometric fact. Transform the coordinate system so the vehicle sits at the origin facing right. The look-ahead point $(x, y)$ lies on the path a distance $L_d$ away. The unique circle passing through both the origin (vehicle) and $(x, y)$ that is tangent to the vehicle's heading has radius:

$$R = \frac{L_d^2}{2 \lvert y \rvert}$$

Curvature is the reciprocal: $\kappa = \frac{2 \lvert y \rvert}{L_d^2}$.

For a vehicle with wheelbase $W$ (distance between axles), the front-wheel steering angle $\delta$ satisfies $\tan \delta = W \kappa$, giving:

$$\delta = \arctan\!\left(\frac{2 W \lvert y \rvert}{L_d^2}\right)$$

where $y$ is the lateral offset of the look-ahead point in the vehicle's frame. Positive $y$ means steer left; negative means steer right. That is the entire algorithm — one formula, executed at every timestep.

Stability and convergence. Pure Pursuit is not derived from control theory; it is purely geometric. For a straight path it converges exponentially, but on tight curves with a large $L_d$ it can develop a sustained chordal error (cutting the corner). The parameter $L_d$ is often made speed-dependent — $L_d = k \cdot v$ for some constant $k$ — so the look-ahead scales with how fast the vehicle is moving, maintaining the same reaction time regardless of speed.

Pure Pursuit's simplicity makes it surprisingly durable in real systems:

• Autonomous cars (low-speed): parking lots, campus shuttles, and warehouse AGVs rely on Pure Pursuit because it is easy to tune and robust to small localization errors.
• Agricultural robotics: tractors and harvesters follow GPS waypoints at low speed on predictable terrain — exactly the regime where Pure Pursuit shines.
• Competitive robotics: Formula Student Driverless teams frequently use Pure Pursuit as their baseline path-following controller before adding more sophisticated planners.
• Drone waypoint navigation: UAVs following a horizontal ground track apply the same circular-arc geometry in the horizontal plane.
• Teaching control theory: Pure Pursuit is the canonical first example before introducing PID, LQR, and model-predictive control — its visual clarity makes the feedback loop tangible.

More sophisticated controllers (Stanley, MPC, LQR) outperform Pure Pursuit on high-speed or dynamically unstable vehicles, but for the vast majority of mobile robots that move slowly over known paths, Pure Pursuit remains the first tool engineers reach for.

Pure Pursuit is a reminder that the best algorithms are not always the most complex. A car steers toward a point ahead on the path, moves a little, picks a new point, and repeats — and from that loop emerges smooth, reliable path following across farms, warehouses, and campuses worldwide.

The single free parameter, look-ahead distance $L_d$, encodes the entire trade-off between agility and smoothness. Tune it well and the vehicle tracks any curve; tune it poorly and it oscillates or cuts corners. That simplicity is also a limitation: when vehicles move fast, when paths curve sharply, or when dynamics matter, engineers reach for richer controllers. But as a foundation — and as an introduction to the geometry of autonomous navigation — Pure Pursuit has no equal.