Simulation Learning Lab has moved beyond the earlier runtime milestone into a fuller learning pipeline.
The current product can take a topic, image or video, prepare evidence, enrich it with OCR or transcription, author a causal mechanism, validate that mechanism and compile it into an interactive learning runtime.
The important change is not that there are more screens. It is that the lesson now has a contract.
Evidence is not the mechanism
A screenshot, frame or transcript is evidence. It can show what was observed, but it should not silently become the explanation of why a system behaves the way it does.
The product therefore keeps deterministic preprocessing separate from semantic interpretation. Media metadata, representative video frames, OCR and transcripts are prepared first. The causal mechanism is authored after that, either manually or with optional multimodal generation.
That separation makes it possible to retain provenance instead of flattening source material and interpretation into one answer.
The mechanism is not the renderer
The central object is a structured simulation specification.
It describes entities, stages, state transitions, scenarios, retrieval prompts, provenance and teaching choices. A visual grammar then decides how that mechanism should be rendered.
The current runtime supports eight grammars, including state machines, factories, circuits, agent fields, timelines and robot worlds.
The causal model remains the same underneath them.
That matters because a new lesson should not require a new application before it can become interactive.
Why add a compiler
The compiler validates and normalises the simulation specification, applies grammar defaults and produces a portable runtime bundle.
That turns the authoring problem into a contract problem instead of a repeated frontend implementation problem.
A valid mechanism can become an interactive artifact quickly, while a particularly important lesson can still receive a higher-fidelity custom renderer later.
Learning has to survive the visual layer
The runtime now includes stage traversal, scenario switching, cumulative state inspection, active-recall questions, provenance, a fidelity ledger and local mastery tracking.
Those features are deliberately tied to the same mechanism model. The learner is not only watching an animation. They can inspect what changed, change a condition, answer a retrieval prompt and compare the resulting state.
That is the direction I wanted from the product: evidence becomes a model, the model becomes an experiment, and the experiment becomes something a learner can interrogate.