Gsap

Meng ToCommunityCreated by Meng To

Skill
Tool integration
Software development
MIT
Medium risk

From the author

Use when you need to add or debug professional web animations with GSAP (timelines, ScrollTrigger, stagger, transforms) in HTML/CSS/JS/React. Includes patterns for smooth motion, performance, and common pitfalls.

— the description by Meng To

AutoGineer summary

Written by AutoGineer from the skill’s own files, not by the author

This skill provides a comprehensive reference for using the GreenSock Animation Platform (GSAP) to create high-quality web animations. It covers core concepts such as tweens, timelines, easing, and staggering, as well as advanced functionality like ScrollTrigger for scroll-driven storytelling. The guide also addresses common performance pitfalls, such as layout-induced jank, and provides best practices for integrating GSAP into modern frameworks like React, including proper cleanup to prevent memory leaks.

What it does

Explains how to create and chain complex animation sequences using GSAP timelines.
Provides patterns for scroll-driven animations using the ScrollTrigger plugin.
Offers guidance on performance optimization by prioritizing transforms over layout properties.
Details best practices for integrating animations in single-page applications (SPAs).
Includes common troubleshooting steps for animation issues and layout reflows.

When to use it

When building high-quality UI motion, page transitions, or micro-interactions.
When you need to orchestrate complex, multi-element animation sequences.
When implementing scroll-based storytelling or pinned sections.
When debugging animation performance or layout-related jank.
When integrating GSAP into React or other component-based frameworks.

Advantages

Enables precise control over animation timing and sequencing.
Provides robust tools for scroll-based interactions.
Helps avoid common performance bottlenecks in web animations.
Supports clean integration patterns for modern JavaScript frameworks.

Usage examples

“Create a hero section entrance animation where elements fade in and slide up with a stagger effect.”: The agent provides a GSAP from() tween using autoAlpha and y-transforms with a stagger property to animate elements sequentially.
“How do I pin a section while scrubbing through an animation as the user scrolls?”: The agent provides a ScrollTrigger configuration with pin, scrub, and trigger parameters to link the animation timeline to the scroll position.

Install

Download the skill as a ZIP:
https://mp-staging.autogineer.com/agent-skills/mengto/gsap/download
Unzip it into the cross-client skills folder of your project:
```
mkdir -p .agents/skills && unzip gsap.zip -d .agents/skills
```

Documentation by Meng To

GSAP (GreenSock) — Web Animation Skill

When to use

High-quality UI/motion design: entrances, micro-interactions, page transitions
Timeline-based sequences (vs. scattered CSS transitions)
Scroll-driven storytelling (with ScrollTrigger)
Complex easing, staggering, orchestration across many elements

Key concepts & APIs

Tweens:
- gsap.to(targets, vars)
- gsap.from(targets, vars)
- gsap.fromTo(targets, fromVars, toVars)
Timelines:
- const tl = gsap.timeline({ defaults, repeat, yoyo, paused })
- Chain: tl.to(...).from(...).addLabel('x').add(() => ...)
- Position parameter: absolute 1.2, relative "+=0.5", overlap "-=0.3", label "intro"
Eases: ease: "power2.out", "expo.inOut", "elastic.out(1, 0.3)"
Staggers: stagger: 0.05 or { each, from: "start|center|end|random", grid }
Performance-friendly properties:
- Prefer transforms (x, y, scale, rotation) and opacity (autoAlpha)
ScrollTrigger (plugin):
- gsap.registerPlugin(ScrollTrigger)
- Inline: gsap.to(".box", { scrollTrigger: ".box", x: 500 })
- Advanced: scrollTrigger: { trigger, start, end, scrub, pin, snap, markers }
- Standalone: ScrollTrigger.create({ trigger, start, end, onUpdate, onToggle })

Common pitfalls (and fixes)

Animating layout properties (top/left/width/height) → jank
- Use transforms, add will-change: transform, avoid forced reflow.
ScrollTrigger “not firing” due to wrong trigger sizing/overflow containers
- Ensure trigger exists, has height, and check scroll container (nested scrolling needs config).
Not cleaning up in SPA/React
- Use gsap.context() and revert on unmount; kill triggers (ScrollTrigger.getAll().forEach(t => t.kill())) if needed.
FOUC / measuring before fonts/images load
- Initialize after layout is stable; run ScrollTrigger.refresh() after images load.

