An open-source Autonomous Mobile Robot simulation stack for ROS 2 Jazzy and Gazebo Harmonic.

Watch the demo video

rbot is a simulation-first Autonomous Mobile Robot (AMR) reference stack for ROS 2 Jazzy and Gazebo Harmonic. It combines robot description, Gazebo simulation, ros2_control, teleoperation, sensor simulation, localization, mapping, and Nav2 navigation in one ROS 2 workspace.

The project is for ROS users, students, and robotics teams that need a practical AMR baseline to run, inspect, and adapt. Its value is in the integration: a current ROS 2 workspace, Docker-first workflows, modern Nav2 configuration, and documentation that follows the full mapping-to-navigation path.

Gazebo Harmonic is the supported simulator. Isaac Sim packages are present as scaffolding for planned future integration.

rbot packages the AMR simulation path into one workspace: a Gazebo Harmonic robot model, ROS-Gazebo bridges, ros2_control, teleoperation, sensor topics, EKF localization, SLAM Toolbox mapping, AMCL, and Nav2.

Use these commands for a mapping and autonomous navigation loop.

Prerequisites: Docker with Compose support. For RViz on Linux, make sure X11 forwarding is available.

1. Start mapping with RViz:

   bash scripts/run_sim.sh --headless --rviz-mapping

   • Drive the robot through the map with teleop (next command).
   • See Run mapping with SLAM Toolbox for how to save the map.

2. Start teleop:

   docker compose -f docker/docker-compose.yml run --rm teleop

   • Use the joystick or keyboard controls to cover open aisles, corners, and doorways.

3. Start navigation with RViz:

   bash scripts/run_sim.sh --headless --rviz-nav --map /ros2_ws/maps/my_map.yaml

   • In RViz2, use Set Initial Pose from the top panel to align AMCL with the robot.
   • Use Nav2 Goal from the top panel to send the robot to a target pose.

rbot/
├── .devcontainer/        # VS Code Dev Container setup
├── .github/workflows/    # CI build, lint, and test workflow
├── docker/               # Dockerfiles, compose services, entrypoint
├── docs/                 # Architecture notes, sensor docs, tutorials
├── maps/                 # Example occupancy maps and metadata
├── scripts/              # Build, dependency, simulation, and mesh helpers
└── src/
    ├── bringup/          # Top-level simulation launch orchestration
    ├── control/          # ros2_control and teleoperation packages
    ├── localization/     # EKF and AMCL launch/config packages
    ├── mapping/          # SLAM Toolbox launch/config packages
    ├── navigation/       # Nav2 launch, params, behavior trees, client
    ├── perception/       # LiDAR and camera processing packages
    ├── robot/            # Robot description and mesh packages
    ├── simulation/       # Gazebo packages and Isaac scaffolding
    └── utils/            # Shared utility package placeholder

Docker is the recommended path for first-time users because it keeps ROS, Gazebo, and system dependencies isolated.

Install Docker with Compose support. For GUI simulation on Linux, make sure X11 forwarding is available.

bash scripts/run_sim.sh

Useful variants:

bash scripts/run_sim.sh --headless
bash scripts/run_sim.sh --rviz
bash scripts/run_sim.sh --rviz-nav
bash scripts/run_sim.sh --headless --rviz-nav --map /ros2_ws/maps/my_map.yaml
bash scripts/run_sim.sh --headless --rviz-mapping
bash scripts/run_sim.sh --headless world:=large_warehouse gps_enabled:=true

The script starts services from docker/docker-compose.yml and launches the simulation stack inside the container. Use --map with --rviz-nav when AMCL/Nav2 should localize against a specific map YAML mounted under /ros2_ws/maps/.

Extra arguments after the script flags are forwarded to the simulation launch service. Pass them as standard whitespace-free ROS launch tokens such as name:=value.

zsh scripts/sim_docker.sh
zsh scripts/sim_docker.sh --headless
zsh scripts/sim_docker.sh --shell
zsh scripts/sim_docker.sh world:=large_warehouse

Use this helper when you want direct docker run style control or an interactive shell in the simulation image.

Native setup is useful when you already work in a ROS 2 Jazzy environment.

bash scripts/install_deps.sh
bash scripts/build.sh
source install/setup.bash
ros2 launch rlai_bringup simulation.launch.py

To launch a specific world:

ros2 launch rlai_bringup simulation.launch.py world:=small_warehouse

Headless Gazebo:

ros2 launch rlai_bringup simulation.launch.py headless:=true

ros2 launch rlai_bringup simulation.launch.py localization_enabled:=true

