Pinocchio is open-source software actively developed by the Willow team at Inria in the lovely city of Paris. Pinocchio instantiates state-of-the-art Rigid Body Algorithms for poly-articulated systems, building upon and revisiting the foundational algorithms introduced by Roy Featherstone.

Beyond traditional rigid-body dynamics formulations, Pinocchio delivers cutting-edge algorithmic solutions for modern robotics and physics-based simulation challenges. It efficiently handles closed-loop kinematic mechanisms, solves frictional contact problems, and differentiates physics computations — making it a powerful and versatile library for both research and industrial applications.

Pinocchio also provides analytical derivatives of the main Rigid Body Algorithms — such as the Recursive Newton-Euler Algorithm and the Articulated-Body Algorithm — enabling gradient-based optimization, control, and learning in both simulation and real-world settings.

Pinocchio was originally designed for robotics applications, but it can be used in other contexts (biomechanics, computer graphics, vision, etc.). It is built upon Eigen for linear algebra and coal for collision detection. Pinocchio includes a Python interface for fast code prototyping, directly accessible through Conda.

Pinocchio is now at the heart of various robotics software as Aligator, Crocoddyl, an open-source and efficient Differential Dynamic Programming solver for robotics, the Stack-of-Tasks, an open-source and versatile hierarchical controller framework, or the Humanoid Path Planner, open-source software for Motion and Manipulation Planning. Pinocchio is also a primary source of inspiration for the Kamino simulator developed by Disney Research, which populates the Newton physics engine.

If you want to learn more about Pinocchio internal behaviors and main features, we invite you to read the related paper and the online documentation or DeepWiki.

If you want to dive into Pinocchio directly, only one single line is sufficient (assuming you have Conda):

conda install pinocchio -c conda-forge

or via pip (currently only available on Linux):

pip install pin

Table of contents

• Table of contents
• Pinocchio main features
• Documentation
• Examples
• Tutorials
• Pinocchio continuous integrations
• Performances
• Ongoing developments
• Installation
  • ROS
• Visualization
• Citing Pinocchio
• Questions and Issues
• Core-dev team
• Credits
• Open-source projects relying on Pinocchio
• Acknowledgments

Pinocchio main features

Pinocchio is fast:

• C++ template library,
• cache-friendly,
• support custom scalar type.

Pinocchio is versatile, implementing basic and more advanced rigid body dynamics algorithms:

• forward kinematics and its analytical derivatives,
• forward/inverse dynamics and their analytical derivatives,
• centroidal dynamics and its analytical derivatives,
• computations of kinematic and dynamic regressors for system identification and more,
• full support of closed-loop mechanisms,
• state-of-the-art frictional contact solvers,
• low-complexity constrained articulated body algorithms,
• sparse constrained dynamics and its analytical derivatives,
• full support of multiple-precision floating-point (MPFR) in Python and C++,
• support of modern and open-source Automatic Differentiation frameworks like CppAD or CasADi,
• automatic code generation support is available via CppADCodeGen.

Pinocchio can support description formats:

• URDF format,
• SDF format,
• MJCF format,
• SRDF format,
• programmatically.

Pinocchio is flexible:

File truncated at 100 lines see the full file

Changelog

All notable changes to this project will be documented in this file.

Change that doesn’t affect end user should not be listed:

• CI change
• Github specific file change

The format is based on Keep a Changelog.

[Unreleased]

[4.0.0] - 2026-04-13

Highlights

• lcaba algorithm:
  • Compute forward dynamics for constrained system with closed kinematics loops
  • Python example here
• New constraint API:
  • PointContactConstraintModelTpl, PointAnchorConstraintModelTpl, FrameAnchorConstraintModelTpl, JointLimitConstraintModelTpl and JointFrictionConstraintModelTpl constraint models
  • Each constraint model is associated to its own constraint data
  • Variants ConstraintModelTpl/ConstraintDataTpl encapsulate all constraints models and data
  • Delassus operator API: DelassusOperatorDenseTpl, DelassusOperatorSparseTpl, DelassusOperatorCholeskyExpressionTpl, DelassusOperatorRigidBodyTpl
  • These operators are tightly linked to the new constraints API All these operators compute the same mathematical operator $J M^{-1} J^T$ ($J$ is the constraints jacobian, $M^{-1}$ is the inverse of the mass matrix), but with different algorithms and internal optimizations
• ADMMConstraintSolverTpl and PGSConstraintSolverTpl algorithms:
  • Solve constrained dynamics expressed with the new constraint API
  • Python examples here and here. These examples show how to use each constraint model, how to build a constraint problem, how to compute the associated Delassus operator and how to solve it
