⏳ This skill is pending AI review.

Scores will appear once the review pipeline completes.

version unknown

remotion-motion-graphics

boriwatopal@boriwatopal⭐ 20 stars· last commit 2mo ago· 0 open issues

Build kinetic-typography / logo / brand promo motion graphics as code with Remotion (React) and ship an MP4. Covers analysing a reference clip and the brand SVG logo, build a scene-per-beat project with reusable animation helpers, verify by contact sheet, output 9:16 and 16:9, tweak in Remotion Studio. Use this whenever the user wants a "motion", "motion graphics", "animated logo", "logo reveal", "kinetic text", "promo clip", "intro/outro", "Reels/TikTok/YouTube video" made from a brand, a websi

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.

—/10

// RATINGS

⭐GitHub Stars
⭐⭐ 20 on GitHubGitHub ↗

Growing

🟢ProSkills Score
—
📍

Not yet listed on ClawHub or SkillsMP

// README

Remotion Motion Graphics - Agent Skill

A Claude skill for building kinetic-typography / logo / brand promo motion graphics as code with Remotion (React) and shipping an MP4. It covers the whole path: reading a reference clip and a brand's SVG logo, a scene-per-beat project with reusable animation helpers, a verify-by-contact-sheet loop, both 9:16 and 16:9 outputs from one codebase, and Remotion Studio for tweaks.

Built while cloning the motion of a reference promo for hundredable.com — the workflow is general, the video is not included.

Install

Claude Code (CLI / desktop app) — clone the skill into your skills folder:

git clone https://github.com/Boriwatopal/agent-skill-remotion-motion-graphics.git /tmp/rmg && \
cp -R /tmp/rmg/skills/remotion-motion-graphics ~/.claude/skills/ && rm -rf /tmp/rmg

Or for one project only: copy skills/remotion-motion-graphics into <project>/.claude/skills/.

claude.ai / Cowork — download dist/remotion-motion-graphics.skill (or grab it from the latest release) and upload it in Settings → Capabilities → Skills.

Then just ask for a motion piece: the skill triggers on requests like "make an animated logo from this SVG", "make a promo clip like this video", "ทำโมชั่นโลโก้", or any Remotion code work.

Folder Structure

skills/remotion-motion-graphics/
  SKILL.md                              # The workflow: read material → scaffold → scenes → verify → deliver
  assets/                               # Starter code to copy into src/
    theme.template.ts                   #   brand colours, PORTRAIT/LANDSCAPE presets, named scene durations
    layout.ts                           #   useLayout() — every position derives from the frame size
    anim.ts                             #   easing curves, prog(), springAt(), riseStyle(), typed()
    fonts.ts, Main.template.tsx, Root.template.tsx
    components/
      Backgrounds.tsx                   #   LightBg / DarkBg with brand glow
      Cursors.tsx                       #   arrow + dot cursors that spring between targets
      Words.tsx                         #   word-by-word reveal with optional exit
      SvgArt.tsx                        #   animate SVG artwork per path (letter pop, character bounce)
  scripts/
    analyze_reference.sh                # contact sheets from a reference video → beat map
    svg_to_paths.mjs                    # SVG → TypeScript path data + bounding-box report
    check_render.sh                     # low-res render + contact sheets for a composition
    still_frame.sh                      # one frame from an MP4 at a timestamp
  references/
    scene-patterns.md                   # 16 motion patterns with the timings that worked
    verification-and-gotchas.md         # the check loop and the traps met in practice
    remotion-rules/                     # 13 official Remotion rule files (see Credits)
dist/remotion-motion-graphics.skill     # packaged skill for claude.ai upload

What the workflow does

  1. Read the material first. Contact sheets from the reference clip become a beat map; the brand site or the logo's SVG fills give colours, font and real copy; the logo's paths are mapped so letters and character can animate separately.
  2. One skeleton for every ratio. Named scene durations in one theme file, a layout hook so positions derive from useVideoConfig(), one file per scene. A second <Composition> gives 16:9 without a second codebase.
  3. Patterns, not improvisation. Phrase swap, pill → button → click, flying collage, circle wipe, ticker + panel wipe, shape hand-off between scenes, route drawing, UI toggle moment, gradient statement, character + letter pop, bubble rows, chart card, spotlight, burst → lockup, fade out.
  4. Verify like an editor. tsc → 0.3-scale render → look at every contact sheet → still-render suspicious frames → fix → final render → pull a frame from the final file as proof.
  5. Deliver. MP4 next to the source files, Remotion Studio for scrubbing, an honest summary of what was invented and what was left out.

Requirements

  • Node.js 18+ (Remotion 4), ffmpeg / ffprobe on PATH (for the analysis and check scripts)
  • Chrome is downloaded by Remotion on first render

