Open-source deterministic game SDK for trade and diplomacy simulations
Every civilization. Every trade route. Every betrayal. One deterministic engine.
Between Two Roads is an open-source C# SDK for building trade and diplomacy simulations across Godot and Unity with deterministic, replayable simulation.
For teams building simulation-heavy games that need deterministic replay, modular systems, and the freedom to ship through Godot or Unity.
The core tension
Building simulation games is broken.
Teams spend months wiring save systems, event buses, tick pipelines, and state machines before writing a meaningful line of gameplay.
Then the simulation gets entangled with rendering and engine code, tests become flaky, replay drifts, and changing engines starts to look like a rewrite.
Between Two Roads exists to separate the simulation kernel from the runtime around it so the architecture can survive scale, change, and reuse.
Capabilities
What the SDK gives you.
Between Two Roads is shaped like infrastructure. It is designed to make simulation behavior predictable, portable, and testable long before presentation concerns arrive.
Deterministic to the Tick
Seed randomness, order events, and reproduce the same state every time for replay, debugging, AI training, and multiplayer confidence.
Modules, Not Monoliths
Adopt only what you need across resources, economics, factions, population, narrative, campaign, and relationships.
Engine-Agnostic Core
Write domain simulation once and adapt it to Godot 4.6 or Unity 6+ without rewriting the core model.
Architecture Enforcement
Keep boundaries honest with Clean Architecture and Roslyn analyzers that fail builds when dependencies point the wrong way.
Operating model
Clean Architecture, all the way down.
Domain logic stays pure. Application orchestrates. Infrastructure implements. Engine adapters bridge outward. The result is a simulation kernel that does not care about scenes, rendering, or UI until you deliberately connect them.
How it works
- Domain contains pure business rules across simulation and core modules.
- Application coordinates use cases, DTOs, and command-query workflows.
- Infrastructure handles persistence, configuration, and logging behind interfaces.
- Adapters bridge the same core into Godot and Unity runtimes.
Core modules
- Core.Time: tick-based time that never drifts.
- Core.Events: ordered, immutable domain events.
- Resources and Economics: production, markets, stockpiles, and price discovery.
- Factions, Population, and Relationships: power, migration, diplomacy, and betrayal.
- Narrative and Campaign: arcs, triggers, and progression across scenarios.
Use cases
Where it fits.
Trade and diplomacy simulation games
Deterministic replay systems for strategy, multiplayer, and AI workflows
Cross-engine simulation foundations built with modular Clean Architecture
Stay close
Follow Between Two Roads as it opens up.
Get release notes, architecture updates, and module previews as the SDK evolves in public.
Open source by design. Built for deterministic trade and diplomacy simulations.