32-Voice Synthesizer

`Dual Waveset Synth with 5D Filter, and More`

On this Page:: Downloads of 'Mocha Edition'; Quick Start; Main Features; Help Panel Screenshots; Design Source; (Click the images for a lightbox slideshow)

Husserl2 aims to be one of the best free synths you can get. Because it takes advantage of all the cores available on your machine, it cannot run inside plugin hosts, which only support one core thread per plugin. As a result, this is a standalone app with native, ASIO, and ReWire client drivers for connection to all current standard DAWs. Although the app includes anti-aliased oscillators and a 4x-oversampled filter, for professional applications a sample rate of at least 88kHz is recommended to provide crisp results in the C8 octave, but if you only play to C7 then standard sample rates are sufficient.

Downloads of 'Mocha Edition'

Windows 10 (64-bit):
Cycling74 Max8 Source:

Quick Start

Created: Winter 2019

Modified: Oct 6 2021

Mocha Release

Warning: Michael Jackson in my YouTube Demo! Most people don't like my own music, lol, and my YouTube vidoes take a while to get going, but everyone who's tried the synth out for themselves are very pleased with Husserl2.

To try it out, unzip to any location and open. If necessary, select a different Audio Driver from the toolbar or menu. The ad_directsound driver works for me. There's also ASIO and ReWire drivers if you want.

To demo the presets, double click the preset names to recall them (a single click on the preset names selects them for the add/insert/replace/delete buttons). The current playing notes are saved with a preset when you store it. If you dont want to recall notes when recalling a preset, turn RESTORE NOTES off.

The next most important thing to know is that the list boxes below each knob select a modulation source for that knob, with the modulation amount set by clicking and dragging on the number field below the list box.

The toolbar in the top left of the main panel has buttons to open the MIDI file player, bank manager, and detailed interactive help.

Main Features

2 Oscillators with dual contour, phase, ring modulation, frequency modulation, oscillator mix, plus gate/osc sync controls. EPTR-antialiased square/pulse and saw/triangle waveforms are followed by 44 wavesets, including filter sweeps, morphs, formants, and harmonic bundles. The wavesets contain 5,842 individual wavecycles, with 256 sample points each, and 127 wavecycles per waveset. To calculate intermediate points between each wavecycle, the current wavepoint is spline-interpolated for the prevous and next wavecycle, then the fractional offset is linearly interpolated between them to create the output value.

SVF Filter with cutoff, resonance, 0/2/4 pole mix, LP/BP/HP mix, and saturation continuously variable in 5 dimensions, providing a million unique settings from the synth panel. There are some dead zones, but the filter is always effective with cutoff set to note pitch, and provides about half a million unique usable sounds (by setting the filter cutoff above the note pitch if mixing more low-pass filtering, or below the note pitch with more high-pass filtering). When set lower, transient peaks are louder, until there is no saturation at the minumum setting. When set higher, the input is boosted, and transient peaks are increasingly distorted by mirroring the signal to within the unity-gain range.

Internally, the filter is a dual two-pole Butterworth cascade, with the the lowpass, bandpass, and hipass outputs mixed after each stage. The input is delayed to remove phase offset from the filter and mxed appropriately with the two-pole and four-pole outputs, which is then passed to a 4x-oversampled saturator (a tanh-based waveshaper, with level continually adjusted between maximum levels sampled at 40Hz, and mirror-based distortion at higher saturation settings). Finally the saturator output is downsampled and returned. The filter curve display for the 100,000 possible filter settings is calculated at screen refresh rate from a 1,000-entry table of predrawn 100-point filter curves.

Compressor and limiter with polyphonic and monophonic modes. The limiter and compressor are integrated into one function for optimal performance, with min/max samples at the filter saturator rate. Standard attack, release, threshold, and ratio controls are available.
Internal Modulation Matrix with 151 modulation destinations and 143 sources including:
- 3 ADSR Envelopes with graph control of velocity shaping. The ADSR curve is linearly interpolated from a precaulculated, 64K-entry tablle of POW(2.5) values. ADSR values are updated at audio rate.
- 3 LFOs with sine/double-sine, square/pulse, saw/triangle, stepped, and random waveforms; contour shaping, freq mod, amp mod, and sync; two polyphonic, one monophonic linked to mod wheel. The LFOs calculate output values in the same manner as for the oscillators, except anti-aliasing is disabled, at audio clock rate.
- Sample and Hold with adjustable trigger level on the modulator. The S&H output is available for mixdown in the XY pad.
- XY Pad to mix up to four modulation sources to any modulation destination. The individual X and Y axes, as well as the combined XY value, are available as modulation sources in additive and multiplicative forms. The additive form mixes the X/Y values, and the multiplicative form allows an envelope to control the LFO level, for example.
- 120 Mapped MIDI Controllers, plus bend, modwheel + lfo, note pitch, velocity, voice number, and #notes. the voice number allows for example slight detunings on each voice.
50 Microtuning Tables with classical, oriental, and experimental tunings across the entire MIDI range.
Preset Manager with simple button controls, preset naming, and bank load/save.
Lots of Demo Presets. Notes may be stored and recalled with presets too.
MIDI file player built in, with channel selection.
MIDI I/O: note on/off, MIDI clock, program change, pitch bend, all 90 panel controls, and standard MIDI controllers such as pedals, etc.
Graph Display of oscillator waveforms, filter settings, audio waveform, and modulation values for most recent voice.
Resizable Panel. Zoom in or out as much as you like. Synth reopens the way you closed it.
Interactive Help built in for wavesets, filter characteristics, microtuning tables, and with complete description of all panel controls.
Fully Compiled 64-bit Multithreaded Audio Path, carefully optimized for performance without sacrificing quality. Base CPU usage is ~9% for first voice, +0.75% per playing voice, on a 4GHz i7 @44.1kHz with Windows10 DirectX drivers.
Open Source distribution in Cycling74 Max8, if you wish to change it in any way.

