From a71b7e7cf7153978576c0bbf4e764f2bfa93c674 Mon Sep 17 00:00:00 2001 From: Pablo Alcantar Date: Sat, 11 Apr 2026 21:40:51 +0200 Subject: [PATCH 01/14] Fix getBankForIndex() bounds check Was clamping to programsPerBank (10) instead of numBanks (3). The banks array only has numBanks elements, so an out-of-range index would access beyond the array. Never triggered in practice because ProgramSelector pre-clamps, but incorrect regardless. Co-Authored-By: Claude Opus 4.6 (1M context) --- src/noise-plethora/plugins/Banks.cpp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/noise-plethora/plugins/Banks.cpp b/src/noise-plethora/plugins/Banks.cpp index 70558b6..7197df2 100644 --- a/src/noise-plethora/plugins/Banks.cpp +++ b/src/noise-plethora/plugins/Banks.cpp @@ -106,7 +106,7 @@ static std::array banks { bank1, bank2, bank3 }; //, bank5 }; Bank& getBankForIndex(int i) { if (i < 0) i = 0; - if (i >= programsPerBank) - i = (programsPerBank - 1); + if (i >= numBanks) + i = (numBanks - 1); return banks[i]; } From e699fa6e768716283bce294eaa1421d9fa353a3a Mon Sep 17 00:00:00 2001 From: Pablo Alcantar Date: Sat, 11 Apr 2026 21:41:05 +0200 Subject: [PATCH 02/14] Add Banks D and E: 20 new noise synthesis plugins Bank D "Resonant Bodies" (10 plugins): - CombNoise, PluckCloud, TubeResonance, FormantNoise, BowedMetal - FlangeNoise, NoiseBells, NoiseHarmonics, IceRain, DroneBody Bank E "Chaos Machines" (10 plugins): - LogisticNoise, HenonDust, CellularSynth, StochasticPulse, BitShift - FeedbackFM, RunawayFilter, GlitchLoop, SubHarmonic, DualAttractor Co-Authored-By: Claude Opus 4.6 (1M context) --- src/noise-plethora/plugins/Banks.cpp | 41 +++-- src/noise-plethora/plugins/Banks.hpp | 2 +- src/noise-plethora/plugins/Banks_Def.hpp | 28 +++- src/noise-plethora/plugins/P_BitShift.hpp | 55 +++++++ src/noise-plethora/plugins/P_BowedMetal.hpp | 137 +++++++++++++++++ .../plugins/P_CellularSynth.hpp | 131 ++++++++++++++++ src/noise-plethora/plugins/P_CombNoise.hpp | 100 +++++++++++++ src/noise-plethora/plugins/P_DroneBody.hpp | 86 +++++++++++ .../plugins/P_DualAttractor.hpp | 133 +++++++++++++++++ src/noise-plethora/plugins/P_FeedbackFM.hpp | 67 +++++++++ src/noise-plethora/plugins/P_FlangeNoise.hpp | 60 ++++++++ src/noise-plethora/plugins/P_FormantNoise.hpp | 106 +++++++++++++ src/noise-plethora/plugins/P_GlitchLoop.hpp | 106 +++++++++++++ src/noise-plethora/plugins/P_HenonDust.hpp | 76 ++++++++++ src/noise-plethora/plugins/P_IceRain.hpp | 66 ++++++++ .../plugins/P_LogisticNoise.hpp | 70 +++++++++ src/noise-plethora/plugins/P_NoiseBells.hpp | 141 ++++++++++++++++++ .../plugins/P_NoiseHarmonics.hpp | 64 ++++++++ src/noise-plethora/plugins/P_PluckCloud.hpp | 119 +++++++++++++++ .../plugins/P_RunawayFilter.hpp | 55 +++++++ .../plugins/P_StochasticPulse.hpp | 68 +++++++++ src/noise-plethora/plugins/P_SubHarmonic.hpp | 101 +++++++++++++ .../plugins/P_TubeResonance.hpp | 109 ++++++++++++++ 23 files changed, 1900 insertions(+), 21 deletions(-) create mode 100644 src/noise-plethora/plugins/P_BitShift.hpp create mode 100644 src/noise-plethora/plugins/P_BowedMetal.hpp create mode 100644 src/noise-plethora/plugins/P_CellularSynth.hpp create mode 100644 src/noise-plethora/plugins/P_CombNoise.hpp create mode 100644 src/noise-plethora/plugins/P_DroneBody.hpp create mode 100644 src/noise-plethora/plugins/P_DualAttractor.hpp create mode 100644 src/noise-plethora/plugins/P_FeedbackFM.hpp create mode 100644 src/noise-plethora/plugins/P_FlangeNoise.hpp create mode 100644 src/noise-plethora/plugins/P_FormantNoise.hpp create mode 100644 src/noise-plethora/plugins/P_GlitchLoop.hpp create mode 100644 src/noise-plethora/plugins/P_HenonDust.hpp create mode 100644 src/noise-plethora/plugins/P_IceRain.hpp create mode 100644 src/noise-plethora/plugins/P_LogisticNoise.hpp create mode 100644 src/noise-plethora/plugins/P_NoiseBells.hpp create mode 100644 src/noise-plethora/plugins/P_NoiseHarmonics.hpp create mode 100644 src/noise-plethora/plugins/P_PluckCloud.hpp create mode 100644 src/noise-plethora/plugins/P_RunawayFilter.hpp create mode 100644 src/noise-plethora/plugins/P_StochasticPulse.hpp create mode 100644 src/noise-plethora/plugins/P_SubHarmonic.hpp create mode 100644 src/noise-plethora/plugins/P_TubeResonance.hpp diff --git a/src/noise-plethora/plugins/Banks.cpp b/src/noise-plethora/plugins/Banks.cpp index 7197df2..df020ff 100644 --- a/src/noise-plethora/plugins/Banks.cpp +++ b/src/noise-plethora/plugins/Banks.cpp @@ -77,31 +77,42 @@ int Bank::getSize() { #include "P_Rwalk_BitCrushPW.hpp" #include "P_Rwalk_LFree.hpp" -// Bank D: Test / other -//#include "P_TestPlugin.hpp" -//#include "P_TeensyAlt.hpp" -//#include "P_WhiteNoise.hpp" -//#include "P_Rwalk_LBit.hpp" -//#include "P_Rwalk_SineFM.hpp" -//#include "P_VarWave.hpp" -//#include "P_RwalkVarWave.hpp" -//#include "P_Rwalk_ModWave.hpp" -//#include "P_Rwalk_WaveTwist.hpp" +// Bank D: Resonant Bodies +#include "P_CombNoise.hpp" +#include "P_PluckCloud.hpp" +#include "P_TubeResonance.hpp" +#include "P_FormantNoise.hpp" +#include "P_BowedMetal.hpp" +#include "P_FlangeNoise.hpp" +#include "P_NoiseBells.hpp" +#include "P_NoiseHarmonics.hpp" +#include "P_IceRain.hpp" +#include "P_DroneBody.hpp" + +// Bank E: Chaos Machines +#include "P_LogisticNoise.hpp" +#include "P_HenonDust.hpp" +#include "P_CellularSynth.hpp" +#include "P_StochasticPulse.hpp" +#include "P_BitShift.hpp" +#include "P_FeedbackFM.hpp" +#include "P_RunawayFilter.hpp" +#include "P_GlitchLoop.hpp" +#include "P_SubHarmonic.hpp" +#include "P_DualAttractor.hpp" static const Bank bank1 BANKS_DEF_1; // Banks_Def.hpp static const Bank bank2 BANKS_DEF_2; static const Bank bank3 BANKS_DEF_3; -//static const Bank bank4 BANKS_DEF_4; -//static const Bank bank5 BANKS_DEF_5; -static std::array banks { bank1, bank2, bank3 }; //, bank5 }; +static const Bank bank4 BANKS_DEF_4; +static const Bank bank5 BANKS_DEF_5; +static std::array banks { bank1, bank2, bank3, bank4, bank5 }; -// static const Bank bank6 BANKS_DEF_6; // static const Bank bank7 BANKS_DEF_7; // static const Bank bank8 BANKS_DEF_8; // static const Bank bank9 BANKS_DEF_9; // static const Bank bank10 BANKS_DEF_10; -// static std::array banks { bank1, bank2, bank3, bank4, bank5, bank6, bank7, bank8, bank9, bank10 }; Bank& getBankForIndex(int i) { if (i < 0) diff --git a/src/noise-plethora/plugins/Banks.hpp b/src/noise-plethora/plugins/Banks.hpp index c7a703b..cfece95 100644 --- a/src/noise-plethora/plugins/Banks.hpp +++ b/src/noise-plethora/plugins/Banks.hpp @@ -6,7 +6,7 @@ #include static const int programsPerBank = 10; -static const int numBanks = 3; +static const int numBanks = 5; struct Bank { diff --git a/src/noise-plethora/plugins/Banks_Def.hpp b/src/noise-plethora/plugins/Banks_Def.hpp index 41c1f63..10334aa 100644 --- a/src/noise-plethora/plugins/Banks_Def.hpp +++ b/src/noise-plethora/plugins/Banks_Def.hpp @@ -40,14 +40,32 @@ } #define BANKS_DEF_4 { \ - { "TestPlugin", 1.0 }, \ - { "WhiteNoise", 1.0 }, \ - { "TeensyAlt", 1.0 } \ + { "CombNoise", 1.0 }, \ + { "PluckCloud", 1.0 }, \ + { "TubeResonance", 1.0 }, \ + { "FormantNoise", 1.0 }, \ + { "BowedMetal", 1.0 }, \ + { "FlangeNoise", 1.0 }, \ + { "NoiseBells", 0.8 }, \ + { "NoiseHarmonics", 1.0 }, \ + { "IceRain", 1.0 }, \ + { "DroneBody", 1.0 } \ + } + +#define BANKS_DEF_5 { \ + { "LogisticNoise", 1.0 }, \ + { "HenonDust", 1.0 }, \ + { "CellularSynth", 1.0 }, \ + { "StochasticPulse", 1.0 }, \ + { "BitShift", 1.0 }, \ + { "FeedbackFM", 1.0 }, \ + { "RunawayFilter", 1.0 }, \ + { "GlitchLoop", 1.0 }, \ + { "SubHarmonic", 1.0 }, \ + { "DualAttractor", 1.0 } \ } -#define BANKS_DEF_5 // #define BANKS_DEF_6 -// #define BANKS_DEF_7 // #define BANKS_DEF_8 // #define BANKS_DEF_9 // #define BANKS_DEF_10 diff --git a/src/noise-plethora/plugins/P_BitShift.hpp b/src/noise-plethora/plugins/P_BitShift.hpp new file mode 100644 index 0000000..6f4f2f2 --- /dev/null +++ b/src/noise-plethora/plugins/P_BitShift.hpp @@ -0,0 +1,55 @@ +#pragma once + +#include "NoisePlethoraPlugin.hpp" + +class BitShift : public NoisePlethoraPlugin { + +public: + + BitShift() { } + + ~BitShift() override {} + + BitShift(const BitShift&) = delete; + BitShift& operator=(const BitShift&) = delete; + + void init() override { + // sawtooths produce diverse bit patterns — XOR creates rich digital artifacts + // (square waves only have 2 values, XOR of ±32767 produces near-silence) + waveform1.begin(1.0f, 100, WAVEFORM_SAWTOOTH); + waveform2.begin(1.0f, 200, WAVEFORM_SAWTOOTH); + combine1.setCombineMode(1); // XOR + } + + void process(float k1, float k2) override { + float freq1 = 20.0f + pow(k1, 2) * 5000.0f; + float freq2 = freq1 * (1.0f + k2 * 7.0f); + waveform1.frequency(freq1); + waveform2.frequency(freq2); + } + + void processGraphAsBlock(TeensyBuffer& blockBuffer) override { + + waveform1.update(nullptr, nullptr, &wf1Block); + waveform2.update(nullptr, nullptr, &wf2Block); + combine1.update(&wf1Block, &wf2Block, &combineBlock); + + blockBuffer.pushBuffer(combineBlock.data, AUDIO_BLOCK_SAMPLES); + } + + AudioStream& getStream() override { + return combine1; + } + unsigned char getPort() override { + return 0; + } + +private: + audio_block_t wf1Block, wf2Block, combineBlock; + + AudioSynthWaveformModulated waveform1; + AudioSynthWaveformModulated waveform2; + AudioEffectDigitalCombine combine1; +}; + +REGISTER_PLUGIN(BitShift); diff --git a/src/noise-plethora/plugins/P_BowedMetal.hpp b/src/noise-plethora/plugins/P_BowedMetal.hpp new file mode 100644 index 0000000..545dfee --- /dev/null +++ b/src/noise-plethora/plugins/P_BowedMetal.hpp @@ -0,0 +1,137 @@ +#pragma once + +#include "NoisePlethoraPlugin.hpp" +#include + +// BowedMetal: White noise excites 8 high-Q resonators at dense, inharmonic +// metallic ratios. More resonators + closer spacing than NoiseBells = denser, +// more reverberant metallic character. Like bowing a cymbal or singing bowl. + +class BowedMetal : public NoisePlethoraPlugin { + +public: + + BowedMetal() { } + + ~BowedMetal() override {} + + BowedMetal(const BowedMetal&) = delete; + BowedMetal& operator=(const BowedMetal&) = delete; + + void init() override { + noise1.amplitude(0.5f); + + for (int i = 0; i < NUM_RES; i++) { + y1[i] = 0.0f; + y2[i] = 0.0f; + } + + updateResonators(200.0f, 0.5f, 0.5f); + } + + void process(float k1, float k2) override { + float freq = 30.0f + pow(k1, 2) * 2000.0f; + + // k2 low = struck (short ring, louder noise burst) + // k2 high = bowed (long ring, quieter continuous noise) + float ringTime = 0.997f + k2 * 0.0025f; // r: 0.997 → 0.9995 + float noiseLevel = 0.6f - k2 * 0.45f; // 0.6 → 0.15 + noise1.amplitude(noiseLevel); + + updateResonators(freq, k2, ringTime); + } + + void processGraphAsBlock(TeensyBuffer& blockBuffer) override { + noise1.update(&noiseBlock); + + for (int i = 0; i < AUDIO_BLOCK_SAMPLES; i++) { + float input = noiseBlock.data[i] / 32767.0f; + + float mixed = 0.0f; + + for (int r = 0; r < NUM_RES; r++) { + float out = coeff_a[r] * y1[r] - coeff_b[r] * y2[r] + coeff_g[r] * input; + + y2[r] = y1[r]; + y1[r] = out; + + if (!std::isfinite(out)) { + y1[r] = 0.0f; + y2[r] = 0.0f; + out = 0.0f; + } + + mixed += out * gains[r]; + } + + mixed *= 0.1f; + + if (mixed > 1.0f) mixed = 1.0f; + if (mixed < -1.0f) mixed = -1.0f; + outputBlock.data[i] = (int16_t)(mixed * 32767.0f); + } + + blockBuffer.pushBuffer(outputBlock.data, AUDIO_BLOCK_SAMPLES); + } + + AudioStream& getStream() override { + return dc1; + } + unsigned char getPort() override { + return 0; + } + +private: + + static const int NUM_RES = 8; + + // Metal plate / cymbal mode ratios (based on circular plate vibration modes) + // These are denser and more irregular than bell ratios + static constexpr float modeRatios[NUM_RES] = { + 1.000f, 1.183f, 1.506f, 1.741f, + 2.098f, 2.534f, 2.917f, 3.483f + }; + + void updateResonators(float fundamental, float k2, float ringTime) { + for (int i = 0; i < NUM_RES; i++) { + float f = fundamental * modeRatios[i]; + if (f > 19000.0f) f = 19000.0f; + if (f < 20.0f) f = 20.0f; + + // higher modes decay faster + float r = ringTime - i * 0.0002f; + if (r < 0.99f) r = 0.99f; + + float w = 2.0f * M_PI * f / 44100.0f; + + coeff_a[i] = 2.0f * r * std::cos(w); + coeff_b[i] = r * r; + coeff_g[i] = 1.0f - r; + } + + // dense amplitude distribution (all modes audible, slight rolloff) + gains[0] = 1.0f; + gains[1] = 0.9f; + gains[2] = 0.85f; + gains[3] = 0.75f; + gains[4] = 0.65f; + gains[5] = 0.55f; + gains[6] = 0.45f; + gains[7] = 0.35f; + } + + AudioSynthNoiseWhite noise1; + AudioSynthWaveformDc dc1; + + audio_block_t noiseBlock, outputBlock; + + float y1[NUM_RES] = {}; + float y2[NUM_RES] = {}; + + float coeff_a[NUM_RES] = {}; + float coeff_b[NUM_RES] = {}; + float coeff_g[NUM_RES] = {}; + float gains[NUM_RES] = {}; +}; + +REGISTER_PLUGIN(BowedMetal); diff --git a/src/noise-plethora/plugins/P_CellularSynth.hpp b/src/noise-plethora/plugins/P_CellularSynth.hpp new file mode 100644 index 0000000..fcd54dd --- /dev/null +++ b/src/noise-plethora/plugins/P_CellularSynth.hpp @@ -0,0 +1,131 @@ +#pragma once + +#include "NoisePlethoraPlugin.hpp" + +class CellularSynth : public NoisePlethoraPlugin { + +public: + + CellularSynth() { } + + ~CellularSynth() override {} + + CellularSynth(const CellularSynth&) = delete; + CellularSynth& operator=(const CellularSynth&) = delete; + + void init() override { + // Initialize CA with single cell in center + for (int i = 0; i < 32; i++) { + cells[i] = false; + } + cells[16] = true; + + clockCounter = 0; + clockSamples = 128; + rule = 110; + + float fundamental = 55.0f; + float masterVolume = 0.2f; + + for (int i = 0; i < 8; i++) { + osc[i].begin(masterVolume, fundamental * (i + 1), WAVEFORM_SAWTOOTH); + osc[i].frequencyModulation(0.1f); + } + + // Mixer gains: each sub-mixer has 4 inputs + for (int ch = 0; ch < 4; ch++) { + mixerA.gain(ch, 0.5f); + mixerB.gain(ch, 0.5f); + } + // Master mixer combines two sub-mixers + masterMixer.gain(0, 0.7f); + masterMixer.gain(1, 0.7f); + masterMixer.gain(2, 0.0f); + masterMixer.gain(3, 0.0f); + + // Set initial amplitudes from CA state + updateOscAmplitudes(); + } + + void process(float k1, float k2) override { + rule = (int)(k1 * 255.0f); + clockSamples = (int)(128 + (1.0f - k2) * 128.0f * 50.0f); + + clockCounter += AUDIO_BLOCK_SAMPLES; + if (clockCounter >= clockSamples) { + evolveCA(); + updateOscAmplitudes(); + clockCounter = 0; + } + } + + void processGraphAsBlock(TeensyBuffer& blockBuffer) override { + + // Update all 8 oscillators (no modulation input) + for (int i = 0; i < 8; i++) { + osc[i].update(nullptr, nullptr, &oscBlock[i]); + } + + // Mix through hierarchy: 4 oscs per sub-mixer + mixerA.update(&oscBlock[0], &oscBlock[1], &oscBlock[2], &oscBlock[3], &mixerABlock); + mixerB.update(&oscBlock[4], &oscBlock[5], &oscBlock[6], &oscBlock[7], &mixerBBlock); + + // Master mix + masterMixer.update(&mixerABlock, &mixerBBlock, nullptr, nullptr, &masterBlock); + + blockBuffer.pushBuffer(masterBlock.data, AUDIO_BLOCK_SAMPLES); + } + + AudioStream& getStream() override { + return masterMixer; + } + unsigned char getPort() override { + return 0; + } + +private: + + void evolveCA() { + bool newCells[32]; + for (int i = 0; i < 32; i++) { + int left = (i - 1 + 32) % 32; + int right = (i + 1) % 32; + + int pattern = (cells[left] ? 4 : 0) + | (cells[i] ? 2 : 0) + | (cells[right] ? 1 : 0); + + newCells[i] = ((rule >> pattern) & 1) != 0; + } + for (int i = 0; i < 32; i++) { + cells[i] = newCells[i]; + } + } + + void updateOscAmplitudes() { + // 32 cells grouped into 8 groups of 4 + for (int g = 0; g < 8; g++) { + int count = 0; + for (int c = 0; c < 4; c++) { + if (cells[g * 4 + c]) count++; + } + float amp = count * 0.25f; // 0, 0.25, 0.5, 0.75, 1.0 + osc[g].amplitude(amp); + } + } + + bool cells[32] = {}; + int clockCounter = 0; + int clockSamples = 128; + int rule = 110; + + audio_block_t oscBlock[8] = {}; + audio_block_t mixerABlock, mixerBBlock, masterBlock; + + AudioSynthWaveformModulated osc[8]; + AudioMixer4 mixerA; + AudioMixer4 mixerB; + AudioMixer4 masterMixer; +}; + +REGISTER_PLUGIN(CellularSynth); diff --git a/src/noise-plethora/plugins/P_CombNoise.hpp b/src/noise-plethora/plugins/P_CombNoise.hpp new file mode 100644 index 0000000..abe8dec --- /dev/null +++ b/src/noise-plethora/plugins/P_CombNoise.hpp @@ -0,0 +1,100 @@ +#pragma once + +#include "NoisePlethoraPlugin.hpp" + +class CombNoise : public NoisePlethoraPlugin { + +public: + + CombNoise() { } + + ~CombNoise() override {} + + // delete copy constructors + CombNoise(const CombNoise&) = delete; + CombNoise& operator=(const CombNoise&) = delete; + + void init() override { + noise1.amplitude(1); + + for (int c = 0; c < 4; c++) { + writePos[c] = 0; + for (int i = 0; i < 2048; i++) { + delayBuffer[c][i] = 0.0f; + } + } + } + + void process(float k1, float k2) override { + float delayInSamples = 44100.0f / (40.0f + pow(k1, 2) * 4960.0f); + feedback = k2 * 0.95f; + + // 4 combs at delay ratios 1.0, 0.7, 0.5, 0.35 + delaySamples[0] = delayInSamples * 1.0f; + delaySamples[1] = delayInSamples * 0.7f; + delaySamples[2] = delayInSamples * 0.5f; + delaySamples[3] = delayInSamples * 0.35f; + + // clamp delay lengths to valid buffer range + for (int c = 0; c < 4; c++) { + if (delaySamples[c] < 1.0f) delaySamples[c] = 1.0f; + if (delaySamples[c] > 2047.0f) delaySamples[c] = 2047.0f; + } + } + + void processGraphAsBlock(TeensyBuffer& blockBuffer) override { + // generate noise block + noise1.update(&noiseBlock); + + for (int i = 0; i < AUDIO_BLOCK_SAMPLES; i++) { + float input = noiseBlock.data[i] / 32767.0f; + float mixed = 0.0f; + + for (int c = 0; c < 4; c++) { + int delay = (int)delaySamples[c]; + if (delay < 1) delay = 1; + if (delay > 2047) delay = 2047; + + int readPos = writePos[c] - delay; + if (readPos < 0) readPos += 2048; + + float out = input + feedback * delayBuffer[c][readPos]; + delayBuffer[c][writePos[c]] = out; + + writePos[c] = (writePos[c] + 1) & 2047; // mod 2048 + + mixed += out; + } + + // mix 4 combs equally (scale by 0.25) + mixed *= 0.25f; + + // clamp and convert to int16 + if (mixed > 1.0f) mixed = 1.0f; + if (mixed < -1.0f) mixed = -1.0f; + outputBlock.data[i] = (int16_t)(mixed * 32767.0f); + } + + blockBuffer.pushBuffer(outputBlock.data, AUDIO_BLOCK_SAMPLES); + } + + AudioStream& getStream() override { + return dc1; + } + unsigned char getPort() override { + return 0; + } + +private: + AudioSynthNoiseWhite noise1; + AudioSynthWaveformDc dc1; // dummy for getStream() + + audio_block_t noiseBlock, outputBlock; + + float delayBuffer[4][2048] = {}; + int writePos[4] = {}; + float delaySamples[4] = {100.0f, 70.0f, 50.0f, 35.0f}; + float feedback = 0.0f; +}; + +REGISTER_PLUGIN(CombNoise); // this is important, so that we can include the plugin in a bank diff --git a/src/noise-plethora/plugins/P_DroneBody.hpp b/src/noise-plethora/plugins/P_DroneBody.hpp new file mode 100644 index 0000000..07ed040 --- /dev/null +++ b/src/noise-plethora/plugins/P_DroneBody.hpp @@ -0,0 +1,86 @@ +#pragma once + +#include "NoisePlethoraPlugin.hpp" + +class DroneBody : public NoisePlethoraPlugin { + +public: + + DroneBody() + // : patchCord1(sine_fm1, 0, mixer1, 0) + // , patchCord2(sine_fm2, 0, mixer1, 1) + // , patchCord3(mixer1, 0, wavefolder1, 0) + // , patchCord4(dc1, 0, wavefolder1, 1) + { } + + ~DroneBody() override {} + + // delete copy constructors + DroneBody(const DroneBody&) = delete; + DroneBody& operator=(const DroneBody&) = delete; + + void init() override { + sine_fm1.frequency(100); + sine_fm1.amplitude(1.0); + + sine_fm2.frequency(101); + sine_fm2.amplitude(1.0); + + dc1.amplitude(0.3); + + mixer1.gain(0, 0.5); + mixer1.gain(1, 0.5); + + // Zero out the feedback blocks + prevSine1Block.zeroAudioBlock(); + prevSine2Block.zeroAudioBlock(); + } + + void process(float k1, float k2) override { + float freq = 20.0f + pow(k1, 2) * 500.0f; + float detune_ratio = 1.0f + k2 * 0.05f; + float dc_fold = 0.1f + k2 * 0.5f; + + sine_fm1.frequency(freq); + sine_fm2.frequency(freq * detune_ratio); + dc1.amplitude(dc_fold); + } + + void processGraphAsBlock(TeensyBuffer& blockBuffer) override { + // Cross-modulation: each sine is modulated by the previous block's output of the other + sine_fm1.update(&prevSine2Block, &sine1Block); + sine_fm2.update(&prevSine1Block, &sine2Block); + + // Save copies for next block's cross-feedback + memcpy(prevSine1Block.data, sine1Block.data, sizeof(int16_t) * AUDIO_BLOCK_SAMPLES); + memcpy(prevSine2Block.data, sine2Block.data, sizeof(int16_t) * AUDIO_BLOCK_SAMPLES); + + // Mix both sines + mixer1.update(&sine1Block, &sine2Block, nullptr, nullptr, &mixBlock); + + // Wavefold with DC bias + dc1.update(&dcBlock); + wavefolder1.update(&mixBlock, &dcBlock, &wfBlock); + + blockBuffer.pushBuffer(wfBlock.data, AUDIO_BLOCK_SAMPLES); + } + + AudioStream& getStream() override { + return dc1; + } + unsigned char getPort() override { + return 0; + } + +private: + audio_block_t sine1Block, sine2Block, mixBlock, dcBlock, wfBlock; + audio_block_t prevSine1Block, prevSine2Block; + + AudioSynthWaveformSineModulated sine_fm1; + AudioSynthWaveformSineModulated sine_fm2; + AudioSynthWaveformDc dc1; + AudioEffectWaveFolder wavefolder1; + AudioMixer4 mixer1; +}; + +REGISTER_PLUGIN(DroneBody); diff --git a/src/noise-plethora/plugins/P_DualAttractor.hpp b/src/noise-plethora/plugins/P_DualAttractor.hpp new file mode 100644 index 0000000..da710d0 --- /dev/null +++ b/src/noise-plethora/plugins/P_DualAttractor.hpp @@ -0,0 +1,133 @@ +#pragma once + +#include "NoisePlethoraPlugin.hpp" +#include + +class DualAttractor : public NoisePlethoraPlugin { + +public: + + DualAttractor() { } + + ~DualAttractor() override {} + + DualAttractor(const DualAttractor&) = delete; + DualAttractor& operator=(const DualAttractor&) = delete; + + void init() override { + // Lorenz system 1 + x1 = 1.0f; + y1 = 1.0f; + z1 = 1.0f; + + // Lorenz system 2 + x2 = -1.0f; + y2 = 0.0f; + z2 = 2.0f; + + coupling = 0.0f; + baseFreq = 100.0f; + + sine1.amplitude(0.7f); + sine1.frequency(100.0f); + sine2.amplitude(0.7f); + sine2.frequency(150.0f); + + mixer.gain(0, 1.0f); + mixer.gain(1, 1.0f); + mixer.gain(2, 0.0f); + mixer.gain(3, 0.0f); + } + + void process(float k1, float k2) override { + coupling = k1 * 5.0f; + baseFreq = 30.0f + std::pow(k2, 2.0f) * 2000.0f; + + // Lorenz parameters + const float sigma = 10.0f; + const float rho = 28.0f; + const float beta = 8.0f / 3.0f; + const float dt = 0.001f; + + // Run 10 integration steps for stability + for (int step = 0; step < 10; step++) { + float dx1 = sigma * (y1 - x1) + coupling * (x2 - x1); + float dy1 = x1 * (rho - z1) - y1; + float dz1 = x1 * y1 - beta * z1; + + float dx2 = sigma * (y2 - x2) + coupling * (x1 - x2); + float dy2 = x2 * (rho - z2) - y2; + float dz2 = x2 * y2 - beta * z2; + + x1 += dx1 * dt; + y1 += dy1 * dt; + z1 += dz1 * dt; + + x2 += dx2 * dt; + y2 += dy2 * dt; + z2 += dz2 * dt; + } + + // Check for NaN/infinity and reset if needed + if (!std::isfinite(x1) || !std::isfinite(y1) || !std::isfinite(z1)) { + x1 = 1.0f; + y1 = 1.0f; + z1 = 1.0f; + } + if (!std::isfinite(x2) || !std::isfinite(y2) || !std::isfinite(z2)) { + x2 = -1.0f; + y2 = 0.0f; + z2 = 2.0f; + } + + // Map Lorenz x outputs to frequency offsets + float freq1 = baseFreq + x1 * baseFreq * 0.1f; + float freq2 = baseFreq * 1.5f + x2 * baseFreq * 0.1f; + + // Clamp frequencies to reasonable range + if (freq1 < 20.0f) freq1 = 20.0f; + if (freq1 > 20000.0f) freq1 = 20000.0f; + if (freq2 < 20.0f) freq2 = 20.0f; + if (freq2 > 20000.0f) freq2 = 20000.0f; + + sine1.frequency(freq1); + sine2.frequency(freq2); + } + + void processGraphAsBlock(TeensyBuffer& blockBuffer) override { + sine1.update(&s1Block); + sine2.update(&s2Block); + mixer.update(&s1Block, &s2Block, nullptr, nullptr, &mixBlock); + + blockBuffer.pushBuffer(mixBlock.data, AUDIO_BLOCK_SAMPLES); + } + + AudioStream& getStream() override { + return mixer; + } + unsigned char getPort() override { + return 0; + } + +private: + AudioSynthWaveformSine sine1; + AudioSynthWaveformSine sine2; + AudioMixer4 mixer; + + audio_block_t s1Block, s2Block, mixBlock; + + // Lorenz system 1 + float x1 = 1.0f; + float y1 = 1.0f; + float z1 = 1.0f; + + // Lorenz system 2 + float x2 = -1.0f; + float y2 = 0.0f; + float z2 = 2.0f; + + float coupling = 0.0f; + float baseFreq = 100.0f; +}; + +REGISTER_PLUGIN(DualAttractor); diff --git a/src/noise-plethora/plugins/P_FeedbackFM.hpp b/src/noise-plethora/plugins/P_FeedbackFM.hpp new file mode 100644 index 0000000..620f351 --- /dev/null +++ b/src/noise-plethora/plugins/P_FeedbackFM.hpp @@ -0,0 +1,67 @@ +#pragma once + +#include "NoisePlethoraPlugin.hpp" +#include + +class FeedbackFM : public NoisePlethoraPlugin { + +public: + + FeedbackFM() { } + + ~FeedbackFM() override {} + + FeedbackFM(const FeedbackFM&) = delete; + FeedbackFM& operator=(const FeedbackFM&) = delete; + + void init() override { + phase = 0.0f; + prevOut = 0.0f; + currentFreq = 440.0f; + currentFeedback = 0.0f; + } + + void process(float k1, float k2) override { + currentFreq = 20.0f + std::pow(k1, 2.0f) * 5000.0f; + currentFeedback = k2 * 2.5f; + } + + void processGraphAsBlock(TeensyBuffer& blockBuffer) override { + const float twoPi = 2.0f * 3.14159265358979323846f; + const float phaseInc = twoPi * currentFreq / 44100.0f; + + for (int i = 0; i < AUDIO_BLOCK_SAMPLES; i++) { + phase += phaseInc; + phase = std::fmod(phase, twoPi); + + float out = std::sin(phase + currentFeedback * prevOut); + prevOut = out; + + int32_t sample = (int32_t)(out * 32767.0f); + if (sample > 32767) sample = 32767; + if (sample < -32767) sample = -32767; + outputBlock.data[i] = (int16_t)sample; + } + + blockBuffer.pushBuffer(outputBlock.data, AUDIO_BLOCK_SAMPLES); + } + + AudioStream& getStream() override { + return dc1; + } + unsigned char getPort() override { + return 0; + } + +private: + AudioSynthWaveformDc dc1; // dummy for getStream() + + audio_block_t outputBlock; + + float phase = 0.0f; + float prevOut = 0.0f; + float currentFreq = 440.0f; + float currentFeedback = 0.0f; +}; + +REGISTER_PLUGIN(FeedbackFM); diff --git a/src/noise-plethora/plugins/P_FlangeNoise.hpp b/src/noise-plethora/plugins/P_FlangeNoise.hpp new file mode 100644 index 0000000..7587af5 --- /dev/null +++ b/src/noise-plethora/plugins/P_FlangeNoise.hpp @@ -0,0 +1,60 @@ +#pragma once + +#include "NoisePlethoraPlugin.hpp" + +#define FLANGE_NOISE_DELAY_LENGTH (8 * AUDIO_BLOCK_SAMPLES) + +class FlangeNoise : public NoisePlethoraPlugin { + +public: + + FlangeNoise() + // : patchCord1(pink1, flange1) + { } + + ~FlangeNoise() override {} + + // delete copy constructors + FlangeNoise(const FlangeNoise&) = delete; + FlangeNoise& operator=(const FlangeNoise&) = delete; + + void init() override { + pink1.amplitude(1.0); + flange1.begin(flangeDelayLine, FLANGE_NOISE_DELAY_LENGTH, s_offset, s_depth, s_rate); + } + + void process(float k1, float k2) override { + float rate = 0.05f + pow(k1, 2) * 5.0f; + int depth = (int)(2 + k2 * 120); // wider sweep range for audible flanging + int offset = (int)(2 + k2 * 80); + + flange1.voices(offset, depth, rate); + } + + void processGraphAsBlock(TeensyBuffer& blockBuffer) override { + pink1.update(&pinkBlock); + flange1.update(&pinkBlock, &flangeBlock); + + blockBuffer.pushBuffer(flangeBlock.data, AUDIO_BLOCK_SAMPLES); + } + + AudioStream& getStream() override { + return pink1; + } + unsigned char getPort() override { + return 0; + } + +private: + audio_block_t pinkBlock, flangeBlock; + + AudioSynthNoisePink pink1; + AudioEffectFlange flange1; + + short flangeDelayLine[FLANGE_NOISE_DELAY_LENGTH]; + int s_offset = 2 * FLANGE_NOISE_DELAY_LENGTH / 4; + int s_depth = FLANGE_NOISE_DELAY_LENGTH / 4; + float s_rate = 0.5; +}; + +REGISTER_PLUGIN(FlangeNoise); diff --git a/src/noise-plethora/plugins/P_FormantNoise.hpp b/src/noise-plethora/plugins/P_FormantNoise.hpp new file mode 100644 index 0000000..51967e3 --- /dev/null +++ b/src/noise-plethora/plugins/P_FormantNoise.hpp @@ -0,0 +1,106 @@ +#pragma once + +#include "NoisePlethoraPlugin.hpp" + +class FormantNoise : public NoisePlethoraPlugin { + +public: + + FormantNoise() { } + + ~FormantNoise() override {} + + // delete copy constructors + FormantNoise(const FormantNoise&) = delete; + FormantNoise& operator=(const FormantNoise&) = delete; + + void init() override { + noise1.amplitude(1); + + filter1.resonance(2.0f); + filter1.octaveControl(0); + filter2.resonance(2.0f); + filter2.octaveControl(0); + filter3.resonance(2.0f); + filter3.octaveControl(0); + + mixer1.gain(0, 0.5f); + mixer1.gain(1, 0.5f); + mixer1.gain(2, 0.5f); + mixer1.gain(3, 0); + } + + void process(float k1, float k2) override { + // Vowel formant table (Hz): + // A=[730,1090,2440], E=[660,1720,2410], I=[270,2290,3010], + // O=[570,840,2410], U=[300,870,2240] + static const float formants[5][3] = { + {730.0f, 1090.0f, 2440.0f}, // A + {660.0f, 1720.0f, 2410.0f}, // E + {270.0f, 2290.0f, 3010.0f}, // I + {570.0f, 840.0f, 2410.0f}, // O + {300.0f, 870.0f, 2240.0f} // U + }; + + // continuous vowel morph: 0=A, 0.25=E, 0.5=I, 0.75=O, 1.0=U + float pos = k1 * 4.0f; // 0..4 + int idx = (int)pos; + if (idx < 0) idx = 0; + if (idx > 3) idx = 3; + float frac = pos - (float)idx; + if (frac < 0.0f) frac = 0.0f; + if (frac > 1.0f) frac = 1.0f; + + // interpolate F1, F2, F3 between adjacent vowels + float f1 = formants[idx][0] + frac * (formants[idx + 1][0] - formants[idx][0]); + float f2 = formants[idx][1] + frac * (formants[idx + 1][1] - formants[idx][1]); + float f3 = formants[idx][2] + frac * (formants[idx + 1][2] - formants[idx][2]); + + filter1.frequency(f1); + filter2.frequency(f2); + filter3.frequency(f3); + + // resonance: q = 1.0 + k2 * 4.0 (range 1-5) + float q = 1.0f + k2 * 4.0f; + filter1.resonance(q); + filter2.resonance(q); + filter3.resonance(q); + } + + void processGraphAsBlock(TeensyBuffer& blockBuffer) override { + // generate noise + noise1.update(&noiseBlock); + + // process through 3 bandpass filters (use bandpass output) + filter1.update(&noiseBlock, nullptr, &filterLP1, &filterBP1, &filterHP1); + filter2.update(&noiseBlock, nullptr, &filterLP2, &filterBP2, &filterHP2); + filter3.update(&noiseBlock, nullptr, &filterLP3, &filterBP3, &filterHP3); + + // mix the 3 bandpass outputs + mixer1.update(&filterBP1, &filterBP2, &filterBP3, nullptr, &mixerOut); + + blockBuffer.pushBuffer(mixerOut.data, AUDIO_BLOCK_SAMPLES); + } + + AudioStream& getStream() override { + return mixer1; + } + unsigned char getPort() override { + return 0; + } + +private: + AudioSynthNoiseWhite noise1; + AudioFilterStateVariable filter1; + AudioFilterStateVariable filter2; + AudioFilterStateVariable filter3; + AudioMixer4 mixer1; + + audio_block_t noiseBlock; + audio_block_t filterLP1, filterBP1, filterHP1; + audio_block_t filterLP2, filterBP2, filterHP2; + audio_block_t filterLP3, filterBP3, filterHP3; + audio_block_t mixerOut; +}; + +REGISTER_PLUGIN(FormantNoise); // this is important, so that we can include the plugin in a bank diff --git a/src/noise-plethora/plugins/P_GlitchLoop.hpp b/src/noise-plethora/plugins/P_GlitchLoop.hpp new file mode 100644 index 0000000..68a64f0 --- /dev/null +++ b/src/noise-plethora/plugins/P_GlitchLoop.hpp @@ -0,0 +1,106 @@ +#pragma once + +#include "NoisePlethoraPlugin.hpp" + +#define GLITCHLOOP_MAX_SAMPLES 8820 + +class GlitchLoop : public NoisePlethoraPlugin { + +public: + + GlitchLoop() { } + + ~GlitchLoop() override {} + + GlitchLoop(const GlitchLoop&) = delete; + GlitchLoop& operator=(const GlitchLoop&) = delete; + + void init() override { + currentLoopLen = GLITCHLOOP_MAX_SAMPLES; + loopPos = 0; + bitDepthAccum = 16.0f; + bitsToLose = 0.0f; + + // Fill buffer with white noise + for (int i = 0; i < GLITCHLOOP_MAX_SAMPLES; i++) { + loopBuffer[i] = random::uniform() * 2.0f - 1.0f; + } + } + + void process(float k1, float k2) override { + currentLoopLen = (int)(441.0f + std::pow(k1, 2.0f) * 8379.0f); + if (currentLoopLen > GLITCHLOOP_MAX_SAMPLES) { + currentLoopLen = GLITCHLOOP_MAX_SAMPLES; + } + if (currentLoopLen < 1) { + currentLoopLen = 1; + } + + bitsToLose = k2 * 0.05f; + } + + void processGraphAsBlock(TeensyBuffer& blockBuffer) override { + + for (int i = 0; i < AUDIO_BLOCK_SAMPLES; i++) { + float sample = loopBuffer[loopPos]; + + // Apply bit depth reduction + int effectiveBits = (int)bitDepthAccum; + if (effectiveBits < 1) effectiveBits = 1; + if (effectiveBits > 16) effectiveBits = 16; + + // Bit crush: quantize to fewer bits + int shift = 16 - effectiveBits; + if (shift > 0) { + // Convert to int16 range, shift right then left to lose bits + int32_t intSample = (int32_t)(sample * 32767.0f); + intSample = (intSample >> shift) << shift; + sample = (float)intSample / 32767.0f; + } + + // Write crushed sample back into buffer for progressive degradation + loopBuffer[loopPos] = sample; + + int32_t out = (int32_t)(sample * 32767.0f); + if (out > 32767) out = 32767; + if (out < -32767) out = -32767; + outputBlock.data[i] = (int16_t)out; + + loopPos++; + if (loopPos >= currentLoopLen) { + loopPos = 0; + bitDepthAccum -= bitsToLose; + + // When bit depth is exhausted, refill with fresh noise + if (bitDepthAccum < 1.0f) { + bitDepthAccum = 16.0f; + for (int j = 0; j < GLITCHLOOP_MAX_SAMPLES; j++) { + loopBuffer[j] = random::uniform() * 2.0f - 1.0f; + } + } + } + } + + blockBuffer.pushBuffer(outputBlock.data, AUDIO_BLOCK_SAMPLES); + } + + AudioStream& getStream() override { + return dc1; + } + unsigned char getPort() override { + return 0; + } + +private: + AudioSynthWaveformDc dc1; // dummy for getStream() + + audio_block_t outputBlock; + + float loopBuffer[GLITCHLOOP_MAX_SAMPLES]; + int loopPos = 0; + int currentLoopLen = GLITCHLOOP_MAX_SAMPLES; + float bitDepthAccum = 16.0f; + float bitsToLose = 0.0f; +}; + +REGISTER_PLUGIN(GlitchLoop); diff --git a/src/noise-plethora/plugins/P_HenonDust.hpp b/src/noise-plethora/plugins/P_HenonDust.hpp new file mode 100644 index 0000000..a1cc1f5 --- /dev/null +++ b/src/noise-plethora/plugins/P_HenonDust.hpp @@ -0,0 +1,76 @@ +#pragma once + +#include "NoisePlethoraPlugin.hpp" + +class HenonDust : public NoisePlethoraPlugin { + +public: + + HenonDust() { } + + ~HenonDust() override {} + + HenonDust(const HenonDust&) = delete; + HenonDust& operator=(const HenonDust&) = delete; + + void init() override { + hx = 0.1f; + hy = 0.1f; + a = 1.4f; + b = 0.3f; + } + + void process(float k1, float k2) override { + // focus k1 on the interesting chaos transition zone (1.15-1.4) + a = 1.15f + k1 * 0.25f; + b = 0.15f + k2 * 0.2f; + } + + void processGraphAsBlock(TeensyBuffer& blockBuffer) override { + + for (int i = 0; i < AUDIO_BLOCK_SAMPLES; i++) { + float new_x = 1.0f - a * hx * hx + hy; + float new_y = b * hx; + hx = new_x; + hy = new_y; + + // Reset on divergence or NaN + if (std::isnan(hx) || std::isinf(hx) || std::isnan(hy) || std::isinf(hy)) { + hx = random::uniform() - 0.5f; + hy = random::uniform() - 0.5f; + } + + // Normalize hx from [-1.5, 1.5] to [-1, 1] + float out = hx; + if (out > 1.5f) out = 1.5f; + if (out < -1.5f) out = -1.5f; + out /= 1.5f; + + int32_t sample = (int32_t)(out * 32767.0f); + if (sample > 32767) sample = 32767; + if (sample < -32767) sample = -32767; + outputBlock.data[i] = (int16_t)sample; + } + + blockBuffer.pushBuffer(outputBlock.data, AUDIO_BLOCK_SAMPLES); + } + + AudioStream& getStream() override { + return dc1; + } + unsigned char getPort() override { + return 0; + } + +private: + AudioSynthWaveformDc dc1; // dummy for getStream() + + audio_block_t outputBlock; + + float hx = 0.1f; + float hy = 0.1f; + float a = 1.4f; + float b = 0.3f; +}; + +REGISTER_PLUGIN(HenonDust); diff --git a/src/noise-plethora/plugins/P_IceRain.hpp b/src/noise-plethora/plugins/P_IceRain.hpp new file mode 100644 index 0000000..460e378 --- /dev/null +++ b/src/noise-plethora/plugins/P_IceRain.hpp @@ -0,0 +1,66 @@ +#pragma once + +#include "NoisePlethoraPlugin.hpp" + +class IceRain : public NoisePlethoraPlugin { + +public: + + IceRain() + // : patchCord1(waveformMod1, freeverb1) + // , patchCord2(waveformMod1, 0, mixer1, 0) + // , patchCord3(freeverb1, 0, mixer1, 1) + { } + + ~IceRain() override {} + + // delete copy constructors + IceRain(const IceRain&) = delete; + IceRain& operator=(const IceRain&) = delete; + + void init() override { + waveformMod1.begin(1.0, 5, WAVEFORM_SAMPLE_HOLD); + waveformMod1.frequencyModulation(10); + + freeverb1.roomsize(0.8); + freeverb1.damping(0.8); + + mixer1.gain(0, 0.3); + mixer1.gain(1, 1.0); + } + + void process(float k1, float k2) override { + float freq = 0.5f + pow(k1, 2) * 200.0f; + float roomsize = 0.3f + k2 * 0.7f; + + waveformMod1.frequency(freq); + freeverb1.roomsize(roomsize); + + mixer1.gain(0, 0.3f * (1.0f - k2)); + mixer1.gain(1, k2 * 2.0f); + } + + void processGraphAsBlock(TeensyBuffer& blockBuffer) override { + waveformMod1.update(nullptr, nullptr, &shBlock); + freeverb1.update(&shBlock, &reverbBlock); + mixer1.update(&shBlock, &reverbBlock, nullptr, nullptr, &mixBlock); + + blockBuffer.pushBuffer(mixBlock.data, AUDIO_BLOCK_SAMPLES); + } + + AudioStream& getStream() override { + return mixer1; + } + unsigned char getPort() override { + return 0; + } + +private: + audio_block_t shBlock, reverbBlock, mixBlock; + + AudioSynthWaveformModulated waveformMod1; + AudioEffectFreeverb freeverb1; + AudioMixer4 mixer1; +}; + +REGISTER_PLUGIN(IceRain); diff --git a/src/noise-plethora/plugins/P_LogisticNoise.hpp b/src/noise-plethora/plugins/P_LogisticNoise.hpp new file mode 100644 index 0000000..e237a0e --- /dev/null +++ b/src/noise-plethora/plugins/P_LogisticNoise.hpp @@ -0,0 +1,70 @@ +#pragma once + +#include "NoisePlethoraPlugin.hpp" + +class LogisticNoise : public NoisePlethoraPlugin { + +public: + + LogisticNoise() { } + + ~LogisticNoise() override {} + + LogisticNoise(const LogisticNoise&) = delete; + LogisticNoise& operator=(const LogisticNoise&) = delete; + + void init() override { + x = 0.5f; + holdCounter = 0; + samplesPerIteration = 1; + r = 3.8f; + } + + void process(float k1, float k2) override { + r = 3.5f + k1 * 0.5f; + samplesPerIteration = std::max(1, (int)(1 + (1.0f - k2) * 30)); + } + + void processGraphAsBlock(TeensyBuffer& blockBuffer) override { + + for (int i = 0; i < AUDIO_BLOCK_SAMPLES; i++) { + holdCounter++; + if (holdCounter >= samplesPerIteration) { + x = r * x * (1.0f - x); + holdCounter = 0; + + // Reset on numerical instability + if (x < 0.0f || x > 1.0f || std::isnan(x) || std::isinf(x)) { + x = 0.5f + (random::uniform() - 0.5f) * 0.1f; + } + } + + float out = x * 2.0f - 1.0f; + int32_t sample = (int32_t)(out * 32767.0f); + if (sample > 32767) sample = 32767; + if (sample < -32767) sample = -32767; + outputBlock.data[i] = (int16_t)sample; + } + + blockBuffer.pushBuffer(outputBlock.data, AUDIO_BLOCK_SAMPLES); + } + + AudioStream& getStream() override { + return dc1; + } + unsigned char getPort() override { + return 0; + } + +private: + AudioSynthWaveformDc dc1; // dummy for getStream() + + audio_block_t outputBlock; + + float x = 0.5f; + float r = 3.8f; + int holdCounter = 0; + int samplesPerIteration = 1; +}; + +REGISTER_PLUGIN(LogisticNoise); diff --git a/src/noise-plethora/plugins/P_NoiseBells.hpp b/src/noise-plethora/plugins/P_NoiseBells.hpp new file mode 100644 index 0000000..e409545 --- /dev/null +++ b/src/noise-plethora/plugins/P_NoiseBells.hpp @@ -0,0 +1,141 @@ +#pragma once + +#include "NoisePlethoraPlugin.hpp" +#include + +// NoiseBells: White noise excites 4 sharp 2-pole resonators at bell-like +// inharmonic ratios. The resonators have very high Q (~500+), creating +// clear ringing tones from noise. Like striking a metal bar or bell. +// +// 2-pole resonator: y[n] = 2*r*cos(w)*y[n-1] - r^2*y[n-2] + (1-r)*x[n] +// r close to 1 = long ring, sharp peak. w = 2*pi*freq/samplerate. + +class NoiseBells : public NoisePlethoraPlugin { + +public: + + NoiseBells() { } + + ~NoiseBells() override {} + + NoiseBells(const NoiseBells&) = delete; + NoiseBells& operator=(const NoiseBells&) = delete; + + void init() override { + noise1.amplitude(1.0); + + for (int i = 0; i < NUM_RESONATORS; i++) { + y1[i] = 0.0f; + y2[i] = 0.0f; + coeff_a[i] = 0.0f; + coeff_b[i] = 0.0f; + coeff_g[i] = 0.0f; + } + + // initial resonator setup + updateResonators(500.0f, 0.5f); + } + + void process(float k1, float k2) override { + float freq = 80.0f + pow(k1, 2) * 4000.0f; + updateResonators(freq, k2); + } + + void processGraphAsBlock(TeensyBuffer& blockBuffer) override { + noise1.update(&noiseBlock); + + for (int i = 0; i < AUDIO_BLOCK_SAMPLES; i++) { + float input = noiseBlock.data[i] / 32767.0f; + + float mixed = 0.0f; + + for (int r = 0; r < NUM_RESONATORS; r++) { + // 2-pole resonator + float out = coeff_a[r] * y1[r] - coeff_b[r] * y2[r] + coeff_g[r] * input; + + y2[r] = y1[r]; + y1[r] = out; + + // safety: reset on NaN/inf + if (!std::isfinite(out)) { + y1[r] = 0.0f; + y2[r] = 0.0f; + out = 0.0f; + } + + mixed += out * gains[r]; + } + + // scale down (resonators can be loud) + mixed *= 0.15f; + + if (mixed > 1.0f) mixed = 1.0f; + if (mixed < -1.0f) mixed = -1.0f; + outputBlock.data[i] = (int16_t)(mixed * 32767.0f); + } + + blockBuffer.pushBuffer(outputBlock.data, AUDIO_BLOCK_SAMPLES); + } + + AudioStream& getStream() override { + return dc1; + } + unsigned char getPort() override { + return 0; + } + +private: + + static const int NUM_RESONATORS = 4; + + void updateResonators(float fundamental, float inharmonicity) { + // bell-like inharmonic ratios (circular membrane / bar modes) + // at inharmonicity=0: nearly harmonic. at 1: very stretched. + float stretch = 1.0f + inharmonicity * 2.0f; + float freqs[NUM_RESONATORS]; + freqs[0] = fundamental; + freqs[1] = fundamental * (1.0f + 0.59f * stretch); // ~1.59 - 2.77 + freqs[2] = fundamental * (1.0f + 1.33f * stretch); // ~2.33 - 4.99 + freqs[3] = fundamental * (1.0f + 2.14f * stretch); // ~3.14 - 7.42 + + // r controls ring time. closer to 1 = longer ring = sharper peak + // higher partials decay faster (lower r) + float baseR = 0.9992f; + + for (int i = 0; i < NUM_RESONATORS; i++) { + float f = freqs[i]; + if (f > 20000.0f) f = 20000.0f; + if (f < 20.0f) f = 20.0f; + + float r = baseR - i * 0.0003f; // higher partials decay slightly faster + float w = 2.0f * M_PI * f / 44100.0f; + + coeff_a[i] = 2.0f * r * std::cos(w); + coeff_b[i] = r * r; + coeff_g[i] = 1.0f - r; // input gain scales with (1-r) for normalization + } + + // amplitude rolloff for higher partials + gains[0] = 1.0f; + gains[1] = 0.7f; + gains[2] = 0.4f; + gains[3] = 0.25f; + } + + AudioSynthNoiseWhite noise1; + AudioSynthWaveformDc dc1; // dummy for getStream + + audio_block_t noiseBlock, outputBlock; + + // resonator state + float y1[NUM_RESONATORS] = {}; + float y2[NUM_RESONATORS] = {}; + + // resonator coefficients + float coeff_a[NUM_RESONATORS] = {}; + float coeff_b[NUM_RESONATORS] = {}; + float coeff_g[NUM_RESONATORS] = {}; + float gains[NUM_RESONATORS] = {}; +}; + +REGISTER_PLUGIN(NoiseBells); diff --git a/src/noise-plethora/plugins/P_NoiseHarmonics.hpp b/src/noise-plethora/plugins/P_NoiseHarmonics.hpp new file mode 100644 index 0000000..26eea82 --- /dev/null +++ b/src/noise-plethora/plugins/P_NoiseHarmonics.hpp @@ -0,0 +1,64 @@ +#pragma once + +#include "NoisePlethoraPlugin.hpp" + +class NoiseHarmonics : public NoisePlethoraPlugin { + +public: + + NoiseHarmonics() + // : patchCord1(noise1, 0, wavefolder1, 0) + // , patchCord2(dc1, 0, wavefolder1, 1) + // , patchCord3(wavefolder1, 0, filter1, 0) + { } + + ~NoiseHarmonics() override {} + + // delete copy constructors + NoiseHarmonics(const NoiseHarmonics&) = delete; + NoiseHarmonics& operator=(const NoiseHarmonics&) = delete; + + void init() override { + noise1.amplitude(1.0); + dc1.amplitude(0.5); + + filter1.frequency(1000); + filter1.resonance(3.0); + filter1.octaveControl(2.0); + } + + void process(float k1, float k2) override { + float dcAmp = 0.05f + pow(k1, 2) * 0.95f; + float filterFreq = 100.0f + pow(k2, 2) * 8000.0f; + + dc1.amplitude(dcAmp); + filter1.frequency(filterFreq); + } + + void processGraphAsBlock(TeensyBuffer& blockBuffer) override { + noise1.update(&noiseBlock); + dc1.update(&dcBlock); + wavefolder1.update(&noiseBlock, &dcBlock, &wfBlock); + filter1.update(&wfBlock, nullptr, &lpBlock, &bpBlock, &hpBlock); + + blockBuffer.pushBuffer(bpBlock.data, AUDIO_BLOCK_SAMPLES); + } + + AudioStream& getStream() override { + return filter1; + } + unsigned char getPort() override { + return 0; + } + +private: + audio_block_t noiseBlock, dcBlock, wfBlock; + audio_block_t lpBlock, bpBlock, hpBlock; + + AudioSynthNoiseWhite noise1; + AudioSynthWaveformDc dc1; + AudioEffectWaveFolder wavefolder1; + AudioFilterStateVariable filter1; +}; + +REGISTER_PLUGIN(NoiseHarmonics); diff --git a/src/noise-plethora/plugins/P_PluckCloud.hpp b/src/noise-plethora/plugins/P_PluckCloud.hpp new file mode 100644 index 0000000..eb0b433 --- /dev/null +++ b/src/noise-plethora/plugins/P_PluckCloud.hpp @@ -0,0 +1,119 @@ +#pragma once + +#include "NoisePlethoraPlugin.hpp" + +class PluckCloud : public NoisePlethoraPlugin { + +public: + + PluckCloud() { } + + ~PluckCloud() override {} + + // delete copy constructors + PluckCloud(const PluckCloud&) = delete; + PluckCloud& operator=(const PluckCloud&) = delete; + + void init() override { + for (int v = 0; v < 6; v++) { + writePos[v] = 0; + filterState[v] = 0.0f; + triggered[v] = false; + for (int i = 0; i < 1024; i++) { + buf[v][i] = 0.0f; + } + } + damping = 0.5f; + baseDelay = 100.0f; + } + + void process(float k1, float k2) override { + float freq = 60.0f + pow(k1, 2) * 2940.0f; + baseDelay = 44100.0f / freq; + damping = 0.98f - k2 * 0.58f; // k2=0: heavy LP (dull thud), k2=1: light LP (bright ring) + + // random retrigger: each voice has ~2% chance per process() call + for (int v = 0; v < 6; v++) { + if (random::uniform() < 0.02f) { + triggerVoice(v); + } + } + } + + void processGraphAsBlock(TeensyBuffer& blockBuffer) override { + // voice detune ratios + static const float detuneRatio[6] = {1.0f, 1.005f, 0.995f, 1.01f, 0.99f, 1.015f}; + + for (int i = 0; i < AUDIO_BLOCK_SAMPLES; i++) { + float mixed = 0.0f; + + for (int v = 0; v < 6; v++) { + float voiceDelay = baseDelay * detuneRatio[v]; + int delay = (int)voiceDelay; + if (delay < 1) delay = 1; + if (delay > 1023) delay = 1023; + + int readPos = writePos[v] - delay; + if (readPos < 0) readPos += 1024; + + // read from delay and apply one-pole LP filter + float delayOut = buf[v][readPos]; + float filtered = damping * filterState[v] + (1.0f - damping) * delayOut; + filterState[v] = filtered; + + // write filtered output back into delay line + buf[v][writePos[v]] = filtered; + writePos[v] = (writePos[v] + 1) & 1023; // mod 1024 + + mixed += filtered; + } + + // scale by number of voices + mixed *= (1.0f / 6.0f); + + // clamp and convert to int16 + if (mixed > 1.0f) mixed = 1.0f; + if (mixed < -1.0f) mixed = -1.0f; + outputBlock.data[i] = (int16_t)(mixed * 32767.0f); + } + + blockBuffer.pushBuffer(outputBlock.data, AUDIO_BLOCK_SAMPLES); + } + + AudioStream& getStream() override { + return dc1; + } + unsigned char getPort() override { + return 0; + } + +private: + + void triggerVoice(int v) { + // fill delay buffer BEHIND writePos so it's immediately read + float voiceDelay = baseDelay; + int delay = (int)voiceDelay; + if (delay < 1) delay = 1; + if (delay > 1023) delay = 1023; + + for (int i = 0; i < delay; i++) { + int pos = (writePos[v] - delay + i + 1024) & 1023; + buf[v][pos] = random::uniform() * 2.0f - 1.0f; + } + filterState[v] = 0.0f; + triggered[v] = true; + } + + AudioSynthWaveformDc dc1; // dummy for getStream() + + audio_block_t outputBlock; + + float buf[6][1024] = {}; + int writePos[6] = {}; + float filterState[6] = {}; + bool triggered[6] = {}; + float damping = 0.5f; + float baseDelay = 100.0f; +}; + +REGISTER_PLUGIN(PluckCloud); // this is important, so that we can include the plugin in a bank diff --git a/src/noise-plethora/plugins/P_RunawayFilter.hpp b/src/noise-plethora/plugins/P_RunawayFilter.hpp new file mode 100644 index 0000000..4e5ed1d --- /dev/null +++ b/src/noise-plethora/plugins/P_RunawayFilter.hpp @@ -0,0 +1,55 @@ +#pragma once + +#include "NoisePlethoraPlugin.hpp" + +class RunawayFilter : public NoisePlethoraPlugin { + +public: + + RunawayFilter() { } + + ~RunawayFilter() override {} + + RunawayFilter(const RunawayFilter&) = delete; + RunawayFilter& operator=(const RunawayFilter&) = delete; + + void init() override { + noise1.amplitude(0.5f); + filter1.frequency(1000.0f); + filter1.resonance(4.8f); + filter1.octaveControl(3.0f); + } + + void process(float k1, float k2) override { + float freq = 30.0f + std::pow(k1, 2.0f) * 10000.0f; + float noiseAmp = 0.01f + k2 * 0.99f; + float resonance = 4.5f + (1.0f - k2) * 0.49f; + + noise1.amplitude(noiseAmp); + filter1.frequency(freq); + filter1.resonance(resonance); + } + + void processGraphAsBlock(TeensyBuffer& blockBuffer) override { + noise1.update(&noiseBlock); + filter1.update(&noiseBlock, nullptr, &lpBlock, &bpBlock, &hpBlock); + + blockBuffer.pushBuffer(bpBlock.data, AUDIO_BLOCK_SAMPLES); + } + + AudioStream& getStream() override { + return filter1; + } + unsigned char getPort() override { + return 0; + } + +private: + AudioSynthNoiseWhite noise1; + AudioFilterStateVariable filter1; + + audio_block_t noiseBlock; + audio_block_t lpBlock, bpBlock, hpBlock; +}; + +REGISTER_PLUGIN(RunawayFilter); diff --git a/src/noise-plethora/plugins/P_StochasticPulse.hpp b/src/noise-plethora/plugins/P_StochasticPulse.hpp new file mode 100644 index 0000000..4613ded --- /dev/null +++ b/src/noise-plethora/plugins/P_StochasticPulse.hpp @@ -0,0 +1,68 @@ +#pragma once + +#include "NoisePlethoraPlugin.hpp" + +class StochasticPulse : public NoisePlethoraPlugin { + +public: + + StochasticPulse() { } + + ~StochasticPulse() override {} + + StochasticPulse(const StochasticPulse&) = delete; + StochasticPulse& operator=(const StochasticPulse&) = delete; + + void init() override { + density = 50.0f; + lastPulseSign = false; + + filter1.frequency(1000); + filter1.resonance(4.5f); + filter1.octaveControl(1.0f); + } + + void process(float k1, float k2) override { + density = 5.0f + pow(k1, 2) * 500.0f; + float filterFreq = 80.0f + pow(k2, 2) * 8000.0f; + filter1.frequency(filterFreq); + } + + void processGraphAsBlock(TeensyBuffer& blockBuffer) override { + + // Generate stochastic impulses + float probability = density / 44100.0f; + + for (int i = 0; i < AUDIO_BLOCK_SAMPLES; i++) { + if (random::uniform() < probability) { + lastPulseSign = !lastPulseSign; + impulseBlock.data[i] = lastPulseSign ? 32767 : -32767; + } + else { + impulseBlock.data[i] = 0; + } + } + + // Filter the impulses - use bandpass output for resonant pings + filter1.update(&impulseBlock, nullptr, &lpBlock, &bpBlock, &hpBlock); + + blockBuffer.pushBuffer(bpBlock.data, AUDIO_BLOCK_SAMPLES); + } + + AudioStream& getStream() override { + return filter1; + } + unsigned char getPort() override { + return 0; + } + +private: + AudioFilterStateVariable filter1; + + audio_block_t impulseBlock, lpBlock, bpBlock, hpBlock; + + float density = 50.0f; + bool lastPulseSign = false; +}; + +REGISTER_PLUGIN(StochasticPulse); diff --git a/src/noise-plethora/plugins/P_SubHarmonic.hpp b/src/noise-plethora/plugins/P_SubHarmonic.hpp new file mode 100644 index 0000000..3e4f3f3 --- /dev/null +++ b/src/noise-plethora/plugins/P_SubHarmonic.hpp @@ -0,0 +1,101 @@ +#pragma once + +#include "NoisePlethoraPlugin.hpp" + +class SubHarmonic : public NoisePlethoraPlugin { + +public: + + SubHarmonic() { } + + ~SubHarmonic() override {} + + SubHarmonic(const SubHarmonic&) = delete; + SubHarmonic& operator=(const SubHarmonic&) = delete; + + void init() override { + source.begin(1.0f, 440.0f, WAVEFORM_SQUARE); + + for (int i = 0; i < 4; i++) { + divCounters[i] = 0; + divStates[i] = false; + } + + divWeights[0] = 1.0f; + divWeights[1] = 0.0f; + divWeights[2] = 0.0f; + divWeights[3] = 0.0f; + + prevSamplePositive = true; + } + + void process(float k1, float k2) override { + float freq = 100.0f + std::pow(k1, 2.0f) * 4000.0f; + source.frequency(freq); + + // Crossfade subharmonic levels based on k2 + divWeights[0] = 1.0f; // div2 always active + divWeights[1] = std::min(1.0f, std::max(0.0f, k2 * 3.0f)); // div3 + divWeights[2] = std::min(1.0f, std::max(0.0f, k2 * 3.0f - 1.0f)); // div5 + divWeights[3] = std::min(1.0f, std::max(0.0f, k2 * 3.0f - 2.0f)); // div7 + } + + void processGraphAsBlock(TeensyBuffer& blockBuffer) override { + source.update(&srcBlock); + + for (int i = 0; i < AUDIO_BLOCK_SAMPLES; i++) { + int16_t srcSample = srcBlock.data[i]; + bool currentPositive = (srcSample >= 0); + + // Detect zero crossing (sign change) + if (currentPositive != prevSamplePositive) { + for (int d = 0; d < 4; d++) { + divCounters[d]++; + if (divCounters[d] >= divRatios[d]) { + divStates[d] = !divStates[d]; + divCounters[d] = 0; + } + } + } + prevSamplePositive = currentPositive; + + // Mix: source quieter, subharmonics louder so you clearly hear them come in + float srcFloat = (float)srcSample / 32767.0f; + float mix = 0.15f * srcFloat; + + for (int d = 0; d < 4; d++) { + float divValue = divStates[d] ? 0.5f : -0.5f; + mix += divWeights[d] * divValue; + } + + int32_t out = (int32_t)(mix * 32767.0f); + if (out > 32767) out = 32767; + if (out < -32767) out = -32767; + outputBlock.data[i] = (int16_t)out; + } + + blockBuffer.pushBuffer(outputBlock.data, AUDIO_BLOCK_SAMPLES); + } + + AudioStream& getStream() override { + return source; + } + unsigned char getPort() override { + return 0; + } + +private: + AudioSynthWaveform source; + + audio_block_t srcBlock; + audio_block_t outputBlock; + + int divRatios[4] = {2, 3, 5, 7}; + int divCounters[4] = {0, 0, 0, 0}; + bool divStates[4] = {false, false, false, false}; + float divWeights[4] = {1.0f, 0.0f, 0.0f, 0.0f}; + + bool prevSamplePositive = true; +}; + +REGISTER_PLUGIN(SubHarmonic); diff --git a/src/noise-plethora/plugins/P_TubeResonance.hpp b/src/noise-plethora/plugins/P_TubeResonance.hpp new file mode 100644 index 0000000..71f3427 --- /dev/null +++ b/src/noise-plethora/plugins/P_TubeResonance.hpp @@ -0,0 +1,109 @@ +#pragma once + +#include "NoisePlethoraPlugin.hpp" + +class TubeResonance : public NoisePlethoraPlugin { + +public: + + TubeResonance() { } + + ~TubeResonance() override {} + + // delete copy constructors + TubeResonance(const TubeResonance&) = delete; + TubeResonance& operator=(const TubeResonance&) = delete; + + void init() override { + noise1.amplitude(1); + + for (int c = 0; c < 4; c++) { + writePos[c] = 0; + for (int i = 0; i < 2048; i++) { + buf[c][i] = 0.0f; + } + } + fundamentalFreq = 200.0f; + feedback = 0.85f; + excitation = 0.5f; + } + + void process(float k1, float k2) override { + fundamentalFreq = 40.0f + pow(k1, 2) * 960.0f; + excitation = k2; + feedback = 0.7f + (1.0f - k2) * 0.25f; + + // set noise amplitude proportional to excitation + noise1.amplitude(excitation); + + // compute delay lengths for 4 harmonics + for (int c = 0; c < 4; c++) { + float harmonic = (float)(c + 1); + float freq = fundamentalFreq * harmonic; + float delaySamples = 44100.0f / freq; + delayLen[c] = (int)delaySamples; + if (delayLen[c] < 1) delayLen[c] = 1; + if (delayLen[c] > 2047) delayLen[c] = 2047; + + // feedback per harmonic scaled by 1/harmonic_number + harmonicFeedback[c] = feedback / harmonic; + } + } + + void processGraphAsBlock(TeensyBuffer& blockBuffer) override { + // generate noise block + noise1.update(&noiseBlock); + + for (int i = 0; i < AUDIO_BLOCK_SAMPLES; i++) { + float input = noiseBlock.data[i] / 32767.0f; + float mixed = 0.0f; + + // process 4 comb filters in parallel + for (int c = 0; c < 4; c++) { + int readPos = writePos[c] - delayLen[c]; + if (readPos < 0) readPos += 2048; + + float delayOut = buf[c][readPos]; + float out = input + harmonicFeedback[c] * delayOut; + buf[c][writePos[c]] = out; + + writePos[c] = (writePos[c] + 1) & 2047; // mod 2048 + + mixed += out; + } + + // mix 4 combs equally + mixed *= 0.25f; + + // clamp and convert to int16 + if (mixed > 1.0f) mixed = 1.0f; + if (mixed < -1.0f) mixed = -1.0f; + outputBlock.data[i] = (int16_t)(mixed * 32767.0f); + } + + blockBuffer.pushBuffer(outputBlock.data, AUDIO_BLOCK_SAMPLES); + } + + AudioStream& getStream() override { + return dc1; + } + unsigned char getPort() override { + return 0; + } + +private: + AudioSynthNoiseWhite noise1; + AudioSynthWaveformDc dc1; // dummy for getStream() + + audio_block_t noiseBlock, outputBlock; + + float buf[4][2048] = {}; + int writePos[4] = {}; + int delayLen[4] = {100, 50, 33, 25}; + float harmonicFeedback[4] = {}; + float fundamentalFreq = 200.0f; + float feedback = 0.85f; + float excitation = 0.5f; +}; + +REGISTER_PLUGIN(TubeResonance); // this is important, so that we can include the plugin in a bank From cf9b8155d4dd8df7134ecebac2a462c3bdb0ab71 Mon Sep 17 00:00:00 2001 From: Pablo Alcantar Date: Sat, 11 Apr 2026 21:41:32 +0200 Subject: [PATCH 03/14] Add complete plugin guide for all 50 algorithms (MD + HTML) Documents Banks A-E with parameter ranges, signal chain descriptions, sound character notes, and navigable table of contents. Dark-themed HTML version included. Co-Authored-By: Claude Opus 4.6 (1M context) --- NOISE_PLETHORA_PLUGIN_GUIDE.html | 1675 ++++++++++++++++++++++++++++++ NOISE_PLETHORA_PLUGIN_GUIDE.md | 864 +++++++++++++++ 2 files changed, 2539 insertions(+) create mode 100644 NOISE_PLETHORA_PLUGIN_GUIDE.html create mode 100644 NOISE_PLETHORA_PLUGIN_GUIDE.md diff --git a/NOISE_PLETHORA_PLUGIN_GUIDE.html b/NOISE_PLETHORA_PLUGIN_GUIDE.html new file mode 100644 index 0000000..5beedbb --- /dev/null +++ b/NOISE_PLETHORA_PLUGIN_GUIDE.html @@ -0,0 +1,1675 @@ + + + + + +Noise Plethora — Complete Plugin Guide + + + +

Noise Plethora — Complete Plugin Guide

+

Befaco Noise Plethora v1.5 + Banks D & E Extension

+

About This Guide

+

The Noise Plethora is a Eurorack noise workstation with 3 digital sound generators (A, B, and C), each followed by an analog multimode filter. Generators A and B run interchangeable algorithms organized in banks of 10. Each algorithm has two parameters controlled by the X and Y knobs (and their corresponding CV inputs, 0–10Vpp).

+

This guide documents all 50 algorithms across 5 banks:

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
BankNameProgramsTheme
ATextures0–9Cross-modulation, ring mod, granular, noise AM
BHH Clusters0–9Additive/cluster synthesis with 6–16 oscillators
CHarsh & Wild0–9Bitcrushing, random walks, chaotic oscillators
DResonant Bodies0–9Delay-based resonance, physical modeling, spectral shaping
EChaos Machines0–9Deterministic chaos, algorithmic processes, digital manipulation
+

Banks A–C are the original Befaco firmware. Banks D–E are community extensions.

+
+

Table of Contents

+ +
+

Bank A: Textures

+

Cross-modulation, ring modulation, granular processing, and noise AM. Focused on complex modulation techniques that create rich, evolving textures.

+
+

A-0: RadioOhNo

+

Four square wave oscillators cross-modulated in couples, summed together.

+

Four pulse-width-modulated oscillators interconnected in feedback pairs: oscillator 1 modulates 2 and vice versa, oscillator 3 modulates 4 and vice versa. A DC source modulates all oscillators' frequency. The cross-modulation creates complex sidebands and chaotic harmonic interactions.

+ + + + + + + + + + + + + + + + + + + + + + + +
ParameterControlRangeEffect
X (k1)Oscillator 1 frequency20 – 2520 HzBase frequency for all 4 oscillators (each at a different ratio). Quadratic mapping for fine control at low frequencies.
Y (k2)PWM / DC modulation0 – 1Controls DC amplitude which modulates all oscillators' frequency. Higher values create wider FM deviation and more chaotic sidebands.
+

Sound character: Aggressive, unstable radio-frequency-like textures. Like tuning between shortwave stations. Rich in aliasing and intermodulation products.

+
+

A-1: Rwalk_SineFMFlange

+

Four random walkers controlling pulse oscillators, FM'd by sines, through a flanger.

+

Four 2D random walkers move in a bounded box with random velocities. Their positions map to the frequencies of 4 pulse wave oscillators, which feed into 4 sine FM oscillators. The mixed output passes through a flanger effect.

+ + + + + + + + + + + + + + + + + + + + + + + +
ParameterControlRangeEffect
X (k1)FM sine frequency10 – 510 HzBase frequency of the 4 sine FM oscillators (each offset by 55–75 Hz).
Y (k2)Flanger modulation rate0 – 3 HzLFO speed of the flanger. Adds swept comb filtering on top of the FM textures.
+

Sound character: Morphing, evolving FM textures with organic movement. The flanger adds spatial depth and sweeping spectral animation. No two moments are alike. Atmospheric and complex.

+
+

A-2: xModRingSqr

+

Cross FM between two square wave oscillators, ring modulated.

+

Two square wave oscillators in a feedback configuration: each modulates the other's frequency. Their outputs are ring modulated (multiplied) together.

+ + + + + + + + + + + + + + + + + + + + + + + +
ParameterControlRangeEffect
X (k1)Oscillator 1 frequency100 – 5100 HzPitch of the first square wave. Quadratic mapping.
Y (k2)Oscillator 2 frequency20 – 1020 HzPitch of the second square wave. Quadratic mapping.
+

Sound character: Metallic, clanging ring modulation. At simple ratios (2:1, 3:2) = tonal metallic tones. At complex ratios = inharmonic metallic clatter.

+
+

A-3: XModRingSine

+

Cross FM between two sine oscillators, ring modulated.

+

Same topology as xModRingSqr but using sine FM oscillators. Sines produce cleaner, more bell-like results than squares.

+ + + + + + + + + + + + + + + + + + + + + + + +
ParameterControlRangeEffect
X (k1)Oscillator 1 frequency100 – 8100 HzPitch of the first sine. Quadratic mapping. Wide range.
Y (k2)Oscillator 2 frequency60 – 3060 HzPitch of the second sine. Quadratic mapping.
+

Sound character: Bell-like and metallic tones. All spectral content comes from the FM and ring modulation. Good for tuned metallic percussion sounds.

+
+

A-4: CrossModRing

+

Four oscillators in a cross-modulation matrix with cascaded ring modulators.

+

Four oscillators (2 square, 1 sawtooth with offset, 1 square) modulate each other's frequencies. Three ring modulators in a cascaded configuration: multiply1 and multiply2 feed into multiply3. The most complex modulation topology in the module.

+ + + + + + + + + + + + + + + + + + + + + + + +
ParameterControlRangeEffect
X (k1)Frequency (all oscillators)1 – 827 HzScales all 4 oscillator frequencies with individual ratios.
Y (k2)FM depth2 – 10 octavesMaster frequency modulation depth. Low = subtle. High = total harmonic chaos.
+

Sound character: Incredibly dense sideband spectrum. From metallic drones at low FM depth to total chaos at high depth. Like a 4-operator FM synth pushed to extremes.

+
+

A-5: Resonoise

+

Square wave FM-modulating a sine, through a wavefolder, controlling a resonant filter on white noise.

+

A modulated square wave drives a sine FM oscillator. The sine passes through a wavefolder, then feeds into a state-variable filter as the frequency control signal. White noise is the audio input to the filter (resonance=3).

+ + + + + + + + + + + + + + + + + + + + + + + +
ParameterControlRangeEffect
X (k1)Both oscillator frequencies20 – 10020 HzControls the modulation rate of the filter cutoff.
Y (k2)Wavefold amount0.03 – 0.23DC bias into the wavefolder. More folding = more complex filter modulation pattern.
+

Sound character: Resonant noise with animated filter modulation. Like white noise through an auto-wah driven by a complex LFO. Organic and vocal.

+
+

A-6: GrainGlitch

+

Square wave through a granular cell, output XOR'd with the input.

+

A square wave feeds into a granular pitch-shifting processor with feedback. The original square wave and the granular output are combined using XOR digital logic.

+ + + + + + + + + + + + + + + + + + + + + + + +
ParameterControlRangeEffect
X (k1)Square wave frequency500 – 5500 HzBase frequency of the source oscillator.
Y (k2)Grain size + speed25–100 ms / 0.125–8xGrain size (pitch shift window) and playback speed ratio.
+

Sound character: Glitchy digital artifacts from XOR combination. Harsh, broken, digital — like a CD skipping.

+
+

A-7: GrainGlitchII

+

Square wave through a granular cell, amplified.

+

Similar to GrainGlitch but without XOR. Granular output amplified 32000x to bring up the quiet signal.

+ + + + + + + + + + + + + + + + + + + + + + + +
ParameterControlRangeEffect
X (k1)Square wave frequency500 – 5500 HzBase frequency of the source oscillator.
Y (k2)Grain size + speed25–100 ms / 0.125–8xSame mapping as GrainGlitch.
+

Sound character: Cleaner granular texture than GrainGlitch. More transparent and "musical" than the XOR version.

+
+

A-8: GrainGlitchIII

+

Sawtooth wave through a granular cell.

+

Similar to GrainGlitchII but using a sawtooth waveform. Richer harmonic spectrum provides more material for the granular processor.

+ + + + + + + + + + + + + + + + + + + + + + + +
ParameterControlRangeEffect
X (k1)Sawtooth frequency400 – 5500 HzBase frequency.
Y (k2)Grain size + speed25–80 ms / 0.125–8xSlightly narrower grain range than I/II.
+

Sound character: The richest granular variant. Textures from buzzy granular drones to scattered metallic fragments.

+
+

A-9: Basurilla

+

White noise amplitude-modulated by 3 independent pulse wave LFOs.

+

Three parallel channels: white noise is ring-modulated by 3 pulse wave oscillators at different rates and pulse widths. The pulse waves gate the noise in complex rhythmic patterns.

+ + + + + + + + + + + + + + + + + + + + + + + +
ParameterControlRangeEffect
X (k1)LFO frequencies0.1 – 110 HzControls all 3 pulse LFOs. Low = slow gates. High = audio-rate AM.
Y (k2)Pulse widths / noise levelPW + inverse amplitudePulse width of the 3 LFOs and inversely controls noise amplitude.
+

Sound character: Chaotic, granular-like texture from noise gated by 3 independent pulse trains. "Basurilla" = "little garbage" in Spanish — beautifully organized trash.

+
+

Bank B: HH Clusters

+

Cluster/additive synthesis using 6–16 oscillators at mathematically related frequency ratios. Dense, shimmering tonal textures.

+
+

B-0: ClusterSaw

+

16 sawtooth oscillators with adjustable geometric frequency spread.

+

Sixteen sawtooths tuned in geometric progression. Each frequency is the previous one multiplied by a constant factor.

+ + + + + + + + + + + + + + + + + + + + + + + +
ParameterControlRangeEffect
X (k1)Base frequency20 – 1020 HzFundamental frequency.
Y (k2)Spread factor1.01 – 1.91Ratio between adjacent oscillators. Low = beating unison. High = wide harmonic spread.
+

Sound character: Shimmering, buzzing mass of sawtooths. The quintessential "cluster" sound. 16 voices create an extremely rich spectral texture.

+
+

B-1: PwCluster

+

6 detuned pulse waveforms with adjustable pulse width.

+

Six pulse waves at fixed detuned ratios (1.227, 1.24, 1.17, 1.2, 1.3). DC-controlled pulse width.

+ + + + + + + + + + + + + + + + + + + + + + + +
ParameterControlRangeEffect
X (k1)Base frequency40 – 8040 HzWidest range of any cluster plugin.
Y (k2)Pulse widthWide – Narrow (inverted)Low Y = full, warm. High Y = thin, nasal.
+

Sound character: Chorused pulse waves. At wide PW: organ-like. At narrow PW: reedy, nasal. Constant beating from non-harmonic detuning.

+
+

B-2: CrCluster2

+

6 detuned sine waves with low-frequency FM from a single modulator.

+

Six sines, all FM'd by one sine at 2.7x the base frequency.

+ + + + + + + + + + + + + + + + + + + + + + + +
ParameterControlRangeEffect
X (k1)Base frequency40 – 8040 HzCluster fundamental.
Y (k2)FM index0 – 1.0Low = pure sine cluster. High = bright FM harmonics.
+

Sound character: Clean sine cluster that becomes progressively FM-modulated. Warm to bright. Spectrally coherent.

+
+

B-3: SineFMcluster

+

6 triangle waves, each independently FM'd by its own sine modulator (subharmonic ratio 0.333).

+ + + + + + + + + + + + + + + + + + + + + + + +
ParameterControlRangeEffect
X (k1)Base frequency300 – 8300 HzHigher starting frequency.
Y (k2)FM index0.1 – 1.0Subharmonic FM adds content below carriers.
+

Sound character: Warm, soft FM cluster. Triangle carriers + subharmonic FM = "analog" feeling warmth and depth.

+
+

B-4: TriFMcluster

+

6 triangle waves, each independently FM'd at very slow ratio (0.07).

+

Same architecture as SineFMcluster but with 1/14th FM ratio. Creates phasing/chorus rather than FM timbral change.

+ + + + + + + + + + + + + + + + + + + + + + + +
ParameterControlRangeEffect
X (k1)Base frequency300 – 8300 HzSame range as SineFMcluster.
Y (k2)FM index0.1 – 1.0Creates slow drifting detuning, not bright harmonics.
+

Sound character: Lush, animated ensemble effect. Like 6 slightly out-of-tune instruments. Very different from SineFMcluster despite identical architecture.

+
+

B-5: PrimeCluster

+

16 oscillators tuned to prime number frequencies, noise-modulated.

+

Sixteen variable-triangle oscillators at primes (53, 127, 199... 1523 Hz), all scaled by a common factor. White noise FM adds animation.

+ + + + + + + + + + + + + + + + + + + + + + + +
ParameterControlRangeEffect
X (k1)Pitch multiplier0.5 – 10.5Scales all 16 primes. Linear mapping.
Y (k2)Noise modulation0 – 0.2Noise FM amount. Low = clean. High = tremolo-like.
+

Gain: 0.8 (reduced to prevent clipping).

+

Sound character: Inharmonic, bell-like chord. No common harmonics — a unique shimmering metallic texture.

+
+

B-6: PrimeCnoise

+

16 triangle oscillators at prime frequencies (wider range variant).

+

Nearly identical to PrimeCluster but with quadratic pitch mapping (k1^2 x 12) for wider range.

+ + + + + + + + + + + + + + + + + + + + + + + +
ParameterControlRangeEffect
X (k1)Pitch multiplier0.5 – 12.5Quadratic mapping — more extreme range.
Y (k2)Noise modulation0 – 0.2Same as PrimeCluster.
+

Gain: 0.8

+

Sound character: Same prime character, different response to knob gestures. More exponential/extreme than PrimeCluster.

+
+

B-7: FibonacciCluster

+

16 sawtooth oscillators at Fibonacci-series frequency spacing.

+

Frequencies follow f(n) = f(n-1) + f(n-2) x spread. Noise FM adds animation.

+ + + + + + + + + + + + + + + + + + + + + + + +
ParameterControlRangeEffect
X (k1)Base frequency50 – 1050 HzFundamental pitch.
Y (k2)Spread factor0.1 – 0.6How fast frequencies diverge. Near 0.618 = golden ratio intervals.
+

Sound character: Nature's favorite ratio. At spread near golden ratio, intervals feel "naturally balanced." Unique organic quality.

+
+

B-8: PartialCluster

+

16 sawtooth oscillators with multiplicative harmonic spacing.

+

Each frequency is the previous multiplied by a spread factor.

+ + + + + + + + + + + + + + + + + + + + + + + +
ParameterControlRangeEffect
X (k1)Base frequency50 – 1050 HzFundamental.
Y (k2)Harmonic spread1.01 – 2.11At 2.0 = octave spacing. Below = dense. Above = stretched/metallic.
+

Sound character: The most "tuneable" cluster. Morph from dense unison to harmonic series to metallic bells by sweeping Y.

+
+

B-9: PhasingCluster

+

16 square waves with individual LFO phase modulation.

+

Each oscillator has its own triangle LFO at a unique rate: 10, 11, 15, 1, 1, 3, 17, 14, 0.11, 5, 2, 7, 1, 0.1, 0.7, 0.5 Hz.

+ + + + + + + + + + + + + + + + + + + + + + + +
ParameterControlRangeEffect
X (k1)Carrier frequency30 – 5030 HzBase frequency for all 16 squares.
Y (k2)Spread1.0 – 1.5Spreads carrier frequencies slightly.
+

Sound character: Massive phasing. 16 oscillators drifting at their own rates — constantly evolving, never-repeating interference patterns. Glacial slow LFOs (0.1 Hz) + shimmer (17 Hz).

+
+

Bank C: Harsh & Wild

+

Extreme processing: bitcrushing, random walks, chaotic oscillators, reverb abuse. The most experimental and aggressive bank.

+
+

C-0: BasuraTotal

+

"Bent" LFSR driving an oscillator with reverb.

+

A Galois LFSR generates pseudo-random timing events that trigger a waveform oscillator. Output through Freeverb.

+ + + + + + + + + + + + + + + + + + + + + + + +
ParameterControlRangeEffect
X (k1)Oscillator frequency200 – 5200 HzPitch of triggered waveform.
Y (k2)Event rateSlow – FastTiming between LFSR-triggered events.
+

Sound character: Sporadic bursts with reverb tails. "BasuraTotal" = "Total Garbage" — chaotic, messy, and beautiful.

+
+

C-1: Atari

+

Two square waves with PWM/FM cross-modulation.

+

First oscillator does PWM on the second, second does FM on the first.

+ + + + + + + + + + + + + + + + + + + + + + + +
ParameterControlRangeEffect
X (k1)Wave 1 frequency10 – 60 HzSub-bass territory.
Y (k2)Wave 2 freq + FM depth10–210 Hz / 3–11 octHigher pitch AND more extreme modulation.
+

Sound character: Classic 8-bit Atari/chiptune. Buzzy, aggressive, nostalgic.

+
+

C-2: WalkingFilomena

+

16 random walkers controlling pulse oscillator frequencies.

+

Sixteen pulse oscillators with independent 2D random walkers in a bounded box.

+ + + + + + + + + + + + + + + + + + + + + + + +
ParameterControlRangeEffect
X (k1)Random walk box size200 – 1800 HzFrequency range of all 16 oscillators.
Y (k2)Pulse width0.1 – 0.9Thin = bright/nasal. Wide = warm/full.
+

Sound character: Shimmering, constantly evolving polyphonic texture. 16 oscillators wandering in pitch space. Organic and alive.

+
+

C-3: S_H (Sample & Hold)

+

Sample-and-hold noise with dirty reverb.

+ + + + + + + + + + + + + + + + + + + + + + + +
ParameterControlRangeEffect
X (k1)S&H rate15 – 5015 HzSlow = stepped tones. Fast = granular noise.
Y (k2)Reverb mixDry – WetDry = stochastic clicks. Wet = ambient wash.
+

Sound character: Classic S&H randomness with spatial depth from reverb.

+
+

C-4: ArrayOnTheRocks

+

FM synthesis with a randomized 256-point wavetable.

+

A 500 Hz sine modulates an arbitrary waveform with randomly corrupted table values.

+ + + + + + + + + + + + + + + + + + + + + + + +
ParameterControlRangeEffect
X (k1)Wavetable oscillator freq10 – 10010 HzPlayback speed.
Y (k2)FM modulator amplitude0 – 1.0Low = clean wavetable. High = rich FM sidebands.
+

Sound character: Unpredictable timbral textures from the corrupted wavetable. Different from standard FM because the carrier waveform itself is partially random.

+
+

C-5: ExistenceIsPain

+

Sample-and-hold noise through 4 bandpass filters modulated by 4 LFOs.

+

S&H source into 4 parallel SVF bandpass filters with independent triangle LFOs at 11, 70, 23, 0.01 Hz. Resonance=5.

+ + + + + + + + + + + + + + + + + + + + + + + +
ParameterControlRangeEffect
X (k1)S&H noise frequency50 – 5050 HzBase texture density.
Y (k2)Filter sweep range0.3 – 3.3 octavesNarrow = focused. Wide = dramatic animation.
+

Sound character: Slowly breathing, organic multiband filtering. The 0.01 Hz LFO creates glacial changes, 70 Hz adds shimmer. Deep, meditative, slightly ominous.

+
+

C-6: WhoKnows

+

Pulse wave through 4 bandpass filters with fast LFO modulation.

+

Similar to ExistenceIsPain but with 5 Hz pulse source and much faster LFOs (21, 70, 90, 77 Hz). Resonance=7.

+ + + + + + + + + + + + + + + + + + + + + + + +
ParameterControlRangeEffect
X (k1)Pulse frequency15 – 515 HzSource frequency.
Y (k2)Filter sweep range0.3 – 6.3 octavesAt high settings, filters sweep wildly.
+

Sound character: Dramatic, rapidly animated filter textures. Audio-rate LFOs create sideband-like effects. Aggressive and chaotic.

+
+

C-7: SatanWorkout

+

Pink noise FM-ing a PWM oscillator, through reverb.

+

Pink noise modulates a PWM oscillator. Freeverb with negative damping (-5).

+ + + + + + + + + + + + + + + + + + + + + + + +
ParameterControlRangeEffect
X (k1)PWM frequency8 – 6008 Hz"Pitch" of noise modulation.
Y (k2)Reverb room size0.001 – 4.0Beyond 1.0 = self-exciting reverb feedback.
+

Sound character: Raw organic noise with reverb. At high Y the reverb self-excites. Relentless intensity.

+
+

C-8: Rwalk_BitCrushPW

+

9 random-walk pulse oscillators, bitcrushed to 1 bit, with reverb.

+

Nine pulse oscillators with 2D random walkers. Mixed, 1-bit crushed, parallel reverb path.

+ + + + + + + + + + + + + + + + + + + + + + + +
ParameterControlRangeEffect
X (k1)Pulse width0.2 – 0.75Timbre control alongside random walk frequencies.
Y (k2)Reverb room size0 – 4.0High = self-exciting reverb.
+

Sound character: Extreme digital destruction. Dense, distorted digital texture with organic pitch movement from random walks. Lo-fi at its most extreme.

+
+

C-9: Rwalk_LFree

+

4 PWM oscillators with random-walk frequencies, through reverb.

+

Four PWM oscillators with independent random walkers. Clean Freeverb (no bitcrushing).

+ + + + + + + + + + + + + + + + + + + + + + + +
ParameterControlRangeEffect
X (k1)Random walk boundary50 – 550 HzFrequency space size.
Y (k2)Reverb room size0 – 1.0Conservative range, clean reverb.
+

Sound character: Spacious, clean random pulse textures. Warm timbre, gentle pitch drift, dreamy ambient reverb. The gentlest of the random walk family.

+
+

Bank D: Resonant Bodies

+

Delay-based resonance, physical modeling, and spectral shaping. What happens when noise passes through resonant structures: comb filters, waveguides, feedback networks, and high-Q resonators.

+
+

D-0: CombNoise

+

White noise through 4 parallel comb filters.

+

A comb filter is a short delay line with feedback — it reinforces frequencies at the delay time and its harmonics. Four combs at ratios 1.0 : 0.7 : 0.5 : 0.35 create a rich, multi-pitched metallic tone.

+ + + + + + + + + + + + + + + + + + + + + + + +
ParameterControlRangeEffect
X (k1)Resonant pitch40 – 5000 HzFundamental frequency of all 4 comb filters.
Y (k2)Feedback0 – 95%Resonance sustain. Low = colored noise. High = clearly pitched ringing.
+

Sound character: Like blowing across a metal pipe. The 4 overlapping combs create a rich harmonic spectrum.

+
+

D-1: PluckCloud

+

6 Karplus-Strong plucked string voices with random retriggering.

+

Noise burst into delay line with LP filter in feedback loop. Voices retrigger randomly (~2% per cycle). Detuned at ratios 1.0, 1.005, 0.995, 1.01, 0.99, 1.015.

+ + + + + + + + + + + + + + + + + + + + + + + +
ParameterControlRangeEffect
X (k1)Pitch center60 – 3000 HzBase pitch for all 6 voices.
Y (k2)Brightness / decayDull – BrightLow = muted string, fast decay. High = bright ring, long sustain.
+

Sound character: Rain on a kalimba, or a prepared piano played by dice. Sparse, organic, constantly evolving.

+
+

D-2: TubeResonance

+

Noise excitation through 4 harmonic comb filters simulating a resonant tube.

+

Four combs at 1x, 2x, 3x, 4x fundamental. Higher harmonics decay faster (feedback scaled by 1/harmonic).

+ + + + + + + + + + + + + + + + + + + + + + + +
ParameterControlRangeEffect
X (k1)Tube length40 – 1000 HzFundamental pitch. Low = long tube. High = short pipe.
Y (k2)ExcitationSelf-resonance – BreathLow = singing bowl drone. High = breathy wind-through-pipe.
+

Sound character: Hollow drone to breathy pipe texture. Harmonic series is clearly audible — sounds like a real resonant object.

+
+

D-3: FormantNoise

+

White noise through 3 bandpass filters at vowel formant frequencies.

+

Interpolates between 5 vowel shapes (A, E, I, O, U) using 3 SVF bandpass filters.

+ + + + + + + + + + + + + + + + + + + + + + + +
ParameterControlRangeEffect
X (k1)Vowel morphA → E → I → O → USmooth interpolation between vowel formants.
Y (k2)ResonanceQ 1.0 – 5.0Wide/breathy to sharp/nasal vowels.
+

Formant table (Hz):

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
VowelF1F2F3
A73010902440
E66017202410
I27022903010
O5708402410
U3008702240
+

Sound character: Robotic choir whispering vowels. Sweep X for ghostly "aaah → eeeh → iiih → oooh → uuuh."

+
+

D-4: BowedMetal

+

Noise exciting 8 high-Q resonators at dense metallic frequency ratios.

+

Eight 2-pole resonators (Q ~300–500) at plate vibration mode ratios. Denser than NoiseBells = more reverberant.

+ + + + + + + + + + + + + + + + + + + + + + + +
ParameterControlRangeEffect
X (k1)Fundamental pitch30 – 2030 HzAll 8 resonators scale proportionally.
Y (k2)Struck → BowedShort ring – Infinite sustainLow = cymbal hit. High = bowed singing bowl.
+

Resonator ratios: 1.000, 1.183, 1.506, 1.741, 2.098, 2.534, 2.917, 3.483

+

Sound character: Dense metallic reverberance. Bowed cymbal or gong. More diffuse than NoiseBells.

+
+

D-5: FlangeNoise

+

Pink noise through a flanger effect.

+

Swept comb filter on noise. Classic "jet engine whoosh."

+ + + + + + + + + + + + + + + + + + + + + + + +
ParameterControlRangeEffect
X (k1)Flange rate0.05 – 5 HzSlow sweep to fast warble.
Y (k2)Flange depthSubtle – DeepPhase-like to dramatic comb sweep.
+

Sound character: Jet plane flyover, ocean through metal tube, wind in rotating vent.

+
+

D-6: NoiseBells

+

White noise exciting 4 sharp 2-pole resonators at bell-like inharmonic ratios.

+

Extremely high Q (~625) creates laser-sharp peaks. Clear ringing tones from noise.

+ + + + + + + + + + + + + + + + + + + + + + + +
ParameterControlRangeEffect
X (k1)Bell pitch80 – 4080 HzFundamental. All 4 resonators scale.
Y (k2)InharmonicityChime → GongNear-harmonic (wind chime) to stretched (gamelan).
+

Resonator ratios (vary with Y):

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
ResonatorY=0 (chime)Y=1 (gong)
11.00x1.00x
21.59x2.48x
32.33x4.33x
43.14x6.35x
+

Sound character: Clear bell tones from noise. Visible on spectrum analyzer as 4 needle-sharp peaks.

+
+

D-7: NoiseHarmonics

+

White noise through a wavefolder, then resonant bandpass filter.

+

Wavefolder creates harmonics from noise (DC bias controlled). SVF filter (Q=3) selects a frequency band.

+ + + + + + + + + + + + + + + + + + + + + + + +
ParameterControlRangeEffect
X (k1)Wavefold intensityGentle – HeavyMore folding = denser harmonics.
Y (k2)Filter frequency100 – 8100 HzSelects which band is heard.
+

Sound character: Aggressive buzzing. Like an angry bee swarm at a specific pitch. Grittier than plain filtered noise.

+
+

D-8: IceRain

+

Sparse sample-and-hold events with long reverb tails.

+

Random stepped values at controllable rate into Freeverb (high damping).

+ + + + + + + + + + + + + + + + + + + + + + + +
ParameterControlRangeEffect
X (k1)Droplet density0.5 – 200 HzSparse plinks to dense rain.
Y (k2)Reverb sizeSmall – VastDry/close to cathedral-like.
+

Sound character: Crystalline drops in a cave. Sparse plinks with shimmering tails. Very spatial and ambient.

+
+

D-9: DroneBody

+

Two cross-modulated FM sines through a wavefolder.

+

Slightly detuned sines with block-delayed cross-feedback FM. Wavefolder adds harmonics.

+ + + + + + + + + + + + + + + + + + + + + + + +
ParameterControlRangeEffect
X (k1)Drone pitch20 – 520 HzFundamental of both sines.
Y (k2)Detune + FoldClean – RichY=0: clean hum. Y=1: beating + growling overtones.
+

Sound character: Deep meditative drone. Tibetan singing bowl meets power transformer. Good for sustained bass.

+
+

Bank E: Chaos Machines

+

Deterministic chaos, algorithmic processes, and digital manipulation. Mathematical systems that hover between order and noise.

+
+

E-0: LogisticNoise

+

Logistic map chaotic oscillator: x(n+1) = r * x(n) * (1 - x(n))

+ + + + + + + + + + + + + + + + + + + + + + + +
ParameterControlRangeEffect
X (k1)Chaos parameter r3.5 – 4.03.5=periodic. 3.57=chaos onset. 3.83=period-3 window. 4.0=full chaos.
Y (k2)Output rateSlow – FastHeld samples (buzzy tone) to per-sample (noise-like at r=4).
+

Sound character: Mathematical structure dissolving into chaos. Sweep r to hear windows of order breaking into noise. The period-3 window at r~3.83 is particularly striking.

+
+

E-1: HenonDust

+

Henon attractor: x' = 1 - a*x^2 + y, y' = b*x

+ + + + + + + + + + + + + + + + + + + + + + + +
ParameterControlRangeEffect
X (k1)Parameter a1.15 – 1.40Low=periodic. ~1.2=period-doubling. 1.4=full chaos.
Y (k2)Parameter b0.15 – 0.35Attractor shape and crackle density.
+

Sound character: Alien vinyl surface noise. Almost-repeating patterns that never quite repeat. Living, deterministic crackle.

+
+

E-2: CellularSynth

+

1D cellular automaton (32 cells) controlling 8 sawtooth oscillators at harmonics of 55 Hz.

+ + + + + + + + + + + + + + + + + + + + + + + +
ParameterControlRangeEffect
X (k1)CA rule0 – 255Rule 30=chaotic. Rule 90=fractal. Rule 110=complex.
Y (k2)Evolution speedGlacial – RapidHow fast the CA evolves.
+

Sound character: Alien music box that rewrites its own score. Some rules = steady drone, others = constant mutation.

+
+

E-3: StochasticPulse

+

Poisson-distributed impulses through a resonant bandpass filter (Q=4.5).

+ + + + + + + + + + + + + + + + + + + + + + + +
ParameterControlRangeEffect
X (k1)Impulse density5 – 505 /secSparse pings to dense crackling.
Y (k2)Filter frequency80 – 8080 HzPitch of the resonant ring.
+

Sound character: Geiger counter meets resonant drum. Random metallic pings with clear musical pitch.

+
+

E-4: BitShift

+

Two sawtooth oscillators combined via XOR digital logic.

+ + + + + + + + + + + + + + + + + + + + + + + +
ParameterControlRangeEffect
X (k1)Oscillator 1 freq20 – 5020 HzFirst sawtooth.
Y (k2)Oscillator 2 ratio1:1 – 1:8Simple ratios = structured. Irrational = maximum complexity.
+

Sound character: Broken NES / ZX Spectrum. Hard digital edges, rapidly shifting sum/difference tones. Aggressive 8-bit.

+
+

E-5: FeedbackFM

+

Single sine with sample-delayed self-feedback into its own phase.

+ + + + + + + + + + + + + + + + + + + + + + + +
ParameterControlRangeEffect
X (k1)Carrier frequency20 – 5020 HzPitch.
Y (k2)Feedback0 – 2.5 rad0=sine. ~0.8=bright. ~1.5=metallic. ~2.0=gritty. 2.5=noise.
+

Sound character: The full timbral spectrum in one knob. Classic DX7 operator technique. Sweet spot at Y~1.0 = vocal/nasal quality.

+
+

E-6: RunawayFilter

+

White noise through a self-oscillating SVF (Q ~4.5–4.99).

+ + + + + + + + + + + + + + + + + + + + + + + +
ParameterControlRangeEffect
X (k1)Filter frequency30 – 10030 HzPitched self-oscillation tone.
Y (k2)Noise injectionWhistle – NoiseY=0: clean sine whistle. Y=1: resonant noise. Transition zone = sweet spot.
+

Sound character: Pitched whistle fighting noise. Like tuning a shortwave radio. Fragile tone that breaks and reforms.

+
+

E-7: GlitchLoop

+

Noise captured into a loop with progressive bit-depth degradation.

+ + + + + + + + + + + + + + + + + + + + + + + +
ParameterControlRangeEffect
X (k1)Loop length10 – 200 msShort = buzz. Long = stutter.
Y (k2)Degradation rateStable – RapidHow fast the loop crumbles. Refills when bit depth hits 1.
+

Sound character: Digital decay. Loop captures, degrades, collapses to 1-bit, refreshes. Rhythmic destruction cycle.

+
+

E-8: SubHarmonic

+

Square wave with frequency dividers at /2, /3, /5, /7.

+ + + + + + + + + + + + + + + + + + + + + + + +
ParameterControlRangeEffect
X (k1)Fundamental frequency100 – 4100 HzSource square wave pitch.
Y (k2)Subharmonic mix/2 only → All fourProgressive: Y=0: octave below. Y=0.33: +fifth below. Y=0.66: +major 3rd down. Y=1: +minor 7th down.
+

Subharmonic intervals at 440 Hz: /2=220 Hz, /3=~147 Hz, /5=88 Hz, /7=~63 Hz

+

Sound character: Deep rumbling sub-bass. Earth-shaking low end at full Y with low fundamental. Tectonic.

+
+

E-9: DualAttractor

+

Two coupled Lorenz attractors driving two sine oscillators.

+

Lorenz system: dx/dt = sigma(y-x), dy/dt = x(rho-z)-y, dz/dt = xy-beta*z. sigma=10, rho=28, beta=8/3.

+ + + + + + + + + + + + + + + + + + + + + + + +
ParameterControlRangeEffect
X (k1)Coupling strength0 – 50=independent chaos. 5=tones lock/unlock in bursts.
Y (k2)Base frequency30 – 2030 HzCenter pitch the attractors orbit.
+

Sound character: Two drunk musicians trying to play in unison. Moments of harmony interrupted by chaos. Organic, alive, never repeating.

+
+

Generated from firmware source code analysis. Befaco Noise Plethora v1.5 + Banks D & E extension.

+ + \ No newline at end of file diff --git a/NOISE_PLETHORA_PLUGIN_GUIDE.md b/NOISE_PLETHORA_PLUGIN_GUIDE.md new file mode 100644 index 0000000..5feff92 --- /dev/null +++ b/NOISE_PLETHORA_PLUGIN_GUIDE.md @@ -0,0 +1,864 @@ +# Noise Plethora — Complete Plugin Guide + +*Befaco Noise Plethora v1.5 + Banks D & E Extension* + +## About This Guide + +The Noise Plethora is a Eurorack noise workstation with 3 digital sound generators (A, B, and C), each followed by an analog multimode filter. Generators A and B run interchangeable algorithms organized in banks of 10. Each algorithm has two parameters controlled by the **X** and **Y** knobs (and their corresponding CV inputs, 0–10Vpp). + +This guide documents all 50 algorithms across 5 banks: + +| Bank | Name | Programs | Theme | +|------|------|----------|-------| +| **A** | Textures | 0–9 | Cross-modulation, ring mod, granular, noise AM | +| **B** | HH Clusters | 0–9 | Additive/cluster synthesis with 6–16 oscillators | +| **C** | Harsh & Wild | 0–9 | Bitcrushing, random walks, chaotic oscillators | +| **D** | Resonant Bodies | 0–9 | Delay-based resonance, physical modeling, spectral shaping | +| **E** | Chaos Machines | 0–9 | Deterministic chaos, algorithmic processes, digital manipulation | + +Banks A–C are the original Befaco firmware. Banks D–E are community extensions. + +--- + +## Table of Contents + +- [Bank A: Textures](#bank-a-textures) + - [A-0: RadioOhNo](#a-0-radioohno) — Cross-modulated square waves + - [A-1: Rwalk_SineFMFlange](#a-1-rwalk_sinefmflange) — Random walk FM + flanger + - [A-2: xModRingSqr](#a-2-xmodringsqr) — Cross FM square ring mod + - [A-3: XModRingSine](#a-3-xmodringsine) — Cross FM sine ring mod + - [A-4: CrossModRing](#a-4-crossmodring) — 4-osc cascaded ring mod + - [A-5: Resonoise](#a-5-resonoise) — Wavefolder-controlled resonant filter + - [A-6: GrainGlitch](#a-6-grainglitch) — Granular + XOR + - [A-7: GrainGlitchII](#a-7-grainglitchii) — Granular amplified + - [A-8: GrainGlitchIII](#a-8-grainglitchiii) — Granular sawtooth + - [A-9: Basurilla](#a-9-basurilla) — Noise gated by 3 pulse LFOs +- [Bank B: HH Clusters](#bank-b-hh-clusters) + - [B-0: ClusterSaw](#b-0-clustersaw) — 16 sawtooths, geometric spread + - [B-1: PwCluster](#b-1-pwcluster) — 6 pulse waves, adjustable PW + - [B-2: CrCluster2](#b-2-crcluster2) — 6 sines, single FM modulator + - [B-3: SineFMcluster](#b-3-sinefmcluster) — 6 triangles, independent sub-FM + - [B-4: TriFMcluster](#b-4-trifmcluster) — 6 triangles, ultra-slow FM + - [B-5: PrimeCluster](#b-5-primecluster) — 16 oscillators at prime frequencies + - [B-6: PrimeCnoise](#b-6-primecnoise) — Primes, wider range variant + - [B-7: FibonacciCluster](#b-7-fibonaccicluster) — 16 sawtooths, Fibonacci spacing + - [B-8: PartialCluster](#b-8-partialcluster) — 16 sawtooths, multiplicative spread + - [B-9: PhasingCluster](#b-9-phasingcluster) — 16 squares with 16 independent LFOs +- [Bank C: Harsh & Wild](#bank-c-harsh--wild) + - [C-0: BasuraTotal](#c-0-basuratotal) — LFSR-triggered oscillator + reverb + - [C-1: Atari](#c-1-atari) — 8-bit cross-modulation + - [C-2: WalkingFilomena](#c-2-walkingfilomena) — 16 random-walk oscillators + - [C-3: S_H](#c-3-s_h-sample--hold) — Sample & hold + reverb + - [C-4: ArrayOnTheRocks](#c-4-arrayontherocks) — Randomized wavetable FM + - [C-5: ExistenceIsPain](#c-5-existenceispain) — 4 LFO-swept bandpass filters + - [C-6: WhoKnows](#c-6-whoknows) — Fast LFO bandpass filters + - [C-7: SatanWorkout](#c-7-satanworkout) — Pink noise FM + reverb + - [C-8: Rwalk_BitCrushPW](#c-8-rwalk_bitcrushpw) — 9 random walks, 1-bit crush + - [C-9: Rwalk_LFree](#c-9-rwalk_lfree) — 4 PWM random walks + reverb +- [Bank D: Resonant Bodies](#bank-d-resonant-bodies) + - [D-0: CombNoise](#d-0-combnoise) — 4 parallel comb filters + - [D-1: PluckCloud](#d-1-pluckcloud) — 6 Karplus-Strong voices + - [D-2: TubeResonance](#d-2-tuberesonance) — Harmonic comb filter tube + - [D-3: FormantNoise](#d-3-formantnoise) — Vowel formant filters + - [D-4: BowedMetal](#d-4-bowedmetal) — 8 metallic resonators + - [D-5: FlangeNoise](#d-5-flangenoise) — Pink noise flanger + - [D-6: NoiseBells](#d-6-noisebells) — 4 sharp bell resonators + - [D-7: NoiseHarmonics](#d-7-noiseharmonics) — Wavefolder + bandpass + - [D-8: IceRain](#d-8-icerain) — S&H droplets + reverb + - [D-9: DroneBody](#d-9-dronebody) — Cross-FM drone + wavefolder +- [Bank E: Chaos Machines](#bank-e-chaos-machines) + - [E-0: LogisticNoise](#e-0-logisticnoise) — Logistic map chaos + - [E-1: HenonDust](#e-1-henondust) — Henon attractor crackle + - [E-2: CellularSynth](#e-2-cellularsynth) — Cellular automaton + 8 oscillators + - [E-3: StochasticPulse](#e-3-stochasticpulse) — Random impulses + resonant filter + - [E-4: BitShift](#e-4-bitshift) — Two sawtooths XOR'd + - [E-5: FeedbackFM](#e-5-feedbackfm) — Self-feedback FM sine + - [E-6: RunawayFilter](#e-6-runawayfilter) — Self-oscillating SVF + - [E-7: GlitchLoop](#e-7-glitchloop) — Loop with bit degradation + - [E-8: SubHarmonic](#e-8-subharmonic) — Frequency dividers + - [E-9: DualAttractor](#e-9-dualattractor) — Coupled Lorenz oscillators + +--- + +## Bank A: Textures + +Cross-modulation, ring modulation, granular processing, and noise AM. Focused on complex modulation techniques that create rich, evolving textures. + +--- + +### A-0: RadioOhNo + +**Four square wave oscillators cross-modulated in couples, summed together.** + +Four pulse-width-modulated oscillators interconnected in feedback pairs: oscillator 1 modulates 2 and vice versa, oscillator 3 modulates 4 and vice versa. A DC source modulates all oscillators' frequency. The cross-modulation creates complex sidebands and chaotic harmonic interactions. + +| Parameter | Control | Range | Effect | +|-----------|---------|-------|--------| +| **X (k1)** | Oscillator 1 frequency | 20 – 2520 Hz | Base frequency for all 4 oscillators (each at a different ratio). Quadratic mapping for fine control at low frequencies. | +| **Y (k2)** | PWM / DC modulation | 0 – 1 | Controls DC amplitude which modulates all oscillators' frequency. Higher values create wider FM deviation and more chaotic sidebands. | + +**Sound character:** Aggressive, unstable radio-frequency-like textures. Like tuning between shortwave stations. Rich in aliasing and intermodulation products. + +--- + +### A-1: Rwalk_SineFMFlange + +**Four random walkers controlling pulse oscillators, FM'd by sines, through a flanger.** + +Four 2D random walkers move in a bounded box with random velocities. Their positions map to the frequencies of 4 pulse wave oscillators, which feed into 4 sine FM oscillators. The mixed output passes through a flanger effect. + +| Parameter | Control | Range | Effect | +|-----------|---------|-------|--------| +| **X (k1)** | FM sine frequency | 10 – 510 Hz | Base frequency of the 4 sine FM oscillators (each offset by 55–75 Hz). | +| **Y (k2)** | Flanger modulation rate | 0 – 3 Hz | LFO speed of the flanger. Adds swept comb filtering on top of the FM textures. | + +**Sound character:** Morphing, evolving FM textures with organic movement. The flanger adds spatial depth and sweeping spectral animation. No two moments are alike. Atmospheric and complex. + +--- + +### A-2: xModRingSqr + +**Cross FM between two square wave oscillators, ring modulated.** + +Two square wave oscillators in a feedback configuration: each modulates the other's frequency. Their outputs are ring modulated (multiplied) together. + +| Parameter | Control | Range | Effect | +|-----------|---------|-------|--------| +| **X (k1)** | Oscillator 1 frequency | 100 – 5100 Hz | Pitch of the first square wave. Quadratic mapping. | +| **Y (k2)** | Oscillator 2 frequency | 20 – 1020 Hz | Pitch of the second square wave. Quadratic mapping. | + +**Sound character:** Metallic, clanging ring modulation. At simple ratios (2:1, 3:2) = tonal metallic tones. At complex ratios = inharmonic metallic clatter. + +--- + +### A-3: XModRingSine + +**Cross FM between two sine oscillators, ring modulated.** + +Same topology as xModRingSqr but using sine FM oscillators. Sines produce cleaner, more bell-like results than squares. + +| Parameter | Control | Range | Effect | +|-----------|---------|-------|--------| +| **X (k1)** | Oscillator 1 frequency | 100 – 8100 Hz | Pitch of the first sine. Quadratic mapping. Wide range. | +| **Y (k2)** | Oscillator 2 frequency | 60 – 3060 Hz | Pitch of the second sine. Quadratic mapping. | + +**Sound character:** Bell-like and metallic tones. All spectral content comes from the FM and ring modulation. Good for tuned metallic percussion sounds. + +--- + +### A-4: CrossModRing + +**Four oscillators in a cross-modulation matrix with cascaded ring modulators.** + +Four oscillators (2 square, 1 sawtooth with offset, 1 square) modulate each other's frequencies. Three ring modulators in a cascaded configuration: multiply1 and multiply2 feed into multiply3. The most complex modulation topology in the module. + +| Parameter | Control | Range | Effect | +|-----------|---------|-------|--------| +| **X (k1)** | Frequency (all oscillators) | 1 – 827 Hz | Scales all 4 oscillator frequencies with individual ratios. | +| **Y (k2)** | FM depth | 2 – 10 octaves | Master frequency modulation depth. Low = subtle. High = total harmonic chaos. | + +**Sound character:** Incredibly dense sideband spectrum. From metallic drones at low FM depth to total chaos at high depth. Like a 4-operator FM synth pushed to extremes. + +--- + +### A-5: Resonoise + +**Square wave FM-modulating a sine, through a wavefolder, controlling a resonant filter on white noise.** + +A modulated square wave drives a sine FM oscillator. The sine passes through a wavefolder, then feeds into a state-variable filter as the frequency control signal. White noise is the audio input to the filter (resonance=3). + +| Parameter | Control | Range | Effect | +|-----------|---------|-------|--------| +| **X (k1)** | Both oscillator frequencies | 20 – 10020 Hz | Controls the modulation rate of the filter cutoff. | +| **Y (k2)** | Wavefold amount | 0.03 – 0.23 | DC bias into the wavefolder. More folding = more complex filter modulation pattern. | + +**Sound character:** Resonant noise with animated filter modulation. Like white noise through an auto-wah driven by a complex LFO. Organic and vocal. + +--- + +### A-6: GrainGlitch + +**Square wave through a granular cell, output XOR'd with the input.** + +A square wave feeds into a granular pitch-shifting processor with feedback. The original square wave and the granular output are combined using XOR digital logic. + +| Parameter | Control | Range | Effect | +|-----------|---------|-------|--------| +| **X (k1)** | Square wave frequency | 500 – 5500 Hz | Base frequency of the source oscillator. | +| **Y (k2)** | Grain size + speed | 25–100 ms / 0.125–8x | Grain size (pitch shift window) and playback speed ratio. | + +**Sound character:** Glitchy digital artifacts from XOR combination. Harsh, broken, digital — like a CD skipping. + +--- + +### A-7: GrainGlitchII + +**Square wave through a granular cell, amplified.** + +Similar to GrainGlitch but without XOR. Granular output amplified 32000x to bring up the quiet signal. + +| Parameter | Control | Range | Effect | +|-----------|---------|-------|--------| +| **X (k1)** | Square wave frequency | 500 – 5500 Hz | Base frequency of the source oscillator. | +| **Y (k2)** | Grain size + speed | 25–100 ms / 0.125–8x | Same mapping as GrainGlitch. | + +**Sound character:** Cleaner granular texture than GrainGlitch. More transparent and "musical" than the XOR version. + +--- + +### A-8: GrainGlitchIII + +**Sawtooth wave through a granular cell.** + +Similar to GrainGlitchII but using a sawtooth waveform. Richer harmonic spectrum provides more material for the granular processor. + +| Parameter | Control | Range | Effect | +|-----------|---------|-------|--------| +| **X (k1)** | Sawtooth frequency | 400 – 5500 Hz | Base frequency. | +| **Y (k2)** | Grain size + speed | 25–80 ms / 0.125–8x | Slightly narrower grain range than I/II. | + +**Sound character:** The richest granular variant. Textures from buzzy granular drones to scattered metallic fragments. + +--- + +### A-9: Basurilla + +**White noise amplitude-modulated by 3 independent pulse wave LFOs.** + +Three parallel channels: white noise is ring-modulated by 3 pulse wave oscillators at different rates and pulse widths. The pulse waves gate the noise in complex rhythmic patterns. + +| Parameter | Control | Range | Effect | +|-----------|---------|-------|--------| +| **X (k1)** | LFO frequencies | 0.1 – 110 Hz | Controls all 3 pulse LFOs. Low = slow gates. High = audio-rate AM. | +| **Y (k2)** | Pulse widths / noise level | PW + inverse amplitude | Pulse width of the 3 LFOs and inversely controls noise amplitude. | + +**Sound character:** Chaotic, granular-like texture from noise gated by 3 independent pulse trains. "Basurilla" = "little garbage" in Spanish — beautifully organized trash. + +--- + +## Bank B: HH Clusters + +Cluster/additive synthesis using 6–16 oscillators at mathematically related frequency ratios. Dense, shimmering tonal textures. + +--- + +### B-0: ClusterSaw + +**16 sawtooth oscillators with adjustable geometric frequency spread.** + +Sixteen sawtooths tuned in geometric progression. Each frequency is the previous one multiplied by a constant factor. + +| Parameter | Control | Range | Effect | +|-----------|---------|-------|--------| +| **X (k1)** | Base frequency | 20 – 1020 Hz | Fundamental frequency. | +| **Y (k2)** | Spread factor | 1.01 – 1.91 | Ratio between adjacent oscillators. Low = beating unison. High = wide harmonic spread. | + +**Sound character:** Shimmering, buzzing mass of sawtooths. The quintessential "cluster" sound. 16 voices create an extremely rich spectral texture. + +--- + +### B-1: PwCluster + +**6 detuned pulse waveforms with adjustable pulse width.** + +Six pulse waves at fixed detuned ratios (1.227, 1.24, 1.17, 1.2, 1.3). DC-controlled pulse width. + +| Parameter | Control | Range | Effect | +|-----------|---------|-------|--------| +| **X (k1)** | Base frequency | 40 – 8040 Hz | Widest range of any cluster plugin. | +| **Y (k2)** | Pulse width | Wide – Narrow (inverted) | Low Y = full, warm. High Y = thin, nasal. | + +**Sound character:** Chorused pulse waves. At wide PW: organ-like. At narrow PW: reedy, nasal. Constant beating from non-harmonic detuning. + +--- + +### B-2: CrCluster2 + +**6 detuned sine waves with low-frequency FM from a single modulator.** + +Six sines, all FM'd by one sine at 2.7x the base frequency. + +| Parameter | Control | Range | Effect | +|-----------|---------|-------|--------| +| **X (k1)** | Base frequency | 40 – 8040 Hz | Cluster fundamental. | +| **Y (k2)** | FM index | 0 – 1.0 | Low = pure sine cluster. High = bright FM harmonics. | + +**Sound character:** Clean sine cluster that becomes progressively FM-modulated. Warm to bright. Spectrally coherent. + +--- + +### B-3: SineFMcluster + +**6 triangle waves, each independently FM'd by its own sine modulator (subharmonic ratio 0.333).** + +| Parameter | Control | Range | Effect | +|-----------|---------|-------|--------| +| **X (k1)** | Base frequency | 300 – 8300 Hz | Higher starting frequency. | +| **Y (k2)** | FM index | 0.1 – 1.0 | Subharmonic FM adds content below carriers. | + +**Sound character:** Warm, soft FM cluster. Triangle carriers + subharmonic FM = "analog" feeling warmth and depth. + +--- + +### B-4: TriFMcluster + +**6 triangle waves, each independently FM'd at very slow ratio (0.07).** + +Same architecture as SineFMcluster but with 1/14th FM ratio. Creates phasing/chorus rather than FM timbral change. + +| Parameter | Control | Range | Effect | +|-----------|---------|-------|--------| +| **X (k1)** | Base frequency | 300 – 8300 Hz | Same range as SineFMcluster. | +| **Y (k2)** | FM index | 0.1 – 1.0 | Creates slow drifting detuning, not bright harmonics. | + +**Sound character:** Lush, animated ensemble effect. Like 6 slightly out-of-tune instruments. Very different from SineFMcluster despite identical architecture. + +--- + +### B-5: PrimeCluster + +**16 oscillators tuned to prime number frequencies, noise-modulated.** + +Sixteen variable-triangle oscillators at primes (53, 127, 199... 1523 Hz), all scaled by a common factor. White noise FM adds animation. + +| Parameter | Control | Range | Effect | +|-----------|---------|-------|--------| +| **X (k1)** | Pitch multiplier | 0.5 – 10.5 | Scales all 16 primes. Linear mapping. | +| **Y (k2)** | Noise modulation | 0 – 0.2 | Noise FM amount. Low = clean. High = tremolo-like. | + +**Gain:** 0.8 (reduced to prevent clipping). + +**Sound character:** Inharmonic, bell-like chord. No common harmonics — a unique shimmering metallic texture. + +--- + +### B-6: PrimeCnoise + +**16 triangle oscillators at prime frequencies (wider range variant).** + +Nearly identical to PrimeCluster but with quadratic pitch mapping (k1^2 x 12) for wider range. + +| Parameter | Control | Range | Effect | +|-----------|---------|-------|--------| +| **X (k1)** | Pitch multiplier | 0.5 – 12.5 | Quadratic mapping — more extreme range. | +| **Y (k2)** | Noise modulation | 0 – 0.2 | Same as PrimeCluster. | + +**Gain:** 0.8 + +**Sound character:** Same prime character, different response to knob gestures. More exponential/extreme than PrimeCluster. + +--- + +### B-7: FibonacciCluster + +**16 sawtooth oscillators at Fibonacci-series frequency spacing.** + +Frequencies follow `f(n) = f(n-1) + f(n-2) x spread`. Noise FM adds animation. + +| Parameter | Control | Range | Effect | +|-----------|---------|-------|--------| +| **X (k1)** | Base frequency | 50 – 1050 Hz | Fundamental pitch. | +| **Y (k2)** | Spread factor | 0.1 – 0.6 | How fast frequencies diverge. Near 0.618 = golden ratio intervals. | + +**Sound character:** Nature's favorite ratio. At spread near golden ratio, intervals feel "naturally balanced." Unique organic quality. + +--- + +### B-8: PartialCluster + +**16 sawtooth oscillators with multiplicative harmonic spacing.** + +Each frequency is the previous multiplied by a spread factor. + +| Parameter | Control | Range | Effect | +|-----------|---------|-------|--------| +| **X (k1)** | Base frequency | 50 – 1050 Hz | Fundamental. | +| **Y (k2)** | Harmonic spread | 1.01 – 2.11 | At 2.0 = octave spacing. Below = dense. Above = stretched/metallic. | + +**Sound character:** The most "tuneable" cluster. Morph from dense unison to harmonic series to metallic bells by sweeping Y. + +--- + +### B-9: PhasingCluster + +**16 square waves with individual LFO phase modulation.** + +Each oscillator has its own triangle LFO at a unique rate: 10, 11, 15, 1, 1, 3, 17, 14, 0.11, 5, 2, 7, 1, 0.1, 0.7, 0.5 Hz. + +| Parameter | Control | Range | Effect | +|-----------|---------|-------|--------| +| **X (k1)** | Carrier frequency | 30 – 5030 Hz | Base frequency for all 16 squares. | +| **Y (k2)** | Spread | 1.0 – 1.5 | Spreads carrier frequencies slightly. | + +**Sound character:** Massive phasing. 16 oscillators drifting at their own rates — constantly evolving, never-repeating interference patterns. Glacial slow LFOs (0.1 Hz) + shimmer (17 Hz). + +--- + +## Bank C: Harsh & Wild + +Extreme processing: bitcrushing, random walks, chaotic oscillators, reverb abuse. The most experimental and aggressive bank. + +--- + +### C-0: BasuraTotal + +**"Bent" LFSR driving an oscillator with reverb.** + +A Galois LFSR generates pseudo-random timing events that trigger a waveform oscillator. Output through Freeverb. + +| Parameter | Control | Range | Effect | +|-----------|---------|-------|--------| +| **X (k1)** | Oscillator frequency | 200 – 5200 Hz | Pitch of triggered waveform. | +| **Y (k2)** | Event rate | Slow – Fast | Timing between LFSR-triggered events. | + +**Sound character:** Sporadic bursts with reverb tails. "BasuraTotal" = "Total Garbage" — chaotic, messy, and beautiful. + +--- + +### C-1: Atari + +**Two square waves with PWM/FM cross-modulation.** + +First oscillator does PWM on the second, second does FM on the first. + +| Parameter | Control | Range | Effect | +|-----------|---------|-------|--------| +| **X (k1)** | Wave 1 frequency | 10 – 60 Hz | Sub-bass territory. | +| **Y (k2)** | Wave 2 freq + FM depth | 10–210 Hz / 3–11 oct | Higher pitch AND more extreme modulation. | + +**Sound character:** Classic 8-bit Atari/chiptune. Buzzy, aggressive, nostalgic. + +--- + +### C-2: WalkingFilomena + +**16 random walkers controlling pulse oscillator frequencies.** + +Sixteen pulse oscillators with independent 2D random walkers in a bounded box. + +| Parameter | Control | Range | Effect | +|-----------|---------|-------|--------| +| **X (k1)** | Random walk box size | 200 – 1800 Hz | Frequency range of all 16 oscillators. | +| **Y (k2)** | Pulse width | 0.1 – 0.9 | Thin = bright/nasal. Wide = warm/full. | + +**Sound character:** Shimmering, constantly evolving polyphonic texture. 16 oscillators wandering in pitch space. Organic and alive. + +--- + +### C-3: S_H (Sample & Hold) + +**Sample-and-hold noise with dirty reverb.** + +| Parameter | Control | Range | Effect | +|-----------|---------|-------|--------| +| **X (k1)** | S&H rate | 15 – 5015 Hz | Slow = stepped tones. Fast = granular noise. | +| **Y (k2)** | Reverb mix | Dry – Wet | Dry = stochastic clicks. Wet = ambient wash. | + +**Sound character:** Classic S&H randomness with spatial depth from reverb. + +--- + +### C-4: ArrayOnTheRocks + +**FM synthesis with a randomized 256-point wavetable.** + +A 500 Hz sine modulates an arbitrary waveform with randomly corrupted table values. + +| Parameter | Control | Range | Effect | +|-----------|---------|-------|--------| +| **X (k1)** | Wavetable oscillator freq | 10 – 10010 Hz | Playback speed. | +| **Y (k2)** | FM modulator amplitude | 0 – 1.0 | Low = clean wavetable. High = rich FM sidebands. | + +**Sound character:** Unpredictable timbral textures from the corrupted wavetable. Different from standard FM because the carrier waveform itself is partially random. + +--- + +### C-5: ExistenceIsPain + +**Sample-and-hold noise through 4 bandpass filters modulated by 4 LFOs.** + +S&H source into 4 parallel SVF bandpass filters with independent triangle LFOs at 11, 70, 23, 0.01 Hz. Resonance=5. + +| Parameter | Control | Range | Effect | +|-----------|---------|-------|--------| +| **X (k1)** | S&H noise frequency | 50 – 5050 Hz | Base texture density. | +| **Y (k2)** | Filter sweep range | 0.3 – 3.3 octaves | Narrow = focused. Wide = dramatic animation. | + +**Sound character:** Slowly breathing, organic multiband filtering. The 0.01 Hz LFO creates glacial changes, 70 Hz adds shimmer. Deep, meditative, slightly ominous. + +--- + +### C-6: WhoKnows + +**Pulse wave through 4 bandpass filters with fast LFO modulation.** + +Similar to ExistenceIsPain but with 5 Hz pulse source and much faster LFOs (21, 70, 90, 77 Hz). Resonance=7. + +| Parameter | Control | Range | Effect | +|-----------|---------|-------|--------| +| **X (k1)** | Pulse frequency | 15 – 515 Hz | Source frequency. | +| **Y (k2)** | Filter sweep range | 0.3 – 6.3 octaves | At high settings, filters sweep wildly. | + +**Sound character:** Dramatic, rapidly animated filter textures. Audio-rate LFOs create sideband-like effects. Aggressive and chaotic. + +--- + +### C-7: SatanWorkout + +**Pink noise FM-ing a PWM oscillator, through reverb.** + +Pink noise modulates a PWM oscillator. Freeverb with negative damping (-5). + +| Parameter | Control | Range | Effect | +|-----------|---------|-------|--------| +| **X (k1)** | PWM frequency | 8 – 6008 Hz | "Pitch" of noise modulation. | +| **Y (k2)** | Reverb room size | 0.001 – 4.0 | Beyond 1.0 = self-exciting reverb feedback. | + +**Sound character:** Raw organic noise with reverb. At high Y the reverb self-excites. Relentless intensity. + +--- + +### C-8: Rwalk_BitCrushPW + +**9 random-walk pulse oscillators, bitcrushed to 1 bit, with reverb.** + +Nine pulse oscillators with 2D random walkers. Mixed, 1-bit crushed, parallel reverb path. + +| Parameter | Control | Range | Effect | +|-----------|---------|-------|--------| +| **X (k1)** | Pulse width | 0.2 – 0.75 | Timbre control alongside random walk frequencies. | +| **Y (k2)** | Reverb room size | 0 – 4.0 | High = self-exciting reverb. | + +**Sound character:** Extreme digital destruction. Dense, distorted digital texture with organic pitch movement from random walks. Lo-fi at its most extreme. + +--- + +### C-9: Rwalk_LFree + +**4 PWM oscillators with random-walk frequencies, through reverb.** + +Four PWM oscillators with independent random walkers. Clean Freeverb (no bitcrushing). + +| Parameter | Control | Range | Effect | +|-----------|---------|-------|--------| +| **X (k1)** | Random walk boundary | 50 – 550 Hz | Frequency space size. | +| **Y (k2)** | Reverb room size | 0 – 1.0 | Conservative range, clean reverb. | + +**Sound character:** Spacious, clean random pulse textures. Warm timbre, gentle pitch drift, dreamy ambient reverb. The gentlest of the random walk family. + +--- + +## Bank D: Resonant Bodies + +Delay-based resonance, physical modeling, and spectral shaping. What happens when noise passes through resonant structures: comb filters, waveguides, feedback networks, and high-Q resonators. + +--- + +### D-0: CombNoise + +**White noise through 4 parallel comb filters.** + +A comb filter is a short delay line with feedback — it reinforces frequencies at the delay time and its harmonics. Four combs at ratios 1.0 : 0.7 : 0.5 : 0.35 create a rich, multi-pitched metallic tone. + +| Parameter | Control | Range | Effect | +|-----------|---------|-------|--------| +| **X (k1)** | Resonant pitch | 40 – 5000 Hz | Fundamental frequency of all 4 comb filters. | +| **Y (k2)** | Feedback | 0 – 95% | Resonance sustain. Low = colored noise. High = clearly pitched ringing. | + +**Sound character:** Like blowing across a metal pipe. The 4 overlapping combs create a rich harmonic spectrum. + +--- + +### D-1: PluckCloud + +**6 Karplus-Strong plucked string voices with random retriggering.** + +Noise burst into delay line with LP filter in feedback loop. Voices retrigger randomly (~2% per cycle). Detuned at ratios 1.0, 1.005, 0.995, 1.01, 0.99, 1.015. + +| Parameter | Control | Range | Effect | +|-----------|---------|-------|--------| +| **X (k1)** | Pitch center | 60 – 3000 Hz | Base pitch for all 6 voices. | +| **Y (k2)** | Brightness / decay | Dull – Bright | Low = muted string, fast decay. High = bright ring, long sustain. | + +**Sound character:** Rain on a kalimba, or a prepared piano played by dice. Sparse, organic, constantly evolving. + +--- + +### D-2: TubeResonance + +**Noise excitation through 4 harmonic comb filters simulating a resonant tube.** + +Four combs at 1x, 2x, 3x, 4x fundamental. Higher harmonics decay faster (feedback scaled by 1/harmonic). + +| Parameter | Control | Range | Effect | +|-----------|---------|-------|--------| +| **X (k1)** | Tube length | 40 – 1000 Hz | Fundamental pitch. Low = long tube. High = short pipe. | +| **Y (k2)** | Excitation | Self-resonance – Breath | Low = singing bowl drone. High = breathy wind-through-pipe. | + +**Sound character:** Hollow drone to breathy pipe texture. Harmonic series is clearly audible — sounds like a real resonant object. + +--- + +### D-3: FormantNoise + +**White noise through 3 bandpass filters at vowel formant frequencies.** + +Interpolates between 5 vowel shapes (A, E, I, O, U) using 3 SVF bandpass filters. + +| Parameter | Control | Range | Effect | +|-----------|---------|-------|--------| +| **X (k1)** | Vowel morph | A → E → I → O → U | Smooth interpolation between vowel formants. | +| **Y (k2)** | Resonance | Q 1.0 – 5.0 | Wide/breathy to sharp/nasal vowels. | + +**Formant table (Hz):** + +| Vowel | F1 | F2 | F3 | +|-------|-----|------|------| +| A | 730 | 1090 | 2440 | +| E | 660 | 1720 | 2410 | +| I | 270 | 2290 | 3010 | +| O | 570 | 840 | 2410 | +| U | 300 | 870 | 2240 | + +**Sound character:** Robotic choir whispering vowels. Sweep X for ghostly "aaah → eeeh → iiih → oooh → uuuh." + +--- + +### D-4: BowedMetal + +**Noise exciting 8 high-Q resonators at dense metallic frequency ratios.** + +Eight 2-pole resonators (Q ~300–500) at plate vibration mode ratios. Denser than NoiseBells = more reverberant. + +| Parameter | Control | Range | Effect | +|-----------|---------|-------|--------| +| **X (k1)** | Fundamental pitch | 30 – 2030 Hz | All 8 resonators scale proportionally. | +| **Y (k2)** | Struck → Bowed | Short ring – Infinite sustain | Low = cymbal hit. High = bowed singing bowl. | + +**Resonator ratios:** 1.000, 1.183, 1.506, 1.741, 2.098, 2.534, 2.917, 3.483 + +**Sound character:** Dense metallic reverberance. Bowed cymbal or gong. More diffuse than NoiseBells. + +--- + +### D-5: FlangeNoise + +**Pink noise through a flanger effect.** + +Swept comb filter on noise. Classic "jet engine whoosh." + +| Parameter | Control | Range | Effect | +|-----------|---------|-------|--------| +| **X (k1)** | Flange rate | 0.05 – 5 Hz | Slow sweep to fast warble. | +| **Y (k2)** | Flange depth | Subtle – Deep | Phase-like to dramatic comb sweep. | + +**Sound character:** Jet plane flyover, ocean through metal tube, wind in rotating vent. + +--- + +### D-6: NoiseBells + +**White noise exciting 4 sharp 2-pole resonators at bell-like inharmonic ratios.** + +Extremely high Q (~625) creates laser-sharp peaks. Clear ringing tones from noise. + +| Parameter | Control | Range | Effect | +|-----------|---------|-------|--------| +| **X (k1)** | Bell pitch | 80 – 4080 Hz | Fundamental. All 4 resonators scale. | +| **Y (k2)** | Inharmonicity | Chime → Gong | Near-harmonic (wind chime) to stretched (gamelan). | + +**Resonator ratios (vary with Y):** + +| Resonator | Y=0 (chime) | Y=1 (gong) | +|-----------|-------------|------------| +| 1 | 1.00x | 1.00x | +| 2 | 1.59x | 2.48x | +| 3 | 2.33x | 4.33x | +| 4 | 3.14x | 6.35x | + +**Sound character:** Clear bell tones from noise. Visible on spectrum analyzer as 4 needle-sharp peaks. + +--- + +### D-7: NoiseHarmonics + +**White noise through a wavefolder, then resonant bandpass filter.** + +Wavefolder creates harmonics from noise (DC bias controlled). SVF filter (Q=3) selects a frequency band. + +| Parameter | Control | Range | Effect | +|-----------|---------|-------|--------| +| **X (k1)** | Wavefold intensity | Gentle – Heavy | More folding = denser harmonics. | +| **Y (k2)** | Filter frequency | 100 – 8100 Hz | Selects which band is heard. | + +**Sound character:** Aggressive buzzing. Like an angry bee swarm at a specific pitch. Grittier than plain filtered noise. + +--- + +### D-8: IceRain + +**Sparse sample-and-hold events with long reverb tails.** + +Random stepped values at controllable rate into Freeverb (high damping). + +| Parameter | Control | Range | Effect | +|-----------|---------|-------|--------| +| **X (k1)** | Droplet density | 0.5 – 200 Hz | Sparse plinks to dense rain. | +| **Y (k2)** | Reverb size | Small – Vast | Dry/close to cathedral-like. | + +**Sound character:** Crystalline drops in a cave. Sparse plinks with shimmering tails. Very spatial and ambient. + +--- + +### D-9: DroneBody + +**Two cross-modulated FM sines through a wavefolder.** + +Slightly detuned sines with block-delayed cross-feedback FM. Wavefolder adds harmonics. + +| Parameter | Control | Range | Effect | +|-----------|---------|-------|--------| +| **X (k1)** | Drone pitch | 20 – 520 Hz | Fundamental of both sines. | +| **Y (k2)** | Detune + Fold | Clean – Rich | Y=0: clean hum. Y=1: beating + growling overtones. | + +**Sound character:** Deep meditative drone. Tibetan singing bowl meets power transformer. Good for sustained bass. + +--- + +## Bank E: Chaos Machines + +Deterministic chaos, algorithmic processes, and digital manipulation. Mathematical systems that hover between order and noise. + +--- + +### E-0: LogisticNoise + +**Logistic map chaotic oscillator: `x(n+1) = r * x(n) * (1 - x(n))`** + +| Parameter | Control | Range | Effect | +|-----------|---------|-------|--------| +| **X (k1)** | Chaos parameter r | 3.5 – 4.0 | 3.5=periodic. 3.57=chaos onset. 3.83=period-3 window. 4.0=full chaos. | +| **Y (k2)** | Output rate | Slow – Fast | Held samples (buzzy tone) to per-sample (noise-like at r=4). | + +**Sound character:** Mathematical structure dissolving into chaos. Sweep r to hear windows of order breaking into noise. The period-3 window at r~3.83 is particularly striking. + +--- + +### E-1: HenonDust + +**Henon attractor: `x' = 1 - a*x^2 + y, y' = b*x`** + +| Parameter | Control | Range | Effect | +|-----------|---------|-------|--------| +| **X (k1)** | Parameter a | 1.15 – 1.40 | Low=periodic. ~1.2=period-doubling. 1.4=full chaos. | +| **Y (k2)** | Parameter b | 0.15 – 0.35 | Attractor shape and crackle density. | + +**Sound character:** Alien vinyl surface noise. Almost-repeating patterns that never quite repeat. Living, deterministic crackle. + +--- + +### E-2: CellularSynth + +**1D cellular automaton (32 cells) controlling 8 sawtooth oscillators at harmonics of 55 Hz.** + +| Parameter | Control | Range | Effect | +|-----------|---------|-------|--------| +| **X (k1)** | CA rule | 0 – 255 | Rule 30=chaotic. Rule 90=fractal. Rule 110=complex. | +| **Y (k2)** | Evolution speed | Glacial – Rapid | How fast the CA evolves. | + +**Sound character:** Alien music box that rewrites its own score. Some rules = steady drone, others = constant mutation. + +--- + +### E-3: StochasticPulse + +**Poisson-distributed impulses through a resonant bandpass filter (Q=4.5).** + +| Parameter | Control | Range | Effect | +|-----------|---------|-------|--------| +| **X (k1)** | Impulse density | 5 – 505 /sec | Sparse pings to dense crackling. | +| **Y (k2)** | Filter frequency | 80 – 8080 Hz | Pitch of the resonant ring. | + +**Sound character:** Geiger counter meets resonant drum. Random metallic pings with clear musical pitch. + +--- + +### E-4: BitShift + +**Two sawtooth oscillators combined via XOR digital logic.** + +| Parameter | Control | Range | Effect | +|-----------|---------|-------|--------| +| **X (k1)** | Oscillator 1 freq | 20 – 5020 Hz | First sawtooth. | +| **Y (k2)** | Oscillator 2 ratio | 1:1 – 1:8 | Simple ratios = structured. Irrational = maximum complexity. | + +**Sound character:** Broken NES / ZX Spectrum. Hard digital edges, rapidly shifting sum/difference tones. Aggressive 8-bit. + +--- + +### E-5: FeedbackFM + +**Single sine with sample-delayed self-feedback into its own phase.** + +| Parameter | Control | Range | Effect | +|-----------|---------|-------|--------| +| **X (k1)** | Carrier frequency | 20 – 5020 Hz | Pitch. | +| **Y (k2)** | Feedback | 0 – 2.5 rad | 0=sine. ~0.8=bright. ~1.5=metallic. ~2.0=gritty. 2.5=noise. | + +**Sound character:** The full timbral spectrum in one knob. Classic DX7 operator technique. Sweet spot at Y~1.0 = vocal/nasal quality. + +--- + +### E-6: RunawayFilter + +**White noise through a self-oscillating SVF (Q ~4.5–4.99).** + +| Parameter | Control | Range | Effect | +|-----------|---------|-------|--------| +| **X (k1)** | Filter frequency | 30 – 10030 Hz | Pitched self-oscillation tone. | +| **Y (k2)** | Noise injection | Whistle – Noise | Y=0: clean sine whistle. Y=1: resonant noise. Transition zone = sweet spot. | + +**Sound character:** Pitched whistle fighting noise. Like tuning a shortwave radio. Fragile tone that breaks and reforms. + +--- + +### E-7: GlitchLoop + +**Noise captured into a loop with progressive bit-depth degradation.** + +| Parameter | Control | Range | Effect | +|-----------|---------|-------|--------| +| **X (k1)** | Loop length | 10 – 200 ms | Short = buzz. Long = stutter. | +| **Y (k2)** | Degradation rate | Stable – Rapid | How fast the loop crumbles. Refills when bit depth hits 1. | + +**Sound character:** Digital decay. Loop captures, degrades, collapses to 1-bit, refreshes. Rhythmic destruction cycle. + +--- + +### E-8: SubHarmonic + +**Square wave with frequency dividers at /2, /3, /5, /7.** + +| Parameter | Control | Range | Effect | +|-----------|---------|-------|--------| +| **X (k1)** | Fundamental frequency | 100 – 4100 Hz | Source square wave pitch. | +| **Y (k2)** | Subharmonic mix | /2 only → All four | Progressive: Y=0: octave below. Y=0.33: +fifth below. Y=0.66: +major 3rd down. Y=1: +minor 7th down. | + +**Subharmonic intervals at 440 Hz:** /2=220 Hz, /3=~147 Hz, /5=88 Hz, /7=~63 Hz + +**Sound character:** Deep rumbling sub-bass. Earth-shaking low end at full Y with low fundamental. Tectonic. + +--- + +### E-9: DualAttractor + +**Two coupled Lorenz attractors driving two sine oscillators.** + +Lorenz system: `dx/dt = sigma(y-x)`, `dy/dt = x(rho-z)-y`, `dz/dt = xy-beta*z`. sigma=10, rho=28, beta=8/3. + +| Parameter | Control | Range | Effect | +|-----------|---------|-------|--------| +| **X (k1)** | Coupling strength | 0 – 5 | 0=independent chaos. 5=tones lock/unlock in bursts. | +| **Y (k2)** | Base frequency | 30 – 2030 Hz | Center pitch the attractors orbit. | + +**Sound character:** Two drunk musicians trying to play in unison. Moments of harmony interrupted by chaos. Organic, alive, never repeating. From 06cbb8fa895fd0e22a3f275bf5fc6a84d586a4a9 Mon Sep 17 00:00:00 2001 From: Pablo Alcantar Date: Sat, 11 Apr 2026 21:57:16 +0200 Subject: [PATCH 04/14] Add Bank F "Stochastic": 10 pulse, noise, and random texture plugins - PulseWander: smooth random walk pulse patterns - TwinPulse: two correlated random walks - QuantPulse: quantized random (1-6 bit depth) - ShapedPulse: shaped probability distribution (uniform/tri/gaussian) - ShiftPulse: 4-stage shift register pulse sequences - MetallicNoise: 6 inharmonic square oscillators (cymbal technique) - NoiseSlew: white noise with adjustable LP slew - NoiseBurst: sporadic noise bursts with envelope - LFSRNoise: 16-bit LFSR with selectable tap configurations - DualPulse: two S&H generators at independent rates Co-Authored-By: Claude Opus 4.6 (1M context) --- NOISE_PLETHORA_PLUGIN_GUIDE.html | 319 +++++++++++++++++- NOISE_PLETHORA_PLUGIN_GUIDE.md | 176 +++++++++- src/noise-plethora/plugins/Banks.cpp | 20 +- src/noise-plethora/plugins/Banks.hpp | 2 +- src/noise-plethora/plugins/Banks_Def.hpp | 15 +- src/noise-plethora/plugins/P_DualPulse.hpp | 84 +++++ src/noise-plethora/plugins/P_LFSRNoise.hpp | 85 +++++ .../plugins/P_MetallicNoise.hpp | 87 +++++ src/noise-plethora/plugins/P_NoiseBurst.hpp | 80 +++++ src/noise-plethora/plugins/P_NoiseSlew.hpp | 71 ++++ src/noise-plethora/plugins/P_PulseWander.hpp | 82 +++++ src/noise-plethora/plugins/P_QuantPulse.hpp | 83 +++++ src/noise-plethora/plugins/P_ShapedPulse.hpp | 97 ++++++ src/noise-plethora/plugins/P_ShiftPulse.hpp | 102 ++++++ src/noise-plethora/plugins/P_TwinPulse.hpp | 101 ++++++ 15 files changed, 1389 insertions(+), 15 deletions(-) create mode 100644 src/noise-plethora/plugins/P_DualPulse.hpp create mode 100644 src/noise-plethora/plugins/P_LFSRNoise.hpp create mode 100644 src/noise-plethora/plugins/P_MetallicNoise.hpp create mode 100644 src/noise-plethora/plugins/P_NoiseBurst.hpp create mode 100644 src/noise-plethora/plugins/P_NoiseSlew.hpp create mode 100644 src/noise-plethora/plugins/P_PulseWander.hpp create mode 100644 src/noise-plethora/plugins/P_QuantPulse.hpp create mode 100644 src/noise-plethora/plugins/P_ShapedPulse.hpp create mode 100644 src/noise-plethora/plugins/P_ShiftPulse.hpp create mode 100644 src/noise-plethora/plugins/P_TwinPulse.hpp diff --git a/NOISE_PLETHORA_PLUGIN_GUIDE.html b/NOISE_PLETHORA_PLUGIN_GUIDE.html index 5beedbb..fca4b0d 100644 --- a/NOISE_PLETHORA_PLUGIN_GUIDE.html +++ b/NOISE_PLETHORA_PLUGIN_GUIDE.html @@ -30,10 +30,10 @@

Noise Plethora — Complete Plugin Guide

-

Befaco Noise Plethora v1.5 + Banks D & E Extension

+

Befaco Noise Plethora v1.5 + Banks D, E & F Extension

About This Guide

The Noise Plethora is a Eurorack noise workstation with 3 digital sound generators (A, B, and C), each followed by an analog multimode filter. Generators A and B run interchangeable algorithms organized in banks of 10. Each algorithm has two parameters controlled by the X and Y knobs (and their corresponding CV inputs, 0–10Vpp).

-

This guide documents all 50 algorithms across 5 banks:

+

This guide documents all 60 algorithms across 6 banks:

@@ -74,9 +74,15 @@

About This Guide

+ + + + + +
0–9 Deterministic chaos, algorithmic processes, digital manipulation
FStochastic0–9Random pulses, metallic noise, LFSR sequences, noise textures
-

Banks A–C are the original Befaco firmware. Banks D–E are community extensions.

+

Banks A–C are the original Befaco firmware. Banks D–F are community extensions.

Table of Contents

Bank A: Textures

@@ -1669,7 +1686,301 @@

E-9: DualAttractor

Sound character: Two drunk musicians trying to play in unison. Moments of harmony interrupted by chaos. Organic, alive, never repeating.

+
+

Bank F: Stochastic

+

Random processes generating pulses, transients, and noise textures. The pulse-based algorithms (F-0 through F-4) exploit the Noise Plethora's internal DC blocker to transform random stepped values into unique transient/pulse shapes — a character exclusive to this module's architecture.

+
+

F-0: PulseWander

+

Smooth random walk generating organic pulse patterns.

+

A random target value is chosen periodically, and a one-pole LP filter smoothly tracks it. The module's DC blocker transforms held values into distinctive pulse shapes with natural attack/decay envelopes.

+ + + + + + + + + + + + + + + + + + + + + + + +
ParameterControlRangeEffect
X (k1)Rate5 – 400 HzHow often a new random target is chosen. Low = sparse, isolated pulses. High = dense, overlapping transients.
Y (k2)SmoothnessInstant – Smoothk2=0: instant jumps (sharp S&H pulses). k2=1: smooth glide between targets (softer, rounder transients). The LP filter alpha auto-scales with rate.
+

Sound character: Organic, irregular pulse train. Each pulse has a unique amplitude from the random walk. The smoothness control morphs from sharp clicks to rounded bumps. Unlike a regular clock, the randomness creates a "breathing" quality.

+
+

F-1: TwinPulse

+

Two random walks with controllable correlation creating crossed pulse patterns.

+

Two independent random walk generators running at the same rate. The correlation control blends the second walk toward the first, creating patterns that range from fully independent (complex interference) to identical (simple doubled pulse).

+ + + + + + + + + + + + + + + + + + + + + + + +
ParameterControlRangeEffect
X (k1)Rate5 – 400 HzSpeed of both random walks.
Y (k2)CorrelationIndependent – Identical0 = two completely unrelated pulse streams (complex polyrhythmic interference). 1 = both outputs identical (single pulse stream, louder). Sweet spot around 0.3–0.7 where patterns partially align.
+

Sound character: Two overlapping pulse patterns. At low correlation, a complex, polyrhythmic texture where pulses sometimes align and sometimes don't. At high correlation, they merge into a single stream. The interplay creates a rhythmic quality that pure randomness lacks.

+
+

F-2: QuantPulse

+

Random values quantized to N bits, creating stepped pulse patterns.

+

Generates random values quantized to a variable number of discrete levels (2^bits). At 1 bit: binary (2 levels). At 6 bits: 64 levels. The DC blocker creates pulses whose amplitude is quantized to these levels.

+ + + + + + + + + + + + + + + + + + + + + + + +
ParameterControlRangeEffect
X (k1)Rate5 – 500 HzClock speed. How often a new quantized random value is generated.
Y (k2)Bit depth1 – 6 bits (continuous)Quantization resolution. 1 bit = binary pulse (on/off). 2 bits = 4 levels. 6 bits = 64 levels (nearly continuous). Continuous morphing between bit depths.
+

Sound character: Quantized random pulses. At low bits: harsh, digital, with clearly discrete amplitude steps. At high bits: smoother, approaching the character of PulseWander. The bit quantization adds a lo-fi, digital texture to the random process.

+
+

F-3: ShapedPulse

+

Random with variable probability distribution shape.

+

The random values follow different probability distributions depending on Y. Uniform (flat — all values equally likely), triangular (values near center more likely), or peaked/gaussian (values strongly concentrated near center, rare extremes).

+ + + + + + + + + + + + + + + + + + + + + + + +
ParameterControlRangeEffect
X (k1)Rate5 – 500 HzClock speed.
Y (k2)DistributionUniform → Triangular → Gaussian0 = uniform (all amplitudes equally likely — evenly distributed pulses). 0.5 = triangular (sum of 2 uniforms — moderate peak clustering). 1.0 = peaked (sum of 4 uniforms, central limit theorem — most pulses near zero, rare large ones).
+

Sound character: The distribution shape is audible. Uniform: even, balanced pulse amplitudes. Peaked: mostly quiet with occasional loud spikes — creates a "crackling" or "dripping" quality where large events are rare surprises.

+
+

F-4: ShiftPulse

+

4-stage shift register creating evolving pulse sequences.

+

A shift register where random values enter stage 1 and shift down to stages 2, 3, 4 on each clock tick. All 4 stages are mixed in the output with adjustable weighting, creating patterns that evolve as values propagate through the chain.

+ + + + + + + + + + + + + + + + + + + + + + + +
ParameterControlRangeEffect
X (k1)Clock rate5 – 300 HzSpeed of the shift register clock.
Y (k2)Stage mixStage 1 only → All 4Progressive activation: Y=0: only stage 1 (fastest changing). Y=0.33: adds stage 2 (delayed echo). Y=0.66: adds stage 3. Y=1.0: all 4 stages equally mixed. The delayed repetitions create rhythmic pattern echoes.
+

Sound character: A pulse pattern that develops delayed echoes of itself. At low Y: simple random pulses. As Y increases, you hear the same values repeated 1, 2, 3 steps later, creating a cascading effect — like an echo chamber for random events.

+
+

F-5: MetallicNoise

+

6 square wave oscillators at inharmonic frequencies mixed and highpass filtered.

+

The classic technique used in the TR-808 cymbal and hi-hat circuits: six pulse oscillators at non-harmonic frequency ratios, summed together. The resulting waveform has a dense, metallic spectral character that no single oscillator can produce. A highpass filter controls brightness.

+ + + + + + + + + + + + + + + + + + + + + + + +
ParameterControlRangeEffect
X (k1)Pitch multiplier0.5x – 2.5xScales all 6 base frequencies together. At 1.0x: original frequencies. Below 1.0: lower, darker. Above: higher, brighter.
Y (k2)Brightness500 – 15500 Hz HPFHighpass filter cutoff. Low = full-bodied metallic noise. High = thin, sizzling hi-hat territory.
+

Base frequencies (Hz): 205.3, 304.4, 369.6, 522.7, 800.6, 1053.4

+

Sound character: Unmistakably metallic. At low HPF: thick, crash cymbal-like. At high HPF: thin, closed hi-hat sizzle. The 6 inharmonic frequencies create dense beating patterns that give the "shimmer" characteristic of real cymbals.

+
+

F-6: NoiseSlew

+

White noise with adjustable one-pole lowpass slew.

+

A simple but effective texture generator: white noise passed through a one-pole LP filter with adjustable cutoff. At high cutoff: full noise. At low cutoff: smooth, slowly undulating random wave. A mix control adds raw noise texture on top of the slewed signal.

+ + + + + + + + + + + + + + + + + + + + + + + +
ParameterControlRangeEffect
X (k1)SmoothnessSmooth – NoisyLP filter coefficient. Low = very smooth, slowly varying random wave. High = barely filtered, noise-like.
Y (k2)Texture mixClean – TexturedBlends raw noise on top of the slewed signal. 0 = only slewed output. 1 = slewed + 30% raw noise for gritty texture.
+

Sound character: The full spectrum from smooth random undulation to white noise in one algorithm. At X=0: a gentle, wandering random wave. At X=1: nearly unfiltered noise. The texture mix adds a "grain" to the smooth version without overpowering it.

+
+

F-7: NoiseBurst

+

Sporadic bursts of white noise with silence between them.

+

Generates discrete events: random-length bursts of noise separated by silence. Each burst has a natural fade-out envelope (20-sample ramp) to prevent clicks. The density controls how often bursts occur.

+ + + + + + + + + + + + + + + + + + + + + + + +
ParameterControlRangeEffect
X (k1)Burst density~1/sec – ~130/secAverage burst rate. Low = sparse, isolated events. High = dense but never continuous — always gaps between bursts.
Y (k2)Burst length1 ms – 100 msDuration of each noise burst. Short = percussive clicks. Long = noise "grains."
+

Sound character: Sporadic noise events in silence. Like a Geiger counter, or rain hitting a window irregularly. At high density with short bursts: crackling granular texture. At low density with long bursts: isolated noise "drops" with natural decay.

+
+

F-8: LFSRNoise

+

16-bit Linear Feedback Shift Register with selectable tap configurations.

+

A classic LFSR pseudo-random sequence generator with 8 different feedback tap polynomials. Different taps produce different sequence lengths and spectral characteristics. Output quantized to 16 discrete levels (top 4 bits) for a recognizable stepped character.

+ + + + + + + + + + + + + + + + + + + + + + + +
ParameterControlRangeEffect
X (k1)Clock rate5 – 500 HzHow fast the register shifts. Low = slow stepped pattern. High = fast digital noise with pitch.
Y (k2)Tap selection8 configurationsSelects from 8 feedback polynomials. Each produces a different sequence pattern — some nearly random, some with audible repetition. Sweep to find sweet spots.
+

Sound character: Digital pseudo-random sequences with a lo-fi, quantized character. Different taps create different "flavors" of digital noise — some more tonal, some more chaotic. The 16-level quantization gives it a distinctly stepped, 4-bit retro quality.

+
+

F-9: DualPulse

+

Two sample-and-hold generators running at independent rates, mixed together.

+

Two independent S&H circuits, each generating random values at their own clock rate. The outputs are mixed 50/50, creating complex polyrhythmic stepped patterns from the interaction of two independent clocks.

+ + + + + + + + + + + + + + + + + + + + + + + +
ParameterControlRangeEffect
X (k1)S&H 1 rate5 – 500 HzClock speed of the first generator.
Y (k2)S&H 2 rate5 – 500 HzClock speed of the second generator. Independent of X.
+

Sound character: Two overlapping random step patterns. When the two rates are similar: slow beating between the patterns. When rates are very different: a fast pattern modulated by a slow one. At simple ratios (2:1, 3:2): hints of regularity emerge. At complex ratios: maximally unpredictable interaction.

-

Generated from firmware source code analysis. Befaco Noise Plethora v1.5 + Banks D & E extension.

+

Generated from firmware source code analysis. Befaco Noise Plethora v1.5 + Banks D, E & F extension.

\ No newline at end of file diff --git a/NOISE_PLETHORA_PLUGIN_GUIDE.md b/NOISE_PLETHORA_PLUGIN_GUIDE.md index 5feff92..d1d11ec 100644 --- a/NOISE_PLETHORA_PLUGIN_GUIDE.md +++ b/NOISE_PLETHORA_PLUGIN_GUIDE.md @@ -1,12 +1,12 @@ # Noise Plethora — Complete Plugin Guide -*Befaco Noise Plethora v1.5 + Banks D & E Extension* +*Befaco Noise Plethora v1.5 + Banks D, E & F Extension* ## About This Guide The Noise Plethora is a Eurorack noise workstation with 3 digital sound generators (A, B, and C), each followed by an analog multimode filter. Generators A and B run interchangeable algorithms organized in banks of 10. Each algorithm has two parameters controlled by the **X** and **Y** knobs (and their corresponding CV inputs, 0–10Vpp). -This guide documents all 50 algorithms across 5 banks: +This guide documents all 60 algorithms across 6 banks: | Bank | Name | Programs | Theme | |------|------|----------|-------| @@ -15,8 +15,9 @@ This guide documents all 50 algorithms across 5 banks: | **C** | Harsh & Wild | 0–9 | Bitcrushing, random walks, chaotic oscillators | | **D** | Resonant Bodies | 0–9 | Delay-based resonance, physical modeling, spectral shaping | | **E** | Chaos Machines | 0–9 | Deterministic chaos, algorithmic processes, digital manipulation | +| **F** | Stochastic | 0–9 | Random pulses, metallic noise, LFSR sequences, noise textures | -Banks A–C are the original Befaco firmware. Banks D–E are community extensions. +Banks A–C are the original Befaco firmware. Banks D–F are community extensions. --- @@ -77,6 +78,17 @@ Banks A–C are the original Befaco firmware. Banks D–E are community extensio - [E-7: GlitchLoop](#e-7-glitchloop) — Loop with bit degradation - [E-8: SubHarmonic](#e-8-subharmonic) — Frequency dividers - [E-9: DualAttractor](#e-9-dualattractor) — Coupled Lorenz oscillators +- [Bank F: Stochastic](#bank-f-stochastic) + - [F-0: PulseWander](#f-0-pulsewander) — Smooth random walk pulses + - [F-1: TwinPulse](#f-1-twinpulse) — Two correlated random walks + - [F-2: QuantPulse](#f-2-quantpulse) — Quantized random (1-6 bits) + - [F-3: ShapedPulse](#f-3-shapedpulse) — Shaped probability distribution + - [F-4: ShiftPulse](#f-4-shiftpulse) — 4-stage shift register sequences + - [F-5: MetallicNoise](#f-5-metallicnoise) — 6 inharmonic square oscillators + - [F-6: NoiseSlew](#f-6-noiseslew) — Noise with adjustable LP slew + - [F-7: NoiseBurst](#f-7-noiseburst) — Sporadic noise bursts + - [F-8: LFSRNoise](#f-8-lfsrnoise) — LFSR pseudo-random sequences + - [F-9: DualPulse](#f-9-dualpulse) — Two S&H at independent rates --- @@ -862,3 +874,161 @@ Lorenz system: `dx/dt = sigma(y-x)`, `dy/dt = x(rho-z)-y`, `dz/dt = xy-beta*z`. | **Y (k2)** | Base frequency | 30 – 2030 Hz | Center pitch the attractors orbit. | **Sound character:** Two drunk musicians trying to play in unison. Moments of harmony interrupted by chaos. Organic, alive, never repeating. + +--- + +## Bank F: Stochastic + +Random processes generating pulses, transients, and noise textures. The pulse-based algorithms (F-0 through F-4) exploit the Noise Plethora's internal DC blocker to transform random stepped values into unique transient/pulse shapes — a character exclusive to this module's architecture. + +--- + +### F-0: PulseWander + +**Smooth random walk generating organic pulse patterns.** + +A random target value is chosen periodically, and a one-pole LP filter smoothly tracks it. The module's DC blocker transforms held values into distinctive pulse shapes with natural attack/decay envelopes. + +| Parameter | Control | Range | Effect | +|-----------|---------|-------|--------| +| **X (k1)** | Rate | 5 – 400 Hz | How often a new random target is chosen. Low = sparse, isolated pulses. High = dense, overlapping transients. | +| **Y (k2)** | Smoothness | Instant – Smooth | k2=0: instant jumps (sharp S&H pulses). k2=1: smooth glide between targets (softer, rounder transients). The LP filter alpha auto-scales with rate. | + +**Sound character:** Organic, irregular pulse train. Each pulse has a unique amplitude from the random walk. The smoothness control morphs from sharp clicks to rounded bumps. Unlike a regular clock, the randomness creates a "breathing" quality. + +--- + +### F-1: TwinPulse + +**Two random walks with controllable correlation creating crossed pulse patterns.** + +Two independent random walk generators running at the same rate. The correlation control blends the second walk toward the first, creating patterns that range from fully independent (complex interference) to identical (simple doubled pulse). + +| Parameter | Control | Range | Effect | +|-----------|---------|-------|--------| +| **X (k1)** | Rate | 5 – 400 Hz | Speed of both random walks. | +| **Y (k2)** | Correlation | Independent – Identical | 0 = two completely unrelated pulse streams (complex polyrhythmic interference). 1 = both outputs identical (single pulse stream, louder). Sweet spot around 0.3–0.7 where patterns partially align. | + +**Sound character:** Two overlapping pulse patterns. At low correlation, a complex, polyrhythmic texture where pulses sometimes align and sometimes don't. At high correlation, they merge into a single stream. The interplay creates a rhythmic quality that pure randomness lacks. + +--- + +### F-2: QuantPulse + +**Random values quantized to N bits, creating stepped pulse patterns.** + +Generates random values quantized to a variable number of discrete levels (2^bits). At 1 bit: binary (2 levels). At 6 bits: 64 levels. The DC blocker creates pulses whose amplitude is quantized to these levels. + +| Parameter | Control | Range | Effect | +|-----------|---------|-------|--------| +| **X (k1)** | Rate | 5 – 500 Hz | Clock speed. How often a new quantized random value is generated. | +| **Y (k2)** | Bit depth | 1 – 6 bits (continuous) | Quantization resolution. 1 bit = binary pulse (on/off). 2 bits = 4 levels. 6 bits = 64 levels (nearly continuous). Continuous morphing between bit depths. | + +**Sound character:** Quantized random pulses. At low bits: harsh, digital, with clearly discrete amplitude steps. At high bits: smoother, approaching the character of PulseWander. The bit quantization adds a lo-fi, digital texture to the random process. + +--- + +### F-3: ShapedPulse + +**Random with variable probability distribution shape.** + +The random values follow different probability distributions depending on Y. Uniform (flat — all values equally likely), triangular (values near center more likely), or peaked/gaussian (values strongly concentrated near center, rare extremes). + +| Parameter | Control | Range | Effect | +|-----------|---------|-------|--------| +| **X (k1)** | Rate | 5 – 500 Hz | Clock speed. | +| **Y (k2)** | Distribution | Uniform → Triangular → Gaussian | 0 = uniform (all amplitudes equally likely — evenly distributed pulses). 0.5 = triangular (sum of 2 uniforms — moderate peak clustering). 1.0 = peaked (sum of 4 uniforms, central limit theorem — most pulses near zero, rare large ones). | + +**Sound character:** The distribution shape is audible. Uniform: even, balanced pulse amplitudes. Peaked: mostly quiet with occasional loud spikes — creates a "crackling" or "dripping" quality where large events are rare surprises. + +--- + +### F-4: ShiftPulse + +**4-stage shift register creating evolving pulse sequences.** + +A shift register where random values enter stage 1 and shift down to stages 2, 3, 4 on each clock tick. All 4 stages are mixed in the output with adjustable weighting, creating patterns that evolve as values propagate through the chain. + +| Parameter | Control | Range | Effect | +|-----------|---------|-------|--------| +| **X (k1)** | Clock rate | 5 – 300 Hz | Speed of the shift register clock. | +| **Y (k2)** | Stage mix | Stage 1 only → All 4 | Progressive activation: Y=0: only stage 1 (fastest changing). Y=0.33: adds stage 2 (delayed echo). Y=0.66: adds stage 3. Y=1.0: all 4 stages equally mixed. The delayed repetitions create rhythmic pattern echoes. | + +**Sound character:** A pulse pattern that develops delayed echoes of itself. At low Y: simple random pulses. As Y increases, you hear the same values repeated 1, 2, 3 steps later, creating a cascading effect — like an echo chamber for random events. + +--- + +### F-5: MetallicNoise + +**6 square wave oscillators at inharmonic frequencies mixed and highpass filtered.** + +The classic technique used in the TR-808 cymbal and hi-hat circuits: six pulse oscillators at non-harmonic frequency ratios, summed together. The resulting waveform has a dense, metallic spectral character that no single oscillator can produce. A highpass filter controls brightness. + +| Parameter | Control | Range | Effect | +|-----------|---------|-------|--------| +| **X (k1)** | Pitch multiplier | 0.5x – 2.5x | Scales all 6 base frequencies together. At 1.0x: original frequencies. Below 1.0: lower, darker. Above: higher, brighter. | +| **Y (k2)** | Brightness | 500 – 15500 Hz HPF | Highpass filter cutoff. Low = full-bodied metallic noise. High = thin, sizzling hi-hat territory. | + +**Base frequencies (Hz):** 205.3, 304.4, 369.6, 522.7, 800.6, 1053.4 + +**Sound character:** Unmistakably metallic. At low HPF: thick, crash cymbal-like. At high HPF: thin, closed hi-hat sizzle. The 6 inharmonic frequencies create dense beating patterns that give the "shimmer" characteristic of real cymbals. + +--- + +### F-6: NoiseSlew + +**White noise with adjustable one-pole lowpass slew.** + +A simple but effective texture generator: white noise passed through a one-pole LP filter with adjustable cutoff. At high cutoff: full noise. At low cutoff: smooth, slowly undulating random wave. A mix control adds raw noise texture on top of the slewed signal. + +| Parameter | Control | Range | Effect | +|-----------|---------|-------|--------| +| **X (k1)** | Smoothness | Smooth – Noisy | LP filter coefficient. Low = very smooth, slowly varying random wave. High = barely filtered, noise-like. | +| **Y (k2)** | Texture mix | Clean – Textured | Blends raw noise on top of the slewed signal. 0 = only slewed output. 1 = slewed + 30% raw noise for gritty texture. | + +**Sound character:** The full spectrum from smooth random undulation to white noise in one algorithm. At X=0: a gentle, wandering random wave. At X=1: nearly unfiltered noise. The texture mix adds a "grain" to the smooth version without overpowering it. + +--- + +### F-7: NoiseBurst + +**Sporadic bursts of white noise with silence between them.** + +Generates discrete events: random-length bursts of noise separated by silence. Each burst has a natural fade-out envelope (20-sample ramp) to prevent clicks. The density controls how often bursts occur. + +| Parameter | Control | Range | Effect | +|-----------|---------|-------|--------| +| **X (k1)** | Burst density | ~1/sec – ~130/sec | Average burst rate. Low = sparse, isolated events. High = dense but never continuous — always gaps between bursts. | +| **Y (k2)** | Burst length | 1 ms – 100 ms | Duration of each noise burst. Short = percussive clicks. Long = noise "grains." | + +**Sound character:** Sporadic noise events in silence. Like a Geiger counter, or rain hitting a window irregularly. At high density with short bursts: crackling granular texture. At low density with long bursts: isolated noise "drops" with natural decay. + +--- + +### F-8: LFSRNoise + +**16-bit Linear Feedback Shift Register with selectable tap configurations.** + +A classic LFSR pseudo-random sequence generator with 8 different feedback tap polynomials. Different taps produce different sequence lengths and spectral characteristics. Output quantized to 16 discrete levels (top 4 bits) for a recognizable stepped character. + +| Parameter | Control | Range | Effect | +|-----------|---------|-------|--------| +| **X (k1)** | Clock rate | 5 – 500 Hz | How fast the register shifts. Low = slow stepped pattern. High = fast digital noise with pitch. | +| **Y (k2)** | Tap selection | 8 configurations | Selects from 8 feedback polynomials. Each produces a different sequence pattern — some nearly random, some with audible repetition. Sweep to find sweet spots. | + +**Sound character:** Digital pseudo-random sequences with a lo-fi, quantized character. Different taps create different "flavors" of digital noise — some more tonal, some more chaotic. The 16-level quantization gives it a distinctly stepped, 4-bit retro quality. + +--- + +### F-9: DualPulse + +**Two sample-and-hold generators running at independent rates, mixed together.** + +Two independent S&H circuits, each generating random values at their own clock rate. The outputs are mixed 50/50, creating complex polyrhythmic stepped patterns from the interaction of two independent clocks. + +| Parameter | Control | Range | Effect | +|-----------|---------|-------|--------| +| **X (k1)** | S&H 1 rate | 5 – 500 Hz | Clock speed of the first generator. | +| **Y (k2)** | S&H 2 rate | 5 – 500 Hz | Clock speed of the second generator. Independent of X. | + +**Sound character:** Two overlapping random step patterns. When the two rates are similar: slow beating between the patterns. When rates are very different: a fast pattern modulated by a slow one. At simple ratios (2:1, 3:2): hints of regularity emerge. At complex ratios: maximally unpredictable interaction. diff --git a/src/noise-plethora/plugins/Banks.cpp b/src/noise-plethora/plugins/Banks.cpp index df020ff..9160144 100644 --- a/src/noise-plethora/plugins/Banks.cpp +++ b/src/noise-plethora/plugins/Banks.cpp @@ -101,18 +101,26 @@ int Bank::getSize() { #include "P_SubHarmonic.hpp" #include "P_DualAttractor.hpp" +// Bank F: Stochastic +#include "P_PulseWander.hpp" +#include "P_TwinPulse.hpp" +#include "P_QuantPulse.hpp" +#include "P_ShapedPulse.hpp" +#include "P_ShiftPulse.hpp" +#include "P_MetallicNoise.hpp" +#include "P_NoiseSlew.hpp" +#include "P_NoiseBurst.hpp" +#include "P_LFSRNoise.hpp" +#include "P_DualPulse.hpp" + static const Bank bank1 BANKS_DEF_1; // Banks_Def.hpp static const Bank bank2 BANKS_DEF_2; static const Bank bank3 BANKS_DEF_3; static const Bank bank4 BANKS_DEF_4; static const Bank bank5 BANKS_DEF_5; -static std::array banks { bank1, bank2, bank3, bank4, bank5 }; - -// static const Bank bank7 BANKS_DEF_7; -// static const Bank bank8 BANKS_DEF_8; -// static const Bank bank9 BANKS_DEF_9; -// static const Bank bank10 BANKS_DEF_10; +static const Bank bank6 BANKS_DEF_6; +static std::array banks { bank1, bank2, bank3, bank4, bank5, bank6 }; Bank& getBankForIndex(int i) { if (i < 0) diff --git a/src/noise-plethora/plugins/Banks.hpp b/src/noise-plethora/plugins/Banks.hpp index cfece95..4dfea6e 100644 --- a/src/noise-plethora/plugins/Banks.hpp +++ b/src/noise-plethora/plugins/Banks.hpp @@ -6,7 +6,7 @@ #include static const int programsPerBank = 10; -static const int numBanks = 5; +static const int numBanks = 6; struct Bank { diff --git a/src/noise-plethora/plugins/Banks_Def.hpp b/src/noise-plethora/plugins/Banks_Def.hpp index 10334aa..0c91c7f 100644 --- a/src/noise-plethora/plugins/Banks_Def.hpp +++ b/src/noise-plethora/plugins/Banks_Def.hpp @@ -65,7 +65,20 @@ { "DualAttractor", 1.0 } \ } -// #define BANKS_DEF_6 +#define BANKS_DEF_6 { \ + { "PulseWander", 1.0 }, \ + { "TwinPulse", 1.0 }, \ + { "QuantPulse", 1.0 }, \ + { "ShapedPulse", 1.0 }, \ + { "ShiftPulse", 1.0 }, \ + { "MetallicNoise", 1.0 }, \ + { "NoiseSlew", 1.0 }, \ + { "NoiseBurst", 1.0 }, \ + { "LFSRNoise", 1.0 }, \ + { "DualPulse", 1.0 } \ + } + +// #define BANKS_DEF_7 // #define BANKS_DEF_8 // #define BANKS_DEF_9 // #define BANKS_DEF_10 diff --git a/src/noise-plethora/plugins/P_DualPulse.hpp b/src/noise-plethora/plugins/P_DualPulse.hpp new file mode 100644 index 0000000..336184b --- /dev/null +++ b/src/noise-plethora/plugins/P_DualPulse.hpp @@ -0,0 +1,84 @@ +#pragma once + +#include "NoisePlethoraPlugin.hpp" +#include + +class DualPulse : public NoisePlethoraPlugin { + +public: + + DualPulse() { } + + ~DualPulse() override {} + + DualPulse(const DualPulse&) = delete; + DualPulse& operator=(const DualPulse&) = delete; + + void init() override { + value1 = 0.0f; + value2 = 0.0f; + counter1 = 0; + counter2 = 0; + samplesPerClock1 = 441; + samplesPerClock2 = 441; + } + + void process(float k1, float k2) override { + float rate1 = 5.0f + std::pow(k1, 2) * 495.0f; + float rate2 = 5.0f + std::pow(k2, 2) * 495.0f; + samplesPerClock1 = (int)(AUDIO_SAMPLE_RATE_EXACT / rate1); + if (samplesPerClock1 < 1) samplesPerClock1 = 1; + samplesPerClock2 = (int)(AUDIO_SAMPLE_RATE_EXACT / rate2); + if (samplesPerClock2 < 1) samplesPerClock2 = 1; + } + + void processGraphAsBlock(TeensyBuffer& blockBuffer) override { + + for (int i = 0; i < AUDIO_BLOCK_SAMPLES; i++) { + counter1++; + if (counter1 >= samplesPerClock1) { + value1 = random::uniform() * 2.0f - 1.0f; + counter1 = 0; + } + + counter2++; + if (counter2 >= samplesPerClock2) { + value2 = random::uniform() * 2.0f - 1.0f; + counter2 = 0; + } + + float out = 0.5f * value1 + 0.5f * value2; + + // Add dither + out += (random::uniform() - 0.5f) * 0.01f; + + if (out > 1.0f) out = 1.0f; + if (out < -1.0f) out = -1.0f; + + outputBlock.data[i] = (int16_t)(out * 32767.0f); + } + + blockBuffer.pushBuffer(outputBlock.data, AUDIO_BLOCK_SAMPLES); + } + + AudioStream& getStream() override { + return dc1; + } + unsigned char getPort() override { + return 0; + } + +private: + AudioSynthWaveformDc dc1; // dummy for getStream() + + audio_block_t outputBlock; + + float value1 = 0.0f; + float value2 = 0.0f; + int counter1 = 0; + int counter2 = 0; + int samplesPerClock1 = 441; + int samplesPerClock2 = 441; +}; + +REGISTER_PLUGIN(DualPulse); diff --git a/src/noise-plethora/plugins/P_LFSRNoise.hpp b/src/noise-plethora/plugins/P_LFSRNoise.hpp new file mode 100644 index 0000000..5e3bb9e --- /dev/null +++ b/src/noise-plethora/plugins/P_LFSRNoise.hpp @@ -0,0 +1,85 @@ +#pragma once + +#include "NoisePlethoraPlugin.hpp" +#include + +class LFSRNoise : public NoisePlethoraPlugin { + +public: + + LFSRNoise() { } + + ~LFSRNoise() override {} + + LFSRNoise(const LFSRNoise&) = delete; + LFSRNoise& operator=(const LFSRNoise&) = delete; + + void init() override { + lfsr = 0xACE1; + clockCounter = 0; + samplesPerClock = 441; + currentTaps = taps[0]; + } + + void process(float k1, float k2) override { + float rate = 5.0f + std::pow(k1, 2) * 495.0f; + samplesPerClock = (int)(AUDIO_SAMPLE_RATE_EXACT / rate); + if (samplesPerClock < 1) samplesPerClock = 1; + + int tapIndex = (int)(k2 * 7.99f); + if (tapIndex < 0) tapIndex = 0; + if (tapIndex > 7) tapIndex = 7; + currentTaps = taps[tapIndex]; + } + + void processGraphAsBlock(TeensyBuffer& blockBuffer) override { + + for (int i = 0; i < AUDIO_BLOCK_SAMPLES; i++) { + clockCounter++; + if (clockCounter >= samplesPerClock) { + uint16_t masked = lfsr & currentTaps; + uint16_t feedback = __builtin_popcount(masked) & 1; + lfsr = (lfsr >> 1) | (feedback << 15); + clockCounter = 0; + } + + // Output top 4 bits: 16 discrete levels + int16_t quantized = (int16_t)(lfsr >> 12); + float out = quantized / 7.5f - 1.0f; + + // Add dither + out += (random::uniform() - 0.5f) * 0.01f; + + if (out > 1.0f) out = 1.0f; + if (out < -1.0f) out = -1.0f; + + outputBlock.data[i] = (int16_t)(out * 32767.0f); + } + + blockBuffer.pushBuffer(outputBlock.data, AUDIO_BLOCK_SAMPLES); + } + + AudioStream& getStream() override { + return dc1; + } + unsigned char getPort() override { + return 0; + } + +private: + AudioSynthWaveformDc dc1; // dummy for getStream() + + audio_block_t outputBlock; + + static constexpr uint16_t taps[8] = { + 0x002D, 0x0039, 0xD008, 0xB400, + 0x6000, 0xD295, 0xB002, 0xE100 + }; + + uint16_t lfsr = 0xACE1; + int clockCounter = 0; + int samplesPerClock = 441; + uint16_t currentTaps = 0x002D; +}; + +REGISTER_PLUGIN(LFSRNoise); diff --git a/src/noise-plethora/plugins/P_MetallicNoise.hpp b/src/noise-plethora/plugins/P_MetallicNoise.hpp new file mode 100644 index 0000000..2d7d1b6 --- /dev/null +++ b/src/noise-plethora/plugins/P_MetallicNoise.hpp @@ -0,0 +1,87 @@ +#pragma once + +#include "NoisePlethoraPlugin.hpp" +#include + +class MetallicNoise : public NoisePlethoraPlugin { + +public: + + MetallicNoise() { } + + ~MetallicNoise() override {} + + MetallicNoise(const MetallicNoise&) = delete; + MetallicNoise& operator=(const MetallicNoise&) = delete; + + void init() override { + for (int i = 0; i < 6; i++) { + osc[i].begin(0.3f, baseFreqs[i], WAVEFORM_SQUARE); + } + + mixer1.gain(0, 1.0f); + mixer1.gain(1, 1.0f); + mixer1.gain(2, 1.0f); + mixer1.gain(3, 1.0f); + + mixer2.gain(0, 1.0f); + mixer2.gain(1, 1.0f); + mixer2.gain(2, 0.0f); + mixer2.gain(3, 0.0f); + + mixer3.gain(0, 1.0f); + mixer3.gain(1, 1.0f); + mixer3.gain(2, 0.0f); + mixer3.gain(3, 0.0f); + + filter1.frequency(5000); + filter1.resonance(0.7f); + filter1.octaveControl(2.0f); + } + + void process(float k1, float k2) override { + float pitchMult = 0.5f + k1 * 2.0f; + for (int i = 0; i < 6; i++) { + osc[i].frequency(baseFreqs[i] * pitchMult); + } + + float filterFreq = 500.0f + std::pow(k2, 2) * 15000.0f; + filter1.frequency(filterFreq); + } + + void processGraphAsBlock(TeensyBuffer& blockBuffer) override { + for (int i = 0; i < 6; i++) { + osc[i].update(nullptr, nullptr, &oscBlock[i]); + } + + mixer1.update(&oscBlock[0], &oscBlock[1], &oscBlock[2], &oscBlock[3], &mixerBlock[0]); + mixer2.update(&oscBlock[4], &oscBlock[5], nullptr, nullptr, &mixerBlock[1]); + mixer3.update(&mixerBlock[0], &mixerBlock[1], nullptr, nullptr, &mixerBlock[2]); + + filter1.update(&mixerBlock[2], nullptr, &filterLP, &filterBP, &filterHP); + + blockBuffer.pushBuffer(filterHP.data, AUDIO_BLOCK_SAMPLES); + } + + AudioStream& getStream() override { + return filter1; + } + unsigned char getPort() override { + return 0; + } + +private: + static constexpr float baseFreqs[6] = {205.3f, 304.4f, 369.6f, 522.7f, 800.6f, 1053.4f}; + + AudioSynthWaveformModulated osc[6]; + AudioMixer4 mixer1; + AudioMixer4 mixer2; + AudioMixer4 mixer3; + AudioFilterStateVariable filter1; + + audio_block_t oscBlock[6]; + audio_block_t mixerBlock[3]; + audio_block_t filterLP, filterBP, filterHP; +}; + +REGISTER_PLUGIN(MetallicNoise); diff --git a/src/noise-plethora/plugins/P_NoiseBurst.hpp b/src/noise-plethora/plugins/P_NoiseBurst.hpp new file mode 100644 index 0000000..126a2fd --- /dev/null +++ b/src/noise-plethora/plugins/P_NoiseBurst.hpp @@ -0,0 +1,80 @@ +#pragma once + +#include "NoisePlethoraPlugin.hpp" +#include + +class NoiseBurst : public NoisePlethoraPlugin { + +public: + + NoiseBurst() { } + + ~NoiseBurst() override {} + + NoiseBurst(const NoiseBurst&) = delete; + NoiseBurst& operator=(const NoiseBurst&) = delete; + + void init() override { + noise1.amplitude(1.0f); + burstCounter = 0; + currentBurstLen = 200; + burstProb = 0.001f; + } + + void process(float k1, float k2) override { + burstProb = 0.00002f + std::pow(k1, 2) * 0.003f; + currentBurstLen = (int)(44 + k2 * 4400); + } + + void processGraphAsBlock(TeensyBuffer& blockBuffer) override { + noise1.update(&noiseBlock); + + for (int i = 0; i < AUDIO_BLOCK_SAMPLES; i++) { + if (burstCounter > 0) { + // Envelope fade-out on last 20 samples + float gain = 1.0f; + if (burstCounter < 20) { + gain = burstCounter / 20.0f; + } + outputBlock.data[i] = (int16_t)(noiseBlock.data[i] * gain); + burstCounter--; + } + else { + if (random::uniform() < burstProb) { + burstCounter = currentBurstLen; + // Output this sample as part of the burst + float gain = 1.0f; + if (burstCounter < 20) { + gain = burstCounter / 20.0f; + } + outputBlock.data[i] = (int16_t)(noiseBlock.data[i] * gain); + burstCounter--; + } + else { + outputBlock.data[i] = 0; + } + } + } + + blockBuffer.pushBuffer(outputBlock.data, AUDIO_BLOCK_SAMPLES); + } + + AudioStream& getStream() override { + return dc1; + } + unsigned char getPort() override { + return 0; + } + +private: + AudioSynthWaveformDc dc1; // dummy for getStream() + AudioSynthNoiseWhite noise1; + + audio_block_t noiseBlock, outputBlock; + + int burstCounter = 0; + int currentBurstLen = 200; + float burstProb = 0.001f; +}; + +REGISTER_PLUGIN(NoiseBurst); diff --git a/src/noise-plethora/plugins/P_NoiseSlew.hpp b/src/noise-plethora/plugins/P_NoiseSlew.hpp new file mode 100644 index 0000000..137f20e --- /dev/null +++ b/src/noise-plethora/plugins/P_NoiseSlew.hpp @@ -0,0 +1,71 @@ +#pragma once + +#include "NoisePlethoraPlugin.hpp" +#include + +class NoiseSlew : public NoisePlethoraPlugin { + +public: + + NoiseSlew() { } + + ~NoiseSlew() override {} + + NoiseSlew(const NoiseSlew&) = delete; + NoiseSlew& operator=(const NoiseSlew&) = delete; + + void init() override { + noise1.amplitude(1.0f); + slewState = 0.0f; + alpha = 0.01f; + mix = 0.0f; + } + + void process(float k1, float k2) override { + alpha = 0.0003f + std::pow(k1, 3) * 0.15f; + mix = k2; + } + + void processGraphAsBlock(TeensyBuffer& blockBuffer) override { + noise1.update(&noiseBlock); + + for (int i = 0; i < AUDIO_BLOCK_SAMPLES; i++) { + float noiseSample = noiseBlock.data[i] / 32767.0f; + + slewState = slewState * (1.0f - alpha) + noiseSample * alpha; + + // NaN guard + if (std::isnan(slewState) || std::isinf(slewState)) { + slewState = 0.0f; + } + + float out = slewState * (1.0f - mix * 0.7f) + noiseSample * mix * 0.3f; + + if (out > 1.0f) out = 1.0f; + if (out < -1.0f) out = -1.0f; + + outputBlock.data[i] = (int16_t)(out * 32767.0f); + } + + blockBuffer.pushBuffer(outputBlock.data, AUDIO_BLOCK_SAMPLES); + } + + AudioStream& getStream() override { + return dc1; + } + unsigned char getPort() override { + return 0; + } + +private: + AudioSynthWaveformDc dc1; // dummy for getStream() + AudioSynthNoiseWhite noise1; + + audio_block_t noiseBlock, outputBlock; + + float slewState = 0.0f; + float alpha = 0.01f; + float mix = 0.0f; +}; + +REGISTER_PLUGIN(NoiseSlew); diff --git a/src/noise-plethora/plugins/P_PulseWander.hpp b/src/noise-plethora/plugins/P_PulseWander.hpp new file mode 100644 index 0000000..b13b2aa --- /dev/null +++ b/src/noise-plethora/plugins/P_PulseWander.hpp @@ -0,0 +1,82 @@ +#pragma once + +#include +#include "NoisePlethoraPlugin.hpp" + +class PulseWander : public NoisePlethoraPlugin { + +public: + + PulseWander() { } + + ~PulseWander() override {} + + PulseWander(const PulseWander&) = delete; + PulseWander& operator=(const PulseWander&) = delete; + + void init() override { + currentValue = random::uniform() * 2.0f - 1.0f; + targetValue = random::uniform() * 2.0f - 1.0f; + smoothAlpha = 0.1f; + sampleCounter = 0; + samplesPerTarget = 441; + } + + void process(float k1, float k2) override { + float rate = 5.0f + std::pow(k1, 2) * 395.0f; + samplesPerTarget = std::max(1, (int)(44100.0f / rate)); + + float minAlpha = 3.0f / (float)samplesPerTarget; + smoothAlpha = minAlpha + (1.0f - k2) * (1.0f - minAlpha); + } + + void processGraphAsBlock(TeensyBuffer& blockBuffer) override { + + for (int i = 0; i < AUDIO_BLOCK_SAMPLES; i++) { + sampleCounter++; + if (sampleCounter >= samplesPerTarget) { + targetValue = random::uniform() * 2.0f - 1.0f; + sampleCounter = 0; + } + + currentValue = currentValue * (1.0f - smoothAlpha) + targetValue * smoothAlpha; + + // NaN/Inf guard + if (!std::isfinite(currentValue)) { + currentValue = 0.0f; + } + + float out = currentValue + (random::uniform() - 0.5f) * 0.01f; + + if (out > 1.0f) out = 1.0f; + if (out < -1.0f) out = -1.0f; + + int32_t sample = (int32_t)(out * 32767.0f); + if (sample > 32767) sample = 32767; + if (sample < -32767) sample = -32767; + outputBlock.data[i] = (int16_t)sample; + } + + blockBuffer.pushBuffer(outputBlock.data, AUDIO_BLOCK_SAMPLES); + } + + AudioStream& getStream() override { + return dc1; + } + unsigned char getPort() override { + return 0; + } + +private: + AudioSynthWaveformDc dc1; + + audio_block_t outputBlock; + + float currentValue = 0.0f; + float targetValue = 0.0f; + float smoothAlpha = 0.1f; + int sampleCounter = 0; + int samplesPerTarget = 441; +}; + +REGISTER_PLUGIN(PulseWander); diff --git a/src/noise-plethora/plugins/P_QuantPulse.hpp b/src/noise-plethora/plugins/P_QuantPulse.hpp new file mode 100644 index 0000000..defcc39 --- /dev/null +++ b/src/noise-plethora/plugins/P_QuantPulse.hpp @@ -0,0 +1,83 @@ +#pragma once + +#include +#include "NoisePlethoraPlugin.hpp" + +class QuantPulse : public NoisePlethoraPlugin { + +public: + + QuantPulse() { } + + ~QuantPulse() override {} + + QuantPulse(const QuantPulse&) = delete; + QuantPulse& operator=(const QuantPulse&) = delete; + + void init() override { + currentValue = 0.0f; + sampleCounter = 0; + samplesPerClock = 441; + bits = 3.0f; + } + + void process(float k1, float k2) override { + float rate = 5.0f + std::pow(k1, 2) * 495.0f; + samplesPerClock = std::max(1, (int)(44100.0f / rate)); + + bits = 1.0f + k2 * 5.0f; + } + + void processGraphAsBlock(TeensyBuffer& blockBuffer) override { + + for (int i = 0; i < AUDIO_BLOCK_SAMPLES; i++) { + sampleCounter++; + if (sampleCounter >= samplesPerClock) { + float raw = random::uniform() * 2.0f - 1.0f; + float levels = std::pow(2.0f, bits); + currentValue = std::round(raw * levels) / levels; + + if (currentValue > 1.0f) currentValue = 1.0f; + if (currentValue < -1.0f) currentValue = -1.0f; + + sampleCounter = 0; + } + + // NaN/Inf guard + if (!std::isfinite(currentValue)) { + currentValue = 0.0f; + } + + float out = currentValue + (random::uniform() - 0.5f) * 0.01f; + + if (out > 1.0f) out = 1.0f; + if (out < -1.0f) out = -1.0f; + + int32_t sample = (int32_t)(out * 32767.0f); + if (sample > 32767) sample = 32767; + if (sample < -32767) sample = -32767; + outputBlock.data[i] = (int16_t)sample; + } + + blockBuffer.pushBuffer(outputBlock.data, AUDIO_BLOCK_SAMPLES); + } + + AudioStream& getStream() override { + return dc1; + } + unsigned char getPort() override { + return 0; + } + +private: + AudioSynthWaveformDc dc1; + + audio_block_t outputBlock; + + float currentValue = 0.0f; + int sampleCounter = 0; + int samplesPerClock = 441; + float bits = 3.0f; +}; + +REGISTER_PLUGIN(QuantPulse); diff --git a/src/noise-plethora/plugins/P_ShapedPulse.hpp b/src/noise-plethora/plugins/P_ShapedPulse.hpp new file mode 100644 index 0000000..7f22982 --- /dev/null +++ b/src/noise-plethora/plugins/P_ShapedPulse.hpp @@ -0,0 +1,97 @@ +#pragma once + +#include +#include "NoisePlethoraPlugin.hpp" + +class ShapedPulse : public NoisePlethoraPlugin { + +public: + + ShapedPulse() { } + + ~ShapedPulse() override {} + + ShapedPulse(const ShapedPulse&) = delete; + ShapedPulse& operator=(const ShapedPulse&) = delete; + + void init() override { + currentValue = 0.0f; + sampleCounter = 0; + samplesPerClock = 441; + shape = 0.0f; + } + + void process(float k1, float k2) override { + float rate = 5.0f + std::pow(k1, 2) * 495.0f; + samplesPerClock = std::max(1, (int)(44100.0f / rate)); + + shape = k2; + } + + void processGraphAsBlock(TeensyBuffer& blockBuffer) override { + + for (int i = 0; i < AUDIO_BLOCK_SAMPLES; i++) { + sampleCounter++; + if (sampleCounter >= samplesPerClock) { + float val; + + if (shape < 0.5f) { + // Blend uniform and triangular + float blend = shape * 2.0f; + float uniform = random::uniform() * 2.0f - 1.0f; + float tri = (random::uniform() + random::uniform()) - 1.0f; + val = uniform * (1.0f - blend) + tri * blend; + } + else { + // Blend triangular and peaked (pseudo-gaussian) + float blend = (shape - 0.5f) * 2.0f; + float tri = (random::uniform() + random::uniform()) - 1.0f; + float peaked = (random::uniform() + random::uniform() + random::uniform() + random::uniform()) * 0.5f - 1.0f; + val = tri * (1.0f - blend) + peaked * blend; + } + + if (val > 1.0f) val = 1.0f; + if (val < -1.0f) val = -1.0f; + + currentValue = val; + sampleCounter = 0; + } + + // NaN/Inf guard + if (!std::isfinite(currentValue)) { + currentValue = 0.0f; + } + + float out = currentValue + (random::uniform() - 0.5f) * 0.01f; + + if (out > 1.0f) out = 1.0f; + if (out < -1.0f) out = -1.0f; + + int32_t sample = (int32_t)(out * 32767.0f); + if (sample > 32767) sample = 32767; + if (sample < -32767) sample = -32767; + outputBlock.data[i] = (int16_t)sample; + } + + blockBuffer.pushBuffer(outputBlock.data, AUDIO_BLOCK_SAMPLES); + } + + AudioStream& getStream() override { + return dc1; + } + unsigned char getPort() override { + return 0; + } + +private: + AudioSynthWaveformDc dc1; + + audio_block_t outputBlock; + + float currentValue = 0.0f; + int sampleCounter = 0; + int samplesPerClock = 441; + float shape = 0.0f; +}; + +REGISTER_PLUGIN(ShapedPulse); diff --git a/src/noise-plethora/plugins/P_ShiftPulse.hpp b/src/noise-plethora/plugins/P_ShiftPulse.hpp new file mode 100644 index 0000000..64327ea --- /dev/null +++ b/src/noise-plethora/plugins/P_ShiftPulse.hpp @@ -0,0 +1,102 @@ +#pragma once + +#include +#include "NoisePlethoraPlugin.hpp" + +class ShiftPulse : public NoisePlethoraPlugin { + +public: + + ShiftPulse() { } + + ~ShiftPulse() override {} + + ShiftPulse(const ShiftPulse&) = delete; + ShiftPulse& operator=(const ShiftPulse&) = delete; + + void init() override { + for (int i = 0; i < 4; i++) { + stages[i] = 0.0f; + stageWeights[i] = 0.0f; + } + stageWeights[0] = 1.0f; + sampleCounter = 0; + samplesPerClock = 441; + } + + void process(float k1, float k2) override { + float rate = 5.0f + std::pow(k1, 2) * 295.0f; + samplesPerClock = std::max(1, (int)(44100.0f / rate)); + + // Crossfade stage weights based on k2 + stageWeights[0] = 1.0f; + stageWeights[1] = std::min(1.0f, k2 * 3.0f); + stageWeights[2] = std::min(1.0f, std::max(0.0f, k2 * 3.0f - 1.0f)); + stageWeights[3] = std::min(1.0f, std::max(0.0f, k2 * 3.0f - 2.0f)); + + // Normalize weights + float sum = stageWeights[0] + stageWeights[1] + stageWeights[2] + stageWeights[3]; + if (sum > 0.0f) { + for (int i = 0; i < 4; i++) { + stageWeights[i] /= sum; + } + } + } + + void processGraphAsBlock(TeensyBuffer& blockBuffer) override { + + for (int i = 0; i < AUDIO_BLOCK_SAMPLES; i++) { + sampleCounter++; + if (sampleCounter >= samplesPerClock) { + // Shift register: shift down + stages[3] = stages[2]; + stages[2] = stages[1]; + stages[1] = stages[0]; + stages[0] = random::uniform() * 2.0f - 1.0f; + + sampleCounter = 0; + } + + float out = 0.0f; + for (int s = 0; s < 4; s++) { + out += stageWeights[s] * stages[s]; + } + + // NaN/Inf guard + if (!std::isfinite(out)) { + out = 0.0f; + } + + out += (random::uniform() - 0.5f) * 0.01f; + + if (out > 1.0f) out = 1.0f; + if (out < -1.0f) out = -1.0f; + + int32_t sample = (int32_t)(out * 32767.0f); + if (sample > 32767) sample = 32767; + if (sample < -32767) sample = -32767; + outputBlock.data[i] = (int16_t)sample; + } + + blockBuffer.pushBuffer(outputBlock.data, AUDIO_BLOCK_SAMPLES); + } + + AudioStream& getStream() override { + return dc1; + } + unsigned char getPort() override { + return 0; + } + +private: + AudioSynthWaveformDc dc1; + + audio_block_t outputBlock; + + float stages[4] = {0.0f, 0.0f, 0.0f, 0.0f}; + float stageWeights[4] = {1.0f, 0.0f, 0.0f, 0.0f}; + int sampleCounter = 0; + int samplesPerClock = 441; +}; + +REGISTER_PLUGIN(ShiftPulse); diff --git a/src/noise-plethora/plugins/P_TwinPulse.hpp b/src/noise-plethora/plugins/P_TwinPulse.hpp new file mode 100644 index 0000000..90ad90e --- /dev/null +++ b/src/noise-plethora/plugins/P_TwinPulse.hpp @@ -0,0 +1,101 @@ +#pragma once + +#include +#include "NoisePlethoraPlugin.hpp" + +class TwinPulse : public NoisePlethoraPlugin { + +public: + + TwinPulse() { } + + ~TwinPulse() override {} + + TwinPulse(const TwinPulse&) = delete; + TwinPulse& operator=(const TwinPulse&) = delete; + + void init() override { + currentA = random::uniform() * 2.0f - 1.0f; + targetA = random::uniform() * 2.0f - 1.0f; + currentB = random::uniform() * 2.0f - 1.0f; + targetB = random::uniform() * 2.0f - 1.0f; + counterA = 0; + counterB = 0; + alpha = 0.1f; + correlation = 0.0f; + samplesPerTarget = 441; + } + + void process(float k1, float k2) override { + float rate = 5.0f + std::pow(k1, 2) * 395.0f; + samplesPerTarget = std::max(1, (int)(44100.0f / rate)); + + alpha = 4.0f / (float)samplesPerTarget; + if (alpha > 0.5f) alpha = 0.5f; + + correlation = k2; + } + + void processGraphAsBlock(TeensyBuffer& blockBuffer) override { + + for (int i = 0; i < AUDIO_BLOCK_SAMPLES; i++) { + counterA++; + if (counterA >= samplesPerTarget) { + targetA = random::uniform() * 2.0f - 1.0f; + counterA = 0; + } + + counterB++; + if (counterB >= samplesPerTarget) { + targetB = random::uniform() * 2.0f - 1.0f; + counterB = 0; + } + + currentA = currentA * (1.0f - alpha) + targetA * alpha; + currentB = currentB * (1.0f - alpha) + targetB * alpha; + + // NaN/Inf guard + if (!std::isfinite(currentA)) currentA = 0.0f; + if (!std::isfinite(currentB)) currentB = 0.0f; + + float blendedB = correlation * currentA + (1.0f - correlation) * currentB; + float out = 0.5f * currentA + 0.5f * blendedB; + + out += (random::uniform() - 0.5f) * 0.01f; + + if (out > 1.0f) out = 1.0f; + if (out < -1.0f) out = -1.0f; + + int32_t sample = (int32_t)(out * 32767.0f); + if (sample > 32767) sample = 32767; + if (sample < -32767) sample = -32767; + outputBlock.data[i] = (int16_t)sample; + } + + blockBuffer.pushBuffer(outputBlock.data, AUDIO_BLOCK_SAMPLES); + } + + AudioStream& getStream() override { + return dc1; + } + unsigned char getPort() override { + return 0; + } + +private: + AudioSynthWaveformDc dc1; + + audio_block_t outputBlock; + + float currentA = 0.0f; + float targetA = 0.0f; + float currentB = 0.0f; + float targetB = 0.0f; + int counterA = 0; + int counterB = 0; + int samplesPerTarget = 441; + float alpha = 0.1f; + float correlation = 0.0f; +}; + +REGISTER_PLUGIN(TwinPulse); From 416f149276a8925d05de846535c4fe5ce190ead1 Mon Sep 17 00:00:00 2001 From: Pablo Alcantar Date: Sat, 11 Apr 2026 22:11:57 +0200 Subject: [PATCH 05/14] Fix 3 bugs found in audit - SubHarmonic: normalize mix to prevent clipping when multiple subharmonics are active (max sum was 2.15, now auto-normalized) - LFSRNoise: reset LFSR to seed if it reaches 0x0000 to prevent permanent lockup with non-maximal tap configurations - MetallicNoise: reduce oscillator amplitude from 0.3 to 0.15 to prevent internal clipping (6 * 0.15 = 0.9 < 1.0) Co-Authored-By: Claude Opus 4.6 (1M context) --- src/noise-plethora/plugins/P_LFSRNoise.hpp | 1 + src/noise-plethora/plugins/P_MetallicNoise.hpp | 2 +- src/noise-plethora/plugins/P_SubHarmonic.hpp | 11 +++++++---- 3 files changed, 9 insertions(+), 5 deletions(-) diff --git a/src/noise-plethora/plugins/P_LFSRNoise.hpp b/src/noise-plethora/plugins/P_LFSRNoise.hpp index 5e3bb9e..b06bfaf 100644 --- a/src/noise-plethora/plugins/P_LFSRNoise.hpp +++ b/src/noise-plethora/plugins/P_LFSRNoise.hpp @@ -40,6 +40,7 @@ class LFSRNoise : public NoisePlethoraPlugin { uint16_t masked = lfsr & currentTaps; uint16_t feedback = __builtin_popcount(masked) & 1; lfsr = (lfsr >> 1) | (feedback << 15); + if (lfsr == 0) lfsr = 0xACE1; // prevent permanent lockup clockCounter = 0; } diff --git a/src/noise-plethora/plugins/P_MetallicNoise.hpp b/src/noise-plethora/plugins/P_MetallicNoise.hpp index 2d7d1b6..e6edf86 100644 --- a/src/noise-plethora/plugins/P_MetallicNoise.hpp +++ b/src/noise-plethora/plugins/P_MetallicNoise.hpp @@ -16,7 +16,7 @@ class MetallicNoise : public NoisePlethoraPlugin { void init() override { for (int i = 0; i < 6; i++) { - osc[i].begin(0.3f, baseFreqs[i], WAVEFORM_SQUARE); + osc[i].begin(0.15f, baseFreqs[i], WAVEFORM_SQUARE); // 6*0.15=0.9 max sum, no clipping } mixer1.gain(0, 1.0f); diff --git a/src/noise-plethora/plugins/P_SubHarmonic.hpp b/src/noise-plethora/plugins/P_SubHarmonic.hpp index 3e4f3f3..c936670 100644 --- a/src/noise-plethora/plugins/P_SubHarmonic.hpp +++ b/src/noise-plethora/plugins/P_SubHarmonic.hpp @@ -59,13 +59,16 @@ class SubHarmonic : public NoisePlethoraPlugin { } prevSamplePositive = currentPositive; - // Mix: source quieter, subharmonics louder so you clearly hear them come in + // Mix: source + subharmonics, normalized to prevent clipping float srcFloat = (float)srcSample / 32767.0f; - float mix = 0.15f * srcFloat; + float totalWeight = 0.15f; + for (int d = 0; d < 4; d++) totalWeight += divWeights[d] * 0.35f; + float norm = 0.9f / totalWeight; + float mix = 0.15f * norm * srcFloat; for (int d = 0; d < 4; d++) { - float divValue = divStates[d] ? 0.5f : -0.5f; - mix += divWeights[d] * divValue; + float divValue = divStates[d] ? 0.35f : -0.35f; + mix += divWeights[d] * norm * divValue; } int32_t out = (int32_t)(mix * 32767.0f); From eb2c507c2583fb855b7ba58786fe10fc023e92dc Mon Sep 17 00:00:00 2001 From: Pablo Alcantar Date: Sat, 11 Apr 2026 22:58:01 +0200 Subject: [PATCH 06/14] Differentiate similar-sounding plugins based on spectral analysis MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - NoiseHarmonics: switch bandpass→lowpass output, increase wavefold range, lower Q. Now gritty/buzzy vs TubeResonance's clean resonance. (was 0.963 spectral similarity, should now be much lower) - DualAttractor: increase Lorenz modulation depth 10%→40% of base freq. Frequencies wander dramatically vs DroneBody's stable beating. (was 0.946 similarity) - StochasticPulse: mix dry impulse clicks with filtered output, lower Q from 4.5 to 3.5. Now percussive/clicky vs smooth continuous before. (crest factor was 2.0x, should increase significantly) - BowedMetal: increase resonator r baseline (0.997→0.9985), reduce noise amplitude. More tonal shimmer, less noise floor. (spectral flatness was 0.23/noisy, should drop toward tonal) Co-Authored-By: Claude Opus 4.6 (1M context) --- src/noise-plethora/plugins/P_BowedMetal.hpp | 4 ++-- src/noise-plethora/plugins/P_DualAttractor.hpp | 6 +++--- src/noise-plethora/plugins/P_NoiseHarmonics.hpp | 9 +++++---- src/noise-plethora/plugins/P_StochasticPulse.hpp | 14 ++++++++++++-- 4 files changed, 22 insertions(+), 11 deletions(-) diff --git a/src/noise-plethora/plugins/P_BowedMetal.hpp b/src/noise-plethora/plugins/P_BowedMetal.hpp index 545dfee..91099eb 100644 --- a/src/noise-plethora/plugins/P_BowedMetal.hpp +++ b/src/noise-plethora/plugins/P_BowedMetal.hpp @@ -34,8 +34,8 @@ class BowedMetal : public NoisePlethoraPlugin { // k2 low = struck (short ring, louder noise burst) // k2 high = bowed (long ring, quieter continuous noise) - float ringTime = 0.997f + k2 * 0.0025f; // r: 0.997 → 0.9995 - float noiseLevel = 0.6f - k2 * 0.45f; // 0.6 → 0.15 + float ringTime = 0.9985f + k2 * 0.0013f; // r: 0.9985 → 0.9998 (higher baseline) + float noiseLevel = 0.4f - k2 * 0.32f; // 0.4 → 0.08 (less noise overall) noise1.amplitude(noiseLevel); updateResonators(freq, k2, ringTime); diff --git a/src/noise-plethora/plugins/P_DualAttractor.hpp b/src/noise-plethora/plugins/P_DualAttractor.hpp index da710d0..60b380b 100644 --- a/src/noise-plethora/plugins/P_DualAttractor.hpp +++ b/src/noise-plethora/plugins/P_DualAttractor.hpp @@ -80,9 +80,9 @@ class DualAttractor : public NoisePlethoraPlugin { z2 = 2.0f; } - // Map Lorenz x outputs to frequency offsets - float freq1 = baseFreq + x1 * baseFreq * 0.1f; - float freq2 = baseFreq * 1.5f + x2 * baseFreq * 0.1f; + // Map Lorenz x outputs to frequency offsets — wide modulation for chaotic character + float freq1 = baseFreq + x1 * baseFreq * 0.4f; + float freq2 = baseFreq * 1.5f + x2 * baseFreq * 0.4f; // Clamp frequencies to reasonable range if (freq1 < 20.0f) freq1 = 20.0f; diff --git a/src/noise-plethora/plugins/P_NoiseHarmonics.hpp b/src/noise-plethora/plugins/P_NoiseHarmonics.hpp index 26eea82..8ca7977 100644 --- a/src/noise-plethora/plugins/P_NoiseHarmonics.hpp +++ b/src/noise-plethora/plugins/P_NoiseHarmonics.hpp @@ -23,13 +23,13 @@ class NoiseHarmonics : public NoisePlethoraPlugin { dc1.amplitude(0.5); filter1.frequency(1000); - filter1.resonance(3.0); + filter1.resonance(1.5); // lower Q = wider, grittier character filter1.octaveControl(2.0); } void process(float k1, float k2) override { - float dcAmp = 0.05f + pow(k1, 2) * 0.95f; - float filterFreq = 100.0f + pow(k2, 2) * 8000.0f; + float dcAmp = 0.1f + pow(k1, 2) * 1.5f; // wider range, more aggressive folding + float filterFreq = 60.0f + pow(k2, 2) * 8000.0f; dc1.amplitude(dcAmp); filter1.frequency(filterFreq); @@ -41,7 +41,8 @@ class NoiseHarmonics : public NoisePlethoraPlugin { wavefolder1.update(&noiseBlock, &dcBlock, &wfBlock); filter1.update(&wfBlock, nullptr, &lpBlock, &bpBlock, &hpBlock); - blockBuffer.pushBuffer(bpBlock.data, AUDIO_BLOCK_SAMPLES); + // lowpass instead of bandpass — lets all wavefolder harmonics through + blockBuffer.pushBuffer(lpBlock.data, AUDIO_BLOCK_SAMPLES); } AudioStream& getStream() override { diff --git a/src/noise-plethora/plugins/P_StochasticPulse.hpp b/src/noise-plethora/plugins/P_StochasticPulse.hpp index 4613ded..1371aed 100644 --- a/src/noise-plethora/plugins/P_StochasticPulse.hpp +++ b/src/noise-plethora/plugins/P_StochasticPulse.hpp @@ -16,9 +16,10 @@ class StochasticPulse : public NoisePlethoraPlugin { void init() override { density = 50.0f; lastPulseSign = false; + dryMix = 0.3f; filter1.frequency(1000); - filter1.resonance(4.5f); + filter1.resonance(3.5f); // lower Q = shorter ring, more percussive filter1.octaveControl(1.0f); } @@ -43,9 +44,17 @@ class StochasticPulse : public NoisePlethoraPlugin { } } - // Filter the impulses - use bandpass output for resonant pings + // Filter the impulses + mix dry clicks for percussive attack filter1.update(&impulseBlock, nullptr, &lpBlock, &bpBlock, &hpBlock); + for (int i = 0; i < AUDIO_BLOCK_SAMPLES; i++) { + // Mix: dry click + resonant ring + int32_t mixed = (int32_t)(impulseBlock.data[i] * dryMix) + bpBlock.data[i]; + if (mixed > 32767) mixed = 32767; + if (mixed < -32767) mixed = -32767; + bpBlock.data[i] = (int16_t)mixed; + } + blockBuffer.pushBuffer(bpBlock.data, AUDIO_BLOCK_SAMPLES); } @@ -62,6 +71,7 @@ class StochasticPulse : public NoisePlethoraPlugin { audio_block_t impulseBlock, lpBlock, bpBlock, hpBlock; float density = 50.0f; + float dryMix = 0.3f; bool lastPulseSign = false; }; From 593b6fcc638e3b631cb4b0ee09ff9c64c3ff9794 Mon Sep 17 00:00:00 2001 From: Pablo Alcantar Date: Sat, 11 Apr 2026 23:42:28 +0200 Subject: [PATCH 07/14] Add stereo mode to Noise Plethora MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Right-click → "Stereo Mode" toggles stereo. When active: - Generator B mirrors A's algorithm automatically - XA/YA control both generators' sound parameters - XB becomes stereo width (decorrelation offset between L/R) - YB becomes stereo movement speed (LFO rate for offset) - Both display dots light up to indicate stereo mode - State persisted to JSON Also updates bank aliases in context menu to include new bank names. Co-Authored-By: Claude Opus 4.6 (1M context) --- src/NoisePlethora.cpp | 57 ++++++++++++++++++++++++++++++++++++++----- 1 file changed, 51 insertions(+), 6 deletions(-) diff --git a/src/NoisePlethora.cpp b/src/NoisePlethora.cpp index 4bc9f06..ab5fee9 100644 --- a/src/NoisePlethora.cpp +++ b/src/NoisePlethora.cpp @@ -172,6 +172,11 @@ struct NoisePlethora : Module { ProgramSelector programSelector; // tracks banks and programs for both sections A/B, including which is the "active" section ProgramSelector programSelectorWithCV; // as above, but also with CV for program applied as an offset - works like Plaits Model CV input + + // Stereo mode: B mirrors A's algorithm, XB/YB become stereo width/movement + bool stereoMode = false; + float stereoLFOPhase = 0.f; + float stereoOffset = 0.f; // UI / UX for A/B std::string textDisplayA = " ", textDisplayB = " "; bool isDisplayActiveA = false, isDisplayActiveB = false; @@ -274,6 +279,24 @@ struct NoisePlethora : Module { updateParamsTimer.trigger(updateTimeSecs); } + // Stereo mode: sync B's program to A and update stereo LFO + if (stereoMode && updateParams) { + // Sync B to A's algorithm + std::string_view aName = programSelectorWithCV.getA().getCurrentProgramName(); + if (aName != algorithmName[SECTION_B]) { + // Copy A's bank/program to B + programSelector.getB().setBank(programSelector.getA().getBank()); + programSelector.getB().setProgram(programSelector.getA().getProgram()); + } + + // Update stereo LFO: XB = width, YB = movement speed + float width = params[X_B_PARAM].getValue(); + float speed = params[Y_B_PARAM].getValue(); + stereoLFOPhase += speed * 0.3f * updateTimeSecs; + if (stereoLFOPhase > 1.f) stereoLFOPhase -= 1.f; + stereoOffset = width * 0.4f * std::sin(2.f * M_PI * stereoLFOPhase); + } + // process A, B and C processTopSection(SECTION_A, X_A_PARAM, Y_A_PARAM, FILTER_TYPE_A_PARAM, CUTOFF_A_PARAM, CUTOFF_CV_A_PARAM, RES_A_PARAM, @@ -335,8 +358,17 @@ struct NoisePlethora : Module { float out = 0.f; if (algorithm[SECTION] && outputs[OUTPUT].isConnected()) { - float cvX = params[X_PARAM].getValue() + rescale(inputs[X_INPUT].getVoltage(), -10.f, +10.f, -1.f, 1.f); - float cvY = params[Y_PARAM].getValue() + rescale(inputs[Y_INPUT].getVoltage(), -10.f, +10.f, -1.f, 1.f); + float cvX, cvY; + + if (stereoMode && SECTION == SECTION_B) { + // Stereo mode: B reads A's params. Offset on k2 (timbre), NOT k1 (pitch). + cvX = params[X_A_PARAM].getValue() + rescale(inputs[X_A_INPUT].getVoltage(), -10.f, +10.f, -1.f, 1.f); + cvY = params[Y_A_PARAM].getValue() + rescale(inputs[Y_A_INPUT].getVoltage(), -10.f, +10.f, -1.f, 1.f) + stereoOffset; + } + else { + cvX = params[X_PARAM].getValue() + rescale(inputs[X_INPUT].getVoltage(), -10.f, +10.f, -1.f, 1.f); + cvY = params[Y_PARAM].getValue() + rescale(inputs[Y_INPUT].getVoltage(), -10.f, +10.f, -1.f, 1.f); + } // update parameters of the algorithm if (updateParams) { @@ -425,15 +457,19 @@ struct NoisePlethora : Module { else if (programKnobMode == BANK_MODE) { textDisplayA = 'A' + programSelectorWithCV.getA().getBank(); } - isDisplayActiveA = programSelectorWithCV.getMode() == SECTION_A; + isDisplayActiveA = stereoMode || (programSelectorWithCV.getMode() == SECTION_A); - if (programKnobMode == PROGRAM_MODE) { + if (stereoMode) { + // In stereo mode, B shows same as A + textDisplayB = textDisplayA; + } + else if (programKnobMode == PROGRAM_MODE) { textDisplayB = std::to_string(programSelectorWithCV.getB().getProgram()); } else if (programKnobMode == BANK_MODE) { textDisplayB = 'A' + programSelectorWithCV.getB().getBank(); } - isDisplayActiveB = programSelectorWithCV.getMode() == SECTION_B; + isDisplayActiveB = stereoMode || (programSelectorWithCV.getMode() == SECTION_B); } // handle convoluted logic for the multifunction Program knob @@ -567,6 +603,11 @@ struct NoisePlethora : Module { if (blockDCJ) { blockDC = json_boolean_value(blockDCJ); } + + json_t* stereoModeJ = json_object_get(rootJ, "stereoMode"); + if (stereoModeJ) { + stereoMode = json_boolean_value(stereoModeJ); + } } json_t* dataToJson() override { @@ -577,6 +618,7 @@ struct NoisePlethora : Module { json_object_set_new(rootJ, "bypassFilters", json_boolean(bypassFilters)); json_object_set_new(rootJ, "blockDC", json_boolean(blockDC)); + json_object_set_new(rootJ, "stereoMode", json_boolean(stereoMode)); return rootJ; } @@ -833,7 +875,7 @@ struct NoisePlethoraWidget : ModuleWidget { // build the two algorithm selection menus programmatically menu->addChild(createMenuLabel("Algorithms")); - std::vector bankAliases = {"Textures", "HH Clusters", "Harsh & Wild", "Test"}; + std::vector bankAliases = {"Textures", "HH Clusters", "Harsh & Wild", "Resonant Bodies", "Chaos Machines", "Stochastic"}; char programNames[] = "AB"; for (int sectionId = 0; sectionId < 2; ++sectionId) { @@ -874,6 +916,9 @@ struct NoisePlethoraWidget : ModuleWidget { } + menu->addChild(createMenuLabel("Stereo")); + menu->addChild(createBoolPtrMenuItem("Stereo Mode (B mirrors A, XB=width, YB=speed)", "", &module->stereoMode)); + menu->addChild(createMenuLabel("Filters")); menu->addChild(createBoolPtrMenuItem("Remove DC", "", &module->blockDC)); menu->addChild(createBoolPtrMenuItem("Bypass Filters", "", &module->bypassFilters)); From 60fa85150429a8a90521b06729dbc67144040941 Mon Sep 17 00:00:00 2001 From: Pablo Alcantar Date: Sun, 12 Apr 2026 00:11:15 +0200 Subject: [PATCH 08/14] Add sound categories guide (MD + HTML) Classifies all 60 programs into 5 categories: Drone, Harsh/Noise, Percussive/Rhythmic, Textural/Ambient, and Chaotic/Experimental. Includes versatile programs table and tips per category. Co-Authored-By: Claude Opus 4.6 (1M context) --- NOISE_PLETHORA_CATEGORIES.html | 430 +++++++++++++++++++++++++++++++++ NOISE_PLETHORA_CATEGORIES.md | 140 +++++++++++ 2 files changed, 570 insertions(+) create mode 100644 NOISE_PLETHORA_CATEGORIES.html create mode 100644 NOISE_PLETHORA_CATEGORIES.md diff --git a/NOISE_PLETHORA_CATEGORIES.html b/NOISE_PLETHORA_CATEGORIES.html new file mode 100644 index 0000000..615ce85 --- /dev/null +++ b/NOISE_PLETHORA_CATEGORIES.html @@ -0,0 +1,430 @@ +Noise Plethora Categories

Noise Plethora — Sound Categories

+

Befaco Noise Plethora v1.5 + Banks D, E & F Extension

+

Table of Contents

+ +
+

Every program in the Noise Plethora can be broadly classified by its sonic character. Some programs are versatile and appear in multiple categories depending on knob positions — see Versatile Programs for details.

+
+

🔊 DRONE — Sustained, meditative, evolving

+

Long, sustained tones that evolve slowly. Ideal for ambient backgrounds, meditation, soundscapes, and bass layers. Best experienced with the module's analog filters in lowpass mode with moderate resonance.

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
ProgramNameWhy it works for drone
D-4BowedMetal8 metallic resonators with infinite sustain at high Y. Singing bowl character.
D-6NoiseBells4 ultra-sharp resonant peaks ring continuously. Crystal bell drone.
D-9DroneBodyTwo beating sines + wavefolder. Designed specifically for drones.
D-2TubeResonanceSelf-resonating tube drone at Y=0. Hollow, harmonic series.
D-0CombNoiseSustained metallic resonance at high feedback. Pipe organ character.
E-5FeedbackFMPure sine at Y=0. The most "clean" drone source.
E-6RunawayFilterSelf-oscillating filter whistle. Clean pitched tone.
E-9DualAttractorTwo sines drifting chaotically. Never repeats, always moving.
B-4TriFMcluster6 triangles with ultra-slow phasing. Lush ensemble drift.
B-0ClusterSaw16 sawtooths in tight cluster. Massive shimmering wall.
B-8PartialClusterHarmonic series from unison to bells. Most tuneable cluster.
B-9PhasingCluster16 squares with 16 independent LFOs. Self-evolving forever.
B-5PrimeClusterInharmonic prime number chord. Unique metallic shimmer.
+

Tip: Use stereo mode with BowedMetal or NoiseBells for an immersive, wide drone. Set XB (width) to ~0.3 for subtle stereo.

+
+

⚡ HARSH / NOISE — Aggressive, industrial, digital destruction

+

Raw, aggressive textures. Bitcrushing, distortion, chaotic modulation. Good for industrial music, harsh noise, sound design, and adding grit to other sources via mixing.

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
ProgramNameCharacter
E-4BitShiftXOR of two sawtooths. 8-bit digital screech.
E-7GlitchLoopCaptured noise loop that degrades to 1-bit over time.
C-8Rwalk_BitCrushPW9 random-walk oscillators crushed to 1 bit. Extreme lo-fi.
C-7SatanWorkoutPink noise FM + self-exciting reverb. Relentless.
C-0BasuraTotalLFSR-triggered chaotic bursts with reverb. "Total Garbage."
A-6GrainGlitchGranular + XOR. Broken CD character.
D-7NoiseHarmonicsWavefolded noise through filter. Angry bee swarm.
A-0RadioOhNo4-way cross-modulation. Unstable shortwave radio.
C-6WhoKnowsAudio-rate filter sweeps. Wild and unpredictable.
A-4CrossModRingTriple cascaded ring mod. Maximum sideband chaos.
+

Tip: Harsh programs respond dramatically to the analog resonance control. Crank the module's RES knob with these for screaming filter peaks.

+
+

🥁 PERCUSSIVE / RHYTHMIC — Pulses, clicks, patterns

+

Programs that produce discrete events, rhythmic patterns, or percussive textures. From sparse droplets to dense crackle. Useful as rhythmic noise sources, triggers for other modules, or standalone percussion.

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
ProgramNameCharacter
D-1PluckCloudRandom plucked strings. Kalimba in the rain.
D-8IceRainSparse droplets + reverb tails. Crystalline ambient percussion.
E-3StochasticPulseRandom metallic pings with resonant filter. Geiger counter.
E-8SubHarmonicSquare wave + sub-octave dividers. Tectonic bass pulse.
A-9BasurillaNoise gated by 3 pulse LFOs. Complex rhythmic chopping.
F-0PulseWanderOrganic random walk pulses. Breathing rhythm.
F-1TwinPulseTwo correlated pulse streams. Polyrhythmic interference.
F-7NoiseBurstSporadic noise bursts with envelope. Rain on window.
F-4ShiftPulse4-stage shift register. Cascading pulse echoes.
E-2CellularSynthCellular automaton patterns. Self-rewriting music box.
+

Tip: PluckCloud (D-1) and IceRain (D-8) are the most "musical" percussive sources. Use the analog lowpass filter to tame the high end for a warmer, more natural percussion texture.

+
+

🌊 TEXTURAL / AMBIENT — Atmospheric, spatial, enveloping

+

Smooth, evolving, atmospheric textures. Filtered noise, spatial effects, organic movement. Ideal for ambient soundscapes, film sound design, and background layers.

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
ProgramNameCharacter
D-3FormantNoiseGhost choir morphing through vowels. Robotic whispers.
D-5FlangeNoiseSwept comb filter on noise. Jet engine, ocean waves.
C-9Rwalk_LFreePWM random walk + clean reverb. Dreamy, spacious.
C-3S_HSample-hold + reverb. Ambient stochastic clicks.
C-5ExistenceIsPain4 slow LFO-swept filters. Deep, breathing, organic.
A-1Rwalk_SineFMFlangeFM + random walk + flanger. Complex atmospheric.
F-6NoiseSlewSlew-limited noise. From smooth waves to hiss.
B-7FibonacciClusterGolden ratio spacing. Naturally balanced shimmer.
C-2WalkingFilomena16 random-walk oscillators. Living, breathing mass.
B-3SineFMclusterSubharmonic FM. Warm analog ensemble.
+

Tip: These textures shine in stereo mode. FormantNoise (D-3) in stereo with XB at ~0.4 creates a wide vocal-like wash where each channel whispers slightly different vowels.

+
+

🔮 CHAOTIC / EXPERIMENTAL — Unpredictable, mathematical, alien

+

Programs based on mathematical chaos, digital logic, and stochastic processes. Sounds that don't exist in the acoustic world. For experimental music, generative systems, and sound design.

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
ProgramNameCharacter
E-0LogisticNoiseLogistic map. Order dissolving into chaos. Period-3 windows.
E-1HenonDustHenon attractor. Alien vinyl crackle.
E-2CellularSynthCellular automaton. Self-rewriting alien music box.
F-2QuantPulseQuantized random (1-6 bits). Digital stepped textures.
F-3ShapedPulseShaped probability distribution. Uniform to gaussian.
F-5MetallicNoise6 inharmonic squares (cymbal technique). Pure metallic.
F-8LFSRNoiseShift register sequences. 4-bit retro digital patterns.
F-9DualPulseTwo S&H at independent rates. Polyrhythmic steps.
C-4ArrayOnTheRocksCorrupted wavetable + FM. Broken digital beauty.
A-2xModRingSqrCross-FM ring mod squares. Metallic clang.
+

Tip: LogisticNoise (E-0) is the most unique program in the module. Slowly sweep X from left to right to hear the transition from periodic order through bifurcation into full chaos. The period-3 window at X≈0.66 is a brief island of order in the noise — genuinely beautiful mathematics made audible.

+
+

Versatile Programs

+

These programs change category dramatically depending on knob positions:

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
ProgramY lowY highRange
E-5 FeedbackFMPure sine (DRONE)White noise (HARSH)The entire timbral spectrum in one knob
E-6 RunawayFilterClean whistle (DRONE)Resonant noise (TEXTURAL)Self-oscillation to noise wash
D-2 TubeResonanceHollow drone (DRONE)Breathy pipe (TEXTURAL)Self-resonance to wind
E-2 CellularSynthSteady drone (DRONE, simple rules)Rapid mutation (CHAOTIC, Rule 30)Order to chaos via rule selection
D-4 BowedMetalStruck cymbal (PERCUSSIVE, Y low)Infinite shimmer (DRONE, Y high)Hit to sustain
B-8 PartialClusterDense unison (DRONE, Y≈1)Metallic bells (CHAOTIC, Y>2)Harmonic to inharmonic
C-7 SatanWorkoutRaw noise texture (HARSH)Self-exciting reverb feedback (EXPERIMENTAL)Noise to feedback

Befaco Noise Plethora v1.5 + Banks D, E & F extension.

\ No newline at end of file diff --git a/NOISE_PLETHORA_CATEGORIES.md b/NOISE_PLETHORA_CATEGORIES.md new file mode 100644 index 0000000..c3eab3c --- /dev/null +++ b/NOISE_PLETHORA_CATEGORIES.md @@ -0,0 +1,140 @@ +# Noise Plethora — Sound Categories + +*Befaco Noise Plethora v1.5 + Banks D, E & F Extension* + +## Table of Contents + +- [Drone](#-drone--sustained-meditative-evolving) +- [Harsh / Noise](#-harsh--noise--aggressive-industrial-digital-destruction) +- [Percussive / Rhythmic](#-percussive--rhythmic--pulses-clicks-patterns) +- [Textural / Ambient](#-textural--ambient--atmospheric-spatial-enveloping) +- [Chaotic / Experimental](#-chaotic--experimental--unpredictable-mathematical-alien) +- [Versatile Programs](#versatile-programs) + +--- + +Every program in the Noise Plethora can be broadly classified by its sonic character. Some programs are versatile and appear in multiple categories depending on knob positions — see [Versatile Programs](#versatile-programs) for details. + +--- + +### 🔊 DRONE — Sustained, meditative, evolving + +Long, sustained tones that evolve slowly. Ideal for ambient backgrounds, meditation, soundscapes, and bass layers. Best experienced with the module's analog filters in lowpass mode with moderate resonance. + +| Program | Name | Why it works for drone | +|---------|------|----------------------| +| D-4 | BowedMetal | 8 metallic resonators with infinite sustain at high Y. Singing bowl character. | +| D-6 | NoiseBells | 4 ultra-sharp resonant peaks ring continuously. Crystal bell drone. | +| D-9 | DroneBody | Two beating sines + wavefolder. Designed specifically for drones. | +| D-2 | TubeResonance | Self-resonating tube drone at Y=0. Hollow, harmonic series. | +| D-0 | CombNoise | Sustained metallic resonance at high feedback. Pipe organ character. | +| E-5 | FeedbackFM | Pure sine at Y=0. The most "clean" drone source. | +| E-6 | RunawayFilter | Self-oscillating filter whistle. Clean pitched tone. | +| E-9 | DualAttractor | Two sines drifting chaotically. Never repeats, always moving. | +| B-4 | TriFMcluster | 6 triangles with ultra-slow phasing. Lush ensemble drift. | +| B-0 | ClusterSaw | 16 sawtooths in tight cluster. Massive shimmering wall. | +| B-8 | PartialCluster | Harmonic series from unison to bells. Most tuneable cluster. | +| B-9 | PhasingCluster | 16 squares with 16 independent LFOs. Self-evolving forever. | +| B-5 | PrimeCluster | Inharmonic prime number chord. Unique metallic shimmer. | + +**Tip:** Use stereo mode with BowedMetal or NoiseBells for an immersive, wide drone. Set XB (width) to ~0.3 for subtle stereo. + +--- + +### ⚡ HARSH / NOISE — Aggressive, industrial, digital destruction + +Raw, aggressive textures. Bitcrushing, distortion, chaotic modulation. Good for industrial music, harsh noise, sound design, and adding grit to other sources via mixing. + +| Program | Name | Character | +|---------|------|-----------| +| E-4 | BitShift | XOR of two sawtooths. 8-bit digital screech. | +| E-7 | GlitchLoop | Captured noise loop that degrades to 1-bit over time. | +| C-8 | Rwalk_BitCrushPW | 9 random-walk oscillators crushed to 1 bit. Extreme lo-fi. | +| C-7 | SatanWorkout | Pink noise FM + self-exciting reverb. Relentless. | +| C-0 | BasuraTotal | LFSR-triggered chaotic bursts with reverb. "Total Garbage." | +| A-6 | GrainGlitch | Granular + XOR. Broken CD character. | +| D-7 | NoiseHarmonics | Wavefolded noise through filter. Angry bee swarm. | +| A-0 | RadioOhNo | 4-way cross-modulation. Unstable shortwave radio. | +| C-6 | WhoKnows | Audio-rate filter sweeps. Wild and unpredictable. | +| A-4 | CrossModRing | Triple cascaded ring mod. Maximum sideband chaos. | + +**Tip:** Harsh programs respond dramatically to the analog resonance control. Crank the module's RES knob with these for screaming filter peaks. + +--- + +### 🥁 PERCUSSIVE / RHYTHMIC — Pulses, clicks, patterns + +Programs that produce discrete events, rhythmic patterns, or percussive textures. From sparse droplets to dense crackle. Useful as rhythmic noise sources, triggers for other modules, or standalone percussion. + +| Program | Name | Character | +|---------|------|-----------| +| D-1 | PluckCloud | Random plucked strings. Kalimba in the rain. | +| D-8 | IceRain | Sparse droplets + reverb tails. Crystalline ambient percussion. | +| E-3 | StochasticPulse | Random metallic pings with resonant filter. Geiger counter. | +| E-8 | SubHarmonic | Square wave + sub-octave dividers. Tectonic bass pulse. | +| A-9 | Basurilla | Noise gated by 3 pulse LFOs. Complex rhythmic chopping. | +| F-0 | PulseWander | Organic random walk pulses. Breathing rhythm. | +| F-1 | TwinPulse | Two correlated pulse streams. Polyrhythmic interference. | +| F-7 | NoiseBurst | Sporadic noise bursts with envelope. Rain on window. | +| F-4 | ShiftPulse | 4-stage shift register. Cascading pulse echoes. | +| E-2 | CellularSynth | Cellular automaton patterns. Self-rewriting music box. | + +**Tip:** PluckCloud (D-1) and IceRain (D-8) are the most "musical" percussive sources. Use the analog lowpass filter to tame the high end for a warmer, more natural percussion texture. + +--- + +### 🌊 TEXTURAL / AMBIENT — Atmospheric, spatial, enveloping + +Smooth, evolving, atmospheric textures. Filtered noise, spatial effects, organic movement. Ideal for ambient soundscapes, film sound design, and background layers. + +| Program | Name | Character | +|---------|------|-----------| +| D-3 | FormantNoise | Ghost choir morphing through vowels. Robotic whispers. | +| D-5 | FlangeNoise | Swept comb filter on noise. Jet engine, ocean waves. | +| C-9 | Rwalk_LFree | PWM random walk + clean reverb. Dreamy, spacious. | +| C-3 | S_H | Sample-hold + reverb. Ambient stochastic clicks. | +| C-5 | ExistenceIsPain | 4 slow LFO-swept filters. Deep, breathing, organic. | +| A-1 | Rwalk_SineFMFlange | FM + random walk + flanger. Complex atmospheric. | +| F-6 | NoiseSlew | Slew-limited noise. From smooth waves to hiss. | +| B-7 | FibonacciCluster | Golden ratio spacing. Naturally balanced shimmer. | +| C-2 | WalkingFilomena | 16 random-walk oscillators. Living, breathing mass. | +| B-3 | SineFMcluster | Subharmonic FM. Warm analog ensemble. | + +**Tip:** These textures shine in stereo mode. FormantNoise (D-3) in stereo with XB at ~0.4 creates a wide vocal-like wash where each channel whispers slightly different vowels. + +--- + +### 🔮 CHAOTIC / EXPERIMENTAL — Unpredictable, mathematical, alien + +Programs based on mathematical chaos, digital logic, and stochastic processes. Sounds that don't exist in the acoustic world. For experimental music, generative systems, and sound design. + +| Program | Name | Character | +|---------|------|-----------| +| E-0 | LogisticNoise | Logistic map. Order dissolving into chaos. Period-3 windows. | +| E-1 | HenonDust | Henon attractor. Alien vinyl crackle. | +| E-2 | CellularSynth | Cellular automaton. Self-rewriting alien music box. | +| F-2 | QuantPulse | Quantized random (1-6 bits). Digital stepped textures. | +| F-3 | ShapedPulse | Shaped probability distribution. Uniform to gaussian. | +| F-5 | MetallicNoise | 6 inharmonic squares (cymbal technique). Pure metallic. | +| F-8 | LFSRNoise | Shift register sequences. 4-bit retro digital patterns. | +| F-9 | DualPulse | Two S&H at independent rates. Polyrhythmic steps. | +| C-4 | ArrayOnTheRocks | Corrupted wavetable + FM. Broken digital beauty. | +| A-2 | xModRingSqr | Cross-FM ring mod squares. Metallic clang. | + +**Tip:** LogisticNoise (E-0) is the most unique program in the module. Slowly sweep X from left to right to hear the transition from periodic order through bifurcation into full chaos. The period-3 window at X≈0.66 is a brief island of order in the noise — genuinely beautiful mathematics made audible. + +--- + +## Versatile Programs + +These programs change category dramatically depending on knob positions: + +| Program | Y low | Y high | Range | +|---------|-------|--------|-------| +| **E-5 FeedbackFM** | Pure sine (DRONE) | White noise (HARSH) | The entire timbral spectrum in one knob | +| **E-6 RunawayFilter** | Clean whistle (DRONE) | Resonant noise (TEXTURAL) | Self-oscillation to noise wash | +| **D-2 TubeResonance** | Hollow drone (DRONE) | Breathy pipe (TEXTURAL) | Self-resonance to wind | +| **E-2 CellularSynth** | Steady drone (DRONE, simple rules) | Rapid mutation (CHAOTIC, Rule 30) | Order to chaos via rule selection | +| **D-4 BowedMetal** | Struck cymbal (PERCUSSIVE, Y low) | Infinite shimmer (DRONE, Y high) | Hit to sustain | +| **B-8 PartialCluster** | Dense unison (DRONE, Y≈1) | Metallic bells (CHAOTIC, Y>2) | Harmonic to inharmonic | +| **C-7 SatanWorkout** | Raw noise texture (HARSH) | Self-exciting reverb feedback (EXPERIMENTAL) | Noise to feedback | From 8d178265de24b300f462984111a81c65c5074bec Mon Sep 17 00:00:00 2001 From: Pablo Alcantar Date: Sun, 12 Apr 2026 00:11:26 +0200 Subject: [PATCH 09/14] Add stereo mode guide (MD + HTML) Documents stereo mode activation (VCV + hardware), control mapping, internal signal flow, offset formula, and 5 stereo patch ideas. Co-Authored-By: Claude Opus 4.6 (1M context) --- NOISE_PLETHORA_STEREO_GUIDE.html | 224 +++++++++++++++++++++++++++++++ NOISE_PLETHORA_STEREO_GUIDE.md | 153 +++++++++++++++++++++ 2 files changed, 377 insertions(+) create mode 100644 NOISE_PLETHORA_STEREO_GUIDE.html create mode 100644 NOISE_PLETHORA_STEREO_GUIDE.md diff --git a/NOISE_PLETHORA_STEREO_GUIDE.html b/NOISE_PLETHORA_STEREO_GUIDE.html new file mode 100644 index 0000000..6fc0405 --- /dev/null +++ b/NOISE_PLETHORA_STEREO_GUIDE.html @@ -0,0 +1,224 @@ +Noise Plethora Stereo Guide

Noise Plethora — Stereo Mode Guide

+

Befaco Noise Plethora v1.5 + Banks D, E & F Extension

+

Table of Contents

+ +
+

What It Does

+

Stereo mode transforms the Noise Plethora from two independent mono generators into a single stereo sound source. Generator B automatically mirrors Generator A's algorithm, and the B knobs (XB/YB) are repurposed as stereo controls.

+

The result: a wide stereo field from a single algorithm, where the left and right channels share the same pitch but differ in timbral character. The difference varies slowly over time, creating organic stereo movement.

+
+

How to Activate (VCV Rack)

+
    +
  1. Right-click on the Noise Plethora module
    2. +
  2. Under "Stereo," check "Stereo Mode"
    3. +
  3. Both display dots light up to confirm stereo is active
    4. +
  4. To deactivate: right-click and uncheck
    5. +
+
+

How to Activate (Hardware)

+

Double-click the Program/Bank encoder (two quick clicks within 300ms):

+ + + + + + + + + + + + + + + + + + + + + +
GestureAction
Single clickToggle between Gen A and Gen B (normal)
Double-clickToggle stereo mode
Hold 400msEnter/exit bank mode
+

When stereo mode is active: +- Both dots on the 7-segment display light up simultaneously +- The display briefly shows "St" on activation and "no" on deactivation +- Both digits show the same program number

+
+

Controls in Stereo Mode

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
ControlNormal ModeStereo Mode
XA knobk1 for Gen Ak1 for both (pitch/primary param)
YA knobk2 for Gen Ak2 for both (timbre/secondary param)
XB knobk1 for Gen BStereo Width (0=mono, 1=wide)
YB knobk2 for Gen BStereo Movement (LFO speed for width modulation)
CV XACV for k1 ACV for k1 both
CV YACV for k2 ACV for k2 both
CV XBCV for k1 BNot used (manual only)
CV YBCV for k2 BNot used (manual only)
EncoderSelect program for A or BSelect program for both
Filter AFilter for Gen AFilter for left channel
Filter BFilter for Gen BFilter for right channel
+

Note: The analog filters remain fully independent in stereo mode. This is a feature — setting the two filters differently (e.g., LP on left, HP on right) adds an additional layer of stereo character on top of the digital decorrelation.

+
+

How It Works Internally

+
                    XA (k1) ─────────────────────→ Gen A ──→ Filter A ──→ LEFT
+                    YA (k2) ─────────────────────→   │
+                                                      │
+                                                      │ (same algorithm)
+                                                      │
+                    XA (k1) ─────────────────────→ Gen B ──→ Filter B ──→ RIGHT
+                    YA (k2) + stereo offset ─────→   │
+                                                      │
+                    XB ──→ offset amount              │
+                    YB ──→ offset LFO speed ──────────┘
+
+

The stereo offset is applied to k2 (timbre), not k1 (pitch). This is critical — it means both channels always play at the same frequency, but with slightly different timbral character. This creates a natural, phase-free stereo width without the pitch-detuning artifacts of traditional chorus effects.

+

The offset follows a slow sine LFO:

+
offset = XB × 0.4 × sin(2π × YB × 0.3 × time)
+
+
    +
  • XB = 0: offset is zero → mono (both channels identical)
    • +
  • XB = 0.5: offset swings ±0.2 → moderate stereo width
    • +
  • XB = 1.0: offset swings ±0.4 → maximum stereo width
    • +
  • YB = 0: offset is static → fixed stereo spread
    • +
  • YB = 0.5: offset moves slowly → gentle stereo movement
    • +
  • YB = 1.0: offset moves faster → animated stereo field
    • +
+
+

Stereo Patch Ideas

+

1. Immersive Bell Drone

+
    +
  • Program: D-6 NoiseBells
    • +
  • Stereo Mode: ON
    • +
  • XA: ~0.3 (medium bell pitch)
    • +
  • YA: ~0.2 (nearly harmonic, chime-like)
    • +
  • XB: 0.3 (moderate width)
    • +
  • YB: 0.15 (very slow movement)
    • +
  • Filter A: LP, cutoff medium, res low
    • +
  • Filter B: LP, cutoff slightly higher than A
    • +
  • Result: wide, shimmering bell drone where each ear hears slightly different harmonic content
    • +
+

2. Vocal Wash

+
    +
  • Program: D-3 FormantNoise
    • +
  • Stereo Mode: ON
    • +
  • XA: modulated by slow LFO (vowel morphing)
    • +
  • YA: ~0.6 (moderate resonance)
    • +
  • XB: 0.5 (wide)
    • +
  • YB: 0.2 (slow drift)
    • +
  • Filter A: BP, cutoff ~1kHz
    • +
  • Filter B: BP, cutoff ~1.5kHz
    • +
  • Result: ghostly stereo choir, each ear whispers a slightly different vowel
    • +
+

3. Metallic Stereo Texture

+
    +
  • Program: D-4 BowedMetal
    • +
  • Stereo Mode: ON
    • +
  • XA: ~0.4
    • +
  • YA: ~0.8 (long sustain, bowed character)
    • +
  • XB: 0.6 (wide separation)
    • +
  • YB: 0.3 (moderate movement)
    • +
  • Filter A: HP, cutoff low (full spectrum)
    • +
  • Filter B: LP, cutoff medium (darker)
    • +
  • Result: left ear = bright metallic shimmer, right ear = dark resonant glow. Complementary stereo.
    • +
+

4. Chaos Stereo Field

+
    +
  • Program: E-9 DualAttractor
    • +
  • Stereo Mode: ON
    • +
  • XA: ~0.5 (moderate coupling)
    • +
  • YA: ~0.4
    • +
  • XB: 0.4
    • +
  • YB: 0.4
    • +
  • Result: two Lorenz attractors already create wandering tones. In stereo mode, the additional timbral offset makes each channel's attractor feel independent while remaining harmonically related.
    • +
+

5. Wide Cluster

+
    +
  • Program: B-0 ClusterSaw
    • +
  • Stereo Mode: ON
    • +
  • XA: ~0.3 (low fundamental)
    • +
  • YA: ~0.1 (tight cluster = thick unison)
    • +
  • XB: 0.2 (subtle width)
    • +
  • YB: 0.1 (very slow)
    • +
  • Result: massive wide chorused sawtooth wall. The subtle timbral difference between channels creates a huge sound from a simple cluster.
    • +

Befaco Noise Plethora v1.5 + Banks D, E & F extension.

\ No newline at end of file diff --git a/NOISE_PLETHORA_STEREO_GUIDE.md b/NOISE_PLETHORA_STEREO_GUIDE.md new file mode 100644 index 0000000..d33e018 --- /dev/null +++ b/NOISE_PLETHORA_STEREO_GUIDE.md @@ -0,0 +1,153 @@ +# Noise Plethora — Stereo Mode Guide + +*Befaco Noise Plethora v1.5 + Banks D, E & F Extension* + +## Table of Contents + +- [What It Does](#what-it-does) +- [How to Activate (VCV Rack)](#how-to-activate-vcv-rack) +- [How to Activate (Hardware)](#how-to-activate-hardware) +- [Controls in Stereo Mode](#controls-in-stereo-mode) +- [How It Works Internally](#how-it-works-internally) +- [Stereo Patch Ideas](#stereo-patch-ideas) + +--- + +## What It Does + +Stereo mode transforms the Noise Plethora from two independent mono generators into a single **stereo sound source**. Generator B automatically mirrors Generator A's algorithm, and the B knobs (XB/YB) are repurposed as stereo controls. + +The result: a wide stereo field from a single algorithm, where the left and right channels share the same pitch but differ in timbral character. The difference varies slowly over time, creating organic stereo movement. + +--- + +## How to Activate (VCV Rack) + +1. **Right-click** on the Noise Plethora module +2. Under "Stereo," check **"Stereo Mode"** +3. Both display dots light up to confirm stereo is active +4. To deactivate: right-click and uncheck + +--- + +## How to Activate (Hardware) + +**Double-click** the Program/Bank encoder (two quick clicks within 300ms): + +| Gesture | Action | +|---------|--------| +| Single click | Toggle between Gen A and Gen B (normal) | +| **Double-click** | **Toggle stereo mode** | +| Hold 400ms | Enter/exit bank mode | + +When stereo mode is active: +- Both dots on the 7-segment display light up simultaneously +- The display briefly shows "St" on activation and "no" on deactivation +- Both digits show the same program number + +--- + +## Controls in Stereo Mode + +| Control | Normal Mode | Stereo Mode | +|---------|------------|-------------| +| **XA knob** | k1 for Gen A | k1 for **both** (pitch/primary param) | +| **YA knob** | k2 for Gen A | k2 for **both** (timbre/secondary param) | +| **XB knob** | k1 for Gen B | **Stereo Width** (0=mono, 1=wide) | +| **YB knob** | k2 for Gen B | **Stereo Movement** (LFO speed for width modulation) | +| **CV XA** | CV for k1 A | CV for k1 **both** | +| **CV YA** | CV for k2 A | CV for k2 **both** | +| **CV XB** | CV for k1 B | Not used (manual only) | +| **CV YB** | CV for k2 B | Not used (manual only) | +| **Encoder** | Select program for A or B | Select program for **both** | +| **Filter A** | Filter for Gen A | Filter for **left channel** | +| **Filter B** | Filter for Gen B | Filter for **right channel** | + +**Note:** The analog filters remain fully independent in stereo mode. This is a feature — setting the two filters differently (e.g., LP on left, HP on right) adds an additional layer of stereo character on top of the digital decorrelation. + +--- + +## How It Works Internally + +``` + XA (k1) ─────────────────────→ Gen A ──→ Filter A ──→ LEFT + YA (k2) ─────────────────────→ │ + │ + │ (same algorithm) + │ + XA (k1) ─────────────────────→ Gen B ──→ Filter B ──→ RIGHT + YA (k2) + stereo offset ─────→ │ + │ + XB ──→ offset amount │ + YB ──→ offset LFO speed ──────────┘ +``` + +**The stereo offset is applied to k2 (timbre), not k1 (pitch).** This is critical — it means both channels always play at the same frequency, but with slightly different timbral character. This creates a natural, phase-free stereo width without the pitch-detuning artifacts of traditional chorus effects. + +The offset follows a slow sine LFO: + +``` +offset = XB × 0.4 × sin(2π × YB × 0.3 × time) +``` + +- **XB = 0**: offset is zero → mono (both channels identical) +- **XB = 0.5**: offset swings ±0.2 → moderate stereo width +- **XB = 1.0**: offset swings ±0.4 → maximum stereo width +- **YB = 0**: offset is static → fixed stereo spread +- **YB = 0.5**: offset moves slowly → gentle stereo movement +- **YB = 1.0**: offset moves faster → animated stereo field + +--- + +## Stereo Patch Ideas + +### 1. Immersive Bell Drone +- Program: **D-6 NoiseBells** +- Stereo Mode: ON +- XA: ~0.3 (medium bell pitch) +- YA: ~0.2 (nearly harmonic, chime-like) +- XB: 0.3 (moderate width) +- YB: 0.15 (very slow movement) +- Filter A: LP, cutoff medium, res low +- Filter B: LP, cutoff slightly higher than A +- *Result: wide, shimmering bell drone where each ear hears slightly different harmonic content* + +### 2. Vocal Wash +- Program: **D-3 FormantNoise** +- Stereo Mode: ON +- XA: modulated by slow LFO (vowel morphing) +- YA: ~0.6 (moderate resonance) +- XB: 0.5 (wide) +- YB: 0.2 (slow drift) +- Filter A: BP, cutoff ~1kHz +- Filter B: BP, cutoff ~1.5kHz +- *Result: ghostly stereo choir, each ear whispers a slightly different vowel* + +### 3. Metallic Stereo Texture +- Program: **D-4 BowedMetal** +- Stereo Mode: ON +- XA: ~0.4 +- YA: ~0.8 (long sustain, bowed character) +- XB: 0.6 (wide separation) +- YB: 0.3 (moderate movement) +- Filter A: HP, cutoff low (full spectrum) +- Filter B: LP, cutoff medium (darker) +- *Result: left ear = bright metallic shimmer, right ear = dark resonant glow. Complementary stereo.* + +### 4. Chaos Stereo Field +- Program: **E-9 DualAttractor** +- Stereo Mode: ON +- XA: ~0.5 (moderate coupling) +- YA: ~0.4 +- XB: 0.4 +- YB: 0.4 +- *Result: two Lorenz attractors already create wandering tones. In stereo mode, the additional timbral offset makes each channel's attractor feel independent while remaining harmonically related.* + +### 5. Wide Cluster +- Program: **B-0 ClusterSaw** +- Stereo Mode: ON +- XA: ~0.3 (low fundamental) +- YA: ~0.1 (tight cluster = thick unison) +- XB: 0.2 (subtle width) +- YB: 0.1 (very slow) +- *Result: massive wide chorused sawtooth wall. The subtle timbral difference between channels creates a huge sound from a simple cluster.* From a851338056f17c29e7a1527251a4d413d996bbb4 Mon Sep 17 00:00:00 2001 From: Pablo Alcantar Date: Sun, 12 Apr 2026 11:46:37 +0200 Subject: [PATCH 10/14] Improve stereo mode: real L/R amplitude panning Replace timbral offset with real amplitude panning (gainL/gainR modulated by sine LFO). Quadratic speed response (max 1.5 Hz) matches firmware behavior. XB controls pan width (0=mono center, 1=full L/R swing), YB controls pan LFO speed. Co-Authored-By: Claude Opus 4.6 (1M context) --- src/NoisePlethora.cpp | 27 ++++++++++++++++++--------- 1 file changed, 18 insertions(+), 9 deletions(-) diff --git a/src/NoisePlethora.cpp b/src/NoisePlethora.cpp index ab5fee9..be4877a 100644 --- a/src/NoisePlethora.cpp +++ b/src/NoisePlethora.cpp @@ -173,10 +173,11 @@ struct NoisePlethora : Module { ProgramSelector programSelector; // tracks banks and programs for both sections A/B, including which is the "active" section ProgramSelector programSelectorWithCV; // as above, but also with CV for program applied as an offset - works like Plaits Model CV input - // Stereo mode: B mirrors A's algorithm, XB/YB become stereo width/movement + // Stereo mode: B mirrors A's algorithm, XB/YB become stereo pan width/speed bool stereoMode = false; float stereoLFOPhase = 0.f; - float stereoOffset = 0.f; + float stereoGainL = 1.f; + float stereoGainR = 1.f; // UI / UX for A/B std::string textDisplayA = " ", textDisplayB = " "; bool isDisplayActiveA = false, isDisplayActiveB = false; @@ -289,12 +290,15 @@ struct NoisePlethora : Module { programSelector.getB().setProgram(programSelector.getA().getProgram()); } - // Update stereo LFO: XB = width, YB = movement speed + // Update stereo LFO: XB = pan width, YB = pan speed + // Real L/R panning via amplitude modulation float width = params[X_B_PARAM].getValue(); float speed = params[Y_B_PARAM].getValue(); - stereoLFOPhase += speed * 0.3f * updateTimeSecs; + stereoLFOPhase += speed * speed * 1.5f * updateTimeSecs; // quadratic: max 1.5 Hz if (stereoLFOPhase > 1.f) stereoLFOPhase -= 1.f; - stereoOffset = width * 0.4f * std::sin(2.f * M_PI * stereoLFOPhase); + float pan = width * std::sin(2.f * M_PI * stereoLFOPhase); + stereoGainL = clamp(1.f - pan, 0.f, 2.f) * 0.5f; + stereoGainR = clamp(1.f + pan, 0.f, 2.f) * 0.5f; } // process A, B and C @@ -361,9 +365,9 @@ struct NoisePlethora : Module { float cvX, cvY; if (stereoMode && SECTION == SECTION_B) { - // Stereo mode: B reads A's params. Offset on k2 (timbre), NOT k1 (pitch). + // Stereo mode: B reads A's params (same pitch and timbre) cvX = params[X_A_PARAM].getValue() + rescale(inputs[X_A_INPUT].getVoltage(), -10.f, +10.f, -1.f, 1.f); - cvY = params[Y_A_PARAM].getValue() + rescale(inputs[Y_A_INPUT].getVoltage(), -10.f, +10.f, -1.f, 1.f) + stereoOffset; + cvY = params[Y_A_PARAM].getValue() + rescale(inputs[Y_A_INPUT].getVoltage(), -10.f, +10.f, -1.f, 1.f); } else { cvX = params[X_PARAM].getValue() + rescale(inputs[X_INPUT].getVoltage(), -10.f, +10.f, -1.f, 1.f); @@ -403,7 +407,12 @@ struct NoisePlethora : Module { } } - outputs[OUTPUT].setVoltage(Saturator::process(out) * 5.f); + // Apply stereo panning gain + float stereoGain = 1.f; + if (stereoMode) { + stereoGain = (SECTION == SECTION_A) ? stereoGainL : stereoGainR; + } + outputs[OUTPUT].setVoltage(Saturator::process(out) * 5.f * stereoGain); } // process section C @@ -917,7 +926,7 @@ struct NoisePlethoraWidget : ModuleWidget { } menu->addChild(createMenuLabel("Stereo")); - menu->addChild(createBoolPtrMenuItem("Stereo Mode (B mirrors A, XB=width, YB=speed)", "", &module->stereoMode)); + menu->addChild(createBoolPtrMenuItem("Stereo Mode (B mirrors A, XB=pan width, YB=pan speed)", "", &module->stereoMode)); menu->addChild(createMenuLabel("Filters")); menu->addChild(createBoolPtrMenuItem("Remove DC", "", &module->blockDC)); From cbe7d0e80b22369a72156f7e5f442be0df2452db Mon Sep 17 00:00:00 2001 From: Pablo Alcantar Date: Sun, 12 Apr 2026 12:20:09 +0200 Subject: [PATCH 11/14] Sync documentation with firmware repo - Fix incorrect "3 generators (A, B, C)" to "2 generators (A and B)" - Update STEREO_GUIDE to match actual implementation (amplitude panning, not timbral offset), add state behavior section, display details, and hardware-specific controls Co-Authored-By: Claude Opus 4.6 (1M context) --- NOISE_PLETHORA_PLUGIN_GUIDE.md | 2 +- NOISE_PLETHORA_STEREO_GUIDE.md | 135 +++++++++++++++++++++++---------- 2 files changed, 94 insertions(+), 43 deletions(-) diff --git a/NOISE_PLETHORA_PLUGIN_GUIDE.md b/NOISE_PLETHORA_PLUGIN_GUIDE.md index d1d11ec..88cfc3d 100644 --- a/NOISE_PLETHORA_PLUGIN_GUIDE.md +++ b/NOISE_PLETHORA_PLUGIN_GUIDE.md @@ -4,7 +4,7 @@ ## About This Guide -The Noise Plethora is a Eurorack noise workstation with 3 digital sound generators (A, B, and C), each followed by an analog multimode filter. Generators A and B run interchangeable algorithms organized in banks of 10. Each algorithm has two parameters controlled by the **X** and **Y** knobs (and their corresponding CV inputs, 0–10Vpp). +The Noise Plethora is a Eurorack noise workstation with 2 digital sound generators (A and B), each followed by an analog multimode filter. Generators A and B run interchangeable algorithms organized in banks of 10. Each algorithm has two parameters controlled by the **X** and **Y** knobs (and their corresponding CV inputs, 0–10Vpp). This guide documents all 60 algorithms across 6 banks: diff --git a/NOISE_PLETHORA_STEREO_GUIDE.md b/NOISE_PLETHORA_STEREO_GUIDE.md index d33e018..88a80da 100644 --- a/NOISE_PLETHORA_STEREO_GUIDE.md +++ b/NOISE_PLETHORA_STEREO_GUIDE.md @@ -9,15 +9,16 @@ - [How to Activate (Hardware)](#how-to-activate-hardware) - [Controls in Stereo Mode](#controls-in-stereo-mode) - [How It Works Internally](#how-it-works-internally) +- [State Behavior](#state-behavior) - [Stereo Patch Ideas](#stereo-patch-ideas) --- ## What It Does -Stereo mode transforms the Noise Plethora from two independent mono generators into a single **stereo sound source**. Generator B automatically mirrors Generator A's algorithm, and the B knobs (XB/YB) are repurposed as stereo controls. +Stereo mode transforms the Noise Plethora from two independent mono generators into a single **stereo sound source**. Generator B automatically mirrors Generator A's algorithm, and the B knobs (XB/YB) are repurposed as stereo panning controls. -The result: a wide stereo field from a single algorithm, where the left and right channels share the same pitch but differ in timbral character. The difference varies slowly over time, creating organic stereo movement. +The result: a wide stereo field from a single algorithm, where a sine LFO pans the sound between the left and right outputs by modulating channel amplitudes. --- @@ -32,18 +33,19 @@ The result: a wide stereo field from a single algorithm, where the left and righ ## How to Activate (Hardware) -**Double-click** the Program/Bank encoder (two quick clicks within 300ms): +**Double-click** the Program/Bank encoder button (two clicks within 300 ms): | Gesture | Action | |---------|--------| -| Single click | Toggle between Gen A and Gen B (normal) | +| Single click | Toggle between Gen A and Gen B (normal mode) | | **Double-click** | **Toggle stereo mode** | -| Hold 400ms | Enter/exit bank mode | +| Hold >400 ms | Enter/exit bank mode | When stereo mode is active: -- Both dots on the 7-segment display light up simultaneously -- The display briefly shows "St" on activation and "no" on deactivation -- Both digits show the same program number +- Both decimal dots on the 7-segment display light up simultaneously +- Both digits show the same value (A's program number or bank letter) +- Single-click (A/B toggle) is disabled +- The module auto-exits bank mode upon entering stereo --- @@ -53,49 +55,103 @@ When stereo mode is active: |---------|------------|-------------| | **XA knob** | k1 for Gen A | k1 for **both** (pitch/primary param) | | **YA knob** | k2 for Gen A | k2 for **both** (timbre/secondary param) | -| **XB knob** | k1 for Gen B | **Stereo Width** (0=mono, 1=wide) | -| **YB knob** | k2 for Gen B | **Stereo Movement** (LFO speed for width modulation) | +| **XB knob** | k1 for Gen B | **Pan width** (0 = mono center, 1 = full L/R swing) | +| **YB knob** | k2 for Gen B | **Pan LFO speed** (0 = static, max = 1.5 Hz) | | **CV XA** | CV for k1 A | CV for k1 **both** | | **CV YA** | CV for k2 A | CV for k2 **both** | | **CV XB** | CV for k1 B | Not used (manual only) | | **CV YB** | CV for k2 B | Not used (manual only) | -| **Encoder** | Select program for A or B | Select program for **both** | +| **Encoder turn** | Select program for A or B | Select program for **both** (A changes, B follows) | +| **Single click** | Toggle A/B | **Disabled** (locked to A) | +| **Hold >400 ms** | Bank mode | Bank mode (works normally) | +| **Double-click** | Enter stereo | **Exit stereo** (restores B) | | **Filter A** | Filter for Gen A | Filter for **left channel** | | **Filter B** | Filter for Gen B | Filter for **right channel** | -**Note:** The analog filters remain fully independent in stereo mode. This is a feature — setting the two filters differently (e.g., LP on left, HP on right) adds an additional layer of stereo character on top of the digital decorrelation. +**Note:** The analog filters remain fully independent in stereo mode. Setting the two filters differently (e.g., LP on left, HP on right) adds an additional layer of stereo character on top of the digital panning. --- ## How It Works Internally ``` - XA (k1) ─────────────────────→ Gen A ──→ Filter A ──→ LEFT - YA (k2) ─────────────────────→ │ - │ - │ (same algorithm) - │ - XA (k1) ─────────────────────→ Gen B ──→ Filter B ──→ RIGHT - YA (k2) + stereo offset ─────→ │ - │ - XB ──→ offset amount │ - YB ──→ offset LFO speed ──────────┘ + XA (k1) ──→ Gen A ──→ ampA (gainL) ──→ Filter A ──→ LEFT + YA (k2) ──→ │ + │ (same algorithm, same params) + XA (k1) ──→ Gen B ──→ ampB (gainR) ──→ Filter B ──→ RIGHT + YA (k2) ──→ │ + │ + XB ──→ pan width (amplitude) + YB ──→ pan LFO speed ───────────────────┘ ``` -**The stereo offset is applied to k2 (timbre), not k1 (pitch).** This is critical — it means both channels always play at the same frequency, but with slightly different timbral character. This creates a natural, phase-free stereo width without the pitch-detuning artifacts of traditional chorus effects. - -The offset follows a slow sine LFO: +**The stereo effect uses real amplitude panning** — a sine LFO modulates the gain of each channel inversely: ``` -offset = XB × 0.4 × sin(2π × YB × 0.3 × time) +pan = width * sin(2pi * phase) +gainL = (1 - pan) / 2 +gainR = (1 + pan) / 2 +phase += speed^2 * 1.5 * dt (time-based, independent of loop rate) ``` -- **XB = 0**: offset is zero → mono (both channels identical) -- **XB = 0.5**: offset swings ±0.2 → moderate stereo width -- **XB = 1.0**: offset swings ±0.4 → maximum stereo width -- **YB = 0**: offset is static → fixed stereo spread -- **YB = 0.5**: offset moves slowly → gentle stereo movement -- **YB = 1.0**: offset moves faster → animated stereo field +### Pan Width (XB) + +| XB position | Pan range | Perceived effect | +|-------------|-----------|------------------| +| 0.0 | No panning | Mono (both channels equal, 0.5 / 0.5) | +| 0.5 | Half swing | Moderate stereo (0.25 – 0.75) | +| 1.0 | Full swing | Full pan (0.0 – 1.0, hard left to hard right) | + +### Pan LFO Speed (YB) + +The speed control has a **quadratic response** (`speed^2 * 1.5 Hz`) for fine control at low settings: + +| YB position | LFO rate | Cycle time | +|-------------|----------|------------| +| 0.0 | 0 Hz | Static (no movement) | +| 0.1 | 0.015 Hz | ~67 seconds | +| 0.2 | 0.06 Hz | ~17 seconds | +| 0.3 | 0.135 Hz | ~7.4 seconds | +| 0.5 | 0.375 Hz | ~2.7 seconds | +| 0.7 | 0.735 Hz | ~1.4 seconds | +| 1.0 | 1.5 Hz | ~0.67 seconds | + +### Display in Stereo Mode + +The 7-segment display has two digits, each with a decimal dot. In stereo mode both dots light up simultaneously as the stereo indicator. Both digits mirror Generator A's current value: + +| View | Display | Meaning | +|------|---------|---------| +| Program mode | `3.3.` | Program 3 on both generators, both dots = stereo active | +| Bank mode | `A.A.` | Bank A on both generators, both dots = stereo active | + +In normal (non-stereo) mode only one dot is lit, indicating which generator (A or B) the encoder controls. + +--- + +## State Behavior + +### Entering Stereo (double-click) + +1. Saves B's current bank, program, and A/B selection +2. Syncs B to A's algorithm +3. Forces encoder to control A (B follows automatically) +4. Auto-exits bank mode (so the stereo display indicator is visible) +5. Both decimal dots turn on + +### During Stereo + +- Encoder changes A's program/bank; B mirrors the change instantly +- Single click (A/B toggle) is disabled +- Hold >400 ms enters bank mode normally (both dots stay on) +- XB and YB control panning instead of Gen B parameters + +### Exiting Stereo (double-click) + +1. Restores channel gains to unity (1.0, 1.0) +2. Restores B's saved bank and program +3. Restores previous A/B selection +4. Both decimal dots return to normal behavior --- @@ -103,51 +159,46 @@ offset = XB × 0.4 × sin(2π × YB × 0.3 × time) ### 1. Immersive Bell Drone - Program: **D-6 NoiseBells** -- Stereo Mode: ON - XA: ~0.3 (medium bell pitch) - YA: ~0.2 (nearly harmonic, chime-like) - XB: 0.3 (moderate width) - YB: 0.15 (very slow movement) - Filter A: LP, cutoff medium, res low - Filter B: LP, cutoff slightly higher than A -- *Result: wide, shimmering bell drone where each ear hears slightly different harmonic content* +- *Result: wide, shimmering bell drone that slowly sweeps between speakers* ### 2. Vocal Wash - Program: **D-3 FormantNoise** -- Stereo Mode: ON - XA: modulated by slow LFO (vowel morphing) - YA: ~0.6 (moderate resonance) - XB: 0.5 (wide) - YB: 0.2 (slow drift) - Filter A: BP, cutoff ~1kHz - Filter B: BP, cutoff ~1.5kHz -- *Result: ghostly stereo choir, each ear whispers a slightly different vowel* +- *Result: ghostly stereo choir panning gently across the field* ### 3. Metallic Stereo Texture - Program: **D-4 BowedMetal** -- Stereo Mode: ON - XA: ~0.4 - YA: ~0.8 (long sustain, bowed character) - XB: 0.6 (wide separation) - YB: 0.3 (moderate movement) - Filter A: HP, cutoff low (full spectrum) - Filter B: LP, cutoff medium (darker) -- *Result: left ear = bright metallic shimmer, right ear = dark resonant glow. Complementary stereo.* +- *Result: metallic shimmer sweeping left-right. Filter differences add tonal depth to the pan.* ### 4. Chaos Stereo Field - Program: **E-9 DualAttractor** -- Stereo Mode: ON - XA: ~0.5 (moderate coupling) - YA: ~0.4 - XB: 0.4 - YB: 0.4 -- *Result: two Lorenz attractors already create wandering tones. In stereo mode, the additional timbral offset makes each channel's attractor feel independent while remaining harmonically related.* +- *Result: two Lorenz attractors panning slowly. The chaotic timbral evolution combined with spatial movement creates an immersive, unpredictable field.* ### 5. Wide Cluster - Program: **B-0 ClusterSaw** -- Stereo Mode: ON - XA: ~0.3 (low fundamental) - YA: ~0.1 (tight cluster = thick unison) - XB: 0.2 (subtle width) - YB: 0.1 (very slow) -- *Result: massive wide chorused sawtooth wall. The subtle timbral difference between channels creates a huge sound from a simple cluster.* +- *Result: massive chorused sawtooth wall that breathes between speakers. Subtle width keeps it cohesive.* From 27e2999aee6291e38ef8aab88102a07041ba554a Mon Sep 17 00:00:00 2001 From: Pablo Alcantar Date: Wed, 15 Apr 2026 09:37:32 +0200 Subject: [PATCH 12/14] Remove HTML documentation files MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Local-only rendered versions of the markdown guides — not needed in the repo. Co-Authored-By: Claude Opus 4.6 (1M context) --- NOISE_PLETHORA_CATEGORIES.html | 430 ------- NOISE_PLETHORA_PLUGIN_GUIDE.html | 1986 ------------------------------ NOISE_PLETHORA_STEREO_GUIDE.html | 224 ---- 3 files changed, 2640 deletions(-) delete mode 100644 NOISE_PLETHORA_CATEGORIES.html delete mode 100644 NOISE_PLETHORA_PLUGIN_GUIDE.html delete mode 100644 NOISE_PLETHORA_STEREO_GUIDE.html diff --git a/NOISE_PLETHORA_CATEGORIES.html b/NOISE_PLETHORA_CATEGORIES.html deleted file mode 100644 index 615ce85..0000000 --- a/NOISE_PLETHORA_CATEGORIES.html +++ /dev/null @@ -1,430 +0,0 @@ -Noise Plethora Categories

Noise Plethora — Sound Categories

-

Befaco Noise Plethora v1.5 + Banks D, E & F Extension

-

Table of Contents

- -
-

Every program in the Noise Plethora can be broadly classified by its sonic character. Some programs are versatile and appear in multiple categories depending on knob positions — see Versatile Programs for details.

-
-

🔊 DRONE — Sustained, meditative, evolving

-

Long, sustained tones that evolve slowly. Ideal for ambient backgrounds, meditation, soundscapes, and bass layers. Best experienced with the module's analog filters in lowpass mode with moderate resonance.

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
ProgramNameWhy it works for drone
D-4BowedMetal8 metallic resonators with infinite sustain at high Y. Singing bowl character.
D-6NoiseBells4 ultra-sharp resonant peaks ring continuously. Crystal bell drone.
D-9DroneBodyTwo beating sines + wavefolder. Designed specifically for drones.
D-2TubeResonanceSelf-resonating tube drone at Y=0. Hollow, harmonic series.
D-0CombNoiseSustained metallic resonance at high feedback. Pipe organ character.
E-5FeedbackFMPure sine at Y=0. The most "clean" drone source.
E-6RunawayFilterSelf-oscillating filter whistle. Clean pitched tone.
E-9DualAttractorTwo sines drifting chaotically. Never repeats, always moving.
B-4TriFMcluster6 triangles with ultra-slow phasing. Lush ensemble drift.
B-0ClusterSaw16 sawtooths in tight cluster. Massive shimmering wall.
B-8PartialClusterHarmonic series from unison to bells. Most tuneable cluster.
B-9PhasingCluster16 squares with 16 independent LFOs. Self-evolving forever.
B-5PrimeClusterInharmonic prime number chord. Unique metallic shimmer.
-

Tip: Use stereo mode with BowedMetal or NoiseBells for an immersive, wide drone. Set XB (width) to ~0.3 for subtle stereo.

-
-

⚡ HARSH / NOISE — Aggressive, industrial, digital destruction

-

Raw, aggressive textures. Bitcrushing, distortion, chaotic modulation. Good for industrial music, harsh noise, sound design, and adding grit to other sources via mixing.

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
ProgramNameCharacter
E-4BitShiftXOR of two sawtooths. 8-bit digital screech.
E-7GlitchLoopCaptured noise loop that degrades to 1-bit over time.
C-8Rwalk_BitCrushPW9 random-walk oscillators crushed to 1 bit. Extreme lo-fi.
C-7SatanWorkoutPink noise FM + self-exciting reverb. Relentless.
C-0BasuraTotalLFSR-triggered chaotic bursts with reverb. "Total Garbage."
A-6GrainGlitchGranular + XOR. Broken CD character.
D-7NoiseHarmonicsWavefolded noise through filter. Angry bee swarm.
A-0RadioOhNo4-way cross-modulation. Unstable shortwave radio.
C-6WhoKnowsAudio-rate filter sweeps. Wild and unpredictable.
A-4CrossModRingTriple cascaded ring mod. Maximum sideband chaos.
-

Tip: Harsh programs respond dramatically to the analog resonance control. Crank the module's RES knob with these for screaming filter peaks.

-
-

🥁 PERCUSSIVE / RHYTHMIC — Pulses, clicks, patterns

-

Programs that produce discrete events, rhythmic patterns, or percussive textures. From sparse droplets to dense crackle. Useful as rhythmic noise sources, triggers for other modules, or standalone percussion.

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
ProgramNameCharacter
D-1PluckCloudRandom plucked strings. Kalimba in the rain.
D-8IceRainSparse droplets + reverb tails. Crystalline ambient percussion.
E-3StochasticPulseRandom metallic pings with resonant filter. Geiger counter.
E-8SubHarmonicSquare wave + sub-octave dividers. Tectonic bass pulse.
A-9BasurillaNoise gated by 3 pulse LFOs. Complex rhythmic chopping.
F-0PulseWanderOrganic random walk pulses. Breathing rhythm.
F-1TwinPulseTwo correlated pulse streams. Polyrhythmic interference.
F-7NoiseBurstSporadic noise bursts with envelope. Rain on window.
F-4ShiftPulse4-stage shift register. Cascading pulse echoes.
E-2CellularSynthCellular automaton patterns. Self-rewriting music box.
-

Tip: PluckCloud (D-1) and IceRain (D-8) are the most "musical" percussive sources. Use the analog lowpass filter to tame the high end for a warmer, more natural percussion texture.

-
-

🌊 TEXTURAL / AMBIENT — Atmospheric, spatial, enveloping

-

Smooth, evolving, atmospheric textures. Filtered noise, spatial effects, organic movement. Ideal for ambient soundscapes, film sound design, and background layers.

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
ProgramNameCharacter
D-3FormantNoiseGhost choir morphing through vowels. Robotic whispers.
D-5FlangeNoiseSwept comb filter on noise. Jet engine, ocean waves.
C-9Rwalk_LFreePWM random walk + clean reverb. Dreamy, spacious.
C-3S_HSample-hold + reverb. Ambient stochastic clicks.
C-5ExistenceIsPain4 slow LFO-swept filters. Deep, breathing, organic.
A-1Rwalk_SineFMFlangeFM + random walk + flanger. Complex atmospheric.
F-6NoiseSlewSlew-limited noise. From smooth waves to hiss.
B-7FibonacciClusterGolden ratio spacing. Naturally balanced shimmer.
C-2WalkingFilomena16 random-walk oscillators. Living, breathing mass.
B-3SineFMclusterSubharmonic FM. Warm analog ensemble.
-

Tip: These textures shine in stereo mode. FormantNoise (D-3) in stereo with XB at ~0.4 creates a wide vocal-like wash where each channel whispers slightly different vowels.

-
-

🔮 CHAOTIC / EXPERIMENTAL — Unpredictable, mathematical, alien

-

Programs based on mathematical chaos, digital logic, and stochastic processes. Sounds that don't exist in the acoustic world. For experimental music, generative systems, and sound design.

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
ProgramNameCharacter
E-0LogisticNoiseLogistic map. Order dissolving into chaos. Period-3 windows.
E-1HenonDustHenon attractor. Alien vinyl crackle.
E-2CellularSynthCellular automaton. Self-rewriting alien music box.
F-2QuantPulseQuantized random (1-6 bits). Digital stepped textures.
F-3ShapedPulseShaped probability distribution. Uniform to gaussian.
F-5MetallicNoise6 inharmonic squares (cymbal technique). Pure metallic.
F-8LFSRNoiseShift register sequences. 4-bit retro digital patterns.
F-9DualPulseTwo S&H at independent rates. Polyrhythmic steps.
C-4ArrayOnTheRocksCorrupted wavetable + FM. Broken digital beauty.
A-2xModRingSqrCross-FM ring mod squares. Metallic clang.
-

Tip: LogisticNoise (E-0) is the most unique program in the module. Slowly sweep X from left to right to hear the transition from periodic order through bifurcation into full chaos. The period-3 window at X≈0.66 is a brief island of order in the noise — genuinely beautiful mathematics made audible.

-
-

Versatile Programs

-

These programs change category dramatically depending on knob positions:

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
ProgramY lowY highRange
E-5 FeedbackFMPure sine (DRONE)White noise (HARSH)The entire timbral spectrum in one knob
E-6 RunawayFilterClean whistle (DRONE)Resonant noise (TEXTURAL)Self-oscillation to noise wash
D-2 TubeResonanceHollow drone (DRONE)Breathy pipe (TEXTURAL)Self-resonance to wind
E-2 CellularSynthSteady drone (DRONE, simple rules)Rapid mutation (CHAOTIC, Rule 30)Order to chaos via rule selection
D-4 BowedMetalStruck cymbal (PERCUSSIVE, Y low)Infinite shimmer (DRONE, Y high)Hit to sustain
B-8 PartialClusterDense unison (DRONE, Y≈1)Metallic bells (CHAOTIC, Y>2)Harmonic to inharmonic
C-7 SatanWorkoutRaw noise texture (HARSH)Self-exciting reverb feedback (EXPERIMENTAL)Noise to feedback

Befaco Noise Plethora v1.5 + Banks D, E & F extension.

\ No newline at end of file diff --git a/NOISE_PLETHORA_PLUGIN_GUIDE.html b/NOISE_PLETHORA_PLUGIN_GUIDE.html deleted file mode 100644 index fca4b0d..0000000 --- a/NOISE_PLETHORA_PLUGIN_GUIDE.html +++ /dev/null @@ -1,1986 +0,0 @@ - - - - - -Noise Plethora — Complete Plugin Guide - - - -

Noise Plethora — Complete Plugin Guide

-

Befaco Noise Plethora v1.5 + Banks D, E & F Extension

-

About This Guide

-

The Noise Plethora is a Eurorack noise workstation with 3 digital sound generators (A, B, and C), each followed by an analog multimode filter. Generators A and B run interchangeable algorithms organized in banks of 10. Each algorithm has two parameters controlled by the X and Y knobs (and their corresponding CV inputs, 0–10Vpp).

-

This guide documents all 60 algorithms across 6 banks:

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
BankNameProgramsTheme
ATextures0–9Cross-modulation, ring mod, granular, noise AM
BHH Clusters0–9Additive/cluster synthesis with 6–16 oscillators
CHarsh & Wild0–9Bitcrushing, random walks, chaotic oscillators
DResonant Bodies0–9Delay-based resonance, physical modeling, spectral shaping
EChaos Machines0–9Deterministic chaos, algorithmic processes, digital manipulation
FStochastic0–9Random pulses, metallic noise, LFSR sequences, noise textures
-

Banks A–C are the original Befaco firmware. Banks D–F are community extensions.

-
-

Table of Contents

- -
-

Bank A: Textures

-

Cross-modulation, ring modulation, granular processing, and noise AM. Focused on complex modulation techniques that create rich, evolving textures.

-
-

A-0: RadioOhNo

-

Four square wave oscillators cross-modulated in couples, summed together.

-

Four pulse-width-modulated oscillators interconnected in feedback pairs: oscillator 1 modulates 2 and vice versa, oscillator 3 modulates 4 and vice versa. A DC source modulates all oscillators' frequency. The cross-modulation creates complex sidebands and chaotic harmonic interactions.

- - - - - - - - - - - - - - - - - - - - - - - -
ParameterControlRangeEffect
X (k1)Oscillator 1 frequency20 – 2520 HzBase frequency for all 4 oscillators (each at a different ratio). Quadratic mapping for fine control at low frequencies.
Y (k2)PWM / DC modulation0 – 1Controls DC amplitude which modulates all oscillators' frequency. Higher values create wider FM deviation and more chaotic sidebands.
-

Sound character: Aggressive, unstable radio-frequency-like textures. Like tuning between shortwave stations. Rich in aliasing and intermodulation products.

-
-

A-1: Rwalk_SineFMFlange

-

Four random walkers controlling pulse oscillators, FM'd by sines, through a flanger.

-

Four 2D random walkers move in a bounded box with random velocities. Their positions map to the frequencies of 4 pulse wave oscillators, which feed into 4 sine FM oscillators. The mixed output passes through a flanger effect.

- - - - - - - - - - - - - - - - - - - - - - - -
ParameterControlRangeEffect
X (k1)FM sine frequency10 – 510 HzBase frequency of the 4 sine FM oscillators (each offset by 55–75 Hz).
Y (k2)Flanger modulation rate0 – 3 HzLFO speed of the flanger. Adds swept comb filtering on top of the FM textures.
-

Sound character: Morphing, evolving FM textures with organic movement. The flanger adds spatial depth and sweeping spectral animation. No two moments are alike. Atmospheric and complex.

-
-

A-2: xModRingSqr

-

Cross FM between two square wave oscillators, ring modulated.

-

Two square wave oscillators in a feedback configuration: each modulates the other's frequency. Their outputs are ring modulated (multiplied) together.

- - - - - - - - - - - - - - - - - - - - - - - -
ParameterControlRangeEffect
X (k1)Oscillator 1 frequency100 – 5100 HzPitch of the first square wave. Quadratic mapping.
Y (k2)Oscillator 2 frequency20 – 1020 HzPitch of the second square wave. Quadratic mapping.
-

Sound character: Metallic, clanging ring modulation. At simple ratios (2:1, 3:2) = tonal metallic tones. At complex ratios = inharmonic metallic clatter.

-
-

A-3: XModRingSine

-

Cross FM between two sine oscillators, ring modulated.

-

Same topology as xModRingSqr but using sine FM oscillators. Sines produce cleaner, more bell-like results than squares.

- - - - - - - - - - - - - - - - - - - - - - - -
ParameterControlRangeEffect
X (k1)Oscillator 1 frequency100 – 8100 HzPitch of the first sine. Quadratic mapping. Wide range.
Y (k2)Oscillator 2 frequency60 – 3060 HzPitch of the second sine. Quadratic mapping.
-

Sound character: Bell-like and metallic tones. All spectral content comes from the FM and ring modulation. Good for tuned metallic percussion sounds.

-
-

A-4: CrossModRing

-

Four oscillators in a cross-modulation matrix with cascaded ring modulators.

-

Four oscillators (2 square, 1 sawtooth with offset, 1 square) modulate each other's frequencies. Three ring modulators in a cascaded configuration: multiply1 and multiply2 feed into multiply3. The most complex modulation topology in the module.

- - - - - - - - - - - - - - - - - - - - - - - -
ParameterControlRangeEffect
X (k1)Frequency (all oscillators)1 – 827 HzScales all 4 oscillator frequencies with individual ratios.
Y (k2)FM depth2 – 10 octavesMaster frequency modulation depth. Low = subtle. High = total harmonic chaos.
-

Sound character: Incredibly dense sideband spectrum. From metallic drones at low FM depth to total chaos at high depth. Like a 4-operator FM synth pushed to extremes.

-
-

A-5: Resonoise

-

Square wave FM-modulating a sine, through a wavefolder, controlling a resonant filter on white noise.

-

A modulated square wave drives a sine FM oscillator. The sine passes through a wavefolder, then feeds into a state-variable filter as the frequency control signal. White noise is the audio input to the filter (resonance=3).

- - - - - - - - - - - - - - - - - - - - - - - -
ParameterControlRangeEffect
X (k1)Both oscillator frequencies20 – 10020 HzControls the modulation rate of the filter cutoff.
Y (k2)Wavefold amount0.03 – 0.23DC bias into the wavefolder. More folding = more complex filter modulation pattern.
-

Sound character: Resonant noise with animated filter modulation. Like white noise through an auto-wah driven by a complex LFO. Organic and vocal.

-
-

A-6: GrainGlitch

-

Square wave through a granular cell, output XOR'd with the input.

-

A square wave feeds into a granular pitch-shifting processor with feedback. The original square wave and the granular output are combined using XOR digital logic.

- - - - - - - - - - - - - - - - - - - - - - - -
ParameterControlRangeEffect
X (k1)Square wave frequency500 – 5500 HzBase frequency of the source oscillator.
Y (k2)Grain size + speed25–100 ms / 0.125–8xGrain size (pitch shift window) and playback speed ratio.
-

Sound character: Glitchy digital artifacts from XOR combination. Harsh, broken, digital — like a CD skipping.

-
-

A-7: GrainGlitchII

-

Square wave through a granular cell, amplified.

-

Similar to GrainGlitch but without XOR. Granular output amplified 32000x to bring up the quiet signal.

- - - - - - - - - - - - - - - - - - - - - - - -
ParameterControlRangeEffect
X (k1)Square wave frequency500 – 5500 HzBase frequency of the source oscillator.
Y (k2)Grain size + speed25–100 ms / 0.125–8xSame mapping as GrainGlitch.
-

Sound character: Cleaner granular texture than GrainGlitch. More transparent and "musical" than the XOR version.

-
-

A-8: GrainGlitchIII

-

Sawtooth wave through a granular cell.

-

Similar to GrainGlitchII but using a sawtooth waveform. Richer harmonic spectrum provides more material for the granular processor.

- - - - - - - - - - - - - - - - - - - - - - - -
ParameterControlRangeEffect
X (k1)Sawtooth frequency400 – 5500 HzBase frequency.
Y (k2)Grain size + speed25–80 ms / 0.125–8xSlightly narrower grain range than I/II.
-

Sound character: The richest granular variant. Textures from buzzy granular drones to scattered metallic fragments.

-
-

A-9: Basurilla

-

White noise amplitude-modulated by 3 independent pulse wave LFOs.

-

Three parallel channels: white noise is ring-modulated by 3 pulse wave oscillators at different rates and pulse widths. The pulse waves gate the noise in complex rhythmic patterns.

- - - - - - - - - - - - - - - - - - - - - - - -
ParameterControlRangeEffect
X (k1)LFO frequencies0.1 – 110 HzControls all 3 pulse LFOs. Low = slow gates. High = audio-rate AM.
Y (k2)Pulse widths / noise levelPW + inverse amplitudePulse width of the 3 LFOs and inversely controls noise amplitude.
-

Sound character: Chaotic, granular-like texture from noise gated by 3 independent pulse trains. "Basurilla" = "little garbage" in Spanish — beautifully organized trash.

-
-

Bank B: HH Clusters

-

Cluster/additive synthesis using 6–16 oscillators at mathematically related frequency ratios. Dense, shimmering tonal textures.

-
-

B-0: ClusterSaw

-

16 sawtooth oscillators with adjustable geometric frequency spread.

-

Sixteen sawtooths tuned in geometric progression. Each frequency is the previous one multiplied by a constant factor.

- - - - - - - - - - - - - - - - - - - - - - - -
ParameterControlRangeEffect
X (k1)Base frequency20 – 1020 HzFundamental frequency.
Y (k2)Spread factor1.01 – 1.91Ratio between adjacent oscillators. Low = beating unison. High = wide harmonic spread.
-

Sound character: Shimmering, buzzing mass of sawtooths. The quintessential "cluster" sound. 16 voices create an extremely rich spectral texture.

-
-

B-1: PwCluster

-

6 detuned pulse waveforms with adjustable pulse width.

-

Six pulse waves at fixed detuned ratios (1.227, 1.24, 1.17, 1.2, 1.3). DC-controlled pulse width.

- - - - - - - - - - - - - - - - - - - - - - - -
ParameterControlRangeEffect
X (k1)Base frequency40 – 8040 HzWidest range of any cluster plugin.
Y (k2)Pulse widthWide – Narrow (inverted)Low Y = full, warm. High Y = thin, nasal.
-

Sound character: Chorused pulse waves. At wide PW: organ-like. At narrow PW: reedy, nasal. Constant beating from non-harmonic detuning.

-
-

B-2: CrCluster2

-

6 detuned sine waves with low-frequency FM from a single modulator.

-

Six sines, all FM'd by one sine at 2.7x the base frequency.

- - - - - - - - - - - - - - - - - - - - - - - -
ParameterControlRangeEffect
X (k1)Base frequency40 – 8040 HzCluster fundamental.
Y (k2)FM index0 – 1.0Low = pure sine cluster. High = bright FM harmonics.
-

Sound character: Clean sine cluster that becomes progressively FM-modulated. Warm to bright. Spectrally coherent.

-
-

B-3: SineFMcluster

-

6 triangle waves, each independently FM'd by its own sine modulator (subharmonic ratio 0.333).

- - - - - - - - - - - - - - - - - - - - - - - -
ParameterControlRangeEffect
X (k1)Base frequency300 – 8300 HzHigher starting frequency.
Y (k2)FM index0.1 – 1.0Subharmonic FM adds content below carriers.
-

Sound character: Warm, soft FM cluster. Triangle carriers + subharmonic FM = "analog" feeling warmth and depth.

-
-

B-4: TriFMcluster

-

6 triangle waves, each independently FM'd at very slow ratio (0.07).

-

Same architecture as SineFMcluster but with 1/14th FM ratio. Creates phasing/chorus rather than FM timbral change.

- - - - - - - - - - - - - - - - - - - - - - - -
ParameterControlRangeEffect
X (k1)Base frequency300 – 8300 HzSame range as SineFMcluster.
Y (k2)FM index0.1 – 1.0Creates slow drifting detuning, not bright harmonics.
-

Sound character: Lush, animated ensemble effect. Like 6 slightly out-of-tune instruments. Very different from SineFMcluster despite identical architecture.

-
-

B-5: PrimeCluster

-

16 oscillators tuned to prime number frequencies, noise-modulated.

-

Sixteen variable-triangle oscillators at primes (53, 127, 199... 1523 Hz), all scaled by a common factor. White noise FM adds animation.

- - - - - - - - - - - - - - - - - - - - - - - -
ParameterControlRangeEffect
X (k1)Pitch multiplier0.5 – 10.5Scales all 16 primes. Linear mapping.
Y (k2)Noise modulation0 – 0.2Noise FM amount. Low = clean. High = tremolo-like.
-

Gain: 0.8 (reduced to prevent clipping).

-

Sound character: Inharmonic, bell-like chord. No common harmonics — a unique shimmering metallic texture.

-
-

B-6: PrimeCnoise

-

16 triangle oscillators at prime frequencies (wider range variant).

-

Nearly identical to PrimeCluster but with quadratic pitch mapping (k1^2 x 12) for wider range.

- - - - - - - - - - - - - - - - - - - - - - - -
ParameterControlRangeEffect
X (k1)Pitch multiplier0.5 – 12.5Quadratic mapping — more extreme range.
Y (k2)Noise modulation0 – 0.2Same as PrimeCluster.
-

Gain: 0.8

-

Sound character: Same prime character, different response to knob gestures. More exponential/extreme than PrimeCluster.

-
-

B-7: FibonacciCluster

-

16 sawtooth oscillators at Fibonacci-series frequency spacing.

-

Frequencies follow f(n) = f(n-1) + f(n-2) x spread. Noise FM adds animation.

- - - - - - - - - - - - - - - - - - - - - - - -
ParameterControlRangeEffect
X (k1)Base frequency50 – 1050 HzFundamental pitch.
Y (k2)Spread factor0.1 – 0.6How fast frequencies diverge. Near 0.618 = golden ratio intervals.
-

Sound character: Nature's favorite ratio. At spread near golden ratio, intervals feel "naturally balanced." Unique organic quality.

-
-

B-8: PartialCluster

-

16 sawtooth oscillators with multiplicative harmonic spacing.

-

Each frequency is the previous multiplied by a spread factor.

- - - - - - - - - - - - - - - - - - - - - - - -
ParameterControlRangeEffect
X (k1)Base frequency50 – 1050 HzFundamental.
Y (k2)Harmonic spread1.01 – 2.11At 2.0 = octave spacing. Below = dense. Above = stretched/metallic.
-

Sound character: The most "tuneable" cluster. Morph from dense unison to harmonic series to metallic bells by sweeping Y.

-
-

B-9: PhasingCluster

-

16 square waves with individual LFO phase modulation.

-

Each oscillator has its own triangle LFO at a unique rate: 10, 11, 15, 1, 1, 3, 17, 14, 0.11, 5, 2, 7, 1, 0.1, 0.7, 0.5 Hz.

- - - - - - - - - - - - - - - - - - - - - - - -
ParameterControlRangeEffect
X (k1)Carrier frequency30 – 5030 HzBase frequency for all 16 squares.
Y (k2)Spread1.0 – 1.5Spreads carrier frequencies slightly.
-

Sound character: Massive phasing. 16 oscillators drifting at their own rates — constantly evolving, never-repeating interference patterns. Glacial slow LFOs (0.1 Hz) + shimmer (17 Hz).

-
-

Bank C: Harsh & Wild

-

Extreme processing: bitcrushing, random walks, chaotic oscillators, reverb abuse. The most experimental and aggressive bank.

-
-

C-0: BasuraTotal

-

"Bent" LFSR driving an oscillator with reverb.

-

A Galois LFSR generates pseudo-random timing events that trigger a waveform oscillator. Output through Freeverb.

- - - - - - - - - - - - - - - - - - - - - - - -
ParameterControlRangeEffect
X (k1)Oscillator frequency200 – 5200 HzPitch of triggered waveform.
Y (k2)Event rateSlow – FastTiming between LFSR-triggered events.
-

Sound character: Sporadic bursts with reverb tails. "BasuraTotal" = "Total Garbage" — chaotic, messy, and beautiful.

-
-

C-1: Atari

-

Two square waves with PWM/FM cross-modulation.

-

First oscillator does PWM on the second, second does FM on the first.

- - - - - - - - - - - - - - - - - - - - - - - -
ParameterControlRangeEffect
X (k1)Wave 1 frequency10 – 60 HzSub-bass territory.
Y (k2)Wave 2 freq + FM depth10–210 Hz / 3–11 octHigher pitch AND more extreme modulation.
-

Sound character: Classic 8-bit Atari/chiptune. Buzzy, aggressive, nostalgic.

-
-

C-2: WalkingFilomena

-

16 random walkers controlling pulse oscillator frequencies.

-

Sixteen pulse oscillators with independent 2D random walkers in a bounded box.

- - - - - - - - - - - - - - - - - - - - - - - -
ParameterControlRangeEffect
X (k1)Random walk box size200 – 1800 HzFrequency range of all 16 oscillators.
Y (k2)Pulse width0.1 – 0.9Thin = bright/nasal. Wide = warm/full.
-

Sound character: Shimmering, constantly evolving polyphonic texture. 16 oscillators wandering in pitch space. Organic and alive.

-
-

C-3: S_H (Sample & Hold)

-

Sample-and-hold noise with dirty reverb.

- - - - - - - - - - - - - - - - - - - - - - - -
ParameterControlRangeEffect
X (k1)S&H rate15 – 5015 HzSlow = stepped tones. Fast = granular noise.
Y (k2)Reverb mixDry – WetDry = stochastic clicks. Wet = ambient wash.
-

Sound character: Classic S&H randomness with spatial depth from reverb.

-
-

C-4: ArrayOnTheRocks

-

FM synthesis with a randomized 256-point wavetable.

-

A 500 Hz sine modulates an arbitrary waveform with randomly corrupted table values.

- - - - - - - - - - - - - - - - - - - - - - - -
ParameterControlRangeEffect
X (k1)Wavetable oscillator freq10 – 10010 HzPlayback speed.
Y (k2)FM modulator amplitude0 – 1.0Low = clean wavetable. High = rich FM sidebands.
-

Sound character: Unpredictable timbral textures from the corrupted wavetable. Different from standard FM because the carrier waveform itself is partially random.

-
-

C-5: ExistenceIsPain

-

Sample-and-hold noise through 4 bandpass filters modulated by 4 LFOs.

-

S&H source into 4 parallel SVF bandpass filters with independent triangle LFOs at 11, 70, 23, 0.01 Hz. Resonance=5.

- - - - - - - - - - - - - - - - - - - - - - - -
ParameterControlRangeEffect
X (k1)S&H noise frequency50 – 5050 HzBase texture density.
Y (k2)Filter sweep range0.3 – 3.3 octavesNarrow = focused. Wide = dramatic animation.
-

Sound character: Slowly breathing, organic multiband filtering. The 0.01 Hz LFO creates glacial changes, 70 Hz adds shimmer. Deep, meditative, slightly ominous.

-
-

C-6: WhoKnows

-

Pulse wave through 4 bandpass filters with fast LFO modulation.

-

Similar to ExistenceIsPain but with 5 Hz pulse source and much faster LFOs (21, 70, 90, 77 Hz). Resonance=7.

- - - - - - - - - - - - - - - - - - - - - - - -
ParameterControlRangeEffect
X (k1)Pulse frequency15 – 515 HzSource frequency.
Y (k2)Filter sweep range0.3 – 6.3 octavesAt high settings, filters sweep wildly.
-

Sound character: Dramatic, rapidly animated filter textures. Audio-rate LFOs create sideband-like effects. Aggressive and chaotic.

-
-

C-7: SatanWorkout

-

Pink noise FM-ing a PWM oscillator, through reverb.

-

Pink noise modulates a PWM oscillator. Freeverb with negative damping (-5).

- - - - - - - - - - - - - - - - - - - - - - - -
ParameterControlRangeEffect
X (k1)PWM frequency8 – 6008 Hz"Pitch" of noise modulation.
Y (k2)Reverb room size0.001 – 4.0Beyond 1.0 = self-exciting reverb feedback.
-

Sound character: Raw organic noise with reverb. At high Y the reverb self-excites. Relentless intensity.

-
-

C-8: Rwalk_BitCrushPW

-

9 random-walk pulse oscillators, bitcrushed to 1 bit, with reverb.

-

Nine pulse oscillators with 2D random walkers. Mixed, 1-bit crushed, parallel reverb path.

- - - - - - - - - - - - - - - - - - - - - - - -
ParameterControlRangeEffect
X (k1)Pulse width0.2 – 0.75Timbre control alongside random walk frequencies.
Y (k2)Reverb room size0 – 4.0High = self-exciting reverb.
-

Sound character: Extreme digital destruction. Dense, distorted digital texture with organic pitch movement from random walks. Lo-fi at its most extreme.

-
-

C-9: Rwalk_LFree

-

4 PWM oscillators with random-walk frequencies, through reverb.

-

Four PWM oscillators with independent random walkers. Clean Freeverb (no bitcrushing).

- - - - - - - - - - - - - - - - - - - - - - - -
ParameterControlRangeEffect
X (k1)Random walk boundary50 – 550 HzFrequency space size.
Y (k2)Reverb room size0 – 1.0Conservative range, clean reverb.
-

Sound character: Spacious, clean random pulse textures. Warm timbre, gentle pitch drift, dreamy ambient reverb. The gentlest of the random walk family.

-
-

Bank D: Resonant Bodies

-

Delay-based resonance, physical modeling, and spectral shaping. What happens when noise passes through resonant structures: comb filters, waveguides, feedback networks, and high-Q resonators.

-
-

D-0: CombNoise

-

White noise through 4 parallel comb filters.

-

A comb filter is a short delay line with feedback — it reinforces frequencies at the delay time and its harmonics. Four combs at ratios 1.0 : 0.7 : 0.5 : 0.35 create a rich, multi-pitched metallic tone.

- - - - - - - - - - - - - - - - - - - - - - - -
ParameterControlRangeEffect
X (k1)Resonant pitch40 – 5000 HzFundamental frequency of all 4 comb filters.
Y (k2)Feedback0 – 95%Resonance sustain. Low = colored noise. High = clearly pitched ringing.
-

Sound character: Like blowing across a metal pipe. The 4 overlapping combs create a rich harmonic spectrum.

-
-

D-1: PluckCloud

-

6 Karplus-Strong plucked string voices with random retriggering.

-

Noise burst into delay line with LP filter in feedback loop. Voices retrigger randomly (~2% per cycle). Detuned at ratios 1.0, 1.005, 0.995, 1.01, 0.99, 1.015.

- - - - - - - - - - - - - - - - - - - - - - - -
ParameterControlRangeEffect
X (k1)Pitch center60 – 3000 HzBase pitch for all 6 voices.
Y (k2)Brightness / decayDull – BrightLow = muted string, fast decay. High = bright ring, long sustain.
-

Sound character: Rain on a kalimba, or a prepared piano played by dice. Sparse, organic, constantly evolving.

-
-

D-2: TubeResonance

-

Noise excitation through 4 harmonic comb filters simulating a resonant tube.

-

Four combs at 1x, 2x, 3x, 4x fundamental. Higher harmonics decay faster (feedback scaled by 1/harmonic).

- - - - - - - - - - - - - - - - - - - - - - - -
ParameterControlRangeEffect
X (k1)Tube length40 – 1000 HzFundamental pitch. Low = long tube. High = short pipe.
Y (k2)ExcitationSelf-resonance – BreathLow = singing bowl drone. High = breathy wind-through-pipe.
-

Sound character: Hollow drone to breathy pipe texture. Harmonic series is clearly audible — sounds like a real resonant object.

-
-

D-3: FormantNoise

-

White noise through 3 bandpass filters at vowel formant frequencies.

-

Interpolates between 5 vowel shapes (A, E, I, O, U) using 3 SVF bandpass filters.

- - - - - - - - - - - - - - - - - - - - - - - -
ParameterControlRangeEffect
X (k1)Vowel morphA → E → I → O → USmooth interpolation between vowel formants.
Y (k2)ResonanceQ 1.0 – 5.0Wide/breathy to sharp/nasal vowels.
-

Formant table (Hz):

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
VowelF1F2F3
A73010902440
E66017202410
I27022903010
O5708402410
U3008702240
-

Sound character: Robotic choir whispering vowels. Sweep X for ghostly "aaah → eeeh → iiih → oooh → uuuh."

-
-

D-4: BowedMetal

-

Noise exciting 8 high-Q resonators at dense metallic frequency ratios.

-

Eight 2-pole resonators (Q ~300–500) at plate vibration mode ratios. Denser than NoiseBells = more reverberant.

- - - - - - - - - - - - - - - - - - - - - - - -
ParameterControlRangeEffect
X (k1)Fundamental pitch30 – 2030 HzAll 8 resonators scale proportionally.
Y (k2)Struck → BowedShort ring – Infinite sustainLow = cymbal hit. High = bowed singing bowl.
-

Resonator ratios: 1.000, 1.183, 1.506, 1.741, 2.098, 2.534, 2.917, 3.483

-

Sound character: Dense metallic reverberance. Bowed cymbal or gong. More diffuse than NoiseBells.

-
-

D-5: FlangeNoise

-

Pink noise through a flanger effect.

-

Swept comb filter on noise. Classic "jet engine whoosh."

- - - - - - - - - - - - - - - - - - - - - - - -
ParameterControlRangeEffect
X (k1)Flange rate0.05 – 5 HzSlow sweep to fast warble.
Y (k2)Flange depthSubtle – DeepPhase-like to dramatic comb sweep.
-

Sound character: Jet plane flyover, ocean through metal tube, wind in rotating vent.

-
-

D-6: NoiseBells

-

White noise exciting 4 sharp 2-pole resonators at bell-like inharmonic ratios.

-

Extremely high Q (~625) creates laser-sharp peaks. Clear ringing tones from noise.

- - - - - - - - - - - - - - - - - - - - - - - -
ParameterControlRangeEffect
X (k1)Bell pitch80 – 4080 HzFundamental. All 4 resonators scale.
Y (k2)InharmonicityChime → GongNear-harmonic (wind chime) to stretched (gamelan).
-

Resonator ratios (vary with Y):

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
ResonatorY=0 (chime)Y=1 (gong)
11.00x1.00x
21.59x2.48x
32.33x4.33x
43.14x6.35x
-

Sound character: Clear bell tones from noise. Visible on spectrum analyzer as 4 needle-sharp peaks.

-
-

D-7: NoiseHarmonics

-

White noise through a wavefolder, then resonant bandpass filter.

-

Wavefolder creates harmonics from noise (DC bias controlled). SVF filter (Q=3) selects a frequency band.

- - - - - - - - - - - - - - - - - - - - - - - -
ParameterControlRangeEffect
X (k1)Wavefold intensityGentle – HeavyMore folding = denser harmonics.
Y (k2)Filter frequency100 – 8100 HzSelects which band is heard.
-

Sound character: Aggressive buzzing. Like an angry bee swarm at a specific pitch. Grittier than plain filtered noise.

-
-

D-8: IceRain

-

Sparse sample-and-hold events with long reverb tails.

-

Random stepped values at controllable rate into Freeverb (high damping).

- - - - - - - - - - - - - - - - - - - - - - - -
ParameterControlRangeEffect
X (k1)Droplet density0.5 – 200 HzSparse plinks to dense rain.
Y (k2)Reverb sizeSmall – VastDry/close to cathedral-like.
-

Sound character: Crystalline drops in a cave. Sparse plinks with shimmering tails. Very spatial and ambient.

-
-

D-9: DroneBody

-

Two cross-modulated FM sines through a wavefolder.

-

Slightly detuned sines with block-delayed cross-feedback FM. Wavefolder adds harmonics.

- - - - - - - - - - - - - - - - - - - - - - - -
ParameterControlRangeEffect
X (k1)Drone pitch20 – 520 HzFundamental of both sines.
Y (k2)Detune + FoldClean – RichY=0: clean hum. Y=1: beating + growling overtones.
-

Sound character: Deep meditative drone. Tibetan singing bowl meets power transformer. Good for sustained bass.

-
-

Bank E: Chaos Machines

-

Deterministic chaos, algorithmic processes, and digital manipulation. Mathematical systems that hover between order and noise.

-
-

E-0: LogisticNoise

-

Logistic map chaotic oscillator: x(n+1) = r * x(n) * (1 - x(n))

- - - - - - - - - - - - - - - - - - - - - - - -
ParameterControlRangeEffect
X (k1)Chaos parameter r3.5 – 4.03.5=periodic. 3.57=chaos onset. 3.83=period-3 window. 4.0=full chaos.
Y (k2)Output rateSlow – FastHeld samples (buzzy tone) to per-sample (noise-like at r=4).
-

Sound character: Mathematical structure dissolving into chaos. Sweep r to hear windows of order breaking into noise. The period-3 window at r~3.83 is particularly striking.

-
-

E-1: HenonDust

-

Henon attractor: x' = 1 - a*x^2 + y, y' = b*x

- - - - - - - - - - - - - - - - - - - - - - - -
ParameterControlRangeEffect
X (k1)Parameter a1.15 – 1.40Low=periodic. ~1.2=period-doubling. 1.4=full chaos.
Y (k2)Parameter b0.15 – 0.35Attractor shape and crackle density.
-

Sound character: Alien vinyl surface noise. Almost-repeating patterns that never quite repeat. Living, deterministic crackle.

-
-

E-2: CellularSynth

-

1D cellular automaton (32 cells) controlling 8 sawtooth oscillators at harmonics of 55 Hz.

- - - - - - - - - - - - - - - - - - - - - - - -
ParameterControlRangeEffect
X (k1)CA rule0 – 255Rule 30=chaotic. Rule 90=fractal. Rule 110=complex.
Y (k2)Evolution speedGlacial – RapidHow fast the CA evolves.
-

Sound character: Alien music box that rewrites its own score. Some rules = steady drone, others = constant mutation.

-
-

E-3: StochasticPulse

-

Poisson-distributed impulses through a resonant bandpass filter (Q=4.5).

- - - - - - - - - - - - - - - - - - - - - - - -
ParameterControlRangeEffect
X (k1)Impulse density5 – 505 /secSparse pings to dense crackling.
Y (k2)Filter frequency80 – 8080 HzPitch of the resonant ring.
-

Sound character: Geiger counter meets resonant drum. Random metallic pings with clear musical pitch.

-
-

E-4: BitShift

-

Two sawtooth oscillators combined via XOR digital logic.

- - - - - - - - - - - - - - - - - - - - - - - -
ParameterControlRangeEffect
X (k1)Oscillator 1 freq20 – 5020 HzFirst sawtooth.
Y (k2)Oscillator 2 ratio1:1 – 1:8Simple ratios = structured. Irrational = maximum complexity.
-

Sound character: Broken NES / ZX Spectrum. Hard digital edges, rapidly shifting sum/difference tones. Aggressive 8-bit.

-
-

E-5: FeedbackFM

-

Single sine with sample-delayed self-feedback into its own phase.

- - - - - - - - - - - - - - - - - - - - - - - -
ParameterControlRangeEffect
X (k1)Carrier frequency20 – 5020 HzPitch.
Y (k2)Feedback0 – 2.5 rad0=sine. ~0.8=bright. ~1.5=metallic. ~2.0=gritty. 2.5=noise.
-

Sound character: The full timbral spectrum in one knob. Classic DX7 operator technique. Sweet spot at Y~1.0 = vocal/nasal quality.

-
-

E-6: RunawayFilter

-

White noise through a self-oscillating SVF (Q ~4.5–4.99).

- - - - - - - - - - - - - - - - - - - - - - - -
ParameterControlRangeEffect
X (k1)Filter frequency30 – 10030 HzPitched self-oscillation tone.
Y (k2)Noise injectionWhistle – NoiseY=0: clean sine whistle. Y=1: resonant noise. Transition zone = sweet spot.
-

Sound character: Pitched whistle fighting noise. Like tuning a shortwave radio. Fragile tone that breaks and reforms.

-
-

E-7: GlitchLoop

-

Noise captured into a loop with progressive bit-depth degradation.

- - - - - - - - - - - - - - - - - - - - - - - -
ParameterControlRangeEffect
X (k1)Loop length10 – 200 msShort = buzz. Long = stutter.
Y (k2)Degradation rateStable – RapidHow fast the loop crumbles. Refills when bit depth hits 1.
-

Sound character: Digital decay. Loop captures, degrades, collapses to 1-bit, refreshes. Rhythmic destruction cycle.

-
-

E-8: SubHarmonic

-

Square wave with frequency dividers at /2, /3, /5, /7.

- - - - - - - - - - - - - - - - - - - - - - - -
ParameterControlRangeEffect
X (k1)Fundamental frequency100 – 4100 HzSource square wave pitch.
Y (k2)Subharmonic mix/2 only → All fourProgressive: Y=0: octave below. Y=0.33: +fifth below. Y=0.66: +major 3rd down. Y=1: +minor 7th down.
-

Subharmonic intervals at 440 Hz: /2=220 Hz, /3=~147 Hz, /5=88 Hz, /7=~63 Hz

-

Sound character: Deep rumbling sub-bass. Earth-shaking low end at full Y with low fundamental. Tectonic.

-
-

E-9: DualAttractor

-

Two coupled Lorenz attractors driving two sine oscillators.

-

Lorenz system: dx/dt = sigma(y-x), dy/dt = x(rho-z)-y, dz/dt = xy-beta*z. sigma=10, rho=28, beta=8/3.

- - - - - - - - - - - - - - - - - - - - - - - -
ParameterControlRangeEffect
X (k1)Coupling strength0 – 50=independent chaos. 5=tones lock/unlock in bursts.
Y (k2)Base frequency30 – 2030 HzCenter pitch the attractors orbit.
-

Sound character: Two drunk musicians trying to play in unison. Moments of harmony interrupted by chaos. Organic, alive, never repeating.

-
-

Bank F: Stochastic

-

Random processes generating pulses, transients, and noise textures. The pulse-based algorithms (F-0 through F-4) exploit the Noise Plethora's internal DC blocker to transform random stepped values into unique transient/pulse shapes — a character exclusive to this module's architecture.

-
-

F-0: PulseWander

-

Smooth random walk generating organic pulse patterns.

-

A random target value is chosen periodically, and a one-pole LP filter smoothly tracks it. The module's DC blocker transforms held values into distinctive pulse shapes with natural attack/decay envelopes.

- - - - - - - - - - - - - - - - - - - - - - - -
ParameterControlRangeEffect
X (k1)Rate5 – 400 HzHow often a new random target is chosen. Low = sparse, isolated pulses. High = dense, overlapping transients.
Y (k2)SmoothnessInstant – Smoothk2=0: instant jumps (sharp S&H pulses). k2=1: smooth glide between targets (softer, rounder transients). The LP filter alpha auto-scales with rate.
-

Sound character: Organic, irregular pulse train. Each pulse has a unique amplitude from the random walk. The smoothness control morphs from sharp clicks to rounded bumps. Unlike a regular clock, the randomness creates a "breathing" quality.

-
-

F-1: TwinPulse

-

Two random walks with controllable correlation creating crossed pulse patterns.

-

Two independent random walk generators running at the same rate. The correlation control blends the second walk toward the first, creating patterns that range from fully independent (complex interference) to identical (simple doubled pulse).

- - - - - - - - - - - - - - - - - - - - - - - -
ParameterControlRangeEffect
X (k1)Rate5 – 400 HzSpeed of both random walks.
Y (k2)CorrelationIndependent – Identical0 = two completely unrelated pulse streams (complex polyrhythmic interference). 1 = both outputs identical (single pulse stream, louder). Sweet spot around 0.3–0.7 where patterns partially align.
-

Sound character: Two overlapping pulse patterns. At low correlation, a complex, polyrhythmic texture where pulses sometimes align and sometimes don't. At high correlation, they merge into a single stream. The interplay creates a rhythmic quality that pure randomness lacks.

-
-

F-2: QuantPulse

-

Random values quantized to N bits, creating stepped pulse patterns.

-

Generates random values quantized to a variable number of discrete levels (2^bits). At 1 bit: binary (2 levels). At 6 bits: 64 levels. The DC blocker creates pulses whose amplitude is quantized to these levels.

- - - - - - - - - - - - - - - - - - - - - - - -
ParameterControlRangeEffect
X (k1)Rate5 – 500 HzClock speed. How often a new quantized random value is generated.
Y (k2)Bit depth1 – 6 bits (continuous)Quantization resolution. 1 bit = binary pulse (on/off). 2 bits = 4 levels. 6 bits = 64 levels (nearly continuous). Continuous morphing between bit depths.
-

Sound character: Quantized random pulses. At low bits: harsh, digital, with clearly discrete amplitude steps. At high bits: smoother, approaching the character of PulseWander. The bit quantization adds a lo-fi, digital texture to the random process.

-
-

F-3: ShapedPulse

-

Random with variable probability distribution shape.

-

The random values follow different probability distributions depending on Y. Uniform (flat — all values equally likely), triangular (values near center more likely), or peaked/gaussian (values strongly concentrated near center, rare extremes).

- - - - - - - - - - - - - - - - - - - - - - - -
ParameterControlRangeEffect
X (k1)Rate5 – 500 HzClock speed.
Y (k2)DistributionUniform → Triangular → Gaussian0 = uniform (all amplitudes equally likely — evenly distributed pulses). 0.5 = triangular (sum of 2 uniforms — moderate peak clustering). 1.0 = peaked (sum of 4 uniforms, central limit theorem — most pulses near zero, rare large ones).
-

Sound character: The distribution shape is audible. Uniform: even, balanced pulse amplitudes. Peaked: mostly quiet with occasional loud spikes — creates a "crackling" or "dripping" quality where large events are rare surprises.

-
-

F-4: ShiftPulse

-

4-stage shift register creating evolving pulse sequences.

-

A shift register where random values enter stage 1 and shift down to stages 2, 3, 4 on each clock tick. All 4 stages are mixed in the output with adjustable weighting, creating patterns that evolve as values propagate through the chain.

- - - - - - - - - - - - - - - - - - - - - - - -
ParameterControlRangeEffect
X (k1)Clock rate5 – 300 HzSpeed of the shift register clock.
Y (k2)Stage mixStage 1 only → All 4Progressive activation: Y=0: only stage 1 (fastest changing). Y=0.33: adds stage 2 (delayed echo). Y=0.66: adds stage 3. Y=1.0: all 4 stages equally mixed. The delayed repetitions create rhythmic pattern echoes.
-

Sound character: A pulse pattern that develops delayed echoes of itself. At low Y: simple random pulses. As Y increases, you hear the same values repeated 1, 2, 3 steps later, creating a cascading effect — like an echo chamber for random events.

-
-

F-5: MetallicNoise

-

6 square wave oscillators at inharmonic frequencies mixed and highpass filtered.

-

The classic technique used in the TR-808 cymbal and hi-hat circuits: six pulse oscillators at non-harmonic frequency ratios, summed together. The resulting waveform has a dense, metallic spectral character that no single oscillator can produce. A highpass filter controls brightness.

- - - - - - - - - - - - - - - - - - - - - - - -
ParameterControlRangeEffect
X (k1)Pitch multiplier0.5x – 2.5xScales all 6 base frequencies together. At 1.0x: original frequencies. Below 1.0: lower, darker. Above: higher, brighter.
Y (k2)Brightness500 – 15500 Hz HPFHighpass filter cutoff. Low = full-bodied metallic noise. High = thin, sizzling hi-hat territory.
-

Base frequencies (Hz): 205.3, 304.4, 369.6, 522.7, 800.6, 1053.4

-

Sound character: Unmistakably metallic. At low HPF: thick, crash cymbal-like. At high HPF: thin, closed hi-hat sizzle. The 6 inharmonic frequencies create dense beating patterns that give the "shimmer" characteristic of real cymbals.

-
-

F-6: NoiseSlew

-

White noise with adjustable one-pole lowpass slew.

-

A simple but effective texture generator: white noise passed through a one-pole LP filter with adjustable cutoff. At high cutoff: full noise. At low cutoff: smooth, slowly undulating random wave. A mix control adds raw noise texture on top of the slewed signal.

- - - - - - - - - - - - - - - - - - - - - - - -
ParameterControlRangeEffect
X (k1)SmoothnessSmooth – NoisyLP filter coefficient. Low = very smooth, slowly varying random wave. High = barely filtered, noise-like.
Y (k2)Texture mixClean – TexturedBlends raw noise on top of the slewed signal. 0 = only slewed output. 1 = slewed + 30% raw noise for gritty texture.
-

Sound character: The full spectrum from smooth random undulation to white noise in one algorithm. At X=0: a gentle, wandering random wave. At X=1: nearly unfiltered noise. The texture mix adds a "grain" to the smooth version without overpowering it.

-
-

F-7: NoiseBurst

-

Sporadic bursts of white noise with silence between them.

-

Generates discrete events: random-length bursts of noise separated by silence. Each burst has a natural fade-out envelope (20-sample ramp) to prevent clicks. The density controls how often bursts occur.

- - - - - - - - - - - - - - - - - - - - - - - -
ParameterControlRangeEffect
X (k1)Burst density~1/sec – ~130/secAverage burst rate. Low = sparse, isolated events. High = dense but never continuous — always gaps between bursts.
Y (k2)Burst length1 ms – 100 msDuration of each noise burst. Short = percussive clicks. Long = noise "grains."
-

Sound character: Sporadic noise events in silence. Like a Geiger counter, or rain hitting a window irregularly. At high density with short bursts: crackling granular texture. At low density with long bursts: isolated noise "drops" with natural decay.

-
-

F-8: LFSRNoise

-

16-bit Linear Feedback Shift Register with selectable tap configurations.

-

A classic LFSR pseudo-random sequence generator with 8 different feedback tap polynomials. Different taps produce different sequence lengths and spectral characteristics. Output quantized to 16 discrete levels (top 4 bits) for a recognizable stepped character.

- - - - - - - - - - - - - - - - - - - - - - - -
ParameterControlRangeEffect
X (k1)Clock rate5 – 500 HzHow fast the register shifts. Low = slow stepped pattern. High = fast digital noise with pitch.
Y (k2)Tap selection8 configurationsSelects from 8 feedback polynomials. Each produces a different sequence pattern — some nearly random, some with audible repetition. Sweep to find sweet spots.
-

Sound character: Digital pseudo-random sequences with a lo-fi, quantized character. Different taps create different "flavors" of digital noise — some more tonal, some more chaotic. The 16-level quantization gives it a distinctly stepped, 4-bit retro quality.

-
-

F-9: DualPulse

-

Two sample-and-hold generators running at independent rates, mixed together.

-

Two independent S&H circuits, each generating random values at their own clock rate. The outputs are mixed 50/50, creating complex polyrhythmic stepped patterns from the interaction of two independent clocks.

- - - - - - - - - - - - - - - - - - - - - - - -
ParameterControlRangeEffect
X (k1)S&H 1 rate5 – 500 HzClock speed of the first generator.
Y (k2)S&H 2 rate5 – 500 HzClock speed of the second generator. Independent of X.
-

Sound character: Two overlapping random step patterns. When the two rates are similar: slow beating between the patterns. When rates are very different: a fast pattern modulated by a slow one. At simple ratios (2:1, 3:2): hints of regularity emerge. At complex ratios: maximally unpredictable interaction.

-
-

Generated from firmware source code analysis. Befaco Noise Plethora v1.5 + Banks D, E & F extension.

- - \ No newline at end of file diff --git a/NOISE_PLETHORA_STEREO_GUIDE.html b/NOISE_PLETHORA_STEREO_GUIDE.html deleted file mode 100644 index 6fc0405..0000000 --- a/NOISE_PLETHORA_STEREO_GUIDE.html +++ /dev/null @@ -1,224 +0,0 @@ -Noise Plethora Stereo Guide

Noise Plethora — Stereo Mode Guide

-

Befaco Noise Plethora v1.5 + Banks D, E & F Extension

-

Table of Contents

- -
-

What It Does

-

Stereo mode transforms the Noise Plethora from two independent mono generators into a single stereo sound source. Generator B automatically mirrors Generator A's algorithm, and the B knobs (XB/YB) are repurposed as stereo controls.

-

The result: a wide stereo field from a single algorithm, where the left and right channels share the same pitch but differ in timbral character. The difference varies slowly over time, creating organic stereo movement.

-
-

How to Activate (VCV Rack)

-
    -
  1. Right-click on the Noise Plethora module
    2. -
  2. Under "Stereo," check "Stereo Mode"
    3. -
  3. Both display dots light up to confirm stereo is active
    4. -
  4. To deactivate: right-click and uncheck
    5. -
-
-

How to Activate (Hardware)

-

Double-click the Program/Bank encoder (two quick clicks within 300ms):

- - - - - - - - - - - - - - - - - - - - - -
GestureAction
Single clickToggle between Gen A and Gen B (normal)
Double-clickToggle stereo mode
Hold 400msEnter/exit bank mode
-

When stereo mode is active: -- Both dots on the 7-segment display light up simultaneously -- The display briefly shows "St" on activation and "no" on deactivation -- Both digits show the same program number

-
-

Controls in Stereo Mode

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
ControlNormal ModeStereo Mode
XA knobk1 for Gen Ak1 for both (pitch/primary param)
YA knobk2 for Gen Ak2 for both (timbre/secondary param)
XB knobk1 for Gen BStereo Width (0=mono, 1=wide)
YB knobk2 for Gen BStereo Movement (LFO speed for width modulation)
CV XACV for k1 ACV for k1 both
CV YACV for k2 ACV for k2 both
CV XBCV for k1 BNot used (manual only)
CV YBCV for k2 BNot used (manual only)
EncoderSelect program for A or BSelect program for both
Filter AFilter for Gen AFilter for left channel
Filter BFilter for Gen BFilter for right channel
-

Note: The analog filters remain fully independent in stereo mode. This is a feature — setting the two filters differently (e.g., LP on left, HP on right) adds an additional layer of stereo character on top of the digital decorrelation.

-
-

How It Works Internally

-
                    XA (k1) ─────────────────────→ Gen A ──→ Filter A ──→ LEFT
-                    YA (k2) ─────────────────────→   │
-                                                      │
-                                                      │ (same algorithm)
-                                                      │
-                    XA (k1) ─────────────────────→ Gen B ──→ Filter B ──→ RIGHT
-                    YA (k2) + stereo offset ─────→   │
-                                                      │
-                    XB ──→ offset amount              │
-                    YB ──→ offset LFO speed ──────────┘
-
-

The stereo offset is applied to k2 (timbre), not k1 (pitch). This is critical — it means both channels always play at the same frequency, but with slightly different timbral character. This creates a natural, phase-free stereo width without the pitch-detuning artifacts of traditional chorus effects.

-

The offset follows a slow sine LFO:

-
offset = XB × 0.4 × sin(2π × YB × 0.3 × time)
-
-
    -
  • XB = 0: offset is zero → mono (both channels identical)
    • -
  • XB = 0.5: offset swings ±0.2 → moderate stereo width
    • -
  • XB = 1.0: offset swings ±0.4 → maximum stereo width
    • -
  • YB = 0: offset is static → fixed stereo spread
    • -
  • YB = 0.5: offset moves slowly → gentle stereo movement
    • -
  • YB = 1.0: offset moves faster → animated stereo field
    • -
-
-

Stereo Patch Ideas

-

1. Immersive Bell Drone

-
    -
  • Program: D-6 NoiseBells
    • -
  • Stereo Mode: ON
    • -
  • XA: ~0.3 (medium bell pitch)
    • -
  • YA: ~0.2 (nearly harmonic, chime-like)
    • -
  • XB: 0.3 (moderate width)
    • -
  • YB: 0.15 (very slow movement)
    • -
  • Filter A: LP, cutoff medium, res low
    • -
  • Filter B: LP, cutoff slightly higher than A
    • -
  • Result: wide, shimmering bell drone where each ear hears slightly different harmonic content
    • -
-

2. Vocal Wash

-
    -
  • Program: D-3 FormantNoise
    • -
  • Stereo Mode: ON
    • -
  • XA: modulated by slow LFO (vowel morphing)
    • -
  • YA: ~0.6 (moderate resonance)
    • -
  • XB: 0.5 (wide)
    • -
  • YB: 0.2 (slow drift)
    • -
  • Filter A: BP, cutoff ~1kHz
    • -
  • Filter B: BP, cutoff ~1.5kHz
    • -
  • Result: ghostly stereo choir, each ear whispers a slightly different vowel
    • -
-

3. Metallic Stereo Texture

-
    -
  • Program: D-4 BowedMetal
    • -
  • Stereo Mode: ON
    • -
  • XA: ~0.4
    • -
  • YA: ~0.8 (long sustain, bowed character)
    • -
  • XB: 0.6 (wide separation)
    • -
  • YB: 0.3 (moderate movement)
    • -
  • Filter A: HP, cutoff low (full spectrum)
    • -
  • Filter B: LP, cutoff medium (darker)
    • -
  • Result: left ear = bright metallic shimmer, right ear = dark resonant glow. Complementary stereo.
    • -
-

4. Chaos Stereo Field

-
    -
  • Program: E-9 DualAttractor
    • -
  • Stereo Mode: ON
    • -
  • XA: ~0.5 (moderate coupling)
    • -
  • YA: ~0.4
    • -
  • XB: 0.4
    • -
  • YB: 0.4
    • -
  • Result: two Lorenz attractors already create wandering tones. In stereo mode, the additional timbral offset makes each channel's attractor feel independent while remaining harmonically related.
    • -
-

5. Wide Cluster

-
    -
  • Program: B-0 ClusterSaw
    • -
  • Stereo Mode: ON
    • -
  • XA: ~0.3 (low fundamental)
    • -
  • YA: ~0.1 (tight cluster = thick unison)
    • -
  • XB: 0.2 (subtle width)
    • -
  • YB: 0.1 (very slow)
    • -
  • Result: massive wide chorused sawtooth wall. The subtle timbral difference between channels creates a huge sound from a simple cluster.
    • -

Befaco Noise Plethora v1.5 + Banks D, E & F extension.

\ No newline at end of file From 9a09d46cec0e7200b8d6dbfdb630a18c7d2c0026 Mon Sep 17 00:00:00 2001 From: Pablo Alcantar Date: Thu, 16 Apr 2026 10:01:34 +0200 Subject: [PATCH 13/14] Remove documentation files from PR Keep the PR focused on code changes only. Co-Authored-By: Claude Opus 4.6 (1M context) --- NOISE_PLETHORA_CATEGORIES.md | 140 ----- NOISE_PLETHORA_PLUGIN_GUIDE.md | 1034 -------------------------------- NOISE_PLETHORA_STEREO_GUIDE.md | 204 ------- 3 files changed, 1378 deletions(-) delete mode 100644 NOISE_PLETHORA_CATEGORIES.md delete mode 100644 NOISE_PLETHORA_PLUGIN_GUIDE.md delete mode 100644 NOISE_PLETHORA_STEREO_GUIDE.md diff --git a/NOISE_PLETHORA_CATEGORIES.md b/NOISE_PLETHORA_CATEGORIES.md deleted file mode 100644 index c3eab3c..0000000 --- a/NOISE_PLETHORA_CATEGORIES.md +++ /dev/null @@ -1,140 +0,0 @@ -# Noise Plethora — Sound Categories - -*Befaco Noise Plethora v1.5 + Banks D, E & F Extension* - -## Table of Contents - -- [Drone](#-drone--sustained-meditative-evolving) -- [Harsh / Noise](#-harsh--noise--aggressive-industrial-digital-destruction) -- [Percussive / Rhythmic](#-percussive--rhythmic--pulses-clicks-patterns) -- [Textural / Ambient](#-textural--ambient--atmospheric-spatial-enveloping) -- [Chaotic / Experimental](#-chaotic--experimental--unpredictable-mathematical-alien) -- [Versatile Programs](#versatile-programs) - ---- - -Every program in the Noise Plethora can be broadly classified by its sonic character. Some programs are versatile and appear in multiple categories depending on knob positions — see [Versatile Programs](#versatile-programs) for details. - ---- - -### 🔊 DRONE — Sustained, meditative, evolving - -Long, sustained tones that evolve slowly. Ideal for ambient backgrounds, meditation, soundscapes, and bass layers. Best experienced with the module's analog filters in lowpass mode with moderate resonance. - -| Program | Name | Why it works for drone | -|---------|------|----------------------| -| D-4 | BowedMetal | 8 metallic resonators with infinite sustain at high Y. Singing bowl character. | -| D-6 | NoiseBells | 4 ultra-sharp resonant peaks ring continuously. Crystal bell drone. | -| D-9 | DroneBody | Two beating sines + wavefolder. Designed specifically for drones. | -| D-2 | TubeResonance | Self-resonating tube drone at Y=0. Hollow, harmonic series. | -| D-0 | CombNoise | Sustained metallic resonance at high feedback. Pipe organ character. | -| E-5 | FeedbackFM | Pure sine at Y=0. The most "clean" drone source. | -| E-6 | RunawayFilter | Self-oscillating filter whistle. Clean pitched tone. | -| E-9 | DualAttractor | Two sines drifting chaotically. Never repeats, always moving. | -| B-4 | TriFMcluster | 6 triangles with ultra-slow phasing. Lush ensemble drift. | -| B-0 | ClusterSaw | 16 sawtooths in tight cluster. Massive shimmering wall. | -| B-8 | PartialCluster | Harmonic series from unison to bells. Most tuneable cluster. | -| B-9 | PhasingCluster | 16 squares with 16 independent LFOs. Self-evolving forever. | -| B-5 | PrimeCluster | Inharmonic prime number chord. Unique metallic shimmer. | - -**Tip:** Use stereo mode with BowedMetal or NoiseBells for an immersive, wide drone. Set XB (width) to ~0.3 for subtle stereo. - ---- - -### ⚡ HARSH / NOISE — Aggressive, industrial, digital destruction - -Raw, aggressive textures. Bitcrushing, distortion, chaotic modulation. Good for industrial music, harsh noise, sound design, and adding grit to other sources via mixing. - -| Program | Name | Character | -|---------|------|-----------| -| E-4 | BitShift | XOR of two sawtooths. 8-bit digital screech. | -| E-7 | GlitchLoop | Captured noise loop that degrades to 1-bit over time. | -| C-8 | Rwalk_BitCrushPW | 9 random-walk oscillators crushed to 1 bit. Extreme lo-fi. | -| C-7 | SatanWorkout | Pink noise FM + self-exciting reverb. Relentless. | -| C-0 | BasuraTotal | LFSR-triggered chaotic bursts with reverb. "Total Garbage." | -| A-6 | GrainGlitch | Granular + XOR. Broken CD character. | -| D-7 | NoiseHarmonics | Wavefolded noise through filter. Angry bee swarm. | -| A-0 | RadioOhNo | 4-way cross-modulation. Unstable shortwave radio. | -| C-6 | WhoKnows | Audio-rate filter sweeps. Wild and unpredictable. | -| A-4 | CrossModRing | Triple cascaded ring mod. Maximum sideband chaos. | - -**Tip:** Harsh programs respond dramatically to the analog resonance control. Crank the module's RES knob with these for screaming filter peaks. - ---- - -### 🥁 PERCUSSIVE / RHYTHMIC — Pulses, clicks, patterns - -Programs that produce discrete events, rhythmic patterns, or percussive textures. From sparse droplets to dense crackle. Useful as rhythmic noise sources, triggers for other modules, or standalone percussion. - -| Program | Name | Character | -|---------|------|-----------| -| D-1 | PluckCloud | Random plucked strings. Kalimba in the rain. | -| D-8 | IceRain | Sparse droplets + reverb tails. Crystalline ambient percussion. | -| E-3 | StochasticPulse | Random metallic pings with resonant filter. Geiger counter. | -| E-8 | SubHarmonic | Square wave + sub-octave dividers. Tectonic bass pulse. | -| A-9 | Basurilla | Noise gated by 3 pulse LFOs. Complex rhythmic chopping. | -| F-0 | PulseWander | Organic random walk pulses. Breathing rhythm. | -| F-1 | TwinPulse | Two correlated pulse streams. Polyrhythmic interference. | -| F-7 | NoiseBurst | Sporadic noise bursts with envelope. Rain on window. | -| F-4 | ShiftPulse | 4-stage shift register. Cascading pulse echoes. | -| E-2 | CellularSynth | Cellular automaton patterns. Self-rewriting music box. | - -**Tip:** PluckCloud (D-1) and IceRain (D-8) are the most "musical" percussive sources. Use the analog lowpass filter to tame the high end for a warmer, more natural percussion texture. - ---- - -### 🌊 TEXTURAL / AMBIENT — Atmospheric, spatial, enveloping - -Smooth, evolving, atmospheric textures. Filtered noise, spatial effects, organic movement. Ideal for ambient soundscapes, film sound design, and background layers. - -| Program | Name | Character | -|---------|------|-----------| -| D-3 | FormantNoise | Ghost choir morphing through vowels. Robotic whispers. | -| D-5 | FlangeNoise | Swept comb filter on noise. Jet engine, ocean waves. | -| C-9 | Rwalk_LFree | PWM random walk + clean reverb. Dreamy, spacious. | -| C-3 | S_H | Sample-hold + reverb. Ambient stochastic clicks. | -| C-5 | ExistenceIsPain | 4 slow LFO-swept filters. Deep, breathing, organic. | -| A-1 | Rwalk_SineFMFlange | FM + random walk + flanger. Complex atmospheric. | -| F-6 | NoiseSlew | Slew-limited noise. From smooth waves to hiss. | -| B-7 | FibonacciCluster | Golden ratio spacing. Naturally balanced shimmer. | -| C-2 | WalkingFilomena | 16 random-walk oscillators. Living, breathing mass. | -| B-3 | SineFMcluster | Subharmonic FM. Warm analog ensemble. | - -**Tip:** These textures shine in stereo mode. FormantNoise (D-3) in stereo with XB at ~0.4 creates a wide vocal-like wash where each channel whispers slightly different vowels. - ---- - -### 🔮 CHAOTIC / EXPERIMENTAL — Unpredictable, mathematical, alien - -Programs based on mathematical chaos, digital logic, and stochastic processes. Sounds that don't exist in the acoustic world. For experimental music, generative systems, and sound design. - -| Program | Name | Character | -|---------|------|-----------| -| E-0 | LogisticNoise | Logistic map. Order dissolving into chaos. Period-3 windows. | -| E-1 | HenonDust | Henon attractor. Alien vinyl crackle. | -| E-2 | CellularSynth | Cellular automaton. Self-rewriting alien music box. | -| F-2 | QuantPulse | Quantized random (1-6 bits). Digital stepped textures. | -| F-3 | ShapedPulse | Shaped probability distribution. Uniform to gaussian. | -| F-5 | MetallicNoise | 6 inharmonic squares (cymbal technique). Pure metallic. | -| F-8 | LFSRNoise | Shift register sequences. 4-bit retro digital patterns. | -| F-9 | DualPulse | Two S&H at independent rates. Polyrhythmic steps. | -| C-4 | ArrayOnTheRocks | Corrupted wavetable + FM. Broken digital beauty. | -| A-2 | xModRingSqr | Cross-FM ring mod squares. Metallic clang. | - -**Tip:** LogisticNoise (E-0) is the most unique program in the module. Slowly sweep X from left to right to hear the transition from periodic order through bifurcation into full chaos. The period-3 window at X≈0.66 is a brief island of order in the noise — genuinely beautiful mathematics made audible. - ---- - -## Versatile Programs - -These programs change category dramatically depending on knob positions: - -| Program | Y low | Y high | Range | -|---------|-------|--------|-------| -| **E-5 FeedbackFM** | Pure sine (DRONE) | White noise (HARSH) | The entire timbral spectrum in one knob | -| **E-6 RunawayFilter** | Clean whistle (DRONE) | Resonant noise (TEXTURAL) | Self-oscillation to noise wash | -| **D-2 TubeResonance** | Hollow drone (DRONE) | Breathy pipe (TEXTURAL) | Self-resonance to wind | -| **E-2 CellularSynth** | Steady drone (DRONE, simple rules) | Rapid mutation (CHAOTIC, Rule 30) | Order to chaos via rule selection | -| **D-4 BowedMetal** | Struck cymbal (PERCUSSIVE, Y low) | Infinite shimmer (DRONE, Y high) | Hit to sustain | -| **B-8 PartialCluster** | Dense unison (DRONE, Y≈1) | Metallic bells (CHAOTIC, Y>2) | Harmonic to inharmonic | -| **C-7 SatanWorkout** | Raw noise texture (HARSH) | Self-exciting reverb feedback (EXPERIMENTAL) | Noise to feedback | diff --git a/NOISE_PLETHORA_PLUGIN_GUIDE.md b/NOISE_PLETHORA_PLUGIN_GUIDE.md deleted file mode 100644 index 88cfc3d..0000000 --- a/NOISE_PLETHORA_PLUGIN_GUIDE.md +++ /dev/null @@ -1,1034 +0,0 @@ -# Noise Plethora — Complete Plugin Guide - -*Befaco Noise Plethora v1.5 + Banks D, E & F Extension* - -## About This Guide - -The Noise Plethora is a Eurorack noise workstation with 2 digital sound generators (A and B), each followed by an analog multimode filter. Generators A and B run interchangeable algorithms organized in banks of 10. Each algorithm has two parameters controlled by the **X** and **Y** knobs (and their corresponding CV inputs, 0–10Vpp). - -This guide documents all 60 algorithms across 6 banks: - -| Bank | Name | Programs | Theme | -|------|------|----------|-------| -| **A** | Textures | 0–9 | Cross-modulation, ring mod, granular, noise AM | -| **B** | HH Clusters | 0–9 | Additive/cluster synthesis with 6–16 oscillators | -| **C** | Harsh & Wild | 0–9 | Bitcrushing, random walks, chaotic oscillators | -| **D** | Resonant Bodies | 0–9 | Delay-based resonance, physical modeling, spectral shaping | -| **E** | Chaos Machines | 0–9 | Deterministic chaos, algorithmic processes, digital manipulation | -| **F** | Stochastic | 0–9 | Random pulses, metallic noise, LFSR sequences, noise textures | - -Banks A–C are the original Befaco firmware. Banks D–F are community extensions. - ---- - -## Table of Contents - -- [Bank A: Textures](#bank-a-textures) - - [A-0: RadioOhNo](#a-0-radioohno) — Cross-modulated square waves - - [A-1: Rwalk_SineFMFlange](#a-1-rwalk_sinefmflange) — Random walk FM + flanger - - [A-2: xModRingSqr](#a-2-xmodringsqr) — Cross FM square ring mod - - [A-3: XModRingSine](#a-3-xmodringsine) — Cross FM sine ring mod - - [A-4: CrossModRing](#a-4-crossmodring) — 4-osc cascaded ring mod - - [A-5: Resonoise](#a-5-resonoise) — Wavefolder-controlled resonant filter - - [A-6: GrainGlitch](#a-6-grainglitch) — Granular + XOR - - [A-7: GrainGlitchII](#a-7-grainglitchii) — Granular amplified - - [A-8: GrainGlitchIII](#a-8-grainglitchiii) — Granular sawtooth - - [A-9: Basurilla](#a-9-basurilla) — Noise gated by 3 pulse LFOs -- [Bank B: HH Clusters](#bank-b-hh-clusters) - - [B-0: ClusterSaw](#b-0-clustersaw) — 16 sawtooths, geometric spread - - [B-1: PwCluster](#b-1-pwcluster) — 6 pulse waves, adjustable PW - - [B-2: CrCluster2](#b-2-crcluster2) — 6 sines, single FM modulator - - [B-3: SineFMcluster](#b-3-sinefmcluster) — 6 triangles, independent sub-FM - - [B-4: TriFMcluster](#b-4-trifmcluster) — 6 triangles, ultra-slow FM - - [B-5: PrimeCluster](#b-5-primecluster) — 16 oscillators at prime frequencies - - [B-6: PrimeCnoise](#b-6-primecnoise) — Primes, wider range variant - - [B-7: FibonacciCluster](#b-7-fibonaccicluster) — 16 sawtooths, Fibonacci spacing - - [B-8: PartialCluster](#b-8-partialcluster) — 16 sawtooths, multiplicative spread - - [B-9: PhasingCluster](#b-9-phasingcluster) — 16 squares with 16 independent LFOs -- [Bank C: Harsh & Wild](#bank-c-harsh--wild) - - [C-0: BasuraTotal](#c-0-basuratotal) — LFSR-triggered oscillator + reverb - - [C-1: Atari](#c-1-atari) — 8-bit cross-modulation - - [C-2: WalkingFilomena](#c-2-walkingfilomena) — 16 random-walk oscillators - - [C-3: S_H](#c-3-s_h-sample--hold) — Sample & hold + reverb - - [C-4: ArrayOnTheRocks](#c-4-arrayontherocks) — Randomized wavetable FM - - [C-5: ExistenceIsPain](#c-5-existenceispain) — 4 LFO-swept bandpass filters - - [C-6: WhoKnows](#c-6-whoknows) — Fast LFO bandpass filters - - [C-7: SatanWorkout](#c-7-satanworkout) — Pink noise FM + reverb - - [C-8: Rwalk_BitCrushPW](#c-8-rwalk_bitcrushpw) — 9 random walks, 1-bit crush - - [C-9: Rwalk_LFree](#c-9-rwalk_lfree) — 4 PWM random walks + reverb -- [Bank D: Resonant Bodies](#bank-d-resonant-bodies) - - [D-0: CombNoise](#d-0-combnoise) — 4 parallel comb filters - - [D-1: PluckCloud](#d-1-pluckcloud) — 6 Karplus-Strong voices - - [D-2: TubeResonance](#d-2-tuberesonance) — Harmonic comb filter tube - - [D-3: FormantNoise](#d-3-formantnoise) — Vowel formant filters - - [D-4: BowedMetal](#d-4-bowedmetal) — 8 metallic resonators - - [D-5: FlangeNoise](#d-5-flangenoise) — Pink noise flanger - - [D-6: NoiseBells](#d-6-noisebells) — 4 sharp bell resonators - - [D-7: NoiseHarmonics](#d-7-noiseharmonics) — Wavefolder + bandpass - - [D-8: IceRain](#d-8-icerain) — S&H droplets + reverb - - [D-9: DroneBody](#d-9-dronebody) — Cross-FM drone + wavefolder -- [Bank E: Chaos Machines](#bank-e-chaos-machines) - - [E-0: LogisticNoise](#e-0-logisticnoise) — Logistic map chaos - - [E-1: HenonDust](#e-1-henondust) — Henon attractor crackle - - [E-2: CellularSynth](#e-2-cellularsynth) — Cellular automaton + 8 oscillators - - [E-3: StochasticPulse](#e-3-stochasticpulse) — Random impulses + resonant filter - - [E-4: BitShift](#e-4-bitshift) — Two sawtooths XOR'd - - [E-5: FeedbackFM](#e-5-feedbackfm) — Self-feedback FM sine - - [E-6: RunawayFilter](#e-6-runawayfilter) — Self-oscillating SVF - - [E-7: GlitchLoop](#e-7-glitchloop) — Loop with bit degradation - - [E-8: SubHarmonic](#e-8-subharmonic) — Frequency dividers - - [E-9: DualAttractor](#e-9-dualattractor) — Coupled Lorenz oscillators -- [Bank F: Stochastic](#bank-f-stochastic) - - [F-0: PulseWander](#f-0-pulsewander) — Smooth random walk pulses - - [F-1: TwinPulse](#f-1-twinpulse) — Two correlated random walks - - [F-2: QuantPulse](#f-2-quantpulse) — Quantized random (1-6 bits) - - [F-3: ShapedPulse](#f-3-shapedpulse) — Shaped probability distribution - - [F-4: ShiftPulse](#f-4-shiftpulse) — 4-stage shift register sequences - - [F-5: MetallicNoise](#f-5-metallicnoise) — 6 inharmonic square oscillators - - [F-6: NoiseSlew](#f-6-noiseslew) — Noise with adjustable LP slew - - [F-7: NoiseBurst](#f-7-noiseburst) — Sporadic noise bursts - - [F-8: LFSRNoise](#f-8-lfsrnoise) — LFSR pseudo-random sequences - - [F-9: DualPulse](#f-9-dualpulse) — Two S&H at independent rates - ---- - -## Bank A: Textures - -Cross-modulation, ring modulation, granular processing, and noise AM. Focused on complex modulation techniques that create rich, evolving textures. - ---- - -### A-0: RadioOhNo - -**Four square wave oscillators cross-modulated in couples, summed together.** - -Four pulse-width-modulated oscillators interconnected in feedback pairs: oscillator 1 modulates 2 and vice versa, oscillator 3 modulates 4 and vice versa. A DC source modulates all oscillators' frequency. The cross-modulation creates complex sidebands and chaotic harmonic interactions. - -| Parameter | Control | Range | Effect | -|-----------|---------|-------|--------| -| **X (k1)** | Oscillator 1 frequency | 20 – 2520 Hz | Base frequency for all 4 oscillators (each at a different ratio). Quadratic mapping for fine control at low frequencies. | -| **Y (k2)** | PWM / DC modulation | 0 – 1 | Controls DC amplitude which modulates all oscillators' frequency. Higher values create wider FM deviation and more chaotic sidebands. | - -**Sound character:** Aggressive, unstable radio-frequency-like textures. Like tuning between shortwave stations. Rich in aliasing and intermodulation products. - ---- - -### A-1: Rwalk_SineFMFlange - -**Four random walkers controlling pulse oscillators, FM'd by sines, through a flanger.** - -Four 2D random walkers move in a bounded box with random velocities. Their positions map to the frequencies of 4 pulse wave oscillators, which feed into 4 sine FM oscillators. The mixed output passes through a flanger effect. - -| Parameter | Control | Range | Effect | -|-----------|---------|-------|--------| -| **X (k1)** | FM sine frequency | 10 – 510 Hz | Base frequency of the 4 sine FM oscillators (each offset by 55–75 Hz). | -| **Y (k2)** | Flanger modulation rate | 0 – 3 Hz | LFO speed of the flanger. Adds swept comb filtering on top of the FM textures. | - -**Sound character:** Morphing, evolving FM textures with organic movement. The flanger adds spatial depth and sweeping spectral animation. No two moments are alike. Atmospheric and complex. - ---- - -### A-2: xModRingSqr - -**Cross FM between two square wave oscillators, ring modulated.** - -Two square wave oscillators in a feedback configuration: each modulates the other's frequency. Their outputs are ring modulated (multiplied) together. - -| Parameter | Control | Range | Effect | -|-----------|---------|-------|--------| -| **X (k1)** | Oscillator 1 frequency | 100 – 5100 Hz | Pitch of the first square wave. Quadratic mapping. | -| **Y (k2)** | Oscillator 2 frequency | 20 – 1020 Hz | Pitch of the second square wave. Quadratic mapping. | - -**Sound character:** Metallic, clanging ring modulation. At simple ratios (2:1, 3:2) = tonal metallic tones. At complex ratios = inharmonic metallic clatter. - ---- - -### A-3: XModRingSine - -**Cross FM between two sine oscillators, ring modulated.** - -Same topology as xModRingSqr but using sine FM oscillators. Sines produce cleaner, more bell-like results than squares. - -| Parameter | Control | Range | Effect | -|-----------|---------|-------|--------| -| **X (k1)** | Oscillator 1 frequency | 100 – 8100 Hz | Pitch of the first sine. Quadratic mapping. Wide range. | -| **Y (k2)** | Oscillator 2 frequency | 60 – 3060 Hz | Pitch of the second sine. Quadratic mapping. | - -**Sound character:** Bell-like and metallic tones. All spectral content comes from the FM and ring modulation. Good for tuned metallic percussion sounds. - ---- - -### A-4: CrossModRing - -**Four oscillators in a cross-modulation matrix with cascaded ring modulators.** - -Four oscillators (2 square, 1 sawtooth with offset, 1 square) modulate each other's frequencies. Three ring modulators in a cascaded configuration: multiply1 and multiply2 feed into multiply3. The most complex modulation topology in the module. - -| Parameter | Control | Range | Effect | -|-----------|---------|-------|--------| -| **X (k1)** | Frequency (all oscillators) | 1 – 827 Hz | Scales all 4 oscillator frequencies with individual ratios. | -| **Y (k2)** | FM depth | 2 – 10 octaves | Master frequency modulation depth. Low = subtle. High = total harmonic chaos. | - -**Sound character:** Incredibly dense sideband spectrum. From metallic drones at low FM depth to total chaos at high depth. Like a 4-operator FM synth pushed to extremes. - ---- - -### A-5: Resonoise - -**Square wave FM-modulating a sine, through a wavefolder, controlling a resonant filter on white noise.** - -A modulated square wave drives a sine FM oscillator. The sine passes through a wavefolder, then feeds into a state-variable filter as the frequency control signal. White noise is the audio input to the filter (resonance=3). - -| Parameter | Control | Range | Effect | -|-----------|---------|-------|--------| -| **X (k1)** | Both oscillator frequencies | 20 – 10020 Hz | Controls the modulation rate of the filter cutoff. | -| **Y (k2)** | Wavefold amount | 0.03 – 0.23 | DC bias into the wavefolder. More folding = more complex filter modulation pattern. | - -**Sound character:** Resonant noise with animated filter modulation. Like white noise through an auto-wah driven by a complex LFO. Organic and vocal. - ---- - -### A-6: GrainGlitch - -**Square wave through a granular cell, output XOR'd with the input.** - -A square wave feeds into a granular pitch-shifting processor with feedback. The original square wave and the granular output are combined using XOR digital logic. - -| Parameter | Control | Range | Effect | -|-----------|---------|-------|--------| -| **X (k1)** | Square wave frequency | 500 – 5500 Hz | Base frequency of the source oscillator. | -| **Y (k2)** | Grain size + speed | 25–100 ms / 0.125–8x | Grain size (pitch shift window) and playback speed ratio. | - -**Sound character:** Glitchy digital artifacts from XOR combination. Harsh, broken, digital — like a CD skipping. - ---- - -### A-7: GrainGlitchII - -**Square wave through a granular cell, amplified.** - -Similar to GrainGlitch but without XOR. Granular output amplified 32000x to bring up the quiet signal. - -| Parameter | Control | Range | Effect | -|-----------|---------|-------|--------| -| **X (k1)** | Square wave frequency | 500 – 5500 Hz | Base frequency of the source oscillator. | -| **Y (k2)** | Grain size + speed | 25–100 ms / 0.125–8x | Same mapping as GrainGlitch. | - -**Sound character:** Cleaner granular texture than GrainGlitch. More transparent and "musical" than the XOR version. - ---- - -### A-8: GrainGlitchIII - -**Sawtooth wave through a granular cell.** - -Similar to GrainGlitchII but using a sawtooth waveform. Richer harmonic spectrum provides more material for the granular processor. - -| Parameter | Control | Range | Effect | -|-----------|---------|-------|--------| -| **X (k1)** | Sawtooth frequency | 400 – 5500 Hz | Base frequency. | -| **Y (k2)** | Grain size + speed | 25–80 ms / 0.125–8x | Slightly narrower grain range than I/II. | - -**Sound character:** The richest granular variant. Textures from buzzy granular drones to scattered metallic fragments. - ---- - -### A-9: Basurilla - -**White noise amplitude-modulated by 3 independent pulse wave LFOs.** - -Three parallel channels: white noise is ring-modulated by 3 pulse wave oscillators at different rates and pulse widths. The pulse waves gate the noise in complex rhythmic patterns. - -| Parameter | Control | Range | Effect | -|-----------|---------|-------|--------| -| **X (k1)** | LFO frequencies | 0.1 – 110 Hz | Controls all 3 pulse LFOs. Low = slow gates. High = audio-rate AM. | -| **Y (k2)** | Pulse widths / noise level | PW + inverse amplitude | Pulse width of the 3 LFOs and inversely controls noise amplitude. | - -**Sound character:** Chaotic, granular-like texture from noise gated by 3 independent pulse trains. "Basurilla" = "little garbage" in Spanish — beautifully organized trash. - ---- - -## Bank B: HH Clusters - -Cluster/additive synthesis using 6–16 oscillators at mathematically related frequency ratios. Dense, shimmering tonal textures. - ---- - -### B-0: ClusterSaw - -**16 sawtooth oscillators with adjustable geometric frequency spread.** - -Sixteen sawtooths tuned in geometric progression. Each frequency is the previous one multiplied by a constant factor. - -| Parameter | Control | Range | Effect | -|-----------|---------|-------|--------| -| **X (k1)** | Base frequency | 20 – 1020 Hz | Fundamental frequency. | -| **Y (k2)** | Spread factor | 1.01 – 1.91 | Ratio between adjacent oscillators. Low = beating unison. High = wide harmonic spread. | - -**Sound character:** Shimmering, buzzing mass of sawtooths. The quintessential "cluster" sound. 16 voices create an extremely rich spectral texture. - ---- - -### B-1: PwCluster - -**6 detuned pulse waveforms with adjustable pulse width.** - -Six pulse waves at fixed detuned ratios (1.227, 1.24, 1.17, 1.2, 1.3). DC-controlled pulse width. - -| Parameter | Control | Range | Effect | -|-----------|---------|-------|--------| -| **X (k1)** | Base frequency | 40 – 8040 Hz | Widest range of any cluster plugin. | -| **Y (k2)** | Pulse width | Wide – Narrow (inverted) | Low Y = full, warm. High Y = thin, nasal. | - -**Sound character:** Chorused pulse waves. At wide PW: organ-like. At narrow PW: reedy, nasal. Constant beating from non-harmonic detuning. - ---- - -### B-2: CrCluster2 - -**6 detuned sine waves with low-frequency FM from a single modulator.** - -Six sines, all FM'd by one sine at 2.7x the base frequency. - -| Parameter | Control | Range | Effect | -|-----------|---------|-------|--------| -| **X (k1)** | Base frequency | 40 – 8040 Hz | Cluster fundamental. | -| **Y (k2)** | FM index | 0 – 1.0 | Low = pure sine cluster. High = bright FM harmonics. | - -**Sound character:** Clean sine cluster that becomes progressively FM-modulated. Warm to bright. Spectrally coherent. - ---- - -### B-3: SineFMcluster - -**6 triangle waves, each independently FM'd by its own sine modulator (subharmonic ratio 0.333).** - -| Parameter | Control | Range | Effect | -|-----------|---------|-------|--------| -| **X (k1)** | Base frequency | 300 – 8300 Hz | Higher starting frequency. | -| **Y (k2)** | FM index | 0.1 – 1.0 | Subharmonic FM adds content below carriers. | - -**Sound character:** Warm, soft FM cluster. Triangle carriers + subharmonic FM = "analog" feeling warmth and depth. - ---- - -### B-4: TriFMcluster - -**6 triangle waves, each independently FM'd at very slow ratio (0.07).** - -Same architecture as SineFMcluster but with 1/14th FM ratio. Creates phasing/chorus rather than FM timbral change. - -| Parameter | Control | Range | Effect | -|-----------|---------|-------|--------| -| **X (k1)** | Base frequency | 300 – 8300 Hz | Same range as SineFMcluster. | -| **Y (k2)** | FM index | 0.1 – 1.0 | Creates slow drifting detuning, not bright harmonics. | - -**Sound character:** Lush, animated ensemble effect. Like 6 slightly out-of-tune instruments. Very different from SineFMcluster despite identical architecture. - ---- - -### B-5: PrimeCluster - -**16 oscillators tuned to prime number frequencies, noise-modulated.** - -Sixteen variable-triangle oscillators at primes (53, 127, 199... 1523 Hz), all scaled by a common factor. White noise FM adds animation. - -| Parameter | Control | Range | Effect | -|-----------|---------|-------|--------| -| **X (k1)** | Pitch multiplier | 0.5 – 10.5 | Scales all 16 primes. Linear mapping. | -| **Y (k2)** | Noise modulation | 0 – 0.2 | Noise FM amount. Low = clean. High = tremolo-like. | - -**Gain:** 0.8 (reduced to prevent clipping). - -**Sound character:** Inharmonic, bell-like chord. No common harmonics — a unique shimmering metallic texture. - ---- - -### B-6: PrimeCnoise - -**16 triangle oscillators at prime frequencies (wider range variant).** - -Nearly identical to PrimeCluster but with quadratic pitch mapping (k1^2 x 12) for wider range. - -| Parameter | Control | Range | Effect | -|-----------|---------|-------|--------| -| **X (k1)** | Pitch multiplier | 0.5 – 12.5 | Quadratic mapping — more extreme range. | -| **Y (k2)** | Noise modulation | 0 – 0.2 | Same as PrimeCluster. | - -**Gain:** 0.8 - -**Sound character:** Same prime character, different response to knob gestures. More exponential/extreme than PrimeCluster. - ---- - -### B-7: FibonacciCluster - -**16 sawtooth oscillators at Fibonacci-series frequency spacing.** - -Frequencies follow `f(n) = f(n-1) + f(n-2) x spread`. Noise FM adds animation. - -| Parameter | Control | Range | Effect | -|-----------|---------|-------|--------| -| **X (k1)** | Base frequency | 50 – 1050 Hz | Fundamental pitch. | -| **Y (k2)** | Spread factor | 0.1 – 0.6 | How fast frequencies diverge. Near 0.618 = golden ratio intervals. | - -**Sound character:** Nature's favorite ratio. At spread near golden ratio, intervals feel "naturally balanced." Unique organic quality. - ---- - -### B-8: PartialCluster - -**16 sawtooth oscillators with multiplicative harmonic spacing.** - -Each frequency is the previous multiplied by a spread factor. - -| Parameter | Control | Range | Effect | -|-----------|---------|-------|--------| -| **X (k1)** | Base frequency | 50 – 1050 Hz | Fundamental. | -| **Y (k2)** | Harmonic spread | 1.01 – 2.11 | At 2.0 = octave spacing. Below = dense. Above = stretched/metallic. | - -**Sound character:** The most "tuneable" cluster. Morph from dense unison to harmonic series to metallic bells by sweeping Y. - ---- - -### B-9: PhasingCluster - -**16 square waves with individual LFO phase modulation.** - -Each oscillator has its own triangle LFO at a unique rate: 10, 11, 15, 1, 1, 3, 17, 14, 0.11, 5, 2, 7, 1, 0.1, 0.7, 0.5 Hz. - -| Parameter | Control | Range | Effect | -|-----------|---------|-------|--------| -| **X (k1)** | Carrier frequency | 30 – 5030 Hz | Base frequency for all 16 squares. | -| **Y (k2)** | Spread | 1.0 – 1.5 | Spreads carrier frequencies slightly. | - -**Sound character:** Massive phasing. 16 oscillators drifting at their own rates — constantly evolving, never-repeating interference patterns. Glacial slow LFOs (0.1 Hz) + shimmer (17 Hz). - ---- - -## Bank C: Harsh & Wild - -Extreme processing: bitcrushing, random walks, chaotic oscillators, reverb abuse. The most experimental and aggressive bank. - ---- - -### C-0: BasuraTotal - -**"Bent" LFSR driving an oscillator with reverb.** - -A Galois LFSR generates pseudo-random timing events that trigger a waveform oscillator. Output through Freeverb. - -| Parameter | Control | Range | Effect | -|-----------|---------|-------|--------| -| **X (k1)** | Oscillator frequency | 200 – 5200 Hz | Pitch of triggered waveform. | -| **Y (k2)** | Event rate | Slow – Fast | Timing between LFSR-triggered events. | - -**Sound character:** Sporadic bursts with reverb tails. "BasuraTotal" = "Total Garbage" — chaotic, messy, and beautiful. - ---- - -### C-1: Atari - -**Two square waves with PWM/FM cross-modulation.** - -First oscillator does PWM on the second, second does FM on the first. - -| Parameter | Control | Range | Effect | -|-----------|---------|-------|--------| -| **X (k1)** | Wave 1 frequency | 10 – 60 Hz | Sub-bass territory. | -| **Y (k2)** | Wave 2 freq + FM depth | 10–210 Hz / 3–11 oct | Higher pitch AND more extreme modulation. | - -**Sound character:** Classic 8-bit Atari/chiptune. Buzzy, aggressive, nostalgic. - ---- - -### C-2: WalkingFilomena - -**16 random walkers controlling pulse oscillator frequencies.** - -Sixteen pulse oscillators with independent 2D random walkers in a bounded box. - -| Parameter | Control | Range | Effect | -|-----------|---------|-------|--------| -| **X (k1)** | Random walk box size | 200 – 1800 Hz | Frequency range of all 16 oscillators. | -| **Y (k2)** | Pulse width | 0.1 – 0.9 | Thin = bright/nasal. Wide = warm/full. | - -**Sound character:** Shimmering, constantly evolving polyphonic texture. 16 oscillators wandering in pitch space. Organic and alive. - ---- - -### C-3: S_H (Sample & Hold) - -**Sample-and-hold noise with dirty reverb.** - -| Parameter | Control | Range | Effect | -|-----------|---------|-------|--------| -| **X (k1)** | S&H rate | 15 – 5015 Hz | Slow = stepped tones. Fast = granular noise. | -| **Y (k2)** | Reverb mix | Dry – Wet | Dry = stochastic clicks. Wet = ambient wash. | - -**Sound character:** Classic S&H randomness with spatial depth from reverb. - ---- - -### C-4: ArrayOnTheRocks - -**FM synthesis with a randomized 256-point wavetable.** - -A 500 Hz sine modulates an arbitrary waveform with randomly corrupted table values. - -| Parameter | Control | Range | Effect | -|-----------|---------|-------|--------| -| **X (k1)** | Wavetable oscillator freq | 10 – 10010 Hz | Playback speed. | -| **Y (k2)** | FM modulator amplitude | 0 – 1.0 | Low = clean wavetable. High = rich FM sidebands. | - -**Sound character:** Unpredictable timbral textures from the corrupted wavetable. Different from standard FM because the carrier waveform itself is partially random. - ---- - -### C-5: ExistenceIsPain - -**Sample-and-hold noise through 4 bandpass filters modulated by 4 LFOs.** - -S&H source into 4 parallel SVF bandpass filters with independent triangle LFOs at 11, 70, 23, 0.01 Hz. Resonance=5. - -| Parameter | Control | Range | Effect | -|-----------|---------|-------|--------| -| **X (k1)** | S&H noise frequency | 50 – 5050 Hz | Base texture density. | -| **Y (k2)** | Filter sweep range | 0.3 – 3.3 octaves | Narrow = focused. Wide = dramatic animation. | - -**Sound character:** Slowly breathing, organic multiband filtering. The 0.01 Hz LFO creates glacial changes, 70 Hz adds shimmer. Deep, meditative, slightly ominous. - ---- - -### C-6: WhoKnows - -**Pulse wave through 4 bandpass filters with fast LFO modulation.** - -Similar to ExistenceIsPain but with 5 Hz pulse source and much faster LFOs (21, 70, 90, 77 Hz). Resonance=7. - -| Parameter | Control | Range | Effect | -|-----------|---------|-------|--------| -| **X (k1)** | Pulse frequency | 15 – 515 Hz | Source frequency. | -| **Y (k2)** | Filter sweep range | 0.3 – 6.3 octaves | At high settings, filters sweep wildly. | - -**Sound character:** Dramatic, rapidly animated filter textures. Audio-rate LFOs create sideband-like effects. Aggressive and chaotic. - ---- - -### C-7: SatanWorkout - -**Pink noise FM-ing a PWM oscillator, through reverb.** - -Pink noise modulates a PWM oscillator. Freeverb with negative damping (-5). - -| Parameter | Control | Range | Effect | -|-----------|---------|-------|--------| -| **X (k1)** | PWM frequency | 8 – 6008 Hz | "Pitch" of noise modulation. | -| **Y (k2)** | Reverb room size | 0.001 – 4.0 | Beyond 1.0 = self-exciting reverb feedback. | - -**Sound character:** Raw organic noise with reverb. At high Y the reverb self-excites. Relentless intensity. - ---- - -### C-8: Rwalk_BitCrushPW - -**9 random-walk pulse oscillators, bitcrushed to 1 bit, with reverb.** - -Nine pulse oscillators with 2D random walkers. Mixed, 1-bit crushed, parallel reverb path. - -| Parameter | Control | Range | Effect | -|-----------|---------|-------|--------| -| **X (k1)** | Pulse width | 0.2 – 0.75 | Timbre control alongside random walk frequencies. | -| **Y (k2)** | Reverb room size | 0 – 4.0 | High = self-exciting reverb. | - -**Sound character:** Extreme digital destruction. Dense, distorted digital texture with organic pitch movement from random walks. Lo-fi at its most extreme. - ---- - -### C-9: Rwalk_LFree - -**4 PWM oscillators with random-walk frequencies, through reverb.** - -Four PWM oscillators with independent random walkers. Clean Freeverb (no bitcrushing). - -| Parameter | Control | Range | Effect | -|-----------|---------|-------|--------| -| **X (k1)** | Random walk boundary | 50 – 550 Hz | Frequency space size. | -| **Y (k2)** | Reverb room size | 0 – 1.0 | Conservative range, clean reverb. | - -**Sound character:** Spacious, clean random pulse textures. Warm timbre, gentle pitch drift, dreamy ambient reverb. The gentlest of the random walk family. - ---- - -## Bank D: Resonant Bodies - -Delay-based resonance, physical modeling, and spectral shaping. What happens when noise passes through resonant structures: comb filters, waveguides, feedback networks, and high-Q resonators. - ---- - -### D-0: CombNoise - -**White noise through 4 parallel comb filters.** - -A comb filter is a short delay line with feedback — it reinforces frequencies at the delay time and its harmonics. Four combs at ratios 1.0 : 0.7 : 0.5 : 0.35 create a rich, multi-pitched metallic tone. - -| Parameter | Control | Range | Effect | -|-----------|---------|-------|--------| -| **X (k1)** | Resonant pitch | 40 – 5000 Hz | Fundamental frequency of all 4 comb filters. | -| **Y (k2)** | Feedback | 0 – 95% | Resonance sustain. Low = colored noise. High = clearly pitched ringing. | - -**Sound character:** Like blowing across a metal pipe. The 4 overlapping combs create a rich harmonic spectrum. - ---- - -### D-1: PluckCloud - -**6 Karplus-Strong plucked string voices with random retriggering.** - -Noise burst into delay line with LP filter in feedback loop. Voices retrigger randomly (~2% per cycle). Detuned at ratios 1.0, 1.005, 0.995, 1.01, 0.99, 1.015. - -| Parameter | Control | Range | Effect | -|-----------|---------|-------|--------| -| **X (k1)** | Pitch center | 60 – 3000 Hz | Base pitch for all 6 voices. | -| **Y (k2)** | Brightness / decay | Dull – Bright | Low = muted string, fast decay. High = bright ring, long sustain. | - -**Sound character:** Rain on a kalimba, or a prepared piano played by dice. Sparse, organic, constantly evolving. - ---- - -### D-2: TubeResonance - -**Noise excitation through 4 harmonic comb filters simulating a resonant tube.** - -Four combs at 1x, 2x, 3x, 4x fundamental. Higher harmonics decay faster (feedback scaled by 1/harmonic). - -| Parameter | Control | Range | Effect | -|-----------|---------|-------|--------| -| **X (k1)** | Tube length | 40 – 1000 Hz | Fundamental pitch. Low = long tube. High = short pipe. | -| **Y (k2)** | Excitation | Self-resonance – Breath | Low = singing bowl drone. High = breathy wind-through-pipe. | - -**Sound character:** Hollow drone to breathy pipe texture. Harmonic series is clearly audible — sounds like a real resonant object. - ---- - -### D-3: FormantNoise - -**White noise through 3 bandpass filters at vowel formant frequencies.** - -Interpolates between 5 vowel shapes (A, E, I, O, U) using 3 SVF bandpass filters. - -| Parameter | Control | Range | Effect | -|-----------|---------|-------|--------| -| **X (k1)** | Vowel morph | A → E → I → O → U | Smooth interpolation between vowel formants. | -| **Y (k2)** | Resonance | Q 1.0 – 5.0 | Wide/breathy to sharp/nasal vowels. | - -**Formant table (Hz):** - -| Vowel | F1 | F2 | F3 | -|-------|-----|------|------| -| A | 730 | 1090 | 2440 | -| E | 660 | 1720 | 2410 | -| I | 270 | 2290 | 3010 | -| O | 570 | 840 | 2410 | -| U | 300 | 870 | 2240 | - -**Sound character:** Robotic choir whispering vowels. Sweep X for ghostly "aaah → eeeh → iiih → oooh → uuuh." - ---- - -### D-4: BowedMetal - -**Noise exciting 8 high-Q resonators at dense metallic frequency ratios.** - -Eight 2-pole resonators (Q ~300–500) at plate vibration mode ratios. Denser than NoiseBells = more reverberant. - -| Parameter | Control | Range | Effect | -|-----------|---------|-------|--------| -| **X (k1)** | Fundamental pitch | 30 – 2030 Hz | All 8 resonators scale proportionally. | -| **Y (k2)** | Struck → Bowed | Short ring – Infinite sustain | Low = cymbal hit. High = bowed singing bowl. | - -**Resonator ratios:** 1.000, 1.183, 1.506, 1.741, 2.098, 2.534, 2.917, 3.483 - -**Sound character:** Dense metallic reverberance. Bowed cymbal or gong. More diffuse than NoiseBells. - ---- - -### D-5: FlangeNoise - -**Pink noise through a flanger effect.** - -Swept comb filter on noise. Classic "jet engine whoosh." - -| Parameter | Control | Range | Effect | -|-----------|---------|-------|--------| -| **X (k1)** | Flange rate | 0.05 – 5 Hz | Slow sweep to fast warble. | -| **Y (k2)** | Flange depth | Subtle – Deep | Phase-like to dramatic comb sweep. | - -**Sound character:** Jet plane flyover, ocean through metal tube, wind in rotating vent. - ---- - -### D-6: NoiseBells - -**White noise exciting 4 sharp 2-pole resonators at bell-like inharmonic ratios.** - -Extremely high Q (~625) creates laser-sharp peaks. Clear ringing tones from noise. - -| Parameter | Control | Range | Effect | -|-----------|---------|-------|--------| -| **X (k1)** | Bell pitch | 80 – 4080 Hz | Fundamental. All 4 resonators scale. | -| **Y (k2)** | Inharmonicity | Chime → Gong | Near-harmonic (wind chime) to stretched (gamelan). | - -**Resonator ratios (vary with Y):** - -| Resonator | Y=0 (chime) | Y=1 (gong) | -|-----------|-------------|------------| -| 1 | 1.00x | 1.00x | -| 2 | 1.59x | 2.48x | -| 3 | 2.33x | 4.33x | -| 4 | 3.14x | 6.35x | - -**Sound character:** Clear bell tones from noise. Visible on spectrum analyzer as 4 needle-sharp peaks. - ---- - -### D-7: NoiseHarmonics - -**White noise through a wavefolder, then resonant bandpass filter.** - -Wavefolder creates harmonics from noise (DC bias controlled). SVF filter (Q=3) selects a frequency band. - -| Parameter | Control | Range | Effect | -|-----------|---------|-------|--------| -| **X (k1)** | Wavefold intensity | Gentle – Heavy | More folding = denser harmonics. | -| **Y (k2)** | Filter frequency | 100 – 8100 Hz | Selects which band is heard. | - -**Sound character:** Aggressive buzzing. Like an angry bee swarm at a specific pitch. Grittier than plain filtered noise. - ---- - -### D-8: IceRain - -**Sparse sample-and-hold events with long reverb tails.** - -Random stepped values at controllable rate into Freeverb (high damping). - -| Parameter | Control | Range | Effect | -|-----------|---------|-------|--------| -| **X (k1)** | Droplet density | 0.5 – 200 Hz | Sparse plinks to dense rain. | -| **Y (k2)** | Reverb size | Small – Vast | Dry/close to cathedral-like. | - -**Sound character:** Crystalline drops in a cave. Sparse plinks with shimmering tails. Very spatial and ambient. - ---- - -### D-9: DroneBody - -**Two cross-modulated FM sines through a wavefolder.** - -Slightly detuned sines with block-delayed cross-feedback FM. Wavefolder adds harmonics. - -| Parameter | Control | Range | Effect | -|-----------|---------|-------|--------| -| **X (k1)** | Drone pitch | 20 – 520 Hz | Fundamental of both sines. | -| **Y (k2)** | Detune + Fold | Clean – Rich | Y=0: clean hum. Y=1: beating + growling overtones. | - -**Sound character:** Deep meditative drone. Tibetan singing bowl meets power transformer. Good for sustained bass. - ---- - -## Bank E: Chaos Machines - -Deterministic chaos, algorithmic processes, and digital manipulation. Mathematical systems that hover between order and noise. - ---- - -### E-0: LogisticNoise - -**Logistic map chaotic oscillator: `x(n+1) = r * x(n) * (1 - x(n))`** - -| Parameter | Control | Range | Effect | -|-----------|---------|-------|--------| -| **X (k1)** | Chaos parameter r | 3.5 – 4.0 | 3.5=periodic. 3.57=chaos onset. 3.83=period-3 window. 4.0=full chaos. | -| **Y (k2)** | Output rate | Slow – Fast | Held samples (buzzy tone) to per-sample (noise-like at r=4). | - -**Sound character:** Mathematical structure dissolving into chaos. Sweep r to hear windows of order breaking into noise. The period-3 window at r~3.83 is particularly striking. - ---- - -### E-1: HenonDust - -**Henon attractor: `x' = 1 - a*x^2 + y, y' = b*x`** - -| Parameter | Control | Range | Effect | -|-----------|---------|-------|--------| -| **X (k1)** | Parameter a | 1.15 – 1.40 | Low=periodic. ~1.2=period-doubling. 1.4=full chaos. | -| **Y (k2)** | Parameter b | 0.15 – 0.35 | Attractor shape and crackle density. | - -**Sound character:** Alien vinyl surface noise. Almost-repeating patterns that never quite repeat. Living, deterministic crackle. - ---- - -### E-2: CellularSynth - -**1D cellular automaton (32 cells) controlling 8 sawtooth oscillators at harmonics of 55 Hz.** - -| Parameter | Control | Range | Effect | -|-----------|---------|-------|--------| -| **X (k1)** | CA rule | 0 – 255 | Rule 30=chaotic. Rule 90=fractal. Rule 110=complex. | -| **Y (k2)** | Evolution speed | Glacial – Rapid | How fast the CA evolves. | - -**Sound character:** Alien music box that rewrites its own score. Some rules = steady drone, others = constant mutation. - ---- - -### E-3: StochasticPulse - -**Poisson-distributed impulses through a resonant bandpass filter (Q=4.5).** - -| Parameter | Control | Range | Effect | -|-----------|---------|-------|--------| -| **X (k1)** | Impulse density | 5 – 505 /sec | Sparse pings to dense crackling. | -| **Y (k2)** | Filter frequency | 80 – 8080 Hz | Pitch of the resonant ring. | - -**Sound character:** Geiger counter meets resonant drum. Random metallic pings with clear musical pitch. - ---- - -### E-4: BitShift - -**Two sawtooth oscillators combined via XOR digital logic.** - -| Parameter | Control | Range | Effect | -|-----------|---------|-------|--------| -| **X (k1)** | Oscillator 1 freq | 20 – 5020 Hz | First sawtooth. | -| **Y (k2)** | Oscillator 2 ratio | 1:1 – 1:8 | Simple ratios = structured. Irrational = maximum complexity. | - -**Sound character:** Broken NES / ZX Spectrum. Hard digital edges, rapidly shifting sum/difference tones. Aggressive 8-bit. - ---- - -### E-5: FeedbackFM - -**Single sine with sample-delayed self-feedback into its own phase.** - -| Parameter | Control | Range | Effect | -|-----------|---------|-------|--------| -| **X (k1)** | Carrier frequency | 20 – 5020 Hz | Pitch. | -| **Y (k2)** | Feedback | 0 – 2.5 rad | 0=sine. ~0.8=bright. ~1.5=metallic. ~2.0=gritty. 2.5=noise. | - -**Sound character:** The full timbral spectrum in one knob. Classic DX7 operator technique. Sweet spot at Y~1.0 = vocal/nasal quality. - ---- - -### E-6: RunawayFilter - -**White noise through a self-oscillating SVF (Q ~4.5–4.99).** - -| Parameter | Control | Range | Effect | -|-----------|---------|-------|--------| -| **X (k1)** | Filter frequency | 30 – 10030 Hz | Pitched self-oscillation tone. | -| **Y (k2)** | Noise injection | Whistle – Noise | Y=0: clean sine whistle. Y=1: resonant noise. Transition zone = sweet spot. | - -**Sound character:** Pitched whistle fighting noise. Like tuning a shortwave radio. Fragile tone that breaks and reforms. - ---- - -### E-7: GlitchLoop - -**Noise captured into a loop with progressive bit-depth degradation.** - -| Parameter | Control | Range | Effect | -|-----------|---------|-------|--------| -| **X (k1)** | Loop length | 10 – 200 ms | Short = buzz. Long = stutter. | -| **Y (k2)** | Degradation rate | Stable – Rapid | How fast the loop crumbles. Refills when bit depth hits 1. | - -**Sound character:** Digital decay. Loop captures, degrades, collapses to 1-bit, refreshes. Rhythmic destruction cycle. - ---- - -### E-8: SubHarmonic - -**Square wave with frequency dividers at /2, /3, /5, /7.** - -| Parameter | Control | Range | Effect | -|-----------|---------|-------|--------| -| **X (k1)** | Fundamental frequency | 100 – 4100 Hz | Source square wave pitch. | -| **Y (k2)** | Subharmonic mix | /2 only → All four | Progressive: Y=0: octave below. Y=0.33: +fifth below. Y=0.66: +major 3rd down. Y=1: +minor 7th down. | - -**Subharmonic intervals at 440 Hz:** /2=220 Hz, /3=~147 Hz, /5=88 Hz, /7=~63 Hz - -**Sound character:** Deep rumbling sub-bass. Earth-shaking low end at full Y with low fundamental. Tectonic. - ---- - -### E-9: DualAttractor - -**Two coupled Lorenz attractors driving two sine oscillators.** - -Lorenz system: `dx/dt = sigma(y-x)`, `dy/dt = x(rho-z)-y`, `dz/dt = xy-beta*z`. sigma=10, rho=28, beta=8/3. - -| Parameter | Control | Range | Effect | -|-----------|---------|-------|--------| -| **X (k1)** | Coupling strength | 0 – 5 | 0=independent chaos. 5=tones lock/unlock in bursts. | -| **Y (k2)** | Base frequency | 30 – 2030 Hz | Center pitch the attractors orbit. | - -**Sound character:** Two drunk musicians trying to play in unison. Moments of harmony interrupted by chaos. Organic, alive, never repeating. - ---- - -## Bank F: Stochastic - -Random processes generating pulses, transients, and noise textures. The pulse-based algorithms (F-0 through F-4) exploit the Noise Plethora's internal DC blocker to transform random stepped values into unique transient/pulse shapes — a character exclusive to this module's architecture. - ---- - -### F-0: PulseWander - -**Smooth random walk generating organic pulse patterns.** - -A random target value is chosen periodically, and a one-pole LP filter smoothly tracks it. The module's DC blocker transforms held values into distinctive pulse shapes with natural attack/decay envelopes. - -| Parameter | Control | Range | Effect | -|-----------|---------|-------|--------| -| **X (k1)** | Rate | 5 – 400 Hz | How often a new random target is chosen. Low = sparse, isolated pulses. High = dense, overlapping transients. | -| **Y (k2)** | Smoothness | Instant – Smooth | k2=0: instant jumps (sharp S&H pulses). k2=1: smooth glide between targets (softer, rounder transients). The LP filter alpha auto-scales with rate. | - -**Sound character:** Organic, irregular pulse train. Each pulse has a unique amplitude from the random walk. The smoothness control morphs from sharp clicks to rounded bumps. Unlike a regular clock, the randomness creates a "breathing" quality. - ---- - -### F-1: TwinPulse - -**Two random walks with controllable correlation creating crossed pulse patterns.** - -Two independent random walk generators running at the same rate. The correlation control blends the second walk toward the first, creating patterns that range from fully independent (complex interference) to identical (simple doubled pulse). - -| Parameter | Control | Range | Effect | -|-----------|---------|-------|--------| -| **X (k1)** | Rate | 5 – 400 Hz | Speed of both random walks. | -| **Y (k2)** | Correlation | Independent – Identical | 0 = two completely unrelated pulse streams (complex polyrhythmic interference). 1 = both outputs identical (single pulse stream, louder). Sweet spot around 0.3–0.7 where patterns partially align. | - -**Sound character:** Two overlapping pulse patterns. At low correlation, a complex, polyrhythmic texture where pulses sometimes align and sometimes don't. At high correlation, they merge into a single stream. The interplay creates a rhythmic quality that pure randomness lacks. - ---- - -### F-2: QuantPulse - -**Random values quantized to N bits, creating stepped pulse patterns.** - -Generates random values quantized to a variable number of discrete levels (2^bits). At 1 bit: binary (2 levels). At 6 bits: 64 levels. The DC blocker creates pulses whose amplitude is quantized to these levels. - -| Parameter | Control | Range | Effect | -|-----------|---------|-------|--------| -| **X (k1)** | Rate | 5 – 500 Hz | Clock speed. How often a new quantized random value is generated. | -| **Y (k2)** | Bit depth | 1 – 6 bits (continuous) | Quantization resolution. 1 bit = binary pulse (on/off). 2 bits = 4 levels. 6 bits = 64 levels (nearly continuous). Continuous morphing between bit depths. | - -**Sound character:** Quantized random pulses. At low bits: harsh, digital, with clearly discrete amplitude steps. At high bits: smoother, approaching the character of PulseWander. The bit quantization adds a lo-fi, digital texture to the random process. - ---- - -### F-3: ShapedPulse - -**Random with variable probability distribution shape.** - -The random values follow different probability distributions depending on Y. Uniform (flat — all values equally likely), triangular (values near center more likely), or peaked/gaussian (values strongly concentrated near center, rare extremes). - -| Parameter | Control | Range | Effect | -|-----------|---------|-------|--------| -| **X (k1)** | Rate | 5 – 500 Hz | Clock speed. | -| **Y (k2)** | Distribution | Uniform → Triangular → Gaussian | 0 = uniform (all amplitudes equally likely — evenly distributed pulses). 0.5 = triangular (sum of 2 uniforms — moderate peak clustering). 1.0 = peaked (sum of 4 uniforms, central limit theorem — most pulses near zero, rare large ones). | - -**Sound character:** The distribution shape is audible. Uniform: even, balanced pulse amplitudes. Peaked: mostly quiet with occasional loud spikes — creates a "crackling" or "dripping" quality where large events are rare surprises. - ---- - -### F-4: ShiftPulse - -**4-stage shift register creating evolving pulse sequences.** - -A shift register where random values enter stage 1 and shift down to stages 2, 3, 4 on each clock tick. All 4 stages are mixed in the output with adjustable weighting, creating patterns that evolve as values propagate through the chain. - -| Parameter | Control | Range | Effect | -|-----------|---------|-------|--------| -| **X (k1)** | Clock rate | 5 – 300 Hz | Speed of the shift register clock. | -| **Y (k2)** | Stage mix | Stage 1 only → All 4 | Progressive activation: Y=0: only stage 1 (fastest changing). Y=0.33: adds stage 2 (delayed echo). Y=0.66: adds stage 3. Y=1.0: all 4 stages equally mixed. The delayed repetitions create rhythmic pattern echoes. | - -**Sound character:** A pulse pattern that develops delayed echoes of itself. At low Y: simple random pulses. As Y increases, you hear the same values repeated 1, 2, 3 steps later, creating a cascading effect — like an echo chamber for random events. - ---- - -### F-5: MetallicNoise - -**6 square wave oscillators at inharmonic frequencies mixed and highpass filtered.** - -The classic technique used in the TR-808 cymbal and hi-hat circuits: six pulse oscillators at non-harmonic frequency ratios, summed together. The resulting waveform has a dense, metallic spectral character that no single oscillator can produce. A highpass filter controls brightness. - -| Parameter | Control | Range | Effect | -|-----------|---------|-------|--------| -| **X (k1)** | Pitch multiplier | 0.5x – 2.5x | Scales all 6 base frequencies together. At 1.0x: original frequencies. Below 1.0: lower, darker. Above: higher, brighter. | -| **Y (k2)** | Brightness | 500 – 15500 Hz HPF | Highpass filter cutoff. Low = full-bodied metallic noise. High = thin, sizzling hi-hat territory. | - -**Base frequencies (Hz):** 205.3, 304.4, 369.6, 522.7, 800.6, 1053.4 - -**Sound character:** Unmistakably metallic. At low HPF: thick, crash cymbal-like. At high HPF: thin, closed hi-hat sizzle. The 6 inharmonic frequencies create dense beating patterns that give the "shimmer" characteristic of real cymbals. - ---- - -### F-6: NoiseSlew - -**White noise with adjustable one-pole lowpass slew.** - -A simple but effective texture generator: white noise passed through a one-pole LP filter with adjustable cutoff. At high cutoff: full noise. At low cutoff: smooth, slowly undulating random wave. A mix control adds raw noise texture on top of the slewed signal. - -| Parameter | Control | Range | Effect | -|-----------|---------|-------|--------| -| **X (k1)** | Smoothness | Smooth – Noisy | LP filter coefficient. Low = very smooth, slowly varying random wave. High = barely filtered, noise-like. | -| **Y (k2)** | Texture mix | Clean – Textured | Blends raw noise on top of the slewed signal. 0 = only slewed output. 1 = slewed + 30% raw noise for gritty texture. | - -**Sound character:** The full spectrum from smooth random undulation to white noise in one algorithm. At X=0: a gentle, wandering random wave. At X=1: nearly unfiltered noise. The texture mix adds a "grain" to the smooth version without overpowering it. - ---- - -### F-7: NoiseBurst - -**Sporadic bursts of white noise with silence between them.** - -Generates discrete events: random-length bursts of noise separated by silence. Each burst has a natural fade-out envelope (20-sample ramp) to prevent clicks. The density controls how often bursts occur. - -| Parameter | Control | Range | Effect | -|-----------|---------|-------|--------| -| **X (k1)** | Burst density | ~1/sec – ~130/sec | Average burst rate. Low = sparse, isolated events. High = dense but never continuous — always gaps between bursts. | -| **Y (k2)** | Burst length | 1 ms – 100 ms | Duration of each noise burst. Short = percussive clicks. Long = noise "grains." | - -**Sound character:** Sporadic noise events in silence. Like a Geiger counter, or rain hitting a window irregularly. At high density with short bursts: crackling granular texture. At low density with long bursts: isolated noise "drops" with natural decay. - ---- - -### F-8: LFSRNoise - -**16-bit Linear Feedback Shift Register with selectable tap configurations.** - -A classic LFSR pseudo-random sequence generator with 8 different feedback tap polynomials. Different taps produce different sequence lengths and spectral characteristics. Output quantized to 16 discrete levels (top 4 bits) for a recognizable stepped character. - -| Parameter | Control | Range | Effect | -|-----------|---------|-------|--------| -| **X (k1)** | Clock rate | 5 – 500 Hz | How fast the register shifts. Low = slow stepped pattern. High = fast digital noise with pitch. | -| **Y (k2)** | Tap selection | 8 configurations | Selects from 8 feedback polynomials. Each produces a different sequence pattern — some nearly random, some with audible repetition. Sweep to find sweet spots. | - -**Sound character:** Digital pseudo-random sequences with a lo-fi, quantized character. Different taps create different "flavors" of digital noise — some more tonal, some more chaotic. The 16-level quantization gives it a distinctly stepped, 4-bit retro quality. - ---- - -### F-9: DualPulse - -**Two sample-and-hold generators running at independent rates, mixed together.** - -Two independent S&H circuits, each generating random values at their own clock rate. The outputs are mixed 50/50, creating complex polyrhythmic stepped patterns from the interaction of two independent clocks. - -| Parameter | Control | Range | Effect | -|-----------|---------|-------|--------| -| **X (k1)** | S&H 1 rate | 5 – 500 Hz | Clock speed of the first generator. | -| **Y (k2)** | S&H 2 rate | 5 – 500 Hz | Clock speed of the second generator. Independent of X. | - -**Sound character:** Two overlapping random step patterns. When the two rates are similar: slow beating between the patterns. When rates are very different: a fast pattern modulated by a slow one. At simple ratios (2:1, 3:2): hints of regularity emerge. At complex ratios: maximally unpredictable interaction. diff --git a/NOISE_PLETHORA_STEREO_GUIDE.md b/NOISE_PLETHORA_STEREO_GUIDE.md deleted file mode 100644 index 88a80da..0000000 --- a/NOISE_PLETHORA_STEREO_GUIDE.md +++ /dev/null @@ -1,204 +0,0 @@ -# Noise Plethora — Stereo Mode Guide - -*Befaco Noise Plethora v1.5 + Banks D, E & F Extension* - -## Table of Contents - -- [What It Does](#what-it-does) -- [How to Activate (VCV Rack)](#how-to-activate-vcv-rack) -- [How to Activate (Hardware)](#how-to-activate-hardware) -- [Controls in Stereo Mode](#controls-in-stereo-mode) -- [How It Works Internally](#how-it-works-internally) -- [State Behavior](#state-behavior) -- [Stereo Patch Ideas](#stereo-patch-ideas) - ---- - -## What It Does - -Stereo mode transforms the Noise Plethora from two independent mono generators into a single **stereo sound source**. Generator B automatically mirrors Generator A's algorithm, and the B knobs (XB/YB) are repurposed as stereo panning controls. - -The result: a wide stereo field from a single algorithm, where a sine LFO pans the sound between the left and right outputs by modulating channel amplitudes. - ---- - -## How to Activate (VCV Rack) - -1. **Right-click** on the Noise Plethora module -2. Under "Stereo," check **"Stereo Mode"** -3. Both display dots light up to confirm stereo is active -4. To deactivate: right-click and uncheck - ---- - -## How to Activate (Hardware) - -**Double-click** the Program/Bank encoder button (two clicks within 300 ms): - -| Gesture | Action | -|---------|--------| -| Single click | Toggle between Gen A and Gen B (normal mode) | -| **Double-click** | **Toggle stereo mode** | -| Hold >400 ms | Enter/exit bank mode | - -When stereo mode is active: -- Both decimal dots on the 7-segment display light up simultaneously -- Both digits show the same value (A's program number or bank letter) -- Single-click (A/B toggle) is disabled -- The module auto-exits bank mode upon entering stereo - ---- - -## Controls in Stereo Mode - -| Control | Normal Mode | Stereo Mode | -|---------|------------|-------------| -| **XA knob** | k1 for Gen A | k1 for **both** (pitch/primary param) | -| **YA knob** | k2 for Gen A | k2 for **both** (timbre/secondary param) | -| **XB knob** | k1 for Gen B | **Pan width** (0 = mono center, 1 = full L/R swing) | -| **YB knob** | k2 for Gen B | **Pan LFO speed** (0 = static, max = 1.5 Hz) | -| **CV XA** | CV for k1 A | CV for k1 **both** | -| **CV YA** | CV for k2 A | CV for k2 **both** | -| **CV XB** | CV for k1 B | Not used (manual only) | -| **CV YB** | CV for k2 B | Not used (manual only) | -| **Encoder turn** | Select program for A or B | Select program for **both** (A changes, B follows) | -| **Single click** | Toggle A/B | **Disabled** (locked to A) | -| **Hold >400 ms** | Bank mode | Bank mode (works normally) | -| **Double-click** | Enter stereo | **Exit stereo** (restores B) | -| **Filter A** | Filter for Gen A | Filter for **left channel** | -| **Filter B** | Filter for Gen B | Filter for **right channel** | - -**Note:** The analog filters remain fully independent in stereo mode. Setting the two filters differently (e.g., LP on left, HP on right) adds an additional layer of stereo character on top of the digital panning. - ---- - -## How It Works Internally - -``` - XA (k1) ──→ Gen A ──→ ampA (gainL) ──→ Filter A ──→ LEFT - YA (k2) ──→ │ - │ (same algorithm, same params) - XA (k1) ──→ Gen B ──→ ampB (gainR) ──→ Filter B ──→ RIGHT - YA (k2) ──→ │ - │ - XB ──→ pan width (amplitude) - YB ──→ pan LFO speed ───────────────────┘ -``` - -**The stereo effect uses real amplitude panning** — a sine LFO modulates the gain of each channel inversely: - -``` -pan = width * sin(2pi * phase) -gainL = (1 - pan) / 2 -gainR = (1 + pan) / 2 -phase += speed^2 * 1.5 * dt (time-based, independent of loop rate) -``` - -### Pan Width (XB) - -| XB position | Pan range | Perceived effect | -|-------------|-----------|------------------| -| 0.0 | No panning | Mono (both channels equal, 0.5 / 0.5) | -| 0.5 | Half swing | Moderate stereo (0.25 – 0.75) | -| 1.0 | Full swing | Full pan (0.0 – 1.0, hard left to hard right) | - -### Pan LFO Speed (YB) - -The speed control has a **quadratic response** (`speed^2 * 1.5 Hz`) for fine control at low settings: - -| YB position | LFO rate | Cycle time | -|-------------|----------|------------| -| 0.0 | 0 Hz | Static (no movement) | -| 0.1 | 0.015 Hz | ~67 seconds | -| 0.2 | 0.06 Hz | ~17 seconds | -| 0.3 | 0.135 Hz | ~7.4 seconds | -| 0.5 | 0.375 Hz | ~2.7 seconds | -| 0.7 | 0.735 Hz | ~1.4 seconds | -| 1.0 | 1.5 Hz | ~0.67 seconds | - -### Display in Stereo Mode - -The 7-segment display has two digits, each with a decimal dot. In stereo mode both dots light up simultaneously as the stereo indicator. Both digits mirror Generator A's current value: - -| View | Display | Meaning | -|------|---------|---------| -| Program mode | `3.3.` | Program 3 on both generators, both dots = stereo active | -| Bank mode | `A.A.` | Bank A on both generators, both dots = stereo active | - -In normal (non-stereo) mode only one dot is lit, indicating which generator (A or B) the encoder controls. - ---- - -## State Behavior - -### Entering Stereo (double-click) - -1. Saves B's current bank, program, and A/B selection -2. Syncs B to A's algorithm -3. Forces encoder to control A (B follows automatically) -4. Auto-exits bank mode (so the stereo display indicator is visible) -5. Both decimal dots turn on - -### During Stereo - -- Encoder changes A's program/bank; B mirrors the change instantly -- Single click (A/B toggle) is disabled -- Hold >400 ms enters bank mode normally (both dots stay on) -- XB and YB control panning instead of Gen B parameters - -### Exiting Stereo (double-click) - -1. Restores channel gains to unity (1.0, 1.0) -2. Restores B's saved bank and program -3. Restores previous A/B selection -4. Both decimal dots return to normal behavior - ---- - -## Stereo Patch Ideas - -### 1. Immersive Bell Drone -- Program: **D-6 NoiseBells** -- XA: ~0.3 (medium bell pitch) -- YA: ~0.2 (nearly harmonic, chime-like) -- XB: 0.3 (moderate width) -- YB: 0.15 (very slow movement) -- Filter A: LP, cutoff medium, res low -- Filter B: LP, cutoff slightly higher than A -- *Result: wide, shimmering bell drone that slowly sweeps between speakers* - -### 2. Vocal Wash -- Program: **D-3 FormantNoise** -- XA: modulated by slow LFO (vowel morphing) -- YA: ~0.6 (moderate resonance) -- XB: 0.5 (wide) -- YB: 0.2 (slow drift) -- Filter A: BP, cutoff ~1kHz -- Filter B: BP, cutoff ~1.5kHz -- *Result: ghostly stereo choir panning gently across the field* - -### 3. Metallic Stereo Texture -- Program: **D-4 BowedMetal** -- XA: ~0.4 -- YA: ~0.8 (long sustain, bowed character) -- XB: 0.6 (wide separation) -- YB: 0.3 (moderate movement) -- Filter A: HP, cutoff low (full spectrum) -- Filter B: LP, cutoff medium (darker) -- *Result: metallic shimmer sweeping left-right. Filter differences add tonal depth to the pan.* - -### 4. Chaos Stereo Field -- Program: **E-9 DualAttractor** -- XA: ~0.5 (moderate coupling) -- YA: ~0.4 -- XB: 0.4 -- YB: 0.4 -- *Result: two Lorenz attractors panning slowly. The chaotic timbral evolution combined with spatial movement creates an immersive, unpredictable field.* - -### 5. Wide Cluster -- Program: **B-0 ClusterSaw** -- XA: ~0.3 (low fundamental) -- YA: ~0.1 (tight cluster = thick unison) -- XB: 0.2 (subtle width) -- YB: 0.1 (very slow) -- *Result: massive chorused sawtooth wall that breathes between speakers. Subtle width keeps it cohesive.* From 1a5a25d9509aff7912cce15c925e63ea1ca74023 Mon Sep 17 00:00:00 2001 From: Pablo Alcantar Date: Mon, 20 Apr 2026 20:12:51 +0200 Subject: [PATCH 14/14] Fix program knob dead when picking Bank B in stereo mode --- src/NoisePlethora.cpp | 9 ++++++++- 1 file changed, 8 insertions(+), 1 deletion(-) diff --git a/src/NoisePlethora.cpp b/src/NoisePlethora.cpp index be4877a..d31ff14 100644 --- a/src/NoisePlethora.cpp +++ b/src/NoisePlethora.cpp @@ -282,6 +282,10 @@ struct NoisePlethora : Module { // Stereo mode: sync B's program to A and update stereo LFO if (stereoMode && updateParams) { + // In stereo mode A is the master: ensure the program knob always edits A, + // even if mode was flipped to B by a context-menu selection + programSelector.setMode(SECTION_A); + // Sync B to A's algorithm std::string_view aName = programSelectorWithCV.getA().getCurrentProgramName(); if (aName != algorithmName[SECTION_B]) { @@ -910,7 +914,10 @@ struct NoisePlethoraWidget : ModuleWidget { if (implemented) { menu->addChild(createMenuItem(algorithmName.data(), currentProgramAndBank ? CHECKMARK_STRING : "", [ = ]() { - module->setAlgorithm(sectionId, algorithmName); + // In stereo mode A is the master and B mirrors it, so route + // Program B picks to A to avoid silently-overridden selections + const int targetSection = module->stereoMode ? 0 : sectionId; + module->setAlgorithm(targetSection, algorithmName); })); } else {