Communitygithub.com

ReelStudio: Thema rein, Reel raus

Erstelle kurze vertikale Videos (Instagram Reels, TikTok, YouTube Shorts) lokal mit ReelStudio. Codex schreibt das Skript, plant und codiert die Szenen und prüft die eigenen Frames; OpenRouter übernimmt die Stimme, Bilder und Wort-Zeitstempel; Remotion rendert das MP4 auf diesem Mac.

Was ist ReelStudio: Thema rein, Reel raus?

ReelStudio ist ein KI-gestütztes Tool zur Erstellung vertikaler Kurzvideos, das über Codex oder direkt über die Kommandozeile gesteuert wird. Es ermöglicht die vollständige, lokale Produktion von Reels, von der Skripterstellung über die Szenenplanung bis hin zum Rendering. Der Workflow umfasst: Themen-Sammlung und Markenauswahl, Skripterstellung mit Storyboard (Bibel des Looks beachten), Sprachsynthese und Timing via OpenRouter (verschiedene TTS-Modelle), Erstellung von Bildmaterial (KI-Bilder, echte Fotos von Wikimedia, SVG-Diagramme) und finale Komposition in React/Remotion. Es unterstützt verschiedene Looks und Marken, die das visuelle Styling (Farben, Schriftarten, Maskottchen) vorgeben. Premium-Qualität wird durch den "Zoom-Format"-Ansatz erreicht: Eine große, kontinuierliche Welt wird mit einer gleitenden Kamera erkundet, ohne harte Schnitte. Der gesamte Prozess ist deterministisch, lokal und für die Zusammenarbeit mit KI-Agenten wie Codex optimiert.

Funktioniert mit✓Claude Code✓Codex CLI~Cursor✓Gemini CLI
npx skills add https://github.com/luke30001/reelstudio-codex/tree/HEAD/plugins/reelstudio/skills/reel

In Ihrer bevorzugten KI fragen

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

Dokumentation

Was macht ReelStudio: Thema rein, Reel raus?

Du bist der Produzent und die Crew. Tue, was nur du tun kannst (Schreiben, Regie führen, Szenen coden, Frames beurteilen) und führe den Befehl reelstudio für das aus, was du nicht tun kannst (Stimme, Bilder, Zeitstempel, Rendering).

reelstudio <command>     # = $RS unten; Starter in ~/.local/bin, führt ~/ReelStudio/engine/bin/rs.mjs aus

$RS steht unten für reelstudio. Wenn reelstudio nicht im PATH ist, verwende node ~/ReelStudio/engine/bin/rs.mjs (nach der ersten Einrichtung) oder node <Plugin-Root>/engine/bin/rs.mjs (der Plugin-Root befindet sich zwei Ordner über dieser SKILL.md). Die Engine ruft OpenRouter auf und führt ffmpeg und Headless Chrome (Remotion) aus, benötigt also Netzwerkzugriff und muss in ~/ReelStudio schreiben können: Wenn die Sandbox einen reelstudio-Befehl blockiert, fordere erweiterte Berechtigungen dafür an, anstatt einen Workaround zu finden. Führe jeden Befehl einzeln aus (keine cd … &&-Ketten oder Pipes). setup, frames und render können einige Minuten dauern.

