# DialogueNodes gives Godot a graph editor for branching dialogue

> nagidev/DialogueNodes is a Godot editor plugin for creating, testing and exporting branching dialogue trees, with conditional options, bbcoded text animations, character portraits, signals and variables, an in-editor previewer and localisation through tres files. It is written in GDScript, its latest tagged release is v1.2 from 2024, and two known bugs are documented in the README.

**nagidev/DialogueNodes** — A plugin for creating, editing and using branching dialogues in Godot

- Repository: https://github.com/nagidev/DialogueNodes
- Stars: 541 · Forks: 39
- Language: GDScript
- License: MIT
- Published: 2026-10-22 · Updated: 2026-10-22 · Language: en
- Canonical page: https://hysenlabs.com/projects/nagidev-dialoguenodes

## A graph editor for conversations, inside the Godot editor

DialogueNodes is a plugin for creating and exporting dialogue trees from within the Godot Editor. The reasoning behind it is stated plainly in the README. Godot provides all the tools needed to create your own dialogue system, but for most game developers that task is tedious and complex, and the plugin is where the tedious part is removed. What it adds is an editor extension, so the work happens on a graph of nodes and connections inside the same window as the rest of your project, and the result is dialogue you can test before you ship it. The intended user is a game developer whose game has conversations, which in practice means narrative games, adventure games, role playing games and anything with a shopkeeper who says different things depending on what you did earlier. The plugin is distributed under the MIT licence, is completely free, and the README adds that it does not require any payment of any kind, with the author's Ko-fi link offered for support. The screenshots in the repository show the editor, the dialogue box and the node graph, and the icon and assets directories are part of the plugin package.

## Conditions, bbcode animations, portraits and localisation

The feature list is where the value of the plugin becomes concrete. There is a simple editor with a straightforward dialogue box, so the runtime presentation is not trying to be a general purpose UI kit. Dialogue animations with bbcodes mean you can type markup in the text and have it animate, which is how the box reveals a line rather than dumping it. Conditional dialogues and options are the core of a branching conversation, so branches can be gated on state instead of being a static tree. Support for variables and signals is what makes those conditions expressible, since a signal can advance a conversation or set a flag that a later node reads. Character portraits and colours handle the presentation of who is talking. The in-editor dialogue previewer is the feature that changes the working method, because you can read a line and try a branch without leaving the editor or starting the game. Localisation comes through tres files, which fits Godot's resource system and means a translation is a resource rather than a separate string table, and the repository root carries a default_env.tres to match.

## Installation goes through the AssetLib, not a package manager

There is no script to run, and the installation path is entirely inside Godot. The README gives four steps. Search for Dialogue Nodes in the Godot AssetLib, install the plugin, enable the plugin from the project settings, and you are done. The full instructions, including how to install the plugin directly from the GitHub repository, live in the project wiki, and the README links both the installation and setup page and a separate page for installing from GitHub. This is a different onboarding experience from a library you add to a manifest, and it has one practical consequence worth planning for. Because the plugin is enabled per project through project settings, adopting it is a decision you make per project rather than a line you add to a build file, and updating it means going back through the AssetLib or re-cloning the repository, not bumping a version number. The repository layout is consistent with a Godot plugin, with an addons/ directory holding the plugin itself, an assets/ directory, the icon files, a project.godot and a default_env.tres.

## Two known bugs the README does not hide

The known issues section is short and specific, which is a good sign for a plugin of this size. The first is that using a return character in the dialogue results in options not showing up in certain cases, which is a functional problem for anyone using line breaks in a branching option. The second is visual, with DialogNodes in the graph having options that overflow outside the edges, and the README attributes that to a bug introduced in Godot 4.2, linking the corresponding Godot engine issue. That second one is worth understanding properly, because it means the layout glitch is not the plugin's own regression but a change in how the engine lays out nodes, and it will affect anyone whose projects run Godot 4.2 or later. The README also asks that before filing a bug you check whether the same or a similar issue already exists, and points to the issues page of the repository. Documentation is another honest gap. The wiki is still being updated frequently, some of the functionality might not be documented, and the author asks people to contact him if they want to help with the documentation.

## C# projects are explicitly not a supported target

