# remotion-transitions

Adopt this skill: https://proskills.md/skills/other/ashad001-remotion-transitions

Page: https://proskills.md/skills/other/ashad001-remotion-transitions
This document is the public skill bundle for that page. It contains SKILL.md and every helper file the catalog carries. No login is required.

## File: SKILL.md
size: 2648
sha: 8df962de1f9d331781a3a5ae91800933c9966ab1
upstream: https://github.com/ashad001/remotion-transitions/blob/HEAD/SKILL.md

```text
---
name: remotion-transitions
description: This skill should be used when the user asks to create custom Remotion transitions, asks about "cool transitions", "cinematic transitions", "striped transitions", "glitch transitions", "custom TransitionPresentation", or wants to build scene-to-scene transitions in Remotion beyond the built-in library. Also triggers for "how to make transitions in Remotion", "custom transition", "high-energy transitions", "energy transitions", "branded transitions".
version: 1.0.0
---

# Remotion Custom Transitions

This skill teaches you how to build **production-grade, high-energy custom transitions** in Remotion using the `TransitionPresentation` API — the same pattern used in Fyltr's Instagram Reel campaign.

## Quick Reference

- [Custom Transition Pattern](./references/custom-transition-pattern.md) — The `TransitionPresentation` API, the exact component shape, and how timing works
- [Transition Catalog](./references/transition-catalog.md) — 6 battle-tested transitions with full source: Striped Slam, Zoom Punch, Diagonal Reveal, Emerald Burst, Vertical Shutter, Glitch Slam
- [Animation Math](./references/animation-math.md) — Easing functions, stagger formulas, spring configs, and the `clamp` extrapolation pattern used throughout

## Core Concept

Remotion's `@remotion/transitions` package exposes a `TransitionPresentation` type. You implement a **component** that receives:
- `presentationProgress` — `0` at transition start → `1` at transition end
- `presentationDirection` — `"exiting"` (old scene) or `"entering"` (new scene)
- `children` — the scene being wrapped

The same component wraps **both** scenes simultaneously. You animate different things depending on direction.

## Golden Rules

1. **Never use CSS transitions/animations** — all motion via `interpolate()` / `spring()` driven by `presentationProgress`
2. **Never use `useCurrentFrame()`** inside a transition component — use `presentationProgress` only
3. Always return `{ component, props: {} }` — the `props` object must exist even if empty
4. **Create instances outside components** at module level to keep them stable across re-renders
5. Pair with `linearTiming` (for dramatic frame-perfect transitions) or `springTiming` (for springy physics)

## When to Load References

- Building a new custom transition → load [custom-transition-pattern.md](./references/custom-transition-pattern.md) first
- Copying/adapting an existing effect → load [transition-catalog.md](./references/transition-catalog.md)
- Debugging timing or easing math → load [animation-math.md](./references/animation-math.md)
```

## File: README.md
size: 2543
sha: d7086b55174692b96fb5d15fb6763ef0222e9467
upstream: https://github.com/ashad001/remotion-transitions/blob/HEAD/README.md

````text
# remotion-transitions

A Claude Code skill plugin for building **custom scene transitions in Remotion** — covers the `TransitionPresentation` API from scratch, animation math, timing patterns, and a catalog of production-ready examples to learn from or drop in directly.

## Transitions

| Name | Effect | Best for |
|---|---|---|
| **Striped Slam** | Alternating brand-color bars slam in from both sides, then retract | Opening cuts, high-impact moments |
| **Zoom Punch** | Outgoing scene retreats; incoming punches in with cubic ease | Mid-sequence energy |
| **Diagonal Reveal** | Dark panel sweeps left→right with skewed edge and glowing accent line | Cinematic reveals |
| **Emerald Burst** | Sharp radial flash peaks at the cut, dissolves in 20% of duration | Emotional or product moments |
| **Vertical Shutter** | N vertical panels close over the old scene, then snap open | Graphic, stop-motion feel |
| **Glitch Slam** | Horizontal shake decay + RGB-offset strip tears on exit | Final cuts, CTAs |

## Installation

Once listed on the marketplace:
```
/plugin install remotion-transitions
```

Until then, install via skills.sh:
```bash
npx skills add ashad001/remotion-transitions
```

Or clone manually:
```bash
git clone https://github.com/ashad001/remotion-transitions
```

## Skill triggers

