A practical first path through Storyteller 3.
Storyteller has a large set of tools, but the basic workflow is simple: create a Story, add a Scene, begin a character chain, connect the events that follow, and then bridge that data into your game when you are ready.
Installation and package requirements
Import Storyteller 3 from the Unity Package Manager into the Unity project where you want to use it. Storyteller 3 is designed to function as a self-contained Unity asset and does not require another external tool in order to create and manage stories.
- Open Unity's Package Manager.
- Locate Storyteller 3 in your available assets.
- Download and import the package into the project.
- Allow Unity to finish compiling before opening Storyteller for the first time.
Game Bridge is included with Storyteller 3. You do not need to install a separate runtime package before following the authoring sections of this guide.
Good to know
The core Storyteller workflow does not require AI services. AI-assisted generation and translation are optional features and can be configured later if you choose to use them.
Import Storyteller 3, keep the supplied libraries and assembly definitions together, and wait for compilation. Open Tools → Ruchmair → Storyteller → Storyteller Studio.
Creating a Storyteller 3 Story project
Launch Storyteller from Tools > Ruchmair > Storyteller > Storyteller Studio. When the Storyteller window opens, click New Story in the upper-left corner.
- Choose a folder if you want to control where the Story asset is saved.
- Give the Story a name, or leave the name unchanged to create New Story.
- Press Create. If no folder is selected, Storyteller can create the Story using its normal project location.
What the New Story information is for
The New Story window lets you establish the creative context for the project. This can include information such as the story's year, genre, overview, tone, setting, theme, plot, summary, target audience, narrative style, art style, art medium, and color palette.
You do not need to perfect all of this before creating the project. The same story-level information is available later from the Story's Settings window, so it can evolve as the project develops. Think of these fields as shared context for your story rather than a form that must be completed before you can work.
Why add this information?
Besides keeping the project organized, story-level information gives characters, scenes, exports, and optional AI tools a consistent creative context. For a quick test project, a name and a few basic details are enough.
Choose the Story name and location, create a scene and add the first Character chain. Fill in creative metadata as the project develops.
Creating scenes and nodes
Create a Scene
Scenes divide the Story into manageable sections. From the upper-right area of the canvas, open Project Manager > Go To Scene Manager > Add New Scene.
Double-click a Scene to open it. You can also double-click the Scene name to rename it. Once the Scene is open, the canvas becomes the workspace where you build that part of the story.
Create your first node chain
Hold CTRL + Left Click on an empty area of the canvas to open the Node creation menu, then choose the node you want to add. For a first test, begin with a Character Node. Character Nodes are important because they establish a character's chain of events.
When a node is selected, its editable data appears in the Properties window. The exact properties change with the node type.
The Timeline
Move and trim clips, edit dialogue in place, and refine timing with snapping, ripple edits and locks. Preview localized route audio and export mixes or character stems. Read the Timeline guide →
As nodes are connected into character chains, those nodes are also represented in the Timeline. The Timeline gives you a chronological view of the active story path instead of only the spatial view of the canvas. Timed nodes can show information such as start time, delay, duration and their position in the character's sequence, while route-aware views help you understand how alternate paths affect the flow.
The Canvas answers “what is connected to what?” while the Timeline helps answer “when does this happen?”
Connect the structure on the Canvas. Refine clip timing and text on the Timeline. Select a node to edit its detailed Properties.
Characters and environments
Characters and environments give the connected nodes around them context. They are more than labels on a graph: both can carry reusable information that follows the story into later tools and, when bridged, into runtime data.
Character Nodes
A Character Node identifies the character responsible for a chain of events. Character data can include the character's name and biography as well as deeper profile information, personality data, imagery and voice samples. You can keep the profile lightweight for minor characters and add detail only where it is useful.
Dialogue and other nodes connected through that character's chain can inherit the relationship to the character, which is why beginning with a Character Node makes the flow easier to understand.
Environment Nodes
An Environment Node describes where the following part of the chain is taking place. Environment information can describe the location, mood, physical appearance, history, culture, architecture, time of day, season, weather, lighting and other details, along with an environment image.
When an Environment Node becomes active in a chain, the connected nodes that follow are understood to occur in that environment until another Environment Node changes it. This lets you establish a location once instead of repeating the same information on every dialogue or action.
Keep profiles as simple as the project needs
A Storyteller project does not require a complete biography or world encyclopedia for every scene. Add the information that helps you write, organize, export or drive gameplay, and expand it later when the project benefits from it.
Characters define participant chains and profiles. Environments establish location context. Parent/child evolution relationships connect related states.
Routes, conditions and nonlinear structures
A straight chain is useful for learning Storyteller, but stories often need decisions, alternate outcomes and paths that later return to a shared sequence. Route Nodes are the main authoring tool for those branches.
Connect a Route Node where the story should split, then connect its outputs to the different branches. Each branch can contain its own dialogue, actions, environments and additional routes. Storyteller 3 supports Route structures with multiple outputs, allowing a single decision point to lead into several possible paths.
Links, loops and convergence
Link Nodes help connect sections of the graph without drawing an impractically long connector across the canvas. They can also participate in time skips and looping structures. Routes can be used with these structures to decide when a loop continues, exits, or returns to another part of the story.
When different branches should return to the same continuation, build the graph so those paths converge back into a shared sequence rather than duplicating the remainder of the story.
Where conditions fit
The Route defines the possible structure. At runtime, Game Bridge conditions can decide whether a route, event or interaction should be available based on the current game state. This separation is useful: Storyteller describes the narrative possibilities, while Game Bridge connects those possibilities to gameplay rules.
Localization and translation
Storyteller can store the same story content in multiple languages. A Story has a language list, one language can act as the default/source language, and localized node data is kept aligned with that list.
Start by adding the languages the project actually needs. Write and review the default language first, then fill the translated values manually or use Storyteller's optional translation tools. Dialogue text, accompanying actions and route titles are examples of content that can have language-specific versions.
Translation can be performed on focused selections instead of forcing you to translate an entire project every time. This makes it practical to translate a scene or selected nodes as that part of the story becomes ready.
Runtime language selection
When Storyteller data is pushed through Game Bridge, the SceneData includes the language information needed by the runtime system. Game Bridge can then use the selected language index when retrieving localized text and route options.
Keep dialogue, route choices and language-specific media in the same Story. Review translated text and test the active language in Game Bridge.
Audio, storyboards and media
Storyteller is not limited to written dialogue. Media can be attached to the parts of the story where it is useful, allowing the same narrative data to act as both a writing tool and a lightweight production reference.
Dialogue Nodes can carry localized dialogue, voice recordings, sound effects and storyboard imagery. Action Nodes can use storyboard images and sound effects to show or reinforce what is happening. Characters can also hold voice samples, while Environment Nodes can use images to visually define locations.
On the Timeline, audio-aware timing can help you understand how dialogue and actions fit together. This is particularly useful for cinematic conversations, visual-novel style scenes, timed sequences and any interaction where pacing matters.
You do not need to add media to every node. Use it where the visual or audio reference communicates something the text alone does not.
A practical production workflow
Write and connect the scene first. Add rough storyboards or temporary voice clips during iteration, then replace them with final media later. This keeps story structure separate from asset polish and makes revisions easier.
Game Bridge runtime setup
Game Bridge is included with Storyteller 3. Storyteller is where you author the story; Game Bridge is the set of runtime systems that lets Unity use that authored data during play.
The central runtime asset is SceneData. When you use the Game Bridge editor to Push To Scene Data, the relevant Storyteller scene is converted into runtime-friendly node data. That SceneData can include the connected node set, characters, languages and other information needed by the interaction system.
- Create or select the SceneData that will receive the Storyteller scene.
- Use Game Bridge's editor tools to push the authored scene into that SceneData.
- Add/configure an Interaction component in the gameplay scene.
- Connect the required characters or interactable objects for the interaction.
- Trigger the interaction from gameplay and connect your own UI to the dialogue, route and event data you want to present.
Open Tools > Ruchmair > GameBridge > Game Systems for the component catalogue, or use the complete runtime setup guide. One Interaction can hold multiple SceneData entries with scene-specific Conditions and bindings.
Game Bridge does not force one dialogue-box design. The same story can drive a traditional dialogue window, scrolling history, overhead chat bubbles, phone-message UI, cinematic subtitles or another presentation built for your game.
Saving, history and advanced runtime systems
Once the basic interaction is working, Game Bridge includes systems for projects that need to remember what has happened and restore game state later.
History
The History system can retain information about processed story events. History entries can identify the scene, character, node type, displayed text, route information, timing, participants and other runtime context. This makes it useful for features such as conversation logs, recap screens, debugging, or game logic that needs to know what the player has already experienced.
Saving
The included SaveManager is a generalized JSON persistence system. Save targets are processed in an ordered list, allowing game objects, components and ScriptableObjects to participate in the save/load pipeline. Multiple save slots and lifecycle options can be used when the project needs them.
This runtime save system is separate from saving the Storyteller Story asset in the Unity Editor. Storyteller stores authored project data; the SaveManager is for the state of the game while it is being played.
Advanced structures
Use SaveManager for configured game-object/component state and InteractionSaveManager for narrative progression and runtime World Item state. Coordinate slots and load order, then test restoration after a route choice or item action. Shared event variables are runtime-only. Read the save-system setup →
When should I learn these systems?
After a basic SceneData + Interaction setup is working. Saving and history become much easier to reason about once you already understand what a node looks like at runtime and how your game moves from one node to the next.
SaveManager captures configured game objects and components. InteractionSaveManager captures narrative progression and runtime World Item state.
Edit scenes on the Timeline
Work with the selected route in character tracks, with linked selection across the Timeline, Canvas, Properties and Story Sample.
Write and adjust timing
Click a clip to select it. Double-click dialogue or action text, or press Enter on a selected clip, to edit it in place. Enter commits, Shift+Enter inserts a line break and Escape cancels. Right-click empty track space to create dialogue or actions.
Drag clips to move them and drag the right edge to change duration. Move only preserves unselected start times; Ripple shifts following clips in the same character chain until a locked clip. Use snapping for grid and boundary alignment, or hold Alt during a drag to bypass it. Properties provides exact timing values.
Navigate and listen
Use Fit scene or Frame selection, middle-drag to pan, Shift+wheel to scroll horizontally and Ctrl/Alt+wheel to zoom. Space plays or pauses; click the ruler to seek. Choose a language and route to preview their text, voice and sound effects.
Under Options, Generate Audio prepares the route in memory. Export Audio writes the selected route or distinct branch variants for the current language, including a combined scene WAV, voice/SFX mixes and character stems. Mute and solo affect the generated mix and exports.
Expand character tracks to see voice, sound effects, storyboards and bound Game Bridge event markers. Click an event marker to inspect its condition in Condition Code View. Story Sample follows playback and lets you select the corresponding story node.
Item nodes and possessions
Open the full World Items guide →
Represent a World Item on the canvas and attach its references or state changes to the points in the story where they belong.
- Choose Make Node > Item Node from the canvas context menu, or use the Ctrl/Cmd-click Quick Node Creator.
- Select an existing World Item, or choose New. Multiple Item cards can refer to the same library identity.
- Choose Reference or State Change, click Attach, then choose a target node in the same scene. Escape cancels attachment.
- For a state change, click the dashed link label to open Items & Possessions and configure possession, ownership, environment, status and notes under Node Links.
Reference links identify an item without changing state. State-change links create an event on the target node. These attachments stay separate from execution connections and do not alter the character chain or timing. Use a connected runtime story node for a state change that should execute in game.
History can show active-route events or all authored events, including skipped branches. Route State evaluates an item at a particular story node. When copying cards, select their target nodes too if you want the attachments included; a card copied alone keeps its item identity without linking back to the original targets.
3D character portraits
Use a 2D image or frame a prefab/imported model as the portrait for a character's biography or evolution state.
Open the Character Node's Image options and choose 3D Model, or drag a prefab or imported model from the Project window onto the portrait. Double-click the portrait or choose Portrait Settings… to open Character Portrait.
Drag to orbit, Shift-drag to pan and scroll over the preview to zoom. Adjust framing and background color, then use Save Portrait PNG if you need a separate image. Switching between 2D and 3D retains both assignments and settings. Different evolution states can keep their own framing.
Model portraits are rendered in the Editor and exported as still images. They do not spawn a gameplay character or embed an interactive 3D viewer in Story Viewer. Use materials compatible with the project's render pipeline.
Runtime conditions and event data
Read live game values, retain returned objects and connect multiple public member calls through Conditions and StorytellerEvents.
Compare live values
In a condition check, use Value from for the left side and Compare with for the right. Select a public member or a shared variable; the right side also supports a constant. The member picker can traverse fields, properties, parameterless returning methods and collection elements, including negative indexes counted from the end.
Reuse results between calls
Event arguments can use constants, members, earlier named results, shared runtime variables or the current iteration item. Expand Runtime target / results to target a scene object/component, a static member, an earlier result or a shared variable. A result name is local to one execution; the producing call must run before its consumer.
For example, instantiate a UI prefab, name the returned object, get its text component and assign dialogue from Interaction history. Use Share result on to retain a result on a chosen Condition for another event. Shared variables reset between Play sessions and are not serialized save data.
Collections and inspection
For each item runs a call for each element of a snapshot of the selected collection. Enable Stop on failure for dependent actions when later calls should stop after a failed call; previous side effects are not rolled back.
Open Tools > Ruchmair > GameBridge > Condition Code View to inspect configured conditions and event calls, or open a bound condition through its Timeline marker.
Existing projects and player builds
Existing checks remain executable. Opening a Condition upgrades its old selectors; the loaded-scene selector upgrade command creates backups and saves affected scenes. Shared event variables need their own persistence if your game must save them. For IL2CPP builds, preserve reflected members that would otherwise be stripped and verify the target player build.
Canvas organization and reusable templates
Use node groups to name and move related content together, then hide or show a group without changing its connections or playback. Contextual tooltips explain controls and automatic arrangement handles branches, convergence, links and storyboard spacing.
Templates provide View, Create and Edit workflows for reusable structures. Include the required characters, routes, links, Item cards and target dependencies when capturing a template. Pasting and insertion remap internal references; matching World Item identities can be reused. The included Time Loop template demonstrates an authored return path.
Character and environment evolution use explicit parent/child relationships. Keep linked states consistent while giving each biography/evolution state its own localized context and imagery.
HTML export and Story Viewer
Export a readable, multilingual HTML presentation with story overview, scenes, characters, environments, search and media. Story metadata, localized text, route titles and language-specific audio are presented together.
Export a .storytellerweb package for Story Viewer. Open it through the file picker or drag and drop to inspect its story, scenes, items, read-only Canvas and Timeline. Package processing stays on the device; browser playback does not run Unity Conditions or Game Bridge gameplay.
Unity recognizes the package asset with its Story Viewer icon. Double-clicking opens the website; select or drag the local package there to give the browser access. 3D character portraits export as still images.
Game Bridge
Game Bridge is the connection between authored Storyteller data and the systems in your Unity scene. The basic mental model is: Storyteller Scene → SceneData → Interaction → your game/UI.
SceneData
SceneData is the runtime representation of a Storyteller scene. It contains the raw pushed node set, an active node set used during interaction, character references, languages and the active language index.
Interaction
The Interaction component processes the current SceneData and manages linear or nonlinear interaction flow. It exposes runtime actions such as moving to the next node and changing the active language, while interaction trigger components can begin conversations with specific interactable characters.
Conditions and reflected data
Conditions let runtime logic respond to game state. They can be general to an interaction or associated with specific reflected/node data, allowing events to be gated or invoked at the part of the story where they matter.
Explore every Game Bridge component → · World Items and possessions →
Your UI remains yours
Game Bridge provides the narrative/runtime data rather than prescribing a single finished game UI. Use Unity UI, TextMeshPro, world-space canvases or your own presentation system and connect it to the data/events required by the game.
Storyteller Scene → SceneData → Interaction → Conditions and StorytellerEvents → your UI and gameplay.
Localization
Localization is built around one shared language list and language-specific versions of the content that players see or hear.
Choose a default language
The default language acts as the main authored/source version of the Story. Additional languages are kept in matching positions so Storyteller and Game Bridge can retrieve the correct localized value using the active language index.
Localized content includes story and scene metadata, character biographies, environment descriptions, dialogue accompanying actions and route-choice titles. Language-specific voice and sound-effect data stay associated with the same story.
Translate the content that needs it
Dialogue text, accompanying actions and route titles can be localized. Where media is language-specific, the corresponding language data can also be managed without requiring separate copies of the entire Story.
Use translation tools selectively
Storyteller's optional translation tools can work on focused sets such as selected nodes or larger scene collections. This lets you keep translating as the story changes instead of treating localization as one irreversible final step.
Translation tools can target an individual node, selected nodes, the active scene or all scenes, with broader metadata translation workflows. Review whether existing populated translations may be updated. Use fonts and fallback fonts that cover the target writing systems.
Switch languages at runtime
The language list is carried into SceneData. Game Bridge uses the active language index so the same interaction can return the appropriate localized dialogue and route choices.
Review localized story and scene metadata, biographies, environment details, dialogue, route titles and voice/SFX assignments.
AI Tools
Storyteller 3 can be used without AI. The AI tools are optional assistants for creators who want help generating, expanding or translating project content.
Set up an API key only if you use AI
AI features require your own supported API key. Storyteller provides an API settings area in Unity's Project Settings so the key does not need to be entered repeatedly into individual tools.
Generate within Story context
AI tools can use the Story's creative information—such as genre, tone, setting, theme and narrative style—to help produce content that is closer to the project you are already building.
AI Story Studio and AI Agent
AI Story Studio can build dialogue, actions and branching routes using selected characters and the Story’s creative context. Use its AI Agent button for project discovery, story/scene creation, character biographies, node editing, validated connections, arrangement and saving. Review the tool log and resulting graph.
The Agent works on Storyteller authoring assets. Configure runtime Conditions and events through Game Bridge; use the dedicated tools for exports, images and voice. Online generation uses your configured API access and sends the submitted content to that service.
Images, references and creative context
Optional generation supports story covers, character images and node storyboards. Story, scene, character and environment prompts, image references and camera-composition settings help maintain creative direction. Review generated imagery and text as part of normal production.
Use AI as an editing workflow
Generation is most useful when you review the result like any other authored content. You can generate or expand dialogue, character and environment material, build story structures, translate supported content, and then edit the result directly in Storyteller.
Use the project’s story context and references, inspect generated dialogue and branches, and review timing and connections before pushing to Game Bridge.
Scripting
You can use Storyteller 3 largely through its visual tools, but Game Bridge also exposes runtime data and public components for projects that want direct scripting control.
Start with the runtime data model
SceneData contains the scene-level runtime information. Its node collection is built from classes such as DialogueNodeData, ActionNodeData, CharacterNodeData, EnvironmentNodeData, RouteNodeData, LinkNodeData and EndNodeData.
Control interaction flow
The Interaction component is the main processor for dialogue and interaction flow. Public methods can be called from scripts or UnityEvents where your game needs explicit control—for example, moving forward or changing the active language.
Trigger interactions from gameplay
Interaction trigger components can begin an interaction with an InteractableCharacter or GameObject. This keeps the trigger mechanism flexible: collision, raycast, UI selection, keyboard input or another gameplay system can decide when the conversation begins.
Build on History and SaveManager when needed
History exposes structured records of processed interaction data, while SaveManager provides an ordered persistence pipeline. These are useful extension points when a game needs custom logs, progression tracking, quest state or save/load behavior.
The current authoring namespace is Ruchmair.Storyteller; Game Bridge runtime types use Ruchmair.BridgedData. Review integrations that still reference the older DaiMangou namespaces.
Open Tools > Ruchmair > GameBridge > Game Bridge Function Reference for supported runtime calls and examples. BeginInteraction, BeginMonologue, BeginAt, MoveNext, GoToRoute(int), Pause, Resume and EndSession cover distinct lifecycle actions. Use the runtime guide to choose the intended behavior.
Choose the appropriate entry method, advance with MoveNext, choose an output with GoToRoute(int), and coordinate pause, resume and session ending.
Documentation first. Direct support when needed.
If a workflow is unclear or you find a reproducible problem, the Support page has Discord and direct contact options.