Live pub/sub. Paths that heal themselves.
Managed multiplayer messaging
Positions. Room events. Session pokes. Encrypted hops that pack up and move.
Keep sim and anti-cheat where they belong. Peers can still talk without your game server in the delivery path. FastPubSub holds the long-lived sockets, fans out globally, and hunts another route when a hop goes sour.
Connect through a nearby edge instead of deploying and maintaining WebSocket clusters around the world.
When a path or relay degrades, live traffic moves to another continuously measured route.
Control who can publish and subscribe for players, parties, spectators, and backend services.
Movement, presence, matchmaking, and session events feel rough when timing swings from one tick to the next.
Different ISPs, mobile carriers, cloud regions, and peering paths can make one match feel different for every player.
For fast coordination, the important message is the one that reaches the session now, not the one stored perfectly for later.
When a path degrades, the overlay reroutes in seconds. Relays measure RTT, jitter, and loss continuously — session traffic keeps moving instead of stalling behind retries.
Browsers and game services connect through a familiar client API while FastPubSub operates the global connection and delivery layer.
Messages are distributed near subscribed player groups instead of forcing every update through a central bottleneck.
Issue scoped tokens that define who may publish to each channel and who may listen: player-to-player sessions, party rooms, spectators, match services, or backend-only control channels.
Keep games, customers, rooms, test environments, and production traffic separated with tenant boundaries, independent channel namespaces, and scoped access tokens.
Integration paths
FastPubSub is engine-agnostic messaging. Peers can communicate without your own game server in the delivery path, while authoritative simulation remains optional application logic.
Use the JavaScript SDK in browser or Node.js projects for room events, presence, signaling, and application-managed state updates.
Use the Rust SDK from a Bevy application, a Rust game service, or a custom backend that publishes and subscribes to live session channels.
Connect through the documented client protocol when your runtime supports it. Native Unity, Unreal, and Godot SDKs are not available today.
Position, presence, lobby, and room state updates for active sessions.
Match updates, countdowns, score changes, and authoritative notifications sent to players.
Client events forwarded to coordination services, observers, or regional processors.
Multiplayer networking FAQ
FastPubSub terminates long-lived client connections at distributed edge locations and fans messages out near listeners. Your game backend does not need to own every player socket or broadcast every update itself.
Publish fresh positions, presence, room state, or session events to logical channels. Subscribers receive live updates independently, so one slow listener does not stall faster players.
The network continuously measures latency, jitter, and loss. When a path degrades, traffic is automatically moved to another measured route while the live stream recovers.
No. Peers can exchange live messages through FastPubSub without your own game server, but authoritative simulation, matchmaking, persistence, and anti-cheat remain separate application concerns when your game needs them.
Yes. Players can publish and subscribe directly through scoped FastPubSub channels without your own server in the message path. FastPubSub relays the traffic, so this is serverless for your application, not a direct device-to-device connection or NAT traversal.
No. It is designed for live state where the newest update matters more than replaying an outdated one. Use durable storage or a queue alongside it for purchases, inventory, and audit events.
See why this managed service is not Kafka, NATS, or RabbitMQ software →
Connect players and services to encrypted realtime pub/sub while FastPubSub handles fan-out and route recovery.