Communitygithub.com

tinh2/skills-hub-registry

Créez des vidéos programmatiques avec Remotion (React). Couvre les compositions, animations, séquençage, transitions, intégration audio/vidéo, physique ressort, animations de texte, génération de voix off avec ElevenLabs TTS, intégration FFmpeg, sous-titres, 3D avec Three.js, graphiques et rendu. Basé sur les meilleures pratiques officielles de Remotion.

Qu'est-ce que skills-hub-registry ?

Ce skill permet de générer des vidéos de manière programmatique en utilisant React avec Remotion. Il couvre l'ensemble des fonctionnalités essentielles : création de compositions avec dimensions, FPS et durée personnalisés ; animations fluides via `useCurrentFrame()`, `interpolate()` et des ressorts physiques (spring) ; séquençage avec `<Sequence>` et `<Series>` pour organiser les scènes ; transitions avancées comme le fondu, le glissement ou l'essuyage avec le package `@remotion/transitions`. Il intègre également la gestion audio (trim, fondu, volume dynamique) et vidéo (avec recommandation d'utiliser `<OffthreadVideo>` pour les performances), la génération de voix off via l'API ElevenLabs TTS avec calcul automatique de la durée, et l'utilisation de FFmpeg directement via Remotion. Enfin, il détaille les bonnes pratiques : pas d'animations CSS, utilisation systématique de `staticFile()` pour les assets, préchargement des séquences avec `premountFor`, et typage des props avec `satisfies`. Ce skill est basé sur les sources officielles de Remotion (remotion-dev/skills) et convient à tout projet Remotion.

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

Demander à votre IA préférée

Ouvre une nouvelle conversation avec cette compétence d'agent déjà préchargée.

Documentation

Remotion -- Création de vidéos en React

Utilisez ce skill lorsque vous travaillez avec du code Remotion. Remotion vous permet de créer des vidéos de manière programmatique en utilisant des composants React.

Configuration du projet

npx create-video@latest my-video
cd my-video
npm start        # Aperçu dans le navigateur
npm run render   # Rendu en MP4

Compositions

Un <Composition> définit une vidéo rendable avec ses dimensions, son FPS et sa durée.

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: "Bonjour le monde" } satisfies MyVideoProps}
  />
);

Utilisez les déclarations type pour les props (pas interface) afin d'assurer la sécurité de typage des defaultProps.

Utilisez <Folder> pour organiser les compositions dans la barre latérale. Utilisez <Still> pour les sorties mono-image (miniatures, images OG).

Animations

Toutes les animations DOIVENT utiliser useCurrentFrame(). Les transitions CSS et les classes d'animation Tailwind sont INTERDITES -- elles ne seront pas rendues correctement.

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 }}>Bonjour le monde !</div>;
};

Animations par ressort (Spring)

Les ressorts produisent un mouvement naturel. Ils animent de 0 à 1.

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

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

const scale = spring({ frame, fps });
// Avec configuration :
const smooth = spring({ frame, fps, config: { damping: 200 } }); // Pas de rebond
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 } });

Utilisez le paramètre delay pour retarder le démarrage du ressort :

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

Interpolation

// Interpolation linéaire avec limitation
const opacity = interpolate(frame, [0, 100], [0, 1], {
  extrapolateRight: "clamp",
  extrapolateLeft: "clamp",
});

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

Séquençage

Sequence

Utilisez <Sequence> pour retarder l'apparition des éléments. Utilisez toujours premountFor pour précharger les composants.

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>

Utilisez layout="none" pour éviter le wrapper de positionnement absolu.

Series

Utilisez <Series> pour une lecture séquentielle sans chevauchement :

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>

Un offset négatif crée des transitions avec chevauchement :

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

Transitions

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>

Superpositions de fuites de lumière

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>

Une superposition ne peut pas être adjacente à une transition ou à une autre superposition.

Audio

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

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

// Avec rognage (valeurs en images)
<Audio src={staticFile("audio.mp3")} trimBefore={2 * fps} trimAfter={10 * fps} />

// Contrôle du volume
<Audio src={staticFile("audio.mp3")} volume={0.5} />

// Volume dynamique (callback reçoit l'image)
<Audio src={staticFile("audio.mp3")} volume={(f) =>
  interpolate(f, [0, 30], [0, 1], { extrapolateRight: "clamp" })
} />

// Changement de vitesse
<Audio src={staticFile("audio.mp3")} playbackRate={1.5} />

// Démarrage audio différé
<Sequence from={1 * fps}>
  <Audio src={staticFile("audio.mp3")} />
</Sequence>

Plusieurs composants <Audio> se superposent automatiquement.

Intégration vidéo

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

// Vidéo de base
<Video src={staticFile("video.mp4")} />

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

// Vitesse, volume, boucle
<Video src={staticFile("video.mp4")} playbackRate={2} volume={0.5} loop />

// Pour les performances de rendu, utilisez OffthreadVideo
import { OffthreadVideo } from "remotion";
<OffthreadVideo src={staticFile("video.mp4")} />

Utilisez TOUJOURS <OffthreadVideo> pour de meilleures performances de rendu. Utilisez <Video> uniquement pendant l'aperçu.

Voix off avec ElevenLabs TTS

Générez la parole par scène, puis utilisez calculateMetadata pour dimensionner la composition dynamiquement.

Générer l'audio

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: "Bienvenue dans le spectacle.",
      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);

Durée dynamique

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 };
};

Ressources

Placez les fichiers dans public/ et référencez-les avec staticFile() :

import { staticFile, Img } from "remotion";

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

N'utilisez JAMAIS require() ou import pour les fichiers multimédia. Utilisez toujours staticFile().

Polices

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

// Ou polices locales
const { fontFamily } = loadFont({
  url: staticFile("fonts/MyFont.woff2"),
  display: "swap",
});

FFmpeg dans Remotion

FFmpeg est intégré -- aucune installation nécessaire :

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

Pour le rognage, préférez les props trimBefore/trimAfter à FFmpeg. Utilisez FFmpeg pour la conversion de format ou les opérations que Remotion ne peut pas effectuer nativement.

Lorsque vous utilisez FFmpeg pour rogner, vous DEVEZ ré-encoder pour éviter les images figées :

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

Rendu

# Rendre une composition spécifique
npx remotion render MyVideo output.mp4

# Rendre une image fixe
npx remotion still MyVideo --frame=100 thumbnail.png

# Avec des props personnalisées
npx remotion render MyVideo output.mp4 --props='{"title": "Personnalisé"}'

# Codec spécifique
npx remotion render MyVideo output.webm --codec=vp8

Modèles courants

Vidéo basée sur des scènes

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>
        );
      })}
    </>
  );
};

Musique de fond + voix off

<>
  {/* Musique de fond à faible volume */}
  <Audio src={staticFile("music/bg.mp3")} volume={0.12} loop />

  {/* Voix off des scènes à plein volume */}
  <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>
</>

Règles clés

  1. Pas d'animations CSS -- tout mouvement via useCurrentFrame() + interpolate()/spring()
  2. Pas de classes d'animation Tailwind -- elles ne sont pas rendues correctement
  3. Toujours staticFile() pour les ressources, jamais require()
  4. Toujours prémonter les Sequences avec premountFor
  5. Utilisez <OffthreadVideo> pas <video> pour le rendu
  6. Écrivez les durées en secondes et multipliez par fps
  7. Utilisez le mot-clé satisfies pour la sécurité de typage des defaultProps

Source : remotion-dev/skills, remotion.dev

Skills associés