Your game,
in real time.
From card games to co-op to competitive shooters. Write plain TypeScript with the stack you already use and deploy it to servers that cost nothing when empty.
Multiplayer hosting, on demand.
You write the room, we run it. Every room is a server that starts when the first player joins, stays up while they play, and saves itself when the last one leaves. There is no fleet to size, nothing to keep warm, and no player's machine acting as the host.
One command to ship it
Deploy bundles your room, compares the new schema against the version that is live, and refuses a breaking change unless a migration covers it. You get a URL players can join. Rolling back is the same command with a version on it.
How deploys workRooms start when players do
A sleeping room resumes from a snapshot in 66 ms, and a player who opens a link is playing about half a second later. Between sessions nothing runs and nothing bills.
State survives the sleep
The room saves before it hibernates and restores when it wakes, so a world can sit for days and come back where it stopped. Player storage outlives the room entirely.
Sizes, not servers
Room types declare a size class and we place them. Your project's rooms share a CPU allowance with each other and with nobody else, and capacity grows with your game.
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 builtChoose 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.
Stateful Relay
At no extra cost relay rooms maintain state on the server, players send updates and changes sync to everyone. Re-join and late-join, more players supported.
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.
Plankton
Hundreds of players in one arena with bots. 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 builtWrite 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// 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// 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// 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 }
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 builtAnd 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.
Cheating stops at validate
Every owned write passes a validate rule before the server accepts it, so a client that lies gets a correction instead of an advantage. Anything a player could win by lying about is server-owned and changed through an RPC.
Numbers you can check.
Every figure below is a real measurement against production, not a target. Rerun August 2026; methodology in the docs.
Median over consecutive joins to a running room, through TLS.
Median of 50 joins to hibernated rooms. A room that slept for days is playable on the first connect.
1.7 kB/s per player and zero disconnects over a 3 minute bot run. Interest management keeps bandwidth flat as rooms fill.
Client, schema, and protocol together. Physics loads lazily, only if your game uses it.
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 builtVerifiably 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 worksYour 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:
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.
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 |
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. Room-hours, voice minutes, and storage against your plan, with alerts before you hit a cap.
Dead-simple pricing.
Pay for what you use. Free while you build, $9 a month once you ship, and no seats at any point.
Room-hours
One room awake for an hour, however many players are in it. Empty rooms hibernate and the meter stops. From $0.0025 an hour.
Voice minutes
Per participant, per minute, and only if you turn voice on. $0.002 a minute.
Storage
Saves, snapshots, and the files you deploy. 5 GB free, 50 GB on Indie, then $0.25 per GB-month.
Data in and out is free
Bandwidth is not a meter. Free projects stop at 100 GB a month, Indie is fair use for game traffic.
Rooms come in sizes, and the size sets the rate: Small is the default at $0.0025 an awake hour, Medium and Large cost more because they get more memory and more CPU. Relay rooms run no code of yours and cost $0.001 an hour, which is $0.72 to leave one running all month.
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 rooms 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.
Your game, your stack, in real time.
Add multiplayer to your game, verify it with agents, and share a link.