Designing the Interactive Video Player

I loved the idea from the very beginning.

Building a standalone interactive video player within the technical limits of the time—something that genuinely combined a movie and a game—was an enormous and exciting challenge I didn’t want to miss.

The video player follows a playlist of interconnected video clips until the story reaches an ending. During certain clips, the player is presented with a time-limited set of choices, displayed together with a countdown timer. Based on the selected option—or the lack of one—the video player crossfades into the next clip. That transition may be immediate or delayed, but it always needs to feel smooth.

The following diagram explains the core idea:

|           |===== Choices Visible ====|--|
|            ^ showChoices             ^ hideChoices 
|                                      [ crossfade ]    
|---------------- Clip 1 --------------|-----|
|                                      |------ Clip 2 ------>
cut                                   cut (choice made)

Each choice also affects internal variables, which in turn influence future options and enable different endings.

On paper, these were fairly clear product requirements. Every software engineer knows that initial sense of clarity and optimism—right up until implementation begins, and real constraints of technology and user experience start pushing back.

Tech Stack

At first, we considered hosting all clips on YouTube and using embedded video links to navigate between them. That approach failed almost immediately. The experience was fragmented, immersion was effectively zero, and any form of variable logic or deeper interaction was impossible.

When evaluating technologies that could run smoothly on the web and still allow future porting to mobile platforms, Adobe Flash was the obvious choice for me at the time. I had already worked with Flash; it integrated well with the web and supported mobile deployment. HTML5 video APIs, on the other hand, were still immature at the time (YouTube officially switched its default player from Flash to HTML5 in January 20151).

Despite many shortcomings, prototyping complex interactions in Flash was fast and predictable.

The rest of the stack included HTML, CSS, JavaScript & JQuery, PHP & Nette, MySQL & Dibi, JSON & XML.

I initially used SVN for version control before switching to Git in 2023.

Movie Quality

It was 2011. Computers were relatively slow, and mobile devices were just waking up to the world of high-quality media. The first affordable consumer 4K displays appeared in late 2012, and 1080p was still considered high-end.

Keeping the movie at its original full HD resolution, 60 FPS, and zero compression would have resulted in over 20 GB of data to download into the browser cache. With the target market average internet connection speed of ~15 Mbps in 20122, even segmented downloads would take forever.

That was unacceptable. Every scene had to finish downloading before the previous one ended, allowing assets to load quietly in the background during playback.

The final video format was somewhere “in the middle”:

• Container: Flash Video (FLV)

• Codec: H.264 (AVC 1), 960×540 @ 25 FPS

• Audio: AAC Stereo, 48 kHz

This reduced the entire movie to under 200 MB. The compression ratio was determined by the need to minimize loading interruptions while maintaining good quality. To support this, the movie was split into scenes of varying sizes that could be downloaded incrementally and in advance.

Building the Engine

You can’t just let AI vibe-code an application like this. Not in 2011. Even today, that would not work out of the box without tailoring it to the video content.

There was a shared core logic, but a large portion of the code had to be custom-tailored to the movie itself—its pacing, timing, and imperfections. At the time, there were no AI tools to enhance or even generate footage. Everything was built manually, through iteration after iteration, trial and error.

I strongly believe in iterative development. Throughout my professional career, I’ve consistently pushed my teams toward this mindset: start small, but make sure every iteration ends with a working system.

I jumped straight into prototyping based on early mockups and discussions.

I built it on a clean, modular mediator pattern with the main Controller class that coordinates all the specialized subsystems. The heart of the interactivity is the onFrame method: a hook triggered on every rendered movie frame. By anchoring all logic to the video framerate, the system treated the film itself as the primary clock, ticking every 40 milliseconds. I experimented with using time as the clock mechanism, but even with a small lag, the entire experience was ruined.

Matouš and Víťa recorded a few experimental shots with a friend, who served as the early model for Dana. Using just five clips, I built the first functional prototype and verified that sequential playback worked as intended.

At that point, we knew the concept was viable.

In the next iteration—still without final footage—I added branching choices. The prototype was crude, but functional. Subsequent iterations introduced smooth transitions, background music, multiple-choice mechanisms, and the use of the script.

This was not a system that could be designed top-down. On paper, everything looked reasonable. In practice, every prototype revealed a new way the illusion could break—an awkward cut, a mistimed choice, a transition that felt mechanical instead of cinematic. Each iteration wasn’t only about adding features, but also about identifying where the technology became visible and then removing that seam again.

In total, the original version of Interande took 46 iterations (commits) to build and launch. The 2023 version has taken 151 iterations so far.

The Script

