Modulation chorus · flanger · phaser

01Movement

Chorus, flanger and phaser are usually sold as three effects. They are better understood as one idea seen from three angles: take a copy of the signal, delay or phase-shift it by an amount that changes slowly over time, and add it back to the original. The interference between the two copies sweeps through the spectrum, and the ear reads that sweep as shimmer, width, or a whooshing jet.

All three are linear time-varying systems. At any frozen instant the effect is an ordinary linear filter — a comb, or an allpass cascade — with a perfectly well-defined frequency response. What makes them alive is that a control signal, the low-frequency oscillator (LFO), is continually nudging the filter's parameters, so that response glides. Freeze the LFO and a flanger becomes a static comb filter; a phaser becomes a fixed set of notches. Let it run and the notches march up and down the spectrum.

The distinctions between the three are matters of degree and mechanism, and they are worth stating precisely at the outset because the rest of the page turns on them:

• Flanger — a single short modulated delay, roughly 0.1–10 ms, summed with the dry signal, usually with feedback. Short delays give a comb filter whose notches are harmonically spaced; sweeping the delay slides the whole comb, and feedback sharpens it into the metallic "jet plane".
• Chorus — one or more longer modulated delays, roughly 10–40 ms, with more depth and little or no feedback. The delay is long enough that you no longer hear a comb; instead the pitch wobble of each moving delay detunes the copy, and several decorrelated copies stack into a lush ensemble.
• Phaser — a cascade of first-order allpass sections whose break frequency is swept, summed with the dry signal. Allpass sections do not delay uniformly, so the resulting notches are not harmonically spaced; their number is set by how many stages you cascade.

This page builds each mechanism from its difference equation, then lets you hear all three from one hand-written processing node in the live plugin. The DSP you read in section 8 is, byte for byte, the DSP that renders the audio — the code listing is populated from the same source string that is compiled into the AudioWorklet.

02A short history of putting sound in motion

Modulation effects predate digital signal processing by decades. Every one of them began as a mechanical or electro-mechanical accident that engineers learned to control.

03The shared engine: one LFO

Every modulation effect on this page is driven by the same low-frequency oscillator. It is not in the audio path — you never hear it directly. It is a control signal, running at a rate typically between $0.05$ and $8\ \mathrm{Hz}$, that sets a filter parameter each sample.

A sinusoidal LFO of rate $f_r$ produces

In code the LFO is a single phase accumulator: add a small increment $\Delta\phi = 2\pi f_r/f_s$ each sample and wrap at $2\pi$. From that one running phase we derive the modulated delay time (flanger, chorus) or the allpass break frequency (phaser). A depth control scales the excursion, and a stereo spread control offsets the phase of the right channel by up to $\pi$ so the two channels sweep out of step — the single most important trick for making the effect sound wide.

The generic modulated parameter is an offset plus a scaled LFO:

where $p_0$ is a centre value and $d$ the depth. For a flanger $p$ is a delay in samples; for a phaser it is (via a logarithmic map) a break frequency in hertz. The waveform need not be a sine — triangle gives a linear sweep, and a randomised/smoothed shape gives a slow, unpredictable drift — but the sine is the canonical choice and the one used below.

04Flanger — the swept comb

Add a signal to a short delayed copy of itself and you build a comb filter. Sweep the delay and the comb slides. That is the whole of a flanger.

With a delay of $D$ samples and a mix gain $g$, the feed-forward difference equation is

where $D(n)$ is the LFO-modulated delay. Take the $z$-transform at a frozen $D$ and the transfer function is

The magnitude has nulls wherever $\cos(\omega D) = -1$, i.e. $\omega D = (2k+1)\pi$. Converting $\omega = 2\pi f/f_s$ and $D = f_s \tau$ (with $\tau$ the delay in seconds) gives notch frequencies

These are the flanger's signature: notches at odd multiples of $1/(2\tau)$, harmonically spaced and stacked all the way up the spectrum like the teeth of a comb. A $1\ \mathrm{ms}$ delay puts the first notch at $500\ \mathrm{Hz}$ and repeats every $1\ \mathrm{kHz}$. As the LFO shortens and lengthens $\tau$, every notch slides together — the entire comb breathes.

Feedback: from comb to resonant comb

