omq 0.27.0 → 0.28.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 304adcf07ab3967251a821578bb96376b7c080e2a4d0d16430768ba6855b3557
-  data.tar.gz: 26babe478d3f2f07f8d011b2484083bc1c327a9938eaae0ab199bcdc560eaf55
+  metadata.gz: ec6bb2de8ced07ba0d20f272256c2d163bb2e192f01c292b6d8431c792c4a289
+  data.tar.gz: 662ee0364dd2e6ac7ba28822cfc08d5746bcd3cdf862c41ed48a33472b254bce
 SHA512:
-  metadata.gz: 873f2817de7d8fb063da6b425982493012b4eff08b3035cf86fbce948e3398de34ca319713dc4b1f56e4556250a82b23510a304e5f3a503aa01b367c5e6c6379
-  data.tar.gz: 18df1029acefe76806a1e188e077aad0023ec52a5ae63b31aac09fbe450aec68c4c4688b88b8ae77c19669a30f53c418b65f9a728eb377562a5c74da34e1a8fd
+  metadata.gz: 82b84f4c8e9e4b54d7ec7a4f9d9beca5dc0666a9491220e84c47a8956f6c275ea2172d9dfb509e0f7dcfd16d6a9429dd902703ffbacfc7c28a5b03939818059a
+  data.tar.gz: 26628cfdddb28d49bfbc47e4d7bb8cb9878f0e283f64c8669dd622db713f3fdbceac4776e184fd87cd6c691d92ebc729ead807bcf5e6a3a8e9338a31496e05d9

data/CHANGELOG.md

@@ -1,5 +1,44 @@
 # Changelog
 
+## [Unreleased]
+
+## 0.28.1 - 2026-07-23
+
+### Changed
+
+- Consolidated optional OMQ gems into this repository under `gems/`.
+- Consolidated `protocol-zmtp` into this repository under
+  `gems/protocol-zmtp`.
+- Moved the libzmq backend out of the `omq` gem and into
+  `omq-backend-libzmq`. The old `require "omq/ffi"` and `backend: :ffi`
+  names still work when the backend gem is installed.
+- Release CI now publishes packages from prefixed tags such as
+  `omq-v0.28.0`, `omq-lz4-v0.3.1`, and
+  `omq-backend-rust-v0.1.0`.
+- Removed `omq-blake3zmq` from the development dependency set.
+- Bumped the `protocol-zmtp` dependency requirement to `~> 0.10`.
+
+## 0.28.0 — 2026-07-04
+
+### Changed
+
+- **Ruby in-process transport renamed from `inproc://` to `ruby://`.**
+  The `inproc://` scheme is now reserved for native backends (FFI/libzmq,
+  Rust/omq-tokio) which maintain their own in-process registries.
+  All existing `inproc://` endpoints must be updated to `ruby://`.
+
+### Added
+
+- **`:rust` backend branch in `Socket#init_engine`.** Sockets can now be
+  created with `backend: :rust` to use the Rust/omq-tokio engine
+  (requires `omq-rust` and the native extension).
+- **Cross-backend benchmarks and chart generation.** New bench scripts
+  (`bench_pushpull.rb`, `bench_reqrep.rb`, `bench_pubsub.rb`,
+  `bench_peer.rb`) compare pure Ruby, FFI, and Rust backends.
+  `bench/chart_helper.rb` generates SVG comparison charts.
+- **Soak test.** `test/omq/soak_test.rb` exercises sustained throughput
+  across backends and patterns.
+
 ## 0.27.0 — 2026-04-20
 
 ### Added
@@ -1320,7 +1359,7 @@ Combined effect of caller-owns-data + Reactor fast path on inproc:
 - **Protocol layer extracted into protocol-zmtp gem** — Codec (Frame,
   Greeting, Command), Connection, Mechanism::Null, Mechanism::Curve,
   ValidPeers, and Z85 now live in the
