1. ultrafast
  2. Compare
  3. vs Remotion

Compare

ultrafast vs Remotion.

Remotion renders React components in headless Chrome, one screenshot per frame. ultrafast renders a JSON document on the GPU. Both make video from code; they differ in speed, licence and what an agent can see.

At a glance

Side by side.

ultrafastRemotion
How a frame is madeGPU kernels compiled from the document; encoded on the same GPU with no readbacka React tree laid out in Chrome Headless Shell, screenshotted, encoded with FFmpeg
You writeone JSON document, checked before it rendersa React and TypeScript project
Output tokens for a 10 s shortabout 1,100, all of it the videoabout 5,500, most of it web code
Speed894 fps at 1080p with motion blur on one GPU; 11.6 s of 1080×1920 in about 2.2 s on one L4an 80 s video in 15 s on Lambda across up to 200 functions; a 1-minute example in 19 s
LicenceApache-2.0 or MIT, for everyonesource-available; a company licence from 4 people, counting all staff
Price to renderfree on your GPU$0.01 per render ($100/mo minimum) or $25 per seat per month, plus your AWS bill
Hosted renderingultrafast Cloud is coming soon (waitlist); uf serve on your own GPU todaynone; Lambda in your own AWS account
For agents20 MCP tools (local and remote), a skill, ChatGPT and Claude apps coming soon; frames come back as images13 Agent Skills, plugins for 5 coding agents, Studio WebMCP; the hosted MCP closed on 26 October 2026
Review of the resultreview reads every frame: unreadable, clipped, overlapping or too-brief text, text under app buttons, flashingno built-in review
Effects3D with image-based light and glass, raymarching, particles, fluid and feedback sims, Slang shaders, 19 blend modesThree.js through React Three Fiber, shaders, Lottie, motion blur
ExportH.264, HEVC and AV1 MP4; ProRes proxy to 4444 XQ; transparent ProRes 4444 and VP9 WebM; GIF; PNG and EXR sequences; sound alone. Any size, rendered sharp, and any frame rate; four quality levels from draft to masterH.264, H.265, VP8, VP9, AV1, ProRes, GIF, transparent video, image sequences, sound alone; --scale; CRF and bitrate, no quality levels

Speed

One GPU instead of 200 functions.

Remotion gets its speed by splitting a video across many Lambda functions. ultrafast renders the whole video on one GPU, faster than playback, so a short is done before a cold function starts.

ultrafast, measured

1080p, 6-sample blur, RTX 5090
894 fps
10 s hero, same GPU
0.34 s
11.6 s of 1080×1920, one L4
2.2 s
10 s vertical teaser, 3D
1.68 s
16 s launch film, 3D
4.88 s

Remotion's published figures: an 80 s video in 15 s; a 1-minute render in 19 s for $0.017 of AWS compute.

Tokens

A fifth of the tokens.

Output tokens an agent writes for a 10-second vertical short: footage, a title, three lines of detail, captions timed to each word, a grade and grain. In a web project most of them are web code. In an ultrafast document, every token describes the video.

  1. ultrafast 1,100
  2. Remotion 5,500

describes the video; web code around it: imports, components, styles, timeline set-up, project files

The same title, both ways.

The pottery teaser’s title, its letters rising in one by one.

ultrafast

clay.json: the title node
"title": {
  "op": "text",
  "params": {
    "text": "Spin something new.",
    "font": "ultrafast:display", "weight": 300, "size": 176,
    "color": "#f1e8dc", "position": [80, 380], "valign": "baseline",
    "width": 880, "line_height": 0.9, "tracking": -3,
    "stagger": 0.03,
    "glyph_opacity": { "keys": [
      { "t": 0.7, "v": [0], "ease": "in_out_sine" },
      { "t": 1.5, "v": [1] } ] },
    "glyph_offset": { "keys": [
      { "t": 0.7, "v": [0, 56],
        "ease": { "bezier": [0.16, 1, 0.3, 1] } },
      { "t": 1.8, "v": [0, 0] } ] }
  }
}

Remotion

Title.tsx
import {AbsoluteFill, Easing, interpolate, useCurrentFrame,
  useVideoConfig} from 'remotion';
import {loadFont} from '@remotion/google-fonts/Fraunces';