This starts Gazebo, robot description publishing, ros2_control, and EKF localization.

ros2 launch rlai_bringup simulation.launch.py teleop_enabled:=true

The joystick configuration lives in:

src/control/rlai_teleop/config/joystick.yaml

The convenience software stop service is available at:

ros2 service call /e_stop std_srvs/srv/Trigger {}

This service publishes zero velocity commands while engaged.

ros2 launch rlai_bringup simulation.launch.py \
  mapping_enabled:=true \
  slam_rviz_enabled:=true

Save the map from the mapping container when coverage looks good. When launched through the quick path, the mapping container is named rlai_sim_mapping:

docker exec -it rlai_sim_mapping ros2 run nav2_map_server map_saver_cli -f /ros2_ws/maps/my_map

Do not enable mapping_enabled:=true and use_amcl:=true at the same time. Both publish map -> odom.

ros2 launch rlai_bringup simulation.launch.py \
  use_amcl:=true \
  map_yaml_file:=/absolute/path/to/map.yaml

Example maps are stored in maps/.

ros2 launch rlai_navigation navigation.launch.py \
  map:=/absolute/path/to/map.yaml

Use this when localization is already running and you want to focus on Nav2 behavior.

ros2 run rlai_navigation nav_client --ros-args \
  -p x:=3.0 \
  -p y:=2.0 \
  -p yaw:=0.0

Patrol mode:

ros2 run rlai_navigation nav_client --ros-args -p mode:=patrol

The stack uses a standard mobile robot TF chain:

map -> odom -> base_footprint -> base_link -> sensor frames

Ownership is intentionally split:

• EKF publishes odom -> base_footprint.
• AMCL or SLAM Toolbox publishes map -> odom.
• Robot State Publisher publishes base_footprint -> base_link and sensor frames.

Avoid enabling multiple nodes that publish the same transform.

teleop / Nav2 -> /cmd_vel -> velocity_smoother -> /diff_drive_controller/cmd_vel

The stack uses TwistStamped commands because the Jazzy diff_drive_controller expects stamped velocity input. The software stop node also publishes to /cmd_vel; it is a convenience mechanism for simulation and development.

Gazebo topics are bridged through:

src/simulation/rlai_gazebo/config/ros_gz_bridge.yaml

/joint_states is intentionally not bridged because joint_state_broadcaster owns that ROS topic.

rbot builds on established ROS 2 projects and examples:

• ROS 2 Jazzy documentation
• Gazebo Harmonic documentation
• Nav2 documentation and tutorials
• SLAM Toolbox
• robot_localization
• ros2_control
• BCR Bot
• Linorobot2
• ROSNav

bash scripts/build.sh

Or manually:

source /opt/ros/jazzy/setup.bash
colcon build --symlink-install --cmake-args -DCMAKE_BUILD_TYPE=Release

source install/setup.bash
colcon test --event-handlers console_cohesion+ --return-code-on-test-failure
colcon test-result --verbose

flake8 src --max-line-length=100 --extend-ignore=E203 --exclude=__pycache__

python3 -m compileall -q src scripts

Allow local Docker containers to connect to your X server:

xhost +local:docker

Then rerun the simulation script.

Source the workspace after building:

source install/setup.bash

If using Docker, open a shell in the built container and source the installed workspace there.

Check that a valid map file was provided when use_amcl:=true:

ros2 launch rlai_bringup simulation.launch.py \
  use_amcl:=true \
  map_yaml_file:=/absolute/path/to/map.yaml

Make sure only one component publishes each transform:

• EKF: odom -> base_footprint
• AMCL or SLAM Toolbox: map -> odom
• Robot State Publisher: robot links and sensor frames

Do not run AMCL and SLAM mapping together unless you intentionally change TF ownership.

The Gazebo image installs ROS, Gazebo, Nav2, SLAM, perception, and control dependencies. The first build can take several minutes; later builds should reuse Docker layers.

Future extension points:

• Isaac Sim integration
• Expanded benchmarks and automated scenario tests
• Additional warehouse, outdoor, and mixed-layout environments
• More perception and autonomy examples

Contributions are welcome. Start with CONTRIBUTING.md for development workflow, coding standards, and pull request guidance.

Good first contributions include:

• Improving setup instructions or troubleshooting notes.
• Adding reproducible simulation scenarios.
• Tuning navigation, localization, or mapping configs with before/after evidence.
• Adding tests or validation scripts for launch files, URDF/Xacro, and Gazebo worlds.

This project is licensed under the Apache License 2.0.

Copyright 2026 Robolabs AI (RLXAI ROBOLABSAI PRIVATE LIMITED).