Comparisons

A companion to the main Awesome Robotics Libraries list, providing side-by-side comparisons of physics engines and dynamics libraries commonly used in robotics.

Last updated: February 2026. Feature data verified against source code at each library’s HEAD commit.

Physics Engine Feature Matrix
Robotics Dynamics Libraries
Decision Guide
Benchmark Resources

Physics Engine Feature Matrix

Name	Rigid	Soft	Fluids	Contact Solvers	Differentiable	GPU	Language	License
Brax	✅	❌	❌	Impulse+Baumgarte, XPBD, Projected Gradient QP, MuJoCo	✅	✅	Python	Apache-2.0
Bullet	✅	✅	❌	Sequential Impulse/PGS, Dantzig, Lemke, NNCG	❌	⚠️	C++	Zlib
CHRONO	✅	✅	✅	NSC (DVI), SMC (Hooke/Hertz/Flores)	❌	✅	C++	BSD-3
DART	✅	✅	❌	LCP: Dantzig, PGS, Lemke, + 12 more	✅	❌	C++	BSD-2
Drake	✅	✅	❌	SAP, TAMSI, Similar, Lagged; Hydroelastic	✅	❌	C++	BSD-3
Flex	✅	✅	✅	PBD (Position-Based Dynamics)	❌	✅	C++	Proprietary
Genesis	✅	✅	✅	Newton, CG; GJK+EPA / MPR	✅	✅	Python	Apache-2.0
MuJoCo	✅	✅	❌	Newton, CG, PGS (convex)	✅	✅	C/C++	Apache-2.0
Newton	✅	✅	✅	MuJoCo (via Warp), XPBD, AVBD, penalty	✅	✅	Python	Apache-2.0
Newton Dynamics	✅	⚠️	⚠️	Dantzig LCP	❌	✅	C++	Zlib
nphysics	✅	✅	❌	Moreau-Jean (SOR-prox)	❌	❌	Rust	Apache-2.0
ODE	✅	❌	❌	LCP Dantzig, PGS (QuickStep)	❌	❌	C/C++	LGPL/BSD
PhysX	✅	✅	✅	PGS, TGS	❌	✅	C++	BSD-3
pinocchio	⚠️	❌	❌	Proximal, PGS, ADMM	✅	❌	C++	BSD-2
ReactPhysics3d	✅	❌	❌	Sequential Impulses	❌	❌	C++	Zlib
Simbody	✅	❌	❌	Hunt-Crossley, Hertz, Elastic Foundation, PGS	⚠️	❌	C++	Apache-2.0
SOFA	✅	✅	✅	Penalty, LCP, Lagrange Multipliers, Augmented Lagrangian	❌	✅	C++	LGPL-2.1
Tiny Diff. Sim.	✅	❌	❌	MLCP (PGS), smooth spring-damper	✅	✅	C++	Apache-2.0

Legend: ✅ Supported · ❌ Not supported · ⚠️ Partial/limited

Notes:

