Dialogue tools for Godot 4.7: what each is, read from its repository

Checked on 2026-10-29 from a shallow clone of each repository's default branch (files read, nothing built or run). Release dates are the date of the tag's commit. None of them has been tried in a game here: the trial in a copy of the C# example (build, import, play one conversation headless) was blocked in this session, so "works on 4.7.2 with C#" below means what the project's own files and README say, not a result. The roadmap keeps the trial.

Reading it

• Licence is not the deciding factor: all five repositories are MIT. The NuGet packages Yarn Spinner pulls in have their own licences, which were not read.
• For a C# game on 4.7.2, two are current and say they support it: Dialogue Manager (a C# wrapper over its GDScript runtime, 4.6 or newer) and Yarn Spinner for Godot (written in C#, already on 4.7.2, with more NuGet dependencies).
• godot-ink is C# but its last release is from February 2024 against Godot 4.4.1, and its build downloads from GitHub: a CI runner with no network, or an export without internet, fails. Treat it as at risk until it is tried.
• Dialogic 2 is an alpha, GDScript-first, with its own editor resources instead of text files, so neither the data nor the l10n runner can read its dialogue.
• inkgd has no release for Godot 4 and no commit since 2023.
• Text formats help the kit. .dialogue, .yarn and .ink are plain text: the data runner's names rule can check character names in them, and a line's translation key can be checked as the l10n runner checks translations. Nothing here has wired that up yet.

Dialogue Manager 4 and Yarn Spinner for Godot, side by side

The two current choices for a C# game on 4.7.2. The snippets follow the patterns of each project's own docs and samples (Dialogue Manager's docs/*.md, Yarn Spinner's Samples/); they were not compiled or run here.

The same scene in each

Dialogue Manager, guard.dialogue:

~ start
Guard: Halt, {{Player.Name}}. State your business.
- Deliver a parcel [if Quest.HasParcel /]
	Guard: Pass. [ID:GUARD_PASS]
	$> Quest.Deliver()
	=> END
- Bribe the guard [if Player.Coins >= 10 /]
	Guard: I saw nothing.
	=> END
- Leave
	=> END

Yarn Spinner, guard.yarn:

title: Guard
---
<<declare $coins = 0 as number>>
<<declare $has_parcel = false as bool>>
Guard: Halt. State your business.    #line:guard01
-> Deliver a parcel <<if $has_parcel>>
    Guard: Pass, {get_random_string()}.    #line:guard02
    <<Unlock WorldNode north_gate>>
-> Bribe the guard <<if $coins >= 10>>
    <<set $coins = $coins - 10>>
    Guard: I saw nothing.    #line:guard03
-> Leave
===

Running it from C#

// Dialogue Manager: you walk the lines yourself (or call ShowDialogueBalloon for its example balloon).
using DialogueManagerRuntime;
var dialogue = GD.Load<Resource>("res://guard.dialogue");
var line = await DialogueManager.GetNextDialogueLine(dialogue, "start");
while (line != null)
{
    GD.Print($"{line.Character}: {line.Text}");
    var next = line.Responses.Count > 0
        ? line.Responses.First(r => r.IsAllowed).NextId     // a real UI lets the player choose
        : line.NextId;
    line = await DialogueManager.GetNextDialogueLine(dialogue, next);
}
DialogueManager.DialogueEnded += (Resource r) => GD.Print("done");

// Yarn Spinner: a DialogueRunner node drives line and option views; you start a node and listen.
_dialogueRunner = GetNode<DialogueRunner>(_dialogueRunnerPath);
_dialogueRunner.onDialogueComplete += OnDialogueComplete;
_dialogueRunner.StartDialogue("Guard").Forget();

Giving the dialogue game state and actions

// Dialogue Manager: state is whatever the dialogue can reach (autoloads, DialogueStateContext nodes, [GlobalClass] types).
[GlobalClass]
public partial class Player : RefCounted
{
    public static string Name = "Mira";
    public static int Coins = 3;
}

// Yarn Spinner: variables live in a variable storage, actions are attributes on public methods.
[YarnCommand]                         // <<Unlock WorldNode north_gate>>: WorldNode is the name of the node that owns the method
public void Unlock(string doorId) { /* ... */ }

[YarnFunction("get_random_string")]   // {get_random_string()} in a line
public static string GetRandomString() => "friend";

// _storage.TryGetValue<float>("$coins", out var coins);   // InMemoryVariableStorage; GetAllVariables / SetAllVariables for saves

Capabilities and weaknesses

The kit's choice: Dialogue Manager 4

Decided by the owner on 2026-10-29, after the comparison above. Not tried here (see "Not done"): the choice rests on the project's files and docs, not on a run.

• Version: v4.1.0 (tag of 2026-09-04), which states Godot 4.6 or newer. MIT: keep its LICENSE file with the add-on folder and list it in the game's assets.json / credits like any third-party code.
• Install (from its README and docs): copy addons/dialogue_manager of that tag into the game, enable it under Project Settings > Plugins, and write dialogue as .dialogue files; a global DialogueManager is then available, and a C# game uses the DialogueManagerRuntime wrapper that ships in the add-on folder.
• Keep dialogue in dialogue/ as .dialogue files, so one data.json entry covers them: "names": { "table": "characters", "field": "name", "files": ["dialogue/*.dialogue"], "allow": [] } (the names rule reads every file its globs match, line by line).
• Translations: use static line IDs ([ID:KEY]) and let the dialogue files join the template export under Project Settings > Localization; the CSV or PO that results is an ordinary Godot translation file, which the l10n runner reads.
• State is the game's: expose it through autoloads, [GlobalClass] types or DialogueStateContext nodes, and save it with the game's own save (the runtime keeps none).
• What to watch (from the table): the runtime is GDScript, so a C# game still needs GDScript enabled; a wrong member name in a condition or mutation fails when the line plays, not when the project builds, so play every .dialogue file once in a headless test before shipping. That test is not built yet.

Not done

• Building any of them in a copy of the C# example on Godot 4.7.2, importing a dialogue and playing one conversation headless.
• Reading the licences of the NuGet packages Yarn Spinner depends on.
• The fallback the roadmap names, a JSON dialogue graph checked by the data and l10n runners, because it only makes sense if no tool survives the trial.