Dependency mapping for RPGs & systems-heavy games

Living GDD Know what breaks before you change it.

Built for games where one change ripples everywhere — quests that touch items, items that touch abilities, abilities that touch factions.
Map your design as entities and relationships, then see the downstream impact before you commit to a change.

  • ✓

    Impact analysis — pick any entity as a root and see everything downstream that depends on it, before you touch a thing.

  • ✓

    Automatic validation flags — update a linked entity and everything connected to it gets marked as needing another look. Nothing goes stale quietly.

  • ✓

    Typed entities built for RPG systems — characters, abilities, items, quests, locations, mechanics, factions, and ecosystem entities, with stats where you need them.

Not a design bible and not a rules engine: a working map of how your systems connect and what needs re-checking when they change. Your shipped build stays runtime truth — Living GDD helps you see the blast radius before scope creep buries it.

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.

RPGs aren't hard to imagine. They're hard to change without breaking something else.

Rebalance one ability and three quests assume the old numbers. Rename a faction and twelve dialogue-relevant entities still point at the old one. In systems-heavy games, design elements don't sit in neat chapters — they interlock, and the interlocking is exactly what scattered docs and flat pages don't show you.

Living GDD targets that typed, linked layer: entities, explicit relationships, and an impact view that shows you what's downstream of any change — plus validation flags so connected entities don't quietly go stale. The project overview (needs validation, health by type, activity) makes drift visible instead of something you find during a playtest.

✕

You rebalance an ability and don't find out what quests relied on the old version until QA.

✕

Content lists don't show how factions, items, and quests 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 — and the doc rots.

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

Living GDD doesn't compete with narrative specs, mood boards, or high-level GDD prose — it gives you typed entities, explicit links, and impact analysis for the parts of an RPG's design that behave like a graph (which quest needs which item, which ability affects which faction) so you can see the ripple effects before you make a change.

✓

Complements prose, doesn't replace it.
Keep essays, pitches, and art direction where you already work; use this for the connected systems layer.

✓

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. But when you do, validation flags tell you exactly what else needs a second look — instead of relying on memory. 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: RPG systems as connected, evolving entities, with visibility into what breaks when they change.

Where general-purpose notes struggle (for RPG design)

  • Relationships and dependencies are implied, not explicit — you're relying on memory.
  • Nothing tells you what's downstream when you change a mechanic or ability.
  • When something changes, ripple effects are easy to miss until playtest or QA.
  • Structure decays unless someone constantly curates it by hand.

What this systems layer adds

  • Impact analysis — pick a root entity, see every downstream dependency in one view.
  • Automatic validation flags when a linked entity changes, so nothing goes stale silently.
  • Eight RPG-relevant entity types (characters, abilities, items, quests, locations, mechanics, factions, ecosystem) with categories, tags, and files.
  • Custom stats on characters, abilities, items, and ecosystem entities — defined per project.

Built to answer one question: "what does this touch?"

Typed entities, explicit relationships, impact analysis, and automatic validation flags — plus a project overview that surfaces what needs attention. It complements long-form docs (Notion, Docs, Obsidian); it doesn't try to replace them.

Living GDD · Sample Project

Impact of: Ember Sigil (ability)

  • Linked characters
  • Linked quests
  • Linked mechanics
  • Linked factions

Ability · "Ember Sigil" — downstream impact

3 flagged for validation

Characters

  • ✓ Eira, Flamebound
  • ⚠ Alden, Cartographer — needs validation

Quests

  • ⚠ "Ashfall Prologue" — needs validation
  • ✓ "The Long Thaw"

Rebalance the ability and every linked entity above is what's actually affected — no scavenger hunt through unrelated docs to find out.

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

The product already covers the core loop — entities, links, impact analysis, validation, 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 RPG-relevant 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 analysis view
  • • Automatic validation flags, 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 RPG 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 RPGs and other systems-heavy games

If your game has quests that reference items, abilities that touch factions, or mechanics that ripple across content — this is for you. Designed for indie teams and solo devs on long dev cycles, part-time schedules, and small teams wearing too many hats.

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. But validation flags, impact analysis, and per-entity tasks make "what's out of date?" visible instead of something you find out the hard way.

Grows with you

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

Ready to see what your systems are connected to?

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

Create account Log in