The Mechanics of a Handstand

physicssimulation

The Mechanics of a Handstand

Why is pressing up to a handstand so much harder than kicking up to one? Ask around and you will collect a pile of explanations: not enough shoulder strength, tight shoulders, stiff wrists, short hamstrings, bad timing. Some of these are real constraints. Some, I suspect, are folklore. This notebook builds a small physics model of a handstand and uses it to find out which is which.

The model is a two dimensional, side view rigid body model of a person balancing on their hands. It is deliberately simple, but it is quantitative: segment masses and lengths come from published anthropometric tables, joint strength comes from measured torque and velocity relationships, and every claim the notebook makes is something you can recompute by dragging a slider. This first part builds the model and works out the statics of holding a handstand. The dynamics of getting into one, the kick-up, the press, and the question of which limitations actually matter, build on top of it.

A stick figure gymnast

The body is seven rigid segments in the sagittal plane, viewed from the side. Both arms act together in a handstand, so by symmetry they merge into a single arm segment, and likewise the two hands merge into one. The legs stay independent so that later on the model can lunge and kick. That leaves a hand resting flat on the floor, one straight arm from wrist to shoulder, a torso with the head attached, and a thigh and shank per leg, connected by six joints: wrist, shoulder, two hips, and two knees.

Segment masses, mass centers, and moments of inertia follow de Leva’s adjustment of the Zatsiorsky segment inertia parameters, scaled by height and body mass. The hand is the interesting segment: it is not a point of support but a patch, from the heel of the palm to the finger pads. Where the pressure lands inside that patch is the entire mechanism of handstand balance, which the next section makes precise.

import { expandable } from './lib/expandable.js';
import { createElementStack } from './lib/element-stack.js';
import { createFrameLoop } from './lib/frame-loop.js';
import { observeTheme } from './lib/theme.js';
import { collapseCodeBlocks } from './lib/collapsible-code.js';
import { createSnapshotButton } from './lib/snapshot.js';
import { buildModel } from './anthropometry.js';
import { createWorkspace, massMatrix, rnea, energy } from './dynamics.js';
import {
  ROM_DEFAULTS, clampPose, groundHand, staticAnalysis, pressCorridor, jointLimits,
} from './statics.js';
import { strengthProfile, availableTorque } from './strength.js';
import { drawScene } from './render.js';
import { runScenario, balancedHandstand } from './rollout.js';
import { PRESET_TRAJECTORIES, PRESET_CATCH_WINDOW, PRESET_SWEEPS, PRESET_GALLERY } from './presets.js';

Balance is a statics problem

A pose at rest balances when the center of mass sits directly above the center of pressure, and the center of pressure has nowhere to live except the palm patch:

The wrist is what moves the center of pressure. Pressing down through the fingertips shifts it forward; rocking onto the heel of the palm shifts it back. For body weight the wrist torque required to hold the pressure at a given spot is

so the patch length times body weight is the entire balance authority available in a handstand. This is the wrist strategy that motion capture studies find gymnasts using more than three quarters of the time. Every other joint torque in a static pose is set by gravity: each joint must resist the moment of all the mass beyond it. The chart below reports those torques for the current pose, normalized by body mass, next to each joint’s isometric strength.

What flexibility limits actually do

Try lowering the shoulder flexion limit in the controls above. A shoulder that cannot open to 180 degrees tips the torso off the vertical line, and the pose has to buy that angle back somewhere: arch the back and let the legs travel past vertical, which is the banana, or lean the whole stack toward the fingertips. Lower the wrist limit and the arm itself cannot stand vertical over the palm, forcing a lean that the shoulders must then fight. Neither compensation is free, and the torque chart above prices them.

The hamstrings enter differently, because they are a two joint muscle group. What they limit is not any single joint but the combination of hip flexion and knee extension. With knees straight, hip flexion caps at the toe touch limit; every degree of knee bend buys some of it back. That coupling is why a bent knee press exists, and the model expresses it directly in the hip slider clamp.

The press corridor

A press to handstand is, in the quasi static limit, a path through pose space that keeps the center of mass over the palm the whole way: from a deep pike, through compression, to the stacked handstand. For each combination of hip and shoulder angle, the model solves for the wrist angle that balances the pose, then asks whether that pose is reachable within the flexibility limits and holdable within the strength limits. The result is a corridor: the region of pose space a press is allowed to pass through. Tighten the shoulders or hamstrings in the controls and watch the corridor narrow.

Making it move

