Skip to content
LumenaryAcademy
Systems 70 min

Legged locomotion

Walking is falling, caught in time. Support polygons, the zero-moment point, the linear inverted pendulum and the capture point, gaits, the controllers inside today's walking robots, and the motors that made them possible.

Code tested · 5AI-draftedAwaiting review by a roboticist

Your guides: Chloe · The Builder, Margaret · The Experimenter, Gideon · The Safety Engineer

MotivationH

Why legs, and why they are hard

Wheels need roads. Stairs, ladders, rubble after an earthquake, forest floors and boulder fields defeat them; legs need only a sequence of footholds. That is why inspection robots now walk around offshore platforms and substations, why rescue teams take quadrupeds into collapsed buildings, and why so many companies are building humanoids for spaces designed around human legs.

Legs pay for that freedom with a control problem wheels never have. A wheeled robot stands still when its motors stop. A walking robot spends most of its time on one or two feet, its centre of mass high above a small patch of contact, and would fall within half a second if its controller stopped. Every legged robot must answer, many times a second: where must my feet be, and how hard must they push, so that I do not fall?

This lesson builds the answer in layers: the support polygon, the zero-moment point, the linear inverted pendulum and the capture point; then gaits, the model predictive, whole-body and learned controllers of real robots, and the actuators that made them possible. It builds on Robot dynamics and Model predictive control.

IntuitionH

Static and dynamic stability

Stand on both feet and lean slowly forward. You can lean until a vertical line through your centre of mass passes your toes; then you must step or fall. The region you can lean over is the support polygon: on two flat feet, the outline of both feet and the gap between them; on one foot, that foot.

Definition— Support polygon and static stability

The support polygon is the convex hull of the contact points between a robot and a flat ground. A robot is statically stable if the vertical projection of its centre of mass (CoM) lies inside the support polygon; it could then freeze in place without falling. The static stability margin is the distance from that projection to the nearest edge of the polygon.

A robot that is statically stable at every instant can walk as slowly as it likes and stop anywhere. That needs at least three feet down at all times, so the first walking machines had four or six legs; six-legged robots often use the tripod gait, three legs forming a triangle under the body while the other three swing.

biped, both feet downquadruped, three feet downtrot, two diagonal feetfilled: in contact; hollow: in the air
Support polygons seen from above, with the centre of mass projected onto the ground (the dot). Left, a biped standing on two feet: the polygon includes the area between the feet. Middle, a quadruped with three feet down: a triangle, statically stable if the dot lies inside. Right, a trotting quadruped with two diagonal feet down: the polygon is only a line, so the robot cannot stand still in this phase.

Animals and fast robots do something else. A trotting dog has only two diagonal feet down at a time, so its support polygon is a line and it is never statically stable. It does not fall because the body starts to tip, and before it has tipped far the other pair lands and pushes it back. Stability is a property of the whole cycle, not of each instant: dynamic stability, which is what makes walking fast, efficient and possible on two legs. Human walking is a controlled fall forward, caught by each step.

A gait is the pattern in which feet are lifted and set down; its duty factor is the fraction of the cycle each foot spends on the ground. The program moves a quadruped's feet through one cycle of several gaits, each foot sliding backwards under the body while it is down, and computes the static stability margin at every instant.

python
import numpy as np

def cross(a, b):
    """z-component of the cross product of two 2-D vectors."""
    return a[0] * b[1] - a[1] * b[0]

hips = {"LF": (0.30, 0.15), "RF": (0.30, -0.15), "LH": (-0.30, 0.15), "RH": (-0.30, -0.15)}
stride = 0.20                       # each foot sweeps 20 cm backwards (relative to the body) while on the ground

def feet_on_ground(gait, duty, phase):
    """Positions (body frame, m) of the feet in stance at this phase of the cycle (0 <= phase < 1)."""
    pts = []
    for leg, offset in gait.items():
        u = (phase - offset) % 1.0              # time since this foot touched down, as a fraction of the cycle
        if u < duty:                            # in stance: the foot slides from front to back under the body
            hx, hy = hips[leg]
            pts.append((hx + stride / 2 - stride * u / duty, hy))
    return np.array(pts)

