
The Best Go Libraries For Messaging (59)
Discover the best Go libraries for Messaging! Find the perfect tools to streamline your development and boost productivity. From rabbitroutine to Watermill, we've got you covered. Let the coding begin!
rabbitroutine
Lightweight library that handles RabbitMQ auto-reconnect and publishing retries. The library takes into account the need to re-declare entities in RabbitMQ after reconnection
Watermill
Working efficiently with message streams. Building event driven applications, enabling event sourcing, RPC over messages, sagas. Can use conventional pub/sub implementations like Kafka or RabbitMQ, but also HTTP or MySQL binlog
ami
Go client to reliable queues based on Redis Cluster Streams
amqp
Go RabbitMQ Client Library
Beaver
A real time messaging server to build a scalable in-app notifications, multiplayer games, chat apps in web and mobile apps
Bus
Minimalist message bus implementation for internal communication
Centrifugo
Real-time messaging (Websockets or SockJS) server in Go
Chanify
A push notification server send message to your iOS devices
drone-line
Sending [Line](https://at.line.me/en) notifications using a binary, docker or Drone CI
emitter
Emits events using Go way, with wildcard, predicates, cancellation possibilities and many other good wins
Glue
Robust Go and Javascript Socket Library (Alternative to Socket.io)
Go-MediatR
A library for handling mediator patterns and simplified CQRS patterns within an event-driven architecture, inspired by csharp MediatR library
go-mq
RabbitMQ client with declarative configuration
go-res
Package for building REST/real-time services where clients are synchronized seamlessly, using NATS and Resgate
gorush
Push notification server using [APNs2](https://github.com/sideshow/apns2) and google [GCM](https://github.com/google/go-gcm)
guble
Messaging server using push notifications (Google Firebase Cloud Messaging, Apple Push Notification services, SMS) as well as websockets, a REST API, featuring distributed operation and message-persistence
hare
A user friendly library for sending messages and listening to TCP sockets
hub
A Message/Event Hub for Go applications, using publish/subscribe pattern with support for alias like rabbitMQ exchanges
hypermatch
A very fast and efficient Go library for matching events to a large set of rules
machinery
Asynchronous task queue/job queue based on distributed message passing
pubsub
Simple pubsub package for go
rabtap
RabbitMQ swiss army knife cli app
RapidMQ
RapidMQ is a lightweight and reliable library for managing of the local messages queue
go-notify
Native implementation of the freedesktop notification spec
go-nsq
the official Go package for NSQ
APNs2
HTTP/2 Apple Push Notification provider for Go - Send push notifications to iOS, tvOS, Safari and OSX apps
Asynq
A simple, reliable, and efficient distributed task queue for Go built on top of Redis
backlite
Type-safe, persistent, embedded task queues and background job runner w/ SQLite
Confluent Kafka Golang Client
confluent-kafka-go is Confluent's Golang client for Apache Kafka and the Confluent Platform
EventBus
The lightweight event bus with async compatibility
go-vitotrol
Client library to Viessmann Vitotrol web service
GoEventBus
A blazing‑fast, in‑memory, lock‑free event bus library
golongpoll
HTTP longpoll server library that makes web pub-sub simple
gopush-cluster
gopush-cluster is a go push server cluster
mangos
Pure go implementation of the Nanomsg ("Scalability Protocols") with transport interoperability
messagebus
messagebus is a Go simple async message bus, perfect for using as event bus when doing event sourcing, CQRS, DDD
NATS Go Client
Go client for the NATS
oplog
Generic oplog/replication system for REST APIs
Quamina
Fast pattern-matching for filtering messages and events
Ratus
Ratus is a RESTful asynchronous task queue server
redisqueue
redisqueue provides a producer and consumer of a queue that uses Redis streams
Uniqush-Push
Redis backed unified push service for server-side notifications to mobile devices
varmq
A storage-agnostic message queue and worker pool for concurrent Go programs
zmq4
Go interface to ZeroMQ version 4. Also available for [version 3](https://github.com/pebbe/zmq3) and [version 2](https://github.com/pebbe/zmq2)
broker
Production-grade messaging abstraction with a unified API for various brokers and built-in OpenTelemetry integration
sarama
Go library for Apache Kafka
Commander
A high-level event driven consumer/producer supporting various "dialects" such as Apache Kafka
dbus
Native Go bindings for D-Bus
event
Implementation of the pattern observer
gaurun-client
Gaurun Client written in Go
go-eventbus
Simple Event Bus package for Go
Gollum
A n:m multiplexer that gathers messages from different sources and broadcasts them to a set of destinations
gosd
A library for scheduling when to dispatch a message to a channel
jazz
A simple RabbitMQ abstraction layer for queue administration and publishing and consuming of messages
melody
Minimalist framework for dealing with websocket sessions, includes broadcasting and automatic ping/pong handling
Mercure
Server and library to dispatch server-sent updates using the Mercure protocol (built on top of Server-Sent Events)
nsq-event-bus
A tiny wrapper around NSQ topic and channel
rabbus
A tiny wrapper over amqp exchanges and queues
rmqconn
RabbitMQ Reconnection. Wrapper over amqp.Connection and amqp.Dial. Allowing to do a reconnection when the connection is broken before forcing the call to the Close () method to be closed