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.

We are also preparing several interactive demo projects on FastPubSub.com that show real-world use cases built on top of the network. The first examples include:

• Online Radio — multi-station live audio streaming with metadata snapshots and low-latency Opus frames over pub/sub channels.
• Paint Board — collaborative dot painting where many clients share a canvas in real time through a public channel.

More demos are on the way. They will serve as both live showcases of FastPubSub and reference implementations you can learn from when building your own applications.

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 are temporarily pausing the current testnet and dashboard while the new version is being finalized. We will bring both back online as soon as the updated network is stable.

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.