pinocchio: the pip package is called pin, and it is Linux only
A fast and flexible implementation of Rigid Body Dynamics algorithms and their analytical derivatives
At a glance
- What is it?
- Pinocchio is a rigid body dynamics library built in Paris, and it is unusually explicit about what it is for: not just the algorithms Featherstone introduced, but their analytical derivatives, which is what makes it useful for gradient-based work. The packaging is where the detail sits, from a pip package whose name differs from the project to a Python manifest that contains nothing but a linter configuration.
- Who is it for?
- Pinocchio fits a robotics or simulation team that needs dynamics with derivatives, and the derivative half is the differentiator rather than the dynamics half, which several libraries provide. Two things to check before you depend on it.
- Can I use it commercially?
- Yes. BSD-2-Clause is a permissive licence: you can use, modify and sell software built on it, as long as you keep its copyright and licence notices.
- Is it still maintained?
- Yes. The repository last received commits 2 days ago.
- What is it written in?
- Mainly C++, according to GitHub's language statistics.
Answers come from the project's GitHub data, last synced on November 15, 2026, and from our analysis. They are not legal advice.
Star history
- stack-of-tasks/pinocchio3,866 ★ · +110
| Repository | 2026-09-24 | 2026-11-15 |
|---|---|---|
| stack-of-tasks/pinocchio | 3.8k | 3.9k |
110 Stars in the last 52 days, measured from the daily GitHub snapshot. Compare with other projects
Editorial analysis
The derivatives are the product, not the dynamics
The readme's second paragraph sets up the lineage: the library builds upon and revisits the foundational rigid body algorithms introduced by Roy Featherstone, and it instantiates them for poly-articulated systems.
Then it says what the library does beyond the classical formulations, and the list is where the value is. Forward kinematics and its derivatives. Forward and inverse dynamics and their derivatives. Centroidal dynamics and its derivatives. Kinematic and dynamic regressors for system identification. Full support of closed-loop mechanisms. Sparse constrained dynamics and its derivatives. Low-complexity constrained articulated body algorithms.
Nearly every item has the phrase about derivatives attached, in one form or another.
The reason is stated too: analytical derivatives are what make gradient-based optimisation, control and learning work in simulation. A dynamics library that only returns values forces you to estimate gradients by finite differences; one that returns them exactly removes that cost.
The last two entries extend the same idea outward. Multiple-precision arithmetic is supported in both the C++ and the Python side, and modern automatic differentiation frameworks are supported, along with code generation through a generator that sits on top of one of them.
So there are three routes to a gradient here, and the library supports all three.
Two citation files, and a request to cite the algorithms themselves
The tree carries two citation files at the root, one in the older bibliography format and one in the newer structured format.
And the table of contents has two separate citation sections: one for citing the software, and one for citing specific algorithmic contributions.
That second section is unusual and worth reading closely, because the feature list sets it up. Two bullets in the main features, the frictional contact solvers and the sparse constrained dynamics, are links to preprints on an open archive rather than plain text. So when you use those two solvers, you are being pointed at the paper that introduced them, at the point in a feature list where you would decide whether to use them.
Elsewhere the readme links the project's own paper, on an open archive with an Inria-branded identifier, for anyone who wants to understand its internals.
For an academic library that is unremarkable. For an industrial one it is a real statement about how the maintainers think their work should be attributed: not as a dependency to cite once, but as a set of algorithms to cite individually depending on which part you used.
The acknowledgements and credits sections in the contents complete the picture, along with a list of other open-source projects that rely on the library.
Header-only, templated, and tested on four platforms
The flexibility section is short and each item is a decision.
The library is header only, so there is nothing to link. It uses template instantiation, so the numeric type is a compile-time choice and the readme says a custom scalar type is supported. And it is compliant with three C++ standards, seventeen, twenty and twenty-three.
Those three facts together are why a robotics library can sit inside someone else's build without fighting it. Header-only means no version skew at link time. Templating means the same source compiles against double, float or something else. And supporting three standards means it can be dropped into projects that have not converged on one.
Then the reliability claim, which is worth quoting in its structure: it is reliable and extensively tested, and the three things that testing consists of are unit tests, simulations, and real-world robotics applications.
That is an unusual triple, and the third one cannot be produced by a continuous integration badge. It is a claim about what happens after the tests pass.
Platform support follows: Windows, macOS, Unix and Linux, with a link to a build status page for the matrix. The badge that would show you the matrix is in the readme, but the page behind it is on a separate host.
One line for conda, one for pip, and they are not the same package
The install section says that diving in directly takes one line, assuming you have the conda tool.
conda install pinocchio -c conda-forgeThen the alternative: install via pip, with a note in brackets that it is currently only available on Linux.
That note is the interesting part, because the package you install by pip is not called what the project is called. The pip command is for a differently named package, and the download badges in the readme point at that package rather than at the project name.
So there are three facts a first-time user has to notice. The recommended route is the conda channel. The pip route is narrower in platform support. And the pip route uses a name that does not match the project or the conda package.
None of this is a complaint about the project, and the deeper reason is structural rather than careless: the pip package is produced from the same CMake build as the C++ library, and it is that build's output which has to answer to a package index's naming rules.
The table of contents also promises an installation section with subsections for conda, containers and the robotics middleware, none of which appear on the page you land on.
The Python manifest contains a linter configuration and nothing else
Open the Python project file in this repository and there is no project table in it.
What is there is a linter configuration: two directories excluded, a rule selection that picks the error, pyflakes, import-sorting, path-handling, refactor, upgrade and warning rules, and one rule explicitly ignored.
So the Python distribution is not built from that file. It is built from the C++ build system: a top-level CMake file, a sources file listing what to compile, a directory of CMake modules, and a coverage configuration for the C++ side as well.
Three further files in the root place this library inside the robotics ecosystem rather than only inside a language ecosystem: a package manifest in the format that robotics workspaces expect, a file naming the package for a workspace-oriented build tool, and a file that installs coverage tooling.
Together those four explain why the Python package exists at all. It is an artefact of the same build that produces the C++ library, published so that a Python user does not have to install a compiler.
And that is why the pip route is described as Linux only. The C++ build carries platform-specific pieces, and the Python wheel inherits whatever they do.
Two environment managers, two CI systems, one commented-out badge
The root directory contains more build infrastructure than source-adjacent files, and some of it contradicts other parts.
There are two environment managers: one declared through a pair of files, and another through a different pair. So contributors can get a development environment two ways, and the two are presumably kept in step by hand.
There are two continuous integration configurations, one of them named as private, and a third directory for the forge the source is mirrored on. The coverage badge in the readme points at a host that is not the forge hosting the source, and the badge for that host is present in the readme but commented out.
That combination suggests a project that developed on one forge, moved, and left the old coverage pipeline running. Which is fine, and worth knowing before you click through to see whether a build is green: you will land on a page maintained by an infrastructure this repository no longer uses.
One more file belongs in this group. There is a list of commit revisions for the diff tool to ignore, which is how a project stops a formatting-only commit from rewriting the blame on every line it touched.
Given that a C++ template library does get reformatted wholesale, that file is doing more work than it looks.
Every example algorithm exists twice, once per language
The examples directory is the part of this repository you can learn the most from without a compiler, and its shape is deliberate.
Most entries are Python. Several exist as a pair, with the same algorithm written twice: forward dynamics with derivatives, collisions, and building a reduced model each appear as both a C++ file and a Python file.
That pairing is the point. This is a library whose selling point is that the C++ and the Python sides agree, and the examples are where that agreement is demonstrated rather than asserted.
Then three subdirectories that map to the derivative story from the feature list. One is for a symbolic framework, one for a compiled automatic differentiation approach, and one for generated code.
There is also a build file in the examples directory, so the examples are compiled by the same build system as the library rather than being loose scripts. And one example is a viewer: a desktop viewer example with a name suggesting a single-file instrument panel.
That last one connects to a section in the contents list about visualisation, which is one of several promised sections that do not appear on the page a reader lands on.
Editorial conclusion
Pinocchio fits a robotics or simulation team that needs dynamics with derivatives, and the derivative half is the differentiator rather than the dynamics half, which several libraries provide. Two things to check before you depend on it. The install story has three documented entry points, but the page you land on shows two, and the pip route is described as available on Linux only while the conda route is the recommended one. And the Python package is not built by the Python tooling at all, so anyone expecting a conventional project file to describe it will not find one. The library itself is permissively licensed, header-only, and tested across four desktop platforms, with a build status page linked for the ones you cannot see from here.
Frequently asked questions
what is the use of pinocchio
The repository describes it as a rigid body dynamics library for poly-articulated systems, providing forward and inverse dynamics, centroidal dynamics and their analytical derivatives, kinematic and dynamic regressors for system identification, closed-loop mechanism support, frictional contact solvers and sparse constrained dynamics.
how to install pinocchio
The documented one-line route installs the package from the conda-forge channel, assuming you have the conda tool. A pip route is also given, with a note that it is currently only available on Linux, and the pip package name is shorter than the project name.
Does pinocchio provide derivatives?
Yes. It provides analytical derivatives of the main rigid body algorithms, including the Recursive Newton-Euler and Articulated-Body algorithms, for use in gradient-based optimisation, control and learning, and it also supports automatic differentiation frameworks and code generation on top of one of them.
Which robot description formats does pinocchio read?
Four file formats plus a programmatic route: URDF, SDF, MJCF and SRDF. The repository's own examples include building a reduced model and appending one model to another, so the library can also compose models rather than only load them.
What is pinocchio built on?
On Eigen for linear algebra and on the coal library for collision detection, with a Python interface for fast prototyping. The C++ side is header only and built on templates, which is what lets the same source compile against different numeric types.
Official sources
Add this badge to your README
If you maintain this project, the badge below links readers to this analysis and shows its maintenance status from the daily GitHub snapshot. Paste the markdown into your README; add ?metric=license or ?metric=stars to the image URL for a different field.
[](https://hysenlabs.com/projects/stack-of-tasks-pinocchio)Star history chart for your README
[](https://hysenlabs.com/projects/stack-of-tasks-pinocchio)Was this useful?