Help Panel Screenshots

Design Source

The Max8 patch uses no phantom or vitual connections, and is fully wired, because SEND/RECEIVE pairs introduce an internal buffer delay. Likewise, the control portions of the patch are flat to reduce queue latencies from traversing the inlet/outlet ports. The main patch also contains a compiled JavaScript routine for maintaining display indicators, such as the filter and wave curves. The JavaScript runs in a low-priority thread at screen-refresh rate, so that processing and display of indicators do not interrupt the audio routines.

Much of the audio and display data is precalculated and loaded into buffers to reduce unnecessary transcendentals and divisions. The setup patch shown on the right loads all the buffer data, configures display elements, and defers starting the audio DAC by a message on the low-priority queue (so the buffers and other audio parameters have a chance to initialize first).

Design Notes: Audio Datapath

The audio data patch is derived from the SynthCore Library on this site. The SynthCore library will be extended with this designs enhanced filter and compander. The methods are mostly straightforward. Conditional statements and 'Selector' arguments contain all temporal-specific code, so that only the processing needed for the current clock cycle is performed. The main routine uses acronyms for the 115 input Params, which significantly reduces load time. At the end of the main routine, audio data values neeeded for display indicators for the most recently played note are poked to shared buffers, on a slow clock synchronized with the display rate, and picked up by JavaScript for additional processing on the low-priority thread.

