For a lightweight message broker for event-driven systems, the first results are nats-io/nats-server, centrifugal/centrifugo and binwiederhier/ntfy (ntfy is a self-hosted, topic-based pub/sub messaging server using HTTP, offering simple setup and low resource usage, which fits your need for lightweight service communication, though it specializes in notifications and lacks multi-protocol support). nsqio/nsq and emqx/emqx round out the shortlist. Compare the match explanations and check the project documentation against your requirements.
Discover simple, easy-to-deploy messaging brokers and pub-sub libraries for building event-driven distributed software architectures.
NATS Server is a high-performance, lightweight messaging system designed for cloud-native applications, edge computing, and distributed microservices. It functions as a distributed publish-subscribe broker that routes messages using hierarchical, dot-separated subject strings, enabling decoupled communication between services without requiring centralized broker lookups. The system supports core messaging patterns including asynchronous publish-subscribe, request-reply, and load-balanced queue processing. The platform distinguishes itself through a decentralized architecture that eliminates t
NATS Server is a lightweight, high-performance publish-subscribe broker that is trivially easy to set up (single binary), supports core pub/sub along with request-reply and queue groups, offers optional persistence via JetStream, and provides client libraries for many languages—exactly the kind of simple, low‑resource messaging system this query targets.
Centrifugo is a self-hosted real-time messaging server that provides infrastructure for scalable notifications, a publish-subscribe message broker, and a language-agnostic WebSocket gateway. It allows for the delivery of instant messages and data streams to concurrent users via WebSockets and Server-Sent Events. The system functions as a communication layer that separates network transport from backend business logic. It supports distributed messaging clusters using Redis for coordination of presence and message delivery across multiple server nodes. The project covers channel subscription m
Centrifugo is a self-hosted pub/sub message broker that supports multiple transport protocols (WebSocket, SSE, gRPC) and is easy to set up with a single binary, but its focus on real-time notifications and scalable clustering may make it heavier than what you'd choose for simple service-to-service communication.
ntfy is a self-hosted messaging infrastructure that provides a lightweight platform for sending and receiving real-time notifications. It functions as a topic-based pub-sub server, allowing users to publish and subscribe to message channels using standard HTTP requests. By bridging server-side events with native mobile and desktop clients, it enables the delivery of alerts across various environments through a unified communication layer. The project distinguishes itself by offering a complete, private notification ecosystem that includes persistent message caching and robust access control.
ntfy is a self-hosted, topic-based pub/sub messaging server using HTTP, offering simple setup and low resource usage, which fits your need for lightweight service communication, though it specializes in notifications and lacks multi-protocol support.
NSQ is a distributed, brokerless messaging platform designed for high-throughput, fault-tolerant communication. By utilizing a decentralized topology, it eliminates single points of failure and allows for horizontal scaling across clusters. The system organizes message streams into topics and channels, effectively decoupling producers from consumers to support both streaming and job-oriented workloads. The platform distinguishes itself through a lookup-service-based discovery mechanism that enables clients to dynamically locate producers at runtime without requiring centralized coordination.
NSQ is a pub/sub messaging platform that decouples producers and consumers, but its distributed architecture and emphasis on high throughput make it heavier and more involved to set up than a simple lightweight broker for straightforward service-to-service communication.
This project is a high-performance MQTT broker and IoT data platform designed to manage millions of concurrent device connections. It provides a scalable infrastructure for ingesting, processing, and routing telemetry data across distributed systems, utilizing an actor-based concurrency model to maintain high availability and state synchronization across cluster nodes. The platform distinguishes itself through integrated stream processing and edge computing capabilities. It allows users to execute declarative SQL-based rules directly against incoming message streams for real-time filtering, t
EMQX is a full-featured MQTT broker and IoT platform, which fits the pub/sub messaging category but is designed for high-scale deployments rather than lightweight, simple setups, so it lacks the ease of setup and low resource usage you're looking for.
Redis is a high-performance in-memory key-value store that functions as a distributed cache, message broker, and NoSQL database. It provides sub-millisecond read and write access to data stored in RAM and can operate as a vector database for indexing high-dimensional embeddings. The system supports a wide range of data storage and synchronization primitives, including the management of strings, hashes, lists, sets, and JSON documents. It enables real-time data operations through atomic transactions, hybrid persistence using snapshots and append-only logs, and high-availability configurations
Redis is a high-performance in-memory data store that includes a built-in pub/sub messaging feature, making it a lightweight and easy-to-set-up broker for simple service communication—it covers the core pub/sub model, optional persistence, and broad client library support, though its protocol is limited to Redis rather than multiple wire protocols.
uWebSockets is a C++ networking framework that serves as a high-performance WebSocket server library, HTTP web server, and pub-sub messaging system. It provides the infrastructure necessary to handle standard web requests and maintain low-latency, bidirectional connections between clients and servers. The framework is distinguished by its use of template meta-programming for compile-time optimization and zero-copy buffer management to minimize memory latency. It utilizes a backend-agnostic event loop and static route resolution to process network traffic with minimal runtime overhead. The pr
uWebSockets is a C++ networking framework with pub-sub capabilities, but it is a library you integrate into your own application rather than a standalone, easy-to-set-up message broker — it would require additional development to use as a messaging system between services.
Olric is a distributed data grid and in-memory key-value store that partitions and replicates data across a cluster of servers. It serves as a shared memory system for managing distributed maps, performing atomic operations, and acting as an in-memory data cache. The system provides a distributed locking mechanism for concurrency control and a pub-sub messaging system that broadcasts and routes messages over named channels across the cluster. The platform covers wide-ranging capabilities including cluster management and orchestration, data replication with configurable quorums, and automated
Olric is a distributed data grid and in-memory key-value store that includes a pub-sub messaging feature, but its primary identity is not a lightweight pub/sub broker — it is a heavier distributed system with cluster management and data replication, making it more than what you need for simple pub/sub communication.
MQTTnet is a .NET library providing a framework for implementing MQTT clients and brokers. It includes a broker implementation for hosting a central message hub that routes messages between connected clients and a client library for publishing and subscribing to messages. The project supports both TCP and WebSocket transport layers, enabling secure data traffic through transport layer security. It allows for the development of custom middleware to intercept, transform, or validate messages as they pass through a server. Capability areas include distributed message routing, persistent connect
MQTTnet is a .NET library for building MQTT brokers and clients, not a ready‑to‑run broker — you would need to write code to set it up, which goes against the “easy‑to‑set‑up” intent for a turnkey messaging system.
Apache Pulsar is a cloud-native message queue and distributed publish-subscribe messaging system. It serves as a multi-tenant event streaming platform designed to route data streams for asynchronous communication between producers and consumers. The system distinguishes itself through geo-replication, synchronizing data across multiple geographic regions to ensure high availability and low latency. It implements a multi-tenant architecture that provides isolation and resource management for millions of independent topics. The platform covers high-throughput data streaming and event-driven da
Apache Pulsar is a cloud-native, distributed pub/sub system designed for high throughput and multi-tenancy, not a lightweight, simple-to-set-up broker for basic service communication.
MQTT.js is a JavaScript client library and asynchronous messaging client used to connect to message brokers and exchange data via the MQTT protocol. It provides a broker interface for publishing and subscribing to topics, and includes a command-line interface for interacting with brokers without writing code. The library supports multiple network layers, including TCP, TLS, and WebSockets, and allows for custom WebSocket construction and transport injection to handle specific headers or subprotocols. It implements bandwidth reduction through topic aliasing, which replaces repetitive topic str
MQTT.js is a client library and CLI for connecting to MQTT brokers, not a standalone pub/sub broker itself; while it enables pub/sub messaging, setting it up as a broker still requires a separate server, so it's more of a building block than the lightweight, ready-to-run messaging system you're looking for.
redis-py is a Python client library for executing Redis commands and managing in-memory data structures. It provides the necessary components to integrate Python applications with Redis for data storage and retrieval. The project includes a cluster client for monitoring health and managing automatic failover across multiple active-active database replicas. It also features a connection pool manager to maintain reusable socket connections and a dedicated pub/sub client for subscribing to real-time message channels. The library covers broad capability areas including performance optimization t
This is a Redis client library for Python that supports pub/sub messaging, but the visitor is looking for a lightweight standalone message broker, not a client library for an existing broker like Redis.
| Repository | Stars | Language | License | Last push |
|---|---|---|---|---|
| nats-io/nats-server | 20.1K | Go | Apache-2.0 | |
| centrifugal/centrifugo | 10.4K | Go | Apache-2.0 | |
| 30.8K |
| Go |
| Apache-2.0 |
| nsqio/nsq | 25.7K | Go | MIT |
| emqx/emqx | 16.4K | Erlang | NOASSERTION |
| tporadowski/redis | 10K | C | other |
| uwebsockets/uwebsockets | 18.9K | C++ | Apache-2.0 |
| olric-data/olric | 3.5K | Go | Apache-2.0 |
| chkr1011/mqttnet | 5K | C# | MIT |
| apache/incubator-pulsar | 15.3K | Java | Apache-2.0 |