The runtime for
board game rules engines.

Express your game's state, commands, and turn flow as plain TypeScript. tabletop-engine handles validation, execution, hidden information, and deterministic replay — so you can ship the rules with confidence.

Get started API reference View on GitHub →

Model state with decorators.

Describe your game's data model with `@State()` and `@field()`. The engine compiles a type-safe canonical schema, hydrates a working facade for execution, and projects per-player views for hidden information — all from one declaration.

Learn about state →

```ts theme={null} @State() class GameState { @field(t.array(t.string())) playerOrder: string[] = []; @field(t.state(() => BoardState)) board!: BoardState; getNextPlayer(playerId: string): string { const index = this.playerOrder.indexOf(playerId); if (index === -1) throw new Error(`unknown_player:${playerId}`); return this.playerOrder[(index + 1) % this.playerOrder.length]!; } } ```

Author commands with validate and execute.

Every player action is a command with a `validate` step and an `execute` step. The engine runs them transactionally, surfaces structured errors, and emits semantic events you can stream to clients.

Learn about commands →

```ts theme={null} const defineGameCommand = createCommandFactory(); const buyCard = defineGameCommand({ commandId: "buy_card", commandSchema: t.object({ cardId: t.number() }), }) .validate(({ game, command }) => { const card = game.getCard(command.input.cardId); if (!card) return { ok: false, reason: "unknown_card" }; if (!game.canAfford(command.actorId, card)) { return { ok: false, reason: "insufficient_funds" }; } return { ok: true }; }) .execute(({ game, command }) => { game.buyCard(command.actorId, command.input.cardId); }) .build(); ```

One executor for your rules.

`createGameExecutor` gives you a single runtime that handles command dispatch, stage progression, deterministic RNG, snapshots, and replay. Use it to drive local tests, simulations, and game sessions from the same rule definitions.

Executor reference →

```ts theme={null} const executor = createGameExecutor(game); const initial = executor.createInitialState("seed_1"); const result = executor.executeCommand(initial, { type: "buy_card", actorId: "player_1", input: { cardId: 42 }, }); if (result.ok) { result.state; // next canonical state result.events; // semantic events to stream } executor.getView(result.state, "player_2"); // per-viewer sanitized state ```

Generate schemas and types from your rules.

Use the CLI to derive JSON schemas and TypeScript declarations from your game definition. Keep runtime validation, generated types, and tests aligned with the rules your engine actually runs.

CLI reference →

```bash theme={null} $ tt-kit generate schemas generated schemas:./generated/schemas.generated.json $ tt-kit generate types generated types:./generated/canonical-state.generated.d.ts ```

Built for real games.

Everything you need to model rules end-to-end — from the first turn to a reproducible runtime.

Project a different view of state to each player. The engine sanitizes canonical state into per-seat views automatically. Model setup, draft, action, and scoring phases as a progression graph. The engine handles transitions and lifecycle resolution. Seeded, replayable randomness baked into the runtime — shuffle decks and roll dice without breaking determinism. Capture any state, replay any sequence of commands. Reproduce bugs from production logs in a single line. A test harness designed for game logic. Drive games through full flows with concise, declarative scenarios. Run setup, commands, stages, visibility, snapshots, and replay through one engine-owned execution path.

Build your next game.

Install the package, define a state, write a command, and run it. The first end-to-end game takes about ten minutes.

Install tabletop-engine Build your first game