BogaudioModules

BogaudioModules for VCV Rack
Log | Files | Refs | README | LICENSE
commit 9eed9d8d4fecd171e08ca33dea56bdf5b3ff512c
parent bbe5e818dc104fc775b6159dccb773d075cbef9f
Author: Matt Demanett <matt@demanett.net>
Date:   Sat, 18 May 2019 18:45:22 -0400

v1: create(Input|Output).

Diffstat:

Msrc/AD.cpp | 10+++++-----


Msrc/ADSR.cpp | 4++--


Msrc/AMRM.cpp | 12++++++------


Msrc/Additator.cpp | 22+++++++++++-----------


Msrc/AddrSeq.cpp | 8++++----


Msrc/Analyzer.cpp | 18+++++++++---------


Msrc/AnalyzerXL.cpp | 16++++++++--------


Msrc/Blank3.cpp | 2+-


Msrc/Blank6.cpp | 2+-


Msrc/Bool.cpp | 16++++++++--------


Msrc/CVD.cpp | 8++++----


Msrc/Clpr.cpp | 12++++++------


Msrc/Cmp.cpp | 18+++++++++---------


Msrc/DADSRH.cpp | 8++++----


Msrc/DADSRHPlus.cpp | 30+++++++++++++++---------------


Msrc/DGate.cpp | 6+++---


Msrc/Detune.cpp | 10+++++-----


Msrc/EightFO.cpp | 42+++++++++++++++++++++---------------------


Msrc/EightOne.cpp | 26+++++++++++++-------------


Msrc/FMOp.cpp | 18+++++++++---------


Msrc/FlipFlop.cpp | 16++++++++--------


Msrc/Follow.cpp | 8++++----


Msrc/LFO.cpp | 24++++++++++++------------


Msrc/LLFO.cpp | 6+++---


Msrc/Lag.cpp | 8++++----


Msrc/Lmtr.cpp | 12++++++------


Msrc/Manual.cpp | 16++++++++--------


Msrc/Matrix88.cpp | 32++++++++++++++++----------------


Msrc/Mix1.cpp | 8++++----


Msrc/Mix4.cpp | 32++++++++++++++++----------------


Msrc/Mix8.cpp | 56++++++++++++++++++++++++++++----------------------------


Msrc/Mult.cpp | 18+++++++++---------


Msrc/Mute8.cpp | 50+++++++++++++++++++++++++-------------------------


Msrc/Noise.cpp | 14+++++++-------


Msrc/Nsgt.cpp | 12++++++------


Msrc/Offset.cpp | 8++++----


Msrc/OneEight.cpp | 26+++++++++++++-------------


Msrc/Pan.cpp | 12++++++------


Msrc/Pressor.cpp | 26+++++++++++++-------------


Msrc/Reftone.cpp | 4++--


Msrc/SampleHold.cpp | 12++++++------


Msrc/Shaper.cpp | 12++++++------


Msrc/ShaperPlus.cpp | 32++++++++++++++++----------------


Msrc/Slew.cpp | 8++++----


Msrc/Stack.cpp | 8++++----


Msrc/Sums.cpp | 16++++++++--------


Msrc/Switch.cpp | 16++++++++--------


Msrc/Test.cpp | 12++++++------


Msrc/Test2.cpp | 18+++++++++---------


Msrc/UMix.cpp | 20++++++++++----------


Msrc/VCA.cpp | 12++++++------


Msrc/VCAmp.cpp | 6+++---


Msrc/VCM.cpp | 22+++++++++++-----------


Msrc/VCO.cpp | 18+++++++++---------


Msrc/VU.cpp | 8++++----


Msrc/Walk.cpp | 10+++++-----


Msrc/Walk2.cpp | 22+++++++++++-----------


Msrc/XCO.cpp | 44++++++++++++++++++++++----------------------


Msrc/XFade.cpp | 8++++----


59 files changed, 490 insertions(+), 490 deletions(-)

diff --git a/src/AD.cpp b/src/AD.cpp
@@ -100,12 +100,12 @@ struct ADWidget : ModuleWidget {
 		addParam(createParam<StatefulButton9>(loopParamPosition, module, AD::LOOP_PARAM, 0.0, 1.0, 0.0));
 		addParam(createParam<StatefulButton9>(linearParamPosition, module, AD::LINEAR_PARAM, 0.0, 1.0, 0.0));
 
-		addInput(createPort<Port24>(triggerInputPosition, PortWidget::INPUT, module, AD::TRIGGER_INPUT));
-		addInput(createPort<Port24>(attackInputPosition, PortWidget::INPUT, module, AD::ATTACK_INPUT));
-		addInput(createPort<Port24>(decayInputPosition, PortWidget::INPUT, module, AD::DECAY_INPUT));
+		addInput(createInput<Port24>(triggerInputPosition, module, AD::TRIGGER_INPUT));
+		addInput(createInput<Port24>(attackInputPosition, module, AD::ATTACK_INPUT));
+		addInput(createInput<Port24>(decayInputPosition, module, AD::DECAY_INPUT));
 
-		addOutput(createPort<Port24>(envOutputPosition, PortWidget::OUTPUT, module, AD::ENV_OUTPUT));
-		addOutput(createPort<Port24>(eocOutputPosition, PortWidget::OUTPUT, module, AD::EOC_OUTPUT));
+		addOutput(createOutput<Port24>(envOutputPosition, module, AD::ENV_OUTPUT));
+		addOutput(createOutput<Port24>(eocOutputPosition, module, AD::EOC_OUTPUT));
 
 		addChild(createLight<TinyLight<GreenLight>>(attackLightPosition, module, AD::ATTACK_LIGHT));
 		addChild(createLight<TinyLight<GreenLight>>(decayLightPosition, module, AD::DECAY_LIGHT));
diff --git a/src/ADSR.cpp b/src/ADSR.cpp
@@ -79,9 +79,9 @@ struct ADSRWidget : ModuleWidget {
 		addParam(createParam<Knob29>(releaseParamPosition, module, ADSR::RELEASE_PARAM, 0.0, 1.0, 0.31623));
 		addParam(createParam<StatefulButton9>(linearParamPosition, module, ADSR::LINEAR_PARAM, 0.0, 1.0, 0.0));
 
-		addInput(createPort<Port24>(gateInputPosition, PortWidget::INPUT, module, ADSR::GATE_INPUT));
+		addInput(createInput<Port24>(gateInputPosition, module, ADSR::GATE_INPUT));
 
-		addOutput(createPort<Port24>(outOutputPosition, PortWidget::OUTPUT, module, ADSR::OUT_OUTPUT));
+		addOutput(createOutput<Port24>(outOutputPosition, module, ADSR::OUT_OUTPUT));
 
 		addChild(createLight<TinyLight<GreenLight>>(attackLightPosition, module, ADSR::ATTACK_LIGHT));
 		addChild(createLight<TinyLight<GreenLight>>(decayLightPosition, module, ADSR::DECAY_LIGHT));
diff --git a/src/AMRM.cpp b/src/AMRM.cpp
@@ -63,13 +63,13 @@ struct AMRMWidget : ModuleWidget {
 		addParam(createParam<Knob45>(rectifyParamPosition, module, AMRM::RECTIFY_PARAM, 0.0, 1.0, 0.0));
 		addParam(createParam<Knob45>(drywetParamPosition, module, AMRM::DRYWET_PARAM, 0.0, 1.0, 1.0));
 
-		addInput(createPort<Port24>(modulatorInputPosition, PortWidget::INPUT, module, AMRM::MODULATOR_INPUT));
-		addInput(createPort<Port24>(carrierInputPosition, PortWidget::INPUT, module, AMRM::CARRIER_INPUT));
-		addInput(createPort<Port24>(rectifyInputPosition, PortWidget::INPUT, module, AMRM::RECTIFY_INPUT));
-		addInput(createPort<Port24>(drywetInputPosition, PortWidget::INPUT, module, AMRM::DRYWET_INPUT));
+		addInput(createInput<Port24>(modulatorInputPosition, module, AMRM::MODULATOR_INPUT));
+		addInput(createInput<Port24>(carrierInputPosition, module, AMRM::CARRIER_INPUT));
+		addInput(createInput<Port24>(rectifyInputPosition, module, AMRM::RECTIFY_INPUT));
+		addInput(createInput<Port24>(drywetInputPosition, module, AMRM::DRYWET_INPUT));
 
-		addOutput(createPort<Port24>(rectifyOutputPosition, PortWidget::OUTPUT, module, AMRM::RECTIFY_OUTPUT));
-		addOutput(createPort<Port24>(outOutputPosition, PortWidget::OUTPUT, module, AMRM::OUT_OUTPUT));
+		addOutput(createOutput<Port24>(rectifyOutputPosition, module, AMRM::RECTIFY_OUTPUT));
+		addOutput(createOutput<Port24>(outOutputPosition, module, AMRM::OUT_OUTPUT));
 	}
 };
 
diff --git a/src/Additator.cpp b/src/Additator.cpp
@@ -241,18 +241,18 @@ struct AdditatorWidget : ModuleWidget {
 		));
 		addParam(createParam<StatefulButton9>(phaseParamPosition, module, Additator::PHASE_PARAM, 1.0, 2.0, 1.0));
 
-		addInput(createPort<Port24>(partialsInputPosition, PortWidget::INPUT, module, Additator::PARTIALS_INPUT));
-		addInput(createPort<Port24>(widthInputPosition, PortWidget::INPUT, module, Additator::WIDTH_INPUT));
-		addInput(createPort<Port24>(oddSkewInputPosition, PortWidget::INPUT, module, Additator::ODD_SKEW_INPUT));
-		addInput(createPort<Port24>(evenSkewInputPosition, PortWidget::INPUT, module, Additator::EVEN_SKEW_INPUT));
-		addInput(createPort<Port24>(gainInputPosition, PortWidget::INPUT, module, Additator::GAIN_INPUT));
-		addInput(createPort<Port24>(decayInputPosition, PortWidget::INPUT, module, Additator::DECAY_INPUT));
-		addInput(createPort<Port24>(balanceInputPosition, PortWidget::INPUT, module, Additator::BALANCE_INPUT));
-		addInput(createPort<Port24>(filterInputPosition, PortWidget::INPUT, module, Additator::FILTER_INPUT));
-		addInput(createPort<Port24>(pitchInputPosition, PortWidget::INPUT, module, Additator::PITCH_INPUT));
-		addInput(createPort<Port24>(syncInputPosition, PortWidget::INPUT, module, Additator::SYNC_INPUT));
+		addInput(createInput<Port24>(partialsInputPosition, module, Additator::PARTIALS_INPUT));
+		addInput(createInput<Port24>(widthInputPosition, module, Additator::WIDTH_INPUT));
+		addInput(createInput<Port24>(oddSkewInputPosition, module, Additator::ODD_SKEW_INPUT));
+		addInput(createInput<Port24>(evenSkewInputPosition, module, Additator::EVEN_SKEW_INPUT));
+		addInput(createInput<Port24>(gainInputPosition, module, Additator::GAIN_INPUT));
+		addInput(createInput<Port24>(decayInputPosition, module, Additator::DECAY_INPUT));
+		addInput(createInput<Port24>(balanceInputPosition, module, Additator::BALANCE_INPUT));
+		addInput(createInput<Port24>(filterInputPosition, module, Additator::FILTER_INPUT));
+		addInput(createInput<Port24>(pitchInputPosition, module, Additator::PITCH_INPUT));
+		addInput(createInput<Port24>(syncInputPosition, module, Additator::SYNC_INPUT));
 
-		addOutput(createPort<Port24>(audioOutputPosition, PortWidget::OUTPUT, module, Additator::AUDIO_OUTPUT));
+		addOutput(createOutput<Port24>(audioOutputPosition, module, Additator::AUDIO_OUTPUT));
 
 		addChild(createLight<SmallLight<GreenLight>>(sineLightPosition, module, Additator::SINE_LIGHT));
 		addChild(createLight<SmallLight<GreenLight>>(cosineLightPosition, module, Additator::COSINE_LIGHT));
diff --git a/src/AddrSeq.cpp b/src/AddrSeq.cpp
@@ -138,11 +138,11 @@ struct AddrSeqWidget : ModuleWidget {
 		addParam(createParam<Knob16>(out7ParamPosition, module, AddrSeq::OUT7_PARAM, -1.0, 1.0, 0.0));
 		addParam(createParam<Knob16>(out8ParamPosition, module, AddrSeq::OUT8_PARAM, -1.0, 1.0, 0.0));
 
-		addInput(createPort<Port24>(clockInputPosition, PortWidget::INPUT, module, AddrSeq::CLOCK_INPUT));
-		addInput(createPort<Port24>(resetInputPosition, PortWidget::INPUT, module, AddrSeq::RESET_INPUT));
-		addInput(createPort<Port24>(selectInputPosition, PortWidget::INPUT, module, AddrSeq::SELECT_INPUT));
+		addInput(createInput<Port24>(clockInputPosition, module, AddrSeq::CLOCK_INPUT));
+		addInput(createInput<Port24>(resetInputPosition, module, AddrSeq::RESET_INPUT));
+		addInput(createInput<Port24>(selectInputPosition, module, AddrSeq::SELECT_INPUT));
 
-		addOutput(createPort<Port24>(outOutputPosition, PortWidget::OUTPUT, module, AddrSeq::OUT_OUTPUT));
+		addOutput(createOutput<Port24>(outOutputPosition, module, AddrSeq::OUT_OUTPUT));
 
 		addChild(createLight<SmallLight<GreenLight>>(out1LightPosition, module, AddrSeq::OUT1_LIGHT));
 		addChild(createLight<SmallLight<GreenLight>>(out2LightPosition, module, AddrSeq::OUT2_LIGHT));
diff --git a/src/Analyzer.cpp b/src/Analyzer.cpp
@@ -157,15 +157,15 @@ struct AnalyzerWidget : ModuleWidget {
 		addParam(createParam<StatefulButton9>(qualityParamPosition, module, Analyzer::QUALITY_PARAM, 1.0, 3.0, 1.0));
 		addParam(createParam<StatefulButton9>(windowParamPosition, module, Analyzer::WINDOW_PARAM, 1.0, 3.0, 1.0));
 
-		addInput(createPort<Port24>(signalaInputPosition, PortWidget::INPUT, module, Analyzer::SIGNALA_INPUT));
-		addInput(createPort<Port24>(signalbInputPosition, PortWidget::INPUT, module, Analyzer::SIGNALB_INPUT));
-		addInput(createPort<Port24>(signalcInputPosition, PortWidget::INPUT, module, Analyzer::SIGNALC_INPUT));
-		addInput(createPort<Port24>(signaldInputPosition, PortWidget::INPUT, module, Analyzer::SIGNALD_INPUT));
-
-		addOutput(createPort<Port24>(signalaOutputPosition, PortWidget::OUTPUT, module, Analyzer::SIGNALA_OUTPUT));
-		addOutput(createPort<Port24>(signalbOutputPosition, PortWidget::OUTPUT, module, Analyzer::SIGNALB_OUTPUT));
-		addOutput(createPort<Port24>(signalcOutputPosition, PortWidget::OUTPUT, module, Analyzer::SIGNALC_OUTPUT));
-		addOutput(createPort<Port24>(signaldOutputPosition, PortWidget::OUTPUT, module, Analyzer::SIGNALD_OUTPUT));
+		addInput(createInput<Port24>(signalaInputPosition, module, Analyzer::SIGNALA_INPUT));
+		addInput(createInput<Port24>(signalbInputPosition, module, Analyzer::SIGNALB_INPUT));
+		addInput(createInput<Port24>(signalcInputPosition, module, Analyzer::SIGNALC_INPUT));
+		addInput(createInput<Port24>(signaldInputPosition, module, Analyzer::SIGNALD_INPUT));
+
+		addOutput(createOutput<Port24>(signalaOutputPosition, module, Analyzer::SIGNALA_OUTPUT));
+		addOutput(createOutput<Port24>(signalbOutputPosition, module, Analyzer::SIGNALB_OUTPUT));
+		addOutput(createOutput<Port24>(signalcOutputPosition, module, Analyzer::SIGNALC_OUTPUT));
+		addOutput(createOutput<Port24>(signaldOutputPosition, module, Analyzer::SIGNALD_OUTPUT));
 
 		addChild(createLight<SmallLight<GreenLight>>(qualityUltraLightPosition, module, Analyzer::QUALITY_ULTRA_LIGHT));
 		addChild(createLight<SmallLight<GreenLight>>(qualityHighLightPosition, module, Analyzer::QUALITY_HIGH_LIGHT));
diff --git a/src/AnalyzerXL.cpp b/src/AnalyzerXL.cpp
@@ -272,14 +272,14 @@ struct AnalyzerXLWidget : ModuleWidget {
 		auto signalhInputPosition = Vec(3.0, 251.0);
 		// end generated by svg_widgets.rb
 
-		addInput(createPort<Port24>(signalaInputPosition, PortWidget::INPUT, module, AnalyzerXL::SIGNALA_INPUT));
-		addInput(createPort<Port24>(signalbInputPosition, PortWidget::INPUT, module, AnalyzerXL::SIGNALB_INPUT));
-		addInput(createPort<Port24>(signalcInputPosition, PortWidget::INPUT, module, AnalyzerXL::SIGNALC_INPUT));
-		addInput(createPort<Port24>(signaldInputPosition, PortWidget::INPUT, module, AnalyzerXL::SIGNALD_INPUT));
-		addInput(createPort<Port24>(signaleInputPosition, PortWidget::INPUT, module, AnalyzerXL::SIGNALE_INPUT));
-		addInput(createPort<Port24>(signalfInputPosition, PortWidget::INPUT, module, AnalyzerXL::SIGNALF_INPUT));
-		addInput(createPort<Port24>(signalgInputPosition, PortWidget::INPUT, module, AnalyzerXL::SIGNALG_INPUT));
-		addInput(createPort<Port24>(signalhInputPosition, PortWidget::INPUT, module, AnalyzerXL::SIGNALH_INPUT));
+		addInput(createInput<Port24>(signalaInputPosition, module, AnalyzerXL::SIGNALA_INPUT));
+		addInput(createInput<Port24>(signalbInputPosition, module, AnalyzerXL::SIGNALB_INPUT));
+		addInput(createInput<Port24>(signalcInputPosition, module, AnalyzerXL::SIGNALC_INPUT));
+		addInput(createInput<Port24>(signaldInputPosition, module, AnalyzerXL::SIGNALD_INPUT));
+		addInput(createInput<Port24>(signaleInputPosition, module, AnalyzerXL::SIGNALE_INPUT));
+		addInput(createInput<Port24>(signalfInputPosition, module, AnalyzerXL::SIGNALF_INPUT));
+		addInput(createInput<Port24>(signalgInputPosition, module, AnalyzerXL::SIGNALG_INPUT));
+		addInput(createInput<Port24>(signalhInputPosition, module, AnalyzerXL::SIGNALH_INPUT));
 	}
 
 	void appendContextMenu(Menu* menu) override {
diff --git a/src/Blank3.cpp b/src/Blank3.cpp
@@ -87,7 +87,7 @@ struct Blank3Widget : ModuleWidget {
 		addChild(createWidget<ScrewSilver>(Vec(0, 0)));
 		addChild(createWidget<ScrewSilver>(Vec(box.size.x - 15, 365)));
 
-		addInput(createPort<BlankPort24>(Vec(10.5, 346), PortWidget::INPUT, module, Blank3::IN_INPUT));
+		addInput(createInput<BlankPort24>(Vec(10.5, 346), module, Blank3::IN_INPUT));
 	}
 };
 
diff --git a/src/Blank6.cpp b/src/Blank6.cpp
@@ -87,7 +87,7 @@ struct Blank6Widget : ModuleWidget {
 		addChild(createWidget<ScrewSilver>(Vec(0, 0)));
 		addChild(createWidget<ScrewSilver>(Vec(box.size.x - 15, 365)));
 
-		addInput(createPort<BlankPort24>(Vec(33, 346), PortWidget::INPUT, module, Blank6::IN_INPUT));
+		addInput(createInput<BlankPort24>(Vec(33, 346), module, Blank6::IN_INPUT));
 	}
 };
 
diff --git a/src/Bool.cpp b/src/Bool.cpp
@@ -38,14 +38,14 @@ struct BoolWidget : ModuleWidget {
 		auto notOutputPosition = Vec(10.5, 254.0);
 		// end generated by svg_widgets.rb
 
-		addInput(createPort<Port24>(aInputPosition, PortWidget::INPUT, module, Bool::A_INPUT));
-		addInput(createPort<Port24>(bInputPosition, PortWidget::INPUT, module, Bool::B_INPUT));
-		addInput(createPort<Port24>(notInputPosition, PortWidget::INPUT, module, Bool::NOT_INPUT));
-
-		addOutput(createPort<Port24>(andOutputPosition, PortWidget::OUTPUT, module, Bool::AND_OUTPUT));
-		addOutput(createPort<Port24>(orOutputPosition, PortWidget::OUTPUT, module, Bool::OR_OUTPUT));
-		addOutput(createPort<Port24>(xorOutputPosition, PortWidget::OUTPUT, module, Bool::XOR_OUTPUT));
-		addOutput(createPort<Port24>(notOutputPosition, PortWidget::OUTPUT, module, Bool::NOT_OUTPUT));
+		addInput(createInput<Port24>(aInputPosition, module, Bool::A_INPUT));
+		addInput(createInput<Port24>(bInputPosition, module, Bool::B_INPUT));
+		addInput(createInput<Port24>(notInputPosition, module, Bool::NOT_INPUT));
+
+		addOutput(createOutput<Port24>(andOutputPosition, module, Bool::AND_OUTPUT));
+		addOutput(createOutput<Port24>(orOutputPosition, module, Bool::OR_OUTPUT));
+		addOutput(createOutput<Port24>(xorOutputPosition, module, Bool::XOR_OUTPUT));
+		addOutput(createOutput<Port24>(notOutputPosition, module, Bool::NOT_OUTPUT));
 	}
 };
 
