Built on WebTransportBaselineNewly available2026✓ Chrome · Edge · Firefox · SafariUDP-class datagrams in the browser ↗ — UDP-class datagrams, in the browser
Real-time game servers that scale to zero and wake in ~70ms — with rooms, relay, and presence handled, and no netcode to write.
// your whole server — Silt runs the loop
import type { Room } from "@siltrun/room";
export default {
tick(state = { players: {} }, inputs) {
for (const ev of inputs) {
if (ev.kind === "join") add(state, ev.id);
if (ev.kind === "leave") drop(state, ev.id);
if (ev.kind === "input") move(state, ev);
}
return state; // broadcast to everyone
},
} satisfies Room<{ players: Record<PlayerId, Drifter> }>;// your frontend — join a room, stream presence
import { joinRoom } from "@siltrun/client";
const room = await joinRoom(url, { id });
// draw peers as their presence datagrams arrive
room.on("presence", (id, s) => draw(id, s));
room.on("join", (peer) => add(peer.id));
room.on("leave", (id) => remove(id));
// broadcast your own cursor at ~20Hz
setInterval(() => {
room.presence.set({ x, y, heading });
}, 1000 / 20);Go live and move your cursor in one browser — your motion turns into real presence datagrams that cross the relay into the other browser as they happenGo live and watch presence stream from one browser into the other — real datagrams crossing the relay as they happen. The relay and room read out the actual throughput moving between them. None of it is simulated — it’s the platform running on itself, live.
Hit play and you’re flying. Share the URL and anyone who clicks lands in the same arena — no install, no account, no lobby.
Scaffold a project, install it, and run it locally. It’s one TypeScript room file, with no netcode to write and no server to stand up.
Every package here is public on npm. Nothing to sign up for.
// join a room by URL — one WebTransport connection
import { joinRoom } from "@siltrun/client";
const room = await joinRoom(
"https://your-relay.example/room/lobby", { id });
// others' positions stream in on the datagram lane
room.on("presence", (peerId, state) => draw(peerId, state));
// broadcast yours — latest-wins, ~20Hz, droppable
room.presence.set({ x, y, heading });Write a room’s logic like a Cloudflare Worker, get presence and events like Liveblocks — one TypeScript file, no netcode.
import type { Room } from "@siltrun/room";
const clamp = (v: number) => Math.max(0, Math.min(520, v));
export default {
tick(state = { ships: {} }, inputs) {
for (const ev of inputs) {
if (ev.kind === "join") state.ships[ev.id] = { x: 260, y: 140 };
if (ev.kind === "leave") delete state.ships[ev.id];
if (ev.kind === "input") {
const s = state.ships[ev.from];
if (s) { s.tx = clamp(ev.data.x); s.ty = clamp(ev.data.y); }
}
}
for (const id in state.ships) {
const s = state.ships[id];
if (s.tx == null || s.ty == null) continue;
s.x += (s.tx - s.x) * 0.1;
s.y += (s.ty - s.y) * 0.1;
}
return state;
},
} satisfies Room<State, Cmd>;Your room runs in a Firecracker microVM: nothing to run or pay for while it’s idle, and the first packet wakes it in ~70ms — before the player feels it.
Every alternative forces a trade-off; Silt doesn’t. Both lanes over one WebTransport connection, rooms that scale to zero, and none of the QUIC plumbing to run.
Push a room’s logic, get a URL, and watch it run — waking on the first player, scaling to zero when the last one leaves.
Live today, and building the rest with you.
Come tell us what you’re building. Want one email at launch and nothing else?Join the launch list.
Web multiplayer should have had real infrastructure years ago. WebTransport finally makes it possible, and Silt is building it. The packages are on npm and free to build with; preorder founding‑member access to help make the rest real.
We'll email you once, at launch. The day-to-day happens in theDiscord — come tell us what you're building.
Straight answers to the common questions.
Yes. The packages are on npm: npm create siltrun@latest scaffolds a room and a client, npm install pulls them down, and npm run dev runs the whole thing locally in two browser tabs. The client SDK is @siltrun/client. Nothing to sign up for.
Yes. Run siltrun login to sign in with GitHub, then siltrun deploy room.ts. The deploy is keyed to your account, and every room you ship shows up at console.silt.run with its status, its URL, and its live state. Hosted rooms are capacity-limited during the beta, so a deploy can be refused when the beta is full. Local development has no gate at all: npm run dev needs nothing from us.
To get presence and messaging working, no — you bring a client, and Silt runs the transport, routing, and room lifecycle for you. When your game needs a server to decide what’s actually true — hits, scores, who owns what — you write that logic and Silt runs it in a compute room. Drift’s game logic runs this way today, and you can ship a compute room of your own with siltrun deploy.
Yes. WebTransport reached browser Baseline in March 2026, including iOS. No plugin, no socket fallback.
Baseline status on MDN →They do — they just don’t feel it. The first packet restores the room’s VM in about 70 ms, inside the QUIC handshake’s ~1 s retransmit window, so the connect isn’t delayed.
A room handles ~20–25 players today, measured with real game payloads on one small box — presence packets are ~290 bytes at 15–20 Hz, with spectators beyond. Interest management, on the roadmap, is aiming for ~100 players per room. Bigger worlds span many rooms — each room is an independent microVM, so world scale is horizontal.
Traction and servers. The preorder shows us builders actually want this, and it funds the infrastructure that opens the platform up — the hosted rooms and compute that let you deploy your own games. It isn’t payment for a finished product; it’s what gets it built. You get founding-member status, the $49 rate locked for future paid plans, and the first year of the hobby tier free when the hosted platform ships.
Not currently. The client SDK is headed for open source — it's the part you should be able to audit. The relay and platform are the hosted product and stay closed. No dates promised.
No — the relay and room infrastructure aren't distributed; Silt is the hosted platform. What you run on Silt is your own code: you write the server logic that decides what's true in your game, and it runs in a Silt compute room — that's the product. Drift works exactly this way today.
Today, Silt is built for TypeScript developers — @siltrun/client is a TS client for the browser. What comes next follows what the community actually needs.
No. Treat it like backing a project rather than buying a product. The $49 funds the build. What you get today is founding-member status, the locked rate, and the first hobby-tier year when the platform ships. If you'd rather not spend anything, the packages on npm are free and always will be.
