RSLCPP -- Deterministic Simulations Using ROS 2

arXiv:2601.07052 · cs.RO · Submitted 2026-01-11 · Read on arXiv

Listen

Radio episode about this paper

Transcript

Introduction to the show: ident: Robotics Radio. Generated commentary on the latest robotics and control papers.

Rosa: We're looking at the paper: "RSLCPP -- Deterministic Simulations Using ROS 2".

Dev: Here's the gist of the paper. Simulation is crucial in real-world robotics, offering safe, scalable, and efficient environments for developing a variety of robotic applications<ref:2601.07052#pg2>.

Rosa: Our ROS Simulation Library for C++ (RSLCPP) implements this approach, enabling existing nodes to be combined into a simulation routine that yields reproducible results usually without requiring any source code changes<ref:2601.07052#pg2>.

Dev: We demonstrate that our approach produces identical results across various CPUs and architectures when testing both a synthetic benchmark and a real-world robotics system<ref:2601.07052#pg5>.

Rosa: RSLCPP is open-sourced at https://github.com/TUMFTM/rslcpp<ref:2601.07052#pg2>.

Paper summary: Rosa: So to wrap up on this RSLCPP paper, their main thesis is that ROS two's design makes reproducibility a real challenge for robotics research and industry > <ref:2601.07052#pg1>

Dev: Right. They point out that because it's asynchronous and multi-process, you can't guarantee the execution order of callbacks when things happen on different machines or even across different times >

Rosa: And they claim that this lack of determinism complicates scientific benchmarking and continuous integration, which is where consistent results are absolutely essential >

Dev: To solve this, they propose RSLCPP, which is a library for C++. It lets you combine existing ROS two nodes into one simulation routine that runs deterministically > <ref:2601.07052#pg1>

Rosa: The key claim is that it enables this deterministic execution without needing to change the code of the individual nodes themselves >

Dev: They show this works by implementing a methodology that establishes deterministic execution order and timing for callbacks in a multi-node ROS two system > <ref:2601.07052#pg1>

Conclusion: Rosa: So looking at the authors, Simon Sagmeister, Marcel Weinmann, Phillip Pitschi, and Markus Lienkamp—they put together a framework that addresses a very practical problem for anyone building complex robotic systems >

Dev: It’s about moving simulation away from being just an approximation to something more reliable for testing and validating control software >

Rosa: They showed that even with real-world robotics systems, you can get the same results on different processors if you use this approach >

Dev: The implication is that researchers and engineers who need strict repeatability for scientific testing or continuous integration can use RSLCPP to build those environments reliably >

Simon Sagmeister, Marcel Weinmann, Phillip Pitschi, Markus Lienkamp

Technical University of Munich, Germany

cs.RO

Submitted: 2026-01-11

Updated: 2026-11-07

Comments: Accepted for publication at the 'IEEE Robotics and Automation Practice'

DOI: 10.1109/RAP.2026.3704080

Code: https://github.com/TUMFTM/rslcpp

License: http://arxiv.org/licenses/nonexclusive-distrib/1.0/

Importance score: 90/100

The gist: Simulation is crucial in real-world robotics, offering safe, scalable, and efficient environments for developing a variety of robotic applications<ref:2601.07052#pg2>.

Key concepts

ROS 2 Reproducibility Problem
ROS 2's design, with asynchronous nodes and multi-process communication, makes it hard to get the same results every time. Computation times and message delays vary unpredictably, which ruins scientific testing where consistent data is vital.
Node Composition
This technique combines multiple ROS 2 nodes into one single process. By isolating these nodes within this single process, external communication is minimized, helping to control the execution order and timing of callbacks deterministically.
Discrete-Event Simulation
Simulation time is advanced only after all currently ready events have finished executing. This method creates a step-by-step simulation where time jumps occur only when necessary, ensuring that the sequence of events is strictly controlled and repeatable.

Terminology

Summary

Simulation is crucial in real-world robotics, offering safe, scalable, and efficient environments for developing a variety of robotic applications<ref:2601. p. 007052#pg2>. Our ROS Simulation Library for C++ (RSLCPP) implements this approach, enabling existing nodes to be combined into a simulation routine that yields reproducible results usually without requiring any source code changes<ref:2601. p. 007052#pg2>. We demonstrate that our approach produces identical results across various CPUs and architectures when testing both a synthetic benchmark and a real-world robotics system<ref:2601. p. 007052#pg5>. RSLCPP is open-sourced at https://github. p. 0com/TUMFTM/rslcpp<ref:2601. p. 007052#pg2>.

