Messaging

A simple, reliable, and efficient distributed task queue for Go built on top of Redis

Go library for Apache Kafka

Real-time messaging (Websockets or SockJS) server in Go

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

Push notification server using [APNs2](https://github.com/sideshow/apns2) and google [GCM](https://github.com/google/go-gcm)

Asynchronous task queue/job queue based on distributed message passing

Go client for the NATS

Server and library to dispatch server-sent updates using the Mercure protocol (built on top of Server-Sent Events)

confluent-kafka-go is Confluent's Golang client for Apache Kafka and the Confluent Platform

Minimalist framework for dealing with websocket sessions, includes broadcasting and automatic ping/pong handling

HTTP/2 Apple Push Notification provider for Go - Send push notifications to iOS, tvOS, Safari and OSX apps

the official Go package for NSQ

gopush-cluster is a go push server cluster

Go RabbitMQ Client Library

The lightweight event bus with async compatibility

A real time messaging server to build a scalable in-app notifications, multiplayer games, chat apps in web and mobile apps

Redis backed unified push service for server-side notifications to mobile devices

A push notification server send message to your iOS devices

Go interface to ZeroMQ version 4. Also available for [version 3](https://github.com/pebbe/zmq3) and [version 2](https://github.com/pebbe/zmq2)

Native Go bindings for D-Bus

A n:m multiplexer that gathers messages from different sources and broadcasts them to a set of destinations

Pure go implementation of the Nanomsg ("Scalability Protocols") with transport interoperability

HTTP longpoll server library that makes web pub-sub simple

Emits events using Go way, with wildcard, predicates, cancellation possibilities and many other good wins

Fast pattern-matching for filtering messages and events

Simple pubsub package for go

Robust Go and Javascript Socket Library (Alternative to Socket.io)

Minimalist message bus implementation for internal communication

RabbitMQ swiss army knife cli app

messagebus is a Go simple async message bus, perfect for using as event bus when doing event sourcing, CQRS, DDD

A library for handling mediator patterns and simplified CQRS patterns within an event-driven architecture, inspired by csharp MediatR library

A storage-agnostic message queue and worker pool for concurrent Go programs

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

Type-safe, persistent, embedded task queues and background job runner w/ SQLite

A Message/Event Hub for Go applications, using publish/subscribe pattern with support for alias like rabbitMQ exchanges

redisqueue provides a producer and consumer of a queue that uses Redis streams

Ratus is a RESTful asynchronous task queue server

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

Generic oplog/replication system for REST APIs

A tiny wrapper over amqp exchanges and queues

RabbitMQ client with declarative configuration

Sending [Line](https://at.line.me/en) notifications using a binary, docker or Drone CI

A tiny wrapper around NSQ topic and channel

A blazing‑fast, in‑memory, lock‑free event bus library

Native implementation of the freedesktop notification spec

RapidMQ is a lightweight and reliable library for managing of the local messages queue

Package for building REST/real-time services where clients are synchronized seamlessly, using NATS and Resgate

A high-level event driven consumer/producer supporting various "dialects" such as Apache Kafka

Implementation of the pattern observer

A user friendly library for sending messages and listening to TCP sockets

Matches events against large sets of rules, with rules written in Go or as JSON

Go client to reliable queues based on Redis Cluster Streams

A library for scheduling when to dispatch a message to a channel

Client library to Viessmann Vitotrol web service

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

A simple RabbitMQ abstraction layer for queue administration and publishing and consuming of messages

Simple Event Bus package for Go

Production-grade messaging abstraction with a unified API for various brokers and built-in OpenTelemetry integration

Gaurun Client written in Go

Persistent background jobs in PostgreSQL, MySQL or SQLite, with retries, workflows, recurring jobs and a dashboard

A very fast and efficient Go library for matching events to a large set of rules