---
title: "How to add a screen melt transition with Claude (tested prompt and script)"
description: "Clip A splits into 8-pixel vertical strips that slide down off the bottom one after another, speeding up as they go, so its top edge turns into a ragged row of drips with clip B showing above it. Install one skill and ask Claude Code, or run the Python script we tested yourself."
url: https://www.recharm.com/effects/screen-melt-transition
---

# How to add a screen melt transition with Claude

Clip A splits into 8-pixel vertical strips that slide down off the bottom one after another, speeding up as they go, so its top edge turns into a ragged row of drips with clip B showing above it.

Made by the script on this page, from our own test clips.

## Get this effect

1. ### Switch to Code in your [Claude Desktop App](https://claude.com/download)

2. ### Install the skill (once)

   ```
   Install the Recharm video effects skill: download https://recharm-growth-staging.s3.us-east-2.amazonaws.com/website/downloads/recharm-video-effects.zip and unzip it into ~/.claude/skills
   ```

3. ### Ask for the effect

   ```
   Join clipA.mp4 and clipB.mp4 with a screen melt transition
   Length of the transition in seconds: 1.0
   Width of each falling strip in pixels: 8
   ```

## Several videos, several effects, one ask

Put your clips in the folder, mention them with @, and ask for everything at once. Claude runs one tested script after another on each clip, then joins them.

Put a sale badge on **@clip1.mp4**, give **@clip2.mp4** a VHS look, then join them with a screen melt transition.

## Settings you can change

Ask Claude to change any of these, or edit them at the top of the script.

| Setting     | Default | What it does                                                 |
| ----------- | ------- | ------------------------------------------------------------ |
| `D`         | `1.0`   | Length of the transition in seconds.                         |
| `STRIP`     | `8`     | Width of each falling strip in pixels.                       |
| `MAX_DELAY` | `0.3`   | Latest a strip starts falling, as a share of the transition. |
| `SHADOW`    | `40`    | Height in pixels of the shadow above each strip.             |
| `SEED`      | `7`     | Random seed for the drip pattern.                            |

## Without the skill

Don’t want to install the skill? Paste this prompt into Claude Code and Claude writes the script itself.

```
Join clipA.mp4 and clipB.mp4 with a 1 second screen melt transition (the melt from classic DOOM). It starts 1 second before A ends, so the result is A's length plus B's length minus 1 second. Cut clip A into vertical strips 8 pixels wide. Give each strip a start delay between 0 and 0.3 of the transition, taken from a random walk across the strips so neighbors start close together; once a strip starts it slides straight down, its offset growing with the square of time until it has moved the full frame height by the end of the transition. A keeps playing inside the strips, and clip B, starting from its first frame, plays behind them in the gap that opens above each strip. Darken B to 50% brightness right above each strip's top edge, fading back to full over 40 pixels, so the drips cast a shadow. Crossfade the audio over the same 1 second. Match B's size to A and output 30fps. Use Python with numpy for the strips and ffmpeg to decode and encode, and save it as output.mp4.
```

## Run it without Claude

This is the exact script we tested. Save it as `screen-melt-transition.py` and run:

```
python3 screen-melt-transition.py clipA.mp4 clipB.mp4 output.mp4
```

