The Robot Operating System (ROS) is an open-source software framework for building robotic applications. It provides communication tools, libraries, hardware interfaces, development tools, and reusable packages that help different parts of a robot work together. Despite its name, ROS is not a OS like windows and linux.
By Jordan Lee
Last updated: October 6, 2026
What Is the Robot Operating System?
ROS provides a common software layer for connecting different parts of a robotic system.
A robot might have separate software for:
- Reading camera and sensor data
- Processing images
- Planning movement
- Navigating through an environment
- Controlling motors
- Monitoring the robot
- Running simulations
Instead of putting everything into one large program, ROS lets developers divide the application into smaller software components called nodes. These nodes communicate through standard ROS interfaces.
Making it easier to perform different task individually in robotics application.
ROS grew out of earlier robotics work at Stanford and was developed further at Willow Garage. The first public ROS code repository was created in 2007.
For readers who want the wider context, our engineering software guide covers how robotics software fits alongside CAD, CAE, PLM, EDA, GIS, and other engineering-software categories.
Is ROS an Operating System?
No. ROS is not an operating system in the normal computer-software sense.
It works with an underlying operating system and provides robotics-specific software capabilities. ROS 2 supports several operating systems, with the exact support level depending on the distribution.
A better way to think about ROS is as a robotics software development framework.
How Does ROS Work?
The basic ROS model is built around nodes and communication interfaces.
For example:
Camera Node → Image Topic → Vision Node
The camera node publishes image data. The vision node subscribes to that topic and processes the images.
A larger robot can have many nodes handling sensors, localization, planning, control, visualization, and other tasks.
Nodes
A node is a software process that performs a specific function.
One node might read a laser scanner while another estimates the robot’s position. A third node might plan a path using that position data.
Topics
Topics are used for publish-and-subscribe communication.
A node publishes messages to a topic, and other nodes can subscribe to that topic.
Topics are useful for continuous streams of information such as:
- Camera images
- Laser scans
- Robot position
- Sensor measurements
- Velocity commands
Services
Services use a request-and-response model.
A node sends a request to another node and receives a response. They are useful for operations that need a direct result rather than a continuous stream of data.
Actions
Actions are designed for longer-running tasks.
An action can provide feedback while the task is running and can support cancellation. Robot navigation is a common example because moving to a destination can take time.
Packages
ROS software is organized into packages. A package can contain source code, configuration files, launch files, message definitions, and other resources needed by a particular part of a robotics system.
Packages make it easier to share and reuse software.
ROS 1 vs ROS 2
ROS 1 was the original generation of the Robot Operating System and, ROS 2 introduced a redesigned architecture for requirements such as distributed systems, production deployment, security, and more flexible communication.
The final ROS 1 distribution, ROS Noetic Ninjemys, reached end of life on May 31, 2025. ROS 2 is now the current generation for new ROS development.
Also ROS 1 and ROS 2 differ most significantly in the way they manage communication between nodes.
| Feature | ROS 1 | ROS 2 |
|---|---|---|
| Transport | TCPROS and UDPROS | Middleware abstraction, primarily DDS/RTPS |
| Discovery | Central ROS Master (roscore) | Distributed discovery |
| Quality of Service | Limited built-in control | Configurable QoS policies |
| Current status | Noetic reached EOL in May 2025 | Current ROS generation |
| Main direction | Existing legacy systems | New development and deployment |
ROS 1 used its own TCPROS and UDPROS transport mechanisms and relied on a central ROS Master for discovery and name registration.
ROS 2 uses a middleware abstraction layer. DDS/RTPS is the primary communication foundation, providing distributed discovery and configurable Quality of Service (QoS) settings.
This change is one of the main architectural differences between ROS 1 and ROS 2.
What Is ROS 2 Used For?
ROS 2 can be used to build software for many types of robots, including:
- Mobile robots
- Robotic arms
- Autonomous robots
- Industrial robots
- Research robots
- Service robots
- Robots using cameras, lidar, or other sensors
Typical ROS 2 applications include navigation, perception, motion planning, robot control, sensor processing, and hardware integration.
ROS 2 does not provide every one of these functions by itself. Developers combine the ROS 2 core with packages and frameworks designed for specific tasks.
Common ROS 2 Tools and Frameworks
ROS 2 is much larger than its basic nodes and topics. Several tools and frameworks are commonly used in real projects.
rclcpp and rclpy
rclcpp is the ROS 2 client library for C++, while rclpy provides the Python client library.
These libraries let developers create ROS 2 nodes and use ROS communication features from their programs.
tf2
tf2 handles coordinate-frame transformations.
A robot may have frames for its base, wheels, camera, lidar, and other components. tf2 helps ROS 2 applications understand how those frames relate to one another.
RViz
RViz is a visualization tool used to display robot data.
Engineers can use it to view things such as robot models, sensor data, maps, paths, and coordinate frames.
rosbag2
rosbag2 records and plays back ROS 2 data.
This is useful when testing a robot because developers can record sensor data during a real run and replay it later without running the robot again.
Nav2
It provides components for tasks such as localization, planning, control, and navigation behavior.
MoveIt 2
MoveIt 2 is used for robot manipulation and motion planning, particularly with robotic arms.
It provides tools for planning and executing robot movements and integrates with other ROS 2 components.
ros2_control
ros2_control is a framework for connecting ROS 2 applications with robot hardware and controllers.
It provides hardware interfaces and controller components for robot control rather than making ROS 2 itself a complete motor-control system.
Launch files
ROS 2 launch files allow developers to start multiple nodes and configure them together.
A single launch file can start the nodes required for a complete robot application instead of requiring every node to be started manually.
A Simple ROS 2 Publisher and Subscriber Example
One of the easiest ways to understand ROS 2 is to look at a small publisher and subscriber.
A publisher can send a message to a topic:
import rclpy
from rclpy.node import Node
from std_msgs.msg import String
class Publisher(Node):
def __init__(self):
super().__init__('publisher')
self.pub = self.create_publisher(String, 'topic', 10)
self.timer = self.create_timer(1.0, self.publish)
def publish(self):
msg = String()
msg.data = 'Hello from ROS 2'
self.pub.publish(msg)A subscriber can listen to the same topic:
import rclpy
from rclpy.node import Node
from std_msgs.msg import String
class Subscriber(Node):
def __init__(self):
super().__init__('subscriber')
self.sub = self.create_subscription(
String, 'topic', self.receive, 10)
def receive(self, msg):
self.get_logger().info(msg.data)These are shortened examples that show the communication pattern. A complete ROS 2 Python program also needs rclpy.init() to initialize ROS, a main() function, rclpy.spin() to keep the node running, and rclpy.shutdown() when it exits.
The official ROS 2 Python publisher/subscriber tutorial shows the complete implementation and package setup.
Which ROS 2 Distribution Should You Use?
ROS 2 is released in named distributions, or distros. Each distribution provides a tested collection of ROS 2 packages and has its own support period.
As of the October 6, 2026 update date, the main distributions are:
| Distribution | Released | EOL | Type |
|---|---|---|---|
| Lyrical Luth | May 2026 | May 2031 | LTS |
| Kilted Kaiju | May 2025 | December 2026 | Non-LTS |
| Jazzy Jalisco | May 2024 | May 2029 | LTS |
| Humble Hawksbill | May 2022 | May 2027 | LTS |
| Rolling Ridley | Continuous | No fixed EOL | Development |
Lyrical Luth is the newest ROS 2 LTS release. It is a good choice for a new project if the drivers, packages, and hardware you need support it.
Jazzy Jalisco is still an important choice when you want a more mature ecosystem and broader compatibility with packages that may not yet support the newest distribution.
Humble Hawksbill remains relevant for existing projects but is closer to its May 2027 end of life.
Kilted Kaiju is a non-LTS release and approaches its December 2026 end of life, so it is generally not the best choice for a new long-lived project.
Rolling Ridley is the development distribution. It receives ongoing changes and is better suited to developers who specifically need development versions rather than maximum stability.
Before choosing a distribution, check whether the ROS packages, hardware drivers, simulators, and other dependencies in your project support it.
ROS 2 distributions are not automatically interchangeable. Nodes built for different distributions cannot be assumed to communicate correctly just because both use ROS 2. Package versions, message definitions, middleware behavior, and other dependencies can affect compatibility.
For the current release information, use the official ROS 2 distributions page.
Which Platforms Does ROS 2 Support?
ROS 2 uses a tiered platform-support system. The exact matrix changes by distribution.
For Lyrical Luth, the current platform matrix lists:
| Platform | Support tier |
|---|---|
| Ubuntu 26.04 (Resolute), amd64 and arm64 | Tier 1 |
| Windows 11 with Visual Studio 2022, amd64 | Tier 1 |
| RHEL 10, amd64 | Tier 2 |
| Ubuntu 24.04 (Noble) | Tier 3 |
| macOS | Tier 3 |
| Debian Trixie | Tier 3 |
| OpenEmbedded / Yocto Project | Tier 3 |
Tier 1 platforms receive the strongest level of official support and testing. Tier 2 and Tier 3 have progressively different levels of testing and support.
The exact architecture and platform combinations matter. For example, the Lyrical platform matrix lists Ubuntu 26.04 as Tier 1 for both amd64 and arm64, while Windows 11 Tier 1 support is listed for amd64.
Check the ROS 2 platform support information before choosing an operating system for a new project.
robot operating system
ROS 2 and Simulation
ROS 2 is commonly used with robot simulation software.
The current Gazebo project is the successor to the simulator line that was previously known as Ignition Gazebo. Gazebo Classic reached end of life in January 2025, so it should not be treated as the current Gazebo platform for new projects.
Modern Gazebo can be used with ROS 2 to test robot software in simulated environments.
Simulation can help developers test:
- Robot movement
- Sensors
- Navigation
- Robot models
- Controllers
- Software behavior
This allows many software problems to be found before testing on physical hardware.
Is ROS 2 Free?
Yes. ROS 2 is open-source software, and its code is licensed under the Apache 2.0 license.
That does not mean every ROS-based robotics project is free. A complete system may still require physical robots, sensors, computers, commercial software, cloud services, or engineering work.
The ROS 2 framework itself does not require a traditional commercial software subscription.
How to Get Started With ROS 2
The best starting point is to choose a supported ROS 2 distribution and follow its official installation instructions.
A beginner can then learn the basic concepts in this order:
- Install ROS 2 and create a workspace.
- Learn how nodes work.
- Create a simple publisher and subscriber.
- Learn topics, services, and actions.
- Learn how packages and launch files work.
- Explore tf2 and RViz.
- Move into a specialized framework such as Nav2, MoveIt 2, or ros2_control based on the type of robot being developed.
The official ROS 2 documentation provides installation instructions, tutorials, concepts, and package documentation.
robot operating system
Advantages of ROS 2
ROS 2 has several advantages for robotics software development.
Modular architecture
Applications can be divided into separate nodes and packages instead of one large program.
Reusable software
Developers can use existing packages and frameworks instead of building every robotics function from scratch.
Flexible communication
ROS 2’s middleware architecture provides configurable communication behavior and QoS options.
Hardware integration
ROS 2 can connect software with sensors, controllers, and robot hardware through drivers and frameworks such as ros2_control.
Large ecosystem
ROS 2 has a broad collection of packages and tools covering navigation, manipulation, perception, simulation, visualization, control, and other robotics tasks.
Limitations of ROS 2
ROS 2 is not a complete robot system by itself.
A real robot still needs hardware drivers, control systems, safety mechanisms, sensors, actuators, and other software depending on the application.
ROS 2 also has a learning curve. Developers need to understand concepts such as nodes, topics, services, actions, QoS, packages, transforms, launch files, and middleware.
The correct ROS 2 distribution also matters because hardware drivers and third-party packages may not support every distribution equally.
For commercial or safety-critical systems, ROS 2 should therefore be evaluated as part of the complete engineering system rather than treated as a replacement for every other layer of robot software.
For readers building a larger engineering software stack, ROS 2 is best viewed as a specialized robotics layer that works alongside other engineering tools rather than replacing CAD, simulation, PLM, or other systems.
robot operating system
Who Should Use ROS 2?
ROS 2 is particularly useful for:
- Robotics software developers
- Robotics engineers
- Researchers
- University students learning robotics
- Companies developing robotic systems
- Engineers working on autonomous or mobile robots
- Developers building robotic-arm applications
It is most valuable when a project contains multiple software components that need to communicate, share data, and work together.
robot operating system
Frequently Asked Questions
What does ROS stand for?
ROS stands for Robot Operating System.
Is ROS actually an operating system?
No. ROS is a robotics software framework and development platform that works with an underlying operating system.
Should I learn ROS or ROS 2?
For new development, start with ROS 2. ROS 1 has reached end of life, while ROS 2 is the current generation.
Which ROS 2 distribution should I use?
As of October 2026, Lyrical Luth is the newest LTS release. It is a good option when the packages and hardware you need support it. Jazzy can be a better choice when you need a more mature ecosystem.
What programming languages does ROS 2 use?
C++ and Python are the main languages used through the rclcpp and rclpy client libraries.
Can ROS 2 control a robot?
Yes, ROS 2 can be part of a robot-control system. Frameworks such as ros2_control provide hardware and controller interfaces for this purpose.
Can ROS 2 be used for simulation?
Yes. ROS 2 can work with modern Gazebo and other simulation tools to test robotics software before deploying it to physical hardware.
Is ROS 2 free?
Yes. ROS 2 is open source and licensed under Apache 2.0. Other parts of a robotics project can still have their own costs.
robot operating system
Conclusion
The Robot Operating System (ROS) is an open-source software framework for developing robotic applications. It provides a way to connect software components through nodes, topics, services, actions, packages, and other tools.
ROS 1 was the original generation, while ROS 2 is the current platform for new development. Its redesigned communication architecture uses a middleware abstraction with distributed discovery and configurable QoS.
For a new project, the ROS 2 distribution matters almost as much as the framework itself. Lyrical Luth is the newest LTS release, but Jazzy may be the better choice when required packages and drivers have stronger support there.
With tools such as tf2, RViz, rosbag2, Nav2, MoveIt 2, ros2_control, and modern Gazebo, ROS 2 provides a broad software foundation for building and testing robotic systems.