CLogic Dialogue System

Build dialogue your way, from simple conversations to fully custom narrative systems. The CLogic Dialogue System is a node-based dialogue framework for Unity built on Unity's Graph Toolkit.

Create linear conversations, branching paths, player choices, conditions, events, reusable subgraphs, and custom gameplay interactions through a visual graph.

Complete C# source code included.

Documentation | Non-Commercial Version

⚠️ Early Access

The CLogic Dialogue System uses Unity's Graph Toolkit, which is still evolving. The Dialogue System will remain in Early Access while Graph Toolkit's APIs and workflows continue to mature.

We currently expect Early Access to last until Unity 7, when Graph Toolkit is expected to be more mature.

During this period, updates may require API changes or migration work. If your project depends on a completely stable API between releases, take this into account before using the system in production.

✨ Visual Dialogue Authoring

Build conversations visually rather than hard-coding their flow.

• Node-based dialogue graphs: Create and edit conversations through Unity's Graph Toolkit.
• Branching conversations: Split conversations into different paths based on player choices or game logic.
• Conditional dialogue: Decide which paths are available based on the current state of your game.
• Events & gameplay logic: Trigger actions from within a conversation.
• Subgraphs: Break larger conversations apart and reuse sections through asset subgraphs.
• Real-time validation: Problems can be caught while working on a graph. Supported issues include quick actions for resolving them automatically.

Whether you're making a short NPC exchange or a much larger branching conversation, the graph keeps the dialogue flow visible and structured.

✨ Quick to Set Up

You shouldn't need to build an entire dialogue architecture just to make two characters talk.

Add a Dialogue Director, create a Dialogue Graph, and start building with the included nodes or create your own.

The runtime takes care of progressing through the dialogue. Your project remains responsible for how that dialogue is displayed and how it interacts with the rest of the game.

If the included functionality covers what you need, use it as-is. If it doesn't, extend it.

✨ Built to be Extended

Your dialogue framework shouldn't decide what your game is allowed to do.

The CLogic Dialogue System uses a node and processor architecture that lets you introduce project-specific behaviour without modifying the core runtime.

You can create your own:

• Dialogue nodes
• Node processors
• Pre-processors
• Post-processors
• Conditions
• Gameplay integrations

Nodes define what can appear inside your dialogue graphs. Processors determine what those nodes actually do at runtime.

That means dialogue doesn't have to exist in isolation. It can interact with quests, inventories, relationships, cutscenes, minigames, progression systems, or whatever other systems your project uses.

✨ Designed for Programmers

Need something the package doesn't already provide? Add it without rewriting the system.

The framework is intended to be a foundation rather than a closed solution. You can extend existing behaviour, add nodes and processors that fit your needs, or connect dialogue to your own systems while leaving the underlying runtime alone.

How dialogue fits into the rest of your game's architecture remains under your control.

✨ Core Features

• Visual node-based dialogue authoring
• Linear and branching conversations
• Player dialogue choices
• Conditional dialogue paths
• Dialogue events and custom gameplay logic
• Reusable asset subgraphs
• Real-time graph validation
• Quick fixes for supported validation problems
• Extensible nodes and processors
• Complete C# source code

Start Simple. Extend When You Need It.

The CLogic Dialogue System covers straightforward dialogue without forcing your project to stay within those limits.

For ordinary conversations, use the included nodes and start building. When the defaults are no longer enough, keep the same framework and add your own nodes, processors, conditions, and gameplay behavior without fighting the system.

Try It Before Using It Commercially

Not sure whether it fits your project?

The complete source is available on GitHub for non-commercial use. You can inspect the architecture, create dialogue graphs, experiment with the runtime, and evaluate how it fits your project before purchasing a commercial license.

Commercial use requires an authorized commercial license.