Centrifugo is an open-source scalable real-time messaging server. It instantly delivers messages to application online users connected over supported transports (WebSocket, HTTP-streaming, Server-Sent Events (SSE), GRPC, WebTransport). Centrifugo is built around channel subscriptions – so it's a user-facing PUB/SUB server.

Centrifugo is language-agnostic and can be used to build chat apps, live comments, multiplayer games, real-time data visualizations, collaborative tools, AI streaming responses, etc. in combination with any backend. It is well suited for modern architectures and allows decoupling the business logic from the real-time transport layer.

Official client SDKs are available for JavaScript (browser, Node.js, React Native), Dart/Flutter, Swift, Java, Python, Go, and .NET. In addition, Centrifugo supports a unidirectional approach for simple use cases with no SDK dependency.

For details, go to the Centrifugo documentation site. For runnable demos see centrifugal/examples.

What's changed

Improvements

• New auto_cache_recover channel namespace option to automatically recover subscriptions on (re)subscribe without the subscriber requesting recovery itself, see #1158. In cache recovery mode this delivers the latest channel publication on every (re)subscribe – without the client providing an empty since position itself. It also enables this for server-side subscriptions, which is especially useful for unidirectional clients that may not even know channel names. The option requires force_recovery and force_recovery_mode set to cache. Subscribe and connect proxies may also enable it per subscription with the new cache_recover field in SubscribeOptions.
• OpenTelemetry: Centrifugo node ID is now used as the service.instance.id resource attribute, see #1155. Each Centrifugo process now reports telemetry under a distinct identity, which avoids backends that require points of a time series to arrive in order (notably Google Cloud Managed Service for Prometheus) rejecting or collapsing metrics when several instances report under the same identity. OTEL_SERVICE_NAME and OTEL_RESOURCE_ATTRIBUTES still take precedence over Centrifugo defaults.
• All official Centrifugo SDKs now support a getState subscription callback – read the stream position first, then load your initial state, and return the position so the SDK subscribes from exactly there and recovers on every reconnect. This closes the gap between loading state from your own database and subscribing, see Using recovery in your app.
• All official Centrifugo SDKs now support publication filtering by tags – clients can subscribe with a filter expression so only publications whose tags match are delivered, reducing bandwidth and client-side processing (previously available in centrifuge-js only).

Documentation

• The Client protocol chapter was reworked and now ships with diagrams explaining the frame structure, command/reply sequence, push delivery, ping-pong, batching, and the JSON/Protobuf formats.
• The History and recovery chapter was significantly expanded with diagrams covering stream vs cache recovery modes, the recovery decision flow, and recovery storm mitigation.
• The GrandChat tutorial was actualized for 2026 – the Django/React code was modernized to recent versions and made more idiomatic and type-safe, and a new Two-column layout chapter shows how to build a Telegram/Slack-style messenger layout (room list and open room side by side) live from a single personal-channel subscription.

Miscellaneous

• The linux/386 (32-bit x86) binary is no longer published in releases, see #1154.
• This release is built with Go 1.26.4
• Dependency updates
• See also the corresponding Centrifugo PRO release.

Centrifugo is an open-source scalable real-time messaging server. It instantly delivers messages to application online users connected over supported transports (WebSocket, HTTP-streaming, Server-Sent Events (SSE), GRPC, WebTransport). Centrifugo is built around channel subscriptions – so it's a user-facing PUB/SUB server.

Centrifugo is language-agnostic and can be used to build chat apps, live comments, multiplayer games, real-time data visualizations, collaborative tools, AI streaming responses, etc. in combination with any backend. It is well suited for modern architectures and allows decoupling the business logic from the real-time transport layer.

Official client SDKs are available for JavaScript (browser, Node.js, React Native), Dart/Flutter, Swift, Java, Python, Go, and .NET. In addition, Centrifugo supports a unidirectional approach for simple use cases with no SDK dependency.

For details, go to the Centrifugo documentation site. For runnable demos see centrifugal/examples.

What's changed

Improvements

• OpenTelemetry: authenticate the OTLP exporter with Google Cloud Application Default Credentials (ADC) via the new google_cloud_adc_auth option, see #1143 and #1148. This allows exporting traces directly to Google Cloud's OTLP endpoint (telemetry.googleapis.com) without a sidecar collector, and works with both the grpc and http/protobuf exporter protocols.
• Kafka consumer: added a configurable dial_timeout (default 3s) for establishing a TCP connection to a single broker, and made the initial Ping timeout scale with the number of seed brokers so discovery no longer fails prematurely when some brokers are unreachable, see #1151.
• Centrifugo official Helm chart now supports k8s Gateway API - see Helm chart 13.3.0 release
• Centrifugo now does not embed generated JSON config schema - configuration structure for configdoc is calculated in runtime, #1153