parabol(in1, shape){ 
	return in1*(shape +1 - abs(in1)*shape);
}
spline4xUp(in1){
	History z0, z1, z2, z3;	
	x1 =  -0.0703125*z0 +0.867188*z1 +0.226563*z2 -0.0234375 *z3;
	x2 =  -0.0625   *z0 +0.5625  *z1 + 0.5625 *z2 -0.0625    *z3;
	x3 =  -0.0234375*z0 +0.226563*z1 +0.867188*z2 -0.0703125 *z3;
	z3 = z2; z2 = z1; z1 = z0; z0 = in1;
	return z1, x1, x2, x3;
} 
spline4xDn(in1, in2, in3, in4){
	return -0.0625*in1 +0.5625*in2 +0.5625*in3 -0.0625*in4;
} 
qtanh2(x){
	xa = abs(x); x2 = x  * x; x4 = x2 * x2;
	y  = 1 - 1 / (1 + xa 
		+ x2 + 0.66422417311781 * x2 *xa 
		+ 0.36483285408241 * x4);
	return (x > 0)? y : -y;
}
compander2(in1, type, amp, thresh, ratio, att, rel, lclk){
	History comp0(0), lim0(0), comp1(1), lim1(1), gain(1), gain2(1), rate, rate2;
	x = abs(in1);
	if(lclk> 0){
		if (type==4){ gain = (comp1 > thresh)? thresh +(comp1-thresh)/ratio : 1;
					  rate = (comp1 > comp0)?  att : rel;
		}else if(type == 2){ gain = (lim1 > 0)? amp /lim1 : 0;
							 rate = (lim1 > lim0)?   att : rel;
		} else	{			 rate = (gain2 > gain)?   att : rel;
							 gain = 1; }
		comp0	= comp1; lim0	= lim1; comp1   = 1; lim1	= 1;
	} else {
 		if (x > thresh && x >comp1) comp1 = x;
 		if (x > lim1)               lim1  = x;
	}
	if (change(in1 >=0, init =-9999999) !=0){
		gain2 = gain;
		rate2 = rate;
	}
	return in1 * ramp0(gain2, rate2);
}
mixer3(x){ 
	if(x >0) { return 0, 1 -x, x; } 
 	else { return abs(x), 1 +x, 0; }
} 
ramp0(in1, linc){
	History prev;
	prev = prev + linc * (in1 -prev);		
	return prev;
} 
pulse1(ramp, width, inc){
	Buffer eptr("eptr"); 
	i2 = inc * .5;
	if (ramp <= i2) return peek(eptr, 8192 * (ramp + inc - width)/ inc, 0);
	else if (ramp <= width - i2) return 1; 
	else if (ramp <= width + inc) 
		return (peek(eptr, 8192 * (ramp + inc -(1 - width))/inc, 0))*-1;
    else if (ramp < 1 -i2) return -1;
	else return peek(eptr, 8102 * (ramp + inc - width)/inc, 0);
}
sawup (fc, r1, inc, srx3, sr3d3, rsr) {			// rising saw with EPTR AA
	if (r1 < inc){
		return pow(r1/ fc, 3)*sr3d3 +r1*fc*rsr + 1;
	} else if(r1 < inc *2){
		D = r1 *samplerate /fc;	
		return D*D*D* .66666666666666666667 -D*D*3 +r1*srx3/fc +r1*2;		
	} else if(r1 < inc *3) {
		D = r1 *samplerate /fc;	
		return D*D*D*-.33333333333333333333 +D*D*3 +D *inc*2 -D*9+8;	
	} 
	return r1 * 2 -1;
}
sawdown(fc, ramp, inc, srx3, sr3d3, rsr) {
	if (ramp < inc){
		return neg(pow(ramp / fc, 3)*sr3d3 +ramp*fc*rsr +1);
	} else if(ramp < inc *2){
		D = ramp * samplerate /fc;
		return neg(D*D*D*.66666666666666666667 -D*D*3 +ramp*srx3/fc +ramp *2);		
	} else if(ramp < inc *3) {
		D = ramp *samplerate /fc;	
		return neg(D*D*D*-.33333333333333333333 +D*D*3 +D*inc*2 -D*9+8);	
	}
	return (1 - ramp) *2 -1;
}
triwave(ramp, width){
	History zramp;
	dx1 = ramp - zramp;	// same as delta(), not reliable in functions
	zramp = ramp;
	if (dx1 < 0) return -1;
	else if (ramp > width && zramp < width) return 1;
	return (ramp < width) ? ramp/width *2 -1 : (ramp - width)/(1 - width) *-2 +1;
}
sawtri(r1, w1, inc, fc, rsr, srx3, sr3d3){
	if      (w1 < .001)  return sawdown(fc, r1, inc, srx3, sr3d3, rsr);
	else if (w1 > .999) return sawup (fc, r1, inc, srx3, sr3d3, rsr);
	return triwave(r1, w1); 
}
waveset(ramp, wave, waveset){
	Buffer wav("wav");
	x 	= floor(wave) * 256;
	y 	= x + 256; 		if(y  > 32768)  y -= 32768; 
	r0	= ramp -1; 		if(r0 < 0  )   r0 += 256; 
	r1	= ramp +1;		if(r1 > 256)   r1 -= 256;
	r2	= ramp +2; 		if(r2 > 256)   r2 -= 256;
	x = interp(fract(ramp),	wav.peek( x + r0,   waveset),
							wav.peek( x + ramp, waveset),
							wav.peek( x + r1,   waveset),
							wav.peek( x + r2,   waveset), mode="spline" ) ;
	y = interp(fract(ramp),	wav.peek( y + r0,   waveset),
							wav.peek( y + ramp, waveset),
							wav.peek( y + r1,   waveset),
							wav.peek( y + r2,   waveset), mode="spline" ) ;
	return x + (y - x) * (fract(wave));
}
svfCore3(in1, w, d, d2, g1, g2){ 
	History lz, bz;
	h  			= (in1 - (lz +bz *d)) * d2; 
	hw	= h  *  w;	b  = bz + hw;
	bz	= b  + hw;  bw = b  *  w;
	l 	= lz + bw;  lz = l  + bw;
	return l * g1, b*g2, h * g1;
} 
svf5(in1, pitch, poles, res, sat, type, lclk, linc, pirsr){
	History z1;
	w			= tan(clip(mtof(pitch),50,samplerate *.5)*pirsr); 
	q1			= parabol(res, .5) *.885 +.1;
	q11			= 1 -q1;  q2 = q11 + q11;   q4 = q2 + q2; 
	d			= q2 + w; d2 = 1/(d *w +1);	g1 = q1 +.015;
	lx, bx, hx 	= mixer3(type); 
	l2, b2, h2	= svfCore3(in1, w, d, d2, g1, q4);
	f2			= l2*lx +b2*bx +h2*hx;
	l4, b4, h4	= svfCore3(f2 , w, d, d2, g1, q4);
	p1, p2, p4 	= mixer3(poles); 
	fo		 	= in1*p1 + (f2*p2 +p4*(l4*lx +b4*bx +h4*hx)) *2;
	u1,u2,u3,u4	= spline4xUp(fo);
	s1			= saturator5(u1, sat, lclk, linc, p1);
	s2 			= saturator5(u2, sat, lclk, linc, p1);
	s3 			= saturator5(u3, sat, lclk, linc, p1);
	s4 			= saturator5(u4, sat, lclk, linc, p1);
	if (p1==1 && sat==0)return in1;
	else return spline4xDn(s1, s2, s3, s4);
} 
saturator5(in1, sat, lclk, linc) { 
	History z1, h1, h1p, h1n, h2o, h2, h3, h4;
	if(lclk ==1){ if(h1n >0){ h1 = (h1p - h1n) * .5; h20 = neg(h1 + h1n);
		} else if (h1p <= 0){ h1 = (h1n - h1p) * .5; h20 = h1 - h1p;
		} else {			  h1 = (h1p - h1n) * .5; h2o = h1 - h1p; }
		h2 = (h1 !=0)? 1/h1 : 0; h1n = 0; h1p = 0;
	} else if (change(in1) == -1) { h1p = max(h1p, z1);
	} else if (change(in1) ==  1) { h1n = min(h1n, z1); }
 	h3 		= ramp0(h2, linc); 	h4		= min(h3, 1); z1 -= ramp0(h2o);
	x = mix(z1 *h4, qtanh2(z1 * 4 *h4), 1 - abs(sat));
	if(sat>0){ x = fold(x *(sat*8 +1), -1, 1); }
	z1		= in1;	return x;
}
mod0(base, sel, m, q){
	return (sel==0 || m==0)? base : base + m * q.peek(sel);
}
modClip(base, sel, m, min, max, q){
	return (sel==0 || m==0)? base : clip( base +m *q.peek(sel), min, max);
}
modScale(base, sel, m, q){
	return (sel==0 || m==0)? base : base + base * m * q.peek(sel);
} 
modFold(base, sel, m, min, max, q){
	return (sel==0 || m==0)? base : fold(base + m * q.peek(sel), min, max);
}
ModFoldMix(base, sel, m, min, max, q){ 
	return (sel==0 || m==0)? base : fold(
		base * (1 - m) + base *m * q.peek(sel), min, max); 
}
modFoldDuo(base, sel1, sel2, a, b, min, max, q){
	return fold (base +a *q.peek(sel1) +b *q.peek(sel2), min, max);
}
modRing(base, sel, m, src, a, b, q){
	History h;
	y = a *(1 -h) + a *b *h;
	if (change(y >=0)){
		h = modClip(base, sel, m, 0, 1, q);
		y = a *(1 -h) + a *b *(1-h);
	}
	return y; 
}
env(trg, att, dec, sus, rel, preslope){
	History stage, lvl, lvl2;
	if(trg >0){	if   (stage > 0){ stage = 1; lvl2  = lvl;
			  } else			  stage = 2;
	}else if(trg < 0){			  stage = 5; lvl2  = lvl; }
	stage = selector(stage, stage+preslope, stage+att, stage+dec, 4, stage+rel, 0);
	if(stage <1)	   {lvl= 0;
	}else if(stage < 2){lvl= lvl2 - fract(stage); lvl *=lvl;
	}else if(stage < 3){lvl= fract(stage); 	  	  lvl *=lvl;
	}else if(stage < 4){lvl= fract(stage); 		  lvl *=lvl; lvl= 1 - lvl*(1 -sus);
	}else if(stage < 5){lvl= sus;
	}else if(stage < 6){lvl=  fract(stage); 	  lvl *= lvl; lvl= lvl2 - lvl*lvl2;
	} else 			   {lvl= 0; }
	return lvl, stage;
}
lfo2(lshape, w, lf, lfs, lfm, lam, las, lsnc, gtrg, rsr, q){
 	History l;
	inc = max(0, rsr * modScale(lf, lfs, lfm, q) );
 	if(gtrg>0 && lsnc==1) l = 0;
	else l = fract(l +inc);
	x = selector(lshape, 
			(l >= (w *.9 +.05)) *2 -1, 
			triangle(l, w) *2 -1, 
			waveset(l *256, w * 127, 2), 
			sah(noise(), change(l) <0 ),
			sah (l, change( floor(l /((1-w) *.395 +.1)) ) ) ); 
	return ModFoldMix(x, las, lam, -1, 1, q);
}
xyController(cx0, cx1, cxm, cy0, cy1, cym, q){
	x0     = q.peek(cx0); 		x1     = q.peek(cx1);
	y0     = q.peek(cy0); 		y1     = q.peek(cy1);
	cxm1   = 1 - cxm;	  		cym1   = 1 - cym;
	x0cxm1 = x0 * cxm1; 		y0cym1 = y0 * cym1;
	x1cxm  = x1 * cxm;			y1cym  = y1 * cym;
	tl     = x0cxm1 * cym1;		tr     = y0cym1 * cxm1; 
	bl     = x1cxm  * cym1;		br     = y1cym  * cxm;
	hm     = x1cxm  * x0;		vm     = y1cym  * y0;
	return x0cxm1 + x1cxm, y0cym1 + y1cym, 
		tl+tr+bl+br, tl, bl, tr, br, hm, vm, hm+vm;  
		  
} //------------------------ MAIN ----------------------------------*
Buffer dat("dat", 60, 1), gain("gain", 32, 1), tunings("tunings");  
Data a(20, 1), omega(128), dTune(128);
Param thispoly(-1), lastv(0), o1p(60), bsens, tuning, 
	w1set(1), w1wav, w1was, w1wam, w1wbs, w1wbm, sync,  w1xp, w1xps, w1xpm, 
	w2set(1), w2wav, w2was, w2wam, w2wbs, w2wbm, sync2, w2xp, w2xps, w2xpm, 
	w1d, w1ds, w1dm, rng, rngs, rngm, w2mix, w2mixs, w2mixm,  
	w2d, w2dm, w2ds, fm, fms, fmm, ph, phs, phm,     
	f1c, f1cs, f2cs, f1cm, f2cm, f1p, f1ps, f1pm,	
	f1q, f1qs, f1qm, f1s, f1ss, f1sm, f1t, f1ts, f1tm,
	e1a(.01), e1d(.01), e1s(.75), e1r(.01), e1v(1), e1g,
	e2a(.01), e2d(.01), e2s(.75), e2r(.01), 
	e3a(.01), e3d(.01), e3s(.75), e3r(.01), 
	l1w, l1shape(1), l1ws, l1wm, l1f(1), l1fm, l1fs, 
	l2w, l2shape(1), l2ws, l2wm, l2f(1), l2fm, l2fs, 
	l1am, l1as(1), l1snc, l2am, l2as(1), l2snc,  
	l3f, l3shape(1), sh1m, sh1s, sh1t, whl, bend, 
	cx0, cx1, cxm, cy0, cy1, cym,   
	limon, limlvl, limatt, limrel, limthresh, limratio, ampm, amps; 
