Motion Planning: Computing Collision-Free Paths for Robot Arms
Motion planning is the problem of computing a continuous path from a robot's current configuration to a goal configuration that avoids collisions with obstacles in the workspace. Classical algorithms like RRT and PRM sample the configuration space to find feasible paths, while emerging learned planners use neural networks trained on solved planning problems to accelerate inference.
What Is Motion Planning?
Motion planning is the computational problem of finding a continuous, collision-free path through a robot's configuration space from a start configuration to a goal configuration. The configuration space (C-space) is the space of all possible joint configurations of the robot, and obstacles in the workspace map to forbidden regions in C-space through the robot's kinematics. The planning problem is to find a path in the free C-space — the complement of the obstacle regions — that connects start to goal.
For a serial manipulator with n joints, the C-space is n-dimensional. Collision checking — determining whether a given configuration places the robot in collision with an obstacle — requires computing the robot's geometry at that configuration and testing for intersection with known obstacle geometry. This check is the computational bottleneck of most planning algorithms, as it must be performed for every candidate configuration.
Two families of algorithms dominate practical motion planning. Sampling-based methods (RRT, PRM) randomly sample the C-space and build a graph of collision-free configurations connected by valid local paths. These methods are probabilistically complete and handle high-dimensional C-spaces well. Optimization-based methods (CHOMP, TrajOpt, GPMP) formulate planning as a continuous optimization problem, minimizing a cost function that combines path length, smoothness, and collision penalty. These methods produce smoother paths but can get stuck in local minima.
Historical Context
Motion planning has been a central problem in robotics since the 1970s. The foundational theoretical result is that motion planning is PSPACE-hard in the dimension of C-space (Reif, 1979), meaning exact algorithms have exponential worst-case complexity. This motivated the development of approximate and sampling-based methods.
The breakthrough came with Probabilistic Roadmaps (Kavraki et al., 1996) and Rapidly-exploring Random Trees (LaValle, 1998), which provided practical algorithms for high-dimensional planning. RRT and its bidirectional variant RRT-Connect became the workhorses of robot motion planning, implemented in the widely-used OMPL library.
The emergence of learned motion planning (2020-present) represents a paradigm shift. MPiNets (Fishman et al., 2023) and related work showed that neural networks trained on solved planning problems can generate collision-free paths orders of magnitude faster than classical planners, at the cost of completeness guarantees.
Practical Implications
For teams building manipulation systems, motion planning is typically handled by established libraries (OMPL, MoveIt) rather than trained from scratch. However, learned motion planning is increasingly relevant for applications requiring very fast planning (high-speed pick-and-place, reactive obstacle avoidance) where classical planners are too slow.
The training data for learned planners consists of solved planning problems — diverse obstacle configurations with start and goal poses and their solution paths. Generating this data requires running classical planners on many randomly generated scenes, which is computationally expensive but parallelizable. Claru provides pre-computed planning datasets across diverse manipulation environments for teams developing learned planners.
Common Misconceptions
Motion planning and path planning are the same thing.
Path planning finds a geometric path without considering dynamics or timing. Motion planning additionally considers the robot's dynamics, velocity limits, and timing — producing a trajectory (path + timing) rather than just a path. In practice, the terms are often used interchangeably for robot arms where dynamics are less critical.
Classical motion planners are obsolete due to learned methods.
Classical planners provide completeness guarantees that learned methods cannot. In safety-critical applications, classical planners remain the standard. Learned methods are most valuable as warm-start initializations for classical planners or in speed-critical applications where completeness can be verified post-hoc.
Motion planning is only needed for obstacle-rich environments.
Even in apparently simple environments, motion planning prevents self-collisions (the robot hitting itself), joint limit violations, and ensures smooth transitions between manipulation phases. Most production manipulation systems use motion planning for all transit motions.
How Claru Supports This
Claru provides purpose-built training datasets for frontier AI and robotics teams, with the data quality and diversity that motion planning systems require for production deployment.
What Is Motion Planning?
Motion planning is the computational problem of finding a path through a robot's configuration space (C-space) that connects a start configuration to a goal configuration while avoiding collisions with obstacles. For a 7-DoF manipulator, the C-space is 7-dimensional, and the planner must search this high-dimensional space for a collision-free trajectory. The output is a sequence of joint configurations that the robot can execute to move from start to goal without hitting anything.
Classical motion planning algorithms fall into two categories: sampling-based and optimization-based. Sampling-based planners like RRT (Rapidly-exploring Random Trees) and PRM (Probabilistic Roadmaps) randomly sample configurations, check them for collisions, and build a graph of connected collision-free configurations. These methods are probabilistically complete — they will find a path if one exists given enough time — but the paths are often jerky and suboptimal. Optimization-based planners like CHOMP and TrajOpt formulate motion planning as a continuous optimization problem, producing smooth trajectories but requiring good initializations.
In robot learning, motion planning intersects with policy learning in several ways. Some policies produce waypoints that a classical motion planner connects. Others produce continuous actions that implicitly solve the planning problem through learned collision avoidance. Hybrid approaches use learned heuristics to guide classical planners, reducing planning time by orders of magnitude while maintaining completeness guarantees.
Motion Planning at a Glance
Comparison
Key approaches compared.
| Method | Speed | Optimality | Completeness |
|---|---|---|---|
| RRT-Connect | 100ms-10s | Non-optimal | Probabilistic |
| RRT* | 1-60s | Asymptotically optimal | Probabilistic |
| CHOMP | 50-500ms | Locally optimal | Local only |
| Learned (MPiNets) | 10-50ms | Non-optimal | Not guaranteed |
Learned Motion Planning
Learned motion planners use neural networks trained on datasets of solved planning problems to predict collision-free paths without expensive online search. The training data consists of (environment, start, goal, solution_path) tuples generated by running classical planners on diverse environments. At inference time, the network predicts a path or a sequence of waypoints that is then verified for collision-freeness.
The primary advantage of learned planners is speed: a neural network can generate a candidate path in milliseconds, compared to seconds or minutes for classical planners in cluttered environments. The primary limitation is that learned planners do not guarantee collision-freeness — the predicted path must be verified, and if invalid, a classical planner is used as fallback.
Training data for learned motion planners requires diverse obstacle configurations, diverse start and goal poses, and high-quality solution paths from classical planners. The diversity of obstacle configurations is the primary determinant of generalization — a planner trained on simple tabletop scenes will not generalize to cluttered shelves without training data from similar environments.
Frequently Asked Questions
Classical planners (RRT-Connect) typically solve in 100ms to 10 seconds depending on scene complexity. Optimization-based planners (CHOMP, TrajOpt) take 50-500ms with good initialization. Learned planners produce candidate paths in 10-50ms but require collision verification.
It depends on the policy architecture. End-to-end visuomotor policies learn implicit collision avoidance from demonstrations and do not use a separate planner. Task-and-motion planning systems use explicit planners for transit motions between manipulation phases. Hybrid approaches are common in production.
Datasets of (environment_description, start_config, goal_config, solution_path) tuples. The environment description is typically a point cloud or occupancy grid of obstacles. Solutions are generated by running classical planners on diverse scenes. 100K-1M solved problems provides a reasonable training set.
Need Motion Planning Training Data?
Claru provides environment-rich demonstration data with obstacle configurations and collision-free trajectories for training learned motion planners.