Statics ends where every interesting question about handstands begins. To simulate motion, the model becomes a floating body in space: the hand is not attached to the floor, it just rests on it, pressed by two one-sided spring contacts under the heel of the palm and the finger pads (and one under each foot for entries). The center of pressure and every toppling failure emerge from those two palm contacts trading load. Joints are driven by servo torques that track a reference trajectory, and every torque respects two layers of muscle physiology. The first is the strength envelope: maximum voluntary torque as a function of joint velocity, after Yeadon, King and Wilson. Isometric strength is available in a slow press while a fast kick pays the Hill hyperbola falloff; at five radians per second a joint has roughly half its isometric torque left. The second is activation dynamics: neural drive follows a first order lag with a time constant near fifty milliseconds, so torque cannot step instantaneously and bang-bang corrections are impossible by construction, for the model as for you.

Building this surfaced two failures worth keeping. First, holding a perfectly stacked pose with perfect joint servos still topples: the stacked pose rests the pressure a few millimeters from the heel of the palm, and a body pivoting on the heel point has nothing to push against. Second, servos without anticipatory gravity compensation sag under load, the sag leans the body, the lean raises the load, and the wrist creeps up to its strength cap and over the fingertips. Both are real handstand failures, reproduced by accident.

Finding the easiest way up

Hand-authoring trajectories is a losing game: the naive attempts above fail in exactly the ways beginners do. So instead the notebook searches. A candidate technique is a set of spline knots for each of the six joints plus a total duration, thirty seven numbers in all, and its score is a physics rollout: did it arrive at a balanced handstand, meaning the stacked configuration with the feet free of the floor and not merely a center of mass in the right place; how much of the strength envelope did it burn; how much metabolic work it spent, with concentric work charged at muscle efficiency and eccentric absorption cheap, so churning the legs reads as expensive the way it should; did it violate a flexibility limit; did the palms stay planted; did it fall and how early. A covariance matrix adaptation evolution strategy (CMA-ES) then climbs that score. Every run is deterministic under its seed, and the presets above were produced by exactly this process offline; the optimizer below runs live in a worker if you want to search under different flexibility or strength settings.

The catch window

A kick-up succeeds or fails in its last quarter second. Once the feet leave the floor the body is, to good approximation, a rigid stack pivoting about the wrists, and the only authority left is the wrist strategy: pressing the center of pressure around inside the palm patch. So ask directly: from which combinations of arrival angle and arrival angular velocity can the wrist strategy still recover to stillness? The answer is the catch window below. Arrive under it and you fall back the way you came; overshoot it and you topple over the top. The optimized kick-up threads its trajectory straight through it.

What the model taught along the way

Some of the best findings were failures the simulation produced on its own, each now pinned by a test so it stays true. Holding a perfectly stacked handstand with perfect joint servos still topples, because the stacked pose rests the pressure on the heel of the palm and a heel pivot has no restoring authority: balance must be actively bought with wrist torque, and biasing the pressure toward mid palm is worth more than any amount of stiffness. Servos without anticipatory gravity compensation sag, lean, and ride the wrist up to its strength cap and over the fingertips. Opening the hips or shoulders before shifting weight onto the hands rocks the body straight back off its palms, which is the beginner’s press attempt in one sentence. And with muscle activation limited to a fifty millisecond time constant, the recoverable catch window for a kick-up shrinks by half, which is why arriving slowly matters more than arriving precisely.

The model is a two dimensional cartoon: merged arms, locked elbows, no lateral balance, no straddle dynamics beyond a projection, penalty friction, torque servos instead of muscles and tendons, and an optimizer that finds good technique rather than provably best technique. Its numbers should be read as mechanisms and thresholds, not prescriptions. But the mechanisms agree with what the force plates and the coaches have been saying all along, and it is rather pleasant to watch the folklore sort itself into the parts that are physics and the parts that are just repetition.

Every optimization run, on the record

Trajectory optimization fails in creative ways, and a cost number proves nothing. So every optimization result this notebook relies on is embedded and re-simulated here, live, as a filmstrip: successes, stalls, and flails alike. Each row is also available in the playback scenario menu above (the entries in brackets) with full force instrumentation. If a row looks wrong, it is wrong, whatever its cost says.

Validation

The physics core is exercised by offline gates (run with node src/notebooks/handstand/test/dynamics.mjs and friends): the recursive Newton-Euler dynamics against finite differences of the energy function, free-fall momentum conservation, a textbook double pendulum, penalty-contact settling, the Yeadon-King torque curve landmarks, and deterministic optimization. The cell below reruns a fast subset in your browser against the current model so the page can vouch for itself.

Comments