From a technical perspective, the script wasn’t a screenplay—it was a data structure. A declarative description of timing, conditions, and transitions implemented as a JSON tree with the following structure:

...
v28a: {next: "v32"},
v28b: {
   next: "v29b",
   showChoices: 170,
   hideChoices: 290,
   points: 1, time: 2,
   choices: [
      {jump: "v29b", x: 250, y: 450, text: "HANA", insta: true},
      {jump: "v29c", x: 430, y: 450, text: "JANA", insta: true},
      {jump: "v29a", x: 600, y: 450, text: "DANA", insta: true},
   ]
},
...
v37x: {
   next: "=time>4?v37y:v37n",
   music: {
      file: "ticho.mp3",
      volume: 0.5
   }
},
...

What mattered was not what the characters said, but when something could be said, interrupted, or redirected without tearing the experience apart. The script defined intent; the engine had to survive reality.

Subscribe now

Semantic Preloading

Although the application includes loading screens, careful optimization ensured they rarely appeared in practice.

The content is split into 16 parts, resulting in 15 potential internal loading moments corresponding to different scenes (bar, city, encounters, and so on). In the original version, scenes were loaded serially. The latest version loads scenes in two parallel queues until everything is fully downloaded—typically before the first scene even ends.

Loading as a Narrative Failure

I also implemented a metric to track the frequency of loading screens during gameplay. Below are statistics showing how many loadings players encountered per play between 2012 and 2025. They illustrate how average connection speeds improved over time, eventually becoming fast enough that downloads completed ahead of playback for 97 % of players by the end of 2025.

The initial peak reflects early load-distribution issues during peak demand. The long-term trend toward uninterrupted playback is visible even though neither the content nor the servers changed. The gap between 2021 and spring 2023 corresponds to the period when the movie was offline.

Since 2023, parallel loading has had only a marginal impact—modern connections are simply fast enough.

Infrastructure as Storytelling

Initially, video files were served from a folder on my personal student hosting plan, which typically handled about 20 MB of traffic per day. After launch—and several times afterward—we peaked at over 230 GB per hour. This triggered alerts on the provider’s side and prompted them to contact me to resolve the situation and move us to a paid plan:

Sun, Jun 14, 2015, 10:00 PM

Dear Mr. Brnka,

During today, data traffic on interande.com increased to 160MB/s (1280Mbps). We are reaching out to resolve this situation and discuss pricing options, as this throughput highly exceeds your plan's SLA.

anafra.cz

While we expected high demand, we never imagined peaks of over 1,000 concurrent players, each streaming 200+ MB of content, sustained for several days. I had to implement a load balancer immediately while the rest of the team scrambled to secure additional storage backends.

We managed to get storage on the Czech University of Technology backbone for a while, and since 2015, the primary storage has been a web RAM disk provided by anafra.cz in exchange for a link on the web. Additional locations mainly serve as backups. This saved Interande, as the average daily data throughput matched a typical monthly quota of regular internet providers.

The load-balancing logic itself uses weighted distribution to prioritize faster storage while spreading traffic evenly. The downloader also implements retries: if a fragment isn’t available on one host, it automatically falls back to another.

The Narrative Angle

A central narrative decision was how the system should behave in the absence of player input. Traditional interactive systems block progression until a choice is made. This approach was incompatible with the cinematic continuity and immersion we wanted to achieve.

Instead, every decision point defined a default jump executed when the choice timer expired. From a technical perspective, this ensured deterministic progression. From a narrative perspective, it prevented the story from acknowledging the player’s hesitation.

The diagram of a “no choice” flow appears as follows:

|   |== Choices Visible ==|
|                                [ crossfade ]
|---------------- Clip 1---------------|------ Clip 2 ------>
cut                                   cut (no choice made = default jump)

Even pausing is disabled during choice windows to prevent the story from acknowledging hesitation.

This mechanism maintains the temporal flow and prevents breaking immersion. Missed choices become narrative events, but the player is slightly penalized for indecision, as the “default path” leads to the worst ending.

Time became an active force rather than a passive resource. If you don’t decide what drink you want, the bartender decides for you!

Illusion of Seamless Editing

This was one of the most challenging parts of the implementation. Each clip began and ended with characters, objects, lighting, and camera framing in slightly different positions. At the same time, player choices could interrupt a clip at any moment, meaning transitions had to work from arbitrary cut points—while still appearing smooth.

The challenge was to programmatically cut the movie in real time and crossfade quickly enough to hide discontinuities. The problem becomes most apparent when a choice window appears near the end of a clip, leaving too little time for a clean crossfade once the decision is made. This caused a few compromises, especially in the dancing scene.

