Threader - Dialogue Toolkit

|| Documentation

|| Feedback 

|| Support 

|| Roadmap

|| Changelog

|| Discord

Threader – Dialogue Toolkit

Threader is a lightweight, production-ready dialogue system built around a visual node graph. Write conversations the way you think about them — as a branching tree — and let Threader handle the rest.

Render pipeline agnostic — works with URP, HDRP, and Built-in. The included demo scene uses URP; the dialogue system itself has no rendering dependency and requires no changes for any pipeline.

VISUAL GRAPH EDITOR

Open the Dialogue Graph window and build conversations by connecting nodes. The editor runs entirely in edit mode — no Play mode needed to author or preview. Add NPC lines, branch on conditions, jump between sections, and set variables mid-conversation, all without writing code. A full set of keyboard shortcuts keeps authoring fast. Right-click any node to bookmark it to the sidebar for instant navigation in large graphs.

Node types (15):

• NPC Node — one or more spoken lines with speaker name, Animator actions, and per-node events. Set Vars actions fire before lines play, so downstream choices already see updated state.
• Player Choice Node — presents choices with inline condition gating per row: show, hide, or lock based on variable values.
• Branch Node — silently routes flow to a True or False output port based on variable conditions, with no dialogue displayed.
• Set Variable Node — writes one or more variables without displaying any dialogue; useful for setting flags at branch starts or resetting counters in loops.
• Jump Node — re-routes execution to any tagged node, enabling loops and shared branches across the graph.
• Sub Graph Node — calls any other dialogue graph as a nested conversation and returns to the parent graph when it ends. Build reusable conversation modules once and reference them across as many graphs as needed.
• Random Node — picks a random output port each time it is reached.
• Weighted Random Node — picks a random output port with configurable per-port weights for controlled probability.
• Switch Node — multi-case routing based on a variable value; each case maps to its own output port.
• Wait Node — pauses execution for a configurable number of seconds.
• Fire Event Node — broadcasts a named string event (local or global scope) to your game code at any point in the flow.
• Play Audio Node — plays audio clips at a speaker's world position without pausing dialogue.
• Animator Trigger Node — sets Animator parameters on any registered speaker.
• Debug Node — logs messages and live variable values to the Console during development.
• End Node — terminates the conversation and optionally auto-switches the NPC's active entry point for the next interaction.

DIALOGUE PREVIEW WINDOW

Test any graph without entering Play mode. Open the Preview Window (Ctrl+Shift+P), select a graph, seed variable values, and step through every branch interactively — line by line, choice by choice. Condition evaluation is live, so locked and hidden choices reflect your seeded values exactly as they would at runtime. An essential tool for catching broken branches before shipping.

SUB-GRAPH SYSTEM

Route flow into any dialogue graph and back — exactly like a function call. Link the Sub Graph Node's "On end" slot to chain additional flow after the nested graph completes.

Speaker identity resolves at runtime: set it on the Sub Graph node directly, inherit it from the calling graph, or let each inner node define its own speaker. Supports unlimited nesting depth; recursive loops are safely blocked. Build reusable conversation modules — shop greetings, quest debriefs, shared NPC reactions — and stamp them across as many graphs as needed without copy-pasting a single node.

BARK SYSTEM

Fire ambient one-liner lines that play in parallel without blocking the player or starting a full conversation. Attach a BarkSource component to any NPC, assign a bark graph, and choose a trigger mode: OnEnter (proximity), OnTimer (cooldown-based loop), or Manual (fire from code). A configurable cooldown prevents bark spam. Barks are automatically suppressed while a full conversation is active. DialogueManager exposes OnBark and PlayBark() so you can drive your own bark UI independently of the main dialogue layer. Perfect for overheard idle chatter, combat callouts, and ambient world-building.

LINE SHEET SYSTEM

Assign per-speaker audio clips and Animator actions to every line in a graph without touching the nodes themselves. Create a Line Sheet asset, add speaker entries, and map each dialogue line to an AudioClip and optional Animator parameters. Audio plays automatically during dialogue from the speaker's world position. Line Sheets keep voice-over production separate from conversation authoring — writers and programmers can work on the graph while audio designers populate the Line Sheet independently.

MULTI-LANGUAGE SUPPORT

Assign multiple Line Sheets to a single graph — one per language. Each sheet overrides the line text and audio for its language. Switch languages at runtime with SetActiveLanguage() and all dialogue, including choice text, resolves from the active language's sheet automatically. Add new languages without modifying a single node in the graph.

