A quarter note lasts 60,000 ÷ BPM milliseconds, so at 140 BPM it’s 428.6 ms and an eighth is 214.3 ms. Halve it for shorter notes, multiply by 1.5 for dotted and by 2/3 for triplets. A delay set by ear a little off that number drifts further off the grid with every repeat, and that’s what makes a throw feel sloppy.

You throw a delay on the last word of the hook and it sounds great on the first repeat. By the third one it’s smearing into the snare and the pocket feels a little drunk. You nudge the time knob, it gets better in one spot and worse in another, and twenty minutes later you’ve automated it off entirely.

Most of the time the delay isn’t too loud or too dark. It’s just a few milliseconds off the tempo, and every repeat doubles down on the mistake.

The one formula

There are 60,000 milliseconds in a minute. Divide by the tempo and you have one beat, which in 4/4 is a quarter note. Everything else comes from that:

• Straight notes. Halve for an eighth, halve again for a sixteenth. Double for a half note.
• Dotted notes. Multiply by 1.5. The dotted eighth is the classic bouncing guitar and vocal delay.
• Triplets. Multiply by 2/3. Triplet delays roll against a straight beat, which is why they sound so good on trap hats and swung vocals.

Here it is as a small script, so you never have to look up a chart again:

#!/usr/bin/env python3
"""Delay and pre-delay times from tempo, in milliseconds.
usage: python3 delay_times.py 140 [0.8]     (optional second number: a playback-speed factor, e.g. a slowed bounce)"""
import sys
bpm = float(sys.argv[1])
if len(sys.argv) > 2:
    bpm *= float(sys.argv[2])                    # slowing the whole bounce slows the tempo by the same factor
beat = 60_000 / bpm                              # one quarter note in ms
notes = [("1/2", 2), ("1/4", 1), ("1/8", 0.5), ("1/16", 0.25)]
print(f"{bpm:g} BPM  (quarter note = {beat:.1f} ms)")
print(f"{'note':>6} {'straight':>10} {'dotted':>10} {'triplet':>10}")
for name, q in notes:
    ms = beat * q
    print(f"{name:>6} {ms:10.1f} {ms*1.5:10.1f} {ms*2/3:10.1f}")
print(f"reverb pre-delay that lands on the grid: 1/64 = {beat/16:.1f} ms, 1/32 = {beat/8:.1f} ms")

$ python3 delay_times.py 140
140 BPM  (quarter note = 428.6 ms)
  note   straight     dotted    triplet
   1/2      857.1     1285.7      571.4
   1/4      428.6      642.9      285.7
   1/8      214.3      321.4      142.9
  1/16      107.1      160.7       71.4
reverb pre-delay that lands on the grid: 1/64 = 26.8 ms, 1/32 = 53.6 ms

If your delay plugin has a sync button, use it, and you’re done. This matters when it doesn’t: hardware units, older plugins, a tape-style delay where you dial milliseconds, or a reverb whose pre-delay only takes a number.

Why “close enough” falls apart

Say you dialed 250 ms by ear in a 140 BPM session. That’s the eighth note at 120 BPM, and on the first repeat it sounds almost right, because 35.7 ms is easy to miss on one hit. But each repeat is a copy of the last one, so the error stacks:

$ python3 drift.py 140 250 0.5
grid 214.3 ms, delay set to 250.0 ms (+35.7 ms per repeat)
repeat 1:   +35.7 ms off the grid  (+16.7% of a step)
repeat 2:   +71.4 ms off the grid  (+33.3% of a step)
repeat 3:  +107.1 ms off the grid  (+50.0% of a step)
repeat 4:  +142.9 ms off the grid  (+66.7% of a step)
repeat 5:  +178.6 ms off the grid  (+83.3% of a step)

By the third repeat the echo lands exactly a sixteenth late, which is a different rhythm, not a slightly loose one. By the fifth it’s most of the way to the next eighth. This is why a long feedback tail set by ear can make a tight beat feel rushed or dragging even when the first slap sounds fine.