Alles lebt in ~/ReelStudio/: reels/<name>/, brands/*.json, looks/<id>/look.json (+ Maskottchen- und Referenzbilder), .env (OpenRouter-Key), config.json (optionale Modell-Überschreibungen). Der Benutzer kann auch alles über die Codex-Web-App steuern: node <plugin root>/app-codex/server.mjs (http://127.0.0.1:4749; es führt codex exec als Produzent aus).

0. Erstmalig

Führe $RS setup aus (kopiert die Engine, installiert Remotion einmal, erstellt die default-Marke). Wenn es meldet, dass kein OpenRouter-Key vorhanden ist, können Stimme und Bilder nicht ausgeführt werden: Stoppe und sage dem Benutzer, er solle ihn selbst setzen (in seinem eigenen Terminal: reelstudio key, oder OPENROUTER_API_KEY=... in ~/ReelStudio/.env). Bitte ihn niemals, den Key in den Chat einzufügen. Führe $RS setup nach einem Update des Plugins erneut aus (der Starter wählt die neueste installierte Plugin-Version aus).

1. Briefing

Hole das Thema (oder das Skript des Benutzers), die Marke ($RS list zeigt Marken und Looks an), die Sprache und die Ziellänge (Standard 25–40 s). Verwende für eine redaktionelle Premium-Qualität (sanfte Kamera-Zooms über eine Welt, Serifen-Headline, rote Pille, saubere Karten) eine Marke mit dem editoriale Look (oder cronaca für Geschichte und wahre Geschichten mit echten Fotos, Marke storia) und das Zoom-Format aus Schritt 5b; jedes Thema funktioniert. Lese ~/ReelStudio/brands/<brand>.json und befolge dessen tone.

Der Look ist die kreative Linie. Jede Marke verweist auf einen Look in ~/ReelStudio/looks/<id>/look.json. Lese ihn, bevor du etwas schreibst, und befolge seine bible (Layout-Regeln, Maskottchen-Verwendung, was zu vermeiden ist). Seine Farben, Schriftart, Bildunterschriften-Stil und Hintergrund werden automatisch angewendet. Sein imageStyle und Referenzbilder werden automatisch zu jedem rs image-Aufruf hinzugefügt, sodass alle Bilder einer Marke einen gemeinsamen Stil haben. Jedes Reel einer Marke muss wie ein Teil derselben Serie aussehen.

2. Skript und Storyboard

$RS new "<Thema>" --brand <Marke> gibt den Reel-Namen aus. Schreibe reels/<name>/reel.json:

{"title": "...", "brand": "default", "scenes": [
  {"id": "hook", "voiceover": "...", "visual": "was auf dem Bildschirm zu sehen ist", "hold": 0.2}
]}

Regeln für das Skript:

  • Hook in den ersten 2 Sekunden: eine überraschende Behauptung, Zahl oder Frage. Kein "Ciao a tutti", kein "In questo video".
  • 5–9 Szenen, eine Idee pro Szene, 6–20 Wörter Voiceover pro Szene. Kurze gesprochene Sätze. Schreibe Zahlen so, wie sie gesprochen werden sollen ("vier", nicht "4"), weil der TTS genau das liest, was du schreibst.
  • Fakten müssen wahr sein. Wenn du dir bei einer Zahl nicht sicher bist, lasse sie weg.
  • Beende mit einem Abschluss, dann einer kurzen CTA-Szene (Folgen, Speichern, ein Wort kommentieren). Der CTA bekommt immer seinen eigenen sauberen Bildschirm: <EndScreen title="…" sub="…" actions={['Speichern', 'Folgen']} /> (undurchsichtiger Markenhintergrund, der die Welt/Fotos bedeckt, Maskottchen, wenn der Look eines hat, Marken-Handle-Pille). Lege den CTA niemals über Fotos, eine Welt oder die Visuals einer anderen Szene.
  • ids sind kurze, stabile Slugs. Das Ändern des voiceover einer Szene vertont nur diese Szene neu.

Zeige dem Benutzer das Skript (nur die Voiceover-Zeilen) und warte auf ein OK, bevor du Geld für die Stimme ausgibst, es sei denn, er hat gesagt, er möchte direkt durchgehen.

3. Stimme und Timing

$RS voice <name>: Erzeugt eine MP3-Datei pro Szene mit Gemini 3.8 Flash TTS (Stimme Charon: #1 in der TTS-Arena, natürlich klingendes Italienisch) über OpenRouter, erhält Wort-Zeitstempel aus Nemotron-Transkription und schreibt timeline.json (Frames bei 30 fps pro Szene und pro Wort). Die voice.instructions der Marke steuern Ton und Tempo (schreibe sie in der Sprache des Reels, z.B. "Dokumentationston, entschlossenes Tempo"). Optionen: --scene id1,id2 um einige Szenen zu wiederholen, --voice <name> (Gemini: Charon, Kore, Puck, Aoede, Fenrir, Leda, Orus, Zephyr…), --tier eleven (ElevenLabs v4: ausdrucksstärkste, versteht [excited] [whispers] [pause]-Tags, aber seine vorgefertigten Stimmen sind englische Sprecher), --tier native (Microsoft MAI-Voice-2.1, echte it-IT-Stimmen Luca/Rosa, langsamer und pausierender), --tier budget, --local (roboterhafte macOS-Entwurfsstimme: nur, wenn der Benutzer ausdrücklich nach einem kostenlosen Entwurf fragt. Verwende sie niemals als Fallback: Wenn voice aufgrund des Netzwerks oder des Keys fehlschlägt, behebe das, z.B. führe denselben Befehl mit Netzwerkzugriff erneut aus, und render verweigert sowieso Entwurfs-Stimmen-Szenen). Jeder Clip wird automatisch poliert: Stille an beiden Enden abgeschnitten, nur Pausen über 0,65 s werden verkürzt (normale Atempausen bleiben, sonst klingt die Stimme atemlos), sanfter EQ und Pegel (--raw-voice überspringt es); der unbearbeitete Take wird in assets/vo/raw/ aufbewahrt, und voice <reel> --repolish wiederholt die Politur, ohne für einen neuen Take zu bezahlen. Der Render bringt den Mix auf −14 LUFS. Szenen folgen mit einer hold von 0,2 s aufeinander; erhöhe sie für einen bewussten dramaturgischen Schlag (0,5–0,8). Sprachbefehle erhalten eine natürliche Tempobemerkung; setze "pace": "free" in der Markenstimme, um sie zu entfernen. Mit --speed über 1,3 beginnt selbst eine ruhige Stimme atemlos zu klingen: schlage 1,2–1,3 für sprachlastige Reels vor. Schreibe Voiceover als zusammenhängende Sätze, die in die nächste Szene übergehen, nicht als isolierte Bildunterschriften. Eine Marke kann Stimmen pro Modell festlegen: "voice": {"voices": {"google/gemini-3.8-flash-tts": "Kore"}}.

4. Bildmaterial: Wähle, was jeder Einstellung dient

Nichts ist erzwungen: Wähle pro Einstellung das Material, das am besten aussieht und ehrlich ist, und mische frei. Frage den Benutzer nach seinem Limit für kostenpflichtige Bilder (Standard ≤ 4).

  • Echte Fotos (Geschichte, Nachrichten, reale Orte, Menschen, existierende Objekte): $RS photo <name> search "<englische Anfrage, Jahr, Ort>" listet lizenzfreie Ergebnisse von Wikimedia Commons (Public Domain, CC0, CC BY/BY-SA) und schreibt frames/photos-sheet.png (4 pro Reihe, Listenreihenfolge): schaue es dir an, wähle aus, dann $RS photo <name> get <n> <imgname> → assets/img/<imgname>.jpg (bis zu 3000 px) mit Autor/Lizenz gespeichert in assets/credits.json. Zeige immer den Credit an (<Credit file="img/x.jpg" />, oder <Photo … credit>). Bevorzuge echte Fotos gegenüber KI-Bildern, wann immer das Motiv wirklich existiert hat; präsentiere niemals ein KI-Bild als historisches Foto.
  • KI-Bilder (Illustration, Konzepte, Rekonstruktionen, Szenen, die keine Kamera eingefangen hat): $RS image <name> <imgname> "<Prompt>" mit der künstlerischen Leitung und den Referenzen des Looks.
    • --world: Nano Banana 2.1 bei 4K (3072×5504, ~$0,12): ein Bild, das groß genug für die Kamerawelt oder einen großen Druck ist; bleibt bis ca. 2,8× Zoom scharf.
    • --res 2K|4K mit --model bytedance-seed/seedream-4.5 (4K, $0,04, dichtere Details) oder anderen Modellen, die es unterstützen; --aspect 1:1|3:4|16:9 für nicht-vertikale Drucke.
    • Standard (MAI-Image-2.7, ~800 px, ~$0,035) und --hero (GPT Image 2.6 Sunburst, beste Detailtreue, ~860 px, ~$0,15–0,21): nur für kleine Karten oder Einschübe, niemals für tiefe Zooms oder Vollbild-Hintergründe.
    • --mascot, --ref img/other.png (Kontinuität), --no-style. Beschreibe Motiv und Komposition; der Look übernimmt den Stil. Füge immer "vertical composition, no text" (oder das richtige Seitenverhältnis) hinzu. Schaue dir jedes generierte Bild an (öffne das PNG mit dem Bildanzeige-Tool, view_image).
  • Vektor (SVG/React) wo es sauberer ist als jedes Bild: Diagramme, Zahlen, Karten und Grafiken, Zeitleisten, Symbole ($RS icon <name> <lucide-name…>), UI, Beschriftungen. Baue es mit Sorgfalt: konsistente Strichstärken, nur die Palette des Looks, weiche Schatten und Farbverläufe, großzügige Abstände. Fälsche niemals ein Objekt oder eine Szene mit groben Formen: Wenn es eine Zeichnung braucht, verwende ein KI-Bild; wenn es existiert hat, verwende ein Foto.
  • Auflösungsregel: Auf dem Bildschirm darf ein Bild niemals größer angezeigt werden als seine Pixelbreite (Zoom × Weltbreite ≤ PNG-Breite); rs frames zeigt Unschärfe an, wenn du es brichst.

5. Baue die Szenen: reels/<name>/src/Reel.tsx

Setze die Komponenten aus @rs zusammen (Quelle: ~/ReelStudio/engine/src/lib/index.tsx, lies es, wenn du Details brauchst):

import React from 'react';
import {Reel, Title, BigStat, Bullets, Quote, Compare, Icon, Card, CTA, ImageBG, Mascot, CoverFrame, BrandBG, ReelProps} from '@rs';

export default (p: ReelProps) => (
  <Reel {...p}
    scenes={{
      hook: <><Title kicker="Psychologie" text="Dein Gehirn *liebt* Listen" /><Mascot pos="peek" /></>,
      stat: <BigStat value={4} prefix="≈" label="Elemente im *Arbeitsgedächtnis*" />,
      why:  <Bullets title="Warum sie funktionieren" items={['Teilt das Problem', 'Reduziert den *Aufwand*']} />,
      cta:  <CTA text="Mehr *Gehirn*-Tricks" />,
    }}
    backgrounds={{ hook: <ImageBG src="img/brain.png" /> }}
  />
);

// Optional: ein Titelbild. Animationen werden hier bereits fertig gerendert.
export const Cover = (p: ReelProps) => (
  <CoverFrame brand={p.brand}><BrandBG /><Title text="Dein Gehirn *liebt* Listen" /><Mascot pos="peek" /></CoverFrame>
);
  • Jede Szenen-ID in reel.json benötigt einen Eintrag in scenes. *Wort* setzt dieses Wort in der Akzentfarbe.
  • Komponenten: Title, Kicker, BigStat (Hochzähler), Bullets (zeitgesteuerte Enthüllung über die Szene, oder at=[frames] synchronisiert mit timeline.json Wort-Frames), Quote, Compare (zwei Spalten), Icon (großes Emoji), Card (gerahmtes Bild), CTA, ImageBG (randloser Ken Burns), BrandBG (der Hintergrund des Looks: Papier, Farbverlauf oder einfarbig; es ist der Standardhintergrund), Mascot (das Maskottchen des Looks: pos="peek" schiebt sich von der rechten Kante herein, "corner" sitzt unten rechts im Inhaltsbereich, "center" ist ein großer Hero; src="img/pose.png" verwendet eine generierte Pose). Overlays sind automatisch: Karaoke-Untertitel, Fortschrittsbalken, Handle. Schalte sie mit captions={false} und ähnlichen Props aus.
  • Text auf dem Bildschirm ergänzt das Voiceover. Wiederhole ihn nicht Wort für Wort, da die Untertitel das bereits tun. Halte ihn auf 2–7 Wörter pro Szene.
  • Benutzerdefinierte Visuals sind in Ordnung: Schreibe deine eigenen React-Komponenten in src/ mit useF(), useScene(), useBrand(), interpolate, spring, fitFont, Stage aus @rs. Halte alles deterministisch (kein Math.random, kein Date).
  • Sicherheitszonen (1080×1920): Inhalt zwischen y=200 und y=1180, innerhalb von Stage. Untertitel sitzen bei y≈1250–1450. Nichts Wichtiges unterhalb von y=1500, wo Instagram seine UI platziert.
  • Variiere die Layouts: Verwende niemals dieselbe Komponente drei Szenen hintereinander.

5b. Das Zoom-Format (redaktionelle Premium-Qualität)

Der Weg zur erstklassigen Erklärvideo-Qualität zu jedem Thema, mit dem editoriale Look (saubere Erklärer) oder dem cronaca Look (Geschichte, Wirtschaft, wahre Geschichten mit echten Fotos): Eine große Welt, eine Kamera, die darüber gleitet und zoomt, niemals ein harter Schnitt. Lese die bible des Looks und befolge sie. Die Welt kann aus echten Fotos, 4K-KI-Bildern und Vektorteilen in jeder Mischung bestehen (Schritt 4).

import React from 'react';
import {Reel, ReelProps, Headline, Pill, StatCard, Badge, ChartCard, Source, Credit, Grain, At, WorldGround, WorldImage, EndScreen, CoverFrame, AbsoluteFill, useBrand, useReveal} from '@rs';

const W: [number, number] = [3240, 6300];
// Drucke, die auf einem Papiertisch ausgelegt sind, weit voneinander entfernt, damit die Kamera reisen kann (Fotos von `rs photo`, 3000 px breit)
const P = {crowd: {x: 1050, y: 1600, w: 1600, h: 1186, r: -2}, line: {x: 2200, y: 5050, w: 1500, h: 1206, r: 1.5}};
const world = (
  <>
    <WorldGround w={W[0]} h={W[1]} pattern="lines" step={64} />
    {Object.entries(P).map(([k, p]) => <WorldImage key={k} src={`img/${k}.jpg`} x={p.x} y={p.y} w={p.w} h={p.h} rotate={p.r} radius={6} grade="bw" />)}
    {/* Museumsartige Beschriftungen, ein roter Faden zwischen den Drucken, ein KI-4K-Bild oder SVG-Teile können auch hier leben */}
  </>
);
const OVER = {x: 1620, y: 3250, zoom: 0.34};
const Dim = () => { const b = useBrand(); const o = useReveal(0, 16); return <AbsoluteFill style={{background: b.colors.bg1, opacity: 0.82 * o}} />; };