-  [protocol-zmtp](https://github.com/paddor/protocol-zmtp) gem. OMQ
+  [protocol-zmtp](gems/protocol-zmtp) gem. OMQ
   re-exports them under `OMQ::ZMTP::` for backwards compatibility.
   protocol-zmtp has zero runtime dependencies.
 - **Unified CURVE mechanism** — one implementation with a pluggable
@@ -1834,4 +1873,4 @@ Initial release. Pure Ruby implementation of ZMTP 3.1 (ZeroMQ) using Async.
 - Linger on close (drain send queue before closing)
 - `max_message_size` enforcement
 - Works inside Async reactors or standalone (shared IO thread)
-- Optional CURVE encryption via the [protocol-zmtp](https://github.com/paddor/protocol-zmtp) gem
+- Optional CURVE encryption via the [protocol-zmtp](gems/protocol-zmtp) gem

data/README.md

@@ -1,6 +1,6 @@
-# ØMQ — ZeroMQ for Ruby, no C required
+# ØMQ.rb
 
-[![CI](https://github.com/zeromq/omq/actions/workflows/ci.yml/badge.svg)](https://github.com/zeromq/omq/actions/workflows/ci.yml)
+[![CI](https://github.com/zeromq/omq.rb/actions/workflows/ci.yml/badge.svg)](https://github.com/zeromq/omq.rb/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)
@@ -9,47 +9,48 @@
 >
 > **8.7 µs** inproc latency | **51 µs** ipc | **64 µs** tcp
 >
-> Ruby 4.0 + YJIT on a Linux VM — see [`bench/`](bench/) for full results
+> Ruby 4.0 + YJIT on a Linux VM. See [`bench/`](bench/) for full results
 
-`gem install omq` and you're done. No libzmq, no compiler, no system packages —
+`gem install omq` and you're done. No libzmq, no compiler, no system packages,
 just Ruby talking to every other ZeroMQ peer out there.
 
-Ø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
+Ø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
+Reconnects, queuing, and back-pressure are handled for you. You write the
 interesting part.
 
-New to ZeroMQ? Start with [GETTING_STARTED.md](doc/GETTING_STARTED.md) — a ~30 min
+New to ZeroMQ? Start with [GETTING_STARTED.md](doc/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`
+- **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,
+- **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
+- **[`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,
+- **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
+- **Every transport**: tcp, ipc (Unix domain sockets), inproc (in-process
   queues)
-- **Async-native** — built on fibers, non-blocking from the ground up
-- **Works outside Async too** — a shared IO thread handles sockets for callers
+- **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
+- **Wire-compatible**: interoperates with libzmq, pyzmq, CZMQ, zmq.rs over tcp
   and ipc
-- **Bind/connect order doesn't matter** — connect before bind, bind before
+- **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](doc/DESIGN.md).
+If you're interested in the steps taken to reach the current performance, read [PERFORMANCE.md](doc/PERFORMANCE.md).
 
 ## Install
 
-No system libraries needed — just Ruby:
+No system libraries needed. Just Ruby:
 
 ```sh
 gem install omq
@@ -115,7 +116,7 @@ end
 
 ### Without Async (IO thread)
 
-OMQ spawns a shared `omq-io` thread when used outside an Async reactor — no
+OMQ spawns a shared `omq-io` thread when used outside an Async reactor. No
 boilerplate needed:
 
 ```ruby
@@ -143,7 +144,7 @@ All sockets expose an `Async::Queue`-inspired interface:
 | `enqueue(item)` / `push(item)` | `enqueue(msg)` / `push(msg)` | Also: `send(msg)`, `<< msg` |
 | `dequeue(timeout:)` / `pop(timeout:)` | `dequeue(timeout:)` / `pop(timeout:)` | Defaults to socket's `read_timeout` |
 | `wait` | `wait` | Blocks indefinitely (ignores `read_timeout`) |
-| `each` | `each` | Yields messages; returns on close or timeout |
+| `each` | `each` | Yields messages, returns on close or timeout |
 
 ```ruby
 pull = OMQ::PULL.bind('inproc://work')
@@ -157,13 +158,13 @@ end
 ## Socket Types
 
 All sockets are thread-safe. Default HWM is 1000 messages per socket.
-`max_message_size` defaults to **`nil` (unlimited)** — set
-`socket.max_message_size = N` to cap inbound frames at `N` bytes; oversized
+`max_message_size` defaults to **`nil` (unlimited)**. Set
+`socket.max_message_size = N` to cap inbound frames at `N` bytes. Oversized
 frames cause the connection to be dropped before the body is read from the
 wire. Classes live under `OMQ::` (alias: `ØMQ`).
 
 **Received messages are frozen** across all transports (inproc, ipc, tcp).
-The array returned by `#receive` and every part inside it is frozen —
+The array returned by `#receive` and every part inside it is frozen.
 mutating a received part raises `FrozenError` rather than silently
 corrupting a shared reference on the inproc fast path. `dup` a part if
 you need to mutate it.
@@ -187,7 +188,7 @@ you need to mutate it.
 
 #### Draft (single-frame only)
 
-Bundled with `omq` but not loaded by `require "omq"` — opt in with the matching
+Bundled with `omq` but not loaded by `require "omq"`. Opt in with the matching
 `require` line. See [`doc/socket-types/`](doc/socket-types/) for per-pattern
 usage.
 
@@ -215,32 +216,54 @@ See the [omq-cli README](https://github.com/paddor/omq-cli) for full documentati
 
 ## Optional libzmq backend
 
-OMQ ships with an optional libzmq FFI backend. Same socket API, but
-backed by libzmq instead of the pure Ruby ZMTP stack. Useful when you
-need libzmq-specific features or for verifying wire compatibility.
+Install `omq-backend-libzmq` for a Ruby 4.0+ libzmq backend. Same socket
+API, but backed by libzmq instead of the pure Ruby ZMTP stack. Useful
+when you need libzmq-specific features or for verifying wire
+compatibility.
 
 ```ruby
-require "omq/ffi"
-push = OMQ::PUSH.new(backend: :ffi)
+require "omq/backend/libzmq"
+push = OMQ::PUSH.new(backend: :libzmq)
 ```
 
 Requires the `ffi` gem and a system libzmq 4.x. `ffi` is not a runtime
-dependency of `omq` — install it explicitly (`gem install ffi`) if you
-want the `:ffi` backend.
+dependency of `omq`. The old `require "omq/ffi"` and `backend: :ffi`
+names still work.
 
 ## Companion Gems
 
-- **[omq-ractor](https://github.com/paddor/omq-ractor)** — bridge OMQ sockets
+- **[protocol-zmtp](gems/protocol-zmtp)**: ZMTP 3.1 frame codec,
+  greeting, security mechanisms, and connection handshake. It lives in
+  this monorepo because `omq` uses it as its wire-protocol module. Most
+  users never require it directly.
+- **[omq-ractor](gems/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.
 
+### Compressed transports
+
+Drop-in TCP replacements that compress every message part on the wire. Both
+peers must use the same scheme. A `tcp://` peer cannot talk to a
+compressed peer. The ZMTP handshake itself runs over plain TCP. Only
+post-handshake message parts are compressed.
+
+- **[omq-lz4](gems/omq-lz4)**: `lz4+tcp://`.
+  LZ4 per-part compression with user dictionaries and `auto_dict:`
+  training from early traffic. Use for new compressed TCP work.
+- **[omq-zstd](gems/omq-zstd)**: experimental `zstd+tcp://`.
+  Zstandard per-part compression kept for research and comparison. Prefer
+  `omq-lz4` for new compressed TCP work. OMQ.rs removed `zstd+tcp://`
+  to reduce transport complexity after lz4rip gained dictionary training.
+
 ### Protocol extensions (RFCs)
 
-Optional plug-ins that extend the ZMTP wire protocol. Each is a separate gem;
+Optional plug-ins that extend the ZMTP wire protocol. Each is a separate gem.
 load the ones you need.
 
-- **[omq-zstd](https://github.com/paddor/omq-zstd)** — transparent
-  Zstandard compression on the wire, negotiated per peer via READY properties.
+- **[omq-qos](gems/omq-qos)**: experimental MQTT-style at-least-once
+  delivery. Receivers send an ACK command frame keyed by xxHash digest.
+  unacked messages re-enqueue to the next peer on disconnect. PUSH/PULL,
+  SCATTER/GATHER, REQ/REP only. Fan-out patterns are out of scope.
 
 ## Development
 
@@ -252,17 +275,16 @@ bundle exec rake
 ### Full development setup
 
 Set `OMQ_DEV=1` to tell Bundler to load sibling projects from source
-(protocol-zmtp, omq-zstd ,nuckle, etc.) instead of released gems.
-This is required for running benchmarks and for testing changes across
-the stack.
+(nuckle, lz4rip, zrip, etc.) instead of released gems. `protocol-zmtp`
+already lives in `gems/protocol-zmtp`. This is required for running
+benchmarks and for testing changes across the stack.
 
 ```sh
 # 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/omq-zstd.git
-git clone https://github.com/paddor/omq-ractor.git
+git clone https://github.com/zeromq/omq.rb.git omq
 git clone https://github.com/paddor/nuckle.git
+git clone https://github.com/paddor/lz4rip-rb.git lz4rip
+git clone https://github.com/paddor/zrip-rb.git zrip
 
 cd omq
 OMQ_DEV=1 bundle install

data/lib/omq/backend.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module OMQ
+  module Backend
+    @engines = {}
+
+    class << self
+      def register(name, engine_class)
+        @engines[name.to_sym] = engine_class
+      end
+
+
+      def fetch(name)
+        @engines[name.to_sym]
+      end
+
+
+      def registered?(name)
+        @engines.key?(name.to_sym)
+      end
+    end
+  end
+end

data/lib/omq/engine.rb

@@ -166,7 +166,7 @@ module OMQ
     end
 
 
-    # Spawns an inproc reconnect retry task under the socket's parent task.
+    # Spawns a ruby:// reconnect retry task under the socket's parent task.
     #
     # @param endpoint [String]
     # @yield [interval] the retry loop body
@@ -185,7 +185,7 @@ module OMQ
 
     # Binds to an endpoint.
     #
-    # @param endpoint [String] e.g. "tcp://127.0.0.1:5555", "inproc://foo"
+    # @param endpoint [String] e.g. "tcp://127.0.0.1:5555", "ruby://foo"
     # @return [URI::Generic] resolved endpoint URI (with auto-selected port for "tcp://host:0")
     # @raise [ArgumentError] on unsupported transport
     #
@@ -216,11 +216,11 @@ module OMQ
       capture_parent_task(parent: parent)
       validate_endpoint!(endpoint)
 
-      if endpoint.start_with?("inproc://")
-        # Inproc connect is synchronous and instant — no Dialer
+      if endpoint.start_with?("ruby://")
+        # Ruby in-process connect is synchronous and instant — no Dialer
         transport = transport_for(endpoint)
         transport.connect(endpoint, self, **opts)
-        @dialers[endpoint] = :inproc  # sentinel for reconnect intent
+        @dialers[endpoint] = :ruby  # sentinel for reconnect intent
       else
         transport = transport_for(endpoint)
         @dialers[endpoint] = transport.dialer(endpoint, self, **opts)
@@ -603,7 +603,7 @@ module OMQ
 
     # Looks up the transport module for an endpoint URI.
     #
-    # @param endpoint [String] endpoint URI (e.g. "tcp://...", "inproc://...")
+    # @param endpoint [String] endpoint URI (e.g. "tcp://...", "ruby://...")
     # @return [Module] the transport module
     # @raise [ArgumentError] if the scheme is not registered
     #

data/lib/omq/pair.rb

@@ -13,7 +13,7 @@ module OMQ
     # @param recv_hwm [Integer, nil] receive high water mark (nil uses default)
     # @param send_timeout [Numeric, nil] send timeout in seconds
     # @param recv_timeout [Numeric, nil] receive timeout in seconds
-    # @param backend [Symbol, nil] :ruby (default) or :ffi
+    # @param backend [Symbol, nil] registered backend name (:ruby by default)
     #
     def initialize(endpoints = nil, linger: Float::INFINITY,
                    send_hwm: nil, recv_hwm: nil,

data/lib/omq/pub_sub.rb

@@ -12,7 +12,7 @@ module OMQ
     # @param send_timeout [Numeric, nil] send timeout in seconds
     # @param on_mute [Symbol] mute strategy for slow subscribers
     # @param conflate [Boolean] keep only latest message per topic
-    # @param backend [Symbol, nil] :ruby (default) or :ffi
+    # @param backend [Symbol, nil] registered backend name (:ruby by default)
     #
     def initialize(endpoints = nil, linger: Float::INFINITY,
                    send_hwm: nil, send_timeout: nil,
@@ -43,7 +43,7 @@ module OMQ
     # @param subscribe [String, nil] subscription prefix; +nil+ (default)
     #   means no subscription — call {#subscribe} explicitly.
     # @param on_mute [Symbol] :block (default), :drop_newest, or :drop_oldest
-    # @param backend [Symbol, nil] :ruby (default) or :ffi
+    # @param backend [Symbol, nil] registered backend name (:ruby by default)
     #
     def initialize(endpoints = nil, recv_hwm: nil, recv_timeout: nil,
                    subscribe: nil, on_mute: :block, backend: nil, &block)
@@ -90,7 +90,7 @@ module OMQ
     # @param send_timeout [Numeric, nil] send timeout in seconds
     # @param recv_timeout [Numeric, nil] receive timeout in seconds
     # @param on_mute [Symbol] mute strategy for slow subscribers
-    # @param backend [Symbol, nil] :ruby (default) or :ffi
+    # @param backend [Symbol, nil] registered backend name (:ruby by default)
     #
     def initialize(endpoints = nil, linger: Float::INFINITY,
                    send_hwm: nil, recv_hwm: nil,
@@ -122,7 +122,7 @@ module OMQ
     # @param subscribe [String, nil] subscription prefix; +nil+ (default)
     #   means no subscription — send a subscribe frame explicitly.
     # @param on_mute [Symbol] mute strategy (:block, :drop_newest, :drop_oldest)
-    # @param backend [Symbol, nil] :ruby (default) or :ffi
+    # @param backend [Symbol, nil] registered backend name (:ruby by default)
     #
     def initialize(endpoints = nil, linger: Float::INFINITY,
                    send_hwm: nil, recv_hwm: nil,

data/lib/omq/push_pull.rb

@@ -10,7 +10,7 @@ module OMQ
     # @param linger [Numeric] linger period in seconds (Float::INFINITY = wait forever, 0 = drop)
     # @param send_hwm [Integer, nil] send high water mark (nil uses default)
     # @param send_timeout [Numeric, nil] send timeout in seconds
-    # @param backend [Symbol, nil] :ruby (default) or :ffi
+    # @param backend [Symbol, nil] registered backend name (:ruby by default)
     #
     def initialize(endpoints = nil, linger: Float::INFINITY, send_hwm: nil, send_timeout: nil, backend: nil, &block)
       init_engine(:PUSH, send_hwm: send_hwm, send_timeout: send_timeout, backend: backend)
@@ -30,7 +30,7 @@ module OMQ
     # @param endpoints [String, nil] endpoint to bind/connect
     # @param recv_hwm [Integer, nil] receive high water mark (nil uses default)
     # @param recv_timeout [Numeric, nil] receive timeout in seconds
-    # @param backend [Symbol, nil] :ruby (default) or :ffi
+    # @param backend [Symbol, nil] registered backend name (:ruby by default)
     #
     def initialize(endpoints = nil, recv_hwm: nil, recv_timeout: nil, backend: nil, &block)
       init_engine(:PULL, recv_hwm: recv_hwm, recv_timeout: recv_timeout, backend: backend)

data/lib/omq/req_rep.rb

@@ -13,7 +13,7 @@ module OMQ
     # @param recv_hwm [Integer, nil] receive high water mark
     # @param send_timeout [Numeric, nil] send timeout in seconds
     # @param recv_timeout [Numeric, nil] receive timeout in seconds
-    # @param backend [Symbol, nil] :ruby (default) or :ffi
+    # @param backend [Symbol, nil] registered backend name (:ruby by default)
     #
     def initialize(endpoints = nil, linger: Float::INFINITY,
                    send_hwm: nil, recv_hwm: nil,
@@ -42,7 +42,7 @@ module OMQ
     # @param recv_hwm [Integer, nil] receive high water mark
     # @param send_timeout [Numeric, nil] send timeout in seconds
     # @param recv_timeout [Numeric, nil] receive timeout in seconds
-    # @param backend [Symbol, nil] :ruby (default) or :ffi
+    # @param backend [Symbol, nil] registered backend name (:ruby by default)
     #
     def initialize(endpoints = nil, linger: Float::INFINITY,
                    send_hwm: nil, recv_hwm: nil,

data/lib/omq/router_dealer.rb

@@ -13,7 +13,7 @@ module OMQ
     # @param recv_hwm [Integer, nil] receive high water mark
     # @param send_timeout [Numeric, nil] send timeout in seconds
     # @param recv_timeout [Numeric, nil] receive timeout in seconds
-    # @param backend [Symbol, nil] :ruby (default) or :ffi
+    # @param backend [Symbol, nil] registered backend name (:ruby by default)
     #
     def initialize(endpoints = nil, linger: Float::INFINITY,
                    send_hwm: nil, recv_hwm: nil,
@@ -42,7 +42,7 @@ module OMQ
     # @param recv_hwm [Integer, nil] receive high water mark
     # @param send_timeout [Numeric, nil] send timeout in seconds
     # @param recv_timeout [Numeric, nil] receive timeout in seconds
-    # @param backend [Symbol, nil] :ruby (default) or :ffi
+    # @param backend [Symbol, nil] registered backend name (:ruby by default)
     #
     def initialize(endpoints = nil, linger: Float::INFINITY,
                    send_hwm: nil, recv_hwm: nil,

data/lib/omq/routing/fan_out.rb

@@ -177,12 +177,13 @@ module OMQ
       #
       def start_conn_send_pump_normal(conn, q, use_wire)
         @engine.spawn_conn_pump_task(conn, annotation: "send pump") do
-          batch = []
+          batch     = []
+          aux_batch = []
 
           loop do
             Routing.dequeue_batch(q, batch)
 
-            if write_matching_batch(conn, batch, use_wire)
+            if write_matching_batch(conn, batch, use_wire, aux_batch)
               conn.flush
               batch.each { |parts| @engine.emit_verbose_msg_sent(conn, parts) }
             end
@@ -197,22 +198,50 @@ module OMQ
       #
       # @return [Boolean] true iff at least one message was written
       #
-      def write_matching_batch(conn, batch, use_wire)
-        sent = false
+      def write_matching_batch(conn, batch, use_wire, aux_batch)
+        if use_wire
+          write_matching_batch_wire(conn, batch, aux_batch)
+        else
+          write_matching_batch_framed(conn, batch, aux_batch)
+        end
+      end
+
 
+      def write_matching_batch_wire(conn, batch, wire_batch)
         batch.each do |parts|
           next unless subscribed?(conn, parts.first || EMPTY_BINARY)
+          wire_batch << Protocol::ZMTP::Codec::Frame.encode_message(parts)
+        end
 
-          if use_wire
-            conn.write_wire(Protocol::ZMTP::Codec::Frame.encode_message(parts))
-          else
-            conn.write_message(parts)
-          end
+        return false if wire_batch.empty?
+
+        if wire_batch.size == 1
+          conn.write_wire(wire_batch.first)
+        else
+          conn.write_wire_batch(wire_batch)
+        end
 
-          sent = true
+        wire_batch.clear
+        true
+      end
+
+
+      def write_matching_batch_framed(conn, batch, msg_batch)
+        batch.each do |parts|
+          next unless subscribed?(conn, parts.first || EMPTY_BINARY)
+          msg_batch << parts
+        end
+
+        return false if msg_batch.empty?
+
+        if msg_batch.size == 1
+          conn.write_message(msg_batch.first)
+        else
+          conn.write_messages(msg_batch)
         end
 
-        sent
+        msg_batch.clear
+        true
       end
 
 

data/lib/omq/socket.rb

@@ -314,21 +314,31 @@ module OMQ
       @options.recv_timeout = recv_timeout if recv_timeout
       @options.conflate     = conflate
       @options.on_mute      = on_mute      if on_mute
-      @engine = case backend
-      when nil, :ruby
-        Engine.new(socket_type, @options)
-      when :ffi
-        require "omq/ffi" unless defined?(FFI::Engine)
-        FFI::Engine.new(socket_type, @options)
-      else
-        raise ArgumentError, "unknown backend: #{backend}"
-      end
+      backend_name = (backend || :ruby).to_sym
+      require_backend(backend_name) unless Backend.registered?(backend_name)
+
+      engine_class = Backend.fetch(backend_name)
+      raise ArgumentError, "unknown backend: #{backend}" unless engine_class
+
+      @engine = engine_class.new(socket_type, @options)
     end
 
 
     private
 
 
+    def require_backend(name)
+      path = case name
+             when :libzmq then "omq/backend/libzmq"
+             when :ffi then "omq/ffi"
+             when :rust then "omq/rust"
+             end
+      return unless path
+
+      require path
+    end
+
+
     # Sets the engine's parent task before the first bind or connect.
     # Must be called OUTSIDE Reactor.run so that non-Async callers
     # get the IO thread's root task, not an ephemeral work task.

data/lib/omq/transport/inproc.rb

@@ -6,16 +6,18 @@ require_relative "inproc/pipe"
 
 module OMQ
   module Transport
-    # In-process transport.
+    # Ruby in-process transport (ruby:// scheme).
     #
-    # Both peers are Ruby backend sockets in the same process (native
-    # ZMQ's inproc registry is separate and unreachable). Messages are
-    # transferred as Ruby arrays — no ZMTP framing, no byte
+    # Both peers are Ruby backend sockets in the same process. Messages
+    # are transferred as Ruby arrays — no ZMTP framing, no byte
     # serialization. Parts are already frozen by Writable#send, so the
     # receiver sees the same immutable contract as ZMTP transports.
     #
+    # The inproc:// scheme is reserved for native backends (FFI/libzmq,
+    # Rust/omq-tokio) which have their own in-process registries.
+    #
     module Inproc
-      Engine.transports["inproc"] = self
+      Engine.transports["ruby"] = self
 
 
       # Socket types that exchange commands (SUBSCRIBE/CANCEL) over inproc.
@@ -38,7 +40,7 @@ module OMQ
 
         # Creates a bound inproc listener.
         #
-        # @param endpoint [String] e.g. "inproc://my-endpoint"
+        # @param endpoint [String] e.g. "ruby://my-endpoint"
         # @param engine [Engine] the owning engine
         # @return [Listener]
         # @raise [ArgumentError] if endpoint is already bound
@@ -61,7 +63,7 @@ module OMQ
 
         # Connects to a bound inproc endpoint.
         #
-        # @param endpoint [String] e.g. "inproc://my-endpoint"
+        # @param endpoint [String] e.g. "ruby://my-endpoint"
         # @param engine [Engine] the connecting engine
         # @return [void]
         #

data/lib/omq/version.rb

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

data/lib/omq.rb

@@ -7,6 +7,7 @@ require "io/stream"
 # Core
 require_relative "omq/version"
 require_relative "omq/constants"
+require_relative "omq/backend"
 require_relative "omq/reactor"
 require_relative "omq/options"
 require_relative "omq/routing"
@@ -24,6 +25,7 @@ require_relative "omq/routing/xsub"
 require_relative "omq/routing/push"
 require_relative "omq/routing/pull"
 require_relative "omq/engine"
+OMQ::Backend.register(:ruby, OMQ::Engine)
 
 # Transport
 require_relative "omq/transport/inproc"