SPEAKER ROSTER

Declare your speaker names in a Speaker Roster asset. Speaker fields throughout the graph editor become type-safe dropdowns instead of free-text strings — no more typos breaking dialogue. Add the roster to your DialogueManager and every graph in the project picks it up automatically.

NODE TEMPLATES

Save any selection of nodes as a reusable template asset. Templates appear in the Create sidebar — drag one onto the canvas to stamp the full node pattern in seconds. Rename, delete, and refresh templates from the sidebar without leaving the graph editor. Stored as DialogueNodeTemplate ScriptableObjects, they live in version control alongside your other project assets.

VARIABLES & CONDITIONS — NO CODE REQUIRED

Create a DialogueVariables asset, define your bools, ints, and strings in the Inspector, then reference them directly in node conditions and Set Vars panels. Choices can be locked (greyed out) or hidden entirely when conditions fail — configurable per row. Assign multiple assets to DialogueManager and the runner searches them in order; split variables by domain (quests, economy, flags) or keep them in one asset.

Embed variable values directly in dialogue text using {varName} tokens, or show a human-readable display name with {varName:name}. Tokens resolve at display time with no additional setup.

For logic that lives in your game code — inventory, reputation, time of day — register a C# delegate with ConditionService and reference it by key on any choice. No subclassing required.

ENTRY POINTS

Tag any node as a named entry point and start NPCs at different branches based on game state. Entry points auto-switch via End nodes or from code through the IDialogueActor interface — the same interface works whether a character uses DialogueTrigger or NPCDialogue, so your quest and save systems never need to know the difference. Perfect for first-meeting, post-quest, and repeat-visit dialogue, all in a single graph.

RUNTIME UI (UI TOOLKIT)

A ready-to-use UI layer built on Unity UI Toolkit handles:

• Typewriter text reveal with configurable speed and punctuation pauses
• Staggered choice button reveal for a polished cascading effect
• Space-to-skip line
• Visited choice history (automatically dims previously selected choices)
• Speaker name display and spatial audio routing

UI TOOLKIT IS NOT REQUIRED!

Swap it out entirely if you prefer your own UI — DialogueManager exposes clean C# events for every dialogue moment, and the runner operates independently of any UI component.

CLEAN API

DialogueManager.Instance.StartDialogue(graph, "AfterQuest", actor);

DialogueManager.Instance.OnNPCLine += line => ShowText(line.Text);

DialogueManager.Instance.OnChoiceNode += choices => BuildButtons(choices);

DialogueManager.Instance.OnDialogueEnd += HideUI;

DialogueManager.Instance.PlayBark(barkGraph, speakerTransform);

DialogueManager.Instance.OnBark += bark => ShowBarkBubble(bark.Text);

DialogueManager.Instance.VariablesList[0].SetBool("foundCat", true);

HIGHLIGHTS

• Fully event-driven — no hard dependency between DialogueManager and your UI
• Sub-graph system — call any dialogue graph from within another and return; compose reusable conversation modules without copy-pasting
• Bark system — fire-and-forget ambient lines that run in parallel without blocking player interaction
• Line Sheet system — per-speaker audio clips and Animator actions kept separate from conversation authoring; supports multiple speakers per graph
• Multi-language support — one Line Sheet per language, switch at runtime with a single call
• Speaker Roster — type-safe speaker name dropdowns across all graphs, no free-text typos
• Node templates — save groups of nodes as reusable drag-to-stamp assets stored in your project
• Graph bookmarks — pin nodes to a sidebar panel for instant one-click navigation in large graphs
• Works with any save system — variables and choice history are plain in-memory data you read and write yourself
• Spatial audio support — lines play from the speaker's world position automatically, with a 2D fallback when no speaker transform is registered
• Animator integration — trigger, bool, int, and float parameters wired per NPC node or via Line Sheet
• Speaker registry — multi-NPC scenes with automatic camera focus and audio routing via IDialogueActor and IDialogueFocus
• 2D and 3D projects supported out of the box

DOCUMENTATION

Full online documentation including a step-by-step quick start, guided tutorial, node reference, variables walkthrough, conditions guide, entry points guide, saving guide, sub-graph guide, bark system guide, line sheet guide, translation guide, node templates guide, and full API reference. Open it any time from inside Unity via Threader → Help & Documentation.