a free guide
Claude Video Effects: Write This, Get This
Copy one message. Claude puts the effect on your own video.
Start
4 simple steps
What you’ll get
- 11 effects you can use on your own video
- One message for each effect, ready to copy
- No editing app needed
Steps
Add your video
Film yourself in vertical, in the middle of the frame. Name the file me.mp4 and put it in a new folder. Open that folder in Claude Code.
Pick an effect
Tap one, press Copy, paste it into Claude Code and press Enter.
Get your video
Claude writes the code and makes your video in the same folder. Want it different? Just tell Claude what to change.
Pick an effect
Tap one to see it bigger.
I'm giving you `me.mp4`, a vertical talking-head clip (static camera, me in the middle). Build this effect in code and export `freeze_frame.mp4` at the clip's own resolution and fps, my audio kept.
**What it is:** I talk normally, and right as I finish my line the picture freezes like a camera shutter: a soft flash, a punch-in toward my face, the room behind me falls out of focus and goes cool and dim while I stay in full colour, a thick white sticker outline draws itself around me, viewfinder brackets snap in, a focus box locks onto my face, and my name card whips in beside me. The frozen shot keeps a slow 3D push so it never looks dead.
**EDIT THESE:**
- Name `Your Name`, role `Your job`, tag `@yourhandle` (placeholders: change these three to my own name, job and handle; if I don't give them to you, keep the placeholders)
- Freeze: at the end of my line (rule below), hold `2.2 s`, then the video ends.
- Room tint: `on` (cool, desaturated room). `off` = the room only blurs and dims, its colours unchanged.
**Setup**
Work in a new folder next to my clip. Use Python 3.10+ with `pip install mediapipe opencv-python numpy pillow` and ffmpeg (install with Homebrew/apt if missing). No After Effects, no paid plugins, no online services.
1. Probe the clip with ffprobe (width, height, fps, duration, audio). Keep its resolution and fps. If it is not 9:16, centre-crop to 9:16 first.
2. Decode frames to PNG (or stream them with OpenCV). Never change the colours of my footage: no grading, no brightness/contrast/saturation changes. Only the graphics are new. Make the colour round-trip exact: decode with `-vf scale=in_range=tv:in_color_matrix=bt709:out_range=pc:flags=accurate_rnd+full_chroma_int` and encode with `-vf scale=in_range=pc:out_color_matrix=bt709:out_range=tv:flags=accurate_rnd+full_chroma_int` plus `-colorspace bt709 -color_primaries bt709 -color_trc bt709`, then check that pixels away from the graphics differ from the source by < 1/255 on average.
3. Person matte (if I give you a matte video, use that instead): for every frame with MediaPipe (Image Segmenter, `selfie_multiclass_256x256` or `selfie_segmenter`), then clean it: upscale with bilinear, guided/joint-bilateral refine against the frame, 1-2 px feather, and temporal smoothing (exponential average 0.6 old / 0.4 new, but no ghosting when I move fast). Face box + landmarks per frame with MediaPipe Face Landmarker (download its `face_landmarker.task` model, or use the bundled FaceMesh with refine_landmarks); smooth them with a One Euro filter so anchored graphics never jitter. If I give you a transcript with word timings, use it instead of transcribing.
4. All layout is derived from MY frame (face box, shoulders, safe area), never hard-coded pixels. Keep every graphic inside x 6 %-94 % and y 7 %-88 % of the frame (Instagram safe area) and never over my eyes or mouth.
5. Find the end of my line: if I give you a transcript with word times use it, otherwise `pip install faster-whisper` (model `small`, `word_timestamps=True`). The line ends at the last word's end time.
6. Clean plate of the room (the room without me), for the parallax and the blur: the median of the frames where those pixels are NOT covered by me; whatever is never uncovered gets a push-pull (pyramid) fill, feathered 3 px.
**THE FREEZE FRAME**
- Pick it from the frames between 0.5 s before and 0.3 s after the end of my line: my eyes open (both eye aspect ratios ≥ 75 % of their clip median), mouth nearly closed (inner-lip gap ≤ 30 % of its clip maximum), and my head not moving (face-centre speed ≤ 2× the lowest speed in that window). Prefer the latest frame that passes. Never pick a frame where I look down. The output = my clip up to that frame, then the 2.2 s hold. Cut my audio at the freeze frame with a 40 ms fade.
- Separate the frozen frame into me (frame × matte) and the room (the clean plate where I was, the real frame elsewhere). If the matte is loose (a halo of room around my hair), rebuild its edge from the difference between the frame and the clean plate.
**THE SEQUENCE** (t = 0 is the freeze frame)
- t −0.20 → 0: anticipation: the live picture eases in 1.00 → 1.015 (easeInQuad) toward my face centre.
- t = 0, the shutter: an exposure flash, not a white veil: multiply the frame in linear light by (1 + 2.2 × f) and add at most 4 % white × f, where f goes 1 → 0 over 0.16 s (easeOutCubic). Highlights and skin flare, the dark room stays dark: it must never turn into a grey screen. Punch-in: the frozen shot scales 1.015 → 1.07 toward my face centre with a spring (stiffness 220, damping 20).
- The room, over 0.35 s (easeOutCubic), and only the room: lens blur to σ 7 px (a disc / bokeh kernel, not a plain Gaussian, so highlights turn into soft round bokeh), dims to 80 %, and with room tint on it desaturates 65 % and its luma maps onto a cool navy duotone (`#0A1020` shadows → `#5C6F9C` highlights) mixed at 70 %. Me: exactly my original pixels, never recoloured.
- 2.5D push during the hold: from 0.35 s to the end I scale 1.07 → 1.10 and the room 1.07 → 1.085 (easeInOutSine), so the room slides a little behind me.
- Sticker outline (from t 0.08 s): a 14 px white band around my matte (distance transform of a smoothed copy of the matte, blur σ 5 then threshold, so the band is a clean sticker edge and doesn't follow single hair strands: 0 < d ≤ 14 px, anti-aliased, round ends; I keep my full hair detail inside it) that sits between the room and me, plus a soft drop shadow of the whole sticker (me + band) on the room: black 35 %, offset (0, 14), blur 30, so I lift off the background. The band DRAWS ITSELF along my silhouette: find the outer contour (OpenCV `findContours`), parameterise it by arc length starting at the top of my head, and reveal both ways down to the frame edge over 0.45 s easeInOutCubic (each band pixel takes the arc position of its nearest contour point). A bright tip leads each drawing end: white 6 px core + soft glow (σ 4 / 12, linear light). Where my silhouette leaves the frame (bottom edge), the band simply stops; never draw a line along the frame edge.
- Viewfinder (from t 0.12 s): four corner L-brackets at the safe-area corners (x 6 % / 94 %, y 7 % / 88 %), legs 64 px, 4 px stroke, white 90 %, round caps. Each flies in from 40 px further out and snaps with a spring (stiffness 260, damping 22), 60 ms apart. Top-left inside the brackets: `❚❚ 00:00:04:12` in mono 22 px white 80 % (the real timecode of the freeze frame, HH:MM:SS:FF), with the pause bars in white 100 %.
- Focus box (from t 0.20 s): four short corner ticks (34 px legs, 4 px, white) around my face box (the face-oval bounds), each side pushed out by ~22 % of the box size so the ticks sit clear of the white band. It starts at 1.4× that size and shrinks onto my face with a spring (stiffness 240, damping 21), then blinks twice (white → 55 % → white, 80 ms each) and stays at 85 %. An `AF · LOCKED` label in mono 22 px white 85 % starts at its top-right corner and runs outward (away from the band; shift it inward only as far as needed to stay inside the safe area), appearing with the blinks.
- Name card (from t 0.25 s), beside me in the lower third, on the side of the frame with more free space next to my shoulder, overlapping my chest by about 20 % of its width (it sits in front of me), its top 120 px below my chin. With tight framing (my shoulders reach the frame edges, no free side) it sits over my chest on one side, inside the safe area; it may cover part of my mic.
- The name (EDIT THESE) in SF Pro Display Heavy 92 px white (SF system font at weight 800 if Heavy isn't installed); under it the role in Bodoni Moda Italic 54 px white 88 % (download it from Google Fonts; use its small optical size, the "18pt" cut, weight 500: the display cuts lose their hairlines and the "A" stops reading); under that the tag in mono caps 28 px `#FF7A1A`, 10 % tracking.
- Card behind the text: dark glass, `#0E0E12` at 72 % over the room blurred σ 20, radius 30, padding 34 / 40, 1.5 px rim white 18 % (brighter top-left), shadow (0, 16) blur 40 black 35 %.
- Entrance: the card slides 120 px in from its side with a spring (stiffness 190, damping 19). The name whips in from the left and the role from the right at the same time (horizontal motion blur while they move, 8+ sub-frames), both settled 0.5 s after the card starts. Then the tag types on (28 ms per character) with a block cursor that blinks twice and disappears.
- While holding: a brighter 140 px segment of light travels along the outline from one frame edge over my head to the other (1.6 s per pass, fading in and out over 70 px at the frame edges; white 100 % + glow σ 6, rest of the band stays white 95 %). The brackets and focus box stay locked to the frame, not to the push.
**SOUND** (synthesise with NumPy)
- Shutter: a 4 ms click + a 30 ms noise burst band-passed 3-6 kHz, then a second, softer click 70 ms later.
- Freeze impact: a soft low "whoomp" (70 Hz with 140 / 210 Hz harmonics, 300 ms) under a short filtered-noise swell.
- Outline drawing: a soft rising shimmer (band-passed noise sweeping 2 → 8 kHz, 450 ms). Each bracket: a tiny tick. Focus lock: two soft camera beeps (2.4 kHz, 40 ms each, 90 ms apart). Name card: a soft whoosh; each typed character a very quiet tick.
- Under the whole hold: a quiet warm pad (two sine notes a fifth apart, slow fade in and out) so the freeze is never dead silent.
**Craft Rules**
- Render all vector graphics (cards, text, lines, rings) at 2x and downsample with a Lanczos filter, so edges are crisp with no jaggies. Use premultiplied alpha when compositing. Lanczos rings on hard edges (bright rim on dark, green on dark): clamp each downsampled pixel to the min/max of its 2x source block so there are no halos.
- Shadow and glow sizes written as "blur N" mean a CSS/Figma blur: Gaussian σ = N / 2.
- Glows and light are added in linear light (convert sRGB to linear, add, convert back), built from 3 stacked Gaussian blurs (tight, medium, wide), so they look like light, not like a grey haze.
- Motion: no linear moves. Entrances use a spring (stiffness ~170, damping ~18, small overshoot) or easeOutExpo; exits use easeInCubic. Stagger related elements by 60-90 ms. Nothing stops dead: let things settle over 150-250 ms. "Lands" = the moment its entrance spring first reaches its target. If the clip ends before a timed beat would finish, move that beat earlier so it completes before the end.
- Fast moves get motion blur: render 5-8 sub-frames per frame for the moving layers and average them.
- Numbers use tabular (monospaced) digits so they don't wobble while they count up, with easeOutExpo counting and a K/M suffix.
- Fonts: use SF Pro Display / SF Pro Text if installed (macOS), otherwise Inter. Small labels in a monospace (SF Mono, JetBrains Mono or Menlo) in caps with 8-12 % letter spacing.
- Sound levels: normalise each sound on its own, then mix so the main hits (clicks, landings, chimes) peak about 9 dB below the RMS of my speech, and beds/whooshes have their loudest 100 ms RMS about 15 dB below my speech RMS. Low thumps get 2nd/3rd harmonics so phone speakers play them. Every sound must be audible on a phone at normal volume and never mask a word. (Where a prompt says "mix N dB under my voice", read it as this rule.)
**Workflow + QA**
1. First render 4 full-resolution stills (start of entrance, mid entrance, settled, and mid exit or the last frame) and LOOK at them: check the graphics are crisp, sit in the right place on MY frame, nothing covers my face, text is readable on a phone. Fix and re-render before doing the full video.
2. Then render the full clip, encode with ffmpeg: H.264, `-crf 16 -preset slow -pix_fmt yuv420p` (on a noisy source where the < 1/255 colour check fails, use `-crf 12`), same fps, `-movflags +faststart`, my audio with the sounds mixed in (AAC 192k). Also make a side-by-side `compare.mp4` (original | effect) and a contact sheet of 12 frames.
3. Check the last frames too (no half-finished animation unless it is meant to exit). Tell me the output paths.I'm giving you `me.mp4`, a vertical talking-head clip (static camera, me in the middle). Build this effect in code and export `glass_dashboard.mp4` at the clip's own resolution and fps, my audio kept.
**What it is:** four Apple-style liquid-glass widgets appear around me and come alive: a big line graph above my head, a ring gauge and a counter at my lower left, a bar chart at my lower right. The glass is REAL glass: you see my room through it, blurred and bent at the edges, with a bright rim and a light glint. The top card sits BEHIND my head (my hair overlaps it), the lower ones float in FRONT of me, so it feels 3D.
**EDIT THESE (placeholder numbers: they are yours to change; use my own numbers and labels if I give them to you):**
- Graph card: label `VIEWS · THIS REEL`, counts 0 → `1.0M`
- Ring gauge: label `SHARE RATE`, 0 → `50 %`
- Counter card: big `500K`, label `VIEWS · TOP 7 REELS`
- Bar chart: label `TOP REELS · K VIEWS`, bars `100, 80, 60, 40, 20` (first bar is the highlight)
- Start time: the widgets begin at `0.4 s` into the clip and stay to the end
**Setup**
Work in a new folder next to my clip. Use Python 3.10+ with `pip install mediapipe opencv-python numpy pillow` and ffmpeg (install with Homebrew/apt if missing). No After Effects, no paid plugins, no online services.
1. Probe the clip with ffprobe (width, height, fps, duration, audio). Keep its resolution and fps. If it is not 9:16, centre-crop to 9:16 first.
2. Decode frames to PNG (or stream them with OpenCV). Never change the colours of my footage: no grading, no brightness/contrast/saturation changes. Only the graphics are new. Make the colour round-trip exact: decode with `-vf scale=in_range=tv:in_color_matrix=bt709:out_range=pc:flags=accurate_rnd+full_chroma_int` and encode with `-vf scale=in_range=pc:out_color_matrix=bt709:out_range=tv:flags=accurate_rnd+full_chroma_int` plus `-colorspace bt709 -color_primaries bt709 -color_trc bt709`, then check that pixels away from the graphics differ from the source by < 1/255 on average.
3. Person matte (if I give you a matte video, use that instead): for every frame with MediaPipe (Image Segmenter, `selfie_multiclass_256x256` or `selfie_segmenter`), then clean it: upscale with bilinear, guided/joint-bilateral refine against the frame, 1-2 px feather, and temporal smoothing (exponential average 0.6 old / 0.4 new, but no ghosting when I move fast). Face box + landmarks per frame with MediaPipe Face Landmarker (download its `face_landmarker.task` model, or use the bundled FaceMesh with refine_landmarks); smooth them with a One Euro filter so anchored graphics never jitter. If I give you a transcript with word timings, use it instead of transcribing.
4. All layout is derived from MY frame (face box, shoulders, safe area), never hard-coded pixels. Keep every graphic inside x 6 %-94 % and y 7 %-88 % of the frame (Instagram safe area) and never over my eyes or mouth.
**LAYOUT** (sizes for a 1080-wide frame; scale everything by width/1080). Measure the free space from my matte first, then pick:
- **Layout A (there are ≥ 330 px between the top of the safe area and the top of my head):** graph card x 64 → 1016, height 300, top at 7 % of the frame height, sitting BEHIND my head (my hair may overlap only its bottom 15 %). Ring card 230 x 230 at the left edge (x 64), its top at my chin + 260 px; counter card 230 x 120 under it (16 px gap); bar card 230 x 300 at the right edge (right x 1016), top aligned with the ring card. All three small cards in FRONT of me.
- **Layout B (tight framing, my head near the top):** graph card x 64 → 1016, height 290, in FRONT of me across my chest, its top 110 px below my chin (never over my mouth; it may cover my mic and shirt). Ring card 230 x 230 beside my head on the side with more free wall, vertically centred on my eye line, with the counter card 230 x 120 directly under it; bar card 230 x 300 on the other side of my head, same top. They may overlap my ear/shoulder by up to 40 px, and where they do they sit behind me; keep the bars' value labels clear of my ear by starting the bar group near the card's outer edge (away from my head). Here the small cards sit BEHIND my head/shoulders where they overlap me (matte on top), which gives the depth.
- Corner radius 36 for the graph card, 30 for the small ones. Hands crossing a card: the card is in front of hands in A, behind in B (follow the matte order above).
**THE GLASS** (do this per widget, per frame, on the 2x canvas)
1. Shape = rounded-rectangle signed distance field (SDF). Thickness profile: flat in the middle, a smooth bevel in the outer 22 px (smoothstep), like a pane with rounded edges.
2. Refraction: normal = gradient of the thickness; sample the background (my frame, pre-blurred with Gaussian σ 16 px = frost) at an offset of normal × 26 px, so the room bends and magnifies at the edges and is calm in the middle.
3. Chromatic dispersion only at the bevel: offset R, G, B by 1.00, 1.035, 1.07 × the refraction offset (a thin rainbow fringe at the edge, nowhere else).
4. Body: mix white 9 % over the refracted image, lift it 4 %, and add a vertical gradient (white 7 % at the top → 0 % at the bottom).
5. Rim light: 1.5 px inner stroke, white 70 % along the top-left edge fading to 18 % at the bottom-right (light comes from top-left); plus a 1 px outer hairline black 10 %.
6. Shadow behind the card onto the room: offset (0, 18), blur 40, black 20 %. Front cards also cast a soft 12 % shadow on me.
7. Specular sweep: once, 250 ms after each card lands, a soft diagonal band (35° from vertical, 120 px wide, white 0 → 22 % → 0) travels across the card in 650 ms, easeInOutSine.
Composite order: room → the cards that are BEHIND me (with their shadows) → me (person matte) → the cards in FRONT of me (with their shadows on me). The glass always refracts what is really behind it: behind-cards refract the room, front-cards refract me and the room.
On a dark background the glass must still read: if the area behind a card is dark (mean luma < 0.25), raise the body white mix to 14 % and the rim to 85 % at the top-left, so the card's shape is clear.
**THE CONTENT**
- Labels: monospace caps 22 px, letter spacing 12 %, white 62 %, at the card's top-left (28 px inset). Big numbers: SF Pro Display / Inter Heavy, tabular digits, white, 92 px on the graph card, 74 px on the counter card, right-aligned at the top-right.
- Line graph: 28 data points of a believable growth curve (slow start, kink up after 60 %, small noise), smoothed with a Catmull-Rom spline. Line 6 px, colour `#32F07A`. It draws left → right over 1.5 s, easeInOutCubic. Glow: the same path blurred at σ 3, 10 and 26 px, added in linear light at 90 %, 55 % and 30 %. Plot the data from 10 % above the card's baseline so the fill always shows. Area under the line: green gradient 38 % at the line → 0 % at the baseline, revealed together with the line, so it clearly reads as a filled chart. Three faint gridlines (white 9 %, 1 px).
- Comet head at the drawing tip: white core 9 px + green halo (σ 14), and a short bright trail (the last 6 % of the line is 40 % brighter). When the line finishes, the head pulses once (scale 1 → 1.7 → 1 in 400 ms) with a soft flash of the glow.
- Ring gauge: track ring white 14 %, 14 px thick, radius 74; the value arc in `#FF7A3D` with round caps sweeps 0 → value over 1.3 s easeOutCubic, its end cap glowing (σ 8). The value counts in the centre (54 px) with the label under it (17 px mono caps).
- Bars: 5 bars, 26 px wide, 14 px gaps, radius 8 on top. The first bar is `#32F07A` with glow, the others white 78 %. They grow from the baseline with a spring (overshoot ≤ 6 %), staggered 70 ms, values counting above them in 18 px mono.
- The graph card's big number is DRIVEN BY THE LINE: it always shows the data value under the comet head (scaled so the last point = the final number; use a running maximum so it never steps back on a noisy curve), so the number and the line climb together and both arrive on the same frame as the comet pulse.
- The other counters: easeOutExpo over 1.4 s. All numbers: tabular digits, format with K/M (e.g. 0 → 1.2M).
**MOTION**
- Entrance: graph card first, then ring (+120 ms), counter (+200 ms), bars (+280 ms). Each card: opacity 0 → 1, scale 0.9 → 1, rise 46 px, and a blur-in σ 14 → 0, with a spring (stiffness 170, damping 18). Content starts 160 ms after its card lands.
- Alive while settled: every card floats ±3 px on a slow sine (periods 3.1, 3.7, 4.3 s, different phases) and follows my head a little: top card moves 12 % of my face-centre motion, lower cards 25 % (parallax, smoothed), plus ±1.5° perspective tilt toward my head's x position.
- If the clip ends while they are still on screen, that is fine; otherwise optional exit: reverse order, 280 ms easeInCubic, slide 40 px down + blur out.
**SOUND** (synthesise with NumPy; soft enough that it never masks a word)
- A soft glass "tink" when each card lands: sine partials 2.1 kHz + 3.2 kHz + 5.4 kHz, 140 ms exponential decay, slightly different pitch per card (in key).
- A gentle airy rise (filtered noise, 1.2 s) under the counting, and one soft low "thock" when the graph's comet pulses (pitch 135 → 90 Hz with 180/270 Hz harmonics and a 4 ms soft transient so phones play it, 80 ms).
**Craft Rules**
- Render all vector graphics (cards, text, lines, rings) at 2x and downsample with a Lanczos filter, so edges are crisp with no jaggies. Use premultiplied alpha when compositing. Lanczos rings on hard edges (bright rim on dark, green on dark): clamp each downsampled pixel to the min/max of its 2x source block so there are no halos.
- Shadow and glow sizes written as "blur N" mean a CSS/Figma blur: Gaussian σ = N / 2.
- Glows and light are added in linear light (convert sRGB to linear, add, convert back), built from 3 stacked Gaussian blurs (tight, medium, wide), so they look like light, not like a grey haze.
- Motion: no linear moves. Entrances use a spring (stiffness ~170, damping ~18, small overshoot) or easeOutExpo; exits use easeInCubic. Stagger related elements by 60-90 ms. Nothing stops dead: let things settle over 150-250 ms. "Lands" = the moment its entrance spring first reaches its target. If the clip ends before a timed beat would finish, move that beat earlier so it completes before the end.
- Fast moves get motion blur: render 5-8 sub-frames per frame for the moving layers and average them.
- Numbers use tabular (monospaced) digits so they don't wobble while they count up, with easeOutExpo counting and a K/M suffix.
- Fonts: use SF Pro Display / SF Pro Text if installed (macOS), otherwise Inter. Small labels in a monospace (SF Mono, JetBrains Mono or Menlo) in caps with 8-12 % letter spacing.
- Sound levels: normalise each sound on its own, then mix so the main hits (clicks, landings, chimes) peak about 9 dB below the RMS of my speech, and beds/whooshes have their loudest 100 ms RMS about 15 dB below my speech RMS. Low thumps get 2nd/3rd harmonics so phone speakers play them. Every sound must be audible on a phone at normal volume and never mask a word. (Where a prompt says "mix N dB under my voice", read it as this rule.)
**Workflow + QA**
1. First render 4 full-resolution stills (start of entrance, mid entrance, settled, and mid exit or the last frame) and LOOK at them: check the graphics are crisp, sit in the right place on MY frame, nothing covers my face, text is readable on a phone. Fix and re-render before doing the full video.
2. Then render the full clip, encode with ffmpeg: H.264, `-crf 16 -preset slow -pix_fmt yuv420p`, same fps, `-movflags +faststart`, keep my audio with the effect's sounds mixed in. Also make a side-by-side `compare.mp4` (original | effect) and a contact sheet of 12 frames.
3. Check the last frames too (no half-finished animation unless it is meant to exit). Tell me the output paths.I'm giving you `me.mp4`, a vertical talking-head clip (me in the middle), and a folder `covers/` with 8-11 of my reel covers (9:16 images). Build this effect in code and export `grid_drop.mp4` at the clip's own resolution and fps, my audio kept.
**What it is:** one continuous camera pull-back: my full-screen video shrinks smoothly into the centre tile of my Instagram profile grid while it keeps playing. The other tiles (my real reels) ripple in around me from the centre outward, each with its view count counting up, and my profile header slides in at the top. It ends on the whole profile with me playing in the middle tile, highlighted.
**EDIT THESE (these values are only placeholders: it must be MY real profile. Before you start, if I have not given you my Instagram handle, name, post / follower / following numbers and one bio line in this message, ask me for them. Never invent them):**
- Handle `@yourhandle`, name `Your Name`, stats `100 posts · 10K followers · 100 following`, one bio line `Your bio line`, avatar `avatar.jpg` (any square photo of me; if missing, use a frame of my face cropped to a circle).
- View counts for the tiles (in order, any number of them; placeholders, use my real counts if I give them): `1.8M, 412K, 96K, 2.4M, 158K, 77K, 640K, 31K, 1.1M`; my own tile: `▶ NEW`.
- Start: `0.3 s`, pull-back lasts `1.1 s`.
**Setup**
Work in a new folder next to my clip. Use Python 3.10+ with `pip install mediapipe opencv-python numpy pillow` and ffmpeg (install with Homebrew/apt if missing). No After Effects, no paid plugins, no online services.
1. Probe the clip with ffprobe (width, height, fps, duration, audio). Keep its resolution and fps. If it is not 9:16, centre-crop to 9:16 first.
2. Decode frames to PNG (or stream them with OpenCV). Never change the colours of my footage: no grading, no brightness/contrast/saturation changes. Only the graphics are new. Make the colour round-trip exact: decode with `-vf scale=in_range=tv:in_color_matrix=bt709:out_range=pc:flags=accurate_rnd+full_chroma_int` and encode with `-vf scale=in_range=pc:out_color_matrix=bt709:out_range=tv:flags=accurate_rnd+full_chroma_int` plus `-colorspace bt709 -color_primaries bt709 -color_trc bt709`, then check that pixels away from the graphics differ from the source by < 1/255 on average.
3. Person matte (if I give you a matte video, use that instead): for every frame with MediaPipe (Image Segmenter, `selfie_multiclass_256x256` or `selfie_segmenter`), then clean it: upscale with bilinear, guided/joint-bilateral refine against the frame, 1-2 px feather, and temporal smoothing (exponential average 0.6 old / 0.4 new, but no ghosting when I move fast). Face box + landmarks per frame with MediaPipe Face Landmarker (download its `face_landmarker.task` model, or use the bundled FaceMesh with refine_landmarks); smooth them with a One Euro filter so anchored graphics never jitter. If I give you a transcript with word timings, use it instead of transcribing.
4. All layout is derived from MY frame (face box, shoulders, safe area), never hard-coded pixels. Keep every graphic inside x 6 %-94 % and y 7 %-88 % of the frame (Instagram safe area) and never over my eyes or mouth.
**THE GRID** (Instagram profile in dark mode; sizes for a 1080-wide frame, scale by width/1080)
- Background `#000`. Grid: 3 columns, tiles 3:4 portrait (Instagram's current grid ratio), 2 px gaps, full width of the profile page. Lay out 3 rows (plus the top of a 4th); my live video is the tile in column 2, row 2. Integer column widths (e.g. 359/358/359 at 1080 wide).
- Each tile shows a cover centre-cropped to 3:4; put similar-looking covers on non-neighbouring tiles. My tile shows my live video cropped to 3:4 around my face: crop width = 2.1 × my face-box width, centred between the face-box centre and my eyes, eyes at 40 % of the tile height; the crop window is fixed (not per frame), so my natural head movement stays.
- View badge on every tile: bottom-left, a small play triangle + the number, SF Pro Text Semibold 26 px white with a soft dark shadow (0, 1, blur 3, black 60 %), plus a subtle dark gradient at the tile's bottom 30 % so it always reads.
- Top bar at the very top of the page: the handle in Semibold 34 px with a small chevron, and a menu icon (three lines) at the right; keep it below 7 % of the frame height.
- Profile header under it (on the same page, scrolls with it): avatar circle 170 px with a thin `#262626` ring; to its right the three stats (bold number 34 px over a 24 px label); under it the name (Semibold 30 px), the bio line (Regular 28 px, white 85 %), then two rounded buttons `Following ⌄` and `Message` (`#262626`, radius 16, height 64, white Semibold 28 px), and the tab bar row (grid icon, reels icon, tagged icon: draw simple line icons, the grid one white with a 2 px underline, the others white 50 %).
**THE CAMERA** (one continuous move)
- Think of the whole profile page as a big canvas. The camera starts zoomed in so that my tile exactly fills the frame AND my video is shown in full 9:16 (it's simply my clip); it ends at scale 1.0 showing the full page width: top bar, header and about 2.5 rows of tiles.
- Interpolate two things over the pull-back with easeInOutQuart: the camera's zoom/position (zoom interpolated in log space), and my tile's crop window, from the full 9:16 frame to the 3:4 tile crop (centre linear, width in log space). My tile is drawn on top of its neighbours while it is still taller than its slot. Do it so my face never jumps: my face's screen position eases smoothly from where it is in the clip to its place in the tile.
- Motion blur on the pull-back: at least 8 sub-frames, adaptively more (up to 48) so sub-frame samples are never more than ~2 px apart anywhere on the page (otherwise text shows a comb), shutter 0.4 frame. A tiny 3D feel: the page tilts back to 6° over the first 40 % of the pull (perspective warp, top edge farther away), holds, then springs flat from 55 % (overshoot 0.5°).
- Settle: after the pull-back, a slow drift (scale 1.000 → 1.012 over the rest of the clip) so it never freezes.
**THE TILES AND HEADER**
- Tiles appear as the camera pulls back, starting 0.16 s after the pull-back starts (never leave empty black around my tile), ordered by distance from my tile (ripple outward), 55 ms apart: each one fades in from black with scale 0.86 → 1, a 4° random tilt → 0 and blur σ 8 → 0, spring (stiffness 200, damping 19). Each badge's number counts up (easeOutExpo, 0.8 s) right after its tile lands.
- The other tiles are slightly moving, not frozen: a slow Ken Burns push (1.00 → 1.04) each, random direction.
- My tile, once settled: a soft white glow border (2 px white 90 % + glow σ 12, 40 %) that pulses once, and its badge `▶ NEW` in Instagram-blue `#0095F6` pill.
- Header: from 300 ms after the pull-back starts, each group drops 150 px into place with a fade and a soft spring (stiffness 55, damping 11) so it lands as the camera reveals it: top bar + avatar first, then stats (+60 ms), name/bio (+120 ms), buttons (+180 ms), tab bar (+240 ms). The follower number counts up.
**SOUND** (synthesise with NumPy)
- The pull-back: a soft rising-then-falling air whoosh (noise band-pass 300 → 2,500 Hz, 1.0 s) with a gentle low swell.
- Tiles: a soft "tick" per tile (6 ms click + 3 kHz ping, 40 ms), getting slightly higher and quieter as the ripple spreads, like a cascade.
- My tile's glow pulse: one soft warm chime (in key, 500 ms decay).
**Craft Rules**
- Render all vector graphics (cards, text, lines, rings) at 2x and downsample with a Lanczos filter, so edges are crisp with no jaggies. Use premultiplied alpha when compositing. Lanczos rings on hard edges (bright rim on dark, green on dark): clamp each downsampled pixel to the min/max of its 2x source block so there are no halos.
- Shadow and glow sizes written as "blur N" mean a CSS/Figma blur: Gaussian σ = N / 2.
- Glows and light are added in linear light (convert sRGB to linear, add, convert back), built from 3 stacked Gaussian blurs (tight, medium, wide), so they look like light, not like a grey haze.
- Motion: no linear moves. Entrances use a spring (stiffness ~170, damping ~18, small overshoot) or easeOutExpo; exits use easeInCubic. Stagger related elements by 60-90 ms. Nothing stops dead: let things settle over 150-250 ms. "Lands" = the moment its entrance spring first reaches its target. If the clip ends before a timed beat would finish, move that beat earlier so it completes before the end.
- Fast moves get motion blur: render 5-8 sub-frames per frame for the moving layers and average them.
- Numbers use tabular (monospaced) digits so they don't wobble while they count up, with easeOutExpo counting and a K/M suffix.
- Fonts: use SF Pro Display / SF Pro Text if installed (macOS), otherwise Inter. Small labels in a monospace (SF Mono, JetBrains Mono or Menlo) in caps with 8-12 % letter spacing.
- Sound levels: normalise each sound on its own, then mix so the main hits (clicks, landings, chimes) peak about 9 dB below the RMS of my speech, and beds/whooshes have their loudest 100 ms RMS about 15 dB below my speech RMS. Low thumps get 2nd/3rd harmonics so phone speakers play them. Every sound must be audible on a phone at normal volume and never mask a word. (Where a prompt says "mix N dB under my voice", read it as this rule.)
**Workflow + QA**
1. First render 4 full-resolution stills (start of entrance, mid entrance, settled, and mid exit or the last frame) and LOOK at them: check the graphics are crisp, sit in the right place on MY frame, nothing covers my face, text is readable on a phone. Fix and re-render before doing the full video.
2. Then render the full clip, encode with ffmpeg: H.264, `-crf 16 -preset slow -pix_fmt yuv420p`, same fps, `-movflags +faststart`, keep my audio with the effect's sounds mixed in. Also make a side-by-side `compare.mp4` (original | effect) and a contact sheet of 12 frames.
3. Check the last frames too (no half-finished animation unless it is meant to exit). Tell me the output paths./word-burst — every word I say floats out of my mouth as pure white 3D type and drifts around my head until the cut
I'm attaching me.mp4: a vertical 9:16 clip where I talk (static camera, me seated at a mic in a dark room, my whole frame, 1080x1920, no bars, no zoom). Build it in code (three.js + canvas, a pure function of time) and export result.mp4 — 1080x1920, 59.94 fps, H.264, my audio untouched, ending 0.06 s after my last word. My footage plays live to the end.
**EDIT THESE:**
- Start: the effect starts at `0.5 s` into the clip (if I give you a transcript with word times, start at my first word instead). Everything below is timed from this start.
SETUP
- Track my mouth (MediaPipe face landmarks) and cut me out with a person matte (subject mode).
- Type: Clash Display Bold outlines (free on Fontshare: download it if you can, otherwise any heavy bold font on my computer), extruded in real 3D (depth 0.3 cap height, gentle bevel), pure white, soft studio light (warm key top-left, cool fill, warm/cool edge lights taken from the colours of MY room, reflections from an environment map painted from my room), very soft shadows on the wall and on me.
THE WORDS
- EVERY word I say from the start on (lowercase; keep digits and acronyms like 3D upper case) leaves my real mouth exactly on its spoken onset, one word at a time, in order: it starts tiny on my lips with a soft breath of light, floats out sideways, toward the camera and up, weightless, on a smooth path, and settles on its own slow orbit round my head (the words spiral round me, never covering my eyes).
- They never stop: slow bobbing and drifting, gentle 3D rotation, and a continuous soft MORPH: the letters breathe and wave (vertex waves along the word + a per-letter breathing scale), liquid but always readable.
- Words pass in front of me and behind me (matte); older words drift further out and go softly out of focus (depth of field: near words are big and soft too); real motion blur (adaptive sub-frames, 180 degree shutter); a slow light sweep over the type near the end.
- Micro details: breath puffs on the lips, motes shed along every flight, 4-point glints on the bevels, floating dust and bokeh, bloom.
SOUND
A soft airy breath and an air tail for every word on its onset, a soft tonal tick when it settles (pentatonic), a glass shimmer pad under the clip, one bell on the last word; 15 dB under my voice.I'm giving you `me.mp4`, a vertical talking-head clip (static camera, me in the middle). Build this effect in code and export `insane_captions.mp4` at the clip's own resolution, 59.94 fps (duplicate the 30p footage frames, evaluate the graphics at 59.94), my audio kept.
**What it is:** huge pure-white, bold, modern captions that pop on screen exactly on each word I say, stacked in big lines. Normal words pop and settle. HERO words are giant, shake the frame, and throw sparks. Everything has weight, like real objects landing, and the whole stack lives in my room, with some words passing BEHIND my head. The depth comes from real light on a rounded satin edge and a shadow that reacts to height, never from outlines or a 3D side. It must look like a premium film title, not a text overlay: lit by my room, in front of AND behind me, always moving.
**EDIT THESE:**
- HERO words: `insane` · `captions` · `popping` (one special move each, below). If I don't say them, take the longest 3 words.
- Colours: fill pure white `#FFFFFF` (no outline, no coloured side), hero accent lime `#C8FF3D` (the ring on `insane`, a touch in the sparks and in the hero shine).
- Font: Clash Display Bold (free on Fontshare: download it if you can), otherwise any heavy bold font on my computer. Tracking -1.5 % (shape the text with HarfBuzz / `uharfbuzz` so kerning works). Lowercase, no punctuation.
**Setup**
Work in a new folder next to my clip. Use Python 3.10+ with `pip install mediapipe opencv-python numpy pillow` and ffmpeg (install with Homebrew/apt if missing). No After Effects, no paid plugins, no online services.
1. Probe the clip with ffprobe (width, height, fps, duration, audio). Keep its resolution and fps. If it is not 9:16, centre-crop to 9:16 first.
2. Decode frames to PNG (or stream them with OpenCV). Never change the colours of my footage: no grading, no brightness/contrast/saturation changes. Only the graphics are new. Make the colour round-trip exact: decode with `-vf scale=in_range=tv:in_color_matrix=bt709:out_range=pc:flags=accurate_rnd+full_chroma_int` and encode with `-vf scale=in_range=pc:out_color_matrix=bt709:out_range=tv:flags=accurate_rnd+full_chroma_int` plus `-colorspace bt709 -color_primaries bt709 -color_trc bt709`, then check that pixels away from the graphics differ from the source by < 1/255 on average.
3. Person matte (if I give you a matte video, use that instead): for every frame with MediaPipe (Image Segmenter, `selfie_multiclass_256x256` or `selfie_segmenter`), then clean it: upscale with bilinear, guided/joint-bilateral refine against the frame, 1-2 px feather, and temporal smoothing (exponential average 0.6 old / 0.4 new, but no ghosting when I move fast). Face box + landmarks per frame with MediaPipe Face Landmarker (download its `face_landmarker.task` model, or use the bundled FaceMesh with refine_landmarks); smooth them with a One Euro filter so anchored graphics never jitter. If I give you a transcript with word timings, use it instead of transcribing.
4. All layout is derived from MY frame (face box, shoulders, safe area), never hard-coded pixels. Keep every graphic inside x 6 %-94 % and y 7 %-88 % of the frame (Instagram safe area) and never over my eyes or mouth.
5. Transcribe my audio with word timestamps (`pip install faster-whisper`, model `small`, `word_timestamps=True`). Then snap every word start to the real sound: find the first rise of my audio energy within ±80 ms of the word start. The pop must hit on the sound, never after it.
**LAYOUT** (sizes for a 1080-wide frame; scale by width/1080)
- Group my words into lines of max 2 words (hero word = its own line). Keep a stack of max 3 lines on screen (only as many as fit between the top safe line y 7 % and my head, usually 2: a line that does not fit is dropped, never overlapped), centred on my face's x, clamped inside x 70-1010.
- The stack sits in the free space above my head if there are ≥ 420 px there; otherwise it sits at chest height. Never over my eyes or mouth.
- Size: normal words are 150 px type (never smaller, phone readable; a 2-word line stays inside x 70-1010). Hero lines fit 940 px wide, nearly the full width (max 340 px type, so they come out larger than the normal words).
- When a new line lands, older lines slide up and shrink to 78 % (60 % for the third), dimmed to about 70 % white (88 % opacity x a tint, 80 % for the third) and slightly out of focus (0.8 px), tinted by the room light (sample the light colours from my clip) so they stay a clean lit white, never flat grey mud. All of them move on the same stiff spring (stiffness ~420, damping ~27) that starts 120 ms before a normal word and 300 ms before a hero word, so the old lines have already cleared UP, and stay readable, before the new word lands. A normal line that comes right before a hero word lands already in its raised slot. Lines that no longer fit leave up and out on the same spring, with motion blur (drop lines, never overlap). Check every frame: ink boxes of different lines must never intersect.
- Hero words pass BEHIND my head: composite them under my person matte, so my head and shoulders stay in front, but only the LOWER edge of a hero word may touch my hair (baseline about 3 % of its type size below the top of my head, never more) so the word stays fully readable. Normal lines stay in front of me.
**THE WORD MATERIAL** (per word, on the 2x canvas)
- Body: pure white. The letters are a soft satin slab with a rounded edge (bevel radius about 7.5 % of the type size): build a height map from the distance-to-edge of the glyph mask (quarter-circle profile, lightly blurred), take its normals and light it with: key light top-left (warm white), fill from the right (cool), a bounce from the lower left and a faint one from the right in the colours of the room's own lights (sample the light colours from my clip), plus a Blinn specular on the lit rim. Flat faces stay pure white, the edges carry the light: warm on left edges, cool on right edges, a faint fall-off at the bottom. No outline, no extrude, no glow haze.
- Contact shadow on the wall, a separate layer behind each word (never baked in): black, soft, offset about (3 + 10 x lift, 8 + 30 x lift) px, blur sigma about 9 + 24 x lift px, opacity 46 % x (1 - 0.45 x lift), where lift goes 1 -> 0 as the word pops in. The shadow is wide and soft while the word is in the air and gets tight and dark the moment it lands (weight).
- Light sweep: a slow band of light (white with a hint of lime) crosses each hero word 200 ms after it lands (1.1 s, easeInOut), lighting the rounded edges and lifting the shaded body to pure white; normal words get a faster, weaker sweep (300 ms) as they land. At three moments of the sweep a four-point star glint appears on the type.
- Real light on me: the bright hero type behind my head wraps a soft light onto the hair/shoulder edge (blurred hero colour x an inner edge band of my matte, strength 0.24, +0.30 on impact) and bounces very faintly on the wall (sigma 70 px, 4.5 %, +7.5 % on impact). Feather the light toward region borders so no box edge shows.
**THE MOTION**
- Every word pops on its snapped start time: from scale 0.35 + rotation ±8° + blur 6 px to scale 1.0 on a spring (stiffness ~320, damping ~16: visible overshoot to ~1.14, settles in 220 ms). Each word gets its own small random final tilt (±3°, seeded, not jittery).
- Words on the same line: the line re-centres smoothly as each new word arrives (spring, no jump).
- Nothing is ever static: every line floats (about 2 px, 0.3-0.8 Hz, +/-0.35 degrees, a different phase per line), about 30 dust motes drift slowly through the free space above my head (far ones are tiny bright specks behind me, near ones big soft bokeh discs in front, tinted with the room's light colours sampled from my clip), and every normal word lands with a 1.5 px camera nudge.
- Hero word landing: frame punch-in 1.0 → 1.035 → 1.0 over 260 ms (easeOutExpo then easeInOut), a 6 px decaying camera shake for 180 ms, and a burst of 24 small sparks (2-5 px, mostly white with a touch of lime, gravity, fade in 450 ms, tiny soft halo) plus 30 micro sparks (1-2 px, fast, 0.2 s) from behind the word, a thin anamorphic light streak across the word (0.3 s) and a landing light pulse that boosts the wall bounce.
- `insane`: lands with a lime ring shockwave (thin ring, radius expands to 620 px in one sharp frame, no smear, fades in 340 ms) and a second thin white ring. The ring also lenses the wall behind me: displace the plate radially along the ring (about 12 px, odd-profile gaussian, sigma 30 px) with an RGB split (0.85 / 1.0 / 1.18) so it reads as dispersion, and leave me unwarped (use my matte). Letters land one by one with a 28 ms stagger, left to right, each coming in from the camera side (scale 1.36 -> 1 with a 6 px blur) and dropping only about 10 % of its type size (a stamp, never a long fall through the older lines).
- `captions`: the word slams down from just above its slot (a drop of 12 % of its type size, so it never crosses the older lines), coming from the camera side (scale 1.18 -> 1, 9 px blur -> 0) with motion blur (6+ sub-frames), squashes 12 % on landing, then stretches back.
- `popping`: each letter pops like a bubble: 45 ms stagger, each letter scales 0 → 1.3 → 1 with a tiny white burst.
- No exit animation. The words that are on screen stay there, and the clip ends 0.06 s after the end of my last sound (find it from the audio energy).
**Craft Rules**
- Render all vector graphics (cards, text, lines, rings) at 2x and downsample with a Lanczos filter, so edges are crisp with no jaggies. Use premultiplied alpha when compositing. Lanczos rings on hard edges (bright rim on dark, green on dark): clamp each downsampled pixel to the min/max of its 2x source block so there are no halos.
- Shadow and glow sizes written as "blur N" mean a CSS/Figma blur: Gaussian σ = N / 2.
- Glows and light are added in linear light (convert sRGB to linear, add, convert back), built from 3 stacked Gaussian blurs (tight, medium, wide), so they look like light, not like a grey haze.
- Motion: no linear moves. Entrances use a spring (stiffness ~170, damping ~18, small overshoot) or easeOutExpo; exits use easeInCubic. Stagger related elements by 60-90 ms. Nothing stops dead: let things settle over 150-250 ms. "Lands" = the moment its entrance spring first reaches its target. If the clip ends before a timed beat would finish, move that beat earlier so it completes before the end.
- Fast moves get motion blur: render 5-8 sub-frames per frame for the moving layers and average them.
- Numbers use tabular (monospaced) digits so they don't wobble while they count up, with easeOutExpo counting and a K/M suffix.
- Fonts: use SF Pro Display / SF Pro Text if installed (macOS), otherwise Inter. Small labels in a monospace (SF Mono, JetBrains Mono or Menlo) in caps with 8-12 % letter spacing.
- Sound levels: normalise each sound on its own, then mix so the main hits (clicks, landings, chimes) peak about 9 dB below the RMS of my speech, and beds/whooshes have their loudest 100 ms RMS about 15 dB below my speech RMS. Low thumps get 2nd/3rd harmonics so phone speakers play them. Every sound must be audible on a phone at normal volume and never mask a word. (Where a prompt says "mix N dB under my voice", read it as this rule.)
**SOUND**
Synthesize and mix under my voice (clearly audible on a phone, +4 dB over the rule below, never masking a word):
- Every normal word: a soft tactile tick (2 ms click + 900 Hz -> 500 Hz sine, 40 ms) with a short wooden body (190 Hz, 16 ms) so it lands with weight.
- Hero word: a clean deep thump (70 Hz, 120 ms, harmonics for phones) + a sub boom (46 -> 80 Hz, 0.45 s) + a 3 ms high crack + a short airy whoosh 80 ms before the landing + a glassy high ping in key (1 per hero) + a 0.7 s sparkle tail (nine random 3-9 kHz partials) + a rising airy light-sweep shimmer under the sweep + a tiny tink on each glint.
- Every stack move (older lines clearing): a soft low-passed noise whoosh sweeping 350 -> 2000 Hz, 0.2 s, 4 dB under the hero whoosh.
- `popping` letters: a tiny bubble blip per letter. Never crunchy or rough.
**Workflow + QA**
1. First render 4 full-resolution stills (start of entrance, mid entrance, settled, and mid exit or the last frame) and LOOK at them: check the graphics are crisp, sit in the right place on MY frame, nothing covers my face, text is readable on a phone. Fix and re-render before doing the full video.
2. Then render the full clip, encode with ffmpeg: H.264, `-crf 16 -preset slow -pix_fmt yuv420p`, same fps, `-movflags +faststart`, keep my audio with the effect's sounds mixed in. Also make a side-by-side `compare.mp4` (original | effect) and a contact sheet of 12 frames.
3. Check the last frames too (no half-finished animation unless it is meant to exit). Tell me the output paths./liquid-lens — a big blob of clear liquid glass grows out of my real fingertip while I say the line
I'm attaching me.mp4: a vertical clip (9:16, me seated in the middle) where I talk with my index finger raised. Build this effect in code and export result.mp4: the whole vertical frame 1080x1920, 59.94 fps, H.264, my audio untouched, my footage and colours untouched.
**EDIT THESE:**
- Start: the effect starts at `0.5 s` into the clip (if I give you a transcript with word times, start at my first word instead). Everything below is timed from this start.
SETUP
Canvas 1080x1920, my clip fills it (no bars, no zoom). Track my index fingertip and its direction with hand landmarks (smoothed over a few frames). Everything is timed from the start: start = 0, the clip ends 0.06 s after my last sound. Render frame by frame in a WebGL2 shader (ray-marched, linear light) with real motion blur.
THE LOOK
One blob of liquid glass: a smooth union of a wobbling ellipsoid, two sloshing lobes, a neck and droplets, ray-marched. Light really refracts through it (index 1.45, red / blue split 0.034 so the edges split into colour), twice - in and out - and lands on my real room behind it, so my face, my hand and the room's lights appear upside down inside the glass. Fresnel rim all round, sharp speculars from my own lights (sample their colours and positions from my clip) and a second-surface reflection like real glass. Nothing grey or milky: almost no absorption, no haze. Soft shadow and a warm / cool pool of light cast on the wall and my hair, a warm glow where the liquid leaves my fingertip, bloom only from the glass highlights, star glints, fine grain.
TIMING (seconds after the start)
0.07 a drop pops out of the fingertip (spring) and sits on it, following the finger.
0.1-2.2 it grows to about 50 % of the frame width (a radius of 0.88 face heights) - a drop, then a bulb, then a blob.
1.1 it lifts off above my head (overshoot spring) on a neck of liquid that stretches, thins and sags with the finger; two droplets bud off the neck and are pulled back in.
1.9 the neck pinches and snaps: three droplets fly, merge into the blob or back into the finger, two tiny sprays, a bead on the fingertip, the blob jolts and wobbles with slow heavy ripples.
2.0-2.26 the free blob floats and keeps growing; a light sweep and a flash on the snap. Hard stop on the last frame (no freeze).
The blob never covers my eyes or mouth (it floats above my hair).
SOUND
Soft wet glass: a liquid pop for the drop, a swell bed while it grows, a reverse suction that peaks at the lift-off, water bubbles for the buds, a liquid impact + drop sweetener + pop on the snap, a wobbly pop, glass taps for the droplets merging, a soft bell and a glass shimmer. Clearly audible (peaks -19 dB).
RULES
My face and colours stay untouched, the glass never covers my eyes or mouth./light-writer — my fingertip is the brush: a white-hot light sits on the tip of my finger the whole time and paints a glowing ribbon wherever I move it
I'm attaching me.mp4: a vertical clip (static camera, me seated at a mic, dark room, 1080x1920, my whole frame) where I talk while I draw loops in the air with my right index finger. Build it in Python (numpy + OpenCV): the same 1080x1920, 59.94 fps, H.264, my audio untouched, no bars, no zoom, no crop. The clip ends 0.06 s after my last word; my footage plays live to the end, nothing freezes.
**EDIT THESE:**
- Start: the effect starts at `0.5 s` into the clip (if I give you a transcript with word times, start at my first word instead). Everything below is timed from this start.
SETUP
- Track my right index fingertip with MediaPipe Hands. Fill short gaps with the hand landmarks, remove one-frame spikes, smooth it (One-Euro / gaussian) and resample the track at 4x the video rate so the path is a continuous curve with no jumps.
- Matte me with a person matte (subject mode).
THE LIGHT (one pen, one ribbon)
- 0.3 s after the start, a white-hot pen head ignites on my fingertip (small ring flash) and stays on the tip for the whole clip, following the real tip at every frame. It never leaves my finger.
- Behind the tip the real finger path is painted as a persistent ribbon of light: white-hot core 2.6 px, body 7.5 px (slower = fatter and brighter, a fresh section is thicker and white-hot, cooling to cream then terracotta over 0.3 s), bloom at 6, 20, 56 and 130 px (Screen), a warm wash on the wall where it passed. The ribbon stays lit and fades only slowly at its oldest end (down to about 45 % after 2 s).
- Older ribbon passes BEHIND my head (my matte hides it), only the fresh part near the tip is in front, so the light never sits on my eyes or mouth.
- Cream and terracotta sparks drift off the ribbon, 1-2 px, twinkling.
RULES
- My face, skin and room untouched (light only added, my own grade on the footage), my fingertip stays in frame.
SOUND
A soft continuous hum and airy shimmer that follow the speed of my hand (louder and brighter when I move fast, almost silent when I hold still) and pan with the fingertip, a tiny bell ting at ignition; 15 dB under my voice./chrome-title — a giant black-chrome CLAUDE rises behind my head and arches over it
I'm attaching me.mp4: a vertical 9:16 talking-head clip (static camera, me seated and centred, dark room). Build this effect in code and export result.mp4 — 1080x1920, 59.94 fps, H.264, my audio untouched.
**EDIT THESE:**
- Start: the effect starts at `0.5 s` into the clip (if I give you a transcript with word times, start at my first word instead). Everything below is timed from this start.
SETUP
- Cut me out with a video-matting model (Robust Video Matting or SAM 2), soft hair edges. Build a clean plate of my room (median of the frames where I am masked out, inpaint the rest).
- Render the word in Blender 4.5 Cycles: GPU, 40 samples + denoise, motion blur 180 degrees, f/3.2, Standard view transform so blacks stay black.
THE LOOK
- Six separate letters C-L-A-U-D-E in Anton: cap height 340 px, squeezed so the word is 900 px wide (x 85-995), extrude 20 px per side, rounded bevel 17 px (10 segments). Gentle arch (radius 1900 px), whole word yawed 7 degrees, middle tops 50 px below the top edge. My head hides only the lower half of A and U.
- Material: black chrome — metallic 1, roughness 0.04 plus a fine noise bump.
- The environment is everything. Make an almost-black equirect map with my clean plate where the camera sees it, and in front of the letters: a narrow panel for my main light and a thin strip for my second light, each in the colour sampled from the lights in my clip, one bright overhead softbox slit, one crisp horizon slit crossing each face, and three tiny hot bulbs that only flash on the bevels. Drift the map slowly (9 degrees over the clip) so reflections never freeze.
- Composite letters over the room, then me on top with my matte (decontaminate edge pixels against the plate). Add a soft cast shadow and contact halo on the wall, a faint warm/cool bounce, light wrap on my hair edge, bloom only on highlights.
TIMING (seconds from the start)
- -0.29: letters start behind my torso, 50 ms apart left to right, leaning back 18 degrees.
- 0.0 to +0.4: they rise past my shoulders and fan out.
- +0.35 to +0.55: spring into place (2 % overshoot) while pitching forward and rolling into the arch; the horizon slit races down each face.
- +0.68 to +1.33: a narrow diagonal light strip (55 px, 34 degrees) sweeps left to right; a fainter cool one follows at +1.93.
- Hold: gentle sway and float, camera push-in 2.5 %. Nothing stops dead.
SOUND
Soft tonal riser under the rise, felt metallic thump on landing, quiet glassy shimmer on the glint, 15 dB under my voice.
RULES
My face and room colours stay untouched, no camera shake, the word stays inside x 70-1010, motion blur on everything that moves./glass-shatter (REAL GLASS) — a real pane of glass in front of the lens is smashed, in high-speed slow motion, and my live picture shows through every piece
I'm attaching me.mp4: a vertical 9:16 talking-head clip (static camera, me seated, dark room) with my mic audio. Build this effect in code and export result.mp4 — 1080x1920, 59.94 fps, H.264, my picture and my audio untouched (only my own colour grade). The clip ends 0.06 s after my last sound (hard cut, it may catch the last pieces); I keep talking live the whole time, nothing freezes.
**EDIT THESE:**
- Start: the effect starts at `0.5 s` into the clip (if I give you a transcript with word times, start at my first word instead). Everything below is timed from this start.
SETUP
- Blender 4.5, Cycles on the GPU (highest sample count that fits about 30 min, 160 samples + OpenImageDenoise, motion blur 0.6 shutter, 16 light bounces, no caustics), Standard view transform. Camera 50 mm, 15 units from the pane, 1 unit = 100 px at the pane. My frame is an emission plane 2.2 units behind the pane (it is the only thing the glass refracts), focus between pane and picture, aperture f/0.5 so only the near flying pieces blur.
- Impact point = my knuckle/palm at the moment of the push (taken from my hand, pulled at least 150 px inside the frame). If I do not push, use the hand nearest the camera at the start time, or the upper chest if no hand is in view.
- Fracture the pane like a real impact (Voronoi on seeds, clipped to the frame, 130 pieces): a crushed core of tiny cells, 11 log-spaced rings elliptically stretched with wobbling radii and about one seed in seven missing (open arcs), 11 principal radial cracks with uneven spacing whose gaps grow forks in the outer rings, 3-level jagged edges. Every shared edge gets the same kinks so neighbours match exactly.
THE LOOK (everything is geometry and light, no drawn crack lines)
- Every piece is a real glass slab: 7 mm (0.24 units) with its own thickness, a 1-3 px bevel on every edge (these bevels ARE the hairline cracks and catch the light), and a slight wedge (thickness varies a few hundredths of a unit across the piece) so my picture visibly splits and offsets across neighbouring pieces. Glass shader: three Glass BSDF lobes with IOR 1.512 / 1.520 / 1.529 (subtle dispersion, rainbow fringes on the cracks), fresnel reflections, a faint green iron absorption volume (greener edges).
- Light: a studio painted from my room, all behind the camera: a big soft panel with a window grid on one side and a cool window with mullions on the other, thin hot strips, a thin LED-like strip, all in the colours sampled from the lights in my clip, a long overhead softbox with a mullion pattern and thin white slits, side/top strips for the bevels, round pinpoint bulbs for sparkle. The rectangle a flat pane mirrors (my field of view) stays dark so intact glass never veils my picture; panels start outside it, so only tilted/tumbling pieces catch sharp glints. The world drifts 9 degrees so glints crawl.
- Impact: a small white crushed crater (ragged rim, grainy white with dark voids), about 22 hairline radial micro-fractures with small branches, 46 tiny bright chips around it, a 2-frame flash. 34 real glass chips are thrown out of the core toward the lens.
- The cracks arrive with a front travelling at 36000 px/s (the whole frame in 3-4 frames); each piece tilts 0.55 degrees on its own axes and lifts a few hundredths of a unit; the tilt keeps growing while the pane holds (creak), pieces over my face tilt less.
TIMING (seconds from the start)
- Crack at 0.45 s: crater + web in 3-4 frames, pane holds for 0.28 s with the creak.
- The pane lets go at 0.73 s (right after the 0.28 s creak): release runs outward from the impact at 9000 px/s. Physics (numpy, 240 Hz): slow-motion burst (speed 0.24) that ramps to 1.7 by 0.62 s after the break, gravity 6.5 units/s2, air drag, tumble with quaternions, sphere collisions between pieces (restitution 0.35, spin kick). Big pieces fly toward the camera and out sideways; pieces over my face leave first and fast, so my eyes and mouth are clear while I keep talking. Every piece is out of frame 1.0 s after the break.
- 34 chips from the core, then 420 specks of glass dust launched from the cracks; every speck flashes when its face turns to the lens (facing-ratio emission), so the dust sparkles. Nothing hangs in the air: gravity and drag move everything until the cut.
- A tiny (1-3 %) push-in on the whole clip.
SOUND (physically modelled, no recording used; 48 kHz stereo, peaks around my voice level on the break, my voice stays clear)
- Impact: 1-3 ms broadband transient, 2-6 kHz snap, 5 damped partials at 3.1-10.4 kHz, crushed-core grit; sparse micro-ticks (creak) while the pane holds, denser toward the break.
- The break: 520 inharmonic modal partials 1.5-14 kHz (decays 15-120 ms shorter for higher pitch, random onsets, dense in the first 150 ms), 700 granular shard grains (1-9 ms band-passed noise), the mid body of the crash 350-1900 Hz, 14 clunks (260-900 Hz) of the big pieces, one glass tink at each piece's release time (pitch from its size, panned to where it is), a low body thump 160 to 75 Hz with 2nd/3rd harmonics for phone speakers.
- Falling tinkles: one tink + click for every simulated collision, 26 pitched "Glass Tap Tiles" samples, a decaying Poisson rain of tiny dust tinks; light room reverb (0.55 s tail, early reflections), soft glue saturation, 15.5 kHz low-pass.
RULES
My face and room colours untouched (only glass is added), nothing flat, no drawn lines, motion blur on everything that moves, the glass never covers my eyes/mouth with a big piece once the pane has let go./glass-halo — three thick glass gyroscope rings spin around my head while I say the line
I'm attaching me.mp4: a vertical clip (9:16, me seated in the middle) where I talk. Build this effect in code and export result.mp4: the whole vertical frame 1080x1920, 59.94 fps, H.264, my audio untouched, my footage and colours untouched.
**EDIT THESE:**
- Start: the effect starts at `0.5 s` into the clip (if I give you a transcript with word times, start at my first word instead). Everything below is timed from this start.
SETUP
Canvas 1080x1920, my clip fills it (no bars, no zoom). A subject cut-out of me (matte) lets the far half of every ring pass behind my head and body. Everything is timed from the start: start = 0, the clip ends 0.06 s after my last sound. Render frame by frame in a WebGL2 shader (ray-marched, linear light) with real motion blur.
THE LOOK
Three real glass rings, each a thick tube (tube radius 0.085-0.105 face heights), ray-marched as tori:
1. a halo ring above my head (radius 1.22 face heights, tilted 72 degrees), 2. a hoop around my head (radius 1.15, opened 46 degrees, side arcs well clear of my face), 3. a wide ring round my shoulders (radius 1.5, tilted 68 degrees).
Light really refracts through every tube twice (index 1.45, red / blue split 0.04): you see my room - its lights, my hand, my face - bent and flipped inside the glass. Fresnel rim, sharp speculars from my own lights (sample the light colours from my clip), second-surface reflections. Light text is engraved on the rings ("GLASS RING" and "AROUND YOUR HEAD" in IBM Plex Mono, small light ticks on the wide ring), the rings spin along their own axes and wobble a few degrees like a gyroscope until the last frame. The glass casts a soft shadow and a warm / cool caustic streak on my hair, wall and shoulders (kept off my face), a warm / cool light pool lies on my hair, sparkle motes drift along the rings, star glints, bloom only from the glass highlights, fine grain.
TIMING (seconds after the start)
0.11 the halo ring flies in from above (spring, overshoot) and lands on my head by 0.40.
0.41 the hoop is DRAWN around my head by a bright point of light, 0.62 s, in its final position; it opens from 66 to 46 degrees.
0.73 the wide ring is drawn the same way round my shoulders (0.74 s).
0.5-1.6 a light sweep, a flash as the halo lands, glints.
until the end: spin + gyroscope wobble, motes; the clip stops 0.06 s after my last sound (no freeze).
No ring ever crosses my eyes or mouth.
SOUND
Crystal whooshes as each ring comes in / is drawn, a soft bell and glass taps when each ring locks, a glass shimmer bed and a glassy spin whoosh. Clearly audible (peaks -18 dB).
RULES
My face and colours stay untouched, the rings never cover my eyes or mouth, nothing leaves the frame edges (the wide ring stops inside it)./card-storm — a tornado of holographic foil cards leaves my fingertip, whips round me and keeps swirling around me until the cut
I'm attaching me.mp4: a vertical 9:16 clip where I talk with my index finger raised (static camera, me seated at a mic in a dark room, my whole frame, 1080x1920, no bars, no zoom). Build it in code (three.js + canvas, one pure function of time) and export result.mp4 — 1080x1920, 59.94 fps, H.264, my audio untouched, ending 0.06 s after my last word. My footage plays live to the end.
**EDIT THESE:**
- Start: the effect starts at `0.5 s` into the clip (if I give you a transcript with word times, start at my first word instead). Everything below is timed from this start.
SETUP
- Track my raised index fingertip (MediaPipe) and cut me out with a person matte (subject mode).
- 40 cards: 18 paper cards (cream paper, a risograph ink blob and a name: the effects of this set), 8 dark UI cards (terminal, chat, toggles, ring, timeline, code, pills, stats), the rest paper cards again. Each card is a slightly curved thin plane with a stack of three offset edge layers (thickness), rounded corners, a foil back.
- HOLOGRAPHIC FOIL: paper areas and a thin frame turn into iridescent foil. The hue comes from the view angle, the position on the card and the reflection direction, so a rainbow sheen sweeps across every card as it turns; narrow diagonal bands, tiny glitter flakes that flash with the angle, a crisp glint band, a fresnel rim. Reflections come from an environment map painted from MY room (the colours and positions of the lights in my clip, sampled from the plate, plus a soft box above).
THE TORNADO
- 0.3 s after the start the first card leaves my fingertip (a small glow gathers on the tip first, a ring flashes on release), then one card every 14 ms.
- Every card rides a smooth helical orbit round my body: the cards sit on a funnel-shaped helix (wide above my head, narrow at my belly, 4 turns, rings tilted 33 degrees with the front lower). Starting at my fingertip each card whips 1-1.6 turns round the vortex while it decelerates (position, azimuth, height and radius ease on different clocks, so nothing snaps) and then keeps turning slowly, with gentle breathing, rolling and tumbling, until the cut.
- Cards pass IN FRONT of me and BEHIND me (matte), crossfading in a 100 px band round my plane. A front card never covers my face: it is eased over the hair or under the chin on a fixed side, never sideways across the face.
- Depth of field: near cards are large and soft, far cards soft; slight camera yaw drift; real motion blur (adaptive sub-frames, 180 degree shutter).
- Light ribbons trail behind every card (0.55 s of its path, foil colours), drawn in front of / behind me where they really are, and faded where they would cross my face.
- Contact shadows of the cards on the wall behind me and on my body, rainbow light cast on the wall, floating dust and bokeh, glitter sparks shed along the paths, a slow foil sweep over the cards near the end.
SOUND
A soft air burst when the first card leaves, a paper flick every third card, an airy riser as the vortex forms, a tonal tick as every fourth card settles (pentatonic), a glass shimmer pad under the whole clip, a whoosh and a bell on the foil sweep; 15 dB under my voice.
More guides
All guides
You did it
Nice! Now try another effect, or send this to a friend.
Get new guides first
Daily AI news and the newest guides. No spam.
More guides
Copy Any Editing Style with ClaudeClaude
Desktop Rug: Hide Your Mess Under a Virtual RugClaude
Build a Cursor-Following Character WebsiteClaude + SeedanceCopied. Now paste it in Claude Code.