Your Video Should Have a Source

A picture makes an abstract idea tangible. A video goes further: it moves through the idea in order, and narrates it on the way. That is why explainer videos are worth making. The creation process, though, is a burden. This article looks at where that burden comes from, at the two approaches most people reach for, and at a third one: giving the video a source.

This article is also a video. Why a Language makes the same argument in under three minutes, and it was produced by the tool it argues for.

The Friction of Creation

Producing a video explainer means friction, whichever traditional tools you reach for. The same obstacles show up in every production:

• Motion is synced to narration by hand. Every timing change means calibrating again.
• The work is labor-intensive and repetitive. The craft is in the story; the hours go to the mechanics.
• Nothing sits under version control. You cannot see what changed between two cuts, or who changed it, or why.
• Styling drifts from one video to the next. A library made over months stops looking like one library.
• Variations resist automation. Each one is built again from the beginning.
• The source moves and the video goes stale. A diagram changes, a name changes, an API changes — and fixing the video is heavy re-work rather than an edit.
• Every language means authoring the whole thing over. A second locale is a second production.

Two approaches dominate. Neither removes this friction.

The Current Landscape

Traditional Editors

• Every change puts you back in the timeline. Scrubbing and aligning, again.
• Keyframe animation is painstaking and slow. Placing a clip only decides when it appears and how long it stays; it then sits there, still. To make it do something — fade up, drift across the frame, grow — you pin one of its properties to a value at one moment, pin a different value later, and let the software work out the frames in between. Each pin is a keyframe: a value, on a property, at a time. They go in by hand, one property at a time.
• Assets are managed by hand, and the overhead stifles the work it is meant to serve.
• The project is a proprietary file, locked to one vendor. It is not text, it cannot be diffed, and it outlives its editor only as long as that editor is supported.

Those pins are anchored to a moment on the timeline, not to the narration they were matched to — so re-recording one line a second longer leaves every pin after it in the wrong place. These tools are superb for one-off creative productions. For anyone publishing technical content on a cadence, the manual overhead compounds with every iteration.

Generative AI

• The output is hard to predict, so the production cycle becomes generate-and-hope.
• Fine-grained control is limited. There is no mechanism to state exact timing or exact position.
• Costs climb with every run, and they climb fastest when you iterate — which is exactly when you need to.
• What comes back is a finished video, not a source. You cannot change one line of it. You can only ask again.

That last point is the one that matters. What comes back is a video file and nothing else: no project, no source, nothing to edit. Changing one caption, one color or one beat of timing means asking again — and what returns is another video file, not the incremental change. Every revision costs a full generation, and risks losing whatever you already had and liked.

There has to be a better way.

A Better Way: It Begins with a Language

A language takes a different path. You describe the what, not the how: which assets a scene uses, how elements behave, how the pieces assemble. The tooling works out the execution.

Three properties follow, and each one earns its place:

• Declarative. A specification, not a sequence of manual operations.
• Deterministic. The same source always produces the same result. No surprises between a preview and a publish.
• Plain text. Which means an AI model can write it — and you can read what it wrote, review it, correct one line of it, and put it under version control.

That third property changes the relationship with AI entirely. Generation stops being a slot machine that returns a finished artifact and becomes a first draft of a source you own. The model proposes; the language keeps the result inspectable, diffable, and exact.

Here is what narration-driven timing looks like in practice, from a published example:

defs:
  assets:
    narration:
      type: "audio"
      file: "./resource/audio/the_narration.mp3"

  const:
    MARGIN: 350 # a beat of quiet before the quote appears
    FADE: "narration.duration * 2.75 / 4" # the fade is a share of the narration

animation:
  timeline:
    0 @ setup:
      - quote:
          - show:
              opacity: 0

    setup.end @ reveal_quote:
      - quote:
          - show:
              opacity: 1
              duration: "FADE"

    setup.end @ narrate_quote:
      - background:
          - show:
              hold:
                after: "narration.duration"
              opacity: 1

