gsap

Reference GSAP tween methods, timelines, and matchMedia for HyperFrames animations.

Updated Apr 20, 2026
One-click install
npx skills add https://github.com/kofiarhin/hyperframes-editor --skill gsap-kofiarhin
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: gsap
Source: https://github.com/kofiarhin/hyperframes-editor/tree/main/.agents/skills/gsap
Command: npx skills add https://github.com/kofiarhin/hyperframes-editor --skill gsap-kofiarhin

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill requires ffmpeg, numpy, and includes scripts (resource) and references (resource) components.

What problem does it solve?

Writing GSAP animations for HyperFrames compositions requires specialized knowledge of GSAP's API, timeline sequencing best practices, and performance optimization rules to avoid common issues like layout thrashing or broken responsive behavior. This Skill eliminates that guesswork by providing a complete, HyperFrames-specific reference and pre-built effect patterns.

Core Features & Use Cases

  • Comprehensive GSAP Reference: Covers core tween methods (to, from, fromTo), timeline construction with position parameters and labels, easing, stagger effects, and responsive animation patterns using gsap.matchMedia().
  • Drop-in Effect Templates: Includes ready-to-use patterns for common HyperFrames use cases like typewriter text reveals and audio visualizers, with all required HTML, CSS, and timeline code.
  • Performance Best Practices: Provides explicit guidance on compositor-friendly properties, will-change usage, and quickTo for frequent updates to ensure smooth 60fps animations.
  • Use Case Example: If you are building a HyperFrames composition with animated text entrances and audio-reactive visuals, this Skill gives you pre-vetted code patterns and rules to avoid common pitfalls like incorrect timeline sequencing or layout-triggering animations.

Quick Start

Use the gsap skill to add a smooth staggered entrance animation to the list items in your HyperFrames composition, following the performance best practices outlined in the reference.

Frequently Asked Questions about gsap

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I create performant GSAP timeline animations for web compositions?

GSAP timeline animations require compositor-friendly properties, will-change usage, and quickTo for frequent updates to maintain 60fps. This reference provides tween methods, position parameters, labels, and proper resource cleanup to prevent memory leaks.

What's the best way to sequence deterministic GSAP animations with position parameters?

Sequencing deterministic GSAP animations requires timeline construction with position parameters and labels. This approach ensures precise timing control for complex animation choreography and stagger effects across multiple elements.

How do I build responsive GSAP animations that adapt to different screen sizes?

Responsive GSAP animations use the gsap.matchMedia() method to conditionally apply animations based on viewport conditions. This pattern ensures web animations trigger or disable appropriately across different device breakpoints.

Can I use GSAP to create a typewriter text reveal effect?

Yes, GSAP can create typewriter text reveals using drop-in effect templates. These pre-built patterns include all required HTML, CSS, and timeline code to achieve character-by-character text animation without manual keyframe configuration.

How do I build an audio visualizer with GSAP timelines?

Audio visualizers with GSAP timelines use pre-built effect templates combining numpy for audio processing and timeline methods for visual rendering. These templates provide the required HTML, CSS, and animation code for audio-reactive visual elements.

Why does my GSAP animation cause layout thrashing and dropped frames?

GSAP animation layout thrashing occurs when animating non-compositor-friendly properties that trigger browser reflow. This reference provides explicit guidance on will-change usage and quickTo methods to avoid performance bottlenecks and maintain smooth rendering.