Remotion Adds Pixel-Based Motion Blur to React Video Rendering

Remotion adds true multi-sample motion blur that works on any React element. You can add it with an AI agent prompt, a Studio button, or one wrapper component.

·
·
·
  • Remotion adds true motion blur for any React or HTML content in rendered video.
  • You can apply it with an agent prompt, a Studio "Motion blur" button, or the <HtmlInCanvasMotionBlur> wrapper.
  • It renders several in-between frames and averages their pixels using Chrome's HTML-in-Canvas API, so colors stay accurate.
  • shutterAngle sets exposure length and samples sets smoothness, which also adds render time.
  • Preview only works in Chrome, the component is still experimental, and the Claude and Codex plugins are out of date. Install the Agent Skills directly.
  • Free for teams of up to 3 people. Larger companies pay $25 per seat or $0.01 per render.

Remotion, the framework for rendering React components as video, has added experimental motion blur for HTML-based content. The new motion-blur documentation describes three ways to apply it: through an AI agent, in Remotion Studio, or with a JSX wrapper.

The feature samples several moments around each output frame and averages their pixels, reproducing the exposure effect of a camera shutter. That process reduces the strobing that makes fast browser-rendered animation resemble a sequence of sharp screenshots.

Sharp frames create strobing

A camera keeps its shutter open for part of each frame, so moving objects leave a visible smear during the exposure. Browser rendering captures one precise instant. Fast movement can therefore jump sharply between positions, especially at lower frame rates.

Remotion now labels its two older motion-blur options as “not recommended” because each carries a visual compromise:

  • <CameraMotionBlur> works in browsers without the new API, but its layered blending can alter colors and opacity.
  • <Trail> draws earlier positions behind the current one, producing a trail rather than a simulated camera exposure.

Chrome turns DOM elements into pixels

The new <HtmlInCanvasMotionBlur> component uses Chrome’s HTML-in-Canvas API. The API rasterizes live DOM elements into a canvas, allowing Remotion to blend captured pixels while preserving their rendered colors and transparency. Chrome describes the underlying feature in its launch post, and Remotion’s documentation says it is enabled by default in Chrome 157 and later.

According to the original pull request, the component renders its children at fractional frame positions around the current output frame. It captures each result in an HTML-in-canvas layout canvas, then averages the pixels into one image.

For an output frame with a 180-degree shutter and eight samples, the renderer captures eight moments across half a frame of exposure. The equivalent Python-like pseudocode is:

bash
def motion_blur(render, frame, shutter_angle=180, samples=8):
    exposure = shutter_angle / 360
    times = [
        frame - exposure / 2 + exposure * i / (samples - 1)
        for i in range(samples)
    ]
    images = [render(time) for time in times]
    return sum(images) / samples

Two controls set the exposure

Property Purpose Effect
shutterAngle Sets the exposure length as a fraction of one frame. 360° covers one frame, 180° covers half a frame, and 90° covers one quarter. At 30 fps, 180° corresponds to 1/60 second.
samples Sets the number of snapshots blended into each output frame. More samples produce a smoother result while increasing render work.

Three routes to the same wrapper

  1. AI agent: Install Remotion’s Agent Skills, reference an element, and run /remotion-markup Add motion blur to this.
  2. Remotion Studio: Select an element in the timeline and click Motion blur. Studio adds the wrapper and exposes the shutter angle and sample count in the sidebar.
  3. JSX: Wrap the animated content in <HtmlInCanvasMotionBlur> and provide its width and height.
javascript
const MovingBox = () => {
  const frame = useCurrentFrame();

  return (
    <div
      style={{transform: `translateX(${frame * 10}px)`}}
    />
  );
};

export const Scene = () => (
  <HtmlInCanvasMotionBlur
    width={1920}
    height={1080}
    samples={8}
    shutterAngle={180}
  >
    <MovingBox />
  </HtmlInCanvasMotionBlur>
);

The frame lookup has to occur inside a descendant of <HtmlInCanvasMotionBlur>, as shown above. Calling useCurrentFrame() in the component that creates the wrapper gives every sample the same time value, so the rendered image remains sharp.

Transitions have a separate integration available from Remotion v4.0.545. Passing a motionBlur prop to <TransitionSeries.Transition> enables blur for every built-in presentation, including slide-ins, whip pans, and scene changes.

Chrome sets the boundary

  • Previews require Chrome. Other browsers display the original unblurred content with a “Motion blur is not visible” notice. Remotion’s server-side renderer works without additional configuration.
  • Client-side renders require HTML-in-Canvas. A render containing motion blur can fail when the browser does not expose the API.
  • Nested canvases are unsupported. An HTML-in-canvas component cannot currently contain another one.
  • Custom transitions need compatible rendering. They must use HTML-in-canvas, and their enter and exit style properties cannot be combined with motion blur.
  • Render cost scales with samples. A setting of 16 samples requires roughly 16 component renders for every output frame.

Remotion v4.0.539 also had a first-frame failure when running the minimal example with npx remotion render. The fix has been merged, so projects using that release should upgrade to a version containing the patch.

Agent plugins lag the release

Remotion reported that its Claude and Codex plugins remained outdated while marketplace updates were under review. Agents installed through those plugin packages may lack instructions for the motion-blur API. Installing the current Agent Skills directly provides the updated guidance:

dockerfile
npx remotion skills add

# Outside a Remotion project:
npx skills add remotion-dev/skills

The skills support Claude Code, Codex, Cursor, Kimi Code, and OpenCode.

Samples drive compute cost

Motion blur carries no separate add-on fee under Remotion’s licensing model. Individuals and companies with fewer than four people can use Remotion for free. Companies with four or more people pay $25 per creator seat each month, while automated rendering costs $0.01 per render with a $100 monthly automation minimum.

The sample count does not change the per-render license charge, but it increases processing time. Cloud-rendering bills can rise accordingly because each output frame requires multiple component renders and pixel captures.

Fast movement gets the clearest benefit

Motion blur is most useful in product promos, animated titles, kinetic typography, sliding interface walkthroughs, map flyovers, whip pans, and other compositions with rapid movement. Prompt-to-video applications built on Remotion can also add it through an agent instruction rather than generating custom blending code.

Projects using <CameraMotionBlur> to handle fast animation can move to the new component with a small wrapper change, provided their preview and client-rendering environments support the required Chrome API. Scenes with little movement gain less from the effect and still incur the additional sampling cost.

Trending
  • No trending articles

Comments

avatar

Next Reads