For a message queue library for Go, the first results are nsqio/nsq (NSQ is a high-performance, distributed messaging platform written in Go that natively supports pub/sub, persistence, and horizontal scaling, making it a flagship example of the requested category), nats-io/nats-server (NATS Server is a high-performance, Go-native message broker that provides robust pub/sub, request-reply patterns, and distributed architecture, making it a flagship solution for reliable messaging in Go-based systems) and hdt3213/godis (Godis is a Redis-compatible, Go-native distributed data store that includes built-in pub/sub messaging and persistence, making it a viable choice for message brokering despite its broader focus as a key-value database). threedotslabs/watermill and apache/kafka round out the shortlist. Compare the match explanations and check the project documentation against your requirements.
We curate open-source GitHub repositories matching “best go message queue libraries”. Results are ranked by relevance to your query — pick filters below to narrow, or refine with AI.
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 high-performance, distributed messaging platform written in Go that natively supports pub/sub, persistence, and horizontal scaling, making it a flagship example of the requested category.
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 high-performance, Go-native message broker that provides robust pub/sub, request-reply patterns, and distributed architecture, making it a flagship solution for reliable messaging in Go-based systems.
Godis is a Redis-compatible in-memory database and distributed key-value store. It functions as a replicated data store and distributed message broker, implementing the Redis protocol to manage complex data structures in memory. The system provides a geospatial indexing engine for proximity-based queries and distance calculations. It ensures high availability and data durability through master-slave replication and write-ahead logging. The project covers a wide range of capabilities including the management of strings, hash maps, lists, and sorted sets. It supports distributed data clusterin
Godis is a Redis-compatible, Go-native distributed data store that includes built-in pub/sub messaging and persistence, making it a viable choice for message brokering despite its broader focus as a key-value database.
Watermill is a Go library for building event-driven applications. It provides a framework for implementing event-driven architectures through a consistent interface for message publishing and subscribing, featuring a pub/sub message router and event stream processing pipelines. The library uses interface-based abstractions to decouple message producers and consumers from the underlying message broker. This allows different messaging technologies to be swapped via plugin-based broker integration. It employs a router-driven dispatch system and middleware-based pipelines to manage cross-cutting
Watermill is a Go library that provides a robust framework for building event-driven systems by abstracting message brokers, making it a highly effective tool for implementing pub/sub and event-driven architectures in Go.
Kafka is a distributed event streaming platform designed for capturing, storing, and processing real-time data streams across interconnected nodes. It functions as a distributed commit log, providing a fault-tolerant storage mechanism that records state changes sequentially to ensure data consistency and durability across distributed environments. The platform distinguishes itself through a partitioned commit log architecture that enables horizontal scaling and parallel processing of data streams. It integrates a stream processing engine for continuous transformations and aggregations, while
While this is a high-performance, distributed message broker that supports pub/sub and persistence, it is implemented in Java and Scala rather than being a native Go library.
This is a Go client library and protocol implementation for interacting with message brokers using the AMQP 0.9.1 standard. It serves as an asynchronous messaging toolkit and message queue client for implementing producer and consumer patterns. The library provides a programmatic interface for managing the full message lifecycle, including publishing, consumption, and delivery acknowledgments. It supports reliable delivery mechanisms such as publishing confirmations and atomic transactions. The project covers the administration of routing topologies through the declaration and binding of que
This is a client library for interacting with existing message brokers like RabbitMQ rather than a self-contained message broker or queue implementation itself.
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
This is a high-performance C++ networking and WebSocket framework rather than a Go-native message broker, making it a building block for real-time communication rather than the specific messaging infrastructure requested.
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
While this is a high-performance, distributed message broker, it is a Java-based platform rather than a native Go library or tool designed for the Go ecosystem.
This project is a Java messaging software development kit designed to facilitate real-time data exchange between applications and message brokers. It functions as an MQTT client library, providing the necessary tools to implement publish-and-subscribe messaging patterns within distributed systems and internet-connected device environments. The library distinguishes itself through its focus on resilient network connectivity and reliable message delivery. It manages persistent connections through internal state machines that handle automatic reconnection and keep-alive heartbeats, ensuring stab
This is a Java-based MQTT client library for connecting to brokers, rather than a message broker or queue library implemented in Go.
This project is a cross-platform C library designed for implementing MQTT messaging in applications. It serves as an asynchronous networking toolkit that enables resource-constrained systems and distributed components to exchange telemetry data and control signals with messaging brokers. The library distinguishes itself through a state-machine-based protocol handler that manages connection lifecycles and persistent session states, ensuring reliable message delivery even during intermittent network connectivity. It utilizes a background thread to manage network operations, allowing application
This is a C-based MQTT client library for connecting to brokers, rather than a message queue or broker implementation written in Go.
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 key-value store and data grid rather than a dedicated message broker, and while it includes pub/sub functionality, it lacks the core message queuing features like persistence and at-least-once delivery required for a reliable message queue.
go-cloud is a toolkit of cloud-agnostic libraries that provide portable Go interfaces for interacting with common cloud services. It enables multi-cloud application development by decoupling business logic from specific provider API implementations. The project utilizes a driver-based system to map generic interface calls to vendor-specific requests. This allows applications to switch between different cloud backends for blob storage, relational databases, and asynchronous publish-subscribe messaging without changing the core application code. Beyond storage and messaging, the toolkit includ
This is a collection of cloud-agnostic abstractions for interacting with various cloud services rather than a standalone message broker or queue implementation itself.
| Repository | Stars | Language | License | Last push |
|---|---|---|---|---|
| nsqio/nsq | 25.7K | Go | MIT | |
| nats-io/nats-server | 20.1K | Go | Apache-2.0 | |
| hdt3213/godis |
| 3.8K |
| Go |
| GPL-3.0 |
| threedotslabs/watermill | 9.8K | Go | MIT |
| apache/kafka | 32.8K | Java | Apache-2.0 |
| streadway/amqp | 4.9K | Go | BSD-2-Clause |
| uwebsockets/uwebsockets | 18.9K | C++ | Apache-2.0 |
| apache/incubator-pulsar | 15.3K | Java | Apache-2.0 |
| eclipse-paho/paho.mqtt.java | 2.3K | Java | NOASSERTION |
| eclipse-paho/paho.mqtt.c | 2.3K | C | NOASSERTION |