Skip to content
Remotion Markup

Remotion Markup Skill

Remotion's official skill for writing the React markup of a video: frame-driven animation with interpolate(), Studio-editable timing, media components, built-in visual effects, transitions, captions and fonts.

GitHub Docs
DevelopmentDesign & Creative
Released
v4.0.545
Remotion License

Install

Install with the skills CLI

One command for Claude Code, Codex, Cursor, GitHub Copilot, Gemini CLI, Windsurf and dozens of other agents. Needs Node.js; the skill is fetched straight from remotion-dev/skills.

$ npx skills add remotion-dev/skills --skill remotion-markup

Run it in a terminal. The CLI finds the agents installed on your machine, asks which ones to add the skill to, and whether to install it into the folder you ran it from or for all your projects.

Other ways to install

Copy the whole skill folder — SKILL.md and any scripts or references beside it — into ~/.claude/skills/remotion-markup/, where Claude Code picks it up in every project. Only git is needed.

tmp=$(mktemp -d) && \
  git clone --depth 1 --branch main https://github.com/remotion-dev/skills.git "$tmp" && \
  mkdir -p ~/.claude/skills && \
  cp -R "$tmp"/skills/remotion-markup ~/.claude/skills/remotion-markup

No scripts or references next to it? Saving the SKILL.md alone as ~/.claude/skills/remotion-markup/SKILL.md works too.

Using another agent? Its personal skills folder
Codex
~/.agents/skills/
Cursor
~/.cursor/skills/
GitHub Copilot
~/.copilot/skills/
Gemini CLI
~/.gemini/skills/
Windsurf
~/.codeium/windsurf/skills/
OpenCode
~/.config/opencode/skills/

About

  • Frame-driven animation with useCurrentFrame(), interpolate() and Easing helpers
  • Studio-editable timing and keyframes kept inline on JSX props
  • Built-in @remotion/effects for color, blur, lighting, distortion and texture
  • Reference files for media, transitions, captions, fonts, Lottie, 3D and audio visualization
  • Preserves edits the user made outside the conversation
  • Adds packages with npx remotion add at matching versions

Remotion Markup is the skill in the remotion-dev/skills repository for writing the content of Remotion compositions, the React components that Remotion renders into video. It complements remotion-best-practices, which the agent loads instead when the task is not about markup, and links out to sibling skills for interactivity, Studio and rendering.

Its rules are written as MUST, SHOULD, MAY and CAN. Animation is driven by useCurrentFrame() and interpolate() with Easing.bezier() or Easing.spring(), because CSS transitions and Tailwind animation classes do not render correctly. Frame subscriptions stay in the smallest component that needs them, all seconds-to-frames math uses fps from useVideoConfig(), and interpolations stay inline on the JSX so Remotion Studio can edit timing and keyframes. It also tells the agent to preserve edits the user made outside the conversation.

Beyond the general rules it is an index of topics with their own reference files: assets and media components, trimming, multi-scene and connected compositions, embedded video and audio, cropping, video matting, transitions, motion blur, the @remotion/effects library (color, blur, lighting, distortion, texture, edge and pixelation effects applied through the effects prop or <HtmlInCanvas>), color correction, 3D, sound effects, audio visualization, maps, captions, right-to-left text, Google and local fonts, GIFs, Lottie, parameterized videos, FFmpeg and silence detection. Packages are added with npx remotion add. Distributed under the Remotion License.

SKILL.md

The instructions your agent loads, as published by Remotion.

SKILL.md
name
remotion-markup
description
Content, animation and effects best practices
version
4.0.545

This is guidance for writing Remotion React Markup.
If this is not relevant, load Remotion Best Practices (remotion-best-practices skill) instead.

MUST marks requirements, SHOULD recommendations, MAY optional actions, and CAN capabilities. Apply them to the requested task.

Preserve user changes

Users may make edits in the code outside of the conversation.

If you detect a surprising change made in the meanwhile, don't overwrite it, assume it was intentional or ask for confirmation.

General rules

