When adding a second kick or a sub layer makes the kick sound thinner, the two layers are cancelling in the low end. One is usually flipped in polarity, starts a millisecond or two late, or both. Zoom in, line up the first low cycle of each layer, flip the polarity of one if their waves move in opposite directions, and check that the low end gets bigger when you add the layer, not smaller.

The top kick has the click. The sub layer has the weight. Solo either one and it sounds great. Play them together and the kick gets… smaller. The snap is still there, but the chest-thump you were adding the layer for is gone. So you turn the sub up, and somehow that barely helps.

That’s not your ears. It’s two waves pushing in opposite directions at the same moment, and in the low end that moment lasts long enough to hear.

Why low layers cancel

A kick’s low end is basically a sine that starts high and drops fast. At 60 Hz one cycle takes about 16.7 ms. If your sub layer is a copy of that motion but upside down, every push from one layer meets a pull from the other, and they subtract. If it’s the right way up but a millisecond or two late, part of each cycle still lines up against the opposite half of the other one.

Both happen all the time. Pack samples aren’t made to match each other. A resampled sub might come out inverted depending on the chain. A sample might have a couple of milliseconds of silence before the hit, or a fade-in. None of that shows at a normal zoom level.

The click on top barely cares. High frequencies have short cycles, and they’re mostly in one layer anyway. That’s why the layered kick still sounds sharp while the body disappears.

We made a layer that fights the kick

In make_kicks.py we built two samples at 48 kHz: a top kick with a click and a pitch drop from 170 to 55 Hz, and a sine sub that follows the same pitch drop with a longer tail. That’s the standard sub-under-the-kick move. Then we wrote the sub the way plenty of samples arrive: polarity flipped, with 1.5 ms of silence in front. Both peak at −6 dBFS.

This script checks a pair of layers. It tries every offset up to 5 ms either way, with and without a polarity flip, and keeps the one that gives the most low end in the first 100 ms, which is the hit you actually feel:

#!/usr/bin/env python3
"""Check two layered samples (kick + kick, kick + 808) for polarity and timing before you blend them.
  python3 layer_check.py top.wav sub.wav [--max-ms 10]
Low end (below 150 Hz) is where layers cancel, so it tries every offset up to --max-ms either way,
with and without a polarity flip, and keeps the one with the most low end in the first 100 ms
(the hit you feel, not the tail)."""
import sys, numpy as np, soundfile as sf
from scipy.signal import butter, sosfilt

def low(x, sr): return sosfilt(butter(4, 150, "low", fs=sr, output="sos"), x)
def lowband_db(x, sr): return 10 * np.log10((low(x, sr)[:int(0.1 * sr)] ** 2).sum() + 1e-20)
def shift(x, k): return np.concatenate([np.zeros(k), x])[:len(x)] if k >= 0 else np.concatenate([x[-k:], np.zeros(-k)])

def main():
    a, sr = sf.read(sys.argv[1]); b, _ = sf.read(sys.argv[2])
    a, b = (v.mean(axis=1) if v.ndim > 1 else v for v in (a, b))
    m = max(len(a), len(b)); a, b = np.pad(a, (0, m - len(a))), np.pad(b, (0, m - len(b)))
    max_ms = float(sys.argv[sys.argv.index("--max-ms") + 1]) if "--max-ms" in sys.argv else 5.0
    L, head = int(sr * max_ms / 1000), int(0.1 * sr)
    la, lb = low(a, sr), low(b, sr)
    hit = lambda x: (x[:head] ** 2).sum()
    e = {(k, p): hit(la + p * shift(lb, k)) for k in range(-L, L + 1) for p in (1, -1)}
    top = max(e.values())                                  # within 0.01 dB of the best, prefer the smallest move
    k, pol = min((kp for kp, v in e.items() if v >= top * 10 ** -0.001), key=lambda kp: abs(kp[0]))
    ref = max(lowband_db(a, sr), lowband_db(b, sr))
    opts = {"as loaded": a + b, "polarity flipped": a - b,
            f"moved {k / sr * 1000:+.2f} ms": a + shift(b, k), "moved + flipped": a - shift(b, k)}
    print(f"{sys.argv[1]} + {sys.argv[2]}  (low end below 150 Hz in the first 100 ms, vs the louder layer alone)")
    for name, s in opts.items():
        print(f"  {name:18s} {lowband_db(s, sr) - ref:+6.2f} dB   peak {20 * np.log10(np.abs(s).max() + 1e-12):+6.2f} dBFS")
    print(f"best: move layer 2 by {k} samples ({k / sr * 1000:+.2f} ms)" + (" and flip its polarity" if pol < 0 else ", keep polarity"))

