Skip to main content
skill CX Codex

kinetograph-render — Claude Code skill: what it does, how to install

kinetograph-render is a Claude Code skill that inspects, previews, and renders Kinetograph scenes. It generates frame strips, validates layout errors, and exports compositions to video.

Apache-2.0 ★ 542 updated 2026-11-17

Install into Claude Code · Skills CLI (Vercel) All methods and platforms ↓
npx skills add 0xS4N4TG/kinetograph --skill kinetograph-render -a claude-code
Open on GitHub

What kinetograph-render does

This tool orchestrates the Kinetograph workflow across TypeScript, JavaScript, JSON, or HTML entry points. Subcommands like still, strip, and onion produce frame grids, individual stills, or blended motion paths into PNGs. Visual inspection is not always necessary: lint flags bounding-box overflows, clipped layers, and unlinked assets, while audio analyze reads integrated LUFS and peak clipping.

Video generation relies on kinetograph render to write MP4, WebM, MOV, GIF, or image sequences with ProRes, H.264, or VP9 codecs. Running doctor assesses DOM elements and CSS rules against Skia capabilities before launching long render jobs. The workflow requires the kinetograph CLI installed on the system.

What it helps with

  • render a multi-frame contact sheet to verify animation timing
  • detect text overflow and missing assets without drawing pixels
  • analyze audio tracks for loudness limits and clipped samples
  • export motion graphics projects to ProRes MOV, MP4, or image sequences

Example prompts for the agent

  • Generate a 12-frame contact strip for src/index.tsx
  • Lint the composition in src/index.tsx across frames to find layout bugs
  • Render src/index.tsx to a ProRes 4444 MOV file

How to install kinetograph-render

1Skills CLI (Vercel)

npx skills add 0xS4N4TG/kinetograph --skill kinetograph-render -a claude-code

2Manually: put the files in place

~/.claude/skills/kinetograph-render/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/kinetograph-render/

Step by step, with commands for each platform: How to install skills in Claude Code: five ways

Questions about kinetograph-render

How to install kinetograph-render in Claude Code?

Run npx skills add 0xS4N4TG/kinetograph --skill kinetograph-render -a claude-code in your terminal.

What does kinetograph-render do?

It gives the AI assistant commands to preview frames, run headless layout audits, analyze audio levels, and compile Kinetograph compositions into video files.

What is required to run kinetograph-render?

You need the kinetograph CLI installed in your environment, along with a tsconfig.json file if you run the check validation step.

Source text

SKILL.md · Apache-2.0
---
name: kinetograph-render
description: Look at, check and export a Kinetograph composition. Use to see frames (`still`, `strip`, `onion`), check a project without pixels (`inspect`, `lint`, `check`, `doctor`, `snapshot`, `audio analyze`), render to MP4, MOV, WebM, GIF or an image sequence, choose codecs, ProRes profiles, alpha and size, or confirm a render came out right.
metadata:
  version: "0.4.0-rc.1"
---

# Look, check, render

Commands take an entry: a project file (`.tsx`, `.ts`, `.jsx`, `.js`), a `.json` scene, or an HTML page (its `index.html`,
or the directory holding it). Choose a composition with `--comp <id>` (`compositions <entry>` lists them) and pass props
with `--props '{"title":"Hi"}'` or a JSON file path. Without `-o`, outputs go to `out/stills/`, `out/sheets/` and
`out/renders/` and the path is printed.

## 1. Look

Open the PNG to see it. `Main` below is the composition id.

- `kinetograph strip src/index.tsx -n 12`: twelve labelled frames at once, `out/sheets/Main-strip.png`. Do this first; it shows
  the whole animation. `--range 10..40`, `--cols N`.
- `kinetograph still src/index.tsx 45`: one frame, `out/stills/Main-f45.png`.
- `kinetograph onion src/index.tsx 0..60 -n 6`: frames blended over each other to show a motion path,
  `out/sheets/Main-onion.png`.

`--scale N` draws at N times the size. A range `a..b` is a to b-1; `a..=b` includes b.

## 2. Check without pixels

- `lint <entry>` (`--frames 0,45,89`; default 8 spread out): text overflowing its box or the canvas, layers off the canvas,
  overlapping text, missing fonts and assets, type errors, each with the frame and layer id. Fix every lint error. It only
  checks what a frame can show: a layer at opacity 0 (or inside a group at opacity 0) and one its clip cuts away
  completely are skipped at that frame.
- `inspect <entry> --frame 45`: every layer's resolved position, size, `bounds`, `matrix` (canvas pixels), effects and text
  lines. Use it instead of guessing from the picture.
- `check <entry>`: `tsc --noEmit` on the project (its nearest `tsconfig.json`). Rendering never type-checks, so a
  misspelled prop (`opactiy={0.5}`) draws at full opacity without an error; `lint` reports the same as `type-error`.
