Comparing Tools for Building Branching Scenarios
When would you use Twine, Storyline, Rise, or other tools for building branching scenarios? It depends on the project and goals.
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.
Originally published 8/3/2021. Updated 7/17/2023.
How about industrial-strength tools? Opinions on, say, NexLearn’s SimWriter? Branchtrack? SmartBuilder? ? Came up in a convo, and haven’t evaluated, just wondered if you have.
I have tried Branchtrack, and I liked it. It’s been a few years since I last used it though, and I would want to spend more time before commenting in detail. It does save time by allowing you to plan the structure in the same tool as you develop the final product.
One of the biggest issues with Branchtrack is the pricing: it’s $1K/year for a limit of 10 scenarios. The next plan up to increase that limit is $4k/year. Even with my specialization in branching scenarios, it’s hard to justify the cost just for a tool that does one thing (even if it does it well).
I just look at look at SimWriter. Their website looks a little dated (copyright 2018), and the technical requirements say you need the Flash player. I’m not sure that tool is being actively used anymore.
I haven’t ever tried SmartBuilder. They have a bunch of examples on their site though, which I appreciate.
Thanks for the reply; much appreciated!
i ‘d like to understand how google forms is defined as a branch scenario tool
It’s clearly not designed for branching scenarios, but you can use it that way by saying that when a specific choice is made, you jump to a different question. I have an example and step-by-step directions here: https://www.christytuckerlearning.com/build-a-branching-scenario-in-google-forms/
Hi Christy, Thank you for all your great content on scenarios. I was wondering if you’ve tried out https://www.yoscenario.com for building scenarios. There is a demo piece on their site that’s called the Andy Dufrayne case, which seems very well made and I’m hoping this is a tool I can add to my tool box.
I’ve not spent enough time on it as yet and would appreciate any feedback on it if you’ve checked it out.
Great question, Anita! I bookmarked Yoscenario about 2 years ago, but I’ve never actually tried it. At the time, it was on a freemium model, but it looks like now it’s a “free but give us money if you want” model. I’ll put it on my list to check out, and I’ll update my post to add that to the list of other tools.
Have you tried it at all? How is it going so far?