System design mapping for games

Living GDD Keep your game’s design connected as it changes.

A system-first workspace for designing games as entities + relationships
so your intent stays navigable through prototypes, iteration, and shifting scope.

  • ✓

    Typed entities — characters, abilities, items, quests, locations, mechanics, factions, and ecosystem entities — with categories, tags, files, and optional stats where you define them.

  • ✓

    System-first navigation (IDE-style panels) so lists, detail, stats, links, and files stay in view while you work.

  • ✓

    SystemLink™ — explicit design links plus graph and impact views so “what touches this?” is a short walk, not a doc hunt.

Not a design bible and not a rules engine: a working map of intent, links, and review state. Your shipped build stays runtime truth — Living GDD helps the team see what changed, what’s linked, and what still needs a pass when scope shifts.

Create account Log in See it in action →

Start on the Free tier (one project, you only — no invited members), then upgrade a workspace to Solo or Team when you need collaborators or more projects. Pricing overview.

Games aren’t hard to imagine. They’re hard to keep navigable while they change.

Mechanics, quests, items, and characters don’t sit in neat chapters — they interlock. When that structure only lives in scattered notes and flat pages, iteration means re-deriving “what connects to what” instead of moving the design forward.

Living GDD targets the typed, linked layer: entities, explicit relationships, and lightweight review signals (pipeline + validation, per-entity tasks) so dependency walks stay short and small edits don’t require rewriting whole sections. When someone does open the workspace, the project overview (needs validation, health by type, activity) and reverse references make drift easier to spot than hunting prose alone.

✕

Dependencies stay implicit — ripple effects hide until playtests or crunch.

✕

Content lists don’t show how systems actually touch each other.

✕

One change forces a scavenger hunt through unrelated docs for what might be stale.

✕

Under time pressure, curating long documents loses to shipping.

Long-form writing stays in Notion, Docs, or Obsidian. This is the systems layer.

Living GDD doesn’t compete with narrative specs, mood boards, or high-level GDD prose — it gives you typed entities and navigable links for the parts of the design that behave like a graph (who, what, where, which mechanic) so they stay scannable as scope shifts.

✓

Complements prose, doesn’t replace it.
Keep essays, pitches, and art direction where you already work; use this for connected game elements.

✓

Built for discovery, not lock-in.
Games emerge through prototyping and playtests — the map evolves alongside that, without pretending paper is law.

✓

Minimum structure first.
Capture intent and dependencies that matter; add detail when it earns its keep.

✓

Honest about drift.
You still choose when to update — validation status, tasks, links, and overview lists make inconsistency easier to see than in prose alone. On Solo and Team workspaces, per-entity change history and snapshots help you remember what moved since last review.

How this differs from Notion, Docs, or Obsidian

Those tools are excellent for writing and freeform notes. Living GDD isn’t trying to replace them — it focuses on something they don’t model well: game systems as connected, evolving entities.

Where general-purpose notes struggle (for games)

  • Relationships and dependencies are implied, not explicit.
  • Design intent gets buried under pages and content lists.
  • When something changes, ripple effects are easy to miss.
  • Structure decays unless someone constantly curates it.

What this systems layer adds

  • Eight entity types (including abilities, factions, ecosystem entities) with categories, tags, and files.
  • SystemLink™ keeps relationships visible; graph and impact views support exploration.
  • Custom stats on characters, abilities, items, and ecosystem entities — defined per project.
  • Pipeline + validation, tasks, and overview so the map stays legible as the game changes.

A navigable map of your game’s systems — with structure you’ll actually keep using.

Today the app gives you typed entities, SystemLink™ relationships, optional stats, files, pipeline and validation status, per-entity tasks, and a project overview that surfaces what needs attention — plus graph and impact views to walk the graph. It complements long-form docs (Notion, Docs, Obsidian); it doesn’t try to replace them.

Living GDD · Sample Project

Entities

  • Characters
  • Abilities
  • Quests
  • Items
  • Locations
  • Factions
  • Mechanics
  • Ecosystem

Eira, Flamebound

Main protagonist · Fire-tuned mage

Role

Main character · Narrative anchor

Tagline

“If the world breaks its rules, why can’t I?”

Alignment

Good

What exists today (and what I’m exploring next)

The product already covers the core loop — entities, links, review signals, and workspace billing. Below is what you can use today, what’s next on the roadmap, and longer-shot directions shaped by feedback.

Available Now

  • • Eight entity types with categories, tags, hero images, and files
  • • Custom stats (characters, abilities, items, ecosystem entities)
  • • Three-panel navigation and tabbed entity detail
  • • SystemLink™ — typed design links, graph explorer, impact view
  • • Pipeline + validation per entity, tasks, optional propagation when stats/links change
  • • Project overview — activity, needs validation, per-type pipeline & health
  • • Workspaces, roles, Free / Solo / Team billing (Stripe)
  • • Per-entity change history & snapshots (Solo, Team, and comped workspaces)

In Progress / Likely Next

  • • Design → implementation export (CSV / JSON) and engine-oriented bundles
  • • Search & filters across entities and links
  • • Example / template projects
  • • Deeper compare / diff on snapshots
  • • Richer collaboration and notifications

Potential Directions

  • • Dialogue tree views
  • • Quest graph views
  • • Crafting system views
  • • Location map views
  • • Deeper graph layouts & filtering
  • • Studio collaboration ideas

Built for indie teams and solo devs

Designed for long dev cycles, part-time schedules, and small teams wearing too many hats. Keep your design knowledge navigable and connected — without turning documentation into a second job.

Minimum necessary

Capture the intent and dependencies that matter. Avoid exhaustive lists that rot the moment you iterate.

Update-friendly

No magic sync — you still choose to update. Status in lists, project overview, and per-entity tasks make “what’s out of date?” easier to see and chip away at than rewriting long pages. Typed links remind you what else might need a pass when one system moves.

Grows with you

Start simple. Add structure as prototypes become real systems — no big-bang documentation rewrite when a mechanic lands.

Ready to map your systems layer?

Create a free account to start a workspace, or log in if you already have one.

Create account Log in