PROVIDER - the de facto framework for robot software

ROS

ROS began at Willow Garage in 2007, and ROS 2 moved to DDS with rclcpp and rclpy client libraries while organising robot software through nodes, topics, services and actions; the component ecosystem is rich, while concept depth, version splits and DDS tuning are the main barriers.

Programming Languages & Frameworks United States 2026.11.19
4.1pts

Detailed Notes

Pros 5 items

Willow Garage started ROS 1 in 2007, and ROS 2 from 2017 switched to DDS as its communication middleware
Organises distributed robot systems with 4 mechanisms: nodes, topics, services and actions
Provides 2 official client libraries, rclcpp and rclpy, covering C++ and Python habits
The ecosystem ships mature components including Nav2, MoveIt, Gazebo and RViz for navigation, arms and simulation
Binary releases target Ubuntu LTS primarily, with 3 further options covering Windows, macOS and real-time kernels

Cons 4 items

A large system with many concepts and tools, so starting from zero takes a long ramp-up
ROS 1 and ROS 2 ecosystems are split, leaving many older packages unmigrated
DDS configuration is intricate, and QoS plus network tuning demand dedicated experience
Focused on research, AMRs and humanoids, with thin support for production safety certification

Service Overview

ROS (Robot Operating System) started at Willow Garage in 2007 as a framework collection for robot software rather than an operating system. ROS 2, introduced from 2017, adopted DDS as its middleware to support multi-machine and real-time scenarios.

In the languages and frameworks category it is the de facto robotics standard: perception, localisation, planning and control become reusable nodes connected through one message protocol.

Key Strengths

  • Clear communication model: 4 mechanisms - nodes, topics, services and actions - cover most robot interactions
  • Two languages: rclcpp for performance-sensitive C++ modules and rclpy for fast algorithm validation
  • Rich components: Nav2 handles navigation, MoveIt handles arms, and Gazebo with RViz covers simulation and visualisation
  • Distributed by default: DDS makes multi-machine and cross-process communication native
  • Abundant material: academic and industrial cases make reference implementations easy to find

Product Ecosystem

Versions and middleware

ROS 1 (Noetic) is still in use, while ROS 2 (Humble, Iron, Jazzy) is the mainline, with DDS/RTPS underneath.

Core components

Nav2, MoveIt 2, Gazebo, RViz2, ros2_control and rosbag2.

Application areas

Autonomous mobile robots, robotic arms, autonomous driving research, drones and academic teaching.

Limitations

  • Concept load: parameters, lifecycle, composition and plugin systems need systematic study
  • Version split: ROS 1 and ROS 2 do not interoperate, so migrating older packages is costly
  • DDS tuning: QoS policies and network setup need experience, or packets and latency suffer
  • Production support: industrial-grade safety certification and deterministic scheduling are still maturing

Use Cases

  • AMRs and mobile robots (★★★★★): navigation and localisation stacks are mature
  • Robotic arms and grasping (★★★★): MoveIt provides a full planning chain
  • Autonomous driving research (★★★★): sensor fusion and bag recording tools are complete
  • Certified production vehicles (★★★): weigh real-time and certification requirements first

Pricing

Item Price Notes
ROS 2 and core components $0 Open source under Apache 2.0
Simulation and tools $0 Gazebo and RViz are free
Commercial support and training Per project Some vendors sell subscriptions

The software is free; cost concentrates in hardware, compute, staffing and training.

FAQ

  • ROS 1 or ROS 2? New projects should use ROS 2, since ROS 1 Noetic is at end of maintenance.
  • Is C++ mandatory? Python works for algorithm validation, while performance-critical code and hardware drivers are better in C++.
  • Must DDS be tuned? Single-machine development can keep defaults, while multi-machine and hard real-time scenarios need QoS and network adjustment. More robotics options are under languages and frameworks.

Code Examples

A publisher node in Python

import rclpy
from rclpy.node import Node
from std_msgs.msg import String

class Talker(Node):
    def __init__(self):
        super().__init__("talker")
        self.pub = self.create_publisher(String, "chatter", 10)
        self.timer = self.create_timer(1.0, self.on_timer)

    def on_timer(self):
        msg = String()
        msg.data = "hello ros 2"
        self.pub.publish(msg)

def main():
    rclpy.init()
    node = Talker()
    rclpy.spin(node)
    node.destroy_node()
    rclpy.shutdown()

create_publisher declares the topic and queue depth, and create_timer fires the callback every second.

A subscriber node in C++

#include "rclcpp/rclcpp.hpp"
#include "std_msgs/msg/string.hpp"

class Listener : public rclcpp::Node {
public:
  Listener() : Node("listener") {
    sub_ = create_subscription<std_msgs::msg::String>(
        "chatter", 10,
        [this](const std_msgs::msg::String::SharedPtr msg) {
          RCLCPP_INFO(get_logger(), "heard: %s", msg->data.c_str());
        });
  }
private:
  rclcpp::Subscription<std_msgs::msg::String>::SharedPtr sub_;
};

create_subscription handles messages in a lambda, and RCLCPP_INFO routes logs into the ROS 2 logging system.

Community & Resources

Visit ROS Website → https://www.ros.org/
Visit Website ↗