Delay Lines and Echo

in reviewThis lesson is complete and being validated before release - details may still change.

Delay line

Loading interactive demo…

A delay line is a ring buffer exactly one delay long. Every sample reads the echo waiting in its slot, writes the input plus a share of that echo back into the same slot, and moves on; what went in comes back out one trip round the ring later, and the feedback makes it come back again and again. Take the tour, or press and explore. Legend:

The panel beside the stage is the real DelayLine class from the published library executing in your browser, with the current line highlighted.

The pluck going in, drawn faintly behind the output.
The line's output so far, and the echoes waiting in the ring on the right.
The sample being computed this step, and the ring slot it reads and writes.

The inset is the ring itself: one bar per slot, as tall as the echo stored there, with the slot in use marked. echoes counts how many repeats stay above -40 dB and tail is how long they take to fall 60 dB, both from the feedback. Press Wet for a 220 Hz pluck through this line, the same class run at 44.1 kHz with the delay at the same milliseconds, and Dry for the pluck on its own.

The code panel shows bare executable code by default. The bar above it names the file (hover the name for the full published path); options holds the toggles: comments, the tracer instrumentation that produces this visualization, and verbose names for the terse identifiers (display only: the default is the byte-exact published file). The view switch adds plain-English narration: both interleaves it with the code, pseudo shows only the pseudocode. hide code collapses the panel; the rail it leaves behind brings it back.

Keys: Space play/pause · ←/→ step · Home/End jump · R reset · F fullscreen · G guided tour

A delay line with feedback is two equations. The ring holds a signal $w$ ; the output mixes the input with the echo read from it:

w[n] = x[n] + g\,w[n-D], \qquad y[n] = (1 - m)\,x[n] + m\,w[n-D],

where $D$ is the delay in samples, $g$ the feedback, and $m$ the mix. Because the ring is exactly $D$ slots long and the pointer reads a slot before overwriting it, $w[n-D]$ is simply whatever is in the slot when the pointer arrives: one circular index does the whole job.

Impulse response. Feed in a single sample of height 1 and the echo side of the output is a geometric series,

h[n] = (1 - m)\,\delta[n] + m \sum_{k \ge 1} g^{\,k-1}\,\delta[n - kD],

one echo every $D$ samples, each $g$ times the last. The sum converges whenever $|g| < 1$ , which is why the class refuses a feedback of 1 or more: at 1 the echoes never die, and above it they grow until the buffer overflows.

In frequency. The feedback loop's transfer function is $1 / (1 - g\,z^{-D})$ , which has $D$ equally spaced resonant peaks between 0 and the sample rate, at every multiple of $f_s / D$ . On the ear this is a comb: at delays under about 20 ms the peaks are far enough apart to hear as a pitch, which is where the flanger lesson begins; above that the ear hears separate echoes instead.

Tail time. Each trip round the ring scales the echo by $g$ , that is by $20 \log_{10} g$ decibels. The time to fall to a floor of $L$ dB (the stage reports $-60$ dB, the usual point of silence) is

T_L = D_{\text{s}} \cdot \frac{L}{20 \log_{10} g},

with $D_{\text{s}}$ the delay in seconds. At $g = 0.5$ that is just under ten trips, so a 250 ms delay rings for about 2.5 s.

