Registry / ai-ml / placo
library0.9.23pypypi✓ verified 80d ago

PlaCo (Planning and Control) is a Python library developed by Rhoban for motion planning and control, particularly in robotics applications. It provides tools for inverse kinematics, contact planning, and motion generation, building upon `pinocchio` and `eigenpy`. The library is currently at version 0.9.20 and has an active but somewhat irregular release cadence, often with minor updates.

pip install placo
INSTALL
IMPORT
SIG · PLACO
P
placo
ai-mlpythonv0.9.23
Install
16.2s avg
Import
360ms
Disk
574MB
Pass rate
4/ 10
Env Coverage4 / 10
glibc
3.93.13
musl
3.93.13
Install & Compatibility
Where this runs
tested against v0.9.23 · pip install
no network on importno background threads
Install × environment matrix
Each cell = how many times install + import succeeded across repeated harness runs. Partial = flaky.
glibc = Debian/Ubuntu slim · musl = Alpine Linux
musl
glibc
py 3.10
✕ build_error
✓ 17.05s
py 3.11
✕ build_error
✓ 15.4s
py 3.12
✕ build_error
✓ 14.75s
py 3.13
✕ build_error
✓ 17.65s
py 3.9
✕ build_error
✕ build_error
574MB installed
● package 574MB
Code
Verified usage

Verified import paths — ran on the pinned version, not inferred.

RobotWrapper
from placo import RobotWrapper
from cmeel.prefix import RobotWrapper

This quickstart demonstrates how to instantiate a robot from an online URDF, set an initial configuration, define an inverse kinematics problem with position and orientation tasks for an end-effector, and solve it using PlaCo's `KinematicsSolver`. It then prints the initial, target, and final positions of the end-effector.

import placo import numpy as np # Create a robot wrapper from an online URDF (e.g., UR5 robot) # This avoids local file dependencies for a quick test. # Ensure internet connectivity for the URDF download. robot = placo.RobotWrapper( "https://raw.githubusercontent.com/ros-industrial/universal_robot/kinetic-devel/ur_description/urdf/ur5_robot.urdf", placo.Flags.FLOATING_BASE # Set to true if the robot base is free-floating (e.g., a humanoid) ) # Set an initial configuration for the robot's joints robot.set_joint_positions({ "shoulder_pan_joint": 0.0, "shoulder_lift_joint": -np.pi / 2, "elbow_joint": np.pi / 2, "wrist_1_joint": -np.pi / 2, "wrist_2_joint": -np.pi / 2, "wrist_3_joint": 0.0 }) robot.update_kinematics() # Update the robot's internal kinematics based on current joint positions # Get the current transform (position and orientation) of the 'tool0' end-effector T_tool0_world = robot.get_transform("tool0") current_position = T_tool0_world.translation current_orientation = T_tool0_world.rotation # as a 3x3 rotation matrix # Define a target for the end-effector: move it slightly forward and up target_position = current_position + np.array([0.1, 0.0, 0.05]) # Move 10cm in X, 5cm in Z target_orientation = current_orientation # Keep the current orientation # Create a kinematics solver instance solver = placo.KinematicsSolver(robot) # Add tasks to the solver # PositionTask: Make the 'tool0' frame reach the target_position position_task = placo.PositionTask(robot.frame_id("tool0"), target_position) position_task.set_weight(1.0) # Set task weight (importance) solver.add_task(position_task) # OrientationTask: Make the 'tool0' frame match the target_orientation orientation_task = placo.OrientationTask(robot.frame_id("tool0"), target_orientation) orientation_task.set_weight(0.5) # Orientation is less critical than position solver.add_task(orientation_task) # Solve the inverse kinematics problem solver.solve(verbose=False) # Set verbose=True for detailed solver output robot.update_kinematics() # Apply the newly calculated joint positions to the robot model # Print the results new_T_tool0_world = robot.get_transform("tool0") print(f"Initial tool0 position: {current_position.round(3)}") print(f"Target tool0 position: {target_position.round(3)}") print(f"Final tool0 position: {new_T_tool0_world.translation.round(3)}")
Debug
Known issues
breakingPlaCo is pre-1.0, and its API can change between minor versions. Methods and class structures may be refactored, leading to `AttributeError` or `TypeError` if code is not updated.
fix
Always consult the latest GitHub README or `examples` directory for the most current API usage. Pin your dependency version (`pip install placo==X.Y.Z`) to avoid unexpected breakages.
affects: <1.0.0
gotchaInstallation can be complex due to underlying C++ dependencies (`eigenpy`, `pinocchio`). Missing system libraries (e.g., Boost, Eigen) or incorrect environment setup can lead to build failures or `ModuleNotFoundError`.
fix
For smoother installation, especially on Linux, consider using `conda` (`conda install -c conda-forge placo`) as it often handles C++ dependencies better. Alternatively, ensure all `eigenpy` and `pinocchio` system-level prerequisites are met if installing via `pip`.
affects: All
gotchaRobotics libraries often use specific coordinate system conventions (e.g., Z-up vs Y-up) or joint orderings that might differ from other tools or your expectations. Misinterpreting these can lead to unexpected robot behavior.
fix
Always verify PlaCo's coordinate system conventions by testing with simple movements or by referring to `pinocchio`'s documentation, as PlaCo builds on it. Visualizing with `meshcat` or `matplotlib` can help catch issues early.
affects: All
gotchaWhile PlaCo provides Python bindings, the core computations are in C++. For very high-frequency or real-time control loops, the Python overhead might introduce latency. Trying to run complex solvers at rates above a few hundred Hz may hit performance limits.
fix
Profile your application to identify bottlenecks. For critical real-time components, consider moving the tightest loops to C++ if possible, or optimizing the Python interface calls. Ensure the `verbose` flag on solvers is `False` for production.
affects: All
Upgrade
Version history
0.9.23latest on PyPI · released May 21, 2026
Audit
Dependencies
numpyrequiredNumerical operations and array manipulation.
scipyrequiredScientific computing tools.
eigenpyrequiredPython bindings for Eigen (dense and sparse matrix algebra), core dependency for numerical operations in robotics.
pinocchiorequiredRobotics library for rigid body dynamics algorithms, core dependency for robot modeling and kinematics.
matplotlibrequiredPlotting and visualization (optional, but often used in examples).
logururequiredFlexible logging library.
meshcatrequired3D visualization (optional, for displaying robot and environment).
Agent activity
19 hits · last 30 days
node
16
Resources
placo — pip install placo · libregistry