What is RobustMQ • Why RobustMQ • Features • Roadmap • Architecture • Quick Start • Documentation • Contributing • Community

⚠️ Development Status RobustMQ is in early development and not yet production-ready. MQTT core is stable and continuing to mature. Kafka, NATS, and AMQP are under active development. Production readiness is targeted for 0.4.0.

RobustMQ is a unified messaging engine built with Rust. One binary, one broker, no external dependencies — deployable from edge devices to cloud clusters. It natively supports MQTT, Kafka, NATS, and AMQP on a shared storage layer: one message written once, consumed by any protocol.

Six core scenarios on one system:

MQTT publish  →  RobustMQ unified storage  →  Kafka consume
                                           →  NATS subscribe
                                           →  AMQP consume

Today's messaging infrastructure is a collection of protocol silos. IoT uses MQTT brokers, data pipelines use Kafka, enterprise systems use RabbitMQ, and AI Agent communication has no native solution. Multiple systems mean duplicate data copies, overlapping operations, and bridging layers that add latency and failure points.

Existing systems carry heavy architectural baggage. Kafka's file-system-based design hits a hard ceiling at tens of thousands of topics. RabbitMQ's Erlang runtime limits throughput headroom. None of these systems were designed for the AI era — retrofitting them is patching old foundations.

RobustMQ is designed from scratch to solve this structurally: unified storage + native multi-protocol support. Not bridging, not routing — one copy of data, each protocol reading it through its own semantic lens. One system replaces multiple brokers. No data duplication, no operational overlap.

• 🦀 Rust-native: No GC, stable and predictable memory footprint, no periodic spikes — consistent from edge devices to cloud clusters
• 🗄️ Unified storage layer: All protocols share one storage engine — data written once, consumed by any protocol, no duplication
• 🔌 Native multi-protocol: MQTT 3.1/3.1.1/5.0, Kafka, NATS, AMQP — natively implemented, full protocol semantics, not emulated
• 🏢 Native multi-tenancy: Unified across all protocols — full data isolation and independent permission management per tenant
• 🌐 Edge-to-cloud: Single binary, zero dependencies, offline buffering with auto-sync — same runtime from edge gateways to cloud clusters
• 🤖 AI Agent communication: NATS-based $AI.API.* extension — native Agent registration, discovery, invocation, and orchestration
• ⚡ Ultra-low-latency dispatch: NATS pure in-memory routing — no disk writes, millisecond to sub-millisecond latency
• 💾 Multi-mode storage: Memory / RocksDB / File, per-topic configuration, automatic cold data tiering to S3
• 🔄 Shared subscription: Break the "concurrency = partition count" limit — consumers scale elastically at any time
• 🛠️ Minimal operations: Single binary, zero external dependencies, built-in Raft consensus, ready out of the box

The approach: slow is smooth, smooth is fast. Each phase done properly before moving on.

Phase 1 — MQTT (current)
  MQTT core production-ready, continuously refined to be the best MQTT Broker available
  Architecture and infrastructure hardened in parallel

Phase 2 — NATS + AI Agent (in progress)
  NATS protocol compatibility + $AI.API.* extension
  Native Agent registration, discovery, invocation, and load balancing

Phase 3 — Kafka (in progress)
  Full Kafka protocol compatibility
  Complete the IoT-to-streaming data path, edge-to-cloud data flow

Phase 4 — AMQP (planned)
  Full AMQP protocol compatibility
  Traditional enterprise messaging migration path

RobustMQ has three components with fixed, clean boundaries:

• Meta Service — metadata management, Raft-based consensus
• Broker — protocol parsing and routing (MQTT / Kafka / NATS / AMQP)
• Storage Engine — unified data storage with pluggable backends

Adding a new protocol means implementing only the Broker parsing layer. Adding a new storage backend means implementing only the Storage Engine interface. The core architecture does not change.

curl -fsSL https://raw.githubusercontent.com/robustmq/robustmq/main/scripts/install.sh | bash
broker-server start

# Publish via MQTT
mqttx pub -h localhost -p 1883 -t "robustmq.multi.protocol" -m "Hello RobustMQ!"

# Consume the same message via Kafka
kafka-console-consumer.sh --bootstrap-server localhost:9092 \
  --topic robustmq.multi.protocol --from-beginning

# Consume the same message via NATS
nats sub "robustmq.multi.protocol"

Access http://localhost:8080 for cluster monitoring and management.

• MQTT Server: 117.72.92.117:1883 (admin/robustmq)
• Web Dashboard: http://demo.robustmq.com:8080

📚 Full installation and usage guide: Documentation

git clone https://github.com/robustmq/robustmq.git
cd robustmq
cargo run --package cmd --bin broker-server

make build           # Basic build
make build-full      # With frontend

📚 Build Guide

• 📖 Official Documentation — Comprehensive guides and API references
• 🚀 Quick Start Guide — Get up and running in minutes
• 🔧 MQTT Documentation — MQTT-specific features and configuration
• 💻 Command Reference — CLI commands and usage
• 🎛️ Web Console — Management interface

We welcome contributions. See our Contribution Guide and Good First Issues.

• 🎮 Discord — Real-time chat and collaboration
• 🐛 GitHub Issues — Bug reports and feature requests
• 💡 GitHub Discussions — General discussions

• 微信群: Join our WeChat group for Chinese-speaking users

  

• 开发者微信: If the group QR code has expired, follow our official WeChat account

  

RobustMQ is licensed under the Apache License 2.0. See LICENSING.md for details.