When the kick and 808 fight for the same 40–80 Hz at the same moment, neither one wins and the master just gets louder and blurrier. Decide who owns each hit first, with arrangement, carving, or sidechain, then measure loudness.

You know the symptom. Solo the kick and it slaps. Solo the 808 and it’s huge. Play them together and the low end turns into one gray thump that pumps the limiter, eats your headroom, and still sounds smaller on a phone than the reference. So you push the master harder. The meter goes up and the mud stays. Loudness repair can’t fix a low end that never decided who was speaking.

This isn’t a lecture on masking curves. It’s triage: who owns each beat, and what’s the cheapest fix that keeps the groove.

Find out what’s actually colliding

Two things have to be true for a real fight: the fundamentals are close in pitch, and they speak at the same time. A kick tuned to 54 Hz over an 808 sitting on G1 (49 Hz) is a clash. If the same 808 slides up to C2 (65 Hz) in the hook, the fight might only happen in the verse. Most “my low end is muddy” sessions come down to one or two notes and one bar shape.

So measure before you start reaching for EQ. If you only have the bounce, pull the parts apart with StemSplit, or do it in the app, and the collision gets obvious fast. Solo kick against 808, then go back to the full mix. Stems diagnose, the session fixes. The script below takes a kick stem and an 808 stem, prints where each one’s low energy peaks, converts that to note names, and tells you how often the 808 is within 6 dB of the kick while the kick is hitting.

#!/usr/bin/env python3
"""lowchair.py — where do the kick and 808 sit, and how often do they collide?
Usage: python3 lowchair.py kick.wav 808.wav   (stems from your session or StemSplit)
Needs: numpy + ffmpeg on PATH."""
import subprocess, sys
import numpy as np

SR = 22050
def load(path):
    raw = subprocess.run(["ffmpeg", "-v", "error", "-i", path, "-ac", "1", "-ar", str(SR),
                          "-f", "f32le", "-"], capture_output=True, check=True).stdout
    return np.frombuffer(raw, dtype=np.float32)

def low_peak(x, lo=25, hi=200):
    """Frequency with the most energy between lo and hi Hz (Welch-style average)."""
    n = 8192
    win = np.hanning(n)
    frames = [x[i:i + n] * win for i in range(0, len(x) - n, n // 2)
              if np.abs(x[i:i + n]).max() > 1e-3]
    spec = np.mean([np.abs(np.fft.rfft(f)) ** 2 for f in frames], axis=0)
    freqs = np.fft.rfftfreq(n, 1 / SR)
    band = (freqs >= lo) & (freqs <= hi)
    return freqs[band][np.argmax(spec[band])]

def note(f):
    m = int(round(69 + 12 * np.log2(f / 440)))
    return "C C# D D# E F F# G G# A A# B".split()[m % 12] + str(m // 12 - 1)

def env_db(x, hop=256):
    x = x[: len(x) // hop * hop].reshape(-1, hop)
    return 20 * np.log10(np.sqrt((x ** 2).mean(axis=1)) + 1e-9)

kick, bass = load(sys.argv[1]), load(sys.argv[2])
n = min(len(kick), len(bass)); kick, bass = kick[:n], bass[:n]
fk, fb = low_peak(kick), low_peak(bass)
ek, eb = env_db(kick), env_db(bass)
hits = ek > ek.max() - 12                       # frames where the kick is actually speaking
clash = hits & (eb > ek - 6)                    # ...and the 808 is within 6 dB of it
print(f"kick low peak : {fk:6.1f} Hz ({note(fk)})")
print(f"808 low peak  : {fb:6.1f} Hz ({note(fb)})")
print(f"distance      : {abs(fk - fb):6.1f} Hz  ({abs(12 * np.log2(fk / fb)):.1f} semitones)")
print(f"kick frames where 808 is within 6 dB: {100 * clash.sum() / max(hits.sum(), 1):.0f}%")

Run it like python3 lowchair.py kick.wav 808.wav. On a synthetic test pair (a 54 Hz kick over a 49 Hz sub) it reports a 1.8-semitone gap and a collision on about two-thirds of the kick frames. That’s a same-chair argument. A gap of five or more semitones with a low collision percentage usually means your problem is somewhere else: the vocal, a synth with too much low-mid, or plain level.

Three fixes, cheapest first

Arrangement is free. In trap the cleanest fix is often just not hitting the 808 on the kick. Let the kick take the one and bring the 808 in an eighth later, or shorten the 808 tail so it’s gone before the next kick lands. Drill does this naturally with sliding 808s and sparse kicks. Respect the gaps the pattern already gives you.

Carving is a choice about who gets the fundamental. Pick one part to own the sub and let the other one live higher. Tune the kick to the key, or a fifth above the 808’s root, and give it a small cut where the 808 sits. Or let the kick own 50–60 Hz and give the 808 its weight from harmonics (light saturation around 100–200 Hz) so it still reads on phones. In house the kick usually takes the sub and the bassline moves up. In rock the kick takes the click and about 60 Hz, and the bass guitar gets 80–120. Same rule, different owner.

Sidechain is the scalpel, not the default. A fast duck on the 808, keyed from the kick, 2–4 dB, with a release that clears before the next hit, keeps both parts heavy and stops them stacking. A multiband or dynamic-EQ duck that only ducks under about 120 Hz is even more transparent. If the pumping is louder than the groove, go back to arrangement.

Settle the fight, then measure

This order matters for delivery. Low-end stacking is where crest factor dies and true peak spikes. Two peaks landing in phase on the same downbeat can overshoot the ceiling even when each part alone is fine. If you send the muddy version to a limiter or a loudness repair, it reaches −14 by squashing the very hit you were trying to save. Once the low end is settled, the same LUFS target usually costs less limiting, and the true-peak row has room to breathe.

So bounce after the fix and run it through CoProducer’s analyze table. Check LUFS, true peak, and clips, and do an A/B against your earlier bounce at matched loudness. If the score moved without touching the master chain, the low end was the problem all along.

Should I always sidechain the 808 to the kick?

No. Check first whether the two actually overlap in pitch and time. Arrangement or a small carve often fixes it with no pumping at all.

Can mastering fix a muddy kick and 808?

Only a little, and not cleanly. A master sees one low end. Deciding who owns each hit happens in the mix, then the master just hits the delivery target.