We chose a white transition for player-initiated choices and applied cubic easing to avoid linear, mechanical fades. In the latest version, crossfades are color-coded: black for default transitions, white to confirm that a player’s choice was registered.

Cinematic Karma

Players earn points by guiding the main character through dialogues and challenges, testing reflexes, memory, and decision-making—often without explicit hints. These points unlock or block narrative paths and determine endings.

The engine tracks two variables throughout the game and evaluates branching rules using a simple lexical analyzer driven by the following regular expression:

const regex = /^=(\w+)([><])(\d+)\?([a-zA-Z0-9-]+):([a-zA-Z0-9-]+)$/;

So, for a jump definition of “if you have more than 7 points after this node, jump to v21; otherwise jump to v20” You’d go with:

v19: {next: "=points>7?v20-a:v20-b"}

If you have 7 or fewer points, Dana walks away, and the game ends early.

Music and Sound Player

Flash’s audio capabilities were very limited, so I created a custom sound library to mix video audio with background music and adjust stereo balance. Music tracks were preloaded with each scene and played on loop.

The sound engine supported logarithmic, V-shaped crossfades with configurable duration. A linear fade sounds wrong to the human ear; a trigonometric curve sounds more cinematic.

A constant-power crossfade implementation looks like this:

const p = Math.min((now - crossFadeStart) / duration, 1);

outTrack.volume = Math.cos(p * 0.5 * Math.PI);
inTrack.volume = Math.sin(p * 0.5 * Math.PI);

if (p < 1) {
   requestAnimationFrame(update);
} else {
   outTrack.pause();
   outTrack.volume = 0;
}

The Limits of Portability

The original architecture accounted for mobile platforms from the start. Shortly after launch, I borrowed an Apple iPad and an Asus Transformer Android tablet and began experimenting with native ports.

Porting a Flash ActionScript project to Android and iOS turned out to be far more difficult than anticipated—and not merely because of tooling. Each platform imposed constraints that directly conflicted with the experience we were trying to preserve. Even basic assumptions, such as consistent resolution, aspect ratio, and video rendering behavior, broke down across devices.

Android

On Android, the most immediate limitation was the 50 MB application size cap. This made it impossible to bundle video assets directly into the APK. Instead, the app had to rely on downloading a separate OBB file containing the movie data.

In theory, this mirrored the web model. In practice, mobile connectivity at the time was significantly less reliable. Loading interruptions became frequent enough to disrupt the cinematic flow. To compensate, the entire asset bundle would have to be downloaded upfront and stored locally on the device before the first play. That would take a long time and most likely several attempts due to interruptions and retries.

While this approach was technically feasible, new issues emerged. During testing, I began observing intermittent blackouts during video playback—sudden failures that halted progress entirely. These issues were difficult to reproduce and even more challenging to eliminate reliably across devices.

iOS

iOS presented a different set of problems. Distribution constraints were less severe, but the platform struggled with seamless video transitions. Cuts that were effectively invisible on the web became noticeably abrupt on iOS, breaking immersion at precisely the moments where continuity mattered most.

This wasn’t a cosmetic flaw—it undermined one of the core design principles of the entire project. Smooth transitions were foundational. Without them, the experience no longer behaved like a film.

Why the Web Won

At that point, it became clear that these were not issues that could be solved through incremental fixes. They were fundamental mismatches between platform behavior and narrative requirements.

Rather than ship a compromised version of the experience, we decided to step back from native mobile apps and focus on the web, where the system behaved predictably, and the experience could remain intact.

At the time, expectations were high. The mobile version was meant to launch globally with an English voiceover and serve as a paid product that would help fund future work. That never happened.

More than a decade later, I finally restored the forgotten English assets in the 2023 web release—closing a long-postponed loop and offering Interande to a worldwide audience.

The Web Cinema

The web version of Interande runs on the Nette backend, which handles session, navigation, language support, scoring, and telemetry. The server runs three presenters and two data models.

Every completed playthrough is stored in a database, allowing long-term analysis of player behavior and system performance.

From the beginning, the goal was to keep the experience lightweight. The application needed to load quickly, run reliably, and stay out of the way of the story. There was no interest in visual excess or interface novelty—only in preserving immersion.

During the design phase, Matouš and I settled on a restrained visual language: a dark theme, subtle patterns, a limited color palette, and gentle blur effects. The interface was designed to feel present when needed and invisible otherwise.

The web itself was deliberately cinematic. In the latest version, if the mouse cursor remains inside the video player window, the interface fades out entirely, leaving only the title visible. Controls reappear on pause or when the cursor leaves the video player area—a simple interaction model that reinforces focus on the film rather than the application.

