A noise gate cuts off the ends of words when it closes as soon as the fading tail dips under the threshold. Tails wobble, so it also flutters open and shut. Add 50 to 100 ms of hold, a release around 150 ms, and a close threshold about 6 dB under the open one (hysteresis), and the gate waits for the word to really finish. Then set the range to about −15 dB instead of full silence so the gaps don’t sound like holes.

You recorded vocals in a bedroom, so there’s a little room noise and some headphone bleed between lines. A gate seems like the obvious fix. Then you play it back and the last letter of every word is missing. “Night” turns into “nigh.” Held notes stop a beat early, and sometimes the end of a word flickers, like someone tapping the mute button.

The gate’s doing exactly what you told it. The problem is that a word doesn’t end in a straight line.

Why gates chop tails

A gate opens when the signal goes above a threshold and closes when it falls back under. The start of a word is easy: it jumps up fast. The end is the hard part. A fading voice doesn’t slide smoothly down to silence. It wobbles, with vibrato, a bit of breath and the room. So it dips under the threshold, the gate starts closing, then the tail pops back up and the gate opens again. That’s the flutter. And the quiet last part of the word, which often carries the consonant, sits below the threshold, so it’s gone.

Gates have three controls for this. Hold keeps the gate open for a set time after the signal drops, so a short dip doesn’t close it. Release sets how slowly it fades shut. Hysteresis, sometimes called a separate close threshold, means it opens at one level and only closes at a lower one.

We wrote gate_check.py to see what each one does. It builds six synthetic sung words (a buzzy 200 Hz tone, 350 ms long, with a tail that fades and wobbles) over a steady noise floor at −60 dBFS. Then it runs a basic gate that opens at −40 dBFS and measures how many times it opens per word, how long after the word it starts closing (the point where it’s 6 dB down), and how far it pushes down the noise between words.

#!/usr/bin/env python3
"""Does the noise gate eat the ends of your words?
  python3 gate_check.py
A synthetic vocal line: six 'words' (a 200 Hz voiced tone, 350 ms at about -14 dBFS RMS) whose
tails decay exponentially (tau 90 ms) with a slight wobble, over a constant noise floor at -60 dBFS
RMS (room tone, headphone bleed). A plain gate opens at -40 dBFS, holds, then fades over the
release. For each setting we report how often it opened per word (1 is ideal; more is chatter),
how long after the word the gate starts closing (gain 6 dB down), and how far it pushed down the noise between words.
"""
import numpy as np

SR = 48000
rng = np.random.default_rng(7)

def take():
    word, gap = int(0.35 * SR), int(0.9 * SR)
    n = 6 * (word + gap)
    t = np.arange(n) / SR
    env = np.zeros(n)
    tail_mask = np.zeros(n, bool)
    starts = []
    for w in range(6):
        s = w * (word + gap) + int(0.3 * SR); starts.append(s)
        a = np.minimum(1, np.arange(word) / (0.015 * SR))
        env[s:s + word] = a
        k = np.arange(gap - int(0.3 * SR))
        wob = 1 + 0.35 * np.sin(2 * np.pi * 9 * k / SR)               # tails are never smooth
        env[s + word:s + word + k.size] = np.exp(-k / (0.09 * SR)) * wob
        tail_mask[s + word:s + word + int(0.4 * SR)] = True
    ends = [s + word for s in starts]
    voice = 0.28 * env * np.sign(np.sin(2 * np.pi * 200 * t)) * 0.7   # buzzy, like a voice
    noise = 10 ** (-60 / 20) * rng.standard_normal(n)
    return voice, noise, tail_mask, starts, ends

def gate(x, open_db=-40, close_db=None, hold_ms=0, release_ms=20, range_db=-80):
    close_db = open_db if close_db is None else close_db
    det = np.abs(x)
    a_r = np.exp(-1 / (0.010 * SR))                                   # 10 ms peak detector
    env = np.empty_like(det); e = 0.0
    for i, v in enumerate(det):
        e = v if v > e else a_r * e + (1 - a_r) * v; env[i] = e
    env_db = 20 * np.log10(env + 1e-12)
    g_floor = 10 ** (range_db / 20)
    step_up = 1 / (0.001 * SR)                                        # 1 ms attack
    rel = np.exp(np.log(g_floor) / max(1, release_ms * SR / 1000))
    g, is_open, held, opens = g_floor, False, 0, []
    out, gain = np.empty_like(x), np.empty_like(x)
    for i in range(x.size):
        if not is_open and env_db[i] > open_db:
            is_open, held = True, 0; opens.append(i)
        elif is_open and env_db[i] < close_db:
            held += 1
            if held > hold_ms * SR / 1000: is_open = False
        elif is_open:
            held = 0
        g = min(1.0, g + step_up) if is_open else max(g_floor, g * rel)
        out[i] = x[i] * g; gain[i] = g
    return out, gain, opens