The plugin was built using GDscript and has not been tested for proper C# support, and for those cases the README points to a separate project, DialogueNodesForCSharp. That is a clean answer rather than an evasion, because Godot 4 supports both GDScript and C# and a plugin written in one language is not automatically usable from the other, since the plugin's own node types and resources are GDScript classes. The practical implication for a team is that the dialogue data and the runtime component would be GDScript inside an otherwise C# project, which raises the question of how much of your game's logic is affected by that boundary, and if you want the graph editor in a C# project you have to look at the other repository instead. This is also the one place where the README names a genuine alternative to the project itself, and it is a good example of the distinction that matters in the plugin ecosystem, since a port in the same design is not the same as a rewrite with a different data model.

## Building a dialogue system yourself instead

The alternative is the one the README names first, which is to use what Godot gives you. The engine has everything required to build a dialogue system, and for a game with a handful of linear lines that is often the right call. The difference in approach is what you take on. Doing it yourself means writing the data format, the runtime that reads it, the condition evaluation and the presentation layer, and in many projects the biggest hidden cost is that the data format is a set of resources or a JSON file that you then edit by hand, which is where the tedium the plugin names actually comes from. DialogueNodes inverts that, with a graph editor as the authoring surface, an export step that produces the runtime data, and a previewer for testing, so your dialogue becomes something you draw rather than something you type. The trade is a dependency on someone else's data format and editor, and a plugin that only understands one engine version range. For a large branching narrative, the authoring surface is the thing that decides how long the writing takes, and that is where this plugin earns its place.

## Release history, push activity and what the gap means

The maintenance picture has two halves that you should read together. The listed releases are v1.2 from 2024-05-12, v1.1 from 2024-04-28 and v1.0 from 2023-10-02, so the tagged versions are more than two years old, and the naming is a simple major version scheme without patch releases, which for an editor plugin is defensible because the asset library install path handles updates separately from tags. The repository, however, is not archived and the last push was on 2026-09-15, so work is still landing in main. That combination means the version you install from the AssetLib and the code in the repository are not obviously the same thing, and the README's own note that the wiki is still being updated and that some functionality might not be documented is consistent with a project that is being worked on in a way that its published artefacts do not fully describe. For an evaluation, the sensible checks are therefore concrete. Look at the graph editor on your Godot version, in particular the node overflow on 4.2 and later, try a branch that uses a return character, and read the wiki pages for the features you actually plan to use rather than trusting the feature list.

## Conclusion

DialogueNodes fits a Godot developer who writes GDScript and has a branching conversation to design, since a visual graph editor and an in-editor previewer remove a lot of hand-editing of dialogue data. It does not fit a C# project, because the plugin is GDScript and has not been tested for that, and it does not fit a project that needs its own dialogue format, since the export targets this plugin's own pipeline. Before you commit to it, read the known issues, in particular the return character bug and the Godot 4.2 node overflow, and note the last push was on 2026-09-15 while the newest tagged release is v1.2 from 2024-05-12.

## FAQ

### How do I install DialogueNodes in Godot?

Search for Dialogue Nodes in the Godot AssetLib, install the plugin, then enable it from the project settings. The README also links wiki pages for setup and for installing the plugin directly from the GitHub repository.

### Does DialogueNodes work in a C# Godot project?

Not properly. The plugin was built using GDScript and has not been tested for C# support, and the README points C# users to the separate DialogueNodesForCSharp project instead.

### What are the known bugs in DialogueNodes?

Using a return character in the dialogue can result in options not showing up in certain cases, and options in the graph can overflow outside the node edges, which the README attributes to a bug introduced in Godot 4.2.

### How does DialogueNodes handle localisation and dialogue conditions?

The feature list includes conditional dialogues and options, support for variables and signals, character portraits and colours, dialogue animations with bbcodes, and localisation through tres files, so a translation is a Godot resource rather than a separate string table.

## Sources

- [Issues](https://github.com/nagidev/DialogueNodes/issues)
- [License: MIT](https://github.com/nagidev/DialogueNodes/blob/main/LICENSE)
- [nagidev/DialogueNodes on GitHub](https://github.com/nagidev/DialogueNodes)
- [README](https://github.com/nagidev/DialogueNodes/blob/main/README.md)
- [Releases](https://github.com/nagidev/DialogueNodes/releases)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/nagidev-dialoguenodes