Communitygithub.com

BintzGavin/helios-skills

Créez une vidéo, un MP4, un GIF, une animation, un clip musical, un court métrage, un film explicatif, une animation de graphiques, une démo produit, un logo animé ou une vidéo sociale à partir de code. Écrivez une page HTML qui dessine chaque image en fonction du temps t, rendez-la image par image en MP4 avec Helios, vérifiez les images fixes et les planches contacts, et ajoutez une bande-son. Utilisez chaque fois que l'utilisateur demande une vidéo ou un fichier d'animation.

Qu'est-ce que helios-skills ?

Cette compétence Helios permet de générer des vidéos, animations et GIFs à partir d'une simple page HTML. Elle repose sur le principe qu'une vidéo Helios est une page HTML unique contenant une fonction `window.renderAt(t)`, où chaque image est une fonction pure du temps `t`. Le rendu est effectué via Helios, qui charge la page dans un navigateur Chrome headless, appelle `renderAt(t)` pour chaque image, capture et encode le MP4, sans nécessiter de bundler, framework ou script de capture supplémentaire. Elle prend en charge divers formats de sortie (MP4, GIF, images fixes) et permet l'ajout de bande-son, la vérification des images via des planches contacts, et le débogage avec une commande `verify` pour s'assurer que chaque image dépend uniquement du temps. Idéale pour les développeurs, créateurs de contenu et marketeurs, elle est compatible avec les outils en ligne de commande Helios et s'utilise avec `npx -y @helios-project/cli@latest`.

Compatible avec~Claude Code~Codex CLI~Cursor
npx skills add https://github.com/BintzGavin/helios-skills/tree/HEAD/plugins/helios/skills/make-video

Demander à votre IA préférée

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

Documentation

Créez une vidéo avec Helios

Une vidéo Helios est une page HTML unique avec une fonction, window.renderAt(t). Elle dessine l'image au temps t secondes. Le moteur de rendu Helios charge la page dans Chrome headless, appelle renderAt(t) une fois par image, capture chaque image et encode le MP4. Pas de bundler, pas de framework et pas de script de capture à écrire.

1. Écrivez la page

Chaque image doit être une fonction pure de t. Le moteur de rendu peut demander les images dans n'importe quel ordre, et il rend la même image de manière identique à chaque fois.

  • Dérivez tout de t : positions, opacité, scène affichée. N'utilisez jamais de compteurs, x += vitesse, physique pas à pas, ou setTimeout/setInterval.
  • L'aléatoire doit être ensemencé. Utilisez rand(seed) ci-dessous, pas un Math.random() nu à l'intérieur de renderAt.
  • Chargez les actifs avant la première image. Conservez une promesse ready pour les polices et images, et rendez renderAt asynchrone en attendant await ready. Le moteur de rendu attend toute promesse que renderAt retourne.
  • Dimensionnez la page à la vidéo. Un canevas de la taille de la vidéo, avec html,body{margin:0;overflow:hidden}.