def hull(pts):
    """Convex hull, anticlockwise (Andrew's monotone chain)."""
    pts = sorted(map(tuple, pts))
    def half(seq):
        out = []
        for p in seq:
            while len(out) >= 2 and cross(np.subtract(out[-1], out[-2]), np.subtract(p, out[-2])) <= 0:
                out.pop()
            out.append(p)
        return out[:-1]
    return np.array(half(pts) + half(pts[::-1]))

def margin(pts, com=(0.0, 0.0)):
    """Signed distance from the CoM to the edge of the support polygon: > 0 inside, <= 0 outside or on a line."""
    if len(pts) < 3:
        return -np.inf if len(pts) < 2 else -abs(cross(pts[1] - pts[0], np.subtract(com, pts[0]))) / np.linalg.norm(pts[1] - pts[0])
    poly = hull(pts)
    d = []
    for a, b in zip(poly, np.roll(poly, -1, axis=0)):
        e = b - a
        d.append(cross(e, np.subtract(com, a)) / np.linalg.norm(e))
    return min(d)

gaits = {
    "crawl, duty 0.75": ({"LH": 0.0, "LF": 0.25, "RH": 0.5, "RF": 0.75}, 0.75),
    "crawl, duty 0.9": ({"LH": 0.0, "LF": 0.25, "RH": 0.5, "RF": 0.75}, 0.90),
    "crawl 0.9, CoM 4 cm back": ({"LH": 0.0, "LF": 0.25, "RH": 0.5, "RF": 0.75}, 0.90),
    "order LF-LH-RF-RH, 0.9": ({"LF": 0.0, "LH": 0.25, "RF": 0.5, "RH": 0.75}, 0.90),
    "trot": ({"LF": 0.0, "RH": 0.0, "RF": 0.5, "LH": 0.5}, 0.50),
    "pace": ({"LF": 0.0, "LH": 0.0, "RF": 0.5, "RH": 0.5}, 0.50),
    "bound": ({"LF": 0.0, "RF": 0.0, "LH": 0.5, "RH": 0.5}, 0.40),
}
print("gait                        duty   feet down     worst stability margin   statically stable?")
for name, (gait, duty) in gaits.items():
    com = (-0.04, 0.0) if "back" in name else (0.0, 0.0)
    phases = np.arange(0, 1, 0.005)
    counts = [len(feet_on_ground(gait, duty, ph)) for ph in phases]
    worst = min(margin(feet_on_ground(gait, duty, ph), com) for ph in phases)
    worst_txt = "no support" if worst == -np.inf else f"{round(100 * worst, 1) + 0.0:+.1f} cm"
    print(f"{name:26}  {duty:4.2f}   {min(counts)} to {max(counts)}        {worst_txt:>12}            {'yes' if worst > 0 else 'no'}")
Runs entirely in your browser, in an isolated worker. Nothing is sent to a server.

Only one row says yes: the crawl with a high duty factor, lifting the feet in the order left hind, left front, right hind, right front. With a duty factor of 0.75 there are always exactly three feet down, but at the instant each foot lifts the CoM sits exactly on the edge of the new triangle (a margin of zero), so the slightest disturbance tips it. Raising the duty factor to 0.9 buys a margin of 8 mm. Moving the CoM 4 cm backwards, as a heavy battery in the wrong place would, or lifting the same feet in a different order, destroys it. The trot, pace and bound are never statically stable: the trot's line of support passes up to 4.5 cm from the CoM, the pace's lies along one side of the body, and the bound has moments with no feet down at all.

DefinitionsH

The zero-moment point

Static stability ignores acceleration, and acceleration is what walking is made of: a robot that stops suddenly tips forwards even with its CoM above the middle of its foot, as a passenger on a braking bus knows. The ground pushes on a flat foot at every point of contact, and those forces add up to one total force acting at one point, the centre of pressure. Because the ground can only push, never pull, the centre of pressure always lies inside the support polygon. The question for a controller is: given the motion I want, where would the centre of pressure have to be?

Definition— Zero-moment point (ZMP)

The zero-moment point is the point on the ground about which the gravity and inertial forces of the robot's motion produce no horizontal moment. If it lies strictly inside the support polygon, a flat-footed robot can perform that motion with its feet staying flat, and it coincides with the centre of pressure. If the motion would need it outside, no ground force can produce the motion: the foot rolls about its edge and the robot starts to tip.

