Build interactive e-learning. Publish to every format an LMS accepts.

Describe it, get a validated draft

Compose writes a Course Spec — objectives, screens, decisions and assessments — runs it through nine gates, repairs what fails, and only then compiles a real project. One run is one undoable change.

Canvas, layers, timeline

Pages → sections → layout containers, with 13 element types, rich text, per-breakpoint responsive overrides and a keyframe timeline. Undo and redo are backed by document patches, not screenshots of state.

A scenario graph, not a slide order

A node-graph editor with 9 node types: choice points, dialogue, condition gates, variable setters, random gates, merges and endings. Variables drive the path; characters and dialogue drive the story.

17 interaction types out of the box

Multiple choice through drag-and-drop, hotspot, matching, ordering, sorting and media annotation — plus a custom escape hatch. Each is independently scorable and weighted, and each reports to the LMS as a real interaction.

A screen, or a scene that plays

Any node can render as a real-time animated scene on a GPU canvas instead of text on a page — cast members with bodies that move, a procedural backdrop, a camera that frames the beat, lip sync. Same document, same assessment graph, same LMS tracking.

Accessibility while you author

A built-in WCAG validator, contrast checker, tab-order manager and caption editor, so problems surface before review rather than after. A rule-driven Learning Design Score grades the project across eight instructional-design categories.

One project, eleven targets

HTML5, SCORM 1.2, SCORM 2004 (3rd and 4th Edition), xAPI, cmi5, AICC, MP4/WebM/MOV renders, and a hosted review build. Every format's runtime exposes the same four tracking calls, so the course never branches on where it landed.

Send a course as a link

Publish to a public URL and anyone holding the link can open the course — no account, no LMS, no download. The link survives a re-publish and dies on a revoke.

Comments on the running course

Review builds are hosted behind an email gate with an in-place comment overlay and live threads. Stakeholders comment on the course as it runs, not on a screenshot of it.

Plugins in a real sandbox

Plugins run in a Web Worker with a startup timeout and a message-type allowlist, governed by a three-level permission model that decides network access and the termination deadline.

Eight providers, plus anything OpenAI-compatible

• Metered: Anthropic.
• Free tiers: Google AI Studio, Groq, OpenRouter, Cerebras, Mistral, Ollama Cloud.
• Local: Ollama — nothing leaves the machine.
• Custom: any OpenAI-compatible endpoint you point it at.
• No key at all: the built-in keyless provider produces a genuine brief-derived draft, so the whole loop is exercisable before you spend anything.

Receipts, not a spinner

• Provider, model and endpoint are named on the run before the first call — and a fallback says, in a sentence, why it fell back.
• Every outbound call is a row: URL, attempt, prompt size, status, latency, bytes, finish reason. Keys travel in a header and never reach that stream.
• Raw model output streams on three channels — reasoning, prose, and the document being written.
• Gate receipts record what passed, what failed and the evidence for each, and survive a reload: runs are journalled and replayable.

It writes from your source material

Attach policies, transcripts, SME documents (DOCX, PPTX, HTML, CSV, JSON, TXT, Markdown) and Compose retrieves from a per-project corpus rather than pasting a blob into the prompt. Retrieval is lexical — BM25 with rank fusion — so it needs no key, no network and no embedding bill. Every claim in the draft can be traced back to the passage it came from, and the grounding gate checks that it resolves.

PDF is not supported yet.

Agent, Edit, Ask, Reviewer, Director

• Agent — plans and executes multi-step work on a whole course.
• Edit — ID-addressed patch operations against the document you have. A batch that would break it is rejected whole, never half-applied.
• Ask — answers questions about the course without touching it.
• Reviewer — audits the teaching and returns anchored findings, changing nothing.
• Director — stages an existing course as animated scenes, and may emit staging operations only. Anything else it proposes is dropped and reported.

Every turn is one change, one history entry, one undo.

Three backends, one frame producer

• WebGPU → WebGL2 → Canvas2D, picked at runtime. Canvas2D is not a token gesture: a package opened straight off a disk cannot upload a texture from a file beside it, and Canvas2D draws it anyway.
• The runtime is generated, not bundled — and it is written into a package only when that project actually stages a scene.
• Characters are the same people as their drawn portraits: a 17-joint body under the same seeded face, so a cast member looks identical in the editor, the graph, the scene and the published course.
• Lip sync is baked while authoring — text to phonemes to a 15-viseme set — so the package ships a lookup table instead of an audio model.

Nobody has to watch it frame by frame

• Flash rate, cut rate, beat length, actor count and particle budget are clamped while compiling, below the WCAG 2.3.1 threshold — and the compiler reports what it clamped. A compiler that cannot emit an unsafe scene needs no check that can fail.
• Reduced motion is a second compiled stream, not a media query — a query has nothing to act on when the motion is a camera transform inside a canvas — plus an in-content pause control.
• The accessibility mirror is an output of the compiler. There is no accessibility tree inside a canvas, so a description per beat is generated from the scene graph and written as real markup inside the canvas element. It is the screen-reader narration, the canvas fallback and the answer to "what does a learner with no GPU get" — all the same text.