Communitygithub.com

BintzGavin/helios-skills

Erstelle Videos, MP4s, GIFs, Animationen, Musikvideos, Kurzfilme, Erklärvideos, Diagrammanimationen, Produktdemos, Logo-Intros oder Social Clips aus Code. Schreibe eine einzelne HTML-Seite, die jeden Frame zu einem Zeitpunkt t zeichnet, rendere sie frame-genau mit Helios zu MP4, überprüfe Standbilder und Kontaktbögen und füge einen Soundtrack hinzu. Verwende dies immer dann, wenn der Benutzer nach einem Video oder einer Animationsdatei fragt.

Was ist helios-skills?

Diese Fähigkeit ermöglicht es Entwicklern, Videos und Animationen direkt aus Code zu erstellen, indem sie eine einzelne, von Helios gerenderte HTML-Seite verwenden. Der Kernansatz besteht darin, eine `window.renderAt(t)`-Funktion zu definieren, die jeden Frame als eine reine Funktion der Zeit `t` zeichnet, was frame-genaue, deterministische Ergebnisse garantiert. Sie unterstützt die Ausgabe als MP4, GIF (über Konvertierung), Standbilder und Kontaktbögen und kann Audiodateien für Soundtracks einbinden. Die Fähigkeit ist plattformunabhängig (CLI-basiert) und beseitigt Komplexitäten wie Bundler, Frameworks oder separate Capture-Skripte, was sie ideal für schnelle Prototypen, Datenvisualisierungs-Clips, Produktdemos und Social-Media-Inhalte macht. Die mitgelieferte SKILL.md-Dokumentation enthält eine vollständige Schritt-für-Schritt-Anleitung, Referenzmaterial und Fehlerbehebung, sodass Entwickler schnell und zuverlässig Code-basierte Videos erstellen können.

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

In Ihrer bevorzugten KI fragen

Öffnet einen neuen Chat, in dem dieser Agent-Skill bereits geladen ist.

Dokumentation

Ein Video mit Helios erstellen

Ein Helios-Video ist eine einzige HTML-Seite mit einer Funktion: window.renderAt(t). Sie zeichnet den Frame zum Zeitpunkt t Sekunden. Der Helios-Renderer lädt die Seite in einem Headless-Chrome, ruft renderAt(t) einmal pro Frame auf, erfasst jeden Frame und kodiert das MP4. Es gibt keinen Bundler, kein Framework und kein zu schreibendes Capture-Skript.

1. Die Seite schreiben

