Up to 50% off yearly plansSee yearly prices

Remotion Tutorial:
Make Your First Video with React, Step by Step

Updated · 8 min read

Remotion makes video from React components. This tutorial builds one short video by hand, using only commands and APIs from Remotion's own documentation, then shows the shorter route through Claude Code. We ran every step below on Remotion 4.0.543 in November 2026. Each step stands on its own, so skip to the one you need.

What do you need before you start?

You need a current Node.js, a code editor and, on a Mac, macOS 15 or later. Remotion's installation page sets the floor at Node 16 or Bun 1.0.3, asks for glibc 2.35 or later on Linux, and says Alpine Linux and nixOS are not supported. The templates ask for more: the Hello World template's package.json declares Node ^20.19.0 || ^22.13.0 || >=24, so install a current LTS release.

Plan for disk space as well. When we set up Remotion for AdAnt's Remotion Video skill, each project needed about 900 MB: the npm packages, a headless Chrome download and the bundler cache left by the first render. All of it stays in the project's node_modules.

Check the license before you use Remotion at work. It is free for individuals, companies of up to 3 people, non-profits and anyone still evaluating it; other companies need a paid Company License. Remotion pricing covers who pays and how much.

You don't need to be a React expert, but every step below is React code: components, props and inline styles. If you would rather describe the video and let an agent write that code, jump to the Claude Code section near the end.

Step 1: How do you create a Remotion project?

Run Remotion's project creator with the Hello World template, then start Remotion Studio.

Bash
npx create-video@latest --yes --hello-world my-video
cd my-video
npm run dev

The first command copies the template into my-video and installs its npm packages. --yes skips every prompt, so it needs a template flag and a folder name, and it fails inside an existing Git repository. npm run dev starts Remotion Studio, the local preview where you watch each composition and start renders from a Render button.

Remotion recommends Hello World for a first project without a coding agent, because it already moves. The blank template, by contrast, renders an empty video until you add content; it is the better start when an agent will write the code. Running npx create-video@latest with no flag opens a wizard instead, which asks for a package manager, a template and whether to install Agent Skills.

Two files matter from the start:

  • src/index.ts is the entry point. It calls registerRoot() once, and the CLI looks for it there by default.
  • src/Root.tsx is the root component. It lists every composition the project can render.

Remotion keeps registerRoot() in its own file on purpose: fast refresh re-runs the file you edit, and the root must be registered only once. The template's src/Root.tsx registers three demo compositions; the next two steps replace them with one of your own.

Step 2: How does a Remotion composition work?

A composition is a React component plus four values: width, height, durationInFrames and fps. Register it in src/Root.tsx with <Composition>, and it appears in the Studio's list and can be rendered. Replace the template's src/Root.tsx with this; Step 3 creates the MyComposition component it imports.

Tsx
import {Composition} from 'remotion';
import {MyComposition} from './MyComposition';

export const RemotionRoot: React.FC = () => {
  return (
    <>
      <Composition id="MyComposition" component={MyComposition} durationInFrames={150} fps={30} width={1920} height={1080} />
      <Composition id="MyCompositionPortrait" component={MyComposition} durationInFrames={150} fps={30} width={1080} height={1920} />
    </>
  );
};

That is Remotion's own pattern: one component, registered twice, gives a landscape video and a portrait one for TikTok or Reels. At 30 fps, 150 frames is five seconds. A video's first frame is 0 and its last is durationInFrames - 1.

Inside a component, useVideoConfig() returns the same four values, so the code can size and time itself from the composition rather than from numbers typed twice.

To feed a composition data, give it defaultProps. They must be plain JSON-serializable values, and both the Studio's props editor and the --props flag at render time can override them. That is how one template becomes one video per customer, city or language.

Step 3: How do you animate with useCurrentFrame, interpolate and spring?

Every frame is your component rendered at one frame number: read it with useCurrentFrame() and compute every moving value from it. Save this as src/MyComposition.tsx:

Tsx
import {AbsoluteFill, interpolate, spring, useCurrentFrame, useVideoConfig} from 'remotion';

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

  const opacity = interpolate(frame, [0, 2 * fps], [0, 1], {
    extrapolateLeft: 'clamp',
    extrapolateRight: 'clamp',
  });
  const scale = spring({frame, fps});

  return (
    <AbsoluteFill style={{justifyContent: 'center', alignItems: 'center', backgroundColor: 'white'}}>
      <div style={{fontSize: 80, opacity, transform: `scale(${scale})`}}>Hello World!</div>
    </AbsoluteFill>
  );
};

interpolate() maps one range onto another: here, frames 0 to two seconds onto opacity 0 to 1, with clamp holding the value at 1 afterwards. Add an easing option, such as Easing.bezier(0.42, 0, 0.58, 1), to curve it.

spring() is a physics animation that runs from 0 to 1 by default and may overshoot a little before it settles. Raise damping in its config option (default 10) to remove the bounce, and pass frame - 20 instead of frame to start it 20 frames later.

The one rule that keeps renders exact: never animate with anything that is not the frame number. Remotion's docs warn that CSS transitions cause flickering, and our own skill adds useState, setTimeout and Math.random, because frames may render out of order and in parallel.

Step 4: How do you add video, audio and timing?

Add @remotion/media, put your files in the public folder, and use its <Video> and <Audio> with staticFile().

Bash
npx remotion add @remotion/media

