Runtime-first infrastructure for multiplayer game makers

From export to a joinable authoritative session.

Upload your Godot 4 Linux dedicated-server export. Crux packages it, runs it in an isolated EU Runtime process, waits for readiness, and gives your players a secure way in - without Docker, fleet management, or exposed-port setup.

Start with Runtime alone. Add Crux auth, player data, matchmaking, live config, economy, and leaderboards only when they remove another piece of your backend.

Deploy a server Read Runtime v0

Every Dev project includes a finite Runtime evaluation allowance. The BaaS Dev plan remains free within its documented limits.

Godot 4 · native PC · ENet/UDP Runtime · EU BaaS Dev free Open source on GitHub

$ curl -X POST \
  "$CRUX/v1/projects/$P/environments/$E/leaderboards/$B/entries/" \
  -H "Authorization: ApiKey $CRUX_KEY" \
  -d '{"player_id": "p_42", "score": 9001}'

HTTP/1.1 200 OK
{
  "accepted": true,
  "entry": { "player_id": "p_42", "score": 9001, "rank": 7 }
}

import { CruxClient } from "crux-sdk";

const gsb = CruxClient.forPlayer(
  "https://crux.supercraft.host", "YOUR_PROJECT_ID", "YOUR_ENV_ID", process.env.GSB_KEY,
);

const auth = await gsb.loginAnonymous();
await gsb.submitScore("global", auth.player_id, 9001);

const top = await gsb.getTop("global", 10);
console.log(`#${top[0].rank} ${top[0].player_id}`);

using Supercraft.Crux;

var gsb = ServerToolkitClient.ForPlayer(
    "https://crux.supercraft.host", "YOUR_PROJECT_ID", "YOUR_ENV_ID", apiKey);

var auth = await gsb.LoginAnonymousAsync();
await gsb.SubmitScoreAsync("global", auth.player_id, 9001);

var top = await gsb.GetTopAsync("global", 10);
Debug.Log($"#{top[0].rank} {top[0].player_id}");

# Autoload Crux once via Project Settings → Autoload
Crux.init_player("https://crux.supercraft.host", "YOUR_PROJECT_ID", "YOUR_ENV_ID", api_key)

var auth = await Crux.login_anonymous()
await Crux.submit_score("global", auth.player_id, 9001.0)

var top = await Crux.get_top("global", 10)
print("#%d %s" % [top[0].rank, top[0].player_id])

-- Server Script in ServerScriptService
local Crux = require(game.ServerScriptService.Crux)
local gsb = Crux.init("YOUR_PROJECT_ID", "YOUR_SERVER_TOKEN", "YOUR_ENV_ID")

game.Players.PlayerAdded:Connect(function(player)
    local record = gsb:VerifyPlayer(player.UserId)
    gsb:SubmitScore("global", record.player_id, 9001)

    local top = gsb:GetLeaderboardTop("global", 10)
    print(string.format("#%d %s", top[1].rank, top[1].player_id))
end)

Why this exists

Most backend tools handle players. Most hosting tools handle deployment.

Crux starts with the outcome developers can feel immediately: your authoritative server is running and players can join it. The BaaS layer remains optional, so you can keep Steam, Supabase, PlayFab, Nakama, or your own services while using Runtime.

Built for live games, not generic apps

Configs, player state, rankings, and server availability stay connected instead of drifting apart across five different tools.

Covers the runtime side too

Not just auth plus a database. Dedicated-server registration, discovery, live config, and matchmaking - the surfaces multiplayer games actually need.

Fewer platforms to stitch

Move faster without assembling separate vendors for auth, persistence, rankings, config rollout, and server discovery.

Cleaner rollout to production

Go from prototype to live without the backend becoming the part slowing down shipping. Environment-aware by design.

Runtime first, backend when useful

What you get

A narrow path to a live authoritative session, plus the backend primitives that can replace adjacent integration work when you choose them. Runtime compute is not an unlimited free feature.

Crux Runtime

Upload a Godot 4 Linux dedicated-server export and get an isolated EU authoritative process, READY endpoint, short-lived join tickets, logs, trusted results, and clean termination. Every Dev project includes a finite evaluation allowance; no Docker required from the developer.

Player Authentication

Email and password, guest sessions, OAuth (Google, GitHub, Discord), and Roblox verification. Support real accounts, onboarding, and authenticated player access without building auth from scratch.

Persistent Player Data

Player-scoped and project-scoped JSON documents for progression, profiles, unlocks, event flags, inventories, and shared runtime values. Server-authoritative with patch semantics.

Leaderboards

Ranked and seasonal boards with configurable rules, fast ranking reads, recurring resets, and support for timed events or score-based loops. Anti-cheat friction on write.

Economy

Currencies, virtual items, and inventories with atomic updates for rewards, sinks, consumables, and grants. Every transaction audited server-side.

Dedicated Server Registry

Register, heartbeat, and search dedicated servers to power server browsers, active session discovery, region-aware listings, and stale cleanup.

Live Config Delivery

Upload versioned bundles and activate them per environment so balance changes, rotations, loot tables, and rulesets ship without a full patch.

Matchmaking

