Communitygithub.com

bardu-rgb/reels

Best Practices für Content, Animation und Effekte in Remotion

Was ist reels?

Diese Skill-Richtlinie definiert die Best Practices für die Erstellung von Remotion React Markup, mit besonderem Fokus auf Animationen, Effekte und Inhalte. Sie wird von KI-Assistenten wie Claude Code, Cursor und Codex genutzt, um sicherzustellen, dass generierte Remotion-Kompositionen effizient, editierbar und konsistent sind. Die Richtlinie umfasst essentielle Regeln zur Nutzung von `interpolate()` anstelle von CSS-Transitions, zur korrekten Verwendung von `useVideoConfig()` und `useCurrentFrame()`, sowie zur Inline-Kodierung von Keyframes für die Studio-Bearbeitung. Sie behandelt Medienkomponenten wie `<Video>`, `<Audio>`, `<CanvasImage>` und `<AnimatedImage>`, sowie fortgeschrittene Themen wie interaktive Komponenten mit `Interactive.withSchema({wrapInSequence: true})`, Multi-Szene-Videos, Connected Compositions, Untertitel, 3D-Inhalte, Karten, Textannotationen, Audio-Visualisierung, Soundeffekte und Motion Blur. Die Skill-Beschreibung ist plattformunabhängig und dient als umfassende Referenz für die professionelle Remotion-Entwicklung.

Funktioniert mit~Claude Code~Codex CLI~Cursor
npx skills add https://github.com/bardu-rgb/reels/tree/HEAD/.agents/skills/remotion-markup

In Ihrer bevorzugten KI fragen

Öffnet einen neuen Chat, in dem dieser Agent-Skill bereits geladen ist.

Vorschau

Aus dem Skill-README

Dokumentation

Das ist eine Anleitung zum Schreiben von Remotion React Markup. Wenn dies nicht relevant ist, lade stattdessen die Remotion Best Practices.

Benutzeränderungen bewahren

Benutzer können außerhalb des Gesprächs Änderungen am Code vornehmen.

Wenn du eine überraschende Änderung bemerkst, die in der Zwischenzeit vorgenommen wurde, überschreibe sie nicht, sondern gehe davon aus, dass sie beabsichtigt war, oder frage nach Bestätigung.

Allgemeine Regeln

Innerhalb einer Composition oder einer Szenenkomponente erhältst du fps aus useVideoConfig() für alle Sekunden-zu-Frames-Berechnungen, einschließlich Timing-Props wie from, trimBefore, durationInFrames und premountFor. Wenn der Ausdruck auf dem JSX-Knoten bleibt, z. B. trimBefore={4 * fps}, kann das Studio das Timing bearbeiten und es bleibt korrekt, wenn sich die Bildrate der Composition ändert.

Treibe Animationen mit useCurrentFrame() und interpolate() an. CSS transition oder animation werden nicht korrekt gerendert, sie müssen umgestaltet werden. Tailwind-Animation-Klassen werden nicht korrekt gerendert, sie müssen umgestaltet werden.

Verwende Easing.bezier() und Easing.spring(), um das Timing anzupassen.

Strukturiere dein Markup gemäß den Remotion Interactivity Best Practices. Bevorzuge Interactive.withSchema({wrapInSequence: true}) für benutzerdefinierte visuelle Komponenten mit editierbaren Props und registriere wiederverwendbare Szenen als Connected Compositions. Setze Timing direkt auf Komponenten, die es unterstützen; vermeide redundante <Sequence>-Wrapper. Gib jeder zeitgesteuerten Komponente, die premountFor unterstützt, eine Sekunde Vorlauf: premountFor={fps}, wobei fps aus useVideoConfig() kommt. Wende dies auf Medien, interaktive Komponenten, <Sequence>, <Series.Sequence>, <TransitionSeries.Sequence> und <TransitionSeries.Overlay> an, einschließlich zeitgesteuerter Komponenten, die in Szenen verschachtelt sind. Mounte auch das übergeordnete Timeline-Element vor, wenn ein verschachteltes Element gemountet werden muss, bevor das übergeordnete Element startet. Eine Komponente ohne premountFor, wie z. B. <TransitionSeries.Transition>, benötigt keinen Ersatz.

