v2.8.0: Add Bypass, Bandit and bugfixes (#55)

* Molten Bypass * Initial release * EvenVCO * Complete re-write for better FM performance * Hard sync added * Octaves * Avoid allocation in the audio thread (thanks @danngreen) * Noise Plethora * Fix labels * Avoid std::string allocations on audio thread (thanks @danngreen)
1 year ago · a4d6bbe878
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,17 @@
 # Change Log

 ## v2.8.0
  * Molten Bypass
    * Initial release
  * EvenVCO
    * Complete re-write for better FM performance
    * Hard sync added
  * Octaves 
    * Avoid allocation in the audio thread (thanks @danngreen)
  * Noise Plethora
    * Fix labels
    * Avoid std::string allocations on audio thread (thanks @danngreen)
  
 ## v2.7.1
  * Midi Thing 2
    * Remove -10 to 0 V configuration
--- a/Makefile
+++ b/Makefile
@@ -6,3 +6,5 @@ SOURCES += $(wildcard src/noise-plethora/*/*.cpp)
 DISTRIBUTABLES += $(wildcard LICENSE*) res

 include $(RACK_DIR)/plugin.mk

 CXXFLAGS += -std=c++17
--- a/docs/Oneiroi.md
+++ b/docs/Oneiroi.md
@@ -0,0 +1,16 @@
 # Befaco Oneiroi

 Based on [Befaco Oneiroi](http://www.befaco.org/oneiroi) Eurorack module. For the official manual, see [here](https://befaco.org/docs/Oneiroi/Oneiroi_User_Manual.pdf).


 ## Differences with hardware

 * Randomisation can optionally be applied to every parameter using the built in VCV randomisation
 * Input gain switch (available on hardware) has been removed as this makes no sense in VCV
 * Undo/redo is natively handled by VCV Rack
 * .wav files can be loaded from the context menu (naive loading no sample rate conversion!)
 * Additional LED indicators have been added for filter type, filter position, modulation type and oscillator octave
 * Distinct virtual knobs are used for each parameter so parameter catch-up (used on hardware) is not needed. 
 * As yet, slew of parameter values on randomize is not supported

 ![Oneiroi](img/Oneiroi.png)
--- a/docs/img/Oneiroi.png
+++ b/docs/img/Oneiroi.png
--- a/plugin.json
+++ b/plugin.json
@@ -1,6 +1,6 @@
 {
  "slug": "Befaco",
  "version": "2.7.1",
  "version": "2.8.0",
  "license": "GPL-3.0-or-later",
  "name": "Befaco",
  "brand": "Befaco",
@@ -314,7 +314,7 @@
      "description": "An accurate voltage source and precision adder.",
      "manualUrl": "https://www.befaco.org/voltio/",
      "modularGridUrl": "https://www.modulargrid.net/e/befaco-voltio",
      "tags": [        
      "tags": [
        "Hardware clone",
        "Polyphonic",
        "Utility"
@@ -331,6 +331,32 @@
        "Oscillator",
        "Polyphonic"
      ]
    },
    {
      "slug": "Bypass",
      "name": "Bypass",
      "description": "A Stereo bypass module to gate control the send of your signals to your favorite effect!",
      "manualUrl": "https://www.befaco.org/molten-bypass/",
      "modularGridUrl": "https://www.modulargrid.net/e/befaco-molten-bypass",
      "tags": [
        "Hardware clone",
        "Mixer",
        "Polyphonic",
        "Utility"
      ]
    },
    {
      "slug": "Bandit",
      "name": "Bandit",
      "description": "A spectral processing playground.",
      "tags": [
        "Equalizer",
        "Filter",
        "Hardware clone",
        "Mixer",
        "Polyphonic",
        "Utility"
      ]
    }
  ]
 }
 }
--- a/res/components/VCVBezelBig.svg
+++ b/res/components/VCVBezelBig.svg
@@ -0,0 +1,150 @@
 <?xml version="1.0" encoding="UTF-8" standalone="no"?>
 <!-- Generator: Adobe Illustrator 25.2.3, SVG Export Plug-In . SVG Version: 6.00 Build 0)  -->

 <svg
   version="1.0"
   id="svg64581"
   x="0px"
   y="0px"
   width="34.015747"
   height="34.015747"
   viewBox="0 0 34.015747 34.015748"
   enable-background="new 0 0 36.02325 36.0188"
   xml:space="preserve"
   sodipodi:docname="VCVBezelBig.svg"
   inkscape:version="1.3.2 (091e20e, 2023-11-25)"
   xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
   xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
   xmlns="http://www.w3.org/2000/svg"
   xmlns:svg="http://www.w3.org/2000/svg"><defs
   id="defs7" />
 <sodipodi:namedview
   bordercolor="#666666"
   borderopacity="1.0"
   fit-margin-bottom="0"
   fit-margin-left="0"
   fit-margin-right="0"
   fit-margin-top="0"
   id="base"
   inkscape:current-layer="svg64581"
   inkscape:cx="-101.01525"
   inkscape:cy="10.101525"
   inkscape:document-units="mm"
   inkscape:pageopacity="0.0"
   inkscape:pageshadow="2"
   inkscape:window-height="1301"
   inkscape:window-maximized="0"
   inkscape:window-width="2560"
   inkscape:window-x="0"
   inkscape:window-y="25"
   inkscape:zoom="1.979899"
   pagecolor="#ffffff"
   showgrid="false"
   inkscape:showpageshadow="2"
   inkscape:pagecheckerboard="0"
   inkscape:deskcolor="#d1d1d1">
 	</sodipodi:namedview>
 <g
   id="g7"
   transform="matrix(0.94421282,0,0,0.94421046,3.5880087e-4,9.4421046e-5)">
 	<g
   id="g5959-5_106_"
   transform="translate(301.93513,1189.951)">
 		<path
   id="path5961-3_112_"
   inkscape:connector-curvature="0"
   d="m -265.91,-1171.937 c 0,9.9474 -8.06683,18.0115 -18.01407,18.0115 -9.94595,0 -18.01144,-8.0641 -18.01144,-18.0115 0,-9.9513 8.06549,-18.0141 18.01141,-18.0141 9.94726,10e-5 18.0141,8.0628 18.0141,18.0141" />
 	</g>
 	<g
   id="g5959-5_105_"
   transform="translate(301.93513,1189.951)">
 		
 			<linearGradient
   id="path5961-3_1_"
   gradientUnits="userSpaceOnUse"
   x1="-590.1001"
   y1="-2191.8545"
   x2="-557.04907"
   y2="-2191.8545"
   gradientTransform="rotate(90,-938.70655,-1537.0705)">
 			<stop
   offset="0"
   style="stop-color:#787878"
   id="stop1" />
 			<stop
   offset="1"
   style="stop-color:#474747"
   id="stop2" />
 		</linearGradient>
 		<path
   id="path5961-3_111_"
   inkscape:connector-curvature="0"
   fill="url(#path5961-3_1_)"
   d="m -300.44827,-1171.9395 c 0,-9.1261 7.40079,-16.5244 16.52676,-16.5244 9.12473,0 16.52429,7.3984 16.52429,16.5244 0,9.1297 -7.39957,16.5268 -16.52432,16.5268 -9.12595,0 -16.52673,-7.3971 -16.52673,-16.5268"
   style="fill:url(#path5961-3_1_)" />
 	</g>
 	<g
   opacity="0.21"
   id="g4">
 		<g
   id="g5959-5_104_"
   transform="translate(301.93513,1189.951)">
 			
 				<linearGradient
   id="path5961-3_2_"
   gradientUnits="userSpaceOnUse"
   x1="-299.58844"
   y1="-1111.948"
   x2="-268.70374"
   y2="-1111.948"
   gradientTransform="rotate(-90,-314.02952,-1142.0548)">
 				<stop
   offset="0.00559"
   style="stop-color:#6B6B6B"
   id="stop3" />
 				<stop
   offset="1"
   style="stop-color:#DEDEDE"
   id="stop4" />
 			</linearGradient>
 			<path
   id="path5961-3_110_"
   inkscape:connector-curvature="0"
   fill="url(#path5961-3_2_)"
   d="m -283.92389,-1156.496 c -8.52792,0 -15.44122,-6.9156 -15.44122,-15.4434 0,-8.5267 6.9133,-15.4412 15.44122,-15.4412 8.53131,0 15.44348,6.9145 15.44348,15.4412 0,8.5278 -6.91214,15.4434 -15.44348,15.4434"
   style="fill:url(#path5961-3_2_)" />
 		</g>
 	</g>
 	<g
   id="g6">
 		<g
   id="g5959-5_103_"
   transform="translate(301.93513,1189.951)">
 			
 				<linearGradient
   id="path5961-3_3_"
   gradientUnits="userSpaceOnUse"
   x1="-298.98605"
   y1="-1111.948"
   x2="-269.30612"
   y2="-1111.948"
   gradientTransform="rotate(-90,-314.02952,-1142.0548)">
 				<stop
   offset="0.00559"
   style="stop-color:#5B5B5B"
   id="stop5" />
 				<stop
   offset="1"
   style="stop-color:#6C6C6C"
   id="stop6" />
 			</linearGradient>
 			<path
   id="path5961-3_109_"
   inkscape:connector-curvature="0"
   fill="url(#path5961-3_3_)"
   d="m -283.92386,-1157.0984 c -8.19525,0 -14.83887,-6.6459 -14.83887,-14.8409 0,-8.1941 6.64362,-14.839 14.83887,-14.839 8.19852,0 14.84106,6.6449 14.84106,14.8388 1e-5,8.1952 -6.64251,14.8411 -14.84106,14.8411"
   style="fill:url(#path5961-3_3_)" />
 		</g>
 	</g>
 </g>
 </svg>
--- a/res/panels/Bandit.svg
+++ b/res/panels/Bandit.svg
--- a/res/panels/Bypass.svg
+++ b/res/panels/Bypass.svg
--- a/src/Bandit.cpp
+++ b/src/Bandit.cpp
@@ -0,0 +1,322 @@
 #include "plugin.hpp"

 using namespace simd;

 struct Bandit : Module {
 	enum ParamId {
 		LOW_GAIN_PARAM,
 		LOW_MID_GAIN_PARAM,
 		HIGH_MID_GAIN_PARAM,
 		HIGH_GAIN_PARAM,
 		PARAMS_LEN
 	};
 	enum InputId {
 		LOW_INPUT,
 		LOW_MID_INPUT,
 		HIGH_MID_INPUT,
 		HIGH_INPUT,
 		LOW_RETURN_INPUT,
 		LOW_MID_RETURN_INPUT,
 		HIGH_MID_RETURN_INPUT,
 		HIGH_RETURN_INPUT,
 		LOW_CV_INPUT,
 		LOW_MID_CV_INPUT,
 		HIGH_MID_CV_INPUT,
 		HIGH_CV_INPUT,
 		ALL_INPUT,
 		ALL_CV_INPUT,
 		INPUTS_LEN
 	};
 	enum OutputId {
 		LOW_OUTPUT,
 		LOW_MID_OUTPUT,
 		HIGH_MID_OUTPUT,
 		HIGH_OUTPUT,
 		MIX_OUTPUT,
 		OUTPUTS_LEN
 	};
 	enum LightId {
 		ENUMS(MIX_CLIP_LIGHT, 3),
 		ENUMS(MIX_LIGHT, 3),
 		LIGHTS_LEN
 	};

 	// float_4 * [4] give 16 polyphony channels, [2] is for cascading biquads
 	dsp::TBiquadFilter<float_4> filterLow[4][2], filterLowMid[4][2], filterHighMid[4][2], filterHigh[4][2];
 	float clipTimer = 0.f;
 	const float clipTime = 0.25f;
 	dsp::ClockDivider ledUpdateClock;
 	const int ledUpdateRate = 64;
 	bool applySaturation = true;

 	Bandit() {
 		config(PARAMS_LEN, INPUTS_LEN, OUTPUTS_LEN, LIGHTS_LEN);
 		auto lowGainParam = configParam(LOW_GAIN_PARAM, 0.f, 1.f, 0.75f, "Low gain");
 		lowGainParam->description = "Lowpass <300 Hz";
 		auto lowMidGainParam = configParam(LOW_MID_GAIN_PARAM, 0.f, 1.f, 0.75f, "Low mid gain");
 		lowMidGainParam->description = "Bandpass ~750 Hz";
 		auto highMidGainParam = configParam(HIGH_MID_GAIN_PARAM, 0.f, 1.f, 0.75f, "High mid gain");
 		highMidGainParam->description = "Bandpass ~1.5 kHz";
 		auto highGainParam = configParam(HIGH_GAIN_PARAM, 0.f, 1.f, 0.75f, "High gain");
 		highGainParam->description = "Highpass >3 kHz";

 		// band inputs
 		configInput(LOW_INPUT, "Low");
 		configInput(LOW_MID_INPUT, "Low mid");
 		configInput(HIGH_MID_INPUT, "High mid");
 		configInput(HIGH_INPUT, "High");

 		// band send outputs
 		auto outLowSend = configOutput(LOW_OUTPUT, "Low");
 		outLowSend->description = "Normalled to Low band return";
 		auto outLowMidSend = configOutput(LOW_MID_OUTPUT, "Low mid");
 		outLowMidSend->description = "Normalled to Low Mid band return";
 		auto outHighMidSend = configOutput(HIGH_MID_OUTPUT, "High mid");
 		outHighMidSend->description = "Normalled to High Mid band return";
 		auto outHighSend = configOutput(HIGH_OUTPUT, "High");
 		outHighSend->description = "Normalled to High band return";

 		// band return inputs
 		configInput(LOW_RETURN_INPUT, "Low return");
 		configInput(LOW_MID_RETURN_INPUT, "Low mid return");
 		configInput(HIGH_MID_RETURN_INPUT, "High mid return");
 		configInput(HIGH_RETURN_INPUT, "High return");

 		// band gain CVs
 		configInput(LOW_CV_INPUT, "Low CV");
 		configInput(LOW_MID_CV_INPUT, "Low mid CV");
 		configInput(HIGH_MID_CV_INPUT, "High mid CV");
 		configInput(HIGH_CV_INPUT, "High CV");
 		configInput(ALL_INPUT, "All");
 		auto allCvInput = configInput(ALL_CV_INPUT, "All CV");
 		allCvInput->description = "Mix VCA, 10V to fully open";

 		// mix out
 		configOutput(MIX_OUTPUT, "Mix");

 		ledUpdateClock.setDivision(ledUpdateRate);
 	}

 	void onSampleRateChange() override {
 		const float sr = APP->engine->getSampleRate();
 		const float lowFc = 300.f / sr;
 		const float lowMidFc = 750.f / sr;
 		const float highMidFc = 1500.f / sr;
 		const float highFc = 3800.f / sr;
 		// Qs for cascaded biquads to get Butterworth response, see https://www.earlevel.com/main/2016/09/29/cascading-filters/
 		// technically only for LOWPASS and HIGHPASS, but seems to work well for BANDPASS too
 		const float Q[2] = {0.54119610f, 1.3065630f};
 		const float V = 1.f;

 		for (int i = 0; i < 4; ++i) {
 			for (int stage = 0; stage < 2; ++stage) {
 				filterLow[i][stage].setParameters(dsp::TBiquadFilter<float_4>::Type::LOWPASS, lowFc, Q[stage], V);
 				filterLowMid[i][stage].setParameters(dsp::TBiquadFilter<float_4>::Type::BANDPASS, lowMidFc, Q[stage], V);
 				filterHighMid[i][stage].setParameters(dsp::TBiquadFilter<float_4>::Type::BANDPASS, highMidFc, Q[stage], V);
 				filterHigh[i][stage].setParameters(dsp::TBiquadFilter<float_4>::Type::HIGHPASS, highFc, Q[stage], V);
 			}
 		}
 	}

 	void processBypass(const ProcessArgs& args) override {
 		const int maxPolyphony = std::max({1, inputs[ALL_INPUT].getChannels(), inputs[LOW_INPUT].getChannels(),
 		                                   inputs[LOW_MID_INPUT].getChannels(), inputs[HIGH_MID_INPUT].getChannels(),
 		                                   inputs[HIGH_INPUT].getChannels()});


 		for (int c = 0; c < maxPolyphony; c += 4) {
 			const float_4 inLow = inputs[LOW_INPUT].getPolyVoltageSimd<float_4>(c);
 			const float_4 inLowMid = inputs[LOW_MID_INPUT].getPolyVoltageSimd<float_4>(c);
 			const float_4 inHighMid = inputs[HIGH_MID_INPUT].getPolyVoltageSimd<float_4>(c);
 			const float_4 inHigh = inputs[HIGH_INPUT].getPolyVoltageSimd<float_4>(c);
 			const float_4 inAll = inputs[ALL_INPUT].getPolyVoltageSimd<float_4>(c);

 			// bypass sums all inputs to the output
 			outputs[MIX_OUTPUT].setVoltageSimd<float_4>(inLow + inLowMid + inHighMid + inHigh + inAll, c);
 		}

 		outputs[MIX_OUTPUT].setChannels(maxPolyphony);
 	}


 	void process(const ProcessArgs& args) override {

 		const int maxPolyphony = std::max({1, inputs[ALL_INPUT].getChannels(), inputs[LOW_INPUT].getChannels(),
 		                                   inputs[LOW_MID_INPUT].getChannels(), inputs[HIGH_MID_INPUT].getChannels(),
 		                                   inputs[HIGH_INPUT].getChannels()});

 		const bool allReturnsActiveAndMonophonic = inputs[LOW_RETURN_INPUT].isMonophonic() && inputs[LOW_MID_RETURN_INPUT].isMonophonic() &&
 		  inputs[HIGH_MID_RETURN_INPUT].isMonophonic() && inputs[HIGH_RETURN_INPUT].isMonophonic();

 		float_4 mixOutput[4] = {};
 		for (int c = 0; c < maxPolyphony; c += 4) {

 			const float_4 inLow = inputs[LOW_INPUT].getPolyVoltageSimd<float_4>(c);
 			const float_4 inLowMid = inputs[LOW_MID_INPUT].getPolyVoltageSimd<float_4>(c);
 			const float_4 inHighMid = inputs[HIGH_MID_INPUT].getPolyVoltageSimd<float_4>(c);
 			const float_4 inHigh = inputs[HIGH_INPUT].getPolyVoltageSimd<float_4>(c);
 			const float_4 inAll = inputs[ALL_INPUT].getPolyVoltageSimd<float_4>(c);

 			const float_4 lowGain = params[LOW_GAIN_PARAM].getValue() * clamp(inputs[LOW_CV_INPUT].getNormalPolyVoltageSimd<float_4>(10.f, c) / 10.f, 0.f, 1.f);
 			const float_4 outLow = 0.7 * 2 * filterLow[c / 4][1].process(filterLow[c / 4][0].process((inLow + inAll) * lowGain));
 			outputs[LOW_OUTPUT].setVoltageSimd<float_4>(outLow, c);

 			const float_4 lowMidGain = params[LOW_MID_GAIN_PARAM].getValue() * clamp(inputs[LOW_MID_CV_INPUT].getNormalPolyVoltageSimd<float_4>(10.f, c) / 10.f, 0.f, 1.f);
 			const float_4 outLowMid = 2 * filterLowMid[c / 4][1].process(filterLowMid[c / 4][0].process((inLowMid + inAll) * lowMidGain));
 			outputs[LOW_MID_OUTPUT].setVoltageSimd<float_4>(outLowMid, c);

 			const float_4 highMidGain = params[HIGH_MID_GAIN_PARAM].getValue() * clamp(inputs[HIGH_MID_CV_INPUT].getNormalPolyVoltageSimd<float_4>(10.f, c) / 10.f, 0.f, 1.f);
 			const float_4 outHighMid = 2 * filterHighMid[c / 4][1].process(filterHighMid[c / 4][0].process((inHighMid + inAll) * highMidGain));
 			outputs[HIGH_MID_OUTPUT].setVoltageSimd<float_4>(outHighMid, c);

 			const float_4 highGain = params[HIGH_GAIN_PARAM].getValue() * clamp(inputs[HIGH_CV_INPUT].getNormalPolyVoltageSimd<float_4>(10.f, c) / 10.f, 0.f, 1.f);
 			const float_4 outHigh = 0.7 * 2 * filterHigh[c / 4][1].process(filterHigh[c / 4][0].process((inHigh + inAll) * highGain));
 			outputs[HIGH_OUTPUT].setVoltageSimd<float_4>(outHigh, c);

 			// the fx return input is normalled to the fx send output
 			mixOutput[c / 4]  = inputs[LOW_RETURN_INPUT].getNormalPolyVoltageSimd<float_4>(outLow * !outputs[LOW_OUTPUT].isConnected(), c);
 			mixOutput[c / 4] += inputs[LOW_MID_RETURN_INPUT].getNormalPolyVoltageSimd<float_4>(outLowMid * !outputs[LOW_MID_OUTPUT].isConnected(), c);
 			mixOutput[c / 4] += inputs[HIGH_MID_RETURN_INPUT].getNormalPolyVoltageSimd<float_4>(outHighMid * !outputs[HIGH_MID_OUTPUT].isConnected(), c);
 			mixOutput[c / 4] += inputs[HIGH_RETURN_INPUT].getNormalPolyVoltageSimd<float_4>(outHigh * !outputs[HIGH_OUTPUT].isConnected(), c);
 			mixOutput[c / 4] = mixOutput[c / 4] * clamp(inputs[ALL_CV_INPUT].getNormalPolyVoltageSimd<float_4>(10.f, c) / 10.f, 0.f, 1.f);

 			if (applySaturation) {
 				mixOutput[c / 4] = Saturator<float_4>::process(mixOutput[c / 4] / 10.f) * 10.f;
 			}

 			outputs[MIX_OUTPUT].setVoltageSimd<float_4>(mixOutput[c / 4], c);
 		}

 		outputs[LOW_OUTPUT].setChannels(maxPolyphony);
 		outputs[LOW_MID_OUTPUT].setChannels(maxPolyphony);
 		outputs[HIGH_MID_OUTPUT].setChannels(maxPolyphony);
 		outputs[HIGH_OUTPUT].setChannels(maxPolyphony);

 		if (allReturnsActiveAndMonophonic) {
 			// special case: if all return paths are connected and monophonic, then output mix should be monophonic
 			outputs[MIX_OUTPUT].setChannels(1);
 		}
 		else {
 			// however, if it's a mix (some normalled from input, maybe some polyphonic), then it should be polyphonic
 			outputs[MIX_OUTPUT].setChannels(maxPolyphony);
 		}

 		if (ledUpdateClock.process()) {
 			processLEDs(mixOutput, args.sampleTime * ledUpdateRate);
 		}
 	}

 	void processLEDs(const float_4* output, const float sampleTime) {

 		const int maxPolyphony = outputs[MIX_OUTPUT].getChannels();

 		if (maxPolyphony == 1) {
 			const float rmsOut = std::fabs(output[0][0]);
 			lights[MIX_LIGHT + 0].setBrightness(0.f);
 			lights[MIX_LIGHT + 1].setBrightnessSmooth(rmsOut / 5.f, sampleTime);
 			lights[MIX_LIGHT + 2].setBrightness(0.f);

 			if (rmsOut > 10.f) {
 				clipTimer = clipTime;
 			}

 			const bool clip = clipTimer > 0.f;
 			if (clip) {
 				clipTimer -= sampleTime;
 			}

 			lights[MIX_CLIP_LIGHT + 0].setBrightnessSmooth(clip, sampleTime);
 			lights[MIX_CLIP_LIGHT + 1].setBrightness(0.f);
 			lights[MIX_CLIP_LIGHT + 2].setBrightness(0.f);
 		}
 		else {

 			float maxRmsOut = 0.f;
 			for (int c = 0; c < maxPolyphony; c++) {
 				maxRmsOut = std::max(maxRmsOut, std::fabs(output[c / 4][c % 4]));
 			}

 			lights[MIX_LIGHT + 0].setBrightness(0.f);
 			lights[MIX_LIGHT + 1].setBrightness(0.f);
 			lights[MIX_LIGHT + 2].setBrightnessSmooth(maxRmsOut / 5.f, sampleTime);

 			// if any channel peaks above 10V, turn the clip light on for the next clipTime seconds
 			if (maxRmsOut > 10.f) {
 				clipTimer = clipTime;
 			}

 			const bool clip = clipTimer > 0.f;
 			if (clip) {
 				clipTimer -= sampleTime;
 			}
 			lights[MIX_CLIP_LIGHT + 0].setBrightnessSmooth(clip, sampleTime);
 			lights[MIX_CLIP_LIGHT + 1].setBrightness(0.f);
 			lights[MIX_CLIP_LIGHT + 2].setBrightness(0.f);
 		}
 	}

 	void dataFromJson(json_t* rootJ) override {
 		json_t* applySaturationJ = json_object_get(rootJ, "applySaturation");
 		if (applySaturationJ) {
 			applySaturation = json_boolean_value(applySaturationJ);
 		}
 	}

 	json_t* dataToJson() override {
 		json_t* rootJ = json_object();
 		json_object_set_new(rootJ, "applySaturation", json_boolean(applySaturation));

 		return rootJ;
 	}
 };


 struct BanditWidget : ModuleWidget {
 	BanditWidget(Bandit* module) {
 		setModule(module);
 		setPanel(createPanel(asset::plugin(pluginInstance, "res/panels/Bandit.svg")));

 		addChild(createWidget<Knurlie>(Vec(RACK_GRID_WIDTH, 0)));
 		addChild(createWidget<Knurlie>(Vec(RACK_GRID_WIDTH, RACK_GRID_HEIGHT - RACK_GRID_WIDTH)));

 		addParam(createParam<BefacoSlidePot>(mm2px(Vec(3.062, 51.365)), module, Bandit::LOW_GAIN_PARAM));
 		addParam(createParam<BefacoSlidePot>(mm2px(Vec(13.23, 51.365)), module, Bandit::LOW_MID_GAIN_PARAM));
 		addParam(createParam<BefacoSlidePot>(mm2px(Vec(23.398, 51.365)), module, Bandit::HIGH_MID_GAIN_PARAM));
 		addParam(createParam<BefacoSlidePot>(mm2px(Vec(33.566, 51.365)), module, Bandit::HIGH_GAIN_PARAM));

 		addInput(createInputCentered<BefacoInputPort>(mm2px(Vec(5.038, 14.5)), module, Bandit::LOW_INPUT));
 		addInput(createInputCentered<BefacoInputPort>(mm2px(Vec(15.178, 14.5)), module, Bandit::LOW_MID_INPUT));
 		addInput(createInputCentered<BefacoInputPort>(mm2px(Vec(25.253, 14.5)), module, Bandit::HIGH_MID_INPUT));
 		addInput(createInputCentered<BefacoInputPort>(mm2px(Vec(35.328, 14.5)), module, Bandit::HIGH_INPUT));
 		addInput(createInputCentered<BefacoInputPort>(mm2px(Vec(5.045, 40.34)), module, Bandit::LOW_RETURN_INPUT));
 		addInput(createInputCentered<BefacoInputPort>(mm2px(Vec(15.118, 40.34)), module, Bandit::LOW_MID_RETURN_INPUT));
 		addInput(createInputCentered<BefacoInputPort>(mm2px(Vec(25.19, 40.338)), module, Bandit::HIGH_MID_RETURN_INPUT));
 		addInput(createInputCentered<BefacoInputPort>(mm2px(Vec(35.263, 40.34)), module, Bandit::HIGH_RETURN_INPUT));
 		addInput(createInputCentered<BefacoInputPort>(mm2px(Vec(5.038, 101.229)), module, Bandit::LOW_CV_INPUT));
 		addInput(createInputCentered<BefacoInputPort>(mm2px(Vec(15.113, 101.229)), module, Bandit::LOW_MID_CV_INPUT));
 		addInput(createInputCentered<BefacoInputPort>(mm2px(Vec(25.187, 101.231)), module, Bandit::HIGH_MID_CV_INPUT));
 		addInput(createInputCentered<BefacoInputPort>(mm2px(Vec(35.263, 101.229)), module, Bandit::HIGH_CV_INPUT));
 		addInput(createInputCentered<BefacoInputPort>(mm2px(Vec(10.075, 113.502)), module, Bandit::ALL_INPUT));
 		addInput(createInputCentered<BefacoInputPort>(mm2px(Vec(20.15, 113.5)), module, Bandit::ALL_CV_INPUT));

 		addOutput(createOutputCentered<BefacoOutputPort>(mm2px(Vec(5.045, 27.248)), module, Bandit::LOW_OUTPUT));
 		addOutput(createOutputCentered<BefacoOutputPort>(mm2px(Vec(15.118, 27.256)), module, Bandit::LOW_MID_OUTPUT));
 		addOutput(createOutputCentered<BefacoOutputPort>(mm2px(Vec(25.19, 27.256)), module, Bandit::HIGH_MID_OUTPUT));
 		addOutput(createOutputCentered<BefacoOutputPort>(mm2px(Vec(35.263, 27.256)), module, Bandit::HIGH_OUTPUT));
 		addOutput(createOutputCentered<BefacoOutputPort>(mm2px(Vec(30.225, 113.5)), module, Bandit::MIX_OUTPUT));

 		addChild(createLightCentered<MediumLight<RedGreenBlueLight>>(mm2px(Vec(37.781, 111.125)), module, Bandit::MIX_CLIP_LIGHT));
 		addChild(createLightCentered<MediumLight<RedGreenBlueLight>>(mm2px(Vec(37.781, 115.875)), module, Bandit::MIX_LIGHT));
 	}

 	void appendContextMenu(Menu* menu) override {
 		Bandit* module = dynamic_cast<Bandit*>(this->module);
 		assert(module);

 		menu->addChild(new MenuSeparator());
 		menu->addChild(createBoolPtrMenuItem("Soft clip at ±10V", "", &module->applySaturation));

 	}
 };

 Model* modelBandit = createModel<Bandit, BanditWidget>("Bandit");
--- a/src/Bypass.cpp
+++ b/src/Bypass.cpp
@@ -0,0 +1,283 @@
 #include "plugin.hpp"

 using namespace simd;

 struct Bypass : Module {
 	enum ParamId {
 		MODE_PARAM,
 		FX_GAIN_PARAM,
 		LAUNCH_MODE_PARAM,
 		LAUNCH_BUTTON_PARAM,
 		SLEW_TIME_PARAM,
 		PARAMS_LEN
 	};
 	enum InputId {
 		IN_R_INPUT,
 		FROM_FX_L_INPUT,
 		FROM_FX_R_INPUT,
 		LAUNCH_INPUT,
 		IN_L_INPUT,
 		INPUTS_LEN
 	};
 	enum OutputId {
 		TO_FX_L_OUTPUT,
 		TO_FX_R_OUTPUT,
 		OUT_L_OUTPUT,
 		OUT_R_OUTPUT,
 		OUTPUTS_LEN
 	};
 	enum LightId {
 		LAUNCH_LED,
 		LIGHTS_LEN
 	};
 	enum LatchMode {
 		TOGGLE_MODE, 	// i.e. latch
 		MOMENTARY_MODE // i.e. gate
 	};
 	enum ReturnMode {
 		HARD_MODE,
 		SOFT_MODE
 	};
 	ReturnMode returnMode = ReturnMode::HARD_MODE;
 	ParamQuantity* launchParam, * slewTimeParam;
 	dsp::SchmittTrigger launchCvTrigger;
 	dsp::BooleanTrigger launchButtonTrigger;
 	dsp::BooleanTrigger latchTrigger;
 	dsp::SlewLimiter clickFilter;
 	bool launchButtonHeld = false;
 	bool applySaturation = true;
 	bool active = false;

 	struct GainParamQuantity : ParamQuantity {
 		std::string getDisplayValueString() override {
 			if (getValue() < 0.f) {
 				return string::f("%g dB", 30 * getValue());
 			}
 			else {
 				return string::f("%g dB", 12 * getValue());
 			}
 		}
 	};

 	Bypass() {
 		config(PARAMS_LEN, INPUTS_LEN, OUTPUTS_LEN, LIGHTS_LEN);
 		auto switchParam = configSwitch(MODE_PARAM, 0.f, 1.f, 0.f, "Return mode", {"Hard", "Soft"});
 		switchParam->description = "In hard mode, Bypass wil cut off any sound coming from the loop.\nWith soft mode, the FX return is still active giving you reverb tails, decaying delay taps etc.";
 		configParam<GainParamQuantity>(FX_GAIN_PARAM, -1.f, 1.f, 0.f, "FX return gain");
 		configSwitch(LAUNCH_MODE_PARAM, 0.f, 1.f, 0.f, "Launch Mode", {"Latch (Toggle)", "Gate (Momentary)"});
 		launchParam = configButton(LAUNCH_BUTTON_PARAM, "Launch");
 		slewTimeParam = configParam(SLEW_TIME_PARAM, .005f, 0.05f, 0.01f, "Slew time", "s");

 		configInput(IN_L_INPUT, "Left");
 		configInput(IN_R_INPUT, "Right");
 		configInput(FROM_FX_L_INPUT, "From FX L");
 		configInput(FROM_FX_R_INPUT, "From FX R");
 		configInput(LAUNCH_INPUT, "Launch");

 		configOutput(TO_FX_L_OUTPUT, "To FX L");
 		configOutput(TO_FX_R_OUTPUT, "To FX R");
 		configOutput(OUT_L_OUTPUT, "Left");
 		configOutput(OUT_R_OUTPUT, "Right");

 		configBypass(IN_L_INPUT, OUT_L_OUTPUT);
 		configBypass(IN_R_INPUT, OUT_R_OUTPUT);
 	}

 	void process(const ProcessArgs& args) override {

 		// slew time in secs (so take inverse for lambda)
 		clickFilter.rise = clickFilter.fall = 1.0 / params[SLEW_TIME_PARAM].getValue();

 		const int maxInputChannels = std::max({1, inputs[IN_L_INPUT].getChannels(), inputs[IN_R_INPUT].getChannels()});
 		const int maxFxReturnChannels = std::max({1, inputs[FROM_FX_L_INPUT].getChannels(), inputs[FROM_FX_R_INPUT].getChannels()});

 		const LatchMode latchMode = (LatchMode) params[LAUNCH_MODE_PARAM].getValue();
 		const ReturnMode returnMode = (ReturnMode) params[MODE_PARAM].getValue();


 		const bool launchCvTriggered = launchCvTrigger.process(inputs[LAUNCH_INPUT].getVoltage());
 		const bool launchButtonPressed = launchButtonTrigger.process(launchButtonHeld);

 		// logical or (high if either high)
 		const float launchValue = std::max(launchCvTrigger.isHigh(), launchButtonTrigger.isHigh());
 		if (latchMode == LatchMode::TOGGLE_MODE) {
 			const bool risingEdge = launchCvTriggered || launchButtonPressed;

 			if (risingEdge) {
 				active = !active;
 			}
 		}

 		// FX send section
 		const float sendActive = clickFilter.process(args.sampleTime, (latchMode == LatchMode::TOGGLE_MODE) ? active : launchValue);
 		for (int c = 0; c < maxInputChannels; c += 4) {
 			const float_4 inL = inputs[IN_L_INPUT].getPolyVoltageSimd<float_4>(c);
 			const float_4 inR = inputs[IN_R_INPUT].getNormalPolyVoltageSimd<float_4>(inL, c);

 			// we start be assuming that FXs can be polyphonic, but recognise that often they are not
 			outputs[TO_FX_L_OUTPUT].setVoltageSimd<float_4>(inL * sendActive, c);
 			outputs[TO_FX_R_OUTPUT].setVoltageSimd<float_4>(inR * sendActive, c);
 		}
 		// fx send polyphony is set by input polyphony
 		outputs[TO_FX_L_OUTPUT].setChannels(maxInputChannels);
 		outputs[TO_FX_R_OUTPUT].setChannels(maxInputChannels);


 		// FX return section
 		const float gainTaper = params[FX_GAIN_PARAM].getValue() < 0.f ? 30 * params[FX_GAIN_PARAM].getValue() : params[FX_GAIN_PARAM].getValue() * 12;
 		const float fxReturnGain = std::pow(10, gainTaper / 20.0f);
 		float_4 dryLeft, dryRight, outL, outR;
 		for (int c = 0; c < maxFxReturnChannels; c += 4) {

 			const bool fxMonophonic = (maxInputChannels == 1);
 			if (fxMonophonic) {
 				// if the return fx is monophonic, mix down dry inputs to monophonic also
 				dryLeft = inputs[IN_L_INPUT].getVoltageSum();
 				dryRight = inputs[IN_R_INPUT].isConnected() ? inputs[IN_R_INPUT].getVoltageSum() : inputs[IN_L_INPUT].getVoltageSum();
 			}
 			else {
 				// if the return fx is polyphonic, then we don't need to do anything special
 				dryLeft = inputs[IN_L_INPUT].getPolyVoltageSimd<float_4>(c);
 				dryRight = inputs[IN_R_INPUT].getNormalPolyVoltageSimd<float_4>(dryLeft, c);
 			}

 			const float_4 fxLeftReturn = fxReturnGain * inputs[FROM_FX_L_INPUT].getPolyVoltageSimd<float_4>(c);
 			const float_4 fxRightReturn = fxReturnGain * inputs[FROM_FX_R_INPUT].getPolyVoltageSimd<float_4>(c);

 			if (returnMode == ReturnMode::HARD_MODE) {
 				outL = dryLeft * (1 - sendActive) + sendActive * fxLeftReturn;
 				outR = dryRight * (1 - sendActive) + sendActive * fxRightReturn;
 			}
 			else {
 				outL = dryLeft * (1 - sendActive) + fxLeftReturn;
 				outR = dryRight * (1 - sendActive) + fxRightReturn;
 			}

 			if (applySaturation) {
 				outL = Saturator<float_4>::process(outL / 10.f) * 10.f;
 				outR = Saturator<float_4>::process(outR / 10.f) * 10.f;
 			}

 			outputs[OUT_L_OUTPUT].setVoltageSimd<float_4>(outL, c);
 			outputs[OUT_R_OUTPUT].setVoltageSimd<float_4>(outR, c);
 		}

 		// output polyphony is set by fx return polyphony
 		outputs[OUT_L_OUTPUT].setChannels(maxFxReturnChannels);
 		outputs[OUT_R_OUTPUT].setChannels(maxFxReturnChannels);

 		lights[LAUNCH_LED].setSmoothBrightness(sendActive, args.sampleTime);
 	}

 	void dataFromJson(json_t* rootJ) override {
 		json_t* applySaturationJ = json_object_get(rootJ, "applySaturation");
 		if (applySaturationJ) {
 			applySaturation = json_boolean_value(applySaturationJ);
 		}

 		json_t* activeJ = json_object_get(rootJ, "active");
 		if (activeJ) {
 			active = json_boolean_value(activeJ);
 		}
 	}

 	json_t* dataToJson() override {
 		json_t* rootJ = json_object();

 		json_object_set_new(rootJ, "applySaturation", json_boolean(applySaturation));
 		json_object_set_new(rootJ, "active", json_boolean(active));

 		return rootJ;
 	}
 };

 /** From VCV Free */
 struct VCVBezelBig : app::SvgSwitch {
 	VCVBezelBig() {
 		addFrame(Svg::load(asset::plugin(pluginInstance, "res/components/VCVBezelBig.svg")));
 	}
 };

 template <typename TBase>
 struct VCVBezelLightBig : TBase {
 	VCVBezelLightBig() {
 		this->borderColor = color::WHITE_TRANSPARENT;
 		this->bgColor = color::WHITE_TRANSPARENT;
 		this->box.size = mm2px(math::Vec(11, 11));
 	}
 };

 struct RecordButton : LightButton<VCVBezelBig, VCVBezelLightBig<RedLight>> {
 	// Instead of using onAction() which is called on mouse up, handle on mouse down
 	void onDragStart(const event::DragStart& e) override {
 		Bypass* module = dynamic_cast<Bypass*>(this->module);
 		if (e.button == GLFW_MOUSE_BUTTON_LEFT) {
 			if (module) {
 				module->launchButtonHeld = true;
 			}
 		}

 		LightButton::onDragStart(e);
 	}

 	void onDragEnd(const event::DragEnd& e) override {
 		Bypass* module = dynamic_cast<Bypass*>(this->module);
 		if (e.button == GLFW_MOUSE_BUTTON_LEFT) {
 			if (module) {
 				module->launchButtonHeld = false;
 			}
 		}
 	}
 };

 struct BypassWidget : ModuleWidget {

 	SvgSwitch* launchParam;

 	BypassWidget(Bypass* module) {
 		setModule(module);
 		setPanel(createPanel(asset::plugin(pluginInstance, "res/panels/Bypass.svg")));

 		addChild(createWidget<Knurlie>(Vec(RACK_GRID_WIDTH, 0)));
 		addChild(createWidget<Knurlie>(Vec(RACK_GRID_WIDTH, RACK_GRID_HEIGHT - RACK_GRID_WIDTH)));

 		addParam(createParam<CKSSHoriz2>(mm2px(Vec(6.7, 63.263)), module, Bypass::MODE_PARAM));
 		addParam(createParamCentered<BefacoTinyKnobWhite>(mm2px(Vec(10.0, 78.903)), module, Bypass::FX_GAIN_PARAM));
 		addParam(createParam<CKSSNarrow>(mm2px(Vec(13.8, 91.6)), module, Bypass::LAUNCH_MODE_PARAM));

 		launchParam = createLightParamCentered<RecordButton>(mm2px(Vec(10.0, 111.287)), module, Bypass::LAUNCH_BUTTON_PARAM, Bypass::LAUNCH_LED);
 		addParam(launchParam);

 		addInput(createInputCentered<BefacoInputPort>(mm2px(Vec(15.016, 15.03)), module, Bypass::IN_R_INPUT));
 		addInput(createInputCentered<BefacoInputPort>(mm2px(Vec(4.947, 40.893)), module, Bypass::FROM_FX_L_INPUT));
 		addInput(createInputCentered<BefacoInputPort>(mm2px(Vec(15.001, 40.893)), module, Bypass::FROM_FX_R_INPUT));
 		addInput(createInputCentered<BefacoInputPort>(mm2px(Vec(6.648, 95.028)), module, Bypass::LAUNCH_INPUT));
 		addInput(createInputCentered<BefacoInputPort>(mm2px(Vec(4.947, 15.03)), module, Bypass::IN_L_INPUT));

 		addOutput(createOutputCentered<BefacoOutputPort>(mm2px(Vec(4.957, 27.961)), module, Bypass::TO_FX_L_OUTPUT));
 		addOutput(createOutputCentered<BefacoOutputPort>(mm2px(Vec(14.957, 27.961)), module, Bypass::TO_FX_R_OUTPUT));
 		addOutput(createOutputCentered<BefacoOutputPort>(mm2px(Vec(4.947, 53.846)), module, Bypass::OUT_L_OUTPUT));
 		addOutput(createOutputCentered<BefacoOutputPort>(mm2px(Vec(14.957, 53.824)), module, Bypass::OUT_R_OUTPUT));
 	}

 	// for context menu
 	struct SlewTimeSider : ui::Slider {
 		explicit SlewTimeSider(ParamQuantity* q_) {
 			quantity = q_;
 			this->box.size.x = 200.0f;
 		}
 	};

 	void appendContextMenu(Menu* menu) override {
 		Bypass* module = dynamic_cast<Bypass*>(this->module);
 		assert(module);

 		menu->addChild(new MenuSeparator());
 		menu->addChild(createBoolPtrMenuItem("Soft clip at ±10V", "", &module->applySaturation));
 		menu->addChild(new SlewTimeSider(module->slewTimeParam));

 	}
 };


 Model* modelBypass = createModel<Bypass, BypassWidget>("Bypass");
--- a/src/EvenVCO.cpp
+++ b/src/EvenVCO.cpp
@@ -1,4 +1,5 @@
 #include "plugin.hpp"
 #include "ChowDSP.hpp"

 using simd::float_4;

@@ -26,20 +27,11 @@ struct EvenVCO : Module {
 		NUM_OUTPUTS
 	};

 	float_4 phase[4] = {};
 	float_4 tri[4] = {};

 	/** The value of the last sync input */
 	float sync = 0.0;
 	/** The outputs */
 	/** Whether we are past the pulse width already */
 	bool halfPhase[PORT_MAX_CHANNELS] = {};
 	float_4 phase[4] = {};
 	dsp::TSchmittTrigger<float_4> syncTrigger[4];
 	bool removePulseDC = true;

 	dsp::MinBlepGenerator<16, 32> triSquareMinBlep[PORT_MAX_CHANNELS];
 	dsp::MinBlepGenerator<16, 32> doubleSawMinBlep[PORT_MAX_CHANNELS];
 	dsp::MinBlepGenerator<16, 32> sawMinBlep[PORT_MAX_CHANNELS];
 	dsp::MinBlepGenerator<16, 32> squareMinBlep[PORT_MAX_CHANNELS];
 	bool limitPW = true;

 	EvenVCO() {
 		config(NUM_PARAMS, NUM_INPUTS, NUM_OUTPUTS);
@@ -51,7 +43,7 @@ struct EvenVCO : Module {
 		configInput(PITCH1_INPUT, "Pitch 1");
 		configInput(PITCH2_INPUT, "Pitch 2");
 		configInput(FM_INPUT, "FM");
 		configInput(SYNC_INPUT, "Sync (not implemented)");
 		configInput(SYNC_INPUT, "Sync");
 		configInput(PWM_INPUT, "Pulse Width Modulation");

 		configOutput(TRI_OUTPUT, "Triangle");
@@ -59,157 +51,191 @@ struct EvenVCO : Module {
 		configOutput(EVEN_OUTPUT, "Even");
 		configOutput(SAW_OUTPUT, "Sawtooth");
 		configOutput(SQUARE_OUTPUT, "Square");

 		// calculate up/downsampling rates
 		onSampleRateChange();
 	}

 	void process(const ProcessArgs& args) override {
 	void onSampleRateChange() override {
 		float sampleRate = APP->engine->getSampleRate();
 		for (int i = 0; i < NUM_OUTPUTS; ++i) {
 			for (int c = 0; c < 4; c++) {
 				oversampler[i][c].setOversamplingIndex(oversamplingIndex);
 				oversampler[i][c].reset(sampleRate);
 			}
 		}

 		int channels_pitch1 = inputs[PITCH1_INPUT].getChannels();
 		int channels_pitch2 = inputs[PITCH2_INPUT].getChannels();
 		const float lowFreqRegime = oversampler[0][0].getOversamplingRatio() * 1e-3 * sampleRate;
 		DEBUG("Low freq regime: %g", lowFreqRegime);
 	}

 		int channels = 1;
 		channels = std::max(channels, channels_pitch1);
 		channels = std::max(channels, channels_pitch2);
 	float_4 aliasSuppressedTri(float_4* phases) {
 		float_4 triBuffer[3];
 		for (int i = 0; i < 3; ++i) {
 			float_4 p = 2 * phases[i] - 1.0; 				// range -1.0 to +1.0
 			float_4 s = 0.5 - simd::abs(p); 				// eq 30
 			triBuffer[i] = (s * s * s - 0.75 * s) / 3.0; 	// eq 29
 		}
 		return (triBuffer[0] - 2.0 * triBuffer[1] + triBuffer[2]);
 	}

 		float pitch_0 = 1.f + std::round(params[OCTAVE_PARAM].getValue()) + params[TUNE_PARAM].getValue() / 12.f;
 	float_4 aliasSuppressedSaw(float_4* phases) {
 		float_4 sawBuffer[3];
 		for (int i = 0; i < 3; ++i) {
 			float_4 p = 2 * phases[i] - 1.0; 		// range -1 to +1
 			sawBuffer[i] = (p * p * p - p) / 6.0;	// eq 11
 		}

 		// Compute frequency, pitch is 1V/oct
 		float_4 pitch[4] = {};
 		for (int c = 0; c < channels; c += 4)
 			pitch[c / 4] = pitch_0;
 		return (sawBuffer[0] - 2.0 * sawBuffer[1] + sawBuffer[2]);
 	}

 		if (inputs[PITCH1_INPUT].isConnected()) {
 			for (int c = 0; c < channels; c += 4)
 				pitch[c / 4] += inputs[PITCH1_INPUT].getPolyVoltageSimd<float_4>(c);
 	float_4 aliasSuppressedDoubleSaw(float_4* phases) {
 		float_4 sawBuffer[3];
 		for (int i = 0; i < 3; ++i) {
 			float_4 p = 4.0 * simd::ifelse(phases[i] < 0.5,  phases[i], phases[i] - 0.5) - 1.0;
 			sawBuffer[i] = (p * p * p - p) / 24.0;	// eq 11 (modified for doubled freq)
 		}

 		if (inputs[PITCH2_INPUT].isConnected()) {
 			for (int c = 0; c < channels; c += 4)
 				pitch[c / 4] += inputs[PITCH2_INPUT].getPolyVoltageSimd<float_4>(c);
 		}
 		return (sawBuffer[0] - 2.0 * sawBuffer[1] + sawBuffer[2]);
 	}

 		if (inputs[FM_INPUT].isConnected()) {
 			for (int c = 0; c < channels; c += 4)
 				pitch[c / 4] += inputs[FM_INPUT].getPolyVoltageSimd<float_4>(c) / 4.f;
 		}
 	float_4 aliasSuppressedOffsetSaw(float_4* phases, float_4 pw) {
 		float_4 sawOffsetBuff[3];

 		float_4 freq[4] = {};
 		for (int c = 0; c < channels; c += 4) {
 			freq[c / 4] = dsp::FREQ_C4 * simd::pow(2.f, pitch[c / 4]);
 			freq[c / 4] = clamp(freq[c / 4], 0.f, 20000.f);
 		for (int i = 0; i < 3; ++i) {
 			float_4 p = 2 * phases[i] - 1.0; 	// range -1 to +1
 			float_4 pwp = p + 2 * pw;			// phase after pw (pw in [0, 1])
 			pwp += simd::ifelse(pwp > 1, -2, 0);     			// modulo on [-1, +1]
 			sawOffsetBuff[i] = (pwp * pwp * pwp - pwp) / 6.0;	// eq 11
 		}
 		return (sawOffsetBuff[0] - 2.0 * sawOffsetBuff[1] + sawOffsetBuff[2]);
 	}

 		// Pulse width
 		float_4 pw[4] = {};
 		for (int c = 0; c < channels; c += 4)
 			pw[c / 4] = params[PWM_PARAM].getValue();
 	chowdsp::VariableOversampling<6, float_4> oversampler[NUM_OUTPUTS][4]; 	// uses a 2*6=12th order Butterworth filter
 	int oversamplingIndex = 2; 	// default is 2^oversamplingIndex == x4 oversampling

 		if (inputs[PWM_INPUT].isConnected()) {
 			for (int c = 0; c < channels; c += 4)
 				pw[c / 4] += inputs[PWM_INPUT].getPolyVoltageSimd<float_4>(c) / 5.f;
 		}
 	void process(const ProcessArgs& args) override {

 		// pitch inputs determine number of polyphony engines
 		const int channels = std::max({1, inputs[PITCH1_INPUT].getChannels(), inputs[PITCH2_INPUT].getChannels()});

 		const float pitchKnobs = 1.f + std::round(params[OCTAVE_PARAM].getValue()) + params[TUNE_PARAM].getValue() / 12.f;
 		const int oversamplingRatio = oversampler[0][0].getOversamplingRatio();

 		float_4 deltaPhase[4] = {};
 		float_4 oldPhase[4] = {};
 		for (int c = 0; c < channels; c += 4) {
 			pw[c / 4] = rescale(clamp(pw[c / 4], -1.0f, 1.0f), -1.0f, 1.0f, 0.05f, 1.0f - 0.05f);
 			float_4 pw = simd::clamp(params[PWM_PARAM].getValue() + inputs[PWM_INPUT].getPolyVoltageSimd<float_4>(c) / 5.f, -1.f, 1.f);
 			if (limitPW) {
 				pw = simd::rescale(pw, -1, +1, 0.05f, 0.95f);
 			}
 			else {
 				pw = simd::rescale(pw, -1.f, +1.f, 0.f, 1.f);
 			}

 			// Advance phase
 			deltaPhase[c / 4] = clamp(freq[c / 4] * args.sampleTime, 1e-6f, 0.5f);
 			oldPhase[c / 4] = phase[c / 4];
 			phase[c / 4] += deltaPhase[c / 4];
 		}
 			const float_4 fmVoltage = inputs[FM_INPUT].getPolyVoltageSimd<float_4>(c) * 0.25f;
 			const float_4 pitch = inputs[PITCH1_INPUT].getPolyVoltageSimd<float_4>(c) + inputs[PITCH2_INPUT].getPolyVoltageSimd<float_4>(c);
 			const float_4 freq = dsp::FREQ_C4 * simd::pow(2.f, pitchKnobs + pitch + fmVoltage);
 			const float_4 deltaBasePhase = simd::clamp(freq * args.sampleTime / oversamplingRatio, 1e-6, 0.5f);
 			// floating point arithmetic doesn't work well at low frequencies, specifically because the finite difference denominator
 			// becomes tiny - we check for that scenario and use naive / 1st order waveforms in that frequency regime (as aliasing isn't
 			// a problem there). With no oversampling, at 44100Hz, the threshold frequency is 44.1Hz.
 			const float_4 lowFreqRegime = simd::abs(deltaBasePhase) < 1e-3;
 			// 1 / denominator for the second-order FD
 			const float_4 denominatorInv = 0.25 / (deltaBasePhase * deltaBasePhase);

 		// the next block can't be done with SIMD instructions, but should at least be completed with
 		// blocks of 4 (otherwise popping artfifacts are generated from invalid phase/oldPhase/deltaPhase)
 		const int channelsRoundedUpNearestFour = (1 + (channels - 1) / 4) * 4;
 		for (int c = 0; c < channelsRoundedUpNearestFour; c++) {
 			// pulsewave waveform doesn't have DC even for non 50% duty cycles, but Befaco team would like the option
 			// for it to be added back in for hardware compatibility reasons
 			const float_4 pulseDCOffset = (!removePulseDC) * 2.f * (0.5f - pw);

 			if (oldPhase[c / 4].s[c % 4] < 0.5 && phase[c / 4].s[c % 4] >= 0.5) {
 				float crossing = -(phase[c / 4].s[c % 4] - 0.5) / deltaPhase[c / 4].s[c % 4];
 				triSquareMinBlep[c].insertDiscontinuity(crossing, 2.f);
 				doubleSawMinBlep[c].insertDiscontinuity(crossing, -2.f);
 			}
 			// hard sync
 			const float_4 syncMask = syncTrigger[c / 4].process(inputs[SYNC_INPUT].getPolyVoltageSimd<float_4>(c));
 			phase[c / 4] = simd::ifelse(syncMask, 0.5f, phase[c / 4]);

 			if (!halfPhase[c] && phase[c / 4].s[c % 4] >= pw[c / 4].s[c % 4]) {
 				float crossing  = -(phase[c / 4].s[c % 4] - pw[c / 4].s[c % 4]) / deltaPhase[c / 4].s[c % 4];
 				squareMinBlep[c].insertDiscontinuity(crossing, 2.f);
 				halfPhase[c] = true;
 			}
 			float_4* osBufferTri = oversampler[TRI_OUTPUT][c / 4].getOSBuffer();
 			float_4* osBufferSaw = oversampler[SAW_OUTPUT][c / 4].getOSBuffer();
 			float_4* osBufferSin = oversampler[SINE_OUTPUT][c / 4].getOSBuffer();
 			float_4* osBufferSquare = oversampler[SQUARE_OUTPUT][c / 4].getOSBuffer();
 			float_4* osBufferEven = oversampler[EVEN_OUTPUT][c / 4].getOSBuffer();
 			for (int i = 0; i < oversamplingRatio; ++i) {

 			// Reset phase if at end of cycle
 			if (phase[c / 4].s[c % 4] >= 1.f) {
 				phase[c / 4].s[c % 4] -= 1.f;
 				float crossing = -phase[c / 4].s[c % 4] / deltaPhase[c / 4].s[c % 4];
 				triSquareMinBlep[c].insertDiscontinuity(crossing, -2.f);
 				doubleSawMinBlep[c].insertDiscontinuity(crossing, -2.f);
 				squareMinBlep[c].insertDiscontinuity(crossing, -2.f);
 				sawMinBlep[c].insertDiscontinuity(crossing, -2.f);
 				halfPhase[c] = false;
 			}
 		}
 				phase[c / 4] += deltaBasePhase;
 				// ensure within [0, 1]
 				phase[c / 4] -= simd::floor(phase[c / 4]);

 		float_4 triSquareMinBlepOut[4] = {};
 		float_4 doubleSawMinBlepOut[4] = {};
 		float_4 sawMinBlepOut[4] = {};
 		float_4 squareMinBlepOut[4] = {};

 		float_4 triSquare[4] = {};
 		float_4 sine[4] = {};
 		float_4 doubleSaw[4] = {};

 		float_4 even[4] = {};
 		float_4 saw[4] = {};
 		float_4 square[4] = {};
 		float_4 triOut[4] = {};

 		for (int c = 0; c < channelsRoundedUpNearestFour; c++) {
 			triSquareMinBlepOut[c / 4].s[c % 4] = triSquareMinBlep[c].process();
 			doubleSawMinBlepOut[c / 4].s[c % 4] = doubleSawMinBlep[c].process();
 			sawMinBlepOut[c / 4].s[c % 4] = sawMinBlep[c].process();
 			squareMinBlepOut[c / 4].s[c % 4] = squareMinBlep[c].process();
 		}
 				float_4 phases[3]; // phase as extrapolated to the current and two previous samples

 		for (int c = 0; c < channels; c += 4) {
 				phases[0] = phase[c / 4] - 2 * deltaBasePhase + simd::ifelse(phase[c / 4] < 2 * deltaBasePhase, 1.f, 0.f);
 				phases[1] = phase[c / 4] - deltaBasePhase + simd::ifelse(phase[c / 4] < deltaBasePhase, 1.f, 0.f);
 				phases[2] = phase[c / 4];

 			triSquare[c / 4] = simd::ifelse((phase[c / 4] < 0.5f), -1.f, +1.f);
 			triSquare[c / 4] += triSquareMinBlepOut[c / 4];
 				if (outputs[SINE_OUTPUT].isConnected() || outputs[EVEN_OUTPUT].isConnected()) {
 					// sin doesn't need PDW
 					osBufferSin[i] = -simd::cos(M_PI + 2.0 * M_PI * phase[c / 4]);
 				}

 			// Integrate square for triangle
 				if (outputs[TRI_OUTPUT].isConnected()) {
 					const float_4 dpwOrder1 = 1.0 - 2.0 * simd::abs(2 * phase[c / 4] - 1.0);
 					const float_4 dpwOrder3 = aliasSuppressedTri(phases) * denominatorInv;

 			tri[c / 4] += (4.f * triSquare[c / 4]) * (freq[c / 4] * args.sampleTime);
 			tri[c / 4] *= (1.f - 40.f * args.sampleTime);
 			triOut[c / 4] = 5.f * tri[c / 4];
 					osBufferTri[i] = -simd::ifelse(lowFreqRegime, dpwOrder1, dpwOrder3);
 				}

 			sine[c / 4] = 5.f * simd::cos(2 * M_PI * phase[c / 4]);
 				if (outputs[SAW_OUTPUT].isConnected()) {
 					const float_4 dpwOrder1 = 2 * phase[c / 4] - 1.0;
 					const float_4 dpwOrder3 = aliasSuppressedSaw(phases) * denominatorInv;

 			// minBlep adds a small amount of DC that becomes significant at higher frequencies,
 			// this subtracts DC based on empirical observvations about the scaling relationship
 			const float sawCorrect = -5.7;
 			const float_4 sawDCComp = deltaPhase[c / 4] * sawCorrect;
 					osBufferSaw[i] = simd::ifelse(lowFreqRegime, dpwOrder1, dpwOrder3);
 				}

 			doubleSaw[c / 4] = simd::ifelse((phase[c / 4] < 0.5), (-1.f + 4.f * phase[c / 4]), (-1.f + 4.f * (phase[c / 4] - 0.5f)));
 			doubleSaw[c / 4] += doubleSawMinBlepOut[c / 4];
 			doubleSaw[c / 4] += 2.f * sawDCComp;
 			doubleSaw[c / 4] *= 5.f;
 				if (outputs[SQUARE_OUTPUT].isConnected()) {

 			even[c / 4] = 0.55 * (doubleSaw[c / 4] + 1.27 * sine[c / 4]);
 			saw[c / 4] = -1.f + 2.f * phase[c / 4];
 			saw[c / 4] += sawMinBlepOut[c / 4];
 			saw[c / 4] += sawDCComp;
 			saw[c / 4] *= 5.f;
 					float_4 dpwOrder1 = simd::ifelse(phase[c / 4] < pw, -1.0, +1.0);
 					dpwOrder1 -= removePulseDC ? 2.f * (0.5f - pw) : 0.f;

 			square[c / 4] = simd::ifelse((phase[c / 4] < pw[c / 4]),  -1.f, +1.f);
 			square[c / 4] += squareMinBlepOut[c / 4];
 			square[c / 4] += removePulseDC * 2.f * (pw[c / 4] - 0.5f);
 			square[c / 4] *= 5.f;
 					float_4 saw = aliasSuppressedSaw(phases);
 					float_4 sawOffset = aliasSuppressedOffsetSaw(phases, pw);
 					float_4 dpwOrder3 = (saw - sawOffset) * denominatorInv + pulseDCOffset;

 			// Set outputs
 			outputs[TRI_OUTPUT].setVoltageSimd(triOut[c / 4], c);
 			outputs[SINE_OUTPUT].setVoltageSimd(sine[c / 4], c);
 			outputs[EVEN_OUTPUT].setVoltageSimd(even[c / 4], c);
 			outputs[SAW_OUTPUT].setVoltageSimd(saw[c / 4], c);
 			outputs[SQUARE_OUTPUT].setVoltageSimd(square[c / 4], c);
 		}
 					osBufferSquare[i] = simd::ifelse(lowFreqRegime, dpwOrder1, dpwOrder3);
 				}

 				if (outputs[EVEN_OUTPUT].isConnected()) {

 					float_4 dpwOrder1 = 4.0 * simd::ifelse(phase[c / 4] < 0.5, phase[c / 4], phase[c / 4] - 0.5) - 1.0;
 					float_4 dpwOrder3 = aliasSuppressedDoubleSaw(phases) * denominatorInv;
 					float_4 doubleSaw = simd::ifelse(lowFreqRegime, dpwOrder1, dpwOrder3);
 					osBufferEven[i] = 0.55 * (doubleSaw + 1.27 * osBufferSin[i]);
 				}


 			} 	// end of oversampling loop

 			// downsample (if required)
 			if (outputs[SINE_OUTPUT].isConnected()) {
 				const float_4 outSin = (oversamplingRatio > 1) ? oversampler[SINE_OUTPUT][c / 4].downsample() : osBufferSin[0];
 				outputs[SINE_OUTPUT].setVoltageSimd(5.f * outSin, c);
 			}

 			if (outputs[TRI_OUTPUT].isConnected()) {
 				const float_4 outTri = (oversamplingRatio > 1) ? oversampler[TRI_OUTPUT][c / 4].downsample() : osBufferTri[0];
 				outputs[TRI_OUTPUT].setVoltageSimd(5.f * outTri, c);
 			}

 			if (outputs[SAW_OUTPUT].isConnected()) {
 				const float_4 outSaw = (oversamplingRatio > 1) ? oversampler[SAW_OUTPUT][c / 4].downsample() : osBufferSaw[0];
 				outputs[SAW_OUTPUT].setVoltageSimd(5.f * outSaw, c);
 			}

 			if (outputs[SQUARE_OUTPUT].isConnected()) {
 				const float_4 outSquare = (oversamplingRatio > 1) ? oversampler[SQUARE_OUTPUT][c / 4].downsample() : osBufferSquare[0];
 				outputs[SQUARE_OUTPUT].setVoltageSimd(5.f * outSquare, c);
 			}

 			if (outputs[EVEN_OUTPUT].isConnected()) {
 				const float_4 outEven = (oversamplingRatio > 1) ? oversampler[EVEN_OUTPUT][c / 4].downsample() : osBufferEven[0];
 				outputs[EVEN_OUTPUT].setVoltageSimd(5.f * outEven, c);
 			}

 		} 	// end of channels loop

 		// Outputs
 		outputs[TRI_OUTPUT].setChannels(channels);
@@ -223,6 +249,8 @@ struct EvenVCO : Module {
 	json_t* dataToJson() override {
 		json_t* rootJ = json_object();
 		json_object_set_new(rootJ, "removePulseDC", json_boolean(removePulseDC));
 		json_object_set_new(rootJ, "limitPW", json_boolean(limitPW));
 		json_object_set_new(rootJ, "oversamplingIndex", json_integer(oversampler[0][0].getOversamplingIndex()));
 		return rootJ;
 	}

@@ -231,6 +259,17 @@ struct EvenVCO : Module {
 		if (pulseDCJ) {
 			removePulseDC = json_boolean_value(pulseDCJ);
 		}

 		json_t* limitPWJ = json_object_get(rootJ, "limitPW");
 		if (limitPWJ) {
 			limitPW = json_boolean_value(limitPWJ);
 		}

 		json_t* oversamplingIndexJ = json_object_get(rootJ, "oversamplingIndex");
 		if (oversamplingIndexJ) {
 			oversamplingIndex = json_integer_value(oversamplingIndexJ);
 			onSampleRateChange();
 		}
 	}
 };

@@ -269,10 +308,22 @@ struct EvenVCOWidget : ModuleWidget {

 		menu->addChild(new MenuSeparator());
 		menu->addChild(createSubmenuItem("Hardware compatibility", "",
 			[ = ](Menu * menu) {
 		[ = ](Menu * menu) {
 			menu->addChild(createBoolPtrMenuItem("Remove DC from pulse", "", &module->removePulseDC));
 			}
 		));
 			menu->addChild(createBoolPtrMenuItem("Limit pulsewidth (5\%-95\%)", "", &module->limitPW));
 		}
 		                                ));

 		menu->addChild(createIndexSubmenuItem("Oversampling",
 		{"Off", "x2", "x4", "x8"},
 		[ = ]() {
 			return module->oversamplingIndex;
 		},
 		[ = ](int mode) {
 			module->oversamplingIndex = mode;
 			module->onSampleRateChange();
 		}
 		                                     ));
 	}
 };

--- a/src/NoisePlethora.cpp
+++ b/src/NoisePlethora.cpp
@@ -160,8 +160,10 @@ struct NoisePlethora : Module {

 	// section A/B
 	bool bypassFilters = false;
 	std::shared_ptr<NoisePlethoraPlugin> algorithm[2]; 		// pointer to actual algorithm
 	std::string algorithmName[2];							// variable to cache which algorithm is active (after program CV applied)
 	std::shared_ptr<NoisePlethoraPlugin> algorithm[2]{nullptr, nullptr}; 	// pointer to actual algorithm
 	std::string_view algorithmName[2]{"", ""};				// variable to cache which algorithm is active (after program CV applied)
 	std::map<std::string_view, std::shared_ptr<NoisePlethoraPlugin>> A_algorithms{};
 	std::map<std::string_view, std::shared_ptr<NoisePlethoraPlugin>> B_algorithms{};

 	// filters for A/B
 	StateVariableFilter2ndOrder svfFilter[2];
@@ -195,11 +197,11 @@ struct NoisePlethora : Module {
 		configParam(Y_A_PARAM, 0.f, 1.f, 0.5f, "YA");
 		configParam(CUTOFF_CV_A_PARAM, 0.f, 1.f, 0.f, "Cutoff CV A");
 		configSwitch(FILTER_TYPE_A_PARAM, 0.f, 2.f, 0.f, "Filter type", {"Lowpass", "Bandpass", "Highpass"});
 		configParam(PROGRAM_PARAM, -INFINITY, +INFINITY, 0.f, "Program/Bank selection");
 		configParam(PROGRAM_PARAM, 0, 1, 0.f, "Program/Bank selection");
 		configSwitch(FILTER_TYPE_B_PARAM, 0.f, 2.f, 0.f, "Filter type", {"Lowpass", "Bandpass", "Highpass"});
 		configParam(CUTOFF_CV_B_PARAM, 0.f, 1.f, 0.f, "Cutoff B");
 		configParam(CUTOFF_CV_B_PARAM, 0.f, 1.f, 0.f, "Cutoff CV B");
 		configParam(X_B_PARAM, 0.f, 1.f, 0.5f, "XB");
 		configParam(CUTOFF_B_PARAM, 0.f, 1.f, 1.f, "Cutoff CV B");
 		configParam(CUTOFF_B_PARAM, 0.f, 1.f, 1.f, "Cutoff B");
 		configParam(RES_B_PARAM, 0.f, 1.f, 0.f, "Resonance B");
 		configParam(Y_B_PARAM, 0.f, 1.f, 0.5f, "YB");
 		configSwitch(FILTER_TYPE_C_PARAM, 0.f, 2.f, 0.f, "Filter type", {"Lowpass", "Bandpass", "Highpass"});
@@ -231,6 +233,11 @@ struct NoisePlethora : Module {
 		getInputInfo(PROG_A_INPUT)->description = "CV sums with active program (0.5V increments)";
 		getInputInfo(PROG_B_INPUT)->description = "CV sums with active program (0.5V increments)";

 		for (auto const &entry : MyFactory::Instance()->factoryFunctionRegistry) {
 			A_algorithms[entry.first] = MyFactory::Instance()->Create(entry.first);
 			B_algorithms[entry.first] = MyFactory::Instance()->Create(entry.first);
 		}

 		setAlgorithm(SECTION_B, "radioOhNo");
 		setAlgorithm(SECTION_A, "radioOhNo");
 		onSampleRateChange();
@@ -298,19 +305,19 @@ struct NoisePlethora : Module {
 		programSelectorWithCV.getSection(SECTION).setBank(bank);
 		programSelectorWithCV.getSection(SECTION).setProgram(programWithCV);

 		const std::string newAlgorithmName = programSelectorWithCV.getSection(SECTION).getCurrentProgramName();
 		std::string_view newAlgorithmName = programSelectorWithCV.getSection(SECTION).getCurrentProgramName();

 		// this is just a caching check to avoid constantly re-initialisating the algorithms
 		if (newAlgorithmName != algorithmName[SECTION]) {

 			algorithm[SECTION] = MyFactory::Instance()->Create(newAlgorithmName);
 			algorithm[SECTION] = SECTION == Section::SECTION_A ? A_algorithms[newAlgorithmName] : B_algorithms[newAlgorithmName];
 			algorithmName[SECTION] = newAlgorithmName;

 			if (algorithm[SECTION]) {
 				algorithm[SECTION]->init();
 			}
 			else {
 				DEBUG("WARNING: Failed to initialise %s in programSelector", newAlgorithmName.c_str());
 				DEBUG("WARNING: Failed to initialise %s in programSelector", newAlgorithmName.data());
 			}
 		}
 	}
@@ -433,25 +440,23 @@ struct NoisePlethora : Module {
 	void processProgramBankKnobLogic(const ProcessArgs& args) {

 		// program knob will either change program for current bank...
 		if (programButtonDragged) {
 			// work out the change (in discrete increments) since the program/bank knob started being dragged
 			const int delta = (int)(dialResolution * (params[PROGRAM_PARAM].getValue() - programKnobReferenceState));
 		{

 			if (programKnobMode == PROGRAM_MODE) {
 				const int numProgramsForCurrentBank = getBankForIndex(programSelector.getCurrent().getBank()).getSize();
 				const int currentProgram = programSelector.getCurrent().getProgram();
 				const int newProgramFromKnob = (int) std::round((numProgramsForCurrentBank - 1) * params[PROGRAM_PARAM].getValue());

 				if (delta != 0) {
 					const int newProgramFromKnob = unsigned_modulo(programSelector.getCurrent().getProgram() + delta, numProgramsForCurrentBank);
 					programKnobReferenceState = params[PROGRAM_PARAM].getValue();
 				if (newProgramFromKnob != currentProgram) {
 					setAlgorithmViaProgram(newProgramFromKnob);
 				}
 			}
 			// ...or change bank, (trying to) keep program the same
 			else {
 				const int currentBank = programSelector.getCurrent().getBank();
 				const int newBankFromKnob = (int) std::round((numBanks - 1) * params[PROGRAM_PARAM].getValue());

 				if (delta != 0) {
 					const int newBankFromKnob = unsigned_modulo(programSelector.getCurrent().getBank() + delta, numBanks);
 					programKnobReferenceState = params[PROGRAM_PARAM].getValue();
 				if (currentBank != newBankFromKnob) {
 					setAlgorithmViaBank(newBankFromKnob);
 				}
 			}
@@ -502,7 +507,7 @@ struct NoisePlethora : Module {
 	void setAlgorithmViaProgram(int newProgram) {

 		const int currentBank = programSelector.getCurrent().getBank();
 		const std::string algorithmName = getBankForIndex(currentBank).getProgramName(newProgram);
 		std::string_view algorithmName = getBankForIndex(currentBank).getProgramName(newProgram);
 		const int section = programSelector.getMode();

 		setAlgorithm(section, algorithmName);
@@ -513,13 +518,13 @@ struct NoisePlethora : Module {
 		const int currentProgram = programSelector.getCurrent().getProgram();
 		// the new bank may not have as many algorithms
 		const int currentProgramInNewBank = clamp(currentProgram, 0, getBankForIndex(newBank).getSize() - 1);
 		const std::string algorithmName = getBankForIndex(newBank).getProgramName(currentProgramInNewBank);
 		const std::string_view algorithmName = getBankForIndex(newBank).getProgramName(currentProgramInNewBank);
 		const int section = programSelector.getMode();

 		setAlgorithm(section, algorithmName);
 	}

 	void setAlgorithm(int section, std::string algorithmName) {
 	void setAlgorithm(int section, std::string_view algorithmName) {

 		if (section > 1) {
 			return;
@@ -537,7 +542,7 @@ struct NoisePlethora : Module {
 			}
 		}

 		DEBUG("WARNING: Didn't find %s in programSelector", algorithmName.c_str());
 		DEBUG("WARNING: Didn't find %s in programSelector", algorithmName.data());
 	}

 	void dataFromJson(json_t* rootJ) override {
@@ -565,8 +570,8 @@ struct NoisePlethora : Module {
 	json_t* dataToJson() override {
 		json_t* rootJ = json_object();

 		json_object_set_new(rootJ, "algorithmA", json_string(programSelector.getA().getCurrentProgramName().c_str()));
 		json_object_set_new(rootJ, "algorithmB", json_string(programSelector.getB().getCurrentProgramName().c_str()));
 		json_object_set_new(rootJ, "algorithmA", json_string(programSelector.getA().getCurrentProgramName().data()));
 		json_object_set_new(rootJ, "algorithmB", json_string(programSelector.getB().getCurrentProgramName().data()));

 		json_object_set_new(rootJ, "bypassFilters", json_boolean(bypassFilters));
 		json_object_set_new(rootJ, "blockDC", json_boolean(blockDC));
@@ -648,7 +653,7 @@ struct NoisePlethoraLEDDisplay : LightWidget {
 	}

 	void setTooltip() {
 		std::string activeName = module->programSelector.getSection(section).getCurrentProgramName();
 		std::string_view activeName = module->programSelector.getSection(section).getCurrentProgramName();
 		tooltip = new ui::Tooltip;
 		tooltip->text = activeName;
 		APP->scene->addChild(tooltip);
@@ -839,7 +844,7 @@ struct NoisePlethoraWidget : ModuleWidget {
 					menu->addChild(createSubmenuItem(string::f("Bank %d: %s", i + 1, bankAliases[i].c_str()), currentBank == i ? CHECKMARK_STRING : "", [ = ](Menu * menu) {
 						for (int j = 0; j < getBankForIndex(i).getSize(); ++j) {
 							const bool currentProgramAndBank = (currentProgram == j) && (currentBank == i);
 							const std::string algorithmName = getBankForIndex(i).getProgramName(j);
 							std::string_view algorithmName = getBankForIndex(i).getProgramName(j);

 							bool implemented = false;
 							for (auto item : MyFactory::Instance()->factoryFunctionRegistry) {
@@ -850,14 +855,14 @@ struct NoisePlethoraWidget : ModuleWidget {
 							}

 							if (implemented) {
 								menu->addChild(createMenuItem(algorithmName, currentProgramAndBank ? CHECKMARK_STRING : "",
 								menu->addChild(createMenuItem(algorithmName.data(), currentProgramAndBank ? CHECKMARK_STRING : "",
 								[ = ]() {
 									module->setAlgorithm(sectionId, algorithmName);
 								}));
 							}
 							else {
 								// placeholder text (greyed out)
 								menu->addChild(createMenuLabel(algorithmName));
 								menu->addChild(createMenuLabel(algorithmName.data()));
 							}
 						}
 					}));
@@ -874,4 +879,4 @@ struct NoisePlethoraWidget : ModuleWidget {
 };


 Model* modelNoisePlethora = createModel<NoisePlethora, NoisePlethoraWidget>("NoisePlethora");
 Model* modelNoisePlethora = createModel<NoisePlethora, NoisePlethoraWidget>("NoisePlethora");
--- a/src/Octaves.cpp
+++ b/src/Octaves.cpp
@@ -80,12 +80,12 @@ struct Octaves : Module {
 		configInput(VOCT2_INPUT, "V/Octave 2");
 		configInput(SYNC_INPUT, "Sync");
 		configInput(PWM_INPUT, "PWM");
 		configInput(GAIN_01F_INPUT, "Gain x1F CV");
 		configInput(GAIN_02F_INPUT, "Gain x1F CV");
 		configInput(GAIN_04F_INPUT, "Gain x1F CV");
 		configInput(GAIN_08F_INPUT, "Gain x1F CV");
 		configInput(GAIN_16F_INPUT, "Gain x1F CV");
 		configInput(GAIN_32F_INPUT, "Gain x1F CV");
 		configInput(GAIN_01F_INPUT, "Gain Fundamental CV");
 		configInput(GAIN_02F_INPUT, "Gain x2F CV");
 		configInput(GAIN_04F_INPUT, "Gain x4F CV");
 		configInput(GAIN_08F_INPUT, "Gain x8F CV");
 		configInput(GAIN_16F_INPUT, "Gain x16F CV");
 		configInput(GAIN_32F_INPUT, "Gain x32F CV");

 		configOutput(OUT_01F_OUTPUT, "x1F");
 		configOutput(OUT_02F_OUTPUT, "x2F");
@@ -115,12 +115,10 @@ struct Octaves : Module {
 		const int numActivePolyphonyEngines = getNumActivePolyphonyEngines();

 		// work out active outputs
 		const std::vector<int> connectedOutputs = getConnectedOutputs();
 		if (connectedOutputs.size() == 0) {
 		const int highestOutput = getMaxConnectedOutput();
 		if (highestOutput == -1) {
 			return;
 		}
 		// only process up to highest active channel
 		const int highestOutput = *std::max_element(connectedOutputs.begin(), connectedOutputs.end());

 		for (int c = 0; c < numActivePolyphonyEngines; c += 4) {

@@ -200,8 +198,10 @@ struct Octaves : Module {
 			}
 		}	// end of polyphony loop

 		for (int connectedOutput : connectedOutputs) {
 			outputs[OUT_01F_OUTPUT + connectedOutput].setChannels(numActivePolyphonyEngines);
 		for (int c = 0; c < NUM_OUTPUTS; c++) {
 			if (outputs[OUT_01F_OUTPUT + c].isConnected()) {
 				outputs[OUT_01F_OUTPUT + c].setChannels(numActivePolyphonyEngines);
 			}
 		}
 	}

@@ -219,14 +219,14 @@ struct Octaves : Module {
 		return activePolyphonyEngines;
 	}

 	std::vector<int> getConnectedOutputs() {
 		std::vector<int> connectedOutputs;
 	int getMaxConnectedOutput() {
 		int maxChans = -1;
 		for (int c = 0; c < NUM_OUTPUTS; c++) {
 			if (outputs[OUT_01F_OUTPUT + c].isConnected()) {
 				connectedOutputs.push_back(c);
 				maxChans = c;
 			}
 		}
 		return connectedOutputs;
 		return maxChans;
 	}

 	json_t* dataToJson() override {
@@ -333,4 +333,4 @@ struct OctavesWidget : ModuleWidget {
 	}
 };

 Model* modelOctaves = createModel<Octaves, OctavesWidget>("Octaves");
 Model* modelOctaves = createModel<Octaves, OctavesWidget>("Octaves");
--- a/src/noise-plethora/plugins/Banks.cpp
+++ b/src/noise-plethora/plugins/Banks.cpp
@@ -14,7 +14,7 @@ Bank::Bank(const BankElem& p1, const BankElem& p2, const BankElem& p3,
 	: programs{p1, p2, p3, p4, p5, p6, p7, p8, p9, p10}
 { }

 const std::string Bank::getProgramName(int i) {
 std::string_view Bank::getProgramName(int i) {
 	if (i >= 0 && i < programsPerBank) {
 		return programs[i].name;
 	}
--- a/src/noise-plethora/plugins/Banks.hpp
+++ b/src/noise-plethora/plugins/Banks.hpp
@@ -1,6 +1,7 @@
 #pragma once

 #include <string>
 #include <string_view>
 #include <memory>
 #include <array>

@@ -30,7 +31,7 @@ struct Bank {
 	     const BankElem& p7 = defaultElem, const BankElem& p8 = defaultElem,
 	     const BankElem& p9 = defaultElem, const BankElem& p10 = defaultElem);

 	const std::string getProgramName(int i);
 	std::string_view getProgramName(int i);
 	float getProgramGain(int i);

 	int getSize();
--- a/src/noise-plethora/plugins/ProgramSelector.hpp
+++ b/src/noise-plethora/plugins/ProgramSelector.hpp
@@ -68,7 +68,7 @@ public:
 		return program.setValue(p, getBankForIndex(getBank()).getSize());
 	}

 	const std::string getCurrentProgramName() {
 	const std::string_view getCurrentProgramName() {
 		return getBankForIndex(getBank()).getProgramName(getProgram());
 	}

--- a/src/plugin.cpp
+++ b/src/plugin.cpp
@@ -31,4 +31,6 @@ void init(rack::Plugin *p) {
 	p->addModel(modelMidiThing);
 	p->addModel(modelVoltio);
 	p->addModel(modelOctaves);
 	p->addModel(modelBypass);
 	p->addModel(modelBandit);
 }
--- a/src/plugin.hpp
+++ b/src/plugin.hpp
@@ -32,6 +32,8 @@ extern Model* modelBurst;
 extern Model* modelMidiThing;
 extern Model* modelVoltio;
 extern Model* modelOctaves;
 extern Model* modelBypass;
 extern Model* modelBandit;

 struct Knurlie : SvgScrew {
 	Knurlie() {
@@ -240,6 +242,13 @@ struct Davies1900hWhiteKnobEndless : Davies1900hKnob {
 	}
 };

 template <typename TBase = WhiteLight>
 struct VeryLargeSimpleLight : TBase {
 	VeryLargeSimpleLight() {
 		this->box.size = mm2px(math::Vec(7, 7));
 	}
 };

 inline int unsigned_modulo(int a, int b) {
 	return ((a % b) + b) % b;
 }