Skip to content
News // changelog

Changelog

What's new in GameRelay, newest first. Follow it with RSS. Every SDK release's full notes are on GitHub.

Sign players in with Firebase, Supabase, Clerk or Auth0

  • A signed-in player is now the same player on every device, with their saves and leaderboard entries, and your game needs no server for it. Pick your sign-in provider under Settings → Player sign-in, then pass the ID token your sign-in already has: GameRelay.connect({ publicKey, idToken: () => auth.currentUser?.getIdToken() }).
  • Firebase, Supabase and Clerk have presets; Auth0 and any other OpenID Connect provider work through their issuer. Names come from the account’s username or your game’s playerName, never a player’s full name unless you ask for it. You can also turn off anonymous players, so only signed-in players join.
  • SDK 0.1.0-alpha.17 adds relay.signedIn and two error codes: sign_in_expired (idToken returned an expired token; reconnects ask for a fresh one) and sign_in_required (the game only lets signed-in players join; show your sign-in, then connect again). Games on gamerelay.io/sdk/v0/ have it already. On npm and JSR it's @gamerelay/sdk@0.1.0-alpha.17.

Read the guide →

Test bots for your AI assistant

  • Your AI assistant can now put test players into your live game through the account MCP server. It writes how each bot plays in a few lines of JavaScript, reads what the bot logs, and changes it while the game runs.
  • Your game says what a bot sees and controls with room.bots() (SDK 0.1.0-alpha.11). Bots run in your own tab on localhost, in a locked-down Worker with its network APIs removed, and never in your players’ browsers.
  • racecar is the first game with bots: an assistant can take over one of its AI cars and race it.

Read the guide →

90 days of uptime on the status page

  • The status page now shows the last 90 days as a row of ticks, one per day, for the game server and each relay (the last 30 on a phone). Hover or tap a day for its uptime, how long anything was down and how many times the server restarted.
  • Deploys restart the server in seconds and games reconnect on their own, so they show as maintenance, not down time. Every day with down time is listed under the bars.

Status →

