What Are Runaway Games

Definition of runaway games

Runaway games are interactive experiences built by feeding AI video models short prompts or image references that generate branching video clips. They differ from traditional games because every sequence is synthesized on demand rather than pre-rendered.

They are not standard video editors or static image tools. The output must respond to user choices in real time.

How the models generate sequences

Runway's system starts with a text prompt or first frame. It then uses temporal layers to predict the next 2-4 seconds of motion. Flixly users can replicate similar flows with Text to Video or Image to Video and the Veo 3.1 model.

Seedance 2.0 handles camera path control while Kling 3.0 adds consistent character motion across clips. Each model accepts 512x512 to 1280x720 frames and returns 24 fps MP4 files.

Concrete inputs and outputs

A typical run takes a 3-second reference clip plus a 12-word prompt. The model returns a 6-second continuation. Credit cost on Flixly sits at 18 credits per 720p second.

Users chain outputs by uploading the last frame of one generation as the first frame of the next. This creates the branching effect required for gameplay.

Common file specs

• Input: PNG or JPG at 1:1 or 16:9
• Output: H.264 MP4, 24 fps, 5-8 seconds
• Audio: optional 48 kHz WAV from Music Generation

Real workflow examples

A designer loads a static scene into Reference to Video. They type "character walks left then pauses". The model returns a loopable segment. They repeat the step for three choice paths.

Another flow uses First to Last Frame to lock start and end poses, then lets the model fill motion. This technique reduces drift when building longer play sessions.

Where to start

Begin with a single prompt test on the Text to Video page.

FAQ

How many seconds of video does one credit buy on Flixly?

One credit buys roughly 0.4 seconds of 720p output from Veo 3.1 or Seedance 2.0.

Can I export runaway game clips for Unity?

Yes. Download the MP4 and import the frames as an image sequence. Flixly outputs standard H.264 files that Unity accepts without conversion.

Does Flixly support lip sync inside game clips?

Yes. Run generated video through Lip Sync Video and supply a 10-second audio file. The tool returns a new MP4 with matched mouth movement.

What resolution works best for branching sequences?

1280x720 keeps generation under 25 seconds per clip while preserving enough detail for character consistency across branches.

Managing branch consistency over multiple clips

Users maintain visual continuity by feeding the final frame of each clip back into the next generation as a reference image. This technique works best when the prompt includes explicit descriptors such as clothing color, hair length, and lighting direction. For longer sessions, keep a separate folder of key reference frames labeled by scene and character state. When drift appears in facial features, reload the original seed frame and append the phrase "exact same face as previous clip" to the prompt.

Camera paths benefit from Seedance 2.0 because its motion controls allow users to lock pan speed and tilt angle across branches. Write the camera instruction once, then reuse it verbatim in every continuation prompt. If a branch requires a sudden cut, generate a short transition clip that starts on the last frame of the prior segment and ends on the first frame of the next.

Audio layering and timing

Runaway games rarely need synchronized dialogue, but environmental sound helps players stay oriented. Generate a base music track once, then slice it into short loops that match each branch length. Import the loops into a simple video editor and align them to the start of each MP4. For footsteps or object interactions, record separate 2-second WAV files and place them manually on the timeline.

When lip sync is required for a character who speaks, first create the silent video clip, then pass it through the lip-sync tool with a pre-recorded line. The resulting file keeps the original motion while adding mouth movement. Test timing by playing the clip at 24 fps and adjusting the audio offset by single-frame increments until the words land on visible jaw movement.

Checklist before chaining clips

• Confirm the last frame of the current clip matches the intended first frame of the next prompt.
• Verify aspect ratio remains identical across the entire sequence.
• Export a low-resolution test version before committing full credits to a long branch.
• Store every generation seed and prompt in a text file so any clip can be recreated exactly.
• Check that audio loops do not contain clicks at the join points.

Selecting models for specific scene types

Different models handle motion types with varying reliability. Use the table below to match scene demands to the most stable option.

