Yes, a slowed or screwed version needs its own peak check, and often a light re-master. Slowing a song changes its length, pitch and tone, and it can turn peaks that were hiding between samples into real ones. Adding reverb or echo stacks new peaks on top. Measure the slowed render, and keep its true peak under −1 dBTP before it goes to a store or a streaming service.

Slowed versions are everywhere now: the official “slowed + reverb” cut next to the original, the screwed tape a DJ makes for the car, the half-speed edit for a video. They feel like a creative bonus, so they tend to skip the checks the main master got. That’s where the trouble starts. The slowed file is a new render, and the meter doesn’t care how good it sounds.

What actually changes when you slow a song down?

The classic screw sound comes from slowing the whole record, the way a turntable or tape machine does when you drop the speed. Tempo and pitch go down together. The Houston style that DJ Screw pioneered pulled songs down to roughly 60 to 70 BPM and then chopped, skipped and repeated parts on top. Digital tools call this varispeed: play the samples back at a lower rate, then resample to a normal rate like 44.1 or 48 kHz.

Three things move when you do that:

• Length. At 80% speed a three-minute song runs three minutes and 45 seconds.
• Pitch and tone. Everything drops, by about four semitones at 80%. Energy moves toward the low end, so the song feels heavier.
• Measured loudness. Loudness meters built on ITU-R BS.1770 weight the upper mids more than the deep lows. When the song’s energy slides down, the reading usually drops a little, about a LU in our test below, even though nobody turned anything down.

What doesn’t change is the rulebook at the other end. A store or streaming service measures the slowed file exactly as it measures any other master.

Why can a slowed version clip when the original didn’t?

There are two common reasons, and they stack.

The first is peaks between samples. A loud master often has a sample peak of −0.1 dBFS but a true peak over 0 dBTP, because the smooth wave the samples describe rises higher between them. Those are the overs that codecs and converters run into. When you slow the song and resample it, the new samples land in new places on that same wave, and some land right on top of those hidden peaks. The over that only a true-peak meter could see becomes a real sample value over full scale. If anything downstream works in fixed point, that’s hard clipping.

The second is what you add. Slowed versions almost always get extra processing: reverb, echo, a bass boost, a bit of saturation. Reverb and echo are delayed copies of the song mixed back in. On a sustained pad they mostly add a wash. On a kick, a snare or a hard vocal consonant, the delayed copy can land on the next hit and the two add together. A master with a perfectly legal peak can come out of a reverb plugin a dB or two over.

There’s also a quieter third reason: people slow the loud master, the one that was already squeezed to the ceiling, because it’s the file they have. That master had no headroom to begin with.

How do you check a slowed render?

Measure it like any other master: integrated loudness plus true peak. Here’s a small script that does the slowdown and the before/after check in one go. It uses FFmpeg’s asetrate, aresample and ebur128 filters, so the only things you need are Python and FFmpeg. It writes a 32-bit float file, so nothing is clipped on disk while you look at the numbers.

#!/usr/bin/env python3
"""screw_check.py: slow a finished master the way a screw/varispeed render does, then check it again.
Usage: python3 screw_check.py MASTER [SPEED] [--reverb]
SPEED 0.8 = 80% speed (pitch drops with tempo, like slowing a record). --reverb adds a simple echo tail
like the "slowed + reverb" style. Prints integrated loudness and true peak (FFmpeg ebur128, ITU-R BS.1770)
before and after, and the gain that puts the slowed render back under -1.0 dBTP.
Writes slowed.wav (32-bit float, so nothing is clipped on disk). Your master is only read.
Needs: Python 3, FFmpeg on PATH."""
import re, subprocess, sys

def meter(path):
    err = subprocess.run(["ffmpeg", "-hide_banner", "-nostats", "-i", path, "-af", "ebur128=peak=true+sample",
                          "-f", "null", "-"], capture_output=True, text=True).stderr
    peaks = re.findall(r"Peak:\s+(-?[\d.inf]+) dBFS", err)
    return dict(I=float(re.findall(r"I:\s+(-?[\d.]+) LUFS", err)[-1]),
                SP=float(peaks[-2]), TP=float(peaks[-1]))

def render(src, dst, speed, reverb):
    rate = int(re.search(r"(\d+) Hz", subprocess.run(["ffmpeg", "-hide_banner", "-i", src],
               capture_output=True, text=True).stderr).group(1))
    chain = f"asetrate={rate * speed:.0f},aresample={rate}"      # varispeed: tempo and pitch together
    if reverb:
        chain += ",volume=-12dB,aecho=1.0:1.0:60|130|210:0.35|0.25|0.15,volume=12dB"  # echo tail added to dry (run 12 dB down: aecho clips at full scale)
    subprocess.run(["ffmpeg", "-v", "error", "-y", "-i", src, "-af", chain, "-c:a", "pcm_f32le", dst], check=True)

def main(src, speed=0.8, reverb=False):
    a = meter(src); render(src, "slowed.wav", speed, reverb); b = meter("slowed.wav")
    label = f"slowed {speed:.0%}" + (" + reverb" if reverb else "")
    print(f"{'':20}{'LUFS':>8}{'sample pk':>11}{'true pk':>9}")
    for name, d in (("original", a), (label, b)):
        ok = "ok" if d["TP"] <= -1.0 else "OVER -1 dBTP"
        print(f"{name:20}{d['I']:8.1f}{d['SP']:+11.1f}{d['TP']:+9.1f}  {ok}")
    if b["TP"] > -1.0:
        g = -1.0 - b["TP"] - 0.1
        print(f"\nturn the slowed render down {-g:.1f} dB (or re-limit it with true-peak mode) before upload")
    else:
        print("\nslowed render is under -1.0 dBTP")

