Comparing Tools for Building Branching Scenarios

When would you use Twine instead of Storyline or other tools for building branching scenarios? At one of my presentations, a participant asked why I’d bother creating something in Twine rather than just storyboarding directly in Storyline, especially if I was using character images. Whether I would use Twine, Storyline, Rise, or something else depends on the project and the goals.

Strengths of different tools Twine

• Creating the branching structure: Twine is strongest at creating the branching structure and writing the decision paths. If the branching is significant, or the scenario is long, I can build the initial prototype in about half the time it would take in Storyline. 
• Revising the structure: Twine is best for revising the branching structure. Being able to drag and drop the passages to organize particular parts of the branching makes it much easier to see what’s happening. It’s also easier to see when a revision would break the structure and figure out how to fix it. I talk about revising branching structure in a past post.
• Responsive output: Twine creates a responsive output (it’s HTML). With the sidebar hidden, it works well even on a small phone. 
• Game features: Twine is used by many independent game developers. If you’re interested in game features like variables, randomization, scores, and customized feedback, Twine has the power to do all of that.
• Free: Twine is a free, open source tool. You can download it or use the browser-based version.

Storyline

• Animation and Media: Storyline is great for timed animation, special effects, and controlling exactly what each slide will look like. It’s also much easier to do audio in Storyline.
• SCORM: Storyline makes SCORM output easy.

Rise

• Easy to build: The Rise scenario block is easy and fast. As long as you’re happy with the layout in Rise, it’s fast to create sometthing
• Responsive: Like everything in Rise, it’s responsive.

Google Forms

• Collect data: Because it’s a survey tool, Google Forms automatically collects data on responses and provides charts. Without requiring an LMS or even login, you can build and share a branching scenario that collects data.
• Free: Google Forms is a free tool, and many educators are already familiar with it.

iSpring

• Structure and presentation: iSpring’s TalkMaster lets you build the branching structure with a drag and drop tool. You can also create the final presentation in the same tool, without needing to rebuild it.
• Fast: It’s fast to build in iSpring. Being able to build the structure and the final product in the same tool saves time. The options are limited (for example, you can’t control the layout), but that also means you have less to spend time on.
• Characters: You can use built-in characters and assign them one of 5 emotions.
• Built-in scoring: It’s easy to assign a score for each choice and create an overall score.
• Conversation simulations: iSpring is great for building quick conversation simulations; that’s what it’s designed for.

Combining tools for building branching scenarios

My most common workflow has been to use a combination of Twine and Storyline. I write and prototype in Twine. It’s fast, and it provides a functional, text-only prototype quickly to aid the revision process.

Once most of the structural revisions are done, then I migrate the content to Storyline.  

Examples for when to choose each tool Simple conversation: Rise

For a simple 2-person conversation simulation without extensive branching, I might use the Rise scenario block. It’s fast. The big drawback is that you can’t see the structure at all. Without any visual of the flowchart, you have to either have a simple structure or track the structure in a tool like Twine or Miro.

Try the Rise conversation example.

Complex animation or media: Storyline

For more complex visuals or animation, like simulating text messages, I use Storyline. Maybe I could come up with a way to replicate this in Twine, but it would honestly require hours of additional work. It’s much smarter to build in Storyline for this type of interaction with movement. Storyline is also a good choice for interactive video (assuming you either record live video or create animated videos in Vyond or a similar tool).

Collect data: Google Forms

If I wanted to collect data on every choice learners make in a scenario, without needing an LMS, Google Forms is a good choice. This could even be an option for a quick prototype to see if your distractors were plausible or to see if the question difficulty is appropriate.

I personally probably wouldn’t use it otherwise, since I have other tools available, but it’s a good option for people with limited budgets or who are already using a lot of Google tools (like many teachers and higher ed instructors).

Learn how to create a branching scenario in Google Forms.

Conversation with simple scoring: iSpring

iSpring is designed to create conversation simulations, and it has a basic built-in scoring function. It’s easy to create a pass/fail score, although customized feedback for different levels would require some creativity.

The layout is fixed, with limited options to customize it. As long as you like the look and feel, iSpring could speed up your branching scenario development. This is the tool that Clark Aldrich uses for his Short Sims (he usually uses custom graphics rather than the built-in characters).

As a side note, iSpring is a Russian company.

See an example of the writing feedback scenario in iSpring.

Chat simulation or chatbot: Twine

For a simple chat simulation, I would use Twine and not rebuild it in Storyline. Twine with the Trialogue format would be much faster than anything in Storyline. I built this whole chat simulation with 50 passages in 2 hours.

Extensive branching: Twine

For more extensive branching, I would at least plan everything in Twine first. For example, I created a branching scenario project for one of my clients where the final version included over 70 slides. I could have planned it in Storyline, but building the links across that many decision points would have been clunky in Storyline. Twine lets me drag and drop all the passages so I can clearly see the bottlenecks and branches, as in the image below.

However, I did eventually build the project above in Storyline after the Twine prototype was reviewed and revised. If I was doing it again now, with the recent improvements to Twine, I’d probably keep it in Twine instead of building it all a second time in Storyline.

Other tools

BranchTrack, H5P, Yo Scenario, and other tools also have the ability to create branching scenarios. I just haven’t used them enough to clearly compare them with other tools.

Same scenario, 5 different tools

If you didn’t click through to the examples above, you may not have noticed that I have built the same basic writing feedback scenario in several different tools. The content isn’t exactly the same, but you can see how different a scenario can feel and function by building it in a different tool.

• Twine
• Storyline
• Rise
• Google Forms
• iSpring

Originally published 8/3/2021. Updated 7/17/2023.

Share this:

• Twitter
• Facebook
• LinkedIn
• Email
• More

• Reddit
• Pinterest
• Pocket

Related Tags: branching scenario, elearning development, scenario-based learning Continue Reading Previous Scenario-Based Learning Presentations