example-gsap
Patterns for using Helios with GSAP (GreenSock). Use when integrating GSAP timelines with the Helios timeline for precise scrubbing and rendering.
Best use case
example-gsap is best used when you need a repeatable AI agent workflow instead of a one-off prompt.
Patterns for using Helios with GSAP (GreenSock). Use when integrating GSAP timelines with the Helios timeline for precise scrubbing and rendering.
Teams using example-gsap should expect a more consistent output, faster repeated execution, less prompt rewriting.
When to use this skill
- You want a reusable workflow that can be run more than once with consistent structure.
When not to use this skill
- You only need a quick one-off answer and do not need a reusable workflow.
- You cannot install or maintain the underlying files, dependencies, or repository context.
Installation
Claude Code / Cursor / Codex
Manual Installation
- Download SKILL.md from GitHub
- Place it in
.claude/skills/gsap/SKILL.mdinside your project - Restart your AI agent — it will auto-discover the skill
How example-gsap Compares
| Feature / Agent | example-gsap | Standard Approach |
|---|---|---|
| Platform Support | Not specified | Limited / Varies |
| Context Awareness | High | Baseline |
| Installation Complexity | Unknown | N/A |
Frequently Asked Questions
What does this skill do?
Patterns for using Helios with GSAP (GreenSock). Use when integrating GSAP timelines with the Helios timeline for precise scrubbing and rendering.
Where can I find the source code?
You can find the source code on GitHub using the link provided at the top of the page.
SKILL.md Source
# GSAP Integration Patterns
To use GSAP with Helios, you must drive the GSAP Timeline instance using the Helios frame state. This allows GSAP animations to be scrubbed, paused, and rendered frame-by-frame.
## Quick Start
### The "Paused Timeline" Pattern
1. Create a GSAP Timeline with `paused: true`.
2. Subscribe to Helios updates.
3. Inside the subscription, convert the Helios frame to seconds.
4. Call `timeline.seek(seconds)` to synchronize.
```html
<script type="module">
import { Helios } from '@helios-project/core';
import { gsap } from 'gsap';
// 1. Initialize Helios
const helios = new Helios({
fps: 30,
durationInSeconds: 5,
});
// 2. Setup GSAP Timeline (PAUSED is critical)
const tl = gsap.timeline({ paused: true });
// 3. Define animations
tl.to(".box", {
rotation: 360,
x: 100,
duration: 2,
ease: "power1.inOut"
})
.to(".box", {
scale: 2,
duration: 2
});
// 4. Subscribe and Sync
helios.subscribe((state) => {
// Convert frame count to seconds
const timeInSeconds = state.currentFrame / helios.fps;
// Seek GSAP to exact time
tl.seek(timeInSeconds);
});
// 5. Bind for Preview
helios.bindToDocumentTimeline();
window.helios = helios;
</script>
```
## Critical Rules
1. **Always Pause:** The GSAP timeline must be initialized with `{ paused: true }`. If it plays automatically, it will fight with Helios for control.
2. **Use Seek:** Do not use `tl.progress()` unless you calculate the normalized 0-1 value. `tl.seek(seconds)` is usually more direct since Helios knows FPS and Frame Count.
3. **No `requestAnimationFrame`:** Do not create your own rAF loop for GSAP. Let Helios drive the updates via `subscribe`.
## Source Files
- Example: `examples/gsap-animation/`Related Skills
example-vue
Patterns for using Helios with Vue. Use when building compositions in a Vue environment.
example-vanilla
Patterns for using Helios with Vanilla JavaScript/TypeScript. Use when building compositions without a framework, or for simple DOM/Canvas manipulations.
example-threejs
Patterns for using Helios with Three.js and React Three Fiber. Use when creating 3D animations or integrating WebGL scenes.
example-tailwind-animation
Learn how to use Tailwind CSS with Helios. Use for styling compositions and animating with utility classes.
example-svelte
Patterns for using Helios with Svelte. Use when building compositions in a Svelte environment, utilizing Svelte stores for reactive frame updates.
example-solid
Patterns for using Helios with SolidJS. Use when building compositions in a SolidJS environment, utilizing signals for fine-grained reactivity.
example-signals-animation
Learn how to use Helios Signals for high-performance, fine-grained reactivity. Use for complex dependency graphs or when optimizing performance.
example-react
Patterns for using Helios with React. Use when building compositions in a React environment.
example-podcast-visualizer
Workflow for creating a podcast visualizer with multi-track audio mixing and DOM-based synchronization. Use when building audio-reactive compositions.
example-pixi
PixiJS integration patterns for Helios. Use when creating high-performance WebGL 2D animations with PixiJS.
example-p5-animation
Learn how to use P5.js with Helios. Use when creating creative coding sketches or generative art.
example-lottie
Lottie integration patterns for Helios. Use when rendering Lottie (Bodymovin) JSON animations synchronously with Helios.