⏳ This skill is pending AI review.
Scores will appear once the review pipeline completes.
remotion-transitions
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".
Choose how to use this skill
You do not need every option. Choose the path your AI client supports. The stable page stays the same; versioned files are immutable.
1. Native installer
This listing has no registered native installer command. Use the complete package or source fallback below, depending on what your client supports.
Do not guess an installer command or replace an existing version without reviewing the diff.
2. Complete package recommended
Download the ZIP when available. It includes SKILL.md plus the references, security notes and version metadata.
No complete ProSkills package is published for this listing yet.3. Prompt-only
Copy the prompt above when the agent can read the stable page or when you want to adopt the workflow without installing a skill.
Need only the instruction file?
Download SKILL.md only if your client requires a single file. The complete ZIP is safer for a full installation because it preserves the references and release context.
No path installs or executes anything by itself. Your agent still needs access to the project files. Before updating, compare the installed version and review the diff.
// RATINGS
// README
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:
npx skills add ashad001/remotion-transitions
Or clone manually:
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 | Entry point, golden rules, quick reference |
custom-transition-pattern.md | TransitionPresentation scaffold, linearTiming vs springTiming, stagger formula, common gotchas |
transition-catalog.md | Full TypeScript source for all transitions with customization tips |
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, deployed on Vercel.
License
MIT
// HOW IT'S BUILT
// FILES
9 files shipped with this skill. Inline text is the catalog copy. The upstream link is the source repository.
SKILL.md2.6 KB8df962de1f9dupstream ↗
--- 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)README.md2.5 KBd7086b551746upstream ↗
# 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 MITreferences/animation-math.md5.1 KB6b7172b196a7upstream ↗
# 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 ```references/custom-transition-pattern.md4.3 KB3b8c61e4432dupstream ↗
# 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 }} /> ```references/transition-catalog.md14 KBfcfae5d566edupstream ↗
# 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 ```.claude-plugin/plugin.json726 B0e57849e833bupstream ↗
{ "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"] }CHANGELOG.md676 B66c3a08a2bc3upstream ↗
# 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 mathLICENSE1.0 KB8c365b2b17b0upstream ↗
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.skills-lock.json242 B53865f0f3600upstream ↗
{ "version": 1, "skills": { "remotion-transitions": { "source": "Ashad001/remotion-transitions", "sourceType": "github", "computedHash": "bcddf1de7d483bf8620e7747c57a1eed82795954eaf2f604dfab3a6c1264a313" } } }
Plain-text copy, no login: /skill-bundles/ashad001-remotion-transitions.md