diff --git a/src/CVD.cpp b/src/CVD.cpp
@@ -73,11 +73,11 @@ struct CVDWidget : ModuleWidget {
 		}
 		addParam(createParam<Knob29>(mixParamPosition, module, CVD::MIX_PARAM, -1.0, 1.0, 0.0));
 
-		addInput(createPort<Port24>(timeInputPosition, PortWidget::INPUT, module, CVD::TIME_INPUT));
-		addInput(createPort<Port24>(mixInputPosition, PortWidget::INPUT, module, CVD::MIX_INPUT));
-		addInput(createPort<Port24>(inInputPosition, PortWidget::INPUT, module, CVD::IN_INPUT));
+		addInput(createInput<Port24>(timeInputPosition, module, CVD::TIME_INPUT));
+		addInput(createInput<Port24>(mixInputPosition, module, CVD::MIX_INPUT));
+		addInput(createInput<Port24>(inInputPosition, module, CVD::IN_INPUT));
 
-		addOutput(createPort<Port24>(outOutputPosition, PortWidget::OUTPUT, module, CVD::OUT_OUTPUT));
+		addOutput(createOutput<Port24>(outOutputPosition, module, CVD::OUT_OUTPUT));
 	}
 };
 
diff --git a/src/Clpr.cpp b/src/Clpr.cpp
@@ -82,13 +82,13 @@ struct ClprWidget : ModuleWidget {
 		addParam(createParam<Knob38>(outputGainParamPosition, module, Clpr::OUTPUT_GAIN_PARAM, 0.0, 1.0, 0.0));
 		addParam(createParam<SliderSwitch2State14>(kneeParamPosition, module, Clpr::KNEE_PARAM, 0.95, 1.0, 0.0));
 
-		addInput(createPort<Port24>(leftInputPosition, PortWidget::INPUT, module, Clpr::LEFT_INPUT));
-		addInput(createPort<Port24>(rightInputPosition, PortWidget::INPUT, module, Clpr::RIGHT_INPUT));
-		addInput(createPort<Port24>(thresholdInputPosition, PortWidget::INPUT, module, Clpr::THRESHOLD_INPUT));
-		addInput(createPort<Port24>(outputGainInputPosition, PortWidget::INPUT, module, Clpr::OUTPUT_GAIN_INPUT));
+		addInput(createInput<Port24>(leftInputPosition, module, Clpr::LEFT_INPUT));
+		addInput(createInput<Port24>(rightInputPosition, module, Clpr::RIGHT_INPUT));
+		addInput(createInput<Port24>(thresholdInputPosition, module, Clpr::THRESHOLD_INPUT));
+		addInput(createInput<Port24>(outputGainInputPosition, module, Clpr::OUTPUT_GAIN_INPUT));
 
-		addOutput(createPort<Port24>(leftOutputPosition, PortWidget::OUTPUT, module, Clpr::LEFT_OUTPUT));
-		addOutput(createPort<Port24>(rightOutputPosition, PortWidget::OUTPUT, module, Clpr::RIGHT_OUTPUT));
+		addOutput(createOutput<Port24>(leftOutputPosition, module, Clpr::LEFT_OUTPUT));
+		addOutput(createOutput<Port24>(rightOutputPosition, module, Clpr::RIGHT_OUTPUT));
 	}
 };
 
diff --git a/src/Cmp.cpp b/src/Cmp.cpp
@@ -201,15 +201,15 @@ struct CmpWidget : ModuleWidget {
 			addParam(w);
 		}
 
-		addInput(createPort<Port24>(aInputPosition, PortWidget::INPUT, module, Cmp::A_INPUT));
-		addInput(createPort<Port24>(bInputPosition, PortWidget::INPUT, module, Cmp::B_INPUT));
-		addInput(createPort<Port24>(windowInputPosition, PortWidget::INPUT, module, Cmp::WINDOW_INPUT));
-		addInput(createPort<Port24>(lagInputPosition, PortWidget::INPUT, module, Cmp::LAG_INPUT));
-
-		addOutput(createPort<Port24>(greaterOutputPosition, PortWidget::OUTPUT, module, Cmp::GREATER_OUTPUT));
-		addOutput(createPort<Port24>(lessOutputPosition, PortWidget::OUTPUT, module, Cmp::LESS_OUTPUT));
-		addOutput(createPort<Port24>(equalOutputPosition, PortWidget::OUTPUT, module, Cmp::EQUAL_OUTPUT));
-		addOutput(createPort<Port24>(notEqualOutputPosition, PortWidget::OUTPUT, module, Cmp::NOT_EQUAL_OUTPUT));
+		addInput(createInput<Port24>(aInputPosition, module, Cmp::A_INPUT));
+		addInput(createInput<Port24>(bInputPosition, module, Cmp::B_INPUT));
+		addInput(createInput<Port24>(windowInputPosition, module, Cmp::WINDOW_INPUT));
+		addInput(createInput<Port24>(lagInputPosition, module, Cmp::LAG_INPUT));
+
+		addOutput(createOutput<Port24>(greaterOutputPosition, module, Cmp::GREATER_OUTPUT));
+		addOutput(createOutput<Port24>(lessOutputPosition, module, Cmp::LESS_OUTPUT));
+		addOutput(createOutput<Port24>(equalOutputPosition, module, Cmp::EQUAL_OUTPUT));
+		addOutput(createOutput<Port24>(notEqualOutputPosition, module, Cmp::NOT_EQUAL_OUTPUT));
 	}
 };
 