Fixes

• Kafka consumer with AWS MSK IAM auth: re-assume the STS role on each SASL re-auth instead of reusing cached credentials, fixing periodic ILLEGAL_SASL_STATE errors during re-authentication, see #1146 by @samir-is-here which fixes #1144.
• Fix unidirectional subscribe stream proxy not closing on unsubscribe, see #1150.

Miscellaneous

• This release is built with Go 1.26.4
• Dependency updates
• This is the latest release that ships linux/386 binary
• See also the corresponding Centrifugo PRO release.

Centrifugo is an open-source scalable real-time messaging server. Centrifugo can instantly deliver messages to application online users connected over supported transports (WebSocket, HTTP-streaming, Server-Sent Events (SSE/EventSource), GRPC, WebTransport). Centrifugo has the concept of a channel – so it's a user-facing PUB/SUB server.

Centrifugo is language-agnostic and can be used to build chat apps, live comments, multiplayer games, real-time data visualizations, collaborative tools, etc. in combination with any backend. It is well suited for modern architectures and allows decoupling the business logic from the real-time transport layer.

Several official client SDKs for browser and mobile development wrap the bidirectional protocol. In addition, Centrifugo supports a unidirectional approach for simple use cases with no SDK dependency.

For details, go to the Centrifugo documentation site.

What's changed

Improvements

• Support Prometheus native histograms, see #1136. See in docs. Summaries are now DEPRECATED in Centrifugo. Metrics which only had summary now have histogram analogue exposed.
• Kafka consumer: don't re-init the client on retriable fetch errors, see #1137. Should improve stability of consumer during temporary issues with Kafka and prevent unnecessary rebalances.

Fixes

• Add missing envconfig tags to NATS JetStream consumer config so its fields can be configured via environment variables, see #1117 by @thuy-le-kafi. Also applied the same fix to the Redis Streams and Azure Service Bus consumer configs, which had the same gap.
• Fix: Scope JWKS cache by resolved endpoint URL #1142. Fixes GHSA-g6vg-wj8f-48cj reported by @sondt99
• Fix a bunch of flaky integration tests.

Miscellaneous

• This release is built with Go 1.26.3
• Dependency updates
• See also the corresponding Centrifugo PRO release.

Centrifugo is an open-source scalable real-time messaging server. Centrifugo can instantly deliver messages to application online users connected over supported transports (WebSocket, HTTP-streaming, Server-Sent Events (SSE/EventSource), GRPC, WebTransport). Centrifugo has the concept of a channel – so it's a user-facing PUB/SUB server.

For details, go to the Centrifugo documentation site.

What's changed

This release introduces two new subscription primitives and three Postgres-backed components. Centrifugo evolves from a channel-based pub/sub server into a real-time companion for Postgres-backed applications. From a stream based broker to a state synchronization realtime backend.

A blog series accompanies this release. Two posts are published today:

• Shared poll subscriptions: O(unique items) polling with low-latency updates introduces one of the new subscription types,
• Recreating a Two Million Particle World at 30 Hz with Centrifugo puts shared poll to work reproducing David Gerrells' particle simulation on top of Centrifugo's WebSocket protocol.

Five more posts will follow during this week, covering map subscriptions, the PostgreSQL stream broker, the PostgreSQL controller, and a wrap-up tying it all together:

• Day 2: Map subscriptions (Part 1) — synchronized key-value state and presence
• Day 3: Map subscriptions (Part 2) — when your PostgreSQL transaction is your real-time publish
• Day 4: Transactional publishing for stream subscriptions with PostgreSQL
• Day 5: Multi-node Centrifugo on PostgreSQL alone

Note, we consider map subscriptions and shared poll experimental for now. Features are huge and we expect API to stabilize within next months.

Highlights of release

• Map subscriptions — new subscription type for synchronized key-value collections (cursors, presence, scoreboards, dashboards, feature flags).
• Shared poll subscriptions — new subscription type for read-only state where the backend doesn't control writes (third-party feeds, configuration sync, live counters).
• PostgreSQL stream broker — transactional publishing for stream subscriptions inside your SQL transactions.
• PostgreSQL map broker — transactional publishing for map subscriptions inside your SQL transactions.
• PostgreSQL controller — multi-node Centrifugo clusters on PostgreSQL alone, no Redis required.

