Posts / Cyclone DDS vs Fast DDS: Two Implementations of the Same Standard, and Which One to Use with ROS 2

Cyclone DDS vs Fast DDS: Two Implementations of the Same Standard, and Which One to Use with ROS 2

You install ROS 2 and everything works. Then a forum answer says “try Cyclone DDS”, a MoveIt page tells you to export another RMW, and a colleague says their robot only works over Wi-Fi with Fast DDS tuned by an XML file. You end up with two names, Cyclone DDS and Fast DDS, that both contain “DDS”, and no clear idea of what is actually different.

This post answers four questions in order. What is DDS, and why can two products carry the same name? Where does each one come from? How does ROS 2 plug into them, and why did its default change once? And, in practice, which one should you pick? The references are listed at the end, and the claims that rest on community reports rather than on documentation are marked as such.

Key takeaway
DDS is a specification, not a product. Cyclone DDS and Fast DDS are two independent implementations of it. Because they share a wire protocol (RTPS), they can talk to each other. ROS 2 hides both behind the RMW layer, so you switch with one environment variable. Start with the default of your distribution, and change only for a measured problem: discovery on a network, large messages, latency, or a vendor requirement.

DDS is a standard, not a library

DDS stands for Data Distribution Service. It is a specification published by the OMG (Object Management Group, the body behind UML and CORBA). The first formal version, 1.0, dates from December 2004, and the current one, 1.4, from March 2015 [1]. It defines three things:

  • A data-centric publish/subscribe model. Participants share topics with a type. A publisher writes samples, a subscriber reads them, and neither knows the other’s address.
  • A QoS system. Reliability, durability, history depth, deadline, liveliness and so on, set on each endpoint and matched between publisher and subscriber. The QoS profiles you know from ROS 2 are the DDS ones.
  • An API, in several language mappings, that a vendor can implement.

What RTPS means

The DDS specification describes the behaviour and the API, but not what travels on the cable. Two products written from it alone could not talk to each other. That is the job of a second OMG standard, DDSI-RTPS, the DDS Interoperability Wire Protocol [2].

RTPS stands for Real-Time Publish-Subscribe. It defines:

  • The message format: how a sample, a heartbeat or an acknowledgement is encoded in bytes.
  • The discovery protocol: how participants announce themselves and find the endpoints of the others. In practice, a participant sends announcements to a multicast address, then peers exchange the lists of their publishers and subscribers.
  • The reliability mechanism on top of UDP: sequence numbers, heartbeats and negative acknowledgements, so that a “reliable” QoS can be honoured on a network that loses packets.

RTPS exists in several versions: 2.0 (April 2008), 2.3 (May 2019), 2.5 (April 2022) [2]. Fast DDS announced in 2020 that it complied with DDS 1.4 and RTPS 2.2 [3].

RTPS is defined independently of the transport. It needs a transport that carries messages, such as UDP/IP, and UDP is the one that every vendor implements, so it is the one that guarantees interoperability [2]. A vendor can add others (shared memory, TCP), but only between its own participants.

So “DDS” in both names means “implements the OMG DDS specification”, and the shared RTPS protocol is what lets them interoperate. It says nothing about the code, the licence, the performance or the configuration. Compare it with SQL: PostgreSQL and MySQL both speak SQL, and nobody expects them to behave the same.

What the standards fix, and what they leave open

Fixed by the standardsLeft to each vendor
The data model and the QoS policiesThe code base, the language, the threading model
The content of the RTPS messages, sent over UDP (so vendors interoperate)Extra data paths besides UDP: shared memory (which can bypass RTPS between two processes of the same machine), TCP, others. They only work between two participants of the same vendor
The discovery protocol (multicast by default)Extra discovery modes (a central discovery server, a static peer list)
The API namesConfiguration: XML profiles, environment variables, defaults
Performance, memory use, tooling, licence and support

Everything in the right column is where the two products differ, and where your problems will come from. Two nodes using the same QoS on the same machine can behave differently with the two vendors, because the standard says what must happen, not how fast or with which defaults.

A concrete example from ROS 2 history: when the ROS 2 TSC (Technical Steering Committee) chose the Galactic default, it noted that Fast DDS publishes asynchronously by default (publish returns before the data is sent, like ROS 1), whereas Cyclone DDS publishes synchronously [4]. Same API, same QoS, different default behaviour.

