example-vanilla
Patterns for using Helios with Vanilla JavaScript/TypeScript. Use when building compositions without a framework, or for simple DOM/Canvas manipulations.
Best use case
example-vanilla is best used when you need a repeatable AI agent workflow instead of a one-off prompt.
Patterns for using Helios with Vanilla JavaScript/TypeScript. Use when building compositions without a framework, or for simple DOM/Canvas manipulations.
Teams using example-vanilla 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/vanilla/SKILL.mdinside your project - Restart your AI agent — it will auto-discover the skill
How example-vanilla Compares
| Feature / Agent | example-vanilla | 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 Vanilla JavaScript/TypeScript. Use when building compositions without a framework, or for simple DOM/Canvas manipulations.
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
# Vanilla JS Composition Patterns
Integrate Helios into standard HTML/JS applications using direct DOM manipulation and subscriptions.
## Quick Start
### 1. Setup
Initialize Helios and bind to the document timeline.
```typescript
import { Helios } from '@helios-project/core';
// 1. Initialize Helios
const helios = new Helios({
duration: 10,
fps: 30,
width: 1920,
height: 1080,
autoSyncAnimations: true // Sync WAAPI/CSS animations
});
// 2. Expose for Player/Studio
(window as any).helios = helios;
// 3. Bind to external timeline (important for Renderer/Studio)
helios.bindToDocumentTimeline();
```
### 2. Subscribe to Updates
Use `subscribe` to update the DOM or Canvas on every frame.
```typescript
const box = document.getElementById('box');
helios.subscribe((state) => {
if (!box) return;
const { currentFrame, fps } = state;
const time = currentFrame / fps;
// Animate based on time
const x = time * 100;
box.style.transform = `translateX(${x}px)`;
// Update text
box.textContent = `Frame: ${currentFrame}`;
});
```
### 3. Captions Example
Driven by SRT content.
```typescript
const captionBox = document.getElementById('captions');
helios.subscribe((state) => {
if (!captionBox) return;
const activeCues = state.activeCaptions;
if (activeCues.length > 0) {
captionBox.innerText = activeCues.map(c => c.text).join('\n');
captionBox.style.opacity = '1';
} else {
captionBox.innerText = '';
captionBox.style.opacity = '0';
}
});
```
## Key Concepts
- **Direct DOM Manipulation:** Use `style.transform`, `textContent`, etc., inside the `subscribe` callback.
- **`bindToDocumentTimeline`:** Crucial for allowing the `HeliosPlayer` or `Renderer` to drive the animation.
- **Performance:** Avoid expensive layout thrashing (reading offsets then writing styles) inside the loop.
## Source Files
- Example: `examples/vanilla-captions-animation/`
- Example: `examples/simple-canvas-animation/`Related Skills
example-vue
Patterns for using Helios with Vue. Use when building compositions in a Vue environment.
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.
example-gsap
Patterns for using Helios with GSAP (GreenSock). Use when integrating GSAP timelines with the Helios timeline for precise scrubbing and rendering.