No version for distro humble showing jazzy. Known supported distros are highlighted in the buttons above.
Repo symbol

rko_slam repository

rko_slam

ROS Distro
jazzy

Repository Summary

Checkout URI https://github.com/PRBonn/rko_slam.git
VCS Type git
VCS Version master
Last Updated 2026-09-25
Dev Status DEVELOPED
Released UNRELEASED
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

Packages

Name Version
rko_slam 0.0.1

README

rko_slam

ROS2 LiDAR-inertial SLAM for your odometry: drift correction and multi-session alignment

[![Jazzy](https://github.com/PRBonn/rko_slam/actions/workflows/ros_jazzy.yaml/badge.svg)](https://github.com/PRBonn/rko_slam/actions/workflows/ros_jazzy.yaml) [![Kilted](https://github.com/PRBonn/rko_slam/actions/workflows/ros_kilted.yaml/badge.svg)](https://github.com/PRBonn/rko_slam/actions/workflows/ros_kilted.yaml) [![Lyrical](https://github.com/PRBonn/rko_slam/actions/workflows/ros_lyrical.yaml/badge.svg)](https://github.com/PRBonn/rko_slam/actions/workflows/ros_lyrical.yaml) [![Rolling](https://github.com/PRBonn/rko_slam/actions/workflows/ros_rolling.yaml/badge.svg)](https://github.com/PRBonn/rko_slam/actions/workflows/ros_rolling.yaml) [![Docs](https://img.shields.io/badge/docs-prbonn.github.io-blue)](https://prbonn.github.io/rko_slam/) [![GitHub License](https://img.shields.io/github/license/PRBonn/rko_slam)](/LICENSE) [![GitHub last commit](https://img.shields.io/github/last-commit/PRBonn/rko_slam)](/)

A 3 km drive with the odometry alone, and with rko_slam running on top of it
A 3 km drive that ends where it started, with rko_lio, and with rko_slam running on top of it

rko_slam is a ROS2 LiDAR-inertial SLAM system. It runs on top of a LiDAR-inertial odometry. An odometry tells you how you moved, and over a long enough run its estimate drifts: come back to a place you have been before and the two visits do not land on the same spot. rko_slam runs next to the odometry, uses the LiDAR and IMU, recognizes the revisit, and corrects the whole trajectory behind you. You keep the odometry as it is, and you additionally get a map <- odom correction on TF, a pose graph, and the sub-maps the system built along the way.

The odometry it assumes by default is rko_lio, my LiDAR-inertial odometry package, which is also a build dependency. At run time any odometry that publishes odom <- base on TF and is locally consistent will do - LiDAR-only odometry, wheel odometry, whatever you already run. The IMU is optional as well: leave imu_topic unset and rko_slam runs on the LiDAR alone.

The same revisit detector works across runs, not just within one, as an offline step. Give it the run directories of several sessions of the same place - different days, different directions, whatever - and it finds where they overlap and solves all of them into one frame.

Three sessions of the same place, each in its own frame, and in one frame after alignment
Three sessions of the same place, recorded on different days, and the one frame they end up in

Documentation is at prbonn.github.io/rko_slam.

Build

Supported distros: Jazzy, Kilted, Lyrical, Rolling.

For now, rko_lio has to be built in the same workspace.

cd <ws>/src
git clone https://github.com/PRBonn/rko_lio
git clone https://github.com/PRBonn/rko_slam
cd <ws> && rosdep install --from-paths src --ignore-src -y
colcon build --packages-select rko_lio rko_slam

apt installs will be supported, same as with rko_lio. Dependencies and build options are covered in the docs.

Usage

Three entrypoints: slam.launch.py (mode:=online|offline), odometry_and_slam.launch.py, and align.launch.py. -s lists every parameter with its documentation, and anything you leave unset keeps the node’s own default.

Online, next to a running rko_lio, consuming its deskewed scan:

ros2 launch rko_slam slam.launch.py lidar_topic:=/rko_lio/deskewed_scan imu_topic:=/your/imu rviz:=true

Offline, self-draining a bag, with the odometry from the bag’s own /tf, and writing the run to disk:

ros2 launch rko_slam slam.launch.py mode:=offline bag_path:=/data/my_bag \
  lidar_topic:=/rko_lio/deskewed_scan imu_topic:=/your/imu dump_results:=true

Multi-session alignment of the run directories those runs wrote:

ros2 launch rko_slam align.launch.py run_dirs:="[results/run_1, results/run_2]"

Running with another odometry, running rko_lio alongside with odometry_and_slam.launch.py, taking the odometry from a TUM file, what a run writes to disk, every parameter and what it does, and how the system works are all in the docs.

Acknowledgments and Citation

This work was developed as part of my thesis (published soon), and much of it is inspired by KISS-SLAM - the initial version was essentially a reimplementation for ROS2.

File truncated at 100 lines see the full file

Repo symbol

rko_slam repository

rko_slam

ROS Distro
jazzy

Repository Summary

Checkout URI https://github.com/PRBonn/rko_slam.git
VCS Type git
VCS Version master
Last Updated 2026-09-25
Dev Status DEVELOPED
Released UNRELEASED
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

Packages

Name Version
rko_slam 0.0.1

README

rko_slam

ROS2 LiDAR-inertial SLAM for your odometry: drift correction and multi-session alignment

[![Jazzy](https://github.com/PRBonn/rko_slam/actions/workflows/ros_jazzy.yaml/badge.svg)](https://github.com/PRBonn/rko_slam/actions/workflows/ros_jazzy.yaml) [![Kilted](https://github.com/PRBonn/rko_slam/actions/workflows/ros_kilted.yaml/badge.svg)](https://github.com/PRBonn/rko_slam/actions/workflows/ros_kilted.yaml) [![Lyrical](https://github.com/PRBonn/rko_slam/actions/workflows/ros_lyrical.yaml/badge.svg)](https://github.com/PRBonn/rko_slam/actions/workflows/ros_lyrical.yaml) [![Rolling](https://github.com/PRBonn/rko_slam/actions/workflows/ros_rolling.yaml/badge.svg)](https://github.com/PRBonn/rko_slam/actions/workflows/ros_rolling.yaml) [![Docs](https://img.shields.io/badge/docs-prbonn.github.io-blue)](https://prbonn.github.io/rko_slam/) [![GitHub License](https://img.shields.io/github/license/PRBonn/rko_slam)](/LICENSE) [![GitHub last commit](https://img.shields.io/github/last-commit/PRBonn/rko_slam)](/)

A 3 km drive with the odometry alone, and with rko_slam running on top of it
A 3 km drive that ends where it started, with rko_lio, and with rko_slam running on top of it

rko_slam is a ROS2 LiDAR-inertial SLAM system. It runs on top of a LiDAR-inertial odometry. An odometry tells you how you moved, and over a long enough run its estimate drifts: come back to a place you have been before and the two visits do not land on the same spot. rko_slam runs next to the odometry, uses the LiDAR and IMU, recognizes the revisit, and corrects the whole trajectory behind you. You keep the odometry as it is, and you additionally get a map <- odom correction on TF, a pose graph, and the sub-maps the system built along the way.

The odometry it assumes by default is rko_lio, my LiDAR-inertial odometry package, which is also a build dependency. At run time any odometry that publishes odom <- base on TF and is locally consistent will do - LiDAR-only odometry, wheel odometry, whatever you already run. The IMU is optional as well: leave imu_topic unset and rko_slam runs on the LiDAR alone.

The same revisit detector works across runs, not just within one, as an offline step. Give it the run directories of several sessions of the same place - different days, different directions, whatever - and it finds where they overlap and solves all of them into one frame.

Three sessions of the same place, each in its own frame, and in one frame after alignment
Three sessions of the same place, recorded on different days, and the one frame they end up in

Documentation is at prbonn.github.io/rko_slam.

Build

Supported distros: Jazzy, Kilted, Lyrical, Rolling.

For now, rko_lio has to be built in the same workspace.

cd <ws>/src
git clone https://github.com/PRBonn/rko_lio
git clone https://github.com/PRBonn/rko_slam
cd <ws> && rosdep install --from-paths src --ignore-src -y
colcon build --packages-select rko_lio rko_slam

apt installs will be supported, same as with rko_lio. Dependencies and build options are covered in the docs.

Usage

Three entrypoints: slam.launch.py (mode:=online|offline), odometry_and_slam.launch.py, and align.launch.py. -s lists every parameter with its documentation, and anything you leave unset keeps the node’s own default.

Online, next to a running rko_lio, consuming its deskewed scan:

ros2 launch rko_slam slam.launch.py lidar_topic:=/rko_lio/deskewed_scan imu_topic:=/your/imu rviz:=true

Offline, self-draining a bag, with the odometry from the bag’s own /tf, and writing the run to disk:

ros2 launch rko_slam slam.launch.py mode:=offline bag_path:=/data/my_bag \
  lidar_topic:=/rko_lio/deskewed_scan imu_topic:=/your/imu dump_results:=true

Multi-session alignment of the run directories those runs wrote:

ros2 launch rko_slam align.launch.py run_dirs:="[results/run_1, results/run_2]"

Running with another odometry, running rko_lio alongside with odometry_and_slam.launch.py, taking the odometry from a TUM file, what a run writes to disk, every parameter and what it does, and how the system works are all in the docs.

Acknowledgments and Citation

This work was developed as part of my thesis (published soon), and much of it is inspired by KISS-SLAM - the initial version was essentially a reimplementation for ROS2.

File truncated at 100 lines see the full file

Repo symbol

rko_slam repository

rko_slam

ROS Distro
kilted

Repository Summary

Checkout URI https://github.com/PRBonn/rko_slam.git
VCS Type git
VCS Version master
Last Updated 2026-09-25
Dev Status DEVELOPED
Released UNRELEASED
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

Packages

Name Version
rko_slam 0.0.1

README

rko_slam

ROS2 LiDAR-inertial SLAM for your odometry: drift correction and multi-session alignment

[![Jazzy](https://github.com/PRBonn/rko_slam/actions/workflows/ros_jazzy.yaml/badge.svg)](https://github.com/PRBonn/rko_slam/actions/workflows/ros_jazzy.yaml) [![Kilted](https://github.com/PRBonn/rko_slam/actions/workflows/ros_kilted.yaml/badge.svg)](https://github.com/PRBonn/rko_slam/actions/workflows/ros_kilted.yaml) [![Lyrical](https://github.com/PRBonn/rko_slam/actions/workflows/ros_lyrical.yaml/badge.svg)](https://github.com/PRBonn/rko_slam/actions/workflows/ros_lyrical.yaml) [![Rolling](https://github.com/PRBonn/rko_slam/actions/workflows/ros_rolling.yaml/badge.svg)](https://github.com/PRBonn/rko_slam/actions/workflows/ros_rolling.yaml) [![Docs](https://img.shields.io/badge/docs-prbonn.github.io-blue)](https://prbonn.github.io/rko_slam/) [![GitHub License](https://img.shields.io/github/license/PRBonn/rko_slam)](/LICENSE) [![GitHub last commit](https://img.shields.io/github/last-commit/PRBonn/rko_slam)](/)

A 3 km drive with the odometry alone, and with rko_slam running on top of it
A 3 km drive that ends where it started, with rko_lio, and with rko_slam running on top of it

rko_slam is a ROS2 LiDAR-inertial SLAM system. It runs on top of a LiDAR-inertial odometry. An odometry tells you how you moved, and over a long enough run its estimate drifts: come back to a place you have been before and the two visits do not land on the same spot. rko_slam runs next to the odometry, uses the LiDAR and IMU, recognizes the revisit, and corrects the whole trajectory behind you. You keep the odometry as it is, and you additionally get a map <- odom correction on TF, a pose graph, and the sub-maps the system built along the way.

The odometry it assumes by default is rko_lio, my LiDAR-inertial odometry package, which is also a build dependency. At run time any odometry that publishes odom <- base on TF and is locally consistent will do - LiDAR-only odometry, wheel odometry, whatever you already run. The IMU is optional as well: leave imu_topic unset and rko_slam runs on the LiDAR alone.

The same revisit detector works across runs, not just within one, as an offline step. Give it the run directories of several sessions of the same place - different days, different directions, whatever - and it finds where they overlap and solves all of them into one frame.

Three sessions of the same place, each in its own frame, and in one frame after alignment
Three sessions of the same place, recorded on different days, and the one frame they end up in

Documentation is at prbonn.github.io/rko_slam.

Build

Supported distros: Jazzy, Kilted, Lyrical, Rolling.

For now, rko_lio has to be built in the same workspace.

cd <ws>/src
git clone https://github.com/PRBonn/rko_lio
git clone https://github.com/PRBonn/rko_slam
cd <ws> && rosdep install --from-paths src --ignore-src -y
colcon build --packages-select rko_lio rko_slam

apt installs will be supported, same as with rko_lio. Dependencies and build options are covered in the docs.

Usage

Three entrypoints: slam.launch.py (mode:=online|offline), odometry_and_slam.launch.py, and align.launch.py. -s lists every parameter with its documentation, and anything you leave unset keeps the node’s own default.

Online, next to a running rko_lio, consuming its deskewed scan:

ros2 launch rko_slam slam.launch.py lidar_topic:=/rko_lio/deskewed_scan imu_topic:=/your/imu rviz:=true

Offline, self-draining a bag, with the odometry from the bag’s own /tf, and writing the run to disk:

ros2 launch rko_slam slam.launch.py mode:=offline bag_path:=/data/my_bag \
  lidar_topic:=/rko_lio/deskewed_scan imu_topic:=/your/imu dump_results:=true

Multi-session alignment of the run directories those runs wrote:

ros2 launch rko_slam align.launch.py run_dirs:="[results/run_1, results/run_2]"

Running with another odometry, running rko_lio alongside with odometry_and_slam.launch.py, taking the odometry from a TUM file, what a run writes to disk, every parameter and what it does, and how the system works are all in the docs.

Acknowledgments and Citation

This work was developed as part of my thesis (published soon), and much of it is inspired by KISS-SLAM - the initial version was essentially a reimplementation for ROS2.

File truncated at 100 lines see the full file

Repo symbol

rko_slam repository

rko_slam

ROS Distro
lyrical

Repository Summary

Checkout URI https://github.com/PRBonn/rko_slam.git
VCS Type git
VCS Version master
Last Updated 2026-09-25
Dev Status DEVELOPED
Released UNRELEASED
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

Packages

Name Version
rko_slam 0.0.1

README

rko_slam

ROS2 LiDAR-inertial SLAM for your odometry: drift correction and multi-session alignment

[![Jazzy](https://github.com/PRBonn/rko_slam/actions/workflows/ros_jazzy.yaml/badge.svg)](https://github.com/PRBonn/rko_slam/actions/workflows/ros_jazzy.yaml) [![Kilted](https://github.com/PRBonn/rko_slam/actions/workflows/ros_kilted.yaml/badge.svg)](https://github.com/PRBonn/rko_slam/actions/workflows/ros_kilted.yaml) [![Lyrical](https://github.com/PRBonn/rko_slam/actions/workflows/ros_lyrical.yaml/badge.svg)](https://github.com/PRBonn/rko_slam/actions/workflows/ros_lyrical.yaml) [![Rolling](https://github.com/PRBonn/rko_slam/actions/workflows/ros_rolling.yaml/badge.svg)](https://github.com/PRBonn/rko_slam/actions/workflows/ros_rolling.yaml) [![Docs](https://img.shields.io/badge/docs-prbonn.github.io-blue)](https://prbonn.github.io/rko_slam/) [![GitHub License](https://img.shields.io/github/license/PRBonn/rko_slam)](/LICENSE) [![GitHub last commit](https://img.shields.io/github/last-commit/PRBonn/rko_slam)](/)

A 3 km drive with the odometry alone, and with rko_slam running on top of it
A 3 km drive that ends where it started, with rko_lio, and with rko_slam running on top of it

rko_slam is a ROS2 LiDAR-inertial SLAM system. It runs on top of a LiDAR-inertial odometry. An odometry tells you how you moved, and over a long enough run its estimate drifts: come back to a place you have been before and the two visits do not land on the same spot. rko_slam runs next to the odometry, uses the LiDAR and IMU, recognizes the revisit, and corrects the whole trajectory behind you. You keep the odometry as it is, and you additionally get a map <- odom correction on TF, a pose graph, and the sub-maps the system built along the way.

The odometry it assumes by default is rko_lio, my LiDAR-inertial odometry package, which is also a build dependency. At run time any odometry that publishes odom <- base on TF and is locally consistent will do - LiDAR-only odometry, wheel odometry, whatever you already run. The IMU is optional as well: leave imu_topic unset and rko_slam runs on the LiDAR alone.

The same revisit detector works across runs, not just within one, as an offline step. Give it the run directories of several sessions of the same place - different days, different directions, whatever - and it finds where they overlap and solves all of them into one frame.

Three sessions of the same place, each in its own frame, and in one frame after alignment
Three sessions of the same place, recorded on different days, and the one frame they end up in

Documentation is at prbonn.github.io/rko_slam.

Build

Supported distros: Jazzy, Kilted, Lyrical, Rolling.

For now, rko_lio has to be built in the same workspace.

cd <ws>/src
git clone https://github.com/PRBonn/rko_lio
git clone https://github.com/PRBonn/rko_slam
cd <ws> && rosdep install --from-paths src --ignore-src -y
colcon build --packages-select rko_lio rko_slam

apt installs will be supported, same as with rko_lio. Dependencies and build options are covered in the docs.

Usage

Three entrypoints: slam.launch.py (mode:=online|offline), odometry_and_slam.launch.py, and align.launch.py. -s lists every parameter with its documentation, and anything you leave unset keeps the node’s own default.

Online, next to a running rko_lio, consuming its deskewed scan:

ros2 launch rko_slam slam.launch.py lidar_topic:=/rko_lio/deskewed_scan imu_topic:=/your/imu rviz:=true

Offline, self-draining a bag, with the odometry from the bag’s own /tf, and writing the run to disk:

ros2 launch rko_slam slam.launch.py mode:=offline bag_path:=/data/my_bag \
  lidar_topic:=/rko_lio/deskewed_scan imu_topic:=/your/imu dump_results:=true

Multi-session alignment of the run directories those runs wrote:

ros2 launch rko_slam align.launch.py run_dirs:="[results/run_1, results/run_2]"

Running with another odometry, running rko_lio alongside with odometry_and_slam.launch.py, taking the odometry from a TUM file, what a run writes to disk, every parameter and what it does, and how the system works are all in the docs.

Acknowledgments and Citation

This work was developed as part of my thesis (published soon), and much of it is inspired by KISS-SLAM - the initial version was essentially a reimplementation for ROS2.

File truncated at 100 lines see the full file

Repo symbol

rko_slam repository

rko_slam

ROS Distro
rolling

Repository Summary

Checkout URI https://github.com/PRBonn/rko_slam.git
VCS Type git
VCS Version master
Last Updated 2026-09-25
Dev Status DEVELOPED
Released UNRELEASED
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

Packages

Name Version
rko_slam 0.0.1

README

rko_slam

ROS2 LiDAR-inertial SLAM for your odometry: drift correction and multi-session alignment

[![Jazzy](https://github.com/PRBonn/rko_slam/actions/workflows/ros_jazzy.yaml/badge.svg)](https://github.com/PRBonn/rko_slam/actions/workflows/ros_jazzy.yaml) [![Kilted](https://github.com/PRBonn/rko_slam/actions/workflows/ros_kilted.yaml/badge.svg)](https://github.com/PRBonn/rko_slam/actions/workflows/ros_kilted.yaml) [![Lyrical](https://github.com/PRBonn/rko_slam/actions/workflows/ros_lyrical.yaml/badge.svg)](https://github.com/PRBonn/rko_slam/actions/workflows/ros_lyrical.yaml) [![Rolling](https://github.com/PRBonn/rko_slam/actions/workflows/ros_rolling.yaml/badge.svg)](https://github.com/PRBonn/rko_slam/actions/workflows/ros_rolling.yaml) [![Docs](https://img.shields.io/badge/docs-prbonn.github.io-blue)](https://prbonn.github.io/rko_slam/) [![GitHub License](https://img.shields.io/github/license/PRBonn/rko_slam)](/LICENSE) [![GitHub last commit](https://img.shields.io/github/last-commit/PRBonn/rko_slam)](/)

A 3 km drive with the odometry alone, and with rko_slam running on top of it
A 3 km drive that ends where it started, with rko_lio, and with rko_slam running on top of it

rko_slam is a ROS2 LiDAR-inertial SLAM system. It runs on top of a LiDAR-inertial odometry. An odometry tells you how you moved, and over a long enough run its estimate drifts: come back to a place you have been before and the two visits do not land on the same spot. rko_slam runs next to the odometry, uses the LiDAR and IMU, recognizes the revisit, and corrects the whole trajectory behind you. You keep the odometry as it is, and you additionally get a map <- odom correction on TF, a pose graph, and the sub-maps the system built along the way.

The odometry it assumes by default is rko_lio, my LiDAR-inertial odometry package, which is also a build dependency. At run time any odometry that publishes odom <- base on TF and is locally consistent will do - LiDAR-only odometry, wheel odometry, whatever you already run. The IMU is optional as well: leave imu_topic unset and rko_slam runs on the LiDAR alone.

The same revisit detector works across runs, not just within one, as an offline step. Give it the run directories of several sessions of the same place - different days, different directions, whatever - and it finds where they overlap and solves all of them into one frame.

Three sessions of the same place, each in its own frame, and in one frame after alignment
Three sessions of the same place, recorded on different days, and the one frame they end up in

Documentation is at prbonn.github.io/rko_slam.

Build

Supported distros: Jazzy, Kilted, Lyrical, Rolling.

For now, rko_lio has to be built in the same workspace.

cd <ws>/src
git clone https://github.com/PRBonn/rko_lio
git clone https://github.com/PRBonn/rko_slam
cd <ws> && rosdep install --from-paths src --ignore-src -y
colcon build --packages-select rko_lio rko_slam

apt installs will be supported, same as with rko_lio. Dependencies and build options are covered in the docs.

Usage

Three entrypoints: slam.launch.py (mode:=online|offline), odometry_and_slam.launch.py, and align.launch.py. -s lists every parameter with its documentation, and anything you leave unset keeps the node’s own default.

Online, next to a running rko_lio, consuming its deskewed scan:

ros2 launch rko_slam slam.launch.py lidar_topic:=/rko_lio/deskewed_scan imu_topic:=/your/imu rviz:=true

Offline, self-draining a bag, with the odometry from the bag’s own /tf, and writing the run to disk:

ros2 launch rko_slam slam.launch.py mode:=offline bag_path:=/data/my_bag \
  lidar_topic:=/rko_lio/deskewed_scan imu_topic:=/your/imu dump_results:=true

Multi-session alignment of the run directories those runs wrote:

ros2 launch rko_slam align.launch.py run_dirs:="[results/run_1, results/run_2]"

Running with another odometry, running rko_lio alongside with odometry_and_slam.launch.py, taking the odometry from a TUM file, what a run writes to disk, every parameter and what it does, and how the system works are all in the docs.

Acknowledgments and Citation

This work was developed as part of my thesis (published soon), and much of it is inspired by KISS-SLAM - the initial version was essentially a reimplementation for ROS2.

File truncated at 100 lines see the full file

No version for distro ardent showing jazzy. Known supported distros are highlighted in the buttons above.
Repo symbol

rko_slam repository

rko_slam

ROS Distro
jazzy

Repository Summary

Checkout URI https://github.com/PRBonn/rko_slam.git
VCS Type git
VCS Version master
Last Updated 2026-09-25
Dev Status DEVELOPED
Released UNRELEASED
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

Packages

Name Version
rko_slam 0.0.1

README

rko_slam

ROS2 LiDAR-inertial SLAM for your odometry: drift correction and multi-session alignment

[![Jazzy](https://github.com/PRBonn/rko_slam/actions/workflows/ros_jazzy.yaml/badge.svg)](https://github.com/PRBonn/rko_slam/actions/workflows/ros_jazzy.yaml) [![Kilted](https://github.com/PRBonn/rko_slam/actions/workflows/ros_kilted.yaml/badge.svg)](https://github.com/PRBonn/rko_slam/actions/workflows/ros_kilted.yaml) [![Lyrical](https://github.com/PRBonn/rko_slam/actions/workflows/ros_lyrical.yaml/badge.svg)](https://github.com/PRBonn/rko_slam/actions/workflows/ros_lyrical.yaml) [![Rolling](https://github.com/PRBonn/rko_slam/actions/workflows/ros_rolling.yaml/badge.svg)](https://github.com/PRBonn/rko_slam/actions/workflows/ros_rolling.yaml) [![Docs](https://img.shields.io/badge/docs-prbonn.github.io-blue)](https://prbonn.github.io/rko_slam/) [![GitHub License](https://img.shields.io/github/license/PRBonn/rko_slam)](/LICENSE) [![GitHub last commit](https://img.shields.io/github/last-commit/PRBonn/rko_slam)](/)

A 3 km drive with the odometry alone, and with rko_slam running on top of it
A 3 km drive that ends where it started, with rko_lio, and with rko_slam running on top of it

rko_slam is a ROS2 LiDAR-inertial SLAM system. It runs on top of a LiDAR-inertial odometry. An odometry tells you how you moved, and over a long enough run its estimate drifts: come back to a place you have been before and the two visits do not land on the same spot. rko_slam runs next to the odometry, uses the LiDAR and IMU, recognizes the revisit, and corrects the whole trajectory behind you. You keep the odometry as it is, and you additionally get a map <- odom correction on TF, a pose graph, and the sub-maps the system built along the way.

The odometry it assumes by default is rko_lio, my LiDAR-inertial odometry package, which is also a build dependency. At run time any odometry that publishes odom <- base on TF and is locally consistent will do - LiDAR-only odometry, wheel odometry, whatever you already run. The IMU is optional as well: leave imu_topic unset and rko_slam runs on the LiDAR alone.

The same revisit detector works across runs, not just within one, as an offline step. Give it the run directories of several sessions of the same place - different days, different directions, whatever - and it finds where they overlap and solves all of them into one frame.

Three sessions of the same place, each in its own frame, and in one frame after alignment
Three sessions of the same place, recorded on different days, and the one frame they end up in

Documentation is at prbonn.github.io/rko_slam.

Build

Supported distros: Jazzy, Kilted, Lyrical, Rolling.

For now, rko_lio has to be built in the same workspace.

cd <ws>/src
git clone https://github.com/PRBonn/rko_lio
git clone https://github.com/PRBonn/rko_slam
cd <ws> && rosdep install --from-paths src --ignore-src -y
colcon build --packages-select rko_lio rko_slam

apt installs will be supported, same as with rko_lio. Dependencies and build options are covered in the docs.

Usage

Three entrypoints: slam.launch.py (mode:=online|offline), odometry_and_slam.launch.py, and align.launch.py. -s lists every parameter with its documentation, and anything you leave unset keeps the node’s own default.

Online, next to a running rko_lio, consuming its deskewed scan:

ros2 launch rko_slam slam.launch.py lidar_topic:=/rko_lio/deskewed_scan imu_topic:=/your/imu rviz:=true

Offline, self-draining a bag, with the odometry from the bag’s own /tf, and writing the run to disk:

ros2 launch rko_slam slam.launch.py mode:=offline bag_path:=/data/my_bag \
  lidar_topic:=/rko_lio/deskewed_scan imu_topic:=/your/imu dump_results:=true

Multi-session alignment of the run directories those runs wrote:

ros2 launch rko_slam align.launch.py run_dirs:="[results/run_1, results/run_2]"

Running with another odometry, running rko_lio alongside with odometry_and_slam.launch.py, taking the odometry from a TUM file, what a run writes to disk, every parameter and what it does, and how the system works are all in the docs.

Acknowledgments and Citation

This work was developed as part of my thesis (published soon), and much of it is inspired by KISS-SLAM - the initial version was essentially a reimplementation for ROS2.

File truncated at 100 lines see the full file

No version for distro bouncy showing jazzy. Known supported distros are highlighted in the buttons above.
Repo symbol

rko_slam repository

rko_slam

ROS Distro
jazzy

Repository Summary

Checkout URI https://github.com/PRBonn/rko_slam.git
VCS Type git
VCS Version master
Last Updated 2026-09-25
Dev Status DEVELOPED
Released UNRELEASED
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

Packages

Name Version
rko_slam 0.0.1

README

rko_slam

ROS2 LiDAR-inertial SLAM for your odometry: drift correction and multi-session alignment

[![Jazzy](https://github.com/PRBonn/rko_slam/actions/workflows/ros_jazzy.yaml/badge.svg)](https://github.com/PRBonn/rko_slam/actions/workflows/ros_jazzy.yaml) [![Kilted](https://github.com/PRBonn/rko_slam/actions/workflows/ros_kilted.yaml/badge.svg)](https://github.com/PRBonn/rko_slam/actions/workflows/ros_kilted.yaml) [![Lyrical](https://github.com/PRBonn/rko_slam/actions/workflows/ros_lyrical.yaml/badge.svg)](https://github.com/PRBonn/rko_slam/actions/workflows/ros_lyrical.yaml) [![Rolling](https://github.com/PRBonn/rko_slam/actions/workflows/ros_rolling.yaml/badge.svg)](https://github.com/PRBonn/rko_slam/actions/workflows/ros_rolling.yaml) [![Docs](https://img.shields.io/badge/docs-prbonn.github.io-blue)](https://prbonn.github.io/rko_slam/) [![GitHub License](https://img.shields.io/github/license/PRBonn/rko_slam)](/LICENSE) [![GitHub last commit](https://img.shields.io/github/last-commit/PRBonn/rko_slam)](/)

A 3 km drive with the odometry alone, and with rko_slam running on top of it
A 3 km drive that ends where it started, with rko_lio, and with rko_slam running on top of it

rko_slam is a ROS2 LiDAR-inertial SLAM system. It runs on top of a LiDAR-inertial odometry. An odometry tells you how you moved, and over a long enough run its estimate drifts: come back to a place you have been before and the two visits do not land on the same spot. rko_slam runs next to the odometry, uses the LiDAR and IMU, recognizes the revisit, and corrects the whole trajectory behind you. You keep the odometry as it is, and you additionally get a map <- odom correction on TF, a pose graph, and the sub-maps the system built along the way.

The odometry it assumes by default is rko_lio, my LiDAR-inertial odometry package, which is also a build dependency. At run time any odometry that publishes odom <- base on TF and is locally consistent will do - LiDAR-only odometry, wheel odometry, whatever you already run. The IMU is optional as well: leave imu_topic unset and rko_slam runs on the LiDAR alone.

The same revisit detector works across runs, not just within one, as an offline step. Give it the run directories of several sessions of the same place - different days, different directions, whatever - and it finds where they overlap and solves all of them into one frame.

Three sessions of the same place, each in its own frame, and in one frame after alignment
Three sessions of the same place, recorded on different days, and the one frame they end up in

Documentation is at prbonn.github.io/rko_slam.

Build

Supported distros: Jazzy, Kilted, Lyrical, Rolling.

For now, rko_lio has to be built in the same workspace.

cd <ws>/src
git clone https://github.com/PRBonn/rko_lio
git clone https://github.com/PRBonn/rko_slam
cd <ws> && rosdep install --from-paths src --ignore-src -y
colcon build --packages-select rko_lio rko_slam

apt installs will be supported, same as with rko_lio. Dependencies and build options are covered in the docs.

Usage

Three entrypoints: slam.launch.py (mode:=online|offline), odometry_and_slam.launch.py, and align.launch.py. -s lists every parameter with its documentation, and anything you leave unset keeps the node’s own default.

Online, next to a running rko_lio, consuming its deskewed scan:

ros2 launch rko_slam slam.launch.py lidar_topic:=/rko_lio/deskewed_scan imu_topic:=/your/imu rviz:=true

Offline, self-draining a bag, with the odometry from the bag’s own /tf, and writing the run to disk:

ros2 launch rko_slam slam.launch.py mode:=offline bag_path:=/data/my_bag \
  lidar_topic:=/rko_lio/deskewed_scan imu_topic:=/your/imu dump_results:=true

Multi-session alignment of the run directories those runs wrote:

ros2 launch rko_slam align.launch.py run_dirs:="[results/run_1, results/run_2]"

Running with another odometry, running rko_lio alongside with odometry_and_slam.launch.py, taking the odometry from a TUM file, what a run writes to disk, every parameter and what it does, and how the system works are all in the docs.

Acknowledgments and Citation

This work was developed as part of my thesis (published soon), and much of it is inspired by KISS-SLAM - the initial version was essentially a reimplementation for ROS2.

File truncated at 100 lines see the full file

No version for distro crystal showing jazzy. Known supported distros are highlighted in the buttons above.
Repo symbol

rko_slam repository

rko_slam

ROS Distro
jazzy

Repository Summary

Checkout URI https://github.com/PRBonn/rko_slam.git
VCS Type git
VCS Version master
Last Updated 2026-09-25
Dev Status DEVELOPED
Released UNRELEASED
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

Packages

Name Version
rko_slam 0.0.1

README

rko_slam

ROS2 LiDAR-inertial SLAM for your odometry: drift correction and multi-session alignment

[![Jazzy](https://github.com/PRBonn/rko_slam/actions/workflows/ros_jazzy.yaml/badge.svg)](https://github.com/PRBonn/rko_slam/actions/workflows/ros_jazzy.yaml) [![Kilted](https://github.com/PRBonn/rko_slam/actions/workflows/ros_kilted.yaml/badge.svg)](https://github.com/PRBonn/rko_slam/actions/workflows/ros_kilted.yaml) [![Lyrical](https://github.com/PRBonn/rko_slam/actions/workflows/ros_lyrical.yaml/badge.svg)](https://github.com/PRBonn/rko_slam/actions/workflows/ros_lyrical.yaml) [![Rolling](https://github.com/PRBonn/rko_slam/actions/workflows/ros_rolling.yaml/badge.svg)](https://github.com/PRBonn/rko_slam/actions/workflows/ros_rolling.yaml) [![Docs](https://img.shields.io/badge/docs-prbonn.github.io-blue)](https://prbonn.github.io/rko_slam/) [![GitHub License](https://img.shields.io/github/license/PRBonn/rko_slam)](/LICENSE) [![GitHub last commit](https://img.shields.io/github/last-commit/PRBonn/rko_slam)](/)

A 3 km drive with the odometry alone, and with rko_slam running on top of it
A 3 km drive that ends where it started, with rko_lio, and with rko_slam running on top of it

rko_slam is a ROS2 LiDAR-inertial SLAM system. It runs on top of a LiDAR-inertial odometry. An odometry tells you how you moved, and over a long enough run its estimate drifts: come back to a place you have been before and the two visits do not land on the same spot. rko_slam runs next to the odometry, uses the LiDAR and IMU, recognizes the revisit, and corrects the whole trajectory behind you. You keep the odometry as it is, and you additionally get a map <- odom correction on TF, a pose graph, and the sub-maps the system built along the way.

The odometry it assumes by default is rko_lio, my LiDAR-inertial odometry package, which is also a build dependency. At run time any odometry that publishes odom <- base on TF and is locally consistent will do - LiDAR-only odometry, wheel odometry, whatever you already run. The IMU is optional as well: leave imu_topic unset and rko_slam runs on the LiDAR alone.

The same revisit detector works across runs, not just within one, as an offline step. Give it the run directories of several sessions of the same place - different days, different directions, whatever - and it finds where they overlap and solves all of them into one frame.

Three sessions of the same place, each in its own frame, and in one frame after alignment
Three sessions of the same place, recorded on different days, and the one frame they end up in

Documentation is at prbonn.github.io/rko_slam.

Build

Supported distros: Jazzy, Kilted, Lyrical, Rolling.

For now, rko_lio has to be built in the same workspace.

cd <ws>/src
git clone https://github.com/PRBonn/rko_lio
git clone https://github.com/PRBonn/rko_slam
cd <ws> && rosdep install --from-paths src --ignore-src -y
colcon build --packages-select rko_lio rko_slam

apt installs will be supported, same as with rko_lio. Dependencies and build options are covered in the docs.

Usage

Three entrypoints: slam.launch.py (mode:=online|offline), odometry_and_slam.launch.py, and align.launch.py. -s lists every parameter with its documentation, and anything you leave unset keeps the node’s own default.

Online, next to a running rko_lio, consuming its deskewed scan:

ros2 launch rko_slam slam.launch.py lidar_topic:=/rko_lio/deskewed_scan imu_topic:=/your/imu rviz:=true

Offline, self-draining a bag, with the odometry from the bag’s own /tf, and writing the run to disk:

ros2 launch rko_slam slam.launch.py mode:=offline bag_path:=/data/my_bag \
  lidar_topic:=/rko_lio/deskewed_scan imu_topic:=/your/imu dump_results:=true

Multi-session alignment of the run directories those runs wrote:

ros2 launch rko_slam align.launch.py run_dirs:="[results/run_1, results/run_2]"

Running with another odometry, running rko_lio alongside with odometry_and_slam.launch.py, taking the odometry from a TUM file, what a run writes to disk, every parameter and what it does, and how the system works are all in the docs.

Acknowledgments and Citation

This work was developed as part of my thesis (published soon), and much of it is inspired by KISS-SLAM - the initial version was essentially a reimplementation for ROS2.

File truncated at 100 lines see the full file

No version for distro eloquent showing jazzy. Known supported distros are highlighted in the buttons above.
Repo symbol

rko_slam repository

rko_slam

ROS Distro
jazzy

Repository Summary

Checkout URI https://github.com/PRBonn/rko_slam.git
VCS Type git
VCS Version master
Last Updated 2026-09-25
Dev Status DEVELOPED
Released UNRELEASED
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

Packages

Name Version
rko_slam 0.0.1

README

rko_slam

ROS2 LiDAR-inertial SLAM for your odometry: drift correction and multi-session alignment

[![Jazzy](https://github.com/PRBonn/rko_slam/actions/workflows/ros_jazzy.yaml/badge.svg)](https://github.com/PRBonn/rko_slam/actions/workflows/ros_jazzy.yaml) [![Kilted](https://github.com/PRBonn/rko_slam/actions/workflows/ros_kilted.yaml/badge.svg)](https://github.com/PRBonn/rko_slam/actions/workflows/ros_kilted.yaml) [![Lyrical](https://github.com/PRBonn/rko_slam/actions/workflows/ros_lyrical.yaml/badge.svg)](https://github.com/PRBonn/rko_slam/actions/workflows/ros_lyrical.yaml) [![Rolling](https://github.com/PRBonn/rko_slam/actions/workflows/ros_rolling.yaml/badge.svg)](https://github.com/PRBonn/rko_slam/actions/workflows/ros_rolling.yaml) [![Docs](https://img.shields.io/badge/docs-prbonn.github.io-blue)](https://prbonn.github.io/rko_slam/) [![GitHub License](https://img.shields.io/github/license/PRBonn/rko_slam)](/LICENSE) [![GitHub last commit](https://img.shields.io/github/last-commit/PRBonn/rko_slam)](/)

A 3 km drive with the odometry alone, and with rko_slam running on top of it
A 3 km drive that ends where it started, with rko_lio, and with rko_slam running on top of it

rko_slam is a ROS2 LiDAR-inertial SLAM system. It runs on top of a LiDAR-inertial odometry. An odometry tells you how you moved, and over a long enough run its estimate drifts: come back to a place you have been before and the two visits do not land on the same spot. rko_slam runs next to the odometry, uses the LiDAR and IMU, recognizes the revisit, and corrects the whole trajectory behind you. You keep the odometry as it is, and you additionally get a map <- odom correction on TF, a pose graph, and the sub-maps the system built along the way.

The odometry it assumes by default is rko_lio, my LiDAR-inertial odometry package, which is also a build dependency. At run time any odometry that publishes odom <- base on TF and is locally consistent will do - LiDAR-only odometry, wheel odometry, whatever you already run. The IMU is optional as well: leave imu_topic unset and rko_slam runs on the LiDAR alone.

The same revisit detector works across runs, not just within one, as an offline step. Give it the run directories of several sessions of the same place - different days, different directions, whatever - and it finds where they overlap and solves all of them into one frame.

Three sessions of the same place, each in its own frame, and in one frame after alignment
Three sessions of the same place, recorded on different days, and the one frame they end up in

Documentation is at prbonn.github.io/rko_slam.

Build

Supported distros: Jazzy, Kilted, Lyrical, Rolling.

For now, rko_lio has to be built in the same workspace.

cd <ws>/src
git clone https://github.com/PRBonn/rko_lio
git clone https://github.com/PRBonn/rko_slam
cd <ws> && rosdep install --from-paths src --ignore-src -y
colcon build --packages-select rko_lio rko_slam

apt installs will be supported, same as with rko_lio. Dependencies and build options are covered in the docs.

Usage

Three entrypoints: slam.launch.py (mode:=online|offline), odometry_and_slam.launch.py, and align.launch.py. -s lists every parameter with its documentation, and anything you leave unset keeps the node’s own default.

Online, next to a running rko_lio, consuming its deskewed scan:

ros2 launch rko_slam slam.launch.py lidar_topic:=/rko_lio/deskewed_scan imu_topic:=/your/imu rviz:=true

Offline, self-draining a bag, with the odometry from the bag’s own /tf, and writing the run to disk:

ros2 launch rko_slam slam.launch.py mode:=offline bag_path:=/data/my_bag \
  lidar_topic:=/rko_lio/deskewed_scan imu_topic:=/your/imu dump_results:=true

Multi-session alignment of the run directories those runs wrote:

ros2 launch rko_slam align.launch.py run_dirs:="[results/run_1, results/run_2]"

Running with another odometry, running rko_lio alongside with odometry_and_slam.launch.py, taking the odometry from a TUM file, what a run writes to disk, every parameter and what it does, and how the system works are all in the docs.

Acknowledgments and Citation

This work was developed as part of my thesis (published soon), and much of it is inspired by KISS-SLAM - the initial version was essentially a reimplementation for ROS2.

File truncated at 100 lines see the full file

No version for distro dashing showing jazzy. Known supported distros are highlighted in the buttons above.
Repo symbol

rko_slam repository

rko_slam

ROS Distro
jazzy

Repository Summary

Checkout URI https://github.com/PRBonn/rko_slam.git
VCS Type git
VCS Version master
Last Updated 2026-09-25
Dev Status DEVELOPED
Released UNRELEASED
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

Packages

Name Version
rko_slam 0.0.1

README

rko_slam

ROS2 LiDAR-inertial SLAM for your odometry: drift correction and multi-session alignment

[![Jazzy](https://github.com/PRBonn/rko_slam/actions/workflows/ros_jazzy.yaml/badge.svg)](https://github.com/PRBonn/rko_slam/actions/workflows/ros_jazzy.yaml) [![Kilted](https://github.com/PRBonn/rko_slam/actions/workflows/ros_kilted.yaml/badge.svg)](https://github.com/PRBonn/rko_slam/actions/workflows/ros_kilted.yaml) [![Lyrical](https://github.com/PRBonn/rko_slam/actions/workflows/ros_lyrical.yaml/badge.svg)](https://github.com/PRBonn/rko_slam/actions/workflows/ros_lyrical.yaml) [![Rolling](https://github.com/PRBonn/rko_slam/actions/workflows/ros_rolling.yaml/badge.svg)](https://github.com/PRBonn/rko_slam/actions/workflows/ros_rolling.yaml) [![Docs](https://img.shields.io/badge/docs-prbonn.github.io-blue)](https://prbonn.github.io/rko_slam/) [![GitHub License](https://img.shields.io/github/license/PRBonn/rko_slam)](/LICENSE) [![GitHub last commit](https://img.shields.io/github/last-commit/PRBonn/rko_slam)](/)

A 3 km drive with the odometry alone, and with rko_slam running on top of it
A 3 km drive that ends where it started, with rko_lio, and with rko_slam running on top of it

rko_slam is a ROS2 LiDAR-inertial SLAM system. It runs on top of a LiDAR-inertial odometry. An odometry tells you how you moved, and over a long enough run its estimate drifts: come back to a place you have been before and the two visits do not land on the same spot. rko_slam runs next to the odometry, uses the LiDAR and IMU, recognizes the revisit, and corrects the whole trajectory behind you. You keep the odometry as it is, and you additionally get a map <- odom correction on TF, a pose graph, and the sub-maps the system built along the way.

The odometry it assumes by default is rko_lio, my LiDAR-inertial odometry package, which is also a build dependency. At run time any odometry that publishes odom <- base on TF and is locally consistent will do - LiDAR-only odometry, wheel odometry, whatever you already run. The IMU is optional as well: leave imu_topic unset and rko_slam runs on the LiDAR alone.

The same revisit detector works across runs, not just within one, as an offline step. Give it the run directories of several sessions of the same place - different days, different directions, whatever - and it finds where they overlap and solves all of them into one frame.

Three sessions of the same place, each in its own frame, and in one frame after alignment
Three sessions of the same place, recorded on different days, and the one frame they end up in

Documentation is at prbonn.github.io/rko_slam.

Build

Supported distros: Jazzy, Kilted, Lyrical, Rolling.

For now, rko_lio has to be built in the same workspace.

cd <ws>/src
git clone https://github.com/PRBonn/rko_lio
git clone https://github.com/PRBonn/rko_slam
cd <ws> && rosdep install --from-paths src --ignore-src -y
colcon build --packages-select rko_lio rko_slam

apt installs will be supported, same as with rko_lio. Dependencies and build options are covered in the docs.

Usage

Three entrypoints: slam.launch.py (mode:=online|offline), odometry_and_slam.launch.py, and align.launch.py. -s lists every parameter with its documentation, and anything you leave unset keeps the node’s own default.

Online, next to a running rko_lio, consuming its deskewed scan:

ros2 launch rko_slam slam.launch.py lidar_topic:=/rko_lio/deskewed_scan imu_topic:=/your/imu rviz:=true

Offline, self-draining a bag, with the odometry from the bag’s own /tf, and writing the run to disk:

ros2 launch rko_slam slam.launch.py mode:=offline bag_path:=/data/my_bag \
  lidar_topic:=/rko_lio/deskewed_scan imu_topic:=/your/imu dump_results:=true

Multi-session alignment of the run directories those runs wrote:

ros2 launch rko_slam align.launch.py run_dirs:="[results/run_1, results/run_2]"

Running with another odometry, running rko_lio alongside with odometry_and_slam.launch.py, taking the odometry from a TUM file, what a run writes to disk, every parameter and what it does, and how the system works are all in the docs.

Acknowledgments and Citation

This work was developed as part of my thesis (published soon), and much of it is inspired by KISS-SLAM - the initial version was essentially a reimplementation for ROS2.

File truncated at 100 lines see the full file

No version for distro galactic showing jazzy. Known supported distros are highlighted in the buttons above.
Repo symbol

rko_slam repository

rko_slam

ROS Distro
jazzy

Repository Summary

Checkout URI https://github.com/PRBonn/rko_slam.git
VCS Type git
VCS Version master
Last Updated 2026-09-25
Dev Status DEVELOPED
Released UNRELEASED
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

Packages

Name Version
rko_slam 0.0.1

README

rko_slam

ROS2 LiDAR-inertial SLAM for your odometry: drift correction and multi-session alignment

[![Jazzy](https://github.com/PRBonn/rko_slam/actions/workflows/ros_jazzy.yaml/badge.svg)](https://github.com/PRBonn/rko_slam/actions/workflows/ros_jazzy.yaml) [![Kilted](https://github.com/PRBonn/rko_slam/actions/workflows/ros_kilted.yaml/badge.svg)](https://github.com/PRBonn/rko_slam/actions/workflows/ros_kilted.yaml) [![Lyrical](https://github.com/PRBonn/rko_slam/actions/workflows/ros_lyrical.yaml/badge.svg)](https://github.com/PRBonn/rko_slam/actions/workflows/ros_lyrical.yaml) [![Rolling](https://github.com/PRBonn/rko_slam/actions/workflows/ros_rolling.yaml/badge.svg)](https://github.com/PRBonn/rko_slam/actions/workflows/ros_rolling.yaml) [![Docs](https://img.shields.io/badge/docs-prbonn.github.io-blue)](https://prbonn.github.io/rko_slam/) [![GitHub License](https://img.shields.io/github/license/PRBonn/rko_slam)](/LICENSE) [![GitHub last commit](https://img.shields.io/github/last-commit/PRBonn/rko_slam)](/)

A 3 km drive with the odometry alone, and with rko_slam running on top of it
A 3 km drive that ends where it started, with rko_lio, and with rko_slam running on top of it

rko_slam is a ROS2 LiDAR-inertial SLAM system. It runs on top of a LiDAR-inertial odometry. An odometry tells you how you moved, and over a long enough run its estimate drifts: come back to a place you have been before and the two visits do not land on the same spot. rko_slam runs next to the odometry, uses the LiDAR and IMU, recognizes the revisit, and corrects the whole trajectory behind you. You keep the odometry as it is, and you additionally get a map <- odom correction on TF, a pose graph, and the sub-maps the system built along the way.

The odometry it assumes by default is rko_lio, my LiDAR-inertial odometry package, which is also a build dependency. At run time any odometry that publishes odom <- base on TF and is locally consistent will do - LiDAR-only odometry, wheel odometry, whatever you already run. The IMU is optional as well: leave imu_topic unset and rko_slam runs on the LiDAR alone.

The same revisit detector works across runs, not just within one, as an offline step. Give it the run directories of several sessions of the same place - different days, different directions, whatever - and it finds where they overlap and solves all of them into one frame.

Three sessions of the same place, each in its own frame, and in one frame after alignment
Three sessions of the same place, recorded on different days, and the one frame they end up in

Documentation is at prbonn.github.io/rko_slam.

Build

Supported distros: Jazzy, Kilted, Lyrical, Rolling.

For now, rko_lio has to be built in the same workspace.

cd <ws>/src
git clone https://github.com/PRBonn/rko_lio
git clone https://github.com/PRBonn/rko_slam
cd <ws> && rosdep install --from-paths src --ignore-src -y
colcon build --packages-select rko_lio rko_slam

apt installs will be supported, same as with rko_lio. Dependencies and build options are covered in the docs.

Usage

Three entrypoints: slam.launch.py (mode:=online|offline), odometry_and_slam.launch.py, and align.launch.py. -s lists every parameter with its documentation, and anything you leave unset keeps the node’s own default.

Online, next to a running rko_lio, consuming its deskewed scan:

ros2 launch rko_slam slam.launch.py lidar_topic:=/rko_lio/deskewed_scan imu_topic:=/your/imu rviz:=true

Offline, self-draining a bag, with the odometry from the bag’s own /tf, and writing the run to disk:

ros2 launch rko_slam slam.launch.py mode:=offline bag_path:=/data/my_bag \
  lidar_topic:=/rko_lio/deskewed_scan imu_topic:=/your/imu dump_results:=true

Multi-session alignment of the run directories those runs wrote:

ros2 launch rko_slam align.launch.py run_dirs:="[results/run_1, results/run_2]"

Running with another odometry, running rko_lio alongside with odometry_and_slam.launch.py, taking the odometry from a TUM file, what a run writes to disk, every parameter and what it does, and how the system works are all in the docs.

Acknowledgments and Citation

This work was developed as part of my thesis (published soon), and much of it is inspired by KISS-SLAM - the initial version was essentially a reimplementation for ROS2.

File truncated at 100 lines see the full file

No version for distro foxy showing jazzy. Known supported distros are highlighted in the buttons above.
Repo symbol

rko_slam repository

rko_slam

ROS Distro
jazzy

Repository Summary

Checkout URI https://github.com/PRBonn/rko_slam.git
VCS Type git
VCS Version master
Last Updated 2026-09-25
Dev Status DEVELOPED
Released UNRELEASED
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

Packages

Name Version
rko_slam 0.0.1

README

rko_slam

ROS2 LiDAR-inertial SLAM for your odometry: drift correction and multi-session alignment

[![Jazzy](https://github.com/PRBonn/rko_slam/actions/workflows/ros_jazzy.yaml/badge.svg)](https://github.com/PRBonn/rko_slam/actions/workflows/ros_jazzy.yaml) [![Kilted](https://github.com/PRBonn/rko_slam/actions/workflows/ros_kilted.yaml/badge.svg)](https://github.com/PRBonn/rko_slam/actions/workflows/ros_kilted.yaml) [![Lyrical](https://github.com/PRBonn/rko_slam/actions/workflows/ros_lyrical.yaml/badge.svg)](https://github.com/PRBonn/rko_slam/actions/workflows/ros_lyrical.yaml) [![Rolling](https://github.com/PRBonn/rko_slam/actions/workflows/ros_rolling.yaml/badge.svg)](https://github.com/PRBonn/rko_slam/actions/workflows/ros_rolling.yaml) [![Docs](https://img.shields.io/badge/docs-prbonn.github.io-blue)](https://prbonn.github.io/rko_slam/) [![GitHub License](https://img.shields.io/github/license/PRBonn/rko_slam)](/LICENSE) [![GitHub last commit](https://img.shields.io/github/last-commit/PRBonn/rko_slam)](/)

A 3 km drive with the odometry alone, and with rko_slam running on top of it
A 3 km drive that ends where it started, with rko_lio, and with rko_slam running on top of it

rko_slam is a ROS2 LiDAR-inertial SLAM system. It runs on top of a LiDAR-inertial odometry. An odometry tells you how you moved, and over a long enough run its estimate drifts: come back to a place you have been before and the two visits do not land on the same spot. rko_slam runs next to the odometry, uses the LiDAR and IMU, recognizes the revisit, and corrects the whole trajectory behind you. You keep the odometry as it is, and you additionally get a map <- odom correction on TF, a pose graph, and the sub-maps the system built along the way.

The odometry it assumes by default is rko_lio, my LiDAR-inertial odometry package, which is also a build dependency. At run time any odometry that publishes odom <- base on TF and is locally consistent will do - LiDAR-only odometry, wheel odometry, whatever you already run. The IMU is optional as well: leave imu_topic unset and rko_slam runs on the LiDAR alone.

The same revisit detector works across runs, not just within one, as an offline step. Give it the run directories of several sessions of the same place - different days, different directions, whatever - and it finds where they overlap and solves all of them into one frame.

Three sessions of the same place, each in its own frame, and in one frame after alignment
Three sessions of the same place, recorded on different days, and the one frame they end up in

Documentation is at prbonn.github.io/rko_slam.

Build

Supported distros: Jazzy, Kilted, Lyrical, Rolling.

For now, rko_lio has to be built in the same workspace.

cd <ws>/src
git clone https://github.com/PRBonn/rko_lio
git clone https://github.com/PRBonn/rko_slam
cd <ws> && rosdep install --from-paths src --ignore-src -y
colcon build --packages-select rko_lio rko_slam

apt installs will be supported, same as with rko_lio. Dependencies and build options are covered in the docs.

Usage

Three entrypoints: slam.launch.py (mode:=online|offline), odometry_and_slam.launch.py, and align.launch.py. -s lists every parameter with its documentation, and anything you leave unset keeps the node’s own default.

Online, next to a running rko_lio, consuming its deskewed scan:

ros2 launch rko_slam slam.launch.py lidar_topic:=/rko_lio/deskewed_scan imu_topic:=/your/imu rviz:=true

Offline, self-draining a bag, with the odometry from the bag’s own /tf, and writing the run to disk:

ros2 launch rko_slam slam.launch.py mode:=offline bag_path:=/data/my_bag \
  lidar_topic:=/rko_lio/deskewed_scan imu_topic:=/your/imu dump_results:=true

Multi-session alignment of the run directories those runs wrote:

ros2 launch rko_slam align.launch.py run_dirs:="[results/run_1, results/run_2]"

Running with another odometry, running rko_lio alongside with odometry_and_slam.launch.py, taking the odometry from a TUM file, what a run writes to disk, every parameter and what it does, and how the system works are all in the docs.

Acknowledgments and Citation

This work was developed as part of my thesis (published soon), and much of it is inspired by KISS-SLAM - the initial version was essentially a reimplementation for ROS2.

File truncated at 100 lines see the full file

No version for distro iron showing jazzy. Known supported distros are highlighted in the buttons above.
Repo symbol

rko_slam repository

rko_slam

ROS Distro
jazzy

Repository Summary

Checkout URI https://github.com/PRBonn/rko_slam.git
VCS Type git
VCS Version master
Last Updated 2026-09-25
Dev Status DEVELOPED
Released UNRELEASED
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

Packages

Name Version
rko_slam 0.0.1

README

rko_slam

ROS2 LiDAR-inertial SLAM for your odometry: drift correction and multi-session alignment

[![Jazzy](https://github.com/PRBonn/rko_slam/actions/workflows/ros_jazzy.yaml/badge.svg)](https://github.com/PRBonn/rko_slam/actions/workflows/ros_jazzy.yaml) [![Kilted](https://github.com/PRBonn/rko_slam/actions/workflows/ros_kilted.yaml/badge.svg)](https://github.com/PRBonn/rko_slam/actions/workflows/ros_kilted.yaml) [![Lyrical](https://github.com/PRBonn/rko_slam/actions/workflows/ros_lyrical.yaml/badge.svg)](https://github.com/PRBonn/rko_slam/actions/workflows/ros_lyrical.yaml) [![Rolling](https://github.com/PRBonn/rko_slam/actions/workflows/ros_rolling.yaml/badge.svg)](https://github.com/PRBonn/rko_slam/actions/workflows/ros_rolling.yaml) [![Docs](https://img.shields.io/badge/docs-prbonn.github.io-blue)](https://prbonn.github.io/rko_slam/) [![GitHub License](https://img.shields.io/github/license/PRBonn/rko_slam)](/LICENSE) [![GitHub last commit](https://img.shields.io/github/last-commit/PRBonn/rko_slam)](/)

A 3 km drive with the odometry alone, and with rko_slam running on top of it
A 3 km drive that ends where it started, with rko_lio, and with rko_slam running on top of it

rko_slam is a ROS2 LiDAR-inertial SLAM system. It runs on top of a LiDAR-inertial odometry. An odometry tells you how you moved, and over a long enough run its estimate drifts: come back to a place you have been before and the two visits do not land on the same spot. rko_slam runs next to the odometry, uses the LiDAR and IMU, recognizes the revisit, and corrects the whole trajectory behind you. You keep the odometry as it is, and you additionally get a map <- odom correction on TF, a pose graph, and the sub-maps the system built along the way.

The odometry it assumes by default is rko_lio, my LiDAR-inertial odometry package, which is also a build dependency. At run time any odometry that publishes odom <- base on TF and is locally consistent will do - LiDAR-only odometry, wheel odometry, whatever you already run. The IMU is optional as well: leave imu_topic unset and rko_slam runs on the LiDAR alone.

The same revisit detector works across runs, not just within one, as an offline step. Give it the run directories of several sessions of the same place - different days, different directions, whatever - and it finds where they overlap and solves all of them into one frame.

Three sessions of the same place, each in its own frame, and in one frame after alignment
Three sessions of the same place, recorded on different days, and the one frame they end up in

Documentation is at prbonn.github.io/rko_slam.

Build

Supported distros: Jazzy, Kilted, Lyrical, Rolling.

For now, rko_lio has to be built in the same workspace.

cd <ws>/src
git clone https://github.com/PRBonn/rko_lio
git clone https://github.com/PRBonn/rko_slam
cd <ws> && rosdep install --from-paths src --ignore-src -y
colcon build --packages-select rko_lio rko_slam

apt installs will be supported, same as with rko_lio. Dependencies and build options are covered in the docs.

Usage

Three entrypoints: slam.launch.py (mode:=online|offline), odometry_and_slam.launch.py, and align.launch.py. -s lists every parameter with its documentation, and anything you leave unset keeps the node’s own default.

Online, next to a running rko_lio, consuming its deskewed scan:

ros2 launch rko_slam slam.launch.py lidar_topic:=/rko_lio/deskewed_scan imu_topic:=/your/imu rviz:=true

Offline, self-draining a bag, with the odometry from the bag’s own /tf, and writing the run to disk:

ros2 launch rko_slam slam.launch.py mode:=offline bag_path:=/data/my_bag \
  lidar_topic:=/rko_lio/deskewed_scan imu_topic:=/your/imu dump_results:=true

Multi-session alignment of the run directories those runs wrote:

ros2 launch rko_slam align.launch.py run_dirs:="[results/run_1, results/run_2]"

Running with another odometry, running rko_lio alongside with odometry_and_slam.launch.py, taking the odometry from a TUM file, what a run writes to disk, every parameter and what it does, and how the system works are all in the docs.

Acknowledgments and Citation

This work was developed as part of my thesis (published soon), and much of it is inspired by KISS-SLAM - the initial version was essentially a reimplementation for ROS2.

File truncated at 100 lines see the full file

No version for distro lunar showing jazzy. Known supported distros are highlighted in the buttons above.
Repo symbol

rko_slam repository

rko_slam

ROS Distro
jazzy

Repository Summary

Checkout URI https://github.com/PRBonn/rko_slam.git
VCS Type git
VCS Version master
Last Updated 2026-09-25
Dev Status DEVELOPED
Released UNRELEASED
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

Packages

Name Version
rko_slam 0.0.1

README

rko_slam

ROS2 LiDAR-inertial SLAM for your odometry: drift correction and multi-session alignment

[![Jazzy](https://github.com/PRBonn/rko_slam/actions/workflows/ros_jazzy.yaml/badge.svg)](https://github.com/PRBonn/rko_slam/actions/workflows/ros_jazzy.yaml) [![Kilted](https://github.com/PRBonn/rko_slam/actions/workflows/ros_kilted.yaml/badge.svg)](https://github.com/PRBonn/rko_slam/actions/workflows/ros_kilted.yaml) [![Lyrical](https://github.com/PRBonn/rko_slam/actions/workflows/ros_lyrical.yaml/badge.svg)](https://github.com/PRBonn/rko_slam/actions/workflows/ros_lyrical.yaml) [![Rolling](https://github.com/PRBonn/rko_slam/actions/workflows/ros_rolling.yaml/badge.svg)](https://github.com/PRBonn/rko_slam/actions/workflows/ros_rolling.yaml) [![Docs](https://img.shields.io/badge/docs-prbonn.github.io-blue)](https://prbonn.github.io/rko_slam/) [![GitHub License](https://img.shields.io/github/license/PRBonn/rko_slam)](/LICENSE) [![GitHub last commit](https://img.shields.io/github/last-commit/PRBonn/rko_slam)](/)

A 3 km drive with the odometry alone, and with rko_slam running on top of it
A 3 km drive that ends where it started, with rko_lio, and with rko_slam running on top of it

rko_slam is a ROS2 LiDAR-inertial SLAM system. It runs on top of a LiDAR-inertial odometry. An odometry tells you how you moved, and over a long enough run its estimate drifts: come back to a place you have been before and the two visits do not land on the same spot. rko_slam runs next to the odometry, uses the LiDAR and IMU, recognizes the revisit, and corrects the whole trajectory behind you. You keep the odometry as it is, and you additionally get a map <- odom correction on TF, a pose graph, and the sub-maps the system built along the way.

The odometry it assumes by default is rko_lio, my LiDAR-inertial odometry package, which is also a build dependency. At run time any odometry that publishes odom <- base on TF and is locally consistent will do - LiDAR-only odometry, wheel odometry, whatever you already run. The IMU is optional as well: leave imu_topic unset and rko_slam runs on the LiDAR alone.

The same revisit detector works across runs, not just within one, as an offline step. Give it the run directories of several sessions of the same place - different days, different directions, whatever - and it finds where they overlap and solves all of them into one frame.

Three sessions of the same place, each in its own frame, and in one frame after alignment
Three sessions of the same place, recorded on different days, and the one frame they end up in

Documentation is at prbonn.github.io/rko_slam.

Build

Supported distros: Jazzy, Kilted, Lyrical, Rolling.

For now, rko_lio has to be built in the same workspace.

cd <ws>/src
git clone https://github.com/PRBonn/rko_lio
git clone https://github.com/PRBonn/rko_slam
cd <ws> && rosdep install --from-paths src --ignore-src -y
colcon build --packages-select rko_lio rko_slam

apt installs will be supported, same as with rko_lio. Dependencies and build options are covered in the docs.

Usage

Three entrypoints: slam.launch.py (mode:=online|offline), odometry_and_slam.launch.py, and align.launch.py. -s lists every parameter with its documentation, and anything you leave unset keeps the node’s own default.

Online, next to a running rko_lio, consuming its deskewed scan:

ros2 launch rko_slam slam.launch.py lidar_topic:=/rko_lio/deskewed_scan imu_topic:=/your/imu rviz:=true

Offline, self-draining a bag, with the odometry from the bag’s own /tf, and writing the run to disk:

ros2 launch rko_slam slam.launch.py mode:=offline bag_path:=/data/my_bag \
  lidar_topic:=/rko_lio/deskewed_scan imu_topic:=/your/imu dump_results:=true

Multi-session alignment of the run directories those runs wrote:

ros2 launch rko_slam align.launch.py run_dirs:="[results/run_1, results/run_2]"

Running with another odometry, running rko_lio alongside with odometry_and_slam.launch.py, taking the odometry from a TUM file, what a run writes to disk, every parameter and what it does, and how the system works are all in the docs.

Acknowledgments and Citation

This work was developed as part of my thesis (published soon), and much of it is inspired by KISS-SLAM - the initial version was essentially a reimplementation for ROS2.

File truncated at 100 lines see the full file

No version for distro jade showing jazzy. Known supported distros are highlighted in the buttons above.
Repo symbol

rko_slam repository

rko_slam

ROS Distro
jazzy

Repository Summary

Checkout URI https://github.com/PRBonn/rko_slam.git
VCS Type git
VCS Version master
Last Updated 2026-09-25
Dev Status DEVELOPED
Released UNRELEASED
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

Packages

Name Version
rko_slam 0.0.1

README

rko_slam

ROS2 LiDAR-inertial SLAM for your odometry: drift correction and multi-session alignment

[![Jazzy](https://github.com/PRBonn/rko_slam/actions/workflows/ros_jazzy.yaml/badge.svg)](https://github.com/PRBonn/rko_slam/actions/workflows/ros_jazzy.yaml) [![Kilted](https://github.com/PRBonn/rko_slam/actions/workflows/ros_kilted.yaml/badge.svg)](https://github.com/PRBonn/rko_slam/actions/workflows/ros_kilted.yaml) [![Lyrical](https://github.com/PRBonn/rko_slam/actions/workflows/ros_lyrical.yaml/badge.svg)](https://github.com/PRBonn/rko_slam/actions/workflows/ros_lyrical.yaml) [![Rolling](https://github.com/PRBonn/rko_slam/actions/workflows/ros_rolling.yaml/badge.svg)](https://github.com/PRBonn/rko_slam/actions/workflows/ros_rolling.yaml) [![Docs](https://img.shields.io/badge/docs-prbonn.github.io-blue)](https://prbonn.github.io/rko_slam/) [![GitHub License](https://img.shields.io/github/license/PRBonn/rko_slam)](/LICENSE) [![GitHub last commit](https://img.shields.io/github/last-commit/PRBonn/rko_slam)](/)

A 3 km drive with the odometry alone, and with rko_slam running on top of it
A 3 km drive that ends where it started, with rko_lio, and with rko_slam running on top of it

rko_slam is a ROS2 LiDAR-inertial SLAM system. It runs on top of a LiDAR-inertial odometry. An odometry tells you how you moved, and over a long enough run its estimate drifts: come back to a place you have been before and the two visits do not land on the same spot. rko_slam runs next to the odometry, uses the LiDAR and IMU, recognizes the revisit, and corrects the whole trajectory behind you. You keep the odometry as it is, and you additionally get a map <- odom correction on TF, a pose graph, and the sub-maps the system built along the way.

The odometry it assumes by default is rko_lio, my LiDAR-inertial odometry package, which is also a build dependency. At run time any odometry that publishes odom <- base on TF and is locally consistent will do - LiDAR-only odometry, wheel odometry, whatever you already run. The IMU is optional as well: leave imu_topic unset and rko_slam runs on the LiDAR alone.

The same revisit detector works across runs, not just within one, as an offline step. Give it the run directories of several sessions of the same place - different days, different directions, whatever - and it finds where they overlap and solves all of them into one frame.

Three sessions of the same place, each in its own frame, and in one frame after alignment
Three sessions of the same place, recorded on different days, and the one frame they end up in

Documentation is at prbonn.github.io/rko_slam.

Build

Supported distros: Jazzy, Kilted, Lyrical, Rolling.

For now, rko_lio has to be built in the same workspace.

cd <ws>/src
git clone https://github.com/PRBonn/rko_lio
git clone https://github.com/PRBonn/rko_slam
cd <ws> && rosdep install --from-paths src --ignore-src -y
colcon build --packages-select rko_lio rko_slam

apt installs will be supported, same as with rko_lio. Dependencies and build options are covered in the docs.

Usage

Three entrypoints: slam.launch.py (mode:=online|offline), odometry_and_slam.launch.py, and align.launch.py. -s lists every parameter with its documentation, and anything you leave unset keeps the node’s own default.

Online, next to a running rko_lio, consuming its deskewed scan:

ros2 launch rko_slam slam.launch.py lidar_topic:=/rko_lio/deskewed_scan imu_topic:=/your/imu rviz:=true

Offline, self-draining a bag, with the odometry from the bag’s own /tf, and writing the run to disk:

ros2 launch rko_slam slam.launch.py mode:=offline bag_path:=/data/my_bag \
  lidar_topic:=/rko_lio/deskewed_scan imu_topic:=/your/imu dump_results:=true

Multi-session alignment of the run directories those runs wrote:

ros2 launch rko_slam align.launch.py run_dirs:="[results/run_1, results/run_2]"

Running with another odometry, running rko_lio alongside with odometry_and_slam.launch.py, taking the odometry from a TUM file, what a run writes to disk, every parameter and what it does, and how the system works are all in the docs.

Acknowledgments and Citation

This work was developed as part of my thesis (published soon), and much of it is inspired by KISS-SLAM - the initial version was essentially a reimplementation for ROS2.

File truncated at 100 lines see the full file

No version for distro indigo showing jazzy. Known supported distros are highlighted in the buttons above.
Repo symbol

rko_slam repository

rko_slam

ROS Distro
jazzy

Repository Summary

Checkout URI https://github.com/PRBonn/rko_slam.git
VCS Type git
VCS Version master
Last Updated 2026-09-25
Dev Status DEVELOPED
Released UNRELEASED
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

Packages

Name Version
rko_slam 0.0.1

README

rko_slam

ROS2 LiDAR-inertial SLAM for your odometry: drift correction and multi-session alignment

[![Jazzy](https://github.com/PRBonn/rko_slam/actions/workflows/ros_jazzy.yaml/badge.svg)](https://github.com/PRBonn/rko_slam/actions/workflows/ros_jazzy.yaml) [![Kilted](https://github.com/PRBonn/rko_slam/actions/workflows/ros_kilted.yaml/badge.svg)](https://github.com/PRBonn/rko_slam/actions/workflows/ros_kilted.yaml) [![Lyrical](https://github.com/PRBonn/rko_slam/actions/workflows/ros_lyrical.yaml/badge.svg)](https://github.com/PRBonn/rko_slam/actions/workflows/ros_lyrical.yaml) [![Rolling](https://github.com/PRBonn/rko_slam/actions/workflows/ros_rolling.yaml/badge.svg)](https://github.com/PRBonn/rko_slam/actions/workflows/ros_rolling.yaml) [![Docs](https://img.shields.io/badge/docs-prbonn.github.io-blue)](https://prbonn.github.io/rko_slam/) [![GitHub License](https://img.shields.io/github/license/PRBonn/rko_slam)](/LICENSE) [![GitHub last commit](https://img.shields.io/github/last-commit/PRBonn/rko_slam)](/)

A 3 km drive with the odometry alone, and with rko_slam running on top of it
A 3 km drive that ends where it started, with rko_lio, and with rko_slam running on top of it

rko_slam is a ROS2 LiDAR-inertial SLAM system. It runs on top of a LiDAR-inertial odometry. An odometry tells you how you moved, and over a long enough run its estimate drifts: come back to a place you have been before and the two visits do not land on the same spot. rko_slam runs next to the odometry, uses the LiDAR and IMU, recognizes the revisit, and corrects the whole trajectory behind you. You keep the odometry as it is, and you additionally get a map <- odom correction on TF, a pose graph, and the sub-maps the system built along the way.

The odometry it assumes by default is rko_lio, my LiDAR-inertial odometry package, which is also a build dependency. At run time any odometry that publishes odom <- base on TF and is locally consistent will do - LiDAR-only odometry, wheel odometry, whatever you already run. The IMU is optional as well: leave imu_topic unset and rko_slam runs on the LiDAR alone.

The same revisit detector works across runs, not just within one, as an offline step. Give it the run directories of several sessions of the same place - different days, different directions, whatever - and it finds where they overlap and solves all of them into one frame.

Three sessions of the same place, each in its own frame, and in one frame after alignment
Three sessions of the same place, recorded on different days, and the one frame they end up in

Documentation is at prbonn.github.io/rko_slam.

Build

Supported distros: Jazzy, Kilted, Lyrical, Rolling.

For now, rko_lio has to be built in the same workspace.

cd <ws>/src
git clone https://github.com/PRBonn/rko_lio
git clone https://github.com/PRBonn/rko_slam
cd <ws> && rosdep install --from-paths src --ignore-src -y
colcon build --packages-select rko_lio rko_slam

apt installs will be supported, same as with rko_lio. Dependencies and build options are covered in the docs.

Usage

Three entrypoints: slam.launch.py (mode:=online|offline), odometry_and_slam.launch.py, and align.launch.py. -s lists every parameter with its documentation, and anything you leave unset keeps the node’s own default.

Online, next to a running rko_lio, consuming its deskewed scan:

ros2 launch rko_slam slam.launch.py lidar_topic:=/rko_lio/deskewed_scan imu_topic:=/your/imu rviz:=true

Offline, self-draining a bag, with the odometry from the bag’s own /tf, and writing the run to disk:

ros2 launch rko_slam slam.launch.py mode:=offline bag_path:=/data/my_bag \
  lidar_topic:=/rko_lio/deskewed_scan imu_topic:=/your/imu dump_results:=true

Multi-session alignment of the run directories those runs wrote:

ros2 launch rko_slam align.launch.py run_dirs:="[results/run_1, results/run_2]"

Running with another odometry, running rko_lio alongside with odometry_and_slam.launch.py, taking the odometry from a TUM file, what a run writes to disk, every parameter and what it does, and how the system works are all in the docs.

Acknowledgments and Citation

This work was developed as part of my thesis (published soon), and much of it is inspired by KISS-SLAM - the initial version was essentially a reimplementation for ROS2.

File truncated at 100 lines see the full file

No version for distro hydro showing jazzy. Known supported distros are highlighted in the buttons above.
Repo symbol

rko_slam repository

rko_slam

ROS Distro
jazzy

Repository Summary

Checkout URI https://github.com/PRBonn/rko_slam.git
VCS Type git
VCS Version master
Last Updated 2026-09-25
Dev Status DEVELOPED
Released UNRELEASED
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

Packages

Name Version
rko_slam 0.0.1

README

rko_slam

ROS2 LiDAR-inertial SLAM for your odometry: drift correction and multi-session alignment

[![Jazzy](https://github.com/PRBonn/rko_slam/actions/workflows/ros_jazzy.yaml/badge.svg)](https://github.com/PRBonn/rko_slam/actions/workflows/ros_jazzy.yaml) [![Kilted](https://github.com/PRBonn/rko_slam/actions/workflows/ros_kilted.yaml/badge.svg)](https://github.com/PRBonn/rko_slam/actions/workflows/ros_kilted.yaml) [![Lyrical](https://github.com/PRBonn/rko_slam/actions/workflows/ros_lyrical.yaml/badge.svg)](https://github.com/PRBonn/rko_slam/actions/workflows/ros_lyrical.yaml) [![Rolling](https://github.com/PRBonn/rko_slam/actions/workflows/ros_rolling.yaml/badge.svg)](https://github.com/PRBonn/rko_slam/actions/workflows/ros_rolling.yaml) [![Docs](https://img.shields.io/badge/docs-prbonn.github.io-blue)](https://prbonn.github.io/rko_slam/) [![GitHub License](https://img.shields.io/github/license/PRBonn/rko_slam)](/LICENSE) [![GitHub last commit](https://img.shields.io/github/last-commit/PRBonn/rko_slam)](/)

A 3 km drive with the odometry alone, and with rko_slam running on top of it
A 3 km drive that ends where it started, with rko_lio, and with rko_slam running on top of it

rko_slam is a ROS2 LiDAR-inertial SLAM system. It runs on top of a LiDAR-inertial odometry. An odometry tells you how you moved, and over a long enough run its estimate drifts: come back to a place you have been before and the two visits do not land on the same spot. rko_slam runs next to the odometry, uses the LiDAR and IMU, recognizes the revisit, and corrects the whole trajectory behind you. You keep the odometry as it is, and you additionally get a map <- odom correction on TF, a pose graph, and the sub-maps the system built along the way.

The odometry it assumes by default is rko_lio, my LiDAR-inertial odometry package, which is also a build dependency. At run time any odometry that publishes odom <- base on TF and is locally consistent will do - LiDAR-only odometry, wheel odometry, whatever you already run. The IMU is optional as well: leave imu_topic unset and rko_slam runs on the LiDAR alone.

The same revisit detector works across runs, not just within one, as an offline step. Give it the run directories of several sessions of the same place - different days, different directions, whatever - and it finds where they overlap and solves all of them into one frame.

Three sessions of the same place, each in its own frame, and in one frame after alignment
Three sessions of the same place, recorded on different days, and the one frame they end up in

Documentation is at prbonn.github.io/rko_slam.

Build

Supported distros: Jazzy, Kilted, Lyrical, Rolling.

For now, rko_lio has to be built in the same workspace.

cd <ws>/src
git clone https://github.com/PRBonn/rko_lio
git clone https://github.com/PRBonn/rko_slam
cd <ws> && rosdep install --from-paths src --ignore-src -y
colcon build --packages-select rko_lio rko_slam

apt installs will be supported, same as with rko_lio. Dependencies and build options are covered in the docs.

Usage

Three entrypoints: slam.launch.py (mode:=online|offline), odometry_and_slam.launch.py, and align.launch.py. -s lists every parameter with its documentation, and anything you leave unset keeps the node’s own default.

Online, next to a running rko_lio, consuming its deskewed scan:

ros2 launch rko_slam slam.launch.py lidar_topic:=/rko_lio/deskewed_scan imu_topic:=/your/imu rviz:=true

Offline, self-draining a bag, with the odometry from the bag’s own /tf, and writing the run to disk:

ros2 launch rko_slam slam.launch.py mode:=offline bag_path:=/data/my_bag \
  lidar_topic:=/rko_lio/deskewed_scan imu_topic:=/your/imu dump_results:=true

Multi-session alignment of the run directories those runs wrote:

ros2 launch rko_slam align.launch.py run_dirs:="[results/run_1, results/run_2]"

Running with another odometry, running rko_lio alongside with odometry_and_slam.launch.py, taking the odometry from a TUM file, what a run writes to disk, every parameter and what it does, and how the system works are all in the docs.

Acknowledgments and Citation

This work was developed as part of my thesis (published soon), and much of it is inspired by KISS-SLAM - the initial version was essentially a reimplementation for ROS2.

File truncated at 100 lines see the full file

No version for distro kinetic showing jazzy. Known supported distros are highlighted in the buttons above.
Repo symbol

rko_slam repository

rko_slam

ROS Distro
jazzy

Repository Summary

Checkout URI https://github.com/PRBonn/rko_slam.git
VCS Type git
VCS Version master
Last Updated 2026-09-25
Dev Status DEVELOPED
Released UNRELEASED
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

Packages

Name Version
rko_slam 0.0.1

README

rko_slam

ROS2 LiDAR-inertial SLAM for your odometry: drift correction and multi-session alignment

[![Jazzy](https://github.com/PRBonn/rko_slam/actions/workflows/ros_jazzy.yaml/badge.svg)](https://github.com/PRBonn/rko_slam/actions/workflows/ros_jazzy.yaml) [![Kilted](https://github.com/PRBonn/rko_slam/actions/workflows/ros_kilted.yaml/badge.svg)](https://github.com/PRBonn/rko_slam/actions/workflows/ros_kilted.yaml) [![Lyrical](https://github.com/PRBonn/rko_slam/actions/workflows/ros_lyrical.yaml/badge.svg)](https://github.com/PRBonn/rko_slam/actions/workflows/ros_lyrical.yaml) [![Rolling](https://github.com/PRBonn/rko_slam/actions/workflows/ros_rolling.yaml/badge.svg)](https://github.com/PRBonn/rko_slam/actions/workflows/ros_rolling.yaml) [![Docs](https://img.shields.io/badge/docs-prbonn.github.io-blue)](https://prbonn.github.io/rko_slam/) [![GitHub License](https://img.shields.io/github/license/PRBonn/rko_slam)](/LICENSE) [![GitHub last commit](https://img.shields.io/github/last-commit/PRBonn/rko_slam)](/)

A 3 km drive with the odometry alone, and with rko_slam running on top of it
A 3 km drive that ends where it started, with rko_lio, and with rko_slam running on top of it

rko_slam is a ROS2 LiDAR-inertial SLAM system. It runs on top of a LiDAR-inertial odometry. An odometry tells you how you moved, and over a long enough run its estimate drifts: come back to a place you have been before and the two visits do not land on the same spot. rko_slam runs next to the odometry, uses the LiDAR and IMU, recognizes the revisit, and corrects the whole trajectory behind you. You keep the odometry as it is, and you additionally get a map <- odom correction on TF, a pose graph, and the sub-maps the system built along the way.

The odometry it assumes by default is rko_lio, my LiDAR-inertial odometry package, which is also a build dependency. At run time any odometry that publishes odom <- base on TF and is locally consistent will do - LiDAR-only odometry, wheel odometry, whatever you already run. The IMU is optional as well: leave imu_topic unset and rko_slam runs on the LiDAR alone.

The same revisit detector works across runs, not just within one, as an offline step. Give it the run directories of several sessions of the same place - different days, different directions, whatever - and it finds where they overlap and solves all of them into one frame.

Three sessions of the same place, each in its own frame, and in one frame after alignment
Three sessions of the same place, recorded on different days, and the one frame they end up in

Documentation is at prbonn.github.io/rko_slam.

Build

Supported distros: Jazzy, Kilted, Lyrical, Rolling.

For now, rko_lio has to be built in the same workspace.

cd <ws>/src
git clone https://github.com/PRBonn/rko_lio
git clone https://github.com/PRBonn/rko_slam
cd <ws> && rosdep install --from-paths src --ignore-src -y
colcon build --packages-select rko_lio rko_slam

apt installs will be supported, same as with rko_lio. Dependencies and build options are covered in the docs.

Usage

Three entrypoints: slam.launch.py (mode:=online|offline), odometry_and_slam.launch.py, and align.launch.py. -s lists every parameter with its documentation, and anything you leave unset keeps the node’s own default.

Online, next to a running rko_lio, consuming its deskewed scan:

ros2 launch rko_slam slam.launch.py lidar_topic:=/rko_lio/deskewed_scan imu_topic:=/your/imu rviz:=true

Offline, self-draining a bag, with the odometry from the bag’s own /tf, and writing the run to disk:

ros2 launch rko_slam slam.launch.py mode:=offline bag_path:=/data/my_bag \
  lidar_topic:=/rko_lio/deskewed_scan imu_topic:=/your/imu dump_results:=true

Multi-session alignment of the run directories those runs wrote:

ros2 launch rko_slam align.launch.py run_dirs:="[results/run_1, results/run_2]"

Running with another odometry, running rko_lio alongside with odometry_and_slam.launch.py, taking the odometry from a TUM file, what a run writes to disk, every parameter and what it does, and how the system works are all in the docs.

Acknowledgments and Citation

This work was developed as part of my thesis (published soon), and much of it is inspired by KISS-SLAM - the initial version was essentially a reimplementation for ROS2.

File truncated at 100 lines see the full file

No version for distro melodic showing jazzy. Known supported distros are highlighted in the buttons above.
Repo symbol

rko_slam repository

rko_slam

ROS Distro
jazzy

Repository Summary

Checkout URI https://github.com/PRBonn/rko_slam.git
VCS Type git
VCS Version master
Last Updated 2026-09-25
Dev Status DEVELOPED
Released UNRELEASED
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

Packages

Name Version
rko_slam 0.0.1

README

rko_slam

ROS2 LiDAR-inertial SLAM for your odometry: drift correction and multi-session alignment

[![Jazzy](https://github.com/PRBonn/rko_slam/actions/workflows/ros_jazzy.yaml/badge.svg)](https://github.com/PRBonn/rko_slam/actions/workflows/ros_jazzy.yaml) [![Kilted](https://github.com/PRBonn/rko_slam/actions/workflows/ros_kilted.yaml/badge.svg)](https://github.com/PRBonn/rko_slam/actions/workflows/ros_kilted.yaml) [![Lyrical](https://github.com/PRBonn/rko_slam/actions/workflows/ros_lyrical.yaml/badge.svg)](https://github.com/PRBonn/rko_slam/actions/workflows/ros_lyrical.yaml) [![Rolling](https://github.com/PRBonn/rko_slam/actions/workflows/ros_rolling.yaml/badge.svg)](https://github.com/PRBonn/rko_slam/actions/workflows/ros_rolling.yaml) [![Docs](https://img.shields.io/badge/docs-prbonn.github.io-blue)](https://prbonn.github.io/rko_slam/) [![GitHub License](https://img.shields.io/github/license/PRBonn/rko_slam)](/LICENSE) [![GitHub last commit](https://img.shields.io/github/last-commit/PRBonn/rko_slam)](/)

A 3 km drive with the odometry alone, and with rko_slam running on top of it
A 3 km drive that ends where it started, with rko_lio, and with rko_slam running on top of it

rko_slam is a ROS2 LiDAR-inertial SLAM system. It runs on top of a LiDAR-inertial odometry. An odometry tells you how you moved, and over a long enough run its estimate drifts: come back to a place you have been before and the two visits do not land on the same spot. rko_slam runs next to the odometry, uses the LiDAR and IMU, recognizes the revisit, and corrects the whole trajectory behind you. You keep the odometry as it is, and you additionally get a map <- odom correction on TF, a pose graph, and the sub-maps the system built along the way.

The odometry it assumes by default is rko_lio, my LiDAR-inertial odometry package, which is also a build dependency. At run time any odometry that publishes odom <- base on TF and is locally consistent will do - LiDAR-only odometry, wheel odometry, whatever you already run. The IMU is optional as well: leave imu_topic unset and rko_slam runs on the LiDAR alone.

The same revisit detector works across runs, not just within one, as an offline step. Give it the run directories of several sessions of the same place - different days, different directions, whatever - and it finds where they overlap and solves all of them into one frame.

Three sessions of the same place, each in its own frame, and in one frame after alignment
Three sessions of the same place, recorded on different days, and the one frame they end up in

Documentation is at prbonn.github.io/rko_slam.

Build

Supported distros: Jazzy, Kilted, Lyrical, Rolling.

For now, rko_lio has to be built in the same workspace.

cd <ws>/src
git clone https://github.com/PRBonn/rko_lio
git clone https://github.com/PRBonn/rko_slam
cd <ws> && rosdep install --from-paths src --ignore-src -y
colcon build --packages-select rko_lio rko_slam

apt installs will be supported, same as with rko_lio. Dependencies and build options are covered in the docs.

Usage

Three entrypoints: slam.launch.py (mode:=online|offline), odometry_and_slam.launch.py, and align.launch.py. -s lists every parameter with its documentation, and anything you leave unset keeps the node’s own default.

Online, next to a running rko_lio, consuming its deskewed scan:

ros2 launch rko_slam slam.launch.py lidar_topic:=/rko_lio/deskewed_scan imu_topic:=/your/imu rviz:=true

Offline, self-draining a bag, with the odometry from the bag’s own /tf, and writing the run to disk:

ros2 launch rko_slam slam.launch.py mode:=offline bag_path:=/data/my_bag \
  lidar_topic:=/rko_lio/deskewed_scan imu_topic:=/your/imu dump_results:=true

Multi-session alignment of the run directories those runs wrote:

ros2 launch rko_slam align.launch.py run_dirs:="[results/run_1, results/run_2]"

Running with another odometry, running rko_lio alongside with odometry_and_slam.launch.py, taking the odometry from a TUM file, what a run writes to disk, every parameter and what it does, and how the system works are all in the docs.

Acknowledgments and Citation

This work was developed as part of my thesis (published soon), and much of it is inspired by KISS-SLAM - the initial version was essentially a reimplementation for ROS2.

File truncated at 100 lines see the full file

No version for distro noetic showing jazzy. Known supported distros are highlighted in the buttons above.
Repo symbol

rko_slam repository

rko_slam

ROS Distro
jazzy

Repository Summary

Checkout URI https://github.com/PRBonn/rko_slam.git
VCS Type git
VCS Version master
Last Updated 2026-09-25
Dev Status DEVELOPED
Released UNRELEASED
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

Packages

Name Version
rko_slam 0.0.1

README

rko_slam

ROS2 LiDAR-inertial SLAM for your odometry: drift correction and multi-session alignment

[![Jazzy](https://github.com/PRBonn/rko_slam/actions/workflows/ros_jazzy.yaml/badge.svg)](https://github.com/PRBonn/rko_slam/actions/workflows/ros_jazzy.yaml) [![Kilted](https://github.com/PRBonn/rko_slam/actions/workflows/ros_kilted.yaml/badge.svg)](https://github.com/PRBonn/rko_slam/actions/workflows/ros_kilted.yaml) [![Lyrical](https://github.com/PRBonn/rko_slam/actions/workflows/ros_lyrical.yaml/badge.svg)](https://github.com/PRBonn/rko_slam/actions/workflows/ros_lyrical.yaml) [![Rolling](https://github.com/PRBonn/rko_slam/actions/workflows/ros_rolling.yaml/badge.svg)](https://github.com/PRBonn/rko_slam/actions/workflows/ros_rolling.yaml) [![Docs](https://img.shields.io/badge/docs-prbonn.github.io-blue)](https://prbonn.github.io/rko_slam/) [![GitHub License](https://img.shields.io/github/license/PRBonn/rko_slam)](/LICENSE) [![GitHub last commit](https://img.shields.io/github/last-commit/PRBonn/rko_slam)](/)

A 3 km drive with the odometry alone, and with rko_slam running on top of it
A 3 km drive that ends where it started, with rko_lio, and with rko_slam running on top of it

rko_slam is a ROS2 LiDAR-inertial SLAM system. It runs on top of a LiDAR-inertial odometry. An odometry tells you how you moved, and over a long enough run its estimate drifts: come back to a place you have been before and the two visits do not land on the same spot. rko_slam runs next to the odometry, uses the LiDAR and IMU, recognizes the revisit, and corrects the whole trajectory behind you. You keep the odometry as it is, and you additionally get a map <- odom correction on TF, a pose graph, and the sub-maps the system built along the way.

The odometry it assumes by default is rko_lio, my LiDAR-inertial odometry package, which is also a build dependency. At run time any odometry that publishes odom <- base on TF and is locally consistent will do - LiDAR-only odometry, wheel odometry, whatever you already run. The IMU is optional as well: leave imu_topic unset and rko_slam runs on the LiDAR alone.

The same revisit detector works across runs, not just within one, as an offline step. Give it the run directories of several sessions of the same place - different days, different directions, whatever - and it finds where they overlap and solves all of them into one frame.

Three sessions of the same place, each in its own frame, and in one frame after alignment
Three sessions of the same place, recorded on different days, and the one frame they end up in

Documentation is at prbonn.github.io/rko_slam.

Build

Supported distros: Jazzy, Kilted, Lyrical, Rolling.

For now, rko_lio has to be built in the same workspace.

cd <ws>/src
git clone https://github.com/PRBonn/rko_lio
git clone https://github.com/PRBonn/rko_slam
cd <ws> && rosdep install --from-paths src --ignore-src -y
colcon build --packages-select rko_lio rko_slam

apt installs will be supported, same as with rko_lio. Dependencies and build options are covered in the docs.

Usage

Three entrypoints: slam.launch.py (mode:=online|offline), odometry_and_slam.launch.py, and align.launch.py. -s lists every parameter with its documentation, and anything you leave unset keeps the node’s own default.

Online, next to a running rko_lio, consuming its deskewed scan:

ros2 launch rko_slam slam.launch.py lidar_topic:=/rko_lio/deskewed_scan imu_topic:=/your/imu rviz:=true

Offline, self-draining a bag, with the odometry from the bag’s own /tf, and writing the run to disk:

ros2 launch rko_slam slam.launch.py mode:=offline bag_path:=/data/my_bag \
  lidar_topic:=/rko_lio/deskewed_scan imu_topic:=/your/imu dump_results:=true

Multi-session alignment of the run directories those runs wrote:

ros2 launch rko_slam align.launch.py run_dirs:="[results/run_1, results/run_2]"

Running with another odometry, running rko_lio alongside with odometry_and_slam.launch.py, taking the odometry from a TUM file, what a run writes to disk, every parameter and what it does, and how the system works are all in the docs.

Acknowledgments and Citation

This work was developed as part of my thesis (published soon), and much of it is inspired by KISS-SLAM - the initial version was essentially a reimplementation for ROS2.

File truncated at 100 lines see the full file