Where they come from

A short timeline helps, because the history explains the names and the ROS 2 choices. The colours tell whose story each event belongs to.

2004
DDS 1.0Standard
The OMG publishes the first specification [1]. The first commercial implementations come from vendors such as RTI (Connext DDS) and PrismTech (OpenSplice), mostly for defence, aerospace and industrial systems.
2008
RTPS 2.0Standard
The interoperability wire protocol reaches version 2.0, the base that lets implementations from different vendors talk to each other [2].
~2011
Cyclone DDS starts inside OpenSpliceCyclone DDS
The code that becomes Cyclone DDS is born about ten years before 2021, inside ADLINK’s OpenSplice product [5].
Mar 2015
DDS 1.4Standard
The current version of the specification [1].
2017
Fast RTPS, default of ROS 2Fast DDS
eProsima’s implementation, then called Fast RTPS (a name that said what it covered), is the ROS 2 default from the first releases [4]. It is open source under Apache 2.0 [8].
2018
Cyclone DDS joins EclipseCyclone DDS
First commit to the Eclipse project. Its initial contribution is the Vortex OpenSplice 6.8 code base [5], [6].
Feb 2019
Cyclone DDS 0.1.0Cyclone DDS
First release of Eclipse Cyclone DDS [5]. It is now an Eclipse Foundation project, licensed under EPL 2.0 and EDL 1.0 [7].
Jun 2020
ROS 2 FoxyROS 2
Fast RTPS is renamed Fast DDS 2.0 and announces compliance with DDS 1.4 and RTPS 2.2 [3]. Cyclone DDS becomes Tier 1 [9]. OpenSplice support is dropped [4].
May 2021
ROS 2 Galactic: Cyclone DDS by defaultROS 2
The TSC chooses Cyclone DDS as the default RMW [10].
May 2022
ROS 2 Humble: back to Fast DDSROS 2
Fast DDS is the default again [11].
2024 to 2026
ROS 2 Jazzy and LyricalROS 2
Fast DDS stays the default [12], [13].

So which came first? In code lineage, Cyclone’s ancestor (OpenSplice) is older. As an open-source project, Cyclone only appeared in 2018, while Fast RTPS was already used by ROS 2. Neither is a fork of the other: they are independent code bases that meet at the RTPS protocol.

How ROS 2 uses them

ROS 2 does not call DDS directly. Between your rclcpp or rclpy code and the middleware there is a thin interface called RMW (ROS Middleware Interface). Each middleware has an RMW package that translates ROS concepts (node, topic, QoS profile) into its own API: Fig. 1 shows where the vendor sits.

