multiplayer rooms · webtransport

Build a browser multiplayer game. Silt runs the netcode.

Join a room from the browser with @silt/client — no QUIC, certs, or routing to set up. Two lanes over one WebTransport connection: presence (unreliable, ~20 Hz) and events (reliable, ordered). Rooms scale to zero: $0 idle, ~70 ms cold wake.

Play the demo Join the waitlist

Demo · live 2-player rock-paper-scissors

~70ms
Cold wake: ~20Hz
Presence: $0
When idle

room :: /room/:idcompute room

peers [3] p_01p_02 p_03presence ▸ datagram · ~20hz

// HOW IT WORKS · DATAPLANE

What Silt handles when a player joins a room.

Silt runs the transport, routing, and room lifecycle. Here is the path an inbound packet takes, from the browser to the room VM.

DATAPLANE — INGRESS PATHREV · v0

presence · unreliable · droppableevents · reliable · ordered

01.
CONNECT
One WebTransport connection
joinRoom() opens one WebTransport (QUIC) connection to a room URL. WebTransport reached browser Baseline in March 2026, including iOS. No socket fallback, no cert setup.
02.
ROUTE
Routed by Connection-ID
The edge reads each inbound QUIC packet's Connection-ID and forwards it across the netns boundary to the microVM running that room. Two clients on the same URL reach the same VM. Proven live.
03.
WAKE
Scale-to-zero, wake-on-packet
An idle room has no running VM. The first packet restores its Firecracker µVM in ~70ms — inside the QUIC handshake's ~1s retransmit window (RFC 9002), so the client's connect isn't delayed.
04.
SPLIT
Two lanes, one room
presence rides unreliable datagrams (latest-wins, ~20Hz); events ride a reliable, ordered stream. A WebSocket has one lane and head-of-line-blocks under loss.

03// QUICKSTART

The @silt/client shape, in five lines.

No QUIC handshake, no cert pinning, no server to deploy. Join a room by URL, set your presence state, listen for everyone else's. The two lanes ride one WebTransport connection. This is the client API shape — point it at your own relay to run it.

Presence rooms are inearly access — the sample above illustrates the API; it isn't a live room you can join today.

// INSTALL

$npm i @silt/client

Read the quickstart→The two-lane model ↗

●hello-room.ts

// 1. join a room by URL — one WebTransport connection
import { joinRoom } from "@silt/client";

const room = await joinRoom("https://your-relay.example/room/lobby", { 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

Two lanes, scale-to-zero, no backend.

The transport a realtime multiplayer game needs: an unreliable presence lane, rooms that scale to zero at $0 idle, and a pure-relay default that needs no server code.

// TRANSPORT

Two lanes, one connection.

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

presence

events

// IDLE

$0 while idle.

A room has no running VM until a client connects. No traffic, no VM, no charge.

$0 / idle

// COLD START

~70ms cold wake.

The first packet restores the room VM inside the QUIC handshake's ~1s retransmit window, so the client's connect isn't delayed.

~70ms

// SERVER CODE

No server code required.

A relay room needs no server code — bring a client, the backend is optional.

0 LOC server

// PLATFORM

WebTransport, browser Baseline.

WebTransport reached browser Baseline in March 2026, including iOS. Real UDP in the browser, no plugin to install.

2026 baseline

05.

// COMPARE · POSITIONING_MATRIX

Silt versus the alternatives.

A WebSocket has one lane and head-of-line-blocks under loss. HTTP serverless scales to zero but can't pass datagrams. A game-server fleet passes UDP but runs warm, and you operate it. Silt has both lanes, scales to zero, and runs the QUIC layer for you.

capability

Plain WebSocket

ws://

HTTP serverless

CF Workers

Server fleets

Agones

silt

webtransport

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 wake ~70msfirst packet to live room

—persistent

✓JS isolates

✕fleet warmup

✓~70ms 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

06// WAITLIST

Join the waitlist, or back the build.

Silt is early and built in the open. The dataplane is proven on real hardware; compute-in-the-room is next. Join the waitlist for launch, or preorder founding-member access now.

// WAITLISTearly access

// FOUNDING MEMBER

$49one-time preorder

Silt is early — this preorder funds the build. You get founding-member status, this $49 rate locked for future paid plans, and the first year of the hobby tier free when the hosted platform ships.

→Founding-member status
→$49 rate locked for future paid plans
→First year of the hobby tier, free at launch

Back Silt — $49

preorder — this funds the build, not a finished product