Skip to content

How to Start with Rust in ROS 2 Based Robotics Systems?

Rust is a modern programming language intended for high-performance systems. Let’s check if it makes sense to use it in robotics systems based on the ROS 2 framework.


  1. Introduction to ROS2
  2. Why Rust?
  3. Example of Rust package in ROS 2
  4. Conclusion

Introduction to ROS2

ROS2 (Robot Operating System) is a second version of the most popular robotics open-source software framework. It allows to divide complex systems into smaller parts, called nodes. The nodes communicate with each other with a few mechanisms, like topics, services, or actions. The ROS provides also multiple tools for debugging, packages managing and binaries launching.

Topics – a publish-subscribe pattern

It is a basic messaging pattern used in ROS. According to it, nodes can take the role of publishers or subscribers, or both at once. The publisher (sender of message) sends a specified type (class) of the message on the specified channel (topic). On the other hand, a subscriber expresses its interest in a specific type of message on the specified topic. Then, it receives only messages that are sent to this topic. To sum up, in the publish-subscribe messaging pattern, publishers don’t send messages to specific subscribers but to the topic which can be observed by subscribers.

Why Rust?

Rust is a modern programming language that is becoming more and more popular (StackOverflow Survey). And there are few reasons for that Firstly, it has easy, intuitive syntax. Simultaneously, it’s a high-performance language with an emphasis on safety.

Main features

  • Compiled language, created by Mozilla.
  • Memory safety, no garbage collection.
  • Statically and strongly typed. Static typing means that types are known at compile-time. On the other hand, strong typing forbids implicit conversions between unrelated types.
  • High-performance, general purpose, and multi-paradigm language.
  • Applications from embedded systems to graphical interfaces.

Comparison of Rust with C++

Why compare Rust with C++? Because both are high-performance languages and are intended for similar applications.


  • Both are open-source compiled languages.
  • One and the other are high-performance languages and their efficiency is comparable in benchmarks (for example this benchmark).
  • Both are intended to use with a minimal set of runtime dependencies.
  • As mentioned, they are intended for similar applications, for example embedded or IoT systems.
  • Both allow to easy use of C code (C++ code also can be called from Rust but it’s not so easy and convenient).
  • Rust and C++ are statically typed, so all types have to be known at compile-time.


Easy of use
  • I know it can be subjective but I think that Rust is easier to use. It has better library integration and dependencies management system. Dependencies management is not convenient in C++ and probably each C++ programmer found out about it. It’s especially annoying in smaller, short-term projects.
  • Rust has a very usable and easy-to-use tool for the project management Cargo. In comparison, C++ projects can use make which is very powerful but also harder to learn and use.
  • Rust has more convenient, modern syntax (of course it’s rather a subjective opinion but not the only one). In recent years C++ has been significantly changed (simplified and extended with new features).
  • The documentation of Rust is really good. But in my opinion, C++ documentation is also great, especially since that language has its years.
  • Probably C++ will be a better choice for GUI applications because of more tools. But still Rust can be used for example with Qt library.
  • Rust has traits to handle abstractions. They’re used for both Run-time polymorphism and Compile-time polymorphism.
  • On the other hand, the C++ has multiple mechanisms for abstractions. These mechanisms are abstract classes, templates but also concepts, introduced in C++20.
  • Unsafe code in Rust is always written intentionally, or at least it has to be marked as unsafe.
  • Safe code in C++ needs more attention. There are multiple protections for that but are not enabled by default.
  • Rust is strongly typed while C++ is weakly typed. So, in Rust, implicit conversions between unrelated types are not allowed.

Example of Rust package in ROS 2

Rust support in ROS 2

Rust is not supported in ROS 2 by default. However, there are two solutions to provide such a support.

I have used the first one (ros2-rust) package. Mostly, because it’s more actively developed and in my opinion has a better documentation. So, the presented example will be based on this approach.


Testing Environment

I have used the following specification. However, newer versions should be also fine, especially Ubuntu 22.04 and ROS 2 Humble.

Used software:

  • Ubuntu 20.04
  • Python 3.9
  • rustc 1.64.0 (Rust compiler)
  • ROS 2 Galactic

Environment preparation

  • Install Python 3.8+
  • Install ROS 2 Galactic (or Humble). Here is the instruction for Ubuntu.
  • Install Rust (the script is intended for Linux).
    curl --proto '=https' --tlsv1.2 -sSf | sh
  • If you have already installed the Rust, then just update it:
    rustup update
  • Install tools necessary to configure and build the ros2-rust ROS package
    sudo apt install -y git libclang-dev python3-vcstool python3-pip
  • Install packages necessary to use Cargo with ROS packaging system colcon
    cargo install cargo-ament-build
    pip install git+
    pip install git+

Workspace creation

  • Create a new workspace
    mkdir -p ~/ros2_rust_ws/src
    cd ~/ros2_rust_ws/src

