Planet ROS
Planet ROS - http://planet.ros.org
Planet ROS - http://planet.ros.org
http://planet.ros.org
ROS Discourse General: ROS 2 Jazzy for macOS (Apple Silicon): release 26.11.20.9, self-contained, Gazebo included, Nav2 up in 78 s
A new ROS 2 Jazzy for Apple Silicon Macs is out on Homebrew: ros2-jazzy 26.11.20.9. It’s built natively on macOS from source, with no VM or Docker. Installation and setup are in the tap: idesign0/homebrew-ros2.
Video (real speed): a TurtleBot 4 launches with Nav2, undocks and drives 11.6 m across the warehouse world on an M2.
ROS 2 Jazzy on macOS (Apple Silicon): TurtleBot 4 + Nav2 in Gazebo, real speed
TL;DR
- About 1,870 packages from 638 source repos. Most of the ~200 not shipped are Linux-only (kernel or device APIs, CUDA) or depend on one.
- Self-contained: the Homebrew libraries it was built against ship inside the package, so a Homebrew update on your Mac can’t break it any more.
- Gazebo Harmonic included (Ogre 2 on Metal).
setup.zshsets every path, so remove any oldGZ_*/QML2_IMPORT_PATHexports. - Faster startup: libraries are dead-stripped. A TurtleBot 4 + Nav2 sim (Gazebo GUI + RViz) went from 2–3 min to 78 s.
What changed compared to the previous Jazzy
| Before | 26.11.20.9 | |
|---|---|---|
| Homebrew dependencies | linked against your Homebrew, relinked in post_install (broke on abseil/DART updates) |
bundled in the keg: 215 libraries, 28 frameworks; nothing loads from Homebrew at run time |
| Gazebo | separate copy, GZ_* exports in your shell |
Harmonic from inside the keg (opt/gz_*_vendor), no exports |
| Direct library links | ~190 per Nav2 server | 6 per Nav2 server, 77 % fewer across the tree (-dead_strip_dylibs) |
| TurtleBot 4 + Nav2 bring-up | 2–3 min | robot + map ~22 s, full stack 78 s |
ros2 CLI |
~0.4 s per command |
Also included: MoveIt 2, Nav2, ros2_control, Autoware Core, MOLA, RTAB-Map, Cartographer, PCL, Webots, MuJoCo, Open-RMF and MAVROS, plus Zenoh, Cyclone DDS and iceoryx as middleware.
Tip for big launches: Cyclone DDS on loopback
With dozens of nodes (Nav2, TurtleBot), this profile was the most reliable one on macOS:
export RMW_IMPLEMENTATION=rmw_cyclonedds_cpp
export CYCLONEDDS_URI='<CycloneDDS><Domain><General><Interfaces><NetworkInterface name="lo0" multicast="true"/></Interfaces></General><Discovery><ParticipantIndex>none</ParticipantIndex></Discovery></Domain></CycloneDDS>'
ParticipantIndex none: the default per-process index pool runs out with big launches.lo0: discovery multicast over Wi-Fi was lossy. The same launch came up in 20 s, several minutes or not at all; on loopback it comes up in ~22 s every run. This only works when all nodes are on one Mac.- Don’t combine it with
ROS_AUTOMATIC_DISCOVERY_RANGE=LOCALHOST.
The Fast DDS shared-memory issue from my RMW measurements post is fixed in the next build. That build carries eProsima/Fast-DDS#6632 (still in review upstream) in our Fast DDS fork.
Known issues
- Nav2
map_servercan’t read.pgmmaps yet: the bundled GraphicsMagick is missing its decoders. Until the next build:export DYLD_LIBRARY_PATH=$(brew --prefix graphicsmagick)/lib:$DYLD_LIBRARY_PATH. - Building your own workspace against it works for about 96 % of packages (
find_package()from a clean overlay). Some gz components and Boost.Python still fail; that’s what I’m working on now.
Upstream first
I don’t want a macOS fork of ROS 2. 101 of the 638 repos are forks carrying macOS fixes, each tracking its upstream branch, so upstream changes land automatically. The fixes go back upstream: so far 76 PRs in 44 projects, 40 merged (Nav2, MoveIt 2, ros2_control, RViz, rosbag2, MOLA, …).
Build system: idesign0/ros2_macOS. If something doesn’t work on your Mac, please open an issue in the tap. Reports from other Macs and macOS versions are especially welcome.
1 post - 1 participant
ROS Discourse General: Cloudini 1.5.0: brutally faster, same great compression
Hi,
I have a sufficiently meaningful release to decide bothering you people.
Cloudini 1.5.0 is out, and it is 50% faster than before (it was already pretty damn fast).
1 post - 1 participant
ROS Discourse General: Resetting/Clearing a message without reallocating?
I’m looking for feedback about an problem/proposal!
I find when writing controllers or other performance sensitive c++ code where I want to publish something, that I have to make a compromise between memory efficiency and semantics/correctness. Specifically, I would like my code to behave as if I am creating a new message from scratch each time, but without actually doing that. But right now I either have to store/reuse a message (like realtime publisher does), or create a new message each time. Creating a new one will get rid of any memory (especially heap memory allocated by the lists in the message). Reusing one risks leaving some fields or subfields with stale data from the previous iteration.
Does anyone have tips for me here?
Finally, I would propose that the code gen for cpp messages could generate a clear method, which would clear all lists in the message and recursively for sub messages, plus also maybe resetting any other types to their default values. Thoughts?
1 post - 1 participant
ROS Discourse General: submissions for biggest 3D awards are open, wanted to share in case anyone's interested :)
hey all! I’m one of the organizers for Z-axis awards, the world’s largest creative award in AI 3D, with a $300,000 prize pool. It’s funded by Meshy supported by OpenAI, Capcut, Unity, Elevenlabs, and more!
I love seeing what this community is building! With robotics, one of our six tracks, we want to recognize the people bringing ideas to life in 3D and finding creative ways to use AI 3D in the real world.
Applications are open here: https://www.meshy.ai/z-axis-awards. would love to see y’all’s projects presented ![]()
1 post - 1 participant
ROS Discourse General: Full ROS2 Lyrical support for Pollen's Reachy Mini
Hi ROS folks!
After testing, refining and eventually adopting it in our lab, time to share with everyone our ROS2 stack for Pollen Robotics’ Reachy Mini.
Some highlights:
- ROS2 Lyrical + zenoh; easy to install (one deb package that pulls and keeps a Lyrical Docker image up-to-date)
- install side-by-side with the Pollen SDK: you choose whether you want ROS or the SDK via a simple
systemd enable/disable - Compatible with ROS4HRI https://ros4hri.github.io/
- Hardware video compression → 30fps full HD over Wifi
- realtime ASR + TTS on Reachy’s RaspberryPi 4 (!)
Installation instructions:
Source code:
…and a big thank
to the LLMs which made it possible in a short time frame!
1 post - 1 participant
ROS Discourse General: Fault correlation for ROS 2: one cause, many faults (and what automotive does about it)
I have dug through noisy logs many times just to find the one real cause. Two situations keep coming back.
At startup, every robot I have worked with throws a pile of errors because drivers are still connecting and nodes are waiting for each other. Most go away on their own, but they sit in the log next to the one that matters.
Then there are chain reactions. One thing breaks and a minute later other nodes report missing data, timeouts and a failed bringup. I already know this is really one fault, but the robot reports it as many.

