Proven end-to-end at full load — no specialised or exotic hardware.
Tech · Sigilwake platform
The engine room behind a turn-based multiplayer RPG.
Sigilwake looks like a hand-drawn duel between two champions — and at its simplest that is exactly what it is. Two players each pick a champion from an original cast and trade moves one at a time: cast an ability, defend, break the other's rhythm, until one falls. No reflexes, no twitch — every match is a small game of chess dressed as a hand-drawn fantasy brawl, played on phones, browsers and desktops, live or as a replay.
Underneath, the architecture handles ten thousand players at once, drops a queued player into a live match in about four seconds anywhere in the world, and runs every fight at full frame-rate from phone to desktop. The game is refereed entirely on our own servers; live combat spins up on cloud instances that appear and vanish with demand; and every finished match becomes fuel for a Neural AI that teaches itself to play. The rest of this page walks through it, layer by layer.
Overview
Why a turn-based RPG needs this much backend.
At a glance Sigilwake looks simple — two champions, one move per turn, no reflexes. It is tempting to publish something that simple the cheap, off-the-shelf way. That is exactly the path most indie games take, and exactly why so many are overrun by cheaters, bled by refund fraud, and abandoned inside a year. Sigilwake is built the opposite way — and here is what that buys.
Server-authoritative from day one
The player's device is a screen, not a referee. Every point of health, every resource, every dice roll, every reward is decided on our side — the app only shows the result. A player can never edit their own health, hand themselves a prize, or declare themselves the winner. It is the one design that holds up the moment real money and real competition enter the room.
A backend built at two speeds
Not everything a game does is equally urgent. Signing in, saving progress, running the shop and the leaderboards can take a comfortable moment. Resolving a live duel, turn by turn, cannot. So we built the backend at two speeds — a calm layer for the everyday and a fast layer engineered purely for the heat of a match — each able to grow on its own as the audience does.
Combat that scales on demand
A live match does not need a machine sitting idle waiting for it. Our combat instances are disposable: one is summoned the instant two players are matched, runs the fight, and is retired the moment it ends. Capacity follows demand automatically, around the world — so we pay only for the minutes players are actually fighting, never for empty seats.
An AI that learns from every match
Every fight ever played is quietly recorded and fed back into a self-teaching AI. Night after night the system plays millions of matches against itself, finds where the game is unfair, and sharpens both the balance and the opponent. The destination is a compact AI mind — small enough to live inside the game itself — that already outplays most human testers and will one day fight at a level no person can.
From the queue to a live opponent — anywhere in the world.
Sustained on a single instance.
A brain small enough to run inside the app — already beats most human testers.
Architecture map
The whole platform at a glance.
Two physical nodes. Nine microservices. One canonical combat engine, compiled into both the client (for local previews and PvE) and the server (as the source of truth for every PvP match).