The fix is boring: type the number. If you want the delay a hair behind for feel, push it a few milliseconds late on purpose, and keep the feedback low so the drift can’t pile up.

Pre-delay can sit on the grid too

Reverb pre-delay is the gap before the reverb starts. It keeps the dry vocal clear of its own wash, which is half of what we covered in filtering the reverb return. Any value from about 10 to 60 ms can work, but picking one that’s a clean division of the beat makes the tail feel attached to the groove. At 140 BPM a 1/64 note is 26.8 ms and a 1/32 is 53.6 ms. Start at the 1/64 for a vocal that needs to stay up front, and try the 1/32 on a slow ballad or a snare plate where you want the space to open up.

Slowed and sped-up versions

When you slow the whole bounce, everything printed in it slows together, delays included, so the repeats stay locked to the beat. That goes for a screw in ScrewAI, a tape-style varispeed, or a nightcore speed-up. What doesn’t follow along is any new delay you add after the fact. At 0.8× speed a 140 BPM record becomes 112 BPM, so a fresh throw needs the new tempo:

$ python3 delay_times.py 140 0.8
112 BPM  (quarter note = 535.7 ms)
  note   straight     dotted    triplet
   1/2     1071.4     1607.1      714.3
   1/4      535.7      803.6      357.1
   1/8      267.9      401.8      178.6
  1/16      133.9      200.9       89.3
reverb pre-delay that lands on the grid: 1/64 = 33.5 ms, 1/32 = 67.0 ms

The eighth goes from 214.3 ms to 267.9 ms. Re-use the old number on the slowed version and you’re back to drifting. If you’re making a slowed cut for a release, our note on why screw tempo still needs a legal peak covers the delivery side.

Making throws sit

1. Put the delay on a send, not the insert. Then you can automate the send level on the exact word you want thrown, and leave the rest of the vocal dry.
2. Filter the return. A high-pass around 300 to 500 Hz and a low-pass somewhere in the 4 to 8 kHz range keeps repeats behind the lead instead of competing with it.
3. Keep feedback low on busy beats. Two or three audible repeats is plenty under a full arrangement. Long tails belong in the gaps.
4. Duck it. A compressor on the delay return keyed from the dry vocal pushes the repeats down while the singer is singing and lets them bloom in the space after.
5. Check it in mono. Ping-pong delays are wide by design. Fold to mono and make sure the throw doesn’t vanish or flam. More in why wide mixes fail in mono.

Genre notes

• Trap and drill. Eighth-triplet throws on the last word of a bar sit right with triplet hat rolls. Keep them short and ducked so they don’t mask the 808.
• R&B. A quarter or dotted eighth with gentle feedback on a send, filtered dark, gives the vocal a trail without pushing it back.
• Rock and indie. A slapback around 80 to 140 ms is usually set for feel rather than the grid, and that’s fine because it has no feedback to drift.
• House and techno. Dotted eighths on a stab or vocal chop are the default for a reason. Sync it, and automate the feedback for builds.
• Reggae and dub. Long, high-feedback tails are the instrument. That’s exactly when the number has to be right, because you’re going to hear every repeat.

How do I calculate delay time from BPM?

Divide 60,000 by the tempo to get a quarter note in milliseconds. At 140 BPM that’s 428.6 ms. Halve it for an eighth (214.3 ms), multiply by 1.5 for a dotted note and by 2/3 for a triplet.

What is a dotted eighth delay in milliseconds?

Three-quarters of a beat: 60,000 ÷ BPM × 0.75. At 140 BPM it’s 321.4 ms, at 120 BPM it’s 375 ms.

Why does my delay sound off beat even though it’s close?

Each repeat copies the one before, so a small error adds up. A 250 ms delay in a 140 BPM song is 35.7 ms late on the first repeat and a full sixteenth note late by the third.

Should reverb pre-delay be synced to tempo?

It doesn’t have to be, but a value that’s a clean division of the beat tends to feel attached to the groove. At 140 BPM, 1/64 is 26.8 ms and 1/32 is 53.6 ms, both inside the common 10 to 60 ms range.