Roadmap

Future features and directions, loosely ordered by impact and feasibility. Living document — reorder freely.

---

Tier 1 — Authoring Power

Fill the gaps that scripting-based tools (Ink) currently win on. These are what serious narrative designers expect.

Scripting & Logic

• Variables — setVariable() / getVariable() on engine state, beyond simple discoveries. Lets authors track numbers (gold, relationship scores, willpower) instead of just boolean flags.
• Expressions in conditions — gold >= 50, relationship.maya > 5, not just discovery presence checks. Ink calls these "logic".
• Computed text — interpolate variables/expressions into content text. "You have {gold} gold."
• Counters — built-in tracking of how many times an event was visited, choice taken, character spoken to.
• Weighted choices — random selection among choices with weights. Or: probability-based event triggering.
• Lists / sets — first-class data structures in state. "Items in your bag", "people you've met today" without abusing discoveries.

Flow Control

• Subroutines / reusable scenes — define a scene once, call it from multiple places with parameters. Ink calls these "stitches" and "knots".
• Tunnels — go to a sub-scene, come back. Useful for repeatable interactions like "examine the room" that should return wherever you came from.
• Functions — author-defined logic blocks. Compute a derived value from state and use it.

Authoring UX

• Inline conditional text — write {has_key: 'You unlock the door' | 'It's locked'} in content rather than separate variants. (Story Maker would render this with a nice UI.)
• Multi-author / collaboration — two writers editing the same project. Hard problem; defer until customer asks.
• Version control inside the editor — diff views, change history, named saves. Most authors won't touch git.

---

Tier 2 — Skins & Rendering

The cinematic skin proves the abstraction. More skins prove it's not a coincidence.

Skin: Phone / Texts

The original Doppelganger paradigm. Apps (texts, social, news, map). Notifications. Typing indicators. Most useful for modern mystery/thriller stories.

Skin: Visual Novel

Sprite-based VN with character portraits, multi-character staging, expression changes mid-scene, transitions (fade/dissolve). The classic anime/dating-sim aesthetic. Big audience.

Skin: 2D Explorable

Top-down or sidescroller exploration. Walk around, click things, talk to NPCs. Like a point-and-click adventure. The biggest jump from current "static scene" model — needs spatial coordinates and player-controlled motion.

Skin: Audio-First / Podcast Drama

Engine drives audio playback with branching. Choices via voice or button. Useful for accessibility and a rapidly growing podcast-narrative space.

Cross-skin features

• Multi-character staging — SceneStaging.cast[] on events. Show 2+ characters on screen at once (group dialogue, eavesdropping). Skins decide layout.
• Transitions — between scenes (cuts, fades, custom). Engine emits transition hints; skins implement.
• Type-on text reveal for dialogue (already noted in PROGRESS.md).
• Particle effects for atmosphere (rain, dust, snow) — already noted as deferred.

---

Tier 3 — Distribution & Integrations

Where Ink wins today: integrations. We're web-only; that's a real ceiling.

Engine Bindings

• Unity package — wrap the JS engine in a Unity-compatible runtime. Authors export from Story Maker, drop the JSON into Unity, get a C# API matching useTimeline(). The cinematic skin patterns translate directly to Unity UI.
• Unreal plugin — same idea for Unreal. Bigger lift; defer until a clear customer asks.
• Godot — open source, growing fast, narrative-friendly community. Could be the easiest of the three.
• Mobile (React Native) — ship iOS/Android apps that use the engine directly. Easier than Unity, lower ceiling.

Distribution

• One-click deploy to Netlify / Vercel / Cloudflare Pages from inside Story Maker. Author finishes their game, hits "Publish", gets a URL.
• itch.io export bundle — generate a zip that uploads directly to itch.io as an HTML5 game.
• Steam packaging — wrap the cinematic skin + game JSON as a Steam-shippable executable (Tauri or Electron). Larger work, but huge market.
• Game Maker / RPG Maker imports — pipe their narrative data into our engine. Land grab move.

Hosting (optional service)

The "tiny proxy" idea from earlier — run a Cloudflare Worker / serverless function that:

• Holds API keys for LLM providers (creator doesn't expose them in client)
• Bills creators per usage with a markup
• Single endpoint creators point ClaudeProvider's baseUrl at

This is the recurring revenue layer if we want one.

---

Tier 4 — Story Maker Polish

Making the editor itself a joy.

Visualization

• Filter / collapse dialogue threads in graph view (PROGRESS.md notes this).
• Path-tracing mode — pick a start and end event, highlight all paths between them in the graph.
• Heatmap mode — overlay how many times each event has been visited in playtests.
• Mini-map for the graph view (already exists via React Flow but customizable).

Authoring helpers

• Search across all events / characters / discoveries. Cmd-K palette.
• Find unreachable scenes — orphan detection beyond what Discoveries panel shows.
• Linting / validation — broken leads_to targets, duplicate event IDs, missing required fields, character speaking before they're introduced, etc.
• Auto-suggest discoveries while typing prerequisites — pull from existing usage.
• Copy/duplicate event — clone a scene to use as a template.
• Templates — start a new game from a "noir mystery" or "fantasy quest" template.

Live LLM testing

• Test Chat panel in the character editor — type to a character, see how they respond with current settings, iterate without leaving the editor. Promised in earlier discussions, not yet built.
• Conversation triggers UI — the keyword-fires-scripted-response system from ENGINE_IMPROVEMENTS.md. Mostly typed already; needs UI.

---

Tier 5 — Engine Internals

Backend / architecture work that unlocks features above.

Plugin System (Phase 4 from ENGINE_PLAN.md)

• Formal plugin manifest, loader, lifecycle.
• Skins as plugins.
• Custom apps (for phone-style skins) as plugins.
• Marketplace path: creators publish plugins, others install.

Character System Overhaul (from ENGINE_IMPROVEMENTS.md)

• Conversation triggers (keyword → scripted response with discoveries).
• Dynamic story context overrides (mood changes via contextOverrides on conditions).
• Character effects on events (event sets character mood).
• Truthfulness / forbidden topics / agenda topics actually wired into LLM prompt.

Performance / Scale

• Lazy event loading — for huge games, don't ship all events to the client. Load on demand by act.
• Streaming LLM responses — tokens as they arrive, not full response at end. Better feel.
• Server-side compilation — preprocess game JSON for runtime efficiency (precomputed ancestry, validation, etc.).

---

Tier 6 — Community & Ecosystem

Long-term, lower priority.

Marketplace

• Skin marketplace — paid skins (phone, VN, etc.) creators can buy.
• Character marketplace — pre-built character profiles for common archetypes (the worried friend, the shady dealer, the wise mentor). Drop into your game, customize.
• Game template marketplace — full starter games creators can fork.

Multiplayer / Social

• Co-op authoring — multiple writers in one project. Real-time? Branch/merge?
• Player-shared playthroughs — generate shareable links to a specific path through someone's game.
• Branching social — players see what choices their friends made.

Education

• Curriculum / lesson plans for using Story Maker in narrative writing classes. Ink has done this well.

---

Tier 7 — Wild Ideas

For the parking lot. Not committing, but worth keeping in mind.

• AI-assisted authoring — "Generate three more choices for this scene matching the tone of the existing ones." Or "expand this stub event." LLM-powered authoring help.
• Voice acting via TTS — ElevenLabs / OpenAI voices for character lines, configured per character.
• Player-generated content — runtime tools for players to author their own scenes within a creator's game.
• AR / location-based games — engine drives an AR experience tied to physical locations. Geocaching meets narrative.
• Procedural side content — LLM generates filler events, NPCs, side quests within author-defined constraints.

---

Anti-Goals

What we're explicitly NOT doing, to stay focused.

• Not a code-first scripting language. Ink owns that lane. We're GUI-first.
• Not a real-time multiplayer engine. Single-player narrative is the target.
• Not a graphics engine. Skins handle rendering; we don't write WebGL or shader code.
• Not a server framework. Engine runs client-side. Optional proxy for LLM is the only server piece we'll consider.
• Not enterprise-features-first. No SAML, audit logs, role-based access until clear market signal.