BogaudioModules

commit 96a1d785b9119307e37211806290caff78f1f629
parent 8b91d0ca4ed12c9da190c819667f8a75f3e7772c
Author: Matt Demanett <matt@demanett.net>
Date:   Fri, 16 Feb 2018 00:28:58 -0500

Update to build against Rack master (getting ready for 0.6).

Diffstat:
M
Makefile
 | 
22
++++++++--------------
M
README.md
 | 
6
++++--
M
scripts/svg_widgets.rb
 | 
55
+++++++++++++++++++++++++++++--------------------------
M
src/Analyzer.cpp
 | 
61
+++++++++++++++++++++++++++++++++----------------------------
M
src/DADSRH.cpp
 | 
94
++++++++++++++++++++++++++++++++++++++++++-------------------------------------
M
src/DADSRHPlus.cpp
 | 
111
++++++++++++++++++++++++++++++++++++++++++-------------------------------------
M
src/DGate.cpp
 | 
42
++++++++++++++++++++++++------------------
M
src/Detune.cpp
 | 
29
+++++++++++++++++------------
M
src/Manual.cpp
 | 
39
++++++++++++++++++++++-----------------
M
src/Noise.cpp
 | 
27
++++++++++++++++-----------
M
src/Offset.cpp
 | 
35
++++++++++++++++++++---------------
M
src/Reftone.cpp
 | 
31
++++++++++++++++++-------------
M
src/SampleHold.cpp
 | 
38
++++++++++++++++++++++----------------
M
src/Shaper.cpp
 | 
62
++++++++++++++++++++++++++++++++++----------------------------
M
src/ShaperPlus.cpp
 | 
96
++++++++++++++++++++++++++++++++++++++++++-------------------------------------
M
src/SixHP.cpp
 | 
21
+++++++++++++--------
M
src/Stack.cpp
 | 
41
+++++++++++++++++++++++------------------
M
src/Switch.cpp
 | 
37
+++++++++++++++++++++----------------
M
src/Test.cpp
 | 
41
+++++++++++++++++++++++------------------
M
src/VCA.cpp
 | 
35
++++++++++++++++++++---------------
M
src/bogaudio.cpp
 | 
42
+++++++++++++++++++-----------------------
M
src/bogaudio.hpp
 | 
98
++++++++++++++++---------------------------------------------------------------
M
src/dadsrh_core.cpp
 | 
4
++--
M
src/dsp/oscillator.cpp
 | 
2
--
M
src/shaper_core.cpp
 | 
6
+++---

25 files changed, 551 insertions(+), 524 deletions(-)
diff --git a/Makefile b/Makefile
@@ -1,4 +1,8 @@
 
+SLUG=Bogaudio
+VERSION=0.6.4
+FLAGS += -DSLUG=$(SLUG) -DVERSION=$(VERSION)
+
 ifdef REQUIRE_VERSION
 FLAGS += -DREQUIRE_VERSION=$(REQUIRE_VERSION)
 endif
