RSLCPP -- Deterministic Simulations Using ROS 2
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'
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>.
-
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>.
-
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>.
-
Simulation time is advanced only after the executor has finished executing all ready entities, creating a discrete-event simulation<ref:2601. p. 107052#pg4>.
-
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
-
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. -
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 yieldsignificant result jitter
when run natively in ROS 2. This confirms applicability to resource-constrained systems by constraining thread counts and queue depths. -
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 theanalysis of system performance under varying latency conditions without requiring runtime optimization of the underlying algorithms.
Related papers
- Rethinking Actions: Continuity-Aware Priors for World-Model Planning
- MOSAIC: Modular Obstacle and Spatial-Aware Framework for Manipulation In Cluttered Scenes
- SAGAS: Semantic-Aware Graph-Assisted Stitching for Offline Temporal Logic Planning
- DexSeed: Expanding Human Hand-Object Interactions into Robot Demonstrations for Dexterous Policy Learning
- LaST0.5: A Generalist World Action Model with Interaction-Centric Latent Reasoning
- CIALLO: Learning Shared Intent Representations for Cross-Embodiment Manipulation