Skip to content
RobothecaBeta

Software

PlaCo

By Rhoban, from github.com/Rhoban/placo (opens in a new tab)

  • Robot arms and industry
  • Library
  • MIT

PlaCo is a planning and control library for robots, solving whole-body kinematics and dynamics as quadratic programs. It has a C++ core with Python bindings.

Open on GitHub (opens in a new tab)

Facts

GitHub stars
390read on 6 Nov 2026
Last update
1 Nov 2026Newest commit on master
Maintenance
Activea commit in the last 90 days
Difficulty
Intermediate
Hardware it needs, as the project states it
Linux or macOS (x86-64 and arm64) with Python 3.10 or later; no other hardware is stated.

Checked on GitHub on 6 Nov 2026.

Licenses

Code
MIT (opens in a new tab)

Read by Robotheca from LICENSE (opens in a new tab) (MIT) at commit 6ca649d (opens in a new tab), on 6 Nov 2026.

Commercial use
Yes

Overview

What it does: Robotheca's summary

  • Solves task-space inverse kinematics with tasks such as frames, center of mass, joints, gears and wheels.
  • Solves task-space inverse dynamics, including contacts, torque limits and velocity limits.
  • Builds on the pinocchio library and the qpmad QP solver.
  • Offers a high-level API where whole-body control problems are expressed as tasks and constraints.
  • Installable from PyPI as a wheel, for Linux and macOS on x86-64 and arm64, with Python 3.10 or later.
  • The C++ API requires building from source.

Written by Robotheca from the project's README (opens in a new tab) at commit b54affb, not by its creator.

The README

The creator's own README, copied as written: README.md by Rhoban, at commit 6ca649d, under MIT (opens in a new tab). The original on GitHub (opens in a new tab).

Read the README here

Image: PlaCo (opens in a new tab)

Rhoban's Planning and Control library

QP-based task-space inverse kinematics and dynamics for robots.

Written in C++ for runtime performance, with Python bindings for fast prototyping.

(opens in a new tab) (opens in a new tab) (opens in a new tab) (opens in a new tab) (opens in a new tab) (opens in a new tab)

Documentation (opens in a new tab)  ·  Getting started (opens in a new tab)  ·  Examples repository (opens in a new tab)  ·  Build from source (opens in a new tab)  ·  Paper (opens in a new tab)

pip install placo
What is PlaCo?

PlaCo is Rhoban's planning and control library. It comes with its own lightweight rigid body algorithms, implemented with pinocchio (opens in a new tab) as a reference (and coal (opens in a new tab) for collisions), and the qpmad (opens in a new tab) QP solver, and provides a high-level API to express whole-body control problems as a set of tasks and constraints, which are assembled into a quadratic program and solved for you.

Task-Space Inverse Kinematics

Specify tasks for constrained inverse kinematics (IK): frames, center of mass, joints, gears, wheels…

Documentation (opens in a new tab)  ·  Examples gallery (opens in a new tab)

Task-Space Inverse Dynamics

Specify tasks for constrained inverse dynamics (ID), including contacts, torque and velocity limits.

Documentation (opens in a new tab)  ·  Examples gallery (opens in a new tab)

Installation

PlaCo is distributed as a wheel for Linux and macOS (x86-64 and arm64), and requires Python 3.10 or later:

pip install placo

It can also be built from sources (opens in a new tab), which is required to use the C++ API.

A first taste
import numpy as np
import placo

# Load a robot and create the kinematics solver
robot = placo.RobotWrapper("models/6axis/robot.urdf")
solver = placo.KinematicsSolver(robot)
solver.mask_fbase(True)  # the robot is anchored to the ground

# Ask the "effector" frame to reach a given pose
effector_task = solver.add_frame_task("effector", np.eye(4))
effector_task.configure("effector", "soft", 1.0, 1.0)

# Solve the IK, and integrate the result in the robot state
robot.update_kinematics()
solver.solve(True)

Head to the getting started guide (opens in a new tab) for a walkthrough, or to the examples repository (opens in a new tab) for runnable robots and scenarios.

Resources
Acknowledgements

PlaCo was first built on top of pinocchio (opens in a new tab). Its rigid body model (kinematics, dynamics, URDF and MJCF loading) is now a lighter, standalone implementation, written with pinocchio as its reference: it follows pinocchio's conventions and formulas, and was validated against it. We are grateful to the pinocchio developers for their work. Collisions and distances are computed with coal (opens in a new tab).

Citation

If you use PlaCo in your research, please cite the following paper:

@misc{duclusaud2025placo,
      title={PlaCo: a QP-based robot planning and control framework},
      author={Marc Duclusaud and Grégoire Passault and Vincent Padois and Olivier Ly},
      year={2025},
      eprint={2511.06141},
      archivePrefix={arXiv},
      primaryClass={cs.RO},
      url={https://arxiv.org/abs/2511.06141},
}
License

PlaCo is released under the MIT License (opens in a new tab).

It includes a copy of the qpmad (opens in a new tab) QP solver (Apache 2.0 License), see thirdparty/qpmad (opens in a new tab).

Files and versions

Facts read at commit 6ca649d

Robotheca read the repository at two versions: the summary at b54affb and the facts and the README at 6ca649d (read on 6 Nov 2026).

Robotheca never hosts the code: each link goes to the creator's own page.

Works with

3 robots on Robotheca

The robots on Robotheca that use it or can run it, each with how the link was found.

Use it

How to install it, in the creator's words: The project's website (opens in a new tab)

Robotheca doesn't review code. Read it before running it.

Robotheca lists software as a reference: nothing is hosted or run here, and every fact links to where it was read.