npx remotion add installs a Remotion package at the same version as your other Remotion packages, so the whole project stays on one release.

Tsx
import {Audio, Video} from '@remotion/media';
import {staticFile} from 'remotion';

export const MyComposition = () => (
  <>
    <Video src={staticFile('video.mp4')} />
    <Audio src={staticFile('music.mp3')} volume={0.2} loop />
  </>
);

This plays a video with quieter, looping background music. The video's own sound is included; add muted to the <Video> to hear only the music. A remote URL works as src too, if its server allows cross-origin requests. Remotion recommends these tags for new projects; the older media tags in the remotion package remain for fallback cases.

To place anything in time, use the timing props that Remotion's components share, <Audio>, <Video> and <AbsoluteFill> among them:

  • from moves an item along the timeline.
  • durationInFrames sets how long it shows.
  • trimBefore cuts the start of its own content.
Tsx
<Audio from={30} durationInFrames={90} src={staticFile('audio.mp3')} />

That clip starts at frame 30 and lasts 90 frames. Children of a timed component count their own frames from 0: inside an AbsoluteFill with from={30}, useCurrentFrame() returns 10 at frame 40 of the video. You will see <Sequence> doing the same job in older code; Remotion's docs now say using it directly is no longer recommended, though it still works.

Step 5: How do you render the video to MP4?

Run npx remotion render with the composition's ID, and the video lands in the out folder as an H.264 MP4, here out/MyComposition.mp4.

Bash
npx remotion render MyComposition

Without --codec, Remotion uses the H.264 encoder. Leave out the ID and it asks you to pick one, but only in an interactive terminal; in CI or any other non-interactive shell the command fails, so always pass the ID in scripts. You can also render from the Studio's Render button.

Pass data with --props, as a JSON string or a path to a JSON file:

Bash
npx remotion render MyComposition --props=./props.json

Remotion notes that inline JSON breaks on Windows shells, so a file is the safer habit.

Render stills before the full video. They take seconds and catch most mistakes:

Bash
npx remotion still MyComposition out/check.png --frame=45

By default still renders frame 0 as a PNG; --frame picks another. Frame 45 is 1.5 seconds in, so the text should be at three-quarters opacity. One check worth copying from our own work: render the same frame twice and compare the files. On Remotion 4.0.541 ours came out byte-identical, which shows the video depends only on the frame number; this tutorial's frame 45 did the same on 4.0.543.

How do you make the same video with Claude Code?

Start from the blank template, add Remotion's Agent Skills, keep the Studio running, and describe the video to Claude Code in a second terminal. Remotion's coding-agents page gives these steps:

  1. npx create-video --yes --blank my-video
  2. cd my-video
  3. npx remotion skills add
  4. npm run dev
  5. In a second terminal, in the same folder, run claude and describe the video.

The skills teach the agent Remotion's rules. /remotion-best-practices covers all of them, /remotion-render starts a render, and /remotion-license looks up the license terms. Remotion also publishes a Claude Code plugin: claude plugin marketplace add remotion-dev/claude-code-plugin, then claude plugin install remotion@remotion, restart Claude Code, and start with /remotion:remotion-create followed by your prompt.

The agent writes the same compositions, interpolate() calls and springs as the steps above, so reading them is still how you fix the timing or the text. AdAnt, an AI social media marketing team, publishes a free Remotion Video skill for this route: it states Remotion's license terms first, installs one pinned version and includes the source of a split-flap board film. Remotion with AI covers the agent route in more depth.

Which Remotion commands does this tutorial use?

CommandWhat it does
npx create-video@latest --yes --hello-world my-videoCreates a project from the Hello World template
npx create-video --yes --blank my-videoCreates a blank project, the start for a coding agent
npm run devStarts Remotion Studio
npx remotion add @remotion/mediaAdds a Remotion package at your Remotion version
npx remotion skills addInstalls Remotion's Agent Skills
npx remotion still <id> out.pngRenders one frame as an image
npx remotion render <id>Renders the video, H.264 MP4 by default, into out

Once a render works on your machine, the next questions are usually where to render at scale and what to build. Remotion Lambda covers rendering on AWS, and Remotion examples walks through finished projects and the techniques behind them.

Frequently asked questions

Do I need to know React to learn Remotion?

It helps. A Remotion video is React components with props and inline styles, so basic React is enough to follow every step here. With a coding agent you can get a first video without writing code, but you will read React to fix its timing and text.

Why does my Remotion video flicker when it renders?

Usually because something moves without being driven by useCurrentFrame(), such as a CSS transition or animation. Remotion's docs warn about exactly this. Compute every moving value from the frame number with interpolate() or spring() instead.

How do I make a vertical video for TikTok or Reels in Remotion?

Register a second composition for the same component with width 1080 and height 1920. Remotion's own example does this, so one component renders both a landscape and a portrait version.

Is Remotion free to learn?

Yes. Remotion's license lets anyone evaluate it before using it commercially, and it stays free for individuals, companies of up to 3 people and non-profits. Larger companies need a paid Company License once they use it for real work.

Should I still use Sequence in Remotion?

It still works, and older code uses it everywhere. Remotion's docs now say using Sequence directly is no longer recommended, and put the same timing props (from, durationInFrames, trimBefore) on its components instead.

The studio dispatch

One useful idea on AI-made ads, every other week. No fluff.