marselo-4/TotAuto / .claude/skills/gsap-scrolltrigger
gsap-scrolltrigger
VerifiedComprehensive skill for GSAP (GreenSock Animation Platform) and ScrollTrigger plugin. Use this skill when creating web animations, scroll-driven experiences, timelines, tweens, scroll-triggered animations, pinning, scrubbing, parallax effects, or animating DOM elements, SVG, Canvas, WebGL, or Three.js. Triggers on tasks involving GSAP, ScrollTrigger, smooth animations, scroll effects, or animation sequencing.
| File | Kind | Size |
|---|---|---|
| SKILL.md | skill md | 16.8 KB |
| assets/easings/easing_visualizer.html | other | 14.0 KB |
| assets/examples/README.md | markdown | 8.2 KB |
| assets/starter_scroll/README.md | markdown | 10.5 KB |
| assets/starter_scroll/index.html | other | 8.1 KB |
| assets/starter_scroll/main.js | script | 9.6 KB |
| assets/starter_scroll/style.css | other | 11.3 KB |
| references/api_reference.md | markdown | 8.8 KB |
| references/common_patterns.md | markdown | 23.9 KB |
| references/easing_guide.md | markdown | 16.0 KB |
| scripts/generate_animation.pyexecutable | script | 13.6 KB |
| scripts/timeline_builder.pyexecutable | script | 18.3 KB |
references/easing_guide.md
View on GitHub# GSAP Easing Functions - Visual Guide
## What Are Easings?
Easings control the **rate of change** during an animation, making motion feel more natural and expressive. They define the acceleration curve between the start and end of an animation.
- **Linear**: Constant speed (robotic, unnatural)
- **Ease In**: Starts slow, ends fast (acceleration)
- **Ease Out**: Starts fast, ends slow (deceleration) - **Most common**
- **Ease InOut**: Starts slow, speeds up, ends slow (smooth both ends)
## Why Easings Matter
```javascript
// Without proper easing - feels robotic
gsap.to(".box", { x: 500, duration: 1, ease: "none" });
// With easing - feels natural
gsap.to(".box", { x: 500, duration: 1, ease: "power2.out" });
```
**The 80/20 Rule**: Most UI animations use `power2.out`, `power3.out`, or `back.out`.
---
## Easing Families
### 1. Power Easings (Most Common)
Power easings use polynomial curves. Higher numbers = more aggressive curves.
#### power1 (Quad)
```
Curve Shape:
in: ╱───── Gentle acceleration
out: ─────╲ Gentle deceleration
inOut: ╱───╲ Gentle both ends
```
**Use Cases**:
- Subtle UI transitions
- Small movements (tooltips, dropdowns)
- Background animations that shouldn't grab attention
**Example**:
```javascript
// Tooltip fade in
gsap.from(".tooltip", {
opacity: 0,
y: -10,
duration: 0.3,
ease: "power1.out"
});
```
---
#### power2 (Cubic) ⭐ MOST POPULAR
```
Curve Shape:
in: ╱╱──── Moderate acceleration
out: ────╲╲ Moderate deceleration
inOut: ╱──╲ Moderate both ends
```
**Use Cases**:
- **Default choice for most UI animations**
- Button clicks, modal animations
- Element entrances/exits
- Smooth scrolling
**Example**:
```javascript
// Modal slide in
gsap.from(".modal", {
y: 50,
opacity: 0,
duration: 0.5,
ease: "power2.out" // ⭐ Most common choice
});
```
---
#### power3 (Quart)
```
Curve Shape:
in: ╱╱╱─── Strong acceleration
out: ───╲╲╲ Strong deceleration
inOut: ╱─╲ Strong both ends
```
**Use Cases**:
- Hero animations
- Page transitions
- Large movements across screen
- Attention-grabbing effects
**Example**:
```javascript
// Hero section reveal
gsap.from(".hero", {
scale: 0.8,
opacity: 0,
duration: 1,
ease: "power3.out"
});
```
---
#### power4 (Quint)
```
Curve Shape:
in: ╱╱╱╱── Very strong acceleration
out: ──╲╲╲╲ Very strong deceleration
inOut: ╱╲ Very strong both ends
```
**Use Cases**:
- Dramatic reveals
- Full-screen transitions
- Heavy objects (metaphorically)
- When you want maximum impact
**Example**:
```javascript
// Full-screen overlay
gsap.to(".overlay", {
scale: 1,
opacity: 1,
duration: 0.8,
ease: "power4.out"
});
```
---
### 2. Back Easings (Overshoot)
Back easings **overshoot** the target, then settle back. Creates anticipation and playfulness.
```
Curve Shape:
in: ╲╱──── Backs up, then accelerates
out: ────╱╲ Overshoots, then settles
inOut: ╲╱─╱╲ Both ends overshoot
```
**Parameters**: `back.out(1.7)` - Higher number = more overshoot (default: 1.7)
**Use Cases**:
- Playful UI elements
- Buttons with personality
- Attention-grabbing reveals
- Fun micro-interactions
**Example**:
```javascript
// Button with bounce
gsap.from(".button", {
scale: 0,
duration: 0.5,
ease: "back.out(1.7)" // Classic overshoot
});
// Extreme overshoot for fun effect
gsap.from(".badge", {
scale: 0,
rotation: -180,
duration: 0.8,
ease: "back.out(3)" // More dramatic
});
```
**Pro Tip**: Use `back.out(1.2)` for subtle overshoot, `back.out(2.5)` for exaggerated effect.
---
### 3. Elastic Easings (Spring/Rubber Band)
Elastic easings create a **spring/bounce** effect, oscillating around the target.
```
Curve Shape:
in: ╲╱╲╱── Oscillates, then accelerates
out: ──╱╲╱╲ Overshoots multiple times, then settles
inOut: ╲╱╲╱╲ Both ends oscillate
```
**Parameters**: `elastic.out(amplitude, period)`
- **amplitude**: Strength of oscillation (default: 1)
- **period**: Frequency of oscillation (default: 0.3)
**Use Cases**:
- Cartoonish effects
- Game UI elements
- Fun landing pages
- Notification badges
- **Use sparingly** - can feel gimmicky
**Example**:
```javascript
// Notification badge
gsap.from(".badge", {
scale: 0,
duration: 1,
ease: "elastic.out(1, 0.3)"
});
// Stronger spring effect
gsap.from(".icon", {
y: -50,
duration: 1.5,
ease: "elastic.out(1.5, 0.4)" // More bounce
});
```
**Warning**: Elastic can feel unprofessional if overused. Best for gaming/playful interfaces.
---
### 4. Bounce Easings
Bounce easings simulate a **bouncing ball** landing.
```
Curve Shape:
in: ╲╱╲╱╲── Bounces, then accelerates
out: ──╲╱╲╱╲ Lands with decreasing bounces
inOut: ╲╱─╱╲ Both ends bounce
```
**Use Cases**:
- Elements "dropping" into place
- Playful UI (games, children's apps)
- Landing animations
- Fun effects (use sparingly)
**Example**:
```javascript
// Element drops in
gsap.from(".card", {
y: -200,
duration: 1,
ease: "bounce.out"
});
// Multiple cards with stagger
gsap.from(".card", {
y: -100,
opacity: 0,
duration: 1,
ease: "bounce.out",
stagger: 0.1
});
```
**Pro Tip**: Combine with `power2.in` for objects falling before bouncing.
---
### 5. Circ Easings (Circular)
Circular easings use a quarter-circle curve. Creates **sharp acceleration/deceleration**.
```
Curve Shape:
in: ╱╱──── Sharp acceleration (quarter circle)
out: ────╲╲ Sharp deceleration
inOut: ╱──╲ Sharp both ends
```
**Use Cases**:
- Fast, snappy movements
- Material Design-style animations
- Quick transitions
- When you want instant impact
**Example**:
```javascript
// Quick slide-in drawer
gsap.to(".drawer", {
x: 0,
duration: 0.3,
ease: "circ.out"
});
```
---
### 6. Expo Easings (Exponential)
Exponential easings create **very dramatic** acceleration/deceleration curves.
```
Curve Shape:
in: ╱╱╱─── Extremely slow start, then explodes
out: ───╲╲╲ Extremely fast start, then crawls
inOut: ╱─╲ Extreme both ends
```
**Use Cases**:
- Dramatic reveals
- Cinematic effects
- Zoom-in/zoom-out animations
- When you want **maximum drama**
**Example**:
```javascript
// Dramatic zoom in
gsap.from(".hero-image", {
scale: 5,
opacity: 0,
duration: 1.5,
ease: "expo.out"
});
// Intense page transition
gsap.to(".page", {
x: -window.innerWidth,
duration: 1,
ease: "expo.inOut"
});
```
---
### 7. Sine Easings
Sine easings are **extremely gentle**, using a sine wave curve.
```
Curve Shape:
in: ╱───── Very gentle acceleration
out: ─────╲ Very gentle deceleration
inOut: ╱───╲ Very gentle both ends
```
**Use Cases**:
- Subtle, barely-noticeable animations
- Background movements
- Ambient effects
- Parallax scrolling
- When animation should be **invisible**
**Example**:
```javascript
// Gentle parallax
gsap.to(".bg", {
y: 100,
ease: "sine.out",
scrollTrigger: {
scrub: true
}
});
// Subtle float animation
gsap.to(".cloud", {
y: "+=20",
duration: 3,
ease: "sine.inOut",
yoyo: true,
repeat: -1
});
```
---
### 8. None (Linear)
No easing at all - constant speed throughout.
```
Curve Shape: ────── Perfectly straight line
```
**Use Cases**:
- **ScrollTrigger with scrub** (let user control speed)
- Loading bars (constant progress)
- Background loops
- Mechanical movements
- **Rarely used for regular animations**
**Example**:
```javascript
// Horizontal scroll (user controls speed)
gsap.to(".panels", {
xPercent: -100,
ease: "none", // User controls via scroll
scrollTrigger: {
scrub: true
}
});
// Loading bar
gsap.to(".progress", {
width: "100%",
duration: 5,
ease: "none"
});
```
---
## Quick Decision Tree
### 1. What's the purpose?
**Subtle UI transition** → `power1.out` or `power2.out`
**Standard animation** → `power2.out` ⭐ (default choice)
**Hero/dramatic effect** → `power3.out` or `power4.out`
**Playful/fun** → `back.out(1.7)` or `elastic.out()`
**Game/cartoon** → `bounce.out` or `elastic.out()`
**Scroll-driven** → `none` (with scrub)
**Background/ambient** → `sine.inOut`
---
### 2. How noticeable should it be?
```
Subtle ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━→ Dramatic
sine.out power1.out power2.out power3.out expo.out
⭐ Start here
Gentle ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━→ Playful
circ.out back.out(1.2) back.out(1.7) elastic.out()
```
---
## Common Patterns by Use Case
### UI Animations (80% of use cases)
```javascript
// Standard choice
ease: "power2.out"
// Slightly more dramatic
ease: "power3.out"
// Playful
ease: "back.out(1.7)"
```
### Scroll Animations
```javascript
// Let user control speed
ease: "none",
scrollTrigger: { scrub: true }
// Smooth snap scrolling
ease: "power2.inOut",
scrollTrigger: { snap: 1 }
```
### Micro-interactions
```javascript
// Button hover
ease: "power1.out", duration: 0.2
// Toggle switch
ease: "back.out(2)", duration: 0.4
// Ripple effect
ease: "power2.out", duration: 0.6
```
### Page Transitions
```javascript
// Standard page transition
ease: "power3.inOut", duration: 0.8
// Dramatic reveal
ease: "expo.out", duration: 1.2
```
### Loading States
```javascript
// Loading spinner
ease: "none", repeat: -1
// Progress bar
ease: "power2.out", duration: 2
```
---
## Easing Combinations
### Sequential Easings (Timeline)
```javascript
const tl = gsap.timeline();
// Slide in fast, settle slow
tl.to(".card", { y: 0, duration: 0.3, ease: "power3.in" })
.to(".card", { scale: 1, duration: 0.4, ease: "back.out(2)" });
```
### Staggered with Different Easings
```javascript
gsap.from(".item", {
opacity: 0,
y: 50,
duration: 0.6,
ease: "power2.out",
stagger: {
each: 0.1,
ease: "power1.inOut" // Easing for stagger timing itself
}
});
```
### Physics-based Fallback
```javascript
// Light object (fast)
gsap.to(".feather", { y: 500, duration: 2, ease: "sine.in" });
// Heavy object (slow start)
gsap.to(".anvil", { y: 500, duration: 1.5, ease: "power4.in" });
```
---
## Custom Easings
### Custom Bezier Curve
```javascript
// Use CustomEase plugin (Club GreenSock)
gsap.registerPlugin(CustomEase);
CustomEase.create("customBounce", "0.5,0,0.75,1.5,1");
gsap.to(".box", {
x: 500,
duration: 1,
ease: "customBounce"
});
```
### Steps (Stepped Animation)
```javascript
// Simulate frame-by-frame animation
gsap.to(".sprite", {
x: 500,
duration: 1,
ease: "steps(12)" // 12 discrete steps
});
```
---
## Testing Easings
### Easing Visualizer (Inline Tool)
Save this as `easings.html` to test easings visually:
```html
<!DOCTYPE html>
<html>
<head>
<script src="https://cdn.jsdelivr.net/npm/gsap@3/dist/gsap.min.js"></script>
<style>
body { font-family: system-ui; padding: 40px; background: #1a1a2e; color: white; }
.box { width: 50px; height: 50px; background: #00ffcc; margin: 20px 0; border-radius: 8px; }
button { padding: 10px 20px; margin: 5px; background: #00ffcc; border: none; border-radius: 5px; cursor: pointer; }
</style>
</head>
<body>
<h1>GSAP Easing Tester</h1>
<div id="boxes"></div>
<button onclick="testAll()">Test All Easings</button>
<script>
const easings = [
"none",
"power1.out", "power2.out", "power3.out", "power4.out",
"back.out(1.7)", "elastic.out(1, 0.3)", "bounce.out",
"circ.out", "expo.out", "sine.out"
];
const container = document.getElementById('boxes');
easings.forEach(ease => {
const label = document.createElement('div');
label.textContent = ease;
label.style.marginTop = '20px';
container.appendChild(label);
const box = document.createElement('div');
box.className = 'box';
box.dataset.ease = ease;
container.appendChild(box);
});
function testAll() {
document.querySelectorAll('.box').forEach(box => {
gsap.fromTo(box,
{ x: 0 },
{ x: 500, duration: 1.5, ease: box.dataset.ease }
);
});
}
</script>
</body>
</html>
```
**Online Tools**:
- [GreenSock Ease Visualizer](https://gsap.com/docs/v3/Eases)
- [Cubic Bezier Generator](https://cubic-bezier.com)
---
## Performance Notes
### Do Easings Affect Performance?
**No** - Easings are mathematical functions with negligible overhead. Choose based on aesthetics, not performance.
**Exception**: Custom bezier curves with many control points can be slightly slower (still negligible).
---
## Common Mistakes
### ❌ Using Linear for UI Animations
```javascript
// Feels robotic
gsap.to(".button", { scale: 1.1, duration: 0.3, ease: "none" });
```
✅ **Fix**: Use `power2.out`
```javascript
gsap.to(".button", { scale: 1.1, duration: 0.3, ease: "power2.out" });
```
---
### ❌ Over-using Elastic/Bounce
```javascript
// Every element bounces - feels gimmicky
gsap.from(".item", { scale: 0, ease: "elastic.out(2, 0.3)", stagger: 0.1 });
```
✅ **Fix**: Use sparingly for key elements
```javascript
// Only hero element has elastic
gsap.from(".hero", { scale: 0, ease: "elastic.out(1, 0.3)" });
gsap.from(".item", { scale: 0, ease: "back.out(1.7)", stagger: 0.1 });
```
---
### ❌ Wrong Direction (in vs out)
```javascript
// Element exits with ease.in (feels slow to start)
gsap.to(".modal", { opacity: 0, ease: "power2.in" });
```
✅ **Fix**: Use `out` for exits
```javascript
gsap.to(".modal", { opacity: 0, ease: "power2.out" });
```
**Rule**:
- **Entrances** → `ease.out` (fast start, slow end)
- **Exits** → `ease.out` (consistent)
- **Both** → `ease.inOut` (smooth both ends)
---
## Best Practices
### 1. Start with power2.out
It's the goldilocks easing - not too gentle, not too aggressive.
### 2. Match Easing to Content
- **Lightweight** (modals, tooltips) → `power1.out` or `power2.out`
- **Medium** (cards, sections) → `power2.out` or `power3.out`
- **Heavy** (full pages, heroes) → `power3.out` or `power4.out`
### 3. Be Consistent
Use the same easing family throughout your project for cohesion.
### 4. Test at Different Speeds
Easings behave differently at different durations:
```javascript
// Too short - easing barely noticeable
duration: 0.1, ease: "power3.out"
// Sweet spot
duration: 0.4, ease: "power3.out"
// Too long - feels sluggish
duration: 2, ease: "power3.out"
```
### 5. Consider Context
- **Professional/Corporate** → `power2.out`, `power3.out`
- **Playful/Fun** → `back.out`, `elastic.out`
- **Luxury/Premium** → `expo.out`, `power4.out`
- **Fast/Responsive** → `circ.out`, `power2.out`
---
## Cheat Sheet
| Use Case | Easing | Duration | Notes |
|----------|--------|----------|-------|
| Default UI | `power2.out` | 0.3-0.5s | Start here |
| Hero animation | `power3.out` | 0.8-1.2s | More impact |
| Button hover | `power1.out` | 0.2s | Quick & subtle |
| Modal open | `power2.out` | 0.4s | Smooth entrance |
| Tooltip | `power1.out` | 0.2s | Fast & light |
| Scroll scrub | `none` | N/A | User-controlled |
| Page transition | `power3.inOut` | 0.8s | Smooth both ends |
| Playful button | `back.out(1.7)` | 0.5s | Overshoot |
| Notification | `back.out(2)` | 0.6s | Attention-grabbing |
| Parallax | `sine.out` | N/A | Barely noticeable |
| Loading bar | `none` | Variable | Constant speed |
| Bounce-in | `bounce.out` | 1s | Use sparingly |
---
## Summary
**The 3 Easings You Need to Know**:
1. **power2.out** ⭐ - Your default choice (80% of animations)
2. **power3.out** - For dramatic effects
3. **back.out(1.7)** - For playful interactions
**Golden Rules**:
- When in doubt, use `power2.out`
- Entrances and exits both use `.out`
- ScrollTrigger with scrub uses `none`
- Be consistent across your project
- Test different durations to find the sweet spot
**Remember**: Good easing makes animations feel natural and purposeful. Bad easing makes them feel robotic or gimmicky.
Related skills
| Skill | Stars | Updated | Works with | Status | Install |
|---|---|---|---|---|---|
| reverse-engineer-anythingmorluto/reaReverse engineer native, managed, Electron/JavaScript, packaged, firmware, and browser targets with REA, and build agent environments (AgentEnv bundles) of web applications from a live instance or a capture, and of Linux desktop apps with a task from a request. Use shipped-artifact or requested runtime evidence to explain features, compare versions, decompile code, or guide a reconstruction. Skip REA for ordinary source-repository architecture analysis. | Stars: 471k | Updated | Claude CodeCodex | Verified | Install |
| diagnosing-superpowersobra/superpowersUse when a superpowers session went wrong and your human partner wants to know why — repeated work, ignored plans, stumbles, poor results, a skill that didn't fire, "it took too long", "why is it so expensive", "what is it doing" — or wants to build a bug report for the superpowers maintainers, for the current session or a past one identified by id or path, on any harness. | Stars: 322k | Updated | Claude CodeCodex | Verified | Install |
| dispatching-parallel-agentsobra/superpowersUse when facing 2+ independent tasks that can be worked on without shared state or sequential dependencies | Stars: 322k | Updated | Claude CodeCodex | Verified | Install |
| executing-plansobra/superpowersUse when executing an implementation plan in the current session as the implementer yourself — your human partner chose inline execution, or no subagent tool is available | Stars: 322k | Updated | Claude CodeCodex | Verified | Install |