pinocchio 2.6.21.bcr.7Latest published 7.7mo ago
MODULE.bazel
bazel_dep(name = "pinocchio", version = "2.6.21.bcr.7")
Dependencies
README

Pinocchio Logo

License Documentation Ask DeepWiki Coverage Report Conda Downloads Conda Version PyPI version pre-commit.ci status

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

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:

  • header only,
  • template instantiation,
  • C++ 17/20/23 compliant.

Pinocchio is extensible. Pinocchio is multi-thread friendly. Pinocchio is reliable and extensively tested (unit tests, simulations, and real-world robotics applications). Pinocchio is supported and tested on Windows, Mac OS X, Unix, and Linux (see build status here).

Documentation

The online documentation for the latest release of Pinocchio is available here. A cheat sheet pdf with the main functions and algorithms can be found here.

Examples

In the examples directory, we provide some basic examples of using Pinocchio in Python. Additional examples introducing Pinocchio are also available in the documentation.

Tutorials

Pinocchio comes with a large set of tutorials that introduce the basic tools for robot control. Tutorial and training documents are listed here. You can also consider the interactive Jupyter notebook set of tutorials developed by Nicolas Mansard and Yann de Mont-Marin.

Pinocchio continuous integrations

Pinocchio is constantly tested for several platforms and distributions, as reported below:

CI on ROS ROS
CI on Linux via APT linux
CI on macOS and Windows via Pixi mac
CI on Linux via Robotpkg Pipeline Status

Performances

Pinocchio exploits, at best, the sparsity induced by the kinematic tree of robotics systems. Thanks to modern programming language paradigms, Pinocchio can unroll most of the computations directly at compile time, allowing to achieve impressive performances for an extensive range of robots, as illustrated by the plot below, obtained on a standard laptop equipped with an Intel Core i7 CPU @ 2.4 GHz.

Pinocchio Logo

For other benchmarks, and mainly the capacity of Pinocchio to exploit, at best, your CPU capacities using advanced code generation techniques, we refer to the technical paper. In addition, the introspection may also help you to understand and compare the performances of the modern rigid body dynamics libraries.

Ongoing developments

If you want to follow the current developments, you can refer to the devel branch. The devel branch only contains the latest release. Any new Pull Request should be submitted on the devel branch.

Installation

Pinocchio can be easily installed on various Linux (Ubuntu, Fedora, etc.) and Unix distributions (Mac OS X, BSD, etc.). Please refer to the installation procedure.

Conda

You simply need this simple line:

conda install pinocchio -c conda-forge

Docker

docker run --rm -it ghcr.io/stack-of-tasks/pinocchio:devel

ROS

Pinocchio is also deployed on ROS. You may follow its deployment status below.

If you're interested in using Pinocchio on systems and/or with packages that integrate with the ROS ecosystem, we recommend the installation of Pinocchio via the binaries distributed via the ROS PPA. Here, you can install Pinocchio using:

sudo apt install ros-$ROS_DISTRO-pinocchio

This installs Pinocchio with Coal support for collision checking and with Python bindings. You can then use Pinocchio in your ROS packages by:

  • Depending on Pinocchio in your package.xml config (<depend>pinocchio</depend>)
  • Including Pinocchio via CMake (find_package(pinocchio REQUIRED)) and linking against Pinocchio (target_link_libraries(my_library pinocchio::pinocchio))

We include support and hooks to discover the package for ROS build systems. A ROS 2 example can be found in this repository.

Please note that we always advise including the pinocchio/fwd.hpp header as the first include to avoid compilation errors from differing Boost-variant sizes.

ROS 2 Distro Build Status
Humble
Jazzy
Kilted
Lyrical
Rolling

Visualization

Pinocchio provides support for many open-source and free visualizers:

  • Gepetto Viewer: a C++ viewer based on OpenSceneGraph with Python bindings and Blender export. See here for a C++ example on mixing Pinocchio and Gepetto Viewer.
  • Meshcat: supporting visualization in Python and which can be embedded inside any browser.
  • Panda3d: supporting visualization in Python and which can be embedded inside any browser.
  • RViz: supporting visualization in Python and which can interact with other ROS packages.
  • Viser: supporting browser-based visualization in Python, with support for widgets such as sliders and interactive markers.