Jeder Frame muss eine reine Funktion von t sein. Der Renderer kann die Frames in beliebiger Reihenfolge anfordern und rendert denselben Frame jedes Mal identisch.

  • Leite alles von t ab: Positionen, Deckkraft, welche Szene angezeigt wird. Verwende niemals Zähler, x += speed, Schritt-für-Schritt-Physik oder setTimeout/setInterval.
  • Zufälligkeit muss gesät werden. Verwende rand(seed) (siehe unten), nicht ein bloßes Math.random() innerhalb von renderAt.
  • Lade Assets vor dem ersten Frame. Halte ein ready-Promise für Schriftarten und Bilder bereit und mache renderAt asynchron und lasse es await ready verwenden. Der Renderer wartet auf jedes Promise, das renderAt zurückgibt.
  • Passe die Seitengröße an das Video an. Ein Canvas in der Größe des Videos, mit 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 über [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 alle geladenen Bilder

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

  // Szene 1 (0–3s): Titel erscheint von unten.
  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('Hallo, Video', W / 2, H / 2 + 60 * (1 - p));
  ctx.globalAlpha = 1;

  // Partikel: eine gesäte Position pro Partikel, animiert durch 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>

DOM-, CSS-, SVG- und WebGL-Seiten funktionieren ebenfalls. Setze Stile von t innerhalb von renderAt oder lasse CSS-Animationen und GSAP/Motion-Timelines laufen. Der Renderer sucht diese zu jedem Frame-Zeitpunkt. Siehe references/pages.md.

2. Rendern

npx -y @helios-project/cli@latest render video.html -o video.mp4 --duration 12
FlagVerwendung
--duration <s>Länge in Sekunden. Bruchteile sind in Ordnung. Erforderlich für eine renderAt-Seite.
--width 1080 --height 1920Rahmengröße; Standard ist 1920×1080. Passe sie an dein Canvas an. Vertikal 9:16 ist 1080x1920.
--fps <n>Bildrate; Standard ist 30.
--audio song.mp3Soundtrack, auf das Video zugeschnitten.
--mode canvasSchneller für eine Seite, die nur aus einem einzigen, vollformatigen <canvas> besteht. Der Standard dom erfasst die Seite so, wie sie aussieht.
--preset mediumFür die endgültige Datei. Sie ist bei gleicher Qualität um ein Vielfaches kleiner und benötigt länger zum Kodieren. Der Standard ultrafast ist schnell für Entwürfe.

Das Rendern ist frame-genau. Frame n ist genau renderAt(n / fps), ohne ausgelassene oder doppelte Frames und ohne Abhängigkeit von der Maschinengeschwindigkeit.

Für ein GIF rendere das MP4 und konvertiere es dann. Siehe references/pages.md.

3. Überprüfe die Frames, bevor du sagst, es ist fertig

Übergebe kein Video, das du nicht angesehen hast. Rendere Standbilder und Kontaktbögen von der Seite selbst; sie sind schnell und benötigen keine Kodierung:

npx -y @helios-project/cli@latest still video.html --at 0.5,3,7.25            # PNGs in voller Größe
npx -y @helios-project/cli@latest sheet video.html --every 1 --duration 12   # ein beschriftetes Raster
npx -y @helios-project/cli@latest sheet video.html --strip 2:3 --fps 30      # jeden Frame in 2–3s
npx -y @helios-project/cli@latest sheet video.html --at 4 --crop 600,300,720,480  # in eine Region zoomen

Überprüfe vor einem langen Render, ob die Seite wirklich eine Funktion von t ist:

npx -y @helios-project/cli@latest verify video.html --duration 12   # beendet mit 1 und nennt die Frames, die von der Historie abhängen

Öffne die PNGs mit deinem Bildbetrachter und überprüfe:

  • Text ist lesbar und innerhalb des Rahmens
  • Übergänge finden tatsächlich statt
  • Es gibt keine leeren oder schwarzen Frames
  • Das Tempo entspricht der Vorgabe

Korrigiere die Seite, überprüfe erneut und rendere erneut.

4. Musik und Ton

--audio multiplexed eine Audiodatei. Um Bilder mit der Musik zu synchronisieren, verwende eine der folgenden Methoden:

  • Bekannter BPM: Beat k fällt bei k * 60 / bpm Sekunden. Treibe Pulse von t gegen dieses Raster.
  • Unbekanntes Tempo: Analysiere das Audio in der Seite. Dekodiere es einmal und berechne eine Lautstärkehüllkurve vor, dann lese die Hüllkurve bei t in renderAt. Siehe references/music.md.

Wenn etwas schief geht

SymptomBehebung
„Wie lange soll das Video sein? Gib --duration an“Füge --duration <Sekunden> hinzu.
window.renderAt(2.5) threw: …Deine Seite hat zu diesem Zeitpunkt einen Fehler verursacht. Die Nachricht enthält deinen Stack-Trace.
Der erste Render pausiert, um Chromium herunterzuladenDas ist zu erwarten und passiert einmal. Führe nicht selbst npx playwright install aus: es holt einen Build für die falsche Playwright-Version.
„Die Seite definiert weder window.helios noch window.renderAt(t) …“Dein Skript hat renderAt nie definiert. Überprüfe die Seite auf einen Ladefehler, wie z. B. einen Syntaxfehler oder einen fehlgeschlagenen Import.
Frames unterscheiden sich zwischen zwei Rendern, oder verify schlägt fehlEtwas ist keine Funktion von t: ein ungesätes Math.random(), ein Zähler oder ein Timer.
Leere WebGL-FramesZeichne innerhalb von renderAt (oder einer rAF-Schleife), nicht einmalig beim Laden.

Größere Projekte (React/Vue-Komponenten, Studio-Bearbeitung, verteiltes Cloud-Rendering) verwenden die Helios-Pakete direkt: 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.

Verwandte Skills