ROS 2 documentation Logo
  • About ROS
  • Get started
    • Installation
      • Installing on Ubuntu - how-to
      • Installing on Windows (binary) - how-to
      • Installing on RHEL / Fedora (RPM packages) - how-to
      • Advanced installation options
        • Installing on Ubuntu (source) - how-to
        • Installing on Ubuntu (source Pixi) - how-to
        • Installing on Ubuntu (binary) - how-to
        • Installing on Windows (source) - how-to
        • Installing on RHEL (source) - how-to
        • Installing on RHEL (binary) - how-to
        • Installing on macOS (source) - how-to
        • Installing latest development (source) - how-to
        • Maintaining source checkout - how-to
      • RMW implementations
        • DDS implementations
          • Working with Eclipse Cyclone DDS - how-to
          • Working with GurumNetworks GurumDDS - how-to
          • Working with RTI Connext DDS - how-to
          • Working with eProsima Fast DDS - how-to
        • Non-DDS-Implementations
          • Working with Zenoh - how-to
        • Working with multiple ROS 2 middleware implementations - how-to
      • Mirrors
      • Installing from the snapshot repository
      • Installing ROS 2 on Raspberry Pi - how-to
      • Troubleshooting installation - how-to
    • First steps with ROS - learning path
    • Setting up your environment - how-to
    • Setting up Turtlesim - how-to
    • Glossary
  • Distributions
    • Development process for a release
    • Lyrical Luth (codename ‘lyrical’; May, 2026)
      • ROS 2 Lyrical Luth Complete Changelog
      • Lyrical Luth Release Timeline
      • Lyrical Luth Supported Platforms
    • Kilted Kaiju (codename ‘kilted’; May, 2025)
      • ROS 2 Kilted Kaiju Complete Changelog
    • Jazzy Jalisco (jazzy)
      • Jazzy Jalisco changelog
    • Humble Hawksbill (humble)
      • Humble Hawksbill changelog
    • Rolling Ridley (rolling)
    • Development Distribution
      • Makoa Mata-mata (codename makoa; May, 2027)
        • Makoa Mata-mata Release Timeline
        • Makoa Mata-mata Supported Platforms
    • End-of-Life Distributions
      • Iron Irwini (iron)
        • Iron Irwini Changelog
      • Galactic Geochelone (galactic)
        • Galactic Geochelone changelog
      • Foxy Fitzroy (foxy)
      • Eloquent Elusor (eloquent)
      • Dashing Diademata (dashing)
      • Crystal Clemmys (crystal)
      • Bouncy Bolson (bouncy)
      • Ardent Apalone (ardent)
      • Beta 3 (r2b3)
      • Beta 2 (r2b2)
      • Beta 1 (Asphalt)
      • Alphas
  • Framework
    • How ROS works
    • Nodes
      • Discovery
      • The ROS_DOMAIN_ID
      • Logging
      • Composition
      • Working with nodes
        • Learning about nodes - tutorial
        • Using rqt_console to view logs - tutorial
        • Launching multiple nodes — tutorial - how-to
        • Writing a Composable Node (C++) — tutorial
        • Composing multiple nodes in a single process — tutorial
        • Using the Node Interfaces Template Class (C++) — tutorial
        • Summary
        • Using Subordinate Nodes (C++) — tutorial
        • Managing node lifecycles - example
        • Setting up efficient intra-process communication — tutorial
        • Using Callback Groups — how-to
        • Writing an async node with asyncio (Python) - tutorial
    • Interfaces (topics, services, actions)
      • Interfaces
        • Topics vs Services vs Actions
        • Tf2
        • Working with interfaces
          • Recording and playing back data — tutorial
          • Introducing tf2 — tutorial
          • Quaternion fundamentals — tutorial
          • About rosidl::Buffer backends
            • Using rosidl::Buffer backends - how-to
            • Transporting GPU buffers with rosidl::Buffer - tutorial
            • Writing a rosidl::Buffer backend - tutorial
            • Writing a rosidl::Buffer compatible conversions package - tutorial
      • Topics
        • Learning about topics - tutorial
        • Quality of Service settings
        • Topic statistics
        • Working with topics
          • Topic Keys — tutorial
          • Topic Keys Subscription Filtering — tutorial
          • Creating a content filtering subscription — tutorial
          • Using quality-of-service settings for lossy networks — tutorial
          • Configuring QoS overrides using parameters — tutorial
          • Wait for acknowledgment — tutorial
      • Services
        • Working with services
          • Learning about services - tutorial
          • Synchronous vs. asynchronous service clients — tutorial
      • Actions
        • Working with actions
          • Learning about actions - tutorial
          • Configure action introspection — tutorial
          • Creating an action — tutorial
          • Writing an action server and client (C++) — tutorial
          • Writing an action server and client (Python) — tutorial
    • Parameters
      • Working with parameters - how-to
        • Learning about parameters - tutorial
        • Using the ros2 param command-line tool — how-to
        • Monitoring for parameter changes (Python) — tutorial
        • Monitoring for parameter changes (C++) — tutorial
    • Client libraries
      • Different ROS 2 middleware vendors
      • Executors
      • Internal ROS 2 interfaces
      • ROS 2 middleware implementations
      • Working with Client libraries
        • Using colcon to build packages — tutorial
        • Creating a workspace — tutorial
        • Creating a package — tutorial
        • Writing a simple publisher and subscriber (C++) — tutorial
        • Writing a simple publisher and subscriber (Python) — tutorial
        • Writing a simple service and client (C++) — tutorial
        • Writing a simple service and client (Python) — tutorial
        • Creating custom msg and srv files — tutorial
        • Implementing custom interfaces — tutorial
        • Using parameters in a class (C++) — tutorial
        • Using parameters in a class (Python) — tutorial
        • Using ros2doctor to identify issues — tutorial
        • Creating and using plugins (C++) — tutorial
        • Managing Dependencies with rosdep — tutorial
        • tf2 — learning path
          • Writing a static broadcaster (Python) — tutorial
          • Writing a static broadcaster (C++) — tutorial
          • Writing a broadcaster (Python) — tutorial
          • Writing a broadcaster (C++) — tutorial
          • Writing a listener (Python) — tutorial
          • Writing a listener (C++) — tutorial
          • Adding a frame (Python) — tutorial
          • Adding a frame (C++) — tutorial
          • Using time (C++) — tutorial
          • Traveling in time (C++) — tutorial
          • Using stamped datatypes with tf2_ros::MessageFilter — tutorial
        • Implementing a custom memory allocator — tutorial
        • Recording a bag from a node (C++) — tutorial
        • Recording a bag from a node (Python) — tutorial
        • Reading from a bag file (C++) — tutorial
        • Reading from a bag file (Python) — tutorial
        • Creating an rmw implementation — tutorial
        • Configure Zero Copy Loaned Messages — how-to
  • Tools
    • Introspection and analysis
      • Introspection with command line tools
      • Publishing messages using YAML files - tutorial
      • Enabling topic statistics (C++) - tutorial
      • Using ros2_tracing to trace and analyze an application - tutorial
      • Logging
      • Configuring service introspection - tutorial
      • Examining network traffic - tutorial
    • Node management
      • Using ROS launch to launch composable nodes - how to
      • Creating a launch file - tutorial
      • Working with launch files - tutorial
        • Creating a launch file - tutorial
        • Integrating launch files into ROS 2 packages - tutorial
        • Using substitutions - tutorial
        • Using event handlers - tutorial
        • Managing large projects - tutorial
      • Using event handlers - tutorial
      • Managing large projects - tutorial
      • Using substitutions - tutorial
      • Using XML, YAML, and Python for ROS Launch Files - how-to
      • Integrating launch files into ROS 2 packages - tutorial
      • Unlocking the potential of Fast DDS middleware [community-contributed] - tutorial
      • Using Improved Dynamic Discovery - tutorial
      • Passing ROS arguments to nodes via the command-line - how-to
      • Using Fast DDS Discovery Server as discovery protocol [community-contributed] - tutorial
      • ROS 2 Security
        • Setting up security - tutorial
        • Ensuring security across machines - tutorial
        • Setting access controls - tutorial
    • Debugging
      • Debugging - tutorial
      • Debugging with IDEs [community-contributed] - how-to
      • Getting Backtraces in ROS 2 - how-to
      • Building ROS 2 with tracing - how-to
      • Testing - tutorial
        • Running Tests in ROS 2 from the Command Line - how-to
        • Writing Basic Tests with C++ with GTest - tutorial
        • Writing Basic Tests with Python - tutorial
        • Writing Basic Integration Tests with launch_testing - tutorial
        • Testing Your Code with the ROS Build Farm - tutorial
        • rosbag2: Overriding Quality of Service (QoS) Policies - how-to
        • Testing with pre-release binaries
    • Builds
      • Cross-compilation
      • The build system
      • Understanding security-enabled deployments - tutorial
      • Understanding the security keystore - tutorial
      • Using Xacro to clean up your code - tutorial
      • Supplementing custom rosdep keys - tutorial
      • Using ament Lint CLI Utilities - tutorial
      • Using Eclipse Oxygen with rviz2 [community-contributed] - tutorial
      • Building ROS packages with ament_cmake - how-to
      • Using ament_cmake_python - how-to
      • Building a custom deb package - how-to
      • Running ROS 2 nodes in Docker [community-contributed] - how-to
      • Setting up ROS with VSCode and Docker [community-contributed] - how-to
      • Maintaining ROS Core Packages - how-to
      • Addressing common DDS tuning issues - how-to
      • Using variants - how-to
      • Finding package documentation
      • Using Python Packages with ROS 2 - how-to
      • Developing a ROS package - tutorial
      • Releasing a Package
        • Indexing Your Packages - how-to
        • Releasing first-time packages - how-to
        • Releasing subsequent package versions - how to
        • Release Team / Repository - how-to
        • Creating release track prompts - how-to
      • Building a real-time Linux kernel [community-contributed] - tutorial
      • Building a package with Eclipse 2021-06 - tutorial
      • Implementing custom interfaces - how-to
    • Visualization
      • RViz
        • Using RViz - tutorial
        • Marker: Sending Basic Shapes (C++) - tutorial
        • Using Marker Points and Lines (C++) - tutorial
        • Using Marker Display Types - tutorial
        • Building a Custom RViz Display - tutorial
        • Building a Custom RViz Panel - tutorial
      • Overview and using RQt
      • Creating an rqt_bag Plugin - tutorial
    • Package documentation
      • Documenting a ROS 2 package - how-to
  • Capabilities
    • Simulation
      • URDF
        • Building a visual robot model from scratch — tutorial
        • Building a movable robot model — tutorial
        • Adding physical and collision properties — tutorial
        • Using URDF with robot_state_publisher (C++) — tutorial
        • Using URDF with robot_state_publisher (Python) — tutorial
        • Generating an URDF File — tutorial
      • Experimenting with a dummy robot — tutorial
    • Motion planning and manipulation
      • Understanding real-time programming — tutorial
    • Navigation
    • Perception
  • Integrations
    • Configuring simulators with ROS 2 - learning path
      • Configuring Webots with ROS 2 - tutorial
        • Installing Webots on Ubuntu - tutorial
        • Installing Webots on Windows - tutorial
        • Installing Webots on macOS - tutorial
        • Setting up a robot simulation (Basic) - tutorial
        • Setting up a robot simulation (Advanced) - tutorial
        • Setting up a Reset Handler - tutorial
        • Extending the interface with the Ros2Supervisor node - tutorial
      • Configuring Gazebo with ROS 2 - tutorial
        • Setting up a robot simulation (Gazebo) - tutorial
      • Configuring MVSim with ROS 2 - tutorial
        • Installing MVSim on Ubuntu - tutorial
        • Getting started with MVSim - tutorial
        • Defining worlds, robots, and sensors - tutorial
    • Deploying on IBM Cloud Kubernetes [community-contributed] - tutorial
    • Related projects
      • Intel ROS 2 Projects
      • NVIDIA ROS 2 Projects
      • Visualizing Data and Teleoperating with Phantom Bridge
      • Visualizing ROS 2 data with Foxglove
  • Migration and upgrades
    • Migrating from ROS 1 to ROS 2
      • Migrating Packages
      • Migrating your package.xml to format 2
      • Migrating Interfaces
      • Migrating a C++ Package Example
      • Migrating C++ Packages Reference
      • Migrating a Python Package Example
      • Migrating Python Packages Reference
      • Migrating Launch Files
      • Migrating Parameters
      • Migrating Scripts
    • Using ros1_bridge with upstream ROS on Ubuntu 22.04 - how-to
    • Using a custom rosdistro version - how-to
  • Community
    • Contributing
      • Contributing to code
        • Source control best practices
        • ROS build farms
        • Code style and language versions
        • Code quality guidelines
        • Working with Windows - how to
      • Contributing to documentation
        • Creating or updating documentation — how-to
        • Documentation guidelines
      • Reviewing a pull request (PR) — how-to
      • Making a pull request (PR) — how-to
      • Triaging an issue — how-to
      • Reporting an issue — how-to
    • Features status
    • Feature ideas
    • Roadmap
    • ROSCon talks
    • Project governance
    • Platform EOL policy
    • Platform support tiers
    • Release Schedule
    • Marketing
    • Metrics
    • ROS 2 adopters
      • Add Your Project
  • Contact
  • Citations
  • Contributing to ROS