voice, noise, tail, starts, ends = take()
x = voice + noise
between = np.ones(x.size, bool)
for s in starts: between[s - int(0.05 * SR):s + int(1.0 * SR)] = False
settings = [
    ("hold 0, release 20 ms", dict()),
    ("hold 0, release 150 ms", dict(release_ms=150)),
    ("hold 80 ms, release 150 ms", dict(hold_ms=80, release_ms=150)),
    ("hold 80, release 150, close at -46", dict(hold_ms=80, release_ms=150, close_db=-46)),
    ("same, range -15 dB instead of off", dict(hold_ms=80, release_ms=150, close_db=-46, range_db=-15)),
]
rms = lambda v: np.sqrt(np.mean(v ** 2))
print(f"{'setting':38s} {'opens/word':>10s} {'closing at':>11s} {'noise between':>14s}")
for name, kw in settings:
    y, g, opens = gate(x, **kw)
    cut = []
    for e in ends:                                                    # first sample after the word at -6 dB
        below = np.nonzero(g[e:e + int(0.8 * SR)] < 0.5)[0]
        cut.append(below[0] / SR * 1000 if below.size else np.nan)
    nb = 20 * np.log10(rms(y[between]) / rms(x[between]))
    c = np.nanmean(cut) if not np.all(np.isnan(cut)) else float("nan")
    print(f"{name:38s} {len(opens) / 6:10.1f} {c:8.0f} ms {nb:11.1f} dB")
win = int(0.02 * SR); sm = lambda v: np.sqrt(np.convolve(v ** 2, np.ones(win) / win, "same"))
vt, nf = sm(voice), rms(noise)
sink = [np.nonzero(vt[e:e + int(0.8 * SR)] < nf)[0][0] / SR * 1000 for e in ends]
print(f"(for reference, the tail itself sinks under the noise floor {np.mean(sink):.0f} ms after the word)")

$ python3 gate_check.py
setting                                opens/word  closing at  noise between
hold 0, release 20 ms                         1.5      287 ms       -80.0 dB
hold 0, release 150 ms                        1.5      297 ms       -80.0 dB
hold 80 ms, release 150 ms                    1.0      377 ms       -80.0 dB
hold 80, release 150, close at -46            1.0      508 ms       -76.4 dB
same, range -15 dB instead of off             1.0      547 ms       -14.9 dB
(for reference, the tail itself sinks under the noise floor 491 ms after the word)

Reading the numbers

The tail lasts 491 ms. That’s how long after each word our tail stays above the noise floor, the part you’d actually hear. It’s the number to compare against.

A default gate cuts it at 287 ms, so about 200 ms of every tail is gone. It also opens 1.5 times per word on average, so some words flutter. Making the release slower alone (150 ms) barely helps: 297 ms, and the same flutter. The release only shapes how it closes, not when.

Hold stops the flutter. Adding 80 ms of hold brings it to exactly one open per word and moves the close out to 377 ms. Better, but still early.

A lower close threshold keeps the whole tail. Opening at −40 and closing at −46 moves the close to 508 ms, just past where the tail sinks under the noise. Nothing audible gets cut.

Full silence in the gaps is its own problem. With the gate shutting all the way, the noise between words drops by about 76 to 80 dB, which is complete silence. Then it snaps back in with every word. That on-off room tone is easy to hear on headphones. With the range set to −15 dB, the gaps come down 14.9 dB instead. That’s enough to clean them up while a little room stays underneath, so nothing jumps. (The −6 dB point also moves to 547 ms, because the fade covers only 15 dB.)

This is a simple model of a voice and a basic gate, so treat the exact milliseconds as a guide. Real words end differently, and an S or a T is quieter and shorter than a held vowel.

Settings to start from

1. Threshold: loop a gap, watch the meter, and set the open threshold 6 to 10 dB above the noise. Not higher.
2. Hysteresis or close threshold: about 6 dB below the open threshold. If your gate has no hysteresis control, give it more hold instead.
3. Hold: 50 to 100 ms for vocals. More for slow, held singing, less for fast rap.
4. Release: 100 to 200 ms, so the tail fades instead of snapping off.
5. Range: −10 to −20 dB rather than off. You want the gaps quieter, not dead.
6. Attack: fast, about 1 ms, but if the first letter clicks, slow it a little or use the gate’s lookahead.

When a gate is the wrong tool

If the noise is almost as loud as the quiet parts of the words, no threshold will separate them. The gate will either let the noise through or eat the words. For a vocal, it’s often cleaner to skip the gate and just turn down or clip-gain the gaps by hand. The essay on loud breaths walks through the same move for breaths. When the bleed is the beat itself, leaking out of loud headphones, try running the take through a stem splitter such as StemSplit. It separates the voice from the music, which is something no gate can do while the word is still going.

Gate before compression, too. A compressor raises the noise between words, which makes the gate’s job harder if it comes after. And if you edited the gaps by hand instead, fade every cut, as clicks at edit points explains, or you’ll swap noise for clicks.

Why does my noise gate cut off the ends of words?

Because the fading tail drops under the threshold before the word is really over. In our test a basic gate started closing 287 ms after the word, while the tail stayed audible for 491 ms.

What does hold do on a noise gate?

It keeps the gate open for a set time after the signal drops under the threshold, so short dips don’t close it. In our test 80 ms of hold stopped the gate fluttering open and shut on the tails.

What is hysteresis on a gate?

A lower close threshold than the open one. Opening at −40 dBFS and closing at −46 in our test let the gate stay open through the whole tail.

Should a noise gate close all the way?

Usually not on vocals. Full silence makes room tone snap in and out with every word. A range of about −15 dB keeps the gaps cleaner without holes.