WebTransport · datagram rooms

WebTransport rooms that start instantly, scale to zero, and hide the QUIC plumbing.

The E2B of UDP. Spin up a real-time room in under 100 ms, pay nothing while it sits idle, and never touch the QUIC, cert, or routing plumbing.

<100ms
Cold start
~20Hz
Presence
$0
When idle
room :: /room/graveyardrelay · pure
peers [3]  p_01p_02 p_03presence ▸ datagram · ~20hz
// HOW IT WORKS · DATAPLANE

From join() to first packet, the QUIC plumbing is yours to ignore.

One WebTransport connection, two lanes, and a room that doesn't exist until you arrive. Here is the exact path an inbound packet takes.

DATAPLANE — INGRESS PATHREV · v0
CLIENTEDGEFIRECRACKER µVMpresencedatagrams · unreliableeventsstreams · reliableQUICEDGECID ROUTERdemux · Connection-ID⟂ NETNSroom/graveyardpure relay · scale-to-zeropeers: 2presence ⇄ eventsCOLD → WARM <100mswithin 1× PTO (~1s) · RFC 9002
presence · unreliable · droppableevents · reliable · ordered
  1. 01.
    CONNECT

    Open a room

    joinRoom() opens one WebTransport (QUIC) connection to a room URL. WebTransport hit browser Baseline in March 2026 — no socket fallback, no cert dance, no plumbing of your own.

  2. 02.
    ROUTE

    Edge demuxes by Connection-ID

    The edge reads each inbound QUIC packet's Connection-ID and forwards it across the netns boundary to the exact microVM serving that room. The netns-crossing dataplane is proven live.

  3. 03.
    WAKE

    Scale-to-zero, wake-on-packet

    An idle room doesn't exist. The first inbound packet wakes its Firecracker µVM in <100ms — inside the QUIC handshake's ~1s retransmit window (1× PTO, RFC 9002), so the client never sees the cold start.

  4. 04.
    SPLIT

    Two lanes, one room

    presence rides unreliable datagrams (latest-wins, ~20Hz, droppable); events ride a reliable ordered lane. A plain WebSocket can't do the unreliable lane — it head-of-line-blocks under loss.

03// QUICKSTART

Your first room in five lines.

No QUIC handshake, no cert pinning, no server to deploy. The default room is a pure relay — join it, set your state, listen for everyone else's. The two lanes ride one WebTransport connection.

// INSTALL
$npm i @silt/client
hello-room.ts
// 1. join a room — a pure relay, zero server code
import { joinRoom } from "@silt/client";

const room = await joinRoom("https://demo.silt.run/room/graveyard", { id });

// 2. others' positions stream in on the datagram lane
room.on("presence", (peerId, state) => draw(peerId, state));

// 3. broadcast yours — latest-wins, ~20Hz, droppable
room.presence.set({ x, y, heading });
presence · datagramevents · reliable
04// CAPABILITIES

Built for datagram-rate realtime.

The plumbing a multiplayer, live-media, or telemetry workload needs — the unreliable lane, instant cold starts, and nothing to operate when idle.

// TRANSPORT

Two lanes, one connection.

Presence rides unreliable datagrams — latest-wins, droppable, a ~20 Hz firehose. Events ride a reliable, ordered stream. A plain WebSocket has only one lane, so it head-of-line-blocks under loss.

presence
events
// IDLE

Pay nothing at rest.

A room doesn't exist until someone arrives. No traffic, no VM, no bill.

$0 / idle
// COLD START

Woken on the first packet.

The room VM restores inside the QUIC handshake's retransmit window — the client never sees the cold start.

<100ms
// SERVER CODE

Zero server code.

The default room is a pure relay. Bring a client and skip the backend entirely.

0 LOC server
// PLATFORM

WebTransport, Baseline.

Shipped across browsers in March 2026 — the iOS blocker is gone. Real UDP in the browser, no plugins.

2026 baseline
05.
// COMPARE · POSITIONING_MATRIX

Every alternative wins a column. Only one wins them all.

A WebSocket gives you one reliable lane. Serverless scales to zero but can't speak datagrams. A game-server fleet speaks UDP but never sleeps. Silt is the only one with both lanes, true scale-to-zero, and zero QUIC plumbing — in one place.

capability
Plain WebSocket
ws://
HTTP serverless
CF Workers
Server fleets
Agones
silt
the answer
Unreliable datagram lanepresence · latest-wins · ~20Hz
HOL-blocks under loss
no datagram path
raw UDP, self-run
presence lane
Reliable ordered laneevents · ordered · delivered
the only lane
request/response
DIY
events lane
Both lanes, one connectionthe two-lane model
DIY, two sockets
core differentiator
True scale-to-zeronothing running when idle
always-on server
HTTP only
coarse warm fleets
wake-on-packet
Cold start < 100msfirst packet to live room
persistent
JS isolates
fleet warmup
<100ms restore
Passes UDP datagramsend to end, not terminated
HTTP front door
QUIC / WebTransport
Zero QUIC / cert / routingno plumbing to operate
you run it
managed, no UDP
you run the fleet
fully managed
 supported  partial / DIY  not possible  n/a// faithful — not strawmanned