The simplest model that shows the idea is Kajita's cart–table model: a cart of mass mm (the robot's CoM, at height hh and horizontal position xx) rolling on a light, one-legged table whose small foot is the robot's foot. Taking moments about a point pp on the ground, gravity mgmg acts at horizontal distance x−px - p, and the cart's inertial force mx¨m\ddot x acts at height hh. The moment vanishes when mg(x−p)=mx¨ hmg(x - p) = m\ddot x\,h, so

p=x−hg x¨.p = x - \frac{h}{g}\,\ddot x .

When the CoM is still or moving at constant speed, the ZMP is directly beneath it. To accelerate forwards (x¨>0\ddot x > 0) the ZMP must move behind the CoM, because the foot must push the body forwards; to brake, it must move ahead. The program shifts a robot's weight 12 cm forward, from above its ankle towards its toes, with a smooth profile, at four speeds. The foot reaches 5 cm behind the ankle and 15 cm in front.

python
import numpy as np

g, h = 9.81, 0.80                 # gravity (m/s^2) and centre-of-mass height (m)
heel, toe = -0.05, 0.15           # the foot's extent along x, measured from the ankle (m)
d = 0.12                          # shift the CoM 12 cm forward, from above the ankle towards the toes

def com_shift(T, n=401):
    """A smooth weight shift of length d in T seconds: x(t) = d/2 (1 - cos(pi t / T))."""
    t = np.linspace(0.0, T, n)
    x = d / 2 * (1 - np.cos(np.pi * t / T))
    xdd = d / 2 * (np.pi / T) ** 2 * np.cos(np.pi * t / T)
    return t, x, xdd

print("duration   CoM range (cm)     ZMP range (cm)    ZMP stays on the foot?")
for T in [2.0, 1.3, 1.0, 0.6]:
    t, x, xdd = com_shift(T)
    p = x - h / g * xdd                       # cart-table model: the zero-moment point
    ok = (p.min() >= heel) and (p.max() <= toe)
    print(f"{T:6.1f} s   {100*x.min():5.1f} to {100*x.max():5.1f}     "
          f"{100*p.min():6.1f} to {100*p.max():5.1f}      {'yes' if ok else 'no: the foot would tip'}")

# The same model read backwards: how hard may the CoM accelerate while standing on this foot?
x_now = 0.0
print(f"\nwith the CoM above the ankle, the foot allows accelerations from "
      f"{-(toe - x_now) * g / h:.2f} to {(x_now - heel) * g / h:.2f} m/s^2")
Runs entirely in your browser, in an isolated worker. Nothing is sent to a server.

The CoM never leaves the foot, so a static check would pass all four runs. The ZMP disagrees. Over 1.3 s it just fits, from 2.9 cm behind the ankle to 14.9 cm in front; over one second it must reach 16.8 cm, beyond the toe, as the CoM brakes at the end, and the foot would roll onto its toes. Read backwards, the model gives acceleration limits: with the CoM above the ankle this foot allows between −1.84-1.84 and 0.610.61 m/s², asymmetric because there is much more toe than heel.

This is the logic of ZMP-based walking, used by Japanese humanoids from Honda's P2 and ASIMO to AIST's HRP series: plan the footprints, require the ZMP to move smoothly from one to the next with a margin from the edges, and solve for the CoM trajectory that produces it. Kajita and colleagues solved the last step with preview control, looking about a second ahead; today it is usually a small model predictive control problem.

Worked examplesH

The linear inverted pendulum and the capture point

Turn the cart–table equation around: instead of asking where the ZMP must be for a given motion, ask how the CoM moves for a given ZMP. Solving p=x−(h/g)x¨p = x - (h/g)\ddot x for x¨\ddot x gives

x¨=ω2(x−p),ω=g/h.\ddot x = \omega^2 (x - p), \qquad \omega = \sqrt{g/h}.

This is the linear inverted pendulum model (LIPM): a point mass on a massless, telescopic leg from the ZMP pp, with the leg's length adjusted so that the mass stays at constant height hh. The same equation holds in the sideways direction. It is linear, which is why it is so useful, and it is unstable: the CoM accelerates away from the ZMP, in proportion to how far it already is. For h=0.8h = 0.8 m, ω=3.50\omega = 3.50 s⁻¹, and the time constant 1/ω1/\omega is 286 ms, the timescale on which a person or a humanoid must react to a stumble.