joinOrCreate is stable, smoother entities (SDK alpha.9)

  • relay.joinOrCreate({ maxPlayers, private, updateUrl }) is now part of the v0 promise: it joins the room in the page's invite link, or quick-matches (with private: starts a new room) when there's none or it has closed. It replaces the joinInvite() ?? createRoom() snippet in the docs; a full or locked room still rejects, so tell the player.
  • Moving entities no longer jump a step about once a second next to another entity's keyframe, and updates that arrive late or out of order are placed by time instead of looking like teleports.
  • onLeave: 'host' entities survive a player reloading the page, and when the host role moves before the last changes went out, everyone keeps the room's version instead of a frozen copy or a second onSpawn.
  • Reconnects are sturdier: players who dropped or came back while you were away get player_disconnected / player_reconnected, a broken server greeting fails the connect instead of hanging it, and relay.close() leaves no timers behind.
  • setState refuses the keys constructor, prototype and __proto__ with bad_request (the server refused them, which left the host's state apart), and P2P status lines print only with debug: true.
  • Games on gamerelay.io/sdk/v0/ have it already. On npm and JSR it's @gamerelay/sdk@0.1.0-alpha.9.

Release notes →

Sturdier reconnects and bigger P2P rooms (SDK alpha.8)

  • A reconnect no longer waits forever on a getToken that never answers: it gives up after 15 s and tries again later. connect() still waits as long as your getToken takes, so you can sign the player in first. getToken now gets an AbortSignal: pass it to fetch, or close your sign-in prompt, when the SDK stops waiting.
  • When the host calls room.request() itself, it now times out after 5 s like anyone else's request, instead of waiting forever on a handler that never answers.
  • In rooms of more than 8 players, peer-to-peer connections that were already open stay up (they used to drop after about 20 minutes), and players who couldn't connect directly get connected once the room is back to 8.
  • Sending is faster: each message is written once on its way out, and sizes are counted without copying. The server counts frame sizes faster too.
  • Games on gamerelay.io/sdk/v0/ have it already. On npm and JSR it's @gamerelay/sdk@0.1.0-alpha.8.

Release notes →

Steadier room switches (SDK alpha.7)

  • Joining a room no longer loses the messages that arrive with the server's answer: a state change, a new host or entity updates sent in that same moment reach your new room.
  • A room you left, were kicked from or lost sends nothing any more. Before, a game loop still calling room.send() or setState() on the old room sent into the room you were in now. Now those calls are dropped with a console warning that says why the room closed, request() and the host controls reject with "disconnected", and claim() resolves false. What the old room sends while a join waits for its answer is held, then dropped if you get in or sent if the join fails.
  • A field's precision that isn't a power of ten keeps its own steps: precision 0.25 sends quarters (0.25 used to go out as 0.3). Precision must be a number above 0.
  • Games on gamerelay.io/sdk/v0/ have it already. On npm and JSR it's @gamerelay/sdk@0.1.0-alpha.7.

Release notes →

Games that play inside posts on X

  • Give your game an X embed URL (dashboard → Short links) and its short links play inline when posted on X, as a player card. A room's link takes everyone who opens the post into that room.
  • The embed URL is a page of your game made for a 480×480 frame, on a site that lets x.com frame it. The arena demo does this: post https://gamerelay.io/demo/x to try it.

Short links in the docs →

Relays in Frankfurt and Singapore

  • Player-to-player relays now run in Frankfurt and Singapore as well as San Francisco and New York. Two players race their messages through the relay nearest both of them, so players in Europe and Asia get the fast path too.
  • The check that sets up direct connections also runs near players in Europe and Asia now.
  • Nothing to change in your game.

Everything in one file for AI agents

  • gamerelay.io/llms-full.txt: the llms.txt guide plus the docs, every guide, example and comparison as plain text, for an agent that wants it all in one fetch.
  • Code samples in the docs, guides and examples are syntax highlighted.

llms-full.txt →

A stable SDK line (SDK alpha.6)

  • Load the SDK from gamerelay.io/sdk/v0/gamerelay.js. Within v0, nothing is removed or renamed without a deprecation first: the old name keeps working, with a console warning, for at least 30 days. The old URL serves the same line, so existing games keep working.
  • The API is settled: relay.close() closes everything, every error has a code, fields you shouldn’t assign are read-only, and internals are out of reach.
  • The SDK tells the server its version. If a version gets too old, the console says so and links to what to change.

Versions in the docs →

Limits that protect your game from abuse

  • Saved data is capped at 64 KB per player, and each game has a total from its plan (100 MB on Free, 2 GB on Basic, 20 GB on Pro). Shrinking a save, or overwriting it with one no bigger, always works.
  • One address can't take over a game: it gets at most a quarter of the plan's players online (never fewer than 8), and at most 16 empty rooms.
  • Every limit answers with an error code the SDK already handles (too_large, rate_limited), so games from older SDK versions react sensibly.

Examples from real games

  • A new Examples section: each page takes one problem from a real game and shows the code that solves it. Turn-based chess with moves checked by the host; match, codes, draw offers and rematches; a lobby that lives in a room; AI players the host drives; one clock for every player; hits between players.
  • racecar, our 8-player browser racer, is open source and built on the public SDK only: a full game to read alongside the docs.

Browse the examples →

Guides and honest comparisons

  • Step-by-step guides for adding multiplayer to Phaser, Three.js and Kaplay games, for building one with Claude or ChatGPT, and for putting one on itch.io.
  • Side-by-side comparisons with Playroom Kit, Photon, Colyseus and PartyKit, including when each of them is the better choice.
  • This changelog, with an RSS feed.

Read the guides →

Email notices and support@gamerelay.io

  • Usage warnings by email when an account reaches 80% and 100% of its monthly traffic, once per level per month.
  • Send them to a different address than your sign-in email: Account → Email, confirmed by a link.
  • Write to support@gamerelay.io for help. Addresses that bounce or mark our email as spam are no longer emailed, and the Account page says why.

GameRelay in ChatGPT

  • Both MCP servers work as ChatGPT connectors: the docs server (no account) and the account server, which manages your games, rooms, leaderboards and webhooks.
  • Clients that support MCP Events can react to your game: a new #1 on a leaderboard, a room opening or closing, or a webhook that keeps failing.

Connect an agent →

Host controls and a server browser (SDK alpha.4)

  • The room's host can kick and ban players, lock the room, list or unlist it, resize it and hand the host role over.
  • Room lists show full and locked rooms on request, with a name, custom data and the host for each, and relay.online() says how many players your game has online.
  • Player-to-player relays also accept TLS on port 443, for networks that block UDP.

Player to player, on by default (SDK alpha.2 and alpha.3)

  • Broadcasts also go straight between players, on the same network or through GameRelay's nearest relay, racing the server's copy. Turn it off with connect({ lan: false }).
  • About 18% fewer bytes per relayed message, and connections that recover by themselves after a network change.
  • The SDK is on JSR as well as npm, with release notes on GitHub for every version.

SDK releases →

The SDK is on npm

  • npm i @gamerelay/sdk, published with provenance from the public gamerelay/sdk repo.
  • The sync layer is complete: entities with smoothing, host entities that survive the host leaving, requests, claims, inputs, timers, slots and teams.
  • Console warnings written for the AI that reads them, each naming the section of llms.txt with the fix.

@gamerelay/sdk on npm →

The SDK owns the netcode

  • Declare what exists in your game and who owns it; the SDK sends, smooths and hands it over. No hand-written position messages.
  • relay.tick for a fixed-rate game loop that keeps running in hidden tabs, and a debug overlay with ping, smoothing and traffic.
  • Invite links: room.inviteUrl(), room.shareInvite() and relay.joinInvite().
  • Export your data or delete your account yourself, from the Account page.

Paid plans, sign-in options and a status page

  • Paid plans through Stripe, with a founding price for early accounts.
  • Sign in with Discord or Google, as well as GitHub.
  • A public status page with uptime, players and rooms online, and your own ping.

Plans →

GameRelay

  • Rooms, quick match, lobbies with tags and room lists, parties, chat, saved player data, leaderboards and signed webhooks for browser games, with no server code.