frame-capture — Claude Code skill for web video capture
The frame-capture skill for Claude Code records web pages to MP4 with frame-by-frame control of time. Use it to capture animations, page scrolls, or a comparison of two clips.
MIT ★ 448 updated 2026-11-09
/plugin marketplace add Moh4696/open-3d-skills
/plugin install open-3d-skills@open-3d-skillsWhat frame-capture does
frame-capture records web pages to MP4 by advancing a virtual clock one frame at a time. CSS animation, video, and three.js or WebGL scenes follow that clock rather than the speed of the screen capture. The scripts/record.py script controls scrolling, pointer movement, and a page-ready condition.
scripts/compare.py combines two recordings in a stack or side by side, with labels. Serve the page with scripts/serve.py: Python’s built-in python3 -m http.server ignores HTTP Range requests, so videos on the page cannot seek. Requirements are Python 3.9+, the playwright and pillow packages, a Playwright-installed Chromium or WebKit browser, and ffmpeg on PATH.
WebKit screenshots at 1080p sometimes stall; the script retries the same frame. The --kill-lenis flag stops Lenis from loading, while other smooth-scroll libraries need to be disabled in ?record=1 mode.
What it helps with
- record a page scroll as an MP4
- capture WebGL animation frame by frame
- compare two clips with labels
- record page motion without real-time capture stutter
Example prompts for the agent
- Record the scroll on
http://127.0.0.1:8000/as an MP4. - Capture a demo of this three.js scene.
- Compare
a.mp4andb.mp4in one video with “Before” and “After” labels.
How to install frame-capture
1Plugin marketplace
/plugin marketplace add Moh4696/open-3d-skills/plugin install open-3d-skills@open-3d-skillsThis installs the whole open-3d-skills plugin with all its skills
2Skills CLI (Vercel)
npx skills add Moh4696/open-3d-skills --skill frame-capture -a claude-code3Manually: put the files in place
~/.claude/skills/frame-capture/SKILL.mdCopy the whole skill folder; for one project use .claude/skills/frame-capture/
1Skills CLI (Vercel)
npx skills add Moh4696/open-3d-skills --skill frame-capture -a codex2Manually: put the files in place
.agents/skills/frame-capture/SKILL.mdFor all projects use ~/.agents/skills/
1Skills CLI (Vercel)
npx skills add Moh4696/open-3d-skills --skill frame-capture -a cursor2Manually: put the files in place
.cursor/skills/frame-capture/SKILL.mdCursor also reads .agents/skills/ and .claude/skills/
1GitHub CLI
gh skill install Moh4696/open-3d-skills skills/frame-capture2Manually: put the files in place
.github/skills/frame-capture/SKILL.md1Skills CLI (Vercel)
npx skills add Moh4696/open-3d-skills --skill frame-capture -a gemini-cli2Platform CLI
gemini skills install https://github.com/Moh4696/open-3d-skills --path skills/frame-captureManually: put the files in place
.devin/skills/frame-capture/SKILL.mdThe legacy .windsurf/skills/ path still works
Claude.ai
Zip the folder and upload it in Settings → Capabilities → Skills
Step by step, with commands for each platform: How to install skills in Claude Code: five ways
Questions about frame-capture
How do I install frame-capture in Claude Code?
Run these commands in order: /plugin marketplace add Moh4696/open-3d-skills, then /plugin install open-3d-skills@open-3d-skills.
What does frame-capture do?
It records web pages to MP4 with frame-by-frame time control and can combine two clips into a labelled comparison.
What does frame-capture need to run?
It needs Python 3.9+, the playwright and pillow packages, a Playwright-installed Chromium or WebKit browser, and ffmpeg on PATH.
Source text
SKILL.md · MIT
---
name: frame-capture
description: Records any web page (three.js, WebGL, canvas, GSAP, CSS animation, scroll-driven video) to a perfectly smooth 60 fps MP4 by running the page on a virtual clock, one exact frame at a time, and puts two recordings against each other as a labelled stacked or side-by-side comparison. Use when someone wants a video of a site, a demo clip for X or YouTube, a scroll-through, a showcase reel of a 3D scene, or a "model A vs model B" comparison video. Also use when a screen recording of an animated page stutters or drops frames.
---
# Frame capture
Screen recorders capture whatever the GPU managed to draw in real time, so a heavy scene stutters and a scroll-through looks hand-held. This skill records differently. Before the page's own scripts run, its clock is replaced: `performance.now`, `Date.now` and `requestAnimationFrame` read a virtual time, CSS animations and transitions are pinned to it, and every `<video>` is paused and seeked to it. Each output frame advances the clock by exactly 1/60 s, runs one frame, and takes a screenshot. A frame can take two seconds to render and the video still plays at a perfect 60 fps.
## Tools
| Script | What it does |
| --- | --- |
| `scripts/record.py` | Records a URL to MP4 with scroll keys, pointer motion and a ready condition |
| `scripts/compare.py` | Stacks two clips (or sets them side by side) with labels and rounded panels |
| `scripts/serve.py` | Static server that answers HTTP Range requests, so videos can seek |
Needs Python 3.9+, `pip install playwright pillow`, `python3 -m playwright install chromium webkit`, and ffmpeg on PATH.
## Run
1. **Serve the page with `scripts/serve.py`**, never `python3 -m http.server`. The built-in server ignores Range requests. The browser then cannot seek any video it serves (`video.seekable` is empty) and every recorded video holds its first frame. `record.py` warns when it sees this.
```bash
python3 scripts/serve.py path/to/site --port 8000
```
2. **Make a fast timing pass first.** Ten frames a second shows the choreography in seconds instead of minutes:
```bash
python3 scripts/record.py http://127.0.0.1:8000/ /tmp/check.mp4 --seconds 20 --fps 8 \
--scroll "0:0 2.5:0 9:40% 12:40% 19:100%" --pointer drift
```
Watch it, adjust the keys, repeat. Only then render the full clip.
3. **Render the final.** `--size` is the CSS viewport and `--dpr` multiplies it. `--size 1920x1080 --dpr 1` makes 1080p; `--size 1280x720 --dpr 1.5` makes the same 1920x1080 with a larger layout. Output is H.264, CRF 16, yuv420p, BT.709 tags, faststart, no audio.
```bash
python3 scripts/record.py http://127.0.0.1:8000/ out.mp4 --seconds 20 --fps 60 \
--scroll "0:0 2.5:0 9:40% 12:40% 19:100%" --pointer drift --ready "window.__ready === true"
```
4. **Look at the result** before handing it over. Pull frames at the moments that matter (`ffmpeg -ss 9 -i out.mp4 -frames:v 1 f.png`) and check them: first frame, every scroll stop, the last frame.
### Choreography
- `--scroll` keys are `seconds:position`. Positions are pixels (`1200`), a share of the scroll range (`40%`) or viewport heights (`2.5vh`). Segments ease (half linear, half smootherstep, so a long move never sprints in the middle). Add `~` after the time for a linear segment: `9~:60%`.
- Hold on anything the viewer needs to read: give a pinned section or a counter its own key pair with the same position.
- `--pointer drift` circles the real mouse slowly round the centre, so hover states, parallax and cursor-following rigs come alive. `--pointer 0.7,0.3` parks it.
- For choreography the page knows best (camera flights, a tour), let the page drive itself: define `window.__recordFrame = (t) => { ... }` behind a `?record=1` flag. It is called with the virtual time in seconds before each frame. `window.__recording` is true while recording.
- Smooth-scroll libraries fight a recorder that sets the scroll position. `--kill-lenis` stops Lenis from loading. For others, switch them off under `?record=1`.
## Make the page recordable
- **Time comes from `performance.now()` or the rAF timestamp, never from `setTimeout` or `setInterval`.** Timers keep real time while the clock is virtual, so a `setTimeout(next, 3000)` fires after three real seconds, which might be frame 20 or frame 400. Schedule on the page clock instead:
```js
const pending = [];
const later = (secs, fn) => pending.push({ at: performance.now() / 1000 + secs, fn });
// in the frame loop:
const now = performance.now() / 1000;
for (let i = pending.length - 1; i >= 0; i--) if (now >= pending[i].at) pending.splice(i, 1)[0].fn();
```
- Expose a ready flag (`window.__ready = true` after the first rendered frame, textures decoded, fonts loaded) and pass it as `--ready`. Recording before assets land bakes a loading flash into frame 0.
- In record mode, hide UI that would not be in a film: hints, cursors, loaders, cookie bars.
- If WebGL frames come out black or stale, create the renderer with `preserveDrawingBuffer: true` when recording.
## Browsers
- **Chromium (default)** runs WebGL on the real GPU headless. On macOS the script adds `--use-angle=metal`, which renders at full speed; without it Chromium falls back to SwiftShader, which is correct but many times slower.
- **WebKit** (`--browser webkit`) shows how Safari renders: different font smoothing, colour handling and video decoding. Its screenshots occasionally stall at 1080p (about 1 in 100); the script retries, and because the clock is paused between steps the retry returns the identical frame.
- If Playwright's own Chromium is missing (a version mismatch after an upgrade), the script finds the newest Chromium in the Playwright cache. `CHROME_PATH` overrides it.
- Never record in a visible browser tab you are not looking at, and never in a hidden embedded preview pane. Background tabs throttle or freeze `requestAnimationFrame`. Headless does not.
## Comparisons
```bash
python3 scripts/compare.py a.mp4 b.mp4 versus.mp4 --labels "Model A" "Model B" # stacked, for phones
python3 scripts/compare.py a.mp4 b.mp4 versus.mp4 --labels "Before" "After" --layout side # side by side
```
A fair comparison holds everything equal except the thing being compared:
- Same viewport, same duration, same choreography (`--scroll` keys reused verbatim).
- Crop each source to its content first. Strip watermarks, webcam overlays and UI chrome the other clip does not have.
- Silent output. Two soundtracks fight, and audio steals attention from the picture.
- The shorter clip holds its last frame, so both finish together.
- Name each side honestly in its label. Put the one the audience knows on top.
## Delivery
- Social platforms re-encode everything. 1920x1080 or 1080x1920 at 60 fps, H.264, CRF 14 to 18 survives that best. Higher resolutions are often downscaled anyway.
- Keep the master. Make cut-downs (a 6 s loop, a vertical crop) from it with ffmpeg rather than re-recording.
- Add sound afterwards, timed to the frame numbers the recording printed. Never record audio through the virtual clock.
© exploraX · MIT · Moh4696/open-3d-skills