Version Selector

Spark includes multiple Ren’Py engine versions and lets you choose which one to use for each game.

Spark bundles the following Ren’Py engine versions:

When you import a game, Spark detects the Ren’Py version that was packaged with the game archive (from engine version files such as vc_version.py, __init__.py, or their compiled equivalents) and uses it to suggest a compatible engine.

The game’s script_version.txt is a separate file used internally by Ren’Py to set compatibility flags for the scripting layer — it is not the same as the engine version.

Spark offers two engine suggestion strategies (configurable in Settings):

• Accurate (default) — Recommends an engine matching the same minor version (e.g., a 7.5.x game gets the 7.5.3 engine)
• Latest — Recommends the latest engine within the same major version (e.g., a 7.x game gets the latest 7.x engine, an 8.x game gets the latest 8.x engine)

The engine runtime version is displayed beneath the Launch Game button on the game detail screen. There are two version settings you can change:

This controls which bundled Ren’Py engine Spark uses to run the game.

1. Tap Modify next to the engine version on the game detail screen
2. Select from the version picker
3. Tap Confirm

If you’ve changed the engine and encounter issues, you can revert:

• The original version is saved automatically
• Use the Revert button in the version picker to go back

This updates the game’s script_version.txt, which controls how Ren’Py’s internal compatibility logic is applied. Ren’Py uses this value to enable or disable backwards-compatible behavior for older games.

Changing this can resolve issues where a game expects certain legacy behaviors that have been modified in newer engine versions. See the Ren’Py incompatible changes documentation for details on what changes between versions.

• Game crashes on launch — Try a different engine version
• Missing features — Some games require specific Ren’Py versions
• Performance issues — Newer engines may perform better
• Compatibility — Older games may need older engines

Each game in Spark has three optional launch modes that control how much of Spark’s engine patching and runtime integration is active. These are found in Game Settings (long-press a game in the library).

Safe Mode launches the game using a vanilla, unmodified Ren’Py engine instead of Spark’s custom-patched build. Spark’s engine modifications and script injections are disabled, but the overlay and runtime features remain available.

The launch button turns green and reads “Safe Launch” when this mode is active.

When to use it: A game crashes or misbehaves and you suspect Spark’s engine patches are the cause.

Advanced Mode is designed for games where the developer has made changes directly to the Python layer of the Ren’Py engine. Some games ship with a modified renpy/ directory containing custom engine code — without these modifications, the game may crash or behave incorrectly. When enabled:

• Spark looks for an advanced/renpy directory inside the game folder
• Any Python source files found there override the engine’s built-in Ren’Py sources
• A separate engine version picker appears, independent from the normal version selector

The launch button turns pink and reads “Advanced Launch” when this mode is active.

When to use it: The game includes custom modifications to Ren’Py’s Python source code (a modified renpy/ directory). This is uncommon but some games rely on engine-level changes for custom features, UI frameworks, or compatibility workarounds.

This mode completely removes Spark’s runtime layer from the game session. When enabled:

• The Spark overlay UI (game controls, quick menu, keyboard helper, hide-UI button) never appears
• All runtime Python injection is skipped — dialogue tracking, gallery unlocker, gesture configuration, volume sync, translation system, and keymap overrides are all disabled
• The game runs with zero Spark runtime modifications
• RPY-based settings (developer mode, console, transparent textbox) still work because Ren’Py loads them itself rather than Spark injecting them

When to use it: A game conflicts with Spark’s runtime features and Safe Mode alone didn’t resolve the issue. This provides maximum compatibility and isolation at the cost of all Spark overlay functionality.