History	init(0), lclk0, ltime, linc(1), rsr, srx3, sr3d3, pirsr, mbend,
	vce, op, a1, e1, a2, a3, eslope, l1, l2, l3, l3i, lw1, lw2, sh1, 
	mx, my, mxy, mx0, mx1, my0, my1, mx2, my2, mxy2, 
	ramp1, ramp2, o1w, o2w, o1set, o2set, f1, poles1, q1, sat1, t1, zd;
out1, gtrg, trg, mod, v, x, y  = 0;
if(init==0){
	rsr 		= 1     / samplerate;
	linc  		= 10    / samplerate;
	eslope		= 1 	/ mstosamps(25);
	srx3		= 3     * samplerate;
	sr3d3		= samplerate * samplerate *samplerate /3;
	pirsr		= pi 	/samplerate;
	vce			= thispoly * 0.03125; a.poke(vce, 12);
	init		= 1;
}
lclk0		= (lclk0>1 || gtrg==1)? 0 : lclk0 + linc;
lclk 		= change(lclk0 >.5) >0;
gtrg 		= change(e1g);
if (e1 > 0 || gtrg >0 || thispoly == lastv){
	a1, e1	= env(gtrg, e1a, e1d, e1s, e1r, eslope);
	a1 	   *= e1v;
	x 		= ((e1==4) && (e1s==0))? 1: 0;
	dat.poke(x, thispoly +30);
	a2 		= env(gtrg, e2a, e2d, e2s, e2r, eslope) *e1v;
	a3 		= env(gtrg, e3a, e3d, e3s, e3r, eslope);
	a.poke(a1, 1); a.poke(a2,  2); a.poke(a3,  3); a.poke(e1v, 10);
	gain.poke(a1, thispoly);
	mbend	= bsens * bend;
	v		= mod0(w1d, w1ds, w1dm, a) + mbend;
	a.poke((tunings.peek(o1p) +v -60) *.05, 11); 
	x		= mtof(modClip(tunings.peek(o1p +w1xp, tuning) +v,
 				w1xps, w1xpm, 20, 120, a));
	y		= x * rsr;
	if(gtrg==1) ramp1	= (sync == 1)? 0 : vce ;
	else ramp1 = fract(ramp1 + y);
	if(change(ramp1)<0) {
		o1w = modFoldDuo(w1wav, w1was, w1wbs, w1wam, w1wbm, 0, 127, a);
		o1set = w1set;
	}
	if(o1set == 0) 	 out1 = clip(pulse1 (ramp1, o1w *0.00708661417 + .05, y), -1, 1);
	else if(o1set==1)out1 = sawtri (ramp1, o1w *0.00787401574, y, x, srx3, sr3d3, rsr);
	else 		  	 out1 = waveset(ramp1 *256, o1w, o1set);
	v 		= modClip(tunings.peek(o1p +w2xp, tuning) +v +mod0(w2d, w2ds, w2dm, a), 
				w2xps, w2xpm, 20, 129, a);
	x 		= mtof(v);
	y 		= mod0(fm, fms, fmm, a);
	if (y !=0){
		v	=  v + y;
		x	+= (mtof(tunings.peek(v) +fract(v)) -x) * out1;
	}
 	y		= x * rsr; 
	v 		= modClip(ph, phs, phm, 0, .99, a);
	if 		(sync2 ==0 && gtrg>0) 			ramp2  = v; // phase set on gate trig
	else if (sync2 ==1 && change(out1>v))   ramp2  = 0; // soft sync 
	else 							 		ramp2  = fract(ramp2 + y);
	if(change(ramp2)<0){
		o2w = modFoldDuo(w2wav, w2was, w2wbs, w2wam, w2wbm, 0, 127, a);
		o2set = w2set;
	}
	if(o2set ==0) 	 v = clip(pulse1(ramp2, o2w *0.00708661417 + .05, y),-1, 1);
	else if(o2set==1)v = sawtri (ramp2, o2w *0.00787401574, y, x, srx3, sr3d3, rsr);
	else 		     v = waveset(ramp2 *256, o2w, o2set);
	x 		= modClip(w2mix, w2mixs, w2mixm, 0, 1, a);
	x		= ramp0(x, linc);
	y 		= out1 *(1 -x) + v *x;
	x 		= modClip(rng, rngs, rngm, 0, 1, a);
	out1	= y * (1 -x) + out1 * v * x;
	poles1	= ramp0( modClip(f1p, f1ps, f1pm, -1, 1,   a), linc);
	q1		= ramp0( modClip(f1q, f1qs, f1qm,  0, 1,   a), linc); 
	sat1 	= ramp0( modClip(f1s, f1ss, f1sm, -1, 1,  a), linc);
	t1		= ramp0( modClip(f1t, f1ts, f1tm, -1, 1,   a), linc);
	f1		= tunings.peek(f1c + o1p, tuning) + mbend;
	if (f1cm!=0 && f1cs!=0) f1 += a.peek(f1cs) *f1cm;
	if (f2cm!=0 && f2cs!=0) f1 += a.peek(f2cs) *f2cm;
	f1  	= clip(f1, 20, 120);
	out1 	= svf5(out1, f1, poles1, q1, sat1, t1, lclk, linc, pirsr);
	lw1 	= modFold(l1w, l1ws, l1wm, 0, 1, a);
	l1 		= lfo2(l1shape, lw1, l1f, l1fs, l1fm, l1am, l1as, l1snc, gtrg, rsr, a); 
	lw2 	= modFold(l2w, l2ws, l2wm, 0, 1, a);
	l2 		= lfo2(l2shape, lw2, l2f, l2fs, l2fm, l2am, l2as, l2snc, gtrg, rsr, a); 
	a.poke(l1, 4);	a.poke(l2, 	5);	
	if(change(a.peek(sh1t)>=sh1m)>0){ 
 			sh1 = a.peek(sh1s);
			a.poke(sh1, 	13);
	}
	if(thispoly  ==lastv){
		x		= fract(dat.peek(19) + l3f*rsr);
		dat.poke(x, 19);
		l3 		= selector(l3shape, cycle(x, index="phase"), 
					x *2 -1, neg(x *-2 +1), triangle(x) *2 -1, 
					(x >.5) *2 -1, sah(noise(), (change(x) == -1)) );
		a.poke(l3, 6); a.poke(l3 * whl, 7); a.poke(whl, 8); a.poke(bend,9);
		zd 		+= 1;
		if 		(zd >= 120) zd = 0;
		else if (zd <= 18 ) {
			dat.poke(selector(zd, 
			mx, my, l1,l2,l3, a2,a3, sh1,mod, lw1,lw2,o1w,o2w, f1,poles1,q1,t1,sat1), 
			zd);
		}
	}else {
		l3 		= a.peek(5); mod = a.peek(9);
	}
	mx, my, mxy, mx0, mx1, my0, my1, mx2, my2, mxy2 = 
		xyController(cx0, cx1, cxm, cy0, cy1, cym, a);
	a.poke(mx,  14); a.poke(my,  15); a.poke(mxy, 16); 
	a.poke(mx0, 17); a.poke(mx1, 18); a.poke(my0, 19); a.poke(my1, 20); 
	a.poke(mx2, 21); a.poke(my2, 22); a.poke(mxy2, 23); 
	x = (amps==0 || ampm==0)? 1 : clip(1 + ampm * a.peek(amps), 0, 1);
	out1 = out1 * ramp0(x, linc) * a1;
	out1 = compander2(out1, limon, limlvl, limthresh, limratio, limatt, limrel, lclk);
}