```
#!/usr/bin/env python3
"""Screen melt transition: over 1s clip A breaks into thin vertical strips that slide down the frame at staggered, speeding-up rates, like melting wax, uncovering clip B behind them.

Usage: python3 screen-melt-transition.py clipA.mp4 clipB.mp4 output.mp4  (both clips need an audio track)
Needs ffmpeg and numpy (pip install numpy).
"""
import json
import subprocess
import sys
from itertools import islice

import numpy as np

D = 1.0           # transition length in seconds
FPS = 30          # output frame rate
STRIP = 8         # strip width in pixels
MAX_DELAY = 0.3   # latest a strip starts falling, as a share of the transition
SHADOW = 40       # height in pixels of the shadow each strip casts on clip B above it
SEED = 7          # change for a different drip pattern

def probe(path):
    info = json.loads(subprocess.check_output(["ffprobe", "-v", "error", "-select_streams", "v:0", "-show_entries",
                                               "stream=width,height:format=duration", "-of", "json", path]))
    return info["streams"][0]["width"], info["streams"][0]["height"], float(info["format"]["duration"])

def frames(path):
    """Decode a clip as w x h RGB frames at FPS, cropping it to fill the frame if its shape differs."""
    ff = subprocess.Popen(["ffmpeg", "-v", "error", "-i", path, "-vf",
                           f"scale={w}:{h}:force_original_aspect_ratio=increase,crop={w}:{h},fps={FPS}",
                           "-f", "rawvideo", "-pix_fmt", "rgb24", "-"], stdout=subprocess.PIPE)
    while True:
        data = ff.stdout.read(w * h * 3)
        if len(data) < w * h * 3:
            return
        yield np.frombuffer(data, np.uint8).reshape(h, w, 3)

def start_delays():
    """When each strip starts falling: a random walk across the strips, so neighbors start close together
    and the top edge of A forms ragged drips rather than noise."""
    steps = np.random.default_rng(SEED).uniform(-1, 1, -(-w // STRIP)).cumsum()
    steps = (steps - steps.min()) / max(np.ptp(steps), 1e-6)
    return np.repeat(steps * MAX_DELAY, STRIP)[:w]

def melt(a, b, p):
    """One transition frame at progress p (0-1): each strip of A shifted down by its own amount, B behind."""
    fall = np.clip((p - delays) / (1 - MAX_DELAY), 0, 1) ** 2   # 0-1 per column, speeding up as it falls
    drop = np.round(fall * h).astype(int)
    rows = np.arange(h)[:, None] - drop[None, :]                  # which row of A lands on each output row
    cols = np.broadcast_to(np.arange(w), (h, w))
    shade = 1 - 0.5 * np.clip(1 + rows / SHADOW, 0, 1)            # B darkens just above the top edge of each falling strip
    under = (b * shade[..., None]).astype(np.uint8)
    return np.where((rows >= 0)[..., None], a[np.clip(rows, 0, h - 1), cols], under)

A, B, out = sys.argv[1:4]
w, h, length = probe(A)
delays = start_delays()
cut_in = round((length - D) * FPS)   # first frame of the transition
n = round(D * FPS)                   # frames in the transition

enc = subprocess.Popen(["ffmpeg", "-y", "-v", "error", "-f", "rawvideo", "-pix_fmt", "rgb24", "-s", f"{w}x{h}",
                        "-r", str(FPS), "-i", "-", "-i", A, "-i", B,
                        "-filter_complex", f"[1:a][2:a]acrossfade=d={D}[au]", "-map", "0:v", "-map", "[au]",
                        "-c:v", "libx264", "-crf", "18", "-pix_fmt", "yuv420p", "-c:a", "aac", out],
                       stdin=subprocess.PIPE)
clip_a, clip_b = frames(A), frames(B)
for a in islice(clip_a, cut_in):
    enc.stdin.write(a.tobytes())
for i, (a, b) in enumerate(zip(islice(clip_a, n), islice(clip_b, n))):
    enc.stdin.write(melt(a, b, (i + 1) / n).tobytes())
for b in clip_b:
    enc.stdin.write(b.tobytes())
enc.stdin.close()
if enc.wait():
    sys.exit("ffmpeg failed")
```

## More transitions

- [Barn door transition **Barn door transition**](https://www.recharm.com/effects/barn-door)
- [Blinds transition **Blinds transition**](https://www.recharm.com/effects/blinds-transition)
- [Block dissolve **Block dissolve**](https://www.recharm.com/effects/block-dissolve)
- [Blur transition **Blur transition**](https://www.recharm.com/effects/blur-transition)
- [Bounce transition **Bounce transition**](https://www.recharm.com/effects/bounce-transition)

## Find 3x _winning ads_

Recharm cuts your ad footage into tagged, searchable clips: hooks, testimonials, product shots. Find the shots that win, add the effect with Claude, and ship 3x more ad edits.

[Start 14-day free trial](https://www.recharm.com/get-started)