diff --git a/src/DADSRH.cpp b/src/DADSRH.cpp
@@ -72,11 +72,11 @@ struct DADSRHWidget : ModuleWidget {
 		addParam(createParam<SliderSwitch2State14>(speedParamPosition, module, DADSRH::SPEED_PARAM, 0.0, 1.0, 1.0));
 		addParam(createParam<SliderSwitch2State14>(retriggerParamPosition, module, DADSRH::RETRIGGER_PARAM, 0.0, 1.0, 1.0));
 
-		addInput(createPort<Port24>(triggerInputPosition, PortWidget::INPUT, module, DADSRH::TRIGGER_INPUT));
+		addInput(createInput<Port24>(triggerInputPosition, module, DADSRH::TRIGGER_INPUT));
 
-		addOutput(createPort<Port24>(envOutputPosition, PortWidget::OUTPUT, module, DADSRH::ENV_OUTPUT));
-		addOutput(createPort<Port24>(invOutputPosition, PortWidget::OUTPUT, module, DADSRH::INV_OUTPUT));
-		addOutput(createPort<Port24>(triggerOutputPosition, PortWidget::OUTPUT, module, DADSRH::TRIGGER_OUTPUT));
+		addOutput(createOutput<Port24>(envOutputPosition, module, DADSRH::ENV_OUTPUT));
+		addOutput(createOutput<Port24>(invOutputPosition, module, DADSRH::INV_OUTPUT));
+		addOutput(createOutput<Port24>(triggerOutputPosition, module, DADSRH::TRIGGER_OUTPUT));
 
 		addChild(createLight<TinyLight<GreenLight>>(delayLightPosition, module, DADSRH::DELAY_LIGHT));
 		addChild(createLight<TinyLight<GreenLight>>(attackLightPosition, module, DADSRH::ATTACK_LIGHT));
diff --git a/src/DADSRHPlus.cpp b/src/DADSRHPlus.cpp
@@ -83,22 +83,22 @@ struct DADSRHPlusWidget : ModuleWidget {
 		addParam(createParam<SliderSwitch2State14>(speedParamPosition, module, DADSRHPlus::SPEED_PARAM, 0.0, 1.0, 1.0));
 		addParam(createParam<SliderSwitch2State14>(retriggerParamPosition, module, DADSRHPlus::RETRIGGER_PARAM, 0.0, 1.0, 1.0));
 
-		addInput(createPort<Port24>(delayInputPosition, PortWidget::INPUT, module, DADSRHPlus::DELAY_INPUT));
-		addInput(createPort<Port24>(attackInputPosition, PortWidget::INPUT, module, DADSRHPlus::ATTACK_INPUT));
-		addInput(createPort<Port24>(decayInputPosition, PortWidget::INPUT, module, DADSRHPlus::DECAY_INPUT));
-		addInput(createPort<Port24>(sustainInputPosition, PortWidget::INPUT, module, DADSRHPlus::SUSTAIN_INPUT));
-		addInput(createPort<Port24>(releaseInputPosition, PortWidget::INPUT, module, DADSRHPlus::RELEASE_INPUT));
-		addInput(createPort<Port24>(holdInputPosition, PortWidget::INPUT, module, DADSRHPlus::HOLD_INPUT));
-		addInput(createPort<Port24>(triggerInputPosition, PortWidget::INPUT, module, DADSRHPlus::TRIGGER_INPUT));
+		addInput(createInput<Port24>(delayInputPosition, module, DADSRHPlus::DELAY_INPUT));
+		addInput(createInput<Port24>(attackInputPosition, module, DADSRHPlus::ATTACK_INPUT));
+		addInput(createInput<Port24>(decayInputPosition, module, DADSRHPlus::DECAY_INPUT));
+		addInput(createInput<Port24>(sustainInputPosition, module, DADSRHPlus::SUSTAIN_INPUT));
+		addInput(createInput<Port24>(releaseInputPosition, module, DADSRHPlus::RELEASE_INPUT));
+		addInput(createInput<Port24>(holdInputPosition, module, DADSRHPlus::HOLD_INPUT));
+		addInput(createInput<Port24>(triggerInputPosition, module, DADSRHPlus::TRIGGER_INPUT));
 
-		addOutput(createPort<Port24>(delayOutputPosition, PortWidget::OUTPUT, module, DADSRHPlus::DELAY_OUTPUT));
-		addOutput(createPort<Port24>(attackOutputPosition, PortWidget::OUTPUT, module, DADSRHPlus::ATTACK_OUTPUT));
-		addOutput(createPort<Port24>(decayOutputPosition, PortWidget::OUTPUT, module, DADSRHPlus::DECAY_OUTPUT));
-		addOutput(createPort<Port24>(sustainOutputPosition, PortWidget::OUTPUT, module, DADSRHPlus::SUSTAIN_OUTPUT));
-		addOutput(createPort<Port24>(releaseOutputPosition, PortWidget::OUTPUT, module, DADSRHPlus::RELEASE_OUTPUT));
-		addOutput(createPort<Port24>(envOutputPosition, PortWidget::OUTPUT, module, DADSRHPlus::ENV_OUTPUT));
-		addOutput(createPort<Port24>(invOutputPosition, PortWidget::OUTPUT, module, DADSRHPlus::INV_OUTPUT));
-		addOutput(createPort<Port24>(triggerOutputPosition, PortWidget::OUTPUT, module, DADSRHPlus::TRIGGER_OUTPUT));
+		addOutput(createOutput<Port24>(delayOutputPosition, module, DADSRHPlus::DELAY_OUTPUT));
+		addOutput(createOutput<Port24>(attackOutputPosition, module, DADSRHPlus::ATTACK_OUTPUT));
+		addOutput(createOutput<Port24>(decayOutputPosition, module, DADSRHPlus::DECAY_OUTPUT));
+		addOutput(createOutput<Port24>(sustainOutputPosition, module, DADSRHPlus::SUSTAIN_OUTPUT));
+		addOutput(createOutput<Port24>(releaseOutputPosition, module, DADSRHPlus::RELEASE_OUTPUT));
+		addOutput(createOutput<Port24>(envOutputPosition, module, DADSRHPlus::ENV_OUTPUT));
+		addOutput(createOutput<Port24>(invOutputPosition, module, DADSRHPlus::INV_OUTPUT));
+		addOutput(createOutput<Port24>(triggerOutputPosition, module, DADSRHPlus::TRIGGER_OUTPUT));
 
 		addChild(createLight<TinyLight<GreenLight>>(delayLightPosition, module, DADSRHPlus::DELAY_LIGHT));
 		addChild(createLight<TinyLight<GreenLight>>(attackLightPosition, module, DADSRHPlus::ATTACK_LIGHT));
diff --git a/src/DGate.cpp b/src/DGate.cpp
@@ -106,10 +106,10 @@ struct DGateWidget : ModuleWidget {
 		addParam(createParam<SliderSwitch2State14>(loopParamPosition, module, DGate::LOOP_PARAM, 0.0, 1.0, 1.0));
 		addParam(createParam<Button18>(triggerParamPosition, module, DGate::TRIGGER_PARAM, 0.0, 1.0, 0.0));
 
-		addInput(createPort<Port24>(triggerInputPosition, PortWidget::INPUT, module, DGate::TRIGGER_INPUT));
+		addInput(createInput<Port24>(triggerInputPosition, module, DGate::TRIGGER_INPUT));
 
-		addOutput(createPort<Port24>(gateOutputPosition, PortWidget::OUTPUT, module, DGate::GATE_OUTPUT));
-		addOutput(createPort<Port24>(endOutputPosition, PortWidget::OUTPUT, module, DGate::END_OUTPUT));
+		addOutput(createOutput<Port24>(gateOutputPosition, module, DGate::GATE_OUTPUT));
+		addOutput(createOutput<Port24>(endOutputPosition, module, DGate::END_OUTPUT));
 
 		addChild(createLight<TinyLight<GreenLight>>(delayLightPosition, module, DGate::DELAY_LIGHT));
 		addChild(createLight<TinyLight<GreenLight>>(gateLightPosition, module, DGate::GATE_LIGHT));
diff --git a/src/Detune.cpp b/src/Detune.cpp
@@ -70,12 +70,12 @@ struct DetuneWidget : ModuleWidget {
 			addParam(w);
 		}
 
-		addInput(createPort<Port24>(cvInputPosition, PortWidget::INPUT, module, Detune::CV_INPUT));
-		addInput(createPort<Port24>(inInputPosition, PortWidget::INPUT, module, Detune::IN_INPUT));
+		addInput(createInput<Port24>(cvInputPosition, module, Detune::CV_INPUT));
+		addInput(createInput<Port24>(inInputPosition, module, Detune::IN_INPUT));
 
-		addOutput(createPort<Port24>(thruOutputPosition, PortWidget::OUTPUT, module, Detune::THRU_OUTPUT));
-		addOutput(createPort<Port24>(outPlusOutputPosition, PortWidget::OUTPUT, module, Detune::OUT_PLUS_OUTPUT));
-		addOutput(createPort<Port24>(outMinusOutputPosition, PortWidget::OUTPUT, module, Detune::OUT_MINUS_OUTPUT));
+		addOutput(createOutput<Port24>(thruOutputPosition, module, Detune::THRU_OUTPUT));
+		addOutput(createOutput<Port24>(outPlusOutputPosition, module, Detune::OUT_PLUS_OUTPUT));
+		addOutput(createOutput<Port24>(outMinusOutputPosition, module, Detune::OUT_MINUS_OUTPUT));
 	}
 };
 
diff --git a/src/EightFO.cpp b/src/EightFO.cpp
@@ -245,28 +245,28 @@ struct EightFOWidget : LFOBaseWidget {
 		addPhaseParam(phase1ParamPosition, module, EightFO::PHASE1_PARAM, Phasor::phaseToRadians(basePhase1Offset));
 		addPhaseParam(phase0ParamPosition, module, EightFO::PHASE0_PARAM, Phasor::phaseToRadians(basePhase0Offset));
 
-		addInput(createPort<Port24>(samplePwmInputPosition, PortWidget::INPUT, module, EightFO::SAMPLE_PWM_INPUT));
-		addInput(createPort<Port24>(offsetInputPosition, PortWidget::INPUT, module, EightFO::OFFSET_INPUT));
-		addInput(createPort<Port24>(scaleInputPosition, PortWidget::INPUT, module, EightFO::SCALE_INPUT));
-		addInput(createPort<Port24>(phase7InputPosition, PortWidget::INPUT, module, EightFO::PHASE7_INPUT));
-		addInput(createPort<Port24>(phase6InputPosition, PortWidget::INPUT, module, EightFO::PHASE6_INPUT));
-		addInput(createPort<Port24>(phase5InputPosition, PortWidget::INPUT, module, EightFO::PHASE5_INPUT));
-		addInput(createPort<Port24>(phase4InputPosition, PortWidget::INPUT, module, EightFO::PHASE4_INPUT));
-		addInput(createPort<Port24>(phase3InputPosition, PortWidget::INPUT, module, EightFO::PHASE3_INPUT));
-		addInput(createPort<Port24>(phase2InputPosition, PortWidget::INPUT, module, EightFO::PHASE2_INPUT));
-		addInput(createPort<Port24>(phase1InputPosition, PortWidget::INPUT, module, EightFO::PHASE1_INPUT));
-		addInput(createPort<Port24>(phase0InputPosition, PortWidget::INPUT, module, EightFO::PHASE0_INPUT));
-		addInput(createPort<Port24>(pitchInputPosition, PortWidget::INPUT, module, EightFO::PITCH_INPUT));
-		addInput(createPort<Port24>(resetInputPosition, PortWidget::INPUT, module, EightFO::RESET_INPUT));
+		addInput(createInput<Port24>(samplePwmInputPosition, module, EightFO::SAMPLE_PWM_INPUT));
+		addInput(createInput<Port24>(offsetInputPosition, module, EightFO::OFFSET_INPUT));
+		addInput(createInput<Port24>(scaleInputPosition, module, EightFO::SCALE_INPUT));
+		addInput(createInput<Port24>(phase7InputPosition, module, EightFO::PHASE7_INPUT));
+		addInput(createInput<Port24>(phase6InputPosition, module, EightFO::PHASE6_INPUT));
+		addInput(createInput<Port24>(phase5InputPosition, module, EightFO::PHASE5_INPUT));
+		addInput(createInput<Port24>(phase4InputPosition, module, EightFO::PHASE4_INPUT));
+		addInput(createInput<Port24>(phase3InputPosition, module, EightFO::PHASE3_INPUT));
+		addInput(createInput<Port24>(phase2InputPosition, module, EightFO::PHASE2_INPUT));
+		addInput(createInput<Port24>(phase1InputPosition, module, EightFO::PHASE1_INPUT));
+		addInput(createInput<Port24>(phase0InputPosition, module, EightFO::PHASE0_INPUT));
+		addInput(createInput<Port24>(pitchInputPosition, module, EightFO::PITCH_INPUT));
+		addInput(createInput<Port24>(resetInputPosition, module, EightFO::RESET_INPUT));
 
-		addOutput(createPort<Port24>(phase7OutputPosition, PortWidget::OUTPUT, module, EightFO::PHASE7_OUTPUT));
-		addOutput(createPort<Port24>(phase6OutputPosition, PortWidget::OUTPUT, module, EightFO::PHASE6_OUTPUT));
-		addOutput(createPort<Port24>(phase5OutputPosition, PortWidget::OUTPUT, module, EightFO::PHASE5_OUTPUT));
-		addOutput(createPort<Port24>(phase4OutputPosition, PortWidget::OUTPUT, module, EightFO::PHASE4_OUTPUT));
-		addOutput(createPort<Port24>(phase3OutputPosition, PortWidget::OUTPUT, module, EightFO::PHASE3_OUTPUT));
-		addOutput(createPort<Port24>(phase2OutputPosition, PortWidget::OUTPUT, module, EightFO::PHASE2_OUTPUT));
-		addOutput(createPort<Port24>(phase1OutputPosition, PortWidget::OUTPUT, module, EightFO::PHASE1_OUTPUT));
-		addOutput(createPort<Port24>(phase0OutputPosition, PortWidget::OUTPUT, module, EightFO::PHASE0_OUTPUT));
+		addOutput(createOutput<Port24>(phase7OutputPosition, module, EightFO::PHASE7_OUTPUT));
+		addOutput(createOutput<Port24>(phase6OutputPosition, module, EightFO::PHASE6_OUTPUT));
+		addOutput(createOutput<Port24>(phase5OutputPosition, module, EightFO::PHASE5_OUTPUT));
+		addOutput(createOutput<Port24>(phase4OutputPosition, module, EightFO::PHASE4_OUTPUT));
+		addOutput(createOutput<Port24>(phase3OutputPosition, module, EightFO::PHASE3_OUTPUT));
+		addOutput(createOutput<Port24>(phase2OutputPosition, module, EightFO::PHASE2_OUTPUT));
+		addOutput(createOutput<Port24>(phase1OutputPosition, module, EightFO::PHASE1_OUTPUT));
+		addOutput(createOutput<Port24>(phase0OutputPosition, module, EightFO::PHASE0_OUTPUT));
 
 		addChild(createLight<SmallLight<GreenLight>>(slowLightPosition, module, EightFO::SLOW_LIGHT));
 	}
diff --git a/src/EightOne.cpp b/src/EightOne.cpp
@@ -130,19 +130,19 @@ struct EightOneWidget : ModuleWidget {
 			addParam(w);
 		}
 
-		addInput(createPort<Port24>(in1InputPosition, PortWidget::INPUT, module, EightOne::IN1_INPUT));
-		addInput(createPort<Port24>(in2InputPosition, PortWidget::INPUT, module, EightOne::IN2_INPUT));
-		addInput(createPort<Port24>(in3InputPosition, PortWidget::INPUT, module, EightOne::IN3_INPUT));
-		addInput(createPort<Port24>(in4InputPosition, PortWidget::INPUT, module, EightOne::IN4_INPUT));
-		addInput(createPort<Port24>(in5InputPosition, PortWidget::INPUT, module, EightOne::IN5_INPUT));
-		addInput(createPort<Port24>(in6InputPosition, PortWidget::INPUT, module, EightOne::IN6_INPUT));
-		addInput(createPort<Port24>(in7InputPosition, PortWidget::INPUT, module, EightOne::IN7_INPUT));
-		addInput(createPort<Port24>(in8InputPosition, PortWidget::INPUT, module, EightOne::IN8_INPUT));
-		addInput(createPort<Port24>(clockInputPosition, PortWidget::INPUT, module, EightOne::CLOCK_INPUT));
-		addInput(createPort<Port24>(resetInputPosition, PortWidget::INPUT, module, EightOne::RESET_INPUT));
-		addInput(createPort<Port24>(selectInputPosition, PortWidget::INPUT, module, EightOne::SELECT_INPUT));
-
-		addOutput(createPort<Port24>(outOutputPosition, PortWidget::OUTPUT, module, EightOne::OUT_OUTPUT));
+		addInput(createInput<Port24>(in1InputPosition, module, EightOne::IN1_INPUT));
+		addInput(createInput<Port24>(in2InputPosition, module, EightOne::IN2_INPUT));
+		addInput(createInput<Port24>(in3InputPosition, module, EightOne::IN3_INPUT));
+		addInput(createInput<Port24>(in4InputPosition, module, EightOne::IN4_INPUT));
+		addInput(createInput<Port24>(in5InputPosition, module, EightOne::IN5_INPUT));
+		addInput(createInput<Port24>(in6InputPosition, module, EightOne::IN6_INPUT));
+		addInput(createInput<Port24>(in7InputPosition, module, EightOne::IN7_INPUT));
+		addInput(createInput<Port24>(in8InputPosition, module, EightOne::IN8_INPUT));
+		addInput(createInput<Port24>(clockInputPosition, module, EightOne::CLOCK_INPUT));
+		addInput(createInput<Port24>(resetInputPosition, module, EightOne::RESET_INPUT));
+		addInput(createInput<Port24>(selectInputPosition, module, EightOne::SELECT_INPUT));
+
+		addOutput(createOutput<Port24>(outOutputPosition, module, EightOne::OUT_OUTPUT));
 
 		addChild(createLight<SmallLight<GreenLight>>(in1LightPosition, module, EightOne::IN1_LIGHT));
 		addChild(createLight<SmallLight<GreenLight>>(in2LightPosition, module, EightOne::IN2_LIGHT));
diff --git a/src/FMOp.cpp b/src/FMOp.cpp
@@ -266,15 +266,15 @@ struct FMOpWidget : ModuleWidget {
 		addParam(createParam<StatefulButton9>(envToFeedbackParamPosition, module, FMOp::ENV_TO_FEEDBACK_PARAM, 0.0, 1.0, 0.0));
 		addParam(createParam<StatefulButton9>(envToDepthParamPosition, module, FMOp::ENV_TO_DEPTH_PARAM, 0.0, 1.0, 0.0));
 
-		addInput(createPort<Port24>(sustainInputPosition, PortWidget::INPUT, module, FMOp::SUSTAIN_INPUT));
-		addInput(createPort<Port24>(depthInputPosition, PortWidget::INPUT, module, FMOp::DEPTH_INPUT));
-		addInput(createPort<Port24>(feedbackInputPosition, PortWidget::INPUT, module, FMOp::FEEDBACK_INPUT));
-		addInput(createPort<Port24>(levelInputPosition, PortWidget::INPUT, module, FMOp::LEVEL_INPUT));
-		addInput(createPort<Port24>(pitchInputPosition, PortWidget::INPUT, module, FMOp::PITCH_INPUT));
-		addInput(createPort<Port24>(gateInputPosition, PortWidget::INPUT, module, FMOp::GATE_INPUT));
-		addInput(createPort<Port24>(fmInputPosition, PortWidget::INPUT, module, FMOp::FM_INPUT));
-
-		addOutput(createPort<Port24>(audioOutputPosition, PortWidget::OUTPUT, module, FMOp::AUDIO_OUTPUT));
+		addInput(createInput<Port24>(sustainInputPosition, module, FMOp::SUSTAIN_INPUT));
+		addInput(createInput<Port24>(depthInputPosition, module, FMOp::DEPTH_INPUT));
+		addInput(createInput<Port24>(feedbackInputPosition, module, FMOp::FEEDBACK_INPUT));
+		addInput(createInput<Port24>(levelInputPosition, module, FMOp::LEVEL_INPUT));
+		addInput(createInput<Port24>(pitchInputPosition, module, FMOp::PITCH_INPUT));
+		addInput(createInput<Port24>(gateInputPosition, module, FMOp::GATE_INPUT));
+		addInput(createInput<Port24>(fmInputPosition, module, FMOp::FM_INPUT));
+
+		addOutput(createOutput<Port24>(audioOutputPosition, module, FMOp::AUDIO_OUTPUT));
 
 		addChild(createLight<SmallLight<GreenLight>>(envToLevelLightPosition, module, FMOp::ENV_TO_LEVEL_LIGHT));
 		addChild(createLight<SmallLight<GreenLight>>(envToFeedbackLightPosition, module, FMOp::ENV_TO_FEEDBACK_LIGHT));
diff --git a/src/FlipFlop.cpp b/src/FlipFlop.cpp
@@ -87,15 +87,15 @@ struct FlipFlopWidget : ModuleWidget {
 		auto b2OutputPosition = Vec(10.5, 280.0);
 		// end generated by svg_widgets.rb
 
-		addInput(createPort<Port24>(in1InputPosition, PortWidget::INPUT, module, FlipFlop::IN1_INPUT));
-		addInput(createPort<Port24>(reset1InputPosition, PortWidget::INPUT, module, FlipFlop::RESET1_INPUT));
-		addInput(createPort<Port24>(in2InputPosition, PortWidget::INPUT, module, FlipFlop::IN2_INPUT));
-		addInput(createPort<Port24>(reset2InputPosition, PortWidget::INPUT, module, FlipFlop::RESET2_INPUT));
+		addInput(createInput<Port24>(in1InputPosition, module, FlipFlop::IN1_INPUT));
+		addInput(createInput<Port24>(reset1InputPosition, module, FlipFlop::RESET1_INPUT));
+		addInput(createInput<Port24>(in2InputPosition, module, FlipFlop::IN2_INPUT));
+		addInput(createInput<Port24>(reset2InputPosition, module, FlipFlop::RESET2_INPUT));
 
-		addOutput(createPort<Port24>(a1OutputPosition, PortWidget::OUTPUT, module, FlipFlop::A1_OUTPUT));
-		addOutput(createPort<Port24>(b1OutputPosition, PortWidget::OUTPUT, module, FlipFlop::B1_OUTPUT));
-		addOutput(createPort<Port24>(a2OutputPosition, PortWidget::OUTPUT, module, FlipFlop::A2_OUTPUT));
-		addOutput(createPort<Port24>(b2OutputPosition, PortWidget::OUTPUT, module, FlipFlop::B2_OUTPUT));
+		addOutput(createOutput<Port24>(a1OutputPosition, module, FlipFlop::A1_OUTPUT));
+		addOutput(createOutput<Port24>(b1OutputPosition, module, FlipFlop::B1_OUTPUT));
+		addOutput(createOutput<Port24>(a2OutputPosition, module, FlipFlop::A2_OUTPUT));
+		addOutput(createOutput<Port24>(b2OutputPosition, module, FlipFlop::B2_OUTPUT));
 	}
 };
 
diff --git a/src/Follow.cpp b/src/Follow.cpp
@@ -52,11 +52,11 @@ struct FollowWidget : ModuleWidget {
 		addParam(createParam<Knob29>(responseParamPosition, module, Follow::RESPONSE_PARAM, 0.0, 1.0, 0.3));
 		addParam(createParam<Knob29>(scaleParamPosition, module, Follow::SCALE_PARAM, 0.0, 1.0, 1.0));
 
-		addInput(createPort<Port24>(responseInputPosition, PortWidget::INPUT, module, Follow::RESPONSE_INPUT));
-		addInput(createPort<Port24>(scaleInputPosition, PortWidget::INPUT, module, Follow::SCALE_INPUT));
-		addInput(createPort<Port24>(inInputPosition, PortWidget::INPUT, module, Follow::IN_INPUT));
+		addInput(createInput<Port24>(responseInputPosition, module, Follow::RESPONSE_INPUT));
+		addInput(createInput<Port24>(scaleInputPosition, module, Follow::SCALE_INPUT));
+		addInput(createInput<Port24>(inInputPosition, module, Follow::IN_INPUT));
 
-		addOutput(createPort<Port24>(outOutputPosition, PortWidget::OUTPUT, module, Follow::OUT_OUTPUT));
+		addOutput(createOutput<Port24>(outOutputPosition, module, Follow::OUT_OUTPUT));
 	}
 };
 
diff --git a/src/LFO.cpp b/src/LFO.cpp
@@ -152,18 +152,18 @@ struct LFOWidget : LFOBaseWidget {
 		addParam(createParam<Knob16>(offsetParamPosition, module, LFO::OFFSET_PARAM, -1.0, 1.0, 0.0));
 		addParam(createParam<Knob16>(scaleParamPosition, module, LFO::SCALE_PARAM, 0.0, 1.0, 1.0));
 
-		addInput(createPort<Port24>(sampleInputPosition, PortWidget::INPUT, module, LFO::SAMPLE_INPUT));
-		addInput(createPort<Port24>(pwInputPosition, PortWidget::INPUT, module, LFO::PW_INPUT));
-		addInput(createPort<Port24>(offsetInputPosition, PortWidget::INPUT, module, LFO::OFFSET_INPUT));
-		addInput(createPort<Port24>(scaleInputPosition, PortWidget::INPUT, module, LFO::SCALE_INPUT));
-		addInput(createPort<Port24>(pitchInputPosition, PortWidget::INPUT, module, LFO::PITCH_INPUT));
-		addInput(createPort<Port24>(resetInputPosition, PortWidget::INPUT, module, LFO::RESET_INPUT));
-
-		addOutput(createPort<Port24>(rampUpOutputPosition, PortWidget::OUTPUT, module, LFO::RAMP_UP_OUTPUT));
-		addOutput(createPort<Port24>(rampDownOutputPosition, PortWidget::OUTPUT, module, LFO::RAMP_DOWN_OUTPUT));
-		addOutput(createPort<Port24>(squareOutputPosition, PortWidget::OUTPUT, module, LFO::SQUARE_OUTPUT));
-		addOutput(createPort<Port24>(triangleOutputPosition, PortWidget::OUTPUT, module, LFO::TRIANGLE_OUTPUT));
-		addOutput(createPort<Port24>(sineOutputPosition, PortWidget::OUTPUT, module, LFO::SINE_OUTPUT));
+		addInput(createInput<Port24>(sampleInputPosition, module, LFO::SAMPLE_INPUT));
+		addInput(createInput<Port24>(pwInputPosition, module, LFO::PW_INPUT));
+		addInput(createInput<Port24>(offsetInputPosition, module, LFO::OFFSET_INPUT));
+		addInput(createInput<Port24>(scaleInputPosition, module, LFO::SCALE_INPUT));
+		addInput(createInput<Port24>(pitchInputPosition, module, LFO::PITCH_INPUT));
+		addInput(createInput<Port24>(resetInputPosition, module, LFO::RESET_INPUT));
+
+		addOutput(createOutput<Port24>(rampUpOutputPosition, module, LFO::RAMP_UP_OUTPUT));
+		addOutput(createOutput<Port24>(rampDownOutputPosition, module, LFO::RAMP_DOWN_OUTPUT));
+		addOutput(createOutput<Port24>(squareOutputPosition, module, LFO::SQUARE_OUTPUT));
+		addOutput(createOutput<Port24>(triangleOutputPosition, module, LFO::TRIANGLE_OUTPUT));
+		addOutput(createOutput<Port24>(sineOutputPosition, module, LFO::SINE_OUTPUT));
 
 		addChild(createLight<SmallLight<GreenLight>>(slowLightPosition, module, LFO::SLOW_LIGHT));
 	}