if __name__ == "__main__":
    main()

$ python3 layer_check.py kick_top.wav kick_sub.wav
kick_top.wav + kick_sub.wav  (low end below 150 Hz in the first 100 ms, vs the louder layer alone)
  as loaded           -2.19 dB   peak  -3.85 dBFS
  polarity flipped    +3.94 dB   peak  -2.53 dBFS
  moved -1.40 ms     -10.76 dB   peak -10.09 dBFS
  moved + flipped     +4.80 dB   peak  -0.14 dBFS
best: move layer 2 by -67 samples (-1.40 ms) and flip its polarity

As loaded, adding the sub made the low end 2.19 dB weaker than the top kick on its own. You added a layer and lost weight. Flipping the polarity alone got it to +3.94 dB. Moving the sub 1.40 ms earlier without flipping made it far worse, −10.76 dB, because that lines the waves up perfectly opposite. Both together gave +4.80 dB.

That’s a 7 dB swing in the low end of the hit from two clicks, with no EQ, no compression and no new samples.

The script settled on 1.40 ms rather than the 1.5 ms we put in. The two layers drop pitch at slightly different rates, so the best fit isn’t exactly the delay we added. Within 0.01 dB it prefers the smallest move, and your ears won’t hear the difference.

Doing it by ear and eye in the DAW

1. Zoom in on the start. Put both layers on the same grid line and zoom until you can see single cycles. Line up where each layer’s first low cycle starts, not where the click starts.
2. Look at the direction. If one wave goes up while the other goes down, flip the polarity of one. Most DAWs have a polarity or phase button on the channel or in a utility plugin. It might be labelled Ø.
3. Flip and listen in mono. Toggle the flip with both layers playing. The right setting is the one where the low end gets bigger. If you can’t tell, check in mono at a low volume, where the difference is easiest to hear.
4. Nudge in small steps. Move the sub by a fraction of a millisecond at a time. Some DAWs let you nudge by samples. A delay plugin with a negative or small positive time works too.
5. Then turn it down. Once the layers add instead of cancel, the peak goes up. In our test it went from −3.85 dBFS as loaded to −0.14 dBFS fixed. Trim the layer or the kick bus before it hits the next plugin.

If the two layers have very different pitches, you won’t get them to agree everywhere. In that case, a common move is to let one layer own the lows and high-pass the other one so they overlap less. That’s the same idea as giving the kick and 808 their own space in your kick and 808 are arguing in the same chair.

Layering over a sampled break

This gets sneakier when the kick you’re reinforcing lives inside a loop or a record. If you split a drum stem out of a sample, say with NoDAW StemSplit, and stack your own kick on top, line it up against the kick in the stem, not the grid. The original drummer wasn’t on your grid, and a few milliseconds of drift between hits is normal. Check the polarity on a couple of hits through the loop, not just the first one. There’s more on working with split drums in sampling from separated stems.

Same problem, other places

Anything doubled in the low end can do this: a DI bass with an amp track, two mics on a kick, a dry track against a parallel compressor that adds latency. That last one has its own essay, parallel compression sounds thin? Check the latency first. The fix is the same every time. Line them up, check the polarity, and make sure adding the second one makes the low end bigger.

Why does my kick sound thinner when I layer it?

The layers are cancelling in the low end. Usually one is flipped in polarity, starts a millisecond or two late, or both. In our test that made the low end 2.19 dB weaker than the top kick alone.

Should I flip the polarity of my sub layer?

Try it with both layers playing and keep whichever setting makes the low end bigger. There’s no rule which way is right. It depends on how each sample was made.

How do I line up two kick samples?

Zoom in until you can see single cycles and line up where each one’s first low cycle starts. Then nudge the layer in small steps, a fraction of a millisecond at a time, while you listen to the low end.

Is polarity the same as phase?

Not quite. Flipping polarity turns the whole wave upside down. A phase or timing difference shifts it in time, which affects different frequencies by different amounts. Layered kicks often need both fixes.