How Ink Drives Dynamic Dialogue in HAWKER (and Why We Picked It)
Ink is why HAWKER's NPCs remember. When Duval greets you differently because you helped Sulon last Tuesday, or when Ankou's dialogue branches based on how much ichor you've paid by day six, Ink is running those decisions. This piece, from the team at Tyrian Games, is a short developer log on why we picked Ink over the alternatives, what it actually does, and why dialogue-heavy indie games keep ending up on it.
TL;DR
- Ink is Inkle's open-source narrative scripting language, originally developed for 80 Days and Sorcery!
- Compared to visual-node dialogue systems, Ink handles deep conditional logic and variable tracking natively.
- HAWKER's persistent NPC memory, day-dependent dialogue, and branching narrative all run on Ink.
- Games using Ink include 80 Days, Heaven's Vault, A Highland Song, Neo Cab, and HAWKER in September 2026.
- Ink is free under MIT licensing, which makes the choice less about cost and more about fit.
What is Ink?
Ink is a narrative scripting language developed by Inkle Studios, the team behind 80 Days (2014), Sorcery! (2013), Heaven's Vault (2019), and more recently A Highland Song. It's open source, integrates with Unity and other engines, and is designed specifically for branching narrative with variable state.
Mechanically, Ink is a scripting language that compiles to JSON and runs in a runtime you embed in your game. Writers write stories in Ink's syntax, which looks like screenwriting with flow-control annotations. The runtime tracks which lines have been visited, what variables have been set, and what choices are currently available. The game queries the runtime for the next line or the current choice set.
The pitch, from our perspective, is that Ink treats narrative as programming the way visual-node dialogue systems treat it as diagrams. If your story is complicated with many branches, many variables, and many characters holding persistent memory, Ink scales where visual systems buckle under their own structural weight.
What Ink lets HAWKER do
Four concrete things that were hard in our initial visual-node prototype and easy in Ink.
Persistent NPC memory across runs. Duval remembers that you helped him find his lost saddle even if you died three days ago and restarted the calendar. The memory travels across deaths because Ink's variable store is separate from the run-state. This is structurally difficult in most visual dialogue editors because they treat each conversation as a self-contained tree.
Day-dependent dialogue. Every NPC has different lines on different days. Malgven greets you differently before versus after day seven. Ankou's tone shifts between paying and missing payments. In Ink, this is a few lines of conditional logic per character. In a visual editor, it would be dozens of nested branches that become unmaintainable within weeks.
Dialogue that references prior runs. In a later run, if you previously spared a particular NPC, other characters respond to the Hawker at first meeting with a reference to that earlier decision. Ink handles this natively through variable persistence. Node-based systems often require significant custom infrastructure for the same effect.
Writer-engineer parallelism. Our narrative team can iterate Ink scripts while the engineering team works on systems, and the two work streams don't interfere with each other until the final integration pass. This parallelism is one of the quiet reasons Ink is so widely adopted in dialogue-heavy indie studios. Visual node editors often couple content and system work in ways that slow both teams down.
What we tried before Ink
For the first four months of pre-production we used Unity's built-in dialogue asset workflow plus a commercial visual-node addon. It worked for linear dialogue. It broke down when we started building the NPC memory system.
Specifically, our NPCs have something like 200 to 400 distinct dialogue fragments each, organised by day, by prior-interaction state, and by choice history. Representing this in a visual tree resulted in node graphs that were too large to navigate in a single editor window. Merging changes between team members became painful. Debugging was impossible. On a bad day the editor would lose track of a connection and produce dialogue that went to the wrong branch, with no clear way to identify the break.
We swapped to Ink around month five of pre-production. The NPC dialogue migration took about two weeks. The productivity gain was immediate. By month seven we'd written more dialogue than we had in the previous four months combined, and we could finally trust that the dialogue we'd written would play back the way it was written.
Games that use Ink
Selected examples, with brief context.
80 Days (Inkle, 2014). The flagship. Around 750,000 words of branching narrative across the game, and the production model that proved Ink could scale to full-length commercial titles.
Heaven's Vault (Inkle, 2019). An archaeology-themed adventure with custom language translation mechanics layered on Ink. The translation system uses Ink's variable state to track the player's interpretation of an ancient script.
A Highland Song (Inkle, 2023). Mountain-hiking adventure, extensive use of Ink for environmental dialogue and route-dependent storytelling.
Sorcery! (Inkle, 2013 to 2016). The original Ink showcase across four instalments, each deeply branched.
Neo Cab (Chance Agency, 2019). Cyberpunk driving sim with Ink-scripted passenger dialogue. A great example of Ink outside Inkle's own studio.
Over the Alps (The Stolen Wagon, 2020). Cold War spy adventure with branching Ink-narrative. Demonstrated the language's strength in short, replayable branching stories.
HAWKER (Tyrian Games, September 2026). Grimdark shopkeeper roguelite with Ink driving all dialogue, persistent memory, and branching narrative.
The pattern is dialogue-heavy games with branching structures and variable state. Ink doesn't do everything, but what it does, it does well enough that Inkle's own games have stayed on it across a decade of releases.
When not to use Ink
Not every game is an Ink game. Ink is overkill when your dialogue is simple and linear, when your narrative is entirely non-branching, or when your team has no one willing to learn a scripting language. Ink is not visual, so teams that need a visual editor for writer onboarding will struggle.
Ink is worth it when you have branching dialogue with persistent state, when NPCs need memory across sessions, when you want the narrative team to work independently of the engineering team, or when your story has enough content that visual tools become unmanageable. The threshold is lower than you'd think. Even medium-complexity dialogue benefits from Ink's structure, and the learning curve for writers is under a week for most writers we've onboarded.
What we had to build on top of Ink
Ink is not a complete solution. Four pieces we built ourselves to make Ink work for a full commercial game.
An Ink-to-Unity integration layer. Ink provides a runtime but not UI. Our integration handles speaker attribution, portraits, text pacing, and choice presentation. About 1,500 lines of Unity C#.
A save-state layer that preserves Ink variables. Ink's variable store has to survive save-load cycles, and specifically has to survive death-reset within a run without losing cross-run persistent state. This layer was the trickiest part of the integration.
A voice-acting trigger system. When a line has recorded voiceover, we trigger the audio clip at the right moment, interrupting on skip and syncing with text reveal. About 400 lines of integration.
A build-time validator. Ink scripts can compile successfully and still contain logical errors, like a choice that's unreachable or a variable that's never set. We built a validator that runs at build time and flags these before they reach QA.
All four are standard work for any Ink project at commercial scale. The Inkle team has documentation and community examples for most of it, and the Ink Discord is unusually generous with technical help.
A first-hand Hawker example
One of our favourite moments with Ink was a bug that turned out to be a feature. In late 2024 we'd written a set of dialogue for the caravan's fire-keeper that varied based on how many days the Hawker had gone without eating. The Ink logic tracked the player's food state across runs. In playtest, one tester stacked a few low-food days across runs and received a line from the fire-keeper that we hadn't remembered writing. "You're wearing out faster than you're owning." It was a legitimate Ink-generated line from a conditional branch that depended on three variables being in a specific state.
The tester's response was to check their food level immediately. They hadn't realised the fire-keeper was watching that closely. The moment communicated something neither dialogue nor UI had communicated up to that point, which is that the caravan's NPCs are tracking the Hawker's condition even when they're not being asked to speak about it. We left the line in. We wrote two more in similar conditional branches. That kind of emergent-feeling specificity is what Ink enables when the script is structured around variable state rather than around trees. We couldn't have written those lines in a visual editor because we wouldn't have been tracking the state they depend on. Ink made the whole texture of the caravan's watchfulness possible.
FAQ
What is Ink?
Ink is an open-source narrative scripting language developed by Inkle Studios. It's designed for branching dialogue and variable state, integrates with Unity, and is used in games like 80 Days and Heaven's Vault.
Is Ink free?
Yes. Ink is open source under the MIT License. Using it in commercial games is free.
What games use Ink?
80 Days, Heaven's Vault, A Highland Song, Neo Cab, Over the Alps, and HAWKER in September 2026 among others. The pattern is dialogue-heavy games with branching structures.
Do I need to be a programmer to use Ink?
Writers can learn Ink's syntax in a few hours. It's simpler than most programming languages. Using Ink in a full game project does require at least one programmer to integrate the runtime, but that programmer time is much smaller than the equivalent integration work for most visual dialogue systems.
Is Ink better than Yarn Spinner or Fungus?
Depends on scope. Yarn Spinner and Fungus have visual tools that Ink lacks. Ink scales better to complex branching and variable state. For simple dialogue, Yarn Spinner or Fungus are faster to adopt. For complex narrative, Ink is worth the investment.
Spoiler wall
Everything above keeps Hawker at the level of systems and writing workflow. The caravan, the Hawker's food system, and the NPC memory are all shown in our trailers and store page. Specific late-game branching narrative and the post-demo character outcomes sit behind this wall.
Closing
Ink is why HAWKER's NPCs feel like they're paying attention. Without it, we'd have built something thinner and more fragile, or we'd have spent engineering months building our own narrative infrastructure. Inkle gave the genre this tool for free and we're grateful.
Next read: The light and shadow mechanic, or Why HAWKER uses a 30-day deadline.
Further reading
For related context see narrative roguelites after Hades.