Choices worth reading closely in the implementation (the code panel's comments and tracer checkboxes reveal the full published file):

One slot, read then written. A ring exactly delaySamples long needs only one index: the slot the pointer reads is the slot it last wrote one full trip ago, so the read event and the write event of a sample share a slot. A longer buffer would need a separate read pointer trailing the write pointer by the delay; this is that design with the two pointers merged.
The feedback goes into the ring, the mix goes to the output. What is stored is x + feedback * delayed, so the repeats compound inside the buffer; what comes out is a blend of the dry input and the echo. Swapping the two would make the mix knob change how many echoes there are.
The ring survives between process calls. A real effect runs in blocks of a few hundred samples; clearing the buffer at a block boundary would cut every echo short. reset is for a new note or a changed delay.
wrap is a subtraction, not a remainder. The pointer is compared with the length and set back to zero, which is both cheaper than a modulo and the moment the tour stops on.
tailSeconds is arithmetic on the feedback, not a measurement of the output, and the tests pin it: ten trips at a feedback of 0.5, nothing at all when the feedback is zero.

Echo was the first studio effect, and for twenty years it was tape: a sound recorded on one head and read back by another a little further along, the distance between them being the delay. Les Paul was an early pioneer; Sam Phillips built the Sun Records slapback from two Ampex machines in 1954; the Echoplex of 1959 put a movable record head in a box a guitarist could carry. Bucket-brigade chips replaced the tape in the 1970s and digital memory replaced those, but the mechanism never changed: a buffer one delay long, written at one end, read at the other, a share of the output fed back in.

1954Sam Phillips - At Sun Records, two Ampex 350 recorders produce the slapback echo that marks the label's productions.source
1959Mike Battle - The first Echoplex tape units are made: a moving record head sets the delay without changing the tape speed, and the first 500 go to Chicago Musical Instruments.source
1969F. Sangster and K. Teer, Philips - The bucket-brigade device is developed at Philips Research Labs in the Netherlands: a chain of capacitors passes a sample along one stage per clock, the analog delay line behind the chorus and delay pedals of the next decade.source
1971Eventide - The DDL 1745 arrives as an early digital delay, an expensive rack unit; the Boss DD-2 of 1984 puts the digital delay line in a pedal.source

Used today

Echo, slapback, and dub - A single short repeat thickens a vocal; a long delay with feedback is the dub echo that trails into the next bar.
Chorus, flanger, and reverb - A delay line whose length is swept by an oscillator is a chorus or a flanger; several in parallel with feedback are the combs of a reverb.
Physical modelling - Karplus-Strong plucks a string by feeding a delay line back through a filter: the ring is the string and its length is the pitch.
Network and pipeline buffers - The same ring buffer, written by a producer and read a fixed distance behind, is the jitter buffer in a voice call and the FIFO in a hardware pipeline.

delay250 ms

feedback0.50

mix0.50

delay: 250 ms
echoes: 6
tail: 2.49 s
out/in: 0.80

delay-line.ts

import type { Tracer } from "../trace";import { SampleRate } from "./sample-rate";/** * A delay line: a ring buffer exactly one delay long, so the slot read * at every sample holds what was written there one delay ago. Each * sample reads the echo from the slot, writes the input plus a share of * that echo back into the same slot (the feedback that makes echoes * repeat), mixes the echo with the input, and moves the slot on, * wrapping to the start when it passes the end. The buffer survives * between calls, so a signal can be processed in blocks. * * Time: O(n) per call over n samples. Space: O(D) for a delay of D samples. */export class DelayLine {  private buffer = new Float32Array(1);  private slot = 0;  private ringPosition = 0;  private delaySeconds = 0;  private feedback = 0;  private mix = 0;  constructor(    readonly sampleRate: number,    private readonly tracer?: Tracer,  ) {    SampleRate.assert(sampleRate);  }  /** The length of the ring: how many samples the echo lags the input. */  get delaySamples(): number {    return this.buffer.length;  }  /** Sizes the ring for a delay and sets how much echo is fed back and mixed in. */  configure(delaySeconds: number, feedback: number, mix: number): void {    if (!(delaySeconds > 0)) throw new RangeError(`delay must be positive, got ${delaySeconds}`);    if (!(feedback >= 0 && feedback < 1)) throw new RangeError(`feedback must be in [0, 1), got ${feedback}`);    if (!(mix >= 0 && mix <= 1)) throw new RangeError(`mix must be in [0, 1], got ${mix}`);    const delaySamples = Math.max(1, Math.round(delaySeconds * this.sampleRate));    this.buffer = new Float32Array(delaySamples);    this.slot = 0;    this.ringPosition = 0;    this.delaySeconds = delaySeconds;    this.feedback = feedback;    this.mix = mix;    // ▸ size the ring to the delay and remember feedback and mix    this.tracer?.emit("setup", { delaySeconds, delaySamples, feedback, mix });  }  /** Runs the signal through the line, carrying the ring across calls. */  process(input: ArrayLike<number>): Float32Array {    const out = new Float32Array(input.length);    for (let i = 0; i < input.length; i++) {      const x = input[i]!;      const delayed = this.buffer[this.slot]!;      const echo = this.buffer[this.ringPosition]!;      // ▸ take the echo out of the slot: what went in one delay ago      this.tracer?.emit("read", { index: i, slot: this.slot, delayed });      this.tracer?.emit("read", { index: i, ringPosition: this.ringPosition, echo });      // The same slot is read then overwritten: what goes in now comes      // back out exactly one trip round the ring later.      const stored = x + this.feedback * delayed;      const fedBack = x + this.feedback * echo;      this.buffer[this.slot] = stored;      this.buffer[this.ringPosition] = fedBack;      const y = (1 - this.mix) * x + this.mix * delayed;      const y = (1 - this.mix) * x + this.mix * echo;      // ▸ put the input plus a share of the echo back, mix the output      this.tracer?.emit("write", { index: i, slot: this.slot, stored, y });      this.tracer?.emit("write", { index: i, ringPosition: this.ringPosition, fedBack, y });      out[i] = y;      this.slot += 1;      this.ringPosition += 1;      if (this.slot === this.buffer.length) {      if (this.ringPosition === this.buffer.length) {        this.slot = 0;        this.ringPosition = 0;        // ▸ the slot passed the end of the ring: back to the start        this.tracer?.emit("wrap", { index: i, slot: this.slot });        this.tracer?.emit("wrap", { index: i, ringPosition: this.ringPosition });      }    }    return out;  }  /** How long the echoes take to fall below a floor: each trip round the ring costs 20 log of the feedback. */  tailSeconds(floorDb = -60): number {    if (this.feedback <= 0) return 0;    const perTripDb = 20 * Math.log10(this.feedback);    return this.delaySeconds * (floorDb / perTripDb);  }  /** Clears the ring, for a fresh note. */  reset(): void {    this.buffer.fill(0);    this.slot = 0;    this.ringPosition = 0;  }}

All 128 samples through the line; 6 echoes stay above -40 dB.

import type { Tracer } from "../trace";import { SampleRate } from "./sample-rate";/** * A delay line: a ring buffer exactly one delay long, so the slot read * at every sample holds what was written there one delay ago. Each * sample reads the echo from the slot, writes the input plus a share of * that echo back into the same slot (the feedback that makes echoes * repeat), mixes the echo with the input, and moves the slot on, * wrapping to the start when it passes the end. The buffer survives * between calls, so a signal can be processed in blocks. * * Time: O(n) per call over n samples. Space: O(D) for a delay of D samples. */export class DelayLine { private buffer = new Float32Array(1); private slot = 0; private ringPosition = 0; private delaySeconds = 0; private feedback = 0; private mix = 0; constructor( readonly sampleRate: number, private readonly tracer?: Tracer, ) { SampleRate.assert(sampleRate); } /** The length of the ring: how many samples the echo lags the input. */ get delaySamples(): number { return this.buffer.length; } /** Sizes the ring for a delay and sets how much echo is fed back and mixed in. */ configure(delaySeconds: number, feedback: number, mix: number): void { if (!(delaySeconds > 0)) throw new RangeError(`delay must be positive, got ${delaySeconds}`); if (!(feedback >= 0 && feedback < 1)) throw new RangeError(`feedback must be in [0, 1), got ${feedback}`); if (!(mix >= 0 && mix <= 1)) throw new RangeError(`mix must be in [0, 1], got ${mix}`); const delaySamples = Math.max(1, Math.round(delaySeconds * this.sampleRate)); this.buffer = new Float32Array(delaySamples); this.slot = 0; this.ringPosition = 0; this.delaySeconds = delaySeconds; this.feedback = feedback; this.mix = mix; // ▸ size the ring to the delay and remember feedback and mix this.tracer?.emit("setup", { delaySeconds, delaySamples, feedback, mix }); } /** Runs the signal through the line, carrying the ring across calls. */ process(input: ArrayLike<number>): Float32Array { const out = new Float32Array(input.length); for (let i = 0; i < input.length; i++) { const x = input[i]!; const delayed = this.buffer[this.slot]!; const echo = this.buffer[this.ringPosition]!; // ▸ take the echo out of the slot: what went in one delay ago this.tracer?.emit("read", { index: i, slot: this.slot, delayed }); this.tracer?.emit("read", { index: i, ringPosition: this.ringPosition, echo }); // The same slot is read then overwritten: what goes in now comes // back out exactly one trip round the ring later. const stored = x + this.feedback * delayed; const fedBack = x + this.feedback * echo; this.buffer[this.slot] = stored; this.buffer[this.ringPosition] = fedBack; const y = (1 - this.mix) * x + this.mix * delayed; const y = (1 - this.mix) * x + this.mix * echo; // ▸ put the input plus a share of the echo back, mix the output this.tracer?.emit("write", { index: i, slot: this.slot, stored, y }); this.tracer?.emit("write", { index: i, ringPosition: this.ringPosition, fedBack, y }); out[i] = y; this.slot += 1; this.ringPosition += 1; if (this.slot === this.buffer.length) { if (this.ringPosition === this.buffer.length) { this.slot = 0; this.ringPosition = 0; // ▸ the slot passed the end of the ring: back to the start this.tracer?.emit("wrap", { index: i, slot: this.slot }); this.tracer?.emit("wrap", { index: i, ringPosition: this.ringPosition }); } } return out; } /** How long the echoes take to fall below a floor: each trip round the ring costs 20 log of the feedback. */ tailSeconds(floorDb = -60): number { if (this.feedback <= 0) return 0; const perTripDb = 20 * Math.log10(this.feedback); return this.delaySeconds * (floorDb / perTripDb); } /** Clears the ring, for a fresh note. */ reset(): void { this.buffer.fill(0); this.slot = 0; this.ringPosition = 0; }}