DART

C++ physics engine for articulated rigid body dynamics and robotics simulation

License

BSD-2-Clause

Overview

DART (Dynamic Animation and Robotics Toolkit) is a C++20 physics engine for simulating articulated rigid body dynamics with constraint-based contact handling. Developed at Georgia Tech, it provides forward/inverse kinematics, forward dynamics, Jacobian computation, and collision detection. Unlike GPU-parallel simulators such as Isaac Gym or MuJoCo's MJX, DART focuses on mathematical accuracy for articulated body simulation with support for URDF, SDF, and MJCF formats. Includes Python bindings (dartpy) and integrates with Gazebo.

DART (Dynamic Animation and Robotics Toolkit) is an open-source C++20 physics engine developed at Georgia Tech that provides data structures and algorithms for kinematic and dynamic simulation of articulated rigid body systems. It uses generalized coordinates and Featherstone's Articulated Body Algorithm to deliver the numerical accuracy and stability required for robotics applications.

A distinguishing feature of DART is its unified support for all major robot description formats — URDF, SDF, MJCF, and its own SKEL format — through a single API. It integrates multiple collision detection backends (FCL, Bullet, ODE) and solves contact constraints, joint limits, and closed-loop mechanisms in a coupled constraint dynamics framework. Python bindings (dartpy) are available via PyPI and conda.

With over 14 years of continuous development and more than 500 commits per year, DART is one of the most actively maintained physics engines in robotics. It powers the Gazebo simulator's DART physics backend and is used in research labs worldwide for control algorithm development, motion planning, and computer animation.

Why it matters

DART has been a cornerstone physics engine in robotics simulation for over 14 years, powering the Gazebo simulator and numerous research labs worldwide. Its use of generalized coordinates with Featherstone's Articulated Body Algorithm provides the accuracy and stability that robotics applications demand, while its multi-format support (URDF, SDF, MJCF) makes it uniquely versatile.

Problem it solves

Robotics simulation requires a physics engine that correctly handles articulated body dynamics, joint constraints, contacts, and collisions with high numerical accuracy. DART provides this foundation with a clean API that supports loading robot models from all major formats, plugging in multiple collision detection backends, and computing dynamics suitable for both control algorithm development and computer animation.

Key takeaways

• Uses Featherstone's Articulated Body Algorithm on generalized coordinates for accurate dynamics
• Loads URDF, SDF, MJCF, and SKEL robot description formats through a unified API
• Multiple collision detection backends including FCL, Bullet, and ODE
• Constraint dynamics solver handles joint limits, contacts, and closed-loop mechanisms together
• Cross-platform (Linux, macOS, Windows) with Python bindings via dartpy on PyPI and conda

Who it is for

• Robotics researchers developing and testing control algorithms in simulation
• Gazebo users who need to understand or customize the underlying physics engine
• Computer animation developers requiring physically accurate articulated body simulation
• Reinforcement learning practitioners needing a stable simulation backend

Limitations

• Not as widely used in RL research as MuJoCo or Isaac Sim despite comparable capabilities
• GPU-accelerated simulation is not a current focus — runs on CPU
• The C++20 requirement may be restrictive for projects locked to older compiler versions
• Smaller community and fewer pre-built environments compared to MuJoCo or PyBullet