The case we rebuilt
We staged a startup with Nav2 Jazzy and AMCL in which a Hokuyo Ethernet lidar never connects, as with a pulled data cable or a wrong subnet. The texts are verbatim from urg_node and Nav2, replayed at their real repeat rates.
urg_node reports the diagnostic status “Not Connected”. AMCL publishes map to odom only after it processes a scan, so it never publishes it here. It logs nothing about the missing scans.
global_costmap logs “Timed out waiting for transform from base_link to map to become available” every half second at INFO and fails to activate after 60 seconds. lifecycle_manager_navigation reports “Failed to bring up all requested nodes. Aborting bringup.” and bt_navigator rejects the goal.
The launch log ends up with 164 messages on 222 lines. The lidar error is in there 29 times, between 120 costmap messages. Nothing in the log links one to the other.
How AUTOSAR handles this
Cars have had this for years. The AUTOSAR Classic Diagnostic Event Manager has event dependencies (SWS DEM R24-11, section 7.3.6). Events are assigned to components with parent relations and priorities. A FAILED report while a parent component is FAILED is a “consecutive fault” and is not stored in the failure memory. A causality delay time lets a failure be reclassified when a parent or higher priority failure is reported shortly after it.
The same idea in ros2_medkit
For startup faults, when healing is enabled, PASSED reports heal a fault and take it off the active list.
For the chain reaction we wrote one rule. It names the lidar fault as the cause, the scan, costmap, lifecycle and goal rejection codes as its symptoms, and a time window:
correlation:
enabled: true
default_window_ms: 500
patterns:
scan_dependent_localization:
codes: ["LIDAR_SCAN_TOPIC_NO_EVENTS"]
nav2_global_bringup:
codes: ["GLOBAL_COSTMAP_*", "NAV_LIFECYCLE_*", "BT_NAVIGATOR_GOAL_REJECTED"]
rules:
- id: lidar_not_connected_blocks_localization
name: "Lidar driver is not connected"
mode: hierarchical
window_ms: 5000
root_cause:
codes: ["LIDAR_NOT_CONNECTED"]
symptoms:
- pattern: scan_dependent_localization
- pattern: nav2_global_bringup
mute_symptoms: true
auto_clear_with_root: true
A symptom that arrives after a report of the cause and inside the window is linked to it and muted. The window is measured from the latest report of the cause. That matters here because the costmap gives up a full minute after the lidar first fails. The rule works on fault codes that nodes report to the fault manager, so the reporters decide what a code means.
With this rule, GET /api/v1/faults returned one fault, LIDAR_NOT_CONNECTED, with muted_count 6. ?include_muted=true lists all seven with a root_cause_code for each symptom. Unlike AUTOSAR’s failure memory, a muted symptom stays stored.
Suggesting rules from fault history
After we first shared this, someone asked whether the rules have to stay hand-written (related comment). The fault history already holds what is needed to suggest them: which codes always follow which and how long after.
We would like the system to propose a rule once a pattern holds across many bringups, with an engineer approving it. A wrong rule would mute a real fault. The same history could also flag a symptom that shows up without its usual cause, which often means something changed on the robot. None of this exists yet.
API responses and how to run the example: One Cause, Many Faults: Fault Correlation in ROS 2 | selfpatch.ai
Two questions for the packages you maintain:
- Which failures report their symptoms before the underlying cause, and how do you handle that ordering today?
- And would you trust a rule that was suggested from history, if you had to approve it first?
1 post - 1 participant
ROS Discourse General: ROS 2 on macOS: measured topic rates for each RMW, a Fast DDS shared-memory pitfall, and tuned presets
I run ROS 2 Jazzy and Kilted natively on macOS (Apple Silicon) through my Homebrew tap, idesign0/homebrew-ros2. In my thesis setup, a 2 kHz laser height sensor (std_msgs/Float64) arrived at only a few hundred Hz on the Mac, while the same setup gave the full 2 kHz on Linux.
I benchmarked every RMW on the Mac to find out why, how fast topics can go, and which settings get the most out of each option. Everything below can be reproduced with GitHub - idesign0/ros2-macos-rmw-bench: How fast can ROS 2 nodes talk on macOS? Inter-process rate/latency benchmark for Fast DDS, Cyclone DDS (+iceoryx), Zenoh and composition, with reproducers for macOS-specific issues. · GitHub.
TL;DR
-
Fast DDS’s default shared-memory transport (SHM) has a ~5.7 ms polling tick on macOS. Messages between processes arrive in bursts with ~3 ms median latency, at any rate. A
KEEP_LAST(1)subscriber at 2 kHz receives only ~350–450 Hz, and under heavy load delivery collapses to ~0 %. Linux is not affected. Root cause and proposed fix: [macOS] SHM transport wakes readers on a ~5.7 ms polling tick: Boost.Interprocess falls back to `spin_semaphore` on Apple · Issue #6639 · eProsima/Fast-DDS · GitHub. -
Easiest fix:
export RMW_IMPLEMENTATION=rmw_cyclonedds_cpp. Full 2 kHz at ~90 µs, clean to 50 kHz. -
Best tuned options:
Need Option Result Small messages, fast, no extra daemon Zenoh with batching off lossless to ~90 kHz at ~100 µs p99 (needs Zenoh’s router) Large messages Zenoh + SHM 4 MB at 1961 Hz (~7.8 GB/s), 0.3 ms Absolute fastest (C++ only) Cyclone + iceoryx 200 kHz at 10 µs p50 / 27 µs p99 Staying on Fast DDS FASTDDS_BUILTIN_TRANSPORTS=UDPv4clean to 20 kHz. Ignored with ROS_AUTOMATIC_DISCOVERY_RANGE=LOCALHOST
Setup
- Hardware and OS: MacBook Pro 13" M2 (Mac14,7, 8 cores), macOS 27.0.1, Apple clang.
- ROS 2: Kilted (Fast DDS 3.2.5, Cyclone DDS 0.10.5 + iceoryx 2.0.8, rmw_zenoh) and Jazzy (Fast DDS 2.14.7), from the tap above.
- Benchmark: C++ (
rclcpp) publisher and subscriber in two separate processes, built in Release. Each message carries its send time; the subscriber measures received rate, loss, duplicates and one-way latency. - “Clean” means at least 99.9 % of messages received and p99 latency under 1 ms.
1. A 2 kHz Float64 sensor stream (subscriber KEEP_LAST(1), best effort, rclcpp::spin)
| RMW / config | Received of 2000 Hz | Latency p50 | Latency p99 |
|---|---|---|---|
| Fast DDS, default (SHM + UDP) | 354–402 Hz | 0.5–1.0 ms | 5.2–9.8 ms |
| Fast DDS, default, depth 100 | 2000 Hz | 2.9 ms | 5.6–6.3 ms |
Fast DDS, FASTDDS_BUILTIN_TRANSPORTS=UDPv4 |
1995 Hz | 82–87 µs | 172–204 µs |
| Cyclone DDS | 1998–2000 Hz | 85–97 µs | 151–163 µs |
| Cyclone DDS + iceoryx | 1998–2000 Hz | 33–36 µs | 69–71 µs |
| Zenoh | 1981–1994 Hz | 127–149 µs | 271–275 µs |
| Zenoh, batching off | 1988–2000 Hz | 150 µs | 190 µs |
On Fast DDS the rate is fine with a deep queue, but every message is ~3 ms late: samples come in bursts every ~5.7 ms, and a KEEP_LAST(1) subscriber keeps only the last one of each burst.
2. How fast can you go? (Float64, two processes, subscriber depth 100)
| RMW / config | Clean up to | p50 / p99 there | Above that |
|---|---|---|---|
| Cyclone + iceoryx (C++ only, see caveats) | 200 kHz | 10 / 27 µs | 300 kHz: 98.8 % |
| Zenoh, batching off | ~90 kHz | 53 / 97 µs | the publisher is the limit: publish() slows to ~90 kHz and nothing is lost |
| Cyclone DDS | 50 kHz | 22 / 52 µs | 100–150 kHz: no loss, but p99 7.6–32 ms |
| Zenoh, default | 20 kHz | 31 / 52 µs | 50 kHz: p99 2.1 ms (batching) |
| Fast DDS, UDPv4 only | 20 kHz | 48 / 103 µs | 50 kHz: p99 20 ms; ≥ 100 kHz: 37–51 % |
| Fast DDS, default (SHM) | never | 2.9 / 5.7 ms at every rate | ≥ 100 kHz: 0–1.5 % received, seconds of latency |
| Same process (composition, intra-process) | 100 kHz | 3 / 19 µs (Cyclone) | 200 kHz: 98.9 % |
3. Large messages (two processes, 2 kHz offered, p50 latency)
| RMW / config | 256 KB | 1 MB | 4 MB |
|---|---|---|---|
| Zenoh + SHM | 1999 Hz, 78 µs | 1999 Hz, 128 µs | 1961 Hz, 296 µs |
| Zenoh | 2000 Hz, 173 µs | 2000 Hz, 399 µs | 869 Hz, 1.5 ms |
| Cyclone + iceoryx | 1912 Hz, 32 µs | 1982 Hz, 100 µs | publisher hangs with default RouDi pools; 2001 Hz, 341 µs with bigger pools |
| Cyclone DDS | 1989 Hz, 357 µs | 1964 Hz, 554 µs | 16 Hz |
| Fast DDS, UDPv4 only | 1994 Hz, 154 µs | 1780 Hz, 429 µs | 0 received |
4. Why Fast DDS SHM behaves like this on macOS
Fast DDS waits for SHM data on an interprocess semaphore from its bundled Boost.Interprocess. On macOS, Boost disables the native process-shared primitives (Darwin’s pthread_cond is not truly process-shared, and sem_init returns ENOSYS), so it falls back to a spin semaphore. After a short spin, that semaphore sleeps for half a system tick: sysconf(_SC_CLK_TCK) = 100, so nanosleep(5 ms), ≈ 6 ms in practice.
Shortening that one sleep (an injected nanosleep shim) made the problem disappear, which confirms the cause, but at a CPU cost. A proper fix with macOS 14.4’s os_sync_wait_on_address woke a second process in 6–10 µs in my prototype. Full analysis: [macOS] SHM transport wakes readers on a ~5.7 ms polling tick: Boost.Interprocess falls back to `spin_semaphore` on Apple · Issue #6639 · eProsima/Fast-DDS · GitHub.
Presets: best settings for each option
A. Cyclone DDS: simplest, recommended default
export RMW_IMPLEMENTATION=rmw_cyclonedds_cpp
- No daemon. 2 kHz at ~90 µs; clean to 50 kHz, lossless to ~150 kHz with a growing p99.
- Tuning: socket buffers,
MaxMessageSizeandFragmentSizemade no meaningful difference. The defaults are already its best. - Gotcha: if your
CYCLONEDDS_URIsets<ParticipantIndex>none</ParticipantIndex>(a common tip for many nodes), don’t also setROS_AUTOMATIC_DISCOVERY_RANGE=LOCALHOST. In my test that combination found no peers. - Avoid for very large messages: 4 MB arrived at only 16 Hz. Use Zenoh + SHM or iceoryx for those.
B. Zenoh: tuned, best all-rounder for high rates
ros2 run rmw_zenoh_cpp rmw_zenohd & # router, once per machine
export RMW_IMPLEMENTATION=rmw_zenoh_cpp
export ZENOH_CONFIG_OVERRIDE='transport/link/tx/queue/batching/enabled=false'
# large messages: also enable shared memory (only used for messages > 512 B)
export ZENOH_CONFIG_OVERRIDE='transport/link/tx/queue/batching/enabled=false;transport/shared_memory/enabled=true'
- Batching off is the important knob. At 50 kHz it cuts p99 from 2.1 ms to 65–112 µs. With it, Zenoh is lossless up to the ~90 kHz the publisher can sustain, and it applies back-pressure instead of dropping.
- SHM on is the best large-message option I measured: 4 MB at 1961 Hz.
- Not helpful:
transport/unicast/lowlatency=truemade the tail worse (p99 6–8 ms).
C. Fast DDS: if you have to stay on it
export RMW_IMPLEMENTATION=rmw_fastrtps_cpp
export FASTDDS_BUILTIN_TRANSPORTS=UDPv4
# do NOT set ROS_AUTOMATIC_DISCOVERY_RANGE=LOCALHOST
- Removes the 5.7 ms tick: 2 kHz at ~85 µs; clean to 20 kHz.
- Gotcha: with
ROS_AUTOMATIC_DISCOVERY_RANGE=LOCALHOST,rmw_fastrtpssets up its own SHM + UDP transports (rmw_fastrtps_shared_cpp/src/participant.cpp, Jazzy and Kilted). The variable is then ignored, and I measured the same ~330 Hz / 5 ms behaviour. - Tuning: a UDP-only XML profile with 4 MB socket buffers performed the same as the variable.
- Avoid:
RMW_FASTRTPS_PUBLICATION_MODE=ASYNCHRONOUS:publish()threwcannot publish dataat 5 kHz and aborted the publisher;- 4 MB messages: none arrived.
D. Cyclone DDS + iceoryx: fastest between processes (C++ only)
Both the Jazzy and Kilted kegs ship Cyclone built with iceoryx, plus iox-roudi and iox-introspection-client. Config files: ros2-macos-rmw-bench/config at main · idesign0/ros2-macos-rmw-bench · GitHub
- Start RouDi, the iceoryx daemon. Run one per machine, before or together with your nodes; nodes that start first wait for it.
iox-roudi # default pools: chunks up to 4 MB iox-roudi -c roudi_config_large.toml # adds 8 MB chunks, for messages >= ~4 MB - Enable shared memory in Cyclone:
Or merge theexport RMW_IMPLEMENTATION=rmw_cyclonedds_cpp export CYCLONEDDS_URI='<CycloneDDS><Domain><SharedMemory><Enable>true</Enable></SharedMemory></Domain></CycloneDDS>'<SharedMemory>block into the Cyclone XML you already use. - In a launch file, add
ExecuteProcess(cmd=['iox-roudi'])and set both environment variables withSetEnvironmentVariable. There’s a working example in the repo. - Verify it’s used: latency is the clearest sign, ~10 µs instead of ~70–90 µs over UDP.
iox-introspection-client --portlists the ports.
Results: 2 kHz at ~35 µs; 200 kHz at 10 / 27 µs; 1 MB messages at 1982 Hz, 100 µs.
Rules (from rmw_cyclonedds’ shared memory doc and my measurements):
- Types: zero-copy only for fixed-size message types: no strings, no sequences, so nothing with a
Header. Other types are serialized into shared memory, a smaller gain. - QoS: KEEP_LAST history; reliable and best effort both work. The doc says publisher depth ≤ 16; this build still used shared memory at 17 and 100, but keep ≤ 16 to be safe.
- Limits: one RouDi per machine; at most 127 subscriptions per process.
- Memory pool: if no chunk fits,
publish()blocks forever. A 4 MB message with the default pools hung my publisher. - No RouDi: every node waits for it and aborts after ~60 s.
Bugs I hit (Kilted, Cyclone 0.10.5), reported in Issues · ros2/rmw_cyclonedds · GitHub
- Duplicates between C++ and Python: when one endpoint is
rclcppand the otherrclpy, every message is delivered twice, in both directions. C++ ↔ C++ and Python ↔ Python are fine; every C++ number above was checked for duplicates. - QoS check bypassed: a reliable subscriber receives data from a best-effort publisher over shared memory, even though ROS logs the QoS as incompatible.
- Consequence:
ros2 topic hzshows 2× the real rate. - Known upstream:
transient_localover SHM (ros2/rmw_cyclonedds#401).
E. Composition: fastest with no daemon at all
Load publisher and subscriber as components into one component_container, with use_intra_process_comms: true. Messages never leave the process: 100 kHz at 3 / 19 µs on Cyclone. This works with any RMW.
F. For every option
- Queue depth: with bursty delivery (Fast DDS SHM, USB-serial sensors),
KEEP_LAST(1)/SensorDataQoSsilently drops most messages. If every sample matters, use a deeper queue, for examplerclcpp::QoS(50).best_effort(). - USB-serial sensors: macOS has no equivalent of the Linux udev
latency_timer=1rule for FTDI adapters. Data arrives in ~16 ms batches regardless of RMW. - Executor: the rclcpp EventsExecutor was within 5–10 % of the default at 2 kHz, so it’s not worth switching for this.
- Background load: Spotlight indexing or builds cause occasional 0.1–0.4 s stalls on every transport at high rates.
- Build in Release when you benchmark. An unoptimized build of my own benchmark cut large-message throughput ~3.5×.
Method and caveats
- Same machine, Release build. Each point is a 4 s window after 1.5 s of discovery; ranges are over repeated runs, measured on a quiet machine.
- The rate sweep’s subscriber busy-spins; a normal
rclcpp::spin()node will be a little lower. - Linux was not measured on the same hardware, so I can’t give a side-by-side comparison.
- Reproduce:
scripts/full_sweep.shin GitHub - idesign0/ros2-macos-rmw-bench: How fast can ROS 2 nodes talk on macOS? Inter-process rate/latency benchmark for Fast DDS, Cyclone DDS (+iceoryx), Zenoh and composition, with reproducers for macOS-specific issues. · GitHub runs everything above; RESULTS.md has every number.
Feedback welcome, especially from anyone who sees different numbers on Intel Macs or other macOS versions.
1 post - 1 participant
ROS Discourse General: ROS Wiki Content Migration Effort
In a long running background process, I have identified that there’s a lot of documentation of ROS packages in the ROS wiki which is now archived and many ROS packages don’t have README.md files which is the most common place for people to look for information in modern developmen times. GitHub renders it by default and so does index.ros.org (And this is even more relevant with agents too, they will be very unlikely to find content in the ROS wiki archive)
There’s hundreds of thousands of lines of documentation in there that’s becoming more and more inaccessible.
So what I’ve done is work for a while to setup a pipeline to take packages specific content from the wiki for each package documented there, make sure that there’s a modern equivalent in an active rosdistro. It then converts the Moin Moin Creole into markdown as well as including logic for parsing our custom ROS wiki macros and common structures like Tutorials and FAQs and aggregates those into a proposed README.md
I’m then opening a pull request against the noetic declared branch and if there’s also no content on the latest development branch also there. I’m manually reviewing and filtering out blank content and things that don’t look valauble, but I am not an expert in most of the content. As this is a lot about making sure data is persisted, I’m erroring on the side of opening the PR so that the content is available in the GitHub type of world and accessible/discoverable by future developers even if everyone forgets about the wiki because there’s a lot of valuable content in there that right now is basically going away.
You can see an example here:
I’m progressing through the packages in random order to spread out the load and submitting several per day.
My intent is for them to offer value to the maintainer who probably doesn’t have time to spelunk in the Wiki and convert the content themselves.
If you want to just close any or all of the PR’s that’s fine. If they don’t provide value please just close them and at least the content is now discoverable on GitHub in Markdown if someone else wants to pick it up in the future.
My current progress is below. I’ve submitted 95 of about 1000 with about a 50% reject rate. And that’s after the active filters brought it down from about 5600 packages.
Total packages: 5683
Matched: 1229
Unmatched: 4454
Archived (among matched): 122
Submitted: 95
Exported (no README): 679
Edited: 1
Review [tully2]:
Ready: 37
Ignored: 112
Unreviewed: 530
Extended (has README): 333
Edited: 0
Unreviewed: 333
And some statistics on the PRs opened so far
Summary
Packages submitted: 95
Pull requests: 141
Merged: 14 (10%)
Open: 121 (86%)
Draft: 0 (0%)
Closed: 6 (4%)
Lines changed:
All PRs: +22188/-0 in 368 file(s)
Merged: +1892/-0 in 39 file(s)
Open/draft: +18995/-0 in 299 file(s)
Closed: +1301/-0 in 30 file(s)
Packages with a merged PR: 11
Even with the current ~1800 lines of additional documentation I consider this a success, but I hope that we’ll get quite a bit more out of this.
You can see the process here: GitHub - tfoote/wiki_migration: A place for scripting the migration of ROS wiki content into package READMEs · GitHub
4 posts - 2 participants
ROS Discourse General: Runtime governability in ROS 2: where should changing operating conditions be handled?
Hi all,
I’m looking for architectural experience around a situation in which a ROS 2 system remains technically healthy, but an external operating condition changes while the robot is already performing a task.
ROS 2 already provides important mechanisms for component lifecycle management, supervision and recovery. Nav2 adds planning, control, recovery behaviour and local collision-related mechanisms.
My question is adjacent to those capabilities, rather than a proposal to replace them.
Consider a mobile robot navigating in a shared facility.
Localization is valid. The planner and controller are operating normally. There is no immediate collision hazard and no component failure.
While the task is underway, however, an external operating condition changes. For example, an area that was previously available for the operation is temporarily no longer available.
Where should that kind of changing context be represented and evaluated in a real ROS 2 architecture?
Possible locations might include:
- the task or mission layer;
- a separate supervisory component;
- a fleet or facility-level service;
- or a combination of local and external components.
I would particularly value practical experience around four questions:
-
Which layer should own and update this kind of operating context?
-
How should the system behave if the external source of that context becomes unavailable or outdated?
-
How can higher-level operational logic be introduced without weakening existing local safety, recovery or lifecycle behaviour?
-
In a multi-robot environment, which parts of the operating context should belong to each robot and which should be shared?
I have read the recent discussions here around runtime accountability and runtime trust or authorization. My question is deliberately narrower: the technical stack is functioning as designed, but the conditions surrounding the operation have changed.
At Sentryn, we use “runtime governability” as a public research term for this broader class of questions. We are not announcing a ROS package or claiming a completed ROS 2 integration.
I am mainly interested in existing architectural patterns, operational experience, counterexamples and relevant prior work.
Public research-level context:
Critical feedback is very welcome, particularly from teams operating ROS 2 robots outside controlled laboratory environments.
1 post - 1 participant
ROS Discourse General: Improved write performance for mcap/rosbag2
Hi all,
I just wanted to share that we’ve recently done a bunch of write performance optimizations in the mcap libraries. We’ve also updated rosbag2 in ROS 2 Rolling to take advantage of the new library, so writing your bags should be a bit faster than before. You can read about the improvements in Measuring and improving MCAP performance | Foxglove . Please leave any questions or comments about the improvements, or any future improvements you’d like to see.
Thanks,
Chris Lalancette
3 posts - 2 participants
ROS Discourse General: TC-PEBRAS is hosting a video competition! $250 awards, 3 min videos, due Dec 12, 2026
The IEEE RAS Technical Committee on Performance Evaluation and Benchmarking of Robotic and Automation Systems (TC-PEBRAS) is holding a video competition!
See webpage: PEBRAS Video Competition 2026
Participants are tasked with creating a video covering topics in scope of the TC, which includes performance evaluation, metrics, reproducibility, test methods, benchmarking, datasets, and competitions of robotics and automation systems. The goal of the videos is to promote and educate robot performance evaluation and benchmarking to a general audience (not just other scientists/engineers), highlighting the importance of these concepts in making research progress and transitioning robotics technologies from the lab to the field. Videos should be created specifically for this competition and can feature narrated commentary, interviews with researchers and developers, and demonstrations of PEBRAS topics in action, including footage from competitions and benchmarking exercises.
Participation
The TC-PEBRAS 2026 Video Competition is open to everyone with an interest in robotics, automation, and performance evaluation! We encourage junior and senior researchers to participate. You are not required to be an IEEE RAS member to participate. Your video could be motivated by questions including:
-
What current gaps are there in test and evaluation of robotics and automation? What metrics are missing? What new capabilities do we need to measure?
-
Are there existing test methods and evaluation practices you use in your research that you find particularly useful? Why or why not?
-
Have you participated in a robotics challenge or competition? What was your experience like? How can others be involved?
-
Have you tried reproducing the results of a robotics research paper? How did the results compare? Was it difficult?
Videos should be no longer than 3 minutes and can be uploaded to YouTube (public or unlisted) for submission over e-mail to tc.pebras.video@gmail.com with “TC-PEBRAS 2026 Video Competition” in the subject line by no later than December 12, 2026.
Awards
A total of four $250 awards will be given out across two tracks with a 1st and 2nd place designated for each:
-
General PEBRAS scope: covering any robotics domain related to PEBRAS scope, using footage from your lab, a conference, a competition, or elsewhere.
-
Humanoids 2026 activities: covering activities taken place at the Humanoids 2026 conference, including workshops, competitions, and exhibit displays.
Awards will be granted in the form of reimbursement for expenses related to conference travel (e.g., airfare, hotels). Digital and printed certificates will also be sent to the winners.
All videos will be posted to the IEEE RAS TC-PEBRAS website ( Performance Evaluation & Benchmarking of Robotic and Automation Systems - IEEE Robotics and Automation Society Website ) as part of a larger website update, coming soon!
Schedule
-
November 5, 2026: Competition opens
-
December 12, 2026: Submissions due by 11:59:59 Anywhere on Earth (AoE) via e-mail to tc.pebras.video@gmail.com
-
December 17, 2026: Winners announced
Please e-mail tc.pebras.video@gmail.com with any questions or comments. We look forward to seeing your videos!
1 post - 1 participant
ROS Discourse General: Do you see anything in AMR telemetry before docking/localization failures?
I’m working on an offline monitor for AMR deployment traces. In simulation, I’ve seen multi-sensor state signals change before a modeled failure boundary.
Has anyone seen something similar in real fleets? What signals do you look at before docking misses or localization resets?
2 posts - 2 participants
ROS Discourse General: What happened to "Robot-as-a-Snap"?
If you’re building on ROS 2, odds are you’re running Ubuntu. It’s the default for almost everyone. Over the last few years, Canonical has put a ton of engineering effort into pushing an Ubuntu Robotics ecosystem built around Snaps and Ubuntu Core.
On paper, it sounds like a dream setup for production robots:
-
Atomic & Transactional Updates: Ubuntu Core gives you atomic OS updates and transactional Snap updates. If an update breaks midway through, it automatically rolls back instead of bricking a robot in the field.
-
Version Linking: You can link snap dependencies across versions so you know everything is compatible before triggering an update across the fleet.
-
Built-in ROS 2 Tooling: Snapcraft has ROS 2 extensions and build plugins ready to go out of the box.
-
Observability & Fleet Management: Hooks into the Canonical Observability Stack (Telegraf, Prometheus, Loki) for real-time telemetry, plus Landscape to manage snap versions across your fleet.
Yet, despite all this tech being around for years, there’s surprisingly little chatter about it in the ROS 2 community. On Discourse and in forums, I rarely see people asking questions, sharing setups, or recommending snaps for production.
Instead, when people talk about shipping robots, it usually comes down to:
-
Standard
apton Ubuntu Server: Easy to set up, but updates are fragile. A failedapt upgradecan easily leave a robot in a broken state out in the field. -
Docker: Great for bundling dependencies, but configuring hardware passthrough for heavy GPU workloads like VSLAM or LLMs can add friction.
-
Yocto / Custom Embedded Linux: Gives you total control and clean atomic updates, but now your team is stuck maintaining every single system package.
Where’s the catch?
Why hasn’t the snap ecosystem become the standard way to reliably deploy software onto robot fleets?
-
Is strict confinement getting in the way of hardware access (like passing through GPUs for VSLAM/LLMs, direct serial, GPIO, or cameras)?
-
Is the developer iteration loop just too clunky compared to plain workspace builds?
-
Or are people just happier sticking with Docker or Yocto despite the maintenance headaches?
Curious to hear from anyone deploying ROS 2 in the wild: What are you actually running on your fleet, and what kept you on (or off) Snaps and Ubuntu Core?
15 posts - 6 participants
ROS Discourse General: Call for participation: UAV Perception Testing Track at ICST 2027 (ROS 2 Jazzy, PX4, nvblox, Isaac Sim)
Hi everyone,
We have opened the UAV Perception Testing Track, a tool competition in the Challenge Competition Track of ICST 2027, the IEEE International Conference on Software Testing, Verification and Validation. The question it asks is a practical one for anyone flying ROS 2 drones: which scenarios make a perception-driven autonomy stack fail, in how many different ways?

Flight c0017 from the released training data: after waypoint W4 a rotor strikes a placed pole, recorded as the mechanism (pole, rotor, turn).
What you build
A scenario generator. It writes forest scenarios for a quadrotor: a patrol route, the width of the lane cleared along it, poles placed near the route, tree density, wind, cruise speed and altitude. Generators can be written in Python with the provided starter kit and are submitted as Docker images.
The stack under test (fixed for every team)
- ROS 2 Jazzy
- PX4 in software-in-the-loop, Holybro X500 airframe
- Simulated RGB-D camera with RealSense D455 intrinsics
- nvblox volumetric mapping
- EGO-Planner
- NVIDIA Isaac Sim 6.0.1 with the Pegasus Simulator, procedural forest scenes
How it is scored
Each submission writes 20 scenarios on an undisclosed seed; every scenario is flown three times. A collision is recorded as a failure mechanism: what was struck (pole, tree or terrain), with which part of the vehicle and in which route phase. Generators are ranked by how many distinct mechanisms their scenarios reach, so a generator that finds new ways to fail beats one that repeats the same crash. Scores appear on a live scoreboard and each team can submit up to five times; each team’s best submission is flown again on a new seed for the final ranking.
You do not need a GPU or a local Isaac Sim install to take part: all flights run on our side, while released flight data is available for training on request.
Dates and recognition
- Submission deadline: 15 January 2027 (AoE)
- Prizes for the three best teams in the final ranking
- Participating teams may be invited to submit a 2 to 4 page tool paper in the ICST format
- Results are presented at ICST 2027 in San Sebastián, Spain, 17 to 21 May 2027
Links
- Track site: UAV Perception Testing Track
- Repository and starter kit: GitHub - IDeaLS-Lab/uav-testing-track-2027: UAV Perception Testing Track: a tool competition on test scenario generation for autonomous UAVs, proposed for the ICST 2027 Challenge Competition Track · GitHub
- Official ICST call: ICST 2027 - Challenge Competition Track - ICST 2027
Questions are welcome here or on the repository’s issue tracker. If you have worked on drone testing, nvblox or EGO-Planner, we would especially like to see what scenarios you come up with.
Prakash Aryan, on behalf of the organizers (The Italian Institute of Artificial Intelligence (AI4I) and the University of Bern)
1 post - 1 participant
ROS Discourse General: Intrinsic Core released: Open-source, ROS-compatible real-time control, motion planning and more
A couple of weeks ago during ROSCon, we released Intrinsic Core (GitHub - intrinsic-ai/intrinsic-core: Intrinsic Core™ provides an open, local runtime, SDK, and hardware agnostic, real-time control framework for industrial robotics. · GitHub), open-sourcing foundational capabilities and services from Intrinsic that we’ve been using for real-world manufacturing deployments. Intrinsic Core is interoperable with ROS via standard workspaces, message definitions, and tools, allowing developers to combine their existing ROS packages with Intrinsic capabilities.
We wanted to make it easier to prototype manufacturing workcells. It’s a pre-configured setup containing:
- A hardware-agnostic, real-time control framework, delivering fast, sensor-based feedback
- Pose estimation, motion planning, and grasp planning capabilities
- Simulation tools and a native digital twin
- A reference solution called the Open Machine Tending Solution (OMTS), giving developers a ready-made starting point for real-world CNC machine tending.
The coolest part since releasing this has been watching what people are already doing with it. We’ve seen community members build variations on OMTS that are picking up and inserting car wheels with a custom gripper and larger robot. It’s exciting to see people jumping in and demonstrating this with local inference and ARM support.
As a longtime contributor to open source robotics, I’m excited to see what else we’ll build together - and the solutions made possible by collaborating in the open!
If you want to dig into the code, try out the reference design, or check out how the real-time controller is structured, you can get the repo here:
Connect and find out more
We’re really trying to make this as practical and open as possible for the developer community. Join the Intrinsic developer community to access resources, news, and a community for support. Let us know your thoughts, feedback, or hear about what kind of hardware setups you’d want to test this on.
1 post - 1 participant
ROS Discourse General: How did you like the Wordly service at RosCon Global?
In the opening remarks of this year’s RosCon Global, there is a reference to the “AI interpretation” service Wordly.
Could I ask those who used it how did they like it? Did it do well with all the technical terms? Were there any other blockers or glitches?
I think OSRA also asked for some feedback regarding this service. Will this feedback (or its summary) be publicly available?
I’m asking because my partner is an interpreter and she’s quite interested in knowing how far are these systems today ![]()
1 post - 1 participant
ROS Discourse General: Agentic Development platform for robotics
Hi everyone! ![]()
I’m excited to share something we’ve been building.
We are Upfreq Robotics — building an AI-native development environment for robotics software engineers to accelerate robot software development, simulation, and testing.
We’re currently opening up our application to a small group of beta users, especially ROS2 developers and robotics engineers.
If you’re working with ROS2, developing robot applications, or experimenting with robotics simulation, we’d love to have you try it out and share your feedback.
Interested in early access?
Please fill out the early access form on our website:
Selected beta users will get early access to the application.
Looking forward to connecting with fellow robotics developers! ![]()
4 posts - 2 participants
ROS Discourse General: Survey: where does your time go between laptop and robot? (3 min, results shared back)
Hi all,
I am a robotics researcher looking at where engineering time goes when software moves from a
laptop or simulation to a real robot: integration, bring-up, timing, configuration, debugging
between parts. I am trying to measure this across different setups, not just ROS 2, so answers
from people using PX4, ArduPilot, bare-metal MCU code or in-house frameworks are equally welcome.
Survey link: Robotics Integration Survey
- 20 multiple-choice questions, about 3 minutes
- Anonymous, no email or name asked
- I will post the aggregated results in this thread in about two weeks
If you work on more than one kind of robot, answer for the one you spend the most time on. Multiple answers are accepted for choices marked with square instead of circle.
Thank you, and please share it with colleagues who do not read Discourse. ![]()
1 post - 1 participant
ROS Discourse General: Open Telemetry - the next steps after logs with Matthew Macdonald-Wallace | Cloud Robotics WG Meeting 2026-11-16
The next meeting of the CRWG will be at Mon, Nov 16, 2026 4:00 PM UTC→Mon, Nov 16, 2026 5:00 PM UTC, where guest speaker Matthew Macdonald-Wallace from Dash0 will talk about what comes next once you’ve got your logs under control, and why he thinks Open Telemetry is the best way to approach metrics, logs, and traces today. The aim is visibility from end to end, from the control platform all the way down to the end device.
We will begin recording again from this meeting, and the link will be in the next post, so you won’t miss out if you can’t make it.
Last meeting, we continued editing the first draft of the Logging and Observability guide. We now consider the guide to be completely reviewed; I need to make a few last changes after last meeting, then release the guide, which will be a separate post. If you do see the guide, community contributions are very welcome, just raise an issue or a PR with suggested fixes!
The meeting link for next meeting is here, and you can sign up to our calendar or our Google Group for meeting notifications or keep an eye on the Cloud Robotics Hub.
Hopefully we will see you there!
1 post - 1 participant
ROS Discourse General: FOSDEM 2027: Robotics & Simulation Devroom, 3rd edition!
Hi folks! We have done it again, the 3rd edition of the Robotics and Simulation Devroom got accepted at FOSDEM.
It will take place on Sun, Jan 31, 2027 8:00 AM UTC→Sun, Jan 31, 2027 6:00 PM UTC and is on the ULB campus, in Brussel, Belgium.
The call for participation is open to submit talk proposals for all things robotics, as long it is open source! And of course ROS and Gazebo are included!
If you have attended 5 ROSCons already, then you can talk about something else robotics/simulation related
that is the beauty of FOSDEM, we invite all you crazy robotics people no matter from which project you are.
The deadline is the 23rd of November so don’t wait with writing your proposal or forget to submit! Go, go, go!
And please, propose real-life robot demos. We need more of those!
2 posts - 1 participant
ROS Discourse General: How much RTK fix do your outdoor robots keep under tree canopy? Field data and a test design
For those of you running outdoor robots (lawn mowers, orchard or vineyard platforms, campus AMRs), how much RTK fix do you actually keep under tree canopy?
We recently went through a field test that logged several RTK receivers side by side under roadside trees, and I thought the numbers, and their limits, might be useful here.
What was logged (all at about 10 Hz, viewed in RTKPLOT):
- Half sky + rain, 21.9 km baseline, about 61 min
- Under trees + rain, 16.4 km baseline, about 39 min
- Under trees + network RTK, 1.99 km baseline, about 61 min
What the status bars showed:
- In both long-baseline sessions, three of four record groups (Septentrio mosaic-X5 / mosaic-H based receivers) held 100% fixed (Q=1) for the whole session.
- One record group dropped to 83.3% (half sky) and 88.5% (under trees) fixed, with the rest float or DGPS. The ground track shows jumps of tens of centimetres when that happens.
- On the 1.99 km network RTK session, both record groups held 100%.
What it can’t tell you: there was no ground truth and no raw observation data, the sessions changed canopy, baseline, correction source and weather all at once, and there was one unit per position. So it’s a status comparison, not an accuracy ranking. A fixed flag doesn’t prove the position was right.
If you’re evaluating receivers for a robot that works under trees, this is the test design we’d recommend:
- Same site, baseline and correction source; cross open-sky/under-canopy with dry/wet, three or more repeats each
- A known control point or a long static baseline as truth
- Log raw observations so every receiver can be reprocessed with the same RTKLIB settings
- At least two units per model; log heading at the same time on dual-antenna setups
- Report RMS and 95th percentile, time to first fix and availability, not only fix ratio, after decimating to 1 Hz
On the ROS side, the septentrio_gnss_driver publishes the solution status, so you can log fix state alongside your localization output and see exactly where under the canopy your EKF starts leaning on odometry.
The full write-up with all 36 figures and per-screenshot readings is here: RTK fix ratio under tree canopy and rain
I’d be interested to hear what others see in practice: do you gate your localization on fix status, or blend float solutions with a larger covariance?
Disclosure: I work with Eview GNSS, which makes receivers based on Septentrio modules. Test data was supplied by the test team and is used with permission.
6 posts - 3 participants
ROS Discourse General: ROSCon Türkiye 2026
In collaboration with the Open Robotics , Saha Robotics and Terminal Istanbul will jointly host and organize the very first ROSCon Türkiye 2026!
Location: Terminal Istanbul, Istanbul, Türkiye
Date: December 3–4, 2026
Conference languages: English and Turkish
You can submit your talk proposal using the form in the Talks section of our website. For ticket registration and more information about the event, please visit our official website:
We look forward to welcoming the ROS community to Istanbul!
4 posts - 3 participants
ROS Discourse General: Help us make image_transport and point_cloud_transport better for Makoa!
Hi all, I’m not a maintainer of neither image_transport nor point_cloud_transport, though I’m their big user and proponent (point_cloud_transport has, in the end, origins in my lab
, though it has come a long way since then).
The more I use both throughout various ROS 2 distros, the more obstacles and surprises I keep hitting.
I’ve started putting together a list of issues/API differences/API inconveniences of both: Unify the APIs of image_transport and point_cloud_transport in Makoa? · Issue #434 · ros-perception/image_common · GitHub . My ultimate goal would be to sync the API of both and make it easy to use in both Python and C++. I’d like to get it as easy as changing rclcpp::Publisher for image_transport::Publisher with minimum required code changes and with as many features as the normal publisher/subscriber has (like connect callbacks). Ideally, before Makoa Mata-mata code-freeze (May '27).
Do you agree this is something worth resolving? (there will be some API-level friction caused by this).
Do you see any other issues not mentioned in my Github post? Please add them!
The proposed timeline is collecting inputs until mid November and then start with the implementation.
3 posts - 3 participants
ROS Discourse General: Is OTA for ROS 2 robots a solved problem?
I could not find anything out there built specifically for OTA updates in the ROS 2 ecosystem. Coming from the web I wanted to see how close I could get to the developer experience I know, so I built a small project on a Raspberry Pi. The device pulls new container images from GitHub releases, runs a health check and rolls back automatically if a release is broken.
It turned out to be harder than just shipping Docker containers. My updater for example could not update itself. A/B updates seem to solve that, but each approach has its trade-offs.
So I would love to hear from people who run robots in production. What did you pick and why? Is anything still painful with Mender, balena or other tools or do they already cover everything?
Write-up: The code was the easy part - Max Riazantsev
Code: https://github.com/maxriazantsev/vision-stand
8 posts - 7 participants
ROS Discourse General: Logging and Observability Guide Review Part 4 | Cloud Robotics WG Meeting 2026-10-19
The next meeting of the CRWG will be at Mon, Oct 19, 2026 4:00 PM UTC→Mon, Oct 19, 2026 5:00 PM UTC, where we will continue editing the first draft of the Logging and Observability guide. This will be very similar to the last meeting, except that the group hopes to finish the edit of the guide this meeting and send it to our prior guest speakers for review.
The meeting link for next meeting is here, and you can sign up to our calendar or our Google Group for meeting notifications or keep an eye on the Cloud Robotics Hub.
Hopefully we will see you there!
2 posts - 2 participants