diff --git a/src/LLFO.cpp b/src/LLFO.cpp
@@ -123,10 +123,10 @@ struct LLFOWidget : LFOBaseWidget {
 		addParam(createParam<Knob16>(offsetParamPosition, module, LLFO::OFFSET_PARAM, -1.0, 1.0, 0.0));
 		addParam(createParam<Knob16>(scaleParamPosition, module, LLFO::SCALE_PARAM, 0.0, 1.0, 1.0));
 
-		addInput(createPort<Port24>(pitchInputPosition, PortWidget::INPUT, module, LLFO::PITCH_INPUT));
-		addInput(createPort<Port24>(resetInputPosition, PortWidget::INPUT, module, LLFO::RESET_INPUT));
+		addInput(createInput<Port24>(pitchInputPosition, module, LLFO::PITCH_INPUT));
+		addInput(createInput<Port24>(resetInputPosition, module, LLFO::RESET_INPUT));
 
-		addOutput(createPort<Port24>(outOutputPosition, PortWidget::OUTPUT, module, LLFO::OUT_OUTPUT));
+		addOutput(createOutput<Port24>(outOutputPosition, module, LLFO::OUT_OUTPUT));
 
 		addChild(createLight<SmallLight<GreenLight>>(slowLightPosition, module, LLFO::SLOW_LIGHT));
 		addChild(createLight<SmallLight<GreenLight>>(sineLightPosition, module, LLFO::SINE_LIGHT));
diff --git a/src/Lag.cpp b/src/Lag.cpp
@@ -89,11 +89,11 @@ struct LagWidget : ModuleWidget {
 		}
 		addParam(createParam<Knob29>(shapeParamPosition, module, Lag::SHAPE_PARAM, -1.0, 1.0, 0.0));
 
-		addInput(createPort<Port24>(timeInputPosition, PortWidget::INPUT, module, Lag::TIME_INPUT));
-		addInput(createPort<Port24>(shapeInputPosition, PortWidget::INPUT, module, Lag::SHAPE_INPUT));
-		addInput(createPort<Port24>(inInputPosition, PortWidget::INPUT, module, Lag::IN_INPUT));
+		addInput(createInput<Port24>(timeInputPosition, module, Lag::TIME_INPUT));
+		addInput(createInput<Port24>(shapeInputPosition, module, Lag::SHAPE_INPUT));
+		addInput(createInput<Port24>(inInputPosition, module, Lag::IN_INPUT));
 
-		addOutput(createPort<Port24>(outOutputPosition, PortWidget::OUTPUT, module, Lag::OUT_OUTPUT));
+		addOutput(createOutput<Port24>(outOutputPosition, module, Lag::OUT_OUTPUT));
 	}
 };
 
diff --git a/src/Lmtr.cpp b/src/Lmtr.cpp
@@ -98,13 +98,13 @@ struct LmtrWidget : ModuleWidget {
 		addParam(createParam<Knob38>(outputGainParamPosition, module, Lmtr::OUTPUT_GAIN_PARAM, 0.0, 1.0, 0.0));
 		addParam(createParam<SliderSwitch2State14>(kneeParamPosition, module, Lmtr::KNEE_PARAM, 0.95, 1.0, 0.0));
 
-		addInput(createPort<Port24>(leftInputPosition, PortWidget::INPUT, module, Lmtr::LEFT_INPUT));
-		addInput(createPort<Port24>(rightInputPosition, PortWidget::INPUT, module, Lmtr::RIGHT_INPUT));
-		addInput(createPort<Port24>(thresholdInputPosition, PortWidget::INPUT, module, Lmtr::THRESHOLD_INPUT));
-		addInput(createPort<Port24>(outputGainInputPosition, PortWidget::INPUT, module, Lmtr::OUTPUT_GAIN_INPUT));
+		addInput(createInput<Port24>(leftInputPosition, module, Lmtr::LEFT_INPUT));
+		addInput(createInput<Port24>(rightInputPosition, module, Lmtr::RIGHT_INPUT));
+		addInput(createInput<Port24>(thresholdInputPosition, module, Lmtr::THRESHOLD_INPUT));
+		addInput(createInput<Port24>(outputGainInputPosition, module, Lmtr::OUTPUT_GAIN_INPUT));
 
-		addOutput(createPort<Port24>(leftOutputPosition, PortWidget::OUTPUT, module, Lmtr::LEFT_OUTPUT));
-		addOutput(createPort<Port24>(rightOutputPosition, PortWidget::OUTPUT, module, Lmtr::RIGHT_OUTPUT));
+		addOutput(createOutput<Port24>(leftOutputPosition, module, Lmtr::LEFT_OUTPUT));
+		addOutput(createOutput<Port24>(rightOutputPosition, module, Lmtr::RIGHT_OUTPUT));
 	}
 };
 
diff --git a/src/Manual.cpp b/src/Manual.cpp
@@ -60,14 +60,14 @@ struct ManualWidget : ModuleWidget {
 
 		addParam(createParam<Button18>(triggerParamPosition, module, Manual::TRIGGER_PARAM, 0.0, 1.0, 0.0));
 
-		addOutput(createPort<Port24>(out1OutputPosition, PortWidget::OUTPUT, module, Manual::OUT1_OUTPUT));
-		addOutput(createPort<Port24>(out2OutputPosition, PortWidget::OUTPUT, module, Manual::OUT2_OUTPUT));
-		addOutput(createPort<Port24>(out3OutputPosition, PortWidget::OUTPUT, module, Manual::OUT3_OUTPUT));
-		addOutput(createPort<Port24>(out4OutputPosition, PortWidget::OUTPUT, module, Manual::OUT4_OUTPUT));
-		addOutput(createPort<Port24>(out5OutputPosition, PortWidget::OUTPUT, module, Manual::OUT5_OUTPUT));
-		addOutput(createPort<Port24>(out6OutputPosition, PortWidget::OUTPUT, module, Manual::OUT6_OUTPUT));
-		addOutput(createPort<Port24>(out7OutputPosition, PortWidget::OUTPUT, module, Manual::OUT7_OUTPUT));
-		addOutput(createPort<Port24>(out8OutputPosition, PortWidget::OUTPUT, module, Manual::OUT8_OUTPUT));
+		addOutput(createOutput<Port24>(out1OutputPosition, module, Manual::OUT1_OUTPUT));
+		addOutput(createOutput<Port24>(out2OutputPosition, module, Manual::OUT2_OUTPUT));
+		addOutput(createOutput<Port24>(out3OutputPosition, module, Manual::OUT3_OUTPUT));
+		addOutput(createOutput<Port24>(out4OutputPosition, module, Manual::OUT4_OUTPUT));
+		addOutput(createOutput<Port24>(out5OutputPosition, module, Manual::OUT5_OUTPUT));
+		addOutput(createOutput<Port24>(out6OutputPosition, module, Manual::OUT6_OUTPUT));
+		addOutput(createOutput<Port24>(out7OutputPosition, module, Manual::OUT7_OUTPUT));
+		addOutput(createOutput<Port24>(out8OutputPosition, module, Manual::OUT8_OUTPUT));
 	}
 
 	void appendContextMenu(Menu* menu) override {
diff --git a/src/Matrix88.cpp b/src/Matrix88.cpp
@@ -182,23 +182,23 @@ struct Matrix88Widget : ModuleWidget {
 		addParam(createParam<Knob19>(mix88ParamPosition, module, Matrix88::MIX88_PARAM, -1.0, 1.0, 0.0));
 		addParam(createParam<Knob16>(levelParamPosition, module, Matrix88::LEVEL_PARAM, 0.0, 1.0, 1.0));
 
-		addInput(createPort<Port24>(in1InputPosition, PortWidget::INPUT, module, Matrix88::IN1_INPUT));
-		addInput(createPort<Port24>(in2InputPosition, PortWidget::INPUT, module, Matrix88::IN2_INPUT));
-		addInput(createPort<Port24>(in3InputPosition, PortWidget::INPUT, module, Matrix88::IN3_INPUT));
-		addInput(createPort<Port24>(in4InputPosition, PortWidget::INPUT, module, Matrix88::IN4_INPUT));
-		addInput(createPort<Port24>(in5InputPosition, PortWidget::INPUT, module, Matrix88::IN5_INPUT));
-		addInput(createPort<Port24>(in6InputPosition, PortWidget::INPUT, module, Matrix88::IN6_INPUT));
-		addInput(createPort<Port24>(in7InputPosition, PortWidget::INPUT, module, Matrix88::IN7_INPUT));
-		addInput(createPort<Port24>(in8InputPosition, PortWidget::INPUT, module, Matrix88::IN8_INPUT));
+		addInput(createInput<Port24>(in1InputPosition, module, Matrix88::IN1_INPUT));
+		addInput(createInput<Port24>(in2InputPosition, module, Matrix88::IN2_INPUT));
+		addInput(createInput<Port24>(in3InputPosition, module, Matrix88::IN3_INPUT));
+		addInput(createInput<Port24>(in4InputPosition, module, Matrix88::IN4_INPUT));
+		addInput(createInput<Port24>(in5InputPosition, module, Matrix88::IN5_INPUT));
+		addInput(createInput<Port24>(in6InputPosition, module, Matrix88::IN6_INPUT));
+		addInput(createInput<Port24>(in7InputPosition, module, Matrix88::IN7_INPUT));
+		addInput(createInput<Port24>(in8InputPosition, module, Matrix88::IN8_INPUT));
 
-		addOutput(createPort<Port24>(out1OutputPosition, PortWidget::OUTPUT, module, Matrix88::OUT1_OUTPUT));
-		addOutput(createPort<Port24>(out2OutputPosition, PortWidget::OUTPUT, module, Matrix88::OUT2_OUTPUT));
-		addOutput(createPort<Port24>(out3OutputPosition, PortWidget::OUTPUT, module, Matrix88::OUT3_OUTPUT));
-		addOutput(createPort<Port24>(out4OutputPosition, PortWidget::OUTPUT, module, Matrix88::OUT4_OUTPUT));
-		addOutput(createPort<Port24>(out5OutputPosition, PortWidget::OUTPUT, module, Matrix88::OUT5_OUTPUT));
-		addOutput(createPort<Port24>(out6OutputPosition, PortWidget::OUTPUT, module, Matrix88::OUT6_OUTPUT));
-		addOutput(createPort<Port24>(out7OutputPosition, PortWidget::OUTPUT, module, Matrix88::OUT7_OUTPUT));
-		addOutput(createPort<Port24>(out8OutputPosition, PortWidget::OUTPUT, module, Matrix88::OUT8_OUTPUT));
+		addOutput(createOutput<Port24>(out1OutputPosition, module, Matrix88::OUT1_OUTPUT));
+		addOutput(createOutput<Port24>(out2OutputPosition, module, Matrix88::OUT2_OUTPUT));
+		addOutput(createOutput<Port24>(out3OutputPosition, module, Matrix88::OUT3_OUTPUT));
+		addOutput(createOutput<Port24>(out4OutputPosition, module, Matrix88::OUT4_OUTPUT));
+		addOutput(createOutput<Port24>(out5OutputPosition, module, Matrix88::OUT5_OUTPUT));
+		addOutput(createOutput<Port24>(out6OutputPosition, module, Matrix88::OUT6_OUTPUT));
+		addOutput(createOutput<Port24>(out7OutputPosition, module, Matrix88::OUT7_OUTPUT));
+		addOutput(createOutput<Port24>(out8OutputPosition, module, Matrix88::OUT8_OUTPUT));
 	}
 };
 
diff --git a/src/Mix1.cpp b/src/Mix1.cpp
@@ -53,11 +53,11 @@ struct Mix1Widget : ModuleWidget {
 		}
 		addParam(createParam<MuteButton>(muteParamPosition, module, Mix1::MUTE_PARAM, 0.0, 1.0, 0.0));
 
-		addInput(createPort<Port24>(muteInputPosition, PortWidget::INPUT, module, Mix1::MUTE_INPUT));
-		addInput(createPort<Port24>(levelInputPosition, PortWidget::INPUT, module, Mix1::LEVEL_INPUT));
-		addInput(createPort<Port24>(inInputPosition, PortWidget::INPUT, module, Mix1::IN_INPUT));
+		addInput(createInput<Port24>(muteInputPosition, module, Mix1::MUTE_INPUT));
+		addInput(createInput<Port24>(levelInputPosition, module, Mix1::LEVEL_INPUT));
+		addInput(createInput<Port24>(inInputPosition, module, Mix1::IN_INPUT));
 
-		addOutput(createPort<Port24>(outOutputPosition, PortWidget::OUTPUT, module, Mix1::OUT_OUTPUT));
+		addOutput(createOutput<Port24>(outOutputPosition, module, Mix1::OUT_OUTPUT));
 	}
 };
 
