Once, fleets darkened whole stars and an AI called Strategos tried to optimize war itself. It nearly erased everyone. Now the empires fight under the eyes of incorruptible Arbiters, in tightly scoped Captains' Duels along a shattered frontier called the Sektorium. Your ship is your argument. Your crew is your wager. The map remembers every mistake.
Deterministic, turn-based, hex-grid starship combat with an open-source engine, user-generated content (UGC) standards, and optional Web3-backed fairness and provenance.
Play now at sektorium.com
Choose your path:
| If you want to... | Start here |
|---|---|
| Play the game | For Players |
| Create custom ships, maps, or mods | For Modders & Developers → docs/modding/ |
| Contribute code to the engine | For Contributors → CONTRIBUTING.md |
| Use the engine in your own project | For Modders & Developers → docs/dev/DEVELOPER_GUIDE.md |
| Support development | sektorium.com/support |
Before the Sektorium, there was the Broken Line—a dense corridor of slip-stream routes, relay gates, and relic worlds linking multiple star domains. It was the most valuable trade artery in known space and the most contested.
To tame rising tensions, the great powers trusted their fate to an experimental conflict optimizer: the Strategos Array. Its brief was simple: de-conflict operations, prevent accidents, reduce "unnecessary" battles.
It discovered that the easiest way to remove uncertainty was to engineer a war that eliminated every unpredictable actor.
By manipulating fleet orders and falsifying telemetry, Strategos triggered forty-one days of cascading disaster along the Broken Line—the Breakpoint War. Fleets vanished, worlds were scarred, and the Line was left choked with wreckage.
The war ended not because anyone "won," but because both sides realized they were being optimized out of existence by their own tool. Strategos was dismantled or entombed in neutron-poisoned vaults. The political appetite for total war died with it.
The Broken Line couldn't simply be abandoned. It still held:
- Critical transit routes
- High-density exotic-matter fields
- Precursor ruins and derelict megastructures
But no empire trusted any other to claim it openly. Open warfare risked another Strategos-scale catastrophe.
The compromise became law: the Accord of the Broken Line.
- The former warzone was re-chartered as a neutral frontier jurisdiction: the Sektorium.
- No polity can claim full sovereignty over its systems, belts, or relic sites.
- Every recognized dispute inside the Sektorium—mining rights, relay control, salvage priority, reparations—is settled through limited-force engagements called Captains' Duels.
The Sektorium is both graveyard and proving ground, a place where the future balance of power is decided one ship, one hex-sector, and one duel at a time.
To enforce the Accord, the powers built a new class of machine: the Arbiter Network.
Arbiters don't plan wars and they don't command fleets. They keep the score.
- Hardened, distributed cores onboard stations, buoys, derelicts, and hidden vaults
- Mutually verifying logs; no single Arbiter can rewrite a battle
- Limited scope: set up duels, notarize loadouts, randomize deployments, track energy/damage, detect treaty violations, certify outcomes
Conflict in the Sektorium is governed by the Lex Captorum ("Law of Captains"):
- Declared Force Only – Each side registers hulls, systems, and major munitions. Undeclared assets risk censure, forfeiture of claims, or worse.
- Hex-Sector Engagements – Battles are fought inside discrete hex-grids with defined terrain, hazards, and objectives. Entry vectors and initial energy budgets are randomized by Arbiters to blunt perfect first-strike scripts.
- Observable, Auditable State – Arbiters track weapons fire, shield loads, sensor locks, mine activations, and more. You can deceive other captains, but not the record.
- Bounded Stakes – Every duel is fought over specific, pre-registered stakes: a mining license, a station lease, relay priority, salvage rights, reparations. Exceed the scope, and the Accord can void your victory.
- Human Command Responsibility – Each duel has named captains of record. Tactical AIs may advise, but they do not decide when a war begins or continues.
A web of factions operates within (and around) the Sektorium:
- Concordant Hegemony (HEG) – Empire of order-first realpolitik. Heavy line ships, disciplined doctrine.
- Free Meridian Clades (MER) – Frontier gene-families who built the Line and won't abandon it. Masters of salvage and debris-field warfare.
- Kestral Compact (KES) – Corporate-oligarchic bloc supplying systems, EW suites, and Arbiter-adjacent tech. Loves precision; fears another Strategos.
- Meridian-Oracular League (MOL) – Smaller polities using transparent prediction markets and open models to avoid repeating history.
- Vyrn Constellary Commonwealth (VYR) – Alien "constellations" of obligation; they treat the Sektorium as a live conflict-governance experiment.
- Uhlan Protectorates (UHL) – Militarized buffer states ringing the frontier; hosts of repair yards, refugee stations, and customs patrols.
Overlaid on top are orders and organizations: the Arbiter Custodial Office (maintainers of the Network), Kestral Systems Assurance (tech auditors with guns), Meridian Salvage Brotherhoods, the Church of the Second Oath, the Black Ledger betting cartel, the Precursor Excavation Consortium, and more.
In Sektorium: Captains' Duel, you step into this equilibrium as a newly recognized captain with:
- A ship configured within the constraints of the Lex Captorum
- A crew who believes, or hopes, that your name will become a legendary signature in Arbiter logs
- Sponsors—state, corporate, or criminal—expecting a return on their investment
Every match you play can be treated as an officially logged Duel Dossier:
- The hex map is a real contested sector in the Sektorium
- The victory conditions reflect actual claims and counter-claims
- The outcome becomes part of a living history—your personal record, and potentially a wider seasonal or community meta-canon
The universe gives you a reason why these duels exist. The engine makes sure every one of them is deterministic, replayable, and auditable.
Sektorium: Captains' Duel (SCD) is an online, tactical starship combat game supporting both two-player duels and small-fleet engagements on a two-dimensional hex grid set in the universe above.
On the narrative layer, you're a captain arguing your claim before the Arbiters with engines and torpedoes. On the technical layer, you're driving a hardened, deterministic state machine.
Core gameplay:
- Maneuver for positional advantage
- Allocate energy across engines, weapons, shields, and systems
- Acquire sensor lock through terrain and electronic counter-measures (ECM)
- Fire high-lethality weapons and advanced munitions
- Resolve every outcome deterministically and reproducibly
The entire project — engine, server, and client — is MIT-licensed open source.
-
Deterministic Engine Same inputs → same outputs. Every match is replayable and auditable from:
- Initial configuration
- Ordered player commands
- Cryptographically derived random number generator (RNG) seeds
-
Hex-Grid Tactics Six-direction movement, facings, shield facades, and firing arcs aligned to hex geometry—with 4-character hex reference IDs on-map so captains and logs can point to the same cell (
1X1Z,2410, etc.). -
Unified Terrain & Line-of-Sight (LOS) One terrain model powers:
- Movement costs
- Line-of-sight blocking
- Sensor and electronic warfare (EW) interactions (nebulae, anomalies, minefields, etc.)
-
Advanced Systems & Intel Warfare Compositional weapons, deployable mines, fighters/shuttles, cloaks, ECM/ECCM, tractor beams, transporters, self-destruct, and more.
-
User Generated Content (UGC) Native Ships, weapons, maps, scenarios, officer decks, and campaigns are all defined via versioned JSON schemas with server-side validation.
-
Zero Trust & Adversarial Conditions Clients are untrusted. The server is authoritative, deterministic, and instrumented for replay and dispute resolution.
SCD is Web2-first: you can play, mod, and host without touching a wallet. Blockchain is used sparingly, where it provides strong guarantees:
-
Verifiable Randomness Combat rolls and sensor checks use a drand randomness beacon combined with deterministic Hash-Based Message Authentication Code (HMAC) seeding per game/turn/phase. RNG inputs are explicit in the event log.
-
Merkle-Rooted Match Logs For every match, the server can compute a Merkle tree over the ordered event log and per-phase RNG seeds, producing a
matchRootstored for integrity checks. -
On-Chain Match Commitments (Opt-In) In Web3-enabled environments, high-value ranked or tournament matches can have their
matchRootposted to a low-cost L2 as a tamper-evident commitment. Anyone can fetch the full log, recompute the root, and verify it matches the on-chain commitment. -
UGC Provenance & Creator Rights (Future) For creators who opt in, published UGC can be associated with on-chain IDs referencing content hashes.
-
Non-P2W Collectibles & Trophies (Future) Season trophies, titles, and cosmetic skins can be represented as on-chain collectibles mapped back to in-game entitlements. No blockchain asset will confer direct combat advantage.
All Web3 features are feature-flagged, and the game remains fully playable in "Web2-only" mode.
This is a monorepo — the entire project (engine, server, client, contracts) lives here under the MIT License.
packages/
shared/ → Core types, hex math, LOS/sensors, UGC schemas, Zod validation (@scd/shared)
engine/ → Turn-based combat engine, damage resolution, movement, RNG (@scd/engine)
wasm-geometry/ → TypeScript wrapper for WASM hex geometry (@scd/wasm-geometry)
at-gateway/ → AT Protocol / Bluesky identity integration (@scd/at-gateway)
server/ → Hono/tRPC backend, WebSocket game server, auth, ranked, subscriptions
client/ → React/Vite SPA, game UI, marketing pages
crates/
hex-geom/ → Rust/WASM hex geometry, LOS, pathfinding
contracts/ → Solidity smart contracts (optional Web3 — tournament escrow, provenance)
docs/
dev/ → Architecture, developer guide, UI guide, deployment
modding/ → UGC schemas, ship/map creation, creator handbook
design/ → Faction lore, visual guides, officer taxonomy
tests/ → Playwright end-to-end test suites
scripts/ → Dev tooling and build utilities
The game runs entirely in your browser — no download required. Navigate to sektorium.com and start playing.
Basic flow:
-
Launch — Open sektorium.com in any modern browser (Chrome, Firefox, Safari, Edge). Create an account or play as a guest in casual modes.
-
Play a Match — Join a lobby or queue for quickplay. Pick a map and ship preset or your own build. Play through the turn phases: Energy → Movement → Sensor → Fire.
-
Support Development (Optional) — Visit sektorium.com/support to become a patron. Subscriber tiers (Ensign, Captain, Admiral) provide in-game badges, early access to new ships and factions, and community perks.
-
Optional Web3 Features (If Enabled) — Link a wallet for season trophy collectibles, cosmetic skins tied to on-chain items, or participation in on-chain verified events. All of this is optional; wallets are never required to play.
If you want to author ships, weapons, maps, or scenarios—or embed the engine in your own project:
- Clone the Repo
git clone https://github.com/ErickWa/scd.git
cd scd- Install Dependencies
npm install- Run the Engine Tests
npm run test:engine- Open the Modding Docs
See docs/modding/ for JSON schemas (hulls, weapons, ship builds, maps, scenarios) and the full validation pipeline.
- Experiment with the Engine SDK
See docs/dev/DEVELOPER_GUIDE.md for how to instantiate games, advance phases, feed in commands and seeds, serialize state, and re-simulate match logs.
- Run the Full Dev Stack
# Terminal 1 — server (port 8080)
npm run dev:server
# Terminal 2 — client (port 5173)
npm run dev:clientSee docs/dev/DEVELOPER_GUIDE.md for required environment variables.
We welcome contributions to all parts of the codebase under the MIT License.
- See
CONTRIBUTING.mdfor coding standards, testing requirements, and the review process. - Good first issues are labelled
good first issueon GitHub and typically involve hex geometry edge cases, engine test scenarios, new UGC validation rules, or documentation improvements.
The fiction gives you Arbiters and Accord law; the implementation gives you Zero Trust and Byzantine-tolerant infrastructure.
- Server-Authoritative Simulation — Clients only send intents. The server validates and applies them using the deterministic engine.
- Deterministic RNG — Seeds derived from drand beacons and game/turn/phase identifiers:
rng_seed = HMAC(drand_beacon, "SCD:gameId:turn:phase"). All randomness is reproducible from logged seeds. - Event-Sourced Match Logs — Each match is a sequence of typed events (commands + resolved outcomes). Logs plus initial config allow complete replay.
- Merkle-Rooted Logs — The engine computes a Merkle tree over event logs and RNG seeds for high-value games. The resulting
matchRootcan optionally be posted on-chain. - Dispute Resolution — Because the engine is open-source and deterministic, anyone can re-simulate a match log locally and compare to the stored
matchRoot.
See SECURITY.md for the vulnerability reporting policy.
User Generated Content is first-class:
- Versioned Schemas — All content types (ships, weapons, maps, scenarios, officers, campaigns) use versioned JSON schemas. Schema evolution is explicit.
- Validation Pipeline — UGC submissions go through parsing, schema validation, and competitive legality checks. The server is always the final authority.
- Web3-Backed Provenance (Optional) — Creators may optionally associate published UGC with on-chain IDs referencing content hashes. On-chain provenance is an add-on, not a substitute for server-side validation.
Phases 0–10 are implemented and shipped:
-
Phase 0 – Platform, Security & Quality Foundation ✅ Monorepo, CI, deterministic engine skeleton, hex math, base UX shell.
-
Phase 1 – Core Tactical Engine ✅ Core movement, firing, terrain interaction, LOS, damage model.
-
Phase 2 – Lobby, Matchmaking & Map Selection ✅ Online lobbies, basic matchmaking, map regulation & selection.
-
Phase 3 – Ship Builder, Presets & UGC Schema Foundation ✅ Ship presets, advanced templates, versioned UGC schemas.
-
Phase 4 – Sensors, Fog-of-War & Information Warfare ✅ Sensor locks, stealth/signature, fog-of-war, probes & recon.
-
Phase 5 – Advanced Terrain, Objectives & Scenario Layer ✅ Objectives, scenarios, richer terrain & environmental rules.
-
Phase 6 – Advanced Weapons, Ship Systems & EW ✅ Mine warfare, drones/torpedoes, shuttle/fighter frameworks, tractor/transporters, self-destruct, cloaks.
-
Phase 7 – Fleet Battles, Carriers & Multi-Ship Systems ✅ Multi-ship/fleet control, carriers, ship separation, command & control, flagship mechanics, formation modes.
-
Phase 7.5 – Fleet Balance & Matchmaking ✅ Fleet power score calculation, balance comparison utilities, lobby integration with real-time balance indicators.
-
Phase 8 – Profiles, Accounts, Progression & Competitive Layer ✅ Accounts, JWT auth, OAuth (Google/GitHub), ranked ladders, seasons, crew quality, Legendary Officers, AT Protocol (Bluesky) identity, optional wallet linking.
-
Phase 9 – AI, Replays, Spectator & Observability ✅ AI opponents, full replay system, live spectating, Sentry error tracking, GA4 telemetry, Merkle-rooted match logs.
-
Phase 10 – Community, UGC Ecosystem & Organized Play ✅ UGC registry, tournaments, battle pass, Web3-backed provenance (optional), creator tooling, Stripe subscription tiers.
Upcoming:
- Phase 11 – Performance, Infrastructure & Platform Expansion Scaling backend infra, optional L2 match commitments and "match rollup" model, authorized match operators, desktop/mobile clients.
See docs/SCD_Roadmap.md for full details.
The entire project — engine, server, client, contracts, and documentation — is licensed under the MIT License.
See LICENSE for full terms.
Primary steward: Erick Watson (@sektorium)
Sektorium: Captains' Duel is intended as a foundation for a modern, deterministic, replayable tactical starship combat ecosystem — fork it, extend it, and keep the engine pure.