Quick recipes

1) Hero entrance (stagger)

gsap.from(".hero [data-anim]", {
  y: 24,
  autoAlpha: 0,
  duration: 0.8,
  ease: "power2.out",
  stagger: 0.06,
});

2) Sequenced timeline

const tl = gsap.timeline({ defaults: { ease: "power2.out", duration: 0.6 } });
tl.from(".nav", { y: -20, autoAlpha: 0 })
  .from(".hero-title", { y: 30, autoAlpha: 0 }, "-=0.2")
  .from(".hero-cta", { scale: 0.95, autoAlpha: 0 }, "-=0.2");

3) Scroll-scrub pinned section

gsap.registerPlugin(ScrollTrigger);

gsap.timeline({
  scrollTrigger: {
    trigger: ".story",
    start: "top top",
    end: "+=800",
    scrub: 1,
    pin: true,
  },
}).to(".story .panel", { xPercent: -200 });

What to ask the user (if requirements unclear)

Is this a static site or SPA (React/Next/Vue)? Any page transitions?
Do we need scroll-driven sections (pin/scrub/snap)?
Performance constraints (mobile support, reduced motion)?

Files

ATTRIBUTION.mdAdded by AutoGineer830 B
LICENSELicence file added by AutoGineer1.0 KiB
REFERENCES.md198 B
SKILL.md3.0 KiB
demo/PROMPT.md2.4 KiB
demo/assets/page-01-4f5668c5-fc4a-44e0-bc5e-a664189d3c31-800w.jpg52.1 KiB
demo/assets/page-02-0d868fef-f560-45ca-ab35-5dad4fc29059-800w.webp54.3 KiB
demo/assets/source-preview.jpg34.3 KiB
demo/index.html34.5 KiB
demo/preview.jpg30.7 KiB
demo/source.json3.6 KiB

demo/index.html