@@ -14,7 +18,10 @@ endif
 SOURCES = $(wildcard src/*.cpp src/dsp/*cpp)
 CXXFLAGS += -Isrc -Isrc/dsp
 
-include ../../plugin.mk
+DISTRIBUTABLES += $(wildcard LICENSE* README*) res
+
+RACK_DIR ?= ../..
+include $(RACK_DIR)/plugin.mk
 
 BENCHMARK_SOURCES = $(wildcard benchmarks/*.cpp src/dsp/*cpp)
 BENCHMARK_OBJECTS = $(patsubst %, build/%.o, $(BENCHMARK_SOURCES))
@@ -25,16 +32,3 @@ benchmark: $(BENCHMARK_OBJECTS)
 benchmark_clean:
 	rm -f benchmark $(BENCHMARK_OBJECTS)
 clean: benchmark_clean
-
-distprep:
-	rm -f build/src/bogaudio.cpp*
-
-SLUG=Bogaudio
-dist: distprep
-	@$(MAKE) all REQUIRE_VERSION=1
-	mkdir -p dist/$(SLUG)
-	cp README* dist/$(SLUG)/
-	cp LICENSE* dist/$(SLUG)/
-	cp plugin.* dist/$(SLUG)/
-	cp -R res dist/$(SLUG)/
-	(cd dist && zip -r $(SLUG)-$(VERSION)-$(ARCH).zip $(SLUG))
diff --git a/README.md b/README.md
@@ -19,12 +19,14 @@ You'll need to be set up to build [VCV Rack](https://github.com/VCVRack/Rack) it
   make
   ```
 
-To build for a particular version of Rack, check out the corresponding branch:
+**The master branch of this module currently builds against Rack's master branch**, which has changes that will be released as Rack 0.6.
+
+To build Bogaudio for the current production version of Rack (0.5), check out the corresponding branch:
 
   ```
   (in plugins/BogaudioModules:)
   git fetch
-  git checkout v0.4.0
+  git checkout v0.5.x
   make
   ```
 
diff --git a/scripts/svg_widgets.rb b/scripts/svg_widgets.rb
@@ -6,12 +6,10 @@ OUTPUT_DECIMAL_PLACES=2
 class_template = <<TEMPLATE
 /*
 // For %PLUGIN%.hpp:
-struct %MODULE%Widget : ModuleWidget {
-	%MODULE%Widget();
-};
+extern Model* model%MODULE%;
 
 // For %PLUGIN%.cpp:
-p->addModel(createModel<%MODULE%Widget>("%MANUFACTURER%", "%MANUFACTURER%-%MODULE%", "%MODULE%"));
+p->addModel(model%MODULE%);
 */
 
 #include "%HEADER%.hpp"
@@ -20,23 +18,25 @@ struct %MODULE% : Module {
 %ENUMS%
 
 	%MODULE%() : Module(NUM_PARAMS, NUM_INPUTS, NUM_OUTPUTS, NUM_LIGHTS) {
-		reset();
+		onReset();
 	}
 
-	virtual void reset() override;
+	virtual void onReset() override;
 	virtual void step() override;
 };
 
-void %MODULE%::reset() {
+void %MODULE%::onReset() {
 }
 
 void %MODULE%::step() {
 }
 
 
-%MODULE%Widget::%MODULE%Widget() {
-	%MODULE% *module = new %MODULE%();
-	setModule(module);
+struct %MODULE%Widget : ModuleWidget {
+	%MODULE%Widget(%MODULE%* module);
+};
+
+%MODULE%Widget::%MODULE%Widget(%MODULE%* module) : ModuleWidget(module) {
 	box.size = Vec(RACK_GRID_WIDTH * %HP%, RACK_GRID_HEIGHT);
 
 	{
@@ -52,6 +52,9 @@ void %MODULE%::step() {
 
 %CREATES%
 }
+
+
+Model* model%MODULE% = Model::create<%MODULE%, %MODULE%Widget>("%MANUFACTURER%", "%MANUFACTURER%-%MODULE%", "%MODULE%");
 TEMPLATE
 
 require 'optparse'
@@ -81,7 +84,7 @@ option_parser = OptionParser.new do |opts|
     options[:output] = 'variables'
     options[:variable_style] = v if v
   end
-  opts.on('--creates', 'Output createParam, etc, lines for each widget') do
+  opts.on('--creates', 'Output ParamWidget::create, etc, lines for each widget') do
     options[:output] = 'creates'
   end
   opts.on('--enums', 'Output param/input/output/light ID enums') do
@@ -227,16 +230,16 @@ def make_creates(widgets_by_type, comments, indent, options)
   i1 = indent ? "\t" : ''
   groups = []
   groups << (widgets_by_type['params'] || []).map do |w|
-    "#{i1}addParam(createParam<#{options[:param_class]}>(#{titleize(w.id)}Position, module, #{options[:module]}::#{w.id}, 0.0, 1.0, 0.0));"
+    "#{i1}addParam(ParamWidget::create<#{options[:param_class]}>(#{titleize(w.id)}Position, module, #{options[:module]}::#{w.id}, 0.0, 1.0, 0.0));"
   end.join("\n")
   groups << (widgets_by_type['inputs'] || []).map do |w|
-    "#{i1}addInput(createInput<#{options[:input_class]}>(#{titleize(w.id)}Position, module, #{options[:module]}::#{w.id}));"
+    "#{i1}addInput(Port::create<#{options[:input_class]}>(#{titleize(w.id)}Position, Port::INPUT, module, #{options[:module]}::#{w.id}));"
   end.join("\n")
   groups << (widgets_by_type['outputs'] || []).map do |w|
-    "#{i1}addOutput(createOutput<#{options[:output_class]}>(#{titleize(w.id)}Position, module, #{options[:module]}::#{w.id}));"
+    "#{i1}addOutput(Port::create<#{options[:output_class]}>(#{titleize(w.id)}Position, Port::OUTPUT, module, #{options[:module]}::#{w.id}));"
   end.join("\n")
   groups << (widgets_by_type['lights'] || []).map do |w|
-    "#{i1}addChild(createLight<#{options[:light_class]}>(#{titleize(w.id)}Position, module, #{options[:module]}::#{w.id}));"
+    "#{i1}addChild(ModuleLightWidget::create<#{options[:light_class]}>(#{titleize(w.id)}Position, module, #{options[:module]}::#{w.id}));"
   end.join("\n")
   s = groups.reject(&:empty?).join("\n\n")
   s = [make_comment(true, indent), s, make_comment(false, indent)].join("\n") if comments
@@ -260,18 +263,18 @@ def make_screws(hp, comments, indent)
   i1 = indent ? "\t" : ''
   ss = []
   if hp <= 6
-    ss << 'addChild(createScrew<ScrewSilver>(Vec(0, 0)));'
-	  ss << 'addChild(createScrew<ScrewSilver>(Vec(box.size.x - 15, 365)));'
+    ss << 'addChild(Widget::create<ScrewSilver>(Vec(0, 0)));'
+    ss << 'addChild(Widget::create<ScrewSilver>(Vec(box.size.x - 15, 365)));'
   elsif hp <= 10
-    ss << 'addChild(createScrew<ScrewSilver>(Vec(0, 0)));'
-    ss << 'addChild(createScrew<ScrewSilver>(Vec(box.size.x - 15, 0)));'
-    ss << 'addChild(createScrew<ScrewSilver>(Vec(0, 365)));'
-    ss << 'addChild(createScrew<ScrewSilver>(Vec(box.size.x - 15, 365)));'
+    ss << 'addChild(Widget::create<ScrewSilver>(Vec(0, 0)));'
+    ss << 'addChild(Widget::create<ScrewSilver>(Vec(box.size.x - 15, 0)));'
+    ss << 'addChild(Widget::create<ScrewSilver>(Vec(0, 365)));'
+    ss << 'addChild(Widget::create<ScrewSilver>(Vec(box.size.x - 15, 365)));'
   else
-    ss << 'addChild(createScrew<ScrewSilver>(Vec(15, 0)));'
-    ss << 'addChild(createScrew<ScrewSilver>(Vec(box.size.x - 30, 0)));'
-    ss << 'addChild(createScrew<ScrewSilver>(Vec(15, 365)));'
-    ss << 'addChild(createScrew<ScrewSilver>(Vec(box.size.x - 30, 365)));'
+    ss << 'addChild(Widget::create<ScrewSilver>(Vec(15, 0)));'
+    ss << 'addChild(Widget::create<ScrewSilver>(Vec(box.size.x - 30, 0)));'
+    ss << 'addChild(Widget::create<ScrewSilver>(Vec(15, 365)));'
+    ss << 'addChild(Widget::create<ScrewSilver>(Vec(box.size.x - 30, 365)));'
   end
   ss = ss.map { |s| "#{i1}#{s}" }
   s = ss.join("\n")
@@ -296,7 +299,7 @@ def make_stub(widgets_by_type, template, options)
     s.gsub!(/%POSITIONS%/, make_variables(widgets_by_type, 'positions', !comments, true))
     s.gsub!(/%CREATES%/, make_creates(widgets_by_type, false, true, options))
   end
-  s.sub!(/\s*\}\s*\Z/, "\n}\n")
+  s.sub!(/\s*\}\s*(Model\*.*)\Z/, "\n}\n\n\n\\1")
   s = [make_comment(true, false), s, make_comment(false, false)].join("\n") if comments
   s
 end
diff --git a/src/Analyzer.cpp b/src/Analyzer.cpp
@@ -127,13 +127,13 @@ struct Analyzer : Module {
 	const int _binAverageN = 2;
 
 	Analyzer() : Module(NUM_PARAMS, NUM_INPUTS, NUM_OUTPUTS, NUM_LIGHTS) {
-		reset();
+		onReset();
 	}
 	virtual ~Analyzer() {
-		reset();
+		onReset();
 	}
 
-	virtual void reset() override;
+	virtual void onReset() override;
 	virtual void onSampleRateChange() override;
 	void resetChannels();
 	SpectrumAnalyzer::Size size();
@@ -141,7 +141,7 @@ struct Analyzer : Module {
 	void stepChannel(ChannelAnalyzer*& channelPointer, bool running, Input& input, Output& output);
 };
 
-void Analyzer::reset() {
+void Analyzer::onReset() {
 	resetChannels();
 }
 
@@ -176,10 +176,10 @@ SpectrumAnalyzer::Size Analyzer::size() {
 }
 
 void Analyzer::step() {
-	_range = clampf(params[RANGE_PARAM].value, 0.1, 1.0);
+	_range = params[RANGE_PARAM].value;
 
 	const float maxTime = 0.5;
-	float smooth = clampf(params[SMOOTH_PARAM].value, 0.0, 1.0) * maxTime;
+	float smooth = params[SMOOTH_PARAM].value * maxTime;
 	smooth /= size() / (_overlap * engineGetSampleRate());
 	int smoothN = std::max(1, (int)roundf(smooth));
 	if (_averageN != smoothN) {
@@ -513,9 +513,11 @@ struct OneTenKnob : Knob38 {
 };
 
 
-AnalyzerWidget::AnalyzerWidget() {
-	auto module = new Analyzer();
-	setModule(module);
+struct AnalyzerWidget : ModuleWidget {
+	AnalyzerWidget(Analyzer* module);
+};
+
+AnalyzerWidget::AnalyzerWidget(Analyzer* module) : ModuleWidget(module) {
 	box.size = Vec(RACK_GRID_WIDTH * 20, RACK_GRID_HEIGHT);
 
 	{
@@ -534,10 +536,10 @@ AnalyzerWidget::AnalyzerWidget() {
 		addChild(display);
 	}
 
-	addChild(createScrew<ScrewSilver>(Vec(15, 0)));
-	addChild(createScrew<ScrewSilver>(Vec(box.size.x - 30, 0)));
-	addChild(createScrew<ScrewSilver>(Vec(15, 365)));
-	addChild(createScrew<ScrewSilver>(Vec(box.size.x - 30, 365)));
+	addChild(Widget::create<ScrewSilver>(Vec(15, 0)));
+	addChild(Widget::create<ScrewSilver>(Vec(box.size.x - 30, 0)));
+	addChild(Widget::create<ScrewSilver>(Vec(15, 365)));
+	addChild(Widget::create<ScrewSilver>(Vec(box.size.x - 30, 365)));
 
 	// generated by svg_widgets.rb
 	auto rangeParamPosition = Vec(35.08, 271.08);
@@ -560,22 +562,25 @@ AnalyzerWidget::AnalyzerWidget() {
 	auto powerOnLightPosition = Vec(252.0, 289.0);
 	// end generated by svg_widgets.rb
 
-	addParam(createParam<OneTenKnob>(rangeParamPosition, module, Analyzer::RANGE_PARAM, 0.1, 1.0, 0.5));
-	addParam(createParam<Knob38>(smoothParamPosition, module, Analyzer::SMOOTH_PARAM, 0.0, 1.0, 0.5));
-	addParam(createParam<StatefulButton9>(qualityParamPosition, module, Analyzer::QUALITY_PARAM, 1.0, 2.0, 1.0));
-	addParam(createParam<StatefulButton9>(powerParamPosition, module, Analyzer::POWER_PARAM, 0.0, 1.0, 1.0));
+	addParam(ParamWidget::create<OneTenKnob>(rangeParamPosition, module, Analyzer::RANGE_PARAM, 0.1, 1.0, 0.5));
+	addParam(ParamWidget::create<Knob38>(smoothParamPosition, module, Analyzer::SMOOTH_PARAM, 0.0, 1.0, 0.5));
+	addParam(ParamWidget::create<StatefulButton9>(qualityParamPosition, module, Analyzer::QUALITY_PARAM, 1.0, 2.0, 1.0));
+	addParam(ParamWidget::create<StatefulButton9>(powerParamPosition, module, Analyzer::POWER_PARAM, 0.0, 1.0, 1.0));
 
-	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));
+	addInput(Port::create<Port24>(signalaInputPosition, Port::INPUT, module, Analyzer::SIGNALA_INPUT));
+	addInput(Port::create<Port24>(signalbInputPosition, Port::INPUT, module, Analyzer::SIGNALB_INPUT));
+	addInput(Port::create<Port24>(signalcInputPosition, Port::INPUT, module, Analyzer::SIGNALC_INPUT));
+	addInput(Port::create<Port24>(signaldInputPosition, Port::INPUT, 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));
+	addOutput(Port::create<Port24>(signalaOutputPosition, Port::OUTPUT, module, Analyzer::SIGNALA_OUTPUT));
+	addOutput(Port::create<Port24>(signalbOutputPosition, Port::OUTPUT, module, Analyzer::SIGNALB_OUTPUT));
+	addOutput(Port::create<Port24>(signalcOutputPosition, Port::OUTPUT, module, Analyzer::SIGNALC_OUTPUT));
+	addOutput(Port::create<Port24>(signaldOutputPosition, Port::OUTPUT, module, Analyzer::SIGNALD_OUTPUT));
 
-	addChild(createLight<TinyLight<GreenLight>>(qualityHighLightPosition, module, Analyzer::QUALITY_HIGH_LIGHT));
-	addChild(createLight<TinyLight<GreenLight>>(qualityGoodLightPosition, module, Analyzer::QUALITY_GOOD_LIGHT));
-	addChild(createLight<TinyLight<GreenLight>>(powerOnLightPosition, module, Analyzer::POWER_ON_LIGHT));
+	addChild(ModuleLightWidget::create<TinyLight<GreenLight>>(qualityHighLightPosition, module, Analyzer::QUALITY_HIGH_LIGHT));
+	addChild(ModuleLightWidget::create<TinyLight<GreenLight>>(qualityGoodLightPosition, module, Analyzer::QUALITY_GOOD_LIGHT));
+	addChild(ModuleLightWidget::create<TinyLight<GreenLight>>(powerOnLightPosition, module, Analyzer::POWER_ON_LIGHT));
 }
+
+
+Model* modelAnalyzer = Model::create<Analyzer, AnalyzerWidget>("Bogaudio", "Bogaudio-Analyzer", "Analyzer", VISUAL_TAG);
diff --git a/src/DADSRH.cpp b/src/DADSRH.cpp
@@ -109,10 +109,10 @@ struct DADSRH : TriggerOnLoadModule {
 		_triggerOnLoad,
 		_shouldTriggerOnLoad
 	) {
-		reset();
+		onReset();
 	}
 
-	virtual void reset() override {
+	virtual void onReset() override {
 		_core.reset();
 	}
 
@@ -126,9 +126,12 @@ struct DADSRH : TriggerOnLoadModule {
 };
 
 
-DADSRHWidget::DADSRHWidget() {
-	DADSRH *module = new DADSRH();
-	setModule(module);
+struct DADSRHWidget : ModuleWidget {
+	DADSRHWidget(DADSRH* module);
+	virtual Menu* createContextMenu() override;
+};
+
+DADSRHWidget::DADSRHWidget(DADSRH* module) : ModuleWidget(module) {
 	box.size = Vec(RACK_GRID_WIDTH * 10, RACK_GRID_HEIGHT);
 
 	{
@@ -138,10 +141,10 @@ DADSRHWidget::DADSRHWidget() {
 		addChild(panel);
 	}
 
-	addChild(createScrew<ScrewSilver>(Vec(0, 0)));
-	addChild(createScrew<ScrewSilver>(Vec(box.size.x - 15, 0)));
-	addChild(createScrew<ScrewSilver>(Vec(0, 365)));
-	addChild(createScrew<ScrewSilver>(Vec(box.size.x - 15, 365)));
+	addChild(Widget::create<ScrewSilver>(Vec(0, 0)));
+	addChild(Widget::create<ScrewSilver>(Vec(box.size.x - 15, 0)));
+	addChild(Widget::create<ScrewSilver>(Vec(0, 365)));
+	addChild(Widget::create<ScrewSilver>(Vec(box.size.x - 15, 365)));
 
 	// generated by svg_widgets.rb
 	auto delayParamPosition = Vec(27.08, 33.08);
@@ -181,41 +184,41 @@ DADSRHWidget::DADSRHWidget() {
 	auto releaseShape3LightPosition = Vec(77.0, 284.5);
 	// end generated by svg_widgets.rb
 
-	addParam(createParam<Knob38>(delayParamPosition, module, DADSRH::DELAY_PARAM, 0.0, 1.0, 0.0));
-	addParam(createParam<Knob38>(attackParamPosition, module, DADSRH::ATTACK_PARAM, 0.0, 1.0, 0.12));
-	addParam(createParam<Knob38>(decayParamPosition, module, DADSRH::DECAY_PARAM, 0.0, 1.0, 0.32));
-	addParam(createParam<Knob38>(sustainParamPosition, module, DADSRH::SUSTAIN_PARAM, 0.0, 1.0, 0.5));
-	addParam(createParam<Knob38>(releaseParamPosition, module, DADSRH::RELEASE_PARAM, 0.0, 1.0, 0.32));
-	addParam(createParam<Knob38>(holdParamPosition, module, DADSRH::HOLD_PARAM, 0.0, 1.0, 0.45));
-	addParam(createParam<StatefulButton9>(attackShapeParamPosition, module, DADSRH::ATTACK_SHAPE_PARAM, 1.0, 3.0, 1.0));
-	addParam(createParam<StatefulButton9>(decayShapeParamPosition, module, DADSRH::DECAY_SHAPE_PARAM, 1.0, 3.0, 1.0));
-	addParam(createParam<StatefulButton9>(releaseShapeParamPosition, module, DADSRH::RELEASE_SHAPE_PARAM, 1.0, 3.0, 1.0));
-	addParam(createParam<Button18>(triggerParamPosition, module, DADSRH::TRIGGER_PARAM, 0.0, 1.0, 0.0));
-	addParam(createParam<SliderSwitch2State14>(modeParamPosition, module, DADSRH::MODE_PARAM, 0.0, 1.0, 1.0));
-	addParam(createParam<SliderSwitch2State14>(loopParamPosition, module, DADSRH::LOOP_PARAM, 0.0, 1.0, 1.0));
-	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(createInput<Port24>(triggerInputPosition, module, DADSRH::TRIGGER_INPUT));
-
-	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));
-	addChild(createLight<TinyLight<GreenLight>>(decayLightPosition, module, DADSRH::DECAY_LIGHT));
-	addChild(createLight<TinyLight<GreenLight>>(sustainLightPosition, module, DADSRH::SUSTAIN_LIGHT));
-	addChild(createLight<TinyLight<GreenLight>>(releaseLightPosition, module, DADSRH::RELEASE_LIGHT));
-	addChild(createLight<TinyLight<GreenLight>>(attackShape1LightPosition, module, DADSRH::ATTACK_SHAPE1_LIGHT));
-	addChild(createLight<TinyLight<GreenLight>>(attackShape2LightPosition, module, DADSRH::ATTACK_SHAPE2_LIGHT));
-	addChild(createLight<TinyLight<GreenLight>>(attackShape3LightPosition, module, DADSRH::ATTACK_SHAPE3_LIGHT));
-	addChild(createLight<TinyLight<GreenLight>>(decayShape1LightPosition, module, DADSRH::DECAY_SHAPE1_LIGHT));
-	addChild(createLight<TinyLight<GreenLight>>(decayShape2LightPosition, module, DADSRH::DECAY_SHAPE2_LIGHT));
-	addChild(createLight<TinyLight<GreenLight>>(decayShape3LightPosition, module, DADSRH::DECAY_SHAPE3_LIGHT));
-	addChild(createLight<TinyLight<GreenLight>>(releaseShape1LightPosition, module, DADSRH::RELEASE_SHAPE1_LIGHT));
-	addChild(createLight<TinyLight<GreenLight>>(releaseShape2LightPosition, module, DADSRH::RELEASE_SHAPE2_LIGHT));
-	addChild(createLight<TinyLight<GreenLight>>(releaseShape3LightPosition, module, DADSRH::RELEASE_SHAPE3_LIGHT));
+	addParam(ParamWidget::create<Knob38>(delayParamPosition, module, DADSRH::DELAY_PARAM, 0.0, 1.0, 0.0));
+	addParam(ParamWidget::create<Knob38>(attackParamPosition, module, DADSRH::ATTACK_PARAM, 0.0, 1.0, 0.12));
+	addParam(ParamWidget::create<Knob38>(decayParamPosition, module, DADSRH::DECAY_PARAM, 0.0, 1.0, 0.32));
+	addParam(ParamWidget::create<Knob38>(sustainParamPosition, module, DADSRH::SUSTAIN_PARAM, 0.0, 1.0, 0.5));
+	addParam(ParamWidget::create<Knob38>(releaseParamPosition, module, DADSRH::RELEASE_PARAM, 0.0, 1.0, 0.32));
+	addParam(ParamWidget::create<Knob38>(holdParamPosition, module, DADSRH::HOLD_PARAM, 0.0, 1.0, 0.45));
+	addParam(ParamWidget::create<StatefulButton9>(attackShapeParamPosition, module, DADSRH::ATTACK_SHAPE_PARAM, 1.0, 3.0, 1.0));
+	addParam(ParamWidget::create<StatefulButton9>(decayShapeParamPosition, module, DADSRH::DECAY_SHAPE_PARAM, 1.0, 3.0, 1.0));
+	addParam(ParamWidget::create<StatefulButton9>(releaseShapeParamPosition, module, DADSRH::RELEASE_SHAPE_PARAM, 1.0, 3.0, 1.0));
+	addParam(ParamWidget::create<Button18>(triggerParamPosition, module, DADSRH::TRIGGER_PARAM, 0.0, 1.0, 0.0));
+	addParam(ParamWidget::create<SliderSwitch2State14>(modeParamPosition, module, DADSRH::MODE_PARAM, 0.0, 1.0, 1.0));
+	addParam(ParamWidget::create<SliderSwitch2State14>(loopParamPosition, module, DADSRH::LOOP_PARAM, 0.0, 1.0, 1.0));
+	addParam(ParamWidget::create<SliderSwitch2State14>(speedParamPosition, module, DADSRH::SPEED_PARAM, 0.0, 1.0, 1.0));
+	addParam(ParamWidget::create<SliderSwitch2State14>(retriggerParamPosition, module, DADSRH::RETRIGGER_PARAM, 0.0, 1.0, 1.0));
+
+	addInput(Port::create<Port24>(triggerInputPosition, Port::INPUT, module, DADSRH::TRIGGER_INPUT));
+
+	addOutput(Port::create<Port24>(envOutputPosition, Port::OUTPUT, module, DADSRH::ENV_OUTPUT));
+	addOutput(Port::create<Port24>(invOutputPosition, Port::OUTPUT, module, DADSRH::INV_OUTPUT));
+	addOutput(Port::create<Port24>(triggerOutputPosition, Port::OUTPUT, module, DADSRH::TRIGGER_OUTPUT));
+
+	addChild(ModuleLightWidget::create<TinyLight<GreenLight>>(delayLightPosition, module, DADSRH::DELAY_LIGHT));
+	addChild(ModuleLightWidget::create<TinyLight<GreenLight>>(attackLightPosition, module, DADSRH::ATTACK_LIGHT));
+	addChild(ModuleLightWidget::create<TinyLight<GreenLight>>(decayLightPosition, module, DADSRH::DECAY_LIGHT));
+	addChild(ModuleLightWidget::create<TinyLight<GreenLight>>(sustainLightPosition, module, DADSRH::SUSTAIN_LIGHT));
+	addChild(ModuleLightWidget::create<TinyLight<GreenLight>>(releaseLightPosition, module, DADSRH::RELEASE_LIGHT));
+	addChild(ModuleLightWidget::create<TinyLight<GreenLight>>(attackShape1LightPosition, module, DADSRH::ATTACK_SHAPE1_LIGHT));
+	addChild(ModuleLightWidget::create<TinyLight<GreenLight>>(attackShape2LightPosition, module, DADSRH::ATTACK_SHAPE2_LIGHT));
+	addChild(ModuleLightWidget::create<TinyLight<GreenLight>>(attackShape3LightPosition, module, DADSRH::ATTACK_SHAPE3_LIGHT));
+	addChild(ModuleLightWidget::create<TinyLight<GreenLight>>(decayShape1LightPosition, module, DADSRH::DECAY_SHAPE1_LIGHT));
+	addChild(ModuleLightWidget::create<TinyLight<GreenLight>>(decayShape2LightPosition, module, DADSRH::DECAY_SHAPE2_LIGHT));
+	addChild(ModuleLightWidget::create<TinyLight<GreenLight>>(decayShape3LightPosition, module, DADSRH::DECAY_SHAPE3_LIGHT));
+	addChild(ModuleLightWidget::create<TinyLight<GreenLight>>(releaseShape1LightPosition, module, DADSRH::RELEASE_SHAPE1_LIGHT));
+	addChild(ModuleLightWidget::create<TinyLight<GreenLight>>(releaseShape2LightPosition, module, DADSRH::RELEASE_SHAPE2_LIGHT));
+	addChild(ModuleLightWidget::create<TinyLight<GreenLight>>(releaseShape3LightPosition, module, DADSRH::RELEASE_SHAPE3_LIGHT));
 }
 
 Menu* DADSRHWidget::createContextMenu() {
@@ -226,3 +229,6 @@ Menu* DADSRHWidget::createContextMenu() {
 	menu->addChild(new TriggerOnLoadMenuItem(dadsrh, "Resume Loop on Load"));
 	return menu;
 }
+
+
+Model* modelDADSRH = Model::create<DADSRH, DADSRHWidget>("Bogaudio", "Bogaudio-DADSRH", "DADSR(H)", ENVELOPE_GENERATOR_TAG);
diff --git a/src/DADSRHPlus.cpp b/src/DADSRHPlus.cpp
@@ -120,10 +120,10 @@ struct DADSRHPlus : TriggerOnLoadModule {
 		_triggerOnLoad,
 		_shouldTriggerOnLoad
 	) {
-		reset();
+		onReset();
 	}
 
-	virtual void reset() override {
+	virtual void onReset() override {
 		_core.reset();
 	}
 
@@ -136,9 +136,13 @@ struct DADSRHPlus : TriggerOnLoadModule {
 	}
 };
 
-DADSRHPlusWidget::DADSRHPlusWidget() {
-	DADSRHPlus *module = new DADSRHPlus();
-	setModule(module);
+
+struct DADSRHPlusWidget : ModuleWidget {
+	DADSRHPlusWidget(DADSRHPlus* module);
+	virtual Menu* createContextMenu() override;
+};
+
+DADSRHPlusWidget::DADSRHPlusWidget(DADSRHPlus* module) : ModuleWidget(module) {
 	box.size = Vec(RACK_GRID_WIDTH * 15, RACK_GRID_HEIGHT);
 
 	{
@@ -148,10 +152,10 @@ DADSRHPlusWidget::DADSRHPlusWidget() {
 		addChild(panel);
 	}
 
-	addChild(createScrew<ScrewSilver>(Vec(15, 0)));
-	addChild(createScrew<ScrewSilver>(Vec(box.size.x - 30, 0)));
-	addChild(createScrew<ScrewSilver>(Vec(15, 365)));
-	addChild(createScrew<ScrewSilver>(Vec(box.size.x - 30, 365)));
+	addChild(Widget::create<ScrewSilver>(Vec(15, 0)));
+	addChild(Widget::create<ScrewSilver>(Vec(box.size.x - 30, 0)));
+	addChild(Widget::create<ScrewSilver>(Vec(15, 365)));
+	addChild(Widget::create<ScrewSilver>(Vec(box.size.x - 30, 365)));
 
 	// generated by svg_widgets.rb
 	auto delayParamPosition = Vec(27.08, 33.08);
@@ -202,52 +206,52 @@ DADSRHPlusWidget::DADSRHPlusWidget() {
 	auto releaseShape3LightPosition = Vec(77.0, 284.5);
 	// end generated by svg_widgets.rb
 
-	addParam(createParam<Knob38>(delayParamPosition, module, DADSRHPlus::DELAY_PARAM, 0.0, 1.0, 0.0));
-	addParam(createParam<Knob38>(attackParamPosition, module, DADSRHPlus::ATTACK_PARAM, 0.0, 1.0, 0.12));
-	addParam(createParam<Knob38>(decayParamPosition, module, DADSRHPlus::DECAY_PARAM, 0.0, 1.0, 0.32));
-	addParam(createParam<Knob38>(sustainParamPosition, module, DADSRHPlus::SUSTAIN_PARAM, 0.0, 1.0, 0.5));
-	addParam(createParam<Knob38>(releaseParamPosition, module, DADSRHPlus::RELEASE_PARAM, 0.0, 1.0, 0.32));
-	addParam(createParam<Knob38>(holdParamPosition, module, DADSRHPlus::HOLD_PARAM, 0.0, 1.0, 0.45));
-	addParam(createParam<StatefulButton9>(attackShapeParamPosition, module, DADSRHPlus::ATTACK_SHAPE_PARAM, 1.0, 3.0, 1.0));
-	addParam(createParam<StatefulButton9>(decayShapeParamPosition, module, DADSRHPlus::DECAY_SHAPE_PARAM, 1.0, 3.0, 1.0));
-	addParam(createParam<StatefulButton9>(releaseShapeParamPosition, module, DADSRHPlus::RELEASE_SHAPE_PARAM, 1.0, 3.0, 1.0));
-	addParam(createParam<Button18>(triggerParamPosition, module, DADSRHPlus::TRIGGER_PARAM, 0.0, 1.0, 0.0));
-	addParam(createParam<SliderSwitch2State14>(modeParamPosition, module, DADSRHPlus::MODE_PARAM, 0.0, 1.0, 1.0));
-	addParam(createParam<SliderSwitch2State14>(loopParamPosition, module, DADSRHPlus::LOOP_PARAM, 0.0, 1.0, 1.0));
-	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));
+	addParam(ParamWidget::create<Knob38>(delayParamPosition, module, DADSRHPlus::DELAY_PARAM, 0.0, 1.0, 0.0));
+	addParam(ParamWidget::create<Knob38>(attackParamPosition, module, DADSRHPlus::ATTACK_PARAM, 0.0, 1.0, 0.12));
+	addParam(ParamWidget::create<Knob38>(decayParamPosition, module, DADSRHPlus::DECAY_PARAM, 0.0, 1.0, 0.32));
+	addParam(ParamWidget::create<Knob38>(sustainParamPosition, module, DADSRHPlus::SUSTAIN_PARAM, 0.0, 1.0, 0.5));
+	addParam(ParamWidget::create<Knob38>(releaseParamPosition, module, DADSRHPlus::RELEASE_PARAM, 0.0, 1.0, 0.32));
+	addParam(ParamWidget::create<Knob38>(holdParamPosition, module, DADSRHPlus::HOLD_PARAM, 0.0, 1.0, 0.45));
+	addParam(ParamWidget::create<StatefulButton9>(attackShapeParamPosition, module, DADSRHPlus::ATTACK_SHAPE_PARAM, 1.0, 3.0, 1.0));
+	addParam(ParamWidget::create<StatefulButton9>(decayShapeParamPosition, module, DADSRHPlus::DECAY_SHAPE_PARAM, 1.0, 3.0, 1.0));
+	addParam(ParamWidget::create<StatefulButton9>(releaseShapeParamPosition, module, DADSRHPlus::RELEASE_SHAPE_PARAM, 1.0, 3.0, 1.0));
+	addParam(ParamWidget::create<Button18>(triggerParamPosition, module, DADSRHPlus::TRIGGER_PARAM, 0.0, 1.0, 0.0));
+	addParam(ParamWidget::create<SliderSwitch2State14>(modeParamPosition, module, DADSRHPlus::MODE_PARAM, 0.0, 1.0, 1.0));
+	addParam(ParamWidget::create<SliderSwitch2State14>(loopParamPosition, module, DADSRHPlus::LOOP_PARAM, 0.0, 1.0, 1.0));
+	addParam(ParamWidget::create<SliderSwitch2State14>(speedParamPosition, module, DADSRHPlus::SPEED_PARAM, 0.0, 1.0, 1.0));
+	addParam(ParamWidget::create<SliderSwitch2State14>(retriggerParamPosition, module, DADSRHPlus::RETRIGGER_PARAM, 0.0, 1.0, 1.0));
 
-	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));
+	addInput(Port::create<Port24>(delayInputPosition, Port::INPUT, module, DADSRHPlus::DELAY_INPUT));
+	addInput(Port::create<Port24>(attackInputPosition, Port::INPUT, module, DADSRHPlus::ATTACK_INPUT));
+	addInput(Port::create<Port24>(decayInputPosition, Port::INPUT, module, DADSRHPlus::DECAY_INPUT));
+	addInput(Port::create<Port24>(sustainInputPosition, Port::INPUT, module, DADSRHPlus::SUSTAIN_INPUT));
+	addInput(Port::create<Port24>(releaseInputPosition, Port::INPUT, module, DADSRHPlus::RELEASE_INPUT));
+	addInput(Port::create<Port24>(holdInputPosition, Port::INPUT, module, DADSRHPlus::HOLD_INPUT));
+	addInput(Port::create<Port24>(triggerInputPosition, Port::INPUT, module, DADSRHPlus::TRIGGER_INPUT));
 
-	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));
+	addOutput(Port::create<Port24>(delayOutputPosition, Port::OUTPUT, module, DADSRHPlus::DELAY_OUTPUT));
+	addOutput(Port::create<Port24>(attackOutputPosition, Port::OUTPUT, module, DADSRHPlus::ATTACK_OUTPUT));
+	addOutput(Port::create<Port24>(decayOutputPosition, Port::OUTPUT, module, DADSRHPlus::DECAY_OUTPUT));
+	addOutput(Port::create<Port24>(sustainOutputPosition, Port::OUTPUT, module, DADSRHPlus::SUSTAIN_OUTPUT));
+	addOutput(Port::create<Port24>(releaseOutputPosition, Port::OUTPUT, module, DADSRHPlus::RELEASE_OUTPUT));
+	addOutput(Port::create<Port24>(envOutputPosition, Port::OUTPUT, module, DADSRHPlus::ENV_OUTPUT));
+	addOutput(Port::create<Port24>(invOutputPosition, Port::OUTPUT, module, DADSRHPlus::INV_OUTPUT));
+	addOutput(Port::create<Port24>(triggerOutputPosition, Port::OUTPUT, module, DADSRHPlus::TRIGGER_OUTPUT));
 
-	addChild(createLight<TinyLight<GreenLight>>(delayLightPosition, module, DADSRHPlus::DELAY_LIGHT));
-	addChild(createLight<TinyLight<GreenLight>>(attackLightPosition, module, DADSRHPlus::ATTACK_LIGHT));
-	addChild(createLight<TinyLight<GreenLight>>(decayLightPosition, module, DADSRHPlus::DECAY_LIGHT));
-	addChild(createLight<TinyLight<GreenLight>>(sustainLightPosition, module, DADSRHPlus::SUSTAIN_LIGHT));
-	addChild(createLight<TinyLight<GreenLight>>(releaseLightPosition, module, DADSRHPlus::RELEASE_LIGHT));
-	addChild(createLight<TinyLight<GreenLight>>(attackShape1LightPosition, module, DADSRHPlus::ATTACK_SHAPE1_LIGHT));
-	addChild(createLight<TinyLight<GreenLight>>(attackShape2LightPosition, module, DADSRHPlus::ATTACK_SHAPE2_LIGHT));
-	addChild(createLight<TinyLight<GreenLight>>(attackShape3LightPosition, module, DADSRHPlus::ATTACK_SHAPE3_LIGHT));
-	addChild(createLight<TinyLight<GreenLight>>(decayShape1LightPosition, module, DADSRHPlus::DECAY_SHAPE1_LIGHT));
-	addChild(createLight<TinyLight<GreenLight>>(decayShape2LightPosition, module, DADSRHPlus::DECAY_SHAPE2_LIGHT));
-	addChild(createLight<TinyLight<GreenLight>>(decayShape3LightPosition, module, DADSRHPlus::DECAY_SHAPE3_LIGHT));
-	addChild(createLight<TinyLight<GreenLight>>(releaseShape1LightPosition, module, DADSRHPlus::RELEASE_SHAPE1_LIGHT));
-	addChild(createLight<TinyLight<GreenLight>>(releaseShape2LightPosition, module, DADSRHPlus::RELEASE_SHAPE2_LIGHT));
-	addChild(createLight<TinyLight<GreenLight>>(releaseShape3LightPosition, module, DADSRHPlus::RELEASE_SHAPE3_LIGHT));
+	addChild(ModuleLightWidget::create<TinyLight<GreenLight>>(delayLightPosition, module, DADSRHPlus::DELAY_LIGHT));
+	addChild(ModuleLightWidget::create<TinyLight<GreenLight>>(attackLightPosition, module, DADSRHPlus::ATTACK_LIGHT));
+	addChild(ModuleLightWidget::create<TinyLight<GreenLight>>(decayLightPosition, module, DADSRHPlus::DECAY_LIGHT));
+	addChild(ModuleLightWidget::create<TinyLight<GreenLight>>(sustainLightPosition, module, DADSRHPlus::SUSTAIN_LIGHT));
+	addChild(ModuleLightWidget::create<TinyLight<GreenLight>>(releaseLightPosition, module, DADSRHPlus::RELEASE_LIGHT));
+	addChild(ModuleLightWidget::create<TinyLight<GreenLight>>(attackShape1LightPosition, module, DADSRHPlus::ATTACK_SHAPE1_LIGHT));
+	addChild(ModuleLightWidget::create<TinyLight<GreenLight>>(attackShape2LightPosition, module, DADSRHPlus::ATTACK_SHAPE2_LIGHT));
+	addChild(ModuleLightWidget::create<TinyLight<GreenLight>>(attackShape3LightPosition, module, DADSRHPlus::ATTACK_SHAPE3_LIGHT));
+	addChild(ModuleLightWidget::create<TinyLight<GreenLight>>(decayShape1LightPosition, module, DADSRHPlus::DECAY_SHAPE1_LIGHT));
+	addChild(ModuleLightWidget::create<TinyLight<GreenLight>>(decayShape2LightPosition, module, DADSRHPlus::DECAY_SHAPE2_LIGHT));
+	addChild(ModuleLightWidget::create<TinyLight<GreenLight>>(decayShape3LightPosition, module, DADSRHPlus::DECAY_SHAPE3_LIGHT));
+	addChild(ModuleLightWidget::create<TinyLight<GreenLight>>(releaseShape1LightPosition, module, DADSRHPlus::RELEASE_SHAPE1_LIGHT));
+	addChild(ModuleLightWidget::create<TinyLight<GreenLight>>(releaseShape2LightPosition, module, DADSRHPlus::RELEASE_SHAPE2_LIGHT));
+	addChild(ModuleLightWidget::create<TinyLight<GreenLight>>(releaseShape3LightPosition, module, DADSRHPlus::RELEASE_SHAPE3_LIGHT));
 }
 
 Menu* DADSRHPlusWidget::createContextMenu() {
@@ -258,3 +262,6 @@ Menu* DADSRHPlusWidget::createContextMenu() {
 	menu->addChild(new TriggerOnLoadMenuItem(dadsrhPlus, "Resume Loop on Load"));
 	return menu;
 }
+
+
+Model* modelDADSRHPlus = Model::create<DADSRHPlus, DADSRHPlusWidget>("Bogaudio", "Bogaudio-DADSRHPlus", "DADSR(H)+", ENVELOPE_GENERATOR_TAG);
diff --git a/src/DGate.cpp b/src/DGate.cpp
@@ -40,10 +40,10 @@ struct DGate : TriggerOnLoadModule {
 	float _stageProgress;
 
 	DGate() : TriggerOnLoadModule(NUM_PARAMS, NUM_INPUTS, NUM_OUTPUTS, NUM_LIGHTS) {
-		reset();
+		onReset();
 	}
 
-	virtual void reset() override;
+	virtual void onReset() override;
 	virtual void step() override;
 	bool stepStage(Param& knob);
 	virtual bool shouldTriggerOnNextLoad() override {
@@ -51,7 +51,7 @@ struct DGate : TriggerOnLoadModule {
 	};
 };
 
-void DGate::reset() {
+void DGate::onReset() {
 	_trigger.reset();
 	_triggerOuptutPulseGen.process(10.0);
 	_stage = STOPPED_STAGE;
@@ -112,7 +112,7 @@ void DGate::step() {
 }
 
 bool DGate::stepStage(Param& knob) {
-	float t = clampf(knob.value, 0.0, 1.0);
+	float t = knob.value;
 	t = pow(t, 2);
 	t = fmaxf(t, 0.001);
 	t *= 10.0;
@@ -121,9 +121,12 @@ bool DGate::stepStage(Param& knob) {
 }
 
 
-DGateWidget::DGateWidget() {
-	DGate *module = new DGate();
-	setModule(module);
+struct DGateWidget : ModuleWidget {
+	DGateWidget(DGate* module);
+	virtual Menu* createContextMenu() override;
+};
+
+DGateWidget::DGateWidget(DGate* module) : ModuleWidget(module) {
 	box.size = Vec(RACK_GRID_WIDTH * 3, RACK_GRID_HEIGHT);
 
 	{
@@ -133,8 +136,8 @@ DGateWidget::DGateWidget() {
 		addChild(panel);
 	}
 
-	addChild(createScrew<ScrewSilver>(Vec(0, 0)));
-	addChild(createScrew<ScrewSilver>(Vec(box.size.x - 15, 365)));
+	addChild(Widget::create<ScrewSilver>(Vec(0, 0)));
+	addChild(Widget::create<ScrewSilver>(Vec(box.size.x - 15, 365)));
 
 	// generated by svg_widgets.rb
 	auto delayParamPosition = Vec(7.5, 32.5);
@@ -151,18 +154,18 @@ DGateWidget::DGateWidget() {
 	auto gateLightPosition = Vec(20.8, 124.0);
 	// end generated by svg_widgets.rb
 
-	addParam(createParam<Knob29>(delayParamPosition, module, DGate::DELAY_PARAM, 0.0, 1.0, 0.0));
-	addParam(createParam<Knob29>(gateParamPosition, module, DGate::GATE_PARAM, 0.0, 1.0, 0.32));
-	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));
+	addParam(ParamWidget::create<Knob29>(delayParamPosition, module, DGate::DELAY_PARAM, 0.0, 1.0, 0.0));
+	addParam(ParamWidget::create<Knob29>(gateParamPosition, module, DGate::GATE_PARAM, 0.0, 1.0, 0.32));
+	addParam(ParamWidget::create<SliderSwitch2State14>(loopParamPosition, module, DGate::LOOP_PARAM, 0.0, 1.0, 1.0));
+	addParam(ParamWidget::create<Button18>(triggerParamPosition, module, DGate::TRIGGER_PARAM, 0.0, 1.0, 0.0));
 
-	addInput(createInput<Port24>(triggerInputPosition, module, DGate::TRIGGER_INPUT));
+	addInput(Port::create<Port24>(triggerInputPosition, Port::INPUT, module, DGate::TRIGGER_INPUT));
 
-	addOutput(createOutput<Port24>(gateOutputPosition, module, DGate::GATE_OUTPUT));
-	addOutput(createOutput<Port24>(endOutputPosition, module, DGate::END_OUTPUT));
+	addOutput(Port::create<Port24>(gateOutputPosition, Port::OUTPUT, module, DGate::GATE_OUTPUT));
+	addOutput(Port::create<Port24>(endOutputPosition, Port::OUTPUT, module, DGate::END_OUTPUT));
 
-	addChild(createLight<TinyLight<GreenLight>>(delayLightPosition, module, DGate::DELAY_LIGHT));
-	addChild(createLight<TinyLight<GreenLight>>(gateLightPosition, module, DGate::GATE_LIGHT));
+	addChild(ModuleLightWidget::create<TinyLight<GreenLight>>(delayLightPosition, module, DGate::DELAY_LIGHT));
+	addChild(ModuleLightWidget::create<TinyLight<GreenLight>>(gateLightPosition, module, DGate::GATE_LIGHT));
 }
 
 Menu* DGateWidget::createContextMenu() {
@@ -173,3 +176,6 @@ Menu* DGateWidget::createContextMenu() {
 	menu->addChild(new TriggerOnLoadMenuItem(dgate, "Resume Loop on Load"));
 	return menu;
 }
+
+
+Model* modelDGate = Model::create<DGate, DGateWidget>("Bogaudio", "Bogaudio-DGate", "DGate", UTILITY_TAG);
diff --git a/src/Detune.cpp b/src/Detune.cpp
@@ -40,7 +40,7 @@ void Detune::step() {
 
 	float cents = params[CENTS_PARAM].value;
 	if (inputs[CV_INPUT].active) {
-		cents *= clampf(inputs[CV_INPUT].value, 0.0, 10.0) / 10.0;
+		cents *= clamp(inputs[CV_INPUT].value, 0.0f, 10.0f) / 10.0;
 		cents = roundf(cents);
 	}
 	cents /= 100.0;
@@ -72,9 +72,11 @@ void Detune::step() {
 }
 
 
-DetuneWidget::DetuneWidget() {
-	Detune *module = new Detune();
-	setModule(module);
+struct DetuneWidget : ModuleWidget {
+	DetuneWidget(Detune* module);
+};
+
+DetuneWidget::DetuneWidget(Detune* module) : ModuleWidget(module) {
 	box.size = Vec(RACK_GRID_WIDTH * 3, RACK_GRID_HEIGHT);
 
 	{
@@ -84,8 +86,8 @@ DetuneWidget::DetuneWidget() {
 		addChild(panel);
 	}
 
-	addChild(createScrew<ScrewSilver>(Vec(0, 0)));
-	addChild(createScrew<ScrewSilver>(Vec(box.size.x - 15, 365)));
+	addChild(Widget::create<ScrewSilver>(Vec(0, 0)));
+	addChild(Widget::create<ScrewSilver>(Vec(box.size.x - 15, 365)));
 
 	// generated by svg_widgets.rb
 	auto centsParamPosition = Vec(9.5, 32.5);
@@ -99,15 +101,18 @@ DetuneWidget::DetuneWidget() {
 	// end generated by svg_widgets.rb
 
 	{
-		auto w = createParam<Knob26>(centsParamPosition, module, Detune::CENTS_PARAM, 0.0, 50.0, 0.0);
+		auto w = ParamWidget::create<Knob26>(centsParamPosition, module, Detune::CENTS_PARAM, 0.0, 50.0, 0.0);
 		dynamic_cast<Knob*>(w)->snap = true;
 		addParam(w);
 	}
 
-	addInput(createInput<Port24>(cvInputPosition, module, Detune::CV_INPUT));
-	addInput(createInput<Port24>(inInputPosition, module, Detune::IN_INPUT));
+	addInput(Port::create<Port24>(cvInputPosition, Port::INPUT, module, Detune::CV_INPUT));
+	addInput(Port::create<Port24>(inInputPosition, Port::INPUT, module, Detune::IN_INPUT));
 
-	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));
+	addOutput(Port::create<Port24>(thruOutputPosition, Port::OUTPUT, module, Detune::THRU_OUTPUT));
+	addOutput(Port::create<Port24>(outPlusOutputPosition, Port::OUTPUT, module, Detune::OUT_PLUS_OUTPUT));
+	addOutput(Port::create<Port24>(outMinusOutputPosition, Port::OUTPUT, module, Detune::OUT_MINUS_OUTPUT));
 }
+
+
+Model* modelDetune = Model::create<Detune, DetuneWidget>("Bogaudio", "Bogaudio-Detune", "Detune");
diff --git a/src/Manual.cpp b/src/Manual.cpp
@@ -31,14 +31,14 @@ struct Manual : Module {
 	PulseGenerator _pulse;
 
 	Manual() : Module(NUM_PARAMS, NUM_INPUTS, NUM_OUTPUTS, NUM_LIGHTS) {
-		reset();
+		onReset();
 	}
 
-	virtual void reset() override;
+	virtual void onReset() override;
 	virtual void step() override;
 };
 
-void Manual::reset() {
+void Manual::onReset() {
 	_trigger.reset();
 	_pulse.process(10.0);
 }
@@ -65,9 +65,11 @@ void Manual::step() {
 }
 
 
-ManualWidget::ManualWidget() {
-	Manual *module = new Manual();
-	setModule(module);
+struct ManualWidget : ModuleWidget {
+	ManualWidget(Manual* module);
+};
+
+ManualWidget::ManualWidget(Manual* module) : ModuleWidget(module) {
 	box.size = Vec(RACK_GRID_WIDTH * 3, RACK_GRID_HEIGHT);
 
 	{
@@ -77,8 +79,8 @@ ManualWidget::ManualWidget() {
 		addChild(panel);
 	}
 
-	addChild(createScrew<ScrewSilver>(Vec(0, 0)));
-	addChild(createScrew<ScrewSilver>(Vec(box.size.x - 15, 365)));
+	addChild(Widget::create<ScrewSilver>(Vec(0, 0)));
+	addChild(Widget::create<ScrewSilver>(Vec(box.size.x - 15, 365)));
 
 	// generated by svg_widgets.rb
 	auto triggerParamPosition = Vec(13.5, 22.0);
@@ -93,14 +95,17 @@ ManualWidget::ManualWidget() {
 	auto out8OutputPosition = Vec(10.5, 267.0);
 	// end generated by svg_widgets.rb
 
-	addParam(createParam<Button18>(triggerParamPosition, module, Manual::TRIGGER_PARAM, 0.0, 1.0, 0.0));
+	addParam(ParamWidget::create<Button18>(triggerParamPosition, module, Manual::TRIGGER_PARAM, 0.0, 1.0, 0.0));
 
-	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));
+	addOutput(Port::create<Port24>(out1OutputPosition, Port::OUTPUT, module, Manual::OUT1_OUTPUT));
+	addOutput(Port::create<Port24>(out2OutputPosition, Port::OUTPUT, module, Manual::OUT2_OUTPUT));
+	addOutput(Port::create<Port24>(out3OutputPosition, Port::OUTPUT, module, Manual::OUT3_OUTPUT));
+	addOutput(Port::create<Port24>(out4OutputPosition, Port::OUTPUT, module, Manual::OUT4_OUTPUT));
+	addOutput(Port::create<Port24>(out5OutputPosition, Port::OUTPUT, module, Manual::OUT5_OUTPUT));
+	addOutput(Port::create<Port24>(out6OutputPosition, Port::OUTPUT, module, Manual::OUT6_OUTPUT));
+	addOutput(Port::create<Port24>(out7OutputPosition, Port::OUTPUT, module, Manual::OUT7_OUTPUT));
+	addOutput(Port::create<Port24>(out8OutputPosition, Port::OUTPUT, module, Manual::OUT8_OUTPUT));
 }
+
+
+Model* modelManual = Model::create<Manual, ManualWidget>("Bogaudio", "Bogaudio-Manual", "Manual", UTILITY_TAG);
diff --git a/src/Noise.cpp b/src/Noise.cpp
@@ -62,9 +62,11 @@ void Noise::step() {
 }
 
 
-NoiseWidget::NoiseWidget() {
-	Noise *module = new Noise();
-	setModule(module);
+struct NoiseWidget : ModuleWidget {
+	NoiseWidget(Noise* module);
+};
+
+NoiseWidget::NoiseWidget(Noise* module) : ModuleWidget(module) {
 	box.size = Vec(RACK_GRID_WIDTH * 3, RACK_GRID_HEIGHT);
 
 	{
@@ -74,8 +76,8 @@ NoiseWidget::NoiseWidget() {
 		addChild(panel);
 	}
 
-	addChild(createScrew<ScrewSilver>(Vec(0, 0)));
-	addChild(createScrew<ScrewSilver>(Vec(box.size.x - 15, 365)));
+	addChild(Widget::create<ScrewSilver>(Vec(0, 0)));
+	addChild(Widget::create<ScrewSilver>(Vec(box.size.x - 15, 365)));
 
 	// generated by svg_widgets.rb
 	auto absInputPosition = Vec(10.5, 245.0);
@@ -87,11 +89,14 @@ NoiseWidget::NoiseWidget() {
 	auto absOutputPosition = Vec(10.5, 283.0);
 	// end generated by svg_widgets.rb
 
-	addInput(createInput<Port24>(absInputPosition, module, Noise::ABS_INPUT));
+	addInput(Port::create<Port24>(absInputPosition, Port::INPUT, module, Noise::ABS_INPUT));
 
-	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));
+	addOutput(Port::create<Port24>(whiteOutputPosition, Port::OUTPUT, module, Noise::WHITE_OUTPUT));
+	addOutput(Port::create<Port24>(pinkOutputPosition, Port::OUTPUT, module, Noise::PINK_OUTPUT));
+	addOutput(Port::create<Port24>(redOutputPosition, Port::OUTPUT, module, Noise::RED_OUTPUT));
+	addOutput(Port::create<Port24>(gaussOutputPosition, Port::OUTPUT, module, Noise::GAUSS_OUTPUT));
+	addOutput(Port::create<Port24>(absOutputPosition, Port::OUTPUT, module, Noise::ABS_OUTPUT));
 }
+
+
+Model* modelNoise = Model::create<Noise, NoiseWidget>("Bogaudio", "Bogaudio-Noise", "Noise", NOISE_TAG, UTILITY_TAG);
diff --git a/src/Offset.cpp b/src/Offset.cpp
@@ -33,25 +33,27 @@ void Offset::step() {
 	scale = scale < 0.0 ? -pow(scale, 2.0) : pow(scale, 2.0);
 	scale *= 10.0;
 	if (inputs[IN_INPUT].active) {
-		outputs[OUT_OUTPUT].value = clampf((inputs[IN_INPUT].value + 10.0 * offset) * scale, -10.0, 10.0);
+		outputs[OUT_OUTPUT].value = clamp((inputs[IN_INPUT].value + 10.0f * offset) * scale, -10.0f, 10.0f);
 	}
 	else {
-		outputs[OUT_OUTPUT].value = clampf(10.0 * offset * scale, -10.0, 10.0);
+		outputs[OUT_OUTPUT].value = clamp(10.0f * offset * scale, -10.0f, 10.0f);
 	}
 }
 
 float Offset::knobValue(const Param& knob, const Input& cv) const {
-	float v = clampf(knob.value, -1.0, 1.0);
+	float v = knob.value;
 	if (cv.active) {
-		v *= clampf(cv.value / 10.0, -1.0, 1.0);
+		v *= clamp(cv.value / 10.0f, -1.0f, 1.0f);
 	}
 	return v;
 }
 
 
-OffsetWidget::OffsetWidget() {
-	Offset *module = new Offset();
-	setModule(module);
+struct OffsetWidget : ModuleWidget {
+	OffsetWidget(Offset* module);
+};
+
+OffsetWidget::OffsetWidget(Offset* module) : ModuleWidget(module) {
 	box.size = Vec(RACK_GRID_WIDTH * 3, RACK_GRID_HEIGHT);
 
 	{
@@ -61,8 +63,8 @@ OffsetWidget::OffsetWidget() {
 		addChild(panel);
 	}
 
-	addChild(createScrew<ScrewSilver>(Vec(0, 0)));
-	addChild(createScrew<ScrewSilver>(Vec(box.size.x - 15, 365)));
+	addChild(Widget::create<ScrewSilver>(Vec(0, 0)));
+	addChild(Widget::create<ScrewSilver>(Vec(box.size.x - 15, 365)));
 
 	float knobNudge = 0.4;
 	// generated by svg_widgets.rb
@@ -76,12 +78,15 @@ OffsetWidget::OffsetWidget() {
 	auto outOutputPosition = Vec(10.5, 281.0);
 	// end generated by svg_widgets.rb
 
-	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));
+	addParam(ParamWidget::create<Knob29>(offsetParamPosition, module, Offset::OFFSET_PARAM, -1.0, 1.0, 0.0));
+	addParam(ParamWidget::create<Knob29>(scaleParamPosition, module, Offset::SCALE_PARAM, -1.0, 1.0, 0.316));
 
-	addInput(createInput<Port24>(offsetInputPosition, module, Offset::OFFSET_INPUT));
-	addInput(createInput<Port24>(scaleInputPosition, module, Offset::SCALE_INPUT));
-	addInput(createInput<Port24>(inInputPosition, module, Offset::IN_INPUT));
+	addInput(Port::create<Port24>(offsetInputPosition, Port::INPUT, module, Offset::OFFSET_INPUT));
+	addInput(Port::create<Port24>(scaleInputPosition, Port::INPUT, module, Offset::SCALE_INPUT));
+	addInput(Port::create<Port24>(inInputPosition, Port::INPUT, module, Offset::IN_INPUT));
 
-	addOutput(createOutput<Port24>(outOutputPosition, module, Offset::OUT_OUTPUT));
+	addOutput(Port::create<Port24>(outOutputPosition, Port::OUTPUT, module, Offset::OUT_OUTPUT));
 }
+
+
+Model* modelOffset = Model::create<Offset, OffsetWidget>("Bogaudio", "Bogaudio-Offset", "Offset", ATTENUATOR_TAG, UTILITY_TAG);
diff --git a/src/Reftone.cpp b/src/Reftone.cpp
@@ -51,9 +51,9 @@ void Reftone::step() {
 	const int referencePitch = 0;
 	const int referenceOctave = 4;
 
-	_pitch = clampf(params[PITCH_PARAM].value, 0.0, 11.0);
-	_octave = clampf(params[OCTAVE_PARAM].value, 1.0, 8.0);
-	_fine = clampf(params[FINE_PARAM].value, -0.99, 0.99);
+	_pitch = params[PITCH_PARAM].value;
+	_octave = params[OCTAVE_PARAM].value;
+	_fine = params[FINE_PARAM].value;
 	_frequency = semitoneToFrequency(referenceSemitone + 12*(_octave - referenceOctave) + (_pitch - referencePitch) + _fine);
 
 	if (outputs[CV_OUTPUT].active) {
@@ -218,9 +218,11 @@ float ReftoneDisplay::textRenderWidth(NVGcontext* vg, const char* s, int size) {
 }
 
 
-ReftoneWidget::ReftoneWidget() {
-	Reftone *module = new Reftone();
-	setModule(module);
+struct ReftoneWidget : ModuleWidget {
+	ReftoneWidget(Reftone* module);
+};
+
+ReftoneWidget::ReftoneWidget(Reftone* module) : ModuleWidget(module) {
 	box.size = Vec(RACK_GRID_WIDTH * 3, RACK_GRID_HEIGHT);
 
 	{
@@ -239,8 +241,8 @@ ReftoneWidget::ReftoneWidget() {
 		addChild(display);
 	}
 
-	addChild(createScrew<ScrewSilver>(Vec(0, 0)));
-	addChild(createScrew<ScrewSilver>(Vec(box.size.x - 15, 365)));
+	addChild(Widget::create<ScrewSilver>(Vec(0, 0)));
+	addChild(Widget::create<ScrewSilver>(Vec(box.size.x - 15, 365)));
 
 	// generated by svg_widgets.rb
 	auto pitchParamPosition = Vec(9.5, 89.5);
@@ -252,17 +254,20 @@ ReftoneWidget::ReftoneWidget() {
 	// end generated by svg_widgets.rb
 
 	{
-		auto w = createParam<Knob26>(pitchParamPosition, module, Reftone::PITCH_PARAM, 0.0, 11.0, 9.0);
+		auto w = ParamWidget::create<Knob26>(pitchParamPosition, module, Reftone::PITCH_PARAM, 0.0, 11.0, 9.0);
 		dynamic_cast<Knob*>(w)->snap = true;
 		addParam(w);
 	}
 	{
-		auto w = createParam<Knob26>(octaveParamPosition, module, Reftone::OCTAVE_PARAM, 1.0, 8.0, 4.0);
+		auto w = ParamWidget::create<Knob26>(octaveParamPosition, module, Reftone::OCTAVE_PARAM, 1.0, 8.0, 4.0);
 		dynamic_cast<Knob*>(w)->snap = true;
 		addParam(w);
 	}
-	addParam(createParam<Knob26>(fineParamPosition, module, Reftone::FINE_PARAM, -0.99, 0.99, 0.0));
+	addParam(ParamWidget::create<Knob26>(fineParamPosition, module, Reftone::FINE_PARAM, -0.99, 0.99, 0.0));
 
-	addOutput(createOutput<Port24>(cvOutputPosition, module, Reftone::CV_OUTPUT));
-	addOutput(createOutput<Port24>(outOutputPosition, module, Reftone::OUT_OUTPUT));
+	addOutput(Port::create<Port24>(cvOutputPosition, Port::OUTPUT, module, Reftone::CV_OUTPUT));
+	addOutput(Port::create<Port24>(outOutputPosition, Port::OUTPUT, module, Reftone::OUT_OUTPUT));
 }
+
+
+Model* modelReftone = Model::create<Reftone, ReftoneWidget>("Bogaudio", "Bogaudio-Reftone", "Reftone", TUNER_TAG, UTILITY_TAG);
diff --git a/src/SampleHold.cpp b/src/SampleHold.cpp
@@ -30,10 +30,10 @@ struct SampleHold : Module {
 	WhiteNoiseGenerator _noise;
 
 	SampleHold() : Module(NUM_PARAMS, NUM_INPUTS, NUM_OUTPUTS) {
-		reset();
+		onReset();
 	}
 
-	virtual void reset() override;
+	virtual void onReset() override;
 	virtual void step() override;
 	void step(
 		Param& triggerParam,
@@ -45,7 +45,7 @@ struct SampleHold : Module {
 	);
 };
 
-void SampleHold::reset() {
+void SampleHold::onReset() {
 	_trigger1.reset();
 	_value1 = 0.0;
 	_trigger2.reset();
@@ -91,9 +91,12 @@ void SampleHold::step(
 	out.value = value;
 }
 
-SampleHoldWidget::SampleHoldWidget() {
-	SampleHold *module = new SampleHold();
-	setModule(module);
+
+struct SampleHoldWidget : ModuleWidget {
+	SampleHoldWidget(SampleHold* module);
+};
+
+SampleHoldWidget::SampleHoldWidget(SampleHold* module) : ModuleWidget(module) {
 	box.size = Vec(RACK_GRID_WIDTH * 3, RACK_GRID_HEIGHT);
 
 	{
@@ -103,8 +106,8 @@ SampleHoldWidget::SampleHoldWidget() {
 		addChild(panel);
 	}
 
-	addChild(createScrew<ScrewSilver>(Vec(0, 0)));
-	addChild(createScrew<ScrewSilver>(Vec(box.size.x - 15, 365)));
+	addChild(Widget::create<ScrewSilver>(Vec(0, 0)));
+	addChild(Widget::create<ScrewSilver>(Vec(box.size.x - 15, 365)));
 
 	// generated by svg_widgets.rb
 	auto trigger1ParamPosition = Vec(13.5, 33.0);
@@ -119,14 +122,17 @@ SampleHoldWidget::SampleHoldWidget() {
 	auto out2OutputPosition = Vec(10.5, 291.0);
 	// end generated by svg_widgets.rb
 
-	addParam(createParam<Button18>(trigger1ParamPosition, module, SampleHold::TRIGGER1_PARAM, 0.0, 1.0, 0.0));
-	addParam(createParam<Button18>(trigger2ParamPosition, module, SampleHold::TRIGGER2_PARAM, 0.0, 1.0, 0.0));
+	addParam(ParamWidget::create<Button18>(trigger1ParamPosition, module, SampleHold::TRIGGER1_PARAM, 0.0, 1.0, 0.0));
+	addParam(ParamWidget::create<Button18>(trigger2ParamPosition, module, SampleHold::TRIGGER2_PARAM, 0.0, 1.0, 0.0));
 
-	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));
+	addInput(Port::create<Port24>(trigger1InputPosition, Port::INPUT, module, SampleHold::TRIGGER1_INPUT));
+	addInput(Port::create<Port24>(in1InputPosition, Port::INPUT, module, SampleHold::IN1_INPUT));
+	addInput(Port::create<Port24>(trigger2InputPosition, Port::INPUT, module, SampleHold::TRIGGER2_INPUT));
+	addInput(Port::create<Port24>(in2InputPosition, Port::INPUT, module, SampleHold::IN2_INPUT));
 
-	addOutput(createOutput<Port24>(out1OutputPosition, module, SampleHold::OUT1_OUTPUT));
-	addOutput(createOutput<Port24>(out2OutputPosition, module, SampleHold::OUT2_OUTPUT));
+	addOutput(Port::create<Port24>(out1OutputPosition, Port::OUTPUT, module, SampleHold::OUT1_OUTPUT));
+	addOutput(Port::create<Port24>(out2OutputPosition, Port::OUTPUT, module, SampleHold::OUT2_OUTPUT));
 }
+
+
+Model* modelSampleHold = Model::create<SampleHold, SampleHoldWidget>("Bogaudio", "Bogaudio-SampleHold", "S&H", SAMPLE_AND_HOLD_TAG, DUAL_TAG, UTILITY_TAG);
diff --git a/src/Shaper.cpp b/src/Shaper.cpp
@@ -83,10 +83,10 @@ struct Shaper : TriggerOnLoadModule {
 		_shouldTriggerOnLoad
 	)
 	{
-		reset();
+		onReset();
 	}
 
-	virtual void reset() override {
+	virtual void onReset() override {
 		_core.reset();
 	}
 
@@ -100,9 +100,12 @@ struct Shaper : TriggerOnLoadModule {
 };
 
 
-ShaperWidget::ShaperWidget() {
-	Shaper *module = new Shaper();
-	setModule(module);
+struct ShaperWidget : ModuleWidget {
+	ShaperWidget(Shaper* module);
+	virtual Menu* createContextMenu() override;
+};
+
+ShaperWidget::ShaperWidget(Shaper* module) : ModuleWidget(module) {
 	box.size = Vec(RACK_GRID_WIDTH * 10, RACK_GRID_HEIGHT);
 
 	{
@@ -112,10 +115,10 @@ ShaperWidget::ShaperWidget() {
 		addChild(panel);
 	}
 
-	addChild(createScrew<ScrewSilver>(Vec(0, 0)));
-	addChild(createScrew<ScrewSilver>(Vec(box.size.x - 15, 0)));
-	addChild(createScrew<ScrewSilver>(Vec(0, 365)));
-	addChild(createScrew<ScrewSilver>(Vec(box.size.x - 15, 365)));
+	addChild(Widget::create<ScrewSilver>(Vec(0, 0)));
+	addChild(Widget::create<ScrewSilver>(Vec(box.size.x - 15, 0)));
+	addChild(Widget::create<ScrewSilver>(Vec(0, 365)));
+	addChild(Widget::create<ScrewSilver>(Vec(box.size.x - 15, 365)));
 
 	// generated by svg_widgets.rb
 	auto attackParamPosition = Vec(29.08, 33.08);
@@ -142,30 +145,30 @@ ShaperWidget::ShaperWidget() {
 	auto offLightPosition = Vec(12.0, 237.0);
 	// end generated by svg_widgets.rb
 
-	addParam(createParam<Knob38>(attackParamPosition, module, Shaper::ATTACK_PARAM, 0.0, 1.0, 0.12));
-	addParam(createParam<Knob38>(onParamPosition, module, Shaper::ON_PARAM, 0.0, 1.0, 0.32));
-	addParam(createParam<Knob38>(decayParamPosition, module, Shaper::DECAY_PARAM, 0.0, 1.0, 0.32));
-	addParam(createParam<Knob38>(offParamPosition, module, Shaper::OFF_PARAM, 0.0, 1.0, 0.07));
-	addParam(createParam<Knob38>(envParamPosition, module, Shaper::ENV_PARAM, 0.0, 1.0, 1.0));
-	addParam(createParam<Knob38>(signalParamPosition, module, Shaper::SIGNAL_PARAM, 0.0, 1.0, 0.5));
+	addParam(ParamWidget::create<Knob38>(attackParamPosition, module, Shaper::ATTACK_PARAM, 0.0, 1.0, 0.12));
+	addParam(ParamWidget::create<Knob38>(onParamPosition, module, Shaper::ON_PARAM, 0.0, 1.0, 0.32));
+	addParam(ParamWidget::create<Knob38>(decayParamPosition, module, Shaper::DECAY_PARAM, 0.0, 1.0, 0.32));
+	addParam(ParamWidget::create<Knob38>(offParamPosition, module, Shaper::OFF_PARAM, 0.0, 1.0, 0.07));
+	addParam(ParamWidget::create<Knob38>(envParamPosition, module, Shaper::ENV_PARAM, 0.0, 1.0, 1.0));
+	addParam(ParamWidget::create<Knob38>(signalParamPosition, module, Shaper::SIGNAL_PARAM, 0.0, 1.0, 0.5));
 
-	addParam(createParam<Button18>(triggerParamPosition, module, Shaper::TRIGGER_PARAM, 0.0, 1.0, 0.0));
-	addInput(createInput<Port24>(triggerInputPosition, module, Shaper::TRIGGER_INPUT));
+	addParam(ParamWidget::create<Button18>(triggerParamPosition, module, Shaper::TRIGGER_PARAM, 0.0, 1.0, 0.0));
+	addInput(Port::create<Port24>(triggerInputPosition, Port::INPUT, 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(createOutput<Port24>(triggerOutputPosition, module, Shaper::TRIGGER_OUTPUT));
+	addParam(ParamWidget::create<SliderSwitch2State14>(speedParamPosition, module, Shaper::SPEED_PARAM, 0.0, 1.0, 1.0));
+	addParam(ParamWidget::create<SliderSwitch2State14>(loopParamPosition, module, Shaper::LOOP_PARAM, 0.0, 1.0, 1.0));
+	addOutput(Port::create<Port24>(triggerOutputPosition, Port::OUTPUT, module, Shaper::TRIGGER_OUTPUT));
 
-	addOutput(createOutput<Port24>(envOutputPosition, module, Shaper::ENV_OUTPUT));
-	addOutput(createOutput<Port24>(invOutputPosition, module, Shaper::INV_OUTPUT));
+	addOutput(Port::create<Port24>(envOutputPosition, Port::OUTPUT, module, Shaper::ENV_OUTPUT));
+	addOutput(Port::create<Port24>(invOutputPosition, Port::OUTPUT, module, Shaper::INV_OUTPUT));
 
-	addInput(createInput<Port24>(signalInputPosition, module, Shaper::SIGNAL_INPUT));
-	addOutput(createOutput<Port24>(signalOutputPosition, module, Shaper::SIGNAL_OUTPUT));
+	addInput(Port::create<Port24>(signalInputPosition, Port::INPUT, module, Shaper::SIGNAL_INPUT));
+	addOutput(Port::create<Port24>(signalOutputPosition, Port::OUTPUT, module, Shaper::SIGNAL_OUTPUT));
 
-	addChild(createLight<TinyLight<GreenLight>>(attackLightPosition, module, Shaper::ATTACK_LIGHT));
-	addChild(createLight<TinyLight<GreenLight>>(onLightPosition, module, Shaper::ON_LIGHT));
-	addChild(createLight<TinyLight<GreenLight>>(decayLightPosition, module, Shaper::DECAY_LIGHT));
-	addChild(createLight<TinyLight<GreenLight>>(offLightPosition, module, Shaper::OFF_LIGHT));
+	addChild(ModuleLightWidget::create<TinyLight<GreenLight>>(attackLightPosition, module, Shaper::ATTACK_LIGHT));
+	addChild(ModuleLightWidget::create<TinyLight<GreenLight>>(onLightPosition, module, Shaper::ON_LIGHT));
+	addChild(ModuleLightWidget::create<TinyLight<GreenLight>>(decayLightPosition, module, Shaper::DECAY_LIGHT));
+	addChild(ModuleLightWidget::create<TinyLight<GreenLight>>(offLightPosition, module, Shaper::OFF_LIGHT));
 }
 
 Menu* ShaperWidget::createContextMenu() {
@@ -176,3 +179,6 @@ Menu* ShaperWidget::createContextMenu() {
 	menu->addChild(new TriggerOnLoadMenuItem(shaper, "Resume Loop on Load"));
 	return menu;
 }
+
+
+Model* modelShaper = Model::create<Shaper, ShaperWidget>("Bogaudio", "Bogaudio-Shaper", "Shaper", ENVELOPE_GENERATOR_TAG, AMPLIFIER_TAG);
diff --git a/src/ShaperPlus.cpp b/src/ShaperPlus.cpp
@@ -90,10 +90,10 @@ struct ShaperPlus : TriggerOnLoadModule {
 		_shouldTriggerOnLoad
 	)
 	{
-		reset();
+		onReset();
 	}
 
-	virtual void reset() override {
+	virtual void onReset() override {
 		_core.reset();
 	}
 
@@ -107,9 +107,12 @@ struct ShaperPlus : TriggerOnLoadModule {
 };
 
 
-ShaperPlusWidget::ShaperPlusWidget() {
-	ShaperPlus *module = new ShaperPlus();
-	setModule(module);
+struct ShaperPlusWidget : ModuleWidget {
+	ShaperPlusWidget(ShaperPlus* module);
+	virtual Menu* createContextMenu() override;
+};
+
+ShaperPlusWidget::ShaperPlusWidget(ShaperPlus* module) : ModuleWidget(module) {
 	box.size = Vec(RACK_GRID_WIDTH * 15, RACK_GRID_HEIGHT);
 
 	{
@@ -119,10 +122,10 @@ ShaperPlusWidget::ShaperPlusWidget() {
 		addChild(panel);
 	}
 
-	addChild(createScrew<ScrewSilver>(Vec(15, 0)));
-	addChild(createScrew<ScrewSilver>(Vec(box.size.x - 30, 0)));
-	addChild(createScrew<ScrewSilver>(Vec(15, 365)));
-	addChild(createScrew<ScrewSilver>(Vec(box.size.x - 30, 365)));
+	addChild(Widget::create<ScrewSilver>(Vec(15, 0)));
+	addChild(Widget::create<ScrewSilver>(Vec(box.size.x - 30, 0)));
+	addChild(Widget::create<ScrewSilver>(Vec(15, 365)));
+	addChild(Widget::create<ScrewSilver>(Vec(box.size.x - 30, 365)));
 
 	// generated by svg_widgets.rb
 	auto attackParamPosition = Vec(29.08, 33.08);
@@ -159,42 +162,42 @@ ShaperPlusWidget::ShaperPlusWidget() {
 	auto offLightPosition = Vec(12.0, 237.0);
 	// end generated by svg_widgets.rb
 
-	addParam(createParam<Knob38>(attackParamPosition, module, ShaperPlus::ATTACK_PARAM, 0.0, 1.0, 0.12));
-	addParam(createParam<Knob38>(onParamPosition, module, ShaperPlus::ON_PARAM, 0.0, 1.0, 0.32));
-	addParam(createParam<Knob38>(decayParamPosition, module, ShaperPlus::DECAY_PARAM, 0.0, 1.0, 0.32));
-	addParam(createParam<Knob38>(offParamPosition, module, ShaperPlus::OFF_PARAM, 0.0, 1.0, 0.07));
-	addParam(createParam<Knob38>(envParamPosition, module, ShaperPlus::ENV_PARAM, 0.0, 1.0, 1.0));
-	addParam(createParam<Knob38>(signalParamPosition, module, ShaperPlus::SIGNAL_PARAM, 0.0, 1.0, 0.5));
-
-	addParam(createParam<Button18>(triggerParamPosition, module, ShaperPlus::TRIGGER_PARAM, 0.0, 1.0, 0.0));
-	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(createOutput<Port24>(triggerOutputPosition, module, ShaperPlus::TRIGGER_OUTPUT));
-
-	addOutput(createOutput<Port24>(envOutputPosition, module, ShaperPlus::ENV_OUTPUT));
-	addOutput(createOutput<Port24>(invOutputPosition, module, ShaperPlus::INV_OUTPUT));
-
-	addInput(createInput<Port24>(signalInputPosition, module, ShaperPlus::SIGNAL_INPUT));
-	addOutput(createOutput<Port24>(signalOutputPosition, module, ShaperPlus::SIGNAL_OUTPUT));
-
-	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(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));
-	addChild(createLight<TinyLight<GreenLight>>(decayLightPosition, module, ShaperPlus::DECAY_LIGHT));
-	addChild(createLight<TinyLight<GreenLight>>(offLightPosition, module, ShaperPlus::OFF_LIGHT));
+	addParam(ParamWidget::create<Knob38>(attackParamPosition, module, ShaperPlus::ATTACK_PARAM, 0.0, 1.0, 0.12));
+	addParam(ParamWidget::create<Knob38>(onParamPosition, module, ShaperPlus::ON_PARAM, 0.0, 1.0, 0.32));
+	addParam(ParamWidget::create<Knob38>(decayParamPosition, module, ShaperPlus::DECAY_PARAM, 0.0, 1.0, 0.32));
+	addParam(ParamWidget::create<Knob38>(offParamPosition, module, ShaperPlus::OFF_PARAM, 0.0, 1.0, 0.07));
+	addParam(ParamWidget::create<Knob38>(envParamPosition, module, ShaperPlus::ENV_PARAM, 0.0, 1.0, 1.0));
+	addParam(ParamWidget::create<Knob38>(signalParamPosition, module, ShaperPlus::SIGNAL_PARAM, 0.0, 1.0, 0.5));
+
+	addParam(ParamWidget::create<Button18>(triggerParamPosition, module, ShaperPlus::TRIGGER_PARAM, 0.0, 1.0, 0.0));
+	addInput(Port::create<Port24>(triggerInputPosition, Port::INPUT, module, ShaperPlus::TRIGGER_INPUT));
+
+	addParam(ParamWidget::create<SliderSwitch2State14>(speedParamPosition, module, ShaperPlus::SPEED_PARAM, 0.0, 1.0, 1.0));
+	addParam(ParamWidget::create<SliderSwitch2State14>(loopParamPosition, module, ShaperPlus::LOOP_PARAM, 0.0, 1.0, 1.0));
+	addOutput(Port::create<Port24>(triggerOutputPosition, Port::OUTPUT, module, ShaperPlus::TRIGGER_OUTPUT));
+
+	addOutput(Port::create<Port24>(envOutputPosition, Port::OUTPUT, module, ShaperPlus::ENV_OUTPUT));
+	addOutput(Port::create<Port24>(invOutputPosition, Port::OUTPUT, module, ShaperPlus::INV_OUTPUT));
+
+	addInput(Port::create<Port24>(signalInputPosition, Port::INPUT, module, ShaperPlus::SIGNAL_INPUT));
+	addOutput(Port::create<Port24>(signalOutputPosition, Port::OUTPUT, module, ShaperPlus::SIGNAL_OUTPUT));
+
+	addInput(Port::create<Port24>(attackInputPosition, Port::INPUT, module, ShaperPlus::ATTACK_INPUT));
+	addInput(Port::create<Port24>(onInputPosition, Port::INPUT, module, ShaperPlus::ON_INPUT));
+	addInput(Port::create<Port24>(decayInputPosition, Port::INPUT, module, ShaperPlus::DECAY_INPUT));
+	addInput(Port::create<Port24>(offInputPosition, Port::INPUT, module, ShaperPlus::OFF_INPUT));
+	addInput(Port::create<Port24>(envInputPosition, Port::INPUT, module, ShaperPlus::ENV_INPUT));
+	addInput(Port::create<Port24>(signalcvInputPosition, Port::INPUT, module, ShaperPlus::SIGNALCV_INPUT));
+
+	addOutput(Port::create<Port24>(attackOutputPosition, Port::OUTPUT, module, ShaperPlus::ATTACK_OUTPUT));
+	addOutput(Port::create<Port24>(onOutputPosition, Port::OUTPUT, module, ShaperPlus::ON_OUTPUT));
+	addOutput(Port::create<Port24>(decayOutputPosition, Port::OUTPUT, module, ShaperPlus::DECAY_OUTPUT));
+	addOutput(Port::create<Port24>(offOutputPosition, Port::OUTPUT, module, ShaperPlus::OFF_OUTPUT));
+
+	addChild(ModuleLightWidget::create<TinyLight<GreenLight>>(attackLightPosition, module, ShaperPlus::ATTACK_LIGHT));
+	addChild(ModuleLightWidget::create<TinyLight<GreenLight>>(onLightPosition, module, ShaperPlus::ON_LIGHT));
+	addChild(ModuleLightWidget::create<TinyLight<GreenLight>>(decayLightPosition, module, ShaperPlus::DECAY_LIGHT));
+	addChild(ModuleLightWidget::create<TinyLight<GreenLight>>(offLightPosition, module, ShaperPlus::OFF_LIGHT));
 }
 
 Menu* ShaperPlusWidget::createContextMenu() {
@@ -205,3 +208,6 @@ Menu* ShaperPlusWidget::createContextMenu() {
 	menu->addChild(new TriggerOnLoadMenuItem(shaperPlus, "Resume Loop on Load"));
 	return menu;
 }
+
+
+Model* modelShaperPlus = Model::create<ShaperPlus, ShaperPlusWidget>("Bogaudio", "Bogaudio-ShaperPlus", "Shaper+", ENVELOPE_GENERATOR_TAG, AMPLIFIER_TAG);
diff --git a/src/SixHP.cpp b/src/SixHP.cpp
@@ -19,23 +19,25 @@ struct SixHP : Module {
 	};
 
 	SixHP() : Module(NUM_PARAMS, NUM_INPUTS, NUM_OUTPUTS, NUM_LIGHTS) {
-		reset();
+		onReset();
 	}
 
-	virtual void reset() override;
+	virtual void onReset() override;
 	virtual void step() override;
 };
 
-void SixHP::reset() {
+void SixHP::onReset() {
 }
 
 void SixHP::step() {
 }
 
 
-SixHPWidget::SixHPWidget() {
-	SixHP *module = new SixHP();
-	setModule(module);
+struct SixHPWidget : ModuleWidget {
+	SixHPWidget(SixHP* module);
+};
+
+SixHPWidget::SixHPWidget(SixHP* module) : ModuleWidget(module) {
 	box.size = Vec(RACK_GRID_WIDTH * 6, RACK_GRID_HEIGHT);
 
 	{
@@ -45,6 +47,9 @@ SixHPWidget::SixHPWidget() {
 		addChild(panel);
 	}
 
-	addChild(createScrew<ScrewSilver>(Vec(0, 0)));
-	addChild(createScrew<ScrewSilver>(Vec(box.size.x - 15, 365)));
+	addChild(Widget::create<ScrewSilver>(Vec(0, 0)));
+	addChild(Widget::create<ScrewSilver>(Vec(box.size.x - 15, 365)));
 }
+
+
+Model* modelSixHP = Model::create<SixHP, SixHPWidget>("Bogaudio", "Bogaudio-SixHP", "6HP");
diff --git a/src/Stack.cpp b/src/Stack.cpp
@@ -48,27 +48,29 @@ void Stack::step() {
 	float semitones = params[OCTAVE_PARAM].value * 12.0;
 	semitones += params[SEMIS_PARAM].value;
 	if (inputs[CV_INPUT].active) {
-		semitones += clampf(inputs[CV_INPUT].value, -5.0, 5.0) * 10.0;
+		semitones += clamp(inputs[CV_INPUT].value, -5.0f, 5.0f) * 10.0;
 	}
 	if (params[QUANTIZE_PARAM].value > 0.5) {
 		semitones = roundf(semitones);
 	}
 
 	if (inputs[IN_INPUT].active) {
-		float cv = clampf(inputs[IN_INPUT].value, _minCVOut, _maxCVOut);
+		float cv = clamp(inputs[IN_INPUT].value, _minCVOut, _maxCVOut);
 		outputs[THRU_OUTPUT].value = cv;
-		outputs[OUT_OUTPUT].value = clampf(semitoneToCV(cvToSemitone(cv) + semitones + params[FINE_PARAM].value), _minCVOut, _maxCVOut);
+		outputs[OUT_OUTPUT].value = clamp(semitoneToCV(cvToSemitone(cv) + semitones + params[FINE_PARAM].value), _minCVOut, _maxCVOut);
 	}
 	else {
 		outputs[THRU_OUTPUT].value = semitones / 10.0;
-		outputs[OUT_OUTPUT].value = clampf(semitoneToCV(referenceSemitone + semitones + params[FINE_PARAM].value), _minCVOut, _maxCVOut);
+		outputs[OUT_OUTPUT].value = clamp(semitoneToCV(referenceSemitone + semitones + params[FINE_PARAM].value), _minCVOut, _maxCVOut);
 	}
 }
 
 
-StackWidget::StackWidget() {
-	Stack *module = new Stack();
-	setModule(module);
+struct StackWidget : ModuleWidget {
+	StackWidget(Stack* module);
+};
+
+StackWidget::StackWidget(Stack* module) : ModuleWidget(module) {
 	box.size = Vec(RACK_GRID_WIDTH * 3, RACK_GRID_HEIGHT);
 
 	{
@@ -78,8 +80,8 @@ StackWidget::StackWidget() {
 		addChild(panel);
 	}
 
-	addChild(createScrew<ScrewSilver>(Vec(0, 0)));
-	addChild(createScrew<ScrewSilver>(Vec(box.size.x - 15, 365)));
+	addChild(Widget::create<ScrewSilver>(Vec(0, 0)));
+	addChild(Widget::create<ScrewSilver>(Vec(box.size.x - 15, 365)));
 
 	// generated by svg_widgets.rb
 	auto semisParamPosition = Vec(9.5, 32.5);
@@ -97,26 +99,29 @@ StackWidget::StackWidget() {
 	// end generated by svg_widgets.rb
 
 	{
-		auto w = createParam<Knob26>(semisParamPosition, module, Stack::SEMIS_PARAM, 0.0, 11.0, 0.0);
+		auto w = ParamWidget::create<Knob26>(semisParamPosition, module, Stack::SEMIS_PARAM, 0.0, 11.0, 0.0);
 		dynamic_cast<Knob*>(w)->snap = true;
 		addParam(w);
 	}
 	{
-		auto w = createParam<Knob16>(octaveParamPosition, module, Stack::OCTAVE_PARAM, -3.0, 3.0, 0.0);
+		auto w = ParamWidget::create<Knob16>(octaveParamPosition, module, Stack::OCTAVE_PARAM, -3.0, 3.0, 0.0);
 		auto k = dynamic_cast<SVGKnob*>(w);
 		k->snap = true;
 		k->minAngle = -0.5 * M_PI;
 		k->maxAngle = 0.5 * M_PI;
 		addParam(w);
 	}
-	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));
+	addParam(ParamWidget::create<Knob16>(fineParamPosition, module, Stack::FINE_PARAM, -0.99, 0.99, 0.0));
+	addParam(ParamWidget::create<StatefulButton9>(quantizeParamPosition, module, Stack::QUANTIZE_PARAM, 0.0, 1.0, 1.0));
 
-	addInput(createInput<Port24>(cvInputPosition, module, Stack::CV_INPUT));
-	addInput(createInput<Port24>(inInputPosition, module, Stack::IN_INPUT));
+	addInput(Port::create<Port24>(cvInputPosition, Port::INPUT, module, Stack::CV_INPUT));
+	addInput(Port::create<Port24>(inInputPosition, Port::INPUT, module, Stack::IN_INPUT));
 
-	addOutput(createOutput<Port24>(thruOutputPosition, module, Stack::THRU_OUTPUT));
-	addOutput(createOutput<Port24>(outOutputPosition, module, Stack::OUT_OUTPUT));
+	addOutput(Port::create<Port24>(thruOutputPosition, Port::OUTPUT, module, Stack::THRU_OUTPUT));
+	addOutput(Port::create<Port24>(outOutputPosition, Port::OUTPUT, module, Stack::OUT_OUTPUT));
 
-	addChild(createLight<TinyLight<GreenLight>>(quantizeLightPosition, module, Stack::QUANTIZE_LIGHT));
+	addChild(ModuleLightWidget::create<TinyLight<GreenLight>>(quantizeLightPosition, module, Stack::QUANTIZE_LIGHT));
 }
+
+
+Model* modelStack = Model::create<Stack, StackWidget>("Bogaudio", "Bogaudio-Stack", "Stack");
diff --git a/src/Switch.cpp b/src/Switch.cpp
@@ -31,14 +31,14 @@ struct Switch : Module {
 	SchmittTrigger _trigger;
 
 	Switch() : Module(NUM_PARAMS, NUM_INPUTS, NUM_OUTPUTS, NUM_LIGHTS) {
-		reset();
+		onReset();
 	}
 
-	virtual void reset() override;
+	virtual void onReset() override;
 	virtual void step() override;
 };
 
-void Switch::reset() {
+void Switch::onReset() {
 	_trigger.reset();
 }
 
@@ -57,9 +57,11 @@ void Switch::step() {
 } // namespace bogaudio
 
 
-SwitchWidget::SwitchWidget() {
-	bogaudio::Switch *module = new bogaudio::Switch();
-	setModule(module);
+struct SwitchWidget : ModuleWidget {
+	SwitchWidget(bogaudio::Switch* module);
+};
+
+SwitchWidget::SwitchWidget(bogaudio::Switch* module) : ModuleWidget(module) {
 	box.size = Vec(RACK_GRID_WIDTH * 3, RACK_GRID_HEIGHT);
 
 	{
@@ -69,8 +71,8 @@ SwitchWidget::SwitchWidget() {
 		addChild(panel);
 	}
 
-	addChild(createScrew<ScrewSilver>(Vec(0, 0)));
-	addChild(createScrew<ScrewSilver>(Vec(box.size.x - 15, 365)));
+	addChild(Widget::create<ScrewSilver>(Vec(0, 0)));
+	addChild(Widget::create<ScrewSilver>(Vec(box.size.x - 15, 365)));
 
 	// generated by svg_widgets.rb
 	auto gateParamPosition = Vec(13.5, 22.0);
@@ -85,14 +87,17 @@ SwitchWidget::SwitchWidget() {
 	auto out2OutputPosition = Vec(10.5, 283.0);
 	// end generated by svg_widgets.rb
 
-	addParam(createParam<Button18>(gateParamPosition, module, bogaudio::Switch::GATE_PARAM, 0.0, 1.0, 0.0));
+	addParam(ParamWidget::create<Button18>(gateParamPosition, module, bogaudio::Switch::GATE_PARAM, 0.0, 1.0, 0.0));
 
-	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));
+	addInput(Port::create<Port24>(gateInputPosition, Port::INPUT, module, bogaudio::Switch::GATE_INPUT));
+	addInput(Port::create<Port24>(high1InputPosition, Port::INPUT, module, bogaudio::Switch::HIGH1_INPUT));
+	addInput(Port::create<Port24>(low1InputPosition, Port::INPUT, module, bogaudio::Switch::LOW1_INPUT));
+	addInput(Port::create<Port24>(high2InputPosition, Port::INPUT, module, bogaudio::Switch::HIGH2_INPUT));
+	addInput(Port::create<Port24>(low2InputPosition, Port::INPUT, module, bogaudio::Switch::LOW2_INPUT));
 
-	addOutput(createOutput<Port24>(out1OutputPosition, module, bogaudio::Switch::OUT1_OUTPUT));
-	addOutput(createOutput<Port24>(out2OutputPosition, module, bogaudio::Switch::OUT2_OUTPUT));
+	addOutput(Port::create<Port24>(out1OutputPosition, Port::OUTPUT, module, bogaudio::Switch::OUT1_OUTPUT));
+	addOutput(Port::create<Port24>(out2OutputPosition, Port::OUTPUT, module, bogaudio::Switch::OUT2_OUTPUT));
 }
+
+
+Model* modelSwitch = Model::create<bogaudio::Switch, SwitchWidget>("Bogaudio", "Bogaudio-Switch", "Switch", SWITCH_TAG, UTILITY_TAG);
diff --git a/src/Test.cpp b/src/Test.cpp
@@ -82,7 +82,7 @@ struct Test : Module {
 	, _sineBank2(44101.0, 1000.0, 50)
 #endif
 	{
-		reset();
+		onReset();
 
 #ifdef SINEBANK
     const float baseAmplitude = 5.0;
@@ -158,12 +158,12 @@ struct Test : Module {
 #endif
 	}
 
-	virtual void reset() override;
+	virtual void onReset() override;
 	virtual void step() override;
 	float oscillatorPitch();
 };
 
-void Test::reset() {
+void Test::onReset() {
 }
 
 void Test::step() {
@@ -177,8 +177,8 @@ void Test::step() {
 	}
 	_lpf.setParams(
 		engineGetSampleRate(),
-		10000.0 * clampf(params[PARAM1_PARAM].value, 0.0, 1.0),
-		std::max(10.0 * clampf(params[PARAM2_PARAM].value, 0.0, 1.0), 0.1)
+		10000.0 * clamp(params[PARAM1_PARAM].value, 0.0f, 1.0f),
+		std::max(10.0 * clamp(params[PARAM2_PARAM].value, 0.0f, 1.0f), 0.1)
 	);
 	outputs[OUT_OUTPUT].value = _lpf.next(inputs[IN_INPUT].value);
 
@@ -192,7 +192,7 @@ void Test::step() {
 	_square.setFrequency(oscillatorPitch());
 	float pw = params[PARAM2_PARAM].value;
 	if (inputs[CV2_INPUT].active) {
-		pw += clampf(inputs[CV2_INPUT].value, -5.0, 5.0) / 10.0;
+		pw += clamp(inputs[CV2_INPUT].value, -5.0f, 5.0f) / 10.0f;
 	}
 	_square.setPulseWidth(pw);
 	outputs[OUT_OUTPUT].value = _square.next();
@@ -225,9 +225,11 @@ float Test::oscillatorPitch() {
 }
 
 
-TestWidget::TestWidget() {
-	Test *module = new Test();
-	setModule(module);
+struct TestWidget : ModuleWidget {
+	TestWidget(Test* module);
+};
+
+TestWidget::TestWidget(Test* module) : ModuleWidget(module) {
 	box.size = Vec(RACK_GRID_WIDTH * 3, RACK_GRID_HEIGHT);
 
 	{
@@ -237,8 +239,8 @@ TestWidget::TestWidget() {
 		addChild(panel);
 	}
 
-	addChild(createScrew<ScrewSilver>(Vec(0, 0)));
-	addChild(createScrew<ScrewSilver>(Vec(box.size.x - 15, 365)));
+	addChild(Widget::create<ScrewSilver>(Vec(0, 0)));
+	addChild(Widget::create<ScrewSilver>(Vec(box.size.x - 15, 365)));
 
 	// generated by svg_widgets.rb
 	auto param1ParamPosition = Vec(9.5, 28.5);
@@ -252,13 +254,16 @@ TestWidget::TestWidget() {
 	auto out2OutputPosition = Vec(20.5, 316.0);
 	// end generated by svg_widgets.rb
 
-	addParam(createParam<Knob26>(param1ParamPosition, module, Test::PARAM1_PARAM, 0.0, 1.0, 0.5));
-	addParam(createParam<Knob26>(param2ParamPosition, module, Test::PARAM2_PARAM, 0.0, 1.0, 0.5));
+	addParam(ParamWidget::create<Knob26>(param1ParamPosition, module, Test::PARAM1_PARAM, 0.0, 1.0, 0.5));
+	addParam(ParamWidget::create<Knob26>(param2ParamPosition, module, Test::PARAM2_PARAM, 0.0, 1.0, 0.5));
 
-	addInput(createInput<Port24>(cv1InputPosition, module, Test::CV1_INPUT));
-	addInput(createInput<Port24>(cv2InputPosition, module, Test::CV2_INPUT));
-	addInput(createInput<Port24>(inInputPosition, module, Test::IN_INPUT));
+	addInput(Port::create<Port24>(cv1InputPosition, Port::INPUT, module, Test::CV1_INPUT));
+	addInput(Port::create<Port24>(cv2InputPosition, Port::INPUT, module, Test::CV2_INPUT));
+	addInput(Port::create<Port24>(inInputPosition, Port::INPUT, module, Test::IN_INPUT));
 
-	addOutput(createOutput<Port24>(outOutputPosition, module, Test::OUT_OUTPUT));
-	addOutput(createOutput<Port24>(out2OutputPosition, module, Test::OUT2_OUTPUT));
+	addOutput(Port::create<Port24>(outOutputPosition, Port::OUTPUT, module, Test::OUT_OUTPUT));
+	addOutput(Port::create<Port24>(out2OutputPosition, Port::OUTPUT, module, Test::OUT2_OUTPUT));
 }
+
+
+Model* modelTest = Model::create<Test, TestWidget>("Bogaudio", "Bogaudio-Test", "Test");
diff --git a/src/VCA.cpp b/src/VCA.cpp
@@ -39,9 +39,9 @@ void VCA::step() {
 
 void VCA::channelStep(Input& input, Output& output, Param& knob, Input& cv) {
 	if (input.active && output.active) {
-		float level = clampf(knob.value, 0.0, 1.0);
+		float level = knob.value;
 		if (cv.active) {
-			level *= clampf(cv.value, 0.0, 10.0) / 10.0;
+			level *= clamp(cv.value, 0.0f, 10.0f) / 10.0f;
 		}
 		level = powf(level, 2.0);
 		output.value = level * input.value;
@@ -52,9 +52,11 @@ void VCA::channelStep(Input& input, Output& output, Param& knob, Input& cv) {
 }
 
 
-VCAWidget::VCAWidget() {
-	VCA *module = new VCA();
-	setModule(module);
+struct VCAWidget : ModuleWidget {
+	VCAWidget(VCA* module);
+};
+
+VCAWidget::VCAWidget(VCA* module) : ModuleWidget(module) {
 	box.size = Vec(RACK_GRID_WIDTH * 3, RACK_GRID_HEIGHT);
 
 	{
@@ -64,8 +66,8 @@ VCAWidget::VCAWidget() {
 		addChild(panel);
 	}
 
-	addChild(createScrew<ScrewSilver>(Vec(0, 0)));
-	addChild(createScrew<ScrewSilver>(Vec(box.size.x - 15, 365)));
+	addChild(Widget::create<ScrewSilver>(Vec(0, 0)));
+	addChild(Widget::create<ScrewSilver>(Vec(box.size.x - 15, 365)));
 
 	// generated by svg_widgets.rb
 	auto level1ParamPosition = Vec(9.5, 28.5);
@@ -80,14 +82,17 @@ VCAWidget::VCAWidget() {
 	auto out2OutputPosition = Vec(10.5, 300.0);
 	// end generated by svg_widgets.rb
 
-	addParam(createParam<Knob26>(level1ParamPosition, module, VCA::LEVEL1_PARAM, 0.0, 1.0, 0.5));
-	addParam(createParam<Knob26>(level2ParamPosition, module, VCA::LEVEL2_PARAM, 0.0, 1.0, 0.5));
+	addParam(ParamWidget::create<Knob26>(level1ParamPosition, module, VCA::LEVEL1_PARAM, 0.0, 1.0, 0.5));
+	addParam(ParamWidget::create<Knob26>(level2ParamPosition, module, VCA::LEVEL2_PARAM, 0.0, 1.0, 0.5));
 
-	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));
+	addInput(Port::create<Port24>(cv1InputPosition, Port::INPUT, module, VCA::CV1_INPUT));
+	addInput(Port::create<Port24>(in1InputPosition, Port::INPUT, module, VCA::IN1_INPUT));
+	addInput(Port::create<Port24>(cv2InputPosition, Port::INPUT, module, VCA::CV2_INPUT));
+	addInput(Port::create<Port24>(in2InputPosition, Port::INPUT, module, VCA::IN2_INPUT));
 
-	addOutput(createOutput<Port24>(out1OutputPosition, module, VCA::OUT1_OUTPUT));
-	addOutput(createOutput<Port24>(out2OutputPosition, module, VCA::OUT2_OUTPUT));
+	addOutput(Port::create<Port24>(out1OutputPosition, Port::OUTPUT, module, VCA::OUT1_OUTPUT));
+	addOutput(Port::create<Port24>(out2OutputPosition, Port::OUTPUT, module, VCA::OUT2_OUTPUT));
 }
+
+
+Model* modelVCA = Model::create<VCA, VCAWidget>("Bogaudio", "Bogaudio-VCA", "VCA", AMPLIFIER_TAG, DUAL_TAG, UTILITY_TAG);
diff --git a/src/bogaudio.cpp b/src/bogaudio.cpp
@@ -4,35 +4,31 @@ Plugin *plugin;
 
 void init(rack::Plugin *p) {
 	plugin = p;
-	p->slug = "Bogaudio";
+	p->slug = "Bogaudio"; // TOSTRING(SLUG);
+	p->version = TOSTRING(VERSION);
 	p->website = "https://github.com/bogaudio/BogaudioModules";
 	p->manual = "https://github.com/bogaudio/BogaudioModules/blob/master/README.md";
-#if defined(VERSION)
-	p->version = TOSTRING(VERSION);
-#elif defined(REQUIRE_VERSION)
-#error define VERSION=0.N.M to make dist
-#endif
 
-	p->addModel(createModel<ShaperWidget>("Bogaudio", "Bogaudio-Shaper", "Shaper", ENVELOPE_GENERATOR_TAG, AMPLIFIER_TAG));
-	p->addModel(createModel<ShaperPlusWidget>("Bogaudio", "Bogaudio-ShaperPlus", "Shaper+", ENVELOPE_GENERATOR_TAG, AMPLIFIER_TAG));
-	p->addModel(createModel<DADSRHWidget>("Bogaudio", "Bogaudio-DADSRH", "DADSR(H)", ENVELOPE_GENERATOR_TAG));
-	p->addModel(createModel<DADSRHPlusWidget>("Bogaudio", "Bogaudio-DADSRHPlus", "DADSR(H)+", ENVELOPE_GENERATOR_TAG));
+	p->addModel(modelShaper);
+	p->addModel(modelShaperPlus);
+	p->addModel(modelDADSRH);
+	p->addModel(modelDADSRHPlus);
 
-	p->addModel(createModel<AnalyzerWidget>("Bogaudio", "Bogaudio-Analyzer", "Analyzer", VISUAL_TAG));
+	p->addModel(modelAnalyzer);
 
-	p->addModel(createModel<DetuneWidget>("Bogaudio", "Bogaudio-Detune", "Detune"));
-	p->addModel(createModel<DGateWidget>("Bogaudio", "Bogaudio-DGate", "DGate", UTILITY_TAG));
-	p->addModel(createModel<ManualWidget>("Bogaudio", "Bogaudio-Manual", "Manual", UTILITY_TAG));
-	p->addModel(createModel<NoiseWidget>("Bogaudio", "Bogaudio-Noise", "Noise", NOISE_TAG, UTILITY_TAG));
-	p->addModel(createModel<OffsetWidget>("Bogaudio", "Bogaudio-Offset", "Offset", ATTENUATOR_TAG, UTILITY_TAG));
-	p->addModel(createModel<ReftoneWidget>("Bogaudio", "Bogaudio-Reftone", "Reftone", TUNER_TAG, UTILITY_TAG));
-	p->addModel(createModel<SampleHoldWidget>("Bogaudio", "Bogaudio-SampleHold", "S&H", SAMPLE_AND_HOLD_TAG, DUAL_TAG, UTILITY_TAG));
-	p->addModel(createModel<StackWidget>("Bogaudio", "Bogaudio-Stack", "Stack"));
-	p->addModel(createModel<SwitchWidget>("Bogaudio", "Bogaudio-Switch", "Switch", SWITCH_TAG, UTILITY_TAG));
-	p->addModel(createModel<VCAWidget>("Bogaudio", "Bogaudio-VCA", "VCA", AMPLIFIER_TAG, DUAL_TAG, UTILITY_TAG));
+	p->addModel(modelDetune);
+	p->addModel(modelDGate);
+	p->addModel(modelManual);
+	p->addModel(modelNoise);
+	p->addModel(modelOffset);
+	p->addModel(modelReftone);
+	p->addModel(modelSampleHold);
+	p->addModel(modelStack);
+	p->addModel(modelSwitch);
+	p->addModel(modelVCA);
 
 #ifdef TEST
-	p->addModel(createModel<TestWidget>("Bogaudio", "Bogaudio-Test", "Test"));
-	p->addModel(createModel<SixHPWidget>("Bogaudio", "Bogaudio-SixHP", "6HP"));
+	p->addModel(modelTest);
+	p->addModel(modelSixHP);
 #endif
 }
diff --git a/src/bogaudio.hpp b/src/bogaudio.hpp
@@ -16,81 +16,23 @@ using namespace bogaudio;
 
 extern Plugin *plugin;
 
-namespace bogaudio {
-
-struct ShaperWidget : ModuleWidget {
-	ShaperWidget();
-	virtual Menu* createContextMenu() override;
-};
-
-struct ShaperPlusWidget : ModuleWidget {
-	ShaperPlusWidget();
-	virtual Menu* createContextMenu() override;
-};
-
-struct DADSRHWidget : ModuleWidget {
-	DADSRHWidget();
-	virtual Menu* createContextMenu() override;
-};
-
-struct DADSRHPlusWidget : ModuleWidget {
-	DADSRHPlusWidget();
-	virtual Menu* createContextMenu() override;
-};
-
-struct AnalyzerWidget : ModuleWidget {
-	AnalyzerWidget();
-};
-
-
-struct DetuneWidget : ModuleWidget {
-	DetuneWidget();
-};
-
-struct StackWidget : ModuleWidget {
-	StackWidget();
-};
-
-struct DGateWidget : ModuleWidget {
-	DGateWidget();
-	virtual Menu* createContextMenu() override;
-};
-
-struct OffsetWidget : ModuleWidget {
-	OffsetWidget();
-};
-
-struct SampleHoldWidget : ModuleWidget {
-	SampleHoldWidget();
-};
-
-struct ManualWidget : ModuleWidget {
-	ManualWidget();
-};
-
-struct NoiseWidget : ModuleWidget {
-	NoiseWidget();
-};
-
-struct ReftoneWidget : ModuleWidget {
-	ReftoneWidget();
-};
-
-struct SwitchWidget : ModuleWidget {
-	SwitchWidget();
-};
-
-struct VCAWidget : ModuleWidget {
-	VCAWidget();
-};
-
-
-struct TestWidget : ModuleWidget {
-	TestWidget();
-};
-
-struct SixHPWidget : ModuleWidget {
-	SixHPWidget();
-};
-
-} // namespae bogaudio
+extern Model* modelShaper;
+extern Model* modelShaperPlus;
+extern Model* modelDADSRH;
+extern Model* modelDADSRHPlus;
+
+extern Model* modelAnalyzer;
+
+extern Model* modelDetune;
+extern Model* modelDGate;
+extern Model* modelManual;
+extern Model* modelNoise;
+extern Model* modelOffset;
+extern Model* modelReftone;
+extern Model* modelSampleHold;
+extern Model* modelStack;
+extern Model* modelSwitch;
+extern Model* modelVCA;
+
+extern Model* modelTest;
+extern Model* modelSixHP;
diff --git a/src/dadsrh_core.cpp b/src/dadsrh_core.cpp
@@ -256,9 +256,9 @@ float DADSRHCore::knobTime(const Param& knob, const Input* cv, bool slow, bool a
 }
 
 float DADSRHCore::knobAmount(const Param& knob, const Input* cv) const {
-	float v = clampf(knob.value, 0.0, 1.0);
+	float v = clamp(knob.value, 0.0f, 1.0f);
 	if (cv && cv->active) {
-		v *= clampf(cv->value / 10.0, 0.0, 1.0);
+		v *= clamp(cv->value / 10.0f, 0.0f, 1.0f);
 	}
 	return v;
 }
diff --git a/src/dsp/oscillator.cpp b/src/dsp/oscillator.cpp
@@ -1,7 +1,5 @@
 #include <math.h>
 
-#include "rack.hpp"
-
 #include "oscillator.hpp"
 
 using namespace bogaudio::dsp;
diff --git a/src/shaper_core.cpp b/src/shaper_core.cpp
@@ -86,7 +86,7 @@ void ShaperCore::step() {
 	_signalOutput.value = signalLevel * envelope * _signalInput.normalize(0.0);
 
 	float envLevel = levelParam(_envParam, _envInput);
-	float envOutput = clampf(envLevel * envelope, 0.0, 10.0);
+	float envOutput = clamp(envLevel * envelope, 0.0f, 10.0f);
 	_envOutput.value = envOutput;
 	_invOutput.value = 10.0 - envOutput;
 
@@ -126,9 +126,9 @@ bool ShaperCore::stepStage(const Param& knob, const Input* cv, bool slow) {
 }
 
 float ShaperCore::levelParam(const Param& knob, const Input* cv) const {
-	float v = clampf(knob.value, 0.0, 1.0);
+	float v = clamp(knob.value, 0.0f, 1.0f);
 	if (cv && cv->active) {
-		v *= clampf(cv->value / 10.0, 0.0, 1.0);
+		v *= clamp(cv->value / 10.0f, 0.0f, 1.0f);
 	}
 	return v;
 }