The engine
Loomgine
The engine behind Loom.
Loomgine exists so a model can have real authorship over a video — structure, composition, type, motion and timing — without the result becoming something nobody can inspect, correct or reproduce.
The chain
Seven stages, in order.
Every stage hands over something the next one reads. That is why the work can be inspected between any two steps — and why a fault goes back to the stage that caused it instead of restarting the film.
AI direction
intent becomes decision
A model reads the brief and settles what a director settles before anyone touches a timeline: the premise, the tone, the order of the blocks and the visual argument. Nothing is rendered here and nothing is guessed at pixel level — the output is reasoning the rest of the chain acts on, and that a person can disagree with.
Hands overPremise and toneBlock orderVisual argument
Planning
decision becomes structure
Direction is resolved into scenes: how many, how long each runs, what each carries and how one hands over to the next. Because the plan is data rather than prose it can be redone — change the running time and the blocks redistribute; cut a scene and continuity is recalculated instead of breaking silently.
Hands overScene listDurations and pacingContinuity rules
Assets
the piece gets material
Every scene declares what it needs before anything is fetched or generated: images, audio, icons, charts, brand. Supplied material is used where it exists; what is missing is generated. Because the need comes from the composition rather than from a prompt, a wrong asset is swapped in place without remaking the film.
Hands overResolved mediaGenerated assetsPer-scene manifest
Composition
the scene becomes a program
The heart of Loomgine. A scene is not an image the engine hopes comes out right: it is a document of layers with explicit geometry, type, colour and stacking. Every property has a name and an address — so a model changes a title without redrawing the frame, and a person opens the same scene and adjusts it by hand.
Hands overLayer treeType and layoutAddressable properties
Motion
the program gets time
Motion is written, not hallucinated. Entrances, holds, exits, easing curves and transitions attach to the same properties the composition exposes. A block that runs long is retimed rather than regenerated, and a transition that fights the cut is swapped without touching anything else.
Hands overTimelinesCurves and transitionsRetimable blocks
Validation
checked before it costs a frame
Because the composition is data, it can be inspected before it is rendered: text overflowing its box, contrast that won't survive the screen, a title outside the safe area, a scene that overran, a continuity break. All of it is found by reading the document — and failures go back for correction instead of ending up in a report.
Hands overLegibility and contrastLayout and safe areaFixes applied
Rendering
deterministic output
The last step, and the least dramatic — which is the point. By now the piece is fully specified, so rasterisation has no creative latitude at all: the same document produces the same frames at any resolution, on any run, right through to the final MP4.
Hands overFramesH.264 MP4Reproducible render
Principles
What holds at every stage.
- 01
Addressable
Every property of a scene has a name and a place. A model changes a title without redrawing the frame, and the difference between two versions is something you can read.
- 02
Deterministic
The same project always renders the same frames. That is what makes a review trustworthy and a change safe to redo without disturbing its neighbours.
- 03
Inspectable
A film is data before it is pixels: you can ask what a scene contains, why it runs as long as it does, and which decision put everything where it is.
- 04
Correctable
What validation finds goes back into the document. The engine fixes the fault instead of running everything again and hoping for better luck.
Limits
What it is not.
Text-to-videoLoomgine doesn't sample frames: it composes and renders them. Generative models come in where generated material is wanted — an image, a voice, a texture — and what they return becomes an asset inside the composition, not the composition.
Prompt-to-clipThere is no single leap from a sentence to a file. Direction, planning, composition, motion and validation are separate stages, each with its own output — so any one of them can be revisited on its own.
A filled-in templateA template fixes the structure and lets you swap the words. Here the structure is a decision: how many scenes there are and what each one carries come out of the direction.
