Articulated Body Algorithm
- Also called: ABA, Featherstone's algorithm, Featherstone algorithm
- Category: Software & tooling › Simulation & twins
- Tags: rigid-body-dynamics, forward-dynamics, simulation, algorithms, physics-engines
An efficient recursive algorithm, introduced by Featherstone in 1983, that computes a robot's joint accelerations from applied torques in time proportional to its number of joints.
Definition
Articulated body algorithm (ABA) refers to Roy Featherstone's method for computing the forward dynamics of a robot made of rigid bodies connected by joints in a tree structure: given the current joint positions, velocities and applied torques, it finds the resulting joint accelerations. Featherstone introduced it in 1983, and it is one of the core algorithms in his book Rigid Body Dynamics Algorithms.
The straightforward way to compute forward dynamics is to build the joint-space mass matrix, for example with the composite rigid body algorithm, and then solve a linear system. Building and factoring that matrix grows faster than linearly with the number of joints. The ABA avoids forming the matrix and runs in time proportional to the number of bodies, written O(n).
It does this in three passes over the kinematic tree. An outward pass computes each body's velocity and velocity-dependent bias terms. An inward pass, from the leaves toward the base, computes each body's articulated-body inertia: the apparent inertia of that body together with everything attached beyond it, accounting for the joints in between. A final outward pass computes the joint accelerations from the base to the leaves. The algorithm is written in spatial vector algebra, a six-dimensional notation that combines linear and angular quantities.
The ABA is implemented in rigid-body dynamics libraries such as Pinocchio, RBDL and Drake. For robots with only a few joints, the mass-matrix approach can be just as fast in practice, while the ABA's advantage grows for longer chains and branched robots such as humanoids. The recursive ideas behind it have been extended to related quantities, such as operational-space inertia and contact dynamics.
Why it matters
Simulators, model predictive controllers and trajectory optimizers evaluate forward dynamics many thousands of times. An efficient algorithm such as the ABA directly affects how fast these tools run and how complex a robot they can handle in real time.
Key applications
- Forward dynamics in physics simulators
- Model predictive control and trajectory optimization for legged robots
- Dynamics derivatives for gradient-based optimization
- Real-time simulation of high-degree-of-freedom humanoids and manipulators
In practice
Most robotics teams use the ABA through a library rather than implementing it. A controls engineer might load a humanoid's URDF into Pinocchio and call its forward dynamics routine inside a simulator or model predictive controller, or call its analytical derivatives for gradient-based trajectory optimization. Engineers who write their own dynamics code use Featherstone's book as the reference and test their implementation against the mass-matrix method on the same model.
Common misconceptions
- The ABA computes inverse dynamics — it computes forward dynamics; inverse dynamics is usually computed with the recursive Newton–Euler algorithm
- The ABA is always faster than the mass-matrix method — for robots with few joints the difference can be small or reversed
- The ABA handles closed kinematic loops directly — it is formulated for kinematic trees; loops need additional constraint handling
Who should know this
- Developers of physics simulators and dynamics libraries
- Control engineers working on model predictive control and trajectory optimization
- Researchers in legged locomotion and humanoid robotics
Related technologies
- Recursive Newton–Euler Algorithm
- Composite Rigid Body Algorithm
- Spatial Vector Algebra
- Pinocchio
- RBDL
- Drake
Related terms
Related projects
- GENESIS: World's fastest physics engine: 43M FPS for embodied AI learning
- LeRobot: HuggingFace ML library for real-world robotics in PyTorch
- PyBullet: Python physics simulator for robotics and RL research with fast CPU-based simulation
- RLinf: Scalable infrastructure for post-training foundation models via RL
- Webots: Cross-platform robot simulator with built-in models, sensors, and development environment
- NVIDIA Isaac Sim: NVIDIA Omniverse app for AI-driven robot simulation and testing