Decoding Rheinmetall's onboardapi: The Open-Source Middleware Revolutionizing Defense Tech

For decades, military software development suffered from a deeply entrenched structural flaw: the sensor-to-software bottleneck. When every military vehicle, radar installation, and targeting system ran on proprietary, closed-source middleware, integrating a new sensor meant months of custom engineering, expensive contract modifications, and fragile point-to-point bridging. If an army wanted to feed targeting data from an uncrewed reconnaissance vehicle into a main battle tank’s fire control system, engineers had to write custom translation layers for isolated, proprietary protocols. It was the architectural equivalent of building a custom bridge every time you wanted to connect two houses on the same street.

This friction is precisely why Rheinmetall’s open-source release of onboardapi v9.10.0—featuring interface descriptions and documentation for its core defense middleware—is a watershed moment for defense technology. By standardizing battlefield data exchange, Rheinmetall is helping dismantle the legacy of vendor lock-in that has long plagued military procurement. As the defense sector pivots rapidly toward software-defined defense and rapid sensor-to-shooter integration, understanding the architecture of onboardapi reveals how modern edge systems are changing.

Deconstructing the Architecture: DDS and Data-Centric Pub/Sub

To understand why onboardapi represents a major shift, we have to look at its foundation: the Data Distribution Service (DDS) standard, established by the Object Management Group (OMG).

Traditional enterprise software relies heavily on topic-based publish-subscribe brokers (like MQTT or RabbitMQ) or client-server Remote Procedure Calls (RPC over HTTP/gRPC). In these architectures, a central broker routes messages between producers and consumers. If the broker goes down, or if network congestion spikes, the pipeline breaks. Furthermore, these protocols are “message-centric”—they care about transmitting bytes from point A to point B without inherently understanding the structure or lifecycle of the data itself.

DDS takes a radically different approach: data-centric publish-subscribe.

“In a data-centric architecture, the middleware treats distributed memory as a global data space. Applications simply read and write to strongly typed data topics, and the middleware manages the underlying discovery, delivery, and QoS policies automatically.”

For tactical edge environments—where bandwidth fluctuates wildly, nodes drop offline unpredictably, and latency must be measured in milliseconds—DDS outperforms traditional client-server designs for several reasons:

• Brokerless Discovery: DDS uses peer-to-peer discovery protocols. Nodes discover each other automatically over multicast or configured transports without requiring a central message broker that could become a single point of failure.
• Granular Quality of Service (QoS): Developers can configure over 20 distinct QoS policies per data topic, including DEADLINE, LIVELINESS, TRANSIENT_LOCAL durability, and RELIABILITY (best-effort vs. reliable). This allows raw radar streams to use unreliable, low-latency transport while critical targeting commands use guaranteed delivery.
• Deterministic Performance: DDS implementations are optimized for real-time operating systems (RTOS), ensuring predictable CPU and memory overhead.

Under the Hood: XTypes, XCDR2, and Version Resilience

Building a high-performance middleware is only half the battle in a defense context. The real engineering nightmare of distributed military fleets is heterogeneity.

A modern armored brigade might combine newly manufactured vehicles running updated software stacks with legacy platforms running software versions compiled years prior. If a software update on a reconnaissance drone alters a telemetry data structure, it cannot crash the command vehicle’s fire control computer.

Rheinmetall’s onboardapi solves this through strict adherence to DDS standards for dynamic type evolution: XTypes and XCDR2 encoding.

Dynamic Type Discovery with XTypes

The DDS XTypes specification allows data types to be defined, discovered, and evolved dynamically at runtime rather than being hardcoded at compile time. In onboardapi, interface descriptions are managed in a way that allows nodes to inspect the data types of peers dynamically. If Node A publishes a sensor topic with an extra metadata field that Node B’s older software doesn’t recognize, the XTypes type-assignability rules dictate how Node B gracefully ignores or maps the unfamiliar fields without dropping the entire data stream.

Efficient Serialization with XCDR2

Data serialization at the tactical edge must minimize CPU cycles and wire overhead. onboardapi utilizes XCDR2 (Extensible and Dynamic Topic Types for DDS, Version 2) for encoding data structures. XCDR2 provides two primary representation formats:

1. Plain Representation: Optimized for flat, primitive-heavy structures, matching native memory alignments for zero-copy deserialization.
2. Extensible/Nested Representation: Uses explicit member headers and length tags, allowing fields to be added or removed without breaking backward compatibility.

