v0.20.0

Author: paddor

CHANGELOG.md

@@ -1,6 +1,6 @@
 # Changelog
 
-## Unreleased
+## 0.20.0 — 2026-04-14
 
 ### Changed
 

DESIGN.md

@@ -20,7 +20,7 @@ exists to handle the reality that none of this is true:
 | Topology doesn't change | Bind/connect separation; peers come and go freely |
 | There is one administrator | No broker required; any topology works peer-to-peer |
 | Transport cost is zero | Batched writes reduce syscalls; inproc skips the kernel |
-| The network is homogeneous | ZMTP is a wire protocol; interop with libzmq, nanomsg, etc. |
+| The network is homogeneous | ZMTP is a wire protocol; interop with libzmq, pyzmq, CZMQ, zmq.rs |
 
 OMQ brings all of this to Ruby without C extensions or FFI.
 
@@ -163,7 +163,9 @@ so racing pumps can't double-fire side effects.
 
 **Linger.** On close, send queues are drained for up to `linger` seconds.
 If no peers are connected, listeners stay open so late-arriving peers can
-still receive queued messages. `linger=0` closes immediately.
+still receive queued messages. The default is `Float::INFINITY` (matches
+libzmq: wait forever). `linger=0` closes immediately, dropping anything
+still queued.
 
 **Reconnect.** Failed or lost connections are retried with configurable
 interval (default 100ms). Supports exponential backoff via a Range
@@ -248,9 +250,10 @@ Under light load, batch size is 1 -- no overhead. Under burst load (producer
 faster than consumer), the batch grows and flushes are amortized:
 `N_msgs * N_conns` syscalls become `N_conns` per cycle.
 
-io-stream auto-flushes its write buffer at 64 KB, so large batches hit the
-wire naturally during the write loop. The explicit flush at the end only
-pushes the remainder that didn't fill a buffer.
+io-stream auto-flushes its write buffer at 256 KB (its default
+`MINIMUM_WRITE_SIZE`), so large batches hit the wire naturally during
+the write loop. The explicit flush at the end only pushes the remainder
+that didn't fill a buffer.
 
 For fan-out (PUB/RADIO), one published message is written to all matching
 subscribers before flushing -- so N subscribers see 1 flush each, not N

README.md