Das Studio bearbeitet den JSX-Quellknoten, der ein Element erstellt hat. Erstelle jede Composition-Registrierung, jeden Clip, jede Szene, jede Ebene und jede Sequenz, die unabhängig voneinander bearbeitet werden können soll, als eigenen JSX-Knoten mit seinen editierbaren Props inline. Programmgesteuerte Schleifen sind geeignet, wenn die generierten Instanzen absichtlich als eine Quellvorlage gesteuert werden, nicht wenn Benutzer die Instanzen separat bearbeiten müssen.

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

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

  return (
    <Interactive.Div
      name="Title"
      premountFor={fps}
      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>
  );
};

Behalte den interpolate()-Aufruf inline im style-Prop. Verwende die CSS-Eigenschaften scale, translate, rotate anstelle von transform.

// 👍 Inline editierbare Keyframes und Transform-Kurzformen
style={{
  scale: interpolate(frame, [0, 100], [0, 1], {
    extrapolateLeft: 'clamp',
    extrapolateRight: 'clamp',
    easing: Easing.spring({damping: 200}),
    output: 'perceptual-scale' // Verwende für `scale`-Animationen "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}),
  }),
}}

// 👎 Nicht-inline Werte und Transform-Strings werden im Studio schwerer zu bearbeiten
const scale = interpolate(frame, [0, 100], [0, 1]);

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

Assets

Lege Assets im public/-Ordner im Stammverzeichnis deines Projekts ab. Verwende staticFile(), um auf Dateien aus dem public/-Ordner zu verweisen.

Medienkomponenten

Füge Video und Audio mit <Video> und <Audio> aus @remotion/media hinzu. Füge Bilder mit der <CanvasImage>-Komponente hinzu. Füge animierte GIFs, APNG-, WebP- oder AVIF-Bilder mit <AnimatedImage> hinzu; verwende @remotion/gif, wenn du nicht Chrome verwendest. Verwende staticFile() für Dateien in public/ oder übergib direkt eine Remote-URL:

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

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

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

Wenn die Composition hauptsächlich eine Timeline von Video- oder Audioclips ist, lies video-editing.md, bevor du ihre Quellstruktur wählst.

Beispielszene

Ein Hintergrundvideo mit einem unteren Drittel. Das untere Drittel ist eine interaktive Komponente mit eigener Timeline, registriert als Connected Composition. Sein Text wird als children übergeben und accentColor ist ein editierbares Prop. Die Einblendung ist inline am Aufrufort keyframed.

// MyScene.tsx
import { Video } from "@remotion/media";
import { Easing, interpolate, useCurrentFrame, useVideoConfig } from "remotion";
import { LowerThird } from "./LowerThird";

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

  return (
    <>
      <Video
        name="Background"
        src="https://remotion.media/video.mp4"
        premountFor={fps}
        objectFit="cover"
        style={{
          position: "absolute",
          width: "100%",
          height: "100%",
        }}
      />
      <LowerThird
        name="Lower third"
        from={1 * fps}
        premountFor={fps}
        accentColor="#0b84f3"
        style={{
          opacity: interpolate(frame, [1 * fps, 2 * fps], [0, 1], {
            extrapolateRight: "clamp",
            extrapolateLeft: "clamp",
            easing: Easing.bezier(0.16, 1, 0.3, 1),
          }),
        }}
      >
        Jane Doe, Produktdesignerin
      </LowerThird>
    </>
  );
};
// LowerThird.tsx
import type React from "react";
import { Interactive, type InteractivitySchema } from "remotion";

type LowerThirdProps = {
  readonly children: string;
  readonly accentColor: string;
  readonly style?: React.CSSProperties;
};

const LowerThirdInner: React.FC<LowerThirdProps> = ({
  children,
  accentColor,
  style,
}) => {
  return (
    <Interactive.Div
      style={{
        position: "absolute",
        left: 80,
        bottom: 80,
        display: "flex",
        alignItems: "center",
        gap: 20,
        backgroundColor: "white",
        borderRadius: 16,
        padding: "20px 32px",
        color: "black",
        fontFamily: "Helvetica, Arial, sans-serif",
        fontSize: 48,
        fontWeight: 600,
        ...style,
      }}
    >
      <div
        style={{
          width: 8,
          alignSelf: "stretch",
          borderRadius: 4,
          backgroundColor: accentColor,
        }}
      />
      {children}
    </Interactive.Div>
  );
};

