Wenn diese Fähigkeit aktiviert ist, beginne deine erste Antwort immer mit dem :clapper:-Emoji.
Remotion Video
Remotion ist ein Framework zum programmatischen Erstellen von Videos mit React. Anstatt timeline-basierte Editoren zu verwenden, schreibst du Kompositionen als React-Komponenten, bei denen jeder Frame eine Funktion der aktuellen Frame-Nummer ist. Dies gibt dir die volle Leistungsfähigkeit von TypeScript, npm-Paketen und einer komponentenbasierten Architektur zum Erstellen von Videos – von animierten Erklärvideos und Social-Media-Clips bis hin zu datengesteuerten Visualisierungen und personalisierten Videos in großem Maßstab.
Diese Fähigkeit behandelt die Projekteinrichtung, Kompositionsstruktur, frame-basierte Animationen mit interpolate und spring, Szenensequenzierung, Asset-Verwaltung, Audiointegration, parametrisierte Videos mit Zod-Schemas und das Rendern in MP4/WebM über die CLI oder programmatische APIs.
Wann du diese Fähigkeit einsetzen solltest
Löse diese Fähigkeit aus, wenn der Benutzer:
- Ein Video programmatisch mit React/TypeScript erstellen möchte
- Nach Remotion-Kompositionen, useCurrentFrame oder useVideoConfig fragt
- Text, Elemente oder Übergänge zwischen Szenen animieren muss
- Ein Video in MP4, WebM oder GIF aus Code rendern möchte
- Nach spring-Animationen, interpolate oder frame-basiertem Timing fragt
- Ein neues Remotion-Projekt von Grund auf einrichten muss
- Audio, Bilder oder Schriftarten zu einem Remotion-Video hinzufügen möchte
- Nach parametrisierter/datengesteuerter Videoerstellung fragt
- Remotion Studio zur Vorschau von Kompositionen konfigurieren muss
Verwende diese Fähigkeit NICHT für:
- Allgemeine React-Fragen, die nichts mit Videoerstellung zu tun haben – verwende React-Fähigkeiten
- Videobearbeitung mit traditionellen Timeline-Tools (Premiere, DaVinci, FFmpeg CLI)
- CSS-Animationen für Webseiten – verwende Animations-/Motion-Design-Fähigkeiten
- Videowiedergabe oder Streaming in Web-Apps – verwende Media-Player-Fähigkeiten
Wichtige Prinzipien
-
Jeder Frame ist eine reine Funktion – Eine Remotion-Komponente erhält den aktuellen Frame über
useCurrentFrame()und muss deterministisch für diesen Frame rendern. Keine Seiteneffekte, keine Zufälligkeit ohne Seeds, keine Abhängigkeit von der Echtzeituhr. Dieselbe Frame-Nummer muss immer dieselbe visuelle Ausgabe liefern. -
Kompositionen sind die Einheit des Videos – Jede
<Composition>definiert ein Video mit expliziten Abmessungen (width, height), Bildrate (fps) und Dauer (durationInFrames). Betrachte Kompositionen als "Seiten" in deinem Projekt – eine pro Variante oder Szene, die unabhängig gerendert werden kann. -
Interpolate für alles – Die Funktion
interpolate()bildet Frame-Nummern auf beliebige numerische Werte ab (Deckkraft, Position, Skalierung, Farbkanäle). In Kombination mitextrapolateRight: 'clamp'ist sie das Arbeitstier für alle Animationen. Verwendespring(), wenn du physikbasierte Easing-Effekte benötigst. -
Sequence für Zeitversätze – Verwende
<Sequence from={frame}>, um zu verzögern, wann Kinder zu erscheinen beginnen, und<Series>, um Kinder nacheinander abzuspielen. Verwende niemals setTimeout oder manuelle Frame-Berechnungen für die Sequenzierung – die deklarativen Primitiven kümmern sich darum korrekt in der Vorschau und beim Rendern. -
Assets sind statisch, Daten sind dynamisch – Lege Bilder, Schriftarten und Audiodateien im Ordner
public/ab und referenziere sie mitstaticFile(). Für dynamische Daten (API-Antworten, Datenbankeinträge) verwendedelayRender()/continueRender(), um das Rendern anzuhalten, bis die Daten geladen sind.
Kernkonzepte
Kompositionsstruktur
Jedes Remotion-Projekt hat eine Stammdatei, die Kompositionen registriert:
import { Composition } from 'remotion';
import { MyVideo } from './MyVideo';
export const RemotionRoot: React.FC = () => {
return (
<Composition
id="MyVideo"
component={MyVideo}
durationInFrames={150}
fps={30}
width={1920}
height={1080}
/>
);
};
Frame-basiertes Timing
Das gesamte Timing in Remotion wird in Frames ausgedrückt, nicht in Sekunden. Zur Umrechnung:
- Sekunden in Frames:
seconds * fps - Frames in Sekunden:
frame / fps
Bei 30 fps ist ein 5-Sekunden-Video 150 Frames. Frame 0 ist der erste Frame.
Animationsmodell
Remotion bietet zwei grundlegende Animationsprimitiven:
| Primitive | Anwendungsfall | Beispiel |
|---|---|---|
interpolate() | Lineare/clamped Abbildung von Frame auf Wert | Einblenden, Schieben, Skalieren |
spring() | Physikbasierte Animation mit Dämpfung/Masse | Dynamische Eintritte, natürliche Bewegung |
Beide geben eine Zahl zurück, die du auf Stile anwendest (Deckkraft, Transform usw.).
Häufige Aufgaben
1. Ein neues Remotion-Projekt einrichten
npx create-video@latest
Dies erstellt ein Projekt mit TypeScript, einer Beispielkomposition und dem konfigurierten Remotion Studio. Die Projektstruktur sieht so aus:
my-video/
src/
Root.tsx # Registriert alle Kompositionen
MyComp.tsx # Deine erste Komponente
public/ # Statische Assets (Bilder, Schriftarten, Audio)
remotion.config.ts # Remotion-Konfiguration
package.json
Starte das Vorschau-Studio mit:
npx remotion studio
2. Eine grundlegende Komposition mit useCurrentFrame erstellen
import { AbsoluteFill, useCurrentFrame, useVideoConfig, interpolate } from 'remotion';
export const FadeInText: React.FC = () => {
const frame = useCurrentFrame();
const { fps } = useVideoConfig();
const opacity = interpolate(frame, [0, 30], [0, 1], {
extrapolateRight: 'clamp',
});
const translateY = interpolate(frame, [0, 30], [20, 0], {
extrapolateRight: 'clamp',
});
return (
<AbsoluteFill
style={{
justifyContent: 'center',
alignItems: 'center',
backgroundColor: '#0f0f0f',
}}
>
<h1
style={{
fontSize: 80,
color: 'white',
opacity,
transform: `translateY(${translateY}px)`,
}}
>
Hello Remotion
</h1>
</AbsoluteFill>
);
};
3. Text Wort für Wort animieren
Teile Text in Wörter auf und staffle das Erscheinen jedes Wortes mit <Sequence>:
import { AbsoluteFill, Sequence, useCurrentFrame, interpolate } from 'remotion';
const AnimatedWord: React.FC<{ children: string }> = ({ children }) => {
const frame = useCurrentFrame();
const opacity = interpolate(frame, [0, 15], [0, 1], {
extrapolateRight: 'clamp',
});
const translateY = interpolate(frame, [0, 15], [10, 0], {
extrapolateRight: 'clamp',
});
return (
<span
style={{
display: 'inline-block',
opacity,
transform: `translateY(${translateY}px)`,
marginRight: 12,
}}
>
{children}
</span>
);
};
export const WordByWord: React.FC<{ text: string }> = ({ text }) => {
const words = text.split(' ');
return (
<AbsoluteFill
style={{
justifyContent: 'center',
alignItems: 'center',
backgroundColor: '#1a1a2e',
flexWrap: 'wrap',
padding: 100,
}}
>
{words.map((word, i) => (
<Sequence key={i} from={i * 8}>
<AnimatedWord>{word}</AnimatedWord>
</Sequence>
))}
</AbsoluteFill>
);
};
4. Element-Animationen mit spring
Verwende spring() für physikbasierte Animationen, die sich natürlich anfühlen:
import { AbsoluteFill, useCurrentFrame, useVideoConfig, spring } from 'remotion';
export const SpringCard: React.FC = () => {
const frame = useCurrentFrame();
const { fps } = useVideoConfig();
const scale = spring({
frame,
fps,
config: { damping: 200, stiffness: 100, mass: 0.5 },
});
const slideUp = spring({
frame: frame - 10,
fps,
config: { damping: 12, stiffness: 100 },
});
return (
<AbsoluteFill style={{ justifyContent: 'center', alignItems: 'center', backgroundColor: '#0d1117' }}>
<div
style={{
width: 400,
height: 250,
backgroundColor: '#161b22',
borderRadius: 16,
transform: `scale(${scale}) translateY(${(1 - slideUp) * 50}px)`,
}}
>
<p style={{ color: 'white', fontSize: 32 }}>Spring Animation</p>
</div>
</AbsoluteFill>
);
};
5. Szenenübergänge mit Sequence und Series
Verwende <Sequence> für überlappende Szenen und <Series> für sequenzielle Wiedergabe:
import { AbsoluteFill, Sequence, Series, useCurrentFrame, interpolate } from 'remotion';
const Scene: React.FC<{ color: string; title: string }> = ({ color, title }) => {
const frame = useCurrentFrame();
const opacity = interpolate(frame, [0, 20], [0, 1], {
extrapolateRight: 'clamp',
});
return (
<AbsoluteFill style={{ backgroundColor: color, justifyContent: 'center', alignItems: 'center' }}>
<h1 style={{ color: 'white', fontSize: 72, opacity }}>{title}</h1>
</AbsoluteFill>
);
};
export const MultiScene: React.FC = () => {
return (
<AbsoluteFill>
<Series>
<Series.Sequence durationInFrames={60}>
<Scene color="#e63946" title="Szene Eins" />
</Series.Sequence>
<Series.Sequence durationInFrames={60}>
<Scene color="#457b9d" title="Szene Zwei" />
</Series.Sequence>
<Series.Sequence durationInFrames={60}>
<Scene color="#2a9d8f" title="Szene Drei" />
</Series.Sequence>
</Series>
</AbsoluteFill>
);
};
6. Asset-Verwaltung (Bilder, Schriftarten, staticFile)
Referenziere statische Assets aus dem Ordner public/ mit staticFile():
import { AbsoluteFill, Img, staticFile } from 'remotion';
export const AssetDemo: React.FC = () => {
return (
<AbsoluteFill style={{ justifyContent: 'center', alignItems: 'center' }}>
<Img
src={staticFile('logo.png')}
style={{ width: 300, height: 300 }}
/>
</AbsoluteFill>
);
};
Lade benutzerdefinierte Schriftarten mit @remotion/google-fonts oder CSS @font-face:
import { loadFont } from '@remotion/google-fonts/Inter';
const { fontFamily } = loadFont();
export const FontDemo: React.FC = () => {
return (
<AbsoluteFill style={{ justifyContent: 'center', alignItems: 'center' }}>
<h1 style={{ fontFamily, fontSize: 64, color: 'white' }}>
Benutzerdefinierte Schriftart
</h1>
</AbsoluteFill>
);
};
7. Audio-Integration
Füge Audio mit Lautstärkeregelung und Timing hinzu:
import { AbsoluteFill, Audio, Sequence, staticFile, interpolate } from 'remotion';
export const WithAudio: React.FC = () => {
return (
<AbsoluteFill style={{ backgroundColor: '#000' }}>
<Audio
src={staticFile('hintergrundmusik.mp3')}
volume={(f) =>
interpolate(f, [0, 30, 120, 150], [0, 0.8, 0.8, 0], {
extrapolateLeft: 'clamp',
extrapolateRight: 'clamp',
})
}
/>
<Sequence from={15}>
<Audio src={staticFile('rauschen.mp3')} volume={0.5} />
</Sequence>
</AbsoluteFill>
);
};
8. Videos rendern
Rendere in MP4 über die Kommandozeile:
# Standardkomposition rendern
npx remotion render src/index.ts MyVideo out/video.mp4
# In 4K-Auflösung rendern
npx remotion render src/index.ts MyVideo out/video.mp4 --width 3840 --height 2160
# In WebM rendern
npx remotion render src/index.ts MyVideo out/video.webm --codec vp8
# Einen bestimmten Frame-Bereich rendern
npx remotion render src/index.ts MyVideo out/video.mp4 --frames 0-90
# Mit benutzerdefinierten Props rendern
npx remotion render src/index.ts MyVideo out/video.mp4 --props '{"title": "Hallo"}'
Für programmatisches Rendern siehe references/rendering-guide.md.
Anti-Patterns / häufige Fehler
| Fehler | Warum es falsch ist | Was stattdessen zu tun ist |
|---|---|---|
Math.random() ohne Seed verwenden | Erzeugt während des Renderings pro Frame unterschiedliche Ausgabe | Verwende einen deterministischen Seed oder random() von Remotion |
setTimeout / setInterval verwenden | Zerstört das frame-basierte Rendern – Timer laufen nicht pro Frame weiter | Verwende für das gesamte Timing useCurrentFrame() und Frame-Berechnungen |
Fehlendes extrapolateRight: 'clamp' | Werte überschreiten den Zielbereich in späteren Frames | Füge interpolate() immer { extrapolateRight: 'clamp' } hinzu |
| Fest codierte fps in Frame-Berechnungen | Bricht zusammen, wenn sich die Kompositions-fps ändert | Verwende useVideoConfig().fps, um das Timing abzuleiten |
<Video> für die gerenderte Ausgabe verwenden | Langsamere Rendering-Leistung aufgrund von Suchlauf-Overhead | Verwende <OffthreadVideo> für bessere Rendering-Leistung |
Vergessen von delayRender() für asynchrone Daten | Rendert, bevor die Daten geladen sind, zeigt leere/fehlerhafte Frames | Rufe sofort delayRender() auf, continueRender(), wenn bereit |
| Inline-Stile mit nicht-deterministischen Werten | Flackern oder Inkonsistenz zwischen Vorschau und Render | Leite alle Stilwerte nur von der Frame-Nummer ab |
| Riesige einzelne Komposition | Schwer zu warten und unmöglich, Szenen unabhängig zu rendern | Teile in mehrere Kompositionen auf oder verwende Series für Szenen |
Fallstricke
-
extrapolateRight-Standard ist 'extend' – Wenn du
interpolate(frame, [0, 30], [0, 1])ohne Clamping schreibst, steigt der Wert nach Frame 30 weiter an (z. B. ergibt Frame 60 eine Deckkraft von 2). Übergib immer{ extrapolateRight: 'clamp' }, es sei denn, du möchtest absichtlich eine Extrapolation. -
spring() beginnt bei Frame 0 seines Kontextes – Wenn du
spring()innerhalb einer<Sequence from={60}>verwendest, wird der an spring übergebene Frame bei Frame 60 des Elternteils auf 0 zurückgesetzt. Wenn du den rohen Frame des Elternteils übergibst, ist die Animation bereits abgeschlossen. VerwendeuseCurrentFrame()innerhalb des Sequence-Kindes, nicht einen Frame des Elternteils. -
staticFile()-Pfade sind relativ zu public/ –
staticFile('images/logo.png')sucht nachpublic/images/logo.png. Absolute Pfade oder Pfade außerhalb vonpublic/schlagen in der Vorschau stillschweigend fehl und verursachen beim Rendern einen Fehler. Stelle sicher, dass sich alle Assets im Verzeichnispublic/befinden. -
delayRender hat ein 30-Sekunden-Timeout – Wenn dein asynchroner Vorgang (API-Aufruf, Schriftartenladen) länger als 30 Sekunden dauert, wird das Rendern abgebrochen. Erhöhe das Timeout mit
delayRender('Daten laden', { timeoutInMilliseconds: 60000 })für langsame Vorgänge. -
Kompositionsabmessungen müssen gerade Zahlen sein – Videocodecs (H.264, VP8) erfordern gerade Breite und Höhe. Remotion gibt einen Fehler aus, wenn du ungerade Werte verwendest. Runde Abmessungen auf die nächste gerade Zahl.
-
useCurrentFrame() nicht zwischen mehreren Aufrufen teilen – Jeder Aufruf von
useCurrentFrame()gibt den Frame des nächstgelegenen<Sequence>- oder<Timeline>-Kontextes zurück. Wenn zwei Komponenten, die eine Sequence mit unterschiedlichemfromumschließt,useCurrentFrame()aufrufen, erhalten sie unterschiedliche Werte. Übergib den Frame als Prop, wenn er dieselbe Zeitreferenz haben soll. -
Der Studio-Modus unterscheidet sich vom Render-Modus – Remotion Studio rendert in Echtzeit mit niedrigerer Qualität für die Vorschau. Einige Funktionen wie
<OffthreadVideo>und JavaScript-Worker verhalten sich im Studio anders. Verlasse dich nicht auf die Studio-Leistung für endgültige Render-Zeiten.