If you are a ROS developer/user and you blog about it, ROS wants those contributions on this page ! All you need for that to happen is:
have an RSS/Atom blog (no Tweeter/Facebook/Google+ posts)
open a pull request on planet.ros tracker indicating your name and your RSS feed/ATOM url. (You can just edit the file and click "Propose File Change" to open a pull request.)
make your ROS related posts tagged with any of the following categories: "ROS", "R.O.S.", "ros", "r.o.s."
Warnings
For security reasons, html iframe, embed, object, javascript will be stripped out. Only Youtube videos in object and embed will be kept.
Guidelines
Planet ROS is one of the public faces of ROS and is read by users and potential contributors. The content remains the opinion of the bloggers but Planet ROS reserves the right to remove offensive posts.
Blogs should be related to ROS but that does not mean they should be devoid of personal subjects and opinions : those are encouraged since Planet ROS is a chance to know more about ROS developers.
Posts can be positive and promote ROS, or constructive and describe issues but should not contain useless flaming opinions. We want to keep ROS welcoming :)
ROS covers a wide variety of people and cultures. Profanities, prejudice, lewd comments and content likely to offend are to be avoided. Do not make personal attacks or attacks against other projects on your blog.
Suggestions ?
If you find any bug or have any suggestion, please file a bug on the planet.ros tracker.
For industrial robotics teams, simulation is useful only when the important parts of the simulated system behave enough like the real system to support better engineering decisions. A robot arm that looks right but reaches to the wrong pose is an obvious problem. A gripper that looks right but responds differently during contact can be harder to notice, and in manipulation work it may matter even more.
At Southwest Research Institute, we have been developing and evaluating Physical AI approaches for high-mix manipulation. The broader effort combines teach-through-demonstration with simulation, with the goal of supplementing demonstrations through reinforcement learning. Our lab setup includes Universal Robots UR5e arms and Robotiq 2F-85 grippers. The full workcell matters, but the gripper became the clearest example of a practical problem many robotics teams are beginning to face: the asset that is available is rarely the same thing as the asset that is ready for production-oriented simulation.
Isaac Sim representation of the lab system
Photograph of the lab setup
The first problem: available assets are not automatically usable assets
A common starting point in a simulation project is to use the assets that are already available in the simulator or in the ROS ecosystem. That was our starting point as well. Isaac Sim includes Robotiq gripper assets, and there are public Robotiq-related resources in the ROS and ROS 2 ecosystem. Those resources are valuable, but in our testing they did not immediately give us the behavior we needed.
The issues were not cosmetic. We encountered practical asset-structure and behavior problems, including difficulty restructuring an articulation root, gripper assets that were not instanceable, and contact behavior that failed when a mimic joint encountered an object asymmetrically at one finger pad. Each of those issues matters in a production-oriented simulation workflow.
For readers who do not spend their day in USD internals, an “instanceable” asset is one that can be referenced and reused cleanly rather than copied and manually modified each time. That matters when a simulated workcell becomes more complex or when the same asset must appear in many scenes. A “mimic joint” is a joint whose motion follows another joint. For a mechanically coupled gripper, mimic behavior can be the right abstraction because the physical hardware is not simply two independent fingers driven by unrelated commands.
That distinction is central to the Robotiq 2F-85.
Why the Robotiq 2F-85 is a useful test case
The Robotiq 2F-85 is a parallel gripper, but its mechanism is not as simple as two independent pads moving toward each other. It includes closed-loop mechanical behavior, which creates challenges for simulation asset authoring. The practical modeling decision becomes: should the gripper be represented with one driven joint and mimic behavior, or should both sides be driven independently?
A single driven joint with mimic behavior is attractive because it better reflects how the gripper is normally commanded. Driving both sides independently can make an asset move in simulation, but it introduces extra controller and joint-state complexity and moves the simulation farther away from the real gripper abstraction. We evaluated that path by importing a URDF into USD and adding drives to both sides. For our purposes, that direction created more complexity than value, and it likely would still have required mimic behavior to represent the coupled mechanism faithfully.
NVIDIA’s Isaac Sim documentation includes a tutorial on rigging closed-loop structures using a Robotiq 2F-85 gripper, and that tutorial points to a workflow that starts from a CAD/Onshape representation and then adds the physics, joint, and drive configuration needed to make the asset functional in Isaac Sim. That detail is important: import is only the beginning. A realistic gripper asset still needs careful authoring and validation.
What we tried from the ROS ecosystem
After our initial asset testing, we reviewed several public resources related to Robotiq grippers, including the older ROS-Industrial Robotiq repository, PickNik’s ros2_robotiq_gripper, and UW-Lab resources and assets. It’s worth noting that Robotiq does not currently provide first-party assets for its grippers; all of the resources we tested are community-maintained.
The best-performing candidate in our lab testing was the UW-Lab calibrated USD asset for the Robotiq 2F-85. That asset appears to follow the same general pattern as the Isaac Sim closed-loop structure workflow, with additional modifications. Out of the box, it behaved better than the other candidates we tested. Even though it uses mimic behavior, it did not break when an object contacted one finger before the other, and we did not observe the unexpected mesh behavior we saw elsewhere when larger forces were applied.
Simulated Robotiq 2F-85 mounted on the UR arm
That made the UW-Lab asset a much better starting point. It did not make the problem disappear.
The remaining fidelity gap
The physical Robotiq 2F-85 still exhibited behavior that the simulation did not capture. In the real gripper, when an object is grasped near the base-side region of the finger pads, the pads can angle inward slightly. When the object is grasped farther out on the pads, the pads remain parallel.
In our simulation, that behavior was not represented. The simulated kinematics and physics did not capture the same pad motion we observed on the physical gripper.
Physical Robotiq 2F-85 on the lab robot
That may sound like a small difference. In manipulation, small differences at the contact interface can become large differences in outcome. A grasping policy trained or validated in simulation is sensitive to contact geometry, friction, compliance, joint coupling, and failure modes. A gripper asset that works for visualization may still be insufficient for reinforcement learning, synthetic data generation, or pre-deployment validation.
The broader lesson: conversion is not fidelity
ROS users tend to start with URDF, and for good reason. URDF is familiar, widely supported, and often the most available robot description format for ROS-based systems. SDF is also common in simulation workflows. USD and OpenUSD offer a powerful scene representation for modern simulation and digital-twin workflows. But moving from URDF or SDF to USD does not automatically create the physical and behavioral information needed for high-fidelity simulation.
A converter can translate what is present. It cannot reliably invent what is missing.
That is where the SimReady idea is useful. NVIDIA describes SimReady as more than placing simulation data into a USD file. The goal is to represent simulation-ready content through named, typed, validated properties that tools can interpret, validate, and use. In NVIDIA’s broader description, SimReady assets include physics properties, semantic labels, material attributes, and, where needed, behavioral or articulation data.
For robotics teams, that framing exposes the real gap. A useful production asset is not merely a mesh. It is not merely a URDF. It is not merely a USD file. It is a validated representation of geometry, kinematics, dynamics, contacts, materials, semantics, and control-relevant behavior at the level required by the task.
Practical takeaways for robotics teams
First, validate assets against the behavior that matters for the application. Loading the asset, moving the joints, and rendering the workcell are necessary checks, but they are not enough. For manipulation, validation should include contact cases, asymmetric grasps, edge grasps, expected failure modes, verification of the mesh geometries, and comparisons against the physical hardware.
Second, choose the simulated command abstraction deliberately. For a mechanically coupled gripper, independent finger drives may be convenient during asset authoring, but they may also create a mismatch with the real system. If the physical gripper is commanded as a coupled mechanism, the simulation should preserve that abstraction unless there is a clear reason to do otherwise.
Third, track asset provenance and simulator version. Isaac Sim documentation, import workflows, asset structure, and tuning parameters can vary between versions. A gripper that behaves acceptably in one workflow may require different configuration in another. Asset source, simulator version, import method, and post-import modifications should be captured as part of the engineering record.
Fourth, treat conversion as the start of an asset-authoring workflow rather than the end. URDF-to-USD or SDF-to-USD conversion is valuable, but high-fidelity simulation still requires authoring, tuning, and validation. The missing information often lives with the equipment manufacturer or must be measured experimentally.
Finally, involve equipment manufacturers where possible. Manufacturers are often best positioned to provide richer kinematic, dynamic, material, and behavioral information about their products. The robotics community would benefit from a more standard way to move that information from manufacturer data into ROS-compatible descriptions, USD-based simulation assets, and validation tests.
Toward a better ROS-to-SimReady workflow
The Robotiq 2F-85 experience points to a larger opportunity for the ROS-Industrial, open-source robotics, simulation, AI, and equipment-manufacturer communities. We need workflows that preserve what ROS users already rely on while adding the physical and behavioral fidelity required by modern high-fidelity simulation.
A practical workflow could look something like this:
Manufacturers provide CAD, URDF or SDF descriptions, kinematic details, material properties, actuator behavior, and validation data;
ROS and open-source tools support accessible robot descriptions and integration;
USD-based simulation workflows support composition, reuse, and high-quality scene representation; and
SimReady-style validation defines whether an asset is ready for the intended class of simulation tasks.
The important point is that “simulation ready” should become an engineering claim that can be tested, not a label applied because an asset loads in a simulator.
There are signs this is starting to happen. When we contacted Robotiq prior to publication, they indicated that “an official C++ SDK, ROS 2 driver, URDF and updated Isaac Sim assets are in active development.”
Conclusion
Our experience with the Robotiq 2F-85 was a reminder that the hard part of simulation is not always the robot arm, the environment, or the renderer. Sometimes the hard part is the contact behavior of a gripper pad at the exact point where the simulated world meets the physical one.
URDF, SDF, USD, and SimReady all have roles to play, but no single file format solves the fidelity problem by itself. For production robotics, a simulation asset earns trust only when it reproduces the behaviors that affect the task. The closer the ROS, simulation, AI, and equipment communities can align around that standard, the less time teams will spend rebuilding the same assets and the more confidence they can place in simulation before deploying to real hardware.
For years, there has been a strong and consistent demand for seamless Protobuf serialization in ROS/ROS 2. While there are excellent existing tools in the community, integrating them cleanly into a high-performance, production-ready pipeline often comes with friction.
protoros2 does not reinvent the wheel. Instead, it acts as a non-intrusive “Tri-State Orchestration Engine” that elegantly binds third-party Open-Source foundations into a unified architecture. It allows you to use Protobuf in your stack without compromise.
It provides an out-of-the-box EnterpriseNode wrapper that offers multi-channel communication:
• Proto Channel (Zero-Intrusive Fast-Path): Transparently inspects the underlying RMW serialization format at runtime. If the RMW supports Protobuf natively, it routes messages directly via rclcpp::SerializedMessage. If not, it gracefully falls back to standard CDR via rclcpp::TypeAdapter.
• Flat Channel (Performance Bonus): An optional bypass channel optimized for ultra-low latency IPC (powered by Iceoryx shared memory), fully adapted to the ROS 2 executor ecosystem.
Key Features & Use Cases
We designed protoros2 to be flexible enough to accommodate different team workflows, supporting multiple “Single Source of Truth” (SSOT) architectures seamlessly:
• Use Case A: Standard ROS 2 .msg as SSOT
Write your standard .msg files as usual. protoros2 works seamlessly with standard RMWs (CDR only) or native Protobuf RMWs without altering your application logic. In fallback modes, it can even handle simultaneous CDR and Protobuf topic ecosystems flawlessly.
• Use Case B: AI/Robotics .proto as SSOT
For AI-first teams, define your data structures natively in .proto. protoros2 can either co-exist with a generated mirror IDL or operate purely on .proto, bypassing .msg entirely for a direct, zero-overhead binding.
• Native ROS 2 Executor Support:
Whether you prefer standard Callback Push, WaitSets, CallbackGroups (Mutually Exclusive/Reentrant), Polling Subscribers, or Intra-Process Comm—protoros2 natively integrates these paradigms out of the box.
• MLOps Ecosystem Ready:
Full compatibility with mcap format and rosbag2 plugins. Data scientists can consume protobuf bags directly with native python bindings.
Enterprise Security Built-in
To ensure consistency in large-scale deployments, protoros2 utilizes strict C++ access controls to safely encapsulate the raw rclcpp::Node. It intercepts and disables risky dynamic ROS 2 configurations (like parameter services and QoS overriding) at compile time, guaranteeing predictable behavior on the vehicle edge without sacrificing the standard ROS 2 developer experience.
Acknowledgement
This work stands on the shoulders of giants. We want to express our deepest gratitude to the following incredible projects and their contributors, without which protoros2 would not have been possible:
Shivam will introduce the concepts of Forward and Inverse Kinematics, explain where it fits into robotics (and how important it is!) and get into technical details of how to apply it and how the math works.
Also featured two lighting talks
The Pupper Project team will give an update of their progress and hopefully show off their puppy
We are opening early-access evaluations for ADEL 2.0 (Autonomous Deterministic Executive Layer), a bare-metal C++/Rust execution engine built for ultra-low latency, zero-jitter control loops.
While designed for microsecond satellite maneuver planning under severe compute bounds, ADEL 2.0 provides immediate utility for terrestrial robotics, BVLOS drone flight controllers, and autonomous hardware running ROS/ROS2 node topologies.
Lightweight memory footprint suitable for embedded edge targets.
Interactive Monitor & Visualizer:
We are actively scheduling 15-day to 30-day Hardware-in-the-Loop (HIL) benchmarking pilots with robotics hardware teams and autonomous system integrators.
Feel free to test the live monitor above or reach out at annesham649@gmail.com if you’d like to benchmark ADEL 2.0 against your current ROS control stack!
We have been working on adding real-time functionality to rcl and rclcpp since 2022.
In response to this proposal, we have created a new package that provides real-time functionality without changing the existing packages.
The previous discussion is as follows: ROS lacks a unified mechanism to formally support real-time functionality, and we have tried to achieve this by adding functionality to rcl and rclcpp.
On the other hand, it has been pointed out in past PTCs that it makes it difficult to check at release time and to support the OS.
Since CallbackIsolatedExecutor was announced around the same time, we have also changed our policy to provide functionality in separate packages.
For now, we provide rclcpp-friendly classes. There are four things to do:
Add package description to CMakeLists.txt and package.xml
Add a configuration file in YAML format
Change the main routine in the source file
Change rclcpp::init, rclcpp::shutdown to the rclcpp_realtime namespace
Change executors to be able to apply thread attributes provided by rclcpp_realtime
This allows thread attribute settings to be applied to executors by specifying an environment variable or a configuration file with --ros-args.
See the README below for details.
Despite the name, real-time support, not much has been done.
The thread attributes can be managed through the extended rcl interfaces; APIs for thread operations, abstracted by these attributes, are provided, and executors that use the attributes have been added.
In the future, we will change the mutexes and condition variables used in rclcpp_realtime on an RTOS to call OS-native APIs.
Another challenge is to make intra-process communication real-time, so we can guarantee real-time performance in robot systems that run on a single PC.
TL;DR: A workspace-level uv-managed venv works on stock apt-installed ROS 2 — including a PyTorch+CUDA node — but we hit five reproducible failure modes on the way (verified on Jazzy; none of the mechanisms are Jazzy-specific). Key measurement: the known shebang workaround ([build_scripts] executable = /usr/bin/env python3) does not cover --symlink-install, so when colcon is launched from the system Python there is currently no complete workaround. Below are four minimal change proposals for colcon/ament — all opt-in, none fixing the venv’s location or name, with no behavior change for workspaces that do not use a venv.
Background
PEP 668 disabled pip install into the system Python on Ubuntu 24.04, and deep-learning robotics often needs exact version pins and custom package indexes (e.g. torch==2.6.0+cu124) that package.xml/rosdep currently has no way to declare. A per-workspace virtual environment with pyproject.toml and a lockfile — managed here with uv — is one practical answer. In Letting Python Be Python, the idea that workspaces could become venvs was raised, along with the question of what it would take to get there; Status of Colcon building “standards-based” Python packages covers the related build-tool work. This post adds empirical data to that discussion: we migrated a real robot stack to uv while keeping colcon, ros2 run, and ros2 launch in use, and recorded what broke and why.
What works and what breaks
With a venv created by uv venv --system-site-packages from the distro interpreter, and python-preference = "only-system" set in the [tool.uv] section of pyproject.toml, everything builds and a torch+CUDA inference node runs on the venv’s Python, with lockfile reproducibility and custom wheel indexes.
Setup: Ubuntu 24.04 / apt Jazzy / Python 3.12.3 / setuptools 68.1.2 / uv 0.11.28, and pyproject.toml (click for more details)
Along the way we hit five reproducible failure modes. All of them can be worked around, but the workarounds are not covered by official documentation, so they are easy to rediscover independently:
#
Failure mode
Cause
Current workaround
1
Every shell needs two setup steps (source install/setup.bashand venv activation), in order
The ROS environment and the venv have no knowledge of each other
Hand-written shell setup per project
2
colcon treats directories inside the venv as packages during discovery
Package discovery descends into every subdirectory
ros2 run executes ament_python nodes with the system interpreter even while a venv is active
colcon runs setup.py with its own sys.executable; setuptools writes that interpreter into console-script shebangs
Incomplete — see next section (ros2/ros2#1094, open since 2021)
4
numpy 2.x in the venv breaks apt-built extensions (cv_bridge) at import
Jazzy binaries are built against numpy 1.26’s C ABI
Pin numpy<2 in the workspace
5
uv provisions its own standalone CPython, which mismatches distro-built C extensions
uv’s default python-preference
python-preference = "only-system" in pyproject.toml ([tool.uv])
The remaining gap
Four of the five have complete workarounds; #3 does not. A known mitigation is [build_scripts] executable = /usr/bin/env python3 in setup.cfg (mechanism related to colcon-core#183, reported in ros2/ros2#1094). We measured it on Jazzy:
Regular colcon build: works — scripts get env shebangs and resolve to the active venv.
colcon build --symlink-install: not applied — the develop/editable code path keeps #!/usr/bin/python3, so the mode commonly used during development is not covered.
Launching colcon from the venv itself — .venv/bin/python -m colcon build — covers both modes (with --system-site-packages, the apt-installed colcon is importable from the venv, so nothing extra needs to be installed). The limitation: the venv’s absolute path is written into the generated shebangs, so the result does not survive venv recreation and install/ is not relocatable.
Bottom line: when colcon is launched from the system Python — the common configuration in tutorials and CI — there is currently no complete workaround.
Proposed changes
One design principle for all four: opt-in, no fixed venv location or name, and no behavior change for workspaces that do not involve a venv.
P1 — discovery: skip any directory containing pyvenv.cfg (the PEP 405 marker every venv has) during package discovery — an automatic COLCON_IGNORE for venvs of any name, in any location.
P2 — shebangs: an option to emit #!/usr/bin/env python3 shebangs on both the install and the develop (--symlink-install) code paths. The setup.cfg mitigation covers only the install path and has to be repeated in every package; an option at the build-tool level would cover a whole workspace at once. Where no venv is active, env python3 resolves to /usr/bin/python3 as before.
P3 — activation: record the path of the interpreter colcon built with under install/, and let setup.bash read it and, if that interpreter belongs to a venv, activate it (with an opt-out environment variable). This is a minimal mechanism for the “workspaces as venvs” idea from the threads above, and it leaves the venv’s location entirely up to the user.
Relation to existing work
colcon-uv manages Python dependencies per package, installed during colcon build. This post focuses on one environment and one lockfile per workspace; the two granularities address different needs (per-package isolation vs. one shared environment for a whole launch graph) and can coexist.
Pixi as a co-official installation method concerns how ROS itself is installed. The scope here is different and does not compete with it: keeping the standard apt installation and making the Python layer of one workspace reproducible.
ros-python-wheels distributes ROS client libraries as pip-installable wheels. The direction here is complementary: using pip/uv-managed dependencies inside a standard, apt-based ROS workspace.
A similar uv setup (--system-site-packages + lockfile) has been shared in Status of Colcon building “standards-based” Python packages, with nodes started directly through python. The measurements above cover the case where colcon, ros2 run, and ros2 launch stay in use.
Open questions
For P1: would a package-identification extension in colcon-core, modeled on the existing COLCON_IGNORE one, be an acceptable shape — or would this fit better as a separately distributed extension package?
For P2, which layer would be better suited to handle the develop-path shebang — colcon-core, or the setuptools develop machinery?
For those running workspace-level venvs with colcon in CI or on production robots: which failure modes are missing from the list above (overlays, cross-compilation, non-Ubuntu platforms)?
I’ve been working on a global planning engine aimed at warehouse/fleet
deployments, and I just opened a free API tier. I’d love feedback from people
running real Nav2 fleets.
What it does
You upload an occupancy grid once. It solves a field for your goal (charging
station, pick station, dock), and from then on every path query — from any
start cell — returns a strictly optimal path in microseconds, without
re-searching the map.
The pitch for fleet operators: the cost of global planning stops scaling with
the number of robots.
Measured numbers (C++ core, single thread, low-end 2-core CPU)
1M-cell 3D warehouse map (100³, mezzanine floors + rack walls):
Metric
VectorField
A* (C++, typical)
One-time solve per goal
47 ms
—
Query, any start pose
7 µs
~5 ms, every query
Optimality
1.0000 (BFS-verified)
optimal
Peak memory
5 MB
—
10,000 simultaneous queries
70 ms total
~50 s
Dynamic sites: obstacle removal (cleared shelves, opened gates) is patched
exactly, 5.9× faster than a rebuild, zero error. Every solve is a fixed,
bounded number of identical array operations, so worst-case latency is known
in advance — relevant if you need timing guarantees for certification.
Where this fits in a ROS stack
Input: an occupancy grid (the same data you already publish on /map or
keep in a costmap_2d layer)
Output: an optimal cell path per query
Today: plain REST API, so anything that can HTTP can plan. A native Nav2
global-planner plugin (drop-in replacement for Navfn) is on the roadmap —
the field-reuse model maps nicely onto multi-goal / fleet planners, which is
exactly where Navfn recomputes the most.
Typical integration I’m picturing: your fleet manager uploads the map once per
shift (or per layout change), then every robot’s global plan request is a
~7 µs lookup instead of a Navfn re-search.
Honest limitations
Built for structured, mostly-static environments — warehouses, factories,
indoor drones. Not for highly dynamic unstructured spaces.
Obstacle insertion currently uses a repair fallback; exact fast insertion is
roadmap work.
It’s a hosted API (with an on-prem license option), not an open-source
package. Free tier is genuinely free: 100³ maps, 1,000 solves + 100K
queries/month.
For those running multi-robot fleets: how do you handle global replanning
cost today? Is 5 ms/query/robot actually hurting you, or is local planning
the real bottleneck?
What would a Nav2 plugin need to do for you to consider it (topic/action
interface, costmap update cadence, multi-goal support)?
Any interest in an on-prem / offline deployment for sites without
connectivity?
The OSRF Infrastructure Project is planning to update the Jenkins version of https://build.ros2.org as part of our ongoing efforts to maintain and improve the ROS buildfarm infrastructure. To facilitate this migration, the following services will experience downtime during the maintenance window:
https://build.ros2.org (Jenkins) will be temporarily unavailable or in shutdown mode (not running jobs).
The migration is scheduled to begin on Monday Mon, Aug 3, 2026 11:30 AM UTC (11:30 UTC) and is expected to last for 4 hours. During this time, the buildfarm will be offline, and all queued jobs will need to complete before Jenkins is taken offline.
Once the upgrade is complete, I’ll update this thread to confirm that services are back online. I’ll also be monitoring for any issues that may arise as a result of the upgrade.
Thank you for your patience as we work to improve the ROS buildfarm infrastructure. If you have any questions or concerns, please feel free to reach out in this thread.
Just saw that newly imported Chinese legged and humanoid robots are now banned in USA, what other alternatives are there? I know Unitree had ROS interface in both Go2 dog and G1 humanoid (and you could jailbreak cheap base version instead of expensive research one).
What other alternatives are there?
Will this spur open source/open hardware design?
Again, I’m adding poll of what legged/humanoid robots have you used/planned to use
What legged/humanoid robots have you used/will use?
Recently, I’ve been learning more about Zenoh and its role in the ROS 2 ecosystem. Since most ROS 2 applications rely on DDS for communication, I was curious about how Zenoh approaches the same problem and where it can provide advantages.
From what I’ve learned so far, Zenoh offers a lightweight communication layer that aims to reduce latency, minimize bandwidth usage, and simplify communication across distributed systems. These characteristics make it particularly interesting for robots running on resource-constrained hardware such as the Raspberry Pi or for systems that need to communicate across different networks.
I’m currently developing a mobile robot called Pavlov Mini Wheel, based on ROS 2 Humble, and I’m planning to experiment with Zenoh for communication between the onboard Raspberry Pi and an external laptop running perception and navigation workloads. It seem like an interesting opportunity to compare its behavior with the default DDS-based setup.
This post is the first step in my exploraiton of Zenoh. Over the next few weeks, I plan to document:
Installing Zenoh with ROS 2 Humble
Integrating Zenoh into a existing ROS 2 project
Comparing DDS and Zenoh in practical robotics scenarios
Sharing performance observation from a real robot
If you’ve already used Zenoh in your projects, I’d be happy to hear about your experences, recommendations, or challenges you’ve encountered.
[Update] Thanks to the great feedback in the comments regarding rosbag2 snapshot, I have updated the original post to clarify how YERP and rosbag2 snapshot work perfectly together as a trigger-and-capture pair!
Hi everyone, Recently I have been thinking about a very practical debugging problem in ROS / ROS2 perception pipelines, especially for AMRs and mobile robots. When a robot behaves strangely in the field, the usual workflow is often:
rosbag record everything.
Bring the massive data back.
Replay it and try to find what happened.
Of course, rosbag2 is powerful. I am also aware of rosbag2 snapshot mode, which can keep recent messages in memory and dump a raw topic window when triggered. That is actually very close to the architecture I have in mind. I do not want to replace rosbag2 or its snapshot mode. Instead, I want to explore a lightweight layer above it: an event-triggered Runtime Evidence Layer for ROS perception pipelines.
rosbag2 snapshot: captures the raw ROS topic window.
YERP / EvidenceFlow: decides when the snapshot is worth triggering, records why it was triggered, and adds structured perception-runtime evidence.
So the question is not: Can YERP replace rosbag2? The question is: Can YERP act as the lightweight anomaly detector / evidence sidecar layer that triggers rosbag2 snapshot at the exact right moment?
For example, a robot may run normally most of the time, but occasionally:
average FPS looks fine, but p95 / p99 latency spikes
the local planner receives perception results too late
a detection frame creates too many candidates
postprocess suddenly dominates runtime
the issue is hard to reproduce later
In that case, raw topic replay is useful, but we also need to know:
Why was this moment captured?
Which frame was involved?
Which perception stage became slow? (preprocess, inference, postprocess, callback delay, queue delay, or message age?)
Did output pressure increase? Was there a box-count or candidate-count spike?
That is the role I am exploring for YERP.
Current prototype status
The current YERP Vision prototype has already been tested in a standalone YOLO / edge CV pipeline. It can monitor fields such as preprocess_ms, inference_ms, postprocess_ms, p50/p95/p99 latency, box count, and confidence entropy.
When a runtime pressure event is triggered, it saves local evidence (image.jpg, metadata.json, etc.).
In one test case, a normal-looking YOLO frame was captured not because it was manually labeled as a “[bad frame] ”, but because the runtime trace showed pressure:
The important point is not that the image “looks abnormal”. The important point is: this input frame created measurable runtime pressure, so it became worth saving as evidence.
Community Momentum
This concept is already gaining cross-community traction:
I have introduced this EvidenceFlow approach in the Ultralytics GitHub Discussions, where the team is currently gathering feedback.
I’ve also initiated an open co-testing discussion within the MindSpore Lite community, and developers there are exploring collaboration for edge NPU inference.
Now, I want to bring this discussion to the ROS ecosystem, which is arguably where field debugging is the most painful.
EvidenceFlow Schema v0.1 Draft
Instead of exposing all internal YERP logic, I am thinking about a simple structured sidecar format. A ROS / ROS2 runtime pressure event could look like this:
The goal is not to force every ROS project to use these exact fields, but to discuss what a useful runtime evidence record should contain.
Runtime Overhead
A natural concern is: Will such a probe slow down the robot?
Absolutely valid. A probe should not become the new bottleneck. The design separates the workload:
Fast path (Main inference loop): read existing timestamps, update a fixed-size rolling window, check trigger conditions. No file IO, no large tensor copies, no image saving.
Slow path (Background worker): after a trigger, write JSON / image in a background worker, and optionally call rosbag2 snapshot service. Uses a bounded queue and drops evidence if full to avoid blocking inference.
For production ROS / ROS2 systems, the default modes would likely be shadow_mode (observe only) or (write only when triggered).
How I imagine the rosbag2 integration
Observe: YERP observes perception timing and output metadata.
Log: YERP writes a small EvidenceFlow JSON sidecar.
Trigger: If raw replay is needed, YERP calls rosbag2 snapshot service.
Result: raw bag window + structured reason for capture + perception-stage timing + output metadata.
In short: rosbag2 snapshot tells us what raw ROS messages were around the event. YERP / EvidenceFlow tells us why this event was worth capturing.
Questions for the ROS community
I would really appreciate feedback from people who debug ROS / ROS2 robots in the field.
Does this EvidenceFlow schema cover the information you would want when debugging ROS perception latency?
For ROS2, should such an adapter start at the image topic level, diagnostics level, or executor / callback timing level?
For AMR / mobile robot scenarios, which fields matter most? (frame latency, message age, queue delay, callback delay, TF wait time, etc.)
How do you currently trigger rosbag2 snapshots in real robots? (Manual trigger? Diagnostics threshold? Topic frequency monitoring? Custom anomaly detector? Lifecycle event? Nav2 state?)
Would a small structured JSON sidecar make snapshot bags easier to triage later?
Boundary
To avoid misunderstanding:
YERP is not a replacement for rosbag2.
YERP is not a replacement for tracing or profilers.
YERP does not identify the final root cause by itself.
YERP tries to capture the input frame and runtime metadata that make a case worth investigating.
My current goal is to turn field debugging from “record everything and search later” into “capture structured evidence when runtime pressure actually happens”.
I am sharing this as an early prototype and schema draft. Comments, criticism, field stories, and suggestions are very welcome!
If you find this “Runtime Evidence Layer” concept valuable for your edge AI ROS deployments, or if you are interested in co-designing the ROS2 adapter together, feel free to drop a comment below, open an issue on GitHub, or reach out to me directly!
Over the past few months, I've had the privilege of stepping into the role of leading ROS-Industrial Americas. I'm grateful to Matt Robinson for his years of leadership and the strong community he helped build. At our 2026 Annual Meeting, I had the opportunity to share my first impressions and my vision for where we can go next.
I've reproduced that welcome letter below, because it captures the direction I hope we'll pursue together.
This is my first annual meeting as program director for ROS-Industrial Americas, and one thing has become clear very quickly: the strength of ROS-Industrial has never been a single individual or organization. It's the community itself.
Since we announced the leadership transition, I've heard from dozens of members offering encouragement, advice, questions, and ideas.
You made it immediately obvious that you participate in ROS-Industrial not because of a logo or affiliation, but because you genuinely care about advancing industrial robotics. That commitment matters especially now.
It feels like a lot has changed since our last meeting a year ago. Large language models have rapidly evolved from impressive demonstrations into practical tools used daily by engineers around the world. Those same advances are now beginning to reshape robotics as well.
Major technological shifts create uncertainty, but they also create opportunity. One of the reasons ROS-Industrial exists is to help practitioners evaluate emerging technologies, separate signal from noise, and move useful ideas from research into real-world deployment.
For fourteen years now, ROS-I has helped industrial robotics practitioners advance, adopt, and apply technologies that were once difficult to deploy reliably in industrial contexts. Today, we're seeing another transition. Robotic foundation models, LLMs, Physical AI, synthetic data generation, and learning-enabled systems are creating capabilities that seemed impractical not many years ago.
The question for us is no longer whether these technologies will influence industrial robotics. As we will hear from several speakers, they already have. The question is how we incorporate them responsibly, effectively, openly, and practically into real systems.
As I step into this role, I see part of my responsibility as helping this community ask those questions clearly and answer them together.
ROS-Industrial's mission remains the same: enabling innovation in industrial robotics through collaboration, open-source technology, applied research, and education. New technologies will continue to emerge, and our responsibility is to understand them, evaluate them, and make them useful to industrial practitioners. Today, that includes AI. Tomorrow, it will include technologies not yet imagined.
I am grateful to inherit that mission, and I am committed to stewarding it with diligence, openness, and practical focus.
At this year's meeting, our speakers will introduce new open-source robotics software, explore novel applications of AI, discuss new opportunities for open-source automation, and share real-world experience deploying these solutions in specific contexts. Our workshops will give you a focused opportunity to direct the consortium over the coming years.
But the future of ROS-Industrial will not be determined by keynote speakers, steering committees, or roadmap documents alone. It will be shaped by practitioners who bring real problems, real deployments, real successes, and even real failures back to the community.
I offer my sincere thanks to every one of you and your colleagues who have fed this community over the last year: contributing code, sharing lessons learned, participating in projects, mentoring newcomers, and helping move open-source robotics technology from research into production.
I'm excited about this meeting, but I'm more excited about what we'll all do together in the year ahead.
Sincerely, Jerry Towler Program Director, ROS-Industrial Americas
Hi all — I’m a security engineer researching runtime security for autonomous mobile robot fleets (warehouse/3PL AMRs on ROS 2). I keep hitting one question I can’t answer from the outside, and I’d value the perspective of people who actually run or build these fleets:
For fleets already deployed in production — is anyone doing continuous security monitoring (detecting anomalous behaviour at runtime), or is security still mostly design-time hardening (SROS 2, DDS security) and then hands-off?
When an operator worries about a robot being compromised, is that framed as a cybersecurity problem or purely as a safety/uptime problem? Who owns it internally?
Not selling anything — genuinely trying to understand the current state before assuming a gap exists. Grateful for any real-world experience.
Would you use a free CLI tool to convert CAD assemblies to URDF?
No CAD plugins.
Just one command from your terminal to work in Ros directly.
I’m thinking about open-sourcing the core of a tool I’ve been building over the past few months, and I’d love to validate the idea before releasing it.
The group is skipping two meetings (2026-07-27, 2026-08-10) due to lack of available members!
The next meeting of the CRWG will be at Mon, Aug 24, 2026 4:00 PM UTC→Mon, Aug 24, 2026 5:00 PM UTC, where we will continue editing the first draft of the Logging and Observability guide. We also worked on this last session, but decided not to record as it would make for pretty dry video content!
I’ve spent the last few months building ������� to automate one of the most repetitive parts of robotics development. Instead of manually converting CAD assemblies, configuring joints, generating robot descriptions, and debugging the first setup, the goal is a verified, ready-to-use robotics workspace automatically in ������ and ����.
But now I’m at a point where the technical part feels solid. The new challenge is figuring out how to reach the right users for such a ��������� �������.
If you’ve built developer tools or engineering software, how did you get your first 10 to 50 users? What channels actually worked? What wasted effort would you skip if you started again?
Each event seems to offer “Copy to my calendar”, which does copy a particular event on to my calendar, but the event doesn’t seem to get updates from the original event entity. Also even if the original event is recurring, the copied event seems to be one-time.
Choosing “Add to Google Calendar” option adds this entire community event calendar to my calendar, which shows all events, not just the ones of my interest.
The idea of aggregating the community events at a single location is great!!! It’s just on my personal calendar, having all events would be simply too much, so would like to be selective.
Jetsons seemed to me to have the most mature ecosystem, but some of those price increases surely puts them away from reach of students/hobbyists, and can have also impacts on larger fleet deployments.
I am releasing PyZeROS, an experimental alternative to rclpy for communicating with ROS from Python. This is not a Python wheel packaging rclpy: I bit the bullet and wrote a client from scratch in pure Python.
You can install PyZeROS like a standard python package:
pip install pyzeros
It does not require a ROS installation, colcon workspace, message compilation, or a ROS executor. It communicates with ROS 2 through Zenoh and interoperates with standard ROS 2 nodes using rmw_zenoh_cpp.
The main features are:
Interoperability with Jazzy and Lyrical
Designed for asyncio and asynchronous Python
Topics, services, and QoS
Custom ROS messages defined directly with Python classes
Installation through pip with minimal dependencies
A subscriber looks like this:
import asyncio
import asyncio_for_robotics as afor
import pyzeros
from ros2_pyterfaces.cyclone.all_msgs import String
async def main():
sub = pyzeros.Sub(String, "chatter")
async for msg in sub.listen_reliable():
print(msg.data)
with pyzeros.auto_context(node="listener", namespace="/demo"):
asyncio.run(main())
Why another ROS 2 client?
You’ll find that Rust has many independent ROS 2 client implementations, all with interesting designs and trade-offs. In Python, however, we have only rclpy, and RoboStack+Pixi as (fantastic) alternative installation method.
I made PyZeROS as a Python-native option built around standard Python tooling and asyncio. It’s not a repackaging of rclpy or rcl and is widely different from it. The goal is to communicate with a ROS network from python, not to integrate with the whole ROS ecosystem.
Main differences are:
PyZeROS installs through pip, so it should work easily with standard isolated-environment tooling like venv, uv, pipx, uvx, pixi.
It is primarily coded in python so no additional colcon build to compile a message types. And Python developers can dive into the source code.
It uses standard Python tools and small dependencies. It should run mostly anywhere.
PyZeROS deliberately does not aim to support every ROS feature. The Python ecosystem is prioritized: argparse for configuration, subprocess for launching processes, and importlib.resources for shared package data.
asyncio is the primary executor.
Why asyncio?
Robots are asynchronous systems, so they need an execution model. Python already has one: asyncio, so I use it.
Using callbacks directly is possible, but it can quickly lead to shared-state issues, locks, and complicated lifecycle management. After using asyncio in robot applications for several years, I find async/await much easier to reason about, and the python community has many tools for it. In my benchmarks, PyZeROS is also significantly faster than rclpy’s callback-and-executor model, so there does not appear to be a large performance hit from asyncio.
Custom messages
This is essential to ROS, and making them easy to define was especially important to me. In PyZeROS, you can define them directly as Python dataclasses and interoperate with standard ROS 2 messages:
from dataclasses import dataclass, field
import pyzeros
from ros2_pyterfaces.cyclone import all_msgs, idl
@dataclass
class Sphere(
idl.IdlStruct,
typename="tutorial_interfaces/msg/Sphere",
):
center: all_msgs.Point = field(default_factory=all_msgs.Point)
radius: idl.types.float64 = 0.0
pub = pyzeros.Pub(Sphere, "sphere")
pub.publish(Sphere(radius=42.0))
There is no .msg file, CMake configuration, or colcon build required on the PyZeROS side. For interoperability, the type name, field names, and field types must match the message definition used by the other ROS 2 nodes.
Performance
I also measured PyZeROS against rclpy for round-trip latency:
PyZeROS: ~13 µs
rclpy with SingleThreadedExecutor: ~70 µs
This is about 5.5× faster in this microbenchmark.
The benchmark sends sensor_msgs/msg/JointState messages continuously inside one node using two publisher/subscriber pairs. Keeping everything local minimizes transport latency, so the benchmark primarily measures executor and message serialization/deserialization overhead.
I also tested PyZeROS in a more realistic stress test with 100 nodes publishing mostly JointState messages at around 10 Hz. This uses my own ROS nodes for controlling a robot swarm that I have been working on for several years. In that application, the PyZeROS version used roughly one-quarter of the CPU used by the rclpy version.
Related libraries I created for PyZeROS
ros2-pyterfaces is how I define messages in Python. It provides XCDR1 serialization and ROS RIHS01 type hashes. It can serialize using cyclone_idl (tweaked by me) or cydr (created by me), with cydr being faster than rclpy to ser/de messages. It is a standalone low-level library, so it can also be used independently to send ROS messages over DDS or another RMW:
asyncio-for-robotics (afor) is the asynchronous model that I’ve been using on my robot software for a while now. It already supports ROS (rclpy) and other systems, and it now supports Lyrical and its new AsyncNode:
Feedback, testing, issues, and contributions are very welcome. I am sure there are still some rough edges, but I cannot wait indefinitely for perfection before releasing it. Reaching this point took a long time. ROS is a large ecosystem, and I am already very happy to have topics and services working
I recently released OnSLAM, an open-source Windows application for running LiDAR-inertial odometry and mapping on ROS1 bag files.
It automatically detects compatible LiDAR and IMU topics, runs the mapping pipeline locally, visualizes the trajectory and point-cloud map in the browser, and exports PLY and PCD files.
The main goal is to make it easier to inspect datasets, demonstrate LIO mapping, and generate maps without rebuilding a complete Linux and ROS environment.
The project is still early, and I am looking for users willing to test it with different sensors and datasets.
ASL ETHZ,
What does protoros2 do?
Key Features & Use Cases
Enterprise Security Built-in
Acknowledgement
已创建: src/my_pkg/CMakeLists.txt
功能包 [my_pkg] 生成完毕！
提示: 记得在 CMakeLists.txt 中根据需要补充依赖项。
