Skip to content
kumo

Game servers and matchmaking

kumo can host a multiplayer game’s dedicated match servers and its matchmaker. You set up no servers, no Docker files and no matchmaker of your own: a release puts your server build on kumo, players are matched, and each match starts on a host near them in seconds.

Game servers is in Builds, after Releases. It has two tabs: Servers and Matchmaker.

  • Warm hosts, a match each container. In each region you pick, kumo keeps hosts running with room for the next matches, so a match starts in seconds rather than waiting for a machine to boot. When players come, hosts are added; when they leave, a host stops taking matches, and is removed after its last one ends.
  • Only your game on your hosts. A host carries only your studio’s matches. It admits only the game’s ports; nobody gets a shell on it.
  • The region nearest the players. The matchmaker sends the players’ pings to each region, and the match goes where they play best.
  • A lease per match. A server tells kumo it is alive every few seconds. A server that stops doing so is stopped, and so is its billing.

Regions: Europe, US East, US West and Southeast Asia.

The Servers tab shows:

  • Regions: the regions your matches run in, the price an hour of a host in each, and how many free slots kumo keeps ready there (the minimum and most hosts, and the free slots to keep, can all be 0).
  • Matches: every match, its region, players and state, from Waiting for room to Playing to Ended. Output shows what its server printed (kept 7 days). Stop ends it.
  • This month: what the servers have cost, against your ceiling.
  • Hosts: the host size (S, M or L) and how many matches each host runs.
  • Versions: the live version and the one before it.
  • Keys: the matchmaker’s key and the release key.

A live game never stops at a spending cap. The owners are told at 80% and at 100% of the ceiling. Past it, no new host starts, and matches on the hosts already running go on. Set it to 0 for no ceiling.

A release puts the server build in your studio’s image registry and makes it the live version, together with the game’s client: both go live or neither does. New matches start on the live version; matches already playing finish on theirs. Roll back makes the version before it live again, the same way.

In the release step, choose kumo as the server target and give it the release key (kumoreleasekey). kumo keeps the newest few versions (versionstokeep, at least 2) and never removes the live one or the one a rollback returns to. The registry is your studio’s alone, and keeps its images in a storage bucket only your studio’s registry can open; hosts in every region pull from it directly.

Before a release, the build’s smoke test starts the server as kumo starts a match and checks the match contract (below). A server that breaks it is not released to kumo. The step also reports how long the server took to be ready, its memory and its CPU while it waits for players.

Add a machine of the studio’s makes one of your own computers a host in a region. kumo shows its key once, with the command that runs kumo’s agent on it. It takes matches like kumo’s hosts, at no host cost.

Matches are placed can also be set to On Edgegap, the studio’s account: matches go to Edgegap with your studio’s own Edgegap token, and kumo still runs the matchmaker.

The Matchmaker tab sets how players are matched, as forms, never a file to edit: each mode, its party sizes and maps, the rules a match keeps, and how those rules widen while players wait. Start from a preset.

Every change is checked as you type by the same rules a deploy uses, and Who would match shows what it would do. Apply to the matchmaker puts it live; the matchmaker takes it between matches. Changing it needs the game.config permission in a project.

Each studio has a matchmaker of its own: its players’ accounts are the studio’s, and can be exported.

The server build is any container that keeps kumo’s match contract. It reads:

VariableWhat it holds
KUMO_MATCH_IDThe match
KUMO_MATCH_PORTThe port players connect to
KUMO_MATCH_PLAYERSHow many players the match was formed for
KUMO_MATCH_JOIN_SECONDS, KUMO_MATCH_EMPTY_SECONDSHow long to wait for the first player (300), and to stay once everyone left (30)
KUMO_MATCH_LEASE_URL, KUMO_MATCH_LEASE_KEYWhere and how it tells kumo it is alive

It prints the line KUMO_MATCH_READY (or answers GET /ready) once players can join, sends its lease every 10 seconds with how many players are connected, and exits when the match ends.

Unreal: kumo’s plugin for games (Plugins/KumoGame, which Connect your game in Insights adds to the project) includes the KumoMatch module for servers. It does all four by itself; end a match from the game with End Match.

kumo’s package for the engine keeps the contract for you: Connect your game in Insights adds it, the same package that sends the game’s events. A Dockerfile turns the engine’s Linux server build into the image:

EnginePackageHow
Godot 4addons/kumo_eventsEnable the kumo events plugin (it adds the KumoMatch autoload); export for Linux in the Dedicated Server mode, then the Dockerfile
Unitycom.kumo.eventsKumoMatch starts by itself on a server kumo starts; build Linux Dedicated Server, then the Dockerfile

The game’s server calls three things: ready for players once it listens on the match’s port, connected with its player count when it changes, and end match when the match is over. The package does the rest.

A host is billed by the second it runs, at its provider’s price plus kumo’s margin, as Servers shows for each region. Your own machines cost nothing. Billing is not open yet: until it is, game hosting runs only for the studios we open it to.