`anything2explainer`: The Repo That Compiles a Topic Into a Frame-Accurate Explainer Video

A Remotion-based agent pipeline that writes the script, times the narration, generates the visuals in code, and checks the result like software, not like a film edit.

11 min read • View on GitHub • More from Vincentwei1021

A black industrial machine turns a stack of inputs into a finished video reel. On the left are topic notes and sources, in the middle are gears labeled timestamps, scene code, and QC, and on the right a precise explainer strip exits as output. The image explains that the project treats video as a compiled artifact, not as hallucinated pixels.
The core idea is compilation. Research and script become timing data, timing data becomes code, and code becomes a deterministic render.

Topic in, narrated explainer video out. A Claude Code / Codex skill that turns any topic into a black-canvas motion-graphics explainer video with TTS voiceover, subtitles and a chapter progress bar.

Vincent Wei, Creator / Author · Vincentwei1021/anything2explainer
Key Takeaways

Most AI video tools start from the wrong place for technical explainers. They begin by inventing pixels, which is exactly where text, numbers, and timing usually go bad. `anything2explainer` flips the stack: it starts from a topic, researches it, writes a script, turns that script into code, and renders the result deterministically with Remotion.

Why this is not a video generator

That distinction is the whole story. If a frame contains a statistic, a label, or a citation, a generative video model has to get lucky. This repo does not ask for luck. It asks for source links, timing data, and a render pipeline that can be checked like software.

A WSJ hedcut-style portrait of Vincent Wei based on his GitHub avatar. The image presents the creator as a reference point for the project's authorial voice and provenance.

The timeline engine is the real product

The technical trick is not just that the video is rendered in code. It is that the code is driven by word-level timing. A TTS build step extracts timestamps, writes them into `timeline.ts`, and gives every component a shared clock. That means subtitles, highlights, transitions, and scene changes can all read the same frame number and stay synchronized.

The hidden superpower is a shared timing source. Once word timestamps land in `timeline.ts`, the render loop can keep subtitles, motion, and scene logic in lockstep.

export const SENTENCES = [
  {
    startFrame: 0,
    endFrame: 124,
    text: 'Topic in, narrated explainer video out.'
  },
  {
    startFrame: 125,
    endFrame: 268,
    text: 'Every word is aligned to the render clock.'
  }
];

export const CHAPTER_STARTS = [0, 125, 269];

export function getActiveSentence(frame: number) {
  return SENTENCES.find(
    s => frame >= s.startFrame && frame <= s.endFrame
  );
}

That structure changes the production problem. You are no longer editing after the fact. You are rendering against a timeline contract. If the narration shifts, the frame logic shifts with it.

A video pipeline built for parallel agents

The repo is organized like a factory floor. Research, narration, scene coding, rendering, and quality control are split into grouped work units so agents can run in parallel. The point is throughput, but the deeper value is reliability. A long explainer becomes a set of bounded jobs instead of one giant prompt.

StageWhat it producesWhy it matters
ResearchSource-backed notesFacts are checked before visuals are written
ScriptNarration with structureThe video has a voice before it has motion
Scene codeRemotion componentsThe output is deterministic and editable
QCTiming and motion checksBroken pacing can be caught before export

This is where the repo starts to look less like a demo and more like infrastructure. It assumes AI will make mistakes, then routes those mistakes into reviewable artifacts. That is a much more realistic production stance than asking a model to invent a perfect edit.

A close-up of text being scanned into a timing ruler. Word markers snap to frame divisions while a subtitle strip and moving highlight track the active word. The image explains how the repo turns narration into frame-accurate motion.
Word timestamps are the bridge. They let the render loop know exactly which word is active, so motion and subtitles can lock to speech instead of drifting behind it.

Deterministic motion is the aesthetic trick

The black-canvas look is not just branding. It is a constraint system. A limited palette, seeded randomness, and repeatable background motion make the visuals legible to both humans and agents. The repo can use star fields, dot fields, and layered typography without losing control of the frame.

export function starsAt(frame: number) {
  return Array.from({ length: 80 }, (_, i) => {
    const x = rnd(i, 1) * 1920;
    const y = (rnd(i, 2) * 1080 + frame * 0.15) % 1080;
    const size = 0.6 + rnd(i, 3) * 1.8;
    return { x, y, size };
  });
}

The taste move is simple. Constrain the canvas hard enough that the system can stay consistent, then let variation live inside those constraints. That is how AI-generated motion can feel designed instead of accidental.

Why the repo beats generic AI video for technical content

ApproachAccuracyText fidelityRepeatabilityBest use case
Generative video toolsUnreliableWeak on labels and numbersLowCinematic scenes and mood
ManimHighHighHighMath and logic explainers
Remotion aloneHighHighHighTeams that already write video code
anything2explainerHighHighHighAgent-driven technical explainers

The advantage is not that it replaces every video workflow. It does one job exceptionally well: explainer content where the script, the visuals, and the narration must agree. For that class of work, technical truth matters more than cinematic surprise.

What this means for AI content teams

Seen clearly, `anything2explainer` is not a universal video studio. It is a production system for one demanding category: technical explainers with strict fidelity requirements. That makes it more interesting, not less. It suggests a future where content teams build factories for specific jobs instead of asking one model to do everything.

The bigger lesson is organizational, not visual. If you can turn research, script, timing, render, and QC into separate artifacts, you can delegate them to agents without surrendering control. That is the real promise here: not magical video, but a reproducible pipeline that keeps human standards intact.