// Conceptual representation of a strongly typed sensor topic in onboardapi
namespace rme::onboardapi::sensors {
    struct TargetTelemetry {
        uint32_t target_id;
        double latitude;
        double longitude;
        float velocity_vector[3];
        // XCDR2 and XTypes ensure older nodes can read this struct 
        // even if newer versions append optional fields here.
    };
}

By leveraging XCDR2, systems can achieve near-zero serialization overhead while maintaining ironclad inter-version communication across mixed hardware fleets.

The Hybrid Open Model: EPL v2.0 Meets Proprietary Runtimes

Open-source advocates examining the onboardapi v9.10.0 release will notice a deliberate architectural and legal nuance: it is not entirely open-source in the traditional permissive sense. Instead, it employs a hybrid open model.

• The Interface Definitions (EPL v2.0): All API specifications, documentation (generated via Doxygen v1.9.1), and IDL (Interface Definition Language) descriptions are licensed under the Eclipse Public License v2.0. This allows developers, integrators, and allied defense firms to inspect, analyze, and build wrappers around the interface specifications freely.
• The Runtime Libraries (EULA-RME-SDK-1.0): The actual underlying runtime binaries and execution SDKs remain bound by a proprietary end-user license agreement (EULA-RME-SDK-1.0).

Strategic Rationale

Why adopt this split-brain licensing strategy? For Rheinmetall, this strikes a delicate balance between commercial protection and ecosystem enablement.

By open-sourcing the interface definitions under EPL v2.0, Rheinmetall lowers the barrier to entry for third-party software vendors. Contractors can build applications that speak onboardapi without needing to reverse-engineer proprietary binary blobs. This directly addresses the hardware governance and integration challenges discussed in broader industrial shifts toward open-source hardware sovereignty.

At the same time, retaining control over the runtime SDK via EULA-RME-SDK-1.0 ensures that Rheinmetall protects its core intellectual property, maintains strict safety and certification boundaries, and retains monetization control over mission-critical binary distributions. It is a playbook reminiscent of enterprise software companies offering open-source community editions alongside hardened, enterprise-supported runtimes.

Modular Open Systems Approach (MOSA) and Vendor Lock-In

For decades, the defense procurement model was built on proprietary vendor lock-in. A prime contractor would win a multi-billion-dollar vehicle program, supply both the hardware and the internal software bus, and charge exorbitant maintenance fees for every minor software update or sensor addition.

Today, military buyers are aggressively rejecting this model in favor of MOSA (Modular Open Systems Approach).

MOSA mandates that defense platforms be designed with modular, standards-based interfaces so that components from different vendors can be swapped out with minimal friction. This mirrors the trajectory of other high-stakes technological domains where hardware-software decoupling is critical, such as the restrictions placed on foreign robotics and edge hardware in critical infrastructure.

By publishing onboardapi interfaces, Rheinmetall is positioning itself not as an isolated hardware monopolist, but as an platform orchestrator. In a modern battlespace where AI-driven edge vision, uncrewed swarms, and FPV drone revolutions demand real-time data processing at the tactical edge, armies cannot afford software deployment cycles measured in years. MOSA frameworks powered by open middleware specifications allow soldiers in the field to deploy software patches and new sensor algorithms via over-the-air updates rather than returning vehicles to a depot.

Future Outlook: Toward a ‘Linux of the Battlefield’

The release of onboardapi v9.10.0 is more than a single company’s documentation drop; it is a strategic pressure test for the entire European defense industrial base.

Major prime contractors—such as BAE Systems, Leonardo, and Thales—are now facing market pressure to justify their own proprietary software silos. If Rheinmetall’s open interface approach gains traction across NATO procurement agencies, defense ministries will increasingly write MOSA compliance and open DDS-based middleware standards into their Requests for Proposals (RFPs).

Could we be witnessing the early gestation of a “Linux of the Battlefield”?

While full unification across all NATO member states remains a formidable political and technical challenge, the convergence on OMG DDS standards and open interface specifications makes it increasingly feasible. For software engineers and systems architects building high-reliability edge systems, the takeaway is clear: the future of defense tech is not built on closed, monolithic codebases. It is built on deterministic data-centric middleware, open interface definitions, and relentless interoperability.