If your limiter makes the 808 or bass fuzz, buzz or crackle, the release is probably faster than one cycle of the bass note. A 50 Hz note takes 20 ms per cycle, so a limiter that recovers in 1 to 5 ms is turning the gain up and down inside every wave and bending its shape. Slow the release to 50 ms or more, or add a hold or lookahead of at least half a cycle, and the distortion mostly goes away.

The low end sounds huge, then you put a limiter on the master. The kick and vocal are fine, but the 808 suddenly has a fizz around it, like a blown speaker, worst on the long notes.

Nothing is clipping on the meter. The limiter is doing what it was told. The problem is how fast it lets go.

Why fast release eats bass

A limiter turns the gain down when a peak goes over the ceiling, then lets it come back up. That recovery is the release. On snares and vocals a fast release is a decent way to get loudness, because the limiter lets go between hits.

Bass is different because the waves are slow. A 50 Hz note does one full cycle every 20 ms, with a peak every 10 ms (one positive, one negative). If the limiter recovers in a couple of milliseconds, the gain is going down on every peak and back up in between, a hundred times a second. That isn’t level control anymore. It’s the limiter redrawing the waveform, flattening the top of each wave. That reshaping is distortion: new harmonics at 100 Hz, 150 Hz and up, the fizz you hear.

To put numbers on it, we wrote limiter_check.py. It makes a steady 50 Hz sine, like the sustain of an 808, and pushes it 6 dB into a simple limiter with a −1 dBFS ceiling and instant attack. It measures total harmonic distortion (THD), the added harmonics compared with the note itself, for each release time. It also runs the note slowed to 0.7x (35 Hz) and an 808 pattern to see what each setting costs in loudness.

#!/usr/bin/env python3
"""Does a fast limiter release distort the bass? THD of a steady bass note through a simple peak limiter.
  python3 limiter_check.py [drive_db]
A 50 Hz sine (an 808 sustain) is pushed into a -1 dBFS ceiling with instant attack and an exponential
release. THD = energy in harmonics 2-10 vs the fundamental, measured over whole cycles after it settles.
"Hold" keeps the gain at its deepest over a short centred window (half before, half after: lookahead + hold).
The 35 Hz column is the same note slowed to 0.7x (a slowed edit), so each cycle lasts longer.
The 808 pattern row: 1 s notes, 0.5 s decay, loudness after limiting (BS.1770 K-weighted, ungated)."""
import sys, numpy as np
from scipy.signal import lfilter
from scipy.ndimage import minimum_filter1d

SR = 48000
def limit(x, rel_ms, hold_ms=0.0, ceil_db=-1.0):
    need = np.minimum(1.0, 10 ** (ceil_db / 20) / np.maximum(np.abs(x), 1e-12))
    if hold_ms: need = minimum_filter1d(need, int(hold_ms * SR / 1000) + 1)   # deepest gain over a centred window (hold + lookahead)
    a = np.exp(-1.0 / (rel_ms / 1000 * SR)); g = np.empty_like(x); gl = 1.0
    for i, n in enumerate(need):
        gl = n if n < gl else n + (gl - n) * a
        g[i] = gl
    return x * g
def thd(y, f0):
    seg = y[SR:SR + int(round(SR / f0 * round(f0)))]                    # one second of whole cycles, after settling
    X = np.abs(np.fft.rfft(seg * np.hanning(len(seg)))); f = np.fft.rfftfreq(len(seg), 1 / SR)
    amp = lambda h: X[np.argmin(np.abs(f - h * f0)) - 2: np.argmin(np.abs(f - h * f0)) + 3].max()
    return 100 * np.sqrt(sum(amp(h) ** 2 for h in range(2, 11))) / amp(1)
def lufs(x):
    y = lfilter([1.53512485958697, -2.69169618940638, 1.19839281085285], [1, -1.69065929318241, 0.73248077421585], x)
    y = lfilter([1, -2, 1], [1, -1.99004745483398, 0.99007225036621], y)
    return -0.691 + 10 * np.log10(np.mean(y ** 2))

def main():
    drive = float(sys.argv[1]) if len(sys.argv) > 1 else 6.0
    t = np.arange(SR * 3) / SR; amp = 10 ** ((drive - 1) / 20)     # peaks hit the ceiling `drive` dB too hot
    print(f"Steady bass note pushed {drive:g} dB into a -1 dBFS ceiling (instant attack)")
    print(f"{'release':>20}{'50 Hz THD':>10}{'35 Hz THD':>10}")
    rows = [(1, 0), (5, 0), (20, 0), (50, 0), (150, 0), (20, 3), (20, 6), (20, 10)]
    for rel, hold in rows:
        name = f"{rel} ms" + (f" + {hold} ms hold" if hold else "")
        r50, r35 = (thd(limit(amp * np.sin(2 * np.pi * f * t), rel, hold), f) for f in (50, 35))
        print(f"{name:>20}{r50:>8.1f} %{r35:>8.1f} %")
    pat = np.zeros(SR * 8)
    for s in range(0, len(pat), SR):
        k = np.arange(SR) / SR; pat[s:s + SR] += amp * np.sin(2 * np.pi * 50 * k) * np.exp(-k / 0.5)
    print("\n808 pattern (1 s notes, 0.5 s decay), loudness after the limiter:")
    for rel, hold in ((5, 0), (20, 10), (50, 0), (150, 0), (500, 0)):
        y = limit(pat, rel, hold); name = f"{rel} ms" + (f" + {hold} ms hold" if hold else "")
        print(f"{name:>20}: {lufs(y):6.2f} LUFS, peak {20*np.log10(np.abs(y).max()):.2f} dBFS")

