docs: Ugens > Generators > Stochastic > LFBrownNoise2

🎲 Wandering with LFBrownNoise in SuperCollider

When most people think of “noise,” they imagine static on a TV 📺 or the hiss between FM stations 📻. In synthesis though noise is at the foundations of texture. It can be harsh, or surprisingly smooth. One of my favorite starting points for organic sounding SynthDefs in SuperCollider is the LFBrownNoise family of oscillators which take otherwise chaotic digital randomness and turn it into something organic, like these ocean currents:

🤔 What is LFBrownNoise?

It is really just 3 parts:

LF = Low Frequency → slow changes, good for control signals 🐢
Brown = Brownian motion → like a drunk person stumbling around 🍷🚶‍♂️
Noise = Random values, but with memory ✨

Unlike white noise, which spits out completely unrelated random values each step (pure chaos ⚡), Brownian noise has memory. Each new point is based on the last one, so the signal can’t jump wildly without first drifting through everything in between.

Instead of sharp, jagged chaos, you get a wandering signal that drifts smoothly, like smoke in the air ☁️. The “memory” is what makes it feel alive and organic rather than static-y or harsh.

🎹 A First Example

Here’s a sine wave whose pitch drifts around, guided by Brownian noise:

(
{
    var sig = LFBrownNoise2.kr(1).range(80, 240); // wander between 80–240 Hz at a rate of 1Hz
    SinOsc.ar(sig!2, 0, 0.2); // the last value stated in a function is the return value
}.play;
)

LFBrownNoise1.kr(1) → generates a slow random walk, updated once per second ⏱️
.range(200, 800) → maps the noise into a musical frequency range 🎵
SinOsc → plays a sine wave whose pitch lazily wobbles like a theremin 👽

Compare to LFWhiteNoise.kr(1).range(80, 240)

and regular BrownNoise.kr(1).range(80, 240):

📈 Plotting the Wandering Waveform

Listening is one thing, but seeing it really shows the difference.
You can plot the output of LFBrownNoise over time with .plot:

// Plot 10 seconds of LFBrownNoise2 at 4Hz from range -1 to 1
{ LFBrownNoise2.kr(4).range(-1, 1) }.plot(10);

🪟 Tip: use a window of around 5–10 seconds. Shorter plots look too flat because they are too zoomed in, and very long ones just look thin fuzz because of the wide view.

SuperCollider has three flavors of Brownian noise, see the differences:

LFBrownNoise0 → step-like, choppy 🚧

{ LFBrownNoise0.kr(4) }.plot(10); // choppy steps

LFBrownNoise1 → linear smoothing (straight lines) ➖

{ LFBrownNoise1.kr(4) }.plot(10); // straight lines

LFBrownNoise2 → quadratic smoothing (curvier, organic) 🌊

{ LFBrownNoise2.kr(4) }.plot(10); // curvy smooth

🎨 Making It Musical

The real fun is when you use LFBrownNoise as a controller instead of raw sound.

Wandering stereo panning:

(
{
    var pan = LFBrownNoise2.kr(0.5).range(-1, 1); // wander left ↔ right
    var sig = PinkNoise.ar(0.1);
    Pan2.ar(sig, pan)
}.play;
)

🎧 Feels like the sound is walking across the room.

Breathing filter cutoff:

(
{
    var cutoff = LFBrownNoise1.kr(0.3).range(200, 5000);
    var sig = Saw.ar(110) * 0.1;
    RLPF.ar(sig!2, cutoff, 0.2)
}.play;
)

🌬️ The synth “breathes,” constantly shifting without repeating itself.

🎹 Synth examples

\prizeMachineHum – a prize machine humming in an arcade closed for the night. LFBrownNoise is used to change the numHarmonies parameter of the `Blip` UGen over time which causes unique mechanical noises.

// the synth
(
SynthDef(\prizeMachineHum, {
    arg out = 0, amp = 0.2, pan = 0;
    var sig;
    // signal
    sig = Blip.ar(
        \freq.kr(18),
	// \numHarmonies.kr(4),
        LFBrownNoise1.ar(
		    \sweepHz.kr(0.5)).range(
		        \numHarmLo.kr(8), \numHarmHi.kr(16)
            )
    );
    // filter
    sig = RLPF.ar(sig, \rlpfHz.kr(600), \rlpfRq.kr(0.4));
    sig = RHPF.ar(sig, \rhpfHz.kr(120), \rhpfRq.kr(0.4));
    // pan
    sig = Pan2.ar(sig, pan);
    // out
    Out.ar(out, sig * amp);
}).add;
)
// play it
(
Synth(\prizeMachineHum, [
    \freq, 10,
    \sweepHz, 0.05,
    \numHarmLo, 8, // mess with this range
    \numHarmHi, 12, // mess with this
    \rhpfHz, 120,
    \rhpfRq, 0.8,
    \amp, 0.8
]);
)