export default (p: ReelProps) => (
  <Reel {...p} world={world} worldSize={W} overlay={<Grain amount={0.14} />}
    camera={{
      hook: OVER,                                                                  // Überblick über den gesamten Tisch
      crowd: [{x: 1050, y: 1850, zoom: 0.62}, {x: 1170, y: 1720, zoom: 0.95, at: 0.42, move: 40}], // Hereinzoomen, dann in ein Detail eintauchen
      chart: {x: 1620, y: 4400, zoom: 0.42},                                       // Zurückziehen, Welt abdunkeln, Daten zeigen
      line: {x: 2200, y: 5280, zoom: 0.64},
      cta: OVER,
    }}
    scenes={{
      hook: <Headline title={'Der Schwarze Donnerstag\nder Wall Street'} pill="−11% in wenigen Stunden" />,
      crowd: <><StatCard value={12.9} decimals={1} suffix=" Mio." label="gehandelte Aktien: *ein Rekord*" y={900} w={680} delay={150} /><Credit file="img/crowd.jpg" y={1165} /></>,
      chart: <><Dim /><ChartCard type="line" data={[381, 199, 294, 41]} labels={['Sep 1929', '', '', 'Jul 1932']} title="Dow Jones, 1929–1932" x={540} y={720} w={940} h={640} /><Badge value="−89%" label="vom Höchststand" x={540} y={1150} color="#B3261E" delay={150} /><Source text="Quelle: S&P Dow Jones Indices" y={1215} /></>,
      line: <><StatCard value={25} suffix="%" label="Arbeitslose in den USA 1933" y={880} w={720} /><Credit file="img/line.jpg" y={1170} /></>,
      cta: <EndScreen title={"Geschichten, die\ndie Wirtschaft verändert haben"} sub="Jede Woche eine Krise, erklärt" actions={['Speichern', 'Folgen']} />,  // eigener Bildschirm, niemals über der Welt
    }}
  />
);
export const Cover = (p: ReelProps) => (
  <CoverFrame brand={p.brand} world={world} worldSize={W} shot={{x: 1050, y: 1900, zoom: 0.62}}>
    <Headline title={"Schwarzer Donnerstag:\nDer Crash von 1929"} />
  </CoverFrame>
);

