Write, test, and ship branching dialogue. One tool.
Author in a node graph, integrate through a pull-based API, and let automated path testing play your story thousands of times before QA sees a build.
What is StoryBonsai?
StoryBonsai is a narrative engine and visual editor for Unity, Godot, and any .NET game. Writers build branching dialogue, scenes, locations, items, skill checks, time tracking, and localization in a licensed desktop authoring tool. Developers ship the same engine into their game as a runtime with a typed event API and zero engine dependencies.
Narrative is a production problem
Most dialogue systems treat conversation as a scripting problem. StoryBonsai treats it as a production problem: authoring, reviewing, recording, testing, localizing, and shipping in one workflow. Producers use a built-in test suite and automated path tester to verify the whole story holds together before it reaches QA.
In production
StoryBonsai is in private beta and already in production at a studio on two titles: an FMV game and a historical CRPG set in 1930s New York.
A visual node graph at any scale
A custom canvas editor built for narrative, not diagramming. Every node is a choice: there are no separate dialogue, condition, or branch types to learn. Level-of-detail rendering keeps thousands of nodes responsive; zoom out and nodes become colored tiles, zoom in and full cards appear.
Two drag gestures cover most authoring. Drag from the bottom of a node to wire where the story goes next; drag from the top to say "show this choice only after that one played." Scenes share the canvas with visible bounding boxes, and a companion World Graph shows your locations, travel connections, and staged encounters as one map.
How do you test a branching story before it ships?
StoryBonsai plays your story for you. The path tester runs hundreds to thousands of automated playthroughs, seeded and reproducible, using four strategies:
- Random. Uniform exploration.
- Defaults. Always the first-authored choice; verifies the golden path.
- Coverage-guided. Pushes into under-explored regions.
- Goal-seeking. Drives toward a target scene or variable state.
It walks the world layer too, moving between locations and advancing time, then reports dead ends, unreachable nodes, infinite loops, and unused content, each with the shortest path that reproduced it.
Writers add their own guarantees on top. Expression tests pin
individual conditions with named scenarios the
editor can suggest from boundary analysis. A real-time validator flags
structural errors as you type, and the same checks run headless in CI
with storybonsai validate, pathtest, and
test. Full details in the
path tester manual.
A world layer: locations, items, skills, and time
Locations, items, skills, codex entries, and time are core entities, not variables you fake. Locations connect into a traversable map with gated routes, ambient audio, and arrival events. Encounters stage any scene at any location, triggered by a character, an item, or the place itself, and retire themselves when their resolve condition latches.
Skill checks roll project-configurable dice against a difficulty expression, with situational modifiers and four outcome branches including criticals. Inventory is a list variable plus item metadata, readable in any condition. An optional world clock gates content by time of day, throttles repeatable beats with cooldowns, and reacts to how long the player has been away. See the world layer in the manual.
Localization built in, not bolted on
Every project carries a source locale and any number of target overlays. The editor tracks translation coverage per string, flags stale entries automatically when source text changes, and exports translator handoffs as CSV, JSON, or XLIFF, filtered by status and scope. Imports merge back through a diff that separates clean updates, stale rows, and orphaned keys.
Dialogue supports ICU message format for plurals, selects, and ordinals per locale. Flip the editor into any target locale and the simulator outlines untranslated lines in red; point the path tester at a locale and thousands of automated runs surface every missed string. The full workflow is in the localization manual.
FMV and media out of the box
Video, audio, images, and Unity content are first-class media with timed captions, linked tracks, background clips, and story beats: writer-tagged narrative moments the engine remembers so your game can build "previously on…" recaps from content you already wrote.
The built-in simulator plays it all during authoring: messaging-app
playback with video, captions, and placeholder text for unrecorded
lines. A breadcrumb of every choice lets you rewind to any past
decision without restarting, and the runtime's PeekMedia()
tells your game what to preload so the first frame after a choice is
instant.
An expression language writers can read
Conditions read like sentences: var_health > 0 &&
Played(node_intro). Nearly fifty built-in functions cover play
history, inventory, time of day, math, strings, and stateful slots
like Once, Cycle, and Pick that
remember their own state across a run. Syntax highlighting,
context-aware autocomplete, and a quick reference sit next to every
field. Rename any entity and every expression that references it is
rewritten for you. Every function is documented in the
function
reference.
A pull-based API. Your game owns the loop.
The runtime returns data; your game decides what to do with it. No callback wiring, no inheritance, no sidecar process. Load the exported JSON, pull events, present choices. Typed C# events cover dialogue, media, hooks, activities, skill checks, and variable changes.
runtime.Start();
while (true) {
foreach (var e in runtime.GetEventQueue()) {
HandleEvent(e);
}
var choices = runtime.GetChoices();
if (choices.IsComplete) break;
var picked = await ui.PresentChoices(choices.Choices);
runtime.SelectChoice(picked.Uuid);
}Single-player or multiplayer. Built into the runtime.
Choices belong to players. The runtime tracks per-player state and applies every player's selection in a single pass. Your game handles networking. StoryBonsai handles the narrative.
StoryBonsai is built by Michael Garforth. Building games since 2006: seven years on narrative simulations for healthcare and education, four years at Meta prototyping on unreleased AR hardware.
Frequently asked questions
What is StoryBonsai?
StoryBonsai is a narrative engine and visual editor for Unity, Godot, and any .NET game. Writers create branching dialogue, world state, and skill checks in a licensed desktop editor; the runtime ships as .NET Standard 2.1 assemblies with a typed event API and zero engine dependencies.
What game engines does StoryBonsai support?
The runtime targets .NET Standard 2.1 with zero engine dependencies, so it runs in Unity, Godot (.NET), MonoGame, and any .NET-capable host. Studios drop in the runtime, load the exported project JSON, and drive the story through a pull-based API with typed C# events.
What platforms does StoryBonsai run on?
The editor runs on Windows, macOS, and Linux. The runtime is plain .NET Standard 2.1 assemblies with zero engine dependencies, so it runs anywhere your engine can load them. Games built with StoryBonsai are tested on PC, Mac, and Steam Deck today; mobile and console support is coming.
How does StoryBonsai test branching dialogue?
The built-in path tester plays hundreds to thousands of automated runs using four strategies: random, defaults, coverage-guided, and goal-seeking. It reports dead ends, unreachable nodes, and untranslated strings. Writer-authored expression tests run alongside, and a CLI runs the same checks in CI.
Does StoryBonsai support localization?
Yes. Every project has a source locale plus any number of target overlays. The editor tracks coverage and stale strings, exports CSV, JSON, or XLIFF for translators, and merges round-trips with a diff. Dialogue supports ICU plurals and selects, and the simulator highlights untranslated lines.
Can StoryBonsai handle FMV and video?
Yes. Video, audio, images, and Unity content are first-class media with timed captions, background clips, and story beats. The editor previews media inline, the simulator plays it during authoring, and the runtime tells the game what to preload so transitions are instant.
How is StoryBonsai different from Ink or Yarn Spinner?
Ink and Yarn Spinner are scripting languages. StoryBonsai is a visual editor plus engine with production tooling built in: automated path testing, a writer test suite, localization round-trips, media management, and validation. Writers work in a node graph rather than code, and producers get reports they can hand to a publisher.
How is StoryBonsai different from Dialogue System for Unity?
Dialogue System for Unity is a Unity asset; StoryBonsai is engine-agnostic middleware. Writers author in a standalone desktop editor rather than inside Unity, and the same .NET Standard 2.1 runtime with zero engine dependencies runs in Unity, Godot (.NET), and MonoGame. Automated path testing, localization round-trips, and validation are built in.
More questions? The writer manual documents every feature, function, and event type.
Request Access
StoryBonsai is currently available to select studios. Leave your details and we'll be in touch.