Repository Summary
| Checkout URI | https://github.com/stack-of-tasks/pinocchio.git |
| VCS Type | git |
| VCS Version | devel |
| Last Updated | 2026-04-20 |
| Dev Status | DEVELOPED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| pinocchio | 4.0.0 |
README
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
- 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
CONTRIBUTING
Repository Summary
| Checkout URI | https://github.com/stack-of-tasks/pinocchio.git |
| VCS Type | git |
| VCS Version | devel |
| Last Updated | 2026-04-20 |
| Dev Status | DEVELOPED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| pinocchio | 4.0.0 |
README
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
- 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
CONTRIBUTING
Repository Summary
| Checkout URI | https://github.com/stack-of-tasks/pinocchio.git |
| VCS Type | git |
| VCS Version | devel |
| Last Updated | 2026-04-20 |
| Dev Status | DEVELOPED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| pinocchio | 4.0.0 |
README
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
- 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
CONTRIBUTING
Repository Summary
| Checkout URI | https://github.com/stack-of-tasks/pinocchio.git |
| VCS Type | git |
| VCS Version | devel |
| Last Updated | 2026-04-20 |
| Dev Status | DEVELOPED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| pinocchio | 4.0.0 |
README
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
- 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
CONTRIBUTING
Repository Summary
| Checkout URI | https://github.com/stack-of-tasks/pinocchio.git |
| VCS Type | git |
| VCS Version | devel |
| Last Updated | 2026-04-20 |
| Dev Status | DEVELOPED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| pinocchio | 4.0.0 |
README
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
- 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
CONTRIBUTING
Repository Summary
| Checkout URI | https://github.com/stack-of-tasks/pinocchio.git |
| VCS Type | git |
| VCS Version | devel |
| Last Updated | 2026-04-20 |
| Dev Status | DEVELOPED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| pinocchio | 4.0.0 |
README
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
- 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
CONTRIBUTING
Repository Summary
| Checkout URI | https://github.com/stack-of-tasks/pinocchio.git |
| VCS Type | git |
| VCS Version | devel |
| Last Updated | 2026-04-20 |
| Dev Status | DEVELOPED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| pinocchio | 4.0.0 |
README
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
- 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
CONTRIBUTING
Repository Summary
| Checkout URI | https://github.com/stack-of-tasks/pinocchio.git |
| VCS Type | git |
| VCS Version | devel |
| Last Updated | 2026-04-20 |
| Dev Status | DEVELOPED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| pinocchio | 4.0.0 |
README
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
- 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
CONTRIBUTING
Repository Summary
| Checkout URI | https://github.com/stack-of-tasks/pinocchio.git |
| VCS Type | git |
| VCS Version | devel |
| Last Updated | 2026-04-20 |
| Dev Status | DEVELOPED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| pinocchio | 4.0.0 |
README
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
- 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
CONTRIBUTING
Repository Summary
| Checkout URI | https://github.com/stack-of-tasks/pinocchio.git |
| VCS Type | git |
| VCS Version | devel |
| Last Updated | 2026-04-20 |
| Dev Status | DEVELOPED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| pinocchio | 4.0.0 |
README
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
- 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
CONTRIBUTING
Repository Summary
| Checkout URI | https://github.com/stack-of-tasks/pinocchio.git |
| VCS Type | git |
| VCS Version | devel |
| Last Updated | 2026-04-20 |
| Dev Status | DEVELOPED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| pinocchio | 4.0.0 |
README
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
- 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
CONTRIBUTING
Repository Summary
| Checkout URI | https://github.com/stack-of-tasks/pinocchio.git |
| VCS Type | git |
| VCS Version | devel |
| Last Updated | 2026-04-20 |
| Dev Status | DEVELOPED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| pinocchio | 4.0.0 |
README
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
- 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
CONTRIBUTING
Repository Summary
| Checkout URI | https://github.com/stack-of-tasks/pinocchio.git |
| VCS Type | git |
| VCS Version | devel |
| Last Updated | 2026-04-20 |
| Dev Status | DEVELOPED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| pinocchio | 4.0.0 |
README
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
- 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
CONTRIBUTING
Repository Summary
| Checkout URI | https://github.com/stack-of-tasks/pinocchio.git |
| VCS Type | git |
| VCS Version | devel |
| Last Updated | 2026-04-20 |
| Dev Status | DEVELOPED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| pinocchio | 4.0.0 |
README
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
- 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
CONTRIBUTING
Repository Summary
| Checkout URI | https://github.com/stack-of-tasks/pinocchio.git |
| VCS Type | git |
| VCS Version | devel |
| Last Updated | 2026-04-20 |
| Dev Status | DEVELOPED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| pinocchio | 4.0.0 |
README
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
- 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
CONTRIBUTING
Repository Summary
| Checkout URI | https://github.com/stack-of-tasks/pinocchio.git |
| VCS Type | git |
| VCS Version | devel |
| Last Updated | 2026-04-20 |
| Dev Status | DEVELOPED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| pinocchio | 4.0.0 |
README
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
- 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
CONTRIBUTING
Repository Summary
| Checkout URI | https://github.com/stack-of-tasks/pinocchio.git |
| VCS Type | git |
| VCS Version | devel |
| Last Updated | 2026-04-20 |
| Dev Status | DEVELOPED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| pinocchio | 4.0.0 |
README
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
- 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
CONTRIBUTING
Repository Summary
| Checkout URI | https://github.com/stack-of-tasks/pinocchio.git |
| VCS Type | git |
| VCS Version | devel |
| Last Updated | 2026-04-20 |
| Dev Status | DEVELOPED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| pinocchio | 4.0.0 |
README
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
- 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
CONTRIBUTING
Repository Summary
| Checkout URI | https://github.com/stack-of-tasks/pinocchio.git |
| VCS Type | git |
| VCS Version | devel |
| Last Updated | 2026-04-20 |
| Dev Status | DEVELOPED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| pinocchio | 4.0.0 |
README
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
- 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