The active voices are then mixed and passed to a single-channel output mastering routine. It would be simple to add individual outs for each voice, if desired.

// ramps to new val, incr = 1/#samples
ramp0(in1, linc){
	History prev;
	prev = prev + linc * (in1 -prev);		
	return prev;
} 
compander3(in1, type, amp, thresh, ratio, att, rel, lclk){ // combined ctrl +o/p gain
// in1 		= Signal to limit or compress.
// type		= whether to limit or compress
// amp 		= limiter output amp
// thresh 	= amplitude to start compression
// ratio	= compression ratio after level exceeds amplitude
// att, rel = attack and release in samples
// lclk  	= 0 causes resampling of level.
// Return:	Limited signal. 
	History comp0(0), lim0(0), comp1(1), lim1(1), gain(1), gain2(1), rate, rate2;
	x = abs(in1);
	if(lclk> 0){
		if (type==3){ 							//compressor
			gain = (comp1 > thresh)? amp * (thresh +(comp1 -thresh)/ratio) : amp;
			rate = (comp1 > comp0)?  att : rel;
		} else if (type == 1){ 					// limiter	
			gain  = (lim1 > 0)?      amp /lim1 : 0;
			rate =  (lim1 > lim0)?   att : rel;
		} else	{								// off
			rate = (gain2 > gain)?   att : rel;
			gain = amp;
		}
		comp0	= comp1;
		lim0	= lim1;
		comp1   = 1;
		lim1	= 1;
	} else {
 		if (x > thresh && x >comp1) comp1 = x;
 		if (x > lim1)               lim1  = x;
	}
	if (change(in1 >=0, init =-9999999) !=0){
		gain2 = gain;
		rate2 = rate;
	}
	return in1 * ramp0(gain2, rate2);
}
Param limon, limlvl, limthresh, limratio, limatt, limrel;
History init, lclk, lclk0, ltime, linc;
if(init==0){
	ltime 		= 10/samplerate;
	linc  		= 10/samplerate;
	init		= 1;
}
lclk0		= (lclk0>1)? 0 : lclk0 + ltime;
lclk 		= change(lclk0 >.5);
out1 = compander3(in1, limon, limlvl, limthresh, limratio, limatt, limrel, lclk);