Routing the delayed output back into the delay input turns the feed-forward comb into a feedback (IIR) comb:

whose frozen transfer function has poles as well as zeros,

The feedback coefficient $f$ (kept $|f|<1$ for stability) sharpens the notches into resonant peaks and troughs. Push it towards unity and the sweeping comb rings — this is the aggressive metallic "jet plane" flange. Negative feedback shifts the notch pattern to even harmonics and gives a thinner, hollow character.

05Chorus — a moving delay is a pitch shift

Lengthen the delay past about ten milliseconds and the comb notches fall so close together that the ear no longer resolves them. What you hear instead is the consequence of the delay changing: a moving delay line is a pitch shifter.

Reading a delay line at a time-varying delay $D(t)$ is a resampling operation. If the instantaneous output samples the input at $t-\tau(t)$, then the output's instantaneous frequency is scaled by the rate of change of that read pointer. Differentiating the phase gives the fractional pitch shift

This is precisely the Doppler effect: when the delay is lengthening ($d\tau/dt>0$) the virtual source recedes and the pitch drops; when the delay shortens the pitch rises. A sinusoidal LFO of rate $f_r$ and depth $\tau_d$ gives $\tau(t)=\tau_0+\tau_d\sin(2\pi f_r t)$, so

a gentle vibrato whose peak deviation is $2\pi f_r \tau_d$. With $f_r = 0.5\ \mathrm{Hz}$ and $\tau_d = 3\ \mathrm{ms}$ the deviation is only about $\pm0.9\%$ — a few cents — which is exactly the subtle detune the ear reads as "another player", not "out of tune".

Why several voices widen it

A single detuned copy sounds like a doubling; an ensemble sounds like a section. The trick is decorrelation: run several delay lines, each with its own LFO phase (and ideally a slightly different rate and centre delay), and sum them. Because their pitch wobbles are out of step, the copies drift in and out of unison independently, and the summed comb pattern is smeared rather than periodic. Panning the voices, or giving the left and right channels opposed LFO phases via the stereo-spread control, turns that decorrelation into stereo width. This is why the Juno chorus — two BBD lines with opposed triangle LFOs — sounds so much wider than a single-line pedal.

Chorus normally uses little or no feedback: the point is thickening, not resonance. Adding feedback pulls the character back towards flanging, which is why many units are really one delay line with a mode switch — the same architecture, different delay range, depth and feedback. That is exactly how the plugin below is built.

06Phaser — a cascade of allpass sections

A flanger delays every frequency by the same amount of time. A phaser instead phase-shifts different frequencies by different amounts, using allpass filters, so its notches are not forced into a harmonic comb.

A first-order allpass has unity gain at every frequency but a frequency-dependent phase. In the sign convention used in the code below,

Its phase runs from $0$ at DC to $-\pi$ at Nyquist, passing through $-\pi/2$ at a break frequency $f_b$ set by the coefficient. Mapping a desired break frequency to the coefficient via the bilinear tangent,

Cascade $N$ such sections and their phases add: the total phase reaches $-N\pi/2$ at $f_b$ and continues to $-N\pi$ at Nyquist. Now sum this allpass output with the dry signal:

Wherever the cascade's phase passes through an odd multiple of $\pi$, the delayed copy is in antiphase with the dry signal and a notch appears. A cascade of $N$ first-order sections produces about $\lfloor N/2\rfloor$ notches in the audio band. Sweeping the coefficient $a$ with the LFO drags every break frequency, and the notches glide.

The crucial difference from the flanger: the allpass phase curve is not linear in $\omega$, so the frequencies where the phase hits $\pi, 3\pi, 5\pi,\dots$ are not evenly spaced. Phaser notches are non-uniform, their count fixed by the number of stages rather than by a delay time. A four-stage MXR Phase 90 gives two notches; a Small Stone or a "ten-stage" digital phaser gives more, deeper sweeps. Feedback around the cascade sharpens the notches, just as it does for the flanger.

07Fractional delay and the zipper problem

The modulated delay $D(n)$ is almost never a whole number of samples. Reading the delay line at an integer index and snapping $D(n)$ to the nearest sample produces audible steps — "zipper noise" — every time the pointer jumps. Smooth modulation demands a fractional read.

