A platform for designing
original board games.
Oreste is a space where anyone — not just developers — can invent a board game, write the rules once, and have them enforced automatically when the game is played.
A three-level editor (guided module, visual blocks, code), a safe rule engine that runs identically in the browser and on the server, and a pipeline that goes from the idea all the way to the printed physical game.
Inventing a board game is easy.
Actually playtesting it is not.
Anyone designing a board game faces a chain of obstacles disproportionate to the initial idea.
Prototyping is expensive
Cards, printed dice, tokens, boards remade every time a rule changes. Each iteration takes days.
Finding players is hard
You need people physically present, available, patient. Testing with different people — geographically dispersed — is almost impossible.
Enforcing the rules is exhausting
During the playtest the author must act as referee. Mistakes and oversights pollute the test results. Ambiguous rules stay ambiguous.
Existing digital tools have solved a piece of the problem, never all of it: Tabletopia and Tabletop Simulator offer the digital space but do not enforce the rules. Board Game Arena enforces the rules, but every game requires a PHP developer.
— DOC-001 §1.2 and DOC-003 §5.1Three ways to write the rules.
One game that works.
Oreste is aimed at non-programmers without closing the door to those who are. The editor is organised in three authoring levels: each produces the exact same output, and you can move from the simplest level to the most powerful without throwing away your work.
Configurator
Forms with sliders, dropdowns, toggles. You start from a ready-made template (Game of the Goose, UNO, etc.) and change the visible parameters. Zero code, zero blocks.
Visual Editor
Rules are composed as building blocks (based on Blockly). A visual debugger shows in real time which rule is running during a test game.
Code Editor
JavaScript code editor with autocompletion. Same engine, same API, access to all advanced features. For those who find blocks too tight.
Work continuity. A game started in the Configurator can be opened in the Visual Editor for more sophisticated rules, and then in the Code Editor without rewriting. The reverse direction (from code to blocks) is not guaranteed.
From a blank page to a printed game.
The platform covers the entire board-game creation pipeline. Features are distributed across versions V0 (launch), V1 (multiplayer), V2 (marketplace), V3 (advanced).
Creation
- Ready-made official templates to customise
- Card, board, token and dice editor
- Declarative game schema, automatically validated
- Native multilingual: every string is a translatable key
- AI-assisted game generation from a text description (V3, Alchemist)
Playtest
- Playable simulator directly in the browser
- Step-by-step mode and deterministic replay
- Visual debugger: you see which rule is being executed
- Real-time multiplayer for up to 8 players, persistent games (V1)
- Automatic simulation of 1,000 games to balance the design (V3, Oracle)
Publication
- Marketplace of games created by the community (V2)
- Revenue share proportional to games played (Spotify-style model)
- Ratings, feedback, statistics for designers
- Fork: anyone can start from your game and make a variant with attribution
Physical printing
- Full bundle export: board, cards, rulebook, box (V2+)
- Integration with print-on-demand services (The Game Crafter, Launch Tabletop)
- Material, finish and quantity configuration
- From digital to a physical copy shipped to your door, without leaving the platform
Eight subsystems that make a platform.
Every piece of the platform has a name, a precise responsibility, and a colour. The subsystems are independent — the entire system starts from a single VPS server and scales horizontally without rewrites.
How data flows during a game
GDF + rules.js + assets
draws
applies
orchestrates
A single declarative schema for any game.
Oreste rests on a game definition format — the GDF — that describes the static structure (components, state, layout) separating it from the executable logic (the rules). The GDF v1.0 is a formal, machine-readable JSON Schema 2020-12.
Field-tested
The schema was subjected to stress tests on 7 real games of different genres — Game of the Goose, UNO, Carcassonne, Catan, Risk, Cluedo, Sushi Go. The analysis identified 50 gaps, all resolved or reserved in the schema. None will require destructive changes to the GDF in the future.
Complete schema, incremental engine
The strategy is schema-complete, engine-incremental: the schema declares from V1.0 all the fields needed for future mechanics (graph vertices, per-player visibility, simultaneous actions), but the engine implements them in phases. A game declaring a reserved mechanic remains valid — the engine will activate it when ready.
What this format enables
| Capability | Concrete consequence |
|---|---|
| Machine-readable games | Sentinel can validate them before publication, avoiding broken bundles in the marketplace. |
| Portability | The same bundle runs locally, in multiplayer, and can be exported for physical printing. |
| Multilingual | Every string is a translation key. Adding a language requires no code changes. |
| Automatic balancing | The AI Oracle (V3) can simulate thousands of games and suggest numerical corrections. |
| Reverse engineering | The AI Alchemist (V3) can start from a text rulebook and produce a draft GDF. |
Free to design. Paid to play and publish.
Design is always free and unlimited in the number of games. Paid plans unlock multiplayer and marketplace publication.
Free
- Full design (three levels)
- Local playtest
- Unlimited saving
- Marketplace in limited mode
- Unlimited multiplayer
- Publication
Player
- Everything in the Free plan
- Multiplayer for up to 8 players
- Lobby, chat, spectators
- Persistent games
- Full marketplace catalogue
- Publication
Designer
- Everything in the Player plan
- Marketplace publication
- Revenue share on games played
- Statistics and feedback
- Project document export
- Priority showcase placement
Revenue share — how it works
A portion of subscription revenues is redistributed monthly to designers in proportion to games played. The model is analogous to Spotify for musicians: whoever creates more-used content receives more.
The digital → physical pipeline. From version V2, a designer can export their game as a complete bundle and order physical production through integrated partners (The Game Crafter for print-on-demand, Panda Game Manufacturing for industrial production). No other competitor offers this complete pipeline.
A vision that grows by versions.
Four successive versions cover the entire product arc: from minimum viable (V0) to generative AI (V3). Each version is self-sufficient — at the end of V0 the platform is already usable.
MVP
- GDF Schema v1.0 + Sentinel
- Configurator (2 templates)
- Blockly visual editor
- Engine with safe sandbox
- Local simulator
- Visual debugger
- User account with full auth
Platform
- Secure WebSocket multiplayer
- Per-player state visibility
- Code Editor (Monaco)
- Out-of-turn reactions
- Modal card choices
- Generic renderer for custom games
- 3 official templates
Ecosystem
- Marketplace and publication
- Revenue share
- Forge: component editor
- Simultaneous actions, trading
- Set collection, scoring
- PnP export
- Print-on-demand integration
Advanced
- Alchemist: game from text description
- Oracle: balancing via 1,000-game simulation
- Reverse engineering from PDF rulebook
- Mobile app (PWA or Capacitor)
- Test sandbox with automated bots
Why Oreste and not another.
No existing platform combines accessible creation, automatically enforced rules, multiplayer and physical production. Each solves a piece of the problem.
| Platform | Visual editor | Automated rules | Multiplayer | Physical printing |
|---|---|---|---|---|
| Tabletopia | Partial (assets only) | No | Yes | No |
| Board Game Arena | No | Yes (requires PHP developer) | Yes | No |
| Tabletop Simulator | Partial (3D import) | No | Yes | No |
| Project Oreste | Yes (three levels) | Yes (for non-programmers too) | Yes (V1) | Yes (V2) |
The differentiators in one line each
- Automatically enforced rules for non-programmers — BGA enforces them but requires a PHP developer. Tabletopia and Tabletop Simulator do not enforce them at all.
- Formal, validated game schema — a machine-readable contract that none of the other platforms exposes.
- Free design with no limits — Tabletopia limits free to 1 game. Oreste does not.
- Integrated digital-to-physical pipeline — from the idea to the printed game without leaving the platform.
- AI for generation and balancing (V3) — no competitor offers these features.
Positioning. Oreste is not an alternative to BGA or Tabletopia for players: it is a tool for those who want to create original games. Players arrive as a side effect, attracted by the games published by designers on the platform. The analogy is 'Canva for board games'.
What makes Project Oreste a product, not an editor.
Inclusive
Three levels for three profiles. Nobody excluded.
Rigorous
The rules are executable code, not ambiguous text.
Open
Standard format, export, game forking.
Complete
From the idea to the physical game, without intermediaries.