Scenario Studio

Scenario Studio is an authoring suite that lets instructional designers build branching, evidence-driven training simulations — the kind you usually can’t build in Articulate or H5P without writing code — and ship them to any SCORM-compliant LMS.

In daily use. Two worked examples on the road: Alpha Audit ships as a bundled four-act demo (~4 hours of content), and Northern Light is the first public release — a serious game on itch.io about a Dutch ministry decision. The cover image above is the Studio editing one of Northern Light’s minigames; the Studio is the workshop, Northern Light is what comes out of it.

The problem

Mainstream e-learning tools top out at shallow branching: click an avatar, pick from three answers, get a score. They can’t model the thing that actually matters in workplace judgement training — do I have enough evidence yet, and is it the right kind?

• Articulate Storyline / Rise — linear with light branching; no state, no persistent consequences.
• H5P Branching Scenario — branching trees, but no systems (no inventory of evidence, no trust state, no mini-games).
• Custom Unity / Unreal builds — powerful, but require a full dev team for every course. Instructional designers get locked out of authoring.

The gap: a tool that’s authorable by an instructional designer, runtime-rich enough for serious games, and deliverable through any LMS via SCORM.

The solution

A Godot 4 project with two halves.

The runtime — a serious-game engine for scenario-based learning

A playable scenario is composed from Godot Resources (.tres data files), driven by a small set of engine systems:

• Dialog engine — line-by-line speaker/portrait UI with branching choices, document overlays, and auto-advance nodes.
• Scenario state machine — global ScenarioRunner autoload tracks the current node, character trust (-10..+10), memory flags, evidence cards, scored choices.
• Evidence board — a persistent corkboard-style UI collecting colour-coded cards (Green = verified, Yellow = unverified, Red = disputed) as the player plays. Cards carry through acts.
• Finding builder — a validated card-selection UI. The player drafts audit findings by picking cards from the board. Findings are scored on reliability + keyword coverage, not just “right answer chosen” — so picking only Yellow cards triggers an “Audit Risk” warning in-game.
• Triangulation — quote markers and visit counters baked into the dialog system. The runtime remembers what each stakeholder said; on a second visit, new dialog options unlock that quote one stakeholder’s words back to another. Models how a real analyst builds a case by synthesising what they’ve already heard.
• Stakeholder reactions — during the council/finale, named stakeholders interrupt the player’s defence based on model state and prior fieldwork. The player can accept, push back (a small skill-check on cited evidence), or defer. Reactions accumulate into the final score. Reuses the dialog UI; tightly integrated.
• Mini-game framework — a MiniGameBase contract (setup(config) + completed(score, metadata) signal). Every mini-game is a self-contained scene droppable into any dialog node.
• Context map — a corkboard-and-red-string investigation board for navigating between acts, with a campaign end screen (stars, per-act score breakdown, verdict copy driven by authored thresholds).
• SCORM 1.2 bridge — on scenario_ended, converts the fractional score to 0–100, writes cmi.core.score.raw, sets lesson_status to passed / failed against an authored threshold. HTML5 build + SCORM zip — works in SCORM Cloud, Moodle, TalentLMS.

The authoring suite — a MainScreen plugin for Godot

A full editor plugin (addons/scenario_editor/) that replaces .tres text-editing with form-based UI:

• Campaign tab — title / subtitle, ordered location list with map positions and prerequisites, per-campaign scoring config.
• Scenario tab — a visual graph editor built on Godot’s GraphEdit. Nodes colour-coded by role; drag-to-connect routing; BFS auto-layout; node positions persisted in the resource’s metadata.
• Characters tab — form editor with drop-zone portrait, auto-slugged internal IDs, trust / memory-flag config.
• Minigames tab — bespoke editor per mini-game type. Six are shipped: File Explorer (folder/file tree with metadata), Terminal (a scriptable command-line emulator), Tickets (filterable incident grid), Org Chart (parent-dropdown hierarchy), Explorable Room (drag-to-place clickable hotspots over an illustrated background — the cover image above is this editor), and Spreadsheet (a live CBA-model editor with locked cells, formulas, target ranges, and tiered hint copy).
• Findings tab — template editor for FindingTemplateData (keywords, min / max cards, feedback copy per outcome band) and EvidenceTriggerData (per-choice card emission).
• Evidence tab — campaign-wide library editor for evidence cards. No more Inspector editing per card.
• Glossary tab — vocabulary entries (BAU, NPV, B/C ratio, etc.) that surface as in-game definitions for learners encountering technical terms.
• Tutorial tab — author the welcome tour itself. The 8-step coach-mark walkthrough new authors see when they first open the Studio is a data file, not a hard-coded script.
• Export tab — SCORM packaging from inside the Studio (in progress; engine-level SCORM bridge already ships).
• New Scenario wizard — creates a playable stub from shipped templates in one click.