ROS 2 documentation
  • Integrations
  • Related projects
  • Edit on GitHub

Related projects

Beyond the core stack, many community and company projects extend ROS for simulation, navigation, manipulation, and more. This article surveys major related projects and points to further discovery resources such as the ROS Index.

Area: framework | Content type: about | Level: TBD

Contents

  • Gazebo

  • Large Community Projects

  • Community rosidl::Buffer backends

  • Further Community Projects

  • Company-driven Projects

Gazebo

Gazebo (gazebosim.org) and its predecessor Gazebo Classic are the first open source choice for 3D physics simulation of ROS-based robots.

Large Community Projects

Large community projects involve multiple developers from all over the globe and are typically backed by a dedicated working group (cf. Project governance).

  • ros2_control (control.ros.org): Flexible framework for real-time control of robots implemented with ROS 2.

  • Navigation2 (nav2.org): Comprehensive and flexible navigation stack for mobile robots using ROS 2.

  • MoveIt (moveit.ai): A rich platform for building manipulation applications featuring advanced kinematics, motion planning, control, collision checking, and much more.

  • micro-ROS (micro.ros.org): A platform for putting ROS 2 onto microcontrollers, starting at less than 100 kB of RAM.

Community rosidl::Buffer backends

Out-of-tree buffer backend plugins let rosidl::Buffer fields (uint8[], etc.) use vendor-specific memory domains such as GPU memory. For background, see Using rosidl::Buffer backends - how-to and Writing a rosidl::Buffer backend - tutorial.

  • rosidl_buffer_backends (github.com/ros2/rosidl_buffer_backends): CUDA buffer backend implementation for rosidl::Buffer plus tensor_msgs/msg/ExperimentalTensor and torch_conversions helpers, enabling zero-copy GPU memory sharing between ROS 2 publishers and subscribers.

  • rosidl_buffer_backends_tutorials (github.com/ros2/rosidl_buffer_backends_tutorials): End-to-end demos exercising rosidl_buffer_backends, including the robot_arm_demo featured in Transporting GPU buffers with rosidl::Buffer - tutorial.

Further Community Projects

The global ROS community develops and maintains hundreds of further packages on top of the core ROS 2 stack. Some of them come with their own websites for documentation. Your best entry point to discover these works is the ROS Index (index.ros.org).

Hint for developers: If you maintain a README.md file in the root of your package folder (which is not necessarily the root of your repository), this file is rendered into the overview page of your package at index.ros.org. The file may be used for documenting your package and supersedes the package documentation pages in the ROS Wiki from ROS 1. See the fmi_adapter package as an example.

Company-driven Projects

  • Intel ROS 2 Projects
  • NVIDIA ROS 2 Projects
  • Visualizing Data and Teleoperating with Phantom Bridge
  • Visualizing ROS 2 data with Foxglove
Previous Next

© Copyright 2026, Open Robotics.

Built with Sphinx using a theme provided by Read the Docs.