%%{init: {"flowchart": {"rankSpacing": 24, "nodeSpacing": 20, "padding": 5}}}%% flowchart TB A["your node
rclcpp / rclpy"] --> B["rcl"] B --> C["rmw
(interface)"] C --> D["rmw_fastrtps_cpp"] C --> E["rmw_cyclonedds_cpp"] C --> F["rmw_connextdds"] C --> Z["rmw_zenoh_cpp
(not DDS)"] D --> G["Fast DDS"] E --> H["Cyclone DDS"] F --> I["RTI Connext DDS"] classDef run fill:#FFEFC2,stroke:#E5D28A,color:#6B4A00 class C run
Fig. 1 - The RMW layer is the only place that knows which DDS vendor is used.

Choosing the vendor is a run-time choice, not a build-time one:

# Use Cyclone DDS for everything launched from this terminal
export RMW_IMPLEMENTATION=rmw_cyclonedds_cpp

# Use Fast DDS
export RMW_IMPLEMENTATION=rmw_fastrtps_cpp

Your code does not change. The RMW packages must be installed (ros-<distro>-rmw-cyclonedds-cpp and so on), and the same variable must be set for every process of the system. This is also the origin of the stale-daemon problem described in What ros2 daemon start really does.

Which one is the default

The default has changed once:

DistributionReleased [20]Default RMWReference
Ardent to FoxyDec 2017 to Jun 2020Fast DDS (called Fast RTPS before the rename)[4]
GalacticMay 2021Cyclone DDS[4], [10]
HumbleMay 2022Fast DDS[4], [11]
JazzyMay 2024Fast DDS[12]
Lyrical LuthMay 2026Fast DDS[13]

Iron and Kilted are not in the table. The ROS 2 history post confirms that Fast DDS was the default from Ardent to Humble, Galactic excepted [4], and the Jazzy and Lyrical rows come from their own documentation.

Galactic was a one-release experiment. The TSC chose Cyclone DDS as its default after a benchmarking report and community feedback [10], then went back to Fast DDS for Humble, in what a forum summary calls a very close decision [11]. The lesson is that both are considered good enough to be the default, and that the choice was a trade-off, not a verdict.

The Lyrical documentation also says that, if Fast DDS is not installed, the default is chosen by alphabetical order of the RMW package identifiers [14]. That is a good reason to set RMW_IMPLEMENTATION explicitly on a robot instead of relying on what happens to be installed.

Both vendors are Tier 1 in REP 2000, the level of support the ROS 2 team commits to for a platform [15]. You are not choosing a supported option against an experimental one.

How they differ in practice

These differences come from documentation and community reports, not from benchmarks. Measure on your own hardware before drawing a conclusion.

TopicFast DDSCyclone DDS
Default in ROS 2Yes (all distributions but Galactic)No, one-line switch
Publication mode, by defaultSynchronous since Humble [28], [29] (asynchronous before [27])Synchronous [4]
Same-machine transportShared memory transport, on by default [21]Shared memory through iceoryx, off by default, needs the iceoryx RouDi daemon [16]
DiscoveryMulticast by default, plus a Discovery Server mode [17]Multicast by default, static peers list possible
LicenceApache 2.0 [8]EPL 2.0 / EDL 1.0 [7]
Backed byeProsimaEclipse Foundation

Since Humble the two have the same default publication mode, so the differences that remain are few: shared memory, the Discovery Server, and who is behind each project. The rest of this section goes through them, after a word on the publication mode itself, which is the one you may still have to choose.

Publication mode. This is what the publish() call of your node does with the sample. It is easy to miss, because the API and the QoS are the same and only the behaviour of the call changes. Fig. 2 compares the two modes.

%%{init: {"flowchart": {"rankSpacing": 24, "nodeSpacing": 20, "padding": 5}}}%% flowchart LR subgraph S["Synchronous"] direction TB S1["publish() is called"] --> S2["serialize and send
in your thread"] --> S3["publish() returns"] end subgraph A["Asynchronous"] direction TB A1["publish() is called"] --> A2["copy into a queue"] --> A3["publish() returns"] A2 -.-> A4["a thread of the library
sends from the queue"] end classDef run fill:#FFEFC2,stroke:#E5D28A,color:#6B4A00 class S2,A4 run
Fig. 2 - Synchronous publication sends in your thread. Asynchronous publication copies the sample into a queue and lets a thread of the library send it.
  • Synchronous: the sample is sent directly in the context of your thread [24], and publish() returns once it is in the network sockets or in the shared memory buffers [30]. Delivery is faster, because there is no thread to wake up. The price is that your thread pays for the send: a network that is slow, or a reliable subscriber that does not keep up, can hold the call.
  • Asynchronous: the sample is copied into a queue and a background thread is notified [24]. publish() returns faster and more predictably, which suits a loop that must keep its period, but delivery is slower [30]. The price is a small extra delay on the way to the subscriber, one more thread, and a queue that can fill up.

Asynchronous does not mean that publish() can never block. If the history of the writer is full and no new sample can be added, an asynchronous publisher blocks too, and this has been reported on a low-bandwidth link [26].

The default of Fast DDS changed over time. Up to Galactic, Fast DDS published asynchronously by default (like ROS 1), while Cyclone DDS published synchronously [4], [27]. That made the two hard to compare: the 2020 evaluation report had to run Fast DDS in synchronous mode as well to get a fair result [25]. From Humble on, rmw_fastrtps is synchronous by default too [28], [29], and the Kilted documentation says the same [23]. So with Humble, Jazzy or Lyrical, both vendors publish synchronously unless you change the mode yourself.

With Fast DDS, the mode can be chosen without writing an XML file, with the environment variable of the RMW:

export RMW_FASTRTPS_PUBLICATION_MODE=SYNCHRONOUS    # or ASYNCHRONOUS, or AUTO (let Fast DDS decide)

If RMW_FASTRTPS_USE_QOS_FROM_XML is set to 1, the XML profile wins over this variable [24]. For Cyclone DDS, the 2020 report describes synchronous publication as its only mode [25].

Which mode to pick depends on the delay you care about:

What matters to youModeWhy
publish() must return fast, in a thread that cannot wait (control loop, driver callback)AsynchronousThe call only queues the sample, so it returns quickly and predictably [30]
The data must reach the subscriber as soon as possibleSynchronousNo thread has to be woken up to send it [30]

With asynchronous publication, size the history for the worst case: when it is full, the call blocks too [26].

Shared memory. Fast DDS enables its shared memory transport by default [21], so two Fast DDS participants on the same machine use it without any configuration. The default segment is 512 KB, which is smaller than one 640×480 RGB image (about 0.9 MB), and this has been reported as a limit for camera topics [22]. Cyclone DDS is the opposite: its iceoryx path is off by default and needs the iceoryx RouDi daemon [16]. These points come from the current Fast DDS documentation and from the Cyclone DDS 0.10.5 manual, so check the versions shipped with your distribution.

Discovery. By default both vendors discover peers with multicast. On a flat network with a few nodes this is invisible. With dozens of nodes, several machines or a Wi-Fi access point that filters multicast, discovery becomes the first thing that breaks. Fast DDS offers a Discovery Server, a central point that avoids the all-to-all announcements [17]. Cyclone DDS lets you list peers explicitly. ROS 2 also has its own ROS_AUTOMATIC_DISCOVERY_RANGE and ROS_STATIC_PEERS settings, which apply to both.

Large messages. Images, point clouds and maps are where the transport matters. Over UDP, a large sample is fragmented and a lost fragment forces a resend, which hurts on Wi-Fi. When publisher and subscriber are on the same machine, shared memory removes the network from the picture, and this is where the two vendors differ most in setup.

Which one to choose

A short decision rule, in order:

  1. You have no problem. Keep the default of your distribution. Fewer variables, and most tutorials and bug reports assume it.
  2. You have a discovery or network problem (nodes not seen across machines, Wi-Fi, many nodes). Try the other vendor first, since it costs one environment variable. If the problem stays, the cause is probably configuration, and you can look at the Discovery Server or static peers.
  3. A framework tells you to use one. The MoveIt 2 binary installation page asks you to install the Cyclone DDS RMW and export it, and warns that nodes using it cannot talk to nodes using other RMWs [18]. Read the installation page of the framework and distribution you use, because such advice changes between releases.
  4. You publish large data on one machine. Check the shared memory support of the vendor on your distribution.
  5. You need a vendor contract or a certification (safety, long-term support). That is a commercial question, and it can point to RTI Connext or to a paid support plan from a vendor.
  6. You want to leave DDS. rmw_zenoh_cpp is a non-DDS RMW. It needs the Zenoh router (zenohd) running locally or reachable on the network [19]. It is outside the scope of this post, but it is the third name you will meet in the same discussions.

Whatever you choose, apply two rules: set RMW_IMPLEMENTATION explicitly (in the launch environment, the Dockerfile or the service file), and use the same vendor on every machine of the system unless you have tested the mix.

Can you mix them?

In theory yes, because both speak RTPS. In practice it works for basic topics and gets less reliable with specific QoS combinations, large data or vendor-specific features such as shared memory, which only two nodes of the same vendor can use. The MoveIt 2 page quoted above warns that nodes using the Cyclone DDS RMW cannot talk to nodes using other RMWs [18]. For a robot, a single vendor is the safer choice.

Quick remember

  • DDS is a standard, not a product. Cyclone DDS and Fast DDS are two independent implementations of it. They talk to each other through RTPS, the wire protocol, sent over UDP.
  • ROS 2 hides the vendor behind the RMW. You switch with RMW_IMPLEMENTATION, with no change in your code. Set it explicitly, and use the same vendor on every machine of the system.
  • The default is Fast DDS in every distribution except Galactic, which used Cyclone DDS.
  • The differences are three: shared memory (on by default in Fast DDS, off in Cyclone DDS and dependent on the iceoryx daemon), the Discovery Server (Fast DDS only), and who is behind each project (eProsima under Apache 2.0, the Eclipse Foundation under EPL 2.0 and EDL 1.0).
  • The publication mode is no longer one of them. Both publish synchronously by default since Humble. Synchronous means publish() blocks until the sample is sent, which gives the shortest delivery time. Asynchronous returns faster and more predictably.
  • Which one to choose: keep the default, and change only for a measured problem. Nodes not seen across machines or on Wi-Fi: try the other vendor. Large data on one machine: check shared memory first.

References

  1. OMG, DDS — Data Distribution Service: version history (1.0 December 2004, 1.4 March 2015). omg.org
  2. OMG, DDSI-RTPS — DDS Interoperability Wire Protocol: versions 2.0 (2008), 2.3 (2019), 2.5 (2022). omg.org
  3. eProsima, Fast RTPS becomes Fast DDS in Foxy, ROS Discourse. discourse.ros.org
  4. ROS Discourse, The DDS Race: what we’ve seen so far. discourse.ros.org
  5. Eclipse Foundation, Eclipse Cyclone DDS: IoT Middleware for Robots, Autonomous Vehicles, and Demanding Systems. eclipse.org
  6. Eclipse Foundation, Eclipse Cyclone DDS project proposal. projects.eclipse.org
  7. Eclipse Cyclone DDS, NOTICE.md (licence). github.com
  8. ROS 2 documentation, About Different Middleware Vendors (Kilted): vendors and licences. docs.ros.org
  9. Eclipse Foundation, Eclipse Cyclone DDS now a Tier 1 ROS Middleware. newsroom.eclipse.org
  10. ROS Discourse, ROS 2 Galactic Default Middleware Announced. discourse.openrobotics.org
  11. ROS 2 documentation, About Different Middleware Vendors (Humble). docs.ros.org
  12. ROS 2 documentation, DDS implementations (Jazzy). docs.ros.org
  13. ROS 2 documentation, RMW implementations (Lyrical). docs.ros.org
  14. ROS 2 documentation, Different ROS 2 middleware vendors (Lyrical): the fallback rule when Fast DDS is not installed. docs.ros.org
  15. Open Robotics, REP 2000: ROS 2 Releases and Target Platforms. reps.openrobotics.org
  16. Eclipse Cyclone DDS, Shared memory (iceoryx) manual page, release 0.10.5: check the current manual. sources.debian.org
  17. eProsima, New Discovery Server, ROS Discourse. discourse.openrobotics.org
  18. MoveIt, Install MoveIt 2 from binaries. moveit.ros.org
  19. ROS 2 documentation, ROS 2 middleware implementations (Kilted). docs.ros.org
  20. ROS 2 documentation, Release Schedule (Lyrical): release dates of the distributions. docs.ros.org
  21. eProsima, Fast DDS documentation, Shared Memory Transport: enabled by default, default segment size 512 KB. fast-dds.docs.eprosima.com
  22. ros2/rmw_fastrtps, issue 973: Consider a larger default shared-memory segment (512 KB to 4 MB)? github.com
  23. ROS 2 documentation, FastDDS Configuration (Kilted): rmw_fastrtps uses synchronous publication by default. docs.ros.org
  24. ROS Discourse, RMW Fast DDS Publication Mode: Sync vs Async and how to change it. discourse.openrobotics.org
  25. OSRF TSC, 2020 ROS Middleware Evaluation Report: Fast RTPS and Cyclone DDS publication modes. osrf.github.io
  26. Robotics Stack Exchange, How to get asynchronous publish working on ROS 2 Galactic with Fast RTPS: asynchronous publication can still block when the history is full. answers.ros.org
  27. ros2/rmw_fastrtps, README (Galactic branch): publication mode ASYNCHRONOUS_PUBLISH_MODE, asynchronous when RMW_FASTRTPS_PUBLICATION_MODE is not set. github.com
  28. ros2/rmw_fastrtps, README (Humble branch): publication mode SYNCHRONOUS_PUBLISH_MODE, synchronous when RMW_FASTRTPS_PUBLICATION_MODE is not set. github.com
  29. ros2/rmw_fastrtps, README (Lyrical branch): synchronous by default, same as the Humble, Iron, Jazzy and Kilted branches. github.com
  30. eProsima, DDS: Asynchronous vs Synchronous Publishing: the advantages and caveats of each publication mode. eprosima.com