\subPressureDrone – a deep water current resonant with the atmospheric pressure of the deep sea. See how LFBrownNoise controls 3 different things: BrownNoise Hz, Amplitude / envelope, and resonant filter cutoff. This makes the underwater current “breathe.”

// the synth
(
SynthDef(\subPressureDrone, {
    arg out = 0, amp = 0.8;
    var sig, noiseHz;
    // signal
    noiseHz = LFBrownNoise2.kr(\lfBrownHz.kr(1), 1.2, 0.3);
    sig = BrownNoise.ar(noiseHz.range(0.04, 0.12));
    // envelope
    sig = sig * amp * noiseHz.range(\volRangeLo.kr(0.3), \volRangeHi.kr(0.8));
    // filter
    sig = RLPF.ar(sig, noiseHz.range(\rlpfLo.kr(600), \rlpfHi.kr(800)), \rlpfRq.kr(0.5));
    // pan
    sig = Pan2.ar(sig, SinOsc.kr(\panRate.kr(0.1)).range(-0.1, 0.1));
    // out
    Out.ar(out, sig);
}).add;
)
// play it
(
Synth(\subPressureDrone, [
    \amp, 0.5,
    \lfBrownHz, 0.9,
    \rlpfLo, 840,
    \rlpfHi, 1040,
    \rlpfRq, 0.6,
    \panRate, 0.05,
    \volRangeLo, 0.2,
    \volRangeHi, 0.8
]);
)

🐳\whaleCall- … a whale call

// the synth
(
SynthDef(\whaleCallBN, {
    arg out = 0, amp = 0.5;
    var lfoHz, noiseHz, sig,
        env, levels, times, curves;
    // LFO
    lfoHz = LFBrownNoise2.ar(1).range(0.4, 0.75);
    noiseHz = LFBrownNoise2.ar(lfoHz); // the noise Hz itself is modulated
    // signal
    sig = SinOsc.ar(noiseHz.range(\freqLo.kr(80), \freqHi.kr(200)));
    sig = sig * amp * noiseHz;
    // envelope
    levels = \levels.kr([0, 0.2, 0.7, 0.1, 0]);
    times = \times.kr([1, 2, 2, 2]);
    curves = \curves.kr([-2, -2, 0, -2]);
    env = Env.new(
        levels: levels,
        times:  times,
        curve:  curves
    );
    env = EnvGen.kr(env, doneAction: 2);
    sig = sig * env;
    // filter
    sig = BPF.ar(sig, 240, 0.4);
    // reverb
    sig = FreeVerb.ar(sig, \verbMix.kr(0.6), \verbRoom.kr(0.6), \verbDamp.kr(0.4));
    // delay
    sig = CombN.ar(sig);
    // pan
    sig = Pan2.ar(sig, 0);
    Out.ar(out, sig);
}).add;
)
// play it
(
Synth(\whaleCallBN, [
    \amp, 0.4,
    \noiseHz, rrand(0.4, 0.65).postln,
    \freqLo, exprand(65, 100).postln,
    \freqHi, exprand(140, 200).postln,
    \rhpfLo, 140,
    \rhpfHi, 200,
    \rhpfrqLo, 0.08,
    \rhpfrqHi, 0.46,
    \rlpfLo, 400,
    \rlpfHi, 500,
    \rlpfrqLo, 0.08,
    \rlpfrqHi, 0.46,
    \times, [1, rrand(2.0, 3.0), rrand(2.0, 3.0), rrand(2.0, 3.0)],
    \verbMix, 0.9,
    \verbRoom, 0.9,
    \verbDamp, 0.9
]);
)

🌟 Closing

LFBrownNoise is proof that randomness doesn’t have to mean chaos. By giving noise a little memory, you end up with signals that feel alive: wandering filters, drifting pitches, and ghostly stereo movements. 👻

LFBrownNoise, use it wisely and use it well for your organic undulations …. eew never say that again.

Now get in there and start colliding!

LFBrownNoise: Your Rando Wandering Friend ⬆️↙️⬆️↘️⬅️🚶‍♀️‍➡️