6. Generiere Frames

$RS frames <name> erzeugt alle Frames (Standbilder, die von Remotion gerendert werden). Siehe sie dir genau an — verwende rs frames wiederholt, bis jede Szene perfekt aussieht (vergleiche mit dem Look-Bibel-Layout und den Referenzen). Wenn ein Bild unscharf ist, ist es zu klein (siehe Auflösungsregel in Schritt 4); wenn Text abgeschnitten ist, passe Layout oder Schriftgröße an; wenn ein Übergang ruckelt, passe die Kamera-Keyframes an. Wiederhole, bis alle Frames makellos sind. Nur dann rendere.

7. Rendere

einmalige Hintergrundaufgabe, der Benutzer arbeitet mit anderen Projekten weiter, während sie läuft. $RS render <name> (im Hintergrund). Sobald der Render abgeschlossen ist (Benachrichtigung), sieh dir das Ergebnis an (open reels/<name>/out/<name>.mp4). Wenn der Benutzer nachgereichte Änderungen wünscht, aktualisiere das Skript/die Szene und wiederhole ab dem relevanten Schritt (z.B. Schritt 4 für ein neues Bild, Schritt 5 für einen Layout-Tweak, Schritt 6, dann erneut Schritt 7).

8. Veröffentlichen

Lade nach dem Rendern auf reels/<name>/out/ hoch — wenn möglich automatisch. Wenn etwas schief geht, überarbeite und rendere neu. Lösche nichts ohne Zustimmung des Benutzers.