This skill auto-activates when you ask Claude about:
- Custom Remotion transitions or `TransitionPresentation`
- "cool transitions", "high-energy transitions", "cinematic transitions"
- "striped transitions", "glitch transitions", "zoom punch", "shutter"
- Frame budget math, stagger formulas, spring configs for video

## References

| File | Covers |
|---|---|
| [`SKILL.md`](SKILL.md) | Entry point, golden rules, quick reference |
| [`custom-transition-pattern.md`](references/custom-transition-pattern.md) | `TransitionPresentation` scaffold, `linearTiming` vs `springTiming`, stagger formula, common gotchas |
| [`transition-catalog.md`](references/transition-catalog.md) | Full TypeScript source for all transitions with customization tips |
| [`animation-math.md`](references/animation-math.md) | Easing functions, decaying oscillation, spring configs, `clamp` pattern, frame budget formula, responsive scaling |

## Requirements

- `remotion` ≥ 4.0
- `@remotion/transitions` ≥ 4.0
- React 18+
- TypeScript (recommended)

## Landing page

The landing page lives in a separate repo: [ashad001/remotion-transitions-landing](https://github.com/ashad001/remotion-transitions-landing), deployed on Vercel.

## License

MIT
````

## File: references/animation-math.md
size: 5262
sha: 6b7172b196a7ae49a75e1f812b013d24b0703fcf
upstream: https://github.com/ashad001/remotion-transitions/blob/HEAD/references/animation-math.md

````text
# Animation Math for Transitions

Reference for the easing formulas, spring configs, and interpolation patterns used throughout the transition catalog.

---

## Easing Functions (Pure JS, no imports needed)

These produce `0→1` outputs from `0→1` inputs. Apply AFTER normalizing progress.

```ts
// Cubic ease-out (most common — fast start, decelerates into target)
const easeOut3 = (p: number) => 1 - Math.pow(1 - p, 3);

// Cubic ease-in (slow start — builds momentum)
const easeIn3 = (p: number) => Math.pow(p, 3);

// Cubic ease-in-out (symmetric S-curve — feels "cinematic")
const easeInOut3 = (p: number) =>
  p < 0.5 ? 4 * p * p * p : 1 - Math.pow(-2 * p + 2, 3) / 2;

// Ease-out power (variable exponent — higher n = more snap)
const easeOutN = (p: number, n: number) => 1 - Math.pow(1 - p, n);
// n=2: gentle   n=3: standard   n=4: snappy   n=6: very snappy

// Power ease-in (fractional = fast start, n<1)
const powerIn = (p: number, n: number) => Math.pow(p, n);
// n=0.5: very fast initial drop  n=0.6: medium  n=2: slow
```

### Usage in transitions
```ts
const pe = 1 - Math.pow(1 - presentationProgress, 3); // ease-out cubic
const bx = interpolate(pe, [0, 1], [-12, 116]);        // then map to position
```

---

## Stagger Patterns

### Forward stagger (first element leads)
```ts
const STAGGER = 0.3; // 30% of total duration used as stagger window
const delay = (i / N) * STAGGER;
const p = Math.max(0, Math.min(1, (progress - delay) / (1 - delay)));
```

### Reverse stagger (last element leads)
```ts
const revDelay = ((N - 1 - i) / N) * STAGGER;
const p = Math.max(0, Math.min(1, (progress - revDelay) / (1 - revDelay)));
```

### Bidirectional stagger (center leads, edges follow)
```ts
const center = (N - 1) / 2;
const dist = Math.abs(i - center) / center; // 0 at center, 1 at edges
const delay = dist * STAGGER;
```

---

## Decaying Oscillation (Shake Effect)

Used in `glitchSlam` for the horizontal shake on the exiting scene:

```ts
// sin(progress * π * frequency) × amplitude × decay
const shake = Math.sin(presentationProgress * Math.PI * 12)  // 6 full cycles
            * 30                                               // px amplitude
            * Math.pow(1 - presentationProgress, 1.5);        // decay curve
// Result: lots of shake at start, quickly calms
```

Tuning:
- `* Math.PI * N` → N/2 full oscillation cycles (12 = 6 cycles)
- `amplitude` → max pixel displacement
- Exponent `1.5` → higher = faster decay, lower = longer tail

---

## Spring Configs

All from `{ spring } from "remotion"` or `springTiming` from `@remotion/transitions`.

```ts
// Bouncy entrance (UI elements, cards)
{ damping: 10, stiffness: 380 }  // fast initial + strong overshoot

// Snappy with subtle bounce
{ damping: 14, stiffness: 340 }  // card slam-in with slight settle

// Critically damped — no bounce (smooth arrive)
{ damping: 200 }                 // instant settle, no ring

// Medium — one bounce
{ damping: 12, stiffness: 300 }
```

### Spring as progress driver
```ts
const s = spring({ frame: frame - delay, fps, config: { damping: 10, stiffness: 380 } });
const y = interpolate(s, [0, 1], [startY, 0]); // map spring to position
const opacity = s; // spring output already 0→1
```

---

## Clamp Pattern

Always use this to prevent `interpolate` from extrapolating beyond keyframes:

```ts
const clamp = {
  extrapolateLeft:  "clamp" as const,
  extrapolateRight: "clamp" as const,
};

// Usage
const x = interpolate(frame, [0, 30], [100, 0], clamp);
// At frame -5: returns 100 (not 116)
// At frame 60: returns 0 (not -100)
```

---

## `mixBlendMode` for Overlay Strips

Used in glitch strips to let underlying scene show through:

```ts
style={{ mixBlendMode: "screen" }}
// "screen": light blending — darker pixels become transparent
// Good for glowing color overlays on dark backgrounds

style={{ mixBlendMode: "multiply" }}
// "multiply": darkens — good for ink/shadow effects on light backgrounds

style={{ mixBlendMode: "overlay" }}
// "overlay": contrast boost — preserves highlights and shadows
```

---

## Frame Budget Formula

```
Total output frames = Σ(all scene durationInFrames) - Σ(all transition durationInFrames)

Example (7 scenes, 6 transitions):
  Scenes:      135 + 120 + 150 + 180 + 120 + 150 + 150 = 1005f
  Transitions: 50 + 35 + 40 + 40 + 35 + 30             =  230f
  Output:      1005 - 230                               =  775f = 25.8s @ 30fps
```

### Breathing room rule
Give each scene at least `transition_duration + 30` frames of unique content so
the overlap (where both scenes are visible) doesn't cut important moments.

---

## Responsive Scaling

For 9:16 Instagram Reels (1080×1920 base):

```ts
const { width, height } = useVideoConfig();
const s  = height / 1920;              // vertical scale
const sw = width  / 1080;              // horizontal scale
const sf = Math.sqrt(s * sw);          // geometric mean for font/icon sizes
const r  = (v: number) => Math.round(v * s);   // vertical dimensions
const rs = (v: number) => Math.round(v * sf);  // font sizes and icons
```

Safe zones (avoid notch / caption overlap):
```ts
const SAFE_TOP    = r(288);  // 15% of 1920 = 288px
const SAFE_BOTTOM = r(384);  // 20% of 1920 = 384px
```
````

## File: references/custom-transition-pattern.md
size: 4385
sha: 3b8c61e4432ddc5fac76e9deb65108aa26083084
upstream: https://github.com/ashad001/remotion-transitions/blob/HEAD/references/custom-transition-pattern.md

````text
# Custom Transition Pattern

## The `TransitionPresentation` API

```ts
import type { TransitionPresentation } from "@remotion/transitions";
import { TransitionSeries, linearTiming, springTiming } from "@remotion/transitions";
```

### Component Shape

Every transition is a factory function that returns `{ component, props }`:

```tsx
function myTransition(): TransitionPresentation<Record<string, never>> {
  const component = ({
    presentationProgress,   // 0 → 1 over the transition duration
    presentationDirection,  // "exiting" | "entering"
    children,               // the scene being wrapped (React.ReactNode)
    passedProps,            // typed to your generic — pass {} if none
  }: {
    presentationProgress: number;
    presentationDirection: "entering" | "exiting";
    children: React.ReactNode;
    passedProps: Record<string, never>;
  }) => {
    const entering = presentationDirection === "entering";
    // ... animate based on presentationProgress + direction
    return <AbsoluteFill>{children}</AbsoluteFill>;
  };

  return { component, props: {} };
}
```

### Instantiate at Module Level (Critical)

```ts
// ✅ Outside any component — stable reference, avoids re-mount
const MY_TRANSITION = myTransition();

// ❌ Inside a component — remounts on every render
function MyComp() {
  const t = myTransition(); // BAD
}
```

### Using in TransitionSeries

```tsx
export function MyComposition() {
  return (
    <TransitionSeries>
      <TransitionSeries.Sequence durationInFrames={120}>
        <SceneA />
      </TransitionSeries.Sequence>

      <TransitionSeries.Transition
        presentation={MY_TRANSITION}
        timing={linearTiming({ durationInFrames: 40 })}
      />

      <TransitionSeries.Sequence durationInFrames={120}>
        <SceneB />
      </TransitionSeries.Transition>
    </TransitionSeries>
  );
}
```

## Frame Budget Math

Total frames = Σ(scene durations) − Σ(transition durations)

```
// Example:
// 3 scenes × 120f = 360f
// 2 transitions × 30f = 60f removed
// Total rendered = 300f = 10s @ 30fps
```

## Timing Types

### `linearTiming` — Frame-perfect, dramatic transitions
```ts
linearTiming({ durationInFrames: 50 })
// Use for: striped slams, bursts, glitch effects — where frame-perfect control matters
```

### `springTiming` — Physics-based transitions
```ts
springTiming({ config: { damping: 200 }, durationInFrames: 35 })
// Use for: punchy zoom transitions, smooth reveals
// High damping (200) = no bounce, fast settle
// Low damping (10-14) = springy overshoot
```

## Interpolation Helpers

Always define this once at module level:

```ts
const clamp = {
  extrapolateLeft:  "clamp" as const,
  extrapolateRight: "clamp" as const,
};
```

Then use it everywhere:
```ts
const opacity = interpolate(presentationProgress, [0, 1], [0, 1], clamp);
const x = interpolate(presentationProgress, [0, 0.5, 1], [100, 10, 0], clamp);
```

## Stagger Formula

For N elements with individual stagger offsets:

```ts
const STAGGER = 0.3; // max 30% of total duration used for stagger delay

for (let i = 0; i < N; i++) {
  const delay = (i / N) * STAGGER;
  // Normalize progress for this element: starts later, reaches 1 at p=1
  const p = Math.max(0, Math.min(1, (presentationProgress - delay) / (1 - delay)));
  const eased = 1 - Math.pow(1 - p, 3); // cubic ease-out
  // Use `eased` for this element's position
}

// For reverse stagger (last element first):
const revDelay = ((N - 1 - i) / N) * STAGGER;
```

## Overlay Pattern

Most transitions render **on top of the children** using `pointerEvents: "none"`:

```tsx
return (
  <AbsoluteFill>
    {children}         {/* scene underneath */}
    <div style={{
      position: "absolute",
      inset: 0,
      background: "...",
      pointerEvents: "none",  // never block interaction
    }} />
  </AbsoluteFill>
);
```

## Common Gotchas

### `clockWipe` requires explicit dimensions
```ts
// ❌ Fails — computes SVG clip path without knowing canvas size
clockWipe()

// ✅ Pass width/height explicitly
clockWipe({ width: 1080, height: 1920 })
```

### Negative-width div trick (avoid it)
```ts
// ❌ At progress=0, right: 108% collapses the div (invisible)
<div style={{ inset: 0, right: `${100 - x}%` }} />

// ✅ Use left + right: 0 so the div can never collapse
<div style={{ top: 0, bottom: 0, left: `${x}%`, right: 0 }} />
```
````

## File: references/transition-catalog.md
size: 14358
sha: fcfae5d566ed04afee38ec17a300dd4a02d6ed72
upstream: https://github.com/ashad001/remotion-transitions/blob/HEAD/references/transition-catalog.md

````text
# Transition Catalog

Six production-tested transitions from Fyltr's Instagram Reel campaign. All use the `TransitionPresentation` API — see `custom-transition-pattern.md` for the scaffold.

Design tokens used: `DARK_BG = "#0a0a0a"`, `EMERALD = "#10b981"`. Replace with your own brand colors.

---

## 1. Striped Slam

**Effect:** N horizontal bars (alternating brand colors) slam in from left and right simultaneously, cover the old scene, then retract to reveal the new scene.
**Energy:** Maximum. Best for opening transitions.
**Timing:** `linearTiming({ durationInFrames: 50 })` — needs time for the slam + retract

```tsx
function stripedSlam(stripes = 8): TransitionPresentation<Record<string, never>> {
  const STRIPE_COLORS = [DARK_BG, EMERALD]; // alternate brand colors
  const component = ({
    presentationProgress,
    presentationDirection,
    children,
  }: {
    presentationProgress: number;
    presentationDirection: "entering" | "exiting";
    children: React.ReactNode;
    passedProps: Record<string, never>;
  }) => {
    const bars = Array.from({ length: stripes }, (_, i) => {
      const h = 100 / stripes;
      const color = STRIPE_COLORS[i % STRIPE_COLORS.length];
      const fromLeft = i % 2 === 0; // alternate directions
      const stagger = (i / stripes) * 0.3;
      const p = Math.max(0, Math.min(1, (presentationProgress - stagger) / (1 - stagger)));
      const pe = 1 - Math.pow(1 - p, 3); // cubic ease-out

      let x: number;
      if (presentationDirection === "exiting") {
        // Slam IN: bars come from outside → park at 0
        x = fromLeft
          ? interpolate(pe, [0, 1], [-112, 0])
          : interpolate(pe, [0, 1], [112, 0]);
      } else {
        // Retract: reverse stagger, go back where they came from
        const revStagger = ((stripes - 1 - i) / stripes) * 0.3;
        const rp = Math.max(0, Math.min(1, (presentationProgress - revStagger) / (1 - revStagger)));
        const rpe = 1 - Math.pow(1 - rp, 3);
        x = fromLeft
          ? interpolate(rpe, [0, 1], [0, -112])
          : interpolate(rpe, [0, 1], [0, 112]);
      }

      return (
        <div key={i} style={{
          position: "absolute",
          top: `${i * h}%`,
          left: 0,
          width: "112%",
          height: `${h + 0.4}%`, // +0.4% overlap prevents hairline gaps
          background: color,
          transform: `translateX(${x}%)`,
          pointerEvents: "none",
        }} />
      );
    });

    return <AbsoluteFill>{children}{bars}</AbsoluteFill>;
  };
  return { component, props: {} };
}

// Usage
const STRIPED_SLAM = stripedSlam(8);
// <TransitionSeries.Transition presentation={STRIPED_SLAM} timing={linearTiming({ durationInFrames: 50 })} />
```

**Customization tips:**
- More stripes (12-16) → tighter, more intense
- Larger stagger (0.4) → more cascade feel
- Use 3+ colors in `STRIPE_COLORS` for rainbow effect

---

## 2. Zoom Punch

**Effect:** Old scene zooms out and fades. New scene punches in from a slightly smaller scale with cubic ease-in-out.
**Energy:** Medium-high. Feels like a camera cut with intent.
**Timing:** `springTiming({ config: { damping: 200 }, durationInFrames: 35 })`

```tsx
function zoomPunch(): TransitionPresentation<Record<string, never>> {
  const component = ({
    presentationProgress,
    presentationDirection,
    children,
  }: {
    presentationProgress: number;
    presentationDirection: "entering" | "exiting";
    children: React.ReactNode;
    passedProps: Record<string, never>;
  }) => {
    const entering = presentationDirection === "entering";

    if (entering) {
      const p = presentationProgress;
      // Cubic ease-in-out for smooth punch
      const pe = p < 0.5 ? 4 * p * p * p : 1 - Math.pow(-2 * p + 2, 3) / 2;
      const scale = interpolate(pe, [0, 1], [0.86, 1]);
      return (
        <AbsoluteFill style={{ opacity: presentationProgress, transform: `scale(${scale})` }}>
          {children}
        </AbsoluteFill>
      );
    }

    // Exiting: zoom out slightly (zoom-out = scene "retreats")
    const scale = interpolate(presentationProgress, [0, 1], [1, 1.08]);
    return (
      <AbsoluteFill style={{ opacity: 1 - presentationProgress, transform: `scale(${scale})` }}>
        {children}
      </AbsoluteFill>
    );
  };
  return { component, props: {} };
}
```

**Customization tips:**
- Entering scale `[0.76, 1]` → more dramatic "smash" feel
- Exiting scale `[1, 1.15]` → more aggressive retreat
- Add `filter: blur(...)` on exiting for depth-of-field effect

---

## 3. Diagonal Reveal

**Effect:** A dark panel with a skewed right edge sweeps left→right across the screen, dragging an emerald accent line at the leading edge. Old scene fades beneath; new scene is revealed from the left.
**Energy:** Cinematic. Great mid-sequence for "reveal" moments.
**Timing:** `linearTiming({ durationInFrames: 40 })`

```tsx
function diagonalReveal(): TransitionPresentation<Record<string, never>> {
  const component = ({
    presentationProgress,
    presentationDirection,
    children,
  }: {
    presentationProgress: number;
    presentationDirection: "entering" | "exiting";
    children: React.ReactNode;
    passedProps: Record<string, never>;
  }) => {
    if (presentationDirection === "exiting") {
      return (
        <AbsoluteFill style={{ opacity: 1 - Math.pow(presentationProgress, 0.6) }}>
          {children}
        </AbsoluteFill>
      );
    }

    // Sweep boundary: starts off left (-12%) → sweeps past right edge (116%)
    const pe = 1 - Math.pow(1 - presentationProgress, 2.5); // ease-out power
    const bx = interpolate(pe, [0, 1], [-12, 116]);

    return (
      <AbsoluteFill>
        {children}

        {/* Dark cover: at bx=-12, left=-12% covers everything; at bx=116, collapses */}
        {/* CRITICAL: use left+right:0 NOT inset+right — negative width makes div invisible */}
        <div style={{
          position: "absolute",
          top: 0, bottom: 0,
          left: `${bx}%`,
          right: 0,
          background: DARK_BG,
          pointerEvents: "none",
        }} />

        {/* Skewed leading-edge softener */}
        <div style={{
          position: "absolute",
          top: "-10%", bottom: "-10%",
          left: `${bx - 7}%`,
          width: "10%",
          background: DARK_BG,
          transform: "skewX(-9deg)",
          transformOrigin: "top left",
          pointerEvents: "none",
        }} />

        {/* Accent line at the blade edge */}
        <div style={{
          position: "absolute",
          top: 0, bottom: 0,
          left: `${bx - 0.5}%`,
          width: 3,
          background: EMERALD,
          transform: "skewX(-9deg)",
          boxShadow: `0 0 14px ${EMERALD}, 0 0 32px rgba(16,185,129,0.45)`,
          pointerEvents: "none",
        }} />
      </AbsoluteFill>
    );
  };
  return { component, props: {} };
}
```

**Customization tips:**
- Change sweep direction: start `bx` at `[112, -16]` to sweep right→left
- Change `skewX` angle for sharper/softer blade edge
- Use white panel for "light burst" variant

---

## 4. Emerald Burst

**Effect:** Sharp radial flash erupts from screen center on the cut. Peaks instantly at `presentationProgress = 0`, clears by 20%. Entering scene fades in as the burst dissolves.
**Energy:** High impact. Best for emotional or reveal moments.
**Timing:** `linearTiming({ durationInFrames: 40 })`

```tsx
function emeraldBurst(): TransitionPresentation<Record<string, never>> {
  const component = ({
    presentationProgress,
    presentationDirection,
    children,
  }: {
    presentationProgress: number;
    presentationDirection: "entering" | "exiting";
    children: React.ReactNode;
    passedProps: Record<string, never>;
  }) => {
    const entering = presentationDirection === "entering";

    // Flash: enters at full opacity, clears fast; exits builds late
    const burstOpacity = entering
      ? interpolate(presentationProgress, [0, 0.2, 1], [1, 0, 0], clamp)
      : interpolate(presentationProgress, [0, 0.8, 1], [0, 0, 1], clamp);

    const sceneStyle = entering
      ? { opacity: interpolate(presentationProgress, [0, 0.25, 1], [0, 1, 1], clamp) }
      : { opacity: 1 - Math.pow(presentationProgress, 2) };

    return (
      <AbsoluteFill>
        <AbsoluteFill style={sceneStyle}>{children}</AbsoluteFill>
        <AbsoluteFill style={{
          background: `radial-gradient(circle at 50% 50%, #ffffff 0%, ${EMERALD} 18%, rgba(16,185,129,0.55) 40%, transparent 62%)`,
          opacity: burstOpacity,
          pointerEvents: "none",
        }} />
      </AbsoluteFill>
    );
  };
  return { component, props: {} };
}
```

**Customization tips:**
- White core + brand color → creates a camera flash effect
- Move gradient center: `circle at 50% 30%` for top-origin burst
- Adjust `[0, 0.2, 1]` → `[0, 0.1, 1]` for even sharper flash

---

## 5. Vertical Shutter

**Effect:** N vertical panels (venetian blind style) snap shut over the old scene, then snap open to reveal the new scene. Alternating brand colors per panel.
**Energy:** High. Very graphic, stop-motion feel.
**Timing:** `linearTiming({ durationInFrames: 35 })`

```tsx
function verticalShutter(panels = 7): TransitionPresentation<Record<string, never>> {
  const component = ({
    presentationProgress,
    presentationDirection,
    children,
  }: {
    presentationProgress: number;
    presentationDirection: "entering" | "exiting";
    children: React.ReactNode;
    passedProps: Record<string, never>;
  }) => {
    const w = 100 / panels;
    const shutters = Array.from({ length: panels }, (_, i) => {
      const stagger = (i / panels) * 0.25;
      const p = Math.max(0, Math.min(1, (presentationProgress - stagger) / (1 - stagger)));
      const pe = 1 - Math.pow(1 - p, 3);

      // Exiting: panels CLOSE (scaleX 0→1 from left origin)
      // Entering: panels OPEN (scaleX 1→0)
      const scaleX = presentationDirection === "exiting"
        ? interpolate(pe, [0, 1], [0, 1])
        : interpolate(pe, [0, 1], [1, 0]);

      const color = i % 2 === 0 ? DARK_BG : EMERALD;

      return (
        <div key={i} style={{
          position: "absolute",
          top: 0, bottom: 0,
          left: `${i * w}%`,
          width: `${w + 0.3}%`, // +0.3% overlap prevents gaps
          background: color,
          transform: `scaleX(${scaleX})`,
          transformOrigin: "left center",
          pointerEvents: "none",
        }} />
      );
    });

    return <AbsoluteFill>{children}{shutters}</AbsoluteFill>;
  };
  return { component, props: {} };
}
```

**Customization tips:**
- Horizontal shutter: use `top`/`height` instead of `left`/`width`, `scaleY` instead of `scaleX`, `transformOrigin: "top center"`
- More panels (12-16) → tighter, more frantic look
- `transformOrigin: "center center"` → panels collapse to middle instead of side

---

## 6. Glitch Slam

**Effect:** Old scene shakes horizontally with decaying amplitude while 4 colored RGB-offset horizontal strips tear across. New scene hard-pops in at 12% progress with a brief scale punch.
**Energy:** Maximum chaos. Best as final transition before CTA.
**Timing:** `linearTiming({ durationInFrames: 30 })`

```tsx
function glitchSlam(): TransitionPresentation<Record<string, never>> {
  const component = ({
    presentationProgress,
    presentationDirection,
    children,
  }: {
    presentationProgress: number;
    presentationDirection: "entering" | "exiting";
    children: React.ReactNode;
    passedProps: Record<string, never>;
  }) => {
    const entering = presentationDirection === "entering";

    if (entering) {
      // Hard pop-in at 12%, small scale punch
      const opacity = interpolate(presentationProgress, [0, 0.12, 1], [0, 1, 1], clamp);
      const scale = interpolate(presentationProgress, [0, 0.25, 1], [1.05, 1.01, 1], clamp);
      return (
        <AbsoluteFill style={{ opacity, transform: `scale(${scale})` }}>
          {children}
        </AbsoluteFill>
      );
    }

    // Exiting: shake + RGB strips
    // sin wave decays as (1 - progress)^1.5 → lots of shake early, calms fast
    const shake = Math.sin(presentationProgress * Math.PI * 12) * 30 * Math.pow(1 - presentationProgress, 1.5);
    const opacity = 1 - Math.pow(presentationProgress, 0.5);

    const STRIPS = [
      { top: "18%", h: "4%", dx: 28,  color: "rgba(239,68,68,0.55)"   }, // red
      { top: "37%", h: "2%", dx: -22, color: "rgba(16,185,129,0.55)"  }, // emerald
      { top: "58%", h: "5%", dx: 36,  color: "rgba(59,130,246,0.5)"   }, // blue
      { top: "76%", h: "2%", dx: -18, color: "rgba(255,255,255,0.35)" }, // white
    ];
    const stripOpacity = interpolate(presentationProgress, [0, 0.3, 0.8, 1], [0, 1, 0.6, 0], clamp);

    const strips = STRIPS.map((s, i) => (
      <div key={i} style={{
        position: "absolute",
        top: s.top, left: 0, right: 0,
        height: s.h,
        background: s.color,
        transform: `translateX(${s.dx * presentationProgress * 2}px)`,
        opacity: stripOpacity,
        pointerEvents: "none",
        mixBlendMode: "screen",
      }} />
    ));

    return (
      <AbsoluteFill style={{ opacity, transform: `translateX(${shake}px)` }}>
        {children}
        {strips}
      </AbsoluteFill>
    );
  };
  return { component, props: {} };
}
```

**Customization tips:**
- More `Math.PI * N` → faster shake frequency (more glitchy)
- Adjust `dx` values and add more strips for more visual chaos
- Add `filter: hue-rotate(...)` on the exiting scene for color corruption

---

## Full Scene Sequence (Reel Pattern)

```tsx
// Instantiate all at module level
const STRIPED_SLAM     = stripedSlam(8);
const ZOOM_PUNCH       = zoomPunch();
const DIAGONAL_REVEAL  = diagonalReveal();
const EMERALD_BURST    = emeraldBurst();
const VERTICAL_SHUTTER = verticalShutter(7);
const GLITCH_SLAM      = glitchSlam();

