Announcing iceoryx2 v0.7.0

Christian Eltzschig - 13/09/2025

What Is iceoryx2

iceoryx2 is a service-based communication library designed to build robust and efficient decentralized systems. It enables ultra low-latency communication between processes — similar to Unix domain sockets or message queues, but significantly faster and easier to use.

It includes language bindings for C, C++, Python, and Rust and it runs on Linux, macOS, Windows, FreeBSD and QNX.

iceoryx2 supports messaging patterns such as publish-subscribe, events, request-response stream and the introduced blackboard pattern - a key-value repository in shared memory. It is robust and comes with a decentralized architecture without the need for a central broker.

Check out the iceoryx2 benchmarks and try them out on your platform!

Release v0.7.0

With the new v0.7.0 release of iceoryx2, we’re adding full Python bindings and a network tunnel. That means you can now send data not just between processes on the same machine, but also across hosts - iceoryx2 handles the communication details for you.

We’ve also finished the first version of the iceoryx2 Book, which not only helps you get started quickly but also provides deep background on the overall architecture.

Debugging, introspection, and record-and-replay of data are now possible with the command-line client. On top of that, we’ve introduced a new messaging pattern called blackboard, a key-value repository in shared memory.

And one more thing: iceoryx2 now runs on QNX 7.1. There are plenty of smaller enhancements too. Check out the full release notes here: iceoryx2 v0.7.0 release

The iceoryx2 Book

We’ve put effort into the iceoryx2 book, which serves as a starting point for every user. Whether you’re looking for a quick introduction, a getting-started tutorial, or a deeper dive into the architecture of iceoryx2.

If you’d like to contribute, by writing an article, creating a tutorial on a specific topic, or reporting an issue, we’d be glad to receive your pull request: https://github.com/ekxide/iceoryx2-book

Remark: The iceoryx2 book replaces the previous ReadTheDocs documentation and provides references for C, C++, Python, and Rust.

Python Language Bindings

We’ve ported the iceoryx2 API to Python and added an extensive set of examples on GitHub.

If you’re new to iceoryx2, start with the Getting Started tutorial A Robot Nervous System in the iceoryx2 book. It walks through all the major features across every supported language. You can switch between languages while reading, which makes it easy to build complex systems that mix Python, C, C++, and Rust - without paying the serialization overhead.

A highlight is the publish–subscribe cross-language example, where Python, C, C++, and Rust processes exchange data directly in shared memory. Check it out:

And this isn’t limited to publish-subscribe, the same zero-copy, cross-language communication works with all messaging patterns, including request–response and events.

Network Communication

Until now, iceoryx2 focused on inter-process communication. With the new network tunnel, you can communicate between hosts as well. No complicated setup, no configuration headaches, just run the CLI:

cargo install iceoryx2-cli
iox2 tunnel zenoh

Do that on each host, and your publish–subscribe and event communication is instantly available across machines.

The network tunnel, that connects iceoryx2 instances across the network, is still in development, so some patterns, like request–response and blackboard, aren’t supported yet. But it’s also the first step toward a full gateway: the idea is that you’ll use the native iceoryx2 API while the gateway connects to other protocols in the background.

Picture this: you start a gRPC, MQTT, or DDS gateway, and suddenly your iceoryx2 application can talk to anything, or let others talk to you, without changing a single line of code.

That’s the vision. And with the tunnel, you can already connect iceoryx2 applications across hosts today by just running iox2 tunnel zenoh.

Command Line Client: Debugging And Introspection

We are continuously improving the iox2 command-line client to make it a versatile tool for working with iceoryx2. It allows direct interaction with iceoryx2 from the shell, which is especially useful for debugging.

Let’s start with events. Open two terminals and run the listener example in one of them:

cargo run --example event_listener

Now you can send event notifications to this process and wake it up explicitly:

cargo install iceoryx2-cli
iox2 service notify --event-id 1 --num 2 --interval-in-ms 1500 MyEventName

You can also wait for events directly on the command line, or send and receive publish-subscribe samples. More details and examples can be found in the getting started article on the command line in the iceoryx2 book.

Record And Replay

The iox2 command-line client also supports record and replay. This is useful when you want to capture real data and feed it back into the system during development - for example, creating an endlessly repeating stream of sensor data.

Let’s walk through it with the publish-subscribe example. Start the publisher in one terminal:

cargo run --example publish_subscribe_publisher

In another terminal, record the data for 10 seconds and write it to record.dat:

iox2 service record --timeout-in-sec 10 --output record.dat "My/Funk/ServiceName"

The output file is human-readable by default. Tip: Payloads are stored in hex. This makes it easy to edit them manually and then inject modified data back into the system to test edge cases. Next, stop the publisher and start the subscriber:

cargo run --example publish_subscribe_subscriber

Now replay the recording twice:

iox2 service replay --input record.dat --repetitions 2

A more detailed walkthrough is available in the getting started article on the command line in the iceoryx2 book.

Messaging Pattern: Blackboard

The publish-subscribe pattern can reach its limits when a single publisher needs to serve hundreds or even thousands of subscribers. This often happens when the system requires a global state - for example, in a simulation where every entity’s position and movement must be tracked, or when maintaining a global configuration across multiple components.

With the newly introduced blackboard messaging pattern, iceoryx2 provides a shared-memory key-value repository that every process can access efficiently. A single process can maintain the global state in a thread-safe way, while all others can read it without overhead.

The iceoryx2 book contains a getting started article on the blackboard, and you can also explore some hands-on code in the examples folder on GitHub.

For deeper background on the concept itself, see the article Advanced Messaging Patterns – Blackboard.

Remark: The blackboard messaging pattern is currently available only in Rust. C, C++, and Python bindings will be added in the next release.

New Supported Platforms

For Yocto users, we now provide a dedicated Yocto layer on GitHub.

We have also added support for QNX 7.1. In the open-source repository, QNX is available as a tier-3 platform due to license restrictions. If you require tier-1 support, please reach out to us.

In addition, there is a VxWorks proof of concept. Contact us for details.

Other Feature Highlights

Thread-safe service types Until now, iceoryx2 ports were not thread-safe, which made async use cases tricky. This release introduces ipc_threadsafe::Service and local_threadsafe::Service. These variants are optimized for different contexts, and the service variant example on GitHub introduces all of them, how you can specialize them and shows how to pick the right one.

Service discovery We added a request-response service to obtain the full list of all running services in the system. The list can be kept up to date by subscribing to a publish-subscribe service. See the discovery example.

Graceful shutdown Client-server connections can now be shut down gracefully while the client is receiving a response stream. The API provides PendingResponse::set_disconnect_hint() and ActiveRequest::has_disconnect_hint().

Roadmap: What’s Next?

iceoryx2 Roadmap.

no_std support for embedded use cases
Blackboard Messaging Pattern Language Bindings for C, C++ and Python
QNX 8.0
network tunnel: support for request-response and blackboard
(Moonshot) Go language bindings

Thank You

We want to thank our community. Your ideas, discussions, and collaborative spirit help shape iceoryx2 every day. Even frustrating bugs become less painful when tackled with humor and openness.

Also a big thank you to the iceoryx team, which was relentless in implementing all those features.

And finally, a big thank you to our customers who share our vision:

To create an open-source, certifiable base and communication library that can be trusted in mission-critical systems.