Games
Multiplayer games
Positions, room events, session pings. Players connect to a nearby edge. You skip the regional WebSocket clusters.
Multiplayer details →
FastPubSub Network
Live pub/sub. Paths that heal themselves.
Live pub/sub. Paths that heal themselves.
The mesh is already up. Demos need no login. Or open Cockpit and mint a token.
You publish once. Whoever is subscribed picks it up from a nearby edge. A cable dies, an ISP link goes sour — traffic jumps to another measured overlay hop. Encrypted the whole way.
No global WebSocket farm of your own. Clients just land on the closest edge.
Relays prove who they are. Production traffic never rides in the clear.
Relay dies. Undersea cable gets noisy. The mesh already has another measured route. A few samples vanish. The stream does not.
Fan-out is not stuck on one broker in one region.
Pick a workload
Three calls. Connect, subscribe, publish. Overlay hauls the bytes. Edges fan them out.
Games
Positions, room events, session pings. Players connect to a nearby edge. You skip the regional WebSocket clusters.
Multiplayer details →Fan-out
Quotes, ops events, a ticker on a customer screen. Publish once. Polling is the old way.
Fan-out details →Peers & devices
Signaling. Presence. A sensor that just woke up. Browsers, services, gadgets — they talk through managed relay hops, not through your origin sockets.
Talk about your setup →Platforms
Give customers pub/sub with tokens. Keep the origin away from those sockets. FastPubSub sits in front.
API platform details →Click around
Open two tabs. Or a laptop and a phone. The demo box mints a short access token and hides the master token. Same split you should use in production.
Collaboration
Draw on a laptop, watch it on a phone. Everyone is on the same public channel, 5–60 points a second, with the WebSocket RTT printed on screen.
Miss a dot and nobody cares. Close the tab and the board is gone.
Open Paint Board →Fan-out
One encoder, many listeners. Stations push Opus plus a small snapshot of the current track, so you still see the title if you tune in late. A few stations need a password.
If a frame drops, playback continues. This is live radio over pub/sub, not a library of MP3s and not Icecast with a disk cache.
Open Online Radio →Media
Each room is a tenant. Guests get an invite, the host gets an owner link. You publish your camera and mic on your channels; others subscribe with a pattern. Encode/decode is WebCodecs in the browser (not WebRTC). The demo host only hands out tokens and room state — media does not hairpin through it.
Media encryption for meetings is still off. Treat it as a mesh demo, not a Zoom product.
Open Video Meeting →All demos: demo.fastpubsub.com
Path vs payload
The sample that matters is the one that is true now. TCP waits for every lost byte. Fine for a file. Lethal for a tick stream. FastPubSub spends the budget on a working path. A few samples go missing. That is the deal.
Retransmit. Wait for ACKs. Keep order. One dropped packet parks the queue behind it. The retransmit shows up. The sample is already old.
Good for files and durable logs. Bad for live signals.
No app-level retransmit on the hot path. When the current hop goes sour, the mesh hunts another measured route. During the switch, some messages vanish. The stream comes back.
Fire-and-forget. Encrypted. Relays keep measuring each other.
We do not promise every message. We promise the path.
When links die
Other brokers treat reliability as “every byte must land.” We treat it as “keep the flow alive.” Cable cut. DC gone. BGP flap. DDoS on a peering port. The mesh hunts another hop and keeps shoving traffic.
Receive. Authorize. Route. Deliver. That is the whole hot path. One shot in memory. No disk. No replay buffer.
In, through the mesh, out. Fewer gears. Fewer places to lose a millisecond.
Bootstrap hands the client a shortlist of nearby edges. The client pings them. It sticks to the one that answers fastest.
First hop is measured. Not a region you typed into a config file.
Relays keep scoring paths: RTT, jitter, loss, load. All day. Between DCs.
A path goes sour? The overlay converges on another one in roughly five seconds. Live delivery does not wait for a postmortem.
Relays carry the blob, then copy it close to who subscribed. Nobody parks as the one global choke point.
Kill one relay. Everyone else on the mesh still gets traffic.
Auth should not bounce across an ocean. Local token stores live where people actually connect.
Session data syncs across the mesh. Checks happen nearby. Control still sees one picture.
Master keys do not live on every node. A compromised relay is ugly. It is not a master-key leak.
Transit keeps running while control services or a whole cloud region recover.
Why the overlay exists
Bulk traffic clogs transit. BGP picks policy, not speed. Providers dump packets at the first peering they like. FastPubSub cheats that game in three ways.
Often 5–25 ms less than a detoured or jammed public path. Numbers move. Look at the live map.
Transit routers mix your ticks with everyone else's bulk. Packets sit in shared buffers. You lose milliseconds you never asked for.
We yank the message into the overlay early and send it over cloud and provider backbones that actually exist between those two regions.
BGP wants reachability and policy. Fastest fiber? Optional.
Relays keep measuring each other. Latency. Jitter. Loss. Default path turns ugly — the overlay picks another one it already measured.
Carriers dump traffic at the first public exchange. Extra jitter. Extra miles.
You enter at the nearest edge. The blob stays inside the relay fabric until the far DC.
Hop count is a guess. Relays pick paths from RTT, jitter, and loss they just measured.
Client to edge is encrypted. Relays authenticate each other. Nothing rides in the clear.
Pub/sub and channel names. That is the API. You do not run a worldwide socket farm.
Bootstrap lists nearby edges. The client races them. Fastest ping wins.
Connect, subscribe, publish. Small API. Browsers can use WebTransport. C# and Java wrappers exist in the repo. Not packages yet.
Latest-only. Delta. Fragment. Encrypt. Cap bandwidth. Tokens can also cap KB/s in and out.
FragmentFilter.Jitter shows up on screen. Positions, rooms, session pokes. Players should not feel a bad BGP day.
Dashboards, quotes, customer feeds. Many sockets. Origin should not hold them all.
Shield the origin. Hand out scoped tokens. Run workers active-active. Isolate tenants.
Events hop oceans. Direct Internet routing gets ugly. The stream still has to move.
One PoP dies. One link dies. Traffic moves. That is the point of a mesh.
Encrypted sockets · paths that heal between regions · no disk on the hot path
Relays forward. Edges copy near listeners. No one box in the middle of every fan-out.
No global order on a channel. Each subscriber has its own flow. A phone on 3G does not freeze a trading screen.
Latest state rides measured low-latency hops. History is your problem, on your disk, if you need it.
Rust and JavaScript now. Connect, subscribe, publish. Write the app. Skip the networking scaffolding.
Encrypted global delivery. Measured routing. Failover. Scoped tokens. That core is live. Demos are public. Cockpit and docs are up.
New: Paint Board, Online Radio, Video Meeting — no account. JS SDK @fastpubsub-sdk/client 0.4.x (WebTransport in the browser). Rust SDK fastpubsub-sdk 0.3.x on crates.io.
Mint a token in Cockpit. Or poke the demos first.