# pinocchio
**Repository Path**: null_974_9686/pinocchio
## Basic Information
- **Project Name**: pinocchio
- **Description**: pinocchiopinocchio
- **Primary Language**: Unknown
- **License**: BSD-2-Clause
- **Default Branch**: devel
- **Homepage**: None
- **GVP Project**: No
## Statistics
- **Stars**: 0
- **Forks**: 0
- **Created**: 2026-08-03
- **Last Updated**: 2026-08-03
## Categories & Tags
**Categories**: Uncategorized
**Tags**: None
## README
**Pinocchio** is open-source software actively developed by the [Willow](https://www.di.ens.fr/willow/) team at [Inria](https://www.inria.fr/en) 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](https://github.com/conda-forge/pinocchio-feedstock#installing-pinocchio) through [Conda](https://docs.conda.io/en/latest/).
**Pinocchio** is now at the heart of various robotics software as [Aligator](https://github.com/Simple-Robotics/Aligator), [Crocoddyl](https://github.com/loco-3d/crocoddyl), an open-source and efficient Differential Dynamic Programming solver for robotics, the [Stack-of-Tasks](http://stack-of-tasks.github.io), an open-source and versatile hierarchical controller framework, or the [Humanoid Path Planner](https://humanoid-path-planner.github.io/hpp-doc), open-source software for Motion and Manipulation Planning.
**Pinocchio** is also a primary source of inspiration for the [Kamino](https://disneyresearch.github.io/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](https://hal-laas.archives-ouvertes.fr/hal-01866228) and the online [documentation](https://gepetto.github.io/doc/pinocchio/doxygen-html/) or [DeepWiki](https://deepwiki.com/stack-of-tasks/pinocchio).
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](#table-of-contents)
- [Pinocchio main features](#pinocchio-main-features)
- [Documentation](#documentation)
- [Examples](#examples)
- [Tutorials](#tutorials)
- [Pinocchio continuous integrations](#pinocchio-continuous-integrations)
- [Performances](#performances)
- [Ongoing developments](#ongoing-developments)
- [Installation](#installation)
- [ROS](#ros)
- [Visualization](#visualization)
- [Citing Pinocchio](#citing-pinocchio)
- [Questions and Issues](#questions-and-issues)
- [Core-dev team](#core-dev-team)
- [Credits](#credits)
- [Open-source projects relying on Pinocchio](#open-source-projects-relying-on-pinocchio)
- [Acknowledgments](#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](https://hal.science/hal-04588906v1/file/simplecontacts2024.pdf),
- low-complexity constrained articulated body algorithms,
- [sparse constrained dynamics](https://laas.hal.science/hal-01790971v2/file/18-rss-analytical-derivatives-carpentier.pdf) and its analytical derivatives,
- full support of [multiple-precision floating-point (MPFR)](https://www.mpfr.org/) in Python and C++,
- support of modern and open-source Automatic Differentiation frameworks like [CppAD](https://github.com/coin-or/CppAD) or [CasADi](https://web.casadi.org/),
- automatic code generation support is available via [CppADCodeGen](https://github.com/joaoleal/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](http://robotpkg.openrobots.org/rbulk/robotpkg/math/pinocchio/index.html)).
## Documentation
The online documentation for the latest release of **Pinocchio** is available [here](https://gepetto.github.io/doc/pinocchio/doxygen-html/). A cheat sheet pdf with the main functions and algorithms can be found [here](https://github.com/stack-of-tasks/pinocchio/blob/devel/doc/pinocchio_cheat_sheet.pdf).
## Examples
In the [examples](https://github.com/stack-of-tasks/pinocchio/tree/devel/examples) directory, we provide some basic examples of using Pinocchio in Python.
Additional examples introducing **Pinocchio** are also available in the [documentation](https://gepetto.github.io/doc/pinocchio/doxygen-html/md_doc_d-practical-exercises_intro.html).
## Tutorials
**Pinocchio** comes with a large set of tutorials that introduce the basic tools for robot control.
Tutorial and training documents are listed [here](https://gepetto.github.io/doc/pinocchio/doxygen-html/index.html#OverviewConclu).
You can also consider the interactive Jupyter notebook [set of tutorials](https://github.com/ymontmarin/_tps_robotique) developed by [Nicolas Mansard](https://www.laas.fr/fr/annuaire/223) and [Yann de Mont-Marin](https://github.com/ymontmarin).
## Pinocchio continuous integrations
**Pinocchio** is constantly tested for several platforms and distributions, as reported below:
| CI on ROS |
 |
| CI on Linux via APT |
 |
| CI on macOS and Windows via Pixi |
 |
| CI on Linux via Robotpkg |
 |
## 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.
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](https://hal-laas.archives-ouvertes.fr/hal-01866228).
In addition, the [introspection](https://github.com/rbd-benchmarks/rbd-benchmarks) 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](https://github.com/stack-of-tasks/pinocchio/tree/devel).
The [devel branch](https://github.com/stack-of-tasks/pinocchio/tree/devel/) only contains the latest release. Any new Pull Request should be submitted on the [devel branch](https://github.com/stack-of-tasks/pinocchio/tree/devel/).
## 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](http://stack-of-tasks.github.io/pinocchio/download.html).
### Conda
You simply need this simple line:
```bash
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 (`pinocchio`)
* 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](https://github.com/sea-bass/pinocchio_ros_cpp_example).
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** | [](https://build.ros2.org/job/Hbin_uJ64__pinocchio__ubuntu_jammy_amd64__binary) |
| **Jazzy** | [](https://build.ros2.org/job/Jbin_uN64__pinocchio__ubuntu_noble_amd64__binary) |
| **Kilted** | [](https://build.ros2.org/job/Kbin_uN64__pinocchio__ubuntu_noble_amd64__binary) |
| **Lyrical** | [](https://build.ros2.org/job/Lbin_uR64__pinocchio__ubuntu_resolute_amd64__binary) |
| **Rolling** | [](https://build.ros2.org/job/Rbin_uR64__pinocchio__ubuntu_resolute_amd64__binary) |
## Visualization
**Pinocchio** provides support for many open-source and free visualizers:
- [Gepetto Viewer](https://github.com/Gepetto/gepetto-viewer): a C++ viewer based on [OpenSceneGraph](https://github.com/openscenegraph/OpenSceneGraph) with Python bindings and Blender export. See [here](https://github.com/stack-of-tasks/pinocchio-gepetto-viewer) for a C++ example on mixing **Pinocchio** and **Gepetto Viewer**.
- [Meshcat](https://github.com/rdeits/meshcat): supporting visualization in Python and which can be embedded inside any browser.
- [Panda3d](https://github.com/ikalevatykh/panda3d_viewer): supporting visualization in Python and which can be embedded inside any browser.
- [RViz](https://github.com/ros-visualization/rviz): supporting visualization in Python and which can interact with other ROS packages.
- [Viser](https://github.com/nerfstudio-project/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](https://github.com/stack-of-tasks/pinocchio/blob/devel/bindings/python/pinocchio/visualize/base_visualizer.py).
## Citing Pinocchio
To cite **Pinocchio** in your academic research, please consider citing the [software paper](https://laas.hal.science/hal-01866228v2/file/19-sii-pinocchio.pdf) and use the following BibTeX entry:
```bibtex
@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:
```bibtex
@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.
- de Mont-Marin, Y. Montaut, L. Ponce, J. Herbet, M. & Carpentier, J. (2026). [On the Conic Complementarity of Planar Contacts](https://arxiv.org/pdf/2509.25999). In 2026 International Conference on Robotics and Automation (ICRA).
- Sathya, A., Montaut, L. de Mont-Marin, Y. & Carpentier, J. (2026). [Matrix-Free Delassus Operations: Scalable and Memory-Efficient Algorithms](https://hal.science/hal-05457476v1/file/RAL___Matrix_free_Delassus_Computation.pdf). Preprint.
- Sathya, A. & Carpentier, J. (2025). [Constrained articulated body algorithms for closed-loop mechanisms](https://hal.science/hal-04895583v2/file/main.pdf). In Transactions on Robotics.
- Sathya, A. & Carpentier, J. (2024). [Constrained Articulated Body Dynamics Algorithms](https://hal.science/hal-04443056v2/file/TRO%20-%20Constrained%20Articulated%20Body%20Dynamics%20Algorithms.pdf). In Transactions on Robotics.
- Carpentier, J., Le Lidec, Q. & Montaut, L. (2024, July). [From Compliant to Rigid Contact Simulation: a Unified and Efficient Approach](https://hal.science/hal-04588906). In RSS 2024-Robotics: Science and Systems (RSS 2024).
- Le Lidec, Q., Jallet, W., Montaut, L., Laptev, I., Schmid, C., & Carpentier, J. (2024). [Contact models in robotics: a comparative analysis](https://hal.science/hal-04067291/). IEEE Transactions on Robotics.
- Montaut, L., Le Lidec, Q., Petrik, V., Sivic, J., & Carpentier, J. (2024). [GJK++: Leveraging Acceleration Methods for Faster Collision Detection](https://hal.science/hal-04070039/). IEEE Transactions on Robotics.
- Sathya, A., & Carpentier, J. (2024). [Constrained Articulated Body Dynamics Algorithms](https://hal.science/hal-04443056/). IEEE Transactions on Robotics.
- Montaut, L., Le Lidec, Q., Bambade, A., Petrik, V., Sivic, J., & Carpentier, J. (2023, May). [Differentiable collision detection: a randomized smoothing approach](https://hal.science/hal-03780482/). In 2023 IEEE International Conference on Robotics and Automation (ICRA).
- Montaut, L., Le Lidec, Q., Petrik, V., Sivic, J., & Carpentier, J. (2022, June). [Collision Detection Accelerated: An Optimization Perspective](https://hal.science/hal-03662157/). In Robotics: Science and Systems (RSS 2022).
- Carpentier, J., Budhiraja, R., & Mansard, N. (2021, July). [Proximal and sparse resolution of constrained dynamic equations](https://hal.science/hal-03271811/). In Robotics: Science and Systems (RSS 2021).
- Carpentier, J., & Mansard, N. (2018, June). [Analytical derivatives of rigid body dynamics algorithms](https://hal.science/hal-01790971/). In Robotics: Science and Systems (RSS 2018).
## Questions and Issues
Do you have a question or an issue? You may either directly open a [new question](https://github.com/stack-of-tasks/pinocchio/discussions/new?category=q-a) or a [new issue](https://github.com/stack-of-tasks/pinocchio/issues) or, directly contact us via the mailing list .
## Core-dev team
The currently active core developers of **Pinocchio** are:
- [Justin Carpentier](https://jcarpent.github.io) (Inria): main developer and manager of the project
- [Guilhem Saurel](https://www.laas.fr/fr/annuaire/gsaurel) (LAAS-CNRS): CI/CD, packaging
- [Etienne Arlaud](https://github.com/EtienneAr) (Inria): core developer
- [Wilson Jallet](https://github.com/ManifoldFR) (Inria): extension of Python bindings, C++ visualization API
- [Fabian Schramm](https://github.com/fabinsch) (Inria): core developper
- [Joris Vaillant](https://github.com/jorisv) (Inria): core developer and project manager
- [Ajay Sathya](https://www.ajaysathya.com/) (Inria): core developer
- [Louis Montaut](https://lmontaut.github.io/) (Inria): core developer
- [Quentin Le Lidec](https://quentinll.github.io/) (NYU/formerly Inria): core developer
- [Yann de Mont-Marin](https://ymontmarin.github.io/) (Inria): core developer
- [Jeanne Matheron](https://www.linkedin.com/in/jeanne-matheron/) (Inria): core developer
## 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:
- [Nicolas Mansard](http://projects.laas.fr/gepetto/index.php/Members/NicolasMansard) (LAAS-CNRS): initial project instructor
- [Joseph Mirabel](http://jmirabel.github.io/) (Eureka Robotics): Lie groups and hpp-fcl support
- [Antonio El Khoury](https://www.linkedin.com/in/antonioelkhoury) (Wandercraft): bug fixes
- [Gabriele Buondono](http://projects.laas.fr/gepetto/index.php/Members/GabrieleBuondonno) (LAAS-CNRS): features extension, bug fixes, and Python bindings
- [Florian Valenza](https://fr.linkedin.com/in/florian-valenza-1b274082) (Astek): core developments and hpp-fcl support
- [Wolfgang Merkt](http://www.wolfgangmerkt.com/) (University of Oxford): ROS integration and support
- [Rohan Budhiraja](https://scholar.google.com/citations?user=NW9Io9AAAAAJ) (Inria/LAAS-CNRS): features extension
- [Loïc Estève](https://github.com/lesteve) (Inria): Conda integration and support
- [Igor Kalevatykh](https://github.com/ikalevatykh) (Inria): Panda3d viewer support
- [Matthieu Vigne](https://github.com/matthieuvigne) (Wandercraft): MeshCat viewer support
- [Robin Strudel](https://www.di.ens.fr/robin.strudel/) (Inria): features extension
- [François Keith](https://scholar.google.fr/citations?user=cxSxXiQAAAAJ&hl=en) (CEA): Windows support
- [Sarah El Kazdadi](https://github.com/sarah-ek) (Inria): multi-precision arithmetic support
- [Nicolas Torres Alberto](https://scholar.google.com/citations?user=gYNLhEIAAAAJ&hl=en) (Inria): features extension
- [Shubham Singh](https://github.com/shubhamsingh91) (UT Austin): second-order inverse dynamics derivatives
- [Sebastian Castro](https://roboticseabass.com): Viser visualizer and MeshCat visualizer feature extension
- [Lev Kozlov](https://github.com/lvjonok): Kinetic and potential energy regressors
- [Simeon Nedelchev](https://github.com/simeon-ned): Pseudo inertia and Log-Cholesky parametrization
- [Alexy Legrand](https://www.linkedin.com/in/alexy-legrand-125889232/): Viser color bug fixes
- [Pierre Puchaud](https://github.com/ipuch): Ellipsoid Joint
- [Lucas Joseph](https://github.com/LucasJoseph): Ellipsoid Joint
- [Megane Millan](https://github.com/MegMll): core developer (MJCF, joint mimic, etc.)
- [Tingfan Wu](https://github.com/tingfan): Viser visualizer mesh-scale bug fix
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](https://github.com/loco-3d/crocoddyl): A software to realize model predictive control for complex robotics platforms.
- [TSID](https://github.com/stack-of-tasks/tsid/): A software that implements a Task Space Inverse Dynamics QP.
- [HPP](https://humanoid-path-planner.github.io/hpp-doc/): A SDK that implements motion planners for humanoids and other robots.
- [Jiminy](https://github.com/duburcqa/jiminy): A simulator based on Pinocchio.
- [ocs2](https://github.com/leggedrobotics/ocs2): A toolbox for Optimal Control for Switched Systems (OCS2)
- [TriFingerSimulation](https://github.com/open-dynamic-robot-initiative/trifinger_simulation): TriFinger Robot Simulation (a Robot to perform RL on manipulation).
- [Casadi_Kin_Dyn](https://github.com/ADVRHumanoids/casadi_kin_dyn): IIT Package for generation of symbolic (SX) expressions of robot kinematics and dynamics.
- [PyRoboPlan](https://github.com/sea-bass/pyroboplan): An educational Python library for manipulator motion planning using the Pinocchio Python bindings.
- [RoboPlan](https://github.com/open-planning/roboplan): A modern robot motion planning library based on Pinocchio, built in C++ with Python bindings (successor to PyRoboPlan).
- [ProxSuite-NLP](https://github.com/Simple-Robotics/proxsuite-nlp): A primal-dual augmented Lagrangian solver for nonlinear programming on manifolds.
- [Aligator](https://github.com/Simple-Robotics/aligator): A versatile and efficient framework for constrained trajectory optimization.
- [Simple](https://github.com/Simple-Robotics/Simple): The Simple Simulator: Simulation Made Simple.
- [LoIK](https://github.com/Simple-Robotics/LoIK): Low-Complexity Inverse Kinematics.
- [PlaCo](https://github.com/Rhoban/placo): Rhoban's planning and control library, featuring task-space inverse kinematics and dynamics high-level API for whole-body control tasks.
- [CRISP controllers](https://github.com/utiasDSL/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](https://www.di.ens.fr/willow/) [@INRIA](http://www.inria.fr), with the support of the [Gepetto team](http://projects.laas.fr/gepetto/) [@LAAS-CNRS](http://www.laas.fr).