Skip to main content
skill CX Codex

kinetograph-markup — Claude Code skill

kinetograph-markup is a Claude Code skill for writing and changing Kinetograph video scenes in TSX, HTML, or JSON.

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-markup -a claude-code
Open on GitHub

What kinetograph-markup does

kinetograph-markup writes and edits Kinetograph compositions with layers, shapes, text, images, cameras, audio, fonts, effects, and timing. It uses the Remotion API alongside native elements such as Layer, Rect, Text, Image, Camera, and Audio; Web Audio timing is handled through onFrame.

New compositions import @kinetographdev/core, which ships with kinetograph, so remotion is not installed for that setup. An existing Remotion project keeps its remotion and @remotion/* imports. The entry file must call registerRoot. Fonts are registered before text measurement, and repeatable renders use random(seed) instead of Math.random().

HTML, CSS, SVG, Canvas, and WebGL are supported through compatibility mode, while unsupported drawing may be skipped or approximated. Such projects run doctor from kinetograph-render before render; available plugins are listed with npx kinetograph plugins.

What it helps with

  • create a video scene in TSX, HTML, or JSON
  • arrange a composition with layers, shapes, and text
  • add fonts, media, effects, and a 3D camera
  • sync music and Web Audio with the frame timeline
  • check DOM, CSS, or SVG compatibility before rendering

Example prompts for the agent

  • Write a Kinetograph composition in scene.tsx with a background, text, and entrance animation.
  • Add an Audio layer to card.json and tie its volume to the frame timeline.
  • List the Kinetograph plugins and diagnose the project before rendering.

How to install kinetograph-markup

1Skills CLI (Vercel)

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

2Manually: put the files in place

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

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

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

Questions about kinetograph-markup

How do I install kinetograph-markup in Claude Code?

Run npx skills add 0xS4N4TG/kinetograph --skill kinetograph-markup -a claude-code. The skill file will then be available at ~/.claude/skills/kinetograph-markup/SKILL.md.

What does kinetograph-markup do?

It writes and changes Kinetograph compositions in TSX, HTML, and JSON. The skill covers the Remotion API, native elements, fonts, media, effects, sound, and timing.

What does kinetograph-markup need to work?

New compositions use @kinetographdev/core, which ships with kinetograph; rendering and diagnostics use kinetograph-render. Existing Remotion projects keep their remotion and @remotion/* imports.

Source text

SKILL.md · Apache-2.0
---
name: kinetograph-markup
description: Write or change a Kinetograph composition: the Remotion API, native elements (Layer, Rect, Text, Image, Camera, Audio), layout, type, fonts, media, effects, Web Audio sound, timing, plugins, and what the engine draws and does not. Use when writing or editing the TSX, HTML or JSON scene of a video.
metadata:
  version: "0.4.0-rc.1"
---

# Write a composition

A new project imports the API from `@kinetographdev/core`, which comes with `kinetograph`; never install `remotion`
(`@remotion/*` imports such as the font loaders are mapped too). An existing Remotion project keeps its `remotion` and
`@remotion/*` imports, which map onto the same code. The entry must call `registerRoot`; a file that only exports a
component is not an entry. An entry is a project file (`.tsx`, `.ts`, `.jsx`, `.js`), a `.json` scene, or an HTML page.

```tsx
import { AbsoluteFill, Composition, Layer, Rect, Text, interpolate, registerRoot, spring,
         useCurrentFrame, useVideoConfig, dropShadow, linearGradient, registerFont, staticFile } from '@kinetographdev/core';

registerFont({ family: 'DM Sans', path: staticFile('fonts/DMSans-Medium.ttf') }); // fonts BEFORE any text is measured

const Card = () => {
  const frame = useCurrentFrame();
  const { fps, width, height } = useVideoConfig();
  const s = spring({ frame, fps, config: { damping: 14 } });
  return (
    <AbsoluteFill style={{ backgroundColor: '#10131a' }}>
      <Layer x={width / 2} y={height / 2} scale={s} origin="center" effects={[dropShadow({ y: 12, blur: 24 })]}>
        <Rect width={600} height={300} radius={32} fill={linearGradient(['#f9a', '#fc6'])} />
        <Text font="DM Sans" size={72} color="#fff" x={60} y={100}>gets better</Text>
      </Layer>
    </AbsoluteFill>
  );
};

registerRoot(() => <Composition id="Main" component={Card} durationInFrames={90} fps={30} width={1080} height={1920} />);
```

- Remotion's API works as documented: `useCurrentFrame`, `useVideoConfig`, `interpolate`, `interpolateColors`, `spring`,
  `Easing`, `random`, `Sequence`, `Series`, `Loop`, `Freeze`, `AbsoluteFill`, `Img`, `staticFile`, `delayRender`.
  `staticFile('x.png')` is `public/x.png` next to the entry file, or in the `public/` at the package.json's folder.
- Rendering is a pure function of the frame number. `Math.random()`, `Date.now()` and timers are driven by the frame; use
  `random(seed)` for jitter. Never read the real clock.
- Register fonts before text is laid out. Text with a font that is not registered is a lint error.
- For new work use the native elements below. `<div>`s, `className`, stylesheets, Tailwind and SVG also work (compat
  mode); a frame holding something the engine cannot draw yet is drawn without it or approximated, and the command warns.
  Run `doctor` on such a project before `render` (`kinetograph-render`).

## Elements and effects

Every element takes `id`, `x`, `y`, `scale`, `rotation`, `origin="center"`, `opacity`, `blendMode`, `effects`, `clip`,
`mask`, `matte`, `motionBlur`, and 3D `z`, `rotateX`, `rotateY`. Numbers may be plain or keyframe lists.

| Element | For |
|---|---|
| `<Layer>` | a group; `layout` (flexbox) and `preserve3d` |
| `<Rect>`, `<Ellipse>`, `<Path>`, `<Shape>` | vector shapes with `fill` (colour or gradient) and `stroke` |
| `<Text>` | text; `font`, `size`, `color`, `maxWidth`, `align`, per-character `chars` |
| `<Image>`, `<Img>` | PNG, JPEG, GIF, WebP, SVG files; `fit="cover"` |
| `<Noise>`, `<MeshGradient>`, `<Lottie>` | generated and Lottie layers |
| `<Camera>` | a perspective camera for 3D transforms |
| `<Audio>` | a sound file: `src`, `volume`, `trimBefore`, `playbackRate`, `loop` |

Effects (helpers of the same name; `kinetograph effects` lists their fields): `blur`, `backdropBlur`, `glow`,
`chromaticAberration`, `dropShadow`, `insetShadow`, `saturate`, `contrast`, `brightness`, `grayscale`, `sepia`, `invert`,
`hueRotate`, `gradientMap`, `lut`, `colorGrade` (HyperFrames' grade and its 18 look effects: `{ effects: { halftone: 0.9 } }`),
`grain`, `dither`, `halftone`, `dotMatrix`, `displace`, `cornerPin`, and `shader` for your own WGSL. `motionBlur({ samples: 8 })`
goes in the same `effects` array.

## Sound

Web Audio code runs offline against the frame timeline. Call `onFrame` at module level; `ctx` is an `OfflineAudioContext`,
`t` is the start time in seconds.

```ts
import { onFrame } from '@kinetographdev/audio';

onFrame(42, (ctx, t) => {
  const o = ctx.createOscillator(); const g = ctx.createGain();
  o.frequency.setValueAtTime(3000, t); o.frequency.exponentialRampToValueAtTime(4500, t + 0.055);
  g.gain.setValueAtTime(0.4, t); g.gain.exponentialRampToValueAtTime(0.001, t + 0.06);
  o.connect(g).connect(ctx.destination); o.start(t); o.stop(t + 0.06);
});
```

`<Audio src={staticFile('audio/music.mp3')} volume={(f) => interpolate(f, [0, 30], [0, 1])} />` plays a file. `render`
mixes both into the video. Measure it with `audio analyze` (`kinetograph-render`).

## Habits

- Run `npx kinetograph plugins` and read each plugin's `SKILL.md` before using it. Plugin tools show as `<plugin>_<tool>`.
- Give an explicit `id` to matte sources and to anything an `<Audio>` or matte refers to.
- Use `random(seed)`, never `Math.random()`, so a frame is the same every time.

## References

Read the part you need; these files are large.

| File | What it holds |
|---|---|
| `references/capabilities.md` | the `@remotion/*` packages that import, compat mode (DOM, CSS, SVG, Canvas, WebGL), libraries and plugins that render, HTML and HyperFrames pages, fonts, datamosh, motion tracking, video matting |
| `references/AUTHORING.md` | the contract of each package: §5 helpers, §6 elements and their JSON, §7 the Remotion API, §8 audio, §9 CLI and export, §11 video layers, GSAP and plugins |
| `references/SCENE.md` | the `.json` scene: every layer type, effect and field, and what each means exactly |
| `references/ENGINE.md` | the DOM and CSS engine: what CSS and SVG it draws |
| `references/INTERNALS.md` | how a frame is made, and the code map |

© 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-render 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. 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