Repository Summary
| Description | |
| Checkout URI | https://github.com/IntellectusCorp/rmw_int2dds.git |
| VCS Type | git |
| VCS Version | humble |
| Last Updated | 2026-10-13 |
| Dev Status | DEVELOPED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| int2dds_ffi_vendor | 0.1.8 |
| rmw_int2dds_cpp | 0.1.8 |
| rmw_int2dds_validation | 0.1.8 |
README
ROS 2 RMW for int2DDS
Overview
rmw_int2dds_cpp lets ROS 2 applications run on top of
int2DDS, a Rust
implementation of the OMG DDS standard (RTPS 2.5). It implements the ROS 2 rmw
C interface so that any ROS 2 stack (rclcpp, rclpy, ros2 CLI, tools) can use
int2DDS as its middleware via RMW_IMPLEMENTATION=rmw_int2dds_cpp.
Status: work in progress — APIs and test results are being stabilized ahead of a request for Tier 3 status in REP 2000.
Supported ROS 2 distributions
| Distribution | Status |
|---|---|
| Humble Hawksbill (LTS) | Supported (verified) |
| Jazzy Jalisco (LTS) | Supported (verified) |
| Lyrical Luth (LTS) | Supported (verified, except cross-vendor WStrings - see Known issues) |
| Rolling Ridley | Supported (verified, except cross-vendor WStrings - see Known issues) |
Supported platforms
| Platform | amd64 | arm64 | arm32 |
|---|---|---|---|
| Ubuntu 22.04 (Jammy) | Verified | Verified | Verified |
| Windows 10 | Verified (on Windows 11) | ||
| RHEL 8 | Verified | ||
| Ubuntu 20.04 (Focal) | Verified | Verified | Verified |
| macOS | Verified | ||
| Debian 11 (Bullseye) | Verified | Verified | Verified |
| OpenEmbedded / Yocto | Verified | Verified | Not supported |
- Windows: verified on Windows 11 with Visual Studio 2019. See Windows and macOS.
- macOS: verified on macOS 15.
- OpenEmbedded / Yocto: verified with a local layer that adds the
rmw_int2ddsrecipes. arm32 does not build: the ROS 2 message packages fail beforermw_int2ddsis reached.
Installation
From the ROS 2 apt repository
sudo apt update
sudo apt install ros-humble-rmw-int2dds-cpp
source /opt/ros/humble/setup.bash
export RMW_IMPLEMENTATION=rmw_int2dds_cpp
apt install pulls in the int2dds_ffi_vendor package automatically. The RMW library
and its ament-index marker install into /opt/ros/humble/, so once the environment is
sourced only RMW_IMPLEMENTATION needs to be set.
Supported: humble / jazzy / lyrical / rolling × amd64 / arm64 (rolling: testing repository only).
From the ROS 2 RPM repository (RHEL)
With the ROS 2 RPM repository set up as in the ROS 2 RHEL installation guide:
sudo dnf install ros-humble-rmw-int2dds-cpp
source /opt/ros/humble/setup.bash
export RMW_IMPLEMENTATION=rmw_int2dds_cpp
Latest version (testing repository or source build)
The newest release is available from the ROS 2 testing repository:
sudo apt install -y ros2-testing-apt-source
sudo apt update
sudo apt install ros-humble-rmw-int2dds-cpp
To build from source instead, follow Quick Start.
Windows and macOS
There are no binary packages of rmw_int2dds for Windows or macOS: build it from
source on top of a ROS 2 installation made with the ROS 2 installation guide for
that platform. int2dds_ffi_vendor downloads the FFI for the host from the
int2DDS releases.
Windows, in an x64 Native Tools Command Prompt for VS 2019. The commands below assume ROS 2 Humble in
C:\pixi_ws\ros2-windows; change the paths to match your installation.
The ROS 2 Windows binaries are Release builds, so build rmw_int2dds as Release too:
```bat cd /d C:\pixi_ws pixi shell call C:\pixi_ws\ros2-windows\local_setup.bat
File truncated at 100 lines see the full file
CONTRIBUTING
Contributing to rmw_int2dds_cpp
Thank you for your interest in contributing! This package is the ROS 2 RMW binding for int2DDS. For contributions to the underlying DDS core, see the int2DDS repository.
Code of Conduct
This project adheres to a Code of Conduct.
Contributor License Agreement (CLA)
By submitting a pull request you agree to the project CLA (individual / corporate).
Development Environment
Prerequisites
- A supported ROS 2 distribution (Humble or Jazzy) installed and sourced
- colcon build tool
- A C++17 compiler (GCC/Clang/MSVC), CMake >= 3.14.4
- The int2DDS core library available as a dependency
Workspace setup
mkdir -p ~/ros2_ws/src && cd ~/ros2_ws/src
git clone https://github.com/IntellectusCorp/rmw_int2dds.git
cd ~/ros2_ws
rosdep install --from-paths src --ignore-src -r -y
Building and Testing
# Build
colcon build --packages-up-to rmw_int2dds_cpp
# Run this package's tests
colcon test --packages-select rmw_int2dds_cpp
colcon test-result --verbose
# Run the RMW interface conformance suite against int2DDS
RMW_IMPLEMENTATION=rmw_int2dds_cpp \
colcon test --packages-select test_rmw_implementation
Tier 3 listing requires the full
test_rmw_implementationsuite to pass.
Code Style
This package follows the ROS 2 Code Style and Language Versions guide:
- C++17, max line length 100,
.hpp/.cppextensions - Linters run as tests via
ament_lint_auto+ament_lint_common(ament_clang_format,ament_cpplint,ament_uncrustify,ament_cppcheck) - Build with
-Wall -Wextra -Wpedantic
# Run linters
colcon test --packages-select rmw_int2dds_cpp --ctest-args -R lint
Commit Messages
Use the format TYPE: short description (max 72 chars), imperative mood.
Types: FEAT, FIX, DOCS, STYLE, REFACTOR, TEST, CHORE, PERF.
Reference issues with Fixes #123.
Branch Naming
feature/, fix/, hotfix/, docs/, refactor/, test/ prefixes;
lowercase with hyphens (e.g., feature/qos-deadline).
Pull Request Process
- Rebase on the latest
upstream/main. - Ensure
colcon buildandcolcon testpass, including linters. - Update documentation and
CHANGELOG.rstif behavior or APIs changed. - Open a PR with a clear summary, rationale, and testing notes.
- Request review from maintainers.
Reporting Bugs
Open a GitHub issue with: description, reproduction steps, expected vs actual behavior, environment (OS, ROS 2 distro, int2DDS version), and logs. For security issues, follow SECURITY.md instead.
License
By contributing, you agree your contributions are licensed under the Apache License 2.0.
License of contributions
Any contribution that you make to this repository will be under the Apache 2 License, as dictated by that
File truncated at 100 lines see the full file
Repository Summary
| Description | |
| Checkout URI | https://github.com/IntellectusCorp/rmw_int2dds.git |
| VCS Type | git |
| VCS Version | jazzy |
| Last Updated | 2026-10-13 |
| Dev Status | DEVELOPED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| int2dds_ffi_vendor | 0.1.8 |
| rmw_int2dds_cpp | 0.1.8 |
| rmw_int2dds_validation | 0.1.8 |
README
ROS 2 RMW for int2DDS
Overview
rmw_int2dds_cpp lets ROS 2 applications run on top of
int2DDS, a Rust
implementation of the OMG DDS standard (RTPS 2.5). It implements the ROS 2 rmw
C interface so that any ROS 2 stack (rclcpp, rclpy, ros2 CLI, tools) can use
int2DDS as its middleware via RMW_IMPLEMENTATION=rmw_int2dds_cpp.
Status: work in progress — APIs and test results are being stabilized ahead of a request for Tier 3 status in REP 2000.
Supported ROS 2 distributions
| Distribution | Status |
|---|---|
| Humble Hawksbill (LTS) | Supported (verified) |
| Jazzy Jalisco (LTS) | Supported (verified) |
| Lyrical Luth (LTS) | Supported (verified, except cross-vendor WStrings - see Known issues) |
| Rolling Ridley | Supported (verified, except cross-vendor WStrings - see Known issues) |
Supported platforms
| Platform | amd64 | arm64 | arm32 |
|---|---|---|---|
| Ubuntu 24.04 (Noble) | Verified | Verified | Verified |
| Windows 10 | Verified (on Windows 11) | ||
| RHEL 9 | Verified | ||
| Ubuntu 22.04 (Jammy) | Verified | ||
| macOS | Verified | ||
| Debian 12 (Bookworm) | Verified | Verified | Verified |
| OpenEmbedded / Yocto | Verified | Verified | Not supported |
- Windows: verified on Windows 11 with Visual Studio 2019. See Windows and macOS.
- macOS: verified on macOS 15.
- OpenEmbedded / Yocto: verified with a local layer that adds the
rmw_int2ddsrecipes. arm32 does not build: the ROS 2 message packages fail beforermw_int2ddsis reached.
Installation
From the ROS 2 apt repository
sudo apt update
sudo apt install ros-jazzy-rmw-int2dds-cpp
source /opt/ros/jazzy/setup.bash
export RMW_IMPLEMENTATION=rmw_int2dds_cpp
apt install pulls in the int2dds_ffi_vendor package automatically. The RMW library
and its ament-index marker install into /opt/ros/jazzy/, so once the environment is
sourced only RMW_IMPLEMENTATION needs to be set.
Supported: humble / jazzy / lyrical / rolling × amd64 / arm64 (rolling: testing repository only).
From the ROS 2 RPM repository (RHEL)
With the ROS 2 RPM repository set up as in the ROS 2 RHEL installation guide:
sudo dnf install ros-jazzy-rmw-int2dds-cpp
source /opt/ros/jazzy/setup.bash
export RMW_IMPLEMENTATION=rmw_int2dds_cpp
Latest version (testing repository or source build)
The newest release is available from the ROS 2 testing repository:
sudo apt install -y ros2-testing-apt-source
sudo apt update
sudo apt install ros-jazzy-rmw-int2dds-cpp
To build from source instead, follow Quick Start.
Windows and macOS
There are no binary packages of rmw_int2dds for Windows or macOS: build it from
source on top of a ROS 2 installation made with the ROS 2 installation guide for
that platform. int2dds_ffi_vendor downloads the FFI for the host from the
int2DDS releases.
Windows, in an x64 Native Tools Command Prompt for VS 2019, with ROS 2 Jazzy installed as in the ROS 2 Windows binary guide (C:\pixi_ws).
The ROS 2 Windows binaries are Release builds, so build rmw_int2dds as Release too:
```bat cd /d C:\pixi_ws pixi shell call C:\pixi_ws\ros2-windows\local_setup.bat md C:\dev\ros2_ws\src
File truncated at 100 lines see the full file
CONTRIBUTING
Contributing to rmw_int2dds_cpp
Thank you for your interest in contributing! This package is the ROS 2 RMW binding for int2DDS. For contributions to the underlying DDS core, see the int2DDS repository.
Code of Conduct
This project adheres to a Code of Conduct.
Contributor License Agreement (CLA)
By submitting a pull request you agree to the project CLA (individual / corporate).
Development Environment
Prerequisites
- A supported ROS 2 distribution (Humble or Jazzy) installed and sourced
- colcon build tool
- A C++17 compiler (GCC/Clang/MSVC), CMake >= 3.14.4
- The int2DDS core library available as a dependency
Workspace setup
mkdir -p ~/ros2_ws/src && cd ~/ros2_ws/src
git clone https://github.com/IntellectusCorp/rmw_int2dds.git
cd ~/ros2_ws
rosdep install --from-paths src --ignore-src -r -y
Building and Testing
# Build
colcon build --packages-up-to rmw_int2dds_cpp
# Run this package's tests
colcon test --packages-select rmw_int2dds_cpp
colcon test-result --verbose
# Run the RMW interface conformance suite against int2DDS
RMW_IMPLEMENTATION=rmw_int2dds_cpp \
colcon test --packages-select test_rmw_implementation
Tier 3 listing requires the full
test_rmw_implementationsuite to pass.
Code Style
This package follows the ROS 2 Code Style and Language Versions guide:
- C++17, max line length 100,
.hpp/.cppextensions - Linters run as tests via
ament_lint_auto+ament_lint_common(ament_clang_format,ament_cpplint,ament_uncrustify,ament_cppcheck) - Build with
-Wall -Wextra -Wpedantic
# Run linters
colcon test --packages-select rmw_int2dds_cpp --ctest-args -R lint
Commit Messages
Use the format TYPE: short description (max 72 chars), imperative mood.
Types: FEAT, FIX, DOCS, STYLE, REFACTOR, TEST, CHORE, PERF.
Reference issues with Fixes #123.
Branch Naming
feature/, fix/, hotfix/, docs/, refactor/, test/ prefixes;
lowercase with hyphens (e.g., feature/qos-deadline).
Pull Request Process
- Rebase on the latest
upstream/main. - Ensure
colcon buildandcolcon testpass, including linters. - Update documentation and
CHANGELOG.rstif behavior or APIs changed. - Open a PR with a clear summary, rationale, and testing notes.
- Request review from maintainers.
Reporting Bugs
Open a GitHub issue with: description, reproduction steps, expected vs actual behavior, environment (OS, ROS 2 distro, int2DDS version), and logs. For security issues, follow SECURITY.md instead.
License
By contributing, you agree your contributions are licensed under the Apache License 2.0.
License of contributions
Any contribution that you make to this repository will be under the Apache 2 License, as dictated by that
File truncated at 100 lines see the full file
Repository Summary
| Description | |
| Checkout URI | https://github.com/IntellectusCorp/rmw_int2dds.git |
| VCS Type | git |
| VCS Version | humble |
| Last Updated | 2026-10-13 |
| Dev Status | DEVELOPED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| int2dds_ffi_vendor | 0.1.8 |
| rmw_int2dds_cpp | 0.1.8 |
| rmw_int2dds_validation | 0.1.8 |
README
ROS 2 RMW for int2DDS
Overview
rmw_int2dds_cpp lets ROS 2 applications run on top of
int2DDS, a Rust
implementation of the OMG DDS standard (RTPS 2.5). It implements the ROS 2 rmw
C interface so that any ROS 2 stack (rclcpp, rclpy, ros2 CLI, tools) can use
int2DDS as its middleware via RMW_IMPLEMENTATION=rmw_int2dds_cpp.
Status: work in progress — APIs and test results are being stabilized ahead of a request for Tier 3 status in REP 2000.
Supported ROS 2 distributions
| Distribution | Status |
|---|---|
| Humble Hawksbill (LTS) | Supported (verified) |
| Jazzy Jalisco (LTS) | Supported (verified) |
| Lyrical Luth (LTS) | Supported (verified, except cross-vendor WStrings - see Known issues) |
| Rolling Ridley | Supported (verified, except cross-vendor WStrings - see Known issues) |
Supported platforms
| Platform | amd64 | arm64 | arm32 |
|---|---|---|---|
| Ubuntu 22.04 (Jammy) | Verified | Verified | Verified |
| Windows 10 | Verified (on Windows 11) | ||
| RHEL 8 | Verified | ||
| Ubuntu 20.04 (Focal) | Verified | Verified | Verified |
| macOS | Verified | ||
| Debian 11 (Bullseye) | Verified | Verified | Verified |
| OpenEmbedded / Yocto | Verified | Verified | Not supported |
- Windows: verified on Windows 11 with Visual Studio 2019. See Windows and macOS.
- macOS: verified on macOS 15.
- OpenEmbedded / Yocto: verified with a local layer that adds the
rmw_int2ddsrecipes. arm32 does not build: the ROS 2 message packages fail beforermw_int2ddsis reached.
Installation
From the ROS 2 apt repository
sudo apt update
sudo apt install ros-humble-rmw-int2dds-cpp
source /opt/ros/humble/setup.bash
export RMW_IMPLEMENTATION=rmw_int2dds_cpp
apt install pulls in the int2dds_ffi_vendor package automatically. The RMW library
and its ament-index marker install into /opt/ros/humble/, so once the environment is
sourced only RMW_IMPLEMENTATION needs to be set.
Supported: humble / jazzy / lyrical / rolling × amd64 / arm64 (rolling: testing repository only).
From the ROS 2 RPM repository (RHEL)
With the ROS 2 RPM repository set up as in the ROS 2 RHEL installation guide:
sudo dnf install ros-humble-rmw-int2dds-cpp
source /opt/ros/humble/setup.bash
export RMW_IMPLEMENTATION=rmw_int2dds_cpp
Latest version (testing repository or source build)
The newest release is available from the ROS 2 testing repository:
sudo apt install -y ros2-testing-apt-source
sudo apt update
sudo apt install ros-humble-rmw-int2dds-cpp
To build from source instead, follow Quick Start.
Windows and macOS
There are no binary packages of rmw_int2dds for Windows or macOS: build it from
source on top of a ROS 2 installation made with the ROS 2 installation guide for
that platform. int2dds_ffi_vendor downloads the FFI for the host from the
int2DDS releases.
Windows, in an x64 Native Tools Command Prompt for VS 2019. The commands below assume ROS 2 Humble in
C:\pixi_ws\ros2-windows; change the paths to match your installation.
The ROS 2 Windows binaries are Release builds, so build rmw_int2dds as Release too:
```bat cd /d C:\pixi_ws pixi shell call C:\pixi_ws\ros2-windows\local_setup.bat
File truncated at 100 lines see the full file
CONTRIBUTING
Contributing to rmw_int2dds_cpp
Thank you for your interest in contributing! This package is the ROS 2 RMW binding for int2DDS. For contributions to the underlying DDS core, see the int2DDS repository.
Code of Conduct
This project adheres to a Code of Conduct.
Contributor License Agreement (CLA)
By submitting a pull request you agree to the project CLA (individual / corporate).
Development Environment
Prerequisites
- A supported ROS 2 distribution (Humble or Jazzy) installed and sourced
- colcon build tool
- A C++17 compiler (GCC/Clang/MSVC), CMake >= 3.14.4
- The int2DDS core library available as a dependency
Workspace setup
mkdir -p ~/ros2_ws/src && cd ~/ros2_ws/src
git clone https://github.com/IntellectusCorp/rmw_int2dds.git
cd ~/ros2_ws
rosdep install --from-paths src --ignore-src -r -y
Building and Testing
# Build
colcon build --packages-up-to rmw_int2dds_cpp
# Run this package's tests
colcon test --packages-select rmw_int2dds_cpp
colcon test-result --verbose
# Run the RMW interface conformance suite against int2DDS
RMW_IMPLEMENTATION=rmw_int2dds_cpp \
colcon test --packages-select test_rmw_implementation
Tier 3 listing requires the full
test_rmw_implementationsuite to pass.
Code Style
This package follows the ROS 2 Code Style and Language Versions guide:
- C++17, max line length 100,
.hpp/.cppextensions - Linters run as tests via
ament_lint_auto+ament_lint_common(ament_clang_format,ament_cpplint,ament_uncrustify,ament_cppcheck) - Build with
-Wall -Wextra -Wpedantic
# Run linters
colcon test --packages-select rmw_int2dds_cpp --ctest-args -R lint
Commit Messages
Use the format TYPE: short description (max 72 chars), imperative mood.
Types: FEAT, FIX, DOCS, STYLE, REFACTOR, TEST, CHORE, PERF.
Reference issues with Fixes #123.
Branch Naming
feature/, fix/, hotfix/, docs/, refactor/, test/ prefixes;
lowercase with hyphens (e.g., feature/qos-deadline).
Pull Request Process
- Rebase on the latest
upstream/main. - Ensure
colcon buildandcolcon testpass, including linters. - Update documentation and
CHANGELOG.rstif behavior or APIs changed. - Open a PR with a clear summary, rationale, and testing notes.
- Request review from maintainers.
Reporting Bugs
Open a GitHub issue with: description, reproduction steps, expected vs actual behavior, environment (OS, ROS 2 distro, int2DDS version), and logs. For security issues, follow SECURITY.md instead.
License
By contributing, you agree your contributions are licensed under the Apache License 2.0.
License of contributions
Any contribution that you make to this repository will be under the Apache 2 License, as dictated by that
File truncated at 100 lines see the full file
Repository Summary
| Description | |
| Checkout URI | https://github.com/IntellectusCorp/rmw_int2dds.git |
| VCS Type | git |
| VCS Version | lyrical |
| Last Updated | 2026-10-13 |
| Dev Status | DEVELOPED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| int2dds_ffi_vendor | 0.1.8 |
| rmw_int2dds_cpp | 0.1.8 |
| rmw_int2dds_validation | 0.1.8 |
README
ROS 2 RMW for int2DDS
Overview
rmw_int2dds_cpp lets ROS 2 applications run on top of
int2DDS, a Rust
implementation of the OMG DDS standard (RTPS 2.5). It implements the ROS 2 rmw
C interface so that any ROS 2 stack (rclcpp, rclpy, ros2 CLI, tools) can use
int2DDS as its middleware via RMW_IMPLEMENTATION=rmw_int2dds_cpp.
Status: work in progress — APIs and test results are being stabilized ahead of a request for Tier 3 status in REP 2000.
Supported ROS 2 distributions
| Distribution | Status |
|---|---|
| Humble Hawksbill (LTS) | Supported (verified) |
| Jazzy Jalisco (LTS) | Supported (verified) |
| Lyrical Luth (LTS) | Supported (verified, except cross-vendor WStrings - see Known issues) |
| Rolling Ridley | Supported (verified, except cross-vendor WStrings - see Known issues) |
Supported platforms
| Platform | amd64 | arm64 | arm32 |
|---|---|---|---|
| Ubuntu 26.04 (Resolute) | Verified | Verified | Verified |
| Ubuntu 24.04 (Noble) | Verified | Verified | Verified |
| Windows 11 | Verified | ||
| RHEL 10 | Verified | ||
| macOS | Verified | ||
| Debian 13 (Trixie) | Verified | Verified | Verified |
| OpenEmbedded / Yocto | Verified | Verified | Not supported |
- Windows: verified on Windows 11 with Visual Studio 2022. See Windows and macOS.
- macOS: verified on macOS 15.
- OpenEmbedded / Yocto: verified with a local layer that adds the
rmw_int2ddsrecipes. arm32 does not build: the ROS 2 message packages fail beforermw_int2ddsis reached.
Installation
From the ROS 2 apt repository
sudo apt update
sudo apt install ros-lyrical-rmw-int2dds-cpp
source /opt/ros/lyrical/setup.bash
export RMW_IMPLEMENTATION=rmw_int2dds_cpp
apt install pulls in the int2dds_ffi_vendor package automatically. The RMW library
and its ament-index marker install into /opt/ros/lyrical/, so once the environment is
sourced only RMW_IMPLEMENTATION needs to be set.
Supported: humble / jazzy / lyrical / rolling × amd64 / arm64 (rolling: testing repository only).
From the ROS 2 RPM repository (RHEL)
With the ROS 2 RPM repository set up as in the ROS 2 RHEL installation guide:
sudo dnf install ros-lyrical-rmw-int2dds-cpp
source /opt/ros/lyrical/setup.bash
export RMW_IMPLEMENTATION=rmw_int2dds_cpp
Latest version (testing repository or source build)
The newest release is available from the ROS 2 testing repository:
sudo apt install -y ros2-testing-apt-source
sudo apt update
sudo apt install ros-lyrical-rmw-int2dds-cpp
To build from source instead, follow Quick Start.
Windows and macOS
There are no binary packages of rmw_int2dds for Windows or macOS: build it from
source on top of a ROS 2 installation made with the ROS 2 installation guide for
that platform. int2dds_ffi_vendor downloads the FFI for the host from the
int2DDS releases.
Windows, in an x64 Native Tools Command Prompt for VS 2022, with ROS 2 Lyrical installed as in the ROS 2 Windows binary guide (C:\dev\lyrical).
The ROS 2 Windows binaries are Release builds, so build rmw_int2dds as Release too:
```bat cd /d C:\dev\lyrical pixi shell call C:\dev\lyrical\local_setup.bat md C:\dev\ros2_ws\src
File truncated at 100 lines see the full file
CONTRIBUTING
Contributing to rmw_int2dds_cpp
Thank you for your interest in contributing! This package is the ROS 2 RMW binding for int2DDS. For contributions to the underlying DDS core, see the int2DDS repository.
Code of Conduct
This project adheres to a Code of Conduct.
Contributor License Agreement (CLA)
By submitting a pull request you agree to the project CLA (individual / corporate).
Development Environment
Prerequisites
- A supported ROS 2 distribution (Humble or Jazzy) installed and sourced
- colcon build tool
- A C++17 compiler (GCC/Clang/MSVC), CMake >= 3.14.4
- The int2DDS core library available as a dependency
Workspace setup
mkdir -p ~/ros2_ws/src && cd ~/ros2_ws/src
git clone https://github.com/IntellectusCorp/rmw_int2dds.git
cd ~/ros2_ws
rosdep install --from-paths src --ignore-src -r -y
Building and Testing
# Build
colcon build --packages-up-to rmw_int2dds_cpp
# Run this package's tests
colcon test --packages-select rmw_int2dds_cpp
colcon test-result --verbose
# Run the RMW interface conformance suite against int2DDS
RMW_IMPLEMENTATION=rmw_int2dds_cpp \
colcon test --packages-select test_rmw_implementation
Tier 3 listing requires the full
test_rmw_implementationsuite to pass.
Code Style
This package follows the ROS 2 Code Style and Language Versions guide:
- C++17, max line length 100,
.hpp/.cppextensions - Linters run as tests via
ament_lint_auto+ament_lint_common(ament_clang_format,ament_cpplint,ament_uncrustify,ament_cppcheck) - Build with
-Wall -Wextra -Wpedantic
# Run linters
colcon test --packages-select rmw_int2dds_cpp --ctest-args -R lint
Commit Messages
Use the format TYPE: short description (max 72 chars), imperative mood.
Types: FEAT, FIX, DOCS, STYLE, REFACTOR, TEST, CHORE, PERF.
Reference issues with Fixes #123.
Branch Naming
feature/, fix/, hotfix/, docs/, refactor/, test/ prefixes;
lowercase with hyphens (e.g., feature/qos-deadline).
Pull Request Process
- Rebase on the latest
upstream/main. - Ensure
colcon buildandcolcon testpass, including linters. - Update documentation and
CHANGELOG.rstif behavior or APIs changed. - Open a PR with a clear summary, rationale, and testing notes.
- Request review from maintainers.
Reporting Bugs
Open a GitHub issue with: description, reproduction steps, expected vs actual behavior, environment (OS, ROS 2 distro, int2DDS version), and logs. For security issues, follow SECURITY.md instead.
License
By contributing, you agree your contributions are licensed under the Apache License 2.0.
License of contributions
Any contribution that you make to this repository will be under the Apache 2 License, as dictated by that
File truncated at 100 lines see the full file
Repository Summary
| Description | |
| Checkout URI | https://github.com/IntellectusCorp/rmw_int2dds.git |
| VCS Type | git |
| VCS Version | rolling |
| Last Updated | 2026-10-13 |
| Dev Status | DEVELOPED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| int2dds_ffi_vendor | 0.1.8 |
| rmw_int2dds_cpp | 0.1.8 |
| rmw_int2dds_validation | 0.1.8 |
README
ROS 2 RMW for int2DDS
Overview
rmw_int2dds_cpp lets ROS 2 applications run on top of
int2DDS, a Rust
implementation of the OMG DDS standard (RTPS 2.5). It implements the ROS 2 rmw
C interface so that any ROS 2 stack (rclcpp, rclpy, ros2 CLI, tools) can use
int2DDS as its middleware via RMW_IMPLEMENTATION=rmw_int2dds_cpp.
Status: work in progress — APIs and test results are being stabilized ahead of a request for Tier 3 status in REP 2000.
Supported ROS 2 distributions
| Distribution | Status |
|---|---|
| Humble Hawksbill (LTS) | Supported (verified) |
| Jazzy Jalisco (LTS) | Supported (verified) |
| Lyrical Luth (LTS) | Supported (verified, except cross-vendor WStrings - see Known issues) |
| Rolling Ridley | Supported (verified, except cross-vendor WStrings - see Known issues) |
Supported platforms
| Platform | amd64 | arm64 |
|---|---|---|
| Ubuntu 26.04 (Resolute) | Verified | Verified |
- Windows, macOS: not verified on Rolling.
- arm32: not supported. ROS 2 publishes no arm32 binaries.
Installation
From the ROS 2 apt repository
Rolling packages are published to the ROS 2 testing repository only; see the next section.
Supported: humble / jazzy / lyrical / rolling × amd64 / arm64.
Latest version (testing repository or source build)
The newest release is available from the ROS 2 testing repository:
sudo apt install -y ros2-testing-apt-source
sudo apt update
sudo apt install ros-rolling-rmw-int2dds-cpp
source /opt/ros/rolling/setup.bash
export RMW_IMPLEMENTATION=rmw_int2dds_cpp
To build from source instead, follow Quick Start.
Quick Start
# 1) Get the sources into your ROS 2 workspace
mkdir -p ~/ros2_ws/src && cd ~/ros2_ws/src
git clone -b rolling https://github.com/IntellectusCorp/rmw_int2dds.git
# 2) Build
cd ~/ros2_ws
source /opt/ros/rolling/setup.bash
colcon build --packages-up-to rmw_int2dds_cpp
source install/setup.bash
# 3) Select int2DDS as the middleware
export RMW_IMPLEMENTATION=rmw_int2dds_cpp
# 4) Run any ROS 2 demo
ros2 run demo_nodes_cpp talker
# in another terminal (same RMW_IMPLEMENTATION):
ros2 run demo_nodes_cpp listener
Running examples
# Python (rclpy)
RMW_IMPLEMENTATION=rmw_int2dds_cpp ros2 run demo_nodes_py talker
RMW_IMPLEMENTATION=rmw_int2dds_cpp ros2 run demo_nodes_py listener
These are the minimal per-language talker/listener smoke examples; run each command in its own terminal.
More examples
```bash
Service / client
RMW_IMPLEMENTATION=rmw_int2dds_cpp ros2 run demo_nodes_cpp add_two_ints_server RMW_IMPLEMENTATION=rmw_int2dds_cpp ros2 run demo_nodes_cpp add_two_ints_client
File truncated at 100 lines see the full file
CONTRIBUTING
Contributing to rmw_int2dds_cpp
Thank you for your interest in contributing! This package is the ROS 2 RMW binding for int2DDS. For contributions to the underlying DDS core, see the int2DDS repository.
Code of Conduct
This project adheres to a Code of Conduct.
Contributor License Agreement (CLA)
By submitting a pull request you agree to the project CLA (individual / corporate).
Development Environment
Prerequisites
- A supported ROS 2 distribution (Humble or Jazzy) installed and sourced
- colcon build tool
- A C++17 compiler (GCC/Clang/MSVC), CMake >= 3.14.4
- The int2DDS core library available as a dependency
Workspace setup
mkdir -p ~/ros2_ws/src && cd ~/ros2_ws/src
git clone https://github.com/IntellectusCorp/rmw_int2dds.git
cd ~/ros2_ws
rosdep install --from-paths src --ignore-src -r -y
Building and Testing
# Build
colcon build --packages-up-to rmw_int2dds_cpp
# Run this package's tests
colcon test --packages-select rmw_int2dds_cpp
colcon test-result --verbose
# Run the RMW interface conformance suite against int2DDS
RMW_IMPLEMENTATION=rmw_int2dds_cpp \
colcon test --packages-select test_rmw_implementation
Tier 3 listing requires the full
test_rmw_implementationsuite to pass.
Code Style
This package follows the ROS 2 Code Style and Language Versions guide:
- C++17, max line length 100,
.hpp/.cppextensions - Linters run as tests via
ament_lint_auto+ament_lint_common(ament_clang_format,ament_cpplint,ament_uncrustify,ament_cppcheck) - Build with
-Wall -Wextra -Wpedantic
# Run linters
colcon test --packages-select rmw_int2dds_cpp --ctest-args -R lint
Commit Messages
Use the format TYPE: short description (max 72 chars), imperative mood.
Types: FEAT, FIX, DOCS, STYLE, REFACTOR, TEST, CHORE, PERF.
Reference issues with Fixes #123.
Branch Naming
feature/, fix/, hotfix/, docs/, refactor/, test/ prefixes;
lowercase with hyphens (e.g., feature/qos-deadline).
Pull Request Process
- Rebase on the latest
upstream/main. - Ensure
colcon buildandcolcon testpass, including linters. - Update documentation and
CHANGELOG.rstif behavior or APIs changed. - Open a PR with a clear summary, rationale, and testing notes.
- Request review from maintainers.
Reporting Bugs
Open a GitHub issue with: description, reproduction steps, expected vs actual behavior, environment (OS, ROS 2 distro, int2DDS version), and logs. For security issues, follow SECURITY.md instead.
License
By contributing, you agree your contributions are licensed under the Apache License 2.0.
License of contributions
Any contribution that you make to this repository will be under the Apache 2 License, as dictated by that
File truncated at 100 lines see the full file
Repository Summary
| Description | |
| Checkout URI | https://github.com/IntellectusCorp/rmw_int2dds.git |
| VCS Type | git |
| VCS Version | humble |
| Last Updated | 2026-10-13 |
| Dev Status | DEVELOPED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| int2dds_ffi_vendor | 0.1.8 |
| rmw_int2dds_cpp | 0.1.8 |
| rmw_int2dds_validation | 0.1.8 |
README
ROS 2 RMW for int2DDS
Overview
rmw_int2dds_cpp lets ROS 2 applications run on top of
int2DDS, a Rust
implementation of the OMG DDS standard (RTPS 2.5). It implements the ROS 2 rmw
C interface so that any ROS 2 stack (rclcpp, rclpy, ros2 CLI, tools) can use
int2DDS as its middleware via RMW_IMPLEMENTATION=rmw_int2dds_cpp.
Status: work in progress — APIs and test results are being stabilized ahead of a request for Tier 3 status in REP 2000.
Supported ROS 2 distributions
| Distribution | Status |
|---|---|
| Humble Hawksbill (LTS) | Supported (verified) |
| Jazzy Jalisco (LTS) | Supported (verified) |
| Lyrical Luth (LTS) | Supported (verified, except cross-vendor WStrings - see Known issues) |
| Rolling Ridley | Supported (verified, except cross-vendor WStrings - see Known issues) |
Supported platforms
| Platform | amd64 | arm64 | arm32 |
|---|---|---|---|
| Ubuntu 22.04 (Jammy) | Verified | Verified | Verified |
| Windows 10 | Verified (on Windows 11) | ||
| RHEL 8 | Verified | ||
| Ubuntu 20.04 (Focal) | Verified | Verified | Verified |
| macOS | Verified | ||
| Debian 11 (Bullseye) | Verified | Verified | Verified |
| OpenEmbedded / Yocto | Verified | Verified | Not supported |
- Windows: verified on Windows 11 with Visual Studio 2019. See Windows and macOS.
- macOS: verified on macOS 15.
- OpenEmbedded / Yocto: verified with a local layer that adds the
rmw_int2ddsrecipes. arm32 does not build: the ROS 2 message packages fail beforermw_int2ddsis reached.
Installation
From the ROS 2 apt repository
sudo apt update
sudo apt install ros-humble-rmw-int2dds-cpp
source /opt/ros/humble/setup.bash
export RMW_IMPLEMENTATION=rmw_int2dds_cpp
apt install pulls in the int2dds_ffi_vendor package automatically. The RMW library
and its ament-index marker install into /opt/ros/humble/, so once the environment is
sourced only RMW_IMPLEMENTATION needs to be set.
Supported: humble / jazzy / lyrical / rolling × amd64 / arm64 (rolling: testing repository only).
From the ROS 2 RPM repository (RHEL)
With the ROS 2 RPM repository set up as in the ROS 2 RHEL installation guide:
sudo dnf install ros-humble-rmw-int2dds-cpp
source /opt/ros/humble/setup.bash
export RMW_IMPLEMENTATION=rmw_int2dds_cpp
Latest version (testing repository or source build)
The newest release is available from the ROS 2 testing repository:
sudo apt install -y ros2-testing-apt-source
sudo apt update
sudo apt install ros-humble-rmw-int2dds-cpp
To build from source instead, follow Quick Start.
Windows and macOS
There are no binary packages of rmw_int2dds for Windows or macOS: build it from
source on top of a ROS 2 installation made with the ROS 2 installation guide for
that platform. int2dds_ffi_vendor downloads the FFI for the host from the
int2DDS releases.
Windows, in an x64 Native Tools Command Prompt for VS 2019. The commands below assume ROS 2 Humble in
C:\pixi_ws\ros2-windows; change the paths to match your installation.
The ROS 2 Windows binaries are Release builds, so build rmw_int2dds as Release too:
```bat cd /d C:\pixi_ws pixi shell call C:\pixi_ws\ros2-windows\local_setup.bat
File truncated at 100 lines see the full file
CONTRIBUTING
Contributing to rmw_int2dds_cpp
Thank you for your interest in contributing! This package is the ROS 2 RMW binding for int2DDS. For contributions to the underlying DDS core, see the int2DDS repository.
Code of Conduct
This project adheres to a Code of Conduct.
Contributor License Agreement (CLA)
By submitting a pull request you agree to the project CLA (individual / corporate).
Development Environment
Prerequisites
- A supported ROS 2 distribution (Humble or Jazzy) installed and sourced
- colcon build tool
- A C++17 compiler (GCC/Clang/MSVC), CMake >= 3.14.4
- The int2DDS core library available as a dependency
Workspace setup
mkdir -p ~/ros2_ws/src && cd ~/ros2_ws/src
git clone https://github.com/IntellectusCorp/rmw_int2dds.git
cd ~/ros2_ws
rosdep install --from-paths src --ignore-src -r -y
Building and Testing
# Build
colcon build --packages-up-to rmw_int2dds_cpp
# Run this package's tests
colcon test --packages-select rmw_int2dds_cpp
colcon test-result --verbose
# Run the RMW interface conformance suite against int2DDS
RMW_IMPLEMENTATION=rmw_int2dds_cpp \
colcon test --packages-select test_rmw_implementation
Tier 3 listing requires the full
test_rmw_implementationsuite to pass.
Code Style
This package follows the ROS 2 Code Style and Language Versions guide:
- C++17, max line length 100,
.hpp/.cppextensions - Linters run as tests via
ament_lint_auto+ament_lint_common(ament_clang_format,ament_cpplint,ament_uncrustify,ament_cppcheck) - Build with
-Wall -Wextra -Wpedantic
# Run linters
colcon test --packages-select rmw_int2dds_cpp --ctest-args -R lint
Commit Messages
Use the format TYPE: short description (max 72 chars), imperative mood.
Types: FEAT, FIX, DOCS, STYLE, REFACTOR, TEST, CHORE, PERF.
Reference issues with Fixes #123.
Branch Naming
feature/, fix/, hotfix/, docs/, refactor/, test/ prefixes;
lowercase with hyphens (e.g., feature/qos-deadline).
Pull Request Process
- Rebase on the latest
upstream/main. - Ensure
colcon buildandcolcon testpass, including linters. - Update documentation and
CHANGELOG.rstif behavior or APIs changed. - Open a PR with a clear summary, rationale, and testing notes.
- Request review from maintainers.
Reporting Bugs
Open a GitHub issue with: description, reproduction steps, expected vs actual behavior, environment (OS, ROS 2 distro, int2DDS version), and logs. For security issues, follow SECURITY.md instead.
License
By contributing, you agree your contributions are licensed under the Apache License 2.0.
License of contributions
Any contribution that you make to this repository will be under the Apache 2 License, as dictated by that
File truncated at 100 lines see the full file
Repository Summary
| Description | |
| Checkout URI | https://github.com/IntellectusCorp/rmw_int2dds.git |
| VCS Type | git |
| VCS Version | humble |
| Last Updated | 2026-10-13 |
| Dev Status | DEVELOPED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| int2dds_ffi_vendor | 0.1.8 |
| rmw_int2dds_cpp | 0.1.8 |
| rmw_int2dds_validation | 0.1.8 |
README
ROS 2 RMW for int2DDS
Overview
rmw_int2dds_cpp lets ROS 2 applications run on top of
int2DDS, a Rust
implementation of the OMG DDS standard (RTPS 2.5). It implements the ROS 2 rmw
C interface so that any ROS 2 stack (rclcpp, rclpy, ros2 CLI, tools) can use
int2DDS as its middleware via RMW_IMPLEMENTATION=rmw_int2dds_cpp.
Status: work in progress — APIs and test results are being stabilized ahead of a request for Tier 3 status in REP 2000.
Supported ROS 2 distributions
| Distribution | Status |
|---|---|
| Humble Hawksbill (LTS) | Supported (verified) |
| Jazzy Jalisco (LTS) | Supported (verified) |
| Lyrical Luth (LTS) | Supported (verified, except cross-vendor WStrings - see Known issues) |
| Rolling Ridley | Supported (verified, except cross-vendor WStrings - see Known issues) |
Supported platforms
| Platform | amd64 | arm64 | arm32 |
|---|---|---|---|
| Ubuntu 22.04 (Jammy) | Verified | Verified | Verified |
| Windows 10 | Verified (on Windows 11) | ||
| RHEL 8 | Verified | ||
| Ubuntu 20.04 (Focal) | Verified | Verified | Verified |
| macOS | Verified | ||
| Debian 11 (Bullseye) | Verified | Verified | Verified |
| OpenEmbedded / Yocto | Verified | Verified | Not supported |
- Windows: verified on Windows 11 with Visual Studio 2019. See Windows and macOS.
- macOS: verified on macOS 15.
- OpenEmbedded / Yocto: verified with a local layer that adds the
rmw_int2ddsrecipes. arm32 does not build: the ROS 2 message packages fail beforermw_int2ddsis reached.
Installation
From the ROS 2 apt repository
sudo apt update
sudo apt install ros-humble-rmw-int2dds-cpp
source /opt/ros/humble/setup.bash
export RMW_IMPLEMENTATION=rmw_int2dds_cpp
apt install pulls in the int2dds_ffi_vendor package automatically. The RMW library
and its ament-index marker install into /opt/ros/humble/, so once the environment is
sourced only RMW_IMPLEMENTATION needs to be set.
Supported: humble / jazzy / lyrical / rolling × amd64 / arm64 (rolling: testing repository only).
From the ROS 2 RPM repository (RHEL)
With the ROS 2 RPM repository set up as in the ROS 2 RHEL installation guide:
sudo dnf install ros-humble-rmw-int2dds-cpp
source /opt/ros/humble/setup.bash
export RMW_IMPLEMENTATION=rmw_int2dds_cpp
Latest version (testing repository or source build)
The newest release is available from the ROS 2 testing repository:
sudo apt install -y ros2-testing-apt-source
sudo apt update
sudo apt install ros-humble-rmw-int2dds-cpp
To build from source instead, follow Quick Start.
Windows and macOS
There are no binary packages of rmw_int2dds for Windows or macOS: build it from
source on top of a ROS 2 installation made with the ROS 2 installation guide for
that platform. int2dds_ffi_vendor downloads the FFI for the host from the
int2DDS releases.
Windows, in an x64 Native Tools Command Prompt for VS 2019. The commands below assume ROS 2 Humble in
C:\pixi_ws\ros2-windows; change the paths to match your installation.
The ROS 2 Windows binaries are Release builds, so build rmw_int2dds as Release too:
```bat cd /d C:\pixi_ws pixi shell call C:\pixi_ws\ros2-windows\local_setup.bat
File truncated at 100 lines see the full file
CONTRIBUTING
Contributing to rmw_int2dds_cpp
Thank you for your interest in contributing! This package is the ROS 2 RMW binding for int2DDS. For contributions to the underlying DDS core, see the int2DDS repository.
Code of Conduct
This project adheres to a Code of Conduct.
Contributor License Agreement (CLA)
By submitting a pull request you agree to the project CLA (individual / corporate).
Development Environment
Prerequisites
- A supported ROS 2 distribution (Humble or Jazzy) installed and sourced
- colcon build tool
- A C++17 compiler (GCC/Clang/MSVC), CMake >= 3.14.4
- The int2DDS core library available as a dependency
Workspace setup
mkdir -p ~/ros2_ws/src && cd ~/ros2_ws/src
git clone https://github.com/IntellectusCorp/rmw_int2dds.git
cd ~/ros2_ws
rosdep install --from-paths src --ignore-src -r -y
Building and Testing
# Build
colcon build --packages-up-to rmw_int2dds_cpp
# Run this package's tests
colcon test --packages-select rmw_int2dds_cpp
colcon test-result --verbose
# Run the RMW interface conformance suite against int2DDS
RMW_IMPLEMENTATION=rmw_int2dds_cpp \
colcon test --packages-select test_rmw_implementation
Tier 3 listing requires the full
test_rmw_implementationsuite to pass.
Code Style
This package follows the ROS 2 Code Style and Language Versions guide:
- C++17, max line length 100,
.hpp/.cppextensions - Linters run as tests via
ament_lint_auto+ament_lint_common(ament_clang_format,ament_cpplint,ament_uncrustify,ament_cppcheck) - Build with
-Wall -Wextra -Wpedantic
# Run linters
colcon test --packages-select rmw_int2dds_cpp --ctest-args -R lint
Commit Messages
Use the format TYPE: short description (max 72 chars), imperative mood.
Types: FEAT, FIX, DOCS, STYLE, REFACTOR, TEST, CHORE, PERF.
Reference issues with Fixes #123.
Branch Naming
feature/, fix/, hotfix/, docs/, refactor/, test/ prefixes;
lowercase with hyphens (e.g., feature/qos-deadline).
Pull Request Process
- Rebase on the latest
upstream/main. - Ensure
colcon buildandcolcon testpass, including linters. - Update documentation and
CHANGELOG.rstif behavior or APIs changed. - Open a PR with a clear summary, rationale, and testing notes.
- Request review from maintainers.
Reporting Bugs
Open a GitHub issue with: description, reproduction steps, expected vs actual behavior, environment (OS, ROS 2 distro, int2DDS version), and logs. For security issues, follow SECURITY.md instead.
License
By contributing, you agree your contributions are licensed under the Apache License 2.0.
License of contributions
Any contribution that you make to this repository will be under the Apache 2 License, as dictated by that
File truncated at 100 lines see the full file
Repository Summary
| Description | |
| Checkout URI | https://github.com/IntellectusCorp/rmw_int2dds.git |
| VCS Type | git |
| VCS Version | humble |
| Last Updated | 2026-10-13 |
| Dev Status | DEVELOPED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| int2dds_ffi_vendor | 0.1.8 |
| rmw_int2dds_cpp | 0.1.8 |
| rmw_int2dds_validation | 0.1.8 |
README
ROS 2 RMW for int2DDS
Overview
rmw_int2dds_cpp lets ROS 2 applications run on top of
int2DDS, a Rust
implementation of the OMG DDS standard (RTPS 2.5). It implements the ROS 2 rmw
C interface so that any ROS 2 stack (rclcpp, rclpy, ros2 CLI, tools) can use
int2DDS as its middleware via RMW_IMPLEMENTATION=rmw_int2dds_cpp.
Status: work in progress — APIs and test results are being stabilized ahead of a request for Tier 3 status in REP 2000.
Supported ROS 2 distributions
| Distribution | Status |
|---|---|
| Humble Hawksbill (LTS) | Supported (verified) |
| Jazzy Jalisco (LTS) | Supported (verified) |
| Lyrical Luth (LTS) | Supported (verified, except cross-vendor WStrings - see Known issues) |
| Rolling Ridley | Supported (verified, except cross-vendor WStrings - see Known issues) |
Supported platforms
| Platform | amd64 | arm64 | arm32 |
|---|---|---|---|
| Ubuntu 22.04 (Jammy) | Verified | Verified | Verified |
| Windows 10 | Verified (on Windows 11) | ||
| RHEL 8 | Verified | ||
| Ubuntu 20.04 (Focal) | Verified | Verified | Verified |
| macOS | Verified | ||
| Debian 11 (Bullseye) | Verified | Verified | Verified |
| OpenEmbedded / Yocto | Verified | Verified | Not supported |
- Windows: verified on Windows 11 with Visual Studio 2019. See Windows and macOS.
- macOS: verified on macOS 15.
- OpenEmbedded / Yocto: verified with a local layer that adds the
rmw_int2ddsrecipes. arm32 does not build: the ROS 2 message packages fail beforermw_int2ddsis reached.
Installation
From the ROS 2 apt repository
sudo apt update
sudo apt install ros-humble-rmw-int2dds-cpp
source /opt/ros/humble/setup.bash
export RMW_IMPLEMENTATION=rmw_int2dds_cpp
apt install pulls in the int2dds_ffi_vendor package automatically. The RMW library
and its ament-index marker install into /opt/ros/humble/, so once the environment is
sourced only RMW_IMPLEMENTATION needs to be set.
Supported: humble / jazzy / lyrical / rolling × amd64 / arm64 (rolling: testing repository only).
From the ROS 2 RPM repository (RHEL)
With the ROS 2 RPM repository set up as in the ROS 2 RHEL installation guide:
sudo dnf install ros-humble-rmw-int2dds-cpp
source /opt/ros/humble/setup.bash
export RMW_IMPLEMENTATION=rmw_int2dds_cpp
Latest version (testing repository or source build)
The newest release is available from the ROS 2 testing repository:
sudo apt install -y ros2-testing-apt-source
sudo apt update
sudo apt install ros-humble-rmw-int2dds-cpp
To build from source instead, follow Quick Start.
Windows and macOS
There are no binary packages of rmw_int2dds for Windows or macOS: build it from
source on top of a ROS 2 installation made with the ROS 2 installation guide for
that platform. int2dds_ffi_vendor downloads the FFI for the host from the
int2DDS releases.
Windows, in an x64 Native Tools Command Prompt for VS 2019. The commands below assume ROS 2 Humble in
C:\pixi_ws\ros2-windows; change the paths to match your installation.
The ROS 2 Windows binaries are Release builds, so build rmw_int2dds as Release too:
```bat cd /d C:\pixi_ws pixi shell call C:\pixi_ws\ros2-windows\local_setup.bat
File truncated at 100 lines see the full file
CONTRIBUTING
Contributing to rmw_int2dds_cpp
Thank you for your interest in contributing! This package is the ROS 2 RMW binding for int2DDS. For contributions to the underlying DDS core, see the int2DDS repository.
Code of Conduct
This project adheres to a Code of Conduct.
Contributor License Agreement (CLA)
By submitting a pull request you agree to the project CLA (individual / corporate).
Development Environment
Prerequisites
- A supported ROS 2 distribution (Humble or Jazzy) installed and sourced
- colcon build tool
- A C++17 compiler (GCC/Clang/MSVC), CMake >= 3.14.4
- The int2DDS core library available as a dependency
Workspace setup
mkdir -p ~/ros2_ws/src && cd ~/ros2_ws/src
git clone https://github.com/IntellectusCorp/rmw_int2dds.git
cd ~/ros2_ws
rosdep install --from-paths src --ignore-src -r -y
Building and Testing
# Build
colcon build --packages-up-to rmw_int2dds_cpp
# Run this package's tests
colcon test --packages-select rmw_int2dds_cpp
colcon test-result --verbose
# Run the RMW interface conformance suite against int2DDS
RMW_IMPLEMENTATION=rmw_int2dds_cpp \
colcon test --packages-select test_rmw_implementation
Tier 3 listing requires the full
test_rmw_implementationsuite to pass.
Code Style
This package follows the ROS 2 Code Style and Language Versions guide:
- C++17, max line length 100,
.hpp/.cppextensions - Linters run as tests via
ament_lint_auto+ament_lint_common(ament_clang_format,ament_cpplint,ament_uncrustify,ament_cppcheck) - Build with
-Wall -Wextra -Wpedantic
# Run linters
colcon test --packages-select rmw_int2dds_cpp --ctest-args -R lint
Commit Messages
Use the format TYPE: short description (max 72 chars), imperative mood.
Types: FEAT, FIX, DOCS, STYLE, REFACTOR, TEST, CHORE, PERF.
Reference issues with Fixes #123.
Branch Naming
feature/, fix/, hotfix/, docs/, refactor/, test/ prefixes;
lowercase with hyphens (e.g., feature/qos-deadline).
Pull Request Process
- Rebase on the latest
upstream/main. - Ensure
colcon buildandcolcon testpass, including linters. - Update documentation and
CHANGELOG.rstif behavior or APIs changed. - Open a PR with a clear summary, rationale, and testing notes.
- Request review from maintainers.
Reporting Bugs
Open a GitHub issue with: description, reproduction steps, expected vs actual behavior, environment (OS, ROS 2 distro, int2DDS version), and logs. For security issues, follow SECURITY.md instead.
License
By contributing, you agree your contributions are licensed under the Apache License 2.0.
License of contributions
Any contribution that you make to this repository will be under the Apache 2 License, as dictated by that
File truncated at 100 lines see the full file
Repository Summary
| Description | |
| Checkout URI | https://github.com/IntellectusCorp/rmw_int2dds.git |
| VCS Type | git |
| VCS Version | humble |
| Last Updated | 2026-10-13 |
| Dev Status | DEVELOPED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| int2dds_ffi_vendor | 0.1.8 |
| rmw_int2dds_cpp | 0.1.8 |
| rmw_int2dds_validation | 0.1.8 |
README
ROS 2 RMW for int2DDS
Overview
rmw_int2dds_cpp lets ROS 2 applications run on top of
int2DDS, a Rust
implementation of the OMG DDS standard (RTPS 2.5). It implements the ROS 2 rmw
C interface so that any ROS 2 stack (rclcpp, rclpy, ros2 CLI, tools) can use
int2DDS as its middleware via RMW_IMPLEMENTATION=rmw_int2dds_cpp.
Status: work in progress — APIs and test results are being stabilized ahead of a request for Tier 3 status in REP 2000.
Supported ROS 2 distributions
| Distribution | Status |
|---|---|
| Humble Hawksbill (LTS) | Supported (verified) |
| Jazzy Jalisco (LTS) | Supported (verified) |
| Lyrical Luth (LTS) | Supported (verified, except cross-vendor WStrings - see Known issues) |
| Rolling Ridley | Supported (verified, except cross-vendor WStrings - see Known issues) |
Supported platforms
| Platform | amd64 | arm64 | arm32 |
|---|---|---|---|
| Ubuntu 22.04 (Jammy) | Verified | Verified | Verified |
| Windows 10 | Verified (on Windows 11) | ||
| RHEL 8 | Verified | ||
| Ubuntu 20.04 (Focal) | Verified | Verified | Verified |
| macOS | Verified | ||
| Debian 11 (Bullseye) | Verified | Verified | Verified |
| OpenEmbedded / Yocto | Verified | Verified | Not supported |
- Windows: verified on Windows 11 with Visual Studio 2019. See Windows and macOS.
- macOS: verified on macOS 15.
- OpenEmbedded / Yocto: verified with a local layer that adds the
rmw_int2ddsrecipes. arm32 does not build: the ROS 2 message packages fail beforermw_int2ddsis reached.
Installation
From the ROS 2 apt repository
sudo apt update
sudo apt install ros-humble-rmw-int2dds-cpp
source /opt/ros/humble/setup.bash
export RMW_IMPLEMENTATION=rmw_int2dds_cpp
apt install pulls in the int2dds_ffi_vendor package automatically. The RMW library
and its ament-index marker install into /opt/ros/humble/, so once the environment is
sourced only RMW_IMPLEMENTATION needs to be set.
Supported: humble / jazzy / lyrical / rolling × amd64 / arm64 (rolling: testing repository only).
From the ROS 2 RPM repository (RHEL)
With the ROS 2 RPM repository set up as in the ROS 2 RHEL installation guide:
sudo dnf install ros-humble-rmw-int2dds-cpp
source /opt/ros/humble/setup.bash
export RMW_IMPLEMENTATION=rmw_int2dds_cpp
Latest version (testing repository or source build)
The newest release is available from the ROS 2 testing repository:
sudo apt install -y ros2-testing-apt-source
sudo apt update
sudo apt install ros-humble-rmw-int2dds-cpp
To build from source instead, follow Quick Start.
Windows and macOS
There are no binary packages of rmw_int2dds for Windows or macOS: build it from
source on top of a ROS 2 installation made with the ROS 2 installation guide for
that platform. int2dds_ffi_vendor downloads the FFI for the host from the
int2DDS releases.
Windows, in an x64 Native Tools Command Prompt for VS 2019. The commands below assume ROS 2 Humble in
C:\pixi_ws\ros2-windows; change the paths to match your installation.
The ROS 2 Windows binaries are Release builds, so build rmw_int2dds as Release too:
```bat cd /d C:\pixi_ws pixi shell call C:\pixi_ws\ros2-windows\local_setup.bat
File truncated at 100 lines see the full file
CONTRIBUTING
Contributing to rmw_int2dds_cpp
Thank you for your interest in contributing! This package is the ROS 2 RMW binding for int2DDS. For contributions to the underlying DDS core, see the int2DDS repository.
Code of Conduct
This project adheres to a Code of Conduct.
Contributor License Agreement (CLA)
By submitting a pull request you agree to the project CLA (individual / corporate).
Development Environment
Prerequisites
- A supported ROS 2 distribution (Humble or Jazzy) installed and sourced
- colcon build tool
- A C++17 compiler (GCC/Clang/MSVC), CMake >= 3.14.4
- The int2DDS core library available as a dependency
Workspace setup
mkdir -p ~/ros2_ws/src && cd ~/ros2_ws/src
git clone https://github.com/IntellectusCorp/rmw_int2dds.git
cd ~/ros2_ws
rosdep install --from-paths src --ignore-src -r -y
Building and Testing
# Build
colcon build --packages-up-to rmw_int2dds_cpp
# Run this package's tests
colcon test --packages-select rmw_int2dds_cpp
colcon test-result --verbose
# Run the RMW interface conformance suite against int2DDS
RMW_IMPLEMENTATION=rmw_int2dds_cpp \
colcon test --packages-select test_rmw_implementation
Tier 3 listing requires the full
test_rmw_implementationsuite to pass.
Code Style
This package follows the ROS 2 Code Style and Language Versions guide:
- C++17, max line length 100,
.hpp/.cppextensions - Linters run as tests via
ament_lint_auto+ament_lint_common(ament_clang_format,ament_cpplint,ament_uncrustify,ament_cppcheck) - Build with
-Wall -Wextra -Wpedantic
# Run linters
colcon test --packages-select rmw_int2dds_cpp --ctest-args -R lint
Commit Messages
Use the format TYPE: short description (max 72 chars), imperative mood.
Types: FEAT, FIX, DOCS, STYLE, REFACTOR, TEST, CHORE, PERF.
Reference issues with Fixes #123.
Branch Naming
feature/, fix/, hotfix/, docs/, refactor/, test/ prefixes;
lowercase with hyphens (e.g., feature/qos-deadline).
Pull Request Process
- Rebase on the latest
upstream/main. - Ensure
colcon buildandcolcon testpass, including linters. - Update documentation and
CHANGELOG.rstif behavior or APIs changed. - Open a PR with a clear summary, rationale, and testing notes.
- Request review from maintainers.
Reporting Bugs
Open a GitHub issue with: description, reproduction steps, expected vs actual behavior, environment (OS, ROS 2 distro, int2DDS version), and logs. For security issues, follow SECURITY.md instead.
License
By contributing, you agree your contributions are licensed under the Apache License 2.0.
License of contributions
Any contribution that you make to this repository will be under the Apache 2 License, as dictated by that
File truncated at 100 lines see the full file
Repository Summary
| Description | |
| Checkout URI | https://github.com/IntellectusCorp/rmw_int2dds.git |
| VCS Type | git |
| VCS Version | humble |
| Last Updated | 2026-10-13 |
| Dev Status | DEVELOPED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| int2dds_ffi_vendor | 0.1.8 |
| rmw_int2dds_cpp | 0.1.8 |
| rmw_int2dds_validation | 0.1.8 |
README
ROS 2 RMW for int2DDS
Overview
rmw_int2dds_cpp lets ROS 2 applications run on top of
int2DDS, a Rust
implementation of the OMG DDS standard (RTPS 2.5). It implements the ROS 2 rmw
C interface so that any ROS 2 stack (rclcpp, rclpy, ros2 CLI, tools) can use
int2DDS as its middleware via RMW_IMPLEMENTATION=rmw_int2dds_cpp.
Status: work in progress — APIs and test results are being stabilized ahead of a request for Tier 3 status in REP 2000.
Supported ROS 2 distributions
| Distribution | Status |
|---|---|
| Humble Hawksbill (LTS) | Supported (verified) |
| Jazzy Jalisco (LTS) | Supported (verified) |
| Lyrical Luth (LTS) | Supported (verified, except cross-vendor WStrings - see Known issues) |
| Rolling Ridley | Supported (verified, except cross-vendor WStrings - see Known issues) |
Supported platforms
| Platform | amd64 | arm64 | arm32 |
|---|---|---|---|
| Ubuntu 22.04 (Jammy) | Verified | Verified | Verified |
| Windows 10 | Verified (on Windows 11) | ||
| RHEL 8 | Verified | ||
| Ubuntu 20.04 (Focal) | Verified | Verified | Verified |
| macOS | Verified | ||
| Debian 11 (Bullseye) | Verified | Verified | Verified |
| OpenEmbedded / Yocto | Verified | Verified | Not supported |
- Windows: verified on Windows 11 with Visual Studio 2019. See Windows and macOS.
- macOS: verified on macOS 15.
- OpenEmbedded / Yocto: verified with a local layer that adds the
rmw_int2ddsrecipes. arm32 does not build: the ROS 2 message packages fail beforermw_int2ddsis reached.
Installation
From the ROS 2 apt repository
sudo apt update
sudo apt install ros-humble-rmw-int2dds-cpp
source /opt/ros/humble/setup.bash
export RMW_IMPLEMENTATION=rmw_int2dds_cpp
apt install pulls in the int2dds_ffi_vendor package automatically. The RMW library
and its ament-index marker install into /opt/ros/humble/, so once the environment is
sourced only RMW_IMPLEMENTATION needs to be set.
Supported: humble / jazzy / lyrical / rolling × amd64 / arm64 (rolling: testing repository only).
From the ROS 2 RPM repository (RHEL)
With the ROS 2 RPM repository set up as in the ROS 2 RHEL installation guide:
sudo dnf install ros-humble-rmw-int2dds-cpp
source /opt/ros/humble/setup.bash
export RMW_IMPLEMENTATION=rmw_int2dds_cpp
Latest version (testing repository or source build)
The newest release is available from the ROS 2 testing repository:
sudo apt install -y ros2-testing-apt-source
sudo apt update
sudo apt install ros-humble-rmw-int2dds-cpp
To build from source instead, follow Quick Start.
Windows and macOS
There are no binary packages of rmw_int2dds for Windows or macOS: build it from
source on top of a ROS 2 installation made with the ROS 2 installation guide for
that platform. int2dds_ffi_vendor downloads the FFI for the host from the
int2DDS releases.
Windows, in an x64 Native Tools Command Prompt for VS 2019. The commands below assume ROS 2 Humble in
C:\pixi_ws\ros2-windows; change the paths to match your installation.
The ROS 2 Windows binaries are Release builds, so build rmw_int2dds as Release too:
```bat cd /d C:\pixi_ws pixi shell call C:\pixi_ws\ros2-windows\local_setup.bat
File truncated at 100 lines see the full file
CONTRIBUTING
Contributing to rmw_int2dds_cpp
Thank you for your interest in contributing! This package is the ROS 2 RMW binding for int2DDS. For contributions to the underlying DDS core, see the int2DDS repository.
Code of Conduct
This project adheres to a Code of Conduct.
Contributor License Agreement (CLA)
By submitting a pull request you agree to the project CLA (individual / corporate).
Development Environment
Prerequisites
- A supported ROS 2 distribution (Humble or Jazzy) installed and sourced
- colcon build tool
- A C++17 compiler (GCC/Clang/MSVC), CMake >= 3.14.4
- The int2DDS core library available as a dependency
Workspace setup
mkdir -p ~/ros2_ws/src && cd ~/ros2_ws/src
git clone https://github.com/IntellectusCorp/rmw_int2dds.git
cd ~/ros2_ws
rosdep install --from-paths src --ignore-src -r -y
Building and Testing
# Build
colcon build --packages-up-to rmw_int2dds_cpp
# Run this package's tests
colcon test --packages-select rmw_int2dds_cpp
colcon test-result --verbose
# Run the RMW interface conformance suite against int2DDS
RMW_IMPLEMENTATION=rmw_int2dds_cpp \
colcon test --packages-select test_rmw_implementation
Tier 3 listing requires the full
test_rmw_implementationsuite to pass.
Code Style
This package follows the ROS 2 Code Style and Language Versions guide:
- C++17, max line length 100,
.hpp/.cppextensions - Linters run as tests via
ament_lint_auto+ament_lint_common(ament_clang_format,ament_cpplint,ament_uncrustify,ament_cppcheck) - Build with
-Wall -Wextra -Wpedantic
# Run linters
colcon test --packages-select rmw_int2dds_cpp --ctest-args -R lint
Commit Messages
Use the format TYPE: short description (max 72 chars), imperative mood.
Types: FEAT, FIX, DOCS, STYLE, REFACTOR, TEST, CHORE, PERF.
Reference issues with Fixes #123.
Branch Naming
feature/, fix/, hotfix/, docs/, refactor/, test/ prefixes;
lowercase with hyphens (e.g., feature/qos-deadline).
Pull Request Process
- Rebase on the latest
upstream/main. - Ensure
colcon buildandcolcon testpass, including linters. - Update documentation and
CHANGELOG.rstif behavior or APIs changed. - Open a PR with a clear summary, rationale, and testing notes.
- Request review from maintainers.
Reporting Bugs
Open a GitHub issue with: description, reproduction steps, expected vs actual behavior, environment (OS, ROS 2 distro, int2DDS version), and logs. For security issues, follow SECURITY.md instead.
License
By contributing, you agree your contributions are licensed under the Apache License 2.0.
License of contributions
Any contribution that you make to this repository will be under the Apache 2 License, as dictated by that
File truncated at 100 lines see the full file
Repository Summary
| Description | |
| Checkout URI | https://github.com/IntellectusCorp/rmw_int2dds.git |
| VCS Type | git |
| VCS Version | humble |
| Last Updated | 2026-10-13 |
| Dev Status | DEVELOPED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| int2dds_ffi_vendor | 0.1.8 |
| rmw_int2dds_cpp | 0.1.8 |
| rmw_int2dds_validation | 0.1.8 |
README
ROS 2 RMW for int2DDS
Overview
rmw_int2dds_cpp lets ROS 2 applications run on top of
int2DDS, a Rust
implementation of the OMG DDS standard (RTPS 2.5). It implements the ROS 2 rmw
C interface so that any ROS 2 stack (rclcpp, rclpy, ros2 CLI, tools) can use
int2DDS as its middleware via RMW_IMPLEMENTATION=rmw_int2dds_cpp.
Status: work in progress — APIs and test results are being stabilized ahead of a request for Tier 3 status in REP 2000.
Supported ROS 2 distributions
| Distribution | Status |
|---|---|
| Humble Hawksbill (LTS) | Supported (verified) |
| Jazzy Jalisco (LTS) | Supported (verified) |
| Lyrical Luth (LTS) | Supported (verified, except cross-vendor WStrings - see Known issues) |
| Rolling Ridley | Supported (verified, except cross-vendor WStrings - see Known issues) |
Supported platforms
| Platform | amd64 | arm64 | arm32 |
|---|---|---|---|
| Ubuntu 22.04 (Jammy) | Verified | Verified | Verified |
| Windows 10 | Verified (on Windows 11) | ||
| RHEL 8 | Verified | ||
| Ubuntu 20.04 (Focal) | Verified | Verified | Verified |
| macOS | Verified | ||
| Debian 11 (Bullseye) | Verified | Verified | Verified |
| OpenEmbedded / Yocto | Verified | Verified | Not supported |
- Windows: verified on Windows 11 with Visual Studio 2019. See Windows and macOS.
- macOS: verified on macOS 15.
- OpenEmbedded / Yocto: verified with a local layer that adds the
rmw_int2ddsrecipes. arm32 does not build: the ROS 2 message packages fail beforermw_int2ddsis reached.
Installation
From the ROS 2 apt repository
sudo apt update
sudo apt install ros-humble-rmw-int2dds-cpp
source /opt/ros/humble/setup.bash
export RMW_IMPLEMENTATION=rmw_int2dds_cpp
apt install pulls in the int2dds_ffi_vendor package automatically. The RMW library
and its ament-index marker install into /opt/ros/humble/, so once the environment is
sourced only RMW_IMPLEMENTATION needs to be set.
Supported: humble / jazzy / lyrical / rolling × amd64 / arm64 (rolling: testing repository only).
From the ROS 2 RPM repository (RHEL)
With the ROS 2 RPM repository set up as in the ROS 2 RHEL installation guide:
sudo dnf install ros-humble-rmw-int2dds-cpp
source /opt/ros/humble/setup.bash
export RMW_IMPLEMENTATION=rmw_int2dds_cpp
Latest version (testing repository or source build)
The newest release is available from the ROS 2 testing repository:
sudo apt install -y ros2-testing-apt-source
sudo apt update
sudo apt install ros-humble-rmw-int2dds-cpp
To build from source instead, follow Quick Start.
Windows and macOS
There are no binary packages of rmw_int2dds for Windows or macOS: build it from
source on top of a ROS 2 installation made with the ROS 2 installation guide for
that platform. int2dds_ffi_vendor downloads the FFI for the host from the
int2DDS releases.
Windows, in an x64 Native Tools Command Prompt for VS 2019. The commands below assume ROS 2 Humble in
C:\pixi_ws\ros2-windows; change the paths to match your installation.
The ROS 2 Windows binaries are Release builds, so build rmw_int2dds as Release too:
```bat cd /d C:\pixi_ws pixi shell call C:\pixi_ws\ros2-windows\local_setup.bat
File truncated at 100 lines see the full file
CONTRIBUTING
Contributing to rmw_int2dds_cpp
Thank you for your interest in contributing! This package is the ROS 2 RMW binding for int2DDS. For contributions to the underlying DDS core, see the int2DDS repository.
Code of Conduct
This project adheres to a Code of Conduct.
Contributor License Agreement (CLA)
By submitting a pull request you agree to the project CLA (individual / corporate).
Development Environment
Prerequisites
- A supported ROS 2 distribution (Humble or Jazzy) installed and sourced
- colcon build tool
- A C++17 compiler (GCC/Clang/MSVC), CMake >= 3.14.4
- The int2DDS core library available as a dependency
Workspace setup
mkdir -p ~/ros2_ws/src && cd ~/ros2_ws/src
git clone https://github.com/IntellectusCorp/rmw_int2dds.git
cd ~/ros2_ws
rosdep install --from-paths src --ignore-src -r -y
Building and Testing
# Build
colcon build --packages-up-to rmw_int2dds_cpp
# Run this package's tests
colcon test --packages-select rmw_int2dds_cpp
colcon test-result --verbose
# Run the RMW interface conformance suite against int2DDS
RMW_IMPLEMENTATION=rmw_int2dds_cpp \
colcon test --packages-select test_rmw_implementation
Tier 3 listing requires the full
test_rmw_implementationsuite to pass.
Code Style
This package follows the ROS 2 Code Style and Language Versions guide:
- C++17, max line length 100,
.hpp/.cppextensions - Linters run as tests via
ament_lint_auto+ament_lint_common(ament_clang_format,ament_cpplint,ament_uncrustify,ament_cppcheck) - Build with
-Wall -Wextra -Wpedantic
# Run linters
colcon test --packages-select rmw_int2dds_cpp --ctest-args -R lint
Commit Messages
Use the format TYPE: short description (max 72 chars), imperative mood.
Types: FEAT, FIX, DOCS, STYLE, REFACTOR, TEST, CHORE, PERF.
Reference issues with Fixes #123.
Branch Naming
feature/, fix/, hotfix/, docs/, refactor/, test/ prefixes;
lowercase with hyphens (e.g., feature/qos-deadline).
Pull Request Process
- Rebase on the latest
upstream/main. - Ensure
colcon buildandcolcon testpass, including linters. - Update documentation and
CHANGELOG.rstif behavior or APIs changed. - Open a PR with a clear summary, rationale, and testing notes.
- Request review from maintainers.
Reporting Bugs
Open a GitHub issue with: description, reproduction steps, expected vs actual behavior, environment (OS, ROS 2 distro, int2DDS version), and logs. For security issues, follow SECURITY.md instead.
License
By contributing, you agree your contributions are licensed under the Apache License 2.0.
License of contributions
Any contribution that you make to this repository will be under the Apache 2 License, as dictated by that
File truncated at 100 lines see the full file
Repository Summary
| Description | |
| Checkout URI | https://github.com/IntellectusCorp/rmw_int2dds.git |
| VCS Type | git |
| VCS Version | humble |
| Last Updated | 2026-10-13 |
| Dev Status | DEVELOPED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| int2dds_ffi_vendor | 0.1.8 |
| rmw_int2dds_cpp | 0.1.8 |
| rmw_int2dds_validation | 0.1.8 |
README
ROS 2 RMW for int2DDS
Overview
rmw_int2dds_cpp lets ROS 2 applications run on top of
int2DDS, a Rust
implementation of the OMG DDS standard (RTPS 2.5). It implements the ROS 2 rmw
C interface so that any ROS 2 stack (rclcpp, rclpy, ros2 CLI, tools) can use
int2DDS as its middleware via RMW_IMPLEMENTATION=rmw_int2dds_cpp.
Status: work in progress — APIs and test results are being stabilized ahead of a request for Tier 3 status in REP 2000.
Supported ROS 2 distributions
| Distribution | Status |
|---|---|
| Humble Hawksbill (LTS) | Supported (verified) |
| Jazzy Jalisco (LTS) | Supported (verified) |
| Lyrical Luth (LTS) | Supported (verified, except cross-vendor WStrings - see Known issues) |
| Rolling Ridley | Supported (verified, except cross-vendor WStrings - see Known issues) |
Supported platforms
| Platform | amd64 | arm64 | arm32 |
|---|---|---|---|
| Ubuntu 22.04 (Jammy) | Verified | Verified | Verified |
| Windows 10 | Verified (on Windows 11) | ||
| RHEL 8 | Verified | ||
| Ubuntu 20.04 (Focal) | Verified | Verified | Verified |
| macOS | Verified | ||
| Debian 11 (Bullseye) | Verified | Verified | Verified |
| OpenEmbedded / Yocto | Verified | Verified | Not supported |
- Windows: verified on Windows 11 with Visual Studio 2019. See Windows and macOS.
- macOS: verified on macOS 15.
- OpenEmbedded / Yocto: verified with a local layer that adds the
rmw_int2ddsrecipes. arm32 does not build: the ROS 2 message packages fail beforermw_int2ddsis reached.
Installation
From the ROS 2 apt repository
sudo apt update
sudo apt install ros-humble-rmw-int2dds-cpp
source /opt/ros/humble/setup.bash
export RMW_IMPLEMENTATION=rmw_int2dds_cpp
apt install pulls in the int2dds_ffi_vendor package automatically. The RMW library
and its ament-index marker install into /opt/ros/humble/, so once the environment is
sourced only RMW_IMPLEMENTATION needs to be set.
Supported: humble / jazzy / lyrical / rolling × amd64 / arm64 (rolling: testing repository only).
From the ROS 2 RPM repository (RHEL)
With the ROS 2 RPM repository set up as in the ROS 2 RHEL installation guide:
sudo dnf install ros-humble-rmw-int2dds-cpp
source /opt/ros/humble/setup.bash
export RMW_IMPLEMENTATION=rmw_int2dds_cpp
Latest version (testing repository or source build)
The newest release is available from the ROS 2 testing repository:
sudo apt install -y ros2-testing-apt-source
sudo apt update
sudo apt install ros-humble-rmw-int2dds-cpp
To build from source instead, follow Quick Start.
Windows and macOS
There are no binary packages of rmw_int2dds for Windows or macOS: build it from
source on top of a ROS 2 installation made with the ROS 2 installation guide for
that platform. int2dds_ffi_vendor downloads the FFI for the host from the
int2DDS releases.
Windows, in an x64 Native Tools Command Prompt for VS 2019. The commands below assume ROS 2 Humble in
C:\pixi_ws\ros2-windows; change the paths to match your installation.
The ROS 2 Windows binaries are Release builds, so build rmw_int2dds as Release too:
```bat cd /d C:\pixi_ws pixi shell call C:\pixi_ws\ros2-windows\local_setup.bat
File truncated at 100 lines see the full file
CONTRIBUTING
Contributing to rmw_int2dds_cpp
Thank you for your interest in contributing! This package is the ROS 2 RMW binding for int2DDS. For contributions to the underlying DDS core, see the int2DDS repository.
Code of Conduct
This project adheres to a Code of Conduct.
Contributor License Agreement (CLA)
By submitting a pull request you agree to the project CLA (individual / corporate).
Development Environment
Prerequisites
- A supported ROS 2 distribution (Humble or Jazzy) installed and sourced
- colcon build tool
- A C++17 compiler (GCC/Clang/MSVC), CMake >= 3.14.4
- The int2DDS core library available as a dependency
Workspace setup
mkdir -p ~/ros2_ws/src && cd ~/ros2_ws/src
git clone https://github.com/IntellectusCorp/rmw_int2dds.git
cd ~/ros2_ws
rosdep install --from-paths src --ignore-src -r -y
Building and Testing
# Build
colcon build --packages-up-to rmw_int2dds_cpp
# Run this package's tests
colcon test --packages-select rmw_int2dds_cpp
colcon test-result --verbose
# Run the RMW interface conformance suite against int2DDS
RMW_IMPLEMENTATION=rmw_int2dds_cpp \
colcon test --packages-select test_rmw_implementation
Tier 3 listing requires the full
test_rmw_implementationsuite to pass.
Code Style
This package follows the ROS 2 Code Style and Language Versions guide:
- C++17, max line length 100,
.hpp/.cppextensions - Linters run as tests via
ament_lint_auto+ament_lint_common(ament_clang_format,ament_cpplint,ament_uncrustify,ament_cppcheck) - Build with
-Wall -Wextra -Wpedantic
# Run linters
colcon test --packages-select rmw_int2dds_cpp --ctest-args -R lint
Commit Messages
Use the format TYPE: short description (max 72 chars), imperative mood.
Types: FEAT, FIX, DOCS, STYLE, REFACTOR, TEST, CHORE, PERF.
Reference issues with Fixes #123.
Branch Naming
feature/, fix/, hotfix/, docs/, refactor/, test/ prefixes;
lowercase with hyphens (e.g., feature/qos-deadline).
Pull Request Process
- Rebase on the latest
upstream/main. - Ensure
colcon buildandcolcon testpass, including linters. - Update documentation and
CHANGELOG.rstif behavior or APIs changed. - Open a PR with a clear summary, rationale, and testing notes.
- Request review from maintainers.
Reporting Bugs
Open a GitHub issue with: description, reproduction steps, expected vs actual behavior, environment (OS, ROS 2 distro, int2DDS version), and logs. For security issues, follow SECURITY.md instead.
License
By contributing, you agree your contributions are licensed under the Apache License 2.0.
License of contributions
Any contribution that you make to this repository will be under the Apache 2 License, as dictated by that
File truncated at 100 lines see the full file
Repository Summary
| Description | |
| Checkout URI | https://github.com/IntellectusCorp/rmw_int2dds.git |
| VCS Type | git |
| VCS Version | humble |
| Last Updated | 2026-10-13 |
| Dev Status | DEVELOPED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| int2dds_ffi_vendor | 0.1.8 |
| rmw_int2dds_cpp | 0.1.8 |
| rmw_int2dds_validation | 0.1.8 |
README
ROS 2 RMW for int2DDS
Overview
rmw_int2dds_cpp lets ROS 2 applications run on top of
int2DDS, a Rust
implementation of the OMG DDS standard (RTPS 2.5). It implements the ROS 2 rmw
C interface so that any ROS 2 stack (rclcpp, rclpy, ros2 CLI, tools) can use
int2DDS as its middleware via RMW_IMPLEMENTATION=rmw_int2dds_cpp.
Status: work in progress — APIs and test results are being stabilized ahead of a request for Tier 3 status in REP 2000.
Supported ROS 2 distributions
| Distribution | Status |
|---|---|
| Humble Hawksbill (LTS) | Supported (verified) |
| Jazzy Jalisco (LTS) | Supported (verified) |
| Lyrical Luth (LTS) | Supported (verified, except cross-vendor WStrings - see Known issues) |
| Rolling Ridley | Supported (verified, except cross-vendor WStrings - see Known issues) |
Supported platforms
| Platform | amd64 | arm64 | arm32 |
|---|---|---|---|
| Ubuntu 22.04 (Jammy) | Verified | Verified | Verified |
| Windows 10 | Verified (on Windows 11) | ||
| RHEL 8 | Verified | ||
| Ubuntu 20.04 (Focal) | Verified | Verified | Verified |
| macOS | Verified | ||
| Debian 11 (Bullseye) | Verified | Verified | Verified |
| OpenEmbedded / Yocto | Verified | Verified | Not supported |
- Windows: verified on Windows 11 with Visual Studio 2019. See Windows and macOS.
- macOS: verified on macOS 15.
- OpenEmbedded / Yocto: verified with a local layer that adds the
rmw_int2ddsrecipes. arm32 does not build: the ROS 2 message packages fail beforermw_int2ddsis reached.
Installation
From the ROS 2 apt repository
sudo apt update
sudo apt install ros-humble-rmw-int2dds-cpp
source /opt/ros/humble/setup.bash
export RMW_IMPLEMENTATION=rmw_int2dds_cpp
apt install pulls in the int2dds_ffi_vendor package automatically. The RMW library
and its ament-index marker install into /opt/ros/humble/, so once the environment is
sourced only RMW_IMPLEMENTATION needs to be set.
Supported: humble / jazzy / lyrical / rolling × amd64 / arm64 (rolling: testing repository only).
From the ROS 2 RPM repository (RHEL)
With the ROS 2 RPM repository set up as in the ROS 2 RHEL installation guide:
sudo dnf install ros-humble-rmw-int2dds-cpp
source /opt/ros/humble/setup.bash
export RMW_IMPLEMENTATION=rmw_int2dds_cpp
Latest version (testing repository or source build)
The newest release is available from the ROS 2 testing repository:
sudo apt install -y ros2-testing-apt-source
sudo apt update
sudo apt install ros-humble-rmw-int2dds-cpp
To build from source instead, follow Quick Start.
Windows and macOS
There are no binary packages of rmw_int2dds for Windows or macOS: build it from
source on top of a ROS 2 installation made with the ROS 2 installation guide for
that platform. int2dds_ffi_vendor downloads the FFI for the host from the
int2DDS releases.
Windows, in an x64 Native Tools Command Prompt for VS 2019. The commands below assume ROS 2 Humble in
C:\pixi_ws\ros2-windows; change the paths to match your installation.
The ROS 2 Windows binaries are Release builds, so build rmw_int2dds as Release too:
```bat cd /d C:\pixi_ws pixi shell call C:\pixi_ws\ros2-windows\local_setup.bat
File truncated at 100 lines see the full file
CONTRIBUTING
Contributing to rmw_int2dds_cpp
Thank you for your interest in contributing! This package is the ROS 2 RMW binding for int2DDS. For contributions to the underlying DDS core, see the int2DDS repository.
Code of Conduct
This project adheres to a Code of Conduct.
Contributor License Agreement (CLA)
By submitting a pull request you agree to the project CLA (individual / corporate).
Development Environment
Prerequisites
- A supported ROS 2 distribution (Humble or Jazzy) installed and sourced
- colcon build tool
- A C++17 compiler (GCC/Clang/MSVC), CMake >= 3.14.4
- The int2DDS core library available as a dependency
Workspace setup
mkdir -p ~/ros2_ws/src && cd ~/ros2_ws/src
git clone https://github.com/IntellectusCorp/rmw_int2dds.git
cd ~/ros2_ws
rosdep install --from-paths src --ignore-src -r -y
Building and Testing
# Build
colcon build --packages-up-to rmw_int2dds_cpp
# Run this package's tests
colcon test --packages-select rmw_int2dds_cpp
colcon test-result --verbose
# Run the RMW interface conformance suite against int2DDS
RMW_IMPLEMENTATION=rmw_int2dds_cpp \
colcon test --packages-select test_rmw_implementation
Tier 3 listing requires the full
test_rmw_implementationsuite to pass.
Code Style
This package follows the ROS 2 Code Style and Language Versions guide:
- C++17, max line length 100,
.hpp/.cppextensions - Linters run as tests via
ament_lint_auto+ament_lint_common(ament_clang_format,ament_cpplint,ament_uncrustify,ament_cppcheck) - Build with
-Wall -Wextra -Wpedantic
# Run linters
colcon test --packages-select rmw_int2dds_cpp --ctest-args -R lint
Commit Messages
Use the format TYPE: short description (max 72 chars), imperative mood.
Types: FEAT, FIX, DOCS, STYLE, REFACTOR, TEST, CHORE, PERF.
Reference issues with Fixes #123.
Branch Naming
feature/, fix/, hotfix/, docs/, refactor/, test/ prefixes;
lowercase with hyphens (e.g., feature/qos-deadline).
Pull Request Process
- Rebase on the latest
upstream/main. - Ensure
colcon buildandcolcon testpass, including linters. - Update documentation and
CHANGELOG.rstif behavior or APIs changed. - Open a PR with a clear summary, rationale, and testing notes.
- Request review from maintainers.
Reporting Bugs
Open a GitHub issue with: description, reproduction steps, expected vs actual behavior, environment (OS, ROS 2 distro, int2DDS version), and logs. For security issues, follow SECURITY.md instead.
License
By contributing, you agree your contributions are licensed under the Apache License 2.0.
License of contributions
Any contribution that you make to this repository will be under the Apache 2 License, as dictated by that
File truncated at 100 lines see the full file
Repository Summary
| Description | |
| Checkout URI | https://github.com/IntellectusCorp/rmw_int2dds.git |
| VCS Type | git |
| VCS Version | humble |
| Last Updated | 2026-10-13 |
| Dev Status | DEVELOPED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| int2dds_ffi_vendor | 0.1.8 |
| rmw_int2dds_cpp | 0.1.8 |
| rmw_int2dds_validation | 0.1.8 |
README
ROS 2 RMW for int2DDS
Overview
rmw_int2dds_cpp lets ROS 2 applications run on top of
int2DDS, a Rust
implementation of the OMG DDS standard (RTPS 2.5). It implements the ROS 2 rmw
C interface so that any ROS 2 stack (rclcpp, rclpy, ros2 CLI, tools) can use
int2DDS as its middleware via RMW_IMPLEMENTATION=rmw_int2dds_cpp.
Status: work in progress — APIs and test results are being stabilized ahead of a request for Tier 3 status in REP 2000.
Supported ROS 2 distributions
| Distribution | Status |
|---|---|
| Humble Hawksbill (LTS) | Supported (verified) |
| Jazzy Jalisco (LTS) | Supported (verified) |
| Lyrical Luth (LTS) | Supported (verified, except cross-vendor WStrings - see Known issues) |
| Rolling Ridley | Supported (verified, except cross-vendor WStrings - see Known issues) |
Supported platforms
| Platform | amd64 | arm64 | arm32 |
|---|---|---|---|
| Ubuntu 22.04 (Jammy) | Verified | Verified | Verified |
| Windows 10 | Verified (on Windows 11) | ||
| RHEL 8 | Verified | ||
| Ubuntu 20.04 (Focal) | Verified | Verified | Verified |
| macOS | Verified | ||
| Debian 11 (Bullseye) | Verified | Verified | Verified |
| OpenEmbedded / Yocto | Verified | Verified | Not supported |
- Windows: verified on Windows 11 with Visual Studio 2019. See Windows and macOS.
- macOS: verified on macOS 15.
- OpenEmbedded / Yocto: verified with a local layer that adds the
rmw_int2ddsrecipes. arm32 does not build: the ROS 2 message packages fail beforermw_int2ddsis reached.
Installation
From the ROS 2 apt repository
sudo apt update
sudo apt install ros-humble-rmw-int2dds-cpp
source /opt/ros/humble/setup.bash
export RMW_IMPLEMENTATION=rmw_int2dds_cpp
apt install pulls in the int2dds_ffi_vendor package automatically. The RMW library
and its ament-index marker install into /opt/ros/humble/, so once the environment is
sourced only RMW_IMPLEMENTATION needs to be set.
Supported: humble / jazzy / lyrical / rolling × amd64 / arm64 (rolling: testing repository only).
From the ROS 2 RPM repository (RHEL)
With the ROS 2 RPM repository set up as in the ROS 2 RHEL installation guide:
sudo dnf install ros-humble-rmw-int2dds-cpp
source /opt/ros/humble/setup.bash
export RMW_IMPLEMENTATION=rmw_int2dds_cpp
Latest version (testing repository or source build)
The newest release is available from the ROS 2 testing repository:
sudo apt install -y ros2-testing-apt-source
sudo apt update
sudo apt install ros-humble-rmw-int2dds-cpp
To build from source instead, follow Quick Start.
Windows and macOS
There are no binary packages of rmw_int2dds for Windows or macOS: build it from
source on top of a ROS 2 installation made with the ROS 2 installation guide for
that platform. int2dds_ffi_vendor downloads the FFI for the host from the
int2DDS releases.
Windows, in an x64 Native Tools Command Prompt for VS 2019. The commands below assume ROS 2 Humble in
C:\pixi_ws\ros2-windows; change the paths to match your installation.
The ROS 2 Windows binaries are Release builds, so build rmw_int2dds as Release too:
```bat cd /d C:\pixi_ws pixi shell call C:\pixi_ws\ros2-windows\local_setup.bat
File truncated at 100 lines see the full file
CONTRIBUTING
Contributing to rmw_int2dds_cpp
Thank you for your interest in contributing! This package is the ROS 2 RMW binding for int2DDS. For contributions to the underlying DDS core, see the int2DDS repository.
Code of Conduct
This project adheres to a Code of Conduct.
Contributor License Agreement (CLA)
By submitting a pull request you agree to the project CLA (individual / corporate).
Development Environment
Prerequisites
- A supported ROS 2 distribution (Humble or Jazzy) installed and sourced
- colcon build tool
- A C++17 compiler (GCC/Clang/MSVC), CMake >= 3.14.4
- The int2DDS core library available as a dependency
Workspace setup
mkdir -p ~/ros2_ws/src && cd ~/ros2_ws/src
git clone https://github.com/IntellectusCorp/rmw_int2dds.git
cd ~/ros2_ws
rosdep install --from-paths src --ignore-src -r -y
Building and Testing
# Build
colcon build --packages-up-to rmw_int2dds_cpp
# Run this package's tests
colcon test --packages-select rmw_int2dds_cpp
colcon test-result --verbose
# Run the RMW interface conformance suite against int2DDS
RMW_IMPLEMENTATION=rmw_int2dds_cpp \
colcon test --packages-select test_rmw_implementation
Tier 3 listing requires the full
test_rmw_implementationsuite to pass.
Code Style
This package follows the ROS 2 Code Style and Language Versions guide:
- C++17, max line length 100,
.hpp/.cppextensions - Linters run as tests via
ament_lint_auto+ament_lint_common(ament_clang_format,ament_cpplint,ament_uncrustify,ament_cppcheck) - Build with
-Wall -Wextra -Wpedantic
# Run linters
colcon test --packages-select rmw_int2dds_cpp --ctest-args -R lint
Commit Messages
Use the format TYPE: short description (max 72 chars), imperative mood.
Types: FEAT, FIX, DOCS, STYLE, REFACTOR, TEST, CHORE, PERF.
Reference issues with Fixes #123.
Branch Naming
feature/, fix/, hotfix/, docs/, refactor/, test/ prefixes;
lowercase with hyphens (e.g., feature/qos-deadline).
Pull Request Process
- Rebase on the latest
upstream/main. - Ensure
colcon buildandcolcon testpass, including linters. - Update documentation and
CHANGELOG.rstif behavior or APIs changed. - Open a PR with a clear summary, rationale, and testing notes.
- Request review from maintainers.
Reporting Bugs
Open a GitHub issue with: description, reproduction steps, expected vs actual behavior, environment (OS, ROS 2 distro, int2DDS version), and logs. For security issues, follow SECURITY.md instead.
License
By contributing, you agree your contributions are licensed under the Apache License 2.0.
License of contributions
Any contribution that you make to this repository will be under the Apache 2 License, as dictated by that
File truncated at 100 lines see the full file
Repository Summary
| Description | |
| Checkout URI | https://github.com/IntellectusCorp/rmw_int2dds.git |
| VCS Type | git |
| VCS Version | humble |
| Last Updated | 2026-10-13 |
| Dev Status | DEVELOPED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| int2dds_ffi_vendor | 0.1.8 |
| rmw_int2dds_cpp | 0.1.8 |
| rmw_int2dds_validation | 0.1.8 |
README
ROS 2 RMW for int2DDS
Overview
rmw_int2dds_cpp lets ROS 2 applications run on top of
int2DDS, a Rust
implementation of the OMG DDS standard (RTPS 2.5). It implements the ROS 2 rmw
C interface so that any ROS 2 stack (rclcpp, rclpy, ros2 CLI, tools) can use
int2DDS as its middleware via RMW_IMPLEMENTATION=rmw_int2dds_cpp.
Status: work in progress — APIs and test results are being stabilized ahead of a request for Tier 3 status in REP 2000.
Supported ROS 2 distributions
| Distribution | Status |
|---|---|
| Humble Hawksbill (LTS) | Supported (verified) |
| Jazzy Jalisco (LTS) | Supported (verified) |
| Lyrical Luth (LTS) | Supported (verified, except cross-vendor WStrings - see Known issues) |
| Rolling Ridley | Supported (verified, except cross-vendor WStrings - see Known issues) |
Supported platforms
| Platform | amd64 | arm64 | arm32 |
|---|---|---|---|
| Ubuntu 22.04 (Jammy) | Verified | Verified | Verified |
| Windows 10 | Verified (on Windows 11) | ||
| RHEL 8 | Verified | ||
| Ubuntu 20.04 (Focal) | Verified | Verified | Verified |
| macOS | Verified | ||
| Debian 11 (Bullseye) | Verified | Verified | Verified |
| OpenEmbedded / Yocto | Verified | Verified | Not supported |
- Windows: verified on Windows 11 with Visual Studio 2019. See Windows and macOS.
- macOS: verified on macOS 15.
- OpenEmbedded / Yocto: verified with a local layer that adds the
rmw_int2ddsrecipes. arm32 does not build: the ROS 2 message packages fail beforermw_int2ddsis reached.
Installation
From the ROS 2 apt repository
sudo apt update
sudo apt install ros-humble-rmw-int2dds-cpp
source /opt/ros/humble/setup.bash
export RMW_IMPLEMENTATION=rmw_int2dds_cpp
apt install pulls in the int2dds_ffi_vendor package automatically. The RMW library
and its ament-index marker install into /opt/ros/humble/, so once the environment is
sourced only RMW_IMPLEMENTATION needs to be set.
Supported: humble / jazzy / lyrical / rolling × amd64 / arm64 (rolling: testing repository only).
From the ROS 2 RPM repository (RHEL)
With the ROS 2 RPM repository set up as in the ROS 2 RHEL installation guide:
sudo dnf install ros-humble-rmw-int2dds-cpp
source /opt/ros/humble/setup.bash
export RMW_IMPLEMENTATION=rmw_int2dds_cpp
Latest version (testing repository or source build)
The newest release is available from the ROS 2 testing repository:
sudo apt install -y ros2-testing-apt-source
sudo apt update
sudo apt install ros-humble-rmw-int2dds-cpp
To build from source instead, follow Quick Start.
Windows and macOS
There are no binary packages of rmw_int2dds for Windows or macOS: build it from
source on top of a ROS 2 installation made with the ROS 2 installation guide for
that platform. int2dds_ffi_vendor downloads the FFI for the host from the
int2DDS releases.
Windows, in an x64 Native Tools Command Prompt for VS 2019. The commands below assume ROS 2 Humble in
C:\pixi_ws\ros2-windows; change the paths to match your installation.
The ROS 2 Windows binaries are Release builds, so build rmw_int2dds as Release too:
```bat cd /d C:\pixi_ws pixi shell call C:\pixi_ws\ros2-windows\local_setup.bat
File truncated at 100 lines see the full file
CONTRIBUTING
Contributing to rmw_int2dds_cpp
Thank you for your interest in contributing! This package is the ROS 2 RMW binding for int2DDS. For contributions to the underlying DDS core, see the int2DDS repository.
Code of Conduct
This project adheres to a Code of Conduct.
Contributor License Agreement (CLA)
By submitting a pull request you agree to the project CLA (individual / corporate).
Development Environment
Prerequisites
- A supported ROS 2 distribution (Humble or Jazzy) installed and sourced
- colcon build tool
- A C++17 compiler (GCC/Clang/MSVC), CMake >= 3.14.4
- The int2DDS core library available as a dependency
Workspace setup
mkdir -p ~/ros2_ws/src && cd ~/ros2_ws/src
git clone https://github.com/IntellectusCorp/rmw_int2dds.git
cd ~/ros2_ws
rosdep install --from-paths src --ignore-src -r -y
Building and Testing
# Build
colcon build --packages-up-to rmw_int2dds_cpp
# Run this package's tests
colcon test --packages-select rmw_int2dds_cpp
colcon test-result --verbose
# Run the RMW interface conformance suite against int2DDS
RMW_IMPLEMENTATION=rmw_int2dds_cpp \
colcon test --packages-select test_rmw_implementation
Tier 3 listing requires the full
test_rmw_implementationsuite to pass.
Code Style
This package follows the ROS 2 Code Style and Language Versions guide:
- C++17, max line length 100,
.hpp/.cppextensions - Linters run as tests via
ament_lint_auto+ament_lint_common(ament_clang_format,ament_cpplint,ament_uncrustify,ament_cppcheck) - Build with
-Wall -Wextra -Wpedantic
# Run linters
colcon test --packages-select rmw_int2dds_cpp --ctest-args -R lint
Commit Messages
Use the format TYPE: short description (max 72 chars), imperative mood.
Types: FEAT, FIX, DOCS, STYLE, REFACTOR, TEST, CHORE, PERF.
Reference issues with Fixes #123.
Branch Naming
feature/, fix/, hotfix/, docs/, refactor/, test/ prefixes;
lowercase with hyphens (e.g., feature/qos-deadline).
Pull Request Process
- Rebase on the latest
upstream/main. - Ensure
colcon buildandcolcon testpass, including linters. - Update documentation and
CHANGELOG.rstif behavior or APIs changed. - Open a PR with a clear summary, rationale, and testing notes.
- Request review from maintainers.
Reporting Bugs
Open a GitHub issue with: description, reproduction steps, expected vs actual behavior, environment (OS, ROS 2 distro, int2DDS version), and logs. For security issues, follow SECURITY.md instead.
License
By contributing, you agree your contributions are licensed under the Apache License 2.0.
License of contributions
Any contribution that you make to this repository will be under the Apache 2 License, as dictated by that
File truncated at 100 lines see the full file
Repository Summary
| Description | |
| Checkout URI | https://github.com/IntellectusCorp/rmw_int2dds.git |
| VCS Type | git |
| VCS Version | humble |
| Last Updated | 2026-10-13 |
| Dev Status | DEVELOPED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| int2dds_ffi_vendor | 0.1.8 |
| rmw_int2dds_cpp | 0.1.8 |
| rmw_int2dds_validation | 0.1.8 |
README
ROS 2 RMW for int2DDS
Overview
rmw_int2dds_cpp lets ROS 2 applications run on top of
int2DDS, a Rust
implementation of the OMG DDS standard (RTPS 2.5). It implements the ROS 2 rmw
C interface so that any ROS 2 stack (rclcpp, rclpy, ros2 CLI, tools) can use
int2DDS as its middleware via RMW_IMPLEMENTATION=rmw_int2dds_cpp.
Status: work in progress — APIs and test results are being stabilized ahead of a request for Tier 3 status in REP 2000.
Supported ROS 2 distributions
| Distribution | Status |
|---|---|
| Humble Hawksbill (LTS) | Supported (verified) |
| Jazzy Jalisco (LTS) | Supported (verified) |
| Lyrical Luth (LTS) | Supported (verified, except cross-vendor WStrings - see Known issues) |
| Rolling Ridley | Supported (verified, except cross-vendor WStrings - see Known issues) |
Supported platforms
| Platform | amd64 | arm64 | arm32 |
|---|---|---|---|
| Ubuntu 22.04 (Jammy) | Verified | Verified | Verified |
| Windows 10 | Verified (on Windows 11) | ||
| RHEL 8 | Verified | ||
| Ubuntu 20.04 (Focal) | Verified | Verified | Verified |
| macOS | Verified | ||
| Debian 11 (Bullseye) | Verified | Verified | Verified |
| OpenEmbedded / Yocto | Verified | Verified | Not supported |
- Windows: verified on Windows 11 with Visual Studio 2019. See Windows and macOS.
- macOS: verified on macOS 15.
- OpenEmbedded / Yocto: verified with a local layer that adds the
rmw_int2ddsrecipes. arm32 does not build: the ROS 2 message packages fail beforermw_int2ddsis reached.
Installation
From the ROS 2 apt repository
sudo apt update
sudo apt install ros-humble-rmw-int2dds-cpp
source /opt/ros/humble/setup.bash
export RMW_IMPLEMENTATION=rmw_int2dds_cpp
apt install pulls in the int2dds_ffi_vendor package automatically. The RMW library
and its ament-index marker install into /opt/ros/humble/, so once the environment is
sourced only RMW_IMPLEMENTATION needs to be set.
Supported: humble / jazzy / lyrical / rolling × amd64 / arm64 (rolling: testing repository only).
From the ROS 2 RPM repository (RHEL)
With the ROS 2 RPM repository set up as in the ROS 2 RHEL installation guide:
sudo dnf install ros-humble-rmw-int2dds-cpp
source /opt/ros/humble/setup.bash
export RMW_IMPLEMENTATION=rmw_int2dds_cpp
Latest version (testing repository or source build)
The newest release is available from the ROS 2 testing repository:
sudo apt install -y ros2-testing-apt-source
sudo apt update
sudo apt install ros-humble-rmw-int2dds-cpp
To build from source instead, follow Quick Start.
Windows and macOS
There are no binary packages of rmw_int2dds for Windows or macOS: build it from
source on top of a ROS 2 installation made with the ROS 2 installation guide for
that platform. int2dds_ffi_vendor downloads the FFI for the host from the
int2DDS releases.
Windows, in an x64 Native Tools Command Prompt for VS 2019. The commands below assume ROS 2 Humble in
C:\pixi_ws\ros2-windows; change the paths to match your installation.
The ROS 2 Windows binaries are Release builds, so build rmw_int2dds as Release too:
```bat cd /d C:\pixi_ws pixi shell call C:\pixi_ws\ros2-windows\local_setup.bat
File truncated at 100 lines see the full file
CONTRIBUTING
Contributing to rmw_int2dds_cpp
Thank you for your interest in contributing! This package is the ROS 2 RMW binding for int2DDS. For contributions to the underlying DDS core, see the int2DDS repository.
Code of Conduct
This project adheres to a Code of Conduct.
Contributor License Agreement (CLA)
By submitting a pull request you agree to the project CLA (individual / corporate).
Development Environment
Prerequisites
- A supported ROS 2 distribution (Humble or Jazzy) installed and sourced
- colcon build tool
- A C++17 compiler (GCC/Clang/MSVC), CMake >= 3.14.4
- The int2DDS core library available as a dependency
Workspace setup
mkdir -p ~/ros2_ws/src && cd ~/ros2_ws/src
git clone https://github.com/IntellectusCorp/rmw_int2dds.git
cd ~/ros2_ws
rosdep install --from-paths src --ignore-src -r -y
Building and Testing
# Build
colcon build --packages-up-to rmw_int2dds_cpp
# Run this package's tests
colcon test --packages-select rmw_int2dds_cpp
colcon test-result --verbose
# Run the RMW interface conformance suite against int2DDS
RMW_IMPLEMENTATION=rmw_int2dds_cpp \
colcon test --packages-select test_rmw_implementation
Tier 3 listing requires the full
test_rmw_implementationsuite to pass.
Code Style
This package follows the ROS 2 Code Style and Language Versions guide:
- C++17, max line length 100,
.hpp/.cppextensions - Linters run as tests via
ament_lint_auto+ament_lint_common(ament_clang_format,ament_cpplint,ament_uncrustify,ament_cppcheck) - Build with
-Wall -Wextra -Wpedantic
# Run linters
colcon test --packages-select rmw_int2dds_cpp --ctest-args -R lint
Commit Messages
Use the format TYPE: short description (max 72 chars), imperative mood.
Types: FEAT, FIX, DOCS, STYLE, REFACTOR, TEST, CHORE, PERF.
Reference issues with Fixes #123.
Branch Naming
feature/, fix/, hotfix/, docs/, refactor/, test/ prefixes;
lowercase with hyphens (e.g., feature/qos-deadline).
Pull Request Process
- Rebase on the latest
upstream/main. - Ensure
colcon buildandcolcon testpass, including linters. - Update documentation and
CHANGELOG.rstif behavior or APIs changed. - Open a PR with a clear summary, rationale, and testing notes.
- Request review from maintainers.
Reporting Bugs
Open a GitHub issue with: description, reproduction steps, expected vs actual behavior, environment (OS, ROS 2 distro, int2DDS version), and logs. For security issues, follow SECURITY.md instead.
License
By contributing, you agree your contributions are licensed under the Apache License 2.0.
License of contributions
Any contribution that you make to this repository will be under the Apache 2 License, as dictated by that
File truncated at 100 lines see the full file
Repository Summary
| Description | |
| Checkout URI | https://github.com/IntellectusCorp/rmw_int2dds.git |
| VCS Type | git |
| VCS Version | humble |
| Last Updated | 2026-10-13 |
| Dev Status | DEVELOPED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| int2dds_ffi_vendor | 0.1.8 |
| rmw_int2dds_cpp | 0.1.8 |
| rmw_int2dds_validation | 0.1.8 |
README
ROS 2 RMW for int2DDS
Overview
rmw_int2dds_cpp lets ROS 2 applications run on top of
int2DDS, a Rust
implementation of the OMG DDS standard (RTPS 2.5). It implements the ROS 2 rmw
C interface so that any ROS 2 stack (rclcpp, rclpy, ros2 CLI, tools) can use
int2DDS as its middleware via RMW_IMPLEMENTATION=rmw_int2dds_cpp.
Status: work in progress — APIs and test results are being stabilized ahead of a request for Tier 3 status in REP 2000.
Supported ROS 2 distributions
| Distribution | Status |
|---|---|
| Humble Hawksbill (LTS) | Supported (verified) |
| Jazzy Jalisco (LTS) | Supported (verified) |
| Lyrical Luth (LTS) | Supported (verified, except cross-vendor WStrings - see Known issues) |
| Rolling Ridley | Supported (verified, except cross-vendor WStrings - see Known issues) |
Supported platforms
| Platform | amd64 | arm64 | arm32 |
|---|---|---|---|
| Ubuntu 22.04 (Jammy) | Verified | Verified | Verified |
| Windows 10 | Verified (on Windows 11) | ||
| RHEL 8 | Verified | ||
| Ubuntu 20.04 (Focal) | Verified | Verified | Verified |
| macOS | Verified | ||
| Debian 11 (Bullseye) | Verified | Verified | Verified |
| OpenEmbedded / Yocto | Verified | Verified | Not supported |
- Windows: verified on Windows 11 with Visual Studio 2019. See Windows and macOS.
- macOS: verified on macOS 15.
- OpenEmbedded / Yocto: verified with a local layer that adds the
rmw_int2ddsrecipes. arm32 does not build: the ROS 2 message packages fail beforermw_int2ddsis reached.
Installation
From the ROS 2 apt repository
sudo apt update
sudo apt install ros-humble-rmw-int2dds-cpp
source /opt/ros/humble/setup.bash
export RMW_IMPLEMENTATION=rmw_int2dds_cpp
apt install pulls in the int2dds_ffi_vendor package automatically. The RMW library
and its ament-index marker install into /opt/ros/humble/, so once the environment is
sourced only RMW_IMPLEMENTATION needs to be set.
Supported: humble / jazzy / lyrical / rolling × amd64 / arm64 (rolling: testing repository only).
From the ROS 2 RPM repository (RHEL)
With the ROS 2 RPM repository set up as in the ROS 2 RHEL installation guide:
sudo dnf install ros-humble-rmw-int2dds-cpp
source /opt/ros/humble/setup.bash
export RMW_IMPLEMENTATION=rmw_int2dds_cpp
Latest version (testing repository or source build)
The newest release is available from the ROS 2 testing repository:
sudo apt install -y ros2-testing-apt-source
sudo apt update
sudo apt install ros-humble-rmw-int2dds-cpp
To build from source instead, follow Quick Start.
Windows and macOS
There are no binary packages of rmw_int2dds for Windows or macOS: build it from
source on top of a ROS 2 installation made with the ROS 2 installation guide for
that platform. int2dds_ffi_vendor downloads the FFI for the host from the
int2DDS releases.
Windows, in an x64 Native Tools Command Prompt for VS 2019. The commands below assume ROS 2 Humble in
C:\pixi_ws\ros2-windows; change the paths to match your installation.
The ROS 2 Windows binaries are Release builds, so build rmw_int2dds as Release too:
```bat cd /d C:\pixi_ws pixi shell call C:\pixi_ws\ros2-windows\local_setup.bat
File truncated at 100 lines see the full file
CONTRIBUTING
Contributing to rmw_int2dds_cpp
Thank you for your interest in contributing! This package is the ROS 2 RMW binding for int2DDS. For contributions to the underlying DDS core, see the int2DDS repository.
Code of Conduct
This project adheres to a Code of Conduct.
Contributor License Agreement (CLA)
By submitting a pull request you agree to the project CLA (individual / corporate).
Development Environment
Prerequisites
- A supported ROS 2 distribution (Humble or Jazzy) installed and sourced
- colcon build tool
- A C++17 compiler (GCC/Clang/MSVC), CMake >= 3.14.4
- The int2DDS core library available as a dependency
Workspace setup
mkdir -p ~/ros2_ws/src && cd ~/ros2_ws/src
git clone https://github.com/IntellectusCorp/rmw_int2dds.git
cd ~/ros2_ws
rosdep install --from-paths src --ignore-src -r -y
Building and Testing
# Build
colcon build --packages-up-to rmw_int2dds_cpp
# Run this package's tests
colcon test --packages-select rmw_int2dds_cpp
colcon test-result --verbose
# Run the RMW interface conformance suite against int2DDS
RMW_IMPLEMENTATION=rmw_int2dds_cpp \
colcon test --packages-select test_rmw_implementation
Tier 3 listing requires the full
test_rmw_implementationsuite to pass.
Code Style
This package follows the ROS 2 Code Style and Language Versions guide:
- C++17, max line length 100,
.hpp/.cppextensions - Linters run as tests via
ament_lint_auto+ament_lint_common(ament_clang_format,ament_cpplint,ament_uncrustify,ament_cppcheck) - Build with
-Wall -Wextra -Wpedantic
# Run linters
colcon test --packages-select rmw_int2dds_cpp --ctest-args -R lint
Commit Messages
Use the format TYPE: short description (max 72 chars), imperative mood.
Types: FEAT, FIX, DOCS, STYLE, REFACTOR, TEST, CHORE, PERF.
Reference issues with Fixes #123.
Branch Naming
feature/, fix/, hotfix/, docs/, refactor/, test/ prefixes;
lowercase with hyphens (e.g., feature/qos-deadline).
Pull Request Process
- Rebase on the latest
upstream/main. - Ensure
colcon buildandcolcon testpass, including linters. - Update documentation and
CHANGELOG.rstif behavior or APIs changed. - Open a PR with a clear summary, rationale, and testing notes.
- Request review from maintainers.
Reporting Bugs
Open a GitHub issue with: description, reproduction steps, expected vs actual behavior, environment (OS, ROS 2 distro, int2DDS version), and logs. For security issues, follow SECURITY.md instead.
License
By contributing, you agree your contributions are licensed under the Apache License 2.0.
License of contributions
Any contribution that you make to this repository will be under the Apache 2 License, as dictated by that
File truncated at 100 lines see the full file
Repository Summary
| Description | |
| Checkout URI | https://github.com/IntellectusCorp/rmw_int2dds.git |
| VCS Type | git |
| VCS Version | humble |
| Last Updated | 2026-10-13 |
| Dev Status | DEVELOPED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| int2dds_ffi_vendor | 0.1.8 |
| rmw_int2dds_cpp | 0.1.8 |
| rmw_int2dds_validation | 0.1.8 |
README
ROS 2 RMW for int2DDS
Overview
rmw_int2dds_cpp lets ROS 2 applications run on top of
int2DDS, a Rust
implementation of the OMG DDS standard (RTPS 2.5). It implements the ROS 2 rmw
C interface so that any ROS 2 stack (rclcpp, rclpy, ros2 CLI, tools) can use
int2DDS as its middleware via RMW_IMPLEMENTATION=rmw_int2dds_cpp.
Status: work in progress — APIs and test results are being stabilized ahead of a request for Tier 3 status in REP 2000.
Supported ROS 2 distributions
| Distribution | Status |
|---|---|
| Humble Hawksbill (LTS) | Supported (verified) |
| Jazzy Jalisco (LTS) | Supported (verified) |
| Lyrical Luth (LTS) | Supported (verified, except cross-vendor WStrings - see Known issues) |
| Rolling Ridley | Supported (verified, except cross-vendor WStrings - see Known issues) |
Supported platforms
| Platform | amd64 | arm64 | arm32 |
|---|---|---|---|
| Ubuntu 22.04 (Jammy) | Verified | Verified | Verified |
| Windows 10 | Verified (on Windows 11) | ||
| RHEL 8 | Verified | ||
| Ubuntu 20.04 (Focal) | Verified | Verified | Verified |
| macOS | Verified | ||
| Debian 11 (Bullseye) | Verified | Verified | Verified |
| OpenEmbedded / Yocto | Verified | Verified | Not supported |
- Windows: verified on Windows 11 with Visual Studio 2019. See Windows and macOS.
- macOS: verified on macOS 15.
- OpenEmbedded / Yocto: verified with a local layer that adds the
rmw_int2ddsrecipes. arm32 does not build: the ROS 2 message packages fail beforermw_int2ddsis reached.
Installation
From the ROS 2 apt repository
sudo apt update
sudo apt install ros-humble-rmw-int2dds-cpp
source /opt/ros/humble/setup.bash
export RMW_IMPLEMENTATION=rmw_int2dds_cpp
apt install pulls in the int2dds_ffi_vendor package automatically. The RMW library
and its ament-index marker install into /opt/ros/humble/, so once the environment is
sourced only RMW_IMPLEMENTATION needs to be set.
Supported: humble / jazzy / lyrical / rolling × amd64 / arm64 (rolling: testing repository only).
From the ROS 2 RPM repository (RHEL)
With the ROS 2 RPM repository set up as in the ROS 2 RHEL installation guide:
sudo dnf install ros-humble-rmw-int2dds-cpp
source /opt/ros/humble/setup.bash
export RMW_IMPLEMENTATION=rmw_int2dds_cpp
Latest version (testing repository or source build)
The newest release is available from the ROS 2 testing repository:
sudo apt install -y ros2-testing-apt-source
sudo apt update
sudo apt install ros-humble-rmw-int2dds-cpp
To build from source instead, follow Quick Start.
Windows and macOS
There are no binary packages of rmw_int2dds for Windows or macOS: build it from
source on top of a ROS 2 installation made with the ROS 2 installation guide for
that platform. int2dds_ffi_vendor downloads the FFI for the host from the
int2DDS releases.
Windows, in an x64 Native Tools Command Prompt for VS 2019. The commands below assume ROS 2 Humble in
C:\pixi_ws\ros2-windows; change the paths to match your installation.
The ROS 2 Windows binaries are Release builds, so build rmw_int2dds as Release too:
```bat cd /d C:\pixi_ws pixi shell call C:\pixi_ws\ros2-windows\local_setup.bat
File truncated at 100 lines see the full file
CONTRIBUTING
Contributing to rmw_int2dds_cpp
Thank you for your interest in contributing! This package is the ROS 2 RMW binding for int2DDS. For contributions to the underlying DDS core, see the int2DDS repository.
Code of Conduct
This project adheres to a Code of Conduct.
Contributor License Agreement (CLA)
By submitting a pull request you agree to the project CLA (individual / corporate).
Development Environment
Prerequisites
- A supported ROS 2 distribution (Humble or Jazzy) installed and sourced
- colcon build tool
- A C++17 compiler (GCC/Clang/MSVC), CMake >= 3.14.4
- The int2DDS core library available as a dependency
Workspace setup
mkdir -p ~/ros2_ws/src && cd ~/ros2_ws/src
git clone https://github.com/IntellectusCorp/rmw_int2dds.git
cd ~/ros2_ws
rosdep install --from-paths src --ignore-src -r -y
Building and Testing
# Build
colcon build --packages-up-to rmw_int2dds_cpp
# Run this package's tests
colcon test --packages-select rmw_int2dds_cpp
colcon test-result --verbose
# Run the RMW interface conformance suite against int2DDS
RMW_IMPLEMENTATION=rmw_int2dds_cpp \
colcon test --packages-select test_rmw_implementation
Tier 3 listing requires the full
test_rmw_implementationsuite to pass.
Code Style
This package follows the ROS 2 Code Style and Language Versions guide:
- C++17, max line length 100,
.hpp/.cppextensions - Linters run as tests via
ament_lint_auto+ament_lint_common(ament_clang_format,ament_cpplint,ament_uncrustify,ament_cppcheck) - Build with
-Wall -Wextra -Wpedantic
# Run linters
colcon test --packages-select rmw_int2dds_cpp --ctest-args -R lint
Commit Messages
Use the format TYPE: short description (max 72 chars), imperative mood.
Types: FEAT, FIX, DOCS, STYLE, REFACTOR, TEST, CHORE, PERF.
Reference issues with Fixes #123.
Branch Naming
feature/, fix/, hotfix/, docs/, refactor/, test/ prefixes;
lowercase with hyphens (e.g., feature/qos-deadline).
Pull Request Process
- Rebase on the latest
upstream/main. - Ensure
colcon buildandcolcon testpass, including linters. - Update documentation and
CHANGELOG.rstif behavior or APIs changed. - Open a PR with a clear summary, rationale, and testing notes.
- Request review from maintainers.
Reporting Bugs
Open a GitHub issue with: description, reproduction steps, expected vs actual behavior, environment (OS, ROS 2 distro, int2DDS version), and logs. For security issues, follow SECURITY.md instead.
License
By contributing, you agree your contributions are licensed under the Apache License 2.0.
License of contributions
Any contribution that you make to this repository will be under the Apache 2 License, as dictated by that
File truncated at 100 lines see the full file
Repository Summary
| Description | |
| Checkout URI | https://github.com/IntellectusCorp/rmw_int2dds.git |
| VCS Type | git |
| VCS Version | humble |
| Last Updated | 2026-10-13 |
| Dev Status | DEVELOPED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| int2dds_ffi_vendor | 0.1.8 |
| rmw_int2dds_cpp | 0.1.8 |
| rmw_int2dds_validation | 0.1.8 |
README
ROS 2 RMW for int2DDS
Overview
rmw_int2dds_cpp lets ROS 2 applications run on top of
int2DDS, a Rust
implementation of the OMG DDS standard (RTPS 2.5). It implements the ROS 2 rmw
C interface so that any ROS 2 stack (rclcpp, rclpy, ros2 CLI, tools) can use
int2DDS as its middleware via RMW_IMPLEMENTATION=rmw_int2dds_cpp.
Status: work in progress — APIs and test results are being stabilized ahead of a request for Tier 3 status in REP 2000.
Supported ROS 2 distributions
| Distribution | Status |
|---|---|
| Humble Hawksbill (LTS) | Supported (verified) |
| Jazzy Jalisco (LTS) | Supported (verified) |
| Lyrical Luth (LTS) | Supported (verified, except cross-vendor WStrings - see Known issues) |
| Rolling Ridley | Supported (verified, except cross-vendor WStrings - see Known issues) |
Supported platforms
| Platform | amd64 | arm64 | arm32 |
|---|---|---|---|
| Ubuntu 22.04 (Jammy) | Verified | Verified | Verified |
| Windows 10 | Verified (on Windows 11) | ||
| RHEL 8 | Verified | ||
| Ubuntu 20.04 (Focal) | Verified | Verified | Verified |
| macOS | Verified | ||
| Debian 11 (Bullseye) | Verified | Verified | Verified |
| OpenEmbedded / Yocto | Verified | Verified | Not supported |
- Windows: verified on Windows 11 with Visual Studio 2019. See Windows and macOS.
- macOS: verified on macOS 15.
- OpenEmbedded / Yocto: verified with a local layer that adds the
rmw_int2ddsrecipes. arm32 does not build: the ROS 2 message packages fail beforermw_int2ddsis reached.
Installation
From the ROS 2 apt repository
sudo apt update
sudo apt install ros-humble-rmw-int2dds-cpp
source /opt/ros/humble/setup.bash
export RMW_IMPLEMENTATION=rmw_int2dds_cpp
apt install pulls in the int2dds_ffi_vendor package automatically. The RMW library
and its ament-index marker install into /opt/ros/humble/, so once the environment is
sourced only RMW_IMPLEMENTATION needs to be set.
Supported: humble / jazzy / lyrical / rolling × amd64 / arm64 (rolling: testing repository only).
From the ROS 2 RPM repository (RHEL)
With the ROS 2 RPM repository set up as in the ROS 2 RHEL installation guide:
sudo dnf install ros-humble-rmw-int2dds-cpp
source /opt/ros/humble/setup.bash
export RMW_IMPLEMENTATION=rmw_int2dds_cpp
Latest version (testing repository or source build)
The newest release is available from the ROS 2 testing repository:
sudo apt install -y ros2-testing-apt-source
sudo apt update
sudo apt install ros-humble-rmw-int2dds-cpp
To build from source instead, follow Quick Start.
Windows and macOS
There are no binary packages of rmw_int2dds for Windows or macOS: build it from
source on top of a ROS 2 installation made with the ROS 2 installation guide for
that platform. int2dds_ffi_vendor downloads the FFI for the host from the
int2DDS releases.
Windows, in an x64 Native Tools Command Prompt for VS 2019. The commands below assume ROS 2 Humble in
C:\pixi_ws\ros2-windows; change the paths to match your installation.
The ROS 2 Windows binaries are Release builds, so build rmw_int2dds as Release too:
```bat cd /d C:\pixi_ws pixi shell call C:\pixi_ws\ros2-windows\local_setup.bat
File truncated at 100 lines see the full file
CONTRIBUTING
Contributing to rmw_int2dds_cpp
Thank you for your interest in contributing! This package is the ROS 2 RMW binding for int2DDS. For contributions to the underlying DDS core, see the int2DDS repository.
Code of Conduct
This project adheres to a Code of Conduct.
Contributor License Agreement (CLA)
By submitting a pull request you agree to the project CLA (individual / corporate).
Development Environment
Prerequisites
- A supported ROS 2 distribution (Humble or Jazzy) installed and sourced
- colcon build tool
- A C++17 compiler (GCC/Clang/MSVC), CMake >= 3.14.4
- The int2DDS core library available as a dependency
Workspace setup
mkdir -p ~/ros2_ws/src && cd ~/ros2_ws/src
git clone https://github.com/IntellectusCorp/rmw_int2dds.git
cd ~/ros2_ws
rosdep install --from-paths src --ignore-src -r -y
Building and Testing
# Build
colcon build --packages-up-to rmw_int2dds_cpp
# Run this package's tests
colcon test --packages-select rmw_int2dds_cpp
colcon test-result --verbose
# Run the RMW interface conformance suite against int2DDS
RMW_IMPLEMENTATION=rmw_int2dds_cpp \
colcon test --packages-select test_rmw_implementation
Tier 3 listing requires the full
test_rmw_implementationsuite to pass.
Code Style
This package follows the ROS 2 Code Style and Language Versions guide:
- C++17, max line length 100,
.hpp/.cppextensions - Linters run as tests via
ament_lint_auto+ament_lint_common(ament_clang_format,ament_cpplint,ament_uncrustify,ament_cppcheck) - Build with
-Wall -Wextra -Wpedantic
# Run linters
colcon test --packages-select rmw_int2dds_cpp --ctest-args -R lint
Commit Messages
Use the format TYPE: short description (max 72 chars), imperative mood.
Types: FEAT, FIX, DOCS, STYLE, REFACTOR, TEST, CHORE, PERF.
Reference issues with Fixes #123.
Branch Naming
feature/, fix/, hotfix/, docs/, refactor/, test/ prefixes;
lowercase with hyphens (e.g., feature/qos-deadline).
Pull Request Process
- Rebase on the latest
upstream/main. - Ensure
colcon buildandcolcon testpass, including linters. - Update documentation and
CHANGELOG.rstif behavior or APIs changed. - Open a PR with a clear summary, rationale, and testing notes.
- Request review from maintainers.
Reporting Bugs
Open a GitHub issue with: description, reproduction steps, expected vs actual behavior, environment (OS, ROS 2 distro, int2DDS version), and logs. For security issues, follow SECURITY.md instead.
License
By contributing, you agree your contributions are licensed under the Apache License 2.0.
License of contributions
Any contribution that you make to this repository will be under the Apache 2 License, as dictated by that
File truncated at 100 lines see the full file
Repository Summary
| Description | |
| Checkout URI | https://github.com/IntellectusCorp/rmw_int2dds.git |
| VCS Type | git |
| VCS Version | humble |
| Last Updated | 2026-10-13 |
| Dev Status | DEVELOPED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| int2dds_ffi_vendor | 0.1.8 |
| rmw_int2dds_cpp | 0.1.8 |
| rmw_int2dds_validation | 0.1.8 |
README
ROS 2 RMW for int2DDS
Overview
rmw_int2dds_cpp lets ROS 2 applications run on top of
int2DDS, a Rust
implementation of the OMG DDS standard (RTPS 2.5). It implements the ROS 2 rmw
C interface so that any ROS 2 stack (rclcpp, rclpy, ros2 CLI, tools) can use
int2DDS as its middleware via RMW_IMPLEMENTATION=rmw_int2dds_cpp.
Status: work in progress — APIs and test results are being stabilized ahead of a request for Tier 3 status in REP 2000.
Supported ROS 2 distributions
| Distribution | Status |
|---|---|
| Humble Hawksbill (LTS) | Supported (verified) |
| Jazzy Jalisco (LTS) | Supported (verified) |
| Lyrical Luth (LTS) | Supported (verified, except cross-vendor WStrings - see Known issues) |
| Rolling Ridley | Supported (verified, except cross-vendor WStrings - see Known issues) |
Supported platforms
| Platform | amd64 | arm64 | arm32 |
|---|---|---|---|
| Ubuntu 22.04 (Jammy) | Verified | Verified | Verified |
| Windows 10 | Verified (on Windows 11) | ||
| RHEL 8 | Verified | ||
| Ubuntu 20.04 (Focal) | Verified | Verified | Verified |
| macOS | Verified | ||
| Debian 11 (Bullseye) | Verified | Verified | Verified |
| OpenEmbedded / Yocto | Verified | Verified | Not supported |
- Windows: verified on Windows 11 with Visual Studio 2019. See Windows and macOS.
- macOS: verified on macOS 15.
- OpenEmbedded / Yocto: verified with a local layer that adds the
rmw_int2ddsrecipes. arm32 does not build: the ROS 2 message packages fail beforermw_int2ddsis reached.
Installation
From the ROS 2 apt repository
sudo apt update
sudo apt install ros-humble-rmw-int2dds-cpp
source /opt/ros/humble/setup.bash
export RMW_IMPLEMENTATION=rmw_int2dds_cpp
apt install pulls in the int2dds_ffi_vendor package automatically. The RMW library
and its ament-index marker install into /opt/ros/humble/, so once the environment is
sourced only RMW_IMPLEMENTATION needs to be set.
Supported: humble / jazzy / lyrical / rolling × amd64 / arm64 (rolling: testing repository only).
From the ROS 2 RPM repository (RHEL)
With the ROS 2 RPM repository set up as in the ROS 2 RHEL installation guide:
sudo dnf install ros-humble-rmw-int2dds-cpp
source /opt/ros/humble/setup.bash
export RMW_IMPLEMENTATION=rmw_int2dds_cpp
Latest version (testing repository or source build)
The newest release is available from the ROS 2 testing repository:
sudo apt install -y ros2-testing-apt-source
sudo apt update
sudo apt install ros-humble-rmw-int2dds-cpp
To build from source instead, follow Quick Start.
Windows and macOS
There are no binary packages of rmw_int2dds for Windows or macOS: build it from
source on top of a ROS 2 installation made with the ROS 2 installation guide for
that platform. int2dds_ffi_vendor downloads the FFI for the host from the
int2DDS releases.
Windows, in an x64 Native Tools Command Prompt for VS 2019. The commands below assume ROS 2 Humble in
C:\pixi_ws\ros2-windows; change the paths to match your installation.
The ROS 2 Windows binaries are Release builds, so build rmw_int2dds as Release too:
```bat cd /d C:\pixi_ws pixi shell call C:\pixi_ws\ros2-windows\local_setup.bat
File truncated at 100 lines see the full file
CONTRIBUTING
Contributing to rmw_int2dds_cpp
Thank you for your interest in contributing! This package is the ROS 2 RMW binding for int2DDS. For contributions to the underlying DDS core, see the int2DDS repository.
Code of Conduct
This project adheres to a Code of Conduct.
Contributor License Agreement (CLA)
By submitting a pull request you agree to the project CLA (individual / corporate).
Development Environment
Prerequisites
- A supported ROS 2 distribution (Humble or Jazzy) installed and sourced
- colcon build tool
- A C++17 compiler (GCC/Clang/MSVC), CMake >= 3.14.4
- The int2DDS core library available as a dependency
Workspace setup
mkdir -p ~/ros2_ws/src && cd ~/ros2_ws/src
git clone https://github.com/IntellectusCorp/rmw_int2dds.git
cd ~/ros2_ws
rosdep install --from-paths src --ignore-src -r -y
Building and Testing
# Build
colcon build --packages-up-to rmw_int2dds_cpp
# Run this package's tests
colcon test --packages-select rmw_int2dds_cpp
colcon test-result --verbose
# Run the RMW interface conformance suite against int2DDS
RMW_IMPLEMENTATION=rmw_int2dds_cpp \
colcon test --packages-select test_rmw_implementation
Tier 3 listing requires the full
test_rmw_implementationsuite to pass.
Code Style
This package follows the ROS 2 Code Style and Language Versions guide:
- C++17, max line length 100,
.hpp/.cppextensions - Linters run as tests via
ament_lint_auto+ament_lint_common(ament_clang_format,ament_cpplint,ament_uncrustify,ament_cppcheck) - Build with
-Wall -Wextra -Wpedantic
# Run linters
colcon test --packages-select rmw_int2dds_cpp --ctest-args -R lint
Commit Messages
Use the format TYPE: short description (max 72 chars), imperative mood.
Types: FEAT, FIX, DOCS, STYLE, REFACTOR, TEST, CHORE, PERF.
Reference issues with Fixes #123.
Branch Naming
feature/, fix/, hotfix/, docs/, refactor/, test/ prefixes;
lowercase with hyphens (e.g., feature/qos-deadline).
Pull Request Process
- Rebase on the latest
upstream/main. - Ensure
colcon buildandcolcon testpass, including linters. - Update documentation and
CHANGELOG.rstif behavior or APIs changed. - Open a PR with a clear summary, rationale, and testing notes.
- Request review from maintainers.
Reporting Bugs
Open a GitHub issue with: description, reproduction steps, expected vs actual behavior, environment (OS, ROS 2 distro, int2DDS version), and logs. For security issues, follow SECURITY.md instead.
License
By contributing, you agree your contributions are licensed under the Apache License 2.0.
License of contributions
Any contribution that you make to this repository will be under the Apache 2 License, as dictated by that
File truncated at 100 lines see the full file