INTERCONNECTION
A quick approach to integrating RTI Connext with Rust
Rust has emerged as a powerful systems programming language, garnering attention for its focus on safety, concurrency, and performance. This technical insight showcases a simple approach of interfacing RTI Connext with Rust.
A
s RTI is always focused on the future of distributed systems, we recognize the growing popularity and importance of Rust in modern application development. By combining the strengths of Connext and Rust developers can create even more work well together, because Connext is a data-centric connectivity framework that happens to share many of Rust’s priorities: • Performance: Like Rust, Connext is designed for high-performance, real-time systems.
• Reliability: Connext’s robust communication infrastructure complements Rust’s focus on system reliability.
• Scalability: Both Rust and Connext excel in
• Safety: While Rust ensures memory safety, Connext provides communication safety in distributed systems.
The initial approach toward the goal of Foreign Function Interface (FFI) manually. Rust’s FFI allows you to call Connext’s C API directly from Rust code. Here’s a simple example of how you might initialize a DomainParticipant with RTI XML application creation:
FUTURE WORK TO SOLVE
DEFICIENCIES AND SHARP CORNERS While expedient, this initial approach reveals several areas for improvement. We are working on rtime-rs, which is an ongoing in the simple approach mentioned above. This wrapper aims to provide a more seamless and idiomatic Rust interface for Connext Micro and Connext Cert, focusing on the following problems: Automatic FFI generation
Generating FFI automatically, especially for custom IDL types, is crucial for seamless integration. Currently, this process is manual and error-prone. Solution: Using tools like bindgen to automatically generate FFI bindings for Connext can streamline the integration process. Additionally, a truly idiomatic Rust interface should provide generic functions to
Entity lifetime management Managing the lifetime of entities in Connext can be challenging, but effective management is essential to ensuring system stability. Rust’s ownership model and Connext’s entity management need to be
cumbersome. Replacing them with idiomatic Rust types such as &str would simplify the interface and ease the development work. Solution: Providing idiomatic Rust wrappers for these types would improve usability.
Support for other architectures The current project is limited to Linux x64 systems. Expanding support to other architectures would make the integration more versatile, and can leverage the multi- platform support Connext brings. Solution: Expanding the build script to detect and support other architectures can make the integration more versatile.
Idiomatic advantages
Although these might seem like minor enhance the usability of the libraries. Examples of this are:
replaced with DDS::Domain::Participant. can be mapped to Rust enums, taking
CONCLUSION
This example project demonstrates how to use Rust with Connext Professional on a Linux x64 system. It includes a basic setup and a demonstration of the functionality and is capable of discovering participants in the loopback interface. As a time-saving bonus for developers, it can also provide the following functionality:
• Automated invocation of rtiddsgen • Automated library build for the type support dependencies
reconciled to ensure that entities are properly created and destroyed. Solution: Implementing a Rust wrapper around Connext entities that leverage Rust’s ownership model can help manage entity lifetimes more effectively. For example, associated Data Distribution Service (DDS) entities effectively.
Wrapping of C types Handling C types such as char in Rust can be JULY/AUGUST 2025 | ELECTRONICS FOR ENGINEERS 39
The integration of Connext with Rust represents a powerful combination that leverages the strengths of both technologies. While the current approach provides a functional foundation for developers to begin building distributed systems, the ongoing development promises to deliver an even more robust and idiomatic experience. We’re excited about the possibilities that Rust brings to the table and how it can complement Connext in building robust, high-performance distributed systems. We encourage you to share your use cases and requirements for Rust with RTI (eMail to
pmteam@rti.com).
Page 1 |
Page 2 |
Page 3 |
Page 4 |
Page 5 |
Page 6 |
Page 7 |
Page 8 |
Page 9 |
Page 10 |
Page 11 |
Page 12 |
Page 13 |
Page 14 |
Page 15 |
Page 16 |
Page 17 |
Page 18 |
Page 19 |
Page 20 |
Page 21 |
Page 22 |
Page 23 |
Page 24 |
Page 25 |
Page 26 |
Page 27 |
Page 28 |
Page 29 |
Page 30 |
Page 31 |
Page 32 |
Page 33 |
Page 34 |
Page 35 |
Page 36 |
Page 37 |
Page 38 |
Page 39 |
Page 40 |
Page 41 |
Page 42 |
Page 43 |
Page 44 |
Page 45 |
Page 46
