Interactive demos are now public at demo.fastpubsub.com. No FastPubSub account is required. The demo server issues a short-lived access token to the browser; the master token stays on the backend.

• Paint Board — collaborative canvas on a public channel, 5–60 messages per second, live WebSocket RTT. Open demo
• Online Radio — multi-station live audio with Opus frames and metadata snapshots. Some stations are password protected. Open demo
• Video Meeting — mesh pub/sub with WebCodecs, not WebRTC. Each room is an isolated tenant. The demo server is not in the media path. Meeting media encryption is not enabled yet. Open demo

Early access continues in Cockpit (overlays, tokens, passkeys) and developer docs.

JavaScript SDK @fastpubsub-sdk/client 0.4.4 and Rust SDK fastpubsub-sdk 0.3.3 are published.

• WebTransport — a real browser transport (not a stub), with unidirectional subscribe lines. Node.js without a WebTransport global is not supported yet.
• Token lifecycle — refresh and revoke access tokens from a trusted backend that holds the master token.
• Link quality — application PING/PONG on an open WebSocket, with RTT samples in the client.
• Delivery modes and edge cache — broadcast or deliver-one publish options, plus a longer-lived nearest-edge cache that re-checks latency.
• Token bandwidth rights — optional ingress and egress kilobyte-per-second caps on the access token.

Install with npm install @fastpubsub-sdk/client or add fastpubsub-sdk from crates.io.

The FastPubSub JavaScript SDK is now published on npm: @fastpubsub-sdk/client. It works in the browser and in Node.js, with a small client API for connecting, publishing, and subscribing to channels over WebSocket.

Install it with:

npm install @fastpubsub-sdk/client

Together with the Rust SDK on crates.io, developers can now integrate FastPubSub from both backend and frontend code without writing the low-level protocol by hand.

Live demos built on this SDK are now public: demo.fastpubsub.com.

We published the first FastPubSub Rust SDK: fastpubsub-sdk on crates.io. It is the first step toward making FastPubSub easy to use directly from application code.

The Rust SDK gives developers a simple client library for connecting to FastPubSub, publishing messages, and subscribing to channels without writing the low-level WebSocket protocol code by hand.

We are also preparing the JavaScript SDK. The goal is to make browser and Node.js integration just as simple, with a small client API for real-time pub/sub use cases.

We are building the next version of FastPubSub around a fully decentralized architecture with no single point of failure.

To keep this transition focused and reliable, we temporarily paused the testnet and dashboard while the new version was being finalized.

Update: the live network dashboard is back at dashboard.fastpubsub.com.

Today we launched dashboard.fastpubsub.com — a real-time monitoring dashboard for the FastPubSub overlay network.

The dashboard shows a live world map of all active PoPs (Points of Presence) and the connections between them. You can see in real time how our overlay routes compare to direct internet paths: which routes are faster through the overlay, where the public internet has problems (unreachable hosts, abnormally slow links), and how much latency we save on each hop.

• Live latency map — every node and every measured route between them, updated in real time via WebSocket.
• Overlay vs Direct comparison — each route shows the direct internet RTT and the overlay RTT side by side, with the saving in milliseconds and percent.
• Network anomaly detection — unreachable routes (ping timeout) and abnormally slow routes are highlighted separately so you can see where the public internet is struggling.
• Adjustable filters — sliders to set the minimum saving threshold and the slow-route threshold, so you can focus on the routes that matter.

The dashboard itself is built on top of FastPubSub — it uses our own WebSocket pub/sub infrastructure to stream measurement data from every PoP to the browser. It is both a monitoring tool and a live demo of the network in action.

We are also getting ready to build the first SDKs. The goal is to provide simple, lightweight client libraries for major languages so developers can integrate FastPubSub into their applications with just a few lines of code. More details on SDK plans coming soon.

We are excited to share that our MVP is actively evolving and already has core functionality working end-to-end. Here is what we have operational today:

• Overlay Network — Our custom overlay mesh built on QUIC/UDP is up and running. Brokers discover each other, establish encrypted tunnels, and form a resilient topology independent of public internet routing.
• Latency-Based Routing — Brokers continuously measure round-trip times between each other and compute the fastest paths using a measured-path routing. Traffic is routed through the lowest-latency path in real time.
• Access Tickets — Our authentication layer is in place. Clients receive scoped access tokens that grant them permission to publish or subscribe to specific channels. This ensures that only authorized participants can interact with the network.

The foundation is solid and we are now focused on hardening these components, improving observability, and preparing for the first external testers. Stay tuned for more updates as we move toward a public beta.