Que fait Remotion Compose ?
Vous transformez un brief en langage naturel en une composition Remotion complète, prête à être prévisualisée – du vrai code React/TypeScript avec animation basée sur les images. Le résultat est un fichier .tsx dans src/compositions/, enregistré dans src/Root.tsx, que l'utilisateur peut immédiatement parcourir dans Studio ou confier à remotion-render.
Déclenchez ce skill sur toute demande de création, génération, animation ou "écriture du code vidéo pour" une démo produit, un walkthrough, une mise en avant de fonctionnalité ou une animation marketing – y compris "construis une vidéo de 20 secondes montrant X."
Étape 1 – Extraire le brief
Ne commencez pas à coder tant que vous n'avez pas ces informations. Posez les questions en un seul bloc compact ; comblez les lacunes évidentes avec des valeurs par défaut judicieuses plutôt que de bloquer :
- Durée en secondes, et fps (par défaut 30 – la norme pour les vidéos produit et marketing, et la moitié du coût de rendu par rapport à 60. Utilisez 60fps uniquement pour animer des mouvements fins de curseur ou des interfaces défilantes où 30fps aurait des saccades visibles).
- Scènes – ce qui se passe, dans l'ordre. Incitez à obtenir une liste de séquences : "logo, puis trois fonctionnalités, puis un CTA" plutôt que "une démo de mon application".
- Marque – les couleurs hexadécimales primaire/accent/arrière-plan, et la police (un nom de famille de police
@remotion/google-fonts). - Rapport d'aspect / plateforme – 16:9 paysage (1920×1080), 9:16 portrait (1080×1920) pour les réseaux sociaux, ou 1:1 carré (1080×1080).
- Texte – les vrais titres/noms de fonctionnalités/texte CTA. N'inventez jamais de revendications produit ; demandez les mots réels.
Convertissez les secondes en images partout : durationInFrames = seconds * fps. Longueurs totales typiques : 15-60s pour une démo sociale/produit, 6-15s pour une publicité.
Étape 2 – Construire un plan de scènes
Un <Composition> par vidéo, un composant par scène, assemblés sur la timeline avec <Sequence>. Établissez le budget d'images avant d'écrire le code :
Total : 20s @ 30fps = 600 images
Intro (logo) images 0-90 (Sequence from=0 durationInFrames=90)
Fonctionnalité 1 images 90-240 (Sequence from=90 durationInFrames=150)
Fonctionnalité 2 images 240-390 (Sequence from=240 durationInFrames=150)
Fonctionnalité 3 images 390-540 (Sequence from=390 durationInFrames=150)
CTA outro images 540-600 (Sequence from=540 durationInFrames=60)
Seuils de rythme lors de la budgétisation :
- Accordez à chaque séquence qui porte du texte au moins 2 secondes (60 images à 30fps) – animation d'entrée plus maintien. Un titre a besoin d'environ 150-200 ms de maintien par mot pour être lisible ; un titre de 6 mots nécessite environ 1 seconde de maintien après son apparition.
- Animations d'entrée : 10-20 images. Fondus et sorties : 12-15 images. Plus longues sont perçues comme lentes, plus courtes comme un défaut.
- Aucune scène plus courte qu'environ 45 images sauf s'il s'agit d'un flash délibéré.
<Sequence from={F}> décale l'horloge locale d'un enfant de sorte qu'à l'intérieur de ce composant, useCurrentFrame() commence à 0. Animez chaque scène comme si elle commençait à l'image 0.
Étape 3 – Référence de l'API principale
useCurrentFrame()– l'image courante (l'horloge). Tout s'anime en fonction de cette valeur.useVideoConfig()–{ fps, width, height, durationInFrames }.interpolate(frame, [inFrames], [outValues], opts)– mappage linéaire. Passez toujours{ extrapolateLeft: "clamp", extrapolateRight: "clamp" }pour les entrées/sorties afin que les valeurs ne dépassent pas leur plage.spring({ frame, fps, config })– simulation physique de 0→1 (léger dépassement). À utiliser pour tout ce qui doit paraître vivant (apparitions, glissements, agrandissements).AbsoluteFill– un div plein écran positionné en absolu ; la couche de base de chaque scène.Sequence– décale et limite temporellement les enfants (le planificateur de scènes).Series/Series.Sequence– scènes consécutives sans avoir à calculer manuellement les décalagesfrom.Img,staticFile– voir Étape 6.
Étape 4 – spring() vs interpolate()
Utilisez spring() quand… | Utilisez interpolate() quand… |
|---|---|
| Le mouvement doit sembler physique – apparitions, rebonds, agrandissements, glissements | Vous avez besoin d'un contrôle linéaire précis entre des images exactes |
| Vous voulez un atterrissage/dépassement naturel | Fondus (opacité 0→1), changements de couleur, barres de progression, tout ce qui est synchronisé à l'image |
| Entrées de cartes, logos, badges | Fondus et sorties où un dépassement serait inesthétique |
Modèle – pilotez une transformation avec un spring, une opacité avec interpolate :
const { fps } = useVideoConfig();
const frame = useCurrentFrame();
const pop = spring({ frame, fps, config: { damping: 200 } }); // 0 → 1, vivant
const opacity = interpolate(frame, [0, 15], [0, 1], { extrapolateRight: "clamp" });
const scale = interpolate(pop, [0, 1], [0.8, 1]);
damping: 200 est la configuration de travail – un atterrissage rapide avec un dépassement à peine perceptible. Un damping plus faible (~10-20) rebondit visiblement ; utilisez-le uniquement lorsque le rebond est le but.
Étape 5 – Structure standard de démo produit
Codez cette forme sauf indication contraire du brief : introduction logo/marque → N mises en avant de fonctionnalités → outro CTA. Rendez-la basée sur les données (Étape 6) pour que les variations soient gratuites.
// src/compositions/ProductDemo.tsx
import {
AbsoluteFill, Sequence, useCurrentFrame, useVideoConfig,
interpolate, spring,
} from "remotion";
import { loadFont } from "@remotion/google-fonts/Inter";
const { fontFamily } = loadFont();
export type Feature = { title: string; body: string };
export type ProductDemoProps = {
brand: string;
colors: { bg: string; fg: string; accent: string };
logoText: string;
features: Feature[];
cta: string;
};
const Intro: React.FC<{ text: string; colors: ProductDemoProps["colors"] }> = ({ text, colors }) => {
const frame = useCurrentFrame();
const { fps } = useVideoConfig();
const s = spring({ frame, fps, config: { damping: 200 } });
const scale = interpolate(s, [0, 1], [0.7, 1]);
const opacity = interpolate(frame, [0, 12], [0, 1], { extrapolateRight: "clamp" });
return (
<AbsoluteFill style={{ backgroundColor: colors.bg, justifyContent: "center", alignItems: "center" }}>
<h1 style={{ fontFamily, fontSize: 120, color: colors.fg, transform: `scale(${scale})`, opacity }}>
{text}
</h1>
</AbsoluteFill>
);
};
const FeatureCallout: React.FC<{ feature: Feature; colors: ProductDemoProps["colors"] }> = ({ feature, colors }) => {
const frame = useCurrentFrame();
const { fps } = useVideoConfig();
const slide = spring({ frame, fps, config: { damping: 200 } });
const x = interpolate(slide, [0, 1], [-60, 0]);
const opacity = interpolate(frame, [0, 15], [0, 1], { extrapolateRight: "clamp" });
return (
<AbsoluteFill style={{ backgroundColor: colors.bg, justifyContent: "center", paddingLeft: 160 }}>
<div style={{ transform: `translateX(${x}px)`, opacity }}>
<div style={{ fontFamily, fontSize: 32, color: colors.accent, fontWeight: 700, letterSpacing: 2 }}>
{feature.title.toUpperCase()}
</div>
<div style={{ fontFamily, fontSize: 64, color: colors.fg, maxWidth: 1100, marginTop: 16 }}>
{feature.body}
</div>
</div>
</AbsoluteFill>
);
};
const Outro: React.FC<{ cta: string; colors: ProductDemoProps["colors"] }> = ({ cta, colors }) => {
const frame = useCurrentFrame();
const opacity = interpolate(frame, [0, 18], [0, 1], { extrapolateRight: "clamp" });
return (
<AbsoluteFill style={{ backgroundColor: colors.accent, justifyContent: "center", alignItems: "center" }}>
<h2 style={{ fontFamily, fontSize: 84, color: colors.bg, opacity }}>{cta}</h2>
</AbsoluteFill>
);
};
export const ProductDemo: React.FC<ProductDemoProps> = ({ colors, logoText, features, cta }) => {
const intro = 90;
const per = 150;
const outro = 60;
return (
<AbsoluteFill>
<Sequence durationInFrames={intro}>
<Intro text={logoText} colors={colors} />
</Sequence>
{features.map((f, i) => (
<Sequence key={i} from={intro + i * per} durationInFrames={per}>
<FeatureCallout feature={f} colors={colors} />
</Sequence>
))}
<Sequence from={intro + features.length * per} durationInFrames={outro}>
<Outro cta={cta} colors={colors} />
</Sequence>
</AbsoluteFill>
);
};
Enregistrez-le dans src/Root.tsx, en calculant durationInFrames à partir des mêmes nombres et en fournissant defaultProps :
<Composition
id="ProductDemo"
component={ProductDemo}
durationInFrames={90 + 3 * 150 + 60}
fps={30}
width={1920}
height={1080}
defaultProps={{
brand: "Acme",
colors: { bg: "#0B0B0F", fg: "#FFFFFF", accent: "#6C5CE7" },
logoText: "Acme",
features: [
{ title: "Fast", body: "Ship in seconds, not sprints." },
{ title: "Simple", body: "One prompt, one video." },
{ title: "Yours", body: "Your brand, your copy." },
],
cta: "Start free →",
}}
/>
Pour une vidéo verticale/réseaux sociaux, définissez width={1080} height={1920} ; pour un carré, 1080×1080. Gardez les composants identiques – seule la toile change.
Étape 6 – Props basées sur les données et ressources statiques
La composition ci-dessus est entièrement basée sur les données : chaque mot et chaque couleur est une prop. C'est le but – les variantes (nouveau texte, nouvelle palette, texte localisé) ne nécessitent aucune nouvelle sollicitation ; il suffit de passer des props différentes (remotion-render le fait à partir d'un fichier JSON pour les lots).
Les ressources statiques (logos, captures d'écran, audio) se trouvent dans public/assets/ et sont référencées avec staticFile() – jamais une importation ou un chemin brut :
import { Img, staticFile } from "remotion";
<Img src={staticFile("assets/logo.png")} />
Étape 7 – Résultat
Enregistrez le fichier final dans src/compositions/<VideoName>.tsx, enregistrez-le dans src/Root.tsx, et dites à l'utilisateur de prévisualiser avec npx remotion studio (http://localhost:3000). Puis passez le relai : "Parcourez-le dans Studio. Dites-moi quoi changer – trop rapide, mauvaise couleur, texte différent – et je modifierai et relancerai le rendu (remotion-render)."
À NE PAS FAIRE
- N'animez PAS avec des transitions/animations CSS ou
setTimeout/setInterval. Remotion rend les images de manière indépendante et en parallèle ; tout ce qui n'est pas dérivé deuseCurrentFrame()est invisible ou incohérent dans le rendu final, même si cela semble correct dans l'aperçu du navigateur. - N'utilisez PAS
Math.random()pour des effets de particules/dispersés – chaque worker de rendu obtient des valeurs différentes et les images ne correspondent plus. Utilisezrandom(seed)de Remotion pour un pseudo-aléatoire déterministe. - Ne récupérez PAS de données et n'attendez PAS de travail asynchrone sans
delayRender()/continueRender()– le moteur de rendu capture l'image avant l'arrivée des données. - Ne codez PAS en dur fps, width ou height à l'intérieur des composants de scène – lisez-les depuis
useVideoConfig()pour que le passage de 30 à 60fps ou du paysage au portrait ne casse pas tous les minutages et mises en page. - N'omettez PAS
extrapolateLeft/Right: "clamp"sur les interpolations d'entrée/sortie – l'opacité dépasse 1 et les éléments dérivent hors du canvas après la fin de leur plage. - N'inventez PAS de titres, de revendications de fonctionnalités ou de CTA – utilisez le texte réel de l'utilisateur, et demandez-le s'il manque.
Barre de qualité
- Chaque valeur animée est une fonction pure de
useCurrentFrame()(plus les props) – le défilement arrière dans Studio est identique au défilement avant. - Le budget d'images dans le plan correspond exactement à
durationInFramesdansRoot.tsx, et aucun texte ne reste visible moins que son minimum de lisibilité. - Tout le texte et les couleurs arrivent via des props typées avec
defaultPropsfournis – pas de littéraux cachés dans les composants de scène. - Les ressources se chargent via
staticFile(); le fichier s'enregistre proprement et s'affiche dans Studio sans erreur de console.