New to Claude Skills? Learn how to install them →

Get Claude Skills
calesthio on GitHub

HyperFrames Core

Free

Build and render video compositions from HTML.

by calesthio46.8k stars on calesthio/openmontage
Updated Aug 3, 2026
Get this skill

Free · Opens the source repo

What HyperFrames Core does

HyperFrames Core is a framework designed to facilitate the creation of video compositions directly from HTML files. By utilizing data-* attributes for timing and structure, this skill allows developers to define the timing of animations and media playback in a deterministic manner. The framework ensures that the media is owned by the composition, providing a seamless integration of video and audio elements within the HTML structure. This skill serves as a technical contract for building hyperframes projects, detailing the necessary components and rules for successful implementation.

The core functionality revolves around the composition structure, which can be either a standalone project or a sub-composition. The standalone form requires a top-level index.html file, while sub-compositions are loaded via data-composition-src and must be wrapped in a <template>. This distinction is crucial as it affects how the content is rendered and manipulated. Developers are guided through the process of creating these compositions with a series of reference documents that cover everything from minimal composition structures to advanced sub-composition wiring.

HyperFrames Core emphasizes the importance of adhering to specific rules to avoid silent bugs that can arise during rendering. For instance, it mandates that every composition must have a unique ID and that certain properties, such as display and visibility, cannot be animated. These guidelines ensure that the resulting video compositions are both visually appealing and functionally robust. The skill also provides insights into managing tracks and clips, allowing for complex animations and interactions within the composition.

This skill is ideal for developers and designers working on multimedia projects that require precise timing and control over video playback. Whether you are building interactive presentations, educational content, or artistic video displays, HyperFrames Core offers a structured approach to creating engaging compositions that leverage the power of HTML and modern web technologies.

When to use it

Use this skill when you need to create complex video compositions that require precise timing and media control directly from HTML.

When not to use it

This skill may not be suitable for simple video embedding or projects that do not require detailed timing and structural management.

What you can build with it

Creating Interactive Presentations

Use HyperFrames Core to build engaging presentations that incorporate video and animations, ensuring precise timing and synchronization.

Developing Educational Content

Leverage the framework to create interactive educational materials that require detailed media playback and user interaction.

Artistic Video Displays

Utilize HyperFrames Core to craft artistic video compositions that combine various media elements with complex animations.

How to install HyperFrames Core

View source

1. Install with the skills CLI

npx skills add calesthio/openmontage/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 calesthio

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, hyperframes-media, 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/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/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. lint/validate/inspect do not catch this. 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/.

Non-negotiable rules (silent bugs lint/validate/inspect won't catch)

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 display/visibility; no gsap.set on later-scene clips. → 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> must be a direct child of the host root (never inside a sub-comp <template>/wrapper); the framework owns playback. → 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.
  • Adding a sub-composition: verify its internal data-composition-id before wiring the host.

Validation

Use hyperframes-cli for command details

  • npx hyperframes lint passes (0 errors)
  • npx hyperframes validate passes (0 console errors)
  • npx hyperframes inspect passes (0 errors)
  • 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.