Python API

cuRobo provides accelerated modules for robotics which can be used to build high-performance robotics applications. The library has several modules for numerical optimization, robot kinematics, geometry processing, collision checking, graph search planning. cuRobo provides high-level APIs for performing tasks like collision-free inverse kinematics, model predictive control, and motion planning.

Public API Quick Start:

from curobo.inverse_kinematics import InverseKinematics, InverseKinematicsCfg
from curobo.trajectory_optimizer import TrajectoryOptimizer, TrajectoryOptimizerCfg
from curobo.motion_planner import MotionPlanner, MotionPlannerCfg
from curobo.model_predictive_control import ModelPredictiveControl, ModelPredictiveControlCfg
from curobo.kinematics import Kinematics, KinematicsCfg
from curobo.scene import Scene, Cuboid, Sphere, Mesh
from curobo.servo import JointTargetServo
from curobo.types import JointState

# Forward kinematics
kin = Kinematics(KinematicsCfg.from_robot_yaml_file("franka.yml"))
js = JointState.from_position(q, joint_names=kin.joint_names)
state = kin.compute_kinematics(js)

# Scene representation
scene = Scene(
    cuboid=[Cuboid(name="table", dims=[1, 1, 0.1], pose=[0, 0, 0.5, 1, 0, 0, 0])],
)

# Inverse kinematics
ik_config = InverseKinematicsCfg.create(robot="franka.yml")
ik = InverseKinematics(ik_config)
result = ik.solve_pose(goal_tool_poses=target_poses)

# Trajectory optimization
trajopt = TrajectoryOptimizer(trajopt_config)
trajectory = trajopt.solve_pose(goal_tool_poses=target_poses)

# Model predictive control
mpc = ModelPredictiveControl(mpc_config)
result = mpc.optimize_action_sequence(current_state)

Public API Modules:

• curobo.kinematics - Forward kinematics

• curobo.inverse_kinematics - Inverse kinematics solver

• curobo.trajectory_optimizer - Trajectory optimization

• curobo.trajectory_timeopt - GPU trajectory timeopt with joint and torque limits

• curobo.motion_planner - Motion planning

• curobo.model_predictive_control - Model predictive control

• curobo.motion_retargeter - Motion retargeting using inverse kinematics and model predictive control

• curobo.scene - Scene representation with obstacles

• curobo.collision_checking - Robot collision checking (for custom pipelines)

• curobo.perception - Perception utilities (robot segmentation)

• curobo.robot_builder - Build robot configs from URDF

• curobo.servo - Joint-space command smoothing

• curobo.viewer - Visualization (Rerun, Viser)

• curobo.types - Common data types (JointState, Pose, etc.)

Motion planning iteration budgets

MotionPlanner and BatchMotionPlanner accept a positive integer outer_iterations on each pose-planning call:

Initial solve/check passes

Method	Default outer_iterations	Maximum optimizer steps with default configuration
plan_pose	1	50 per trajectory-optimization solve
plan_pose_waypoints	4	200 per trajectory-optimization solve

Each pass runs initial_check_interval optimizer steps (50 by default), checks feasibility, and stops continuation on success. Further passes retain the iterate and optimizer history. The budget applies independently to direct and RRT-seeded solves; it does not limit the total work across planning retries.

max_attempts limits planning retries. finetune_attempts controls additional refinement passes, each using a separate 25-step budget by default. Changing outer_iterations on one call does not change later calls’ defaults. Waypoint planning uses four passes in both position-only and position-and-orientation tracking modes.

The C++ equivalents are PoseMotionPlanningRequest::outer_iterations (default 1) and WaypointMotionPlanningRequest::outer_iterations (default 4). The waypoint field supplies the budget independently of the embedded motion request. C++ recaptures its optimization graph when the pass count changes; Python reuses its 25-step optimizer graphs within each solve/check pass.