Build ros2_rust from sources

  • Clone the ros2-rust repository to the workspace

    cd ~/ros2_rust_ws/src
    git clone
  • Get all ros2-rust dependencies and source ROS configuration. Make sure that a ROS_DISTRO is set to the correct ROS version (currently ros2_rust supports foxy, galactic, humble and rolling)

    cd ..
    vcs import src < src/ros2_rust/ros2_rust_${ROS_DISTRO}.repos
    . /opt/ros/${ROS_DISTRO}/
  • Build the workspace with ros2-rust

    colcon build --packages-up-to examples_rclrs_minimal_pub_sub

    In case of building issues please check the original building instruction.

ROS package preparation

  • Create a new cargo package rust_example
    cd ~/ros2_rust_ws/src
    cargo new rust_example --bin --vcs none
  • Create package.xml file (it’s a part of each ROS package)

    <package format="3">
        <description>Example package</description>
        <maintainer email="">user</maintainer>
        <license>License type</license>

The rclrs is a main package from ros2_rust intended for ROS. It’s equivalent to rclcpp for C++ in ROS.

  • Add dependencies to Cargo.toml

    anyhow = {version = "*"}
    version = "0.3"
    version = "0.3"
    version = "*"
  • Compile a new package (empty for now)

    colcon build --packages-up-to rust_example

Create a publisher node

  • Rename automatically created src/ to src/

  • Write code for the publisher node. It’s a very simple implementation that publishes a message with number in a loop.

    // Publisher main function
    fn main() -> Result<(), anyhow::Error> {
      let context = rclrs::Context::new(std::env::args())?;
      // Create a node and add publisher to it
      let node = rclrs::create_node(&context, "rust_publisher")?;
      let publisher =
          node.create_publisher::("topic", rclrs::QOS_PROFILE_DEFAULT)?;
      let mut counter: u32 = 1;
      while context.ok() {
          // Prepare a message
          let mut message = std_msgs::msg::String::default();
 = format!("message {}", counter);
          // Publish the message
          println!("Published: {}",;
          counter += 1;
  • Add publisher binary definition to the Cargo.toml

    name = "publisher"
    path = "src/"
  • Build a rust publisher

    source install/setup.bash
    colcon build --packages-select rust_example

Verify if the publisher works correctly

  • Run the publisher node

    ros2 run rust_example publisher
  • Check if data is published correctly on the specified topic (/topic)

    ros2 topic echo /topic

It should show data like

  Published: message 1
  Published: message 2

Create a subscriber node

  • Create src/ file

  • Copy the subscriber code. It just receives data on specified topic and print it.

    // ROS2 subscriber
    fn callback(msg: std_msgs::msg::String) {
    println!("Received: {}",;
    fn main() -> Result<(), anyhow::Error> {
      let context = rclrs::Context::new(std::env::args())?;
      let mut node = rclrs::create_node(&context, "rust_subscriber")?;
      println!("Waiting for messages...");
      let _subscription = node.create_subscription::(
  • Add to subscriber file to Cargo.toml

    name = "subscriber"
    path = "src/"
  • Build the package again to make sure that subscriber code is fine

    colcon build --packages-select rust_example

Test of nodes communication by topic

  • Two terminal will be necessary. Run the publisher node in the first terminal

    ros2 run rust_example publisher
  • In the second terminal run the subscriber node

    ros2 run rust_example subscriber

You should see information about sent and received messages in terminals. If it works, launcher can be created optionally to simplify nodes running process.

Creation of a launch file (optional)

  • Create a new directory launch in the package.

  • Add launch directory to the installation list in Cargo.toml. Just copy below lines.

    install_to_share = ["launch"]
  • Create a launch file publisher_subscriber_launch.yaml. It has been used yaml version but ROS 2 supports also python or XML launchers.

    # Publisher node
    - node: 
      pkg: 'rust_example'
      exec: 'publisher'
      output: 'screen'
    # Subscriber node
    - node:
      pkg: 'rust_example'
      exec: 'subscriber'
      output: 'screen'
  • Run the example with created launch file.

    ros2 launch rust_example publisher_and_subscriber_launch.yaml

You should see information about sent and received messages.

Repository with this example

Code of this example has been published as GitHub repository ros2_rust_example. So, alternatively it could be just cloned and compiled in created workspace with configured ros2_rust.


  • The simple example shows that Rust can be successfully used in ROS 2. Of course, the set of available ROS features is still limited and rclrs implementation is not as mature as the one for C++ (rclcpp) or Python (rclpy).

  • The potential drawback of using Rust at this stage is related to missing libraries. There are a lot of robotics (mrpt, bullet, moveit etc.), optimization (Ceres Solver, CasADi), or computer vision (opencv, pcl) libraries written in C++ or Python. I think sooner or later more Rust libraries or interfaces to existing software appears.

  • However, in my opinion, the Rust has a great potential in ROS environment. Basically, it provides a similar level of performance and the same scope of application as C++. But with simpler code and higher level of safety, that is easier to reach. I hope that at some point, the Rust support will be added to ROS 2 (ros_core) by default in future!

Leave a Reply

Your email address will not be published. Required fields are marked *

This site uses Akismet to reduce spam. Learn how your comment data is processed.