| Scene requirement | Recommended model | Frame handling tip |\ Prompt length guideline |\ Typical output length |\ |-------------------|-------------------|--------------------|-------------------------|-----------------------| | Slow camera dolly through environment | Veo 3.1 | Lock first and last frame | 8-12 words | 6-8 seconds | | Repeating character walk cycle | Seedance 2.0 | Upload same reference every two clips | 6-10 words | 5-6 seconds | | Fast action with multiple moving objects | Kling 3.0 | Add motion blur descriptor in prompt | 10-15 words | 5-7 seconds |

When building a sequence that mixes slow exploration and sudden movement, generate the calm sections first, then insert the action clips as separate branches. This order reduces the chance that a high-motion model will introduce unwanted jitter into a previously stable environment shot. Store the final MP4 files with sequential naming that includes branch ID and clip number so the game logic can load the correct file based on player choice.

Export and integration notes

After all clips are generated, convert the collection into an image-sequence folder structure that a game engine can read directly. Name each sequence folder after its branch and place a JSON manifest beside it that lists start frame, end frame, and next-branch options. This manifest lets the engine preload only the required clips instead of the entire library. If Unity is the target platform, keep the original H.264 files and use the VideoPlayer component with frame-accurate seeking. For web deployment, re-encode the same files to VP9 at 720p to reduce file size while preserving the 24 fps timing established during generation.

Prompt chaining strategies

Effective runaway game sessions depend on reusable prompt templates rather than writing new instructions for every branch. Start by creating a master prompt that contains fixed descriptors for character, environment, and lighting, then swap only the action verbs and camera directives when forking paths. Store these templates in a shared text file so multiple team members can generate consistent continuations without reintroducing drift.

When extending a sequence, copy the last three words of the previous prompt and paste them at the start of the next one. This small overlap helps the model maintain motion continuity. For choice points, append a short suffix such as "option A continues straight" or "option B turns right" directly after the shared base text. Test each suffix in isolation on a 4-second clip before committing to the full branch.

Users who generate more than ten branches in one session often maintain a spreadsheet with columns for branch ID, parent clip, prompt suffix, and seed frame filename. This record lets anyone reload an earlier state without guessing which reference image was used.

Debugging visual drift

Visual drift appears most often in facial features and clothing details after four or more chained clips. The fastest correction is to reload the original seed frame rather than the most recent output. Append the exact phrase "preserve identical facial structure and clothing from seed frame" to the prompt. If the model still alters hair length, add a numeric cue such as "hair length exactly 8 cm below shoulders" instead of relying on qualitative words.

Color shifts in lighting are harder to catch in the preview window. Export a 2-second test clip at the end of each branch and compare its average color histogram against the first clip in the chain. When a branch deviates beyond a 15 percent difference in blue-channel values, regenerate it with an added lighting descriptor copied from the initial prompt.

Motion blur on fast-moving objects can be reduced by inserting the token "sharp motion" at the end of the action description. Conversely, if a model introduces unwanted jitter during slow camera moves, replace that token with "smooth trajectory" and lower the guidance scale by one point in the advanced settings panel.

Preparing assets for web-based playback

Once all branches are finalized, organize the MP4 files into a folder structure that mirrors the choice tree. Name each file with the pattern branchID_clipNumber.mp4 so a simple JavaScript loader can fetch only the required segments. Create a companion JSON file that lists every clip's duration, start time offset, and the IDs of reachable next branches.

For browser playback, re-encode the collection to VP9 using a constant quality setting of 28. This keeps file sizes under 4 MB per 6-second clip while preserving the original 24 fps timing. Test the resulting files inside a hidden video element that preloads the next branch during the current playback. When the player reaches a decision point, swap the source attribute and call play() within a single frame to avoid visible black frames.

If the target site uses a game framework such as Phaser or PixiJS, convert the same clips into sprite-sheet PNG sequences at 1280x720. Keep the JSON manifest beside the sprite sheets so the engine can map player choices directly to texture atlases without additional conversion steps.

Checklist for multi-session projects

• Verify every new branch begins with a frame exported from its parent clip rather than a regenerated frame.
• Run a 3-clip test chain at the start of each day to confirm model parameters have not changed.
• Keep one untouched reference frame per character in a separate folder labeled "seed originals."
• Record the exact model version and any advanced parameter values used for each generation batch.
• After adding audio loops, export a 30-second composite test and listen for phase issues at every join point before publishing the full experience.