Problem Statement

The lack of reproducibility in ROS 2 due to its asynchronous, multi-process design complicates scientific benchmarking and continuous integration, where consistent results are essential<ref:2601.07052#pg2>. Deterministic callback execution cannot be guaranteed when computation times and communication delays vary<ref:2601. p. 007052#pg2>. This lack of reproducibility complicates scientific benchmarking and continuous integration, where consistent results are essential<ref:2601. p. 007052#pg5>.

Methodology for Determinism

To achieve deterministic execution order and timing of callbacks in a multi-node ROS 2 system, the methodology involves several key steps<ref:2601.07052#pg4>.

  1. All nodes are aggregated into a single process by utilizing node composition, which resides within this single process, isolated from external communication<ref:2601. p. 107052#pg4>.

  2. A custom event loop is implemented to establish deterministic execution, utilizing the RCLCPP events executor first introduced in ROS 2 Jazzy<ref:2601. p. 107052#pg4>.

  3. Simulation time is advanced only after the executor has finished executing all ready entities, creating a discrete-event simulation<ref:2601. p. 107052#pg4>.

  4. A delay mechanism is introduced to artificially delay message publication, scheduling its publication to occur after a configurable duration<ref:2601. p. 207052#pg4>.

Validation and Results

The approach was validated across two different experiments<ref:2601.07052#pg5>.

Synthetic Benchmark System:

Ran the synthetic benchmark on various architectures and processors to demonstrate the deterministic execution of our approach<ref:2601.07052#pg5>. Across all 600 simulations, the final hash values were identical, confirming that the simulation framework yields fully deterministic, bit-identical results under the conditions tested<ref:2601. p. 307052#pg5>.

Case Study: LiDAR Odometry:

Even the multi-threaded implementation of KISS-ICP produces repeatable results when executed in RSLCPP<ref:2601.07052#pg5>. Similar to the results obtained from the synthetic benchmark system, all runs across all hardware architectures tested yield identical results<ref:2601. p. 307052#pg5>.

Conclusion and Limitations

RSLCPP offers a modular, open-source solution for reproducible robotic simulation across different hardware setups. However, a limitation is that nodes must finish their callbacks in finite time and must not engage in cyclic undelayed publish-subscribe loops to avoid stalling the executor. p. 3 Single-threaded execution processes callbacks sequentially, increasing the runtime of a single complex simulation. p. 3 RSLCPP is tailored for scientific research, system-level debugging, and continuous integration testing. p. 3

Acknowledgment

Author contributions include S. Sagmeister as the first author who designed the article’s structure and essentially contributed to developing and implementing the framework. p. 3 M. Weinmann and P. p. 3 Pitschi contributed to the writing, design, and implementation. p. 3 M. Lienkamp made an essential contribution to the concept of the research project. p. 3 He revised the paper critically for important intellectual content. p. 3 M. Lienkamp gives final approval for the version to be published and agrees to all aspects of the work. p. 3 AI tools (GPT5. p. 32, Gemini 3 Pro) were used exclusively for editorial, code, and documentation refinement of author-provided input. p. 3

Green — the paper says it, and the page is printed. Red — no passage carries it, so treat that sentence as unverified. The same check runs on your own text: check a summary against its source, $5.

Improvements for AI systems

  1. Deterministic Simulation Framework for ROS 2 Nodes: RSLCPP enables existing nodes to be combined into a simulation routine that yields reproducible results usually without requiring any source code changes. This allows for scientific benchmarking and continuous integration testing across various hardware platforms with bit-identical results, as demonstrated by the synthetic benchmark tests.

  2. Scalable Real-World System Validation: The approach can validate real-world robotics systems, such as LiDAR odometry algorithms like KISS-ICP, showing repeatable results when executed in RSLCPP even on architectures that yield significant result jitter when run natively in ROS 2. This confirms applicability to resource-constrained systems by constraining thread counts and queue depths.

  3. Latency and Timing Analysis Under Deterministic Control: The system can be used to analyze system performance under varying latency conditions because the delay mechanism allows for nanosecond-precise synthetic delays while preserving determinism. This enables the analysis of system performance under varying latency conditions without requiring runtime optimization of the underlying algorithms.

Related papers