Failed to find a free participant index for domain 0

Failed to find a free participant index for domain 0: Cyclone DDS limits on Humble, Jazzy and Lyrical, measured

1793253207.833901 [0]     talker: Failed to find a free participant index for domain 0
[ERROR] [1793253207.834001388] [rmw_cyclonedds_cpp]: rmw_create_node: failed to create domain, error Error
terminate called after throwing an instance of 'rclcpp::exceptions::RCLError'
  what():  failed to initialize rcl node: error not set, at ./src/rcl/node.c:252

That is the 33rd talker on one Jazzy host with RMW_IMPLEMENTATION=rmw_cyclonedds_cpp. The first line is the real error. The rest is ROS 2 reporting that the node has no DDS participant. Humble and Lyrical print the same first two lines with a different what(): text, listed in the table below.

Short answer: Cyclone DDS gives every process on a host a participant index, and the default range is small. On Jazzy and Lyrical, 32 processes started per domain on one host and the 33rd failed, even on a network with multicast. On Humble there was no limit on a multicast-capable network, but with ROS_LOCALHOST_ONLY=1 or a loopback-only container only 9 started. The fix that worked on all three distros is to raise the limit in CYCLONEDDS_URI:

export CYCLONEDDS_URI='<CycloneDDS><Domain><Discovery><ParticipantIndex>auto</ParticipantIndex><MaxAutoParticipantIndex>100</MaxAutoParticipantIndex></Discovery></Domain></CycloneDDS>'

I measured this setting with 20, and exactly 20 processes started on every distro. Pick a number above the count of ROS 2 processes you run on that host, plus the ros2 CLI and its daemon. Every process that uses the domain counts, not every node.

Failed to find a free participant index for domain 0: Cyclone DDS limits on Humble, Jazzy and Lyrical, measured — measured results table
At a glance: the main measured table from this article. Full details below.

Find your error text

The first two lines were identical on all three distros. The line after them depends on the distro and on whether the process is C++ or Python. In every case the process exits right away; C++ nodes abort.

Where Line after failed to create domain, error Error
Humble, C++ node what(): failed to initialize rcl node: rcl node's rmw handle is invalid, at ./src/rcl/node.c:415, after an “error state is being overwritten” block that contains 'error not set, at ./src/rcl/node.c:263'
Humble, rclpy or ros2 CLI rclpy._rclpy_pybind11.RCLError: error creating node: rcl node's rmw handle is invalid, at ./src/rcl/node.c:415
Jazzy, C++ node what(): failed to initialize rcl node: error not set, at ./src/rcl/node.c:252
Jazzy, rclpy or ros2 CLI error creating node: error not set, at ./src/rcl/node.c:252
Lyrical, C++ node what(): failed to initialize rcl node: Expected error message, but none set: 1, at ./src/rcl/node.c:251
Lyrical, rclpy or ros2 CLI error creating node: Expected error message, but none set: 1, at ./src/rcl/node.c:251

“error not set” and “Expected error message, but none set” don’t point to a second problem. The RMW layer failed without setting an error string, and rcl reports that. Search your logs for Failed to find a free participant index instead.

A line that often comes just before it is selected interface "lo" is not multicast-capable: disabling multicast. I saw it on Humble whenever only loopback was used, and on Jazzy when the container had only lo or the URI named lo. Lyrical never printed it. On Humble that line was the reason the limit applied at all.

The ros2 command line hits the same wall. With the host full, ros2 node list --no-daemon and ros2 topic list --no-daemon printed ros2: Failed to find a free participant index for domain 0 and exited.

What I ran

On 2026-10-29 I used the official ros:humble-ros-base, ros:jazzy-ros-base and ros:lyrical-ros-base images on a 2-vCPU Ubuntu server, one distro at a time. Each container got rmw_cyclonedds_cpp and demo_nodes_cpp from apt. A script started demo_nodes_cpp talkers one per second, each as its own process, and checked one second later whether the process was still alive. It stopped a few processes after the first failure and killed everything before the next case. A listener started at the end showed whether the talkers could actually be heard. “Loopback only” means the container’s Docker network was disconnected, so lo was the only interface.