Some Challenges Persist

Safari, in particular, remains problematic due to its restrictions on autoplaying audio and video. Requiring explicit user interaction for every playback transition undermines the very continuity the system is designed to protect. These limitations are outside the application’s control, but they highlight how fragile immersive experiences can be when platform policies intervene.

Despite this, the web remains the most natural home for Interande. It offers reach, flexibility, and—crucially—the ability to evolve. Unlike native platforms, the web version can adapt incrementally without forcing the story into a different shape.

I still have one major task remaining in the TODO list: implementing the correct mobile styling.

Leave a comment

Playing It Again and Again

There were no unit tests. There was no automated test suite. There wasn’t even a meaningful way to simulate the experience without actually playing it.

Internal Instrumentation

For my own dev testing, I used a simple debug panel showing mouse coords for proper choice buttons positioning, variable counters, time elapsed, current and next default jump, frame number/total, autochoice switch, language, memory footprint, and a simple progress bar:

This panel made the invisible visible, allowing me to reason about timing and state without breaking immersion during regular play.

Also, a lot of logging like this:

[net] downlink= 10 parallelDownloads= 2
[preload] preloadPack: Uvod media: 7
[preload] preloadPack: Bar media: 15
[telemetry] game started
[xfade] crossfadeTo: - => v0
[ui] togglePlayPauseButton: ALLOWED 
[music] Switching soundtrack to 0.mp3 vol= 0.5
[xfade] smoothFadeOut enabled
[preload] preloadPack: Sedacky media: 9
[playback] pause()
[focus] User switched away
...

helped me to do most of the heavy lifting. Especially, the autoChoice functionality is priceless. When turned on, it emulates random choices instantly or with a slight delay, allowing you to finish the entire movie in a few seconds to see whether everything calculates correctly, etc.

During the 2012 crunch, we didn’t have this functionality, and the entire team played Interande too many times to stay sane.

Based on the logs, I’ve personally played it over 1000 times!

Testing in the Wild

For external testing, I used my own web-based testing system, which I previously developed to test Flash games. It supported access control, versioning, discussions, SWF instrumentation, and invite keys. It was called FleeBee.

In this system, a small circle of trusted “VIP” testers—our friends, schoolmates, and crew members—helped tirelessly. They took different paths, tried to break the flow, intentionally hesitated, clicked too early or too late, refreshed at the wrong moment, and reported anything that felt off. Logs, screenshots, and long messages describing how something felt were far more valuable than stack traces.

Timing, perception, and continuity only revealed themselves through real playback. A technically correct transition could still feel wrong. A choice that appeared on time could still feel late. The illusion either held—or it didn’t.

Every reported issue fell into one of two categories:

• The system broke (a bug, crash, or missing asset)

• The illusion broke (a bad cut, awkward pause, or scene continuity issue)

The second category was more difficult to fix. The main limitation was that we couldn’t redo the scenes; the material was recorded, and we could only edit what we had. That’s where the script supervisor turned out to be critical—one forgotten purse in the present and then missing in two adjacent shots, and there is no way to cover this up programmatically!

Fixes were validated the same way they were discovered: by playing again. Many times. Often late at night. Usually, after thinking that something was already “done.” Each new build closed some seams and exposed others.

In hindsight, this form of testing more closely resembled rehearsals than verification.

Tracing the Story

From the start, Interande collects telemetry—not for monetization or optimization loops, but to understand how the experience behaves in the real world.

For each playthrough, the system records (besides Google Analytics):

• IP address (for coarse geographic and infrastructure insights, also to roughly distinguish unique players)

• Language and game end timestamp

• Score and final values of internal variables

• Path taken through the story

• Number of loading screens encountered

These metrics serve two purposes.

The first is technical validation. Load counts revealed whether preloading strategies worked as intended. Path distributions exposed edge cases that weren’t sufficiently exercised during testing. Sudden spikes in failed or incomplete sessions often pointed directly to infrastructure or hosting issues.

The second is narrative insight. Seeing how players actually move through the story—where they hesitate, which paths are rare, which endings are common—offers a reality check against assumptions made during design. Some branches that felt important during writing turned out to be rarely reached. Others emerged as dominant simply because they aligned better with player behavior under time pressure.

Over time, the data also became an unintended historical record. Changes in average loading counts mirrored improvements in global connectivity. Infrastructure upgrades showed up as smoother playthroughs, with no changes to a single line of narrative code.

In that sense, the metrics didn’t just describe the game. They documented the environment in which the story lived—and how that environment and player behavior slowly evolved around it.

Final Thoughts