<!doctype html>
<html lang="en">
<head>
  <meta charset="utf-8">
  <meta name="viewport" content="width=device-width, initial-scale=1">
  <meta name="neuform-sandboxed-demo" content="1">
  <meta http-equiv="Content-Security-Policy" content="default-src 'none'; connect-src 'self'; frame-src 'self'; script-src 'unsafe-inline'; style-src 'unsafe-inline'; base-uri 'none'; form-action 'none'; object-src 'none'">
  <title>Sandboxed Neuform demo</title>
  <style>
    html, body, iframe { width: 100%; height: 100%; margin: 0; border: 0; }
    body { overflow: hidden; background: #0b0b0b; }
    iframe { display: block; background: white; }
    .error { box-sizing: border-box; min-height: 100%; padding: 32px; color: #fff; font: 16px/1.5 system-ui, sans-serif; }
  </style>
</head>
<body>
  <iframe id="neuform-demo" title="Sandboxed Neuform design demo" sandbox="allow-scripts" referrerpolicy="no-referrer"></iframe>
  <script>
    const encodedHtml = "<!DOCTYPE html>
<html lang="en" class="antialiased selection:bg-purple-500/30 selection:text-white">
<head>
<meta http-equiv="Content-Security-Policy" content="default-src 'none'; base-uri 'none'; connect-src 'none'; font-src data: https://fonts.gstatic.com; form-action 'none'; frame-src 'none'; img-src blob:; media-src blob:; navigate-to 'none'; object-src 'none'; script-src 'unsafe-inline' __NEUFORM_RUNTIME_SOURCES__; style-src 'unsafe-inline' https://api.fontshare.com https://fonts.googleapis.com; worker-src 'none'">
<script data-neuform-asset-bootstrap>
(() => {
  let received = false;
  const objectUrls = [];
  const replaceAll = (value, replacements) => {
    let next = String(value || "");
    for (const [file, objectUrl] of replacements) next = next.split(file).join(objectUrl);
    return next;
  };
  window.addEventListener("message", (event) => {
    if (received || event.source !== parent || event.data?.type !== "neuform-assets-v1") return;
    received = true;
    const replacements = [];
    for (const asset of event.data.assets || []) {
      if (!asset || typeof asset.file !== "string" || typeof asset.base64 !== "string") continue;
      const binary = atob(asset.base64);
      const bytes = Uint8Array.from(binary, (character) => character.charCodeAt(0));
      const objectUrl = URL.createObjectURL(new Blob([bytes], { type: asset.contentType || "application/octet-stream" }));
      objectUrls.push(objectUrl);
      replacements.push([asset.file, objectUrl]);
    }
    for (const element of document.querySelectorAll("*")) {
      for (const name of ["src", "poster", "srcset", "style"]) {
        const value = element.getAttribute(name);
        if (value) element.setAttribute(name, replaceAll(value, replacements));
      }
    }
    for (const style of document.querySelectorAll("style")) {
      style.textContent = replaceAll(style.textContent, replacements);
    }
  });
  window.addEventListener("pagehide", () => {
    for (const objectUrl of objectUrls) URL.revokeObjectURL(objectUrl);
  }, { once: true });
})();
</script>

<meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Aura - Fluid Drag Interactions</title>
    
    <!-- Fonts -->
    <link rel="preconnect" href="https://fonts.googleapis.com">
    <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
    <link href="https://fonts.googleapis.com/css2?family=Plus+Jakarta+Sans:wght@400;500;600&display=swap" rel="stylesheet">
    
    <!-- Tailwind CSS -->
    <script src="../../../../assets/runtime/runtime-ccc8894b3418-runtime.js"></script>
    
    <!-- Iconify -->
    <script src="../../../../assets/runtime/runtime-163ebd087cfc-iconify-icon-min.js"></script>
    
    <!-- Three.js & GSAP -->
    <script src="../../../../assets/runtime/runtime-25023b521d77-three-min.js"></script>
    <script src="../../../../assets/runtime/runtime-027051effa47-gsap-min.js"></script>
    <!-- Added GSAP Draggable -->
    <script src="../../../../assets/runtime/runtime-8da2c9e0e562-draggable-min.js"></script>

    <script>
        tailwind.config = {
            theme: {
                extend: {
                    fontFamily: {
                        sans: ['"Plus Jakarta Sans"', 'sans-serif'],
                    },
                    colors: {
                        brand: {
                            bg: '#160927',
                            flare: '#5B1E91',
                        }
                    }
                }
            }
        }
    </script>
</head>
<body class="relative min-h-screen bg-brand-bg text-white overflow-hidden" style="font-family: 'Plus Jakarta Sans', sans-serif;">

    <!-- Background Elements: Gradient Flare -->
    <div class="fixed inset-0 z-0 pointer-events-none" style="background: radial-gradient(circle at 50% 60%, rgba(91, 30, 145, 0.5) 0%, rgba(22, 9, 39, 1) 65%);"></div>

    <!-- WebGL Canvas for Dot Matrix Particle Field -->
    <canvas id="webgl-canvas" class="fixed inset-0 z-[1] pointer-events-none"></canvas>

    <!-- Directive: Framed Grid Layout -->
    <div class="fixed inset-4 sm:inset-6 lg:inset-8 z-10 pointer-events-none border border-white/10 rounded-[32px] overflow-hidden mix-blend-overlay">
        <!-- Corner Brackets -->
        <div class="absolute top-0 left-0 w-12 h-12 border-t border-l border-white/30 rounded-tl-[32px]"></div>
        <div class="absolute top-0 right-0 w-12 h-12 border-t border-r border-white/30 rounded-tr-[32px]"></div>
        <div class="absolute bottom-0 left-0 w-12 h-12 border-b border-l border-white/30 rounded-bl-[32px]"></div>
        <div class="absolute bottom-0 right-0 w-12 h-12 border-b border-r border-white/30 rounded-br-[32px]"></div>
        
        <!-- Subtle Diagonal Texture -->
        <div class="absolute inset-0 opacity-[0.03]" style="background-image: repeating-linear-gradient(45deg, transparent, transparent 10px, #ffffff 10px, #ffffff 11px);"></div>
        <!-- Grid Guidelines -->
        <div class="absolute left-1/2 top-0 bottom-0 w-[1px] bg-white/5 -translate-x-1/2"></div>
        <div class="absolute top-[20%] left-0 right-0 h-[1px] bg-white/5"></div>
    </div>

    <!-- Main Content -->
    <main class="relative z-20 flex flex-col items-center min-h-screen pt-8 sm:pt-12 px-4 sm:px-8 w-full max-w-[1400px] mx-auto">
        
        <!-- Header -->
        <header class="w-full flex justify-between items-center mb-10 sm:mb-16 hero-anim opacity-0 translate-y-4">
            <div class="w-10"></div> <!-- Spacer -->
            
            <!-- Logo -->
            <div class="flex items-center gap-2 pr-10">
                <div class="w-10 h-[22px] bg-gradient-to-r from-white to-white/40 rounded-full flex items-center px-[3px] shadow-[0_0_15px_rgba(255,255,255,0.2)]">
                     <div class="w-4 h-4 bg-black rounded-full"></div>
                </div>
                <span class="text-[22px] font-semibold tracking-tight">Aura.</span>
            </div>
            
            <!-- Video Icon Button -->
            <button class="w-11 h-11 bg-white/5 rounded-full flex items-center justify-center backdrop-blur-md border border-white/10 hover:bg-white/10 hover:scale-105 transition-all duration-300">
                <iconify-icon icon="solar:video-camera-record-linear" class="text-2xl"></iconify-icon>
            </button>
        </header>

        <!-- Typography Section -->
        <div class="text-center z-30 mb-8 sm:mb-16 flex flex-col items-center pointer-events-none">
            <h1 class="hero-anim opacity-0 translate-y-6 text-6xl sm:text-8xl lg:text-[110px] leading-[0.9] font-semibold tracking-tighter mb-4 text-transparent bg-clip-text bg-gradient-to-b from-[#F5F5F7] to-[#AFAFB6] filter drop-shadow-[0_4px_24px_rgba(0,0,0,0.5)]">
                Fluid Drag Interactions
            </h1>
            <p class="hero-anim opacity-0 translate-y-4 text-lg sm:text-[22px] text-white/80 tracking-tight font-medium">
                Grab, move, and arrange the elements freely across the canvas.
            </p>
        </div>

        <!-- Floating Cards Composition -->
        <!-- Scaled down wrapper for responsive handling while maintaining strict math -->
        <div class="relative w-full max-w-[1000px] h-[400px] sm:h-[550px] flex justify-center items-center perspective-[2000px] scale-[0.6] sm:scale-75 md:scale-90 lg:scale-100 mt-[-40px] sm:mt-0">
            
            <!-- Card 1 (Far Left, Blue) -->
            <div class="card-item cursor-grab active:cursor-grabbing absolute w-[260px] h-[360px] rounded-3xl shadow-2xl overflow-hidden bg-gradient-to-br from-[#2D3AE4] to-[#161D8A] z-10 border border-white/10"
                 style="transform: translateX(-380px) translateY(80px) rotate(-22deg) scale(0.85); transform-origin: center;">
                 <div class="absolute inset-0 opacity-20 pointer-events-none" style="background-image: linear-gradient(rgba(255,255,255,0.2) 1px, transparent 1px), linear-gradient(90deg, rgba(255,255,255,0.2) 1px, transparent 1px); background-size: 20px 20px;"></div>
                 <div class="p-6 h-full flex flex-col justify-between relative z-10 pointer-events-none">
                    <span class="text-[10px] tracking-widest font-semibold text-white/80">LIVE METRICS</span>
                    <div>
                        <div class="w-8 h-[2px] bg-white mb-4"></div>
                        <h3 class="text-3xl font-medium tracking-tight leading-tight text-white/90">Data<br>sync<br>flow</h3>
                    </div>
                 </div>
            </div>

            <!-- Card 2 (Mid Left, Purple/White) -->
            <div class="card-item cursor-grab active:cursor-grabbing absolute w-[280px] h-[380px] rounded-3xl shadow-[0_20px_50px_rgba(0,0,0,0.5)] overflow-hidden bg-gradient-to-br from-[#E2DDFB] to-[#FDFDFD] z-20 border border-white/40"
                 style="transform: translateX(-200px) translateY(20px) rotate(-10deg) scale(0.95); transform-origin: center;">
                 <div class="p-8 h-full flex flex-col text-gray-800 pointer-events-none">
                    <span class="text-[11px] tracking-[0.2em] font-semibold text-gray-400 mb-6">PURE MINIMAL</span>
                    <h3 class="text-[34px] font-semibold tracking-tighter leading-[0.95] text-[#BDB5E9]">Space<br>gives<br>Focus</h3>
                 </div>
                 <!-- Large purple block -->
                 <div class="absolute -bottom-8 -left-8 w-48 h-48 bg-[#9B32F1] rounded-3xl rotate-12 shadow-lg pointer-events-none"></div>
            </div>

            <!-- Card 4 (Mid Right, Light Blue 3D folder concept) -->
            <div class="card-item cursor-grab active:cursor-grabbing absolute w-[280px] h-[380px] rounded-3xl shadow-[0_20px_50px_rgba(0,0,0,0.5)] overflow-hidden bg-gradient-to-b from-[#2B95E9] to-[#1AE6F0] z-20"
                 style="transform: translateX(200px) translateY(20px) rotate(12deg) scale(0.95); transform-origin: center;">
                 
                 <!-- Simulated 3D Graphic top half -->
                 <div class="h-[55%] relative overflow-hidden flex justify-center items-end pb-4 pointer-events-none">
                     <!-- Abstract blocky shapes -->
                     <div class="w-[180px] h-[140px] bg-[#1E74C8] rounded-xl transform perspective-1000 rotateX(20deg) rotateY(-10deg) relative shadow-2xl flex items-center justify-center border-t border-l border-white/30">
                        <div class="w-[160px] h-[120px] bg-[#F2F6F9] rounded-lg absolute top-[-10px] right-[-10px] shadow-sm overflow-hidden flex flex-col gap-2 p-3">
                            <div class="w-full h-2 bg-gray-200 rounded-full flex gap-2"><div class="w-4 h-full bg-orange-400 rounded-full"></div></div>
                            <div class="w-3/4 h-2 bg-gray-200 rounded-full flex gap-2"><div class="w-6 h-full bg-blue-400 rounded-full"></div></div>
                            <div class="w-full h-2 bg-gray-200 rounded-full mt-4"></div>
                            <div class="w-full h-2 bg-gray-200 rounded-full"></div>
                        </div>
                     </div>
                 </div>
                 <!-- Speech bubble text area bottom half -->
                 <div class="h-[45%] bg-gradient-to-b from-[#F2FBFF] to-[#D5F5FF] relative rounded-t-[40px] p-6 pt-8 pointer-events-none">
                     <!-- Bubble tail -->
                     <div class="absolute -top-6 left-10 w-0 h-0 border-l-[15px] border-l-transparent border-r-[15px] border-r-transparent border-b-[25px] border-b-[#F2FBFF]"></div>
                     <h3 class="text-[#0E526B] font-semibold text-[26px] leading-[0.9] tracking-tighter">THE NEXT<br>WAVE OF<br>INTERACT<br>DESIGN</h3>
                 </div>
            </div>

            <!-- Card 5 (Far Right, Red) -->
            <div class="card-item cursor-grab active:cursor-grabbing absolute w-[260px] h-[360px] rounded-3xl shadow-2xl overflow-hidden bg-[#EB0000] z-10"
                 style="transform: translateX(380px) translateY(80px) rotate(24deg) scale(0.85); transform-origin: center;">
                 <!-- Image with multiply blend -->
                 <img src="assets/page-01-4f5668c5-fc4a-44e0-bc5e-a664189d3c31-800w.jpg" 
                      alt="Portrait texture" 
                      class="absolute inset-0 w-full h-full object-cover object-left mix-blend-multiply opacity-80 filter grayscale contrast-125 pointer-events-none">
                 <div class="absolute inset-0 bg-gradient-to-t from-black/60 via-transparent to-transparent pointer-events-none"></div>
                 <div class="absolute bottom-6 right-6 text-right pointer-events-none">
                    <span class="text-white/60 text-sm font-medium tracking-widest">HEX</span>
                    <h3 class="text-4xl font-semibold tracking-tighter text-white">99</h3>
                 </div>
            </div>

            <!-- Card 3 (Center Focus, Frosted Glass & Border Gradient) -->
            <div class="card-item cursor-grab active:cursor-grabbing absolute w-[300px] h-[420px] rounded-[24px] shadow-[0_30px_80px_rgba(0,0,0,0.7)] z-30 p-[1px] bg-gradient-to-br from-white/60 via-white/10 to-transparent"
                 style="transform: translateX(0px) translateY(0px) rotate(0deg) scale(1.05); transform-origin: center;">
                 <!-- Inner Card Content -->
                 <div class="relative w-full h-full rounded-[23px] overflow-hidden bg-[#2A2326] pointer-events-none">
                     <!-- Background Texture: Blurred warm portrait -->
                     <img src="assets/page-02-0d868fef-f560-45ca-ab35-5dad4fc29059-800w.webp" 
                          alt="Frosted background" 
                          class="absolute inset-0 w-[150%] h-[150%] object-cover -left-1/4 -top-1/4 filter blur-[30px] opacity-70 saturate-150 sepia-[.3]">
                     
                     <!-- Dot Matrix Overlay specific to center card -->
                     <div class="absolute inset-0 opacity-[0.15]" style="background-image: radial-gradient(#fff 1px, transparent 1px); background-size: 4px 4px;"></div>
                     
                     <!-- Noise Overlay -->
                     <div class="absolute inset-0 mix-blend-overlay opacity-40" style="background-image: url('data:image/svg+xml,%3Csvg viewBox=%220 0 200 200%22 xmlns=%22http://www.w3.org/2000/svg%22%3E%3Cfilter id=%22noiseFilter%22%3E%3CfeTurbulence type=%22fractalNoise%22 baseFrequency=%220.85%22 numOctaves=%223%22 stitchTiles=%22stitch%22/%3E%3C/filter%3E%3Crect width=%22100%25%22 height=%22100%25%22 filter=%22url(%23noiseFilter)%22/%3E%3C/svg%3E');"></div>
                     
                     <!-- Gradient masking for edges -->
                     <div class="absolute inset-0 shadow-[inset_0_0_40px_rgba(0,0,0,0.6)]"></div>

                     <!-- Content -->
                     <div class="absolute inset-0 p-8 flex flex-col justify-end text-white pb-10">
                        <span class="text-[11px] tracking-[0.15em] font-medium text-white/90 mb-3 drop-shadow-md">AURA SYSTEMS</span>
                        <h2 class="text-[44px] font-semibold tracking-[[-0.04em]] leading-[0.9] drop-shadow-lg flex flex-col">
                            <span>Expanding</span>
                            <span>the digital</span>
                            <span class="flex items-center gap-2">
                                mind 
                                <!-- Decorative Circle -->
                                <div class="w-8 h-8 rounded-full border-[6px] border-[#D9B5CA] bg-transparent mt-1 shadow-inner"></div>
                            </span>
                        </h2>
                     </div>
                 </div>
            </div>
            
        </div>
    </main>

    <!-- WebGL & Animation Scripts -->
    <script>
        // --- WebGL Background: Dot Matrix Pulse ---
        const canvas = document.getElementById('webgl-canvas');
        
        const renderer = new THREE.WebGLRenderer({ canvas, alpha: true, antialias: false });
        renderer.setPixelRatio(Math.min(window.devicePixelRatio, 2));
        
        const scene = new THREE.Scene();
        const camera = new THREE.PerspectiveCamera(45, window.innerWidth / window.innerHeight, 1, 1000);
        camera.position.z = 100;

        const vertexShader = `
            uniform float uTime;
            attribute float aOffset;
            varying float vAlpha;
            void main() {
                float pulse = sin(uTime * 0.5 + aOffset) * 0.5 + 0.5;
                vec4 mvPosition = modelViewMatrix * vec4(position, 1.0);
                gl_Position = projectionMatrix * mvPosition;
                vAlpha = smoothstep(-150.0, 50.0, mvPosition.z) * (0.1 + 0.3 * pulse);
                gl_PointSize = (2.0 + pulse * 1.5) * (100.0 / -mvPosition.z);
            }
        `;

        const fragmentShader = `
            varying float vAlpha;
            void main() {
                vec2 coord = gl_PointCoord - vec2(0.5);
                if(length(coord) > 0.5) discard;
                gl_FragColor = vec4(1.0, 1.0, 1.0, vAlpha);
            }
        `;

        const gridX = 40;
        const gridZ = 40;
        const spacing = 10;
        const particleCount = gridX * gridZ;
        
        const positions = new Float32Array(particleCount * 3);
        const offsets = new Float32Array(particleCount);

        let i = 0;
        for (let x = 0; x < gridX; x++) {
            for (let z = 0; z < gridZ; z++) {
                positions[i * 3] = (x - gridX / 2) * spacing;
                positions[i * 3 + 1] = (Math.random() * 10) - 15;
                positions[i * 3 + 2] = (z - gridZ / 2) * spacing;
                offsets[i] = Math.random() * Math.PI * 2;
                i++;
            }
        }

        const geometry = new THREE.BufferGeometry();
        geometry.setAttribute('position', new THREE.BufferAttribute(positions, 3));
        geometry.setAttribute('aOffset', new THREE.BufferAttribute(offsets, 1));

        const material = new THREE.ShaderMaterial({
            vertexShader,
            fragmentShader,
            transparent: true,
            depthWrite: false,
            uniforms: {
                uTime: { value: 0 }
            }
        });

        const particles = new THREE.Points(geometry, material);
        particles.rotation.x = Math.PI * 0.4;
        particles.position.y = -20;
        scene.add(particles);

        function resize() {
            camera.aspect = window.innerWidth / window.innerHeight;
            camera.updateProjectionMatrix();
            renderer.setSize(window.innerWidth, window.innerHeight);
        }
        window.addEventListener('resize', resize);
        resize();

        let mouseX = 0;
        let mouseY = 0;
        let targetX = 0;
        let targetY = 0;
        const windowHalfX = window.innerWidth / 2;
        const windowHalfY = window.innerHeight / 2;

        document.addEventListener('mousemove', (event) => {
            mouseX = (event.clientX - windowHalfX) * 0.05;
            mouseY = (event.clientY - windowHalfY) * 0.05;
        });

        const clock = new THREE.Clock();
        function animate() {
            requestAnimationFrame(animate);
            const elapsedTime = clock.getElapsedTime();
            material.uniforms.uTime.value = elapsedTime;

            targetX = mouseX * 0.5;
            targetY = mouseY * 0.5;
            camera.position.x += (targetX - camera.position.x) * 0.02;
            camera.position.y += (-targetY - camera.position.y + 10) * 0.02; 
            camera.lookAt(scene.position);

            renderer.render(scene, camera);
        }
        animate();


        // --- GSAP UI Animations & Drag Interaction ---
        document.addEventListener("DOMContentLoaded", () => {
            // Header & Title fade in
            gsap.to(".hero-anim", {
                y: 0,
                opacity: 1,
                duration: 1,
                stagger: 0.15,
                ease: "power3.out",
                delay: 0.2
            });

            // Cards setup
            const cards = document.querySelectorAll('.card-item');
            let highestZ = 100;
            
            const finalStates = Array.from(cards).map(card => {
                const transform = card.style.transform;
                const matchX = transform.match(/translateX\(([^)]+)\)/);
                const matchY = transform.match(/translateY\(([^)]+)\)/);
                const matchRot = transform.match(/rotate\(([^)]+)\)/);
                const matchScale = transform.match(/scale\(([^)]+)\)/);
                
                return {
                    x: matchX ? parseFloat(matchX[1]) : 0,
                    y: matchY ? parseFloat(matchY[1]) : 0,
                    rotation: matchRot ? parseFloat(matchRot[1]) : 0,
                    scale: matchScale ? parseFloat(matchScale[1]) : 1
                };
            });

            // Register Draggable plugin
            gsap.registerPlugin(Draggable);

            cards.forEach((card, i) => {
                const final = finalStates[i];
                
                // Entrance animation
                gsap.fromTo(card, 
                    {
                        x: final.x * 1.5,
                        y: final.y + 150,
                        rotation: final.rotation * 1.5,
                        scale: final.scale * 0.8,
                        opacity: 0
                    },
                    {
                        x: final.x,
                        y: final.y,
                        rotation: final.rotation,
                        scale: final.scale,
                        opacity: 1,
                        duration: 1.4,
                        ease: "back.out(1.2)",
                        delay: 0.6 + (i * 0.08),
                        onComplete: () => {
                            // Add continuous floating animation which will be paused/resumed on drag
                            card.floatAnim = gsap.to(card, {
                                y: "+=" + (Math.random() * 10 - 5),
                                rotation: "+=" + (Math.random() * 2 - 1),
                                duration: 3 + Math.random() * 2,
                                repeat: -1,
                                yoyo: true,
                                ease: "sine.inOut"
                            });
                        }
                    }
                );

                // Add drag interaction
                Draggable.create(card, {
                    type: "x,y",
                    bounds: window,
                    onPress: function() {
                        // Kill entrance anim if still running, and pause floating
                        gsap.killTweensOf(this.target, "x,y,rotation,scale,opacity");
                        if (this.target.floatAnim) this.target.floatAnim.kill();
                        
                        // Bring card to front
                        highestZ += 1;
                        this.target.style.zIndex = highestZ;
                    },
                    onRelease: function() {
                        // Resume floating from its new dropped position
                        this.target.floatAnim = gsap.to(this.target, {
                            y: "+=" + (Math.random() * 10 - 5),
                            rotation: "+=" + (Math.random() * 2 - 1),
                            duration: 3 + Math.random() * 2,
                            repeat: -1,
                            yoyo: true,
                            ease: "sine.inOut"
                        });
                    }
                });
            });
        });
    </script>
