Multiplane skill
Multiplane renders video from plain HTML pages in headless Chromium and checks that every frame depends only on time.
- 168 ★ on the repository
- Last commit
- Apache-2.0
Extended access
Why this level
- Pages run JavaScript in headless Chromium, so render only scenes you trust.
- Installation downloads Chromium and writes the skill into agent directories.
Install
- Works in
In your terminal, with SkillFoxx CLI
npx skillfoxx add skills/multiplaneDetects the agents on your machine, shows the access level and pins the version.
Other ways to install
Access and checks
How we reviewExtended accessThe tool runs code or makes network calls and only reads external data.
- Pages run JavaScript in headless Chromium, so render only scenes you trust.
- Installation downloads Chromium and writes the skill into agent directories.
This is third-party code. Review the repository files before installing.
What it does
Multiplane, a local video renderer for agents, builds a clip from a web page: the page implements `render(t)` and Chromium captures frames. Supersampling, motion blur, film grain and an FFmpeg encode follow. The `lint` command flags in about a second whatever breaks determinism: wall-clock time, random numbers, CSS animations, network resources. The `verify` command renders the same frames out of order, after a page reload, in one process and in several, then compares pixels. `stills` outputs static PNGs, declared hard `cuts` keep blur from bleeding across them, and an optional 3D layer adds accumulated depth of field. Every command accepts `--json`.
Who it is for. Developers and editors who hand video work to an agent and want a repeatable result built from HTML, CSS and JavaScript.
Good fit when
- An agent builds an animated clip from a web page without a separate video framework.
- A re-render must produce the same pixels.
- A cover or poster needs a still frame with blur and depth of field.
- CI teams want `--json` output with stable error codes.
Not a fit when
- You edit existing video files instead of generating frames from code.
- The clip depends on remote fonts and assets, which the check rejects.
- Node.js 24 and FFmpeg with libx264 cannot be installed.
Example request
Build a 5-second 1920x1080 clip from an HTML page with a moving block, check it with `lint` and `verify`, and output the frame at 2 seconds.Limitations
It needs Node.js 24 or newer, Chromium for Playwright and FFmpeg with libx264; Multiplane does not bundle FFmpeg and its licence depends on your build. The interface may change before 1.0. On Linux, Chromium needs system libraries and `doctor` reports what is missing. Frame rendering on CPU takes a long time, and a hardware encoder exists only for NVIDIA via `--encoder nvenc-h264`. Watch the releases when upgrading: version 0.3 is not yet stable, and `verify` guarantees matching pixels only in the same environment.
How to disable. Delete the skill folder `~/.claude/skills/multiplane` or `~/.agents/skills/multiplane` and the `multiplane` package. The installed Chromium and FFmpeg stay and are removed separately.
FAQ
What is a frame in Multiplane?
The output of the page `render(t)` function. The result depends only on time `t`, so one input in one environment gives identical pixels.
Where does the skill go?
`npx multiplane skill install --host all` puts it in `~/.claude/skills/multiplane` for Claude Code and `~/.agents/skills/multiplane` for Codex. A new agent session is needed afterwards.
What does `lint` check?
It runs without a browser and finds forbidden patterns: wall-clock time, unseeded random numbers, CSS animations and network resources. Each error names the file, line and column.
Can I get only an image?
Yes. `stills` writes PNGs for chosen moments with the same supersampling, blur and depth of field as video.
Is FFmpeg required separately?
Yes, with libx264 support. Set the path with `--ffmpeg`, the `MULTIPLANE_FFMPEG` variable, `config set ffmpeg` or `PATH`.
Discussion
No questions or reviews yet.
Related
SkillsA skill set for writing video in TypeScript and rendering it on the GPU with no browser: compositing, motion graphics, 3D.
A CLI for programmatic video from HTML: the agent assembles frames from templates and renders a finished MP4 on your machine
Skills and CLI from HeyGen: the agent writes HTML compositions and renders them into MP4 videos, captions, motion graphics and decks
A skill that renders HTML and Canvas animation to MP4, GIF or a transparent layer: a browser grabs the frames, ffmpeg encodes.
A skill for promo films and kinetic type: idea and storyboard before the build, MP4 rendered through Chrome and ffmpeg, checked by six gates
A video engine for agents in Rust: Remotion-style TypeScript code or an HTML page turns into MP4 on the GPU, no browser.
Comparison with similar tools
Cards that share the main search query, and how they differ.
| Tool | Official | Repository stars | Main difference |
|---|---|---|---|
| Multiplane (this card) | no | 168 | |
| HyperFrames | no | 83,283 | HyperFrames describes video as compositions; in Multiplane a scene is a plain page with `render(t)` and a `verify` check |
| html-video | no | 4,832 | also builds video from HTML pages; Multiplane adds a determinism check and blur that stops at cuts |
| Remotion Agent Skills | no | 6,903 | teaches agents to write video in React; Multiplane has no framework, only HTML and JavaScript |
README in short
Scenes are plain HTML, CSS and JavaScript. Determinism is checked before rendering, and rendering applies supersampling, linear-light motion blur and film grain.