diff --git a/src/Mix4.cpp b/src/Mix4.cpp
@@ -134,22 +134,22 @@ struct Mix4Widget : ModuleWidget {
 		addSlider(mixParamPosition, module, Mix4::MIX_PARAM, module ? &module->_rmsLevel : NULL);
 		addParam(createParam<MuteButton>(mixMuteParamPosition, module, Mix4::MIX_MUTE_PARAM, 0.0, 1.0, 0.0));
 
-		addInput(createPort<Port24>(cv1InputPosition, PortWidget::INPUT, module, Mix4::CV1_INPUT));
-		addInput(createPort<Port24>(pan1InputPosition, PortWidget::INPUT, module, Mix4::PAN1_INPUT));
-		addInput(createPort<Port24>(in1InputPosition, PortWidget::INPUT, module, Mix4::IN1_INPUT));
-		addInput(createPort<Port24>(cv2InputPosition, PortWidget::INPUT, module, Mix4::CV2_INPUT));
-		addInput(createPort<Port24>(pan2InputPosition, PortWidget::INPUT, module, Mix4::PAN2_INPUT));
-		addInput(createPort<Port24>(in2InputPosition, PortWidget::INPUT, module, Mix4::IN2_INPUT));
-		addInput(createPort<Port24>(cv3InputPosition, PortWidget::INPUT, module, Mix4::CV3_INPUT));
-		addInput(createPort<Port24>(pan3InputPosition, PortWidget::INPUT, module, Mix4::PAN3_INPUT));
-		addInput(createPort<Port24>(in3InputPosition, PortWidget::INPUT, module, Mix4::IN3_INPUT));
-		addInput(createPort<Port24>(cv4InputPosition, PortWidget::INPUT, module, Mix4::CV4_INPUT));
-		addInput(createPort<Port24>(pan4InputPosition, PortWidget::INPUT, module, Mix4::PAN4_INPUT));
-		addInput(createPort<Port24>(in4InputPosition, PortWidget::INPUT, module, Mix4::IN4_INPUT));
-		addInput(createPort<Port24>(mixCvInputPosition, PortWidget::INPUT, module, Mix4::MIX_CV_INPUT));
-
-		addOutput(createPort<Port24>(lOutputPosition, PortWidget::OUTPUT, module, Mix4::L_OUTPUT));
-		addOutput(createPort<Port24>(rOutputPosition, PortWidget::OUTPUT, module, Mix4::R_OUTPUT));
+		addInput(createInput<Port24>(cv1InputPosition, module, Mix4::CV1_INPUT));
+		addInput(createInput<Port24>(pan1InputPosition, module, Mix4::PAN1_INPUT));
+		addInput(createInput<Port24>(in1InputPosition, module, Mix4::IN1_INPUT));
+		addInput(createInput<Port24>(cv2InputPosition, module, Mix4::CV2_INPUT));
+		addInput(createInput<Port24>(pan2InputPosition, module, Mix4::PAN2_INPUT));
+		addInput(createInput<Port24>(in2InputPosition, module, Mix4::IN2_INPUT));
+		addInput(createInput<Port24>(cv3InputPosition, module, Mix4::CV3_INPUT));
+		addInput(createInput<Port24>(pan3InputPosition, module, Mix4::PAN3_INPUT));
+		addInput(createInput<Port24>(in3InputPosition, module, Mix4::IN3_INPUT));
+		addInput(createInput<Port24>(cv4InputPosition, module, Mix4::CV4_INPUT));
+		addInput(createInput<Port24>(pan4InputPosition, module, Mix4::PAN4_INPUT));
+		addInput(createInput<Port24>(in4InputPosition, module, Mix4::IN4_INPUT));
+		addInput(createInput<Port24>(mixCvInputPosition, module, Mix4::MIX_CV_INPUT));
+
+		addOutput(createOutput<Port24>(lOutputPosition, module, Mix4::L_OUTPUT));
+		addOutput(createOutput<Port24>(rOutputPosition, module, Mix4::R_OUTPUT));
 	}
 
 	void addSlider(Vec position, Mix4* module, int id, float* rms) {
diff --git a/src/Mix8.cpp b/src/Mix8.cpp
@@ -194,34 +194,34 @@ struct Mix8Widget : ModuleWidget {
 		addSlider(mixParamPosition, module, Mix8::MIX_PARAM, module ? &module->_rmsLevel : NULL);
 		addParam(createParam<MuteButton>(mixMuteParamPosition, module, Mix8::MIX_MUTE_PARAM, 0.0, 1.0, 0.0));
 
-		addInput(createPort<Port24>(cv1InputPosition, PortWidget::INPUT, module, Mix8::CV1_INPUT));
-		addInput(createPort<Port24>(pan1InputPosition, PortWidget::INPUT, module, Mix8::PAN1_INPUT));
-		addInput(createPort<Port24>(in1InputPosition, PortWidget::INPUT, module, Mix8::IN1_INPUT));
-		addInput(createPort<Port24>(cv2InputPosition, PortWidget::INPUT, module, Mix8::CV2_INPUT));
-		addInput(createPort<Port24>(pan2InputPosition, PortWidget::INPUT, module, Mix8::PAN2_INPUT));
-		addInput(createPort<Port24>(in2InputPosition, PortWidget::INPUT, module, Mix8::IN2_INPUT));
-		addInput(createPort<Port24>(cv3InputPosition, PortWidget::INPUT, module, Mix8::CV3_INPUT));
-		addInput(createPort<Port24>(pan3InputPosition, PortWidget::INPUT, module, Mix8::PAN3_INPUT));
-		addInput(createPort<Port24>(in3InputPosition, PortWidget::INPUT, module, Mix8::IN3_INPUT));
-		addInput(createPort<Port24>(cv4InputPosition, PortWidget::INPUT, module, Mix8::CV4_INPUT));
-		addInput(createPort<Port24>(pan4InputPosition, PortWidget::INPUT, module, Mix8::PAN4_INPUT));
-		addInput(createPort<Port24>(in4InputPosition, PortWidget::INPUT, module, Mix8::IN4_INPUT));
-		addInput(createPort<Port24>(cv5InputPosition, PortWidget::INPUT, module, Mix8::CV5_INPUT));
-		addInput(createPort<Port24>(pan5InputPosition, PortWidget::INPUT, module, Mix8::PAN5_INPUT));
-		addInput(createPort<Port24>(in5InputPosition, PortWidget::INPUT, module, Mix8::IN5_INPUT));
-		addInput(createPort<Port24>(cv6InputPosition, PortWidget::INPUT, module, Mix8::CV6_INPUT));
-		addInput(createPort<Port24>(pan6InputPosition, PortWidget::INPUT, module, Mix8::PAN6_INPUT));
-		addInput(createPort<Port24>(in6InputPosition, PortWidget::INPUT, module, Mix8::IN6_INPUT));
-		addInput(createPort<Port24>(cv7InputPosition, PortWidget::INPUT, module, Mix8::CV7_INPUT));
-		addInput(createPort<Port24>(pan7InputPosition, PortWidget::INPUT, module, Mix8::PAN7_INPUT));
-		addInput(createPort<Port24>(in7InputPosition, PortWidget::INPUT, module, Mix8::IN7_INPUT));
-		addInput(createPort<Port24>(cv8InputPosition, PortWidget::INPUT, module, Mix8::CV8_INPUT));
-		addInput(createPort<Port24>(pan8InputPosition, PortWidget::INPUT, module, Mix8::PAN8_INPUT));
-		addInput(createPort<Port24>(in8InputPosition, PortWidget::INPUT, module, Mix8::IN8_INPUT));
-		addInput(createPort<Port24>(mixCvInputPosition, PortWidget::INPUT, module, Mix8::MIX_CV_INPUT));
-
-		addOutput(createPort<Port24>(lOutputPosition, PortWidget::OUTPUT, module, Mix8::L_OUTPUT));
-		addOutput(createPort<Port24>(rOutputPosition, PortWidget::OUTPUT, module, Mix8::R_OUTPUT));
+		addInput(createInput<Port24>(cv1InputPosition, module, Mix8::CV1_INPUT));
+		addInput(createInput<Port24>(pan1InputPosition, module, Mix8::PAN1_INPUT));
+		addInput(createInput<Port24>(in1InputPosition, module, Mix8::IN1_INPUT));
+		addInput(createInput<Port24>(cv2InputPosition, module, Mix8::CV2_INPUT));
+		addInput(createInput<Port24>(pan2InputPosition, module, Mix8::PAN2_INPUT));
+		addInput(createInput<Port24>(in2InputPosition, module, Mix8::IN2_INPUT));
+		addInput(createInput<Port24>(cv3InputPosition, module, Mix8::CV3_INPUT));
+		addInput(createInput<Port24>(pan3InputPosition, module, Mix8::PAN3_INPUT));
+		addInput(createInput<Port24>(in3InputPosition, module, Mix8::IN3_INPUT));
+		addInput(createInput<Port24>(cv4InputPosition, module, Mix8::CV4_INPUT));
+		addInput(createInput<Port24>(pan4InputPosition, module, Mix8::PAN4_INPUT));
+		addInput(createInput<Port24>(in4InputPosition, module, Mix8::IN4_INPUT));
+		addInput(createInput<Port24>(cv5InputPosition, module, Mix8::CV5_INPUT));
+		addInput(createInput<Port24>(pan5InputPosition, module, Mix8::PAN5_INPUT));
+		addInput(createInput<Port24>(in5InputPosition, module, Mix8::IN5_INPUT));
+		addInput(createInput<Port24>(cv6InputPosition, module, Mix8::CV6_INPUT));
+		addInput(createInput<Port24>(pan6InputPosition, module, Mix8::PAN6_INPUT));
+		addInput(createInput<Port24>(in6InputPosition, module, Mix8::IN6_INPUT));
+		addInput(createInput<Port24>(cv7InputPosition, module, Mix8::CV7_INPUT));
+		addInput(createInput<Port24>(pan7InputPosition, module, Mix8::PAN7_INPUT));
+		addInput(createInput<Port24>(in7InputPosition, module, Mix8::IN7_INPUT));
+		addInput(createInput<Port24>(cv8InputPosition, module, Mix8::CV8_INPUT));
+		addInput(createInput<Port24>(pan8InputPosition, module, Mix8::PAN8_INPUT));
+		addInput(createInput<Port24>(in8InputPosition, module, Mix8::IN8_INPUT));
+		addInput(createInput<Port24>(mixCvInputPosition, module, Mix8::MIX_CV_INPUT));
+
+		addOutput(createOutput<Port24>(lOutputPosition, module, Mix8::L_OUTPUT));
+		addOutput(createOutput<Port24>(rOutputPosition, module, Mix8::R_OUTPUT));
 	}
 
 	void addSlider(Vec position, Mix8* module, int id, float* rms) {
diff --git a/src/Mult.cpp b/src/Mult.cpp
@@ -43,15 +43,15 @@ struct MultWidget : ModuleWidget {
 		auto outb3OutputPosition = Vec(10.5, 282.0);
 		// end generated by svg_widgets.rb
 
-		addInput(createPort<Port24>(inaInputPosition, PortWidget::INPUT, module, Mult::INA_INPUT));
-		addInput(createPort<Port24>(inbInputPosition, PortWidget::INPUT, module, Mult::INB_INPUT));
-
-		addOutput(createPort<Port24>(outa1OutputPosition, PortWidget::OUTPUT, module, Mult::OUTA1_OUTPUT));
-		addOutput(createPort<Port24>(outa2OutputPosition, PortWidget::OUTPUT, module, Mult::OUTA2_OUTPUT));
-		addOutput(createPort<Port24>(outa3OutputPosition, PortWidget::OUTPUT, module, Mult::OUTA3_OUTPUT));
-		addOutput(createPort<Port24>(outb1OutputPosition, PortWidget::OUTPUT, module, Mult::OUTB1_OUTPUT));
-		addOutput(createPort<Port24>(outb2OutputPosition, PortWidget::OUTPUT, module, Mult::OUTB2_OUTPUT));
-		addOutput(createPort<Port24>(outb3OutputPosition, PortWidget::OUTPUT, module, Mult::OUTB3_OUTPUT));
+		addInput(createInput<Port24>(inaInputPosition, module, Mult::INA_INPUT));
+		addInput(createInput<Port24>(inbInputPosition, module, Mult::INB_INPUT));
+
+		addOutput(createOutput<Port24>(outa1OutputPosition, module, Mult::OUTA1_OUTPUT));
+		addOutput(createOutput<Port24>(outa2OutputPosition, module, Mult::OUTA2_OUTPUT));
+		addOutput(createOutput<Port24>(outa3OutputPosition, module, Mult::OUTA3_OUTPUT));
+		addOutput(createOutput<Port24>(outb1OutputPosition, module, Mult::OUTB1_OUTPUT));
+		addOutput(createOutput<Port24>(outb2OutputPosition, module, Mult::OUTB2_OUTPUT));
+		addOutput(createOutput<Port24>(outb3OutputPosition, module, Mult::OUTB3_OUTPUT));
 	}
 };
 
diff --git a/src/Mute8.cpp b/src/Mute8.cpp
@@ -116,31 +116,31 @@ struct Mute8Widget : ModuleWidget {
 		addParam(createParam<SoloMuteButton>(mute7ParamPosition, module, Mute8::MUTE7_PARAM, 0.0, 3.0, 0.0));
 		addParam(createParam<SoloMuteButton>(mute8ParamPosition, module, Mute8::MUTE8_PARAM, 0.0, 3.0, 0.0));
 
-		addInput(createPort<Port24>(input1InputPosition, PortWidget::INPUT, module, Mute8::INPUT1_INPUT));
-		addInput(createPort<Port24>(input2InputPosition, PortWidget::INPUT, module, Mute8::INPUT2_INPUT));
-		addInput(createPort<Port24>(input3InputPosition, PortWidget::INPUT, module, Mute8::INPUT3_INPUT));
-		addInput(createPort<Port24>(input4InputPosition, PortWidget::INPUT, module, Mute8::INPUT4_INPUT));
-		addInput(createPort<Port24>(input5InputPosition, PortWidget::INPUT, module, Mute8::INPUT5_INPUT));
-		addInput(createPort<Port24>(input6InputPosition, PortWidget::INPUT, module, Mute8::INPUT6_INPUT));
-		addInput(createPort<Port24>(input7InputPosition, PortWidget::INPUT, module, Mute8::INPUT7_INPUT));
-		addInput(createPort<Port24>(input8InputPosition, PortWidget::INPUT, module, Mute8::INPUT8_INPUT));
-		addInput(createPort<Port24>(mute1InputPosition, PortWidget::INPUT, module, Mute8::MUTE1_INPUT));
-		addInput(createPort<Port24>(mute2InputPosition, PortWidget::INPUT, module, Mute8::MUTE2_INPUT));
-		addInput(createPort<Port24>(mute3InputPosition, PortWidget::INPUT, module, Mute8::MUTE3_INPUT));
-		addInput(createPort<Port24>(mute4InputPosition, PortWidget::INPUT, module, Mute8::MUTE4_INPUT));
-		addInput(createPort<Port24>(mute5InputPosition, PortWidget::INPUT, module, Mute8::MUTE5_INPUT));
-		addInput(createPort<Port24>(mute6InputPosition, PortWidget::INPUT, module, Mute8::MUTE6_INPUT));
-		addInput(createPort<Port24>(mute7InputPosition, PortWidget::INPUT, module, Mute8::MUTE7_INPUT));
-		addInput(createPort<Port24>(mute8InputPosition, PortWidget::INPUT, module, Mute8::MUTE8_INPUT));
-
-		addOutput(createPort<Port24>(output1OutputPosition, PortWidget::OUTPUT, module, Mute8::OUTPUT1_OUTPUT));
-		addOutput(createPort<Port24>(output2OutputPosition, PortWidget::OUTPUT, module, Mute8::OUTPUT2_OUTPUT));
-		addOutput(createPort<Port24>(output3OutputPosition, PortWidget::OUTPUT, module, Mute8::OUTPUT3_OUTPUT));
-		addOutput(createPort<Port24>(output4OutputPosition, PortWidget::OUTPUT, module, Mute8::OUTPUT4_OUTPUT));
-		addOutput(createPort<Port24>(output5OutputPosition, PortWidget::OUTPUT, module, Mute8::OUTPUT5_OUTPUT));
-		addOutput(createPort<Port24>(output6OutputPosition, PortWidget::OUTPUT, module, Mute8::OUTPUT6_OUTPUT));
-		addOutput(createPort<Port24>(output7OutputPosition, PortWidget::OUTPUT, module, Mute8::OUTPUT7_OUTPUT));
-		addOutput(createPort<Port24>(output8OutputPosition, PortWidget::OUTPUT, module, Mute8::OUTPUT8_OUTPUT));
+		addInput(createInput<Port24>(input1InputPosition, module, Mute8::INPUT1_INPUT));
+		addInput(createInput<Port24>(input2InputPosition, module, Mute8::INPUT2_INPUT));
+		addInput(createInput<Port24>(input3InputPosition, module, Mute8::INPUT3_INPUT));
+		addInput(createInput<Port24>(input4InputPosition, module, Mute8::INPUT4_INPUT));
+		addInput(createInput<Port24>(input5InputPosition, module, Mute8::INPUT5_INPUT));
+		addInput(createInput<Port24>(input6InputPosition, module, Mute8::INPUT6_INPUT));
+		addInput(createInput<Port24>(input7InputPosition, module, Mute8::INPUT7_INPUT));
+		addInput(createInput<Port24>(input8InputPosition, module, Mute8::INPUT8_INPUT));
+		addInput(createInput<Port24>(mute1InputPosition, module, Mute8::MUTE1_INPUT));
+		addInput(createInput<Port24>(mute2InputPosition, module, Mute8::MUTE2_INPUT));
+		addInput(createInput<Port24>(mute3InputPosition, module, Mute8::MUTE3_INPUT));
+		addInput(createInput<Port24>(mute4InputPosition, module, Mute8::MUTE4_INPUT));
+		addInput(createInput<Port24>(mute5InputPosition, module, Mute8::MUTE5_INPUT));
+		addInput(createInput<Port24>(mute6InputPosition, module, Mute8::MUTE6_INPUT));
+		addInput(createInput<Port24>(mute7InputPosition, module, Mute8::MUTE7_INPUT));
+		addInput(createInput<Port24>(mute8InputPosition, module, Mute8::MUTE8_INPUT));
+
+		addOutput(createOutput<Port24>(output1OutputPosition, module, Mute8::OUTPUT1_OUTPUT));
+		addOutput(createOutput<Port24>(output2OutputPosition, module, Mute8::OUTPUT2_OUTPUT));
+		addOutput(createOutput<Port24>(output3OutputPosition, module, Mute8::OUTPUT3_OUTPUT));
+		addOutput(createOutput<Port24>(output4OutputPosition, module, Mute8::OUTPUT4_OUTPUT));
+		addOutput(createOutput<Port24>(output5OutputPosition, module, Mute8::OUTPUT5_OUTPUT));
+		addOutput(createOutput<Port24>(output6OutputPosition, module, Mute8::OUTPUT6_OUTPUT));
+		addOutput(createOutput<Port24>(output7OutputPosition, module, Mute8::OUTPUT7_OUTPUT));
+		addOutput(createOutput<Port24>(output8OutputPosition, module, Mute8::OUTPUT8_OUTPUT));
 
 		addChild(createLight<SmallLight<GreenLight>>(mute1LightPosition, module, Mute8::MUTE1_LIGHT));
 		addChild(createLight<SmallLight<GreenLight>>(mute2LightPosition, module, Mute8::MUTE2_LIGHT));
diff --git a/src/Noise.cpp b/src/Noise.cpp
@@ -55,14 +55,14 @@ struct NoiseWidget : ModuleWidget {
 		auto absOutputPosition = Vec(10.5, 291.0);
 		// end generated by svg_widgets.rb
 
-		addInput(createPort<Port24>(absInputPosition, PortWidget::INPUT, module, Noise::ABS_INPUT));
+		addInput(createInput<Port24>(absInputPosition, module, Noise::ABS_INPUT));
 
-		addOutput(createPort<Port24>(blueOutputPosition, PortWidget::OUTPUT, module, Noise::BLUE_OUTPUT));
-		addOutput(createPort<Port24>(whiteOutputPosition, PortWidget::OUTPUT, module, Noise::WHITE_OUTPUT));
-		addOutput(createPort<Port24>(pinkOutputPosition, PortWidget::OUTPUT, module, Noise::PINK_OUTPUT));
-		addOutput(createPort<Port24>(redOutputPosition, PortWidget::OUTPUT, module, Noise::RED_OUTPUT));
-		addOutput(createPort<Port24>(gaussOutputPosition, PortWidget::OUTPUT, module, Noise::GAUSS_OUTPUT));
-		addOutput(createPort<Port24>(absOutputPosition, PortWidget::OUTPUT, module, Noise::ABS_OUTPUT));
+		addOutput(createOutput<Port24>(blueOutputPosition, module, Noise::BLUE_OUTPUT));
+		addOutput(createOutput<Port24>(whiteOutputPosition, module, Noise::WHITE_OUTPUT));
+		addOutput(createOutput<Port24>(pinkOutputPosition, module, Noise::PINK_OUTPUT));
+		addOutput(createOutput<Port24>(redOutputPosition, module, Noise::RED_OUTPUT));
+		addOutput(createOutput<Port24>(gaussOutputPosition, module, Noise::GAUSS_OUTPUT));
+		addOutput(createOutput<Port24>(absOutputPosition, module, Noise::ABS_OUTPUT));
 	}
 };
 
diff --git a/src/Nsgt.cpp b/src/Nsgt.cpp
@@ -102,13 +102,13 @@ struct NsgtWidget : ModuleWidget {
 		addParam(createParam<Knob38>(ratioParamPosition, module, Nsgt::RATIO_PARAM, 0.0, 1.0, 0.552));
 		addParam(createParam<SliderSwitch2State14>(kneeParamPosition, module, Nsgt::KNEE_PARAM, 0.95, 1.0, 1.0));
 
-		addInput(createPort<Port24>(leftInputPosition, PortWidget::INPUT, module, Nsgt::LEFT_INPUT));
-		addInput(createPort<Port24>(rightInputPosition, PortWidget::INPUT, module, Nsgt::RIGHT_INPUT));
-		addInput(createPort<Port24>(thresholdInputPosition, PortWidget::INPUT, module, Nsgt::THRESHOLD_INPUT));
-		addInput(createPort<Port24>(ratioInputPosition, PortWidget::INPUT, module, Nsgt::RATIO_INPUT));
+		addInput(createInput<Port24>(leftInputPosition, module, Nsgt::LEFT_INPUT));
+		addInput(createInput<Port24>(rightInputPosition, module, Nsgt::RIGHT_INPUT));
+		addInput(createInput<Port24>(thresholdInputPosition, module, Nsgt::THRESHOLD_INPUT));
+		addInput(createInput<Port24>(ratioInputPosition, module, Nsgt::RATIO_INPUT));
 
-		addOutput(createPort<Port24>(leftOutputPosition, PortWidget::OUTPUT, module, Nsgt::LEFT_OUTPUT));
-		addOutput(createPort<Port24>(rightOutputPosition, PortWidget::OUTPUT, module, Nsgt::RIGHT_OUTPUT));
+		addOutput(createOutput<Port24>(leftOutputPosition, module, Nsgt::LEFT_OUTPUT));
+		addOutput(createOutput<Port24>(rightOutputPosition, module, Nsgt::RIGHT_OUTPUT));
 	}
 };
 