Setup (Cyclone DDS, domain 0) Humble Jazzy Lyrical
Default, Docker bridge network (multicast-capable eth0) 40 of 40 started 32, the 33rd failed 32, the 33rd failed
ROS_LOCALHOST_ONLY=1 9, the 10th failed 32, the 33rd failed 32, the 33rd failed
ROS_AUTOMATIC_DISCOVERY_RANGE=LOCALHOST Not tested 32, the 33rd failed 32, the 33rd failed
Loopback only, default 9, the 10th failed 32, the 33rd failed 32, the 33rd failed
ParticipantIndex auto, no maximum set 9, the 10th failed 32, the 33rd failed 32, the 33rd failed
Localhost setting + MaxAutoParticipantIndex 20 20, the 21st failed 20, the 21st failed 20, the 21st failed
Localhost setting + ParticipantIndex none 9, the 10th failed 40 of 40 started, listener heard nothing 40 of 40 started, listener heard nothing
Loopback only + ParticipantIndex none 9, the 10th failed 32, the 33rd failed 40 of 40 started, listener heard them
lo with multicast="true" in the URI + ParticipantIndex none, no localhost variable 30 of 30, listener heard them 30 of 30, listener heard them 30 of 30, listener heard them
Fast DDS (rmw_fastrtps_cpp), localhost setting 45 of 45 36 of 36 36 of 36
Fast DDS, loopback only 45 of 45 36 of 36 36 of 36

“Localhost setting” is ROS_LOCALHOST_ONLY=1 on Humble and ROS_AUTOMATIC_DISCOVERY_RANGE=LOCALHOST on Jazzy and Lyrical. The numbers where nothing failed are where I stopped, not a limit.

Why 9 on Humble and 32 on Jazzy and Lyrical

Cyclone DDS can run in two modes. With ParticipantIndex none it finds peers by multicast and picks any free port. With ParticipantIndex auto each process takes the next free index between 0 and MaxAutoParticipantIndex, and that index decides its fixed UDP port. Peers find each other by sending to those known ports, which works without multicast. When every index is taken, the next process gets “Failed to find a free participant index”.

On Humble (rmw_cyclonedds_cpp 1.3.5, Cyclone 0.10.5) Cyclone’s config trace showed MaxAutoParticipantIndex 9 when nothing set it, and an explicit ParticipantIndex auto with no maximum also stopped at 9, even on the bridge network. On the Docker bridge, where eth0 supports multicast, the talkers bound no index ports at all and 40 of 40 ran. Once only lo was used, through ROS_LOCALHOST_ONLY=1 or a loopback-only container, Cyclone printed that lo is not multicast-capable, switched to indexes, and the 10th process failed.

On Jazzy (rmw_cyclonedds_cpp 2.2.4, Cyclone 0.10.5) and Lyrical (rmw_cyclonedds_cpp 4.1.5, Cyclone 11.0.1) the config trace showed MaxAutoParticipantIndex 32. Jazzy ships the same Cyclone 0.10.5 as Humble, which gave 9, so the 32 comes from the RMW. The limit applied in every default case, including the bridge network with multicast. That is why a launch file that worked on Humble can fail after an upgrade with nothing else changed.

Fix 1: raise MaxAutoParticipantIndex

This kept the localhost discovery behaviour and only moved the limit. With MaxAutoParticipantIndex 20, exactly 20 talkers started on all three distros and the 21st failed. That held with the localhost setting and with lo named in the URI. With 5 talkers under the same setting, a listener heard 36 to 38 messages in 8 seconds on every distro, so discovery kept working.

<CycloneDDS>
  <Domain>
    <Discovery>
      <ParticipantIndex>auto</ParticipantIndex>
      <MaxAutoParticipantIndex>100</MaxAutoParticipantIndex>
    </Discovery>
  </Domain>
</CycloneDDS>

Save it as a file and point to it with export CYCLONEDDS_URI=file:///path/to/cyclonedds.xml, or pass the XML inline as in the short answer. Set it in every shell and launch environment on that host. The value has to cover the most processes you will run at once. I only measured 20. Higher values were not measured here, and the issues linked at the end discuss whether very large values add discovery traffic.

Fix 2: ParticipantIndex none, only where multicast works

ParticipantIndex none removes the index, so there is no limit to hit. My results show it is not a safe drop-in, because it depends on multicast for discovery.

  • Jazzy and Lyrical with the localhost setting: 40 of 40 talkers started and no error was printed, but a fresh listener heard nothing in 8 seconds. With only 5 talkers it was the same. The config trace showed AllowMulticast false under the localhost setting, so with no index and no multicast the processes never found each other. Adding multicast="true" on lo did not change this while the localhost variable was set.
  • Humble with no multicast: the setting did nothing useful. With ROS_LOCALHOST_ONLY=1, with a loopback-only container, and with lo named in the URI, the 10th process still failed. The config trace reported ParticipantIndex: none and the processes still bound index ports.
  • Jazzy, loopback only: the 33rd process failed, same as without the setting.
  • Lyrical, loopback only: it worked. 40 of 40 started, the listener heard them, and Cyclone did not print the “not multicast-capable” line.

