Communitygithub.com

tinh2/skills-hub-registry

Erstelle programmatisch Videos mit Remotion (React). Deckt Kompositionen, Animationen, Sequenzierung, Übergänge, Audio-/Video-Einbettung, Spring-Physik, Textanimationen, Sprachausgabe mit ElevenLabs TTS, FFmpeg-Integration, Untertitel, 3D mit Three.js, Diagramme und Rendering ab. Basierend auf offiziellen Remotion Best Practices.

Was ist skills-hub-registry?

Diese Fähigkeit ermöglicht es einem KI-Agenten, programmatisch Videos mit Remotion zu erstellen, einer React-basierten Bibliothek zur Videoproduktion. Sie umfasst umfassende Anleitungen zum Einrichten von Projekten, Definieren von Kompositionen mit `<Composition>`, Erstellen von Animationen mit `useCurrentFrame()` und `interpolate()` sowie zur Verwendung von Federn (`spring`) für natürliche Bewegungen. Die Fähigkeit behandelt fortgeschrittene Themen wie Sequenzierung mit `<Sequence>` und `<Series>`, das Hinzufügen von Übergängen mit dem `@remotion/transitions`-Paket, die Einbettung von Audio und Video (einschließlich OffthreadVideo für bessere Leistung) und die dynamische Steuerung von Abspielgeschwindigkeit und Lautstärke. Besonders hervorzuheben ist die Integration von ElevenLabs TTS zur Sprachsynthese, wobei `calculateMetadata` zur dynamischen Anpassung der Videolänge verwendet wird. Es werden auch Best Practices für die Einbindung von Assets, die Verwendung von FFmpeg und das Rendern von Videos in verschiedenen Formaten abgedeckt. Die Fähigkeit basiert auf offiziellen Remotion-Richtlinien und stellt sicher, dass alle Animationen korrekt über Frames gerendert werden, ohne auf CSS- oder Tailwind-Animationen zurückzugreifen.

Funktioniert mit✓Claude Code~Codex CLI✓Cursor
npx skills add https://github.com/tinh2/skills-hub-registry/tree/HEAD/build/remotion

In Ihrer bevorzugten KI fragen

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

Dokumentation

Remotion – Videoerstellung in React

Verwende diese Fähigkeit bei der Arbeit mit Remotion-Code. Remotion ermöglicht es dir, Videos programmatisch mit React-Komponenten zu erstellen.

Projekteinrichtung

npx create-video@latest mein-video
cd mein-video
npm start        # Vorschau im Browser
npm run render   # Rendern zu MP4

Kompositionen

Eine <Composition> definiert ein renderbares Video mit Abmessungen, fps und Dauer.

import { Composition } from "remotion";
import { MyVideo } from "./MyVideo";

export const RemotionRoot = () => (
  <Composition
    id="MyVideo"
    component={MyVideo}
    durationInFrames={300}
    fps={30}
    width={1920}
    height={1080}
    defaultProps={{ title: "Hallo Welt" } satisfies MyVideoProps}
  />
);

Verwende type-Deklarationen für Props (nicht interface) für Typsicherheit bei defaultProps.

Verwende <Folder>, um Kompositionen in der Seitenleiste zu organisieren. Verwende <Still> für Einzelbildausgaben (Thumbnails, OG-Bilder).

Animationen

Alle Animationen MÜSSEN useCurrentFrame() verwenden. CSS-Übergänge und Tailwind-Animationsklassen sind VERBOTEN – sie werden nicht korrekt gerendert.

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

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

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

  return <div style={{ opacity }}>Hallo Welt!</div>;
};

Feder-Animationen (Springs)

Federn erzeugen natürliche Bewegungen. Sie animieren von 0 bis 1.

import { spring, useCurrentFrame, useVideoConfig } from "remotion";

const frame = useCurrentFrame();
const { fps } = useVideoConfig();

const scale = spring({ frame, fps });
// Mit Konfiguration:
const smooth = spring({ frame, fps, config: { damping: 200 } }); // Kein Hüpfen
const snappy = spring({ frame, fps, config: { damping: 20, stiffness: 200 } });
const bouncy = spring({ frame, fps, config: { damping: 8 } });
const heavy  = spring({ frame, fps, config: { damping: 15, stiffness: 80, mass: 2 } });

Verwende den Parameter delay, um den Federstart zu verzögern:

const entrance = spring({ frame, fps, delay: 20 });

Interpolation

// Lineare Interpolation mit Clamping
const opacity = interpolate(frame, [0, 100], [0, 1], {
  extrapolateRight: "clamp",
  extrapolateLeft: "clamp",
});