Looking back, I realize I wasn’t just building a video player. I was building a system to manage human attention. Every technical decision—weighted load balancing, frame-accurate timing, smooth crossfades, invisible defaults—served the same purpose: to make the technology disappear.

Immersion in interactive film is fragile. A single loading screen, a cut too visible, or a sound transition that feels mechanical is enough to remind the audience that they are inside an application. Much of the work described here exists solely to prevent that moment—to ensure the story didn’t pause, buffer, or wait, but simply continued.

What surprised me most in retrospect is how closely the technical architecture eventually mirrored the narrative intent. The engine powers more than just a video player. Time moves forward. Indecision has consequences. Continuity matters more than control.

In the next and final article of the series, I’ll share the story of the launch, the shutdown after Flash’s death, and the unexpected rebirth—along with a few bonuses.

Stay tuned, and thanks for reading!

Subscribe now

What makes an interactive movie actually work?

It’s not just clever code or decent actors—it’s alchemy. A mixture of cinematic craft, compelling choices, strong performances, and a team willing to throw everything into a shared vision.

That alchemy clicked with Interande, which somehow racked up over 2.7 million plays in the Czech and Slovak corners of the internet—a digital pond of just 12 million users at the time. Not bad for a no-budget passion startup held together by duct tape, dreams, and the refusal to quit. Sanity clearly wasn’t our strong suit.

But we were dreamers!

It all began back in 2011, when my friend Matouš Ježek pitched me the idea of creating a new generation of interactive film and testing its potential on modern technology. I knew it would be a purely R&D effort and would require a significant amount of time. But I saw the great potential.

We have known each other since childhood. We shared our love for fantasy, gaming, and technology. We collected gamebooks, explored the magical realms of Dungeons & Dragons, and obsessed over Magic: The Gathering. We studied and lived in the same cities for quite some time. While Matouš continued to pursue a career in game design, I focused on game development.

He brought the idea. I brought the tech. I trusted his experience in storytelling and game design, and he relied on my technical skills to bring it all to life. Our solid shared history and passion for games were the foundation we needed.

At that point, we began discussing the technical options available, the timeline, and how to approach the project in an iterative manner. I will elaborate more on the technical side in the following article.

Subscribe now

Matouš had already teamed up with Pavel Gotthard, our screenwriter and executive producer—a true wordsmith who penned a script full of cheeky, memorable lines still quoted today (“Dám ti do toho vodku, aby ti to s ním líp utíkalo / I’ll throw in some vodka to boost the charm levels!”). With a background in dramaturgy and interactive storytelling, Pavel brought both structure and flair.

We now needed someone to shoot the thing.

That’s where Víťa Procházka came in—a meticulous filmmaker who understood that in interactive media, every camera move matters. He choreographed shots with an eye for continuity, knowing that consistency across story branches would make or break the experience.

The Team

Having Pavel, Matouš, and Víťa lead the media side was a turning point. From scripting to shooting alpha test footage for my early prototypes, we worked as one unit.

You can’t simply separate film-making, design, and the in-app experience. They all need to come together, as well as their owners. Filmmakers need to understand the technical possibilities (and limitations) of the technology and prepare the material accordingly. At the same time, software engineering must account for the complexity of the story, game elements, and the limitations of film material.

You already know that the magic of interactive movies is in the thin balance between the quality of the film material and the technology trying to cover up all the imperfections to create an experience as smooth as possible.

And that was my task!

I was finishing my master’s degree and preparing for the final exam, while adding the creation of the interactive player for Interande to my list of leisurely pastimes.

The schedule? Six months from sketches to final product. While I had time to iterate on the tech, the film crew had just two days to capture most of the footage.

We had our core team, but we were excited to bring on talented actors and a fantastic crew!

Interande’s premise was straightforward yet captivating: a classic pick-up artist scenario set in a club, where Petr—our protagonist—is trying to impress Dana, a journalist procrastinating on her article due by sunrise. Not the most responsible journalist, perhaps, but a great character to fit a movie that’s easy enough to film, direct, and gamify.

For this purpose, we needed a special variety of actors who grasp the concept and the game dimension of the movie, are passionate enough, and willing to rehearse multple branches of the story, improvise, and deliver under intense pressure, embracing the chaotic energy required to film an interactive adventure within the narrowest of time frames.

All of that with a budget best described as “non-existent.”

⭐ The Star

We considered several actresses for Dana, but after a few test shoots, Barbora Mudrová stood out—a young Czech actress with a bright smile and even brighter presence. Pavel once joked, “She was the first real actress I talked to,” and she turned out to be the perfect choice: grounded, expressive, and game for the improvisation-heavy chaos ahead.

You!

