The Root Locus

Every feedback controller — a thermostat, a cruise control, a drone's autopilot — has at least one gain: a number that says how hard the system reacts to an error. Crank it up and the response gets faster. Crank it up too far and the same system can start to oscillate, or fly apart.

The reason lives in the poles of the closed-loop system: the roots of its characteristic equation, plotted as points in the complex plane (the s-plane). A system is stable exactly when every pole sits in the left half of that plane. As the gain $K$ increases from $0$ to $\infty$, each pole traces a continuous path. The root locus is the complete picture of those paths — drawn once, valid for every value of $K$ at a glance.

It was invented in 1948 by engineer Walter R. Evans, before anyone had a computer to simulate a control loop, as a way to see stability instead of computing it point by point. Decades later it is still the fastest way to build intuition for what a gain knob actually does.

Below is the open-loop system $G(s)H(s) = \dfrac{K}{s(s+2)(s+4)}$, a textbook three-pole plant. The three × marks are its open-loop poles at $s = 0, -2, -4$. Drag the slider to raise $K$ from $0$ and watch the closed-loop poles (the dots) slide along the locus.

<p class="hint">{{hint_para}}</p>
<div class="wrap">
  <svg id="plane" viewBox="0 0 460 360" class="plane"></svg>
  <div class="side">
    <label class="glabel" for="gain">{{gain_label}}</label>
    <input id="gain" type="range" min="0" max="70" step="0.5" value="0">
    <div class="gval" id="gval">K = 0.0</div>
    <div class="status" id="status">{{status_stable}}</div>
    <button id="reset" type="button" class="ghost">{{btn_reset}}</button>
  </div>
</div>

* { box-sizing: border-box; }
body { font-family: system-ui, sans-serif; color: #222; margin: 0; }
.hint { font-size: .9rem; color: #444; margin: 0 0 .7rem; line-height: 1.45; }
.wrap { display: flex; gap: 1rem; flex-wrap: wrap; align-items: flex-start; }
.plane { width: 100%; max-width: 460px; height: auto; background: #f7f9fb; border: 1px solid #d7dee5; border-radius: 8px; }
.side { flex: 1; min-width: 180px; display: flex; flex-direction: column; gap: .5rem; }
.glabel { font-size: .85rem; font-weight: 600; color: #1d3557; }
input[type="range"] { width: 100%; }
.gval { font: 700 15px ui-monospace, monospace; color: #1d3557; }
.status { font-size: .95rem; font-weight: 700; padding: .4rem .6rem; border-radius: 6px; min-height: 1.4em; }
.status.ok { color: #0a7d33; background: #e5f6ea; }
.status.bad { color: #c92f3c; background: #fdeaec; }
button { font: 600 14px system-ui, sans-serif; padding: .45rem .9rem; border: 1px solid #1d3557;
         background: #fff; color: #1d3557; border-radius: 8px; cursor: pointer; align-self: flex-start; }

// Code not found

Two branches leave the real axis, curve upward and downward, and race toward the imaginary axis. Watch the status readout: at a precise critical gain the pair crosses into the right half-plane and the status flips from stable to unstable. Nothing about the plant changed — only how hard the controller reacts to error. That crossing point is exactly what a control engineer must find before shipping a design.

The root locus is not a numerical trick — it falls directly out of the algebra of feedback.

• The setup. A unity-feedback loop with open-loop transfer function $G(s)H(s)$ has closed-loop poles wherever $1 + K\,G(s)H(s) = 0$, i.e. $K\,G(s)H(s) = -1$. That single complex equation must hold for every point on the locus, for some $K \geq 0$.
• Two conditions, one plot. Splitting $-1$ into magnitude and angle gives the angle condition, $\angle G(s)H(s) = 180^\circ \pmod{360^\circ}$, which alone determines the shape of the locus (it doesn't involve $K$), and the magnitude condition, $K = 1/|G(s)H(s)|$, which tells you which $K$ places a pole at a given point on that shape.
• A few rules sketch the whole thing. The locus starts ($K=0$) at the open-loop poles and ends ($K \to \infty$) at the open-loop zeros or at infinity; it always lies on the real axis to the left of an odd number of real poles/zeros; branches that go to infinity do so along asymptotes centered at $\sigma = \dfrac{\sum \text{poles} - \sum \text{zeros}}{n - m}$; and two real branches that meet break away from the axis at a point where $dK/ds = 0$.
• Finding the instability threshold exactly. For our example, $1 + K\,G(s)H(s)=0$ expands to $s^3 + 6s^2 + 8s + K = 0$. The Routh–Hurwitz criterion turns that cubic into a table whose first column must stay positive for stability; it stays positive only while $K < 48$. At $K = 48$ the locus crosses the imaginary axis at $s = \pm j\sqrt{8}$ — the system rings forever at that frequency — and for any $K$ above it, two poles sit in the right half-plane and every response grows without bound.

None of this needs a simulation. A handful of algebraic rules — first written down by Evans with pencil, ruler and a protractor — pin down the entire family of closed-loop behaviors before a single line of the controller is built.

Any engineered system that senses its own output and corrects itself runs into the same question: how much correction is too much?

• Controller tuning: choosing a proportional, PI or PID gain is choosing a point on the root locus — engineers pick the gain that lands the dominant poles where the response is fast but not too oscillatory.
• Compensator design: adding a lead or lag compensator reshapes the whole locus, bending branches away from instability or pulling them toward a faster, better-damped region.
• Aerospace and robotics: autopilots, drone stabilizers and robot-arm controllers all use root-locus analysis to certify that a design stays stable across its entire operating range of gains.
• Power and process systems: grid frequency regulators and industrial process loops rely on the same picture to avoid the hunting and oscillation that too much feedback gain can trigger.

The specific plant changes — a plane, a motor, a chemical reactor — but the question "where do my poles go as I turn up the gain?" is the same one Evans answered with a single hand-drawn curve.

The root locus compresses an infinite family of "what if I set the gain to $K$?" questions into one drawing. Follow a branch far enough and you can read off, at a glance, the exact gain that turns a calm, well-behaved system into one that oscillates or diverges.

It is a solved problem from 1948, not an open one — but it is a reminder that the boundary between stable and unstable is often just a curve away, and that with the right algebra you can see it coming before you ever build the system. For the algebraic machinery this rests on, see state-space models and the closely related question of controllability and observability.