hvCoMpanklev / ωcapture point: step herestance foot
The linear inverted pendulum. The CoM, at constant height h, sits on a straight leg from the ZMP p on the ground and accelerates away from it. The capture point, a distance v/ω ahead of the CoM, is where the ZMP must be placed for the robot to come to rest; here it is beyond the toe of the stance foot, so the robot must step.

For a fixed ZMP the equation has an exact solution. With initial position x0x_0 and velocity v0v_0,

x(t)=p+(x0−p)cosh⁡ωt+v0ωsinh⁡ωt.x(t) = p + (x_0 - p)\cosh\omega t + \frac{v_0}{\omega}\sinh\omega t .

Both cosh⁡\cosh and sinh⁡\sinh grow like eωt/2e^{\omega t}/2, so in general the CoM runs away. But they can cancel. Split the state into two combinations,

ξ=x+x˙ω,ζ=x−x˙ω,\xi = x + \frac{\dot x}{\omega}, \qquad \zeta = x - \frac{\dot x}{\omega},

and differentiate using x¨=ω2(x−p)\ddot x = \omega^2(x - p): ξ˙=ω(ξ−p)\dot\xi = \omega(\xi - p) and ζ˙=−ω(ζ−p)\dot\zeta = -\omega(\zeta - p). The pendulum's dynamics fall apart into one part that runs away from the ZMP and one that runs towards it.

Theorem— The capture point

For the linear inverted pendulum with the ZMP held at pp, the CoM comes to rest above pp (that is, x(t)→px(t) \to p and x˙(t)→0\dot x(t) \to 0) if and only if p=ξ(0)=x(0)+x˙(0)/ωp = \xi(0) = x(0) + \dot x(0)/\omega. The point ξ\xi is called the capture point (or, in the walking literature, the instantaneous capture point or divergent component of motion).

Proof

The two equations solve to ξ(t)−p=(ξ(0)−p)eωt\xi(t) - p = (\xi(0) - p)e^{\omega t} and ζ(t)−p=(ζ(0)−p)e−ωt\zeta(t) - p = (\zeta(0) - p)e^{-\omega t}, and x=(ξ+ζ)/2x = (\xi + \zeta)/2, x˙=ω(ξ−ζ)/2\dot x = \omega(\xi - \zeta)/2. If p=ξ(0)p = \xi(0), then ξ(t)=p\xi(t) = p for all tt while ζ(t)→p\zeta(t) \to p, so x→px \to p and x˙→0\dot x \to 0. If p≠ξ(0)p \ne \xi(0), then ∣ξ(t)−p∣|\xi(t) - p| grows like eωte^{\omega t} while ζ(t)\zeta(t) stays bounded, so xx and x˙\dot x are unbounded.

∎

The capture point turns balance into geometry. If it lies inside the support polygon, the robot can stop without stepping by shifting its centre of pressure onto it with its ankles (the ankle strategy); if not, it must put a foot on or near it. The program shoves a robot that is standing upright so that it moves forward at 0.6 m/s, tries the ankle strategy, and then simulates a step to three places.

python
import numpy as np

g, h = 9.81, 0.80
w = np.sqrt(g / h)                 # the pendulum's natural rate, 1/s
heel, toe = -0.05, 0.15            # foot extent around the ankle at x = 0 (m)

def lipm(x0, v0, p, t):
    """Exact solution of x'' = w^2 (x - p) for a fixed ZMP p: returns (x, v) after time t."""
    c, s = np.cosh(w * t), np.sinh(w * t)
    return p + (x0 - p) * c + v0 / w * s, (x0 - p) * w * s + v0 * c

def capture_point(x, v):
    return x + v / w

print(f"w = {w:.3f} 1/s, time constant 1/w = {1000 / w:.0f} ms")
# A shove leaves the robot upright over its ankle but moving forward at 0.6 m/s.
x0, v0 = 0.0, 0.6
xi = capture_point(x0, v0)
print(f"capture point right after the shove: {100 * xi:.1f} cm ahead of the ankle (toe at {100 * toe:.0f} cm)")

# Ankle strategy alone: put the ZMP as far forward as it can go, at the toe, and wait.
x, v = lipm(x0, v0, toe, 1.0)
print(f"ZMP held at the toe for 1 s: CoM at {100 * x:.0f} cm, still moving at {v:+.2f} m/s -> falling")

