New to Claude Skills? Learn how to install them →

Get Claude Skills
heygen-com on GitHub

HyperFrames Core

Free

Build and render HTML-based video compositions.

by heygen-com40.4k stars on heygen-com/hyperframes
1 views
Updated Aug 10, 2026
Get this skill

Free · Opens the source repo

What HyperFrames Core does

HyperFrames Core is a skill designed for developers and designers looking to create video compositions using HTML. It provides a structured approach to building renderable projects by leveraging the data-* timing attributes and framework-owned media playback. This skill acts as a technical contract, outlining how to construct a hyperframes project effectively. The composition is defined through an HTML file where the DOM specifies timing, making the animation runtime seekable.

The skill includes a comprehensive set of references that guide users through various aspects of composition creation. For instance, references/minimal-composition.md helps users start with the smallest renderable composition skeleton, while references/composition-patterns.md assists in choosing between monolithic and modular structures. Additionally, users can explore how to handle media playback, declare variables, and manage sub-compositions through dedicated reference files.

HyperFrames Core is particularly useful for those working on multimedia projects that require precise control over timing and media elements. By adhering to the guidelines set forth in this skill, users can ensure their compositions are both functional and visually engaging. The skill is compatible with Tailwind projects, allowing for seamless integration with modern CSS frameworks. Whether you are developing a standalone composition or a sub-composition, this skill provides the necessary tools and documentation to streamline the process.

In summary, HyperFrames Core is an essential skill for anyone involved in creating HTML-based video content. Its structured approach and detailed references make it a valuable resource for developers and designers aiming to enhance their multimedia projects.

When to use it

Use HyperFrames Core when you need to create video compositions from HTML and require precise control over timing and media playback.

When not to use it

Avoid this skill if you are not working with HTML for video rendering or if your project does not require the specific structure outlined in the references.

What you can build with it

Creating a Standalone Video Composition

Use HyperFrames Core to build a top-level `index.html` that directly renders video content with precise timing.

Integrating Sub-Compositions

Leverage the sub-composition capabilities to create modular video elements that can be reused across different projects.

Building with Tailwind CSS

Combine HyperFrames Core with Tailwind CSS to enhance the styling and responsiveness of your video compositions.

How to install HyperFrames Core

View source

1. Install with the skills CLI

npx skills add heygen-com/hyperframes/hyperframes-core --agent claude-code

2. Or install it manually

Download the skill folder and drop it into ~/.claude/skills/ for all projects, or .claude/skills/ to scope it to one repo. Restart Claude Code so it picks up the new skill.

Anthropic's agentic coding CLI, and the reference implementation of Agent Skills. Drop a skill folder into ~/.claude/skills and Claude Code loads it automatically whenever a task matches the skill's description. Claude Code docs

Inside SKILL.md

Written by heygen-com

HyperFrames Core

HyperFrames renders video from HTML. A composition is an HTML file whose DOM declares timing with data-* attributes, whose animation runtime is seekable, and whose media playback is owned by the framework.

This skill is the technical contract — how to build one hyperframes project. The body below is the build guide; per-topic detail lives in references/ (index next), read on demand. Other concerns live in the sibling domain skills — hyperframes-animation, hyperframes-creative, media-use, hyperframes-cli, hyperframes-registry. The capability map in /hyperframes says what each one covers.

References