The simplest interpolator is linear. To read the delay line at fractional position $D = i + \delta$ (integer part $i$, fraction $0\le\delta<1$):

Linear interpolation is cheap and unconditionally stable, and it is what the plugin below uses. Its cost is a mild, delay-dependent low-pass tilt — the interpolator attenuates high frequencies most when $\delta=0.5$ — which for chorus and flanger is inaudible against the effect itself.

Where the very top octave must be preserved, two better options exist:

• Allpass interpolation. A first-order allpass tuned to fractional delay $\delta$ gives exact magnitude (no high-frequency loss) at the cost of a phase error and some transient smearing; it is the classic choice for high-quality flangers. Its coefficient is $\eta = (1-\delta)/(1+\delta)$.
• Lagrange / spline interpolation. A third-order (four-point) Lagrange polynomial is the standard "hi-fi" fractional-delay kernel, trading a few multiplies for a flatter passband than linear.

Whatever the kernel, the deeper requirement is that the read pointer move continuously. As long as $D(n)$ is a smooth function of the LFO and the interpolation is at least linear, the delay glides without zipper artefacts. Julius Smith's treatment of time-varying delay lines in Physical Audio Signal Processing is the definitive reference for choosing between these kernels.

08Live plugin — one node, three effects

Everything above, running in your browser. A single AudioWorklet holds one shared LFO, one pair of interpolated delay lines and one allpass chain; the mode switch chooses which path is active. The code listing beneath the plugin is filled in from the very same source string that is compiled into the worklet — what you read is what you hear.

The exact DSP running above — a hand-written modulated-delay + allpass engine. Chorus/flanger read interpolated delay lines; the phaser runs a first-order allpass cascade. All three share one LFO phase.

loading…

Reading the display

The main graph draws the effect's instantaneous magnitude response, recomputed every animation frame from the live LFO phase, so you watch the notches sweep in real time — a harmonic comb in flanger mode, a smeared comb in chorus, and the non-uniform allpass notches in phaser. Below the plugin, three further canvases expose the internals.

09The same effect in JUCE

In a real plugin you would lean on juce::dsp for the chorus and flanger and hand-roll the allpass cascade for the phaser, all driven by a single juce::dsp::Oscillator LFO and exposed through an AudioProcessorValueTreeState.

The chorus and flanger are the same object — juce::dsp::Chorus is a modulated delay with feedback, so a "flanger" is simply that class configured with a short centre delay and higher feedback. The phaser is a cascade of first-order allpass sections; juce::dsp::FirstOrderTPTFilter in allpass mode, or a bank of juce::dsp::IIR::Filter with allpass coefficients, does the job.

// ---- ModulationProcessor.h -------------------------------------------
#pragma once
#include <juce_audio_processors/juce_audio_processors.h>
#include <juce_dsp/juce_dsp.h>

class ModulationProcessor : public juce::AudioProcessor
{
public:
    ModulationProcessor();
    void prepareToPlay (double sampleRate, int samplesPerBlock) override;
    void processBlock (juce::AudioBuffer<float>&, juce::MidiBuffer&) override;
    // ... boilerplate elided ...

    juce::AudioProcessorValueTreeState apvts;
    static juce::AudioProcessorValueTreeState::ParameterLayout layout();

private:
    enum Mode { Chorus = 0, Flanger, Phaser };

    juce::dsp::Chorus<float>      chorus;   // used for CHORUS and FLANGER
    juce::dsp::Oscillator<float>  lfo;      // shared LFO for the phaser

    // hand-rolled first-order allpass cascade for the phaser
    static constexpr int kMaxStages = 8;
    std::array<juce::dsp::IIR::Filter<float>, kMaxStages> apL, apR;
    std::array<float, 2> fbState { 0.0f, 0.0f };
    double fs = 44100.0;
};