# Stepping strategy: keep the ZMP at the toe for 0.25 s while the swing leg moves, then step.
ts = 0.25
x1, v1 = lipm(x0, v0, toe, ts)
xi1 = capture_point(x1, v1)
print(f"\nat touchdown (t = {ts} s): CoM at {100 * x1:.1f} cm, speed {v1:.3f} m/s, capture point {100 * xi1:.1f} cm")
print("new foot (ZMP) at              CoM relative to the new foot   speed")
print("                               t = 0.5 s      t = 1.0 s       t = 1.0 s")
for label, p in [("capture point - 5 cm", xi1 - 0.05), ("the capture point", xi1),
                 ("capture point + 5 cm", xi1 + 0.05)]:
    (xa, xb), (va, vb) = lipm(x1, v1, p, np.array([0.5, 1.0]))
    print(f"{label:22} {100 * p:5.1f} cm   {100 * (xa - p):+7.1f} cm     {100 * (xb - p):+7.1f} cm    {vb:+7.3f} m/s")

# The capture point obeys xi' = w (xi - p): it runs away from the ZMP and nothing else matters.
xs, vs = lipm(x1, v1, xi1 - 0.05, np.array([0.0, 0.5, 1.0]))
print("\ndistance from the capture point to the foot when stepping 5 cm short:",
      np.round(100 * (capture_point(xs, vs) - (xi1 - 0.05)), 1), "cm at t = 0, 0.5, 1 s")
Runs entirely in your browser, in an isolated worker. Nothing is sent to a server.

Right after the shove the capture point is 17.1 cm ahead of the ankle, beyond the toe, so the ankle strategy fails: a robot standing over its ankle survives a shove without stepping only if v0≤ω(toe−x0)=3.502×0.15=0.525v_0 \le \omega(\text{toe} - x_0) = 3.502 \times 0.15 = 0.525 m/s. So it steps. During the quarter of a second the swing leg takes, the capture point runs on to 20.1 cm. A foot placed exactly there brings the CoM to rest (3 mm short of the foot and moving at 1 cm/s after a second, both decaying like e−ωte^{-\omega t}). A step 5 cm short leaves the capture point ahead of the foot, and the gap grows from 5 cm to 28.8 cm and then 165.9 cm, a factor of e0.5 ω=5.76e^{0.5\,\omega} = 5.76 every half second: the robot falls forward. A step 5 cm long makes it fall backwards. Real feet have size, so there is a capture region: any foot placement whose support area contains the capture point at touchdown will do.

ExplanationH

Gaits, walking and running

Animals choose gaits by speed: a horse walks, trots, canters and gallops; a person walks, then runs. In a walk some foot is always down; in a run each foot is down for less than half the cycle, with flight phases between. Quadruped gaits are named by which legs move together: the trot pairs diagonal legs, the pace pairs the legs on one side, the bound pairs front and back, and the gallop sets all four down at different moments. Most quadruped robots trot over a wide range of speeds, because the diagonal pairs keep the support centred under the body.

Walkers of different sizes are compared by the Froude number Fr=v2/(gL)\mathrm{Fr} = v^2/(gL), with LL the leg length. A walking body vaults over a stiff leg, and gravity must supply the centripetal acceleration v2/Lv^2/L at the top of each arc, so walking becomes impossible as Fr\mathrm{Fr} approaches 1; animals and people switch to running at around Fr≈0.5\mathrm{Fr} \approx 0.5. For a person with 0.9 m legs that is 0.5×9.81×0.9=2.10\sqrt{0.5 \times 9.81 \times 0.9} = 2.10 m/s, about 7.6 km/h, close to where people do break into a run; a small quadruped with 0.3 m legs gets there at 1.21 m/s, which is why little robots look so busy.

Biped walking alternates single support (one foot down, the other swinging) and double support (weight passing from one foot to the other). In the LIPM picture each step puts the new foot a little short of the capture point, so the robot carries on forward over it: a steady walk is a sequence of deliberately incomplete captures.

ExplanationH

How walking robots are controlled in 2026