Keep useCurrentFrame() in the smallest component that needs it. Extract
frame-dependent audio volume, titles, and overlays into their own components
instead of subscribing the whole composition or scene; otherwise unrelated
descendants re-render on every frame. Preserve the existing frame coordinates
when extracting across timing boundaries, and keep editable interpolations
inline on the item's props.

Inside a composition or scene component, get fps from useVideoConfig() for
all seconds-to-frames calculations, including timing props such as from,
trimBefore and durationInFrames. Keeping the expression on
the JSX node, such as trimBefore={4 * fps}, lets Studio edit the timing and
keeps it correct if the composition frame rate changes.

Drive animations using useCurrentFrame() and interpolate().
CSS transition or animation will not render correctly, they need to refactored.
Tailwind animation class will not render correctly, they need to be refactored.

Use Easing.bezier() and Easing.spring() to customize timing.

Before choosing the markup hierarchy, read
editable timeline structure (timeline-structure.md in the remotion-interactivity skill).
Choose editing units first, then the tracks or shared timing boundaries they
need. It includes a complete example with interactive components and their
registrations. For source-editable styles, schemas, and keyframes, see
Remotion Interactivity (remotion-interactivity skill).

import { useCurrentFrame, useVideoConfig, Easing, interpolate, Interactive } from "remotion";

export const FadeIn = () => {
  const frame = useCurrentFrame();
  const {fps} = useVideoConfig();

  return (
    <Interactive.Div
      name="Title"
      style={{
        opacity: interpolate(frame, [0, 2 * fps], [0, 1], {
          extrapolateRight: "clamp",
          extrapolateLeft: "clamp",
          easing: Easing.bezier(0.16, 1, 0.3, 1),
        }),
      }}
    >
      Hello World!
    </Interactive.Div>
  );
};

Keep the interpolate() call inline in the style prop.
Use scale, translate, rotate CSS properties over transform.

// 👍 Inline editable keyframes and transform shorthands
style={{
  scale: interpolate(frame, [0, 100], [0, 1], {
    extrapolateLeft: 'clamp',
    extrapolateRight: 'clamp',
    easing: Easing.spring({damping: 200}),
    output: 'perceptual-scale' // For `scale` animations, use "output: 'perceptual-scale'"
  }),
  translate: interpolate(frame, [0, 100], ["0px 0px", "100px 100px"], {
    extrapolateLeft: 'clamp',
    extrapolateRight: 'clamp',
    easing: Easing.spring({damping: 200}),
  }),
  rotate: interpolate(frame, [0, 100], ["20deg", "90deg"], {
    extrapolateLeft: 'clamp',
    extrapolateRight: 'clamp',
    easing: Easing.spring({damping: 200}),
  }),
}}

// 👎 Non-inline values and transform strings become harder to edit in Studio
const scale = interpolate(frame, [0, 100], [0, 1]);

style={{
  transform: `scale(${scale})`,
}}
Assets

Place assets in the public/ folder at your project root.
Use staticFile() to reference files from the public/ folder.

Media components

Add video and audio using <Video> and <Audio> from @remotion/media.
Add images using the <CanvasImage> component.
Add animated GIFs, APNG, WebP or AVIF images using <AnimatedImage>, use @remotion/gif if not using Chrome.
Use staticFile() for files in public/ or pass a remote URL directly:

import { Audio, Video } from "@remotion/media";
import { staticFile, CanvasImage, AnimatedImage } from "remotion";

export const MyComposition = () => {
  return (
    <>
      <Video src={staticFile("video.mp4")} style={{ opacity: 0.5 }} />
      <Audio src={staticFile("audio.mp3")} />
      <CanvasImage
        src={staticFile("logo.png")}
        style={{ width: 100, height: 100 }}
      />
      <Video src="https://remotion.media/video.mp4" />
      <AnimatedImage src={staticFile('nyancat.gif')} />
    </>
  );
};

If the composition is primarily a timeline of video or audio clips, read
[video-editing.md](video-editing.md) before choosing its source structure.

Delaying, trimming

Use [sequencing](sequencing.md) to choose the timing boundary and
[timing props](timing-props.md) for the supported props and order of operations.