// ---- ModulationProcessor.cpp -----------------------------------------
juce::AudioProcessorValueTreeState::ParameterLayout
ModulationProcessor::layout()
{
    using P = juce::AudioParameterFloat;
    using C = juce::AudioParameterChoice;
    juce::AudioProcessorValueTreeState::ParameterLayout l;
    l.add (std::make_unique<C>("mode", "Mode",
              juce::StringArray{ "Chorus","Flanger","Phaser" }, 0));
    l.add (std::make_unique<P>("rate",  "Rate",
              juce::NormalisableRange<float>(0.05f, 8.0f, 0.0f, 0.3f), 0.4f));
    l.add (std::make_unique<P>("depth", "Depth", 0.0f, 1.0f, 0.5f));
    l.add (std::make_unique<P>("fb",    "Feedback", -0.95f, 0.95f, 0.2f));
    l.add (std::make_unique<P>("mix",   "Mix",   0.0f, 1.0f, 0.5f));
    l.add (std::make_unique<juce::AudioParameterInt>("stages","Stages",2,8,4));
    return l;
}

void ModulationProcessor::prepareToPlay (double sampleRate, int block)
{
    fs = sampleRate;
    juce::dsp::ProcessSpec spec { sampleRate,
                                  (juce::uint32) block,
                                  (juce::uint32) getTotalNumOutputChannels() };
    chorus.prepare (spec);
    lfo.initialise ([] (float x) { return std::sin (x); }, 128);
    lfo.prepare (spec);
    for (auto& f : apL) f.prepare (spec);
    for (auto& f : apR) f.prepare (spec);
}

// first-order allpass coefficient for a given break frequency
static inline float allpassCoeff (float fb, double fs)
{
    const float t = std::tan (juce::MathConstants<float>::pi * fb / (float) fs);
    return (t - 1.0f) / (t + 1.0f);              // matches H(z) = (-a + z^-1)/(1 - a z^-1)
}

void ModulationProcessor::processBlock (juce::AudioBuffer<float>& buffer,
                                        juce::MidiBuffer&)
{
    const int mode   = (int)  apvts.getRawParameterValue ("mode")  ->load();
    const float rate = apvts.getRawParameterValue ("rate")  ->load();
    const float depth= apvts.getRawParameterValue ("depth") ->load();
    const float fb   = apvts.getRawParameterValue ("fb")    ->load();
    const float mix  = apvts.getRawParameterValue ("mix")   ->load();
    const int stages = (int)  apvts.getRawParameterValue ("stages")->load();

    if (mode == Chorus || mode == Flanger)
    {
        // FLANGER = short centre delay + more feedback; CHORUS = long delay, wide depth
        const float centreMs = (mode == Flanger) ? 2.0f : 20.0f;
        chorus.setRate (rate);
        chorus.setDepth (depth);
        chorus.setCentreDelay (centreMs);
        chorus.setFeedback (mode == Flanger ? fb : fb * 0.3f);
        chorus.setMix (mix);
        juce::dsp::AudioBlock<float> block (buffer);
        chorus.process (juce::dsp::ProcessContextReplacing<float> (block));
        return;
    }

    // ---- PHASER: swept allpass cascade summed with dry ----
    lfo.setFrequency (rate);
    auto* L = buffer.getWritePointer (0);
    auto* R = buffer.getNumChannels() > 1 ? buffer.getWritePointer (1) : L;

    for (int n = 0; n < buffer.getNumSamples(); ++n)
    {
        const float m  = 0.5f + 0.5f * lfo.processSample (0.0f);   // 0..1
        const float fbHz = 200.0f * std::pow (11.0f, m * (0.4f + 0.6f * depth));
        const float a  = allpassCoeff (fbHz, fs);
        const auto  co = juce::dsp::IIR::Coefficients<float>::Ptr (
                             new juce::dsp::IIR::Coefficients<float> (-a, 1.0f, 1.0f, -a));

        auto stage = [&] (float x, auto& chain, float& fbSt) -> float
        {
            float v = x + fb * fbSt;
            for (int s = 0; s < stages; ++s) { chain[s].coefficients = co; v = chain[s].processSample (v); }
            fbSt = v;
            return x + mix * v;
        };
        L[n] = stage (L[n], apL, fbState[0]);
        R[n] = stage (R[n], apR, fbState[1]);
    }
}

Idiomatic JUCE: APVTS-backed parameters, juce::dsp::Chorus reused for chorus and flanger, a hand-rolled IIR allpass cascade for the phaser, all sharing one juce::dsp::Oscillator. The allpassCoeff helper is the same tangent map used in the JavaScript, so the two implementations agree sample-for-sample in the frozen limit.

10Reference & further reading

The three effects compared