Your game,
your code,
with in real time.io

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.

Get started $npx irtio init

Server-side code RPCs Client-side prediction Lag compensation Physics Matchmaking Leaderboards Voice chat Persistent worlds Interest management Bots

Multiplayer hosting on demand.

Every room is a micro server that runs your code. It starts when players join and sleeps when players leave. Infinite scaling and free when no one is playing.

One command deploy

Deploy bundles your room, updating your server code and optionally your static assets too. You get a URL players can join. Roll back to any version with the same command.

How deploys work

$ irtio deploy

bundled room.js (9f2c1d84ab30) 2 additive change(s) uploaded bundle deployed v7 reachable at https://torches-out.irt-serve.com

Rooms start when players join

Rooms sleep when empty, wake in 66 ms and cost nothing while they sleep. Event based games sleep between every player action.

Lulls and spikes handled for you

Don't let your game crash right when it goes viral and don't overpay when demand is low. Empty games cost nothing and your game can spike to thousands of players instantly.

Simple pricing

No CCUs. Pay for the time your rooms are active on the CPU you need and not for player count. Efficient code gets rewarded.

Read how rooms sleep and wake

Quiz: a phones-as-controllers party quiz

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.

Try it How it's built

Choose the level of control you need.

One size does not fit all. Depending on your game or app you choose how much authority 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 can 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 cheaters. 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

Arena · server-authoritative + AOI

Plankton

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

How it's built

Write multiplayer like the rest of your code.

Same language, same types, one project. Call functions on the server right from your client code.

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 any 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 a shot as a typed RPC. The server rewinds to the tick the shooter was looking at and checks the hit there, so a shot that landed on their screen lands on the server. Cheating never touches authoritative state.

Lag compensation

fps

// client: fire along your aim
room.call.fire({ dir });

// server: rewind to the tick the shooter saw
fire(state, { dir }, ctx) {
  const at = ctx.clientTick ?? ctx.tick;
  const eye = eyeOf(ctx.clientId);
  return ctx.room.rewind(at, (past) => {
    const ray = new Ray(eye, dir);
    const hit = past.rapier.world.castRay(ray, 100, true);
    const who = hit && past.rapier.who(hit.collider);
    if (who) state.players.get(who.id).hp -= 25;
  });
}

Multiplayer action · relay without player hosts

Bombs

Players place and avoid bombs over relay but using irt.io's stateful relay the server maintains state so late joiners and reconnections are handled seamlessly.

How it's built

And the hard parts, handled.

Client side prediction

Client inputs applied instantly and local physics simulation.

Reconnection

Players resume their sessions seamlessly after a disconnect.

Hosting

Servers, regions, and cloud infrastructure managed automatically.

Replays and clips

Record and playback game sessions, and capture highlights.

Lag compensation

Rewind time to apply player inputs when they arrive late.

Physics

Physics scenes in lockstep across all clients.

Numbers you can check.

Every figure below is a real measurement in production. Last run August 2026.

120 ms join a live room

Median over consecutive joins to a running room, through TLS.

0.5 s wake a sleeping room

Median of 50 joins to hibernated rooms. A room that slept for days is playable on the first connect.

200 players in one arena room

At 1.7 kB/s per player interest management keeps bandwidth flat as rooms fill.

17 kB client SDK, gzipped

Client, schema, and protocol together. Physics loads lazily, only if your game uses it.

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

Verifiably correct.

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

Make your agent prove its work. With AI agents working autonomously, being able to verify your multiplayer logic is critical. A test suite lets agents run simulations and validate their behavior before they call it done.

See how testing works

catch-object

friction-stop

contested-grab

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 and predictable so agents get it right first try.

Read the agent integration guide

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. Room-hours, voice minutes, and storage against your plan, with alerts before you hit a cap.

Explore the dashboard

Rooms live128

Players3,412

Room-hours612

Egress today18 GB

concurrent players · last 7 days

bluefox · rm-3f2MuteKick

nova · rm-3f2MuteKick

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 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.

100 room hours / month 10 rooms active at a time 400 voice minutes / month 100 GB data out / month

See the full pricing page

Your game, your stack, in real time.

Add multiplayer to your game, verify it with agents, and share a link.

$npx irtio init Get started

Your game,your code,with in real time.io

Multiplayer hosting on demand.

One command deploy

Rooms start when players join

Lulls and spikes handled for you

Simple pricing

Trivia Night

Choose the level of control you need.

Relay

Stateful Relay

Ownership

Fully authoritative

Plankton

Write multiplayer like the rest of your code.

Call server functions

Own your objects

Run it on the server

Bombs

And the hard parts, handled.

Client side prediction

Reconnection

Hosting

Replays and clips

Lag compensation

Physics

Numbers you can check.

Salvage

Verifiably correct.

Your agent already speaks irt.io.

Docs written for agents

Verified without a human

A shape agents get right

How irt.io compares.

One dashboard for your live game.

Dead-simple pricing.

Cheaper than a server,scales with your game.

Free while you prototype

Your game, your stack, in real time.

Your game,
your code,
with in real time.io

Cheaper than a server,
scales with your game.