Queue by game mode and region, poll for your match, and get back the live server it was placed on - drawn from your own registry, so a crashed server is never a destination. Pairs players today. Manage the queue from the dashboard, including forming a match by hand.

Social

Friends, pending requests, and blocks. Drop-in social graph so your players can connect without a third-party identity vendor.

Stats & Achievements

Named counters the backend owns, so progression is something you can query rather than a blob you parse. Bind an achievement to a stat and a threshold and it unlocks in the same transaction as the write that earns it - the response tells you what was earned, once, so rewards cannot pay twice.

Inside the dashboard

Built to watch a live game, not a generic app.

The dashboard observes your running game - player writes, server heartbeats, config pushes, and SDK quickstarts for every engine you ship on.

Crux first-run dashboard with setup checklist

Integration model

One API. Three auth modes.

API Key

Admin scripts, CI, tooling, and control-plane access.

Server Token

Dedicated game servers and trusted runtime services.

Player JWT

Authenticated players issued by the auth system.

Players, servers, and operators stay on separate trust boundaries while the surface area is simple enough to integrate with Unity, Roblox, Godot, or any HTTP client.

What teams build faster

Example outcomes

Player profiles and progression
Guest-to-account upgrade flows
Seasonal scoreboards and rank loops
Server browser features
Live event configuration
Balance and loot tuning
Server-authoritative reward systems
Achievements that unlock off a counter
Environment-aware staging and rollout

Open-source showcase

Relay Zero: a whole co-op game wired to Crux, in the open.

Snippets prove an API compiles. Relay Zero proves the architecture: a Godot 4 co-op extraction slice, about 4,000 lines of GDScript, MIT-licensed, where the same simulation runs offline and on an authoritative headless server.

What it demonstrates, in real code

Trust boundaries that hold. Guest sign-in on the client; the server verifies every player token against Crux and match join tokens fail closed.
An authoritative WebSocket server. Fixed 20 Hz simulation, 15 Hz snapshots, peer-bound input, so clients cannot drive another player's actor.
Live ops without redeploys. Versioned config bundles with a last-known-good fallback, packaged defaults, and five ready-made live events.
Server-owned progression. Loadouts, reward claims, and two leaderboards (weekly score, fastest run) are written by the server, never the client.
A deploy story. Headless Linux export, Docker Compose, health check, and a browser client build.

Clone it, gut it, ship yours

It is a working foundation, not a finished game, and its README says exactly what is still missing. That is the point: every claim on this page is something you can read, run, and delete until only your game is left.

Read the code Godot SDK quickstart

Best fit

Built around multiplayer games, not generic app backends.

Most generic backends stop at auth and storage. Crux also covers the runtime needs of server-based games, with a better fit for live ops and environment-aware rollout.

Best suited for

Dedicated-server games
Multiplayer survival and co-op games
Region-based game server fleets
Unity, Roblox, Godot, and custom-engine backends
Indie and mid-size studios that want backend velocity
Teams that do not want to build a platform team before shipping gameplay

Less suited for

Purely offline, single-player games
Projects that only need a generic login database
Highly specialized AAA matchmaking stacks from day one

Why say this clearly? Because the offer is stronger when it reads like a tool built for a specific class of multiplayer game, not a vague "backend for everything."

Platform foundation

The stack you'd have built yourself.

Boring, proven components. No surprise vendor lock-in, no homegrown database engine.

Component	Role
Go API server	Single binary API service
PostgreSQL	Primary data store with row-level security
Redis	Hot caches, rate limiting, matchmaking queues
Bundle storage	Immutable config bundles, one object per version

Clean environment isolation. Production, staging, and test stay separated by design.
Server-aware runtime APIs. Dedicated servers do not impersonate admin clients.
Live-ops friendly. Configs, rankings, and player state fit together operationally.
Stack-flexible. Use it with launchers, dashboards, custom tools, and game services.

The indie backend that can't disappear on you

Built so you never get stranded.

2025 and 2026 were brutal for indie backends - free tiers gutted, whole platforms shut down with weeks of notice, shipped games left broken. Crux is built to be the opposite: a finite Runtime evaluation, a free BaaS tier, an open API, and your data portable on day one.

Free BaaS, finite Runtime evaluation

The Dev BaaS tier is free forever within its documented limits - 10,000 MAU, unlimited projects, and every BaaS feature. Runtime is separate: every Dev project includes three lifetime hours, one concurrent session, and a one-hour session cap.

Open API, open source

Plain HTTP + JSON, and the SDKs plus the full API are open source on GitHub. No black box. Self-hosting the backend is on the roadmap.

Your data, always exportable

Every player, document, leaderboard, and config is readable through the same API you write with. Pull all of your data out, any time - no lock-in.

A written no-strand commitment

If Crux ever winds down, we commit to advance notice and an export window so your game keeps working. Read the sunset & export guarantee.

From the Crux Blog

All articles →

Architecture guides, engine integrations, and vendor comparisons for indie multiplayer game devs.

Get the authoritative server running, then add what your game needs.

Deploy a real Godot server build with Runtime, or start with the free Dev BaaS tier - 10,000 MAU and every BaaS feature within its documented limits.

Start with free BaaS See pricing SDK Quickstart