Two days before filming, we lost the original voice for the main character, Petr. Chaos and panic as everything was already scheduled! Pavel made a last-minute call through his university contacts and somehow roped in the elusive Pavel Hýža. You never see his face in the movie, and honestly, finding photos of him even in real life is a challenge.

He wasn’t just the voice. He was the camera. Since we had no headgear, Víťa filmed the POV shots by holding the Canon 5D camera in front of Pavel, occasionally using his body as a stabilizer. And when the camera needed to show Petr’s hands, they were Víťa’s!

Hand gestures (“ruce”) were even treated explicitly in the shooting plan:

Among our standout supporting cast were memorable figures like bartender Martin Tlapák, Petr’s ex-girlfriend Alžběta Vaculčiaková,

and Dalibor Buš—the drunken friend who later snagged a prestigious Thalia Award.

Not bad for a cast held together by caffeine and good intentions!

The Crew

Then we rallied anyone we could—friends, classmates, girlfriends, strangers from the internet—as extras and testers. But we also needed a real crew: lights, sound, script, makeup, production. That’s when Víťa and Pavel pulled in their networks, and somehow, a whole film crew materialized.

One Night, One City, One Movie

The main interior shoot took place in Brno’s iconic Two Faces club, which generously let us use the space for free. I stopped by to see the chaos and ended up dancing in one of the background scenes.

The pace on stage was fast, and watching Víťa in his element was incredible! Once the club scenes were done, the team moved outside for exteriors, while I returned to my cave to code.

With most footage wrapped, the final challenge was a high-stakes night shoot across Brno.

It kicked off a day later at 7:45 PM in the Husa na provázku Theatre, where Dana sat down for makeup. From there, it was a nonstop race against time. The crew shot through the night, chasing story branches through busy streets and improvised sets. Every scene had to match continuity across multiple outcomes, and every delay risked daylight ruining the shot.

…

It’s early morning on May 1st, 2012, at the bus station somewhere outside the city. The shooting plan explicitly mentions that the sun rises at 05:24 AM to get the final shot.

And so the exhausted crew, fueled only by adrenaline, coffee, and the thrill of creation, captures this last shot in the quiet, awakening outskirts of Brno, Czech Republic. They’ve managed to film the rest of Interande in a single relentless night.

Meanwhile, I’m conspicuously absent from the group photo, asleep at home, preparing to transform their filmed chaos into interactive magic.

Only the easter egg was missing. So we sneaked it in a few days later. Can you guess where it has been filmed?

Leave a comment

The answer is in the following video clip!

That’s how Interande was born—and how it was filmed.

If you’re curious how the interactive player worked, what broke, and how the project eventually rose from the dead, subscribe and stay tuned. The following article dives deep into the technical guts of the platform and how we pushed interactive media beyond “just a gimmick.”

Thank you for reading!

Subscribe now

Forest of Endings

A film delivers a linear experience with a single, predetermined ending. As much as there are interactive movies with a single ending (like the Kinoautomat I mentioned in Part 1), I think more endings hugely improve engagement and repeatability. After all, why stick to a single ending when you don’t have to?

Having numerous endings increases not just the movie’s complexity but also its cost1. Interactive movies face physical limitations when using conventional filmmaking methods.

Tree of Choices

Excessive choices lead to an overwhelming number of branches, necessitating the filming of all possible paths and outcomes.

Look at Chess,

where each of your moves explores its own subtree of possibilities and choices, including the responses your opponent can make and your reactions to those responses. Considering the typical number of legal moves available at a given position is 35 (b), and the typical number of plies is 80 (d), the tree of all these combinations contains up to

nodes. That’s over 40 orders of magnitude greater than the number of atoms in the universe. But even games that can attain numerous internal states frequently reduce almost infinite possibilities to a few potential endings. Chess into win or lose. The interactive film also adopts a graph structure of a decision tree that eventually collapses into a few endings.

When you make a movie with real actors in real environments, it can be cumbersome to get everything into the same setup for multiple choices: items, lights, body positions, and people’s faces, especially!

The greatest challenge with multiple choices is achieving a seamless and smooth transition when cutting the scene.

One thing you should avoid is loops. Loops create a sense of déjà vu. Each moment in the movie must be unique!

Interande: The Snake of Choices

Interande is also designed as a decision tree, shaped into a linear, snake-like shape thanks to the flow of time. It includes up to 28 decision points and 5 different endings. I’ve visualized the structure for you:

The red node represents the start, the blue nodes are endings, the green nodes are decision points, and the grey nodes represent regular scenes (cut scenes). There is one unique checkpoint leading to the first ending that decides whether you make it to the main part of the movie. Can you find it?

