Guides
Comparison

Comparison with Other Tools

How plotknot compares to other narrative scripting tools. This page is for developers choosing a tool for their project.

At a glance

	plotknot	Yarn Spinner	Ink	Loreline
Syntax	Markdown-like DSL	Yarn script (custom)	Ink script (custom)	Markdown-like DSL
Output	Lua data tables	JSON / bytecode	JSON	JSON
Runtime	Thin Lua library	C# / Unity / Godot	C# / JS / others	Runtime library
Extensibility	Lua runtime hooks	C# commands / functions	External functions	Runtime hooks
Editor support	VS Code + LSP	VS Code + Yarn Editor	VS Code + Inky	VS Code
Localization	Built-in keys	Built-in	Built-in	Built-in
Engine coupling	None (data output)	Unity / Godot focused	Engine-agnostic	Engine-agnostic

Syntax

plotknot uses a Markdown-like syntax. Sections are headings, text is plain lines, choices are list items. The goal is low-noise authoring that reads like a document:

# The Tavern

"What'll it be?" asks the barkeep.

choice:
- Ale, please. -> order_ale
- Just information. -> order_info

Yarn Spinner uses a custom script format with [[links]] for navigation and <<commands>> for logic. It’s designed for dialogue-heavy games with node-based flow.

Ink uses a flowing prose style with * for choices and -> for diverts. It’s optimized for deeply branching narrative with complex flow control.

Loreline uses a Markdown-like syntax similar to plotknot, with sections and choices. It targets visual novel and dialogue-heavy games.

Output format

plotknot compiles to plain Lua tables — human-readable data files you can inspect, diff, and debug. The runtime interprets this data; no executable code is generated.

Yarn Spinner compiles to JSON or bytecode. The runtime executes the compiled program.

Ink compiles to JSON. The runtime interprets the JSON story data.

Loreline compiles to JSON data files.

The key distinction: plotknot’s output is data, not a program. The runtime is a thin interpreter. This makes the output easy to inspect and the runtime easy to port to new engines.

Extensibility

plotknot extends at runtime through three Lua hooks:

on_call — handle game function calls from the story
register_function — add functions usable in expressions
on_line_type — handle custom line types in compiled output

No compiler plugins. The language is fixed; the runtime is the extension point.

Yarn Spinner extends through C# commands and functions registered with the dialogue runner. Tight Unity/Godot integration.

Ink extends through external functions bound at runtime. The language itself is rich (lists, threads, tunnels).

Loreline extends through runtime hooks similar to plotknot.

When to choose plotknot

plotknot is a good fit when:

You want minimal syntax. The core language covers sections, choices, variables, conditions, and game interop. No feature bloat.
You want data output. Compiled files are plain Lua tables you can read, diff, and version-control. No opaque bytecode.
You’re using Defold (or Lua-based engines). The runtime is a single Lua file with no dependencies.
You want engine flexibility. The compiler produces data, not engine-specific code. Porting the runtime to Godot, Unity, or a custom engine is a small effort.
You want runtime extensibility without compiler changes. Custom functions, call handlers, and line types cover most game integration needs.

When to choose something else

Yarn Spinner if you’re in Unity or Godot and want a mature, battle-tested tool with a large community and visual editor.
Ink if you need deeply complex narrative flow (threads, tunnels, lists) and a rich authoring tool (Inky).
Loreline if you want a similar Markdown-like syntax with a different runtime model.