diff --git a/packages/superdough/synth.mjs b/packages/superdough/synth.mjs
index 633d0113..3ab3720f 100644
--- a/packages/superdough/synth.mjs
+++ b/packages/superdough/synth.mjs
@@ -20,100 +20,102 @@ const fm = (osc, harmonicityRatio, modulationIndex, wave = 'sine') => {
   return mod(modfreq, modgain, wave);
 };
 
+
 export function registerSynthSounds() {
-  ['sine', 'square', 'triangle', 'sawtooth'].forEach((wave) => {
-    registerSound(
-      wave,
-      (t, value, onended) => {
-        // destructure adsr here, because the default should be different for synths and samples
-        let {
-          attack = 0.001,
-          decay = 0.05,
-          sustain = 0.6,
-          release = 0.01,
-          fmh: fmHarmonicity = 1,
-          fmi: fmModulationIndex,
-          fmenv: fmEnvelopeType = 'lin',
-          fmattack: fmAttack,
-          fmdecay: fmDecay,
-          fmsustain: fmSustain,
-          fmrelease: fmRelease,
-          fmvelocity: fmVelocity,
-          fmwave: fmWaveform = 'sine',
-          vib = 0,
-          vibmod = 0.5,
-        } = value;
-        let { n, note, freq } = value;
-        // with synths, n and note are the same thing
-        note = note || 36;
-        if (typeof note === 'string') {
-          note = noteToMidi(note); // e.g. c3 => 48
-        }
-        // get frequency
-        if (!freq && typeof note === 'number') {
-          freq = midiToFreq(note); // + 48);
-        }
-        // maybe pull out the above frequency resolution?? (there is also getFrequency but it has no default)
-        // make oscillator
-        const { node: o, stop } = getOscillator({
-          t,
-          s: wave,
-          freq,
-          vib,
-          vibmod,
-          partials: n,
-        });
-
-        // FM + FM envelope
-        let stopFm, fmEnvelope;
-        if (fmModulationIndex) {
-          const { node: modulator, stop } = fm(o, fmHarmonicity, fmModulationIndex, fmWaveform);
-          if (![fmAttack, fmDecay, fmSustain, fmRelease, fmVelocity].find((v) => v !== undefined)) {
-            // no envelope by default
-            modulator.connect(o.frequency);
-          } else {
-            fmAttack = fmAttack ?? 0.001;
-            fmDecay = fmDecay ?? 0.001;
-            fmSustain = fmSustain ?? 1;
-            fmRelease = fmRelease ?? 0.001;
-            fmVelocity = fmVelocity ?? 1;
-            fmEnvelope = getEnvelope(fmAttack, fmDecay, fmSustain, fmRelease, fmVelocity, t);
-            if (fmEnvelopeType === 'exp') {
-              fmEnvelope = getExpEnvelope(fmAttack, fmDecay, fmSustain, fmRelease, fmVelocity, t);
-              fmEnvelope.node.maxValue = fmModulationIndex * 2;
-              fmEnvelope.node.minValue = 0.00001;
-            }
-            modulator.connect(fmEnvelope.node);
-            fmEnvelope.node.connect(o.frequency);
+  ['sine', 'square', 'triangle',
+    'sawtooth', 'pink', 'white',
+    'brown'].forEach((wave) => {
+      registerSound(
+        wave,
+        (t, value, onended) => {
+          // destructure adsr here, because the default should be different for synths and samples
+          let {
+            attack = 0.001,
+            decay = 0.05,
+            sustain = 0.6,
+            release = 0.01,
+            fmh: fmHarmonicity = 1,
+            fmi: fmModulationIndex,
+            fmenv: fmEnvelopeType = 'lin',
+            fmattack: fmAttack,
+            fmdecay: fmDecay,
+            fmsustain: fmSustain,
+            fmrelease: fmRelease,
+            fmvelocity: fmVelocity,
+            fmwave: fmWaveform = 'sine',
+            vib = 0,
+            vibmod = 0.5,
+          } = value;
+          let { n, note, freq } = value;
+          // with synths, n and note are the same thing
+          note = note || 36;
+          if (typeof note === 'string') {
+            note = noteToMidi(note); // e.g. c3 => 48
+          }
+          // get frequency
+          if (!freq && typeof note === 'number') {
+            freq = midiToFreq(note); // + 48);
+          }
+          // maybe pull out the above frequency resolution?? (there is also getFrequency but it has no default)
+          // make oscillator
+          const { node: o, stop } = getOscillator({
+            t,
+            s: wave,
+            freq,
+            vib,
+            vibmod,
+            partials: n,
+          });
+          // FM + FM envelope
+          let stopFm, fmEnvelope;
+          if (fmModulationIndex) {
+            const { node: modulator, stop } = fm(o, fmHarmonicity, fmModulationIndex, fmWaveform);
+            if (![fmAttack, fmDecay, fmSustain, fmRelease, fmVelocity].find((v) => v !== undefined)) {
+              // no envelope by default
+              modulator.connect(o.frequency);
+            } else {
+              fmAttack = fmAttack ?? 0.001;
+              fmDecay = fmDecay ?? 0.001;
+              fmSustain = fmSustain ?? 1;
+              fmRelease = fmRelease ?? 0.001;
+              fmVelocity = fmVelocity ?? 1;
+              fmEnvelope = getEnvelope(fmAttack, fmDecay, fmSustain, fmRelease, fmVelocity, t);
+              if (fmEnvelopeType === 'exp') {
+                fmEnvelope = getExpEnvelope(fmAttack, fmDecay, fmSustain, fmRelease, fmVelocity, t);
+                fmEnvelope.node.maxValue = fmModulationIndex * 2;
+                fmEnvelope.node.minValue = 0.00001;
+              }
+              modulator.connect(fmEnvelope.node);
+              fmEnvelope.node.connect(o.frequency);
+            }
+            stopFm = stop;
           }
-          stopFm = stop;
-        }
 
-        // turn down
-        const g = gainNode(0.3);
+          // turn down
+          const g = gainNode(0.3);
 
-        // gain envelope
-        const { node: envelope, stop: releaseEnvelope } = getEnvelope(attack, decay, sustain, release, 1, t);
+          // gain envelope
+          const { node: envelope, stop: releaseEnvelope } = getEnvelope(attack, decay, sustain, release, 1, t);
 
-        o.onended = () => {
-          o.disconnect();
-          g.disconnect();
-          onended();
-        };
-        return {
-          node: o.connect(g).connect(envelope),
-          stop: (releaseTime) => {
-            releaseEnvelope(releaseTime);
-            fmEnvelope?.stop(releaseTime);
-            let end = releaseTime + release;
-            stop(end);
-            stopFm?.(end);
-          },
-        };
-      },
-      { type: 'synth', prebake: true },
-    );
-  });
+          o.onended = () => {
+            o.disconnect();
+            g.disconnect();
+            onended();
+          };
+          return {
+            node: o.connect(g).connect(envelope),
+            stop: (releaseTime) => {
+              releaseEnvelope(releaseTime);
+              fmEnvelope?.stop(releaseTime);
+              let end = releaseTime + release;
+              stop(end);
+              stopFm?.(end);
+            },
+          };
+        },
+        { type: 'synth', prebake: true },
+      );
+    });
 }
 
 export function waveformN(partials, type) {
@@ -146,36 +148,86 @@ export function waveformN(partials, type) {
   return osc;
 }
 
-export function getOscillator({ s, freq, t, vib, vibmod, partials }) {
-  // Make oscillator with partial count
-  let o;
-  if (!partials || s === 'sine') {
-    o = getAudioContext().createOscillator();
-    o.type = s || 'triangle';
-  } else {
-    o = waveformN(partials, s);
-  }
-  o.frequency.value = Number(freq);
-  o.start(t);
+export function getNoiseOscillator({ t, ac, type = 'white' }) {
+  const bufferSize = 2 * ac.sampleRate;
+  const noiseBuffer = ac.createBuffer(1, bufferSize, ac.sampleRate);
+  const output = noiseBuffer.getChannelData(0);
+  let lastOut = 0;
+  let b0, b1, b2, b3, b4, b5, b6;
+  b0 = b1 = b2 = b3 = b4 = b5 = b6 = 0.0;
 
-  // Additional oscillator for vibrato effect
-  let vibrato_oscillator;
-  if (vib > 0) {
-    vibrato_oscillator = getAudioContext().createOscillator();
-    vibrato_oscillator.frequency.value = vib;
-    const gain = getAudioContext().createGain();
-    // Vibmod is the amount of vibrato, in semitones
-    gain.gain.value = vibmod * 100;
-    vibrato_oscillator.connect(gain);
-    gain.connect(o.detune);
-    vibrato_oscillator.start(t);
+  for (let i = 0; i < bufferSize; i++) {
+    if (type === 'white') {
+      output[i] = Math.random() * 2 - 1;
+    } else if (type === 'brown') {
+      let white = Math.random() * 2 - 1;
+      output[i] = (lastOut + (0.02 * white)) / 1.02;
+      lastOut = output[i];
+    } else if (type === 'pink') {
+      let white = Math.random() * 2 - 1;
+      b0 = 0.99886 * b0 + white * 0.0555179;
+      b1 = 0.99332 * b1 + white * 0.0750759;
+      b2 = 0.96900 * b2 + white * 0.1538520;
+      b3 = 0.86650 * b3 + white * 0.3104856;
+      b4 = 0.55000 * b4 + white * 0.5329522;
+      b5 = -0.7616 * b5 - white * 0.0168980;
+      output[i] = b0 + b1 + b2 + b3 + b4 + b5 + b6 + white * 0.5362;
+      output[i] *= 0.11;
+      b6 = white * 0.115926;
+    }
   }
 
+  const o = ac.createBufferSource();
+  o.buffer = noiseBuffer;
+  o.loop = true;
+  o.start(t);
+
   return {
     node: o,
-    stop: (time) => {
-      vibrato_oscillator?.stop(time);
-      o.stop(time);
-    },
+    stop: (time) => o.stop(time)
   };
 }
+
+export function getOscillator({ s, freq, t, vib, vibmod, partials }) {
+  // Make oscillator with partial count
+  let o;
+
+  if (['pink', 'white', 'brown'].includes(s)) {
+    let noiseOscillator = getNoiseOscillator({ t: t, ac: getAudioContext(), type: s })
+    return {
+      node: noiseOscillator.node,
+      stop: noiseOscillator.stop
+    }
+  } else {
+    if (!partials || s === 'sine') {
+      o = getAudioContext().createOscillator();
+      o.type = s || 'triangle';
+    } else {
+      o = waveformN(partials, s);
+    }
+    o.frequency.value = Number(freq);
+    o.start(t);
+
+    // Additional oscillator for vibrato effect
+    let vibrato_oscillator;
+    if (vib > 0) {
+      vibrato_oscillator = getAudioContext().createOscillator();
+      vibrato_oscillator.frequency.value = vib;
+      const gain = getAudioContext().createGain();
+      // Vibmod is the amount of vibrato, in semitones
+      gain.gain.value = vibmod * 100;
+      vibrato_oscillator.connect(gain);
+      gain.connect(o.detune);
+      vibrato_oscillator.start(t);
+    }
+
+    return {
+      node: o,
+      stop: (time) => {
+        vibrato_oscillator?.stop(time);
+        o.stop(time);
+      },
+    };
+  }
+}
+