// Mehrstufige Interpolation
const y = interpolate(frame, [0, 30, 60, 90], [100, 0, 0, -100]);

Sequenzierung

Sequence

Verwende <Sequence>, um das Erscheinen von Elementen zu verzögern. Verwende immer premountFor, um Komponenten vorzuladen.

import { Sequence } from "remotion";

const { fps } = useVideoConfig();

<Sequence from={1 * fps} durationInFrames={2 * fps} premountFor={1 * fps}>
  <Title />
</Sequence>
<Sequence from={2 * fps} durationInFrames={2 * fps} premountFor={1 * fps}>
  <Subtitle />
</Sequence>

Verwende layout="none", um den Wrapper für absolute Positionierung zu vermeiden.

Series

Verwende <Series> für sequentielle Wiedergabe ohne Überlappung:

import { Series } from "remotion";

<Series>
  <Series.Sequence durationInFrames={45}><Intro /></Series.Sequence>
  <Series.Sequence durationInFrames={60}><MainContent /></Series.Sequence>
  <Series.Sequence durationInFrames={30}><Outro /></Series.Sequence>
</Series>

Ein negativer offset erzeugt Überblendungen:

<Series.Sequence offset={-15} durationInFrames={60}>
  <SceneB />
</Series.Sequence>

Übergänge

npx remotion add @remotion/transitions
import { TransitionSeries, linearTiming } from "@remotion/transitions";
import { fade } from "@remotion/transitions/fade";
import { slide } from "@remotion/transitions/slide";
import { wipe } from "@remotion/transitions/wipe";

<TransitionSeries>
  <TransitionSeries.Sequence durationInFrames={60}>
    <SceneA />
  </TransitionSeries.Sequence>
  <TransitionSeries.Transition
    presentation={fade()}
    timing={linearTiming({ durationInFrames: 15 })}
  />
  <TransitionSeries.Sequence durationInFrames={60}>
    <SceneB />
  </TransitionSeries.Sequence>
</TransitionSeries>

Light Leak Overlays

import { LightLeak } from "@remotion/light-leaks";

<TransitionSeries>
  <TransitionSeries.Sequence durationInFrames={60}>
    <SceneA />
  </TransitionSeries.Sequence>
  <TransitionSeries.Overlay durationInFrames={20}>
    <LightLeak />
  </TransitionSeries.Overlay>
  <TransitionSeries.Sequence durationInFrames={60}>
    <SceneB />
  </TransitionSeries.Sequence>
</TransitionSeries>

Ein Overlay kann nicht neben einem Übergang oder einem anderen Overlay platziert werden.

Audio

npx remotion add @remotion/media
import { Audio } from "@remotion/media";
import { staticFile } from "remotion";

// Einfaches Audio
<Audio src={staticFile("audio.mp3")} />

// Mit Trimmen (Werte in Frames)
<Audio src={staticFile("audio.mp3")} trimBefore={2 * fps} trimAfter={10 * fps} />

// Lautstärkeregelung
<Audio src={staticFile("audio.mp3")} volume={0.5} />

// Dynamische Lautstärke (Callback erhält Frame)
<Audio src={staticFile("audio.mp3")} volume={(f) =>
  interpolate(f, [0, 30], [0, 1], { extrapolateRight: "clamp" })
} />

// Geschwindigkeitsänderung
<Audio src={staticFile("audio.mp3")} playbackRate={1.5} />

// Audio-Start verzögern
<Sequence from={1 * fps}>
  <Audio src={staticFile("audio.mp3")} />
</Sequence>

Mehrere <Audio>-Komponenten überlagern sich automatisch.

Video-Einbettung

import { Video } from "@remotion/media";

// Einfaches Video
<Video src={staticFile("video.mp4")} />

// Mit Trimmen
<Video src={staticFile("video.mp4")} trimBefore={2 * fps} trimAfter={10 * fps} />

// Geschwindigkeit, Lautstärke, Schleife
<Video src={staticFile("video.mp4")} playbackRate={2} volume={0.5} loop />

// Für bessere Rendering-Leistung OffthreadVideo verwenden
import { OffthreadVideo } from "remotion";
<OffthreadVideo src={staticFile("video.mp4")} />

Verwende IMMER <OffthreadVideo> für eine bessere Rendering-Leistung. Verwende <Video> nur während der Vorschau.

Sprachausgabe mit ElevenLabs TTS

Generiere Sprache pro Szene und verwende dann calculateMetadata, um die Komposition dynamisch zu dimensionieren.

Audio generieren