The version that worked on all three distros was to drop the localhost variable and mark lo as multicast-capable in the URI yourself:

<CycloneDDS>
  <Domain>
    <General>
      <Interfaces><NetworkInterface name="lo" multicast="true"/></Interfaces>
    </General>
    <Discovery><ParticipantIndex>none</ParticipantIndex></Discovery>
  </Domain>
</CycloneDDS>

With that, 30 of 30 talkers started on each distro, none of them bound an index port, and the listener heard 230 or more messages in 8 seconds. On Humble, keeping ROS_LOCALHOST_ONLY=1 and adding this interface failed on the first node with lo: the same interface may not be selected twice, because the RMW adds lo too. Unset the variable first.

This keeps traffic on the loopback interface, which is the same scope the localhost setting gives you. For what the discovery range settings do across machines, see why ROS 2 nodes can’t see each other and ROS_AUTOMATIC_DISCOVERY_RANGE.

Fix 3: a different ROS_DOMAIN_ID per group

The index range is per domain. On Humble I filled domain 0 until the 10th talker failed, then started talkers with ROS_DOMAIN_ID=1: 9 more started and the 10th failed. On Jazzy and Lyrical I filled domain 0 to 32, and all 10 talkers I started on domain 1 ran. Nodes on different domains don’t see each other, so this only helps when the groups don’t need to talk. It is a workaround, not a fix.

Fix 4: fewer processes, more nodes per process

The limit counts DDS participants, and in these runs one process with one context was one participant, no matter how many nodes it held.

  • One Python process created 40 nodes in one context, each with a publisher, and spun them in one executor. It used one index port. After it, 8 more talkers fit on Humble and 31 on Jazzy and Lyrical, one fewer than the empty-host count.
  • One component_container with 20 Talker components loaded through ros2 component load used two index ports. ros2 node list showed all 20 components. The second port belonged to the ros2 daemon, which ros2 component load started in the background; ps and ss -ulnp on Jazzy showed the container on 7410 and the daemon on 7414. After that, 7 talkers fit on Humble and 30 on Jazzy and Lyrical.

If your launch file starts many small executables, putting them into a container, or a few multi-node processes, reduces how many indexes you use. It does not raise the limit.

Things that quietly use an index

  • The ros2 daemon. With the daemon running, 8 talkers fit on Humble with the localhost setting and 31 on Jazzy and Lyrical. ros2 commands start it in the background when it is not running, as ros2 component load did here, and it keeps running after the command exits.
  • Every ros2 CLI call while it runs. With the host full, ros2 node list --no-daemon and ros2 topic list --no-daemon failed with the same error, so the CLI needs a free index of its own.
  • Any other process that creates a node. A one-line Python script that only called rclpy.create_node() failed at the limit with the same error as the talkers.

How to count participants on a host

With ParticipantIndex auto, each participant binds a unicast discovery port at 7400 + 250 * domain + 10 + 2 * index. On domain 0 that is 7410, 7412, 7414 and so on. List them with the owning process:

ss -ulnp | grep -E ':74(1[02468]|[2-9][02468])\b'

In my runs this matched what failed: 9 even ports in use at the Humble limit, 32 at the Jazzy and Lyrical limit, 20 with MaxAutoParticipantIndex 20, and 1 for the 40-node Python process. ros2 node list counts nodes, not participants, so it can’t tell you how close you are. In none mode the ports are not at fixed numbers, so this check shows nothing. On Humble with a multicast-capable network, 40 talkers bound no index ports.

What about Fast DDS

Under the same conditions Fast DDS (rmw_fastrtps_cpp) did not fail. With the localhost setting and in a loopback-only container, 45 of 45 talkers started on Humble and 36 of 36 on Jazzy and Lyrical, and the listener heard them. I stopped there, so I don’t know where Fast DDS would stop. It did use more memory: 45 Fast DDS talkers on Humble used 1,406 MB RSS in total, while 40 Cyclone talkers on the bridge used 652 MB. On Jazzy, 36 Fast DDS talkers used 1,321 MB and 32 Cyclone talkers used 587 MB. Switching RMW is a valid answer to this error, but it changes more than the participant limit.