The gameplay contains internal variables that shift with the player’s choices, allowing for multiple endings through conditional decision nodes. This system unlocks choices that might otherwise be inaccessible and opens paths that would otherwise stay hidden, enhancing the complexity and personalization of the experience. The two variables tracked globally in Interande are the ❤️Chemistry Index and the ⌛Runaway Index. I’ll share what they do later.

Subscribe now

In Interande, you typically make a choice every 20 seconds, choosing from up to 3 options. So, for a 15-minute experience, there are around 35 minutes of video content, represented by 113 nodes in the snake. However, the shortest path through the movie requires only 57 scenes to reach an ending, while the longest path consists of 66 scenes. There are no loops, no checkpoints, and no save/loads.

You can compare it with the decision tree of Black Mirror: Bandersnatch, which, according to Netflix, contains as many as five endings, 31 decisions, and no variables.

The cut scenes are very long, and there is unlimited time to make choices, making the experience quite different.

Run Forest, Run!

Every movie must maintain its pace, inherently imposing time constraints on the player and enhancing interactivity. In the real world, your date won’t pause for two minutes while you contemplate what to say—there are consequences for that. This leads me to the next limitation: time to choose. There are two general ways to handle timed choices to maintain a good experience. 

The first one is manipulating time, using a bullet time or a pause. There are cases where this makes sense for sure. The other tries to maximize the fluency and the immersion; the ingame time must go on, and the scene must be directed to allow the player enough time to decide while keeping the pressure of the surrounding world just continues to live.

This constant pressure actively increases the player’s engagement. Like in life, choices may appear at any moment and quickly disappear. Once gone, one of the choices is usually taken automatically to maintain the pulse—usually a poor one!

Sometimes, however, a hidden pathway leads beyond the presented choices, especially in moments when silence or nothing is the preferred course of action.

Show the Clock?

An intriguing problem is whether and how to visualize the remaining time during the decision. Not telling the player is interesting but likely unsuitable for casual play. In the original Czech-only version, we used a shrinking progress bar at the bottom of the screen,

whereas in the Reloaded version, I redesigned the choices to fade out slowly with the time running out. This doesn’t say how much time the player has, only when it is about to run out:

Which one do you like better?

Leave a comment

Our Niche

Our concept was innovative. I created a scalable, publicly available web application built on a reusable platform, which allowed us to glue movie scenes into the snake and provide the experience of a “point-and-click” adventure. That alone is not enough. Many components must come together perfectly. If you’re curious about which ones,

Subscribe now

Thank you for reading!

Let’s examine the space between the level of control and realism. I don’t imply that a medium adheres strictly to the laws of physics when speaking of realism. It’s a measure of how effectively it immerses the player. By control, I refer to the frequency and extent to which the player can intervene, make choices, or influence the internal reality.

When a medium provides too much control, it resembles a sandbox—a simulation environment without inner pace. If it extends for a prolonged period without interactive elements, it resembles a conventional film.

Similar to video games, interactive films aim for the intersection of sufficient realism and a satisfying level of control, balancing immersion and the film experience in, as I tend to call it, the Immersion Quadrant.

Realism: The Essence of Immersion

The sole point behind realism is to create an experience tricking your brain into generating a response as if you were truly there—whether on a battlefield or in a bar! The goal is to bring your brain as close to reality as possible and keep you there. To squeeze the neurotransmitters out through a well-mixed cocktail of sensory stimuli. Sometimes, the brain response can be so intense that it leads to addiction.1

One of the best-known games of the Immersion Quadrant is Heavy Rain (2010), thanks to its thick narrative, use of actual movie footage to place the story into real events, the player’s quick choices throughout the gameplay, and multiple endings.

As a dedicated gamer, I learned about various approaches to immersion from multiple perspectives. Being a game developer helped me gain even deeper insight into these mechanics, and this combination will always keep my internal passion for interactive experiences burning.

The rabbit hole goes even deeper when it comes to immersion in today’s video games. The braindance feature in Cyberpunk 2077 (2020) allows players to relive someone else’s memories in a simulated recording of their own experience.

Soon, computer graphics will achieve a level of realism that, when combined with VR2, will make our physical reality undistinguishable from the virtual one. At that point, it will be easy to fully blend interactive film and video game experiences and maximize the immersion. We surely have a lot to look forward to (and also to be afraid of3).

Player: The Vehicle of Control

Another key point of immersion is creating the player’s identity. Control in an interactive film must be limited and channeled into an avatar, a character, or some other level of identity—not just to embody a person but to make it serve as a vehicle for the action. It can be either first-person or third-person style.