// Timings
const T_SLAM    = linearTiming({ durationInFrames: 50 });
const T_ZOOM    = springTiming({ config: { damping: 200 }, durationInFrames: 35 });
const T_DIAG    = linearTiming({ durationInFrames: 40 });
const T_BURST   = linearTiming({ durationInFrames: 40 });
const T_SHUTTER = linearTiming({ durationInFrames: 35 });
const T_GLITCH  = linearTiming({ durationInFrames: 30 });

// Total transition overhead: 50+35+40+40+35+30 = 230 frames removed
```
````

## File: .claude-plugin/plugin.json
size: 726
sha: 0e57849e833bb5313bbd6fe856750e46dd61a9bd
upstream: https://github.com/ashad001/remotion-transitions/blob/HEAD/.claude-plugin/plugin.json

```text
{
  "name": "remotion-transitions",
  "description": "Build custom Remotion scene transitions using the TransitionPresentation API — animation math, stagger formulas, spring configs, frame budget guidance, and a catalog of production-ready patterns for short-form video.",
  "version": "1.0.0",
  "author": {
    "name": "Ashad",
    "url": "https://github.com/ashad001"
  },
  "repository": "https://github.com/ashad001/remotion-transitions",
  "homepage": "https://github.com/ashad001/remotion-transitions#readme",
  "license": "MIT",
  "keywords": ["remotion", "transitions", "video", "react", "animation", "claude-code", "claude-plugin", "short-form-video", "instagram-reels", "motion-design", "typescript", "tiktok"]
}
```

## File: CHANGELOG.md
size: 676
sha: 66c3a08a2bc372323144362e4831d76ad9341bc2
upstream: https://github.com/ashad001/remotion-transitions/blob/HEAD/CHANGELOG.md

```text
# Changelog