Version notes

  • Humble: rmw_cyclonedds_cpp 1.3.5, Cyclone DDS 0.10.5. Default MaxAutoParticipantIndex 9 in the config trace. No index used while a multicast-capable interface was available. The limit of 9 appeared only on loopback, and ParticipantIndex none did not lift it there.
  • Jazzy: rmw_cyclonedds_cpp 2.2.4, Cyclone DDS 0.10.5. MaxAutoParticipantIndex 32 from the RMW, applied in every default case. ROS_LOCALHOST_ONLY=1 behaved like ROS_AUTOMATIC_DISCOVERY_RANGE=LOCALHOST for the count.
  • Lyrical: rmw_cyclonedds_cpp 4.1.5, Cyclone DDS 11.0.1. Same 32 limit and the same error wording on the first two lines, a different what(): text. Unlike Jazzy, ParticipantIndex none on a loopback-only container worked and the nodes heard each other.
  • Fast DDS versions: 2.6.12 on Humble, 2.14.7 on Jazzy, Fast DDS 3.6.2 on Lyrical.

Not tested

  • MaxAutoParticipantIndex values other than 20, and any effect of large values on discovery traffic or CPU.
  • More than 45 processes on Humble or 40 on Jazzy and Lyrical. The cap was for a 2-vCPU machine.
  • ParticipantIndex none on a real multicast network interface on Jazzy and Lyrical.
  • Processes in separate containers or on separate hosts. Every process here ran in one container.
  • Galactic and Iron, and other Cyclone DDS builds than the apt packages above.
  • Launch files and ComposableNodeContainer from launch. I used ros2 component load.
  • Fast DDS limits beyond the counts above, and Zenoh or Connext.

FAQ

What does Failed to find a free participant index for domain 0 mean?

Every ROS 2 process with Cyclone DDS needs a participant index on that host, and all indexes were taken. In my runs that happened at the 10th process on Humble when only loopback was used, and at the 33rd process on Jazzy and Lyrical in every default setup.

How do I fix rmw_create_node: failed to create domain?

If the line before it is “Failed to find a free participant index”, set ParticipantIndex auto and a higher MaxAutoParticipantIndex in CYCLONEDDS_URI. With 20, exactly 20 processes started on Humble, Jazzy and Lyrical, and nodes below the limit still heard each other.

Does ParticipantIndex none fix it?

Only where multicast works. With the localhost setting on Jazzy and Lyrical, nodes started without errors but could not hear each other. On Humble with loopback only, it did not lift the limit. Unsetting the localhost variable and putting lo with multicast=”true” in the URI worked on all three distros.

Why did this start after upgrading from Humble to Jazzy?

Jazzy’s rmw_cyclonedds_cpp sets MaxAutoParticipantIndex to 32 and uses indexes even on a multicast network. Humble ran 40 of 40 talkers on the same Docker network, Jazzy failed at the 33rd.

Does running many nodes in one process avoid the limit?

Yes. A Python process with 40 nodes in one context used one index, and a component container with 20 components used one more, for the ros2 daemon that ros2 component load started. Each process counts, not each node.

Measured on 2026-10-29 with ros:humble-ros-base (sha256:d9bcf2e6f72d..., rmw_cyclonedds_cpp 1.3.5, Cyclone DDS 0.10.5, rmw_fastrtps_cpp 6.2.10, Fast DDS 2.6.12), ros:jazzy-ros-base (sha256:8eed0a4669bb..., rmw_cyclonedds_cpp 2.2.4, Cyclone DDS 0.10.5, rmw_fastrtps_cpp 8.4.4, Fast DDS 2.14.7) and ros:lyrical-ros-base (sha256:3224ee150cb0..., rmw_cyclonedds_cpp 4.1.5, Cyclone DDS 11.0.1, rmw_fastrtps_cpp 9.4.10, Fast DDS 3.6.2), demo_nodes_cpp talkers, one container per distro on a 2-vCPU Ubuntu host. Full digests are in digests.txt.

Script and raw output: evidence folder. Questions this answers: [Iron][nav2] error: Failed to find a free participant index for domain 0, failed to create domain error when spawning many python nodes at once from launch file with cyclonedds, Fix [rmw_cyclonedds_cpp]: rmw_create_node: failed to create domain, error, ROS2 galactic: Failed to find a free participant index for domain.