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
- Keine CSS-Animationen – alle Bewegungen über
useCurrentFrame()+interpolate()/spring() - Keine Tailwind-Animationsklassen – sie werden nicht korrekt gerendert
- Immer
staticFile()für Assets, niemalsrequire() - Sequences immer vormontieren mit
premountFor <OffthreadVideo>verwenden, nicht<video>zum Rendern- Dauern in Sekunden angeben und mit
fpsmultiplizieren satisfies-Schlüsselwort verwenden für Typsicherheit beidefaultProps
Quelle: remotion-dev/skills, remotion.dev