Gotchas captured in the skill

  1. CSS applies filter before clip-path — blur the parent, clip the child, or a soft spotlight gets razor edges.
  2. A "cleanup" full-frame overlay drawn after the content hides the text; the wipe shape already covers the frame.
  3. Artwork cropped at the SVG canvas edge shows a hard cut on dark backgrounds — mask with a gradient that is fully transparent for the first ~4%.
  4. url(#gradient) fills render black without their <defs>; the SVG script swaps them for the first stop colour.
  5. Per-path transforms in inline SVG need transformBox: "fill-box", or scale/rotate pivots on the canvas origin.

Credits

  • references/remotion-rules/ are copied unchanged from remotion-dev/skills (the remotion-best-practices skill, also installable with npx skills add remotion-dev/skills). They remain the work of the Remotion team; see that repository for their terms.
  • Everything else in this repo is released under the MIT License (see LICENSE).

// HOW IT'S BUILT

// FILES

31 files shipped with this skill. Inline text is the catalog copy. The upstream link is the source repository.

  • skills/remotion-motion-graphics/SKILL.md9.0 KB18db2c6b3feeupstream ↗
    ---
    name: remotion-motion-graphics
    description: Build kinetic-typography / logo / brand promo motion graphics as code with Remotion (React) and ship an MP4. Covers analysing a reference clip and the brand SVG logo, build a scene-per-beat project with reusable animation helpers, verify by contact sheet, output 9:16 and 16:9, tweak in Remotion Studio. Use this whenever the user wants a "motion", "motion graphics", "animated logo", "logo reveal", "kinetic text", "promo clip", "intro/outro", "Reels/TikTok/YouTube video" made from a brand, a website, an SVG, or "like this video" — including Thai asks such as "ทำ motion", "ทำโมชั่นโลโก้", "ทำคลิปโปรโมท", "อนิเมทโลโก้", "ทำวิดีโอแบบนี้" — and whenever Remotion code needs writing or fixing. Trigger even if they never say Remotion; if they hand over an .svg logo and a sample .mp4 and say "make one like this", this is the skill. (For a 6-scene product-demo built from a website's screenshots, product-demo-video is the narrower fit; for captioning talking-head clips use hyperframes-captioned-video.)
    ---
    
    # Motion graphics with Remotion
    
    Code-driven video: every frame is a React render of `useCurrentFrame()`, so
    timing is exact, edits are cheap, and the same scenes can output any aspect
    ratio. The craft is in three places: **reading the source material well**,
    **a project skeleton that keeps timing and layout in one place**, and **a
    verification loop that looks at real frames**. This file is the workflow;
    the details live in `references/` and reusable code in `assets/` and
    `scripts/`.
    
    ## 0. Ground rules from Remotion (read before writing scenes)
    `references/remotion-rules/` holds the official rule files (animations,
    timing, text-animations, sequencing, transitions, compositions, fonts,
    images, charts, audio, sfx, videos, light-leaks). Load `animations.md`,
    `timing.md` and `sequencing.md` every time; the rest when the piece needs
    them. The non-negotiables they encode:
    - All motion derives from `useCurrentFrame()`; write times in seconds × fps.
      CSS transitions/animations and Tailwind animation classes do not render.
    - Entrances: `interpolate` + `Easing.bezier(0.16, 1, 0.3, 1)` (or `spring`
      with damping 10-15 when you want a visible bounce). Exits accelerate
      (`Easing.in`). Clamp everything.
    - Typewriter = string slicing, never per-character opacity.
    - `<Sequence premountFor>` / `<Series.Sequence premountFor>` so fonts and
      images are ready; `<Img>` (never `<img>`); `random("seed")` (never
      `Math.random`).
    - The `remotion-best-practices` skill from `remotion-dev/skills` is the full
      source; install it with `npx skills add remotion-dev/skills` for topics
      not bundled here (captions, maps, 3D, Lottie, transparency).
    
    ## 1. Read the brief and the material (before any code)
    1. **Reference clip** (if given): run `scripts/analyze_reference.sh <video> <dir>`
       and view every sheet. Write a beat map: for each 0.5-2 s beat note
       background (light/dark), what enters, how (rise, spring, wipe, type),
       what leaves, and the transition. This map becomes `SCENES` in theme.ts
       with one scene component per beat. Match its rhythm; you are cloning
       motion, not content.
    2. **Brand**: fetch the site (`curl -sL -A "Mozilla/5.0" <url>`) for the
       tagline, product names, real numbers, and font (`grep -oi "inter\|prompt\|kanit"`),
       and the site CSS for colour tokens. If the site is neutral, take colours
       from the logo SVG fills (`grep -o 'fill="[^"]*"' logo.svg | sort | uniq -c`).
       Real copy beats invented copy; when you must invent lines, say so at
       the end.
    3. **Artwork**: `node scripts/svg_to_paths.mjs --report logo.svg` prints
       every path's index, fill, position and size. Decide which indices are
       the wordmark letters, the character, the eyes, etc. (letters are usually
       same-fill, mid-sized, arranged along an arc or line; the big outline path
       is the body). Then `node scripts/svg_to_paths.mjs --out src/logo/paths.ts name=logo.svg`.
       Sort letter indices in reading order (along an arc: by angle around a
       point below the arc). Don't trust rsvg/quicklook previews on macOS;
       verify splits with a Remotion still.
    4. Decide orientation(s) and length. Default 1080x1920 @ 30 fps for social;
       also produce 1920x1080 when asked for "horizontal" — the layout hook
       makes that a second `<Composition>`, not a second codebase.
    5. Don't download assets from third-party hosts without asking; styled
       React cards with the real course/product names look on-brand and need
       no permission.
    
    ## 2. Scaffold and skeleton
    ```bash
    npx create-video@latest --yes --blank --no-tailwind <name>
    cd <name> && npm install && npx remotion add @remotion/google-fonts
    ```
    Copy from `assets/` into `src/`:
    - `theme.template.ts` → `theme.ts`: colours (`C`), `PORTRAIT`/`LANDSCAPE`,
      `SCENES` (named durations in frames, playback order), `TOTAL`.
    - `layout.ts`: `useLayout()` → `{W,H,cx,cy,wide,diag,scale}` derived from
      `useVideoConfig()`. Every position in every scene comes from here
      (`cx - 218`, `H * 0.615`, `wide ? ... : ...`), never from literal 1080/1920.
      The wide version is designed at 1600x900 and scaled 1.2x in `Main`.
    - `anim.ts`: `EASE_OUT/IN/INOUT/POP`, `prog(frame,start,dur,easing)`,
      `springAt(frame,fps,start,{damping,stiffness})`, `riseStyle`, `typed`.
    - `fonts.ts`, `Main.template.tsx` → `Main.tsx` (Series + design-scale
      wrapper), `Root.template.tsx` → `Root.tsx` (two compositions).
    - `components/Backgrounds.tsx` (LightBg with brand glow, DarkBg with glow),
      `components/Cursors.tsx` (arrow + dot), `components/Words.tsx`
      (word-by-word reveal with optional exit), `components/SvgArt.tsx`
      (animate SVG artwork per path: `parts` with `popEach` for letters,
      `characterStyle()` for bounce/bob/sway, `fadeLeft` for edge-cropped art).
    Delete the scaffold's `Composition.tsx`. Keep inline styles.
    
    One file per scene (`scenes/S01Hook.tsx` …), each an `<AbsoluteFill>` with
    its own background so hard cuts are intentional. Local frames start at 0 in
    every scene; timings live at the top of the file as small constants.
    
    ## 3. Write the scenes
    `references/scene-patterns.md` is a catalogue of 16 patterns with timings
    that worked (phrase swap, pill→button→click, flying collage, circle wipe,
    ticker + panel wipe, shape hand-off between scenes, route drawing, UI
    toggle moment, gradient statement, character + letter pop, bubble rows,
    chart card, spotlight, burst → lockup, fade out). Pick the ones the beat map
    calls for; reuse the shapes rather than inventing new mechanics per scene.
    Guidelines that keep it looking designed:
    - Few colours: ink, white, one brand accent, one secondary. Light scenes
      share one `LightBg`, dark scenes one `DarkBg`, so cuts don't flash.
    - Type: headline 58-80 px, labels ≥ 28 px at 1080 wide; weight 600-700;
      letter-spacing −0.5 to −1.2 on big lines.
    - Stagger words 5-7 frames; entrances 12-16 frames; exits 8-10 frames;
      a beat holds ≥ 20 frames after its last element lands.
    - Hand elements between scenes (pill → marker, button position → next
      scene's start) through shared helpers so the cut is invisible.
    - Characters: spring in from below (damping 12), then bob + 2-3° sway;
      pop wordmark letters 2 frames apart with damping 10.
    - Anything positional uses fractions of W/H or offsets from cx/cy, with a
      `wide` branch when a tall element must sit beside its text.
    
    ## 4. Verify like an editor, not a compiler
    `references/verification-and-gotchas.md` has the loop and the traps. Short
    form: `npx tsc --noEmit` → `scripts/check_render.sh <CompId> out/check` →
    view every contact sheet → still-render suspicious frames at 0.5 → fix →
    repeat. Only then `npx remotion render <CompId> out/final.mp4 --codec=h264 --crf=18`,
    and pull a frame or two from the final file as proof. When adding a second
    orientation, re-check the first one's sheet to prove nothing moved.
    
    ## 5. Deliver
    - Copy the MP4 next to the user's source files and send it with the file
      tool (`SendUserFile`), one card per meaningful version.
    - Start Remotion Studio for scrubbing/tweaking: `.claude/launch.json` at the
      session root with `sh -c "cd <project> && npx remotion studio --port 3011 --no-open"`,
      then `preview_start`. Mention the composition ids.
    - In the summary: what each scene does in one line, which copy lines were
      invented, what was not done (no music, no downloaded photos), and the
      one-line re-render command.
    
    ## Files
    - `assets/` — theme, layout hook, anim helpers, fonts, Main/Root templates,
      Backgrounds, Cursors, Words, SvgArt (copy into `src/`).
    - `scripts/analyze_reference.sh` — contact sheets from a reference video.
    - `scripts/svg_to_paths.mjs` — SVG → TS path data with bbox report.
    - `scripts/check_render.sh` — low-res render + sheets for a composition.
    - `scripts/still_frame.sh` — one frame from an MP4 at a timestamp.
    - `references/scene-patterns.md` — the pattern catalogue with timings.
    - `references/verification-and-gotchas.md` — check loop and traps.
    - `references/remotion-rules/` — official Remotion rule files.
    
  • skills/remotion-motion-graphics/scripts/analyze_reference.sh1.1 KB60cc88a6aa47upstream ↗
    #!/usr/bin/env bash
    # Break a reference video into contact sheets so its motion can be mapped beat
    # by beat (backgrounds, cuts, text timing, transitions) before writing scenes.
    #
    # Usage: analyze_reference.sh <video> <out_dir>
    # Produces: <out_dir>/overview.png (1 fps, whole video) and
    #           <out_dir>/seg_<start>s.png (4 fps, 8-second windows, 32 frames each)
    set -euo pipefail
    VIDEO="$1"; OUT="$2"; mkdir -p "$OUT"
    ffprobe -v error -show_entries format=duration:stream=width,height,r_frame_rate -of default=noprint_wrappers=1 "$VIDEO" | tee "$OUT/probe.txt"
    DUR=$(ffprobe -v error -show_entries format=duration -of csv=p=0 "$VIDEO" | cut -d. -f1)
    COLS=6; ROWS=$(( (DUR + COLS) / COLS ))
    ffmpeg -v error -y -i "$VIDEO" -vf "fps=1,scale=180:-1,tile=${COLS}x${ROWS}" "$OUT/overview.png"
    START=0
    while [ "$START" -lt "$DUR" ]; do
      ffmpeg -v error -y -ss "$START" -t 8 -i "$VIDEO" -vf "fps=4,scale=160:-1,tile=8x4" "$OUT/seg_${START}s.png"
      START=$((START + 8))
    done
    echo "wrote $(ls "$OUT"/*.png | wc -l | tr -d ' ') sheets to $OUT — read them with the image viewer and write the beat map"
    
  • skills/remotion-motion-graphics/scripts/check_render.sh951 B5d91244b8f36upstream ↗
    #!/usr/bin/env bash
    # Cheap whole-composition check: render at 0.3 scale, tile frames into contact
    # sheets, and print the paths to view. Catches crashes, overlaps, safe-zone
    # misses and timing problems in ~1 minute instead of a full render.
    #
    # Usage: check_render.sh <composition-id> <out_dir> [sheet_seconds=12] [fps=2]
    # Run from inside the Remotion project.
    set -euo pipefail
    COMP="$1"; OUT="$2"; SEG="${3:-12}"; FPS="${4:-2}"; mkdir -p "$OUT"
    npx remotion render "$COMP" "$OUT/preview_${COMP}.mp4" --scale=0.3 --jpeg-quality=70 --log=error 2>&1 | grep -v -i deprecat || true
    DUR=$(ffprobe -v error -show_entries format=duration -of csv=p=0 "$OUT/preview_${COMP}.mp4" | cut -d. -f1)
    START=0; N=1
    while [ "$START" -le "$DUR" ]; do
      ffmpeg -v error -y -ss "$START" -t "$SEG" -i "$OUT/preview_${COMP}.mp4" -vf "fps=${FPS},scale=200:-1,tile=8x3" "$OUT/${COMP}_sheet${N}.png"
      START=$((START + SEG)); N=$((N + 1))
    done
    ls "$OUT"/${COMP}_sheet*.png
    
  • skills/remotion-motion-graphics/scripts/still_frame.sh277 B715692420c6cupstream ↗
    #!/usr/bin/env bash
    # Extract one frame from a rendered MP4 at a timestamp (seconds) for a
    # close-up check of a single moment. Usage: still_frame.sh <mp4> <seconds> <out.png>
    set -euo pipefail
    ffmpeg -v error -y -ss "$2" -i "$1" -frames:v 1 -vf scale=960:-1 "$3" && echo "$3"
    
  • skills/remotion-motion-graphics/scripts/svg_to_paths.mjs3.6 KB07540b1e104aupstream ↗
    #!/usr/bin/env node
    // Turn one or more SVG files into a TypeScript module of path data + bounding
    // boxes, so artwork can be animated per path in Remotion (see SvgArt.tsx).
    //
    //   node svg_to_paths.mjs --out src/logo/paths.ts dog=logo-dog.svg lemon=logo-lemon.svg
    //   node svg_to_paths.mjs --report logo-dog.svg          # print a bbox table only
    //
    // The report lists every path's index, fill, position and size. Use it to
    // decide which indices form which part (wordmark letters, body, eyes...).
    // Gradient fills (url(#id)) are replaced by their first stop colour, or grey.
    import fs from "node:fs";
    
    const args = process.argv.slice(2);
    let out = null;
    let report = false;
    const inputs = [];
    for (let i = 0; i < args.length; i++) {
      if (args[i] === "--out") out = args[++i];
      else if (args[i] === "--report") report = true;
      else inputs.push(args[i]);
    }
    if (inputs.length === 0) {
      console.error("usage: svg_to_paths.mjs [--out file.ts] [--report] name=file.svg ...");
      process.exit(1);
    }
    
    const parse = (file) => {
      const s = fs.readFileSync(file, "utf8");
      const stops = {};
      for (const g of s.matchAll(/<(linearGradient|radialGradient)[^>]*id="([^"]+)"[^>]*>([\s\S]*?)<\/\1>/g)) {
        const m = g[3].match(/stop-color="([^"]+)"|stop-color:\s*([^;"]+)/);
        stops[g[2]] = m ? m[1] || m[2] : "#9A9AA8";
      }
      const other = s.match(/<(rect|circle|ellipse|polygon|polyline|line|use|image|text)\b/g);
      if (other) console.warn(`${file}: contains ${[...new Set(other)].join(", ")} — only <path> elements are exported; convert shapes to paths in the editor if they matter`);
      const paths = [];
      for (const m of s.matchAll(/<path\b([^>]*)\/?>/g)) {
        const attrs = m[1];
        const d = attrs.match(/\sd="([^"]+)"/)?.[1];
        if (!d) continue;
        let fill = attrs.match(/\sfill="([^"]+)"/)?.[1] ?? "#000000";
        if (fill === "white") fill = "#FFFFFF";
        if (fill === "black") fill = "#000000";
        const grad = fill.match(/url\(#([^)]+)\)/);
        if (grad) fill = stops[grad[1]] ?? "#9A9AA8";
        const nums = d.match(/-?\d*\.?\d+(?:e-?\d+)?/g).map(Number);
        const xs = [], ys = [];
        for (let k = 0; k + 1 < nums.length; k += 2) { xs.push(nums[k]); ys.push(nums[k + 1]); }
        const box = [Math.min(...xs), Math.min(...ys), Math.max(...xs), Math.max(...ys)].map(Math.round);
        paths.push({ d, fill, box });
      }
      const box = [
        Math.min(...paths.map((p) => p.box[0])), Math.min(...paths.map((p) => p.box[1])),
        Math.max(...paths.map((p) => p.box[2])), Math.max(...paths.map((p) => p.box[3])),
      ];
      return { box, paths };
    };
    
    let ts = "// AUTO-GENERATED by svg_to_paths.mjs — do not edit by hand.\n";
    ts += "export type SvgPath = { d: string; fill: string; box: [number, number, number, number] };\n";
    ts += "export type SvgData = { box: [number, number, number, number]; paths: SvgPath[] };\n";
    for (const input of inputs) {
      const eq = input.indexOf("=");
      const name = eq > 0 ? input.slice(0, eq) : input.replace(/.*\//, "").replace(/\W.*$/, "");
      const file = eq > 0 ? input.slice(eq + 1) : input;
      const data = parse(file);
      console.error(`${name}: ${data.paths.length} paths, art box ${data.box.join(",")}`);
      if (report || !out) {
        console.log(`\n=== ${name} (${file})\nidx\tfill\tx,y\tw x h`);
        data.paths.forEach((p, i) => console.log(`${i}\t${p.fill}\t${p.box[0]},${p.box[1]}\t${p.box[2] - p.box[0]}x${p.box[3] - p.box[1]}`));
      }
      ts += `\nexport const ${name}: SvgData = ${JSON.stringify(data)};\n`;
    }
    if (out) {
      fs.mkdirSync(out.replace(/\/[^/]+$/, ""), { recursive: true });
      fs.writeFileSync(out, ts);
      console.error(`wrote ${out} (${(ts.length / 1024).toFixed(0)} KB)`);
    }
    
  • skills/remotion-motion-graphics/references/remotion-rules/animations.md1.1 KB4a02e553570eupstream ↗
    ---
    name: animations
    description: Fundamental animation skills for Remotion
    metadata:
      tags: animations, transitions, frames, useCurrentFrame
    ---
    
    All animations MUST be driven by the `useCurrentFrame()` hook.  
    Write animations in seconds and multiply them by the `fps` value from `useVideoConfig()`.
    
    For eased motion, prefer `interpolate` with explicit frame ranges and an easing—especially `Easing.bezier`, which matches CSS `cubic-bezier` so timing can be shared with web specs and curve editors. See [timing](./timing.md).
    
    ```tsx
    import { useCurrentFrame, Easing } from "remotion";
    
    export const FadeIn = () => {
      const frame = useCurrentFrame();
      const { fps } = useVideoConfig();
    
      const opacity = interpolate(frame, [0, 2 * fps], [0, 1], {
        extrapolateRight: "clamp",
        extrapolateLeft: "clamp",
        easing: Easing.bezier(0.16, 1, 0.3, 1),
      });
    
      return <div style={{ opacity }}>Hello World!</div>;
    };
    ```
    
    CSS transitions or animations are FORBIDDEN - they will not render correctly.  
    Tailwind animation class names are FORBIDDEN - they will not render correctly.
    
  • skills/remotion-motion-graphics/references/remotion-rules/audio.md3.5 KB1097c70e864aupstream ↗
    ---
    name: audio
    description: Using audio and sound in Remotion - importing, trimming, volume, speed, pitch
    metadata:
      tags: audio, media, trim, volume, speed, loop, pitch, mute, sound, sfx
    ---
    
    # Using audio in Remotion
    
    ## Prerequisites
    
    First, the @remotion/media package needs to be installed.
    If it is not installed, use the following command:
    
    ```bash
    npx remotion add @remotion/media
    ```
    
    ## Importing Audio
    
    Use `<Audio>` from `@remotion/media` to add audio to your composition.
    
    ```tsx
    import { Audio } from "@remotion/media";
    import { staticFile } from "remotion";
    
    export const MyComposition = () => {
      return <Audio src={staticFile("audio.mp3")} />;
    };
    ```
    
    Remote URLs are also supported:
    
    ```tsx
    <Audio src="https://remotion.media/audio.mp3" />
    ```
    
    By default, audio plays from the start, at full volume and full length.
    Multiple audio tracks can be layered by adding multiple `<Audio>` components.
    
    ## Trimming
    
    Use `trimBefore` and `trimAfter` to remove portions of the audio. Values are in frames.
    
    ```tsx
    const { fps } = useVideoConfig();
    
    return (
      <Audio
        src={staticFile("audio.mp3")}
        trimBefore={2 * fps} // Skip the first 2 seconds
        trimAfter={10 * fps} // End at the 10 second mark
      />
    );
    ```
    
    The audio still starts playing at the beginning of the composition - only the specified portion is played.
    
    ## Delaying
    
    Wrap the audio in a `<Sequence>` to delay when it starts:
    
    ```tsx
    import { Sequence, staticFile } from "remotion";
    import { Audio } from "@remotion/media";
    
    const { fps } = useVideoConfig();
    
    return (
      <Sequence from={1 * fps}>
        <Audio src={staticFile("audio.mp3")} />
      </Sequence>
    );
    ```
    
    The audio will start playing after 1 second.
    
    ## Volume
    
    Set a static volume (0 to 1):
    
    ```tsx
    <Audio src={staticFile("audio.mp3")} volume={0.5} />
    ```
    
    Or use a callback for dynamic volume based on the current frame:
    
    ```tsx
    import { interpolate } from "remotion";
    
    const { fps } = useVideoConfig();
    
    return (
      <Audio
        src={staticFile("audio.mp3")}
        volume={(f) =>
          interpolate(f, [0, 1 * fps], [0, 1], { extrapolateRight: "clamp" })
        }
      />
    );
    ```
    
    The value of `f` starts at 0 when the audio begins to play, not the composition frame.
    
    ## Muting
    
    Use `muted` to silence the audio. It can be set dynamically:
    
    ```tsx
    const frame = useCurrentFrame();
    const { fps } = useVideoConfig();
    
    return (
      <Audio
        src={staticFile("audio.mp3")}
        muted={frame >= 2 * fps && frame <= 4 * fps} // Mute between 2s and 4s
      />
    );
    ```
    
    ## Speed
    
    Use `playbackRate` to change the playback speed:
    
    ```tsx
    <Audio src={staticFile("audio.mp3")} playbackRate={2} /> {/* 2x speed */}
    <Audio src={staticFile("audio.mp3")} playbackRate={0.5} /> {/* Half speed */}
    ```
    
    Reverse playback is not supported.
    
    ## Looping
    
    Use `loop` to loop the audio indefinitely:
    
    ```tsx
    <Audio src={staticFile("audio.mp3")} loop />
    ```
    
    Use `loopVolumeCurveBehavior` to control how the frame count behaves when looping:
    
    - `"repeat"`: Frame count resets to 0 each loop (default)
    - `"extend"`: Frame count continues incrementing
    
    ```tsx
    <Audio
      src={staticFile("audio.mp3")}
      loop
      loopVolumeCurveBehavior="extend"
      volume={(f) => interpolate(f, [0, 300], [1, 0])} // Fade out over multiple loops
    />
    ```
    
    ## Pitch
    
    Use `toneFrequency` to adjust the pitch without affecting speed. Values range from 0.01 to 2:
    
    ```tsx
    <Audio
      src={staticFile("audio.mp3")}
      toneFrequency={1.5} // Higher pitch
    />
    <Audio
      src={staticFile("audio.mp3")}
      toneFrequency={0.8} // Lower pitch
    />
    ```
    
    Pitch shifting only works during server-side rendering, not in the Remotion Studio preview or in the `<Player />`.
    
  • skills/remotion-motion-graphics/references/remotion-rules/charts.md2.9 KBf03648589241upstream ↗
    ---
    name: charts
    description: Chart and data visualization patterns for Remotion. Use when creating bar charts, pie charts, line charts, stock graphs, or any data-driven animations.
    metadata:
      tags: charts, data, visualization, bar-chart, pie-chart, line-chart, stock-chart, svg-paths, graphs
    ---
    
    # Charts in Remotion
    
    Create charts using React code - HTML, SVG, and D3.js are all supported.
    
    Disable all animations from third party libraries - they cause flickering.  
    Drive all animations from `useCurrentFrame()`.
    
    ## Bar Chart
    
    ```tsx
    const STAGGER_DELAY = 5;
    const frame = useCurrentFrame();
    const { fps } = useVideoConfig();
    
    const bars = data.map((item, i) => {
      const height = spring({
        frame,
        fps,
        delay: i * STAGGER_DELAY,
        config: { damping: 200 },
      });
      return <div style={{ height: height * item.value }} />;
    });
    ```
    
    ## Pie Chart
    
    Animate segments using stroke-dashoffset, starting from 12 o'clock:
    
    ```tsx
    const progress = interpolate(frame, [0, 100], [0, 1]);
    const circumference = 2 * Math.PI * radius;
    const segmentLength = (value / total) * circumference;
    const offset = interpolate(progress, [0, 1], [segmentLength, 0]);
    
    <circle
      r={radius}
      cx={center}
      cy={center}
      fill="none"
      stroke={color}
      strokeWidth={strokeWidth}
      strokeDasharray={`${segmentLength} ${circumference}`}
      strokeDashoffset={offset}
      transform={`rotate(-90 ${center} ${center})`}
    />;
    ```
    
    ## Line Chart / Path Animation
    
    Use `@remotion/paths` for animating SVG paths (line charts, stock graphs, signatures).
    
    Install: `npx remotion add @remotion/paths`  
    Docs: https://remotion.dev/docs/paths.md
    
    ### Convert data points to SVG path
    
    ```tsx
    type Point = { x: number; y: number };
    
    const generateLinePath = (points: Point[]): string => {
      if (points.length < 2) return "";
      return points.map((p, i) => `${i === 0 ? "M" : "L"} ${p.x} ${p.y}`).join(" ");
    };
    ```
    
    ### Draw path with animation
    
    ```tsx
    import { evolvePath } from "@remotion/paths";
    
    const path = "M 100 200 L 200 150 L 300 180 L 400 100";
    const progress = interpolate(frame, [0, 2 * fps], [0, 1], {
      extrapolateLeft: "clamp",
      extrapolateRight: "clamp",
      easing: Easing.out(Easing.quad),
    });
    
    const { strokeDasharray, strokeDashoffset } = evolvePath(progress, path);
    
    <path
      d={path}
      fill="none"
      stroke="#FF3232"
      strokeWidth={4}
      strokeDasharray={strokeDasharray}
      strokeDashoffset={strokeDashoffset}
    />;
    ```
    
    ### Follow path with marker/arrow
    
    ```tsx
    import {
      getLength,
      getPointAtLength,
      getTangentAtLength,
    } from "@remotion/paths";
    
    const pathLength = getLength(path);
    const point = getPointAtLength(path, progress * pathLength);
    const tangent = getTangentAtLength(path, progress * pathLength);
    const angle = Math.atan2(tangent.y, tangent.x);
    
    <g
      style={{
        transform: `translate(${point.x}px, ${point.y}px) rotate(${angle}rad)`,
        transformOrigin: "0 0",
      }}
    >
      <polygon points="0,0 -20,-10 -20,10" fill="#FF3232" />
    </g>;
    ```
    
  • skills/remotion-motion-graphics/references/remotion-rules/compositions.md3.7 KB0db5f60266d1upstream ↗
    ---
    name: compositions
    description: Defining compositions, stills, folders, default props and dynamic metadata
    metadata:
      tags: composition, still, folder, props, metadata
    ---
    
    A `<Composition>` defines the component, width, height, fps and duration of a renderable video.
    
    It normally is placed in the `src/Root.tsx` file.
    
    ```tsx
    import { Composition } from "remotion";
    import { MyComposition } from "./MyComposition";
    
    export const RemotionRoot = () => {
      return (
        <Composition
          id="MyComposition"
          component={MyComposition}
          durationInFrames={100}
          fps={30}
          width={1080}
          height={1080}
        />
      );
    };
    ```
    
    ## Default Props
    
    Pass `defaultProps` to provide initial values for your component.  
    Values must be JSON-serializable (`Date`, `Map`, `Set`, and `staticFile()` are supported).
    
    ```tsx
    import { Composition } from "remotion";
    import { MyComposition, MyCompositionProps } from "./MyComposition";
    
    export const RemotionRoot = () => {
      return (
        <Composition
          id="MyComposition"
          component={MyComposition}
          durationInFrames={100}
          fps={30}
          width={1080}
          height={1080}
          defaultProps={
            {
              title: "Hello World",
              color: "#ff0000",
            } satisfies MyCompositionProps
          }
        />
      );
    };
    ```
    
    Use `type` declarations for props rather than `interface` to ensure `defaultProps` type safety.
    
    ## Folders
    
    Use `<Folder>` to organize compositions in the sidebar.  
    Folder names can only contain letters, numbers, and hyphens.
    
    ```tsx
    import { Composition, Folder } from "remotion";
    
    export const RemotionRoot = () => {
      return (
        <>
          <Folder name="Marketing">
            <Composition id="Promo" /* ... */ />
            <Composition id="Ad" /* ... */ />
          </Folder>
          <Folder name="Social">
            <Folder name="Instagram">
              <Composition id="Story" /* ... */ />
              <Composition id="Reel" /* ... */ />
            </Folder>
          </Folder>
        </>
      );
    };
    ```
    
    ## Stills
    
    Use `<Still>` for single-frame images. It does not require `durationInFrames` or `fps`.
    
    ```tsx
    import { Still } from "remotion";
    import { Thumbnail } from "./Thumbnail";
    
    export const RemotionRoot = () => {
      return (
        <Still id="Thumbnail" component={Thumbnail} width={1280} height={720} />
      );
    };
    ```
    
    ## Calculate Metadata
    
    Use `calculateMetadata` to make dimensions, duration, or props dynamic based on data.
    
    ```tsx
    import { Composition, CalculateMetadataFunction } from "remotion";
    import { MyComposition, MyCompositionProps } from "./MyComposition";
    
    const calculateMetadata: CalculateMetadataFunction<
      MyCompositionProps
    > = async ({ props, abortSignal }) => {
      const data = await fetch(`https://api.example.com/video/${props.videoId}`, {
        signal: abortSignal,
      }).then((res) => res.json());
    
      return {
        durationInFrames: Math.ceil(data.duration * 30),
        props: {
          ...props,
          videoUrl: data.url,
        },
      };
    };
    
    export const RemotionRoot = () => {
      return (
        <Composition
          id="MyComposition"
          component={MyComposition}
          durationInFrames={100} // Placeholder, will be overridden
          fps={30}
          width={1080}
          height={1080}
          defaultProps={{ videoId: "abc123" }}
          calculateMetadata={calculateMetadata}
        />
      );
    };
    ```
    
    The function can return `props`, `durationInFrames`, `width`, `height`, `fps`, and codec-related defaults. It runs once before rendering begins.
    
    ## Nesting compositions within another
    
    To add a composition within another composition, you can use the `<Sequence>` component with a `width` and `height` prop to specify the size of the composition.
    
    ```tsx
    <AbsoluteFill>
      <Sequence width={COMPOSITION_WIDTH} height={COMPOSITION_HEIGHT}>
        <CompositionComponent />
      </Sequence>
    </AbsoluteFill>
    ```
    
  • skills/remotion-motion-graphics/references/remotion-rules/fonts.md3.4 KBc10cd83e6249upstream ↗
    ---
    name: fonts
    description: Loading Google Fonts and local fonts in Remotion
    metadata:
      tags: fonts, google-fonts, typography, text
    ---
    
    # Using fonts in Remotion
    
    ## Google Fonts with @remotion/google-fonts
    
    The recommended way to use Google Fonts. It's type-safe and automatically blocks rendering until the font is ready.
    
    ### Prerequisites
    
    First, the @remotion/google-fonts package needs to be installed.
    If it is not installed, use the following command:
    
    ```bash
    npx remotion add @remotion/google-fonts # If project uses npm
    bunx remotion add @remotion/google-fonts # If project uses bun
    yarn remotion add @remotion/google-fonts # If project uses yarn
    pnpm exec remotion add @remotion/google-fonts # If project uses pnpm
    ```
    
    ```tsx
    import { loadFont } from "@remotion/google-fonts/Lobster";
    
    const { fontFamily } = loadFont();
    
    export const MyComposition = () => {
      return <div style={{ fontFamily }}>Hello World</div>;
    };
    ```
    
    Preferrably, specify only needed weights and subsets to reduce file size:
    
    ```tsx
    import { loadFont } from "@remotion/google-fonts/Roboto";
    
    const { fontFamily } = loadFont("normal", {
      weights: ["400", "700"],
      subsets: ["latin"],
    });
    ```
    
    ### Waiting for font to load
    
    Use `waitUntilDone()` if you need to know when the font is ready:
    
    ```tsx
    import { loadFont } from "@remotion/google-fonts/Lobster";
    
    const { fontFamily, waitUntilDone } = loadFont();
    
    await waitUntilDone();
    ```
    
    ## Local fonts with @remotion/fonts
    
    For local font files, use the `@remotion/fonts` package.
    
    ### Prerequisites
    
    First, install @remotion/fonts:
    
    ```bash
    npx remotion add @remotion/fonts # If project uses npm
    bunx remotion add @remotion/fonts # If project uses bun
    yarn remotion add @remotion/fonts # If project uses yarn
    pnpm exec remotion add @remotion/fonts # If project uses pnpm
    ```
    
    ### Loading a local font
    
    Place your font file in the `public/` folder and use `loadFont()`:
    
    ```tsx
    import { loadFont } from "@remotion/fonts";
    import { staticFile } from "remotion";
    
    await loadFont({
      family: "MyFont",
      url: staticFile("MyFont-Regular.woff2"),
    });
    
    export const MyComposition = () => {
      return <div style={{ fontFamily: "MyFont" }}>Hello World</div>;
    };
    ```
    
    ### Loading multiple weights
    
    Load each weight separately with the same family name:
    
    ```tsx
    import { loadFont } from "@remotion/fonts";
    import { staticFile } from "remotion";
    
    await Promise.all([
      loadFont({
        family: "Inter",
        url: staticFile("Inter-Regular.woff2"),
        weight: "400",
      }),
      loadFont({
        family: "Inter",
        url: staticFile("Inter-Bold.woff2"),
        weight: "700",
      }),
    ]);
    ```
    
    ### Available options
    
    ```tsx
    loadFont({
      family: "MyFont", // Required: name to use in CSS
      url: staticFile("font.woff2"), // Required: font file URL
      format: "woff2", // Optional: auto-detected from extension
      weight: "400", // Optional: font weight
      style: "normal", // Optional: normal or italic
      display: "block", // Optional: font-display behavior
    });
    ```
    
    ## Using in components
    
    Call `loadFont()` at the top level of your component or in a separate file that's imported early:
    
    ```tsx
    import { loadFont } from "@remotion/google-fonts/Montserrat";
    
    const { fontFamily } = loadFont("normal", {
      weights: ["400", "700"],
      subsets: ["latin"],
    });
    
    export const Title: React.FC<{ text: string }> = ({ text }) => {
      return (
        <h1
          style={{
            fontFamily,
            fontSize: 80,
            fontWeight: "bold",
          }}
        >
          {text}
        </h1>
      );
    };
    ```
    
  • skills/remotion-motion-graphics/references/remotion-rules/images.md2.7 KB3b0319442f8bupstream ↗
    ---
    name: images
    description: Embedding images in Remotion using the <Img> component
    metadata:
      tags: images, img, staticFile, png, jpg, svg, webp
    ---
    
    # Using images in Remotion
    
    ## The `<Img>` component
    
    Always use the `<Img>` component from `remotion` to display images:
    
    ```tsx
    import { Img, staticFile } from "remotion";
    
    export const MyComposition = () => {
      return <Img src={staticFile("photo.png")} />;
    };
    ```
    
    ## Important restrictions
    
    **You MUST use the `<Img>` component from `remotion`.** Do not use:
    
    - Native HTML `<img>` elements
    - Next.js `<Image>` component
    - CSS `background-image`
    
    The `<Img>` component ensures images are fully loaded before rendering, preventing flickering and blank frames during video export.
    
    ## Local images with staticFile()
    
    Place images in the `public/` folder and use `staticFile()` to reference them:
    
    ```
    my-video/
    ├─ public/
    │  ├─ logo.png
    │  ├─ avatar.jpg
    │  └─ icon.svg
    ├─ src/
    ├─ package.json
    ```
    
    ```tsx
    import { Img, staticFile } from "remotion";
    
    <Img src={staticFile("logo.png")} />;
    ```
    
    ## Remote images
    
    Remote URLs can be used directly without `staticFile()`:
    
    ```tsx
    <Img src="https://example.com/image.png" />
    ```
    
    Ensure remote images have CORS enabled.
    
    For animated GIFs, use the `<Gif>` component from `@remotion/gif` instead.
    
    ## Sizing and positioning
    
    Use the `style` prop to control size and position:
    
    ```tsx
    <Img
      src={staticFile("photo.png")}
      style={{
        width: 500,
        height: 300,
        position: "absolute",
        top: 100,
        left: 50,
        objectFit: "cover",
      }}
    />
    ```
    
    ## Dynamic image paths
    
    Use template literals for dynamic file references:
    
    ```tsx
    import { Img, staticFile, useCurrentFrame } from "remotion";
    
    const frame = useCurrentFrame();
    
    // Image sequence
    <Img src={staticFile(`frames/frame${frame}.png`)} />
    
    // Selecting based on props
    <Img src={staticFile(`avatars/${props.userId}.png`)} />
    
    // Conditional images
    <Img src={staticFile(`icons/${isActive ? "active" : "inactive"}.svg`)} />
    ```
    
    This pattern is useful for:
    
    - Image sequences (frame-by-frame animations)
    - User-specific avatars or profile images
    - Theme-based icons
    - State-dependent graphics
    
    ## Getting image dimensions
    
    Use `getImageDimensions()` to get the dimensions of an image:
    
    ```tsx
    import { getImageDimensions, staticFile } from "remotion";
    
    const { width, height } = await getImageDimensions(staticFile("photo.png"));
    ```
    
    This is useful for calculating aspect ratios or sizing compositions:
    
    ```tsx
    import {
      getImageDimensions,
      staticFile,
      CalculateMetadataFunction,
    } from "remotion";
    
    const calculateMetadata: CalculateMetadataFunction = async () => {
      const { width, height } = await getImageDimensions(staticFile("photo.png"));
      return {
        width,
        height,
      };
    };
    ```
    
  • skills/remotion-motion-graphics/references/remotion-rules/light-leaks.md2.3 KB354b95666ae9upstream ↗
    ---
    name: light-leaks
    description: Light leak overlay effects for Remotion using @remotion/light-leaks.
    metadata:
      tags: light-leaks, overlays, effects, transitions
    ---
    
    ## Light Leaks
    
    This only works from Remotion 4.0.415 and up. Use `npx remotion versions` to check your Remotion version and `npx remotion upgrade` to upgrade your Remotion version.
    
    `<LightLeak>` from `@remotion/light-leaks` renders a WebGL-based light leak effect. It reveals during the first half of its duration and retracts during the second half.
    
    Typically used inside a `<TransitionSeries.Overlay>` to play over the cut point between two scenes. See the **transitions** rule for `<TransitionSeries>` and overlay usage.
    
    ## Prerequisites
    
    ```bash
    npx remotion add @remotion/light-leaks
    ```
    
    ## Basic usage with TransitionSeries
    
    ```tsx
    import { TransitionSeries } from "@remotion/transitions";
    import { LightLeak } from "@remotion/light-leaks";
    
    <TransitionSeries>
      <TransitionSeries.Sequence durationInFrames={60}>
        <SceneA />
      </TransitionSeries.Sequence>
      <TransitionSeries.Overlay durationInFrames={30}>
        <LightLeak />
      </TransitionSeries.Overlay>
      <TransitionSeries.Sequence durationInFrames={60}>
        <SceneB />
      </TransitionSeries.Sequence>
    </TransitionSeries>;
    ```
    
    ## Props
    
    - `durationInFrames?` — defaults to the parent sequence/composition duration. The effect reveals during the first half and retracts during the second half.
    - `seed?` — determines the shape of the light leak pattern. Different seeds produce different patterns. Default: `0`.
    - `hueShift?` — rotates the hue in degrees (`0`–`360`). Default: `0` (yellow-to-orange). `120` = green, `240` = blue.
    
    ## Customizing the look
    
    ```tsx
    import { LightLeak } from "@remotion/light-leaks";
    
    // Blue-tinted light leak with a different pattern
    <LightLeak seed={5} hueShift={240} />;
    
    // Green-tinted light leak
    <LightLeak seed={2} hueShift={120} />;
    ```
    
    ## Standalone usage
    
    `<LightLeak>` can also be used outside of `<TransitionSeries>`, for example as a decorative overlay in any composition:
    
    ```tsx
    import { AbsoluteFill } from "remotion";
    import { LightLeak } from "@remotion/light-leaks";
    
    const MyComp: React.FC = () => (
      <AbsoluteFill>
        <MyContent />
        <LightLeak durationInFrames={60} seed={3} />
      </AbsoluteFill>
    );
    ```
    
  • skills/remotion-motion-graphics/references/remotion-rules/sequencing.md2.7 KB46b86a8872a7upstream ↗
    ---
    name: sequencing
    description: Sequencing patterns for Remotion - delay, trim, limit duration of items
    metadata:
      tags: sequence, series, timing, delay, trim
    ---
    
    Use `<Sequence>` to delay when an element appears in the timeline.
    
    ```tsx
    import { Sequence } from "remotion";
    
    const {fps} = useVideoConfig();
    
    <Sequence from={1 * fps} durationInFrames={2 * fps} premountFor={1 * fps}>
      <Title />
    </Sequence>
    <Sequence from={2 * fps} durationInFrames={2 * fps} premountFor={1 * fps}>
      <Subtitle />
    </Sequence>
    ```
    
    This will by default wrap the component in an absolute fill element.  
    If the items should not be wrapped, use the `layout` prop:
    
    ```tsx
    <Sequence layout="none">
      <Title />
    </Sequence>
    ```
    
    ## Premounting
    
    This loads the component in the timeline before it is actually played.  
    Always premount any `<Sequence>`!
    
    ```tsx
    <Sequence premountFor={1 * fps}>
      <Title />
    </Sequence>
    ```
    
    ## Series
    
    Use `<Series>` when elements should play one after another without overlap.
    
    ```tsx
    import { Series } from "remotion";
    
    <Series>
      <Series.Sequence durationInFrames={45}>
        <Intro />
      </Series.Sequence>
      <Series.Sequence durationInFrames={60}>
        <MainContent />
      </Series.Sequence>
      <Series.Sequence durationInFrames={30}>
        <Outro />
      </Series.Sequence>
    </Series>;
    ```
    
    Same as with `<Sequence>`, the items will be wrapped in an absolute fill element by default when using `<Series.Sequence>`, unless the `layout` prop is set to `none`.
    
    ### Series with overlaps
    
    Use negative offset for overlapping sequences:
    
    ```tsx
    <Series>
      <Series.Sequence durationInFrames={60}>
        <SceneA />
      </Series.Sequence>
      <Series.Sequence offset={-15} durationInFrames={60}>
        {/* Starts 15 frames before SceneA ends */}
        <SceneB />
      </Series.Sequence>
    </Series>
    ```
    
    ## Frame References Inside Sequences
    
    Inside a Sequence, `useCurrentFrame()` returns the local frame (starting from 0):
    
    ```tsx
    <Sequence from={60} durationInFrames={30}>
      <MyComponent />
      {/* Inside MyComponent, useCurrentFrame() returns 0-29, not 60-89 */}
    </Sequence>
    ```
    
    ## Nested Sequences
    
    Sequences can be nested for complex timing:
    
    ```tsx
    <Sequence from={0} durationInFrames={120}>
      <Background />
      <Sequence from={15} durationInFrames={90} layout="none">
        <Title />
      </Sequence>
      <Sequence from={45} durationInFrames={60} layout="none">
        <Subtitle />
      </Sequence>
    </Sequence>
    ```
    
    ## Nesting compositions within another
    
    To add a composition within another composition, you can use the `<Sequence>` component with a `width` and `height` prop to specify the size of the composition.
    
    ```tsx
    <AbsoluteFill>
      <Sequence width={COMPOSITION_WIDTH} height={COMPOSITION_HEIGHT}>
        <CompositionComponent />
      </Sequence>
    </AbsoluteFill>
    ```
    
  • skills/remotion-motion-graphics/references/remotion-rules/sfx.md867 B41fdc500de70upstream ↗
    ---
    name: sfx
    description: Including sound effects
    metadata:
      tags: sfx, sound, effect, audio
    ---
    
    To include a sound effect, use the `<Audio>` tag:
    
    ```tsx
    import { Audio } from "@remotion/sfx";
    
    <Audio src={"https://remotion.media/whoosh.wav"} />;
    ```
    
    The following sound effects are available:
    
    - `https://remotion.media/whoosh.wav`
    - `https://remotion.media/whip.wav`
    - `https://remotion.media/page-turn.wav`
    - `https://remotion.media/switch.wav`
    - `https://remotion.media/mouse-click.wav`
    - `https://remotion.media/shutter-modern.wav`
    - `https://remotion.media/shutter-old.wav`
    - `https://remotion.media/ding.wav`
    - `https://remotion.media/bruh.wav`
    - `https://remotion.media/vine-boom.wav`
    - `https://remotion.media/windows-xp-error.wav`
    
    For more sound effects, search the internet. A good resource is https://github.com/kapishdima/soundcn/tree/main/assets.
    
  • skills/remotion-motion-graphics/references/remotion-rules/text-animations.md700 Be38b1c574232upstream ↗
    ---
    name: text-animations
    description: Typography and text animation patterns for Remotion.
    metadata:
      tags: typography, text, typewriter, highlighter ken
    ---
    
    ## Text animations
    
    Based on `useCurrentFrame()`, reduce the string character by character to create a typewriter effect.
    
    ## Typewriter Effect
    
    See [Typewriter](assets/text-animations-typewriter.tsx) for an advanced example with a blinking cursor and a pause after the first sentence.
    
    Always use string slicing for typewriter effects. Never use per-character opacity.
    
    ## Word Highlighting
    
    See [Word Highlight](assets/text-animations-word-highlight.tsx) for an example for how a word highlight is animated, like with a highlighter pen.
    
  • skills/remotion-motion-graphics/references/remotion-rules/timing.md4.4 KBb4a3231251f4upstream ↗
    ---
    name: timing
    description: Interpolation and timing in Remotion—prefer interpolate with Bézier easing; springs as a specialized option
    metadata:
      tags: easing, bezier, interpolation, spring, timing
    ---
    
    Drive motion with `interpolate()` over explicit frame range. To customize timing, use **`Easing.bezier`**. The four parameters are the same as CSS `cubic-bezier(x1, y1, x2, y2)`.
    
    A simple linear interpolation is done using the `interpolate` function.
    
    ```ts title="Going from 0 to 1 over 100 frames"
    import { interpolate } from "remotion";
    
    const opacity = interpolate(frame, [0, 100], [0, 1]);
    ```
    
    By default, the values are not clamped, so the value can go outside the range [0, 1].  
    Here is how they can be clamped:
    
    ```ts title="Going from 0 to 1 over 100 frames with extrapolation"
    const opacity = interpolate(frame, [0, 100], [0, 1], {
      extrapolateRight: "clamp",
      extrapolateLeft: "clamp",
    });
    ```
    
    ## Bézier easing
    
    Use `Easing.bezier(x1, y1, x2, y2)` inside the `interpolate` options object. The curve is identical in spirit to CSS animations and transitions, which helps when you are stealing timing from the web or from a designer’s spec.
    
    ```ts
    import { interpolate, Easing } from "remotion";
    
    const opacity = interpolate(frame, [0, 60], [0, 1], {
      easing: Easing.bezier(0.16, 1, 0.3, 1),
      extrapolateLeft: "clamp",
      extrapolateRight: "clamp",
    });
    ```
    
    ### Examples (copy-paste curves)
    
    **1. Crisp UI entrance (strong ease-out, no overshoot)** — slows nicely into the rest value; similar to many system “deceleration” curves.
    
    ```tsx
    const enter = interpolate(frame, [0, 45], [0, 1], {
      easing: Easing.bezier(0.16, 1, 0.3, 1),
      extrapolateLeft: "clamp",
      extrapolateRight: "clamp",
    });
    ```
    
    **2. Editorial / slow fade (balanced ease-in-out)** — symmetric acceleration and deceleration over a hold-friendly move.
    
    ```tsx
    const progress = interpolate(frame, [0, 90], [0, 1], {
      easing: Easing.bezier(0.45, 0, 0.55, 1),
      extrapolateLeft: "clamp",
      extrapolateRight: "clamp",
    });
    ```
    
    **3. Playful overshoot (control point y > 1)** — a little past the target then settles; use sparingly for emphasis.
    
    ```tsx
    const pop = interpolate(frame, [0, 30], [0, 1], {
      easing: Easing.bezier(0.34, 1.56, 0.64, 1),
      extrapolateLeft: "clamp",
      extrapolateRight: "clamp",
    });
    ```
    
    ## Preset easings (`Easing.in` / `Easing.out` / named curves)
    
    Easing can be added to the `interpolate` function without a custom cubic:
    
    ```ts
    import { interpolate, Easing } from "remotion";
    
    const value1 = interpolate(frame, [0, 100], [0, 1], {
      easing: Easing.inOut(Easing.cubic),
      extrapolateLeft: "clamp",
      extrapolateRight: "clamp",
    });
    ```
    
    The default easing is `Easing.linear`.  
    Convexities:
    
    - `Easing.in` — starting slow and accelerating
    - `Easing.out` — starting fast and slowing down
    - `Easing.inOut`
    
    Named curves (from most linear to most curved):
    
    - `Easing.quad`
    - `Easing.cubic` (good default when you do not need a custom cubic)
    - `Easing.sin`
    - `Easing.exp`
    - `Easing.circle`
    
    ### Easing direction for enter/exit animations
    
    Use `Easing.out` for enter animations (starts fast, decelerates into place) and `Easing.in` for exit animations (starts slow, accelerates away). This feels natural because elements arrive with momentum and leave with gravity. When you need a specific curve from design, prefer a single `Easing.bezier(...)` instead of stacking presets.
    
    ## Composing interpolations
    
    When multiple properties share the same timing (e.g. a slide-in panel and a video shift), avoid duplicating the full interpolation for each property. Instead, create a single normalized progress value (0 to 1) and derive each property from it:
    
    ```tsx
    const slideIn = interpolate(
      frame,
      [slideInStart, slideInStart + slideInDuration],
      [0, 1],
      {
        easing: Easing.bezier(0.22, 1, 0.36, 1),
        extrapolateLeft: "clamp",
        extrapolateRight: "clamp",
      },
    );
    const slideOut = interpolate(
      frame,
      [slideOutStart, slideOutStart + slideOutDuration],
      [0, 1],
      { easing: Easing.in(Easing.cubic), extrapolateLeft: "clamp", extrapolateRight: "clamp" },
    );
    const progress = slideIn - slideOut;
    
    // Derive multiple properties from the same progress
    const overlayX = interpolate(progress, [0, 1], [100, 0]);
    const videoX = interpolate(progress, [0, 1], [0, -20]);
    const opacity = interpolate(progress, [0, 1], [0, 1]);
    ```
    
    The key idea: separate **timing** (when and how fast) from **mapping** (what values to animate between).
    
  • skills/remotion-motion-graphics/references/remotion-rules/transitions.md5.7 KB91ef8bd85920upstream ↗
    ---
    name: transitions
    description: Scene transitions and overlays for Remotion using TransitionSeries.
    metadata:
      tags: transitions, overlays, fade, slide, wipe, scenes
    ---
    
    ## TransitionSeries
    
    `<TransitionSeries>` arranges scenes and supports two ways to enhance the cut point between them:
    
    - **Transitions** (`<TransitionSeries.Transition>`) — crossfade, slide, wipe, etc. between two scenes. Shortens the timeline because both scenes play simultaneously during the transition.
    - **Overlays** (`<TransitionSeries.Overlay>`) — render an effect (e.g. a light leak) on top of the cut point without shortening the timeline.
    
    Children are absolutely positioned.
    
    ## Prerequisites
    
    ```bash
    npx remotion add @remotion/transitions
    ```
    
    ## Transition example
    
    ```tsx
    import { TransitionSeries, linearTiming } from "@remotion/transitions";
    import { fade } from "@remotion/transitions/fade";
    
    <TransitionSeries>
      <TransitionSeries.Sequence durationInFrames={60}>
        <SceneA />
      </TransitionSeries.Sequence>
      <TransitionSeries.Transition
        presentation={fade()}
        timing={linearTiming({ durationInFrames: 15 })}
      />
      <TransitionSeries.Sequence durationInFrames={60}>
        <SceneB />
      </TransitionSeries.Sequence>
    </TransitionSeries>;
    ```
    
    ## Overlay example
    
    Any React component can be used as an overlay. For a ready-made effect, see the **light-leaks** rule.
    
    ```tsx
    import { TransitionSeries } from "@remotion/transitions";
    import { LightLeak } from "@remotion/light-leaks";
    
    <TransitionSeries>
      <TransitionSeries.Sequence durationInFrames={60}>
        <SceneA />
      </TransitionSeries.Sequence>
      <TransitionSeries.Overlay durationInFrames={20}>
        <LightLeak />
      </TransitionSeries.Overlay>
      <TransitionSeries.Sequence durationInFrames={60}>
        <SceneB />
      </TransitionSeries.Sequence>
    </TransitionSeries>;
    ```
    
    ## Mixing transitions and overlays
    
    Transitions and overlays can coexist in the same `<TransitionSeries>`, but an overlay cannot be adjacent to a transition or another overlay.
    
    ```tsx
    import { TransitionSeries, linearTiming } from "@remotion/transitions";
    import { fade } from "@remotion/transitions/fade";
    import { LightLeak } from "@remotion/light-leaks";
    
    <TransitionSeries>
      <TransitionSeries.Sequence durationInFrames={60}>
        <SceneA />
      </TransitionSeries.Sequence>
      <TransitionSeries.Overlay durationInFrames={30}>
        <LightLeak />
      </TransitionSeries.Overlay>
      <TransitionSeries.Sequence durationInFrames={60}>
        <SceneB />
      </TransitionSeries.Sequence>
      <TransitionSeries.Transition
        presentation={fade()}
        timing={linearTiming({ durationInFrames: 15 })}
      />
      <TransitionSeries.Sequence durationInFrames={60}>
        <SceneC />
      </TransitionSeries.Sequence>
    </TransitionSeries>;
    ```
    
    ## Transition props
    
    `<TransitionSeries.Transition>` requires:
    
    - `presentation` — the visual effect (e.g. `fade()`, `slide()`, `wipe()`).
    - `timing` — controls speed and easing (e.g. `linearTiming()`, `springTiming()`).
    
    ## Overlay props
    
    `<TransitionSeries.Overlay>` accepts:
    
    - `durationInFrames` — how long the overlay is visible (positive integer).
    - `offset?` — shifts the overlay relative to the cut point center. Positive = later, negative = earlier. Default: `0`.
    
    ## Available transition types
    
    Import transitions from their respective modules:
    
    ```tsx
    import { fade } from "@remotion/transitions/fade";
    import { slide } from "@remotion/transitions/slide";
    import { wipe } from "@remotion/transitions/wipe";
    import { flip } from "@remotion/transitions/flip";
    import { clockWipe } from "@remotion/transitions/clock-wipe";
    ```
    
    ## Slide transition with direction
    
    ```tsx
    import { slide } from "@remotion/transitions/slide";
    
    <TransitionSeries.Transition
      presentation={slide({ direction: "from-left" })}
      timing={linearTiming({ durationInFrames: 20 })}
    />;
    ```
    
    Directions: `"from-left"`, `"from-right"`, `"from-top"`, `"from-bottom"`
    
    ## Timing options
    
    ```tsx
    import { linearTiming, springTiming } from "@remotion/transitions";
    
    // Linear timing - constant speed
    linearTiming({ durationInFrames: 20 });
    
    // Spring timing - organic motion
    springTiming({ config: { damping: 200 }, durationInFrames: 25 });
    ```
    
    ## Duration calculation
    
    Transitions overlap adjacent scenes, so the total composition length is **shorter** than the sum of all sequence durations. Overlays do **not** affect the total duration.
    
    For example, with two 60-frame sequences and a 15-frame transition:
    
    - Without transitions: `60 + 60 = 120` frames
    - With transition: `60 + 60 - 15 = 105` frames
    
    Adding an overlay between two other sequences does not change the total.
    
    ### Getting the duration of a transition
    
    Use the `getDurationInFrames()` method on the timing object:
    
    ```tsx
    import { linearTiming, springTiming } from "@remotion/transitions";
    
    const linearDuration = linearTiming({
      durationInFrames: 20,
    }).getDurationInFrames({ fps: 30 });
    // Returns 20
    
    const springDuration = springTiming({
      config: { damping: 200 },
    }).getDurationInFrames({ fps: 30 });
    // Returns calculated duration based on spring physics
    ```
    
    For `springTiming` without an explicit `durationInFrames`, the duration depends on `fps` because it calculates when the spring animation settles.
    
    ### Calculating total composition duration
    
    ```tsx
    import { linearTiming } from "@remotion/transitions";
    
    const scene1Duration = 60;
    const scene2Duration = 60;
    const scene3Duration = 60;
    
    const timing1 = linearTiming({ durationInFrames: 15 });
    const timing2 = linearTiming({ durationInFrames: 20 });
    
    const transition1Duration = timing1.getDurationInFrames({ fps: 30 });
    const transition2Duration = timing2.getDurationInFrames({ fps: 30 });
    
    const totalDuration =
      scene1Duration +
      scene2Duration +
      scene3Duration -
      transition1Duration -
      transition2Duration;
    // 60 + 60 + 60 - 15 - 20 = 145 frames
    ```
    
  • skills/remotion-motion-graphics/references/remotion-rules/videos.md3.4 KB4d99b31eab0bupstream ↗
    ---
    name: videos
    description: Embedding videos in Remotion - trimming, volume, speed, looping, pitch
    metadata:
      tags: video, media, trim, volume, speed, loop, pitch
    ---
    
    # Using videos in Remotion
    
    ## Prerequisites
    
    First, the @remotion/media package needs to be installed.  
    If it is not, use the following command:
    
    ```bash
    npx remotion add @remotion/media # If project uses npm
    bunx remotion add @remotion/media # If project uses bun
    yarn remotion add @remotion/media # If project uses yarn
    pnpm exec remotion add @remotion/media # If project uses pnpm
    ```
    
    Use `<Video>` from `@remotion/media` to embed videos into your composition.
    
    ```tsx
    import { Video } from "@remotion/media";
    import { staticFile } from "remotion";
    
    export const MyComposition = () => {
      return <Video src={staticFile("video.mp4")} />;
    };
    ```
    
    Remote URLs are also supported:
    
    ```tsx
    <Video src="https://remotion.media/video.mp4" />
    ```
    
    ## Trimming
    
    Use `trimBefore` and `trimAfter` to remove portions of the video. Values are in seconds.
    
    ```tsx
    const { fps } = useVideoConfig();
    
    return (
      <Video
        src={staticFile("video.mp4")}
        trimBefore={2 * fps} // Skip the first 2 seconds
        trimAfter={10 * fps} // End at the 10 second mark
      />
    );
    ```
    
    ## Delaying
    
    Wrap the video in a `<Sequence>` to delay when it appears:
    
    ```tsx
    import { Sequence, staticFile } from "remotion";
    import { Video } from "@remotion/media";
    
    const { fps } = useVideoConfig();
    
    return (
      <Sequence from={1 * fps}>
        <Video src={staticFile("video.mp4")} />
      </Sequence>
    );
    ```
    
    The video will appear after 1 second.
    
    ## Sizing and Position
    
    Use the `style` prop to control size and position:
    
    ```tsx
    <Video
      src={staticFile("video.mp4")}
      style={{
        width: 500,
        height: 300,
        position: "absolute",
        top: 100,
        left: 50,
        objectFit: "cover",
      }}
    />
    ```
    
    ## Volume
    
    Set a static volume (0 to 1):
    
    ```tsx
    <Video src={staticFile("video.mp4")} volume={0.5} />
    ```
    
    Or use a callback for dynamic volume based on the current frame:
    
    ```tsx
    import { interpolate } from "remotion";
    
    const { fps } = useVideoConfig();
    
    return (
      <Video
        src={staticFile("video.mp4")}
        volume={(f) =>
          interpolate(f, [0, 1 * fps], [0, 1], { extrapolateRight: "clamp" })
        }
      />
    );
    ```
    
    Use `muted` to silence the video entirely:
    
    ```tsx
    <Video src={staticFile("video.mp4")} muted />
    ```
    
    ## Speed
    
    Use `playbackRate` to change the playback speed:
    
    ```tsx
    <Video src={staticFile("video.mp4")} playbackRate={2} /> {/* 2x speed */}
    <Video src={staticFile("video.mp4")} playbackRate={0.5} /> {/* Half speed */}
    ```
    
    Reverse playback is not supported.
    
    ## Looping
    
    Use `loop` to loop the video indefinitely:
    
    ```tsx
    <Video src={staticFile("video.mp4")} loop />
    ```
    
    Use `loopVolumeCurveBehavior` to control how the frame count behaves when looping:
    
    - `"repeat"`: Frame count resets to 0 each loop (for `volume` callback)
    - `"extend"`: Frame count continues incrementing
    
    ```tsx
    <Video
      src={staticFile("video.mp4")}
      loop
      loopVolumeCurveBehavior="extend"
      volume={(f) => interpolate(f, [0, 300], [1, 0])} // Fade out over multiple loops
    />
    ```
    
    ## Pitch
    
    Use `toneFrequency` to adjust the pitch without affecting speed. Values range from 0.01 to 2:
    
    ```tsx
    <Video
      src={staticFile("video.mp4")}
      toneFrequency={1.5} // Higher pitch
    />
    <Video
      src={staticFile("video.mp4")}
      toneFrequency={0.8} // Lower pitch
    />
    ```
    
    Pitch shifting only works during server-side rendering, not in the Remotion Studio preview or in the `<Player />`.
    
  • skills/remotion-motion-graphics/references/scene-patterns.md7.2 KBad8c0e190289upstream ↗
    # Motion pattern catalogue
    
    Building blocks that make a kinetic-typography / brand promo feel designed.
    Each pattern names the effect, when it earns its place, and the code shape.
    Everything uses `frame = useCurrentFrame()`, `prog()` / `springAt()` from
    `anim.ts`, and positions from `useLayout()`. Combine 10-15 of these at
    1-4 seconds each for a 30-second piece; alternate light and dark backgrounds
    so hard cuts read as deliberate.
    
    ## Contents
    1. Word-by-word reveal (`<Words>`)
    2. Phrase swap in a sentence
    3. Pill that morphs into a button, cursor click
    4. Objects flying into a collage
    5. Circle wipe carrying text
    6. Ticker + panel wipe + marquee bar
    7. Shape that shrinks into the next scene's element
    8. Route / line drawing on a map
    9. Product-UI moment (typewriter, toggle, radios, dot cursor)
    10. Gradient statement text with a swap
    11. Character bounce + wordmark letters popping
    12. Scrolling bubble rows with one highlighted
    13. Card with a growing chart
    14. Spotlight beam
    15. Burst of chips collapsing into the final lockup
    16. Fade to black
    
    ---
    
    ## 1. Word-by-word reveal
    Every headline lands one word at a time (5-7 frame stagger, 12-14 frame
    rise + fade + 3px blur that clears). Use `<Words text start stagger dur out>`;
    give `out` when the line must leave before the next arrives.
    
    ## 2. Phrase swap in a sentence
    "Want ⚡ to learn faster? / to grow further? / to stop guessing?" — the fixed
    words stay put, the variable phrase cycles. Stack all phrases absolutely at the
    same spot and give each an `IN[i]` / `OUT[i]` window (about 40-50 frames per
    phrase). Exits accelerate up and fade (EASE_IN); entrances rise (EASE_OUT).
    Keep fixed text right-aligned to a fixed x and the phrase left-aligned to it
    so the layout never reflows when word widths change.
    
    ## 3. Pill → button → click
    A small white pill (emoji inside) springs into the sentence
    (`springAt(frame,fps,30,{damping:14,stiffness:140})`, width = 92 × p). At the
    scene end the sentence fades and the pill eases to centre. Next scene: the pill
    grows (`lerp(92,360,prog(frame,0,14))`), the emoji fades, a label types in
    (`typed(text, frame, 6, 40, fps)`), a cursor springs to it and "presses"
    (scale 0.96 for 5 frames), then the button fades out. Cursor moves are chained
    springs so it never teleports:
    ```ts
    const c1 = springAt(frame, fps, 8, { damping: 16, stiffness: 80 });
    const c2 = springAt(frame, fps, 34, { damping: 16, stiffness: 80 });
    const x = lerp(lerp(x0, x1, c1), x2, c2);
    ```
    
    ## 4. Objects flying into a collage
    Cards / photos start off-screen on all sides with ±30° rotation and spring to
    scattered resting spots (`damping: 17, stiffness: 95`, 3-frame stagger), a
    bold white line lands on top with a dark text-shadow. Define resting and start
    positions as fractions of W/H, with a separate set for landscape.
    
    ## 5. Circle wipe carrying text
    A black circle grows from centre to `diag × 1.25` over 20 frames (EASE_INOUT).
    Text sits at the circle's centre (`left:50%; top:50%; translate(-50%,-50%)`) so
    it stays fixed while the circle grows; second line appears after the wipe
    completes, first line lifts 44px to make room. Do not add a full-frame overlay
    "to tidy the edges" — the circle already covers the frame and the overlay hides
    the text.
    
    ## 6. Ticker + panel wipe + marquee bar
    A line translates across at constant speed (`interpolate(frame,[0,41],[W*0.48,-W*0.48])`).
    Mid-way a white panel slides in diagonally from the top-right
    (`translate((1-p)*W, -(1-p)*H*0.55)`), carrying a black bar with a very wide
    blue pill whose text scrolls left 26px/frame. Two motions at once give energy
    without a cut.
    
    ## 7. Shape that becomes the next element
    Grey card, a blue pill with a word → text fades, pill shrinks to a circle,
    background darkens (`interpolateColors`), circle travels to exactly where the
    next scene's marker sits. Export the marker position from a shared helper
    (`markerPos()` in layout.ts) so both scenes agree.
    
    ## 8. Route drawing
    `<path pathLength={1} strokeDasharray={1} strokeDashoffset={1 - draw} />` with
    `draw = prog(frame, 0, 45, EASE_INOUT)`. Define the path in fractions of W/H so
    it survives both orientations. Add a pulsing halo (`sin` on scale/opacity), a
    marker, a tooltip that types two lines, and a slow 10% zoom on the whole map
    with `transformOrigin` at the marker.
    
    ## 9. Product-UI moment
    Typewriter headline + body (`typed()` with `whiteSpace: "pre-line"`), a toggle
    whose knob slides with a spring and whose track alpha follows the same value,
    radio dots that change on a click, and a black dot cursor with chained springs
    that presses on the toggle then the radio. Lay the group out as a fixed 900px
    block centred with `gx = cx - 450; gy = cy - 240`.
    
    ## 10. Gradient statement text
    Two lines stacked at the same spot; each has `background: linear-gradient(...)`,
    `WebkitBackgroundClip: "text"`, `color: "transparent"`. Line 1 scales
    0.94→1 and fades in, exits up (EASE_IN); line 2 rises in 4 frames later. A
    radial glow behind grows from 0 over 40 frames.
    
    ## 11. Character bounce + wordmark letters popping
    Use `SvgArt` with `parts: { body: { indices, origin: "50% 100%", style: characterStyle({ entrance: 4, bobAmp: 55, period: 36, tilt: 2.5 }) }, letters: { indices, popEach: { start: 12, stagger: 2 } } }`.
    Bob amplitude is in viewBox units (50-60 on a 4096 canvas). Order letter
    indices along the arc (sort by angle around a point below the arc) so they pop
    in reading order. Add `fadeLeft` when the artwork is cropped at the canvas
    edge.
    
    ## 12. Scrolling bubble rows
    6-7 rows of dark rounded pills (random widths via `random(seed)`), alternating
    direction and speed, one fixed pill with a blue border and glow that types a
    short line. Portrait: rows start at ~17% height; landscape: start above the
    frame so rows fill it.
    
    ## 13. Card with a growing chart
    Sample 48 points of a rising noisy function into a polyline; reveal with a
    `<clipPath>` rect whose width = head.x; put a white dot at the interpolated
    head point; area fill under the line with a vertical brand gradient. Card
    scales 0.9→1 and drifts a few px over the scene.
    
    ## 14. Spotlight beam
    Two stacked cones (wide soft + narrow bright). Put `filter: blur()` on the
    wrapper and `clipPath: polygon(...)` on the inner div — CSS applies filter
    before clip-path, so blurring a clipped element gives hard edges. Sway with
    `rotate(sin(frame/15)*2.5deg)` from `transformOrigin: "50% 0%"`.
    
    ## 15. Burst → lockup
    18 chips start on a ring (radius 700-1200, seeded angle), rush to centre with
    EASE_IN over 16 frames while blurring (`blur((1-p)*6px)`) and fading; the logo
    springs in with `damping: 11-12` (visible bounce) as they vanish; letters pop;
    tagline rises; URL pill springs; feature chips stagger 4 frames apart.
    Landscape: logo left, copy right; portrait: logo above copy.
    
    ## 16. Fade to black
    Full-frame ink overlay `opacity: prog(frame, T-14, 14, EASE_IN)` in the last
    scene. Always end on a resting frame (nothing still moving).
    
    ---
    
    ## Timing that felt right (30 fps)
    - Hook with 3 phrase swaps: 135 frames. Button + collage: 75. Wipe + line: 45.
    - Ticker/panel: 41. Shape hand-off: 19. Map: 105. UI: 105. Statement: 75.
    - Character: 60. Bubbles: 60. Chart: 45. Character 2: 75. Spotlight: 45.
    - Closing line: 51. Burst + lockup + fade: 84. Total ≈ 1020 (34 s).
    Cut faster than feels comfortable in code; it plays slower than it reads.
    
  • skills/remotion-motion-graphics/references/verification-and-gotchas.md3.3 KB2c1587d14cacupstream ↗
    # Verification loop and gotchas
    
    ## The loop (do it every time, it costs a minute)
    1. `npx tsc --noEmit` — catches prop and import mistakes before Chrome does.
    2. `scripts/check_render.sh <CompId> <out_dir>` — 0.3-scale MP4 + contact
       sheets. View every sheet. Look for: empty frames (a scene crashed or an
       overlay hides content), text under artwork, elements off the safe zone,
       things still moving on the last frame of a scene, colour jumps at cuts.
    3. For a suspicious moment, render one still at 0.5:
       `npx remotion still <CompId> out/f200.png --frame=200 --scale=0.5`
       or grab a frame from the preview with `scripts/still_frame.sh`.
    4. Fix, re-run 1-2 only for changed scenes if you can (a still is enough for a
       local fix), full check again before the final render.
    5. Final: `npx remotion render <CompId> out/final.mp4 --codec=h264 --crf=18`
       (1020 frames at 1080x1920 renders in ~30 s on an M-series Mac).
    6. Extract one or two frames from the FINAL file too — the final render is the
       thing being shipped, not the preview.
    
    ## Gotchas met in practice
    - **Overlay hides content.** A "cleanup" full-frame overlay drawn after the
      content covers the text. Check z-order before adding overlays; usually the
      wipe shape already covers the frame.
    - **filter + clip-path order.** CSS applies `filter` before `clip-path`, so a
      blurred cone clipped to a polygon has razor edges. Blur the parent, clip the
      child.
    - **Artwork cropped at the SVG canvas edge** (a character running off the
      page) shows a hard vertical cut on a dark background. Mask the element with
      a gradient that is fully transparent for the first ~4% and opaque by ~17%;
      a 9% fade is too weak to hide the cut.
    - **Gradient fills in exported SVGs** (`fill="url(#gradient_1)"`) render
      black without their `<defs>`. `svg_to_paths.mjs` swaps them for the first
      stop colour.
    - **Per-path transforms in inline SVG** need `transformBox: "fill-box"` plus
      `transformOrigin`, otherwise scale/rotate pivots on the canvas origin.
    - **`pathLength={1}`** normalises stroke dash math so `strokeDashoffset = 1 - p`
      draws any path regardless of its true length.
    - **`interpolate` input ranges must strictly increase** — duplicate stops crash
      the frame.
    - **Negative-frame springs**: guard with `frame <= start ? 0 : spring(...)`
      (`springAt` does) so look-behind sampling for cursor trails is safe.
    - **Bob amplitude inside an SVG is in viewBox units**, not screen px (50 units
      on a 4096 canvas ≈ 10 px at 840 px wide).
    - **Shell env vars into node**: `export S=...` before `node -e '...process.env.S'`;
      unexported vars come through as `undefined` paths.
    - **rsvg-convert / qlmanage are unreliable** for SVG previews on macOS; verify
      artwork splits with a Remotion still instead — Chrome is the renderer that
      matters.
    - **Emoji** render fine in Remotion's Chrome on macOS (Apple Color Emoji);
      on Linux CI install a colour emoji font or replace them with SVG icons.
    - **Landscape from portrait**: do not letterbox. Derive positions from
      `useLayout()`, keep a 1.2 design scale for 16:9, and give tall artwork a
      side-by-side branch (`wide ? {...} : {...}`). Re-check the portrait sheet
      after the refactor to prove nothing moved.
    - **Deliver the file**: copy the MP4 next to the user's source material and
      send it with the file tool; a path in a message is easy to miss.
    
  • skills/remotion-motion-graphics/assets/anim.ts1.7 KBfa078419db1eupstream ↗
    import { Easing, interpolate, spring } from "remotion";
    
    // Copy-paste curves from the Remotion best-practices rules.
    export const EASE_OUT = Easing.bezier(0.16, 1, 0.3, 1); // crisp UI entrance
    export const EASE_IN = Easing.bezier(0.7, 0, 0.84, 0); // exits accelerate away
    export const EASE_INOUT = Easing.bezier(0.65, 0, 0.35, 1);
    export const POP = Easing.bezier(0.34, 1.56, 0.64, 1); // playful overshoot
    
    // Normalised 0..1 progress over [start, start+dur] with an easing.
    export const prog = (
      frame: number,
      start: number,
      dur: number,
      easing: (t: number) => number = EASE_OUT,
    ) =>
      interpolate(frame, [start, start + dur], [0, 1], {
        easing,
        extrapolateLeft: "clamp",
        extrapolateRight: "clamp",
      });
    
    type SpringOpts = {
      damping?: number;
      mass?: number;
      stiffness?: number;
      durationInFrames?: number;
    };
    
    // Spring progress guarded for negative frames (safe for look-behind sampling).
    export const springAt = (
      frame: number,
      fps: number,
      start: number,
      opts: SpringOpts = {},
    ): number => {
      if (frame <= start) return 0;
      const { durationInFrames, ...config } = opts;
      return spring({
        frame: frame - start,
        fps,
        durationInFrames,
        config: { damping: 200, ...config },
      });
    };
    
    export const riseStyle = (
      p: number,
      dy = 40,
      dx = 0,
    ): React.CSSProperties => ({
      opacity: p,
      transform: `translate(${(1 - p) * dx}px, ${(1 - p) * dy}px)`,
    });
    
    // Typewriter by string slicing (never per-character opacity).
    export const typed = (
      text: string,
      frame: number,
      start: number,
      cps: number,
      fps: number,
    ) => text.slice(0, Math.max(0, Math.floor(((frame - start) * cps) / fps)));
    
    export const clamp01 = (v: number) => Math.min(1, Math.max(0, v));
    
  • skills/remotion-motion-graphics/assets/components/Backgrounds.tsx1.3 KB9090314ea98fupstream ↗
    import { AbsoluteFill } from "remotion";
    import { C, hexToRgba } from "../theme";
    
    // Light backdrop: white top fading into a soft brand glow at the bottom
    // (the reference used lavender; hundredable's brand yellow takes its place).
    export const LightBg: React.FC<{
      glow?: number; // 0..1.2
      color?: string;
      y?: number; // glow center y in %
    }> = ({ glow = 1, color = C.yellow, y = 100 }) => (
      <AbsoluteFill style={{ backgroundColor: C.lightBase }}>
        <AbsoluteFill
          style={{
            background: `radial-gradient(ellipse 85% 55% at 50% ${y}%, ${hexToRgba(
              color,
              0.5 * glow,
            )} 0%, ${hexToRgba(color, 0)} 72%)`,
          }}
        />
        <AbsoluteFill
          style={{
            background:
              "linear-gradient(180deg, #FFFFFF 0%, rgba(255,255,255,0) 40%)",
          }}
        />
      </AbsoluteFill>
    );
    
    export const DarkBg: React.FC<{
      glow?: number; // 0..0.5
      color?: string;
      x?: number;
      y?: number;
      size?: number;
    }> = ({ glow = 0, color = C.yellow, x = 50, y = 60, size = 60 }) => (
      <AbsoluteFill style={{ backgroundColor: C.dark }}>
        {glow > 0 && (
          <AbsoluteFill
            style={{
              background: `radial-gradient(circle at ${x}% ${y}%, ${hexToRgba(
                color,
                glow,
              )} 0%, rgba(0,0,0,0) ${size}%)`,
            }}
          />
        )}
      </AbsoluteFill>
    );
    
  • skills/remotion-motion-graphics/assets/components/Cursors.tsx1.3 KB93d2b856bcbeupstream ↗
    import { C } from "../theme";
    
    type Pt = { x: number; y: number };
    
    // macOS-style pointer arrow (used in the light scenes of the reference).
    export const ArrowCursor: React.FC<{
      pos: Pt;
      color?: string;
      pressed?: boolean;
      opacity?: number;
      size?: number;
    }> = ({ pos, color = C.blue, pressed, opacity = 1, size = 46 }) => (
      <svg
        viewBox="0 0 24 24"
        width={size}
        height={size}
        style={{
          position: "absolute",
          left: pos.x,
          top: pos.y,
          opacity,
          transform: `scale(${pressed ? 0.86 : 1})`,
          transformOrigin: "22% 12%",
          filter: "drop-shadow(0 6px 10px rgba(0,0,0,0.25))",
        }}
      >
        <path
          d="M5.5 3.2 L5.5 20.5 L9.8 16.6 L12.6 22.6 L15.6 21.2 L12.9 15.3 L18.6 15.3 Z"
          fill={color}
          stroke="#FFFFFF"
          strokeWidth={1.6}
          strokeLinejoin="round"
        />
      </svg>
    );
    
    // Black dot cursor (used in the UI scene of the reference).
    export const DotCursor: React.FC<{
      pos: Pt;
      pressed?: boolean;
      opacity?: number;
    }> = ({ pos, pressed, opacity = 1 }) => (
      <div
        style={{
          position: "absolute",
          left: pos.x - 12,
          top: pos.y - 12,
          width: 24,
          height: 24,
          borderRadius: "50%",
          background: C.ink,
          opacity,
          transform: `scale(${pressed ? 0.75 : 1})`,
          boxShadow: "0 6px 16px rgba(0,0,0,0.35)",
        }}
      />
    );
    
  • skills/remotion-motion-graphics/assets/components/SvgArt.tsx4.2 KB234d8e06ee31upstream ↗
    // Renders SVG artwork (a logo, mascot, icon) straight from path data produced
    // by scripts/svg_to_paths.mjs, so any subset of paths can be animated on its
    // own: letters popping in one by one, a character bobbing, a part rotating.
    // Copy to src/components/SvgArt.tsx.
    import { useCurrentFrame, useVideoConfig } from "remotion";
    import { springAt } from "../anim";
    
    export type SvgPath = { d: string; fill: string; box: [number, number, number, number] };
    export type SvgData = { box: [number, number, number, number]; paths: SvgPath[] };
    
    export const unionBox = (paths: SvgPath[]): [number, number, number, number] => [
      Math.min(...paths.map((p) => p.box[0])),
      Math.min(...paths.map((p) => p.box[1])),
      Math.max(...paths.map((p) => p.box[2])),
      Math.max(...paths.map((p) => p.box[3])),
    ];
    
    // A part = a named group of path indices with its own animation.
    export type Part = {
      indices: number[];
      // Return CSS for the group at this frame. transform-box is fill-box, so
      // scale()/rotate() pivot on the group's own centre (or `origin`).
      style?: (frame: number, fps: number) => React.CSSProperties;
      origin?: string; // e.g. "50% 100%" to pivot on the feet
      // Stagger helper: pop each path in the part individually.
      popEach?: { start: number; stagger: number; damping?: number; stiffness?: number };
    };
    
    export const SvgArt: React.FC<{
      data: SvgData;
      width: number;
      parts?: Record<string, Part>;
      crop?: number[]; // path indices to fit the viewBox to (default: all)
      pad?: number;
      fadeLeft?: boolean; // soften artwork cropped at the canvas edge
      style?: React.CSSProperties;
    }> = ({ data, width, parts = {}, crop, pad = 80, fadeLeft, style }) => {
      const frame = useCurrentFrame();
      const { fps } = useVideoConfig();
      const box = crop ? unionBox(crop.map((i) => data.paths[i])) : data.box;
      const vb = [box[0] - pad, box[1] - pad, box[2] - box[0] + pad * 2, box[3] - box[1] + pad * 2];
      const height = (width * vb[3]) / vb[2];
      const assigned = new Set(Object.values(parts).flatMap((p) => p.indices));
      const mask = fadeLeft
        ? "linear-gradient(90deg, rgba(0,0,0,0) 0%, rgba(0,0,0,0) 4.5%, rgba(0,0,0,1) 17%, rgba(0,0,0,1) 100%)"
        : undefined;
    
      return (
        <svg
          viewBox={vb.join(" ")}
          width={width}
          height={height}
          style={{ overflow: "visible", WebkitMaskImage: mask, maskImage: mask, WebkitMaskSize: "100% 100%", maskSize: "100% 100%", ...style }}
        >
          {/* static paths */}
          {data.paths.map((p, i) => (assigned.has(i) ? null : <path key={i} d={p.d} fill={p.fill} />))}
          {/* animated parts */}
          {Object.entries(parts).map(([name, part]) => {
            if (part.popEach) {
              const { start, stagger, damping = 10, stiffness = 170 } = part.popEach;
              return part.indices.map((i, k) => {
                const p = springAt(frame, fps, start + k * stagger, { damping, stiffness });
                return (
                  <g key={`${name}-${i}`} style={{ transformBox: "fill-box", transformOrigin: "center", transform: `scale(${p})`, opacity: Math.max(0, Math.min(1, p * 1.5)) }}>
                    <path d={data.paths[i].d} fill={data.paths[i].fill} />
                  </g>
                );
              });
            }
            return (
              <g key={name} style={{ transformBox: "fill-box", transformOrigin: part.origin ?? "center", ...(part.style ? part.style(frame, fps) : {}) }}>
                {part.indices.map((i) => (
                  <path key={i} d={data.paths[i].d} fill={data.paths[i].fill} />
                ))}
              </g>
            );
          })}
        </svg>
      );
    };
    
    // Ready-made character motion: spring in from below, then bob + sway.
    export const characterStyle =
      (opts: { entrance?: number | null; bobAmp?: number; period?: number; tilt?: number }) =>
      (frame: number, fps: number): React.CSSProperties => {
        const { entrance = 0, bobAmp = 50, period = 40, tilt = 2.5 } = opts;
        const ent = entrance === null ? 1 : springAt(frame, fps, entrance, { damping: 12, stiffness: 110, mass: 0.9 });
        const bob = Math.sin((frame / period) * Math.PI * 2) * bobAmp;
        const rot = Math.sin((frame / period) * Math.PI * 2 + 1.2) * tilt;
        return {
          transform: `translateY(${bob}px) rotate(${rot}deg) translateY(${(1 - ent) * 60}%) scale(${0.7 + 0.3 * ent})`,
          opacity: Math.max(0, Math.min(1, ent * 2)),
        };
      };
    
  • skills/remotion-motion-graphics/assets/components/Words.tsx1.4 KB2372642c99eaupstream ↗
    import { useCurrentFrame } from "remotion";
    import { EASE_IN, EASE_OUT, prog } from "../anim";
    
    // Word-by-word reveal (rise + fade), optional exit. Mirrors the kinetic type
    // in the reference video where each word lands a few frames after the last.
    export const Words: React.FC<{
      text: string;
      start: number;
      stagger?: number;
      dur?: number;
      out?: { start: number; dur?: number };
      style?: React.CSSProperties;
      wordStyle?: (word: string, i: number) => React.CSSProperties;
      dy?: number;
    }> = ({ text, start, stagger = 5, dur = 14, out, style, wordStyle, dy = 22 }) => {
      const frame = useCurrentFrame();
      const words = text.split(" ");
      return (
        <span style={{ display: "inline", ...style }}>
          {words.map((w, i) => {
            const p = prog(frame, start + i * stagger, dur, EASE_OUT);
            const q = out ? prog(frame, out.start + i * 2, out.dur ?? 10, EASE_IN) : 0;
            return (
              <span
                key={i}
                style={{
                  display: "inline-block",
                  whiteSpace: "pre",
                  opacity: p * (1 - q),
                  transform: `translateY(${(1 - p) * dy - q * 36}px)`,
                  filter: p < 1 ? `blur(${(1 - p) * 3}px)` : undefined,
                  ...(wordStyle ? wordStyle(w, i) : {}),
                }}
              >
                {w}
                {i < words.length - 1 ? " " : ""}
              </span>
            );
          })}
        </span>
      );
    };
    
  • skills/remotion-motion-graphics/assets/fonts.ts266 Bbbe844453eaaupstream ↗
    // Copy to src/fonts.ts. Match the brand's font; Inter is the safe default.
    import { loadFont } from "@remotion/google-fonts/Inter";
    
    export const { fontFamily: inter } = loadFont("normal", {
      weights: ["400", "500", "600", "700", "800"],
      subsets: ["latin"],
    });
    
  • skills/remotion-motion-graphics/assets/layout.ts994 B13a172e44a38upstream ↗
    import { useVideoConfig } from "remotion";
    
    // Everything positional derives from the composition size, so the same scenes
    // render the 9:16 (1080x1920) and 16:9 (1920x1080) versions.
    // The wide version is designed at 1600x900 and scaled up 1.2x in <Main> so
    // type and UI read at a comfortable size on a landscape frame.
    export const designScale = (width: number, height: number) => (width > height ? 1.2 : 1);
    
    export const useLayout = () => {
      const { width, height } = useVideoConfig();
      const s = designScale(width, height);
      const W = width / s;
      const H = height / s;
      return { W, H, cx: W / 2, cy: H / 2, wide: W > H, diag: Math.hypot(W, H), scale: s };
    };
    
    export const PILL = { w: 92, h: 60 } as const;
    // vertical centre of the "Want ⚡ ..." row (≈42-44% down the frame)
    export const hookRowY = (cy: number, H: number) => cy - H * 0.083;
    // the map marker the blue pill shrinks into
    export const markerPos = (cx: number, H: number) => ({ x: cx, y: H * 0.615, size: 46 });
    
  • skills/remotion-motion-graphics/assets/Main.template.tsx1.1 KB4154126d5bdfupstream ↗
    // Copy to src/Main.tsx. Arranges scenes in a <Series> (hard cuts, like most
    // kinetic-type promos) inside a design-scale wrapper so one set of scenes
    // serves both 9:16 and 16:9 compositions (see layout.ts).
    import { AbsoluteFill, Series } from "remotion";
    import { inter } from "./fonts";
    import { SCENES } from "./theme";
    import { useLayout } from "./layout";
    import { S01Hook } from "./scenes/S01Hook";
    // ...import the rest of the scenes
    
    const ORDER: [keyof typeof SCENES, React.FC][] = [
      ["hook", S01Hook],
      // ["reveal", S02Reveal], ...
    ];
    
    export const Main: React.FC = () => {
      const { W, H, scale } = useLayout();
      return (
        <AbsoluteFill style={{ fontFamily: inter, backgroundColor: "#0A0A0A", overflow: "hidden" }}>
          <div style={{ position: "absolute", left: 0, top: 0, width: W, height: H, transform: `scale(${scale})`, transformOrigin: "0 0" }}>
            <Series>
              {ORDER.map(([key, Scene]) => (
                <Series.Sequence key={key} durationInFrames={SCENES[key]} premountFor={15}>
                  <Scene />
                </Series.Sequence>
              ))}
            </Series>
          </div>
        </AbsoluteFill>
      );
    };
    
  • skills/remotion-motion-graphics/assets/Root.template.tsx554 B3b430e0333d7upstream ↗
    // Copy to src/Root.tsx. Two compositions, same component.
    import "./index.css";
    import { Composition } from "remotion";
    import { Main } from "./Main";
    import { LANDSCAPE, PORTRAIT, TOTAL } from "./theme";
    
    export const RemotionRoot: React.FC = () => (
      <>
        <Composition id="Promo" component={Main} durationInFrames={TOTAL} fps={PORTRAIT.fps} width={PORTRAIT.width} height={PORTRAIT.height} />
        <Composition id="PromoWide" component={Main} durationInFrames={TOTAL} fps={LANDSCAPE.fps} width={LANDSCAPE.width} height={LANDSCAPE.height} />
      </>
    );
    
  • skills/remotion-motion-graphics/assets/theme.template.ts1.5 KB20cd81c9e8baupstream ↗
    // Brand + timing system. Copy to src/theme.ts and fill the colours from the
    // brand (logo SVG fills, site CSS variables). Keep ONE accent + ink + a light
    // base; motion pieces read best with few colours used consistently.
    export const PORTRAIT = { width: 1080, height: 1920, fps: 30 } as const;
    export const LANDSCAPE = { width: 1920, height: 1080, fps: 30 } as const;
    
    export const C = {
      ink: "#0A0A0A",
      white: "#FFFFFF",
      accent: "#FBF713", // >>> primary brand colour (glows, pills, highlight word)
      accent2: "#0A8CF0", // >>> secondary brand colour (blue text, buttons)
      accentText: "#1C7DE8", // slightly darker accent2 for text on light
      lightBase: "#FCFBF6", // near-white light background
      gray: "#B8B8B8",
      dark: "#070707",
      surface: "#141414",
      surface2: "#1E1E1E",
      border: "rgba(255,255,255,0.10)",
      textDim: "rgba(255,255,255,0.62)",
      inkDim: "rgba(10,10,10,0.5)",
    } as const;
    
    // Scene durations in frames, in playback order. Name every beat; the sum is
    // the composition length, so re-timing one scene never breaks the others.
    export const SCENES = {
      hook: 135,
      reveal: 75,
      statement: 45,
      final: 84,
    } as const;
    
    export const TOTAL = Object.values(SCENES).reduce((a, b) => a + b, 0);
    
    export const hexToRgba = (hex: string, alpha: number) => {
      const h = hex.replace("#", "");
      const r = parseInt(h.substring(0, 2), 16);
      const g = parseInt(h.substring(2, 4), 16);
      const b = parseInt(h.substring(4, 6), 16);
      return `rgba(${r}, ${g}, ${b}, ${alpha})`;
    };
    
    export const lerp = (a: number, b: number, t: number) => a + (b - a) * t;
    
  • README.mdupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

Plain-text copy, no login: /skill-bundles/boriwatopal-agent-skill-remotion-motion-graphics-skills-remotion-motion-graphics.md

// REPO STATS

20 stars
0 open issues
Last commit: 2mo ago