November 19, 2026
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 :slight_smile:

1 post - 1 participant

Read full topic

by Ruby_Wang on November 19, 2026 03:13 PM

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 :wink: to the LLMs which made it possible in a short time frame!

1 post - 1 participant

Read full topic

by severin-lemaignan on November 19, 2026 11:34 AM

November 18, 2026
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.

one_cause_many_faults

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.

Repo: GitHub - selfpatch/ros2_medkit: ros2_medkit - diagnostics gateway for ROS 2 robots. Faults, live data, operations, scripts, locking, triggers, and OTA updates via REST API. No SSH, no custom tooling. · GitHub

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

Read full topic

by Michal_Faferek on November 18, 2026 07:25 PM

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=UDPv4 clean 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, MaxMessageSize and FragmentSize made no meaningful difference. The defaults are already its best.
  • Gotcha: if your CYCLONEDDS_URI sets <ParticipantIndex>none</ParticipantIndex> (a common tip for many nodes), don’t also set ROS_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=true made 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_fastrtps sets 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() threw cannot publish data at 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

  1. 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
    
  2. Enable shared memory in Cyclone:
    export RMW_IMPLEMENTATION=rmw_cyclonedds_cpp
    export CYCLONEDDS_URI='<CycloneDDS><Domain><SharedMemory><Enable>true</Enable></SharedMemory></Domain></CycloneDDS>'
    
    Or merge the <SharedMemory> block into the Cyclone XML you already use.
  3. In a launch file, add ExecuteProcess(cmd=['iox-roudi']) and set both environment variables with SetEnvironmentVariable. There’s a working example in the repo.
  4. Verify it’s used: latency is the clearest sign, ~10 µs instead of ~70–90 µs over UDP. iox-introspection-client --port lists 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 rclcpp and the other rclpy, 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 hz shows 2× the real rate.
  • Known upstream: transient_local over 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) / SensorDataQoS silently drops most messages. If every sample matters, use a deeper queue, for example rclcpp::QoS(50).best_effort().
  • USB-serial sensors: macOS has no equivalent of the Linux udev latency_timer=1 rule 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

Feedback welcome, especially from anyone who sees different numbers on Intel Macs or other macOS versions.

1 post - 1 participant

Read full topic

by idesign0 on November 18, 2026 04:36 PM

November 17, 2026
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

Read full topic

by tfoote on November 17, 2026 09:39 PM

November 15, 2026
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:

  1. Which layer should own and update this kind of operating context?

  2. How should the system behave if the external source of that context becomes unavailable or outdated?

  3. How can higher-level operational logic be introduced without weakening existing local safety, recovery or lifecycle behaviour?

  4. 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

Read full topic

by AndreasBlumer on November 15, 2026 11:51 PM

November 10, 2026
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

Read full topic

by clalancette on November 10, 2026 04:19 PM

November 09, 2026
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:

  1. General PEBRAS scope: covering any robotics domain related to PEBRAS scope, using footage from your lab, a conference, a competition, or elsewhere.

  2. 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

Read full topic

by Adam_Norton on November 09, 2026 08:25 PM

November 08, 2026
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

Read full topic

by Zeynep_Peker on November 08, 2026 11:51 PM

November 06, 2026
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:

  1. Standard apt on Ubuntu Server: Easy to set up, but updates are fragile. A failed apt upgrade can easily leave a robot in a broken state out in the field.

  2. Docker: Great for bundling dependencies, but configuring hardware passthrough for heavy GPU workloads like VSLAM or LLMs can add friction.

  3. 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

Read full topic

by Craig_Lawton-Devine on November 06, 2026 01:41 PM

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?

uav_track_crash

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

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

Read full topic

by prakash-aryan on November 06, 2026 12:42 PM

November 02, 2026
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

Read full topic

by tfoote on November 02, 2026 06:13 PM

November 01, 2026
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 :slight_smile:

1 post - 1 participant

Read full topic

by peci1 on November 01, 2026 04:37 PM

October 31, 2026
Agentic Development platform for robotics

Hi everyone! :waving_hand:

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.

:rocket: Interested in early access?

Please fill out the early access form on our website:

:globe_with_meridians: https://upfreqrobotics.com

Selected beta users will get early access to the application.

Looking forward to connecting with fellow robotics developers! :handshake:

4 posts - 2 participants

Read full topic

by Vignesh on October 31, 2026 07:55 PM

October 30, 2026
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. :slightly_smiling_face:

1 post - 1 participant

Read full topic

by muhammadhumais on October 30, 2026 06:13 PM

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

Read full topic

by mikelikesrobots on October 30, 2026 12:26 PM

October 29, 2026
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 :wink: 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!

1 post - 1 participant

Read full topic

by KimMcG on October 29, 2026 03:39 PM

October 26, 2026
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:

  1. Same site, baseline and correction source; cross open-sky/under-canopy with dry/wet, three or more repeats each
  2. A known control point or a long static baseline as truth
  3. Log raw observations so every receiver can be reprocessed with the same RTKLIB settings
  4. At least two units per model; log heading at the same time on dual-antenna setups
  5. 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

Read full topic

by Eviewgnss on October 26, 2026 06:08 PM

October 20, 2026
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

Read full topic

by BCK on October 20, 2026 01:37 PM

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 :slight_smile: , 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

Read full topic

by peci1 on October 20, 2026 11:51 AM