if __name__ == "__main__": main()

$ python3 limiter_check.py
Steady bass note pushed 6 dB into a -1 dBFS ceiling (instant attack)
             release 50 Hz THD 35 Hz THD
                1 ms    19.5 %    20.5 %
                5 ms    12.4 %    14.2 %
               20 ms     5.9 %     7.4 %
               50 ms     3.0 %     4.0 %
              150 ms     1.1 %     1.6 %
   20 ms + 3 ms hold     2.0 %     3.9 %
   20 ms + 6 ms hold     0.2 %     1.1 %
  20 ms + 10 ms hold     0.0 %     0.1 %

808 pattern (1 s notes, 0.5 s decay), loudness after the limiter:
                5 ms: -10.64 LUFS, peak -1.00 dBFS
  20 ms + 10 ms hold: -11.23 LUFS, peak -1.00 dBFS
               50 ms: -10.99 LUFS, peak -1.00 dBFS
              150 ms: -11.30 LUFS, peak -1.00 dBFS
              500 ms: -12.63 LUFS, peak -1.00 dBFS

Reading the numbers

At 1 ms release the 50 Hz note comes out with 19.5% THD. That’s heavy distortion, close to what you’d get from hard clipping. At 5 ms, a pretty common setting on a loud master, it’s still 12.4%.

Each step slower cleans it up: 5.9% at 20 ms, 3.0% at 50 ms, 1.1% at 150 ms. Once the release is much longer than one cycle, the gain mostly holds still across the wave.

The hold rows are the more interesting fix. Hold keeps the gain at its lowest point for a short window, half before the peak and half after, before the release starts. With a 20 ms release and just 6 ms of hold, the 50 Hz note drops to 0.2% THD. With 10 ms of hold, half of one cycle, it reads 0.0%. The gain stops moving between peaks, so the wave keeps its shape.

Now look at the 35 Hz column. Everything gets worse on the lower note, because each cycle is longer. The 6 ms hold that was clean at 50 Hz gives 1.1% at 35 Hz. Settings that were fine on the original can fuzz on a slowed version of the same song.

The catch: slower release costs loudness

Look at the 808 pattern at the bottom. Every setting hits the same −1.00 dBFS peak, but the loudness isn’t the same. The 5 ms release comes out at −10.64 LUFS. A 50 ms release is −10.99, 150 ms is −11.30, and 500 ms falls to −12.63. A slow release keeps the gain down longer after each hit. The 20 ms release with 10 ms hold lands at −11.23, about 0.6 LU under the fast setting, and it’s clean.

So the fast release isn’t free loudness. You pay for it with distortion. If the master needs that extra half a dB, get it earlier, from a cleaner low end and room under the limiter, which turn the mix down before you limit walks through.

These are synthetic signals and a simple limiter, so treat the percentages as a model. Real limiters have smarter release curves, but the pattern holds: release time against the length of one bass cycle decides whether the limiter controls level or changes the waveform.

How to set it in your session

1. Loop the problem. Find the longest, loudest 808 note and loop it through the limiter. Fizz is easier to hear on a held note.
2. Slow the release until the fizz stops. Start around 50 ms and go up. For bass-heavy music, 100 to 300 ms is a normal range. If your limiter has auto release, try it, then compare against a fixed slow setting.
3. Use hold or lookahead if you have it. Aim for at least half a cycle of your lowest note. Half a cycle at 50 Hz is 10 ms. At 35 Hz it’s about 14 ms.
4. Back off the input. 6 dB into a limiter is a lot for bass-heavy material, and 2 dB less drive often helps more than any release setting. If you want the 808 to cut through on phones, distort it on purpose before the master, as in why your 808 disappears on phone speakers.
5. Compare at matched loudness. The slower setting will be a bit quieter, and quieter usually sounds worse for a few seconds. Match levels before you pick, the same trap as in your mix sounding better loud.

Trap, drill and dubstep live on long sub notes, so they show this first. A clipper before the limiter can shave peaks with a sound you choose, as in clipper vs limiter for hip-hop delivery. Rock and pop with a busy bass guitar usually get away with a medium release. And if you bus-compress the mix, a fast release there can fuzz the same way, which high-passing the sidechain helps with.

Slowed versions need their own check

The 35 Hz column is the one to remember if you make slowed or chopped versions. Slowing the song drops the bass, and the limiter settings that were clean at the original speed can start to fizz. If you make the slowed edit in ScrewAI or anywhere else, treat it as a new master. Run it through the limiter again, loop a long 808 note, and slow the release or add hold until it’s clean. It also needs its own peak check, which screw tempo still needs a legal peak explains.

Why does my limiter distort the bass?

Usually because the release is shorter than one cycle of the bass note. A 50 Hz cycle lasts 20 ms. In our test a 1 ms release gave 19.5% distortion on a 50 Hz note and a 5 ms release gave 12.4%.

What release time should I use on a limiter for bass-heavy music?

Long enough that the fizz on a held 808 note stops. In our test 50 ms brought distortion down to 3.0% and 150 ms to 1.1%. A 20 ms release with 10 ms of hold measured 0.0%.

Does a slower release make the master quieter?

A little. At the same −1 dBFS peak, our 808 pattern measured −10.64 LUFS with a 5 ms release, −10.99 at 50 ms and −12.63 at 500 ms.

Why does my slowed version distort when the original didn’t?

Slowing the song lowers the bass, so each cycle is longer and the same limiter settings fit inside it. A 6 ms hold gave 0.2% distortion at 50 Hz and 1.1% on the same note at 35 Hz.