Communitygithub.com

Helios - Criação de Vídeos a partir de Código

Crie vídeos, MP4s, GIFs, animações, videoclipes, curtas-metragens, vídeos explicativos, animações de gráficos, demonstrações de produtos, aberturas de logotipo ou clipes para redes sociais a partir de código HTML. Escreva uma única página HTML que desenhe qualquer quadro a partir do seu tempo t, renderize-o quadro a quadro em MP4 com Helios, verifique os quadros e as folhas de contato e adicione uma trilha sonora.

O que é Helios - Criação de Vídeos a partir de Código?

Este skill capacita agentes de IA e desenvolvedores a gerar vídeos programaticamente usando o Helios, uma ferramenta de renderização de vídeo a partir de HTML puro. O princípio central é que o usuário escreve uma única página HTML com uma função `window.renderAt(t)`, que desenha o quadro correspondente ao tempo `t` em segundos. O Helios então carrega essa página no Chrome headless, executa `renderAt(t)` para cada quadro, captura e codifica o vídeo em MP4, sem a necessidade de bundlers, frameworks ou scripts de captura. Este skill é extremamente útil para criar animações, vídeos explicativos, demonstrações de produtos, aberturas de logotipos, clipes animados e muito mais, tudo controlado por código. Ele suporta plataformas como Claude Code (através da integração com skills), Cursor ou Codex, permitindo que o agente gere o HTML e depois execute comandos Helios para renderizar o vídeo. O fluxo de trabalho inclui a escrita da página HTML, a renderização com flags como `--duration`, `--fps` e `--audio`, a verificação de quadros com `still` e `sheet`, e a adição de música. A abordagem garante que cada quadro seja uma função pura de `t`, evitando dependências de estado, o que torna a renderização determinística e adequada para animações precisas.

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

Perguntar na sua IA favorita

Abre um novo chat com esta habilidade de agente já pré-carregada.

Documentação

Crie um vídeo com Helios

Um vídeo Helios é uma única página HTML com uma função, window.renderAt(t). Ela desenha o quadro no tempo t em segundos. O renderizador Helios carrega a página no Chrome headless, chama renderAt(t) uma vez por quadro, captura cada quadro e codifica o MP4. Não há bundler, framework ou script de captura para escrever.

1. Escreva a página

Cada quadro deve ser uma função pura de t. O renderizador pode solicitar quadros em qualquer ordem e renderiza o mesmo quadro de forma idêntica todas as vezes.

  • Derive tudo de t: posições, opacidade, qual cena está sendo exibida. Nunca use contadores, x += speed, física passo a passo ou setTimeout/setInterval.
  • A aleatoriedade deve ser semear. Use rand(seed) abaixo, não um Math.random() puro dentro de renderAt.
  • Carregue assets antes do primeiro quadro. Mantenha uma promessa ready para fontes e imagens, e faça renderAt assíncrono e await ready. O renderizador aguarda qualquer promessa que renderAt retorne.
  • Dimensione a página para o vídeo. Um canvas do tamanho do vídeo, com 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 sobre [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;                               // mais quaisquer imagens que você carregar

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

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

  // Partículas: uma posição semear por partícula, animada 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>

Páginas com DOM, CSS, SVG e WebGL também funcionam. Defina estilos a partir de t dentro de renderAt, ou deixe animações CSS e timelines GSAP/motion rodarem. O renderizador as busca para o tempo de cada quadro. Consulte references/pages.md.

2. Renderize

npx -y @helios-project/cli@latest render video.html -o video.mp4 --duration 12
FlagUso
--duration <s>Duração em segundos. Frações são aceitas. Obrigatório para uma página renderAt.
--width 1080 --height 1920Tamanho do quadro; o padrão é 1920×1080. Corresponda ao seu canvas. Vertical 9:16 é 1080x1920.
--fps <n>Taxa de quadros; o padrão é 30.
--audio song.mp3Trilha sonora, cortada para o vídeo.
--mode canvasMais rápido para uma página que contém apenas um <canvas> de tela cheia. O padrão, dom, captura a página como ela aparece.
--preset mediumPara o arquivo final. É várias vezes menor com a mesma qualidade e leva mais tempo para codificar. O padrão, ultrafast, é rápido para rascunhos.

A renderização é quadro a quadro exata. O quadro n é exatamente renderAt(n / fps), sem quadros perdidos ou duplicados e sem dependência da velocidade da máquina.

Para um GIF, renderize o MP4 e depois converta. Consulte references/pages.md.

3. Olhe para os quadros antes de dizer que está pronto

Não entregue um vídeo que você não examinou. Renderize quadros estáticos e folhas de contato a partir da própria página; eles são rápidos e não precisam de codificação:

npx -y @helios-project/cli@latest still video.html --at 0.5,3,7.25            # PNGs em tamanho real
npx -y @helios-project/cli@latest sheet video.html --every 1 --duration 12   # uma grade rotulada
npx -y @helios-project/cli@latest sheet video.html --strip 2:3 --fps 30      # cada quadro entre 2–3s
npx -y @helios-project/cli@latest sheet video.html --at 4 --crop 600,300,720,480  # zoom em uma região

Antes de uma renderização longa, verifique se a página é realmente uma função de t:

npx -y @helios-project/cli@latest verify video.html --duration 12   # sai com código 1 e nomeia os quadros que dependem do histórico

Abra os PNGs com sua ferramenta de visualização de imagens e verifique:

  • o texto é legível e está dentro do quadro
  • as transições realmente acontecem
  • não há quadros vazios ou pretos
  • o ritmo corresponde ao briefing

Corrija a página, verifique novamente e renderize novamente.

4. Música e som

--audio multiplexa um arquivo de áudio. Para sincronizar visuais com a música, use uma destas opções:

  • BPM conhecido: a batida k cai em k * 60 / bpm segundos. Conduza pulsos a partir de t em relação a essa grade.
  • Tempo desconhecido: analise o áudio na página. Decodifique-o uma vez e pré-calcule um envelope de volume e, em seguida, leia o envelope em t dentro de renderAt. Consulte references/music.md.

Quando algo está errado

SintomaCorreção
"How long should the video be? Pass --duration"Adicione --duration <segundos>.
window.renderAt(2.5) threw: …Sua página gerou um erro naquele momento. A mensagem inclui seu stack trace.
A primeira renderização pausa para baixar o ChromiumIsso é esperado e acontece uma vez. Não execute npx playwright install você mesmo: ele busca uma versão para a versão errada do Playwright.
"The page defines no window.helios, window.renderAt(t) …"Seu script nunca definiu renderAt. Verifique a página para um erro de carregamento, como um erro de sintaxe ou uma importação com falha.
Quadros diferem entre duas renderizações, ou verify falhaAlgo não é uma função de t: um Math.random() não semeado, um contador ou um timer.
Quadros WebGL em brancoDesenhe dentro de renderAt (ou um loop rAF), não uma vez no carregamento.

Projetos maiores (componentes React/Vue, edição em estúdio, renderização em nuvem distribuída) usam os pacotes Helios diretamente: 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.

Habilidades Relacionadas