Maps

See [Remotion Maps](./remotion-maps/REFERENCE.md) if wanting to include maps in the video.

Text highlights and annotations

See [text-highlights.md](text-highlights.md) for text highlights (highlight markers), circles, underlines, strike-throughs, crossed-off text, boxes.

Multi-scene videos

See [multi-scene-video.md](multi-scene-video.md) if planning to make a video with multiple subsequent scenes.

Connected compositions

Read [connected compositions](connected-compositions.md) when a scene or group
needs its own editable timeline, or when handling a Studio pre-compose request.
It covers extraction, registration, inherited styles, and verification in both
the parent and standalone views.

Embedding Videos

See [embedding-videos.md](embedding-videos.md) for advanced knowledge about embedding videos - trimming, volume, speed, looping, pitch.

Embedding Audio

See [audio.md](audio.md) for advanced audio features like trimming, volume, speed, pitch.

Cropping

See [cropping.md](cropping.md) if needing to crop the visible rectangle of a component.

Video matting

For background removal, text behind a subject, background blur or replacement,
and effects applied only to a subject, read [video-matting.md](video-matting.md).
Generate reusable foreground layers with @remotion/video-matting before composing them.

Transitions

See [transitions.md](transitions.md) for scene transition patterns.

Motion blur

When adding motion blur or a movement trail, read [motion-blur.md](motion-blur.md) for <HtmlInCanvasMotionBlur>, transition motionBlur, Studio controls, and preview requirements.

Visual and pixel effects

When adding a visual effect, first identify the element or group it should affect.
If the target component supports effects and a built-in effect below matches the
request, prefer that effect over a CSS approximation. For example, apply
vignette() directly to a <Video>'s effects prop when the vignette should
affect that video.

These components accept effects directly:

Import fromComponents
remotion<Img>, <CanvasImage>, <AnimatedImage>, <Solid>, <HtmlInCanvas>
@remotion/media<Video>
@remotion/gif<Gif>
@remotion/rive<RemotionRiveCanvas>
@remotion/shapes<Arrow>, <Callout>, <Circle>, <Ellipse>, <Heart>, <Pie>, <Polygon>, <Rect>, <Spark>, <Star>, <Triangle>

Ordinary HTML elements, <Interactive.*> DOM wrappers, <AbsoluteFill>, and
<Sequence> do not accept effects directly. To apply effects to their content,
wrap them in <HtmlInCanvas> and put the effects prop on the wrapper.

For other elements, prefer regular HTML and CSS where suitable. Consider wrapping
a group in [`<HtmlInCanvas>`](html-in-canvas.md) when post-processing the whole
group is appropriate and the environment supports it.

Read [effects.md](effects.md) before applying an effect for imports, parameters,
and setup. It also covers reusable custom effects with createEffect() when no
built-in effect matches.

Available effects

Built-in effects from @remotion/effects:

  • Color and tone: brightness(), colorCorrection(), colorKey(), contrast(), curves(), duotone(), exposure(), grayscale(), hue(), invert(), levels(), linearGradient(), linearGradientTint(), lut(), saturation(), shadowsHighlights(), thermalVision(), tint(), vibrance(), whiteBalance().
  • Blur and trails: blur(), lightTrail(), linearProgressiveBlur(), radialProgressiveBlur(), regionBlur(), zoomBlur().
  • Lighting: dropShadow(), longShadows(), glow(), lightLeak(), shine(), starburst(), vignette().
  • Distortion and transforms: barrelDistortion(), chromaticAberration(), cornerPin(), fisheye(), mirror(), noiseDisplacement(), scale(), skew(), tile(), uvTranslate(), wave(), xyTranslate().
  • Textures and patterns: burlap(), checkerboard(), contourLines(), dotGrid(), emboss(), flannel(), gridlines(), halftone(), halftoneLinearGradient(), lines(), liquidContours(), noise(), paper(), pattern(), rings(), scanlines(), speckle(), tvSignalOff(), waves(), whiteNoise(), zigzag().
  • Edges: outline(), roughenEdges(), shrinkwrap(), tear().
  • Pixelation and transitions: evolve(), linearProgressivePixelate(), pixelate(), pixelDissolve(), radialProgressivePixelate(), venetianBlinds().