Design Notes: Voice Allocator

Newest in this design is the gen-compiled voice allocator. The algorithm uses three buffers: two to maintain the current pitch and velocity of active notes, and one containing the voice age queue, which is preloaded with values from 1 to 32. When a new note-on message is received, it is placed at the begnning of of the queue taking the voice number of the oldest voice in the age queue. The age of all prior notes is incremented, and the audio path for that voice is switched on in the next audio clock cycle. When a note-off message is received, it is removed from the queue, and older voices which might still be in the release phase are moved up the queue to fill the hole it leaves, then the voice number of the turned-off note is inserted after the last of the previously released notes. This technique ensures that all turned-off notes remain in the queue for the longest possible duration so that their release phases may complete uninterrupted if possible. When the note reaches the end of its release phase (the amplitude envelope reaches zero), the note is turned off in the audio path to reduce CPU utilization. Lastly, the below code issues the voice number of the most recently played note on outlet 5, which sets the voice used for subsequent screen-display of waveform and filter curves. The code listing follows.

// voice state buffers
Buffer pch(), vel(), age();
History numv(0), p0(0), g0(0), vcnt(32), 
	curchan(0), lastv(32), gcnt(1), init;
x, aoff = 0; 
if (in1 <0 || init==0){ 							// RESWETS 
	for (i=1; i<=32; i+=1){
		vel.poke(0, i); 
		pch.poke(0, i);
		age.poke(i, i);
	}
	p0 		= 0;
	numv 	= 0;
	init	= 1;
	if(in1 !=-33){
		vcnt 	= neg(in1);
		lastv 	= vcnt;
	}
}else if (in1 != p0 && in2 >0) {		// NOTE ON
	for(i=1;i<=vcnt; i+=1){
		x = age.peek(i);
		if(x == vcnt){
			if(numv==vcnt){
				if(vel.peek(i)>0){
					out4 = pch.peek(i); //kb overflow update
				}
			}else{
				numv +=1;
				out4= 0;
			}
			age.poke(1, i);
			lastv = i;					// last voice on
			out6 = in2 *.007874;		// velocity
			gcnt += 1;
			out3 = gcnt;				//gate out 0-1
			out2 = in1; 				//fc out, Hz
			out1 = i;
			pch.poke(in1,i); 
			vel.poke(out6,i);
		}else{
			age.poke(x+1,i);
		}
	}
	p0  = in1;
} else if (in1==p0 &&in2>0 || in2 ==0){				//NOTE OFF
	for(i=1;i<=vcnt; i+=1){
		if(pch.peek(i) ==in1){
			p0 = 0;
			aoff = age.peek(i);
			pch.poke(0, i);
			vel.poke(0, i);
			for(j=1;j<=vcnt; j+=1){
				x = age.peek(j);
				if(x>aoff && x<=numv){
					age.poke(x-1, j);
				}
			}
			age.poke(numv, i);
			numv -=1;		
			out4 = 0; 						//kb fix
			out3 = 0; 						//vel 0
			out2 = in1; 					//fr off
			out1 = i;						//voice off
			break;
		}
	}
}
out5 = lastv;