The recording is declared once, as an asset with a name. Everything downstream refers to it by that name and reads narration.duration, the length the compiler measured in the file itself. A timeline, bookmarks that let each step begin where the last one ended, and expressions that read that length. There are no keyframes here, and no scene was given a duration anyone chose: each one is as long as the words spoken over it. Re-record the line and the scene re-fits itself on the next render, without a single number being touched.

The video at the top of this article was written the same way.

The Architectural Foundation: Separation of Concerns

The language enforces a strict separation across three stages, so the cost of an iteration stays local to the stage that changed:

• Generation — procuring the media. Creating raw assets and reading their temporal metadata. Independence: changing visual logic downstream never re-triggers text-to-speech, which is the slow and billable step.
• Animation — executing the logic. Motion, transitions, and spatial behavior. Independence: adjusting an easing curve or a coordinate touches no audio and no base media.
• Composition — assembling the media. Final synchronization of tracks and encoding. Independence: output format, resolution, and bitrate change without re-rendering a single frame of animation.

This is the part a viewer of the video never sees, and it is why the rest works.

The Benefits

Production

• Consistent styling across everything you make. Brand standards live in a shared theme, not in each author’s memory.
• Direct control over timing and position, down to the frame and the pixel.
• Animation paced by the narration itself. A scene reads an audio file and takes its length from what it measures there — your own recording, or one a text-to-speech provider made for you. Re-record the line and the scene re-fits. The timing is derived, not maintained.
• Patterns reused straight from your source, rather than rebuilt per video.
• Assets that compose into any narrative: scenes, diagrams, and audio assemble into larger productions.

Workflow

• Version control, because the source is text made for Git. Every change is tracked, reviewable, and attributable.
• Fast iterations. Edit the source and regenerate; the loop collapses from hours to seconds.
• Scale without proportional effort. Variations are automated, not hand-built.
• One source serves many languages. A locale is another script and another recording, not another production.
• Renders locally. No model in the loop at render time — and if the voice is your own recording, no provider anywhere. The cost is your hardware, the output is reproducible, and your material never leaves your control.

The Possibilities

The potential is broad, and each domain shares one principle: define once, produce consistently, iterate freely.

• Social media. High-velocity technical storytelling, with consistent branding across dozens of variations.
• Knowledge sharing. Documentation that turns models into living explanations — architecture, data flows, and system interactions with motion and narration.
• Education. Complex concepts demystified step by step, where an update to the source material propagates to the video instead of forcing a re-edit.
• Business. Narratives delivered with the precision of code, transcending the limitations of static slides.

One source also means one source for every format. The same file renders the video, captures part of itself as a looping GIF, captures single frames as pictures — a thumbnail among them — and plays live in a web page, where a reader can pause it, seek it, or present it one step at a time with notes beside it. Change the file, and every one of them follows. GIF and picture captures come in the version after version 1, the public trial.

Final Thoughts

The friction of video production has kept engineers reaching for tools built for a different audience, or avoiding video altogether. Traditional editors demand mastery of a craft outside the job. AI generators trade control for convenience and hand back something you cannot edit.

Writing the video down aligns production with how engineers already work: inputs declared in source, outputs produced by a pipeline, changes tracked in version control. The creative decisions stay explicit and human. The mechanical execution becomes automatic.

That is the power of code-driven storytelling in motion — and it is not only about efficiency. It is about treating video as a first-class engineering artifact.

Kinaigraph is the language described here. It is real, it is public, and it is in alpha: the tool is solid, and the language may still change based on the feedback it gets.

• Watch the argument: Why a Language — made with Kinaigraph.
• See what else it makes: the sample gallery — every video on it was rendered by Kinaigraph from text files.
• Read the examples’ sources, each beside its video: github.com/bitscrafter/kinaigraph
• Use this release for anything, commercially included — the grant runs until the release expires, and each release carries its own terms. What you make with it is yours, with no expiry and no conditions.

If you make explainers, technical talks, or course material, start by rendering one of the examples exactly as it stands: its narration is committed, so no key is needed and no account has to be opened. Then make one of your own — your drawing, and a line in your own voice or one you have synthesized. Whatever gets in your way there is exactly what shapes the language next.