Mixing · 3 November 2026 · 7 min
Linear-phase EQ softening your kick? Listen before the hit
A linear-phase low cut doesn’t only take bass away, it moves some of it in front of the hit. In our test, a 60 Hz, 48 dB/oct linear-phase high-pass on a kick put a soft swell ahead of the transient that started 41.6 ms early and peaked 19.6 dB under the kick, while a normal minimum-phase filter with the same curve put nothing before the hit. Use minimum phase on kicks, 808s and anything with a sharp attack, and keep linear phase for jobs where it really earns its place.
You switch your EQ to linear phase because it sounds like the clean, professional option. You high-pass the kick or the drum bus, and something about the punch changes. The hit feels a little soft, like it’s leaning in instead of landing. Solo it and you might hear it: a faint whoomp just before every kick.
That’s pre-ringing, and it’s the price of linear phase.
What linear phase actually trades
A normal EQ, called minimum phase, changes the tone and shifts the timing of frequencies near the cut by a little. Everything it does happens after the sound arrives. A linear-phase EQ keeps every frequency in time with every other, which sounds like a pure win. To do that it has to look ahead and spread its filtering both ways in time, half before the sound and half after.
On a sustained pad you can’t hear it. On a kick, the part of the low end the filter removes gets smeared forward into the silence before the hit. The steeper the slope and the lower the cutoff, the longer that smear, because low frequencies and sharp filters both take longer to ring.
We wrote prering_check.py to measure it. It builds a synthetic kick (a pitch drop from 160 Hz down to 50 Hz, a 300 ms decay and a 2 ms click) with a second of silence before it. Then it high-passes it at 30, 60 and 100 Hz with slopes of 12, 24 and 48 dB/oct, once as a normal minimum-phase filter and once as a linear-phase filter with the exact same curve. It reports how early the pre-ring rises above −60 dB relative to the peak, how loud it gets, and what happens to the kick’s peak.
#!/usr/bin/env python3
"""Linear-phase vs minimum-phase low cut on a kick: how much sound arrives before the hit?
python3 prering_check.py
A synthetic kick (pitch drop 160 -> 50 Hz, 300 ms decay, 2 ms click) is high-passed at 30, 60 and 100 Hz
with Butterworth slopes of 12, 24 and 48 dB/oct. "Minimum phase" = the plain IIR filter (what a normal EQ
does). "Linear phase" = the exact same magnitude response with zero phase, built from the IIR's
frequency response (what a linear-phase EQ does, minus its fixed latency, which DAWs compensate).
Pre-ring = output before the kick starts. Reported: how far ahead it becomes audible-ish (first sample
above -60 dB re the output peak), its peak (dB re the output peak), and the change in the kick's sample peak.
Last block: the linear-phase 60 Hz / 48 dB result slowed to 0.7x by resampling (a slowed edit)."""
import numpy as np
from scipy.signal import butter, sosfilt, sosfreqz, resample_poly
SR, PAD = 48000, 48000 # 1 s of silence before the hit
def kick():
t = np.arange(int(0.6 * SR)) / SR
f = 50 + 110 * np.exp(-t / 0.03) # 160 Hz falling to 50 Hz
body = np.sin(2 * np.pi * np.cumsum(f) / SR) * np.exp(-t / 0.3)
click = np.random.default_rng(1).standard_normal(len(t)) * np.exp(-t / 0.002) * 0.3
x = np.concatenate([np.zeros(PAD), body + click, np.zeros(SR)])
return 0.5 * x / np.abs(x).max()
def minphase(x, fc, order): return sosfilt(butter(order, fc, "highpass", fs=SR, output="sos"), x)
def linphase(x, fc, order):
n = len(x); _, H = sosfreqz(butter(order, fc, "highpass", fs=SR, output="sos"), worN=n // 2 + 1, whole=False)
return np.fft.irfft(np.fft.rfft(x) * np.abs(H), n) # same magnitude, zero phase (latency already removed)
def report(y, ref_peak, onset=PAD, sr=SR):
pk = np.abs(y).max(); pre = np.abs(y[:onset])
over = np.nonzero(pre > pk * 10 ** (-60 / 20))[0]
ms = (onset - over[0]) / sr * 1000 if len(over) else 0.0
pre_db = 20 * np.log10(max(pre.max(), 1e-12) / pk)
return ms, pre_db, 20 * np.log10(pk / ref_peak)
def main():
x = kick(); ref = np.abs(x).max()
print("Synthetic kick, high-pass filter, 48 kHz")
print(f"{'filter':>16}{'phase':>8}{'pre-ring starts':>17}{'pre-ring peak':>15}{'kick peak':>11}")
for fc in (30, 60, 100):
for order, slope in ((2, 12), (4, 24), (8, 48)):
for name, fn in (("min", minphase), ("linear", linphase)):
ms, pdb, dpk = report(fn(x, fc, order), ref)
pre = f"{ms:6.1f} ms early" if ms else " none"
pdb_s = f"{pdb:8.1f} dB" if ms else " --"
print(f"{fc:>4} Hz {slope:>2} dB/oct{name:>8}{pre:>17}{pdb_s:>15}{dpk:>+8.2f} dB")
y = linphase(x, 60, 8); ms, pdb, _ = report(y, ref)
s = resample_poly(y, 10, 7) # play 0.7x: 10/7 as many samples at the same rate
ms_s, pdb_s, _ = report(s, ref, onset=int(round(PAD * 10 / 7)))
print(f"\nLinear-phase 60 Hz 48 dB/oct, then slowed to 0.7x: pre-ring {ms:.1f} ms -> {ms_s:.1f} ms early "
f"(peak {pdb:.1f} -> {pdb_s:.1f} dB)")
if __name__ == "__main__": main()$ python3 prering_check.py
Synthetic kick, high-pass filter, 48 kHz
filter phase pre-ring starts pre-ring peak kick peak
30 Hz 12 dB/oct min none -- -0.36 dB
30 Hz 12 dB/oct linear 22.5 ms early -27.0 dB -0.37 dB
30 Hz 24 dB/oct min none -- -0.12 dB
30 Hz 24 dB/oct linear 35.9 ms early -26.8 dB -0.38 dB
30 Hz 48 dB/oct min none -- -0.56 dB
30 Hz 48 dB/oct linear 65.9 ms early -26.3 dB -0.40 dB
60 Hz 12 dB/oct min none -- -0.54 dB
60 Hz 12 dB/oct linear 11.6 ms early -19.9 dB -0.79 dB
60 Hz 24 dB/oct min none -- -0.75 dB
60 Hz 24 dB/oct linear 25.6 ms early -20.1 dB -0.61 dB
60 Hz 48 dB/oct min none -- -0.98 dB
60 Hz 48 dB/oct linear 41.6 ms early -19.6 dB -0.59 dB
100 Hz 12 dB/oct min none -- -2.19 dB
100 Hz 12 dB/oct linear 11.0 ms early -13.7 dB -1.62 dB
100 Hz 24 dB/oct min none -- -2.09 dB
100 Hz 24 dB/oct linear 19.1 ms early -13.8 dB -1.20 dB
100 Hz 48 dB/oct min none -- -2.38 dB
100 Hz 48 dB/oct linear 30.6 ms early -15.2 dB -0.72 dB
Linear-phase 60 Hz 48 dB/oct, then slowed to 0.7x: pre-ring 41.6 ms -> 59.5 ms early (peak -19.6 -> -18.5 dB)Reading the numbers
Minimum phase never rings early. Every minimum-phase row says “none.” Nothing comes out before the kick starts, no matter how steep the filter.
Linear phase always does, and the steep low ones are long. At 30 Hz the pre-ring starts 22.5 ms early with a 12 dB/oct slope, 35.9 ms with 24 dB/oct and 65.9 ms with 48 dB/oct. At 30 Hz it stays around 26 to 27 dB under the kick peak, because there isn’t much kick energy that low to smear.
Higher cutoffs make it louder but shorter. At 60 Hz, 48 dB/oct, it starts 41.6 ms early and peaks at −19.6 dB. At 100 Hz, which takes a real bite out of this kick, it’s 30.6 ms early and up at −15.2 dB, or −13.7 dB with the 12 dB/oct slope. That’s a lot of low thump arriving before the hit.
The trade is real, though. Look at the kick peak column. At 100 Hz, 48 dB/oct, the minimum-phase filter drops the kick’s peak by 2.38 dB, the linear-phase one only 0.72. The phase shift of a normal filter changes the shape of the waveform, and that’s exactly what linear phase avoids. That’s why mastering engineers reach for it.
This is one synthetic kick in solo, so treat the numbers as a model. In a dense mix, the previous bar often hides the pre-ring. It’s most obvious on intros, breakdowns, sparse beats and anything where the kick lands after silence.
When to use which
- Kick, 808, snare, plucks, anything with a sharp start: minimum phase. If you’re high-passing these at all, a normal EQ keeps the attack clean.
- A gentle low cut on the master or mix bus: either can work. Keep it low and shallow, like 20 Hz at 12 to 24 dB/oct, and listen to the kick in a sparse section. Rumble you can’t hear is eating your limiter covers why that filter is worth having.
- Parallel paths and multi-mic drums: linear phase helps when the same sound runs through two chains and they need to stay lined up. Make sure the delay is compensated, which parallel compression sounds thin? Check the latency first covers.
- Broad tone moves and the top end: a wide, gentle shelf has short, quiet pre-ring, and higher frequencies ring for less time. Linear phase is fine there.
How to check it in your session
- Solo the kick in a sparse part and flip the EQ’s phase mode. Listen just before the hit, not to the hit. If you hear a swell or a softer front edge in linear phase, switch back.
- Look at it. Bounce one kick with each mode and zoom in on the waveform. Any ripple in the silence before the transient is pre-ring.
- If you need linear phase, lower the resolution or the slope. Many linear-phase EQs have a low, medium or high setting. Lower resolution means a shorter filter and less pre-ring, at some cost to accuracy in the lows. Some EQs also have a “natural” or mixed phase mode in between.
- Ask whether the kick needs the cut at all. Often the low cut belongs on everything except the kick and bass. If the kick and 808 are fighting, that’s an arrangement call more than a filter, as your kick and 808 are arguing in the same chair lays out.
Slowed versions stretch it too
If you print a slowed edit from the master, say through ScrewAI, the pre-ring slows with everything else. The test file’s 60 Hz linear-phase pre-ring went from 41.6 ms to 59.5 ms early at 0.7x and drops lower in pitch along with the rest of the song. Fix the EQ on the master before you make the slowed version, rather than hoping it hides.
- What is pre-ringing on a linear-phase EQ?
- Sound that comes out before the original. A linear-phase filter spreads its work both ways in time, so part of what it removes shows up ahead of a transient. In our test, a 60 Hz, 48 dB/oct high-pass on a kick started ringing 41.6 ms early.
- Should I use linear-phase EQ on a kick?
- Usually not for a low cut. A minimum-phase filter with the same curve put nothing before the hit in our test, while linear phase put a swell up to 19.6 dB under the kick peak in front of it.
- When is linear-phase EQ better?
- When phase between parallel or multi-mic paths matters, and for gentle broad moves where pre-ring is short and quiet. It also keeps the waveform shape: at 100 Hz, 48 dB/oct, it lowered our kick’s peak by 0.72 dB vs 2.38 dB for minimum phase.
- Does a steeper filter mean more pre-ring?
- Yes, and so does a lower cutoff. At 30 Hz, linear-phase pre-ring started 22.5 ms early at 12 dB/oct and 65.9 ms early at 48 dB/oct.