Cybersecurity is no longer an optional extra that can be added to a system later. In safety-critical industries such as automotive, defense, robotics, and industrial automation, security is not integral to functional safety. This is driving a significant change in the way modern systems are developed, with an increasing number of organizations turning to the Rust programming language.
Rust’s memory-safe architecture helps to eliminate entire classes of vulnerabilities before the code even runs. Indeed, memory-related issues are estimated to account for around 70% of critical security flaws in systems software. For teams building distributed, real-time systems, this is a difficult statistic to ignore. When your architecture already depends on proven, production-grade communication infrastructure, you need every element of the system to support development velocity. However, real-world adoption is rarely happens overnight. Teams encounter difficulties when attempting to transition to Rust within existing systems, which are often large and based on the Data Distribution Service (DDS®) standard. These challenges include:
- Training and ramp-up time;
- Integration friction with existing C/C++ stacks;
- differences in serialization and code-generation tooling, and
- The organizational risk of rewriting production components all at once.
In short, teams want the safety benefits of Rust, but they also need a safe, low-risk way to achieve them. That’s why the RTI Connector for Rust was developed.
A Practical Bridge Between Rust and DDS
To help developers get strated, RTI is introducing an early-access entry point in the form of a Connector for Rust, which allows teams to experiment with Rust and DDS-based messaging, together, through RTI Connext. A pragmatic approach is being taken by RTI: a lightweight, configuration-driven Connector is being provided that enables developers to publish and subscribe using familiar DDS semantics while integration complexity is minimized.
The goal is simple: To make learning, evaluation and experimentation easy – without forcing production commitments.
By exposing the Connector source code, developers can see how the integration works and have the flexibility to extend it for their own environments.
Why This Matters for System Architects
For architects designing next-generation platforms, the challenge is not just choosing the right technologies, but also managing risk while preparing for the future. In other words, teams can explore what’s next without destabilizing what already works.
Connector for Rust offers a practical on-ramp by enabling:
- Safe experimentation with DDS in Rust
- Rapid prototyping and simulation
- Integration within mixed-language environments
- Exploration of memory-safe system foundations
- Low-latency communication with minimal infrastructure overhead
This release is intentionally designed for experimentation. Early adopters will help shape RTI’s long-term strategy for native Rust support by providing real-world feedback and deployment insights. It also reflects a broader belief:
The future of distributed systems will increasingly demand both performance and provable safety. Rust is rapidly becoming part of that conversation – and RTI is committed to supporting developers as the ecosystem evolves.
How It Works
The Connector wraps Connext Professional’s XML Application Creation capability. DDS entities, such as participants, topics, readers, writers, and types – are defined in an external XML configuration file. Using this model, developers can send and receive data via high-level Rust abstractions based on DDS Dynamic Data, thus eliminating the need for traditional IDL-based code generation. Additional capabilities include:
- Iterator-based data access
- Serde-powered serialization and deserialization
- Compatibility with existing Rust domain models
- Reduced runtime errors with stronger compile-time confidence
The result is faster onboarding and a significantly lower barrier for teams new to DDS.
Caption: The Connector API wraps Connext Professional’s XML Application Creation feature where an XML file defines a DDS system. For each participant in the system, you can create a Connector and use its Inputs and Outputs (DataReaders and DataWriters, respectively) to send and receive samples using DynamicData. (Source: RTI)
A Small Step Toward Fully Native Rust Systems
Over time, native Rust APIs will enable developers to build high-performance distributed systems entirely within the Rust ecosystem, eliminating the need for language switching or architectural compromises. The Connector for Rust is an important early step in that direction. It gives teams immediate access to production-proven DDS technology, while helping RTI to understand how developers want to build the next generation of intelligent, connected systems.
Start Experimenting
Connector for Rust is available now through RTI Labs for developers interested in exploring DDS within Rust environments. If you are developing secure, distributed applications or preparing your architecture for a memory-safe future, now is the time to start learning, testing, and experimenting.
About the author:
Aditi Vira is a Senior Product Manager at RTI, where she leads product strategy and execution for Connext Professional, RTI’s flagship connectivity platform for real-time distributed systems.