## 1.0.0 — 2026-03-12

Initial release.

### Transitions
- Striped Slam — N-bar alternating panel slam from both sides
- Zoom Punch — retreat + cubic ease-in-out punch
- Diagonal Reveal — skewed dark panel sweep with accent line
- Emerald Burst — sharp radial flash with fast dissolve
- Vertical Shutter — venetian blind close/open across N panels
- Glitch Slam — decaying shake + RGB horizontal strip tears

### References
- `custom-transition-pattern.md` — full `TransitionPresentation` API scaffold
- `transition-catalog.md` — complete source for all 6 transitions
- `animation-math.md` — easing, stagger, spring configs, frame budget math
```

## File: LICENSE
size: 1062
sha: 8c365b2b17b065d2935257dc523143da76622a78
upstream: https://github.com/ashad001/remotion-transitions/blob/HEAD/LICENSE

```text
MIT License

Copyright (c) 2026 Ashad

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
```

## File: skills-lock.json
size: 242
sha: 53865f0f3600e31bf70bb642e5535d74b0a04f77
upstream: https://github.com/ashad001/remotion-transitions/blob/HEAD/skills-lock.json

```text
{
  "version": 1,
  "skills": {
    "remotion-transitions": {
      "source": "Ashad001/remotion-transitions",
      "sourceType": "github",
      "computedHash": "bcddf1de7d483bf8620e7747c57a1eed82795954eaf2f604dfab3a6c1264a313"
    }
  }
}
```
