As the automotive industry accelerates its transition to Software-Defined Vehicles (SDVs), one challenge continues to slow teams down: how applications and ECUs exchange data. Today's vehicles are complex software platforms where dozens of systems — from instrument clusters and infotainment to ADAS and body control — all need to produce, consume, and analyze signal data in real-time. Yet the way this data is shared remains fragmented, proprietary, and tightly coupled to specific hardware and middleware stacks.

The result? Developers spend significant effort wiring up custom interfaces, translating between data formats, and rebuilding integrations every time the underlying hardware or data source changes. It's an integration tax that adds cost, slows development, and makes it harder to scale software across vehicle lines.

At QNX, we believe there's a better way. And today, we're putting that belief into action.

Introducing QNX POSIX Publish Subscribe — Now Open Source

We are excited to announce the open-source release of the QNX POSIX Publish Subscribe project, available now on GitHub under the Apache 2.0 license.

This project provides a highly efficient method for exchanging well-defined signals or messages between different applications — and it does so using an interface that every embedded developer already knows: the standard POSIX File API.

No new SDK to install. No proprietary protocol to learn. If you can use open(), read(), write(), or command-line tools like cat, echo, and ls, you can start working with vehicle signals immediately.

What It Is and How It Works

At the heart of the project is the QNX POSIX Publish Subscribe Service (QPP) — a QNX file system resource manager that exposes data through a standard POSIX file interface.

QPP is implemented using QNX’s native resource manager framework and kernel message-passing IPC. This means signal communication is handled using the same lightweight, deterministic primitives that underpin the QNX operating system itself — resulting in an efficient, low-overhead mechanism for inter-process communication within an ECU.

QPP operates in two modes:

• Signal Service: When started with a Signal Catalog — such as one based on the COVESA Vehicle Signal Specification (VSS) — QPP reads the catalog and generates Value, Control, and Metadata files in a directory structure that mirrors the specification. Clients use these files to communicate signal value updates or create actuation requests that change system behavior. This provides a standardized, industry-recognized data model for signal exchange within an ECU.
• Generic Publish Subscribe Messaging: QPP can also function as a flexible publish-subscribe messaging service. Clients can dynamically add or remove topics and branches at runtime using standard POSIX filesystem APIs and common CLI tools — making it immediately accessible for rapid prototyping and custom use cases.

The project also includes the Signal Framework, which solves a critical problem: abstracting signal data from its source. The framework uses Signal Connectors to bind to disparate data sources — whether that's a CAN bus, SOME/IP, a local device, or simulation and playback tooling — and normalizes the data into a consistent format. On the consumption side, Signal Adaptors make that normalized data available to disparate target systems such as the instrument cluster, IVI, or Android via VHAL.

The key benefit? The same client code works in production — where signals come from real hardware — and in a virtualized environment — where signals come from simulation and data playback. This decoupling is essential for enabling the “shift left” development approach that the industry is moving toward.

Positioning Within the Broader Ecosystem

While there are existing approaches to standardizing vehicle signal access—such as API-based data brokers that expose VSS signals through gRPC or WebSocket interfaces ¹—our focus with QNX POSIX Publish Subscribe is fundamentally different.

We are not introducing another API layer. Instead, we are leveraging a well-understood, portable interface—the POSIX file system—to make vehicle signals immediately accessible without requiring developers to adopt new frameworks or communication protocols.

This approach complements broader ecosystem efforts around VSS-based data models by reducing integration friction at the developer level, particularly in embedded and resource-constrained environments. Rather than redefining how signals should be accessed, we are simplifying how developers interact with them – using interfaces they already know.

Why This Matters for Developers

We designed this project with a clear set of principles:

• Zero new APIs to learn. By relying on the POSIX file interface, we've eliminated the overhead and complexity associated with learning and managing yet another proprietary interface. Developers can interact with signals programmatically or from the command line using tools they already use every day.
• Standards-based signal model. When used as a Signal Service, QPP relies on the COVESA VSS — a widely adopted open data model that standardizes how vehicle signals are structured and shared across systems. QNX has actively contributed to the VSS specification and presented this work through COVESA webinar and All Member Meeting presentations.
• Source abstraction that scales. The Signal Framework decouples your application code from the underlying data transport. Whether your signals originate from CAN, SOME/IP, simulation, or playback, your client code doesn't change. This dramatically reduces rework when moving between development, testing, and production environments.
• Extensible by design. Need to connect to a new data source? Build a Signal Connector. Need to expose signals to a new target system? Build a Signal Adaptor. The framework is designed to be easily extended.
• Built-in simulation and playback tooling. The project includes tools for deterministic testing without requiring real hardware — enabling faster iteration and earlier validation.

Why QNX Is Doing This

This release reflects a deliberate strategic choice — not just a code drop.

• We are democratizing technology adoption and accelerating time-to-market. We've learned a great deal through developing this technology and contributing to industry standards like COVESA VSS. By open sourcing QNX POSIX Publish Subscribe Service, we’re making those learnings immediately available to developers without licensing barriers.
• We are fostering an open and collaborative ecosystem. The industry benefits when the data format for signal sharing is standardized. COVESA VSS plays a key role in enabling that interoperability across the ecosystem, reducing fragmentation and accelerating innovation. By releasing this under the Apache 2.0 license, we’re reinforcing our commitment to open, commercial-friendly collaboration.

QNX has been the trusted foundation for mission-critical embedded systems for decades. Open-sourcing this project is a natural extension of that commitment to both developers and the industry.

Get Started

The QNX POSIX Publish Subscribe repository is available now on GitHub. Clone it, explore the sample applications, and see how standardized signal exchange can simplify your development workflow.

If you're new to QNX, QNX Everywhere provides free, perpetual, non-commercial access to QNX SDP 8.0 — everything you need to build, test, and experiment.

We welcome contributions, feedback, and collaboration. Let’s build the future of vehicle signal exchange — openly, together.