This proposal has been approved and the Eclipse LunaDDS project has been created.
Visit the project page for the latest information and development.

Eclipse LunaDDS

Thursday, July 31, 2025 - 10:35 by Thilo Schmitt
This proposal is in the Project Proposal Phase (as defined in the Eclipse Development Process) and is written to declare its intent and scope. We solicit additional participation and input from the community. Please login and add your feedback in the comments section.
Project
Parent Project
Proposal State
Created
Background

While many DDS implementations are powerful, they often require additional features to meet specific use cases—particularly in automotive systems. Eclipse LunaDDS addresses this need by enhancing performance and functionality with a focus on automotive-grade requirements. 

Scope

Eclipse LunaDDS builds upon the DDS (Data Distribution Service) standard, offering targeted improvements to Eclipse CycloneDDS. Its primary goals include:

CycloneDDS Extensions

  • Zero-copy inter-process communication for improved middleware performance.
  • Inter-thread communication for efficient data exchange within applications.
  • Cross-machine communication over Ethernet.
  • Rust Pub/Sub API for modern language integration (planned) .
  • Supported target platforms: QNX 7, x86_64 Linux, and aarch64.
  • Bazel build system for scalable and reproducible builds.
  • Performance optimizations, including memory mapping using huge pages, lock-free data access patterns, optional bypass of the standard DDS data path to reduce serialization overhead for critical applications.

IDL Code Generator

  • A flexible toolset designed to simplify service definition and code generation:
  • Generates RPC-style proxies and skeletons using Jinja2 templates.
  • Provides familiar method-call semantics for automotive developers.
  • Supports automatic type conversion between IDL and C++ (e.g., Boolean → bool).
  • Enables file-based service definitions with a simple syntax.
  • Offers customizable output directories.
  • Includes robust error handling and validation.Supports complex data types and method signatures.
Description

The Eclipse LunaDDS project extends the capabilities of the established Eclipse CycloneDDS middleware by enhancing performance and functionality with a focus on automotive-grade requirements.

The project embraces open-source values, enabling OEMs, Tier 1 suppliers, and technology providers to take full ownership of a core software stack, free from vendor lock-in or opaque license models. Its alignment with the Eclipse Foundation's governance and transparency principles ensures long-term sustainability, community growth, and technological leadership.

Why Here?

The Eclipse Foundation is uniquely positioned to host open middleware technologies with a strong track record in embedded and automotive domains. Eclipse CycloneDDS is already an well-established example of successful technical ecosystems that Eclipse LunaDDS can align with.

The project's values are aligned with Eclipse:

  • Open development model and vendor-neutral governance.
  • Industry collaboration, especially with automotive working groups.
  • Proven ecosystem for driving adoption beyond early prototypes.

By joining the Eclipse Foundation, Eclipse LunaDDS can accelerate adoption and secure long-term sustainability for the technology.

Future Work

Planned future developments include:

  • Continued performance tuning and feature expansion of CycloneDDS enhancements.
  • Further evolution of the IDL Code Generator.
  • Rust Integration:
    • FFI Layer: Enabling Rust applications to interface with Eclipse LunaDDS.
    • Native Rust Implementation: Exploring a Rust-based version of Eclipse LunaDDS, potentially in collaboration with the DustDDS project, to leverage Rust’s safety and performance advantages.
  • Integration of additional protocols and IPC frameworks.


Additionally, we will drive engagement through:

  • Dedicated GitLab group and repositories.
  • Open communication channels like mailing lists or Slack channels.
  • Integration with the Eclipse Software Defined Vehicle (SDV) working group.
Project Scheduling

To be defined. 

Interested Parties

The LunaDDS project will focus on building a strong and diverse contributor base including:

  • Automotive OEMs and Tier 1 suppliers.
  • Middleware providers and integrators.
  • Safety and tooling vendors.
  • Open-source Rust and real-time systems communities.
  • Eclipse Software Defined Vehicle (SDV) working group.
Initial Contribution

First code is planned to be released during Q4/2025. 

Source Repository Type

Hello, as mentioned in your project description there is already a DDS implementation at Eclipse — Cyclone DDS. — which is both mature and high-performing. According to TrendMicro, it is also the most secure DDS implementation on the market, directly addressing one of your key concerns, and it is currently undergoing ISO-26262 ASIL-D certification. 

In addition, the community will soon be releasing Rust bindings for Cyclone DDS, providing a natural starting point for Rust connectivity if DDS is indeed the goal. From my perspective, if the Eclipse community wanted a pure Rust implementation of OMG DDS, building on Cyclone DDS would have been the most coherent approach. 

I remain concerned that launching yet another DDS project risks further fragmenting an ecosystem that is already split across many half-baked implementations. Today, Cyclone DDS is the only open-source, industrial-grade DDS implementation with transparent governance, and it would be valuable to consolidate around it rather than disperse efforts.

That said, if your interest lies in a pure Rust implementation, I would also encourage you to look at Eclipse Zenoh — which, somewhat surprisingly and in spite of being part of SDV, was not mentioned in your list of Eclipse projects. Zenoh is the only protocol on the market able to run from a microcontroller to the data-centre. I believe this report will give you useful insights and additional food for thought. Finally, the Cyclone DDS community would be more than happy to engage with the LunaDDS team to explore ways of creating greater critical mass, rather than contributing to fragmentation. Please don’t hesitate to reach out to myself or the project lead — we’d welcome the conversation.

Due to evolving perspectives and alignment, unmet assumptions, and shifting priorities, it appears that unfortunately the original proposed projects characteristics can't be upheld anymore—namely, an automotive-grade implementation in Rust developed from scratch. Instead, the proposal characteristics now shifted to an extension to Eclipse CycloneDDS (written in C), potentially accompanied by a Rust API via an FFI layer.

While the scope and nature of the contribution have changed considerably, the committment remains to augment the Eclipse ecosystem with this separate open-source project focused on DDS. Therefore, this proposal was reformulated as of September 9th 2025.

Hello, glad to see that the project plans to leverage Eclipse Cyclone DDS. Just an FYI: several of the features listed in your proposal are already available in Cyclone DDS, including:

  • Zero-copy inter-process communication
  • Inter-thread communication
  • Cross-machine communication over Ethernet
  • Rust Pub/Sub API (planned)
  • Target platforms: QNX 7, Linux x86_64, and aarch64

Some of the other items would require  changes to Cyclone DDS core. Unless you intend to fork, it would make far more sense to contribute PRs and collaborate with the Cyclone team.

Lastly, given the project’s evolving scope, the name LunaDDS now feels somewhat misleading—worth reconsidering.