Two worked examples

Alpha Audit — the bundled demo

Ships with the engine as the reference example (examples/alpha_audit/). A full four-act internal-audit training scenario, ~4 hours of content:

1. The File — skills assessment via a file-explorer laptop sim.
2. The Incidents — incident triage via a filterable ticket system and a command-line terminal emulator.
3. The Structure — organisational analysis via an interactive org chart.
4. The Recommendation — synthesis and staffing judgement.

Every act ends in a scored choice plus a finding-builder exercise. Trust and evidence cards carry across acts. The designed-in trap: Ana, your colleague, pushes conclusions that the evidence doesn’t support — the learning is in resisting her without dismissing her. Every data shape, every mini-game, every scoring rule was stress-tested by authoring four hours of real training content in this scenario.

Northern Light — the public release

A separately-published serious game that ships as a standalone build on itch.io. Northern Light: The Van Holten Light puts the player in the role of a junior Dutch ministry analyst running a cost-benefit analysis on a 19th-century lighthouse — should it stay manned, partially automate, or switch to sensors only? Five stakeholders push back on the model in a final council hearing.

Northern Light is the showcase for everything in the engine that came after Alpha Audit shipped: the Explorable Room minigame (drag-to-investigate cottages, with hotspots tied to evidence cards), the Spreadsheet minigame (a live 20-year CBA model with locked cells unlocked through fieldwork), the triangulation system (quote markers between stakeholders), and the stakeholder reactions in the council finale.

If Alpha Audit is the engine’s stress-test, Northern Light is its sales pitch. Play it on itch.io → · Full case file →

Why it’s interesting

As instructional design

• Evidence-first scoring. Most scored e-learning scores choices. This scores the quality of the evidence chain behind a choice. Learners who pick the right answer for the wrong reasons get partial credit; learners who cite disputed sources get flagged.
• Persistent state across acts. Trust and evidence carry through the full experience. Rushing Act 1 costs you in Act 3 when you can’t defend your finding.
• Authorable by the designer. No dev handoff required to change a line of dialogue, re-route a branch, or re-tune a scoring threshold.

As engineering

• Data-driven end to end. Every piece of content is a Godot Resource; the runtime has zero scenario-specific code. The same executable plays Alpha Audit, a compliance scenario, or a clinical-judgement scenario.
• Plugin architecture, not a fork of the editor. The authoring tool is a real Godot EditorPlugin with MainScreen tab and Inspector integration — same tooling as a first-party editor extension.
• LMS-deliverable by default. HTML5 export with a patched imsmanifest.xml and bundled SCORM API wrapper produces a zip that drops into SCORM Cloud, Moodle, TalentLMS, or any compliant LMS. Tested end-to-end.

As a product bet

This is the tool I would have wanted for the last ten years of instructional-design work. It sits between no-code author (too shallow) and custom game studio build (too expensive) — a zone every L&D team with a serious training problem ends up in, and currently has no good tool for.

Tech

• Engine — Godot 4.x (2D, GL Compatibility renderer, HTML5 export)
• Language — GDScript (strict-typed)
• Data — Godot Resources (.tres) — diffable, version-controllable, Inspector-editable
• Delivery — SCORM 1.2 (via a vendored, patched SCORM plugin)
• Authoring — Custom Godot EditorPlugin (MainScreen + Inspector integration)
• Dev loop — Claude Code + GDAI MCP bridge, driving the Godot editor directly over HTTP for scene/script scaffolding

Status

Engine and authoring suite in everyday use. All nine authoring tabs ship; the engine-level SCORM 1.2 bridge has been tested against SCORM Cloud end-to-end. Two examples on the road: Alpha Audit (bundled demo, four acts, full Ana arc) and Northern Light (public release on itch.io). Currently polishing: one-click SCORM packaging from inside the Export tab, a second pass on stakeholder-reaction authoring, and getting the full plugin drop-in-ready for fresh Godot projects.