Own your game’s
backend.

GameKit is a GPL-licensed .NET 10 library — auth, matchmaking, rankings, presence, lobbies, and an admin console as composable NuGet packages you compile into your own ASP.NET Core app. Postgres, Redis, your hardware. Nothing else.

source on GitHub packages on NuGet

sh — zero to backend

$ dotnet add package GameKit.Core
$ dotnet add package GameKit.Auth
$ dotnet add package GameKit.Matchmaking
$ dotnet add package GameKit.Rankings
$ dotnet new install GameKit.Templates
$ dotnet new gamekit -n MyGame
The template "GameKit" was created successfully.
$ docker compose up -d postgres redis
$ dotnet run

GPL-3.0 forever free 0 cloud dependencies 0 telemetry calls 9 composable packages <15 min to first match

A library, not a server

GameKit is not a standalone service you deploy next to your game. It’s a set of NuGet packages you install into your own ASP.NET Core application — your Program.cs, your DI container, your middleware pipeline, your routes. The result is a complete, production-capable backend that runs on hardware you control.

Every algorithm and strategy is an interface you can replace: IMatchmakingStrategy, IRankingAlgorithm, IOAuthProvider, IPasswordHasher. Install only what you need. Own the rest. Depend on no cloud service.

Install only what you need

Every module is its own NuGet package. Anonymous install, no account, no key.

GameKit.Auth

JWT issuance + refresh, Steam, Discord, guest, and password login built in. Google, Apple, Epic, and Argon2 hashing ship as sibling packages.

jwt · oauth · bcrypt/argon2

GameKit.Matchmaking

Redis-backed live queues with pools, rating brackets, parties, backfill, and a background matcher that’s safe across replicas.

redis · pools · parties

GameKit.Rankings

Glicko-2 by default, seasons with reset policies, ladders, and leaderboards. Swap the math via IRankingAlgorithm.

glicko-2 · seasons · ladders

GameKit.Presence

Online / offline / in-match status from TTL-keyed Redis heartbeats. No Postgres tables, no polling loops in your game.

redis-only · heartbeats

GameKit.Lobby

Real-time lobbies over SignalR with a REST surface and a Redis backplane for multi-replica deployments.

signalr · realtime

GameKit.Admin.UI

Blazor Server admin console: player search, bans, audit log, queue depth, and live health — mounted inside your app.

blazor · ops console

GameKit.Core

Entities, DbContext, the fluent builder, GDPR export / delete, account merge, and rate-limiting helpers. The one required package.

ef core · gdpr · builder

GameKit.Cli

Operator tooling: run migrations, take backups, and drill disaster recovery from the terminal — no dashboard required.

migrations · backup · dr

GameKit.OpenApi

An OpenAPI document for every endpoint you mount, generated from the modules you actually installed.

openapi · docs

Compose it. Then replace any part of it.

One fluent builder wires everything into your own DI container. Real code — this is the actual API.

Program.cs

var gamekit = builder.Services
    .AddGameKit(o => o.ConnectionString = cs);

// JWT + Steam / Discord / guest sign-in
gamekit.AddAuth(a => a.Steam.Realm = realm)
       .AddPresence()  // Redis heartbeats
       .AddLobby();    // SignalR lobbies

// Glicko-2 ladder + bracketed matchmaking
gamekit.AddRankings().AddLadder("ranked");
gamekit.AddMatchmaking().AddLadder("ranked");

var app = builder.Build();
app.UseGameKitAuth();
app.UseGameKit();  // authz + auto-migrate
app.MapGameKit();   app.MapAuth();
app.MapMatchmaking();   app.MapRankings();
app.Run();

Swap any strategy

// Every algorithm is an interface.
// Ship your own matcher — GameKit
// discovers it in your DI container.

public sealed class RegionAwareStrategy
    : IMatchmakingStrategy
{
    // pair by ping + rating bracket ...
}

builder.Services.AddSingleton<
    IMatchmakingStrategy,
    RegionAwareStrategy>();

// The same seam exists everywhere:
//   IRankingAlgorithm — swap Glicko-2
//   IOAuthProvider    — bring your own IdP
//   IPasswordHasher   — BCrypt or Argon2

Built for the boring parts

Health & readiness

/health/live and /health/ready endpoints, wired for your load balancer out of the box.

Multi-replica safe

Leader leases for background tickers and graceful drain — scale your app horizontally without split-brain matchers.

Observability, opt-in

OpenTelemetry traces and metrics for every module — and zero instrumentation cost if you never turn it on.

GDPR primitives

Player data export, delete, and account merge are first-class operations, not a support ticket.

Ops runbooks

Backup, disaster recovery, and per-package migrations driven by gamekit CLI commands and documented runbooks.

15-minute start

dotnet new gamekit → docker compose up → first authenticated player and first completed match.