Color correction

Read [color-correction.md](color-correction.md) for primary adjustments with
colorCorrection(), tonal mapping with levels() or curves(), their Studio
editors, and 3D .cube color grades with lut().

3D content

See [./3d.md](./3d.md) for 3D content in Remotion using Three.js and React Three Fiber.

Sound effects

When needing to use sound effects, load the [./sfx.md](./sfx.md) file for more information.

Audio visualization

When needing to visualize audio (spectrum bars, waveforms, bass-reactive effects), load the [./audio-visualization.md](./audio-visualization.md) file for more information.

Maps

For static maps, animated routes and markers, geographic explainers, Mapbox, MapLibre, MapTiler, GeoJSON, or 3D geographic flyovers, load [Remotion Maps](./remotion-maps/REFERENCE.md).

Captions

When dealing with captions or subtitles, load the Remotion Captions (remotion-captions skill) skill for more information.

Arabic and right-to-left text

For Arabic, Persian, Urdu or Hebrew text, read [arabic-text.md](arabic-text.md): set the base direction, animate by word, and split letters only in a way that keeps them joined.

Google Fonts

Is the recommended way to load fonts in Remotion. See [google-fonts.md](google-fonts.md) for how to load Google Fonts.

Local fonts

See [local-fonts.md](local-fonts.md) for how to load local fonts.

GIFs

See [gifs.md](gifs.md) for how to display GIFs synchronized with Remotion's timeline.

Advanced Images

See [images.md](images.md) for sizing and positioning images, dynamic image paths, and getting image dimensions.

Lottie animations

See [lottie.md](lottie.md) for embedding Lottie animations in Remotion.

Timing

See [timing.md](timing.md) for more timing techniques for interpolate().

Parameterized videos

See [parameters.md](parameters.md) for making a composition parametrizable by adding a Zod schema.

Measuring DOM nodes

See [measuring-dom-nodes.md](measuring-dom-nodes.md) for measuring DOM element dimensions in Remotion.

Measuring text

See [measuring-text.md](measuring-text.md) for measuring text dimensions, fitting text to containers, and checking overflow.

Using FFmpeg

For some video operations, such as trimming videos or detecting silence, FFmpeg should be used. Load the [./ffmpeg.md](./ffmpeg.md) file for more information.

Silence detection

When needing to detect and trim silent segments from video or audio files, load the [./silence-detection.md](./silence-detection.md) file.

Dynamic duration, dimensions and data

See [calculate-metadata.md](calculate-metadata.md) for dynamically set composition duration, dimensions, and props.

Compositions and stills

Before registering <Composition> or <Still> elements, read [compositions.md](compositions.md) for source-editable registrations, folders, default props and nesting. For Studio navigation into a scene's own timeline, use [connected compositions](connected-compositions.md).

Advanced sequencing

See [sequencing.md](sequencing.md) for more sequencing patterns - delay, trim, limit duration of items.

Install modules

Use npx remotion add to add new packages with the right version:

npx remotion add @remotion/media

This goes for @remotion/* packages, mediabunny, @mediabunny/*, zod, and @huggingface/transformers.

Visual checks

Visual changes CAN be inspected in Remotion Studio (remotion-studio skill)
or rendered frames (remotion-render skill). Comparisons CAN include visible
layers, cut timing, and synchronized content across the full composition and
connected components.

Install
New

Remotion's official skill for captions in programmatic videos: it holds the agent to the @remotion/captions Caption type and routes it to guides for transcribing audio, rendering animated captions and importing .srt files.

New

Remotion's official skill for exporting a Remotion video: npx remotion render and still, input props, license keys and free-license renders, frame sequences and transparent video output.

Skill: video-shotcraft

by Vincent Wei

Featured

Agent skill that turns Claude Code or Codex into a motion-design studio: real page captures, 150 tested Remotion shots, beat-synced cuts and an editable MP4.

452 views 59 copies
Browse all skills →