Open-source PubNub alternatives

OpenIM is an open-source instant messaging solution aimed at developers rather than end users. The project contrasts itself with standalone chat apps such as Telegram, Signal and Rocket.Chat, saying it is a set of building blocks for adding messaging to your own application instead of an installable chat product.

It consists of the OpenIM SDK, a client-side library, and the OpenIM Server, written in Go. Together they handle sending and receiving messages, managing users and managing groups, so teams can embed chat into social, marketplace, enterprise or other apps without building the infrastructure themselves. The README is translated into many languages and links to community channels on Twitter, Slack and WeChat, and topics mention IM, chat and messaging.

OpenIM is Apache-2.0 licensed and runs on your own servers. It suits product teams and agencies who need to own their messaging stack, for example for data-residency or customization reasons, and who are comfortable operating a Go back end.

This entry covers Centrifugo, the real-time messaging server from the Centrifugal project. It is an open-source PUB/SUB server for user-facing messaging: your backend publishes into channels through a simple HTTP or gRPC API, and clients subscribe to those channels using official SDKs, or a unidirectional approach that needs no SDK.

Messages reach online users over WebSocket, HTTP streaming, Server-Sent Events, gRPC and WebTransport. Because it is language-agnostic, it can sit beside any backend and separates the business logic from the real-time transport. It is used for chat apps, live comments, multiplayer games, data visualizations, collaborative tools and streaming AI responses. An embedded admin UI shows live connections and lets you publish test messages, and Redis support allows scaling out.

Centrifugo is written in Go and licensed under Apache-2.0. It is pitched as a self-run replacement for hosted services like Pusher, Ably and PubNub and for libraries such as socket.io, Phoenix.PubSub and SignalR, and a Docker command starts it in a minute for local trials. The README warns that the insecure flags used in the quick start must never be used in production.

deepstream is an open-source realtime server inspired by ideas from financial trading technology. It lets clients and backend services sync data, exchange messages and make remote procedure calls at high speed and scale, and it is written in TypeScript for Node.js.

It is built on three core concepts. Records are schema-less, persistent documents that clients can edit and observe, with changes synchronized to all connected clients and backend processes in milliseconds and links between records to model relational data. Events provide publish-subscribe messaging with topic-based routing and subscription listening. RPCs offer request-response workflows with load balancing, failover and message routing handled by the server.

Security combines several authentication mechanisms with a permission language called Valve that specifies which user can do which action on which data. deepstream is licensed under MIT and hosted by you, with tutorials, a quickstart and documentation, plus community support on Stack Overflow and GitHub Discussions. It suits developers building collaborative or live-updating applications.

Mercure is a protocol that lets servers push updates to browsers and other HTTP clients without polling, while staying light on battery. It is especially useful for publishing asynchronous, real-time updates to resources served through web APIs, so reactive web and mobile apps can react as data changes.

The repository contains both the protocol, which is also published as an Internet-Draft, and a production-grade reference implementation of a Mercure hub, the server component. The hub is written in Go and is built around Server-Sent Events. A Go library lets applications implement the protocol directly without running a hub, and an official Docker image is provided.

Mercure is free software under AGPL-3.0, created by Kévin Dunglas and sponsored by Les-Tilleuls.coop. Teams that prefer not to operate the hub can use the managed, high-scalability version offered through Mercure.rocks, and the project provides a getting-started guide, full documentation and a demo.

WuKongIM is open-source messaging infrastructure that you build your own product on. It takes care of client connections, storing and syncing messages, presence and delivery to online users, while your application keeps ownership of the user interface, accounts and business rules.

The project suits personal and group chat, customer support, application notifications and streaming AI replies. A key design point is a self-contained messaging core with built-in storage and clustering, so no external database, cache or message queue is required. The repository offers a quick start, a live demo, a showcase and documentation, and the README is available in Chinese as well as English. It is written in Go.

WuKongIM is licensed under Apache-2.0 and runs on your own servers, which suits teams that want to embed chat in their apps without depending on a third-party messaging service or running extra infrastructure.

JuggleIM is a high-performance, scalable instant messaging backend that you host yourself. It is built on a Protobuf and WebSocket long-connection protocol and focuses on efficient message delivery and reliable storage, so teams can add chat to an app, website or business system quickly.

The server supports private chat, group chat and chatrooms, exposes WebSocket and REST APIs, and offers multi-tenant operation, with SDKs for client platforms. It is positioned for social products, customer-service systems and similar use cases. Documentation includes a quick deploy guide, an API reference and an introduction, and the code is written in Go.

JuggleIM is licensed under Apache-2.0 and deployed on your own servers, which keeps message data in your control. It suits product teams that need to embed real-time messaging without relying on a third-party chat service.