• New header convention
  • Introduce omnibus headers:
    • pinocchio/math.hpp
    • pinocchio/spatial.hpp
    • pinocchio/mutlibody.hpp
    • …

Added

• Add lcaba algorithm in pinocchio/algorithm/loop-constrained-aba.hpp
  • Compute forward dynamics for constrained system with closed kinematics loops
• Add computeJointMinimalOrdering in pinocchio/constraints.hpp
  • Compute joint processing order for lcaba
• Add new constraint API in pinocchio/constraints.hpp
  • PointContactConstraintModel: models a unilateral contact constraint with coulomb friction cone
  • PointAnchorConstraintModel: models a point-wise equality constraint (bilateral constraint)
  • FrameAnchorConstraintModel: models a frame-wise equality constraint (bilateral constraint)
  • JointLimitConstraintModel: models a component-wise joint limit lower/upper bound constraint
  • JointFrictionConstraintModel: models a component-wise joint friction lower/upper bound constraint
• Add new Delassus API in pinocchio/algorithm/delassus.hpp
• Add ADMMConstraintSolverTpl in pinocchio/algorithm/solvers/admm-solver.hpp
  • Solve constrained dynamics using an ADMM algorithm
• Add PGSConstraintSolverTpl in pinocchio/algorithm/solvers/pgs-solver.hpp
  • Solve constrained dynamics using a projected Gauss Siedel algorithm
• Add new functions in pinocchio/multibody/liegroup.hpp
  • tangentMap: transforms a configuration variation into a small variation expressed in the parametric space
  • tangentMapProduct and tangentMapTransport: apply tangentMap while exploiting sparsity
• Add mimic joint support for all Lie group related algorithms
• Add new methods to JointModelBase:
  • jointQrows and jointQcols that make selections of size NQ
  • jointQVMap that make selections of size NQ x NV
  • lieGroup that returns the Lie group instance associated to a joint
• Add lieGroup function that returns the Lie group instance associated to a model
• Add new mjcf::buildModel overload to load new constraint API from MJCF
• Add new sdf::buildModel overload to load new constraint API from SDF
• Add new Python functions to load MJCF model:
  • Add pinocchio.buildModelFromMJCFAndRootJoint load model with a custom root joint
  • Add pinocchio.buildModelAndConstraintFromMJCF load model and constraints (new API)
  • Add pinocchio.buildModelAndLegacyConstraintFromMJCF load model and constraints (old API)
• Add Python example showcasing the candlewick visualizer
• Add PINOCCHIO_DISABLE_UNSUPPORTED_WARNINGS C++ definition to disable unsupported algorithm warnings
• Add PINOCCHIO_BUILD_MPFR_TESTING CMake option to build MPFR tests
• Add pinocchio/utils/alloca.hpp: Helpers for mapping stack allocation for Eigen::Map
• Add pinochio/container/eigen-storage.hpp: Introduce internal::EigenStorageTpl
• Add pinochio/container/matrix-stack.hpp: Introduce internal::MatrixStackTpl
• Add pinochio/container/double-entry-container.hpp: Introduce internal::DoubleEntryContainer
• Add internal::MatrixBlockElementTpl in math.hpp
• Add internal::BlockDiagonalMatrixTpl in math.hpp
• Add internal::matrix_product in math.hpp
• Add internal::matrix_inversion in math.hpp
• Add internal::matrix_inversion_code_generated in math.hpp
• Add support to libsdformat > 14

Changed

• C++17 is now the minimal supported version of the C++ standard. Check cppreference to see if your compiler supports it.
• Introduce new header convention described here
  • Omnibus header as default pinocchio include
  • Replace headers guards by #pragma once
• Bindings/python: Add missing arg names in visualizer-visitor.hpp
• Renamed PINOCCHIO_PRAGMA_DEPRECATED_HEADER to PINOCCHIO_MOVED_HEADER
• Docs: update documentation stylesheet, fix some Doxygen config options
• Replace hpp-fcl by coal (see doc/_porting.md):
  • C++:
    • Deprecate pinocchio/multibody/fcl.hpp moved at pinocchio/multibody/coal.hpp
    • Deprecate pinocchio/serialization/fcl.hpp moved at pinocchio/serialization/coal.hpp
    • Deprecate pinocchio/collision/fcl-pinocchio-conversions.hpp moved at pinocchio/collision/coal-pinocchio-conversions.hpp
    • Deprecate pinocchio/bindings/python/collision/fcl/transform.hpp moved at pinocchio/bindings/python/collision/coal/transform.hpp
    • Deprecate pinocchio::toFclTransform3f replaced by pinocchio::toCoalTransform3s
    • Deprecate PINOCCHIO_WITH_HPP_FCL replaced by PINOCCHIO_WITH_COLLISION
  • Python:

File truncated at 100 lines see the full file