</body>
</html>
";
    const assetFiles = ["assets/page-01-4f5668c5-fc4a-44e0-bc5e-a664189d3c31-800w.jpg","assets/page-02-0d868fef-f560-45ca-ab35-5dad4fc29059-800w.webp"];
    const runtimeFiles = ["../../../../assets/runtime/runtime-027051effa47-gsap-min.js","../../../../assets/runtime/runtime-163ebd087cfc-iconify-icon-min.js","../../../../assets/runtime/runtime-25023b521d77-three-min.js","../../../../assets/runtime/runtime-8da2c9e0e562-draggable-min.js","../../../../assets/runtime/runtime-ccc8894b3418-runtime.js"];
    const frame = document.getElementById("neuform-demo");
    const decodeBytes = (value) => Uint8Array.from(atob(value), (character) => character.charCodeAt(0));
    const decode = (value) => new TextDecoder().decode(decodeBytes(value));
    const encodeBytes = (bytes) => {
      let binary = "";
      for (let index = 0; index < bytes.length; index += 32768) {
        binary += String.fromCharCode(...bytes.subarray(index, index + 32768));
      }
      return btoa(binary);
    };
    const mediaTypes = {
      avif: "image/avif",
      gif: "image/gif",
      jpg: "image/jpeg",
      jpeg: "image/jpeg",
      mp4: "video/mp4",
      png: "image/png",
      webm: "video/webm",
      webp: "image/webp"
    };
    const loadAsset = async (file) => {
      const response = await fetch(file, { cache: "no-store", credentials: "omit", redirect: "error" });
      if (!response.ok) throw new Error("Could not load local demo asset: " + file);
      const extension = file.split(".").pop().toLowerCase();
      const contentType = mediaTypes[extension] || "application/octet-stream";
      const bytes = new Uint8Array(await response.arrayBuffer());
      return { base64: encodeBytes(bytes), contentType, file, kind: "asset" };
    };
    Promise.allSettled(assetFiles.map(loadAsset)).then((results) => {
      const runtimeSources = runtimeFiles.map((file) => new URL(file, location.href).href).join(" ");
      const source = decode(encodedHtml).replace("__NEUFORM_RUNTIME_SOURCES__", runtimeSources);
      const mediaAssets = [];
      for (const result of results) {
        if (result.status !== "fulfilled") continue;
        mediaAssets.push(result.value);
      }
      frame.addEventListener("load", () => {
        frame.contentWindow.postMessage({ type: "neuform-assets-v1", assets: mediaAssets }, "*");
      }, { once: true });
      frame.srcdoc = source;
    }).catch((error) => {
      document.body.innerHTML = '<div class="error">Unable to load this sandboxed demo.</div>';
      console.error(error);
    });
  </script>
</body>
</html>

Requirements and compatibility

Works with: Claude Code, Claude apps, OpenAI Codex, GitHub Copilot, Cursor, Gemini CLI, Kiro, OpenCode, Goose, Amp, Roo Code, JetBrains Junie, Factory Droid, Devin (ex-Windsurf), Mistral Vibe, OpenHands, Letta

“Works with” means the tool reads the open Agent Skills format; a skill written for one tool may use features others lack.

Security

What our scanner noticed· Medium risk

Large base64-encoded blobs

A static scan is not a guarantee. Skills are third-party content: review a skill before you let an agent use it.

Attribution and licence

Created by

Meng To

Publisher

Meng To (Community)

Source

MengTo/Skills · agent-skills/web-design/gsap · commit 5ea1661

Licence

MIT License (redistribution allowed)

LICENSE (added by AutoGineer from LICENSE)
ATTRIBUTION.md (written by AutoGineer)

Synced

2026-11-08

AutoGineer is not affiliated with or endorsed by Meng To.

Download ZIP

The ZIP holds the skill’s files, its licence files and an ATTRIBUTION.md. Download gsap.zip