if __name__ == "__main__":
    args = [x for x in sys.argv[1:] if not x.startswith("--")]
    main(args[0], float(args[1]) if len(args) > 1 else 0.8, "--reverb" in sys.argv)

We ran it on synthetic test material, not a real song: a 30-second generated beat with a kick, a snare, hats, bass and chords. One copy is a typical loud bounce, pushed 6 dB into a sample-peak limiter at −0.1 dBFS. The other is the same master turned down so its true peak sits at a legal −1.2 dBTP.

$ python3 screw_check.py master.wav 0.8
                        LUFS  sample pk  true pk
original                -7.6       -0.1     +1.2  OVER -1 dBTP
slowed 80%              -8.7       +1.1     +1.1  OVER -1 dBTP

turn the slowed render down 2.2 dB (or re-limit it with true-peak mode) before upload

$ python3 screw_check.py master_legal.wav 0.8
                        LUFS  sample pk  true pk
original               -10.0       -2.5     -1.2  ok
slowed 80%             -11.1       -1.3     -1.3  ok

slowed render is under -1.0 dBTP

$ python3 screw_check.py master_legal.wav 0.8 --reverb
                        LUFS  sample pk  true pk
original               -10.0       -2.5     -1.2  ok
slowed 80% + reverb    -10.5       +0.9     +0.9  OVER -1 dBTP

turn the slowed render down 2.0 dB (or re-limit it with true-peak mode) before upload

Here’s what those three runs show, still on synthetic audio:

• The loud master was already illegal (+1.2 dBTP) even though its sample peak read −0.1 dBFS. Slowing it barely moved the true peak, but the sample peak jumped from −0.1 to +1.1 dBFS. The hidden over became a real one.
• The legal master stayed legal when we only slowed it (−1.3 dBTP). Slowing on its own is not the villain.
• Add a simple three-tap echo tail and the same legal master came out at +0.9 dBTP, about 2 dB over the line.

Your song will give different numbers. That’s the point: you can’t predict them, so you measure them.

What should you do when the slowed version is over?

You have three fixes. Pick the highest one you can.

1. Slow the mix, then master it. If you have the session or a pre-limiter bounce, slow that and add your reverb, then put the limiter last. The limiter then sees the peaks it actually has to catch. This sounds best, because the limiter isn’t fighting a file that was already limited once.
2. Run a true-peak limiter on the slowed render. Set its ceiling to −1 dBTP (or −2 dBTP for a loud master) and turn on its true-peak or oversampling mode. Keep the gain reduction small. If it’s working hard, go back to fix 1.
3. Turn it down. Plain gain is the cleanest fix of all. The script prints how much it takes. A slowed version a couple of dB quieter is usually fine, for the reason in the next section.

Then measure again. Every fix is a new render, and the only number that counts is the one from the file you upload.

Should a slowed version be as loud as the original?

It doesn’t have to be. Most streaming services turn tracks up or down to a common level when people play them. Spotify’s loudness normalization page says it adjusts tracks to −14 LUFS by ITU 1770, asks for true peak below −1 dBTP, and asks for below −2 dBTP when a master is louder than −14 LUFS, because loud tracks pick up more distortion when they’re encoded. It also says it only turns a quiet track up as far as its true peak allows, leaving 1 dB of headroom for lossy formats.

So a slowed version that lands at −11 LUFS instead of −9 doesn’t lose anything on a normalized playlist. It just gets turned down less. Chasing the original’s loudness by pushing the limiter harder buys you nothing there and costs you punch. The essay on why streaming turns loud masters down walks through that trade.

The exception is a slowed version that will sit in a DJ set or a mixtape next to other tracks with no normalization. There, match it by ear against its neighbours at the same level, and still keep the true peak legal.

A quick checklist for slowed and screwed releases

• Start from the mix, or the quietest master you have, not the loudest.
• Slow it, add the reverb or chops, then limit last with true-peak mode on.
• Measure the exact file you’ll upload: integrated LUFS and true peak.
• Keep true peak under −1 dBTP, or under −2 dBTP if it’s louder than −14 LUFS.
• Listen to the low end on small speakers. Dropping the pitch moves bass notes down, and a sub that worked at full speed can turn into a rumble you can’t hear on a phone.
• If you also make an MP3 or AAC for socials, check that too. Why does my master clip after MP3 or AAC? on its own.

Slowed doesn’t mean exempt. Treat the slowed version as its own master and it’ll survive the trip to the store just as well as the original.

Does slowing a song down fix clipping?

No. Slowing it moves the peaks around and can lower them a little, but a master that was over the ceiling usually stays over. In our synthetic test, a master at +1.2 dBTP was still at +1.1 dBTP after slowing to 80%. Measure the slowed file, not the original.

Why does my slowed and reverb version clip when the original didn’t?

Usually because of what you added. Reverb and echo add delayed copies of the song on top of itself, and when those copies line up with a kick or a vocal hit the peaks add up. Slowing can also turn peaks that sat between samples into real sample values. Either way the file needs a fresh peak check.

What LUFS should a slowed version be?

The same delivery rules apply as for any master. Spotify normalizes to about −14 LUFS and asks for true peak under −1 dBTP, or under −2 dBTP if the master is louder than −14 LUFS. A slowed version can be a bit quieter than the original without anyone noticing, because playback normalization evens it out.

Should I slow the master or the mix?

If you have the session, slow the mix before the limiter and master the slowed version, so the limiter sees the final peaks. If you only have the finished master, slow it, then turn it down or run a true-peak limiter on the slowed render, and measure the result.