Library / SDK
ai-winter/ros_motion_planning avatar
ai-winter/ros_motion_planning

ros_motion_planning: A ROS Noetic Plugin Library for Path Search and Trajectory Optimization

Motion planning and navigation for AGV/AMR: ROS planner plugin implementation of A*, JPS, D*, LPA*, D* Lite, Theta*, RRT, RRT*, RRT-Connect, Informed RRT*, ACO, PSO, Voronoi, PID, LQR, MPC, DWA, APF, Pure Pursuit, etc.

3,615 stars514 forksC++GPL-3.0

At a glance

What is it?
The repository collects A*, JPS, D*, LPA*, Theta*, RRT variants, ACO, PSO, Voronoi, PID, LQR, MPC, DWA, APF and Pure Pursuit as ROS planner plugins, wired to a Gazebo and RViz simulation. It is a study and prototyping environment for Ubuntu 20.04 with ROS Noetic, not a drop-in navigation stack.
Who is it for?
Adopt ros_motion_planning if you are studying or comparing global and local planners on Ubuntu 20.04 with ROS Noetic and you want the algorithms behind a common plugin interface plus a ready Gazebo and RViz scene. Do not adopt it as the navigation layer of a shipped product: the README points to a realworld.md document for that path, the project is GPL-3.0, and the last push was on 2026-04-24, so you are picking up a snapshot.
Can I use it commercially?
Yes, with conditions. GPL-3.0 is a copyleft licence: if you distribute software that includes it, you must release that software's source code under the same licence. Running it internally without distributing it does not trigger that obligation.
Is it still maintained?
Activity is slowing. The repository last received commits 6 months 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.

From daily snapshots

Star history

  • ai-winter/ros_motion_planning3,615 ★ · +22
Star history
Repository2026-09-282026-11-15
ai-winter/ros_motion_planning3.6k3.6k

22 Stars in the last 48 days, measured from the daily GitHub snapshot. Compare with other projects

Editorial analysis

What ros_motion_planning solves, and who it is aimed at

The README frames motion planning as two problems: path searching, which finds a collision-free sequence of configurations from source to destination under path constraints, and trajectory optimization, which refines that path against kinematics, dynamics and obstacles. The repository answers both with a catalogue of implementations rather than a single planner.

The global side covers A*, JPS, D*, LPA*, D* Lite, Theta*, RRT, RRT*, RRT-Connect, Informed RRT*, ACO, PSO and Voronoi. The local and tracking side covers PID, LQR, MPC, DWA, APF and Pure Pursuit. That breadth is the point. If you are an AGV or AMR researcher who wants to compare, say, an incremental search against a sampling planner on the same map and robot model, the work of reimplementing each one and bolting it into a simulation is already done.

It is not aimed at teams who need a navigation stack today. The README's own document table separates configuration, Docker, real robot application and important updates into four links, which tells you the project sees itself as a teaching and experimentation base first. The theory behind the code lives on an external blog, so the repository assumes you arrive with the concepts rather than learn them here.

How the plugin architecture is laid out

The file structure in the README is the clearest statement of the design. Under src there are four entries: core, sim_env, plugins and user_config. core is split into common, path_planner and controller. That split is the architecture in miniature: a shared interface layer, one directory per algorithm family, and a boundary between planning and control.

sim_env holds the simulation: config, launch, maps, meshes, models, rviz, urdf and worlds. This is a Gazebo and RViz environment with its own robot descriptions and world files, so a planner is exercised against a simulated robot rather than a bare graph.

plugins contains dynamic_rviz_config, dynamic_xml_config, gazebo_plugins, map_plugins and rviz_plugins. The two dynamic directories are the interesting part. Combined with the README warning that launch files are regenerated by a Python script from src/user_config/user_config.yaml, the data flow is: you edit one YAML file, a script generates the launch and RViz and XML configuration, and the selected planner loads as a plugin into that generated scene. Editing a launch file directly is documented as possibly having no effect, which is a real trap for anyone used to ROS launch conventions.

There is also a 3rd directory at the top level and a Doxyfile, so third-party code and generated interface documentation are both part of the repository.

