Communitygithub.com

Helios – Crea vídeos desde código

Convierte una página HTML en un video MP4, GIF, animación, videoclip, cortometraje, explicación animada, demo de producto, logo animado o clip social. Renderiza fotograma exacto con Helios, revisa imágenes fijas y hojas de contacto, y añade banda sonora.

¿Qué es Helios – Crea vídeos desde código?

Helios Skills te permite crear vídeos, GIFs y animaciones de alta calidad escribiendo una única página HTML que dibuja cualquier fotograma en función del tiempo t. El renderizador de Helios carga esa página en un navegador headless Chrome, llama a la función `renderAt(t)` una vez por fotograma, captura cada uno y codifica el MP4 resultante, todo sin necesidad de empaquetadores, frameworks ni scripts de captura manuales. Es compatible con Claude Code, Cursor, Codex y otros agentes de IA que ejecuten comandos de terminal. La herramienta ofrece modos para captura rápida (canvas) y captura completa del DOM, soporte para audio (--audio), y permite generar imágenes fijas, hojas de contacto y verificar que la página sea realmente una función pura de t. Está pensada para desarrolladores y creadores que quieran generar contenido visual desde código de forma reproducible y frame‑exacta.

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

Preguntar en tu IA favorita

Abre un nuevo chat con esta habilidad de agente ya precargada.

Documentación

Crea un vídeo con Helios

Un vídeo Helios es una página HTML con una única función, window.renderAt(t). Dibuja el fotograma en el instante t segundos. El renderizador Helios carga la página en Chrome sin interfaz gráfica, llama a renderAt(t) una vez por fotograma, captura cada fotograma y codifica el MP4. No necesitas empaquetador, ni framework, ni escribir un script de captura.

1. Escribe la página

Cada fotograma debe ser una función pura de t. El renderizador puede pedir los fotogramas en cualquier orden y debe renderizar el mismo fotograma de forma idéntica cada vez.

  • Deriva todo de t: posiciones, opacidad, qué escena se muestra. Nunca uses contadores, x += velocidad, físicas paso a paso, ni setTimeout/setInterval.
  • La aleatoriedad debe estar seedada. Usa rand(semilla) más abajo, no uses Math.random() directamente dentro de renderAt.
  • Carga los recursos antes del primer fotograma. Mantén una promesa ready para las fuentes e imágenes, y haz que renderAt sea asíncrono y espere a ready. El renderizador espera cualquier promesa que devuelva renderAt.
  • Ajusta la página al tamaño del vídeo. Un canvas del tamaño del vídeo, con 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, inicio, duracion) => clamp((t - inicio) / duracion);         // 0→1 en [inicio, inicio+duracion]
const rand = (semilla) => { const x = Math.sin(semilla * 12.9898) * 43758.5453; return x - Math.floor(x); };

const ready = document.fonts.ready;                               // más cualquier imagen que cargues

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

  // Escena 1 (0–3s): título aparece ascendiendo.
  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('Hola, vídeo', W / 2, H / 2 + 60 * (1 - p));
  ctx.globalAlpha = 1;

  // Partículas: una posición seedada por partícula, animadas por 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>

También funcionan páginas con DOM, CSS, SVG y WebGL. Aplica estilos desde t dentro de renderAt, o deja que las animaciones CSS y las timelines de GSAP/motion se ejecuten. El renderizador las posiciona en el tiempo de cada fotograma. Consulta references/pages.md.

2. Renderízalo

npx -y @helios-project/cli@latest render video.html -o video.mp4 --duration 12
FlagUso
--duration <s>Duración en segundos. También valen fracciones. Obligatorio para una página con renderAt.
--width 1080 --height 1920Tamaño del fotograma; el valor predeterminado es 1920×1080. Debe coincidir con tu canvas. Vertical 9:16 es 1080x1920.
--fps <n>Fotogramas por segundo; el valor predeterminado es 30.
--audio cancion.mp3Banda sonora, ajustada a la duración del vídeo.
--mode canvasMás rápido para una página que es solo un <canvas> que ocupa toda la pantalla. El valor predeterminado, dom, captura la página tal como se ve.
--preset mediumPara el archivo final. Con la misma calidad ocupa varias veces menos y tarda más en codificar. El valor predeterminado, ultrafast, es rápido para borradores.

El renderizado es fotograma exacto. El fotograma n es exactamente renderAt(n / fps), sin fotogramas perdidos ni duplicados y sin dependencia de la velocidad de la máquina.

Para un GIF, renderiza el MP4 y luego conviértelo. Consulta references/pages.md.

3. Mira los fotogramas antes de decir que está terminado

No entregues un vídeo que no hayas mirado. Renderiza imágenes fijas y hojas de contacto desde la propia página; son rápidas y no necesitan codificación:

npx -y @helios-project/cli@latest still video.html --at 0.5,3,7.25            # PNGs a tamaño completo
npx -y @helios-project/cli@latest sheet video.html --every 1 --duration 12   # una cuadrícula etiquetada
npx -y @helios-project/cli@latest sheet video.html --strip 2:3 --fps 30      # todos los fotogramas entre 2–3s
npx -y @helios-project/cli@latest sheet video.html --at 4 --crop 600,300,720,480  # zoom en una región

Antes de un renderizado largo, comprueba que la página es realmente una función de t:

npx -y @helios-project/cli@latest verify video.html --duration 12   # sale con código 1 y nombra los fotogramas que dependen de historia

Abre los PNGs con tu visor de imágenes y comprueba:

  • el texto es legible y está dentro del fotograma
  • las transiciones realmente ocurren
  • no hay fotogramas vacíos o negros
  • el ritmo coincide con lo solicitado

Corrige la página, compruébalo de nuevo y renderiza otra vez.

4. Música y sonido

--audio multiplexa un archivo de audio. Para sincronizar lo visual con la música, usa una de estas opciones:

  • BPM conocido: el pulso k cae en el segundo k * 60 / bpm. Conduce los destellos desde t contra esa rejilla.
  • Tempo desconocido: analiza el audio dentro de la página. Decódelo una vez y precalcula una envolvente de volumen, luego lee la envolvente en t dentro de renderAt. Consulta references/music.md.

Cuando algo falla

SíntomaSolución
"¿Cuánto debe durar el vídeo? Pasa --duration"Añade --duration <segundos>.
window.renderAt(2.5) lanzó: …Tu página dio error en ese instante. El mensaje incluye tu traza de pila.
El primer renderizado se detiene para descargar ChromiumEs esperado, y ocurre una sola vez. No ejecutes npx playwright install por tu cuenta: descarga una compilación para una versión incorrecta de Playwright.
"La página no define window.helios, window.renderAt(t) …"Tu script nunca definió renderAt. Revisa si la página tiene un error de carga, como un error de sintaxis o una importación fallida.
Los fotogramas difieren entre dos renderizados, o verify fallaAlgo no es función de t: un Math.random() sin seed, un contador o un temporizador.
Fotogramas WebGL en blancoDibuja dentro de renderAt (o un bucle rAF), no una vez al cargar.

Los proyectos más grandes (componentes React/Vue, edición en estudio, renderizado en la nube distribuido) usan los paquetes Helios directamente: 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 relacionados