const {fontFamily} = loadFont('normal', {weights: ['300']});
const TEXT = 'Spin something new.';
const clamp = {
  extrapolateLeft: 'clamp', extrapolateRight: 'clamp',
} as const;

export const Title: React.FC = () => {
  const frame = useCurrentFrame();
  const {fps} = useVideoConfig();
  let n = 0;
  return (
    <AbsoluteFill>
      <h1 style={{
        position: 'absolute', left: 80, top: 222, width: 880,
        margin: 0, fontFamily, fontWeight: 300, fontSize: 176,
        lineHeight: 0.9, letterSpacing: -3, color: '#f1e8dc',
      }}>
        {TEXT.split(' ').map((word, w) => (
          <span key={w} style={{display: 'inline-block'}}>
            {[...word, '\u00a0'].map((ch, c) => {
              const t = frame / fps - 0.7 - 0.03 * n++;
              const opacity = interpolate(t, [0, 0.8], [0, 1], {
                ...clamp, easing: Easing.inOut(Easing.sin),
              });
              const y = interpolate(t, [0, 1.1], [56, 0], {
                ...clamp, easing: Easing.bezier(0.16, 1, 0.3, 1),
              });
              return (
                <span key={c} style={{
                  display: 'inline-block', opacity,
                  transform: `translateY(${y}px)`,
                }}>{ch}</span>
              );
            })}
          </span>
        ))}
      </h1>
    </AbsoluteFill>
  );
};

The rest of the gap is project files such as Root.tsx and package.json, and the effects: grain, a grade and captions timed to each word are a component each in Remotion and one node each in ultrafast.

Licence and cost

No company licence.

Remotion is free for individuals and organisations of up to 3 people. At 4, counting everyone in the company whether they touch video or not, it needs a company licence. ultrafast is Apache-2.0 or MIT for everyone. Tokens at $20 per million output tokens.

10,000 ten-second shorts a monthto write themto render them
ultrafast on your GPUsabout $220 in output tokens$0 in licences
Remotion, Automators licenceabout $1,100 in output tokens$100 in render fees, plus Lambda compute in your AWS account

For agents

An agent that can see what it made.

A Remotion agent writes React and renders it; a person finds out what went wrong. An ultrafast agent checks the document, looks at contact sheets, and fixes what review reports before you watch.

Write

JSON with a published schema and uf ops for every param. No project, no build, no node_modules.

Check and look

check before rendering; frames and contact sheets returned as images; inspect names the node behind a pixel.

Review and fix

review reads every frame for unreadable, clipped or too-brief text and flashing. The agent edits one node and renders again in under a second.

Choose ultrafast when

  • An agent makes the videos and should review them.
  • You render often enough that per-render fees, Lambda bills and model tokens add up.
  • You need 3D, simulation or shader work alongside captions and footage.
  • Your company has more than 3 people and wants a permissive licence.

Choose Remotion when

  • Your video is built from React components you already have.
  • You need Remotion's embeddable web Player.
  • You want the largest community: 74,000 GitHub stars.

Questions

Common questions.

Is ultrafast free for companies?

Yes, at any size. The engine is Apache-2.0 or MIT. Remotion requires a company licence once an organisation has 4 or more people: $0.01 per render with a $100 monthly minimum, or $25 per seat per month.

Can ultrafast render my Remotion project?

Not directly: it doesn't run React. Ask your agent to rewrite the composition as an ultrafast document, or run uf reconstruct on a finished render to get an editable draft.

Does ultrafast need a GPU?

Yes, for now: a Mac with Apple silicon or a Vulkan GPU. ultrafast Cloud, which renders on ours, is coming soon (waitlist).

Does ultrafast have an embeddable web player like Remotion's?

No. ultrafast's live player is a desktop window for authoring. For the web, export an MP4.

How many tokens does an agent spend on a Remotion video?

About 5,500 output tokens for a 10-second short: the composition, its components, styles and project files. The same short as an ultrafast document is about 1,100. At $20 per million output tokens, 10,000 shorts cost about $1,100 to write in Remotion and $220 in ultrafast.

Remotion facts from its docs, checked 21 November 2026: pricing, team size, Lambda, cost example, MCP, skills, plugins. Remotion is a trademark of its owner.

Make one and time it.

Install the engine and time a render on your own GPU.

Read the quickstart

Want it hosted? Join the ultrafast Cloud waitlist.