Installing ros_motion_planning and running a first simulation

The README targets Ubuntu 20.04 LTS with ROS Noetic and calls its quick start a three minute job. Start with a Desktop-Full ROS Noetic install, then git, then the dependencies. Conan is pinned to a specific version, which matters because newer conan releases changed their command surface.

bash
pip install conan==1.59.0
conan remote add conancenter https://center.conan.io

The remaining system packages are installed with apt, including the ROS navigation pieces the simulation depends on.

bash
sudo apt install python-is-python3 \
ros-noetic-amcl \
ros-noetic-base-local-planner \
ros-noetic-map-server \
ros-noetic-move-base \
ros-noetic-navfn \
libgoogle-glog-dev

Clone the repository, then build through the provided script. The README notes a libignition dependency error and points to issue #48, and mentions that catkin-tools may be needed.

bash
cd scripts/
./build.sh

Run the simulation with main.sh from the same directory. After the first build the README says to open a new terminal or source ~/.bashrc. In RViz, use 2D Nav Goal to pick a destination, and the robot moves. The scripts directory also carries killpro.sh to shut the nodes down quickly.

bash
cd scripts/
./main.sh

For multi-agent runs the README says to replace the config with user_config_multi.yaml in main.sh, wait for initialization, then publish goals with rosrun sim_env goal_publisher.py. To read the code itself, install doxygen and graphviz and run doxygen; the generated interface documentation lands in ./docs/html/index.html.

The configuration model is the sharpest edge in the project

One warning in the README deserves more attention than its placement suggests: modifying launch files may not have any effect, because they are regenerated by a Python script from src/user_config/user_config.yaml when you run main.sh. The instruction is to modify configurations in user_config.yaml instead.

This is a deliberate trade. A single YAML entry point makes it cheap to switch robot type, planning algorithm and environmental obstacles, which is exactly what a comparison workflow needs. The cost is that the launch directory becomes generated output that you should not hand-edit, and anyone who has spent years tuning ROS launch files will reach for them out of habit and watch the change vanish on the next run.

There is a second consequence. If the generator script is the only supported path, then any launch-level customization the YAML schema does not expose requires either extending the generator or fighting it. The README does not document a supported override for that case, and it does not document rollback of a configuration change either. Treat user_config.yaml as the contract and read the configuration document linked from the README before assuming a parameter is settable.

Where ros_motion_planning is the wrong tool

The project is pinned to ROS Noetic and Ubuntu 20.04, and the README states this as the tested configuration. Noetic is the last ROS 1 distribution, so a team building on ROS 2 cannot use this repository as-is. The algorithms are portable in principle, but the plugin plumbing, the launch generation and the simulation environment are not, and the README does not describe a ROS 2 branch.

The dependency list also tells you what the project assumes. It pulls in move_base, navfn, amcl and base_local_planner, which means the simulation is built around the ROS 1 navigation stack rather than a standalone planner harness. If you wanted a dependency-light library to embed in a non-ROS system, this is the wrong shape.

Finally, the repository is a catalogue, not a tuned product. A planner that loads and drives a simulated robot to a goal is not the same as a planner that meets a latency budget on real hardware. The README's realworld.md document exists precisely because the simulation path and the deployment path are different, and the README itself does not document the tuning work that separates them.

How it compares with Nav2 and with the Python and MATLAB versions

The obvious alternative for a ROS 2 project is Nav2, the ROS 2 navigation stack. The difference is one of intent. Nav2 is a navigation system: it ships a behaviour tree, lifecycle-managed servers, costmap layers, recovery behaviours and a supported plugin API, and its planners are components you configure. ros_motion_planning is a collection of algorithm implementations wired into a ROS 1 simulation so you can watch them run and compare them. Nav2 gives you a deployment target; this repository gives you a reference implementation of A*, JPS, D* Lite, RRT variants, ACO, PSO, Voronoi, PID, LQR, MPC, DWA, APF and Pure Pursuit behind one interface. Choosing between them is choosing between shipping and studying.

