Multiplayer that
drops into your stack.

From card games to co-op to competitive shooters, write plain typescript with the stack you already use and verify it works with tests that don't take up your time.

Get started $npx irtio init

catch-object

friction-stop

contested-grab

drag to grab · right-click to reshape

Drops into the stack you already ship: Three.jsPhaserCanvasViteVercelNetlify

Your agent already speaks irt.io.

Multiplayer is hard for agents. Lots of moving parts that aren't normally testable. irt.io handles the hard parts and gives your agent the tools to test and verify behavior without a human in the loop.

Try it yourself:

Write a plan to add multiplayer with irt.io

Docs written for agents

An llms.txt, a context-window-sized integration guide, and copy-paste retrofit recipes. Your agent gets the room model right the first time.

Verified without a human

Agents can't open two browsers or line up a shot but they can write a spec, run multiplayer agents against your server, and read the result.

A shape agents get right

One room structure, types that fail loudly, and errors written as the fix. Uniform enough that the wrong thing is a red squiggle, not a runtime surprise.

Read the agent integration guide

Party quiz · event mode + RPCs

Trivia Night

Phones are the controllers, the TV is the host. Different roles see different state. Answers come in as typed RPCs the server scores, and the room hibernates between rounds, so an idle lobby costs almost nothing.

How it's built

Choose the level of control you need.

One size does not fit all but depending on your game or app you choose how much to leave up to the clients.

Relay

For games and apps with full client trust joinRoom() syncs shared state and relays messages between clients. No server code needed.

Ownership

Co-op games and limited trust. Each player owns their own objects. Their changes sync to everyone, with optional server-side validation to clamp or reject impossible actions.

Fully authoritative

For competitive games that can't allow cheats. Zero trust. The server runs the competitive logic so players can only do what the rules allow.

Read our guide to picking the right model

Orbit: a massively multiplayer arena game

Arena · server-authoritative + AOI

Orbit.io

Hundreds of players in one arena. The server owns every cell, and each client only receives what's near it to keep bandwidth flat no matter how crowded it gets.

How it's built

Verifiably correct.

Write a spec, and simulated players. Real multiplayer agents that run against your server. Catch mispredictions, visibility leaks, and race conditions before the changes go live.

See how testing works

$ npx irtio test

two players grab one crate, one wins no client sees state outside its view crate-7: 41 snaps · depends on non-predicted body reconnects within the grace window 3 passed · 1 warning · trace → ./traces/run-08.json

Async board game · no player hosts

Gambit

A match can last days. The room wakes when a move arrives, validates it on the server, notifies the other player, and sleeps again. No host to stay online and nothing to pay while it waits.

How it's built

And the hard parts, handled.

Plain TypeScript, no lock-in

Your server is a normal TypeScript project with the same language, types, and tooling as your client. No proprietary DSL, no database paradigm to learn, no runtime you can't read.

No player hosts

There's no host whose tab ends the game when it closes. Rooms live on the server so worlds persist, turn-based games wait for the next move, and a match survives a dropped player.

No servers to run

Matchmaking, regions, scaling, and sockets are handled. You get a room and a link. As simple to ship as the site you already push to Vercel or Netlify.

Co-op physics · ownership + voice

Salvage

Two to six players haul physics props out of a level. Each player owns and predicts their own character, the server runs the Rapier simulation, and proximity voice is one joinVoice() call.

How it's built

Write multiplayer like the rest of your code.

Same language, same types, one project. Use as much authority as your project needs.

Call server functions

Typed RPCs, defined once and implemented on the side that answers. Deal a hand, resolve a turn. The logic that has to be fair lives on the server.

RPCs

blackjack

// client: call it like a local function
const { cards } = await room.call.deal({ count: 2 });

// server: the server deals from one deck
deal(state, { count }, ctx) {
  return { cards: state.shoe.draw(count) };
}

Own your objects

onJoin hands each player ownership of its entity. The client then writes to what it owns like local state; the server syncs it to everyone and can veto the change.

Ownership

co-op platformer

// server: onJoin gives each player ownership
onJoin(state, ctx) {
  state.players.add(ctx.clientId,
    { x: 0, y: 0 },
    { owner: ctx.clientId });
}

// client: move what you own, like local state
const me = room.state.players[room.me];
me.x += dx;

Run it on the server

The client sends an input as a typed RPC; the server's handler validates and applies it, and the tick advances the simulation. Cheating never touches authoritative state.

Authority and prediction

fps

// client: send an input as a typed RPC
room.rpc.fire({ angle, power });

// server: the handler turns it into a bullet
fire(state, { angle, power }, ctx) {
  const p = state.players[ctx.clientId];
  state.bullets.add({ x: p.x, vx: Math.cos(angle) * power });
}

// server: the tick advances + resolves them
tick(state, dt) {
  for (const b of state.bullets) b.x += b.vx * dt;
  resolveHits(state);   // authoritative
}

How irt.io compares.

	irt.io	Playroom	Colyseus	SpacetimeDB
Zero setup	Yes	Yes	No	Partial
Server authority	Yes	Host	Yes	Yes
Prediction and physics	Yes	No	DIY	DIY
Voice	Yes	No	No	No
Agent-driven testing	Yes	No	No	No
Rooms outlive players	Yes	No	Yes	Yes
Nothing to deploy	Yes	Yes	No	Hosted

Full comparison in the docs

One dashboard for your live game.

Stay in control of your live game with a single dashboard.

Moderate live. See who's connected and in which room, then kick, ban, or mute in a click or wire the same actions into your own admin tools.
Statistics. See concurrent players, room counts, tick cost, reconnects, and handler errors for each deployment.
Usage. CPU, data out, voice minutes, and storage against your plan, with alerts before you hit a cap.

Explore the dashboard

Rooms live128

Players3,412

CPU42%

Egress today18 GB

concurrent players · last 7 days

bluefox · rm-3f2MuteKick

nova · rm-3f2MuteKick

Dead-simple pricing.

Pay for what you use. No seats, no surprises.

CPU

Server compute your rooms actually use.

Data out

Bandwidth from the server to your players.

Voice minutes

Per participant, per minute of voice.

Storage

Snapshots and saved game state.

Cheaper than a server,
scales with your game.

A traditional server means picking something that handles your peaks but sits unused the rest of the time. irt.io hibernates your instances when they're not in use, so you only pay for what you actually need.

And when your game grows, irt.io scales with it, without you thinking about servers and infrastructure.

Free while you prototype

Build and test for free. No credit card. Allowances reset daily, and prototype storage is wiped each night, so you can iterate as much as you want.

[X] CPU hours / day [X] voice minutes / day [X] GB egress / day [X] GB storage, wiped nightly