How game servers get deployed and scaled. One API. Anywhere in the world.

No SDK in your game server. Gameye handles session scheduling, scaling, placement, and failover across bare metal, cloud, and edge — so your team doesn't have to. Here is exactly what happens on every match.

Read our docs  Join our Discord

Updated June 16, 2026

TL;DR

  • You ship a Docker image, not an integration — Gameye deploys and scales your game server through a REST API. Your binary runs as-is with no Gameye code inside it — no SDK, no lifecycle hooks, no plugins, no code changes.
  • Sessions start in 0.5 seconds — Sub-second container spin-up across 21 bare metal and cloud providers in major markets worldwide, with automatic scaling and cloud bursting for launch spikes.
  • Any matchmaker, any engine — Native integrations for Pragma Engine, Nakama, AWS FlexMatch, and PlayFab. Unreal Engine, Unity, and custom engines all supported.
  • Proven at scale — 130M+ sessions since 2017. 250K peak CCU on production titles. 99.99% uptime SLA, no egress fees.
The short version

How does Gameye work?

Gameye replaces the infrastructure work your team would otherwise own: provisioning cloud or bare metal servers, configuring firewalls and networks, writing Terraform or Ansible, managing Docker runtimes on remote machines, and building custom autoscaling logic.

All you need is a Docker image of your game server. Pick your regions, push your image, and call the API. Sessions start in ~0.5 seconds. If demand spikes, Gameye bursts into cloud capacity automatically — no configuration required.

New to the concept itself? Read what game server orchestration is for the background, then come back here for exactly how the deploy-and-scale workflow runs.

Do I need to modify my game server binary?

No. Whatever your engine, use Docker to containerize your game server and upload the image. No Gameye SDK, plugin, or code changes are required in your server binary — your server just starts, listens on its port, and accepts connections.

How long does it take to deploy a game server?

Once your image is uploaded, a session container starts in about 0.5 seconds on the chosen provider. Warm pools keep capacity pre-staged so launch spikes, free weekends, and tournaments do not queue behind cold starts.

How do game servers scale during a player surge?

Automatically. Once your image is uploaded and your matchmaker is connected, Gameye creates sessions on demand via the API. When player numbers surge, the orchestration platform bursts into cloud capacity and spins up new sessions with no manual intervention required.

The session lifecycle: from match request to teardown

Orchestration is what happens in the seconds between a player pressing "Play" and a match starting on a server near them. Here is exactly what Gameye does on every request — with no code running inside your game server to make it happen.

  1. Your matchmaker requests a session. When a match is ready, your matchmaker — Pragma, Nakama, AWS FlexMatch, PlayFab, or your own — calls the Gameye API with the players' regions and the game image to run.
  2. Gameye schedules placement. The orchestrator picks the best machine for that match, weighing player latency, your configured regions, current capacity, and provider health across 21 bare metal and cloud providers. If your preferred region is saturated, it bursts into cloud capacity automatically.
  3. The container starts in ~0.5 seconds. Gameye launches your Docker image as an isolated container on the chosen host. Warm pools keep capacity pre-staged, so launch spikes never queue behind cold provisioning.
  4. You get an IP and port. The API returns the session's connection details. Your matchmaker hands them to the players' clients, and they connect directly to the server — there is no Gameye hop in the data path.
  5. The match runs. The server runs exactly as it would on a machine you manage. Gameye monitors the host; if a provider has an outage, sessions fail over to a healthy provider without your team paging anyone.
  6. Teardown and recycle. When the match ends, Gameye stops the container and reclaims the capacity for the next session. You pay for the compute the match used — per second, with no egress fees on player traffic.

That entire loop — schedule, place, start, return, monitor, reclaim — is the orchestration work your team would otherwise build and operate in-house.

What Gameye runs, and what stays yours

Gameye owns the infrastructure layer so your team doesn't. You keep your game server binary, your matchmaker, and your netcode exactly as they are.

Because there is no Gameye code in your binary and no agent in the data path, there is nothing to rip out if you ever move providers — and nothing new to certify when you ship a build. Weigh the full cost and control trade-offs on our cost comparison, or work out capacity with the server sizing guide.

Deploying updates: upload once, roll out everywhere

Shipping a new build is the same single step as the first deploy. Upload the new image and Gameye rolls it out across the whole infrastructure — every region, every provider — within a few minutes. There is no per-machine deployment, no fleet of servers to patch by hand, and no separate config per data center.

Because deployment is image-based, the build you test is the build that runs everywhere, and rolling back is just pointing at the previous image. Studios running live titles — Chivalry 2, Clone Drone, and others, across 130M+ sessions since 2017 — use this to push hotfixes mid-event without taking the game down.