The README also points to sibling projects by the same author: a Python version and a MATLAB version. Those matter for a different reason. If your goal is to read the algorithm without the ROS build chain, conan, catkin and Gazebo, the Python repository removes most of the setup surface. The MATLAB version suits coursework and quick plots. This C++ repository is the one to pick when you need the planner to run inside a ROS node against a simulated robot with URDF, maps and worlds, because that is the layer the other two do not provide.

Licence, maintenance and what an upgrade costs

The licence is GPL-3.0, stated in the repository's LICENSE file. That is a copyleft licence, and it is a stronger constraint than the permissive licences common in robotics middleware. If you link this code into a distributed product, the GPL-3.0 obligations attach to the combined work. The repository does not offer a dual-licence or commercial-licence option in what it documents, and nothing here is legal advice: if you plan to ship, have your own counsel read the licence against your linking and distribution model. For internal research and coursework the question is usually moot.

On maintenance, the facts are narrow. The repository is not archived. Its last push was on 2026-04-24, and there are no published GitHub releases, so there is no tagged version to pin against. The README links a history document for important updates, and that is where you should look for change context rather than guessing from commit activity.

Upgrade cost is dominated by the pinned toolchain. Conan 1.59.0, ROS Noetic and Ubuntu 20.04 are a single coherent set, and moving any one of them is not a configuration change but a migration. Because launch files are generated, an upgrade that changes the generator also invalidates any local edits you made to generated files. Keep your changes in user_config.yaml and the upgrade surface stays small.

Editorial conclusion

Adopt ros_motion_planning if you are studying or comparing global and local planners on Ubuntu 20.04 with ROS Noetic and you want the algorithms behind a common plugin interface plus a ready Gazebo and RViz scene. Do not adopt it as the navigation layer of a shipped product: the README points to a realworld.md document for that path, the project is GPL-3.0, and the last push was on 2026-04-24, so you are picking up a snapshot. Verify first that conan 1.59.0 resolves in your environment, that the launch files regenerate from src/user_config/user_config.yaml, and that the planner you need is present in src/core/path_planner or src/core/controller before you plan around it.

Frequently asked questions

What does ros_motion_planning need to run?

The README states it is tested on Ubuntu 20.04 LTS with ROS Noetic, and the quick start installs conan 1.59.0 plus ROS packages such as ros-noetic-move-base, ros-noetic-navfn and ros-noetic-amcl. Build and run go through scripts/build.sh and scripts/main.sh.

Which planning algorithms does ros_motion_planning implement?

The repository description lists A*, JPS, D*, LPA*, D* Lite, Theta*, RRT, RRT*, RRT-Connect, Informed RRT*, ACO, PSO, Voronoi, PID, LQR, MPC, DWA, APF and Pure Pursuit. The README groups them into path searching and trajectory optimization.

Why do my edits to the launch files in ros_motion_planning have no effect?

The README warns that launch files are regenerated by a Python script from src/user_config/user_config.yaml when main.sh runs, so direct edits can be overwritten. Change the configuration in user_config.yaml instead.

Is there a Python or MATLAB version of ros_motion_planning?

The README links a Python version and a MATLAB version maintained alongside this C++ repository. Those remove the ROS, conan and Gazebo setup surface, while this repository is the one that runs the planners inside a ROS simulation.

Can ros_motion_planning be used on a real robot?

The README links a realworld.md document described as introducing how to build a real robot application based on the algorithms in the repository. The simulation path through scripts/main.sh is separate from that deployment path, and the README does not document tuning for real hardware.

Official sources

  1. ai-winter/ros_motion_planning on GitHub
  2. Issues
  3. License: GPL-3.0
  4. README
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.

Add this badge to your README

markdown
[![Hysen Labs](https://hysenlabs.com/badge/ai-winter-ros-motion-planning.svg)](https://hysenlabs.com/projects/ai-winter-ros-motion-planning)

Star history chart for your README

markdown
[![Star history](https://hysenlabs.com/chart/ai-winter-ros-motion-planning.svg)](https://hysenlabs.com/projects/ai-winter-ros-motion-planning)

Was this useful?