pdoom-video: The Music Video Engine That Compiles Time Into Pixels
A deterministic Three.js pipeline turns song time into frame-perfect motion, beat-synced typography, and 4K60 exports that match the browser preview.

The video was made with Claude (Opus 5.5) in Claude Code: the concept and treatment, the lyric alignment and audio analysis, the renderer, every scene and the renders were all worked out in conversation with Claude.
- pdoom-video makes motion graphics reproducible by treating song time as a deterministic input and video as a compiled output.
- Its standout trick is adaptive motion blur, which keeps sampling subframes until fast movement resolves cleanly enough for export.
- The timeline is code, not a GUI, so beat-synced scene changes are explicit, inspectable, and lazy-loadable.
- The project is most compelling as an AI-assisted creative system, where Claude helped shape the workflow without replacing the renderer.
The Strange Promise of Deterministic Video
Most video tools assume a timeline you scrub, trim, and nudge by hand. pdoom-video flips that model: the song is the source of truth, and every frame is a function of time. That means the browser preview is not a sketch. It is the same system that produces the final export.
Every frame is a deterministic function of song time, so the live preview in the browser and the offline 1080p60 (or 4K60) export are identical.
Why This Isn’t a Timeline, It’s a Compiler
The repository’s editing model lives in code, not in a GUI. Scene boundaries are expressed through helpers like cut() and after(), which snap transitions to musical structure rather than arbitrary timestamps. That makes the edit decision list readable, reviewable, and reproducible.
// Conceptual shape of the timeline
const scenes = [
cut("intro", after("kick", 2)),
cut("verse", after("snare", 8)),
cut("chorus", after("downbeat", 16)),
]
export function timeline(t: number) {
return scenes.find((scene) => scene.contains(t))
}
| Dimension | Traditional editor | pdoom-video |
|---|---|---|
| Editing model | Drag-and-drop timeline | Code-defined scene graph |
| Determinism | Preview can drift from export | Preview and export share the same path |
| Beat precision | Manual alignment | Beat-aware helpers and audio timing |
| Extensibility | Plugin or UI dependent | Scene modules are isolated TypeScript files |
| Debuggability | Visual inspection in the app | Readable logic plus reproducible frames |
| Best fit | General-purpose editing | Generative music videos and motion graphics |
The deeper design choice is isolation. Scene modules are lazy-loaded, so the engine behaves more like a compilation pipeline than a monolithic app. One scene can fail without poisoning the whole system, which is a useful property when every chapter is effectively a small program.
The 324-Frame Secret
The article’s most surprising trick is the adaptive motion blur loop. A single output frame is not treated as a single moment. The engine samples multiple subframes around that moment, measures error, and keeps increasing density until the blur converges.
This matters because most motion blur in generative video is either too blunt or too expensive. Here, the system decides how much time it needs to inspect. Low motion gets fewer samples. High motion gets many more. The result is cleaner motion without pretending every frame is equally simple.
How Audio Becomes Motion
The audio layer is not a vague reactive signal. It is structured data. Stem separation and lyric alignment turn the track into queryable timing information, so scenes can key off drum hits, word progress, and musical phrasing with millisecond-level control.
// Conceptual helpers from the audio and lyric layers
const hitStrength = audio.hit("kick", t)
const word = lyrics.wordProgress("doom", t)
if (hitStrength > 0.6) {
pulse()
}
if (word > 0.8) {
revealText()
}
That distinction is the difference between reactive visuals and compositional visuals. Reactive systems respond. Queryable systems orchestrate. The latter gives the artist much finer control over synchronization, especially when the goal is precise typography and musical timing.
Claude as Co-Architect, Not Just Co-Pilot
The AI story here is more interesting than a simple prompt-to-video headline. According to the README, Claude helped shape the concept, lyric alignment, audio analysis, renderer, and every scene. That makes the repo a case study in AI-assisted systems design, where the model acts more like an architectural partner than an effects generator.
Why This Beats Direct-Generation Video Tools for This Use Case
The right comparison is not whether this is more magical than AI video generators. It is whether the workflow is better for a problem that demands inspection, repeatability, and beat-level control. For that job, code wins.
| Question | Premiere / After Effects | Remotion | Direct AI video tools | pdoom-video |
|---|---|---|---|---|
| Editing model | Manual timeline and keyframes | React-based composition | Prompt-first generation | Code-defined time compiler |
| Determinism | Strong, but editor-dependent | Strong and inspectable | Often variable | Strong and frame-accurate |
| Beat precision | Possible, but manual | Good with code | Inconsistent | Core design goal |
| Preview vs export parity | Can drift | Usually aligned | Often uncertain | Explicitly matched |
| Extensibility | Plugin ecosystem | Very extensible | Limited internal control | Scene modules and engine code |
| Debuggability | UI-based | Code and logs | Low | High |
| Best fit | General video work | Programmatic video | Fast ideation | Generative music videos |
That does not make pdoom-video a universal replacement. It makes it a specialist tool for a narrow but demanding category: projects where the music is fixed, the timing must be exact, and the visual language needs the consistency of software, not improvisation.
The Bigger Lesson
The real invention in pdoom-video is not one shader, one helper, or one song. It is a reproducible workflow for cinematic motion graphics, built so that timing, rendering, and compositional logic all live together in the repo. That is why the project feels less like a video and more like a compiler for motion.