Many external viewers can also be integrated. For more information, see the example here.

Citing Pinocchio

To cite Pinocchio in your academic research, please consider citing the software paper and use the following BibTeX entry:

@inproceedings{carpentier2019pinocchio,
   title={The Pinocchio C++ library -- A fast and flexible implementation of rigid body dynamics algorithms and their analytical derivatives},
   author={Carpentier, Justin and Saurel, Guilhem and Buondonno, Gabriele and Mirabel, Joseph and Lamiraux, Florent and Stasse, Olivier and Mansard, Nicolas},
   booktitle={IEEE International Symposium on System Integrations (SII)},
   year={2019}
}

And the following one for the link to the GitHub codebase:

@misc{pinocchioweb,
   author = {Justin Carpentier and Florian Valenza and Nicolas Mansard and others},
   title = {Pinocchio: fast forward and inverse dynamics for poly-articulated systems},
   howpublished = {https://stack-of-tasks.github.io/pinocchio},
   year = {2015--2021}
}

Citing specific algorithmic contributions

Pinocchio goes beyond implementing the standard rigid-body dynamics algorithms and results from active research on simulation, learning, and control. Pinocchio provides state-of-the-art algorithms for handling constraints, closed-loops mechanisms, differentiating forward and inverse dynamics, etc. If you use these algorithms, please consider citing them in your research articles.

Contribution

If you want to ask a question, report a bug, request a new feature or contributing with a pull requests please, follow the contribution guideline.

Core-dev team

The currently active core developers of Pinocchio are:

Credits

In addition to the core dev team, the following people have also been involved in the development of Pinocchio and are warmly thanked for their contributions:

If you have participated in the development of Pinocchio, please add your name and contribution to this list.

Open-source projects relying on Pinocchio

  • Crocoddyl: A software to realize model predictive control for complex robotics platforms.
  • TSID: A software that implements a Task Space Inverse Dynamics QP.
  • HPP: A SDK that implements motion planners for humanoids and other robots.
  • Jiminy: A simulator based on Pinocchio.
  • ocs2: A toolbox for Optimal Control for Switched Systems (OCS2)
  • TriFingerSimulation: TriFinger Robot Simulation (a Robot to perform RL on manipulation).
  • Casadi_Kin_Dyn: IIT Package for generation of symbolic (SX) expressions of robot kinematics and dynamics.
  • PyRoboPlan: An educational Python library for manipulator motion planning using the Pinocchio Python bindings.
  • RoboPlan: A modern robot motion planning library based on Pinocchio, built in C++ with Python bindings (successor to PyRoboPlan).
  • ProxSuite-NLP: A primal-dual augmented Lagrangian solver for nonlinear programming on manifolds.
  • Aligator: A versatile and efficient framework for constrained trajectory optimization.
  • Simple: The Simple Simulator: Simulation Made Simple.
  • LoIK: Low-Complexity Inverse Kinematics.
  • PlaCo: Rhoban's planning and control library, featuring task-space inverse kinematics and dynamics high-level API for whole-body control tasks.
  • CRISP controllers: Collection of real-time, C++ controllers for compliant torque-based control for manipulators compatible with ros2_control.

Acknowledgments

The development of Pinocchio is actively led by the Willow team @INRIA, with the support of the Gepetto team @LAAS-CNRS.

About

A fast and flexible implementation of Rigid Body Dynamics algorithms and their analytical derivatives

@stack-of-tasks/pinocchio@stack-of-tasks
Homepage
3782stars
Tuesday, February 17, 2026
@faximan#7566 Add Pinocchio 2.6.21.bcr.7 (#...

Languages

C++93.7%
Python4.4%
CMake1.8%
Batchfile0%
C0%
Nix0%
Shell0%

Maintainers

@bponton-intrinsic
@mering

Compatibility

Versions

2.6.21.bcr.7 +24d2026-02-17
2.6.21.bcr.6 +2.3mo2026-01-23
2.6.21.bcr.5 +1.1mo2025-11-14
2.6.21.bcr.4 +2d2025-10-13
2.6.21.bcr.3 +3.3mo2025-10-10
2.6.21.bcr.2 +3d2025-07-01
2.6.21.bcr.1 +10h2025-06-28
2.6.212025-06-27