When most studios set out to build a digital version of a board game, they reach for a general-purpose game engine, like Unity or Godot (the new kid on the block). It makes sense on the surface: the engine handles rendering, input, and cross-platform builds. But for board games specifically, this approach comes with trade-offs that most publishers never see until the app is already on the store.
The problem with general-purpose engines
A game engine designed for 3D shooters or platformers carries a lot of overhead that a board game simply doesn't need. The result is an app that's larger than necessary, drains more battery, and takes longer to load. For a game where the core interaction is "make a move and wait for your opponent," that overhead is all cost and no benefit.
More importantly, general-purpose engines treat game rules as something you build from scratch every time. There's no built-in concept of "turns," "legal moves," or "game state." Every board game adaptation becomes a custom engineering project, which is why they take so long and cost so much.
What a rules engine gives you
Our engine was built from the ground up for board games. After 20 years of encoding game logic, the hard problems are already solved:
- Turn management and state tracking across dozens of game types
- Multiplayer with reconnection handling and cross-platform play
- Asynchronous play (take your turn whenever, like the original play-by-mail model)
- Rule enforcement and legal move validation
When we start working on a new game, we're not building an app from scratch. In many cases, the rules (which tells the app moves are legal and which are not) are defined in configuration files rather than in code, which means we can go from rulebook to working prototype much faster than a traditional build, and we know that the code already works if the rules have been defined correctly.
Why native matters
Building in Swift and Kotlin means the app uses UI components native to the platform, respects system settings, and has access to features like haptic feedback and push notifications without workarounds. The install size is smaller. Battery usage is lower. The app just feels like it belongs on the phone.
The bottom line
We're not against game engines. They're the right tool for a lot of projects. But for tabletop games, a purpose-built rules engine running natively on the device produces a better app: smaller, faster, and cheaper to maintain over the long haul. That's why we built one.