Getting started with interactive fiction
Trying out Twine and Ink
I’ve always been fascinated by interactive fiction. In the 1980s that meant Choose your own adventure books - the ones where you’d flick back and forth to different pages depending on your choices. In the early 1990s I tried my hand as programming my own interactive fiction in BASIC, but never got very far. In my mid-teens I discovered a programming language called Inform, via the remarkable games of Graham Nelson (Jigsaw apparently was released in 1995), and dabbled extensively.
Inform was a big leap but it was still at the very edge of what I could handle, from a programming perspective. Programming was never my chief interest: it was very much about storytelling for me, and poking at new ways of telling stories. The notion of a text which adapts to the reader/player has always been an intoxicating prospect.
Fast forward a couple of decades and the interactive fiction scene was very different. Inform was still around but there was a new system that was a much better match for my skills. Called Twine, it turned the idea of programming interactive fiction on its head, presenting the creator with a flowchart-style interface instead of requiring actual code.
Twine is entirely free to use. At its most basic, you use cards - like sticky notes on a whiteboard - to create the scenes in your story. These can be connected via hyperlinks, which represent player/reader choices: the equivalent of ‘turn to page 45’ in those old Choose your own adventure books. Here’s a super basic example:
Note the choices, which are surrounded with double square [[brackets]]. That markup denotes a ‘choice’, and Twine automatically spins them out into separate cards. So here’s what the board looks like:
It should be immediately apparent just how easy and intuitive Twine is. My son created his own branching story in it when he was 7 years old. It’s a great way to get into writing IF.
Here’s what that example above looks like when played in a browser:
That’s the other thing: interactive fiction is so well suited to playing in a browser, which in turn means that it adapts very easily to mobile. Combine that with readers being more used to reading on screens and IF is more accessible than ever.
Twine is powerful and you can do a lot more than simple branching options. During lockdown, when my son and his friends couldn’t meet up in person, I created a mini-adventure for them to play. This involved them climbing up a mountain, with two completely separate routes, and combat and puzzles along the way. Here’s the two branching routes up the mountain:
Looks pretty cool, eh? You can see that it’s already getting quite difficult to visually parse. If we look more closely at that bottom-right section, the flowchart arrows are really quite mad:
I even borrowed some code from another Twine user (sorry, can’t remember who!) to implement an actual turn-based combat system, which looked like this:
Anyway, it was cool and the small people it was made for had lots of fun. I also made a prequel experience for my novel The Mechanical Crown in Twine, which you can still play here.
But as mentioned, the flowchart map of games made in Twine can be quite unwieldy - and these are very short, relatively simple games. Taking a break for a few days would then make it almost impossible to remember how it all slotted together when I returned.
Simon K Jones writes is a reader-supported publication. To access author notes and support my work, consider becoming a paid subscriber.
Branching and reactive copy is what I’m really interested in, which is how I ended up looking into Ink. This is an interactive fiction scripting language created by Inkle Studios, creators of 80 Days, Heaven’s Vault, Sorcery! and Overboard! They know what they’re doing when it comes to IF.
Side note: I was lucky enough to chat to Jon Ingold on the Writer’s Centre podcast a few years back. Do give it a listen:
The immediate appeal of Ink is that it is designed for writers, rather than programmers. It’s hugely powerful, but the emphasis in its syntax and the design of Inky, the editor and compiler, is always prioritising the writing. Twine’s graphical interface is very easy and highly intuitive, but it also interrupts the writing flow every step of the way, as you have to open and close each individual story block.
Ink, on the other hand, is flowing text that feels far closer to writing a standard manuscript - it just happens to have bits of markup code scattered through. It also has a very easy to follow and nicely presented user’s guide:
I’ve only just started using Ink in earnest but it already feels more natural than any of the previous IF systems I’ve dabbled in. The ease with which a writer can create amorphous prose is really exciting. Here’s something I’ve been fiddling with as a way to practice and learn the techniques:
This creates a simple looping scene in which the reader repeatedly wakes up in the same location, but with the text changing slowly over time. The sensation of writing narrative which appears to change in semi-real time as the player interacts is really quite thrilling. This is a very basic example, and there’s little in the way of actual interaction or choice. I’m really looking forward to digging into the user guide and exploring the power Ink provides.
I’ve long had a desire to make a computer game, and I suspect Ink will be what finally enables me to do so. I’ll share my experiences as I go, and will put some tests up for you to play with. Should be fun!
Thanks for reading. If you’re a writer and haven’t yet done so, please do fill out the 2022 Online Fiction Writers Survey. I’ll be closing it at the end of the month, which means there’s only a couple of days left. There’s a sneak peak of results here:
See you on Friday for a new Tales from the Triverse chapter.