diff --git a/src/Offset.cpp b/src/Offset.cpp
@@ -54,11 +54,11 @@ struct OffsetWidget : DisableOutputLimitModuleWidget {
 		addParam(createParam<Knob29>(offsetParamPosition, module, Offset::OFFSET_PARAM, -1.0, 1.0, 0.0));
 		addParam(createParam<Knob29>(scaleParamPosition, module, Offset::SCALE_PARAM, -1.0, 1.0, 0.316));
 
-		addInput(createPort<Port24>(offsetInputPosition, PortWidget::INPUT, module, Offset::OFFSET_INPUT));
-		addInput(createPort<Port24>(scaleInputPosition, PortWidget::INPUT, module, Offset::SCALE_INPUT));
-		addInput(createPort<Port24>(inInputPosition, PortWidget::INPUT, module, Offset::IN_INPUT));
+		addInput(createInput<Port24>(offsetInputPosition, module, Offset::OFFSET_INPUT));
+		addInput(createInput<Port24>(scaleInputPosition, module, Offset::SCALE_INPUT));
+		addInput(createInput<Port24>(inInputPosition, module, Offset::IN_INPUT));
 
-		addOutput(createPort<Port24>(outOutputPosition, PortWidget::OUTPUT, module, Offset::OUT_OUTPUT));
+		addOutput(createOutput<Port24>(outOutputPosition, module, Offset::OUT_OUTPUT));
 	}
 };
 
diff --git a/src/OneEight.cpp b/src/OneEight.cpp
@@ -129,19 +129,19 @@ struct OneEightWidget : ModuleWidget {
 			addParam(w);
 		}
 
-		addInput(createPort<Port24>(clockInputPosition, PortWidget::INPUT, module, OneEight::CLOCK_INPUT));
-		addInput(createPort<Port24>(resetInputPosition, PortWidget::INPUT, module, OneEight::RESET_INPUT));
-		addInput(createPort<Port24>(selectInputPosition, PortWidget::INPUT, module, OneEight::SELECT_INPUT));
-		addInput(createPort<Port24>(inInputPosition, PortWidget::INPUT, module, OneEight::IN_INPUT));
-
-		addOutput(createPort<Port24>(out1OutputPosition, PortWidget::OUTPUT, module, OneEight::OUT1_OUTPUT));
-		addOutput(createPort<Port24>(out2OutputPosition, PortWidget::OUTPUT, module, OneEight::OUT2_OUTPUT));
-		addOutput(createPort<Port24>(out3OutputPosition, PortWidget::OUTPUT, module, OneEight::OUT3_OUTPUT));
-		addOutput(createPort<Port24>(out4OutputPosition, PortWidget::OUTPUT, module, OneEight::OUT4_OUTPUT));
-		addOutput(createPort<Port24>(out5OutputPosition, PortWidget::OUTPUT, module, OneEight::OUT5_OUTPUT));
-		addOutput(createPort<Port24>(out6OutputPosition, PortWidget::OUTPUT, module, OneEight::OUT6_OUTPUT));
-		addOutput(createPort<Port24>(out7OutputPosition, PortWidget::OUTPUT, module, OneEight::OUT7_OUTPUT));
-		addOutput(createPort<Port24>(out8OutputPosition, PortWidget::OUTPUT, module, OneEight::OUT8_OUTPUT));
+		addInput(createInput<Port24>(clockInputPosition, module, OneEight::CLOCK_INPUT));
+		addInput(createInput<Port24>(resetInputPosition, module, OneEight::RESET_INPUT));
+		addInput(createInput<Port24>(selectInputPosition, module, OneEight::SELECT_INPUT));
+		addInput(createInput<Port24>(inInputPosition, module, OneEight::IN_INPUT));
+
+		addOutput(createOutput<Port24>(out1OutputPosition, module, OneEight::OUT1_OUTPUT));
+		addOutput(createOutput<Port24>(out2OutputPosition, module, OneEight::OUT2_OUTPUT));
+		addOutput(createOutput<Port24>(out3OutputPosition, module, OneEight::OUT3_OUTPUT));
+		addOutput(createOutput<Port24>(out4OutputPosition, module, OneEight::OUT4_OUTPUT));
+		addOutput(createOutput<Port24>(out5OutputPosition, module, OneEight::OUT5_OUTPUT));
+		addOutput(createOutput<Port24>(out6OutputPosition, module, OneEight::OUT6_OUTPUT));
+		addOutput(createOutput<Port24>(out7OutputPosition, module, OneEight::OUT7_OUTPUT));
+		addOutput(createOutput<Port24>(out8OutputPosition, module, OneEight::OUT8_OUTPUT));
 
 		addChild(createLight<SmallLight<GreenLight>>(out1LightPosition, module, OneEight::OUT1_LIGHT));
 		addChild(createLight<SmallLight<GreenLight>>(out2LightPosition, module, OneEight::OUT2_LIGHT));
diff --git a/src/Pan.cpp b/src/Pan.cpp
@@ -64,13 +64,13 @@ struct PanWidget : ModuleWidget {
 		addParam(createParam<Knob26>(pan1ParamPosition, module, Pan::PAN1_PARAM, -1.0, 1.0, 0.0));
 		addParam(createParam<Knob26>(pan2ParamPosition, module, Pan::PAN2_PARAM, -1.0, 1.0, 0.0));
 
-		addInput(createPort<Port24>(cv1InputPosition, PortWidget::INPUT, module, Pan::CV1_INPUT));
-		addInput(createPort<Port24>(in1InputPosition, PortWidget::INPUT, module, Pan::IN1_INPUT));
-		addInput(createPort<Port24>(cv2InputPosition, PortWidget::INPUT, module, Pan::CV2_INPUT));
-		addInput(createPort<Port24>(in2InputPosition, PortWidget::INPUT, module, Pan::IN2_INPUT));
+		addInput(createInput<Port24>(cv1InputPosition, module, Pan::CV1_INPUT));
+		addInput(createInput<Port24>(in1InputPosition, module, Pan::IN1_INPUT));
+		addInput(createInput<Port24>(cv2InputPosition, module, Pan::CV2_INPUT));
+		addInput(createInput<Port24>(in2InputPosition, module, Pan::IN2_INPUT));
 
-		addOutput(createPort<Port24>(lOutputPosition, PortWidget::OUTPUT, module, Pan::L_OUTPUT));
-		addOutput(createPort<Port24>(rOutputPosition, PortWidget::OUTPUT, module, Pan::R_OUTPUT));
+		addOutput(createOutput<Port24>(lOutputPosition, module, Pan::L_OUTPUT));
+		addOutput(createOutput<Port24>(rOutputPosition, module, Pan::R_OUTPUT));
 	}
 };
 
diff --git a/src/Pressor.cpp b/src/Pressor.cpp
@@ -232,19 +232,19 @@ struct PressorWidget : ModuleWidget {
 		addParam(createParam<SliderSwitch2State14>(dectectorModeParamPosition, module, Pressor::DECTECTOR_MODE_PARAM, 0.0, 1.0, 1.0));
 		addParam(createParam<SliderSwitch2State14>(kneeParamPosition, module, Pressor::KNEE_PARAM, 0.95, 1.0, 1.0));
 
-		addInput(createPort<Port24>(leftInputPosition, PortWidget::INPUT, module, Pressor::LEFT_INPUT));
-		addInput(createPort<Port24>(sidechainInputPosition, PortWidget::INPUT, module, Pressor::SIDECHAIN_INPUT));
-		addInput(createPort<Port24>(thresholdInputPosition, PortWidget::INPUT, module, Pressor::THRESHOLD_INPUT));
-		addInput(createPort<Port24>(ratioInputPosition, PortWidget::INPUT, module, Pressor::RATIO_INPUT));
-		addInput(createPort<Port24>(rightInputPosition, PortWidget::INPUT, module, Pressor::RIGHT_INPUT));
-		addInput(createPort<Port24>(attackInputPosition, PortWidget::INPUT, module, Pressor::ATTACK_INPUT));
-		addInput(createPort<Port24>(releaseInputPosition, PortWidget::INPUT, module, Pressor::RELEASE_INPUT));
-		addInput(createPort<Port24>(inputGainInputPosition, PortWidget::INPUT, module, Pressor::INPUT_GAIN_INPUT));
-		addInput(createPort<Port24>(outputGainInputPosition, PortWidget::INPUT, module, Pressor::OUTPUT_GAIN_INPUT));
-
-		addOutput(createPort<Port24>(envelopeOutputPosition, PortWidget::OUTPUT, module, Pressor::ENVELOPE_OUTPUT));
-		addOutput(createPort<Port24>(leftOutputPosition, PortWidget::OUTPUT, module, Pressor::LEFT_OUTPUT));
-		addOutput(createPort<Port24>(rightOutputPosition, PortWidget::OUTPUT, module, Pressor::RIGHT_OUTPUT));
+		addInput(createInput<Port24>(leftInputPosition, module, Pressor::LEFT_INPUT));
+		addInput(createInput<Port24>(sidechainInputPosition, module, Pressor::SIDECHAIN_INPUT));
+		addInput(createInput<Port24>(thresholdInputPosition, module, Pressor::THRESHOLD_INPUT));
+		addInput(createInput<Port24>(ratioInputPosition, module, Pressor::RATIO_INPUT));
+		addInput(createInput<Port24>(rightInputPosition, module, Pressor::RIGHT_INPUT));
+		addInput(createInput<Port24>(attackInputPosition, module, Pressor::ATTACK_INPUT));
+		addInput(createInput<Port24>(releaseInputPosition, module, Pressor::RELEASE_INPUT));
+		addInput(createInput<Port24>(inputGainInputPosition, module, Pressor::INPUT_GAIN_INPUT));
+		addInput(createInput<Port24>(outputGainInputPosition, module, Pressor::OUTPUT_GAIN_INPUT));
+
+		addOutput(createOutput<Port24>(envelopeOutputPosition, module, Pressor::ENVELOPE_OUTPUT));
+		addOutput(createOutput<Port24>(leftOutputPosition, module, Pressor::LEFT_OUTPUT));
+		addOutput(createOutput<Port24>(rightOutputPosition, module, Pressor::RIGHT_OUTPUT));
 	}
 };
 
diff --git a/src/Reftone.cpp b/src/Reftone.cpp
@@ -229,8 +229,8 @@ struct ReftoneWidget : ModuleWidget {
 		}
 		addParam(createParam<Knob26>(fineParamPosition, module, Reftone::FINE_PARAM, -0.99, 0.99, 0.0));
 
-		addOutput(createPort<Port24>(cvOutputPosition, PortWidget::OUTPUT, module, Reftone::CV_OUTPUT));
-		addOutput(createPort<Port24>(outOutputPosition, PortWidget::OUTPUT, module, Reftone::OUT_OUTPUT));
+		addOutput(createOutput<Port24>(cvOutputPosition, module, Reftone::CV_OUTPUT));
+		addOutput(createOutput<Port24>(outOutputPosition, module, Reftone::OUT_OUTPUT));
 	}
 };
 
