Technology
Loomgine
The engine Loom runs on. It exists so that a model can be given real authorship over a video — structure, composition, typography, motion, timing — without the result becoming something nobody can inspect, correct or reproduce.
01The chain
Seven stages, in order.
Each stage produces something the next one reads. That is what makes the pipeline more than a diagram: work can be inspected between any two steps, and a fault can be sent back to the stage that caused it instead of restarting the piece.
01
AI Direction
Intent becomes a decision
Direction is where the work stops being a request and becomes a set of decisions. The model establishes the premise, the register, the running order and the visual argument — the things a human director settles before anyone touches a timeline. Nothing is rendered at this stage, and nothing is guessed at pixel level. The output is reasoning that the rest of the chain can act on and, just as importantly, that a person can disagree with.
Hands onPremise and registerBeat orderVisual argument
02
Planning
Decision becomes a structure
Planning turns the direction into a structure the engine can build against — a scene list with durations, roles and transitions, and an explicit account of what has to be true by the end of each scene. Because the plan is data rather than prose, it can be re-planned: change the running time and the beats redistribute, cut a scene and the continuity is recomputed instead of quietly breaking.
Hands onScene listDurations and pacingContinuity constraints
03
Assets
The piece acquires material
Every scene declares what it needs before anything is fetched or generated: footage, stills, audio, iconography, a chart, a mark. Supplied material is used where it exists; complementary assets are generated where it does not. Because the requirement is declared by the composition rather than by a prompt, an asset that turns out wrong can be replaced in place, without re-running the film.
Hands onResolved mediaGenerated assetsPer-scene manifest
04
Composition
Scenes become a program
This is the centre of Loomgine. A scene is not a picture the engine hopes came out right; it is a document of layers with explicit geometry, type, colour and stacking. Every property has a name and an address, which is what makes the rest possible: a model can change one heading without redrawing the frame, a person can open the same scene and move it by hand, and a diff between two versions is readable.
Hands onLayer treeTypography and layoutAddressable properties
05
Motion
The program acquires time
Motion is authored, not hallucinated. Entrances, holds, exits, easing curves and transitions are attached to the same addressable properties the composition already exposes, which means motion can be reasoned about: a beat that runs long is retimed rather than regenerated, and a transition that fights the cut is replaced without disturbing the frame it sits between.
Hands onTimelinesEasing and transitionsRetimeable beats
06
Validation
Checked before it costs a frame
Because the composition is data, it can be inspected before it is rendered. Text that overflows its box, contrast that will not survive the medium, a title that leaves the safe area, a scene that runs past its slot, a continuity break between beats — these are found by reading the document, at a fraction of the cost of finding them in a finished file. Failures are routed back for correction, so validation is part of authoring rather than a report at the end.
Hands onLegibility and contrast checksLayout and safe-area checksCorrections applied
07
Rendering
Deterministic output
Rendering is the last step and the least eventful one, which is the point. By this stage the piece is fully specified, so rasterisation has no creative latitude left: the same document produces the same frames at any resolution, on any run. Determinism is what makes a render reviewable, a regression detectable, and a change to one scene cheap to re-emit without touching the others.
Hands onFramesReproducible outputScale-independent masters
02Principles
What holds across every stage.
The chain only works because the same four properties are true at every point in it. They are the reason a model can be given real authorship without the result becoming unreviewable.
01
Addressable
Every property of a scene has a name and a location. A model can change one heading without redrawing the frame, a person can open the same scene and move it by hand, and the difference between two versions is something you can read.
02
Deterministic
The same document renders to the same frames. That is what makes a review meaningful, a regression detectable, and a change to one scene safe to re-emit without disturbing the ones around it.
03
Inspectable
A film is data before it is pixels, so it can be interrogated: what a scene contains, why it runs as long as it does, which decision put a caption where it is.
04
Correctable
Faults found in validation go back into the document. The engine repairs the thing that is wrong rather than re-rolling the whole piece and hoping the next attempt is luckier.
03Boundaries
What Loomgine is not.
The shortest description of this product is the one that gets it wrong, so it is worth being precise about where the engine stops.
Not a text-to-video model
Loomgine does not sample frames, it composes and renders them. Generative models are used where generated material is genuinely wanted — an image, a voice, a texture — and what they return becomes an asset inside a composition rather than the composition itself.
Not a prompt-to-clip pipeline
There is no single hop from a sentence to a finished file. Direction, planning, composition, motion and validation are separate stages with separate outputs, precisely so that any one of them can be examined, changed or redone on its own.
Not a template filled in
A template fixes the structure and lets you swap the words. Here the structure is a decision: how many scenes there are, what each one carries and how it is laid out are outcomes of direction, not slots waiting for content.
A note on this site
Loomgine is developed separately from this website, and nothing here depends on it being available. The Lab publishes finished output, not a live connection to the engine — so the public record of Loom's progress stays readable whatever the engine is doing.
Status
Loom is in development.
There is no product to try yet and nothing to sign up for. What exists is Loomgine — and the Lab, where the engine's output is published as it is built. That is the honest state of things, and it is the most interesting part.
- Product
- Vistral Studio Loom
- In development
- Engine
- Loomgine
- Under construction
- Public record
- Loomgine Lab
- Publishing