FileRead it to…
references/minimal-composition.mdstart from the smallest renderable composition skeleton
references/composition-patterns.mdchoose monolithic vs modular; structure a modular index.html; pick a sub-comp archetype
references/data-attributes.mdlook up any data-* (root / clip / sub-comp host / legacy aliases); use class="clip"
references/tracks-and-clips.mdpick data-track-index, handle same-track overlap / z-index, time a clip relative to another
references/sub-compositions.mdwire a sub-composition (host attrs, <template>, per-instance vars) and animate inside it
references/variables-and-media.mddeclare variables; place <video>/<audio>, set volume, trim
references/determinism-rules.mdbuild a seekable timeline; determinism bans; the animatable-property allowlist; layout / text fit
references/full-screen-motion.mdauthor full-frame motion with shared backgrounds
references/storyboard-format.mdauthor a STORYBOARD.md plan (+ the parsed manifest)
references/review-loop.mdrun the plan → sketch → build review passes on a live board — shared by every storyboard-planning workflow
references/production-loop.mdtake an approved plan to a delivered video — the stage dependencies (audio, frames, assembly, transitions, captions, verify, deliver) a freeform build follows directly
references/brief-contract.mdthe brief's ground rules — mode derivation (collaborative / autonomous), shared field registry, question invariants (the asking itself lives in /hyperframes → the intent layer)
references/brief-format.mdauthor BRIEF.md — the confirmed intent document a workflow's Setup writes and every later step reads
references/script-format.mdauthor the optional SCRIPT.md locked narration
references/subagent-dispatch.mdmap subagent dispatch verbs (parallel fan-out / background / wait) to your harness
references/frame-worker-core.mdthe shared frame-worker role contract — each narrative workflow's packet builder prepends it to that workflow's sub-agents/frame-worker.md delta
references/tailwind.mdwork in a Tailwind v4 project (init --tailwind; runtime contract differs from Studio's v3)

For animation runtime specifics (GSAP API, Lottie, Three.js, etc.) go to hyperframes-animation → adapters/<runtime>.md.

Building a composition

Two root forms (not interchangeable)

  • Standalone (top-level index.html) — root <div data-composition-id="…"> sits directly in <body>, no <template> wrapper (wrapping it hides all content and breaks rendering).
  • Sub-composition (loaded via data-composition-src) — root must be wrapped in <template>.

⚠ Transport rule: the runtime only clones <template> contents; everything outside (incl. <head> styles/scripts) is discarded — put <style>/<script> inside the template. ⚠ Host-id rule: the host slot's data-composition-id must exactly equal the inner template's data-composition-id and the window.__timelines["<id>"] key — no -mount/-slot/-host suffix.

File shape, host wiring, and the pre-render checklist → references/sub-compositions.md.

Root must be sized (silent layout bug)

The standalone root needs an explicit sized box (width/height in px), and every ancestor down to a height:100% element must have a resolved height — otherwise a flex/100% child collapses to ~0 and content piles into the top-left corner. Do not rely on automated gates alone to catch this; inspect a snapshot. Skeleton → references/minimal-composition.md.

One paused timeline

Each composition registers exactly one gsap.timeline({ paused: true }) at window.__timelines["<id>"] (key = root data-composition-id), built synchronously at page load. Render duration = root data-duration, not timeline length. Don't manually nest sub-timelines into the host. Full contract (incl. non-GSAP runtimes) → references/determinism-rules.md + hyperframes-animation/adapters/.

First-pass lint gotchas (a guaranteed first build failure)

Two rules that lint does catch, but only after the fact — write them right the first time:

  • The root composition element must carry data-start="0" (alongside data-composition-id/data-width/data-height); omitting it fails lint with root_composition_missing_data_start.
  • Never pair a CSS initial transform with a GSAP tween on the same property — the CSS value and the tween's start fight and lint rejects it with gsap_css_transform_conflict. Set the initial state inside the tween with gsap.fromTo(el, { x: -40 }, { x: 0 }) instead of a CSS transform: translateX(-40px).

Non-negotiable rules (silent bugs automated gates may miss)

Surfaced here; full rationale in the linked reference. Do not violate:

  • No render-time clocks / unseeded Math.random / network / input-state; no repeat: -1 (use a finite count). → determinism-rules.md
  • Animate only the visual-property allowlist; never tween display or raw visibility. GSAP autoAlpha and zero-duration timeline boundary sets are the only visibility exceptions, and only on non-clip elements or wrappers inside a clip. The framework alone controls .clip visibility. Do not gsap.set later-scene clips at page load. → determinism-rules.md
  • No <br> in body text; transformed elements must be block-level + sized; pulsing absolute decoratives need peak clearance. → determinism-rules.md
  • <video>/<audio> work at any nesting depth (including inside a sub-comp <template> or wrapper); the framework owns playback and seeks/decodes media wherever it lives. The one caveat is timelines, not placement: a sub-comp timeline can't animate host-root elements. → variables-and-media.md
  • Every id must be unique across the assembled page; inside a sub-comp, prefix ids with the composition id (#<id>-hero). Duplicate <video>/<img> ids render blank — the producer injects frames by getElementById, and cross-file dupes slip past lint. → composition-patterns.md
  • A full-screen scene fill goes on a full-bleed child (position:absolute; inset:0), never on the composition root itself — the producer's frame compositing can drop the root element's own background (the frame renders black) even though preview/snapshot show it correctly. → composition-patterns.md

Editing existing compositions

  • Read the files first. Preserve unrelated timing, tracks, IDs, variables, media paths.
  • Match existing composition IDs and timeline keys.
  • Adding a clip: pick a non-overlapping data-track-index or adjust surrounding timing intentionally.
  • data-hidden on any composition element hides it in BOTH preview and render, overriding its time window; it is non-destructive/reversible and toggled by Studio's timeline eye icon.
  • Adding a sub-composition: verify its internal data-composition-id before wiring the host.

Validation

Use hyperframes-cli for command details

  • npx hyperframes check passes (0 findings across lint, runtime, layout, motion, and contrast)
  • Projects with sub-compositions: npx hyperframes snapshot --at <midpoints> and eyeball each frame
  • npx hyperframes preview for review (the user can edit anything in Studio's timeline)
  • npx hyperframes render only after the user approves

Frequently asked questions about HyperFrames Core

Similar skills

Playwright Component Testing

Test React and Vue components in isolation with Playwright.

Fluent UI Blazor

Integrate Fluent UI components in Blazor applications effortlessly.

Build MCP App

Create interactive UI widgets for MCP servers.

Web Design Reviewer

Identify and fix design issues in websites efficiently.

Markstream Install

Seamlessly integrate Markstream for Markdown rendering.

GSAP & Framer Scroll Animation

Create advanced scroll animations effortlessly.