<!doctype html>
<html>
<head>
<meta charset="utf-8">
<style>html,body{margin:0;background:#0b0b10;overflow:hidden}</style>
</head>
<body>
<canvas id="c" width="1920" height="1080"></canvas>
<script>
const W = 1920, H = 1080;
const ctx = document.getElementById('c').getContext('2d');

const clamp = (x, a = 0, b = 1) => Math.min(b, Math.max(a, x));
const ease = (x) => 1 - Math.pow(1 - clamp(x), 3);              // easeOutCubic
const span = (t, start, dur) => clamp((t - start) / dur);         // 0→1 sur [start, start+dur]
const rand = (seed) => { const x = Math.sin(seed * 12.9898) * 43758.5453; return x - Math.floor(x); };

const ready = document.fonts.ready;                               // plus les images que vous chargez

window.renderAt = async (t) => {
  await ready;
  ctx.fillStyle = '#0b0b10';
  ctx.fillRect(0, 0, W, H);

  // Scène 1 (0–3s) : titre qui apparaît.
  const p = ease(span(t, 0.2, 1.2));
  ctx.globalAlpha = p;
  ctx.fillStyle = '#f5b700';
  ctx.font = '800 140px system-ui, sans-serif';
  ctx.textAlign = 'center';
  ctx.fillText('Bonjour, vidéo', W / 2, H / 2 + 60 * (1 - p));
  ctx.globalAlpha = 1;

  // Particules : position ensemencée par particule, animée par t.
  for (let i = 0; i < 80; i++) {
    const x = (rand(i) * W + t * 60 * (0.5 + rand(i + 99))) % W;
    const y = rand(i + 7) * H;
    ctx.fillStyle = `rgba(255,255,255,${0.15 + 0.35 * rand(i + 3)})`;
    ctx.fillRect(x, y, 3, 3);
  }
};
</script>
</body>
</html>

Les pages DOM, CSS, SVG et WebGL fonctionnent aussi. Définissez les styles depuis t dans renderAt, ou laissez les animations CSS et les timelines GSAP/motion s'exécuter. Le moteur de rendu les positionne au temps de chaque image. Voir references/pages.md.

2. Rendez-la

npx -y @helios-project/cli@latest render video.html -o video.mp4 --duration 12
DrapeauUtilisation
--duration <s>Durée en secondes. Les fractions sont acceptées. Obligatoire pour une page renderAt.
--width 1080 --height 1920Taille de l'image ; la valeur par défaut est 1920×1080. Faites correspondre votre canevas. Le format vertical 9:16 est 1080x1920.
--fps <n>Taux d'images par seconde ; la valeur par défaut est 30.
--audio song.mp3Bande-son, découpée à la durée de la vidéo.
--mode canvasPlus rapide pour une page qui n'est qu'un seul <canvas> plein écran. Le mode par défaut, dom, capture la page telle qu'elle apparaît.
--preset mediumPour le fichier final. Il est plusieurs fois plus petit à qualité égale et prend plus de temps à encoder. La valeur par défaut, ultrafast, est rapide pour les brouillons.

Le rendu est image par image exacte. L'image n est exactement renderAt(n / fps), sans images sautées ou dupliquées et sans dépendance à la vitesse de la machine.

Pour un GIF, rendez le MP4 puis convertissez-le. Voir references/pages.md.

3. Examinez les images avant de dire que c'est fini

Ne livrez pas une vidéo que vous n'avez pas regardée. Rendez des images fixes et des planches contacts à partir de la page elle-même ; ils sont rapides et ne nécessitent aucun encodage :

npx -y @helios-project/cli@latest still video.html --at 0.5,3,7.25            # PNGs en pleine taille
npx -y @helios-project/cli@latest sheet video.html --every 1 --duration 12   # une grille étiquetée
npx -y @helios-project/cli@latest sheet video.html --strip 2:3 --fps 30      # chaque image entre 2–3s
npx -y @helios-project/cli@latest sheet video.html --at 4 --crop 600,300,720,480  # zoom sur une région

Avant un long rendu, vérifiez que la page est vraiment une fonction de t :

npx -y @helios-project/cli@latest verify video.html --duration 12   # renvoie 1 et nomme les images qui dépendent de l'historique

Ouvrez les PNGs avec votre outil de visualisation d'images et vérifiez :

  • le texte est lisible et dans le cadre
  • les transitions se produisent réellement
  • il n'y a pas d'images vides ou noires
  • le rythme correspond au brief

Corrigez la page, vérifiez à nouveau, et rendez à nouveau.

4. Musique et son

--audio mixe un fichier audio. Pour synchroniser les visuels avec la musique, utilisez l'une de ces méthodes :

  • BPM connu : le battement k tombe à k * 60 / bpm secondes. Pilotez les impulsions depuis t sur cette grille.
  • Tempo inconnu : analysez l'audio dans la page. Décodez-le une fois et précalculez une enveloppe de volume, puis lisez l'enveloppe à t dans renderAt. Voir references/music.md.

Quand quelque chose ne va pas

SymptômeCorrection
"How long should the video be? Pass --duration"Ajoutez --duration <secondes>.
window.renderAt(2.5) threw: …Votre page a généré une erreur à ce temps. Le message inclut votre trace de pile.
Le premier rendu fait une pause pour télécharger ChromiumC'est normal, et cela se produit une fois. N'exécutez pas npx playwright install vous-même : cela télécharge une build pour la mauvaise version de Playwright.
"The page defines no window.helios, window.renderAt(t) …"Votre script n'a jamais défini renderAt. Vérifiez la page pour une erreur de chargement, comme une erreur de syntaxe ou un import échoué.
Les images diffèrent entre deux rendus, ou verify échoueQuelque chose n'est pas une fonction de t : un Math.random() non ensemencé, un compteur ou une minuterie.
Images WebGL videsDessinez à l'intérieur de renderAt (ou d'une boucle rAF), pas une fois au chargement.

