https://github.com/stack-of-tasks/pinocchio

A fast and flexible implementation of Rigid Body Dynamics algorithms and their analytical derivatives
https://github.com/stack-of-tasks/pinocchio

analytical-derivatives automatic-differentiation c-plus-plus casadi code-generation conda cppad dynamics fcl kinematics motion-planning pinocchio python rigid-body-dynamics robotics ros urdf

Last synced: 4 days ago
JSON representation

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

Host: GitHub
URL: https://github.com/stack-of-tasks/pinocchio
Owner: stack-of-tasks
License: bsd-2-clause
Created: 2014-10-07T15:42:51.000Z (about 12 years ago)
Default Branch: devel
Last Pushed: 2026-10-07T07:47:48.000Z (16 days ago)
Last Synced: 2026-10-10T08:21:09.125Z (13 days ago)
Topics: analytical-derivatives, automatic-differentiation, c-plus-plus, casadi, code-generation, conda, cppad, dynamics, fcl, kinematics, motion-planning, pinocchio, python, rigid-body-dynamics, robotics, ros, urdf
Language: C++
Homepage: http://stack-of-tasks.github.io/pinocchio/
Size: 41.2 MB
Stars: 3,785
Watchers: 68
Forks: 583
Open Issues: 105
Metadata Files:
- Readme: README.md
- Changelog: CHANGELOG.md
- License: LICENSE
- Code of conduct: CODE_OF_CONDUCT.md
- Citation: CITATION.bib

Awesome Lists containing this project

awesome-cpp - stack-of-tasks/pinocchio - A fast and flexible implementation of Rigid Body Dynamics algorithms and their analytical derivatives (Other / Scientific Computing)
awesome-robotic-tooling - pinocchio - A fast and flexible implementation of Rigid Body Dynamics algorithms and their analytical derivatives. (Planning and Control / Vector Map)
awesome-simulation - Pinocchio
awesome-weekly-robotics - pinocchio - a fast and flexible implementation of Rigid Body Dynamics algorithms and their analytical derivatives. Licence: BSD-2 Clause. (Libraries and Frameworks / Autopilots)
awesome-biomechanics - source
awesome-space-robotics - Pinocchio - Fast and flexible C++ library for rigid body dynamics algorithms. (Manipulation / Dynamics & Control)
awesome-mechatronics - Pinocchio - body dynamics with analytical derivatives. The backbone of most modern whole-body controllers. (6. The Robotics Software Stack / Kinematics, dynamics & optimisation libraries)
awesome-robotics - Pinocchio - body dynamics and kinematics for humanoids. | (🦿 Humanoid & Legged Robots)
awesome-ai-robotics - **Pinocchio** - Pinocchio instantiates the state-of-the-art Rigid Body Algorithms for poly-articulated systems based on revisited Roy Featherstone's algorithms. Besides, Pinocchio provides the analytical derivatives of the main Rigid-Body Algorithms, such as the Recursive Newton-Euler Algorithm or the Articulated-Body Algorithm. (Learning Source / Dev Tools)

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)

   * [Conda](#conda)

   * [Docker](#docker)

   * [ROS](#ros)

- [Visualization](#visualization)

- [Citing Pinocchio](#citing-pinocchio)

- [Citing specific algorithmic contributions](#citing-specific-algorithmic-contributions)

- [Contribution](#contribution)

- [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/badge/icon)](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/badge/icon)](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/badge/icon)](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/badge/icon)](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/badge/icon)](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).

## Contribution

If you want to ask a question, report a bug, request a new feature or contributing with a pull requests please, follow the [contribution guideline](./CONTRIBUTING.md).

## 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

-   [Kazuki Sugihara](https://github.com/sugikazu75): addFrame bug fix

-   [Sergi Martinez](https://github.com/Sergim96): scalar-generic Python bindings

-   [tandede](https://github.com/tandede): GCC 10 compatibility for aligned matrix map comparisons

-   [Amane Inoue](https://github.com/isaka1022): MJCF parser bug fixes

-   [Benjamin Delpech](https://github.com/benjiiDELPECH): collisionPairMapping bug fix

-   [Beichen Zhuo](https://github.com/BeichenZhuo): quaternion Log map sign flip 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).

ecosyste.ms

Data

Tools

Indexes

Applications

Experiments

Awesome

https://github.com/stack-of-tasks/pinocchio

Awesome Lists containing this project

README