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.
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.
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.
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'}")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.
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 (the robot's CoM, at height and horizontal position ) rolling on a light, one-legged table whose small foot is the robot's foot. Taking moments about a point on the ground, gravity acts at horizontal distance , and the cart's inertial force acts at height . The moment vanishes when , so
When the CoM is still or moving at constant speed, the ZMP is directly beneath it. To accelerate forwards () 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.
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")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 and 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.
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 for gives
This is the linear inverted pendulum model (LIPM): a point mass on a massless, telescopic leg from the ZMP , with the leg's length adjusted so that the mass stays at constant height . 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 m, s⁻¹, and the time constant is 286 ms, the timescale on which a person or a humanoid must react to a stumble.
For a fixed ZMP the equation has an exact solution. With initial position and velocity ,
Both and grow like , so in general the CoM runs away. But they can cancel. Split the state into two combinations,
and differentiate using : and . 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 , the CoM comes to rest above (that is, and ) if and only if . The point 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 and , and , . If , then for all while , so and . If , then grows like while stays bounded, so and 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.
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")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 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 ). 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 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.
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 , with the leg length. A walking body vaults over a stiff leg, and gravity must supply the centripetal acceleration at the top of each arc, so walking becomes impossible as approaches 1; animals and people switch to running at around . For a person with 0.9 m legs that is 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.
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.
- 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).
- 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 (, ) 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.
- Whole-body control, at hundreds of hertz to a kilohertz, turns those plans into joint torques with the full model of Robot dynamics, , 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.
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.
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 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 : 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
1. Legged locomotion
Warm-upHumanA humanoid's centre of mass is m above the ground and cm ahead of its ankle, and it is accelerating forwards at m/s². Using the cart–table model with 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
CoreHumanA robot's centre of mass is m high and directly above its ankle when it is bumped so that the centre of mass moves forwards at m/s. Using the linear inverted pendulum model with m/s², how far ahead of the ankle is the capture point, to the nearest millimetre?
3. Legged locomotion
CoreHumanA 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?
4. Legged locomotion
CoreHumanWhich 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.
5. Legged locomotion
Warm-upHumanA robot stands on one flat foot with the projection of its centre of mass well inside the foot. Which statement is correct?
6. Legged locomotion
CoreComputationalWrite 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 at the interior samples , estimating the acceleration with the central difference . Return a NumPy array of length .
7. Legged locomotion
StretchComputationalWrite two functions for the linear inverted pendulum with the ZMP held at :
lipm(x0, v0, p, t, h, g=9.81)returns(x, v), the exact position and velocity of the centre of mass seconds after starting at positionx0with velocityv0;capture_point(x, v, h, g=9.81)returns the capture point .
The tests compare lipm with a fine numerical integration and check that stepping onto the capture point brings the robot to rest.
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.