Asobi

git clone https://github.com/widgrensit/asobi
cd asobi/examples/hotreload-demo
docker compose up

UAsobiClient* Client = NewObject<UAsobiClient>();
Client->SetBaseUrl(TEXT("http://localhost:8084"));

UAsobiAuth* Auth = NewObject<UAsobiAuth>();
Auth->Init(Client);

FOnAsobiAuthResponse OnLogin;
OnLogin.BindDynamic(this, &AMyPawn::OnLoggedIn);
Auth->Login(TEXT("player1"), TEXT("secret"), OnLogin);

// After login:
WebSocket->Connect(TEXT("ws://localhost:8084/ws"));
WebSocket->Authenticate(Client->GetAuthToken());
Matchmaker->Add(TEXT("arena"), {}, OnQueued);
WebSocket->OnMatchState.AddDynamic(this, &AMyPawn::OnMatchState);

var asobi = new AsobiClient("localhost", port: 8084);
await asobi.Auth.LoginAsync("player1", "secret");

asobi.Realtime.OnMatchState += state =>
    Debug.Log($"tick {state.tick}");

await asobi.Realtime.ConnectAsync();
await asobi.Matchmaker.AddAsync("arena");
// When matched, server sends match.joined → match.state at tick rate.

@onready var asobi: AsobiClient = $AsobiClient

func _ready():
    await asobi.auth.login("player1", "secret")
    asobi.realtime.match_state.connect(_on_state)
    asobi.realtime.connect_to_server()
    asobi.realtime.add_to_matchmaker("arena")

func _on_state(payload: Dictionary):
    print("tick ", payload.get("tick"))

local asobi = require("asobi.client")
local rt = require("asobi.realtime")

asobi.auth.login("player1", "secret", function(res)
    rt.init(asobi)
    rt.on("match_state", function(payload)
        print("tick " .. payload.tick)
    end)
    rt.connect(function()
        rt.matchmaker_add("arena")
    end)
end)

import { Asobi } from "@widgrensit/asobi";

const asobi = new Asobi({ baseUrl: "http://localhost:8084" });
const { access_token } = await asobi.auth.register({
    username: "player1", password: "secret",
});

const ws = asobi.websocket({ token: access_token });
ws.on("match.state", (s) => console.log("tick", s.tick));
await ws.connect();
ws.sendFire("matchmaker.add", { mode: "arena" });

final asobi = AsobiClient(host: 'localhost', port: 8084);
await asobi.auth.login('player1', 'secret');

asobi.realtime.onMatchState.listen((state) {
    print('tick ${state.tick}');
});

await asobi.realtime.connect();
await asobi.matchmaker.add(mode: 'arena');

-- Server-side game mode (runs inside asobi_lua)
function on_player_joined(match, player)
    game.broadcast(match, "welcome", { player_id = player.id })
end

function on_match_input(match, player, input)
    player.x = player.x + (input.move_x or 0)
    player.y = player.y + (input.move_y or 0)
    -- match.state is diffed and broadcast automatically each tick.
end

Sessions

Matches

Small, ephemeral game sessions assembled by the matchmaker. Players queue, the server forms a match, a game mode runs, results are recorded. Like FTL, Brotato-with-friends, arena shooters, card games.

• Matchmaker with skill + party rules
• Server-authoritative tick (30-60 Hz)
• Auto-cleanup when the match ends
• In-match voting, DMs, chat

Matchmaking docs →

Persistent

Worlds

Long-running worlds with lazy-loaded zones and streamed terrain. Find-or-create joins a world that isn’t full; players drop in and out. Like EVE, Albion, MMOs, shared sandboxes.

• Lazy zones scale on demand
• Binary terrain chunks on join
• ETS-backed reconnection state
• 500+ concurrent players per world

World server docs →

⚙

Per-Process GC

Each match runs in its own process with isolated garbage collection. No stop-the-world pauses affecting other players.

⚡

Preemptive Scheduling

The BEAM scheduler ensures fair CPU time for every match. One expensive operation cannot starve others.

🛡

OTP Supervision

If a match process crashes, it restarts automatically. Players reconnect to a fresh state. The server is unaffected.

☁

Cloud Native

Graceful shutdown, health endpoints, and rolling deploys out of the box. Built for Kubernetes, Fly.io, and any container orchestrator.

📈

100K+ Connections

Lightweight processes and efficient I/O multiplexing. Handle 100K+ concurrent WebSocket connections per node.

📊

Built-in Observability

OpenTelemetry integration, structured logging, and Telemetry events. Monitor every match, queue, and connection.

Authentication

Player registration, login, sessions, and OAuth. Built on nova_auth.

Matchmaking

Automatic player pairing with configurable rules. Lobby and queue support.

Real-Time Sync

WebSocket-based state synchronization at configurable tick rates.

Leaderboards

Ranked scoring with ETS-backed storage. Per-game, per-season, global.

Virtual Economy

Wallets, transactions, inventory, and in-game store.

Social

Friends, groups, chat, and notifications.

Cloud Saves

Persistent player data storage with versioning.

Admin Dashboard

Web-based management UI for players, matches, and economy.

1

2

3

4