- `audio analyze <entry>`: `integratedLufs` (null means silence; aim for about -14 for online video), `truePeakDb` (keep it
  under -1), `clippedSamples` (should be 0) and `silences`. `--range`, `--scenes 0..90,90..180`.
- `snapshot <entry> --update` approves frames (default first, middle, last; `--frames 0,30`); `snapshot <entry>` later diffs
  against `__snapshots__/` and flags a pixel that moved by more than 2 levels.
- `bench <entry>` times the stages (`--frame`, `--runs`, `--range`); `effects` lists the effects and their fields.

Habit: `lint` before `strip`, `strip` before `render`. A command that fails prints the cause: read `error.message` and
`error.code` before changing anything.

## 3. Doctor

`doctor` alone says what this install can do: renderer, addon, CLI and skill versions. `doctor <entry>` (`--range`) runs the
JS stage for every frame, with no GPU, and reports what the engine cannot draw (compat mode; what it can is in
`kinetograph-markup`):

- how many frames are clean (`cleanFrames`, `unsupportedFrames`, `cleanShare`);
- each issue, grouped by element, property and reason, the one on the most frames first: `values` it was seen with, the
  element `paths` (`$0.2 <div>`, the host-tree position) and the inclusive frame `ranges`. An issue with a `property` is that
  CSS property on that element; one with `null` is the element itself. A page script's own `console.error` or uncaught
  error is an issue too.

Remove or replace what the top issues name, then run it again; 100% clean means nothing is left out. `still`, `strip` and
`render` warn about the same on stderr (`compat.leftOut` with `--json`); `--strict` fails with `UNSUPPORTED_CONTENT` on the
first such frame. Run `doctor` before a long render of a project that uses DOM elements or CSS.

## 4. Render

`kinetograph render src/index.tsx` writes `out/renders/Main.mp4` with audio. Common options:

- `--draft` (half size, same as `--scale 0.5`), `--range 0..90`, `--concurrency 4` (frames drawn at once; the file is the same).
- `--scale 2` for 4K from 1080p, drawn at that size, not upscaled.
- `--codec h264|h265|prores|vp9|gif` (the output extension must fit: `.mov` for prores, `.webm` for vp9, `.gif` for gif).
- `--crf 20` or `--video-bitrate 8M`, not both; `--prores-profile 4444`; `--pixel-format yuv444p`; `--audio-codec opus`.
- `--sequence` writes one image per frame into the `-o` folder instead of a video.

Bad combinations are refused with what to change. React runs in production mode (faster); `--dev-react` keeps the
development build for React's warnings. All flags, alpha, codec and encoder rules, and `--sequence` details are in
`references/export.md`.

## 5. Check the render

- Read the summary it prints: size, codec, encoder, pixel format, frames, `repeated`, and the `renderer:` line. `Skia GPU
  (...)` is fast; `Skia CPU (...)` means slow.
- For a long film, `strip` a range first, or render `--draft --range` to check timing.
- With `--json`, read `output` and the `compat` list for what was left out.
- Check the sound with `audio analyze`, and a transparent render by opening the first frame as a PNG
  (`--sequence`) or in a player that shows alpha.

© 0xS4N4TG · Apache-2.0 · 0xS4N4TG/kinetograph

Similar skills

All skills for Frontend and UI →

From the same set8

kinetograph-docs The kinetograph-docs skill for Claude Code searches documentation on kinetograph.dev and reads pages as Markdown. It activates when looking up CLI flags, guides, or compatibility lists for Kinetograph. CX Codex +1 ★ 542repo stars kinetograph-create kinetograph-create is a Claude Code skill that scaffolds video projects and pulls templates from the Kinetograph registry. Triggers when starting a video from scratch or running project setup. CX Codex +1 ★ 542repo stars kinetograph kinetograph is a Claude Code skill that routes video and motion-graphics work to the right next skill for building, checking, or rendering. CX Codex +1 ★ 542repo stars kinetograph-upgrade kinetograph-upgrade is a Claude Code skill that bumps the kinetograph CLI, its @kinetographdev/* packages, and agent skill files together whenever versions mismatch or fall behind. CX Codex +1 ★ 542repo stars kinetograph-studio kinetograph-studio is a Claude Code skill that connects an agent to the local Kinetograph Studio editor. It handles frame markups, timeline spans, and interactive review panels. CX Codex +1 ★ 542repo stars kinetograph-markup kinetograph-markup is a Claude Code skill for writing and changing Kinetograph video scenes in TSX, HTML, or JSON. CX Codex +1 ★ 542repo stars kinetograph-migrate kinetograph-migrate is a Claude Code skill that moves Remotion projects to Kinetograph for browserless video rendering. Triggers when code imports remotion or uses remotion render scripts. CX Codex +1 ★ 542repo stars

Project sponsors

Companies that keep this analytics open