apple-motion

A Claude skill that makes Claude write Remotion videos in the style of Apple's short, fast recap videos - built from frame-accurate measurements of six Apple recaps, not from vibes.

Not affiliated with, endorsed by or sponsored by Apple Inc. "Apple", "WWDC", "SF Pro" and product names are trademarks of Apple Inc. This repository contains no Apple media: only code, numbers measured from publicly available videos, and our own synthesized audio.

_{Demo recap built only with the skill's components and its synthesized music bed (demo/). Measured back with the same pipeline: 11 of 14 metrics inside Apple's p10-p90 range (scorecard).}

Results

6 videos, 1107.1 s, 33187 frames. Full report: reports/extraction_report.md, distributions: skill/apple-motion/references/measurements.md.

Pooled: median shot 56.5 frames, typography cap height 6.67% of frame height (~SF Pro 600.0), typography hold 33.0 frames, calibrated entry spring damping 15.35 / stiffness 115.0 / mass 1, -17.4 LUFS.

What's in here

Install the skill

Claude Code:

git clone https://github.com/IskakovDamir/apple-motion && mkdir -p ~/.claude/skills && cp -R apple-motion/skill/apple-motion ~/.claude/skills/

Claude.ai / Claude apps: download apple-motion-skill.zip from the latest release and upload it under Settings -> Capabilities -> Skills.

Then ask for something like "Make a 30-second Apple-style recap in Remotion of our Q3 launch: three features, one stat, end on the logo". Claude will copy templates/remotion/ into your project, time everything on a beat grid and use the measured springs, sizes, holds and transitions.

How the numbers were made

Six Apple recap videos (1107 s, 33,187 frames) went through nine steps, all in scripts/:

1. Shots - PySceneDetect ContentDetector + a windowed soft-transition pass; every boundary classified (cut, whip, dissolve, mask wipe, scale through, match cut) and false cuts inside continuous motion rejected by alignment (phase correlation + ECC).
2. Text - EasyOCR on every frame of every text-bearing shot; tracks linked by IoU + text similarity, split where text is swapped in place; then a template tracker on "ink" maps gives per-frame scale, position, opacity (glyph cores vs. a local ring), blur (masked NCC against blurred templates) and reveal. Designer typography was separated from UI/product/legal text by visual review of every event (reference/labels/).
3. Animation fits - exact Python port of Remotion's spring() / measureSpring() (verified equal to the stepping implementation), fitted to the leading channel of every entry and exit; plus the closest cubic-bezier and the nearest named easing.
4. Non-text motion - dense optical flow with a similarity model per frame pair: push, pull, pan, tilt, whip, static; accel/decel frames and a fitted spring per camera move.
5. Colour and layout - frame class (pure black / white / gradient / UI / product / footage), backgrounds, accents, 3x3 text placement.
6. Frames - first/middle/last frame of every shot, every frame of every text entry, 4x4 contact sheets.
7. Audio - demucs stems; BPM from a line fit of beat times (librosa's tempo bins are ~2.5% apart), downbeats, sections, SFX candidates off the music grid, faster-whisper word timestamps, EBU R128 loudness.
8. Sync - cuts and text vs. beats, downbeats, word onsets and VO pauses, each with its chance rate and a binomial test.
9. Summary per video, then build_fingerprint.py pools everything into skill/apple-motion/references/fingerprint.json, and build_skill_refs.py regenerates the skill's tokens.ts, measurements.md and the numbers block of SKILL.md.

Calibration: how much to trust the pipeline

The same pipeline is run on videos we rendered ourselves with known fonts and springs (demo/src/Calibration.tsx, scripts/eval_render.py; results in reports/eval/):

• entry styles of the calibration cards (cut, fade, scale down, scale up, blur in, slide, slide under a mask, per-word) are recovered; appear frames are exact for cut-on text and within a few frames for animated entries;
• the tracked position of a masked slide follows the true spring to within 0.01 progress units;
• fitted springs come out ~19% too fast in time scale (damping ratio preserved), so the skill uses calibrated springs (damping / 1.19, stiffness / 1.19^2);
• font weight is read from stroke width / cap height, calibrated on SF Pro Display rendered at weights 400-800;
• known weak spots: blur-driven entries, and a fast scale-down read at its first reliable frame can be labelled as a blur or slide.

The calibration renders found and fixed nine measurement bugs (merged in-place text swaps, per-word settle, per-word vs per-letter, quantised BPM, a reference-frame self-match bias in the settle test, presence leaking across in-place swaps, isolated glitch samples ending holds, counters split as swaps, unreliable start values at low opacity).

Training loop

"Training" here is an explicit loop, not model weights: render -> measure with the same pipeline -> compare with Apple's ranges -> fix the tokens / components / guidance -> render again.

• Demo recap: v2 had 8 of 13 metrics inside Apple's p10-p90 range, v5 10 of 12, v9 11 of 14 (camera-motion metrics were added; beat-lock is informational because Apple's voice-led edits sit at chance level). The loop moved type density, entry timing, loudness, black/white frame share and camera motion toward the corpus.
• Entry speed training (scripts/train_entries.py): every entry type rendered at four spring speeds, measured back, and set to the speed whose measured length matches Apple's median for that type (reports/eval/entry-training.md).
• Blind tests: separate agents that saw only the skill folder wrote recaps from new briefs (demo/src/agent*/). Their notes drove two rounds of fixes - see reports/blind-test.md. The round-2 recap rendered with every self-check metric inside Apple's range; round 4 (voice-over) came out with pure black/white frame shares of 0.03/0.23 against Apple's 0.08/0.21.

Reproduce

Requirements: macOS/Linux, Python 3.12, ffmpeg, yt-dlp, Node 20+. Apple's videos are not redistributed; scripts/download.py fetches them from the public sources in reference/sources.txt for your own analysis.

source scripts/env.sh            # keeps every cache/tmp inside the project folder
python3 -m venv --copies .venv && source scripts/env.sh
pip install "scenedetect[opencv]" opencv-python easyocr librosa demucs scikit-learn scipy pillow numpy faster-whisper
python scripts/download.py
python scripts/s1_shots.py && for s in $(ls data | grep -v _src); do python scripts/s2a_ocr.py $s; done
python scripts/run_pipeline.py   # steps 2b..9, resumable
python scripts/verify_extract.py
python scripts/build_fingerprint.py && python scripts/build_skill_refs.py

Demo:

cd demo && npm install
python ../skill/apple-motion/scripts/synth_audio.py public --bpm 120 --bars 16
ffmpeg -i public/music_raw.wav -af loudnorm=I=-17.4:TP=-2 public/music.wav
npx remotion render src/index.ts Recap out/recap_raw.mp4
../skill/apple-motion/scripts/master.sh out/recap_raw.mp4 out/recap.mp4
python ../skill/apple-motion/scripts/check_render.py out/recap.mp4
python ../scripts/eval_render.py out/recap.mp4 --name mine --truth <truth.json>   # full pipeline scorecard

Storage note: scripts/env.sh keeps every cache, temp dir and model inside the repository folder (pip, torch, Hugging Face, EasyOCR, npm). The original run lived on an external USB drive; source videos are read from a RAM-disk copy when /Volumes/amvideo exists, because the drive dropped off the bus under concurrent reads, and every step is resumable.

License

MIT for code and documentation. Measurements are facts about public videos; no Apple media is included.