const lowerThirdSchema = {
  children: { type: "text-content", default: "", description: "Text" },
  accentColor: {
    type: "color",
    default: "#0b84f3",
    description: "Akzentfarbe",
  },
} as const satisfies InteractivitySchema;

export const LowerThird = Interactive.withSchema({
  Component: LowerThirdInner,
  componentName: "<LowerThird>",
  schema: lowerThirdSchema,
  wrapInSequence: true,
});
// Root.tsx
import { Composition } from "remotion";
import { LowerThird } from "./LowerThird";
import { MyScene } from "./MyScene";

export const RemotionRoot: React.FC = () => {
  return (
    <>
      <Composition
        id="MyScene"
        component={MyScene}
        durationInFrames={60}
        fps={30}
        width={1280}
        height={720}
      />
      <Composition
        id="LowerThird"
        component={LowerThird}
        durationInFrames={30}
        fps={30}
        width={1280}
        height={720}
        defaultProps={{
          children: "Jane Doe, Produktdesignerin",
          accentColor: "#0b84f3",
        }}
      />
    </>
  );
};

Verzögerung, Trimmen

Setze Timing direkt auf Komponenten, die es unterstützen. Siehe Timing Props für die unterstützten Props, Beispiele und die Reihenfolge der Operationen.

Karten

Siehe Remotion Maps, wenn du Karten in das Video einfügen möchtest.

Text-Highlights und Annotationen

Siehe text-highlights.md für Text-Highlights (Highlight-Marker), Kreise, Unterstreichungen, Durchstreichungen, durchgestrichenen Text, Boxen.

Multi-Szene-Videos

Siehe multi-scene-video.md, wenn du ein Video mit mehreren aufeinanderfolgenden Szenen erstellen möchtest.

Connected Compositions

Wenn eine Szene oder eine Gruppe von Ebenen eine eigene bearbeitbare Timeline verdient, folge connected-compositions.md. Bevorzuge diese Struktur für umfangreiche Szenen in einem Multi-Szene-Video.

Pre-Compose-Aktion

Für eine Studio-Anfrage wie Pre-compose Ambient glow (src/BarChart.tsx:134), finde das ausgewählte Sequenz-Markup an der angegebenen Stelle. Erstelle eine Connected Composition gemäß connected-compositions.md: extrahiere das Markup in eine benannte Komponente, mache sie vorzugsweise interaktiv mit Interactive.withSchema({wrapInSequence: true}) und registriere dieselbe exportierte Komponentenreferenz mit einer eindeutigen <Composition> im Root. Rendere die interaktive Komponente direkt mit ihren Timing-Props oder als einziges Kind einer Sequenz, wenn dieser Wrapper einen Zweck hat. Wenn der ausgewählte Knoten bereits eine Sequenz ist, behalte ihre Props und extrahiere ihre Kinder. Die Registrierung benötigt Abmessungen, fps, Dauer und defaultProps äquivalent zur Elternverwendung. Eine Komponentenextraktion ohne registrierte Composition erfüllt eine Pre-Compose-Anfrage nicht.

Übernimm geerbte Stile wie fontFamily und Schriftart-Laden in die extrahierte Komponente; siehe Parent Independence.

Voiceover

Siehe voiceover.md zum Hinzufügen eines KI-generierten Voiceovers zu Remotion-Kompositionen mit ElevenLabs TTS.

Videos einbetten

Siehe embedding-videos.md für fortgeschrittenes Wissen zum Einbetten von Videos – Trimmen, Lautstärke, Geschwindigkeit, Schleifen, Tonhöhe.

Audio einbetten

Siehe audio.md für erweiterte Audiofunktionen wie Trimmen, Lautstärke, Geschwindigkeit, Tonhöhe.

Zuschneiden

Siehe cropping.md, wenn du das sichtbare Rechteck einer Komponente zuschneiden musst.

Übergänge

Siehe transitions.md für Szenenübergangsmuster.

Bewegungsunschärfe

Wenn du Bewegungsunschärfe oder eine Bewegungsspur hinzufügst, lies motion-blur.md für den bevorzugten HTML-in-Canvas-Ansatz, Vorschauanforderungen und Alternativen.