October 18, 2026
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

Read full topic

by maxh1t on October 18, 2026 11:05 PM

October 16, 2026
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

Read full topic

by mikelikesrobots on October 16, 2026 10:29 AM

October 14, 2026
AI-assisted inspection of ROS 2 systems: a preview of DDS Monitor Pro’s MCP integration

Hi everyone,

We at eProsima are sharing a preview of the upcoming AI capabilities in DDS Monitor Pro, with a workflow that is also relevant to engineers working with DDS-based ROS 2 systems.

The Monitor’s built-in Model Context Protocol (MCP) server connects an MCP-compatible AI assistant to the system information and operations available in the Monitor. You can ask questions about the running system and inspect the resulting entities, charts and operations in the workspace.

The preview demonstrates four workflows:

  • Explore discovered applications, topics, publishers and subscribers.
  • Create graphs from selected topic fields.
  • Investigate a communication problem using endpoint configuration, including a reliability QoS mismatch.
  • Publish sample data to a selected topic in a test environment and observe the response.

For ROS 2 deployments using DDS, the connection is the underlying DDS topics and endpoints. The Monitor works at that layer; this is not a claim that it understands every ROS graph concept or supports every ROS middleware implementation.

Fast DDS Pro can also be integrated into ROS 2 and Vulcanexus to provide additional communication capabilities and professional tools. That integration is distinct from the requirements for inspecting a particular system with the Monitor.

The linked videos demonstrate the DDS workflows. For a specific ROS 2 setup, compatibility and the available operations depend on the middleware, versions, topic type information and configuration.

DDS Monitor Pro is a commercial product. These new capabilities are in final testing, with release expected in the coming weeks. The MCP server starts disabled. Once enabled, connected clients can invoke supported operations without a separate approval prompt for each action, so use trusted clients and a test environment for publishing data.

Watch the announcement:

DDS Monitor Pro AI Preview | Explore Your DDS System with Natural Language

Explore the preview, short demonstrations and tutorial:

https://www.eprosima.com/middleware/tools/dds-monitor-pro/ai-preview

Which ROS 2 inspection or debugging tasks would you find most useful to perform through this interface? We would welcome examples of your workflows and questions about compatibility.

1 post - 1 participant

Read full topic

by Jaime_Martin_Losa on October 14, 2026 09:09 AM

October 13, 2026
Rclnodejs 2.3.0: ROS 2 Actions over WebSocket and HTTP/SSE

Send a goal, follow the feedback, get the result. rclnodejs 2.3.0, the ROS 2 client library for Node.js, brings ROS 2 actions to web apps over WebSocket and HTTP/SSE.

ROS 2 Actions from the Browser

The browser SDK derives TypeScript goal, feedback and result types from generated ROS declarations. OpenAPI export also includes action schemas.

With an HTTP runtime on port 9001 exposing a running Fibonacci action server as /fibonacci:

import { connect } from 'rclnodejs/web';

const ros = await connect({ http: 'http://localhost:9001' });
try {
  const goal = await ros.action(
    '/fibonacci',
    { order: 5 },
    { onFeedback: (feedback) => console.log(feedback.sequence) }
  );
  console.log(await goal.result, goal.status);
} finally {
  await ros.close();
}

Web capabilities at a glance

Together with the topic and service support from earlier releases, actions round out the following client-facing operations, controlled by the same capability allow-list:

ROS 2 operation WebSocket HTTP / SSE
Publish topic messages Yes HTTP POST
Subscribe to topics Yes HTTP GET + SSE (opt-in)
Call services Yes HTTP POST
Send action goals, receive feedback/results (new) Yes HTTP POST + SSE
Request cancellation of an action goal (new) Yes; server may reject Not supported

Try the JavaScript and TypeScript demos for runnable examples.

For background on the typed Web SDK and capability runtime first introduced in 2.0.0, see our original announcement.

2 posts - 1 participant

Read full topic

by minggangw on October 13, 2026 07:43 AM

October 08, 2026
Upcoming breaking changes in ros2_control: deprecated Handle / export APIs removed

Quick heads-up for anyone maintaining hardware components or controllers on Rolling or Lyrical: ros2_control 6.12.0 removes the API that has been deprecated since Jazzy. It has been released into Lyrical and Rolling and will reach users with the next sync. We’ve patched most simulators and many public drivers already.

If your package currently builds with deprecation warnings from hardware_interface or controller_interface, it will very likely fail to build after the sync.

Jazzy and Kilted are not affected. The deprecated API remains there for backward compatibility.

Migration notes

We had migration notes for this available for some time but today I made some updates too on this PR, should it be still in flight when you are reading this.

What’s being removed

Affected packages are hardware_interface and controller_interface from this PR ros2_control#3610.

  1. Raw-pointer handles. You can no longer construct a StateInterface/CommandInterface from a double* that points into your own member variables. Handles now own their data, and you access it through shared pointers and the getter/setter API.
  2. Legacy hardware component exports. export_state_interfaces() and export_command_interfaces(), which return interfaces by value, are removed.
  3. Legacy chainable controller exports. The old by-value export methods on ChainableControllerInterface are removed in favour of the shared-pointer on_export_*_interfaces_list() callbacks.

1 post - 1 participant

Read full topic

by bmagyar on October 08, 2026 06:02 PM


Powered by the awesome: Planet