Yes, Centrifugo multi-node cluster only on PostgreSQL is now possible.

Map subscriptions

A new subscription type that delivers synchronized key-value collections over the same WebSocket connection. Centrifugo keeps the collection in the map broker; the client stays in sync.

Three modes for different state shape:

• ephemeral — usually memory or Redis backed, no recovery on reconnect (cursors, typing indicators, in-flight game state).
• recoverable — time-bounded recovery from stream within a window, state converges with the help of offset/epoch mechanics.
• persistent — durable, no per-key TTL — entries live until explicitly removed (feature flags, configuration, catalog state).

Key features:

• Three-phase sync protocol resolves the race between paginated initial state and concurrent updates.
• Per-key TTL handles cleanup on disconnect.
• CAS-style conditional writes handle concurrent updates safely.
• Convergence on reconnect guaranteed by offset/epoch tracking (in recoverable and persistent modes).

Docs: Map subscriptions
Cursors demo: Map Cursors
More Map Demos (with PostgreSQL map broker): v6/map_demo collection — cursors, polls, sprint board, scoreboard, inventory, lobby, tickers, sync protocol visualizer.

Map presence

Map subscriptions introduce a new presence model built on the same sync protocol. Two server-managed subscription types replace the polling-style traditional presence API for use cases that need it:

• map_clients — one entry per connection (client presence).
• map_users — one entry per user (user presence).

Enabled via map_clients_presence_channel_prefix and map_users_presence_channel_prefix on the parent namespace. Presence is published to a separate channel (prefix + channel), so subscribers opt in independently of the parent subscription. Works alongside any parent subscription type (stream, map, shared_poll).

Advantages over traditional presence:

• Paginated state delivery for large participant lists.
• Stream-based catch-up on reconnect (with recoverable mode) — clients receive only the join/leave changes they missed, no full re-fetch.
• Out of the box convergence (must be in recoverable mode for convergence property)

Docs: Presence channels
Demo: v6/map_presence_demo — 100k and 1M presence members synchronized to a single browser tab

Shared poll subscriptions

Server-side polling inversion for read-only state where the backend doesn't control writes. Instead of N clients each polling the backend, Centrifugo aggregates interest across all clients on a node and polls the backend once per cycle for the union of tracked keys. Backend load scales with O(unique items tracked), not O(connected clients).

Key features:

• Per-key authorization via HMAC signatures (faster than JWT, first-class values in protocol).
• Direct publish via shared_poll_publish lowers latency on application write paths.
• Versionless and versioned modes for flexible backend integration.
• Cold-key auto-poll: when a new client tracks a key with no cached data, Centrifugo triggers an immediate backend poll without waiting for the next cycle.
• Reconnect resilience with version comparison: clients reconnect, replay tracked keys, only changed data re-delivered.

Docs: Shared poll
Blog: Shared poll subscriptions: O(unique items) polling with low-latency updates
Demos: v6/shared_poll_demo — votes, drones

PostgreSQL stream broker

Transactional publishing for stream subscriptions. The cf_stream_publish SQL function commits inside your application's SQL transaction — your INSERT/UPDATE and the real-time publish commit together. If the transaction rolls back, the real-time update never happened. No application-side outbox to maintain, no CDC pipeline.

Architecture:

• Partitioned outbox table (cf_stream) with daily date ranges.
• LISTEN/NOTIFY for low-latency wakeup, polling for correctness.
• Drop-partition cleanup — vacuum-free at scale.
• Two independent TTLs: HistoryTTL (queryable history) and HistoryMetaTTL (channel epoch).
• HistorySize enforced at read time, not write time.

Pairs with the SDK's getState callback for the app-owned state pattern: clients load initial state from your application API, then subscribe from the captured stream position. The SDK switches paths automatically — replays from stream history on normal reconnects, calls getState only when the gap exceeds what history covers.

Docs: Engines — PostgreSQL Broker
Example: v6/pg_stream_broker — kitchen orders, multi-tenant per-restaurant channels

PostgreSQL map broker

Transactional publishing for map subscriptions. The cf_map_publish and cf_map_remove SQL functions commit inside your application's SQL transaction — write your row, publish the map update, both atomic.

Same outbox-on-Postgres foundation as the stream broker — partitioned outbox table, LISTEN/NOTIFY wakeup, daily partition retention, vacuum-free cleanup.

