900 frames at exactly 60 per second, 3.5 seconds of digital silence, then a score at -14.0 LUFS integrated and -2.3 dBTP true peak (measured with ffmpeg's ebur128 on our machine). Each of the four cuts rendered in about 25 seconds.
A single image sits on the screen.
Give an AI a few words and you get a tidy picture back. Our own first page looked like that: a flat card, a meaningless yellow ring of light, words that sank. Our public ledger shows it plainly: the pages had been opened 466 times (repeat visits counted) and confirmed sales stood at 0.
So we made the film below the hard way, one frame at a time, and this is how. The finished cut plays at the top of the making-of page: https://zero-trace-ship-kit.zeus-lab-global.workers.dev/story/?utm_source=devto
The four beats
| Time | Picture | Sound |
|---|---|---|
| 0.0–3.5 s | A grey wireframe card, perfectly still. A small monospace label: BEFORE : SILENT FLAT OUTPUT
|
Digital silence |
| 3.5–7.0 s | The grey sinks into #030305; a chamfered smoked-glass panel keeps a 1 px gold bezel, and a reflection runs round it |
A low drop lands at 3.5 s |
| 7.0–11.5 s | Five gold streams pass a glass prism and leave as one wave; the measured figures fade in under the panel | Overtones and soft mechanical ticks |
| 11.5–15.0 s | The headline in silver, the wordmark, and a black-and-gold badge in the lower safe zone | The tail of the score |
One focus per cut, and nothing bright behind the text. The badge sits at 66% of the height in the 1080×1920 cut, above the area that short-video apps cover with their own buttons.
Rendering: draw frame i at time i/60, never "in real time"
Screen recording drops frames whenever the machine is busy. Instead, the scene is a plain HTML page with a 2D canvas and one pure function, frame(t). A small Python server opens it in headless Chrome, and the page draws every frame at its exact time and posts the raw pixels back:
for (let i = 0; i < N; i++) { // N = 15 s × 60
frame(i / FPS); // pure: same t, same picture
const buf = og.getImageData(0, 0, W, H).data.buffer;
await fetch("/__frame?i=" + i, { method: "POST", body: buf });
}
await fetch("/__done?n=" + N, { method: "POST" });
The server writes each body straight into ffmpeg's standard input:
ffmpeg -f rawvideo -pix_fmt rgba -s 1920x1080 -framerate 60 -i - \
-i score_awaken.wav -vf noise=alls=2:allf=t \
-c:v libx264 -crf 17 -preset slow -pix_fmt yuv420p \
-c:a aac -b:a 192k -movflags +faststart -map_metadata -1 -r 60 -t 15 out.mp4
ffmpeg sets the pace (the fetch waits while the pipe is full), so the frame rate is 60 by construction, not by luck. Our media gate then reads the MP4 boxes and reports the measured rate: 900 frames · 60.0 fps measured · sound yes for all four cuts. On our machine each cut took about 25 seconds; the files came out between 2.29 and 2.47 MB at CRF 17, because most of the picture is near-black.
Two details that mattered:
- Seeded randomness. The dust and the guilloche texture use a fixed seed, so every render is identical and a frame can be re-checked later.
- Easing, never linear. Every move uses a quartic ease-out or ease-in-out. Linear motion looked mechanical next to the glass.
Sound: silence first, then measure, then limit
The score was cut from an ambient piece we had already measured, so that its low drop lands exactly at 3.5 s, and padded with true digital silence in front:
ffmpeg -i score_cosmos.wav -af "atrim=1.5:13.0,asetpts=PTS-STARTPTS,\
afade=t=in:d=0.02,afade=t=out:st=10.3:d=1.2,adelay=3500|3500,apad=whole_dur=15" raw.wav
Integrated loudness gates out silence, so the 3.5 s does not drag the figure down; the raw cut measured -15.8 LUFS. Gain plus a true-peak limiter at 192 kHz brought it to target:
ffmpeg -i raw.wav -af "volume=1.8dB,aresample=192000,\
alimiter=limit=-2dB:level=false:attack=1:release=60,aresample=48000" score_awaken.wav
ffmpeg -i out.mp4 -af ebur128=peak=true -f null - # I: -14.0 LUFS, Peak: -2.3 dBFS
An earlier synthesis of ours peaked at -0.5 dBFS true peak, close enough to clip on some decoders. Oversampling to 192 kHz before the limiter is what caught the inter-sample peaks. We also checked the opening: the first 3.45 s of the encoded file read a maximum of -91 dB (AAC's own floor), so the silence survives encoding.
We did not listen-test this on speakers in a studio; the figures above are meter readings, and that is how we describe them.
Who did what
One person decided what the film should feel like and what would not ship. The scene, the score cut and this article were drafted with AI. A second AI, run in an empty folder with only the finished story text, reviewed it for claims we could not support. It asked for seven changes, for example "commit time" instead of "just before publishing" for when our leak check runs. We made them. Plain code (no AI) then checked names, colours, links and leak patterns before anything went out.
What did not work
- The first version of the bezel reflection was drawn as dots and looked like a dotted line. Short stroked segments with fading alpha fixed it.
- In the first end frame the five streams were still faintly visible behind the headline. The panel now fades fully to zero before the words arrive.
- Headless Chrome will not shrink below about 500 px wide, so the phone screenshots of the page are taken inside a 390 px frame.
If you want the pieces
The text-free 60 fps loops, the ambient score, the glass bento grid in plain HTML and CSS, and the animated dial figures are in our Cinema Vault: https://zero-trace-ship-kit.zeus-lab-global.workers.dev/go/vault/?utm_source=devto
The written set-up of the one-person, several-AI studio behind it (roles, review, a budget ledger, the pre-publish check) is Studio Blueprint: https://zero-trace-ship-kit.zeus-lab-global.workers.dev/go/studio/?utm_source=devto
The live figures, sales included, are on the ledger: https://zero-trace-ship-kit.zeus-lab-global.workers.dev/ledger/?utm_source=devto
Disclosure: this article was drafted with AI assistance (Claude) and checked against the measured results and the published files. Product links lead to our own paid kits.
Top comments (0)