Real robots have heavy legs, feet that slip and bodies that rotate, so the LIPM is a planning model, not the whole controller. Most model-based legged controllers have three layers, running at different rates.

  1. A footstep and gait planner, at a few hertz, decides when each foot lifts and roughly where it lands, from the commanded velocity and a map of the terrain (built from cameras and lidar, as in Depth and point clouds).
  2. Model predictive control on a simplified model, at tens of hertz, plans the body's motion and the contact forces over the next half second or so. For quadrupeds the usual model is a single rigid body pushed by the ground at the feet; with its rotation linearised about the planned heading, planning becomes a convex quadratic program, with friction cones as linear inequalities (∣fx∣,∣fy∣≤μfz|f_x|, |f_y| \le \mu f_z, fz≥0f_z \ge 0) and zero force for swinging feet. Di Carlo and colleagues' 2018 controller for the MIT Cheetah 3 made this popular; humanoids often use the LIPM or centroidal dynamics (the robot's total momentum) instead.
  3. Whole-body control, at hundreds of hertz to a kilohertz, turns those plans into joint torques with the full model of Robot dynamics, M(q)q¨+h(q,q˙)=S⊤τ+Jc⊤fM(q)\ddot q + h(q, \dot q) = S^\top\tau + J_c^\top f, solving another quadratic program each tick: track the contact forces, swing-foot trajectories and posture, in order of priority, within torque limits and friction cones, with stance feet held still.

Below that, each joint runs a fast torque or impedance loop (Force and impedance control). ETH Zurich's OCS2 toolbox and the MIT Mini Cheetah's released controller are open-source examples of the whole stack.

Reinforcement-learned controllers. Since about 2019 a different approach has taken over rough terrain. A neural-network policy maps recent sensor readings (joint angles and velocities, the IMU, the previous action, often a height map of the terrain) to joint position targets, which stiff PD loops track. It is trained by reinforcement learning in simulation, on thousands of randomised terrains, masses, frictions and motor properties, so that it works on the real robot without further training. Hwangbo and colleagues at ETH Zurich showed in 2019 that such a policy, with a learned model of the actuators, outperformed ANYmal's hand-built controller; Lee and colleagues (2020) and Miki and colleagues (2022) took ANYmal over rubble, streams and an Alpine hiking trail; Rudin and colleagues (2021) trained walking policies in minutes on one GPU simulating thousands of robots. Groups at Oregon State, UC Berkeley and elsewhere did the same for bipeds, and learned controllers now run on commercial quadrupeds and humanoids. Reinforcement learning for robots and Sim-to-real explain how.

The two approaches are converging. Learned policies are robust to slips and surprises that break a model's assumptions; model-based controllers respect constraints explicitly and are easier to inspect when something goes wrong. In 2026 it is common to see policies trained to track model-based plans, MPC generating training data, and model-based safety layers around learned policies.

ExplanationH

Actuators: why legs got cheaper and better

A leg hits the ground hundreds of times a minute, each impact sending a force spike through the joint's gears. For decades legged robots used high-ratio gearboxes (harmonic drives of 100:1 or more) with stiff position control, or hydraulics, as in Boston Dynamics' BigDog and earlier Atlas and IIT's HyQ. High-ratio gears are fragile under impact and hide the foot's forces from the motor; hydraulics are heavy, noisy and complex.

The quasi-direct-drive (QDD) actuator, developed for the MIT Cheetah robots in the 2010s, takes the opposite path: a large-diameter, high-torque electric motor with a gear ratio of only about 6:1 to 10:1. The joint is backdrivable (push on the leg and the motor turns), impacts are absorbed by the motor's own motion instead of by gear teeth, and the motor current is a good measure of joint torque, so the leg can sense and control contact forces without separate force sensors (proprioceptive force control). Variants of the design are now in many research and commercial legs, and it is a large part of why capable quadrupeds went, within a decade, from one-off laboratory machines to products that many university labs can afford.

Other designs remain in use: series elastic actuators measure force from a spring's deflection, hydraulics still win on power density, and many humanoids pair QDD legs with higher-ratio arms.

ExplanationH

Walking robots around the world

A few landmarks, factually and with dates (the humanoids of 2026 have a lesson of their own, Humanoid robots):

  • Japan led humanoid research for decades: Honda's P2 (1996) and ASIMO (2000; development ended in 2018), AIST's HRP series with Kawada Industries (HRP-2 from 2002, HRP-5P in 2018), and Waseda University's WABIAN robots.
  • South Korea: KAIST's HUBO line of humanoids; DRC-HUBO, which could kneel and roll on wheels built into its knees, won the DARPA Robotics Challenge finals in 2015.
  • United States: Marc Raibert's hopping machines at Carnegie Mellon and MIT in the 1980s showed dynamic balance; Boston Dynamics, which he founded, has sold the Spot quadruped since 2020 and in 2024 replaced its hydraulic Atlas humanoid with an all-electric one. Agility Robotics' Cassie (2017), from research at Oregon State University, and its humanoid successor Digit; MIT's Cheetah robots, whose Mini Cheetah (2019) made the QDD leg widely copied; Ghost Robotics' rugged quadrupeds.
  • Switzerland: ANYbotics, a 2016 spin-off from ETH Zurich, builds ANYmal quadrupeds for industrial inspection, the robot of many of the learning papers above.
  • Italy: IIT's Dynamic Legged Systems lab developed the hydraulic HyQ quadrupeds.
  • China: Unitree Robotics (Hangzhou) sells widely used quadrupeds (the Go and B series) and humanoids (H1, G1), and DEEP Robotics, also in Hangzhou, builds Jueying inspection quadrupeds. Chinese companies and research centres are among the most active builders of humanoids in 2026.

Note

Trying it safely. Even a small quadruped's legs can pinch fingers or kick hard when a controller misbehaves. Start in simulation: models of many legged robots are freely available for MuJoCo (in the MuJoCo Menagerie) and Isaac Lab (see Simulation). On a real robot, test new controllers with the robot hanging in a harness or on a stand, keep clear of the legs, have someone ready at the emergency stop, and follow the manufacturer's procedures for its battery. Larger legged robots are heavy and fast enough to injure; they belong in a cleared, supervised test area.

Common misconceptionsH

Common misconceptions

Misconception

"If the centre of mass is above the foot, the robot will not tip." Only if it is not accelerating. For a moving robot the ZMP must stay inside the support polygon, and it is offset from the CoM's projection by (h/g)x¨(h/g)\ddot x: the weight-shift simulation kept the CoM on the foot and still tipped it at two speeds.

Misconception

"A dynamically stable gait is a statically stable gait done faster." A trot is never statically stable; it works because of timing. Slowing it down makes it harder, not safer, because each pair of legs must hold the body for longer while it tips.

Misconception

"A robot whose ZMP reaches the edge of its foot is about to fall." It means the foot is about to roll about that edge, which becomes a fall only if nothing else is done. The capture point, not the ZMP, says whether a step can still save it; people roll over their heels and toes every step.

Misconception

"Learned locomotion has made models unnecessary." Policies are trained in simulators built on the same rigid-body and contact models, and model-based reasoning is what explains why a policy works or fails. What has changed is that the model is used for training and analysis rather than solved online at every step.

Exercises

Exercises

1. Legged locomotion

Warm-upHuman

A humanoid's centre of mass is 0.900.90 m above the ground and 33 cm ahead of its ankle, and it is accelerating forwards at 1.51.5 m/s². Using the cart–table model with g=9.81g = 9.81 m/s², where is the zero-moment point? Give its position relative to the ankle in millimetres, rounded to the nearest millimetre, with a minus sign if it is behind the ankle.

2. Legged locomotion

CoreHuman

A robot's centre of mass is 1.01.0 m high and directly above its ankle when it is bumped so that the centre of mass moves forwards at 0.50.5 m/s. Using the linear inverted pendulum model with g=9.81g = 9.81 m/s², how far ahead of the ankle is the capture point, to the nearest millimetre?

3. Legged locomotion

CoreHuman

A trotting quadruped has only two diagonal feet on the ground at a time, so its support polygon is a line and it is never statically stable. Why does it not fall over?

Choose one

4. Legged locomotion

CoreHuman

Which of these are true of quasi-direct-drive actuators, compared with the same motor driving the joint through a 100:1 harmonic drive? Select all that apply.

Choose all that apply

5. Legged locomotion

Warm-upHuman

A robot stands on one flat foot with the projection of its centre of mass well inside the foot. Which statement is correct?

Choose one

6. Legged locomotion

CoreComputational

Write zmp_from_com(x, dt, h, g=9.81). It receives the horizontal positions of a robot's centre of mass, x[0], ..., x[n-1] in metres, sampled every dt seconds at constant height h, and returns the cart–table ZMP pk=xk−(h/g)x¨kp_k = x_k - (h/g)\ddot x_k at the interior samples k=1,…,n−2k = 1, \ldots, n-2, estimating the acceleration with the central difference x¨k≈(xk+1−2xk+xk−1)/Δt2\ddot x_k \approx (x_{k+1} - 2x_k + x_{k-1})/\Delta t^2. Return a NumPy array of length n−2n - 2.

Runs entirely in your browser, in an isolated worker. Nothing is sent to a server.

7. Legged locomotion

StretchComputational

Write two functions for the linear inverted pendulum x¨=(g/h)(x−p)\ddot x = (g/h)(x - p) with the ZMP held at pp:

  • lipm(x0, v0, p, t, h, g=9.81) returns (x, v), the exact position and velocity of the centre of mass tt seconds after starting at position x0 with velocity v0;
  • capture_point(x, v, h, g=9.81) returns the capture point ξ=x+v/ω\xi = x + v/\omega.

The tests compare lipm with a fine numerical integration and check that stepping onto the capture point brings the robot to rest.

Runs entirely in your browser, in an isolated worker. Nothing is sent to a server.

Further reading and resources

  • Zero-moment point: thirty five years of its life · Miomir Vukobratović and Branislav Borovac · 2004The ZMP's originators on what it means, what it does not mean, and how it is misused.
  • Capture Point: A Step toward Humanoid Push Recovery · Jerry Pratt, John Carff, Sergey Drakunov and Ambarish Goswami · 2006IEEE-RAS International Conference on Humanoid Robots. Where the capture point was named and first used to choose a step.
  • Biped walking pattern generation by using preview control of zero-moment point · Shuuji Kajita and colleagues (AIST) · 2003IEEE ICRA 2003. The cart–table model and ZMP preview control, the basis of a generation of humanoid walking.
  • Dynamic locomotion in the MIT Cheetah 3 through convex model-predictive control · Jared Di Carlo, Patrick M. Wensing, Benjamin Katz, Gerardo Bledt and Sangbae Kim · 2018IEEE/RSJ IROS 2018. The single-rigid-body MPC that many quadruped controllers still start from.
  • Proprioceptive actuator design in the MIT Cheetah: impact mitigation and high-bandwidth physical interaction for dynamic legged robots · Patrick M. Wensing, Albert Wang, Sangok Seok, David Otten, Jeffrey Lang and Sangbae Kim · 2017IEEE Transactions on Robotics. The case for low gear ratios, and the design of the quasi-direct-drive leg.
  • Learning agile and dynamic motor skills for legged robots · Jemin Hwangbo, Joonho Lee, Alexey Dosovitskiy, Dario Bellicoso, Vassilios Tsounis, Vladlen Koltun and Marco Hutter · 2019Science Robotics. A policy trained in simulation, with a learned model of the actuators, running on ANYmal.
  • Learning quadrupedal locomotion over challenging terrain · Joonho Lee, Jemin Hwangbo, Lorenz Wellhausen, Vladlen Koltun and Marco Hutter · 2020
  • Learning robust perceptive locomotion for quadrupedal robots in the wild · Takahiro Miki, Joonho Lee, Jemin Hwangbo, Lorenz Wellhausen, Vladlen Koltun and Marco Hutter · 2022
  • Learning to walk in minutes using massively parallel deep reinforcement learning · Nikita Rudin, David Hoeller, Philipp Reist and Marco Hutter · 2021Thousands of simulated robots trained at once on one GPU; the code is the open-source legged_gym.
  • RMA: Rapid Motor Adaptation for Legged Robots · Ashish Kumar, Zipeng Fu, Deepak Pathak and Jitendra Malik · 2021
  • Real-world humanoid locomotion with reinforcement learning · Ilija Radosavovic, Tete Xiao, Bike Zhang, Trevor Darrell, Jitendra Malik and Koushil Sreenath · 2023
  • Underactuated Robotics · Russ TedrakeFree online notes with chapters on simple models of walking and running.
  • OCS2, an open-source toolbox for optimal control of legged and mobile robots
  • Isaac LabAn open-source framework, on NVIDIA Isaac Sim, in which many locomotion policies are now trained.