Design Notes: MIDI and Preset Management

Data from a MidiParse object is passed through initial filtering routines before being sent to the preset manager patch. All incoming MIDI data is scaled by a gen object, with a little external string parsing, in the MIDI parse subpatch. The resulting param name/value tuples are sent through the PattrStorage object, then distributed to controls by a pattrHub object at the patch's top level. Outgoing MIDI data is scaled by a gen object that performs the same transformations as for incoming data, but in reverse. The pattrstorage bank is loaded and stored in the Bank Manager patch, which does some tricky stuff to determine the current directory on both PC and Mac platforms.

Upon any panel change, the parameter value is immediately stored in an empty preset slot. Upon closing the device, the slot is saved, and restored upon reopening. Also, with prior experience on Reaktor I found the default method for inserting and deleting presets counterintuitive, so I added the small code section in the [patches] subpatch. This code for example APPENDs presets in the next available empty slot, rather than after the last preset in the bank. Special care is taken on boundary conditions to ensure that a user's hard work is never lost.

outlets = 5;
editfontsize = 6;
var listNum; 		// zero-based chooser list#
var pgm;	 		// one-based pgm# from chooser text
var action 		= 0; // semaphore
var pgmName 	= 'not named';
var dirtyPatch 	= 0;
function bang(){
	if (action=='add' || action=='insert'){ // empty list
		post('bang','\n');
		outlet(0, 'store', 1); // pattrstorage
		outlet(0, 'setall presetNmbr', 1);
		outlet(3, 0); // dirty
		outlet(4, 1); // pgm#
		newName(1, 0);
		post(x, '\n');
	}else if (action == 'delete'){
	}
	action = 0;
}
function newName(pgmNumber, listNumber){
	//post(pgmName, 'length', pgmName.length, '\n');
	if(dirtyPatch==1){
		pgmName = pgmName + "*";
	}
	outlet(0, 'slotname', pgmNumber, pgmName);
	outlet(1, listNumber); // menu update
	return(0);
}
function list(){ // slotlist
	var slots = arrayfromargs(arguments);
	// post('SLOTS', slots, '\n');
	if (action == 'delete'){
		if(listNum == 0){
			outlet(0, 'delete', pgm);
			outlet(0, 'setall presetNmbr', 1);
			outlet(1, 0); // menu update
			outlet(3, 1); // dirty
			outlet(4, 1); // pgm#
		} else {
			var x = slots.indexOf(pgm);
			//post('delete program', pgm, 'slot index',x,'listnum', listNum, '\n');
			outlet(0, 'delete', pgm);
			outlet(0, 'setall presetNmbr', slots[x -1]);
			outlet(0, 'getslotname', slots[x -1]); // slotname
			outlet(1, listNum -1); // menu update
			outlet(3, 1); // dirty
			outlet(4, slots[x -1]); // pgm#
		}
	} else if (action == 'add'){
		var base = slots.indexOf(pgm);
		var x = pgm;
		for(i = base +1; i <129; i++){
			x ++;
			if (i >= 128) {
				outlet(2, 'Cannot add. All later slots are full.');
				break;
			} else if (slots[i] != x) {
				outlet(0, 'store', x); 
				outlet(0, 'setall presetNmbr', x);
				newName(x, i); // set name and update menu
				outlet(3, 0); // dirty
				outlet(4, x); // pgm#
				break;
			}
		}
	} else if (action == 'insert'){
		if (slots[0] == 0){
			outlet(0, 'delete', 0);
			outlet(0, 'getslotlist');
		} else if (slots.length >= 128){ 
			outlet(2, 'Cannot insert, bank full.');
		} else if(listNum !=0 && slots[listNum -1] != pgm -1){// prior item empty
			outlet(0, 'store', pgm -1); 
			outlet(0, 'setall presetNmbr', pgm -1);
			newName(pgm -1, listNum); // set name and update menu
			outlet(3, 0); // dirty
			outlet(4, pgm -1); // pgm#
		} else {							// insert, prior item full
			var base = slots.indexOf(pgm) +1;
 			//post('base', base, 'program', pgm, '\n');
			var x = pgm;
			for(i = base; i <129; i++){
				x++;
				if (i == 128) {
					outlet(2, 'Cannot insert. All later slots are full.');
					break;
				} else if (slots[i] != x) {
					//post('found next empty slot', i, '\n');
					for(j = i +1; j >= pgm; j--){
						outlet(0, 'copy', j -1, j);
					}
					outlet(0, 'store', pgm); // pattrstorage
					outlet(0, 'setall presetNmbr', pgm);
					newName(pgm, listNum); // set name and update menu
					outlet(3, 0); // dirty
					outlet(4, pgm); // pgm#
					break;
				}
			}
		}
	}
	// post('action 0');
	action = 0;
}
function replace(){
	outlet(0, 'store', pgm);
	outlet(0, 'setall presetNmbr', pgm);
	outlet(1, listNum); // menu update
	outlet(3, 0); // dirty
	outlet(4, pgm); // pgm#
//	outlet(0, 'slotname', pgm, a);
}
function text(a){
	pgmName = a;
	outlet(0, 'slotname', pgm, a);
	outlet(1, listNum); // menu update
}
function add(){
	action = 'add';
	outlet(0,'getslotlist'); // pattrstorage
}
function insert(){
	action = 'insert';
	outlet(0,'getslotlist'); // pattrstorage
}
function del(){
	action = 'delete';
	outlet(0,'getslotlist'); // pattrstorage
}
function dirtiedPatch(i){
	dirtyPatch = i;
}
function listnum(x){ 
	listNum = x;
//	post('listNum', x, '\n'); 
}
function slotname(a){
	pgmName = a;
}
function prg(x){ 
	pgm = x;
}

Please contact me if you need assistance with patch modifications, and I will do what I can to help.