RTIPC is a new inter-process communication library for Linux designed specifically for hard real-time workloads, where predictable execution and low latency matter more than the flexibility offered by general-purpose IPC mechanisms.
The project combines shared memory with a Single Producer Single Consumer wait-free queue, allowing processes to exchange data without copying through kernel buffers. Once a communication channel is established, transfers occur directly through shared memory without syscalls in the data path.
RTIPC also provides a “force push” operation. When a queue is full, the producer can discard the oldest unread message and replace it with newer data. This suits workloads where having the latest state matters more than processing every intermediate update.
Because that behavior makes the queue algorithm more complex, the project says it has formally verified the implementation using SPIN/Modex.
Messages are also cacheline-aligned to reduce unnecessary cache-coherence traffic on multi-core systems, while optional eventfd support allows RTIPC channels to work with standard Linux event mechanisms such as select, poll, and epoll.
There is an important trade-off. Both message size and maximum queue length must be fixed when a channel is created. Developers say this restriction is intentional because changing these values dynamically could compromise deterministic execution.
The project positions RTIPC between traditional Linux IPC mechanisms and manually implemented shared-memory communication. Sockets, pipes, and message queues move data through kernel-managed buffers, while shared memory avoids copies but leaves synchronization to the application developer.
RTIPC uses shared memory for the data itself while handling synchronization through its wait-free SPSC implementation.
Creating a connection requires an initial setup phase. The library allocates anonymous shared memory and optional eventfds, then transfers their file descriptors to the other process through a Unix domain socket using SCM_RIGHTS. Once both sides map the memory, communication continues directly through shared memory.
Interestingly, D-Bus can also be used for this initial file-descriptor exchange. In other words, RTIPC is not presented as a general replacement for D-Bus, but as a specialized data path for applications with strict real-time requirements.
The project takes an unusual approach to exchanging structured data between applications in different languages. Instead of recommending Protocol Buffers, Cap’n Proto, FlatBuffers, or other serialization formats, RTIPC suggests using standard C-compatible structures.
There is one notable limitation: a 32-bit process and a 64-bit process cannot safely exchange these structures through RTIPC because their structure alignment may differ.
Finally, keep in mind that RTIPC itself is also still under active development. C11, C++, Rust, and Python implementations are currently being worked on, with the C implementation remaining dependency-free and the Rust version written in pure Rust. Java, C#, and Go support is planned.
For additional detail, see the project’s GitHub page.
Image credits: RTIPC