Best Practices und Warnungen

  • Engpässe managen: voice ist am teuersten (KI-APIs) und render am langsamsten. Optimiere zuerst das Skript.
  • Nicht spammen: Generiere keine unnötigen Bilder oder Wiederholungen. Verwende Standard- und Held-Bilder sparsam.
  • Dateipfade sind stabil: Das Ändern einer id erzeugt eine neue Szene; das Ändern von voiceover löst nur eine Neuvertonung für diese ID aus.
  • Fehlerbehandlung: Wenn ein Befehl fehlschlägt (Netzwerk, fehlender Key, API-Fehler), diagnostiziere und behebe das Problem, anstatt es zu umgehen. Versuche nicht, Dateien manuell zu bearbeiten, es sei denn, der Befehl leitet dich dazu an.
  • Sicherheit: reelstudio setup benötigt Schreibzugriff auf ~/ReelStudio; voice, image und photo benötigen Netzwerkzugriff und den API-Key.

Zusammenfassung der wichtigsten Befehle:

BefehlBeschreibung
$RS new "<Thema>" --brand <brand>Neues Reel erstellen
$RS voice <name>Sprachausgabe und Zeitstempel generieren
$RS image <name> <imgname> "<Prompt>"KI-Bild generieren
$RS photo <name> search "<query>"Echte Fotos durchsuchen
$RS frames <name>Frames zur Überprüfung rendern
$RS render <name>Finales Video rendern
$RS listVerfügbare Marken und Looks auflisten

Fülle jeden Befehl mit der nötigen Sorgfalt und Präzision aus. Du bist der Produzent, Regisseur, Kameramann und Cutter in einem – mache jedes Reel zu einem Meisterwerk.

Integration in den Codex-Ordner

Wenn du auf eine Datei in ~/ReelStudio/ zugreifen musst, aber die Sicherheitsrichtlinien dies blockieren:

  • Bitte den Benutzer um Erlaubnis, den Ordner zu öffnen (codex open ~/ReelStudio)
  • Oder führe einen Befehl aus, der die Datei liest/schreibt (z.B. cat ~/ReelStudio/brands/default.json)

Wenn ein Befehl längere Zeit läuft, informiere den Benutzer und fahre mit anderen Aufgaben fort.

Verwandte Skills