The map broker stores cf_map_state and cf_map_stream in your PostgreSQL database. The state lives in cf_map_* tables that Centrifugo owns, queryable from psql. Best fit when Centrifugo is the natural store for the data — feature flags, IoT device fleet telemetry, lobby rosters, collaborative cursors.

Docs: Map subscriptions — PostgreSQL

PostgreSQL controller

The control-message bus for multi-node Centrifugo (subscribe propagation, disconnects, presence pings, surveys) can now run on PostgreSQL — the same outbox-on-Postgres foundation as the brokers. Until this release, multi-node OSS Centrifugo required Redis for that bus.

With the stream broker, map broker, and controller all on PG, an OSS cluster runs with PostgreSQL as the only messaging-plane dependency. No Redis, no NATS, no separate pub/sub broker.

For applications already running Postgres for everything else, the messaging plane has what it needs.

Docs: [PostgreSQL controller](https://centr...

Centrifugo is an open-source scalable real-time messaging server. Centrifugo can instantly deliver messages to application online users connected over supported transports (WebSocket, HTTP-streaming, Server-Sent Events (SSE/EventSource), GRPC, WebTransport). Centrifugo has the concept of a channel – so it's a user-facing PUB/SUB server.

Centrifugo is language-agnostic and can be used to build chat apps, live comments, multiplayer games, real-time data visualizations, collaborative tools, etc. in combination with any backend. It is well suited for modern architectures and allows decoupling the business logic from the real-time transport layer.

Several official client SDKs for browser and mobile development wrap the bidirectional protocol. In addition, Centrifugo supports a unidirectional approach for simple use cases with no SDK dependency.

For details, go to the Centrifugo documentation site.

What's changed

Miscellaneous

• This release is built with Go 1.26.3
• Dependency updates
• See also the corresponding Centrifugo PRO release.

Centrifugo is an open-source scalable real-time messaging server. Centrifugo can instantly deliver messages to application online users connected over supported transports (WebSocket, HTTP-streaming, Server-Sent Events (SSE/EventSource), GRPC, WebTransport). Centrifugo has the concept of a channel – so it's a user-facing PUB/SUB server.

Centrifugo is language-agnostic and can be used to build chat apps, live comments, multiplayer games, real-time data visualizations, collaborative tools, etc. in combination with any backend. It is well suited for modern architectures and allows decoupling the business logic from the real-time transport layer.

Several official client SDKs for browser and mobile development wrap the bidirectional protocol. In addition, Centrifugo supports a unidirectional approach for simple use cases with no SDK dependency.

For details, go to the Centrifugo documentation site.

What's changed

Improvements

• Kafka consumer now supports AWS STS AssumeRole for MSK IAM authentication via the new consumers[].kafka.assume_role_arn option, #1129 by @samir-is-here. When set together with sasl_mechanism: "aws-msk-iam", Centrifugo loads base credentials via the AWS SDK default credential chain and assumes the specified IAM role to obtain temporary credentials with automatically refreshed session tokens. This is useful for cross-account MSK access or when running Centrifugo with an EC2/EKS/ECS instance profile. Static sasl_user/sasl_password keys remain the default when assume_role_arn is empty. See documentation.

Fixes

• CI fix: set LocalStack image version to 4.14 in development setup, #1119.

Miscellaneous

• This release is built with Go 1.26.2
• Dependency updates
• See also the corresponding Centrifugo PRO release.

Centrifugo is an open-source scalable real-time messaging server. Centrifugo can instantly deliver messages to application online users connected over supported transports (WebSocket, HTTP-streaming, Server-Sent Events (SSE/EventSource), GRPC, WebTransport). Centrifugo has the concept of a channel – so it's a user-facing PUB/SUB server.

Centrifugo is language-agnostic and can be used to build chat apps, live comments, multiplayer games, real-time data visualizations, collaborative tools, etc. in combination with any backend. It is well suited for modern architectures and allows decoupling the business logic from the real-time transport layer.

Several official client SDKs for browser and mobile development wrap the bidirectional protocol. In addition, Centrifugo supports a unidirectional approach for simple use cases with no SDK dependency.

For details, go to the Centrifugo documentation site.

What's changed

This release contains breaking change to address CVE discovered in Dynamic JWKs endpoint feature. If you use that feature you need to update Centrifugo configuration. See fixes section for the details.

Improvements

• This release is the first built with Go 1.26. This version of the Go language includes a new garbage collector called the Green Tea garbage collector. This may affect the performance of your Centrifugo installation; in most cases, we expect the impact to be positive. If you notice any performance changes in Centrifugo after upgrading to this release, please let us know in the community rooms. More information about the new GC can be found here.
• Updated the Alpine image to 3.22 in the Dockerfile.
• Improve lint layout to improve local DX

Fixes

• CVE-2026-32301 Fixed SSRF vulnerability in Dynamic JWKS endpoint feature. When using JWKS endpoint URL templates with placeholders extracted from JWT claims via issuer_regex or audience_regex, an attacker could craft a JWT with malicious claim values to redirect JWKS key fetches to an attacker-controlled server, enabling token forgery. Action required: if you use dynamic JWKS endpoints, update your issuer_regex/audience_regex patterns so that named capture groups used in the JWKS URL template contain only an explicit list of allowed literal values (e.g., (?P<tenant>tenant1|tenant2|tenant3) instead of (?P<tenant>.+)). Centrifugo will now reject configurations where these groups allow arbitrary input. A temporary escape hatch client.token.insecure_skip_jwks_endpoint_safety_check option is available but will be removed in future releases. This security issue was reported by @VarshankNaik
• The Go version update (1.25.7 to 1.26.1) and update of Go x/net library allow inheriting fixes for several recently discovered CVE.

Miscellaneous

• This release is built with Go 1.26.1
• See also the corresponding Centrifugo PRO release.

Centrifugo is an open-source scalable real-time messaging server. Centrifugo can instantly deliver messages to application online users connected over supported transports (WebSocket, HTTP-streaming, Server-Sent Events (SSE/EventSource), GRPC, WebTransport). Centrifugo has the concept of a channel – so it's a user-facing PUB/SUB server.

Centrifugo is language-agnostic and can be used to build chat apps, live comments, multiplayer games, real-time data visualizations, collaborative tools, etc. in combination with any backend. It is well suited for modern architectures and allows decoupling the business logic from the real-time transport layer.

Several official client SDKs for browser and mobile development wrap the bidirectional protocol. In addition, Centrifugo supports a unidirectional approach for simple use cases with no SDK dependency.

For details, go to the Centrifugo documentation site.

What's changed

Fixes

• Transport write must return after data written #1106. This was noticed in CI after a pull request made by @phront3nd3r. This is a regression from v6.6.0 due to malformed buffer reuse in WriteManyFn callback of client writer. This resulted into broken data written into connection – thus connection issues. The problem was reproducing in HTTP Stream and SSE transports (bidirectional and unidirectional). WebSocket, Webtransport, uni GRPC were not affected because they already return once data is written into connection.

Miscellaneous

• This release is built with Go 1.25.7
• See also the corresponding Centrifugo PRO release.

Centrifugo is an open-source scalable real-time messaging server. Centrifugo can instantly deliver messages to application online users connected over supported transports (WebSocket, HTTP-streaming, Server-Sent Events (SSE/EventSource), GRPC, WebTransport). Centrifugo has the concept of a channel – so it's a user-facing PUB/SUB server.

Centrifugo is language-agnostic and can be used to build chat apps, live comments, multiplayer games, real-time data visualizations, collaborative tools, etc. in combination with any backend. It is well suited for modern architectures and allows decoupling the business logic from the real-time transport layer.

Several official client SDKs for browser and mobile development wrap the bidirectional protocol. In addition, Centrifugo supports a unidirectional approach for simple use cases with no SDK dependency.

For details, go to the Centrifugo documentation site.

What's changed

Improvements

• Better configdoc UI #1092. Redesigned centrifugo configdoc interface with top-level navigation, search, JSON/YAML snippets (🔥), and dark/light themes.
• Add hmac_previous_secret_key and hmac_previous_secret_key_valid_until options to provide a possibility to rotate HMAC token #1103, docs
• Adding json_object publication data format – more strict format to ensure a JSON object in channels #1091
• Centrifugo Helm chart v13 was released - comes with many improvements, documentation and examples.
• Adopt latest quic-go and webtransport-go changes, WebTransport test #1101
• Refactor metrics – makes metrics configurable on server start and discoverable from one place #1093
• Kafka consumer: avoid using static instance id by default, add logging, eliminate one extra goroutine per partition, more reliable shutdown #1105

Fixes

• Redis broker: avoid offset incrementing on publication suppress by version centrifugal/centrifuge#549
• Add missing mutex Unlock() by @palkan in centrifugal/centrifuge#552

Miscellaneous

• This release is built with Go 1.25.7
• Updated dependencies
• See also the corresponding Centrifugo PRO release.

Centrifugo is an open-source scalable real-time messaging server. Centrifugo can instantly deliver messages to application online users connected over supported transports (WebSocket, HTTP-streaming, Server-Sent Events (SSE/EventSource), GRPC, WebTransport). Centrifugo has the concept of a channel – so it's a user-facing PUB/SUB server.

Centrifugo is language-agnostic and can be used to build chat apps, live comments, multiplayer games, real-time data visualizations, collaborative tools, etc. in combination with any backend. It is well suited for modern architectures and allows decoupling the business logic from the real-time transport layer.

Several official client SDKs for browser and mobile development wrap the bidirectional protocol. In addition, Centrifugo supports a unidirectional approach for simple use cases with no SDK dependency.

For details, go to the Centrifugo documentation site.

What's changed

This release has a potential breaking change in the Redis Cluster case where users try forming a Centrifugo cluster consisting of nodes with different Centrifugo versions (older than 6.6.0 and 6.6.0+). See details in the Fixes section below. We believe this scenario is very rare, and the risk of causing issues for anyone is minimal. The benefit is supporting ElastiCache Serverless Redis out of the box without extra options.

Improvements

• We are actively working on a new Centrifugo Helm chart v13 major release. See centrifugal/helm-charts#136. The new chart will support new Kubernetes functionality, will have better docs, and more examples and tutorials for Google and AWS managed Kubernetes services. The plan is to release one more version of the v12 chart with Centrifugo v6.6.0 as the base appVersion and then move on to the v13 chart. Note that users of the v12 Helm chart will be able to use newer Centrifugo versions without any issues, as chart versioning is independent of Centrifugo versioning (done through the appVersion). However, new updates, fixes for chart functionality, and documentation will be released only for the v13 chart.
• Performance optimizations for allocation efficiency:
  • under a batched message writing scenario - buffer pools
  • when publishing the message into channel - pool objects in broadcast method
  • when sending data to WebSocket connection - avoid extra data copy

Fixes

• Fix slot issues when publishing with history to ElastiCache Serverless Redis. See the report in #1087 and the fix in centrifugal/centrifuge#541. Centrifugo was not previously tested with ElastiCache Serverless Redis. The finding that Serverless ElastiCache requires using hashtags in channels to follow the same slots as normal data structure keys goes beyond the Redis Cluster specification (where channels are not related to hash slots until using sharded PUB/SUB). The initial thought was to introduce a separate option to support this behavior, but after further consideration, Centrifugo will always use hashtags for channels in the Redis Cluster case. This means we have incompatible changes in the internal Redis protocol: nodes of different Centrifugo versions (<6.6.0 and 6.6.0+) will not work together in one cluster. This scenario is not common at all, and we have never encouraged such a setup. Moreover, when combined with the Redis Cluster condition (under 1% of setups), the chance of causing issues for someone is minimal. During rollout, message loss can happen, but only on the PUB/SUB layer, which is at-most-once anyway. History streams and recovery logic will work as usual and will prevent client state corruption.

Miscellaneous

• This release is built with Go 1.25.5.
• Updated dependencies.
• See also the corresponding Centrifugo PRO release.

Happy New Year

We would like to thank the Centrifugo community for staying with us throughout 2025. Your feedback, bug reports, discussions, and contributions help drive the project forward and make Centrifugo better with every release.

In 2025, we released Centrifugo v6 and, throughout the year, built important functionality on top of that foundation. Major highlights are: new async consumers from popular queue systems, server-side publication filtering, support for RFC 8441 (WebSocket over HTTP/2). A new real-time SDK for C# was introduced. Centrifugo reached 7k+ real installations, usage of our SDKs grew significantly according to CDN stats (example), and we saw more and more projects choosing Centrifugo as their real-time messaging solution. For the first time, we saw a local Go meetup where 2 out of 4 talks were about projects using Centrifugo. This is a great sign of growing adoption. We continue to receive consistently positive feedback from developers, highlighting Centrifugo as a reliable, efficient, and easy-to-use real-time messaging server.

We are looking forward to getting even more things done in 2026 and continuing to improve Centrifugo and the real-time messaging ecosystem.

Happy New Year to everyone, and best wishes for a successful year ahead! 🎄 May the Centrifugal force be with you! 🖲

— Centrifugal Labs team