const response = await fetch(
  `https://api.elevenlabs.io/v1/text-to-speech/${voiceId}`,
  {
    method: "POST",
    headers: {
      "xi-api-key": process.env.ELEVENLABS_API_KEY!,
      "Content-Type": "application/json",
      Accept: "audio/mpeg",
    },
    body: JSON.stringify({
      text: "Willkommen zur Show.",
      model_id: "eleven_multilingual_v2",
      voice_settings: { stability: 0.5, similarity_boost: 0.75, style: 0.3 },
    }),
  },
);
const audioBuffer = Buffer.from(await response.arrayBuffer());
writeFileSync(`public/voiceover/scene-01.mp3`, audioBuffer);

Dynamische Dauer

import { CalculateMetadataFunction, staticFile } from "remotion";

const FPS = 30;
const SCENES = ["voiceover/scene-01.mp3", "voiceover/scene-02.mp3"];

export const calculateMetadata: CalculateMetadataFunction<Props> = async () => {
  const durations = await Promise.all(
    SCENES.map((file) => getAudioDuration(staticFile(file)))
  );
  const totalFrames = durations.reduce((sum, d) => sum + Math.ceil(d * FPS), 0);
  return { durationInFrames: totalFrames };
};

Assets

Lege Dateien in public/ ab und referenziere sie mit staticFile():

import { staticFile, Img } from "remotion";

<Img src={staticFile("logo.png")} />

Verwende NIEMALS require() oder import für Mediendateien. Verwende immer staticFile().

Schriftarten

import { loadFont } from "@remotion/google-fonts/Inter";
const { fontFamily } = loadFont();

// Oder lokale Schriftarten
const { fontFamily } = loadFont({
  url: staticFile("fonts/MyFont.woff2"),
  display: "swap",
});

FFmpeg in Remotion

FFmpeg ist integriert – keine Installation erforderlich:

bunx remotion ffmpeg -i input.mp4 output.mp3
bunx remotion ffprobe input.mp4

Zum Trimmen bevorzuge die Props trimBefore/trimAfter gegenüber FFmpeg. Verwende FFmpeg für Formatkonvertierungen oder Operationen, die Remotion nicht nativ ausführen kann.

Bei Verwendung von FFmpeg zum Trimmen MUSS neu codiert werden, um eingefrorene Frames zu vermeiden:

bunx remotion ffmpeg -ss 00:00:05 -i public/input.mp4 -to 00:00:10 -c:v libx264 -c:a aac public/output.mp4

Rendern

# Bestimmte Komposition rendern
npx remotion render MyVideo output.mp4

# Ein Einzelbild rendern
npx remotion still MyVideo --frame=100 thumbnail.png

# Mit benutzerdefinierten Props
npx remotion render MyVideo output.mp4 --props='{"title": "Benutzerdefiniert"}'

# Bestimmter Codec
npx remotion render MyVideo output.webm --codec=vp8

Häufige Muster

Szenenbasiertes Video

const SCENES = [
  { component: TitleScene, duration: 90 },
  { component: ProblemScene, duration: 150 },
  { component: SolutionScene, duration: 120 },
  { component: CTAScene, duration: 90 },
];

export const MyVideo = () => {
  let offset = 0;
  return (
    <>
      {SCENES.map(({ component: Component, duration }, i) => {
        const from = offset;
        offset += duration;
        return (
          <Sequence key={i} from={from} durationInFrames={duration}>
            <Component />
          </Sequence>
        );
      })}
    </>
  );
};

Hintergrundmusik + Sprachausgabe

<>
  {/* Hintergrundmusik mit geringer Lautstärke */}
  <Audio src={staticFile("music/bg.mp3")} volume={0.12} loop />

  {/* Szenen-Sprachausgabe in voller Lautstärke */}
  <Sequence from={0} durationInFrames={scene1Frames}>
    <Audio src={staticFile("voiceover/scene-01.mp3")} volume={1} />
  </Sequence>
  <Sequence from={scene1Frames} durationInFrames={scene2Frames}>
    <Audio src={staticFile("voiceover/scene-02.mp3")} volume={1} />
  </Sequence>
</>

Wichtige Regeln

  1. Keine CSS-Animationen – alle Bewegungen über useCurrentFrame() + interpolate()/spring()
  2. Keine Tailwind-Animationsklassen – sie werden nicht korrekt gerendert
  3. Immer staticFile() für Assets, niemals require()
  4. Sequences immer vormontieren mit premountFor
  5. <OffthreadVideo> verwenden, nicht <video> zum Rendern
  6. Dauern in Sekunden angeben und mit fps multiplizieren
  7. satisfies-Schlüsselwort verwenden für Typsicherheit bei defaultProps

Quelle: remotion-dev/skills, remotion.dev

Verwandte Skills