Remotion-Video — Die tatsächlichen Frames codieren
Du bist der Encoder und Renderer. Du nimmst Assets — eine Aufnahme, einen Voiceover, B-Roll, ein Transkript — plus React-Code entgegen und erzeugst eine echte Datei: out/video.mp4. Deine Geschwister schreiben Worte und Pläne; du bist der Einzige, der Pixel produziert. Die Strenge hier sind reproduzierbare Frames: gleiche Eingabe, gleiche deterministische Ausgabe, verifiziert durch einen Render, den ffprobe lesen kann.
Dir gehört das Remotion-Projekt-Scaffold, der <Composition> / <Sequence> / <TransitionSeries>-Graph, die Untertitel-Pipeline (Whisper.cpp → toCaptions → createTikTokStyleCaptions), der Pass zur Stille-Entfernung und der npx remotion render-Aufruf mit seinen Codec- und Concurrency-Flags.
Die eine Entscheidung: Frames oder Wörter?
Wenn die Anforderung darin besteht, eine Datei zu erzeugen, bist du hier richtig. Wenn es darum geht, Text oder einen Plan zu erzeugen, leite weiter, bevor du eine einzige .tsx schreibst.
| Die Anforderung | Geht zu | Grund |
|---|---|---|
| Ein MP4/MOV erzeugen, Übergänge, eingebrannte Untertitel, rendern | hier | Dies sind Pixel und Frames |
| Das Skript, den Aufhänger, die Beats, den eingeblendeten Untertitel-Text, den Schnittentscheidungsbogen schreiben | ../video-shorts/SKILL.md | Das sind Wörter; die Schnittentscheidungen, nicht die Schnittausführung |
Audio auf ein LUFS-Ziel mastern, Kapitel + RSS <item> erzeugen | ../podcast/SKILL.md | Audio-Mastering und Feed, nicht Video-Encoding |
| Den narrativen Bogen und Ablauf der Lektion/des Videos strukturieren | ../course-storytelling/SKILL.md | Narrative Architektur, nicht Rendering |
| Das Thumbnail-Bild entwerfen | ../youtube-thumbnails/SKILL.md | Ein Standbild, kein Video |
Grenze in einem Satz: video-shorts entscheidet über die Schnitte und schreibt den Untertiteltext; du führst die Schnitte im Code aus und brennst die Untertitel in die Frames ein.
Baugerüst des Projekts
npx create-video@latest --yes --blank my-video
cd my-video
npm i
npm run dev # öffnet Remotion Studio im Browser
Remotions aktuelle stabile Linie ist 4.0.471; es benötigt Node 16+ (oder Bun 1.0.3+), und lokales Rendern erfordert macOS 15 (Sequoia)+. Seit Januar 2026 liefert Remotion Agent Skills — npx skills add remotion-dev/skills verdrahtet Remotion-bewusste Anleitung in Claude Code. Führe es in einem Remotion-Projekt aus, wenn du das framework-eigene Skill zusätzlich zu diesem laden möchtest.
Setze fps und Abmessungen zuerst auf <Composition> fest und ändere sie niemals mitten im Projekt. Warum: jede nachgelagerte Dauer wird in Frames gemessen, und frames = seconds * fps. Wenn du fps änderst, nachdem du Dauern geschrieben hast, verschiebt sich jede Zeitangabe stillschweigend. Vertikale Shorts sind 1080×1920 @ 30; Querformat ist 1920×1080 @ 30.
Der Kompositionsgraph
// src/Root.tsx
import { Composition } from "remotion";
import { MyVideo } from "./MyVideo";
export const RemotionRoot: React.FC = () => {
return (
<Composition
id="MyVideo" // die id, die du an `remotion render` übergibst
component={MyVideo}
durationInFrames={300} // 10s bei 30fps
fps={30}
width={1080}
height={1920}
/>
);
};
// src/MyVideo.tsx
import { AbsoluteFill, Sequence, useCurrentFrame, interpolate, spring, useVideoConfig } from "remotion";
export const MyVideo: React.FC = () => {
const frame = useCurrentFrame();
const { fps } = useVideoConfig();
const opacity = interpolate(frame, [0, 30], [0, 1], { extrapolateRight: "clamp" });
const scale = spring({ frame, fps, config: { damping: 200 } });
return (
<AbsoluteFill style={{ backgroundColor: "black" }}>
<Sequence from={0} durationInFrames={90}>
<AbsoluteFill style={{ opacity, transform: `scale(${scale})` }}>{/* Szene 1 */}</AbsoluteFill>
</Sequence>
<Sequence from={90} durationInFrames={210}>{/* Szene 2 */}</Sequence>
</AbsoluteFill>
);
};
Animieren mit useCurrentFrame(), interpolate() und spring() nur. Lies niemals die Wanduhrzeit (Date.now()) oder rufe ungesäht Math.random() innerhalb einer Komposition auf. Warum: Rendern ist parallel und frame-adressierbar — jeder Frame wird unabhängig berechnet, daher erzeugt jede Nicht-Frame-Eingabe ein anderes Pixel bei einem erneuten Rendern und bricht die Garantie "gleiche Eingabe, gleiche Ausgabe". Wenn du Zufälligkeit benötigst, verwende Remotions random(seed).
Übergänge
Verwende @remotion/transitions (verfügbar seit v4.0.53). <TransitionSeries> fügt .Sequence (einen Clip, mit durationInFrames) und .Transition (eine presentation + ein timing) ineinander. Die Übergangsdauer wird von der Gesamtdauer abgezogen, sodass benachbarte Sequenzen während des Wipes überlappen.
import { TransitionSeries, linearTiming, springTiming } from "@remotion/transitions";
import { slide } from "@remotion/transitions/slide";
import { fade } from "@remotion/transitions/fade";
import { Easing } from "remotion";
<TransitionSeries>
<TransitionSeries.Sequence durationInFrames={90}>{/* Szene A */}</TransitionSeries.Sequence>
<TransitionSeries.Transition
presentation={slide({ direction: "from-left" })}
timing={springTiming({ config: { damping: 200 }, durationInFrames: 30, durationRestThreshold: 0.001 })}
/>
<TransitionSeries.Sequence durationInFrames={120}>{/* Szene B */}</TransitionSeries.Sequence>
<TransitionSeries.Transition
presentation={fade()}
timing={linearTiming({ durationInFrames: 15, easing: Easing.inOut(Easing.ease) })}
/>
<TransitionSeries.Sequence durationInFrames={90}>{/* Szene C */}</TransitionSeries.Sequence>
</TransitionSeries>
Jede Präsentation ist ein Unterimport (@remotion/transitions/slide, /fade, /wipe, /flip, /clockWipe, /none).
| Präsentation | Gefühl / Wann |
|---|---|
slide | Szene schiebt die nächste herein; direktionale Dynamik zwischen Beats |
fade | Sanfter Crossfade; ruhiger, neutraler Szenenwechsel |
wipe | Eine harte Kante fegt quer; energiegeladen, "nächstes Thema" |
flip | 3D-Karten-Flip; verspielt, für Enthüllungen |
clockWipe | Radialer Sweep; Countdowns, "Zeit vergeht" |
none | Ein harter Schnitt ohne Bewegung, aber dennoch als TransitionSeries-Knoten |
linearTiming für vorhersagbare, frame-genaue Schnitte; springTiming für organische Bewegung. Warum: Linear ist deterministisch in der Dauer, sodass du Frames genau budgetieren kannst; Spring überschwingt und beruhigt sich, was natürlich wirkt, aber durationRestThreshold benötigt, damit der Render weiß, wann er fertig ist.
Animierte eingebrannte Untertitel
Das native Paket @remotion/captions wurde in v4.0.216 ausgeliefert (der gleiche Release, der den alten convertToCaptions()-Helfer deprecated hat). Die Pipeline läuft einmal auf einem Node-Server, dann liest die Komposition die Untertitel:
- Transkribieren.
@remotion/install-whisper-cpplädt Whisper.cpp und ein Modell herunter (medium.enist ~1,5 GB) und transkribiert das Audio auf einem Node-Server in Whisper-JSON. - Konvertieren.
toCaptions()aus@remotion/install-whisper-cppwandelt dieses JSON in einCaption[]mit Zeitstempeln pro Token um. (convertToCaptions()ist der Legacy-Alias — deprecated seit v4.0.216; verwendetoCaptions().) - In Seiten segmentieren.
@remotion/captionscreateTikTokStyleCaptions({ captions, combineTokensWithinMilliseconds })gruppiert Token in "Seiten", die gemeinsam erscheinen.
Der Wert combineTokensWithinMilliseconds ist der Seiten-Größen-Regler. Warum: Ein niedriger Wert (~200ms) behält jedes Wort auf seiner eigenen Seite → Wort-für-Wort-Pop-Animation; ein hoher Wert (~1200ms) packt eine Phrase pro Seite. Niedrige ms = TikTok-Wort-für-Wort-Energie; hohe ms = lesbare Phrasen. Wähle basierend auf dem Format, nicht auf dem Standardwert.
Die vollständige Whisper.cpp-Installation, der Transkriptionsserver und die Token-Highlight-Untertitel-Renderer-Komponente (mit Safe-Zone-Styling) befinden sich in references/captions-pipeline.md — lies es, bevor du die Untertitelebene erstellst.
Automatische Stille-Entfernung
Der Stille-Pass läuft auf dem Quell-Audio/-Video VOR dem Eintritt in Remotion, nicht innerhalb einer Komposition. Warum: Remotion rendert Frames, die du ihm gibst; das Beschneiden von toter Luft ist eine vorgelagerte Bearbeitung des Assets, und wenn du es zuerst machst, spiegelt jede nachgelagerte Frame-Nummer bereits die gestraffte Timeline wider.
Verwende auto-editor (eine Python + ffmpeg-Engine) für einen ersten Durchlauf, der tote Stellen anhand der Lautstärke des Audios beschneidet:
auto-editor input.mp4 --margin 0.2s --edit audio:threshold=4% -o tightened.mp4
--marginpolstert jeden beibehaltenen Bereich, damit Schnitte die Sprache nicht abschneiden.--edit audio:threshold=4%setzt die Lautstärke-Schwelle, unterhalb derer ein Bereich als "Stille" gilt.--export premieregibt eine EDL/XML-Datei aus, statt einer Videodatei, um sie in ein NLE zu reimportieren.
Die pip-Distribution ist veraltet/eingestellt — installiere über das offizielle Binary oder pipx, nicht mit pip install. Warum: Das PyPI-Paket hinkt hinterher und entspricht möglicherweise nicht den dokumentierten Flags. Wenn auto-editor nicht verfügbar ist, ist der Low-Level-Fallback die ffmpeg-Filter silencedetect / silenceremove. Beide, mit der vollständigen Flag-Matrix, befinden sich in references/render-and-pipeline.md.
B-Roll-Overlays
Staple das Overlay über das Hauptvideo, indem du <OffthreadVideo> (oder <Img>) innerhalb eines <AbsoluteFill> schichtest, gesteuert durch ein <Sequence from>:
import { AbsoluteFill, Sequence, OffthreadVideo, staticFile } from "remotion";
const fps = 30;
const broll = { start: 4.0, duration: 3.0 }; // Sekunden
<AbsoluteFill>
<OffthreadVideo src={staticFile("main.mp4")} /> {/* Basisebene */}
<Sequence from={Math.round(broll.start * fps)} durationInFrames={Math.round(broll.duration * fps)}>
<AbsoluteFill style={{ /* z.B. Inset für Bild-im-Bild */ }}>
<OffthreadVideo src={staticFile("broll.mp4")} /> {/* Overlay-Ebene */}
</AbsoluteFill>
</Sequence>
</AbsoluteFill>
Konvertiere jede Zeitangabe mit Math.round(seconds * fps) in Frames, einmal, an der Grenze. Warum: Ein B-Roll-Cue bei 4,0 s ist Frame 120 bei 30fps, aber Frame 240 bei 60fps — behalte Sekunden in deinen Daten und multipliziere mit fps aus useVideoConfig(), sodass eine Änderung der fps niemals Overlays desynchronisiert. Verwende <OffthreadVideo> (nicht das DOM <video> oder <Video>) für frame-genaues Decodieren während des Renderns.
Rendern
# Region zuerst testen: 1-2 Sekunden, validiert die Pipeline kostengünstig
npx remotion render MyVideo out/test.mp4 --frames=0-45
# dann der vollständige Render
npx remotion render MyVideo out/video.mp4
Lasse die Kompositions-ID weg, um einen interaktiven Auswähler zu erhalten. Konfiguriere über @remotion/cli/config in remotion.config.ts oder übergib Flags auf der CLI (Flags gewinnen):
// remotion.config.ts
import { Config } from "@remotion/cli/config";
Config.setConcurrency(8);
Config.setCodec("h264");
| Codec | Verwendung | Flag |
|---|---|---|
h264 | Standard für Web/YouTube; breite Kompatibilität | (Standard) |
h265 | Kleinere Dateien, gleiche Qualität; weniger universelle Wiedergabe | --codec=h265 |
prores | Editierfähiges Master, große Dateien, Re-Import in ein NLE | --codec=prores --prores-profile=4444 --pixel-format=yuva444p10le --image-format=png |
vp8 / gif | Web-Alpha oder Loop-Vorschauen | --codec=vp8 / --codec=gif |
Rendere immer zuerst eine 1–2s-Region (--frames=0-45) vor dem vollständigen Render. Warum: Ein vollständiger Render einer Minuten-langen Komposition kostet echte Zeit und CPU; ein Region-Test deckt eine kaputte Untertitel-Ebene oder ein fehlendes Asset in Sekunden auf. Für Headless/CI-Renderings, deterministische Ausgaberegeln und die vollständige Codec/Qualitäts-Matrix, siehe references/render-and-pipeline.md.
Anti-Patterns
| Schlecht | Warum es bricht | Gut |
|---|---|---|
| Hardcodieren von Dauern in Sekunden innerhalb von JSX | Remotion denkt in Frames; Sekunden desynchronisieren, sobald fps sich ändert | Speichere Sekunden in Daten, Math.round(seconds * fps) an der Grenze |
Date.now() / ungesähtes Math.random() in einer Komposition | Frames rendern parallel und bei erneutem Rendern → nicht-deterministische Pixel | Treibe alles mit useCurrentFrame() an; verwende random(seed) |
Ändern von fps nach dem Schreiben von Dauern | Jede Frame-Anzahl verschiebt sich stillschweigend nachgelagert | Setze fps + Abmessungen auf <Composition> zu Beginn fest, lasse sie unverändert |
| Erneutes Herunterladen des Whisper-Modells bei jedem Lauf | Der ~1,5 GB medium.en-Download wiederholt sich und blockiert die Pipeline | Lade einmal herunter, cache den Modellpfad, verwende ihn wieder |
| Das 1,5 GB Whisper-Modell in git committen | Bläht das Repository auf; das Modell ist ein Build-Asset | .gitignore das Modellverzeichnis; lade es in Setup/CI herunter |
| Vollständiges Video rendern, um eine Änderung zu testen | Minuten verschwendeten Render, um eine kaputte Ebene zu finden | --frames=0-45 Region-Test, dann vollständiger Render |
| Den Untertitel-Text oder Aufhänger hier schreiben | Das ist das Skript, nicht das Encoding | Leite an ../video-shorts/SKILL.md weiter; du brennst es nur ein |
Gewöhnliches <video> / <Video> für B-Roll in einem Render | Nicht frame-genau; reißt oder überspringt beim Rendern | <OffthreadVideo> für frame-exaktes Decodieren |
| Stille-Entfernung innerhalb der Komposition ausführen | Das Beschneiden von toter Luft ist eine vorgelagerte Asset-Bearbeitung | auto-editor auf der Quelldatei vor Remotion |
Verifizieren & Referenzen
bash scripts/verify.sh <project-dir>— prüft, ob das Remotion-Projekt wohlgeformt ist und rendert. Wenn Node + ffmpeg vorhanden sind, führt esnpx remotion compositionsaus, um zu bestätigen, dass eine Kompositions-ID existiert, rendert eine kurze Region in ein temporäres MP4 und verwendetffprobe, um einen Videostream mit den erwarteten Abmessungen/fps zu bestätigen. Mit keinem von beiden fällt es auf eine statische Prüfung zurück: mindestens eine Kompositions-.tsx-Datei existiert und das Render-Skript referenziert eine echte Kompositions-ID und einen Ausgabepfad. Standardmäßig schreibgeschützt; beendet mit 0 bei einem leeren/sauberen Ziel.references/captions-pipeline.md— vollständige Whisper.cpp-Installation + Transkriptionsserver,toCaptions, die Token-Highlight-Untertitel-Renderer-Komponente und Untertitel-Styling/Safe-Zone-Notizen.references/render-and-pipeline.md—auto-editor+ ffmpeg-Stille-Befehle, die vollständige Render-Flag-Matrix, Headless/CI-Render, die Codec-Tabelle undffprobe-Verifikation.