gsap

Implement GSAP animations with timelines and effects for HyperFrames compositions.

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

SYSTEM DOCUMENTATION & REQUIREMENTS

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

What problem does it solve?

Writing GSAP animations for HyperFrames compositions often leads to inconsistent performance, incorrect property usage, and broken timeline sequencing without a centralized reference for best practices and common patterns.

Core Features & Use Cases

  • Full GSAP API Reference: Covers core tween methods (to, from, fromTo, set), correct camelCase property usage, transform aliases, easing options, and function-based values.
  • Timeline Workflow Guidance: Explains timeline creation, position parameters, labels, nesting, and playback control for complex, sequenced animations.
  • Pre-built Effects & Helper Tools: Includes drop-in patterns for typewriter text and audio visualizers, plus a Python script to extract normalized audio data for reactive animations.
  • Use Case: For example, if you are building a HyperFrames product demo with animated text reveals and music-synced visualizers, this skill provides all required patterns and tools to implement them correctly without manual trial and error.

Quick Start

Use the gsap skill to implement a timed typewriter text effect and audio-reactive frequency visualizer in your HyperFrames composition.

Frequently Asked Questions about gsap

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

FAQPage Schema
How do I create GSAP timeline animations for web compositions without performance issues?

GSAP timeline animations require correct property usage, camelCase syntax, and proper position parameters to sequence tweens deterministically. This skill provides a centralized reference for tween methods, timeline nesting, and playback control to ensure performant, correctly structured animation sequences.

Can I build an audio visualizer that reacts to music using GSAP?

Yes, you can build audio-reactive visualizers using GSAP by extracting normalized audio data first. This skill includes a Python script leveraging numpy and ffmpeg to process audio into normalized frequency data, plus drop-in patterns to sync GSAP animations directly to the extracted audio.

What is the best way to implement a typewriter text reveal effect in a web animation?

The best way to implement a typewriter text reveal is using pre-built GSAP effect patterns designed for timed character sequencing. This skill provides drop-in helper patterns specifically for typewriter text reveals, ensuring correct timeline integration without manual trial and error.

Does GSAP work with HyperFrames synchronous timeline capture for deterministic rendering?

Yes, GSAP integrates with HyperFrames' synchronous timeline capture system when following specific best practices. This skill provides the required deterministic animation code patterns, ensuring your GSAP tweens and timelines adhere to HyperFrames' capture and performance optimization requirements.

Why does my GSAP animation break when sequencing multiple tweens in a timeline?

GSAP timeline sequencing breaks when position parameters are incorrect or property aliases are misused. This skill's reference covers correct transform aliases, timeline labels, and nesting techniques to properly sequence complex animations and prevent broken playback.

Do I need ffmpeg and numpy to create audio-reactive web animations with GSAP?

You need ffmpeg and numpy specifically for the audio data extraction step to create audio-reactive GSAP animations. The included Python script uses these dependencies to extract and normalize audio frequency data, which is then required to drive the visualizer's reactive animations.