diff --git a/src/SampleHold.cpp b/src/SampleHold.cpp
@@ -77,13 +77,13 @@ struct SampleHoldWidget : ModuleWidget {
 		addParam(createParam<StatefulButton9>(track1ParamPosition, module, SampleHold::TRACK1_PARAM, 0.0, 1.0, 0.0));
 		addParam(createParam<StatefulButton9>(track2ParamPosition, module, SampleHold::TRACK2_PARAM, 0.0, 1.0, 0.0));
 
-		addInput(createPort<Port24>(trigger1InputPosition, PortWidget::INPUT, module, SampleHold::TRIGGER1_INPUT));
-		addInput(createPort<Port24>(in1InputPosition, PortWidget::INPUT, module, SampleHold::IN1_INPUT));
-		addInput(createPort<Port24>(trigger2InputPosition, PortWidget::INPUT, module, SampleHold::TRIGGER2_INPUT));
-		addInput(createPort<Port24>(in2InputPosition, PortWidget::INPUT, module, SampleHold::IN2_INPUT));
+		addInput(createInput<Port24>(trigger1InputPosition, module, SampleHold::TRIGGER1_INPUT));
+		addInput(createInput<Port24>(in1InputPosition, module, SampleHold::IN1_INPUT));
+		addInput(createInput<Port24>(trigger2InputPosition, module, SampleHold::TRIGGER2_INPUT));
+		addInput(createInput<Port24>(in2InputPosition, module, SampleHold::IN2_INPUT));
 
-		addOutput(createPort<Port24>(out1OutputPosition, PortWidget::OUTPUT, module, SampleHold::OUT1_OUTPUT));
-		addOutput(createPort<Port24>(out2OutputPosition, PortWidget::OUTPUT, module, SampleHold::OUT2_OUTPUT));
+		addOutput(createOutput<Port24>(out1OutputPosition, module, SampleHold::OUT1_OUTPUT));
+		addOutput(createOutput<Port24>(out2OutputPosition, module, SampleHold::OUT2_OUTPUT));
 
 		addChild(createLight<SmallLight<GreenLight>>(track1LightPosition, module, SampleHold::TRACK1_LIGHT));
 		addChild(createLight<SmallLight<GreenLight>>(track2LightPosition, module, SampleHold::TRACK2_LIGHT));
diff --git a/src/Shaper.cpp b/src/Shaper.cpp
@@ -52,17 +52,17 @@ struct ShaperWidget : ModuleWidget {
 		addParam(createParam<Knob38>(signalParamPosition, module, Shaper::SIGNAL_PARAM, 0.0, 1.0, 0.1));
 
 		addParam(createParam<Button18>(triggerParamPosition, module, Shaper::TRIGGER_PARAM, 0.0, 1.0, 0.0));
-		addInput(createPort<Port24>(triggerInputPosition, PortWidget::INPUT, module, Shaper::TRIGGER_INPUT));
+		addInput(createInput<Port24>(triggerInputPosition, module, Shaper::TRIGGER_INPUT));
 
 		addParam(createParam<SliderSwitch2State14>(speedParamPosition, module, Shaper::SPEED_PARAM, 0.0, 1.0, 1.0));
 		addParam(createParam<SliderSwitch2State14>(loopParamPosition, module, Shaper::LOOP_PARAM, 0.0, 1.0, 1.0));
-		addOutput(createPort<Port24>(triggerOutputPosition, PortWidget::OUTPUT, module, Shaper::TRIGGER_OUTPUT));
+		addOutput(createOutput<Port24>(triggerOutputPosition, module, Shaper::TRIGGER_OUTPUT));
 
-		addOutput(createPort<Port24>(envOutputPosition, PortWidget::OUTPUT, module, Shaper::ENV_OUTPUT));
-		addOutput(createPort<Port24>(invOutputPosition, PortWidget::OUTPUT, module, Shaper::INV_OUTPUT));
+		addOutput(createOutput<Port24>(envOutputPosition, module, Shaper::ENV_OUTPUT));
+		addOutput(createOutput<Port24>(invOutputPosition, module, Shaper::INV_OUTPUT));
 
-		addInput(createPort<Port24>(signalInputPosition, PortWidget::INPUT, module, Shaper::SIGNAL_INPUT));
-		addOutput(createPort<Port24>(signalOutputPosition, PortWidget::OUTPUT, module, Shaper::SIGNAL_OUTPUT));
+		addInput(createInput<Port24>(signalInputPosition, module, Shaper::SIGNAL_INPUT));
+		addOutput(createOutput<Port24>(signalOutputPosition, module, Shaper::SIGNAL_OUTPUT));
 
 		addChild(createLight<TinyLight<GreenLight>>(attackLightPosition, module, Shaper::ATTACK_LIGHT));
 		addChild(createLight<TinyLight<GreenLight>>(onLightPosition, module, Shaper::ON_LIGHT));
diff --git a/src/ShaperPlus.cpp b/src/ShaperPlus.cpp
@@ -62,29 +62,29 @@ struct ShaperPlusWidget : ModuleWidget {
 		addParam(createParam<Knob38>(signalParamPosition, module, ShaperPlus::SIGNAL_PARAM, 0.0, 1.0, 0.1));
 
 		addParam(createParam<Button18>(triggerParamPosition, module, ShaperPlus::TRIGGER_PARAM, 0.0, 1.0, 0.0));
-		addInput(createPort<Port24>(triggerInputPosition, PortWidget::INPUT, module, ShaperPlus::TRIGGER_INPUT));
+		addInput(createInput<Port24>(triggerInputPosition, module, ShaperPlus::TRIGGER_INPUT));
 
 		addParam(createParam<SliderSwitch2State14>(speedParamPosition, module, ShaperPlus::SPEED_PARAM, 0.0, 1.0, 1.0));
 		addParam(createParam<SliderSwitch2State14>(loopParamPosition, module, ShaperPlus::LOOP_PARAM, 0.0, 1.0, 1.0));
-		addOutput(createPort<Port24>(triggerOutputPosition, PortWidget::OUTPUT, module, ShaperPlus::TRIGGER_OUTPUT));
+		addOutput(createOutput<Port24>(triggerOutputPosition, module, ShaperPlus::TRIGGER_OUTPUT));
 
-		addOutput(createPort<Port24>(envOutputPosition, PortWidget::OUTPUT, module, ShaperPlus::ENV_OUTPUT));
-		addOutput(createPort<Port24>(invOutputPosition, PortWidget::OUTPUT, module, ShaperPlus::INV_OUTPUT));
+		addOutput(createOutput<Port24>(envOutputPosition, module, ShaperPlus::ENV_OUTPUT));
+		addOutput(createOutput<Port24>(invOutputPosition, module, ShaperPlus::INV_OUTPUT));
 
-		addInput(createPort<Port24>(signalInputPosition, PortWidget::INPUT, module, ShaperPlus::SIGNAL_INPUT));
-		addOutput(createPort<Port24>(signalOutputPosition, PortWidget::OUTPUT, module, ShaperPlus::SIGNAL_OUTPUT));
+		addInput(createInput<Port24>(signalInputPosition, module, ShaperPlus::SIGNAL_INPUT));
+		addOutput(createOutput<Port24>(signalOutputPosition, module, ShaperPlus::SIGNAL_OUTPUT));
 
-		addInput(createPort<Port24>(attackInputPosition, PortWidget::INPUT, module, ShaperPlus::ATTACK_INPUT));
-		addInput(createPort<Port24>(onInputPosition, PortWidget::INPUT, module, ShaperPlus::ON_INPUT));
-		addInput(createPort<Port24>(decayInputPosition, PortWidget::INPUT, module, ShaperPlus::DECAY_INPUT));
-		addInput(createPort<Port24>(offInputPosition, PortWidget::INPUT, module, ShaperPlus::OFF_INPUT));
-		addInput(createPort<Port24>(envInputPosition, PortWidget::INPUT, module, ShaperPlus::ENV_INPUT));
-		addInput(createPort<Port24>(signalcvInputPosition, PortWidget::INPUT, module, ShaperPlus::SIGNALCV_INPUT));
+		addInput(createInput<Port24>(attackInputPosition, module, ShaperPlus::ATTACK_INPUT));
+		addInput(createInput<Port24>(onInputPosition, module, ShaperPlus::ON_INPUT));
+		addInput(createInput<Port24>(decayInputPosition, module, ShaperPlus::DECAY_INPUT));
+		addInput(createInput<Port24>(offInputPosition, module, ShaperPlus::OFF_INPUT));
+		addInput(createInput<Port24>(envInputPosition, module, ShaperPlus::ENV_INPUT));
+		addInput(createInput<Port24>(signalcvInputPosition, module, ShaperPlus::SIGNALCV_INPUT));
 
-		addOutput(createPort<Port24>(attackOutputPosition, PortWidget::OUTPUT, module, ShaperPlus::ATTACK_OUTPUT));
-		addOutput(createPort<Port24>(onOutputPosition, PortWidget::OUTPUT, module, ShaperPlus::ON_OUTPUT));
-		addOutput(createPort<Port24>(decayOutputPosition, PortWidget::OUTPUT, module, ShaperPlus::DECAY_OUTPUT));
-		addOutput(createPort<Port24>(offOutputPosition, PortWidget::OUTPUT, module, ShaperPlus::OFF_OUTPUT));
+		addOutput(createOutput<Port24>(attackOutputPosition, module, ShaperPlus::ATTACK_OUTPUT));
+		addOutput(createOutput<Port24>(onOutputPosition, module, ShaperPlus::ON_OUTPUT));
+		addOutput(createOutput<Port24>(decayOutputPosition, module, ShaperPlus::DECAY_OUTPUT));
+		addOutput(createOutput<Port24>(offOutputPosition, module, ShaperPlus::OFF_OUTPUT));
 
 		addChild(createLight<TinyLight<GreenLight>>(attackLightPosition, module, ShaperPlus::ATTACK_LIGHT));
 		addChild(createLight<TinyLight<GreenLight>>(onLightPosition, module, ShaperPlus::ON_LIGHT));
diff --git a/src/Slew.cpp b/src/Slew.cpp
@@ -94,11 +94,11 @@ struct SlewWidget : ModuleWidget {
 		addParam(createParam<Knob26>(fallParamPosition, module, Slew::FALL_PARAM, 0.0, 1.0, 0.316));
 		addParam(createParam<Knob16>(fallShapeParamPosition, module, Slew::FALL_SHAPE_PARAM, -1.0, 1.0, 0.0));
 
-		addInput(createPort<Port24>(riseInputPosition, PortWidget::INPUT, module, Slew::RISE_INPUT));
-		addInput(createPort<Port24>(fallInputPosition, PortWidget::INPUT, module, Slew::FALL_INPUT));
-		addInput(createPort<Port24>(inInputPosition, PortWidget::INPUT, module, Slew::IN_INPUT));
+		addInput(createInput<Port24>(riseInputPosition, module, Slew::RISE_INPUT));
+		addInput(createInput<Port24>(fallInputPosition, module, Slew::FALL_INPUT));
+		addInput(createInput<Port24>(inInputPosition, module, Slew::IN_INPUT));
 
-		addOutput(createPort<Port24>(outOutputPosition, PortWidget::OUTPUT, module, Slew::OUT_OUTPUT));
+		addOutput(createOutput<Port24>(outOutputPosition, module, Slew::OUT_OUTPUT));
 	}
 };
 
diff --git a/src/Stack.cpp b/src/Stack.cpp
@@ -86,11 +86,11 @@ struct StackWidget : ModuleWidget {
 		addParam(createParam<Knob16>(fineParamPosition, module, Stack::FINE_PARAM, -0.99, 0.99, 0.0));
 		addParam(createParam<StatefulButton9>(quantizeParamPosition, module, Stack::QUANTIZE_PARAM, 0.0, 1.0, 1.0));
 
-		addInput(createPort<Port24>(cvInputPosition, PortWidget::INPUT, module, Stack::CV_INPUT));
-		addInput(createPort<Port24>(inInputPosition, PortWidget::INPUT, module, Stack::IN_INPUT));
+		addInput(createInput<Port24>(cvInputPosition, module, Stack::CV_INPUT));
+		addInput(createInput<Port24>(inInputPosition, module, Stack::IN_INPUT));
 
-		addOutput(createPort<Port24>(thruOutputPosition, PortWidget::OUTPUT, module, Stack::THRU_OUTPUT));
-		addOutput(createPort<Port24>(outOutputPosition, PortWidget::OUTPUT, module, Stack::OUT_OUTPUT));
+		addOutput(createOutput<Port24>(thruOutputPosition, module, Stack::THRU_OUTPUT));
+		addOutput(createOutput<Port24>(outOutputPosition, module, Stack::OUT_OUTPUT));
 
 		addChild(createLight<SmallLight<GreenLight>>(quantizeLightPosition, module, Stack::QUANTIZE_LIGHT));
 	}
diff --git a/src/Sums.cpp b/src/Sums.cpp
@@ -60,15 +60,15 @@ struct SumsWidget : DisableOutputLimitModuleWidget {
 		auto negateOutputPosition = Vec(10.5, 295.0);
 		// end generated by svg_widgets.rb
 
-		addInput(createPort<Port24>(aInputPosition, PortWidget::INPUT, module, Sums::A_INPUT));
-		addInput(createPort<Port24>(bInputPosition, PortWidget::INPUT, module, Sums::B_INPUT));
-		addInput(createPort<Port24>(negateInputPosition, PortWidget::INPUT, module, Sums::NEGATE_INPUT));
+		addInput(createInput<Port24>(aInputPosition, module, Sums::A_INPUT));
+		addInput(createInput<Port24>(bInputPosition, module, Sums::B_INPUT));
+		addInput(createInput<Port24>(negateInputPosition, module, Sums::NEGATE_INPUT));
 
-		addOutput(createPort<Port24>(sumOutputPosition, PortWidget::OUTPUT, module, Sums::SUM_OUTPUT));
-		addOutput(createPort<Port24>(differenceOutputPosition, PortWidget::OUTPUT, module, Sums::DIFFERENCE_OUTPUT));
-		addOutput(createPort<Port24>(maxOutputPosition, PortWidget::OUTPUT, module, Sums::MAX_OUTPUT));
-		addOutput(createPort<Port24>(minOutputPosition, PortWidget::OUTPUT, module, Sums::MIN_OUTPUT));
-		addOutput(createPort<Port24>(negateOutputPosition, PortWidget::OUTPUT, module, Sums::NEGATE_OUTPUT));
+		addOutput(createOutput<Port24>(sumOutputPosition, module, Sums::SUM_OUTPUT));
+		addOutput(createOutput<Port24>(differenceOutputPosition, module, Sums::DIFFERENCE_OUTPUT));
+		addOutput(createOutput<Port24>(maxOutputPosition, module, Sums::MAX_OUTPUT));
+		addOutput(createOutput<Port24>(minOutputPosition, module, Sums::MIN_OUTPUT));
+		addOutput(createOutput<Port24>(negateOutputPosition, module, Sums::NEGATE_OUTPUT));
 	}
 };
 
diff --git a/src/Switch.cpp b/src/Switch.cpp
@@ -64,14 +64,14 @@ struct SwitchWidget : ModuleWidget {
 		addParam(createParam<Button18>(gateParamPosition, module, bogaudio::Switch::GATE_PARAM, 0.0, 10.0, 0.0));
 		addParam(createParam<StatefulButton9>(latchParamPosition, module, bogaudio::Switch::LATCH_PARAM, 0.0, 1.0, 0.0));
 
-		addInput(createPort<Port24>(gateInputPosition, PortWidget::INPUT, module, bogaudio::Switch::GATE_INPUT));
-		addInput(createPort<Port24>(high1InputPosition, PortWidget::INPUT, module, bogaudio::Switch::HIGH1_INPUT));
-		addInput(createPort<Port24>(low1InputPosition, PortWidget::INPUT, module, bogaudio::Switch::LOW1_INPUT));
-		addInput(createPort<Port24>(high2InputPosition, PortWidget::INPUT, module, bogaudio::Switch::HIGH2_INPUT));
-		addInput(createPort<Port24>(low2InputPosition, PortWidget::INPUT, module, bogaudio::Switch::LOW2_INPUT));
-
-		addOutput(createPort<Port24>(out1OutputPosition, PortWidget::OUTPUT, module, bogaudio::Switch::OUT1_OUTPUT));
-		addOutput(createPort<Port24>(out2OutputPosition, PortWidget::OUTPUT, module, bogaudio::Switch::OUT2_OUTPUT));
+		addInput(createInput<Port24>(gateInputPosition, module, bogaudio::Switch::GATE_INPUT));
+		addInput(createInput<Port24>(high1InputPosition, module, bogaudio::Switch::HIGH1_INPUT));
+		addInput(createInput<Port24>(low1InputPosition, module, bogaudio::Switch::LOW1_INPUT));
+		addInput(createInput<Port24>(high2InputPosition, module, bogaudio::Switch::HIGH2_INPUT));
+		addInput(createInput<Port24>(low2InputPosition, module, bogaudio::Switch::LOW2_INPUT));
+
+		addOutput(createOutput<Port24>(out1OutputPosition, module, bogaudio::Switch::OUT1_OUTPUT));
+		addOutput(createOutput<Port24>(out2OutputPosition, module, bogaudio::Switch::OUT2_OUTPUT));
 
 		addChild(createLight<SmallLight<GreenLight>>(latchLightPosition, module, bogaudio::Switch::LATCH_LIGHT));
 	}
diff --git a/src/Test.cpp b/src/Test.cpp
@@ -514,13 +514,13 @@ struct TestWidget : ModuleWidget {
 		addParam(createParam<Knob26>(param2ParamPosition, module, Test::PARAM2_PARAM, 0.0, 1.0, 0.5));
 		addParam(createParam<Knob26>(param3ParamPosition, module, Test::PARAM3_PARAM, 0.0, 1.0, 0.5));
 
-		addInput(createPort<Port24>(cv1InputPosition, PortWidget::INPUT, module, Test::CV1_INPUT));
-		addInput(createPort<Port24>(cv2InputPosition, PortWidget::INPUT, module, Test::CV2_INPUT));
-		addInput(createPort<Port24>(cv3InputPosition, PortWidget::INPUT, module, Test::CV3_INPUT));
-		addInput(createPort<Port24>(inInputPosition, PortWidget::INPUT, module, Test::IN_INPUT));
+		addInput(createInput<Port24>(cv1InputPosition, module, Test::CV1_INPUT));
+		addInput(createInput<Port24>(cv2InputPosition, module, Test::CV2_INPUT));
+		addInput(createInput<Port24>(cv3InputPosition, module, Test::CV3_INPUT));
+		addInput(createInput<Port24>(inInputPosition, module, Test::IN_INPUT));
 
-		addOutput(createPort<Port24>(outOutputPosition, PortWidget::OUTPUT, module, Test::OUT_OUTPUT));
-		addOutput(createPort<Port24>(out2OutputPosition, PortWidget::OUTPUT, module, Test::OUT2_OUTPUT));
+		addOutput(createOutput<Port24>(outOutputPosition, module, Test::OUT_OUTPUT));
+		addOutput(createOutput<Port24>(out2OutputPosition, module, Test::OUT2_OUTPUT));
 	}
 };
 
diff --git a/src/Test2.cpp b/src/Test2.cpp
@@ -144,15 +144,15 @@ struct Test2Widget : ModuleWidget {
 		addParam(createParam<Knob26>(param2bParamPosition, module, Test2::PARAM2B_PARAM, 0.0, 1.0, 0.0));
 		addParam(createParam<Knob26>(param3bParamPosition, module, Test2::PARAM3B_PARAM, 0.0, 1.0, 0.0));
 
-		addInput(createPort<Port24>(cv1aInputPosition, PortWidget::INPUT, module, Test2::CV1A_INPUT));
-		addInput(createPort<Port24>(cv2aInputPosition, PortWidget::INPUT, module, Test2::CV2A_INPUT));
-		addInput(createPort<Port24>(cv3aInputPosition, PortWidget::INPUT, module, Test2::CV3A_INPUT));
-		addInput(createPort<Port24>(cv1bInputPosition, PortWidget::INPUT, module, Test2::CV1B_INPUT));
-		addInput(createPort<Port24>(cv2bInputPosition, PortWidget::INPUT, module, Test2::CV2B_INPUT));
-		addInput(createPort<Port24>(cv3bInputPosition, PortWidget::INPUT, module, Test2::CV3B_INPUT));
-		addInput(createPort<Port24>(inInputPosition, PortWidget::INPUT, module, Test2::IN_INPUT));
-
-		addOutput(createPort<Port24>(outOutputPosition, PortWidget::OUTPUT, module, Test2::OUT_OUTPUT));
+		addInput(createInput<Port24>(cv1aInputPosition, module, Test2::CV1A_INPUT));
+		addInput(createInput<Port24>(cv2aInputPosition, module, Test2::CV2A_INPUT));
+		addInput(createInput<Port24>(cv3aInputPosition, module, Test2::CV3A_INPUT));
+		addInput(createInput<Port24>(cv1bInputPosition, module, Test2::CV1B_INPUT));
+		addInput(createInput<Port24>(cv2bInputPosition, module, Test2::CV2B_INPUT));
+		addInput(createInput<Port24>(cv3bInputPosition, module, Test2::CV3B_INPUT));
+		addInput(createInput<Port24>(inInputPosition, module, Test2::IN_INPUT));
+
+		addOutput(createOutput<Port24>(outOutputPosition, module, Test2::OUT_OUTPUT));
 	}
 };
 
diff --git a/src/UMix.cpp b/src/UMix.cpp
@@ -134,16 +134,16 @@ struct UMixWidget : ModuleWidget {
 
 		addParam(createParam<Knob16>(levelParamPosition, module, UMix::LEVEL_PARAM, 0.0, 1.0, 1.0));
 
-		addInput(createPort<Port24>(in1InputPosition, PortWidget::INPUT, module, UMix::IN1_INPUT));
-		addInput(createPort<Port24>(in2InputPosition, PortWidget::INPUT, module, UMix::IN2_INPUT));
-		addInput(createPort<Port24>(in3InputPosition, PortWidget::INPUT, module, UMix::IN3_INPUT));
-		addInput(createPort<Port24>(in4InputPosition, PortWidget::INPUT, module, UMix::IN4_INPUT));
-		addInput(createPort<Port24>(in5InputPosition, PortWidget::INPUT, module, UMix::IN5_INPUT));
-		addInput(createPort<Port24>(in6InputPosition, PortWidget::INPUT, module, UMix::IN6_INPUT));
-		addInput(createPort<Port24>(in7InputPosition, PortWidget::INPUT, module, UMix::IN7_INPUT));
-		addInput(createPort<Port24>(in8InputPosition, PortWidget::INPUT, module, UMix::IN8_INPUT));
-
-		addOutput(createPort<Port24>(outOutputPosition, PortWidget::OUTPUT, module, UMix::OUT_OUTPUT));
+		addInput(createInput<Port24>(in1InputPosition, module, UMix::IN1_INPUT));
+		addInput(createInput<Port24>(in2InputPosition, module, UMix::IN2_INPUT));
+		addInput(createInput<Port24>(in3InputPosition, module, UMix::IN3_INPUT));
+		addInput(createInput<Port24>(in4InputPosition, module, UMix::IN4_INPUT));
+		addInput(createInput<Port24>(in5InputPosition, module, UMix::IN5_INPUT));
+		addInput(createInput<Port24>(in6InputPosition, module, UMix::IN6_INPUT));
+		addInput(createInput<Port24>(in7InputPosition, module, UMix::IN7_INPUT));
+		addInput(createInput<Port24>(in8InputPosition, module, UMix::IN8_INPUT));
+
+		addOutput(createOutput<Port24>(outOutputPosition, module, UMix::OUT_OUTPUT));
 	}
 
 	void appendContextMenu(Menu* menu) override {
diff --git a/src/VCA.cpp b/src/VCA.cpp
@@ -69,13 +69,13 @@ struct VCAWidget : ModuleWidget {
 		addParam(createParam<Knob26>(level2ParamPosition, module, VCA::LEVEL2_PARAM, 0.0, 1.0, 0.8));
 		addParam(createParam<StatefulButton9>(linearParamPosition, module, VCA::LINEAR_PARAM, 0.0, 1.0, 0.0));
 
-		addInput(createPort<Port24>(cv1InputPosition, PortWidget::INPUT, module, VCA::CV1_INPUT));
-		addInput(createPort<Port24>(in1InputPosition, PortWidget::INPUT, module, VCA::IN1_INPUT));
-		addInput(createPort<Port24>(cv2InputPosition, PortWidget::INPUT, module, VCA::CV2_INPUT));
-		addInput(createPort<Port24>(in2InputPosition, PortWidget::INPUT, module, VCA::IN2_INPUT));
+		addInput(createInput<Port24>(cv1InputPosition, module, VCA::CV1_INPUT));
+		addInput(createInput<Port24>(in1InputPosition, module, VCA::IN1_INPUT));
+		addInput(createInput<Port24>(cv2InputPosition, module, VCA::CV2_INPUT));
+		addInput(createInput<Port24>(in2InputPosition, module, VCA::IN2_INPUT));
 
-		addOutput(createPort<Port24>(out1OutputPosition, PortWidget::OUTPUT, module, VCA::OUT1_OUTPUT));
-		addOutput(createPort<Port24>(out2OutputPosition, PortWidget::OUTPUT, module, VCA::OUT2_OUTPUT));
+		addOutput(createOutput<Port24>(out1OutputPosition, module, VCA::OUT1_OUTPUT));
+		addOutput(createOutput<Port24>(out2OutputPosition, module, VCA::OUT2_OUTPUT));
 
 		addChild(createLight<SmallLight<GreenLight>>(linearLightPosition, module, VCA::LINEAR_LIGHT));
 	}
diff --git a/src/VCAmp.cpp b/src/VCAmp.cpp
@@ -66,10 +66,10 @@ struct VCAmpWidget : ModuleWidget {
 		}
 		addParam(slider);
 
-		addInput(createPort<Port24>(cvInputPosition, PortWidget::INPUT, module, VCAmp::CV_INPUT));
-		addInput(createPort<Port24>(inInputPosition, PortWidget::INPUT, module, VCAmp::IN_INPUT));
+		addInput(createInput<Port24>(cvInputPosition, module, VCAmp::CV_INPUT));
+		addInput(createInput<Port24>(inInputPosition, module, VCAmp::IN_INPUT));
 
-		addOutput(createPort<Port24>(outOutputPosition, PortWidget::OUTPUT, module, VCAmp::OUT_OUTPUT));
+		addOutput(createOutput<Port24>(outOutputPosition, module, VCAmp::OUT_OUTPUT));
 	}
 };
 