@@ -1,41 +1,32 @@
-# OMQ — Where did the C dependency go!?
+# ØMQ — ZeroMQ for Ruby, no C required
 
 [![CI](https://github.com/zeromq/omq/actions/workflows/ci.yml/badge.svg)](https://github.com/zeromq/omq/actions/workflows/ci.yml)
 [![Gem Version](https://img.shields.io/gem/v/omq?color=e9573f)](https://rubygems.org/gems/omq)
 [![License: ISC](https://img.shields.io/badge/License-ISC-blue.svg)](LICENSE)
 [![Ruby](https://img.shields.io/badge/Ruby-%3E%3D%203.3-CC342D?logo=ruby&logoColor=white)](https://www.ruby-lang.org)
 
-`gem install omq` — that's it. No libzmq, no compiler, no system packages. Just Ruby.
-
-OMQ builds ZeroMQ socket patterns on top of [protocol-zmtp](https://github.com/paddor/protocol-zmtp) (a pure Ruby [ZMTP 3.1](https://rfc.zeromq.org/spec/23/) codec) using [Async](https://github.com/socketry/async) fibers. It speaks native ZeroMQ on the wire and interoperates with libzmq, pyzmq, CZMQ, and everything else in the ZMQ ecosystem.
-
 > **932k msg/s** inproc | **328k msg/s** ipc | **329k msg/s** tcp
 >
 > **11.5 µs** inproc latency | **54 µs** ipc | **69 µs** tcp
 >
 > Ruby 4.0 + YJIT on a Linux VM — see [`bench/`](bench/) for full results
 
----
-
-## What is ZeroMQ?
-
-Brokerless message-oriented middleware. No central server, no extra hop — processes talk directly to each other, cutting latency in half compared to broker-based systems. You get the patterns you'd normally build on top of RabbitMQ or Redis — pub/sub, work distribution, request/reply, fan-out — but decentralized, with no single point of failure.
-
-Networking is hard. ZeroMQ abstracts away reconnection, queuing, load balancing, and framing so you can focus on what your system actually does. Start with threads talking over `inproc://`, split into processes with `ipc://`, scale across machines with `tcp://` — same code, same API, just change the URL.
+`gem install omq` and you're done. No libzmq, no compiler, no system packages — just Ruby talking to every other ZeroMQ peer out there.
 
-If you've ever wired up services with raw TCP, HTTP polling, or Redis pub/sub and wished it was simpler, this is what you've been looking for.
+ØMQ gives your Ruby processes a way to talk to each other — and to anything else speaking ZeroMQ — without a broker in the middle. Same API whether they live in the same process, on the same machine, or across the network. Reconnects, queuing, and back-pressure are handled for you; you write the interesting part.
 
-See [GETTING_STARTED.md](GETTING_STARTED.md) for a ~30 min walkthrough of all major patterns with working code.
+New to ZeroMQ? Start with [GETTING_STARTED.md](GETTING_STARTED.md) — a ~30 min walkthrough of every major pattern with working code.
 
 ## Highlights
 
 - **Zero dependencies on C** — no extensions, no FFI, no libzmq. `gem install` just works everywhere
-- **Fast** — YJIT-optimized hot paths, batched sends, GC-tuned allocations, buffered I/O via [io-stream](https://github.com/socketry/io-stream), direct-pipe inproc bypass.
-- **[`omq` CLI](https://github.com/paddor/omq-cli)** — `gem install omq-cli` for a command-line tool with Ruby eval, Ractor parallelism, and script handlers
+- **Fast** — YJIT-optimized hot paths, batched sends, GC-tuned allocations, buffered I/O via [io-stream](https://github.com/socketry/io-stream), direct-pipe inproc bypass
+- **[`omq` CLI](https://github.com/paddor/omq-cli)** — a powerful swiss army knife for ØMQ. `gem install omq-cli`
 - **Every socket pattern** — req/rep, pub/sub, push/pull, dealer/router, xpub/xsub, pair, and all draft types
 - **Every transport** — tcp, ipc (Unix domain sockets), inproc (in-process queues)
-- **Async-native** — built on fibers, non-blocking from the ground up. A shared IO thread handles sockets outside of Async — no reactor needed for simple scripts
-- **Wire-compatible** — interoperates with libzmq, pyzmq, CZMQ over tcp and ipc
+- **Async-native** — built on fibers, non-blocking from the ground up
+- **Works outside Async too** — a shared IO thread handles sockets for callers that aren't inside a reactor, so simple scripts just work
+- **Wire-compatible** — interoperates with libzmq, pyzmq, CZMQ, zmq.rs over tcp and ipc
 - **Bind/connect order doesn't matter** — connect before bind, bind before connect, peers come and go. ZeroMQ reconnects automatically and queued messages drain when peers arrive
 
 For architecture internals, see [DESIGN.md](DESIGN.md).
@@ -164,15 +155,15 @@ All sockets are thread-safe. Default HWM is 1000 messages per socket. `max_messa
 
 #### Draft (single-frame only)
 
-These require the `omq-draft` gem.
+Each draft pattern lives in its own gem — install only the ones you use.
 
-| Pattern | Send | Receive | When HWM full |
-|---------|------|---------|---------------|
-| **CLIENT** / **SERVER** | Work-stealing / routing-ID | Fair-queue | Block |
-| **RADIO** / **DISH** | Group fan-out | Group filter | Drop |
-| **SCATTER** / **GATHER** | Work-stealing | Fair-queue | Block |
-| **PEER** | Routing-ID | Fair-queue | Block |
-| **CHANNEL** | Exclusive 1-to-1 | Exclusive 1-to-1 | Block |
+| Pattern | Send | Receive | When HWM full | Gem |
+|---------|------|---------|---------------|-----|
+| **CLIENT** / **SERVER** | Work-stealing / routing-ID | Fair-queue | Block | [`omq-rfc-clientserver`](https://github.com/paddor/omq-rfc-clientserver) |
+| **RADIO** / **DISH** | Group fan-out | Group filter | Drop | [`omq-rfc-radiodish`](https://github.com/paddor/omq-rfc-radiodish) |
+| **SCATTER** / **GATHER** | Work-stealing | Fair-queue | Block | [`omq-rfc-scattergather`](https://github.com/paddor/omq-rfc-scattergather) |
+| **PEER** | Routing-ID | Fair-queue | Block | [`omq-rfc-p2p`](https://github.com/paddor/omq-rfc-p2p) |
+| **CHANNEL** | Exclusive 1-to-1 | Exclusive 1-to-1 | Block | [`omq-rfc-channel`](https://github.com/paddor/omq-rfc-channel) |
 
 ## CLI
 
@@ -192,6 +183,12 @@ See the [omq-cli README](https://github.com/paddor/omq-cli) for full documentati
 - **[omq-ffi](https://github.com/paddor/omq-ffi)** — libzmq FFI backend. Same OMQ socket API, but backed by libzmq instead of the pure Ruby ZMTP stack. Useful for interop testing and when you need libzmq-specific features. Requires libzmq installed.
 - **[omq-ractor](https://github.com/paddor/omq-ractor)** — bridge OMQ sockets into Ruby Ractors for true parallel processing across cores. I/O stays on the main Ractor, worker Ractors do pure computation.
 
+### Protocol extensions (RFCs)
+
+Optional plug-ins that extend the ZMTP wire protocol. Each is a separate gem; load the ones you need.
+
+- **[omq-rfc-zstd](https://github.com/paddor/omq-rfc-zstd)** — transparent Zstandard compression on the wire, negotiated per peer via READY properties.
+
 ## Development
 
 ```sh
@@ -210,16 +207,16 @@ the stack.
 # clone OMQ and its sibling repos into the same parent directory
 git clone https://github.com/paddor/omq.git
 git clone https://github.com/paddor/protocol-zmtp.git
-git clone https://github.com/paddor/nuckle.git
-git clone https://github.com/paddor/omq-rfc-blake3zmq.git
-git clone https://github.com/paddor/omq-rfc-channel.git
+git clone https://github.com/paddor/omq-rfc-zstd.git
 git clone https://github.com/paddor/omq-rfc-clientserver.git
-git clone https://github.com/paddor/omq-rfc-p2p.git
-git clone https://github.com/paddor/omq-rfc-qos.git
 git clone https://github.com/paddor/omq-rfc-radiodish.git
 git clone https://github.com/paddor/omq-rfc-scattergather.git
+git clone https://github.com/paddor/omq-rfc-channel.git
+git clone https://github.com/paddor/omq-rfc-p2p.git
+git clone https://github.com/paddor/omq-rfc-qos.git
 git clone https://github.com/paddor/omq-ffi.git
 git clone https://github.com/paddor/omq-ractor.git
+git clone https://github.com/paddor/nuckle.git
 
 cd omq
 OMQ_DEV=1 bundle install

lib/omq/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module OMQ
-  VERSION = "0.19.3"
+  VERSION = "0.20.0"
 end