Authoring interactive narrative in Twine 2 vs Ink vs Yarn
A quick and dirty comparison, using examples
(Update: I’ve now included Yarn in this comparison.)
(Note: The follow up to this post, a comparison of getting Unity integration up and running for Twine 2, Ink and Yarn can be found here.)
For a client project recently I started looking into interactive narrative authoring systems that offer Unity integration. Specifically, I’ve been looking at how some common patterns are authored using each system. I didn’t find any systematic comparisons of the two systems online, so I’m very briefly documenting my own efforts here.
Things to note:
- I’m new to Twine, Ink and Yarn, so I welcome any corrections or suggestions.
- The project I’m working on has fairly specific constraints and requirements, including the fact that non-technical people need to be involved in the writing process. My goal here is to imagine what the authoring and work-flow experience of these systems may be like, rather than make any sort of judgement about which one is “better”.
- My intention here isn’t to go deep or teach anyone how to use Twine, Ink or Yarn and the examples below aren’t accompanied with explanations. Go here for Twine 2, here for Ink, and here (and, for advanced stuff, here) for Yarn documentation.
- I may add to this document later.
To create the examples below I used:
- Ink script editor Inky
- Twine 2 editor, scripting in the Harlowe (default) story format.
- Notepad++ to author Yarn files. (I found I had save/load issues with the Yarn Editor, which is a shame as I like the Twine-style graphical interface it offers.)
A player is given a choice (e.g. a dialogue choice).
Based on a player’s choice or some other trigger, the story splits into separate sub-narratives.
Storing and modifying variable data.
Example 1: The availability of a choice is dependent on the game state.
Note that in addition to my own variable (sense_of_mortality), Ink allows me to check whether a piece of content has seen (in this case, At_the_pony_store).
Example 2: The content adapts based on the game state.
The player is allowed to repeatedly return to a point (like a ‘hub’ in a game) from which they can make additional choices.
By default, Ink remembers which choices the player has already made and hides them from the player.
To get the same behaviour in Twine 2 you’d do it manually using scripting (i.e. state tracking + conditional logic), e.g.:
External function calls
Here I’ve just copied/paraphrased information I found in the documentation for Ink and Cradle:
Ink with Ink Unity Integration
- Use “variable observers” to notify the game of state changes
- Use tags to add invisible metadata to a line in ink.
- Use the text itself to write instructions to the game, and then have a game-specific text parser decide what to do with it.
Twine with the Cradle Unity plugin
Cradle allows this via their “cues” and “runtime macros” APIs.
Yarn with the Yarn Spinner Unity plugin
Yarn Spinner allows this with YarnCommand attribute.
I also did a comparison of basic Ink vs Twine 2 integration to see which system might suit our project’s needs. I briefly documented that here. (I’ll be adding Yarn Unity integration to it soon.)