Visuelle und Pixeleffekte

Wenn du einen visuellen Effekt erstellst, überlege, ob er mit CSS und HTML umsetzbar ist oder ob ein Shader benötigt wird. Reihenfolge der Präferenz:

  1. Normales HTML + CSS oder andere Web-Techniken

  2. Ein Effekt, der direkt auf das Element angewendet wird (<Video>, <Img>), oder durch Umwickeln des Inhalts in <HtmlInCanvas>, das auch effects akzeptiert:

    • Ein aufgelisteter Effekt via effects.md
    • Ein benutzerdefinierter createEffect() via effects.md, wenn kein voreingestellter Effekt verfügbar ist.

3D-Inhalte

Siehe ./3d.md für 3D-Inhalte in Remotion mit Three.js und React Three Fiber.

Soundeffekte

Wenn du Soundeffekte verwenden musst, lade die Datei ./sfx.md für weitere Informationen.

Audio-Visualisierung

Wenn du Audio visualisieren musst (Spektrum-Balken, Wellenformen, bassreaktive Effekte), lade die Datei ./audio-visualization.md für weitere Informationen.

Karten

Für statische Karten, animierte Routen und Marker, geografische Erklärungen, Mapbox, MapLibre, MapTiler, GeoJSON oder 3D-geografische Überflüge, lade Remotion Maps.

Untertitel

Wenn du mit Untertiteln oder Bildunterschriften arbeitest, lade den Remotion Captions Skill für weitere Informationen.

Google Fonts

Ist der empfohlene Weg, um Schriftarten in Remotion zu laden. Siehe google-fonts.md für das Laden von Google Fonts.

Lokale Schriftarten

Siehe local-fonts.md für das Laden lokaler Schriftarten.

GIFs

Siehe gifs.md zur Anzeige von GIFs, die mit der Timeline von Remotion synchronisiert sind.

Erweiterte Bilder

Siehe images.md für die Größenanpassung und Positionierung von Bildern, dynamische Bildpfade und das Abrufen von Bildabmessungen.

Lottie-Animationen

Siehe lottie.md zum Einbetten von Lottie-Animationen in Remotion.

Timing

Siehe timing.md für weitere Timing-Techniken für interpolate().

Parametrisierte Videos

Siehe parameters.md, um eine Composition durch Hinzufügen eines Zod-Schemas parametrisierbar zu machen.

Messen von DOM-Knoten

Siehe measuring-dom-nodes.md zum Messen von DOM-Elementabmessungen in Remotion.

Messen von Text

Siehe measuring-text.md zum Messen von Textabmessungen, Anpassen von Text an Container und Überprüfen auf Überlauf.

Verwendung von FFmpeg

Für einige Videooperationen, wie das Trimmen von Videos oder die Erkennung von Stille, sollte FFmpeg verwendet werden. Lade die Datei ./ffmpeg.md für weitere Informationen.

Stille-Erkennung

Wenn du stille Segmente aus Video- oder Audiodateien erkennen und trimmen musst, lade die Datei ./silence-detection.md.

Dynamische Dauer, Abmessungen und Daten

Siehe calculate-metadata.md zum dynamischen Setzen der Composition-Dauer, -Abmessungen und -Metadaten.

Verwendung von React im Kopf

Siehe using-react-in-head.md für das Rendern von React-Komponenten im <head>.

OffthreadVideo

Siehe offthread-video.md für das Abspielen von Videos in einem separaten Thread.

NoReact API

Siehe no-react-sdk.md zum programmgesteuerten Rendern von Remotion-Videos ohne React.

Eingabe-Props

Siehe input-props.md zum Übergeben von Daten an eine Remotion-Komposition.

Lambda

Siehe lambda.md zum Rendern von Remotion-Videos in der Cloud mit AWS Lambda.

Skalieren des Canvas

Um die Größe des Canvas innerhalb der Composition anzupassen (z. B. für die Erstellung von Instagram-Storys), setze den <Composition>-Canvas auf 1080×1920 und verwende scaleToFill() in der Komponente.

Individual skills in this repo

This repo contains 5 individual skills — each has its own dedicated page.

Verwandte Skills