diff --git a/src/VCM.cpp b/src/VCM.cpp
@@ -86,17 +86,17 @@ struct VCMWidget : DisableOutputLimitModuleWidget {
 		addParam(createParam<Knob38>(mixParamPosition, module, VCM::MIX_PARAM, 0.0, 1.0, 0.8));
 		addParam(createParam<StatefulButton9>(linearParamPosition, module, VCM::LINEAR_PARAM, 0.0, 1.0, 0.0));
 
-		addInput(createPort<Port24>(in1InputPosition, PortWidget::INPUT, module, VCM::IN1_INPUT));
-		addInput(createPort<Port24>(cv1InputPosition, PortWidget::INPUT, module, VCM::CV1_INPUT));
-		addInput(createPort<Port24>(in2InputPosition, PortWidget::INPUT, module, VCM::IN2_INPUT));
-		addInput(createPort<Port24>(cv2InputPosition, PortWidget::INPUT, module, VCM::CV2_INPUT));
-		addInput(createPort<Port24>(in3InputPosition, PortWidget::INPUT, module, VCM::IN3_INPUT));
-		addInput(createPort<Port24>(cv3InputPosition, PortWidget::INPUT, module, VCM::CV3_INPUT));
-		addInput(createPort<Port24>(in4InputPosition, PortWidget::INPUT, module, VCM::IN4_INPUT));
-		addInput(createPort<Port24>(cv4InputPosition, PortWidget::INPUT, module, VCM::CV4_INPUT));
-		addInput(createPort<Port24>(mixCvInputPosition, PortWidget::INPUT, module, VCM::MIX_CV_INPUT));
-
-		addOutput(createPort<Port24>(mixOutputPosition, PortWidget::OUTPUT, module, VCM::MIX_OUTPUT));
+		addInput(createInput<Port24>(in1InputPosition, module, VCM::IN1_INPUT));
+		addInput(createInput<Port24>(cv1InputPosition, module, VCM::CV1_INPUT));
+		addInput(createInput<Port24>(in2InputPosition, module, VCM::IN2_INPUT));
+		addInput(createInput<Port24>(cv2InputPosition, module, VCM::CV2_INPUT));
+		addInput(createInput<Port24>(in3InputPosition, module, VCM::IN3_INPUT));
+		addInput(createInput<Port24>(cv3InputPosition, module, VCM::CV3_INPUT));
+		addInput(createInput<Port24>(in4InputPosition, module, VCM::IN4_INPUT));
+		addInput(createInput<Port24>(cv4InputPosition, module, VCM::CV4_INPUT));
+		addInput(createInput<Port24>(mixCvInputPosition, module, VCM::MIX_CV_INPUT));
+
+		addOutput(createOutput<Port24>(mixOutputPosition, module, VCM::MIX_OUTPUT));
 
 		addChild(createLight<SmallLight<GreenLight>>(linearLightPosition, module, VCM::LINEAR_LIGHT));
 	}
diff --git a/src/VCO.cpp b/src/VCO.cpp
@@ -198,15 +198,15 @@ struct VCOWidget : ModuleWidget {
 		addParam(createParam<Knob26>(fmParamPosition, module, VCO::FM_PARAM, 0.0, 1.0, 0.0));
 		addParam(createParam<SliderSwitch2State14>(fmTypeParamPosition, module, VCO::FM_TYPE_PARAM, 0.0, 1.0, 1.0));
 
-		addInput(createPort<Port24>(pitchInputPosition, PortWidget::INPUT, module, VCO::PITCH_INPUT));
-		addInput(createPort<Port24>(syncInputPosition, PortWidget::INPUT, module, VCO::SYNC_INPUT));
-		addInput(createPort<Port24>(pwInputPosition, PortWidget::INPUT, module, VCO::PW_INPUT));
-		addInput(createPort<Port24>(fmInputPosition, PortWidget::INPUT, module, VCO::FM_INPUT));
-
-		addOutput(createPort<Port24>(squareOutputPosition, PortWidget::OUTPUT, module, VCO::SQUARE_OUTPUT));
-		addOutput(createPort<Port24>(sawOutputPosition, PortWidget::OUTPUT, module, VCO::SAW_OUTPUT));
-		addOutput(createPort<Port24>(triangleOutputPosition, PortWidget::OUTPUT, module, VCO::TRIANGLE_OUTPUT));
-		addOutput(createPort<Port24>(sineOutputPosition, PortWidget::OUTPUT, module, VCO::SINE_OUTPUT));
+		addInput(createInput<Port24>(pitchInputPosition, module, VCO::PITCH_INPUT));
+		addInput(createInput<Port24>(syncInputPosition, module, VCO::SYNC_INPUT));
+		addInput(createInput<Port24>(pwInputPosition, module, VCO::PW_INPUT));
+		addInput(createInput<Port24>(fmInputPosition, module, VCO::FM_INPUT));
+
+		addOutput(createOutput<Port24>(squareOutputPosition, module, VCO::SQUARE_OUTPUT));
+		addOutput(createOutput<Port24>(sawOutputPosition, module, VCO::SAW_OUTPUT));
+		addOutput(createOutput<Port24>(triangleOutputPosition, module, VCO::TRIANGLE_OUTPUT));
+		addOutput(createOutput<Port24>(sineOutputPosition, module, VCO::SINE_OUTPUT));
 
 		addChild(createLight<SmallLight<GreenLight>>(slowLightPosition, module, VCO::SLOW_LIGHT));
 	}
diff --git a/src/VU.cpp b/src/VU.cpp
@@ -120,11 +120,11 @@ struct VUWidget : ModuleWidget {
 		auto rOutputPosition = Vec(10.5, 311.0);
 		// end generated by svg_widgets.rb
 
-		addInput(createPort<Port24>(lInputPosition, PortWidget::INPUT, module, VU::L_INPUT));
-		addInput(createPort<Port24>(rInputPosition, PortWidget::INPUT, module, VU::R_INPUT));
+		addInput(createInput<Port24>(lInputPosition, module, VU::L_INPUT));
+		addInput(createInput<Port24>(rInputPosition, module, VU::R_INPUT));
 
-		addOutput(createPort<Port24>(lOutputPosition, PortWidget::OUTPUT, module, VU::L_OUTPUT));
-		addOutput(createPort<Port24>(rOutputPosition, PortWidget::OUTPUT, module, VU::R_OUTPUT));
+		addOutput(createOutput<Port24>(lOutputPosition, module, VU::L_OUTPUT));
+		addOutput(createOutput<Port24>(rOutputPosition, module, VU::R_OUTPUT));
 	}
 };
 
diff --git a/src/Walk.cpp b/src/Walk.cpp
@@ -78,12 +78,12 @@ struct WalkWidget : ModuleWidget {
 		addParam(createParam<Knob16>(offsetParamPosition, module, Walk::OFFSET_PARAM, -1.0, 1.0, 0.0));
 		addParam(createParam<Knob16>(scaleParamPosition, module, Walk::SCALE_PARAM, 0.0, 1.0, 1.0));
 
-		addInput(createPort<Port24>(rateInputPosition, PortWidget::INPUT, module, Walk::RATE_INPUT));
-		addInput(createPort<Port24>(offsetInputPosition, PortWidget::INPUT, module, Walk::OFFSET_INPUT));
-		addInput(createPort<Port24>(scaleInputPosition, PortWidget::INPUT, module, Walk::SCALE_INPUT));
-		addInput(createPort<Port24>(jumpInputPosition, PortWidget::INPUT, module, Walk::JUMP_INPUT));
+		addInput(createInput<Port24>(rateInputPosition, module, Walk::RATE_INPUT));
+		addInput(createInput<Port24>(offsetInputPosition, module, Walk::OFFSET_INPUT));
+		addInput(createInput<Port24>(scaleInputPosition, module, Walk::SCALE_INPUT));
+		addInput(createInput<Port24>(jumpInputPosition, module, Walk::JUMP_INPUT));
 
-		addOutput(createPort<Port24>(outOutputPosition, PortWidget::OUTPUT, module, Walk::OUT_OUTPUT));
+		addOutput(createOutput<Port24>(outOutputPosition, module, Walk::OUT_OUTPUT));
 	}
 };
 
diff --git a/src/Walk2.cpp b/src/Walk2.cpp
@@ -529,17 +529,17 @@ struct Walk2Widget : ModuleWidget {
 		addParam(createParam<Knob16>(scaleXParamPosition, module, Walk2::SCALE_X_PARAM, 0.0, 1.0, 1.0));
 		addParam(createParam<Knob16>(scaleYParamPosition, module, Walk2::SCALE_Y_PARAM, 0.0, 1.0, 1.0));
 
-		addInput(createPort<Port24>(offsetXInputPosition, PortWidget::INPUT, module, Walk2::OFFSET_X_INPUT));
-		addInput(createPort<Port24>(scaleXInputPosition, PortWidget::INPUT, module, Walk2::SCALE_X_INPUT));
-		addInput(createPort<Port24>(rateXInputPosition, PortWidget::INPUT, module, Walk2::RATE_X_INPUT));
-		addInput(createPort<Port24>(offsetYInputPosition, PortWidget::INPUT, module, Walk2::OFFSET_Y_INPUT));
-		addInput(createPort<Port24>(scaleYInputPosition, PortWidget::INPUT, module, Walk2::SCALE_Y_INPUT));
-		addInput(createPort<Port24>(rateYInputPosition, PortWidget::INPUT, module, Walk2::RATE_Y_INPUT));
-		addInput(createPort<Port24>(jumpInputPosition, PortWidget::INPUT, module, Walk2::JUMP_INPUT));
-
-		addOutput(createPort<Port24>(outXOutputPosition, PortWidget::OUTPUT, module, Walk2::OUT_X_OUTPUT));
-		addOutput(createPort<Port24>(outYOutputPosition, PortWidget::OUTPUT, module, Walk2::OUT_Y_OUTPUT));
-		addOutput(createPort<Port24>(distanceOutputPosition, PortWidget::OUTPUT, module, Walk2::DISTANCE_OUTPUT));
+		addInput(createInput<Port24>(offsetXInputPosition, module, Walk2::OFFSET_X_INPUT));
+		addInput(createInput<Port24>(scaleXInputPosition, module, Walk2::SCALE_X_INPUT));
+		addInput(createInput<Port24>(rateXInputPosition, module, Walk2::RATE_X_INPUT));
+		addInput(createInput<Port24>(offsetYInputPosition, module, Walk2::OFFSET_Y_INPUT));
+		addInput(createInput<Port24>(scaleYInputPosition, module, Walk2::SCALE_Y_INPUT));
+		addInput(createInput<Port24>(rateYInputPosition, module, Walk2::RATE_Y_INPUT));
+		addInput(createInput<Port24>(jumpInputPosition, module, Walk2::JUMP_INPUT));
+
+		addOutput(createOutput<Port24>(outXOutputPosition, module, Walk2::OUT_X_OUTPUT));
+		addOutput(createOutput<Port24>(outYOutputPosition, module, Walk2::OUT_Y_OUTPUT));
+		addOutput(createOutput<Port24>(distanceOutputPosition, module, Walk2::DISTANCE_OUTPUT));
 	}
 
 	void appendContextMenu(Menu* menu) override {
diff --git a/src/XCO.cpp b/src/XCO.cpp
@@ -335,28 +335,28 @@ struct XCOWidget : ModuleWidget {
 		addParam(createParam<Knob16>(sinePhaseParamPosition, module, XCO::SINE_PHASE_PARAM, -1.0, 1.0, 0.0));
 		addParam(createParam<Knob16>(sineMixParamPosition, module, XCO::SINE_MIX_PARAM, 0.0, 1.0, 1.0));
 
-		addInput(createPort<Port24>(fmInputPosition, PortWidget::INPUT, module, XCO::FM_INPUT));
-		addInput(createPort<Port24>(fmDepthInputPosition, PortWidget::INPUT, module, XCO::FM_DEPTH_INPUT));
-		addInput(createPort<Port24>(squarePwInputPosition, PortWidget::INPUT, module, XCO::SQUARE_PW_INPUT));
-		addInput(createPort<Port24>(squarePhaseInputPosition, PortWidget::INPUT, module, XCO::SQUARE_PHASE_INPUT));
-		addInput(createPort<Port24>(squareMixInputPosition, PortWidget::INPUT, module, XCO::SQUARE_MIX_INPUT));
-		addInput(createPort<Port24>(sawSaturationInputPosition, PortWidget::INPUT, module, XCO::SAW_SATURATION_INPUT));
-		addInput(createPort<Port24>(sawPhaseInputPosition, PortWidget::INPUT, module, XCO::SAW_PHASE_INPUT));
-		addInput(createPort<Port24>(sawMixInputPosition, PortWidget::INPUT, module, XCO::SAW_MIX_INPUT));
-		addInput(createPort<Port24>(triangleSampleInputPosition, PortWidget::INPUT, module, XCO::TRIANGLE_SAMPLE_INPUT));
-		addInput(createPort<Port24>(trianglePhaseInputPosition, PortWidget::INPUT, module, XCO::TRIANGLE_PHASE_INPUT));
-		addInput(createPort<Port24>(triangleMixInputPosition, PortWidget::INPUT, module, XCO::TRIANGLE_MIX_INPUT));
-		addInput(createPort<Port24>(sineFeedbackInputPosition, PortWidget::INPUT, module, XCO::SINE_FEEDBACK_INPUT));
-		addInput(createPort<Port24>(sinePhaseInputPosition, PortWidget::INPUT, module, XCO::SINE_PHASE_INPUT));
-		addInput(createPort<Port24>(sineMixInputPosition, PortWidget::INPUT, module, XCO::SINE_MIX_INPUT));
-		addInput(createPort<Port24>(pitchInputPosition, PortWidget::INPUT, module, XCO::PITCH_INPUT));
-		addInput(createPort<Port24>(syncInputPosition, PortWidget::INPUT, module, XCO::SYNC_INPUT));
-
-		addOutput(createPort<Port24>(squareOutputPosition, PortWidget::OUTPUT, module, XCO::SQUARE_OUTPUT));
-		addOutput(createPort<Port24>(sawOutputPosition, PortWidget::OUTPUT, module, XCO::SAW_OUTPUT));
-		addOutput(createPort<Port24>(triangleOutputPosition, PortWidget::OUTPUT, module, XCO::TRIANGLE_OUTPUT));
-		addOutput(createPort<Port24>(sineOutputPosition, PortWidget::OUTPUT, module, XCO::SINE_OUTPUT));
-		addOutput(createPort<Port24>(mixOutputPosition, PortWidget::OUTPUT, module, XCO::MIX_OUTPUT));
+		addInput(createInput<Port24>(fmInputPosition, module, XCO::FM_INPUT));
+		addInput(createInput<Port24>(fmDepthInputPosition, module, XCO::FM_DEPTH_INPUT));
+		addInput(createInput<Port24>(squarePwInputPosition, module, XCO::SQUARE_PW_INPUT));
+		addInput(createInput<Port24>(squarePhaseInputPosition, module, XCO::SQUARE_PHASE_INPUT));
+		addInput(createInput<Port24>(squareMixInputPosition, module, XCO::SQUARE_MIX_INPUT));
+		addInput(createInput<Port24>(sawSaturationInputPosition, module, XCO::SAW_SATURATION_INPUT));
+		addInput(createInput<Port24>(sawPhaseInputPosition, module, XCO::SAW_PHASE_INPUT));
+		addInput(createInput<Port24>(sawMixInputPosition, module, XCO::SAW_MIX_INPUT));
+		addInput(createInput<Port24>(triangleSampleInputPosition, module, XCO::TRIANGLE_SAMPLE_INPUT));
+		addInput(createInput<Port24>(trianglePhaseInputPosition, module, XCO::TRIANGLE_PHASE_INPUT));
+		addInput(createInput<Port24>(triangleMixInputPosition, module, XCO::TRIANGLE_MIX_INPUT));
+		addInput(createInput<Port24>(sineFeedbackInputPosition, module, XCO::SINE_FEEDBACK_INPUT));
+		addInput(createInput<Port24>(sinePhaseInputPosition, module, XCO::SINE_PHASE_INPUT));
+		addInput(createInput<Port24>(sineMixInputPosition, module, XCO::SINE_MIX_INPUT));
+		addInput(createInput<Port24>(pitchInputPosition, module, XCO::PITCH_INPUT));
+		addInput(createInput<Port24>(syncInputPosition, module, XCO::SYNC_INPUT));
+
+		addOutput(createOutput<Port24>(squareOutputPosition, module, XCO::SQUARE_OUTPUT));
+		addOutput(createOutput<Port24>(sawOutputPosition, module, XCO::SAW_OUTPUT));
+		addOutput(createOutput<Port24>(triangleOutputPosition, module, XCO::TRIANGLE_OUTPUT));
+		addOutput(createOutput<Port24>(sineOutputPosition, module, XCO::SINE_OUTPUT));
+		addOutput(createOutput<Port24>(mixOutputPosition, module, XCO::MIX_OUTPUT));
 
 		addChild(createLight<SmallLight<GreenLight>>(slowLightPosition, module, XCO::SLOW_LIGHT));
 	}
diff --git a/src/XFade.cpp b/src/XFade.cpp
@@ -76,11 +76,11 @@ struct XFadeWidget : ModuleWidget {
 		}
 		addParam(createParam<StatefulButton9>(linearParamPosition, module, XFade::LINEAR_PARAM, 0.0, 1.0, 0.0));
 
-		addInput(createPort<Port24>(mixInputPosition, PortWidget::INPUT, module, XFade::MIX_INPUT));
-		addInput(createPort<Port24>(aInputPosition, PortWidget::INPUT, module, XFade::A_INPUT));
-		addInput(createPort<Port24>(bInputPosition, PortWidget::INPUT, module, XFade::B_INPUT));
+		addInput(createInput<Port24>(mixInputPosition, module, XFade::MIX_INPUT));
+		addInput(createInput<Port24>(aInputPosition, module, XFade::A_INPUT));
+		addInput(createInput<Port24>(bInputPosition, module, XFade::B_INPUT));
 
-		addOutput(createPort<Port24>(outOutputPosition, PortWidget::OUTPUT, module, XFade::OUT_OUTPUT));
+		addOutput(createOutput<Port24>(outOutputPosition, module, XFade::OUT_OUTPUT));
 
 		addChild(createLight<SmallLight<GreenLight>>(linearLightPosition, module, XFade::LINEAR_LIGHT));
 	}