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
  • Capabilities
  • Navigation
  • Edit on GitHub

Navigation

Navigation capabilities enable a robot to map its position in an environment and plan the path to a new destination. This article summarizes ROS developer tools and guidance available to help with navigation.

Area: navigation, capabilities | Content-type: about | Experience: beginner, intermediate, expert

Table of Contents

  • Summary

  • Community-contributed packages

Summary

Navigation capabilities enable a mobile robot to map its environment, plan a path to a new destination, and then control movement along that path including handling unexpected interruptions, such as an unforeseen obstacle, that happen as it moves.

ROS also includes motion planning capabilities. See Motion planning and manipulation.

ROS capabilities are enabled by community-contributed packages.

Community-contributed packages

  • Nav2: An industry-standard mobile robot navigation system for mobile and surface robotics.

  • EasyNav: A flexible, extensible navigation system for mobile robots.

Previous Next

© Copyright 2026, Open Robotics.

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