Brax: Four physics pipelines — Spring (impulse), Positional (XPBD), Generalized (mass matrix QP), and MJX (delegates to MuJoCo). All written in JAX; differentiable via jax.grad. As of v0.13.0, only brax/training is actively maintained; physics users directed to MJX or MuJoCo Warp.
Bullet GPU: OpenCL rigid-body pipeline exists but is experimental and not widely used.
DART contact: Ships 15+ LCP solvers — Dantzig (default), PGS, Lemke, Baraff, Interior Point, MPRGP, and more. Collision backends: FCL, Bullet, ODE, built-in.
DART differentiable: Analytical Lie-group Jacobians and their time derivatives (not AD).
Drake differentiable: Full AutoDiffXd scalar type throughout MultibodyPlant. Soft bodies via FEM DeformableVolume (NeoHookean).
Flex: Archived — last commit April 2021. GPU-only (CUDA/DX11/DX12), no CPU fallback. Superseded by PhysX 5 + NVIDIA Warp.
Genesis: 6 custom Taichi-based solvers — Rigid (MuJoCo-inspired ABD), FEM (implicit Newton-PCG), MPM (elastic/liquid/sand/snow), SPH (DFSPH), PBD (cloth/elastic/liquid), Stable Fluid (Eulerian gas). Differentiable via Taichi autodiff + custom backward passes (rigid solver backward implemented, MPM/Tool officially supported). Claims 43M FPS (Franka arm, 30K parallel envs, RTX 4090). GPU via Taichi → CUDA/Vulkan/Metal.
MuJoCo soft: Tendons, muscles, and deformable FEM bodies (flexcomp — St. Venant-Kirchhoff, 1D/2D/3D elements). Differentiable via finite-difference in C and full autodiff via MJX (JAX).
Newton: Linux Foundation project (Disney Research, Google DeepMind, NVIDIA). 7 solver backends — Featherstone (CRBA), MuJoCo Warp, Semi-implicit Euler, XPBD, VBD/AVBD, Style3D (projective dynamics cloth), Implicit MPM. Differentiable via NVIDIA Warp’s wp.Tape() reverse-mode AD + analytical IK Jacobians. Supports URDF, MJCF, and USD (with PhysX schema compatibility). Built-in GPU-batched IK (LM + L-BFGS). Active beta.
Newton Dynamics soft: Deformable mesh API existed in v3.14 but was removed/commented out in v4. Fluids via CUDA SPH. The MADEAPPS/newton-dynamics repo is discontinued; active development continues at JulioJerez/newton-dynamics.
nphysics: Passively maintained since July 2021. Officially superseded by Rapier.
pinocchio rigid: Provides dynamics algorithms (ABA, RNEA) but no built-in time-stepper — the user writes the integration loop. Has contact constraint solvers (Proximal, PGS, ADMM) with Coulomb friction cones since v3.
Simbody differentiable: SmoothSphereHalfSpaceForce provides a C²-smooth contact model designed for gradient-based optimization.
SOFA fluids: SPH via the SofaSphFluid plugin; Eulerian grid-based via the bundled SofaEulerianFluid plugin. GPU via bundled SofaCUDA (28 kernel files) and SofaOpenCL plugins.
Tiny Diff. Sim.: Stale — last commit April 2023. GPU via CppAD code generation to CUDA kernels.

Robotics Dynamics Libraries

Libraries commonly used for robot dynamics computation in research and applications.

Name	Forward Dyn.	Inverse Dyn.	IK	URDF	Python API	Analytical Derivatives	Active (2025+)
pinocchio	✅ ABA	✅ RNEA	⚠️	✅	✅	✅	✅
DART	✅ ABA	✅ RNEA	✅	✅	✅	✅	✅
Drake	✅ ABA	✅	✅	✅	✅	✅	✅
MuJoCo	✅	✅	❌	✅	✅	⚠️	✅
Newton	✅ CRBA	✅ RNEA	✅	✅	✅	⚠️	✅
Brax	✅	✅ RNEA	❌	❌	✅	❌	⚠️
RBDL	✅ ABA	✅ RNEA	✅	✅	✅	⚠️	⚠️
Simbody	✅	✅	✅	⚠️	❌	❌	✅
idyntree	✅ ABA	✅ RNEA	✅	✅	✅	⚠️	✅
KDL	✅	✅ RNEA	✅	❌	✅	❌	✅
RBDyn	✅ CRBA	✅ RNEA	✅	✅	✅	⚠️	✅

Notes:

pinocchio IK: Provides Jacobians, integrate(), and example IK loops — but no dedicated IK solver class. The companion project LoIK provides a dedicated solver. Analytical derivatives are the signature feature: closed-form derivatives of RNEA, ABA, constrained dynamics, kinematics, and centroidal dynamics (RSS 2018). Also supports CppAD and CasADi AD backends.
DART IK: Extensive built-in IK — per-node InverseKinematics, HierarchicalIK, WholeBodyIK, CompositeIK, IkFast (OpenRAVE analytical), JacobianDLS, JacobianTranspose. Analytical derivatives: Lie-group Jacobians and time derivatives computed analytically. Also parses URDF, SDF, MJCF, and SKEL formats.
Drake IK: InverseKinematics, GlobalInverseKinematics (mixed-integer), DifferentialInverseKinematics. Analytical derivatives via AutoDiffXd scalar templating. Also parses URDF, SDF, MJCF, and Drake Model Directives (.dmd.yaml).
MuJoCo URDF: Native parser (auto-detects <robot> root element). IK: No built-in solver — provides Jacobians (mj_jac, mj_jacBody) for user-implemented IK. Derivatives: Finite-difference in C (mjd_transitionFD); full autodiff via MJX (JAX). Also native MJCF format.
Newton FD: Featherstone CRBA (H·q̈ = τ − C, Cholesky). Also MuJoCo Warp backend for forward dynamics. ID: Full RNEA implementation. IK: GPU-batched LM + L-BFGS with analytical or autodiff Jacobians (selectable via IKJacobianMode). URDF + MJCF + USD parsers. Derivatives: Warp wp.Tape() autodiff + analytical IK Jacobians. Active beta (Linux Foundation project).
Brax FD: Generalized pipeline solves M·q̈ = -C + τ; also Spring (impulse) and Positional (PBD) pipelines. ID: RNEA in generalized pipeline. IK: None. URDF: No parser — MJCF only (via mujoco.MjModel). Derivatives: Purely JAX autodiff (jax.grad). Active: Only brax/training maintained as of v0.13.0; physics users directed to MJX.
RBDL derivatives: Via CasADi algorithmic differentiation backend (rbdl-casadi), not hand-coded. IK: Built-in damped least-squares with position/orientation/CoM constraints. Activity: Low — last commit June 2025.
Simbody IK: Assembler framework with Markers (point-based) and OrientationSensors conditions. URDF: Example-only reader (Atlas demo), not a core library feature. Simbody’s native API uses MultibodyGraphMaker.
idyntree IK: Full NLP-based IK solver using IPOPT with quaternion/RPY parametrizations and CoM constraints. Derivatives: Experimental forward dynamics linearization (ForwardDynamicsLinearization, marked “HIGHLY EXPERIMENTAL”). Also parses SDF. Correct GitHub repo: robotology/idyntree.
KDL IK: 7+ solver variants — Newton-Raphson, LMA, pseudoinverse, WDLS, nullspace optimization, and tree-based variants. Also provides the Vereshchagin hybrid dynamics solver. URDF: Requires external kdl_parser from ROS. Python: PyKDL via pybind11.
RBDyn FD: CRBA-based (H·q̈ = τ − C with LDLT), not ABA. IK: Jacobian SVD solver with configurable damping. Derivatives: Inverse statics torque Jacobians (∂τ/∂q for static case) and IDIM for parameter identification. Built-in URDF read/write parser, no ROS dependency.

Decision Guide

Which library should I use?

Robotics research (manipulation, locomotion): pinocchio, Drake, or MuJoCo — all actively maintained with strong community support and differentiable simulation.
Reinforcement learning for robotics: MuJoCo (with MJX for GPU-accelerated batched simulation), Isaac Lab (GPU-parallel envs on Isaac Sim), Genesis (43M FPS batched sim), or Brax (JAX-native, training-focused).
Game-like real-time physics: Bullet, PhysX, or ReactPhysics3d.
Biomechanical simulation: Simbody (the engine behind OpenSim).
Multi-physics (FEM, soft bodies, fluids): SOFA, CHRONO, Genesis (6 unified solvers: rigid, FEM, MPM, SPH, PBD, Stable Fluid), or Newton (FEM, MPM, cloth, XPBD on Warp).
Differentiable simulation: pinocchio (analytical derivatives), Drake (AutoDiffXd), MuJoCo MJX (JAX autodiff), Newton (Warp autodiff), Genesis (Taichi autodiff), or Brax (JAX autodiff).
Lightweight rigid-body dynamics: RBDL, KDL, or RBDyn.
Floating-base humanoid estimation/control: idyntree or RBDyn (mc-rtc ecosystem).
GPU-accelerated robotics sim (Warp-based): Newton — Linux Foundation project with MuJoCo Warp backend, 7 solvers, GPU-batched IK.
Rust ecosystem: nphysics (note: passively maintained since 2021; consider Rapier as its successor).

Benchmark Resources

Benchmark Suites

scpeters/benchmark — Benchmark comparisons of rigid-body dynamics simulators.
leggedrobotics/SimBenchmark — Comprehensive benchmark for physics simulation in robotics. [github]
IFToMM — Benchmark problems from the international multibody dynamics community.
BPMD — Benchmark Problems for Multibody Dynamics database.