Sure, it would be sweet to have control over an entire movie reality, where your real-time interactions with objects shape the unfolding story. You could throw a banana skin into the scene to make someone slip, watching the consequences play out. But who would you be in this scenario? Your role and identity might blur, leaving the experience feeling less like a story and more like an experiment in control.

The most common design for an interactive film is simply trying to convince you that you embody the main character and control it through a limited series of predefined points on the timeline. You role-play and take over the decisions. As in a video game, there are moments where you don’t control the character, and it somehow exercises free will with the story’s natural flow. That’s when your hero says something you’d never say, takes a shot of vodka you’d never drink, or shoots people you don’t even know.

Let’s make you a hero then. Everybody likes heroes!

In Interande, you occasionally take first-person control of Petr, a 2011 dating master wannabe from the Czech Republic. You two share dating weaponry and embark on a quest to convince Dana that you are the future in her simulated life.

The Immersion Quadrant

We already know you must embody the player into an avatar in an immersive way that provides enough control. After all, it’s all about entertainment, but to determine the right level of decision-making granularity, you balance many variable elements.

You must consider the technical capabilities, filmmaking skills, screenplay consistency, movie player capabilities, and depth and complexity of the experience you want to provide. This brings limitations. To get the most out of your interactive film, you must discretize the interactivity to a frame level.

We were building Interande as a prototype to prove the concept and validate the overall potential, so we couldn’t bite off more than we could chew back in 2011. I have always thought of a perfectly rendered game that smoothly switches between movie footage and controllable game back and forth in real-time without the player noticing the difference, but we were nowhere near that far. We had to use the classic way of filming the entire movie material, post-processing it, gamifying it, and then gluing it all together while sacrificing a lot of control potential and smoothness to set up the strings for the player to pull.

Our concept was interactivity on this level:

It’s nothing spectacular, especially not today. However, we did not foresee the many challenges upfront, even when we gave the player control of just a single character on a 15-minute journey. One of the pieces turned out to be the special video player we had to develop to power the movie. Don’t forget to subscribe if you’re curious about how it’s built and what challenges we had to overcome.

Subscribe now

Thank you for reading!

It ran smoothly for over 8 years before it aged and shut down. However, a bit of my digital necromancy leading into its recent resurrection inspired me to also share some details about the story, the technology, memories from behind the scenes, and the reasons it was initially discontinued, only to come back to life and entertain thousands of people every month.

It remains one of those experiences that warms my heart whenever I recall it. The enthusiasm we shared, the naivety, the excellence, the hype, and above all, the very talented people willing to fully dedicate themselves to pulling the rope together.

We wanted to explore the potential, believing that technology had finally advanced to a point where it could successfully awaken the next generation of the interactive film medium, lying in wait.

If you're interested in getting a preview before diving into the full reading, you can find it here. It’s originally available in the Czech language, but there’s also an English voiceover, made exclusively for the iOS version of the app and just recently added to the web version.

Interactive?

The concept of an interactive film was already established when we started. There were many attempts to make a film where the audience is given the ability to affect the narrative through some kind of voting to control the choices of the main heroes. Long before it became possible to produce a movie in an individualized way, where players have their private session to play within, one of the earliest examples I'm aware of, originating from the Czech Republic, was the Kinoautomat (1967).

The projection was exclusive to cinemas and was based on the concept of audience voting between two options at specific moments of the movie.

The doorbell rings. Mr. Novák opens the door, and there’s the neighbor, who is locked out of her apartment, almost naked and wearing only a towel. She begs him to let her in. But his wife might return at any moment, and it's her birthday today. Let the neighbor in or not? …CUT!

When a choice had to be made, the movie was paused, and the host stepped in front of the audience, explaining and narrating the choices. The audience then voted using a controller embedded in their seats, which had two buttons (green and red) for the options. However, it was all a façade. While interactive, the storyline remained shallow and linear as it merged into the same node of the story in the very next scene.

This approach was also utilized in later attempts, where viewers could use telephones or other means to vote on decisions in a movie on their TV. An intermezzo debate was introduced during these moments to allow viewers time to cast their votes. While this concept is democratic, its potential is limited, and most of the latest interactive movies focus solely on a single-player experience. Notable movies I’d like to mention are My One Demand (2015) and Black Mirror: BanderSnatch (2018), which I really like because the main character is a game developer.

Imagine a movie that offers an immersive experience where you, as the viewer, can slow down time, enter the movie, and make a decision through one of the characters to change its course. Intriguing, isn’t it? Now, how can it be made real enough to truly immerse you?

Subscribe for the next article to learn how balancing control and realism is key to the success of interactive film.

Subscribe now