Modern ZeroMQ for the hard parts: reconnection, back-pressure, churn, soak tests, and real benchmarks.

Pure Rust ZeroMQ: brokerless message passing for distributed and concurrent applications. OMQ gives you socket-level messaging patterns that work the same way in-process, between processes, and over the network.

• Tokio backend for Linux, macOS, and Windows
• 20 socket types: stable ZMQ patterns plus draft CLIENT/SERVER, RADIO/DISH, SCATTER/GATHER, CHANNEL/PEER, and DGRAM
• 9 transports: TCP, IPC, inproc, UDP, WS, WSS, lz4+tcp://, lz4+ws://, and lz4+wss://
• 3 security mechanisms: PLAIN, CURVE, BLAKE3ZMQ
• No C compiler, no libzmq, no libsodium
• Python binding (pyomq), C API (omq-libzmq)

OMQ is designed for real ZMQ behavior, not just happy-path PUSH/PULL throughput. You get:

• ZeroMQ semantics without extra tuning: no topology-specific socket types, no user-visible batching API, no manual reconnection loop.
• Transport failures are normal: reconnect, connect-before-bind, peer churn, and bind-side restarts are part of the design.
• Peer failures do not become user errors: send() and recv() keep working through disconnects, reconnects, slow consumers, and bind-side restarts.
• HWM back-pressure and routing fairness under load, not only in empty-queue examples.
• The hot paths are size-aware and latency-conscious: tiny messages stay inline without allocation, inproc passes messages by value, and large payloads use zero-copy buffers where it matters.
• Memory-safe Rust for the public crates. unsafe is isolated and checked with Miri.
• Benchmarks cover the real shapes: CPU accounting, fan-in/fan-out, fairness, transport differences (see charts below).

Full comparison charts

cargo add omq-tokio

The Rust backend is omq-tokio: tokio + mio on Linux, macOS, and Windows. It works on single-thread and multi-thread tokio runtimes.

If you know ZeroMQ, you know OMQ. Same socket types, same connect/bind/send/recv:

use omq_tokio::{Message, Options, Socket, SocketType};

let push = Socket::new(SocketType::Push, Options::default());
push.connect("tcp://127.0.0.1:5555".parse()?).await?;
push.send(Message::single("hello")).await?;

let pull = Socket::new(SocketType::Pull, Options::default());
pull.bind("tcp://127.0.0.1:5555".parse()?).await?;
let msg = pull.recv().await?;
assert_eq!(&msg[0], b"hello");

All optional. Default build is the smallest deploy: NULL mechanism + TCP / IPC / inproc / UDP, no C compiler required. Enable any of:

Six crates, one repo.

Every socket type, transport, mechanism, and feature combination is covered by integration tests. The full suite:

• 700+ integration tests across socket types, transports, and mechanisms.
• Protocol fuzzing (~10M iterations per suite): hand-rolled fuzz of the wire parser and the socket-action state machine.
• 29 soak test scenarios: peer churn, reconnect storms, PUB/SUB churn, ROUTER/DEALER churn, HWM reconnect, cancel safety, compression (lz4), PLAIN / CURVE / BLAKE3ZMQ auth, mechanism reconnect, large-message throughput, multi-socket, inproc cross-thread, WebSocket throughput and reconnect. Each scenario samples RSS and FD counts to detect leaks.
• Loom coverage for lock-free inproc queue behavior.
• Miri on yring.
• Strict SemVer because it matters.
• Wire interop with libzmq and pyzmq.

./scripts/test-all.sh             # full sweep
OMQ_FUZZ=1 ./scripts/test-all.sh  # include fuzz suites

• COMPARISONS.md: cross-implementation comparison charts.
• BENCHMARKS_COMPRESSION.md: lz4+tcp throughput on bandwidth-limited links.
• doc/architecture.md: architecture and tokio backend internals.

Linux is the primary platform. All development, testing, and benchmarking happens on Linux. CI is Linux-only for required checks.

macOS should work (omq-tokio via mio / kqueue) but is experimental. The test suite has not been run on macOS recently.

Windows support is substantially complete. omq-tokio fully works with TCP, IPC (named pipes), inproc, UDP, and WebSocket transports. Windows CI is required for merge. Known limitations:

• omq-libzmq is excluded (Unix-only C API surface).
• Some tests are flaky (timer-sensitive assertions).

Requirements:

• Rust 1.93 or newer (edition 2024).

See CONTRIBUTING.md for guidelines and DEVELOPMENT.md for build, test, and benchmark commands.

This project was built with significant LLM assistance throughout: architecture, implementation, tests, benchmark infrastructure, and docs. It's an experiment in what LLM-assisted development can and can't do. The design decisions and direction are mine.

ISC.