Les grands projets (composants React/Vue, édition en studio, rendu cloud distribué) utilisent directement les packages Helios : https://github.com/BintzGavin/helios.

Individual skills in this repo

This repo contains 9 individual skills — each has its own dedicated page.

BintzGavin/helios-skills

>- Story-first motion design philosophy for animated video: motion must earn its place; arc (establish, complicate, resolve); show vs tell; shots as units of thought; quiet vs loud motion; Disney principles with restraint; timing heuristics; composition; grammar by medium (product demos, logos, data viz, explainers); technical commitments (deterministic time, scrubbability, refs); cutting discipline; explicit anti-patterns. Use when planning, storyboarding, critiquing, or implementing programmatic or motion-driven video (Helios, Remotion, explainers, loops, UI capture, logo reveals), or when the user asks for motion direction, pacing, or visual-story structure.

BintzGavin/helios-skills

>- End-to-end production plan template for feeling-first cinematic product promos: brief interrogation, 45s beat structure (cold open through brand), hero-element metaphor, storyboard fidelity ladder, visual system (palette, type, camera, texture), motion mix and easing vocabulary, audio and captions, tooling (animatic through HTML or AE), deliverables matrix, accessibility, review milestones, and compromises to accept or refuse. Use when planning, pitching, storyboarding, or producing polished brand films for any SaaS or consumer product—not category-specific; pair with skills/design/animated-video-philosophy for broader motion principles.

BintzGavin/helios-skills

Patterns for using Helios with Framer Motion. Use when you want to use Framer Motion's physics and transitions but need frame-perfect synchronization with Helios.

BintzGavin/helios-skills

Patterns for using Helios with GSAP (GreenSock). Use when integrating GSAP timelines with the Helios timeline for precise scrubbing and rendering.

BintzGavin/helios-skills

End-to-end guided workflow for creating an explainer or walkthrough video. Extracts brand identity from the repo, generates a measured soundtrack, and produces a narrative-driven motion.dev composition rendered via Helios CLI. Use when making how-it-works, feature walkthrough, or educational videos.

BintzGavin/helios-skills

Motion design framework for programmatic video. Defines anti-slideshow architecture, visual layering, physics-based easing, choreography rules, and quality validation. Reference this skill from any guided video skill.

BintzGavin/helios-skills

End-to-end guided workflow for creating a promotional hype video. Extracts brand identity from the repo, generates beat-synced music, and produces a high-energy motion.dev composition rendered via Helios CLI. Use when making brand-aligned promo or hype videos.

BintzGavin/helios-skills

End-to-end guided workflow for creating a social proof or testimonial video. Extracts brand identity from the repo, generates a warm soundtrack, and produces a trust-building motion.dev composition rendered via Helios CLI. Use when making customer testimonial, review highlight, or social proof videos.

BintzGavin/helios-skills

Workflow for rendering a Helios composition to a video file. Use when you need to automate video production or export a high-quality animation.

Skills associés