Koder MQ - Fast, Durable, Multi-Protocol Message Queue

Everything You Need

Combines the best features from Kafka, RabbitMQ, NATS, Pulsar, and Redis Streams

Named Queues

Persistent FIFO queues with WAL storage, configurable ack timeout, visibility timeout, and automatic dead letter routing.

Topics & Partitions

Pub/sub with partitioned streams, key-based ordering, multiple subscription modes (shared, exclusive, failover, key-shared).

Consumer Groups

Automatic partition assignment with range, round-robin, and sticky rebalancing. Heartbeat monitoring and session timeouts.

Priority Queues

10 priority levels (0-9) with weighted fair scheduling or strict priority mode. Per-level sub-queues for isolation.

Delayed & Scheduled

Timing wheel scheduler for delayed messages up to 7 days. Cron-like recurring schedules with cancel support.

Dead Letter Queues

Automatic DLQ routing after max retries. Inspect, replay, and purge operations. Reason tracking and breakdown.

Transactions

Multi-queue atomic publish with begin/commit/rollback. Ensures all-or-nothing delivery across destinations.

Replay & Seek

Rewind to any timestamp or offset. Seek to earliest, latest, or specific position. Time index for fast lookups.

Schema Registry

JSON Schema, Avro, Protobuf validation. Backward/forward/full compatibility checks. Auto-register on publish.

Stream Processing

Built-in map, filter, aggregate, windowing (tumbling, sliding, session). Stateful processing with checkpointing.

Connectors

Source and sink connectors for PostgreSQL, HTTP webhooks, and files. Batch processing with retry and error handling.

Metrics & Dashboard

Prometheus metrics with per-queue, per-topic, per-consumer granularity. Built-in admin dashboard web UI.

Simple, Powerful API

Get started in seconds with any protocol

REST API

Publish and consume messages with simple HTTP requests. No client library needed.

Create queues and topics
Publish with key, priority, delay
Batch consume with auto-ack
WebSocket for real-time

REST API
# Create a queue
curl -X POST http://localhost:9401/api/v1/queues \
  -H "Content-Type: application/json" \
  -d '{"name": "orders"}'

# Publish a message
curl -X POST http://localhost:9401/api/v1/queues/orders/messages \
  -H "Content-Type: application/json" \
  -d '{
    "body": "{\"id\":1,\"item\":\"laptop\"}",
    "key": "order-1",
    "priority": 5
  }'

# Consume messages
curl -X POST http://localhost:9401/api/v1/queues/orders/consume \
  -H "Content-Type: application/json" \
  -d '{"max_count": 10, "auto_ack": true}'

Koder Lang
require "koder-mq"

# Start broker
app = KoderMQ::App.new

# Create resources
broker = app.broker
broker.create_queue("orders")
broker.create_topic("events", num_partitions: 8)

# Publish to queue
msg = KoderMQ::Message.new(
  body: '{"order_id": 42}',
  key: "order-42",
  priority: 5
)
broker.get_queue("orders").publish(msg)

# Consume from queue
result = broker.get_queue("orders").consume(
  consumer_id: "worker-1",
  auto_ack: false
)
message, token = result
puts message.body
broker.get_queue("orders").ack(message.id)

# Pub/sub on topics
topic = broker.get_topic("events")
sub = topic.subscribe(
  name: "analytics",
  mode: :shared,
  from: :earliest
)

# Stream processing
processor = KoderMQ::Stream::Processor.new(
  name: "order-count",
  source: "events",
  broker: broker
)
processor
  .filter { |msg| msg.headers["type"] == "order" }
  .group_by { |msg| msg.key }
  .count
  .to("order-counts")
  .start

Koder Lang SDK

Full programmatic control with the native Koder Lang client. Type-safe, zero-copy, maximum performance.

Queue and topic management
Producer with batching and transactions
Consumer with prefetch and flow control
Built-in stream processing DSL
Consumer groups with auto-rebalance

How Koder MQ Compares

One binary that replaces your entire messaging stack

Feature	Koder MQ	Kafka	RabbitMQ	NATS	Pulsar	Redis Streams
Named Queues	Yes	No	Yes	Yes	Yes	No
Partitioned Topics	Yes	Yes	No	Yes	Yes	No
Consumer Groups	Yes	Yes	No	Yes	Yes	Yes
Priority Queues	10 levels	No	255	No	No	No
Delayed Messages	Yes	No	Plugin	No	Yes	No
Dead Letter Queue	Auto	No	Yes	No	Yes	No
Transactions	Yes	Yes	Yes	No	Yes	Yes
Schema Registry	Built-in	Separate	No	No	Built-in	No
Stream Processing	Built-in	Streams	No	No	Functions	No
AMQP	0.9.1	No	0.9.1	No	No	No
MQTT	5.0	No	Plugin	Yes	No	No
HTTP/REST	Yes	Proxy	Plugin	Yes	Yes	No
gRPC	Yes	No	No	No	Yes	No
WebSocket	Yes	No	Plugin	Yes	Yes	No
Single Binary	Yes	JVM	Erlang	Yes	JVM	Yes
No External Deps	Yes	ZK/KRaft	Yes	Yes	ZK/BK	Yes

Powerful CLI

Manage everything from the command line

$ kmq serve

Start the message broker with all protocols

$ kmq queues list

List all queues with depth and consumer count

$ kmq queues create --name orders

Create a new persistent queue

$ kmq topics create --name events --partitions 8

Create a topic with 8 partitions

$ kmq produce --name orders --body '{"id":1}'

Publish a message to a queue

$ kmq consume --name orders --count 10

Consume up to 10 messages from a queue

$ kmq stats

Show broker statistics and resource usage

$ kmq config

Print current configuration

Every message delivered.
No matter what.