Opus 5.5 crée des vidéos par le code : 5 exemples étonnants et leurs prompts
Comprenez le rendu image par image et la création sonore avec Opus 5.5, puis explorez cinq exemples — magicien pixelisé, interface, histoire du jeu vidéo, danse et histoire de l’AI — avec leurs prompts détaillés.
Pour créer une vidéo, Opus 5.5 écrit du code d’animation : il dessine les images, organise les plans et le son, puis produit un MP4 par rendu. Magicien pixelisé, interface animée, histoire du jeu vidéo et habillage de danse peuvent suivre cette méthode.
Le principe : dessiner chaque image, puis assembler la vidéo
Imaginez un flipbook dessiné par du code. Celui-ci détermine les éléments présents à un instant donné, leur position et leur évolution. Les outils de rendu extraient ces images dans l’ordre et les encodent pour obtenir la vidéo.
Dans une approche web image par image, la page peut exposer render(t) ou seek(t) : un temps donné produit l’image correspondante. À 30fps, l’image n correspond ainsi à t = n / 30. Playwright ouvre la page, se place au temps voulu et réalise une capture ; FFmpeg assemble les images et la piste sonore en MP4. Remotion et HyperFrames proposent leurs propres contrôles du temps ou des images.
Le rendu doit être reproductible à un instant donné. Fixez la graine des effets aléatoires, attendez le chargement des polices avant les captures et évitez une animation dépendant seulement de minuteurs qui avancent en continu. Sinon, le rendu isolé d’un plan peut changer.
Le code peut aussi produire le son. En Python, numpy et scipy permettent de calculer les ondes des notes et des percussions, puis de les superposer dans le temps pour créer musique et effets. Avec une musique existante, repérez d’abord les temps, puis organisez les mouvements. Un modèle vocal peut produire la narration, synchronisée sur la même chronologie.
Sept familles de code pour différents rendus
| Approche | Usage principal |
|---|---|
| JavaScript＋Canvas 2D | Pixels, graphismes en deux dimensions et illustrations |
| HTML／CSS／SVG | Interfaces, texte et animations de logiciels |
| Shaders WebGL | Lignes de balayage, grain, reflets et particules |
| Three.js | Objets en trois dimensions, espaces et mouvements de caméra |
| p5.js＋p5.brush | Crayon de couleur, aquarelle et traits sur papier |
| HyperFrames／Remotion | Organisation de la chronologie, des plans et du rendu complet |
| Manim | Formules, géométrie et démonstrations mathématiques |
Ces approches se combinent : Canvas dessine un jeu, un shader lui ajoute une texture de vieux téléviseur, puis Three.js ouvre une scène en trois dimensions. Pour représenter précisément un objet réel, vous pouvez fournir un modèle 3D existant.
1. Magicien pixelisé : petite surface et boucle d’action complète
L’animation enchaîne attente, levée du bâton et charge, lancement du sort, puis retour au repos. Le personnage est dessiné sur une petite surface de 128×96, agrandie par un facteur entier. Sa posture change environ 8–12 fois par seconde, tandis que les étincelles et projectiles bougent à chaque image, pour garder le rythme saccadé du pixel art.
Le prompt suivant reprend sous une forme condensée les paramètres et contraintes de fabrication de cet exemple. Vous pouvez le copier directement.
Crée un HTML autonome qui montre un magicien pixelisé lançant un sort, avec JavaScript natif et Canvas 2D, sans bibliothèques, images ni ressources réseau.
Utilise une surface logique de 128×96, centrée et agrandie par un facteur entier. Désactive le lissage des images et place toutes les coordonnées sur des pixels entiers. Aucun dégradé, anticrénelage ni ombre floue. Limite la scène à environ 24 couleurs : bleu foncé et violet pour le fond, couleurs chaudes pour le personnage et quelques accents lumineux pour la magie.
Construis un magicien d’environ 24×32 avec des rectangles de pixels : chapeau courbé, barbe, robe bicolore et bâton serti d’une pierre. Fais de la tête, des bras, du bâton et du bas de la robe des paramètres de posture contrôlables. Exécute l’animation à 60fps, quantifie les postures à 8–12 changements par seconde et garde les particules en mouvement continu.
Enchaîne oscillation au repos, levée du bâton et charge, étincelles convergeant vers la pierre, émission d’un anneau et de projectiles, puis retour à la position initiale. Ajoute un tremblement de 1–2 pixels au lancement. Préalloue les particules et réutilise-les, sans créer de nouveaux objets dans la boucle.
Garde une lune, quelques étoiles et un sol de pierre en arrière-plan. La lumière de la pierre souligne la silhouette. Assure une jonction naturelle entre la fin et le début et des pixels nets quelle que soit la taille de la fenêtre.
2. Interface en transformation : une forme, plusieurs composants
Une forme noire et blanche devient bouton, chargement, lecteur, curseur et graphique. Le même élément évolue sans interruption, tandis que les clics et glissements du pointeur déclenchent les actions.
L’interface repose sur HTML／CSS／SVG. Des ressorts calculent les retours, les temps musicaux organisent les actions et quatre sous-images sont mélangées pour chaque image afin de produire le flou de mouvement.
Demande-moi d’abord 8–12 états d’interface, une palette noir et blanc ou à une seule couleur d’accent, et une musique disponible d’environ 120 BPM. Liste la correspondance entre états et temps musicaux, puis attends ma confirmation avant de commencer.
Crée une animation d’interface HTML de 1440×1440. Utilise un fond gris chaud clair, des composants noirs et blancs et la police Geist. Conserve un seul sujet pendant toute l’animation : transforme sa taille, ses arrondis et son contenu interne, sans remplacer les composants par des coupes. Le pointeur doit réellement cliquer ou glisser.
À 120 BPM, organise 7 mesures : bouton→chargement→coche de confirmation→Dynamic Island→lecteur→barre de progression→curseur de volume→interrupteur→onglets→graphique→palette de commandes→notification→bouton. Associe une action à chaque temps et fais suivre le sujet par le zoom de la caméra.
Calcule tous les états avec seek(t), sans CSS transition, minuteurs ni état accumulé de l’image précédente. Utilise des ressorts analytiques ; calcule séparément les ressorts des deux extrémités de l’indicateur pour produire un étirement. Pendant le glissement, la position du pointeur détermine la valeur ; le rebond commence au relâchement.
Analyse les temps de la musique en Python et aligne actions et effets sonores sur ceux-ci. Avec Playwright, prends 4 échantillons par image, puis mélange-les avec FFmpeg pour le flou de mouvement. Exporte à 60fps. Avant le rendu complet, vérifie des images fixes à chaque temps.
Évite explosions de particules, lueurs, dégradés et rebonds superflus. Contrôle séparément l’arrivée et le départ des anciens et nouveaux textes pour éviter leur superposition. N’ajoute pas will-change aux éléments agrandis ou contenant du texte. La fin et le début doivent se raccorder, y compris la position et la vitesse du pointeur.
3. Histoire du jeu vidéo : changer de rendu avec les époques
Cette histoire du jeu vidéo de deux minutes réunit pixel art Canvas, effets de vieux téléviseur WebGL et scènes 3D Three.js, avec une musique synthétisée en Python. Les premiers jeux utilisent pixels et lignes de balayage, puis la vidéo entre dans des couloirs, des châteaux et des mondes de blocs.
Crée un film de 120 secondes sur l’histoire du jeu vidéo, avec les variations émotionnelles et l’ampleur épique d’une bande-annonce de documentaire.
Format : 1920×1080, 60fps. Dessine toutes les images par le code, sans récupérer d’images ni de vidéos externes. Compose et synthétise toi-même la musique par le code, sans échantillons, ressources audio ni instruments virtuels. Organise les changements de plan selon le rythme musical.
À la fin, assemble images et musique en MP4 et enregistre le fichier dans le dossier de sortie que j’indiquerai.
4. Danse pop : séparer la personne et l’habillage animé
Un modèle vidéo produit d’abord une danse de 15 secondes sur fond vert. Opus retire ensuite le vert et ajoute grands caractères, ruban adhésif, écrans partagés, changements de fond et texte 3D autour du personnage, avec un habillage qui suit la musique.
Les mouvements de la personne viennent de la vidéo ; le décor et les effets sont créés par le code. Il est inutile de redessiner une danse complexe par programmation. Conservez la séquence du personnage et concentrez la production sur l’incrustation, les couches et le rythme.
5. Histoire de l’AI : un même protagoniste visuel tout au long du film
Cette histoire de l’AI de trois minutes est réalisée avec Remotion dans Claude Code. SVG, Canvas et d’autres éléments de code dessinent les images, un modèle vocal assure la narration et Python synthétise la musique.
Un token lumineux relie l’ensemble : connexions d’attention, modèles de langage, multimodalité, raisonnement et appels d’outils suivent le même fil visuel. Pour un film long, il faut d’abord construire l’histoire et le storyboard, puis produire scène par scène.
Avec Remotion, crée une animation de 180 secondes sur l’histoire de l’AI, en 1920×1080, à 30fps, soit 5400 images. Pars du mécanisme d’attention de 2017, puis aborde modèles de langage, multimodalité, raisonnement, agents et questions encore ouvertes sur l’AGI. Adopte la forme d’un essai visuel cinématographique.
Fais traverser le film au token lumineux “the”. Écris d’abord STORYBOARD.md avec le temps, les images, les sous-titres et les transitions de chaque scène. Organise chaque scène séparément, puis intègre-la à la composition principale.
Suis ces chapitres : 0–15 secondes, un mot isolé ; 15–35 secondes, connexions d’attention ; 35–55 secondes, développement des modèles de langage ; 55–80 secondes, ajustement sur instructions et ChatGPT ; 80–100 secondes, multimodalité ; 100–125 secondes, raisonnement ; 125–150 secondes, outils et agents ; 150–170 secondes, question de l’AGI ; les 10 dernières secondes reviennent au token et au titre.
Utilise SVG, Canvas, CSS et des graphismes procéduraux, sans images externes ni vidéos existantes. Privilégie un fond sombre et des accents chauds. Pilote les mouvements par ressorts et courbes d’accélération ; fais naître les transitions des relations graphiques entre scènes voisines.
Garde les textes courts et laisse chaque passage à l’écran au moins 2.5 secondes. Vérifie années, noms et titres d’articles scientifiques, et consigne les incertitudes dans NOTES.md. Après chaque scène, utilise remotion still pour examiner 3–4 images fixes, puis corrige les chevauchements et la mise en page avant de continuer.
Prévois un emplacement facultatif pour la piste public/music.mp3. Sans piste disponible, tu peux d’abord exporter une version silencieuse. Exporte le résultat avec remotion render vers out/film.mp4 et livre aussi les notes de création et NOTES.md.
Les sept informations les plus utiles dans un prompt
Utilisez role pour le rôle de production, inputs pour les ressources nécessaires, direction pour le style et les effets interdits, structure pour les plans et le rythme, build pour la technique et l’export, gotchas pour les erreurs fréquentes et start pour convenir de la première vérification et du moment de confirmation.
Précisez surtout ce que vous ne voulez pas : texte minuscule partout, apparition simultanée de tous les éléments ou grands titres centrés sur des fonds en dégradé à répétition. Regardez d’abord le storyboard et les images clés, puis quelques secondes d’essai aux endroits où le mouvement compte. Ne lancez le rendu complet qu’après confirmation.
Avant la livraison, examinez des images extraites pour contrôler la lisibilité sur mobile, les chevauchements, les arrêts du mouvement, la composition, les temps et la synchronisation du son. Notez les instants problématiques et relancez localement le rendu. Ces critères vérifiables sont plus utiles pour réviser qu’une demande répétée de résultat « plus haut de gamme ».
