From: Jérémie Astor <fennecdjay@gmail.com>
Date: Wed, 23 Mar 2022 07:58:00 +0000 (+0100)
Subject: again
X-Git-Url: http://10.10.0.4:5575/?a=commitdiff_plain;h=809a12c7135063898b488a3584da84ce9b0fdbdd;p=gwion.git

again
---

diff --git a/docs/Reference/Plugins/Analys.mdr b/docs/Reference/Plugins/Analys.mdr
new file mode 100644
index 00000000..ac464471
--- /dev/null
+++ b/docs/Reference/Plugins/Analys.mdr
@@ -0,0 +1,47 @@
+# Analys
+
+compiler generated documentation
+
+```gwion
+#!+ Analys
+class FFT extends UGen {
+  fun int init(int size);
+  fun void compute();
+}
+class ANA extends Object {
+  var @internal @_fft;
+  late FFT @fft;
+  var @internal @fn;
+  fun float compute();
+  fun FFT fft();
+  fun FFT fft(FFT arg);
+}
+class Centroid extends ANA {
+}
+class Spread extends ANA {
+}
+class Skewness extends ANA {
+}
+class Kurtosis extends ANA {
+}
+class RMS extends ANA {
+}
+class Rolloff extends ANA {
+  fun float percent();
+  fun float percent(float arg);
+}
+class Freq extends ANA {
+}
+class ASC extends ANA {
+}
+class ASS extends ANA {
+}
+class FC extends Object {
+  var @internal @vector;
+  fun float[] compute();
+  fun ANA add(ANA arg);
+  fun ANA rem(ANA arg);
+}
+operator FC => (ANA, FC);
+operator FC =< (ANA, FC);
+```
diff --git a/docs/Reference/Plugins/Emoji.mdr b/docs/Reference/Plugins/Emoji.mdr
new file mode 100644
index 00000000..e63dabba
--- /dev/null
+++ b/docs/Reference/Plugins/Emoji.mdr
@@ -0,0 +1,10 @@
+# Emoji
+
+compiler generated documentation
+
+```gwion
+#!+ Emoji
+class Emoji extends string {
+  operator auto new(string arg);
+}
+```
diff --git a/docs/Reference/Plugins/File.mdr b/docs/Reference/Plugins/File.mdr
new file mode 100644
index 00000000..375b54cd
--- /dev/null
+++ b/docs/Reference/Plugins/File.mdr
@@ -0,0 +1,11 @@
+# File
+
+compiler generated documentation
+
+```gwion
+#!+ File
+class File:[ module ] extends Event {
+}
+operator File @scan ();
+operator @ctor (File);
+```
diff --git a/docs/Reference/Plugins/Lsys.mdr b/docs/Reference/Plugins/Lsys.mdr
new file mode 100644
index 00000000..2571e449
--- /dev/null
+++ b/docs/Reference/Plugins/Lsys.mdr
@@ -0,0 +1,13 @@
+# Lsys
+
+compiler generated documentation
+
+```gwion
+#!+ Lsys
+class Lsys extends Object {
+  fun void parse(int ordstring str);
+  fun void reset();
+  fun int size();
+  fun string get();
+}
+```
diff --git a/docs/Reference/Plugins/Machine.mdr b/docs/Reference/Plugins/Machine.mdr
new file mode 100644
index 00000000..cb61bc4e
--- /dev/null
+++ b/docs/Reference/Plugins/Machine.mdr
@@ -0,0 +1,15 @@
+# Machine
+
+compiler generated documentation
+
+```gwion
+#!+ Machine
+fun static int add(string filename);
+fun static int remove(int id);
+fun static int replace(int idstring filename);
+fun static int[] shreds();
+fun static int check(string code);
+fun static int compile(string code);
+fun static int compile_replace(string codestring filename);
+fun static int pass(string[] passes);
+```
diff --git a/docs/Reference/Plugins/Math.mdr b/docs/Reference/Plugins/Math.mdr
new file mode 100644
index 00000000..3eb23cb8
--- /dev/null
+++ b/docs/Reference/Plugins/Math.mdr
@@ -0,0 +1,49 @@
+# Math
+
+compiler generated documentation
+
+```gwion
+#!+ Math
+fun static int abs(int value);
+fun static int rand();
+fun static int rand2(int minint max);
+fun static float randf();
+fun static float rand2f(float value1float value2);
+fun static float fabs(float value);
+fun static float srand(float value);
+fun static float sgn(float value);
+fun static float sin(float value);
+fun static float cos(float value);
+fun static float tan(float value);
+fun static float asin(float value);
+fun static float acos(float value);
+fun static float atan(float value);
+fun static float sinh(float value);
+fun static float cosh(float value);
+fun static float tanh(float value);
+fun static float asinh(float value);
+fun static float acosh(float value);
+fun static float atanh(float value);
+fun static float sqrt(float value);
+fun static float exp(float value);
+fun static float log(float value);
+fun static float log2(float value);
+fun static float log10(float value);
+fun static float floor(float value);
+fun static float ceil(float value);
+fun static float round(float value);
+fun static float trunc(float value);
+fun static float isinf(float value);
+fun static float isnan(float value);
+fun static float hypot(float value1float value2);
+fun static float atan2(float value1float value2);
+fun static float pow(float value1float value2);
+fun static float fmod(float value1float value2);
+fun static float remainder(float value1float value2);
+fun static float min(float value1float value2);
+fun static float max(float value1float value2);
+operator float ** (float, float);
+operator float ** (int, float);
+operator float ** (float, int);
+operator int ** (int, int);
+```
diff --git a/docs/Reference/Plugins/Modules.mdr b/docs/Reference/Plugins/Modules.mdr
new file mode 100644
index 00000000..df5dd287
--- /dev/null
+++ b/docs/Reference/Plugins/Modules.mdr
@@ -0,0 +1,36 @@
+# Modules
+
+compiler generated documentation
+
+```gwion
+#!+ Modules
+class SinOsc extends UGen {
+  fun void init(int size);
+  fun void init(int sizefloat phase);
+  fun float freq();
+  fun float freq(float freq);
+  fun float amp();
+  fun float amp(float amp);
+}
+class Gain extends UGen {
+  fun float gain();
+  fun float gain(float arg0);
+}
+class Impulse extends UGen {
+  fun float next();
+  fun float next(float arg0);
+}
+class FullRect extends UGen {
+}
+class HalfRect extends UGen {
+}
+class Step extends UGen {
+  fun float next();
+  fun float next(float arg0);
+}
+class ZeroX extends UGen {
+}
+typedef Bltriangle TriOsc;
+typedef Blsquare SquareOsc;
+typedef Blsaw SawOsc;
+```
diff --git a/docs/Reference/Plugins/Sndfile.mdr b/docs/Reference/Plugins/Sndfile.mdr
new file mode 100644
index 00000000..0d8931a6
--- /dev/null
+++ b/docs/Reference/Plugins/Sndfile.mdr
@@ -0,0 +1,6 @@
+# Sndfile
+
+compiler generated documentation
+
+```gwion
+```
diff --git a/docs/Reference/Plugins/Soundpipe.mdr b/docs/Reference/Plugins/Soundpipe.mdr
new file mode 100644
index 00000000..2aaedac6
--- /dev/null
+++ b/docs/Reference/Plugins/Soundpipe.mdr
@@ -0,0 +1,1559 @@
+# Soundpipe
+
+compiler generated documentation
+
+```gwion
+#!+ Soundpipe
+const late UGen @soundpipe;
+class ftbl extends Object {
+  var @internal @ftbl;
+  #!- a string of space-separated parameters, in groups of four:
+  #!- 
+  #!- arg 1 is the partial number. must be positive, but it doesn't need to be a whole number.
+  #!- 
+  #!- arg 2 is the strength.
+  #!- 
+  #!- arg 3 is the initial phase (expressed in degrees)
+  #!- 
+  #!- arg 4 is the dc offset. A dc offset of 2 will put a 2-strength sinusoid in the range
+  #!- from (-2,2) to (0, 4)
+  fun void _gen_composite(int Sizestring _argstring);
+  #!- filename
+  fun void _gen_file(int Sizestring _filename);
+  #!- The scale of the distribution, in the range of -/+scale
+  #!- Random seed.
+  fun void _gen_gauss(int Sizefloat _scaleint _seed);
+  #!- A list of ordered xy pairs. X expects whole number integers, as they correlate to index positions in the ftable.
+  fun void _gen_line(int Sizestring _argstring);
+  #!- ftable of amplitudes to use
+  #!- Base frequency.
+  #!- Bandwidth.
+  fun void _gen_padsynth(int Sizeftbl _ampsfloat _ffloat _bw);
+  #!- A string of value pairs. The first value is the value, then the probability.
+  fun void _gen_rand(int Sizestring _argstring);
+  #!- destination ftable
+  fun void _gen_scrambler(int Sizeftbl _dest);
+  fun void _gen_sine(int Size);
+  #!- A list of amplitudes, in the range 0-1, separated by spaces.Each position coordinates to their partial number. Position 1 is the fundamental amplitude (1 * freq). Position 2 is the first overtone (2 * freq), 3 is the second (3 * freq), etc...
+  fun void _gen_sinesum(int Sizestring _argstring);
+  fun void _gen_triangle(int Size);
+  #!- A list of ordered xy pairs. X expects whole number integers, as they correlate to index positions in the ftable.
+  fun void _gen_xline(int Sizestring _argstring);
+}
+#!- ADSR generator
+#!- This is an ADSR generator whose curves are created using a one-pole low pass filter.
+class Adsr extends UGen {
+  fun float atk();
+  #!- Attack time (in seconds)
+  fun float atk(float _atk);
+  fun float dec();
+  #!- Decay time (in seconds)
+  fun float dec(float _dec);
+  fun float sus();
+  #!- Sustain (in range 0-1)
+  fun float sus(float _sus);
+  fun float rel();
+  #!- Release time (in seconds)
+  fun float rel(float _rel);
+}
+#!- Allpass filter
+#!- 
+#!-     Often used for the creation of reverb modules.
+class Allpass extends UGen {
+  #!- The loop time of the filter, in seconds. This can also be thought of as the delay time.
+  fun void init(float _looptime);
+  fun float revtime();
+  #!- The reverberation time, in seconds (RT-60).
+  fun float revtime(float _revtime);
+}
+#!- First-order recursive highpass filter
+#!- 
+#!- 	This is the complement to the tone module.
+class Atone extends UGen {
+  fun float hp();
+  #!- The response curve's half power point (cutoff frequency).
+  fun float hp(float _hp);
+}
+#!- Automatic wah pedal
+#!- 	An automatic wah effect, ported from Guitarix via Faust. 
+class Autowah extends UGen {
+  fun float level();
+  #!- Overall level (between 0 and 1)
+  fun float level(float _level);
+  fun float wah();
+  #!- wah amount
+  fun float wah(float _wah);
+  fun float mix();
+  #!- Wet/dry amount (100 = wet, 0 = dry)
+  fun float mix(float _mix);
+}
+#!- Balance the gain of one signal based on another signal
+#!- 
+#!-     This is often used to restore gain lost in the output of a filter.
+#!- 
+#!- In the source code, the value `ihp` is set to a static 10hz. This is the default value in Csound, and should not often need to be changed.
+class Bal extends UGen {
+}
+#!- Physical model approximating the sound of a struck metal bar
+class Bar extends UGen {
+  #!- Dimensionless stiffness parameter
+  #!- High-frequency loss parameter. Keep this small
+  fun void init(float _iKfloat _ib);
+  fun float bcL();
+  #!- Boundary condition at left end of bar. 1 = clamped, 2 = pivoting, 3 = free
+  fun float bcL(float _bcL);
+  fun float bcR();
+  #!- Boundary condition at right end of bar. 1 = clamped, 2 = pivoting, 3 = free
+  fun float bcR(float _bcR);
+  fun float T30();
+  #!- 30db decay time (in seconds).
+  fun float T30(float _T30);
+  fun float scan();
+  #!- Speed of scanning the output location.
+  fun float scan(float _scan);
+  fun float pos();
+  #!- Position along bar that strike occurs.
+  fun float pos(float _pos);
+  fun float vel();
+  #!- Normalized strike velocity
+  fun float vel(float _vel);
+  fun float wid();
+  #!- Spatial width of strike.
+  fun float wid(float _wid);
+}
+#!- A sweepable biquadratic general purpose filter
+#!- 
+#!-     
+class Biquad extends UGen {
+  fun float b0();
+  #!- biquad coefficient.
+  fun float b0(float _b0);
+  fun float b1();
+  #!- biquad coefficient.
+  fun float b1(float _b1);
+  fun float b2();
+  #!- biquad coefficient.
+  fun float b2(float _b2);
+  fun float a0();
+  #!- biquad coefficient.
+  fun float a0(float _a0);
+  fun float a1();
+  #!- biquad coefficient.
+  fun float a1(float _a1);
+  fun float a2();
+  #!- biquad coefficient.
+  fun float a2(float _a2);
+}
+#!- Bipolar Scale
+#!- 
+#!-     This module scales from bipolar [-1, 1] to another range defined by min and max.
+class Biscale extends UGen {
+  fun float min();
+  #!- Minimum value to scale to.
+  fun float min(float _min);
+  fun float max();
+  #!- Maximum value to scale to.
+  fun float max(float _max);
+}
+#!- Digital signal degradation
+#!- 
+#!-     Bitcrusher will digitally degrade a signal by altering the bitdepth and sampling-rate. 
+class Bitcrush extends UGen {
+  fun float bitdepth();
+  #!- Bit depth. Expects an integer in the range of 1-16. Fractional values will be truncated.
+  fun float bitdepth(float _bitdepth);
+  fun float srate();
+  #!- Sampling rate.
+  fun float srate(float _srate);
+}
+#!- Bandlimited sawtooth oscillator
+#!- This is a bandlimited sawtooth oscillator ported from the `sawtooth` function from the Faust
+#!- programming language.
+class Blsaw extends UGen {
+  fun float freq();
+  #!- Frequency, (range 0-20000)
+  fun float freq(float _freq);
+  fun float amp();
+  #!- Amplitude (range 0-1).
+  fun float amp(float _amp);
+}
+#!- Bandlimited square oscillator
+#!- This is a bandlimited square oscillator ported from the `squaretooth` function from the Faust
+#!- programming language.
+class Blsquare extends UGen {
+  fun float freq();
+  #!- Frequency, (range 0-20000)
+  fun float freq(float _freq);
+  fun float amp();
+  #!- Amplitude (range 0-1).
+  fun float amp(float _amp);
+  fun float width();
+  #!- Duty cycle width (range 0-1).
+  fun float width(float _width);
+}
+#!- Bandlimited triangle oscillator
+#!- This is a bandlimited triangle oscillator ported from the `triangletooth` function from the Faust
+#!- programming language.
+class Bltriangle extends UGen {
+  fun float freq();
+  #!- Frequency, (range 0-20000)
+  fun float freq(float _freq);
+  fun float amp();
+  #!- Amplitude (range 0-1).
+  fun float amp(float _amp);
+}
+#!- Brownian noise generator.
+class Brown extends UGen {
+}
+#!- Bandpass Butterworth filter
+class Butbp extends UGen {
+  fun float freq();
+  #!- Center Frequency. (in Hertz)
+  fun float freq(float _freq);
+  fun float bw();
+  #!- Bandwidth. (in Hertz)
+  fun float bw(float _bw);
+}
+#!- Band-reject Butterworth filter
+class Butbr extends UGen {
+  fun float freq();
+  #!- Center Frequency. (in Hertz)
+  fun float freq(float _freq);
+  fun float bw();
+  #!- Bandwidth. (in Hertz)
+  fun float bw(float _bw);
+}
+#!- Highpass Butterworth filter
+class Buthp extends UGen {
+  fun float freq();
+  #!- Cutoff Frequency.
+  fun float freq(float _freq);
+}
+#!- Lowpass Butterworth filter
+class Butlp extends UGen {
+  fun float freq();
+  #!- Cutoff Frequency.
+  fun float freq(float _freq);
+}
+#!- Applies clip-limiting to a signal
+class Clip extends UGen {
+  fun float lim();
+  #!- threshold / limiting value.
+  fun float lim(float _lim);
+}
+#!- Resettable clock with subdivisions
+class Clock extends UGen {
+  fun float bpm();
+  #!- Clock tempo, in beats per minute.
+  fun float bpm(float _bpm);
+  fun float subdiv();
+  #!- Clock subdivision. 2 = eighths, 4 = 16ths, etc.
+  fun float subdiv(float _subdiv);
+}
+#!- Comb filter
+class Comb extends UGen {
+  #!- The loop time of the filter, in seconds. This can also be thought of as the delay time.
+  fun void init(float _looptime);
+  fun float revtime();
+  #!- Reverberation time, in seconds (RT-60).
+  fun float revtime(float _revtime);
+}
+#!- Compressor
+class Compressor extends UGen {
+  fun float ratio();
+  #!- Ratio to compress with, a value > 1 will compress
+  fun float ratio(float _ratio);
+  fun float thresh();
+  #!- Threshold (in dB) 0 = max
+  fun float thresh(float _thresh);
+  fun float atk();
+  #!- Compressor attack
+  fun float atk(float _atk);
+  fun float rel();
+  #!- Compressor release
+  fun float rel(float _rel);
+}
+#!- Partioned convolution. 
+#!- This module will perform partitioned convolution on an input signal using
+#!- an ftable as an impulse response.
+class Conv extends UGen {
+  #!- Ftable used as the impulse response. 
+  #!- Partition length (in samples). 
+  #!- Must be a power of 2. Lower values will add less latency, at the cost 
+  #!- of requiring more CPU power. 
+  fun void init(ftbl _ftfloat _iPartLen);
+}
+#!- Trigger-based fixed counter
+#!- 
+#!-     The signal output will count from 0 to [N-1], and then
+#!- repeat itself. Count will start when it has been triggered, otherwise it will be -1.
+class Count extends UGen {
+  fun float count();
+  #!- Number to count up to (count - 1). Decimal points will be truncated.
+  fun float count(float _count);
+  fun float mode();
+  #!- Counting mode. 0 = wrap-around, 1 = count up to N -1, then stop and spit out -1
+  fun float mode(float _mode);
+}
+#!- Crossfade two signals. 
+#!- This module will perform a linear crossfade between two input signals.
+class Crossfade extends UGen {
+  fun float pos();
+  #!- Crossfade position. 0 = all signal 1, 1 = all signal 2
+  fun float pos(float _pos);
+}
+#!- A simple DC block filter
+class Dcblock extends UGen {
+}
+#!- Adds a delay to an incoming signal with optional feedback.
+class Delay extends UGen {
+  #!- Delay time, in seconds.
+  fun void init(float _time);
+  fun float feedback();
+  #!- Feedback amount. Should be a value between 0-1.
+  fun float feedback(float _feedback);
+}
+#!- Diode-ladder virtual analogue low-pass filter
+#!- This is a diode-ladder filter designed by Will Pirkle. 
+#!- More information can be found in this paper here: 
+#!- http://www.willpirkle.com/Downloads/AN-6DiodeLadderFilter.pdf
+class Diode extends UGen {
+  fun float freq();
+  #!- 
+  fun float freq(float _freq);
+  fun float res();
+  #!- 
+  fun float res(float _res);
+}
+#!- Read from an audio file
+#!- 
+#!-     Expects a 1-channel file matching the project samplerate. Diskin should be able to read any file format that libsndfile supports.
+class Diskin extends UGen {
+  #!- Filename of the audio file.
+  fun void init(string _filename);
+}
+#!- Distortion using a modified hyperbolic tangent function
+class Dist extends UGen {
+  fun float pregain();
+  #!- Gain applied before waveshaping.
+  fun float pregain(float _pregain);
+  fun float postgain();
+  #!- Gain applied after waveshaping
+  fun float postgain(float _postgain);
+  fun float shape1();
+  #!- Shape of the positive part of the signal. A value of 0 gets a flat clip.
+  fun float shape1(float _shape1);
+  fun float shape2();
+  #!- Like shape1, only for the negative part of the signal.
+  fun float shape2(float _shape2);
+}
+#!- Delta Metro
+#!- 
+#!-     Produce a set of triggers spaced apart by time.
+class Dmetro extends UGen {
+  fun float time();
+  #!- Time between triggers (in seconds). This will update at the start of each trigger.
+  fun float time(float _time);
+}
+#!- Water drop physical model
+#!- 
+#!-     Physical model of the sound of dripping water. When triggered, it will produce a droplet of water.
+class Drip extends UGen {
+  #!- Period of time over which all sound is stopped.
+  fun void init(float _dettack);
+  fun float num_tubes();
+  #!- Number of units.
+  fun float num_tubes(float _num_tubes);
+  fun float amp();
+  #!- Amplitude.
+  fun float amp(float _amp);
+  fun float damp();
+  #!- The damping factor. Maximum value is 2.0.
+  fun float damp(float _damp);
+  fun float shake_max();
+  #!- The amount of energy to add back into the system.
+  fun float shake_max(float _shake_max);
+  fun float freq();
+  #!- Main resonant frequency.
+  fun float freq(float _freq);
+  fun float freq1();
+  #!- The first resonant frequency.
+  fun float freq1(float _freq1);
+  fun float freq2();
+  #!- The second resonant frequency.
+  fun float freq2(float _freq2);
+}
+#!-  Delta trigger
+#!- 
+#!-     This is able to create spaced out triggers. It is set off by a single trigger.
+class Dtrig extends UGen {
+  #!- An ftable containing times in seconds.
+  fun void init(ftbl _ft);
+  fun int loop();
+  #!- When set to 1, dtrig will wrap around and loop again.
+  fun int loop(int _loop);
+  fun float delay();
+  #!- This sets a delay (in seconds) on the triggered output when it is initially triggered. This is useful for rhythmic sequences with rests in the beginnings.
+  fun float delay(float _delay);
+  fun float scale();
+  #!- Scales the timing signal. A scale of 1 is normal, a scale of 2 will double the duration, and a scale of 0.5 will halve it.
+  fun float scale(float _scale);
+}
+#!- A series of random impulses
+class Dust extends UGen {
+  fun float amp();
+  #!- 
+  fun float amp(float _amp);
+  fun float density();
+  #!- 
+  fun float density(float _density);
+  fun int bipolar();
+  #!- Bipolar flag. A non-zero makes the signal bipolar as opposed to unipolar. 
+  fun int bipolar(int _bipolar);
+}
+#!- 2nd order tunable equalization filter
+#!- 
+#!-     This provides a peak/notch filter for building parametric/graphic equalizers. With gain above 1, there will be a peak at the center frequency with a width dependent on bw. If gain is less than 1, a notch is formed around the center frequency (freq).
+#!-     
+class Eqfil extends UGen {
+  fun float freq();
+  #!- The center frequency of the filter
+  fun float freq(float _freq);
+  fun float bw();
+  #!- The peak/notch bandwidth in Hertz
+  fun float bw(float _bw);
+  fun float gain();
+  #!- The peak/notch gain
+  fun float gain(float _gain);
+}
+#!- Produce a line segment with exponential slope
+#!- This will generate a line from value A to value B in given amount of time. 
+#!- When it reaches it's target, it will stay at that value. 
+class Expon extends UGen {
+  fun float a();
+  #!- Inital point.
+  fun float a(float _a);
+  fun float dur();
+  #!- Duration (in seconds)
+  fun float dur(float _dur);
+  fun float b();
+  #!- End point
+  fun float b(float _b);
+}
+#!- Produces sinusoid bursts for granular and formant synthesis
+#!- 
+class Fof extends UGen {
+  #!- ftable for sine wave.
+  #!- Ftable for envelope function (use either gen_line or gen_sinecomp)
+  #!- Maximum number of foflet overlaps.
+  #!- Phase
+  fun void init(ftbl _sineftbl _winint _iolapsfloat _iphs);
+  fun float amp();
+  #!- Overall amplitude
+  fun float amp(float _amp);
+  fun float fund();
+  #!- Fundamental frequency
+  fun float fund(float _fund);
+  fun float form();
+  #!- Formant frequency.
+  fun float form(float _form);
+  fun float oct();
+  #!- Octaviation index, if greater than zero, lowers the effective fund frequency by attenuating odd-numbered sine bursts. whole numbers are full octaves. fractions transpositional.
+  fun float oct(float _oct);
+  fun float band();
+  #!- Bandwidth (in -6db) expressed in Hz. The bandwidth determines the rate of exponential decay throughout the sineburst, before the enveloping is applied.
+  fun float band(float _band);
+  fun float ris();
+  #!- Rise of sinusoid burst (in seconds)
+  fun float ris(float _ris);
+  fun float dec();
+  #!- Decay of the sinusoid burst (in seconds).
+  fun float dec(float _dec);
+  fun float dur();
+  #!- OVerall duration of sinusoid burst (in seconds).
+  fun float dur(float _dur);
+}
+#!- Formant filter
+#!-     When fed with a pulse train, it will generate a series of overlapping grains. Overlapping will occur when 1/freq < dec, but there is no upper limit on the number of overlaps. (cited from www.csounds.com/manual/html/fofilter.html)
+class Fofilt extends UGen {
+  fun float freq();
+  #!- Center frequency.
+  fun float freq(float _freq);
+  fun float atk();
+  #!- Impulse response attack time (in seconds).
+  fun float atk(float _atk);
+  fun float dec();
+  #!- Impulse reponse decay time (in seconds)
+  fun float dec(float _dec);
+}
+#!- Sucession of grains from data in a stored function table
+class Fog extends UGen {
+  #!- ftable for sample.
+  #!- Ftable for envelope function (use either gen_line or gen_sinecomp)
+  #!- Maximum number of foglet overlaps.
+  #!- Phase
+  fun void init(ftbl _wavftbl _winint _iolapsfloat _iphs);
+  fun float amp();
+  #!- Overall amplitude
+  fun float amp(float _amp);
+  fun float dens();
+  #!- Density. The frequency of grains/second.
+  fun float dens(float _dens);
+  fun float trans();
+  #!- Transposition, in terms of playback speed
+  fun float trans(float _trans);
+  fun float spd();
+  #!- Starting sample index, normalized 0-1.
+  fun float spd(float _spd);
+  fun float oct();
+  #!- Octaviation index, if greater than zero, lowers the effective fund frequency by attenuating odd-numbered sine bursts. whole numbers are full octaves. fractions transpositional.
+  fun float oct(float _oct);
+  fun float band();
+  #!- Bandwidth (in -6db) expressed in Hz. The bandwidth determines the rate of exponential decay throughout the sineburst, before the enveloping is applied.
+  fun float band(float _band);
+  fun float ris();
+  #!- Rise of sinusoid burst (in seconds)
+  fun float ris(float _ris);
+  fun float dec();
+  #!- Decay of the sinusoid burst (in seconds).
+  fun float dec(float _dec);
+  fun float dur();
+  #!- OVerall duration of sinusoid burst (in seconds).
+  fun float dur(float _dur);
+}
+#!- Adds artificial foldover to an audio signal
+#!- 
+#!-     Primarily created for use with Decimator.
+class Fold extends UGen {
+  fun float incr();
+  #!- Increment
+  fun float incr(float _incr);
+}
+#!- A short title describing the module
+#!- 
+#!-     This is a description of the entire module.  This is not a real module. This description should be a comprehensive sumary of what this function does.
+#!- 
+#!- Inside the Lua table, this is expressed as a multiline string, however it does not adhere to the tradtional 80 column rule found in programming.
+#!- 
+#!- Write as much text as needed here...
+#!- FM oscilator pair with linear interpolation
+class Fosc extends UGen {
+  #!- Wavetable to read from. Note: the size of this table must be a power of 2.
+  fun void init(ftbl _tbl);
+  fun float freq();
+  #!- Frequency (in Hz)
+  fun float freq(float _freq);
+  fun float amp();
+  #!- Amplitude (typically a value between 0 and 1).
+  fun float amp(float _amp);
+  fun float car();
+  #!- Carrier frequency, expressed as a ratio number in C:M ratio. Typically an integer.
+  fun float car(float _car);
+  fun float mod();
+  #!- Modulator frequency, expressed as a ratio number in C:M ratio. Typically an integer.
+  fun float mod(float _mod);
+  fun float indx();
+  #!- Modulation index. Most commercial synthesizers have a range from 0-8, but there's nothing stopping you from going beyond that.
+  fun float indx(float _indx);
+}
+#!- Series of partials from the harmonic series
+#!- 
+#!-     GBuzz comes from the `buzz` family of Csound opcodes, and is capable of producing a rich spectrum of harmonic content, useful for subtractive synthesis implementation.
+class Gbuzz extends UGen {
+  #!- Soundpipe function table used internally. This should be a sine wave.
+  #!- Phase to start on (in the range 0-1)
+  fun void init(ftbl _ftfloat _iphs);
+  fun float freq();
+  #!- Frequency, in Hertz.
+  fun float freq(float _freq);
+  fun float amp();
+  #!- Amplitude (Typically a value between 0 and 1).
+  fun float amp(float _amp);
+  fun float nharm();
+  #!- Number of harmonics.
+  fun float nharm(float _nharm);
+  fun float lharm();
+  #!- Lowest harmonic present. This should be a whole number integer.
+  fun float lharm(float _lharm);
+  fun float mul();
+  #!- Multiplier. This determines the relative strength of each harmonic.
+  fun float mul(float _mul);
+}
+#!- Generate a composite waveform of sinusoids
+#!- Reads from a wav file
+#!- 
+#!-     This will only load as many samples as the length of the ftable.
+#!- Gaussian distribution
+#!- A series of line segments
+#!- An implementation of the Padsynth Algorithm by Paul Nasca. 
+#!- 
+#!- This is a basic implemenation of the padsynth algorithm. More information can be found here:
+#!- 
+#!- http://zynaddsubfx.sourceforge.net/doc/PADsynth/PADsynth.htm
+#!- 
+#!- This gen routine requires libfftw, and is not compiled by default. See config.mk for more info.
+#!-     
+#!-     
+#!- Generates a user defined random number distribution.
+#!- Scrambles phase of ftable.
+#!- This gen routine will copy the ftable, apply an FFT, apply
+#!- a random phase, and then do an inverse FFT. This effect 
+#!- is ideal for creating pad-like sounds. 
+#!- generates a sampled sinusoid
+#!- Waveform as a sum of harmonically related sine waves 
+#!- generates a sampled triangle wave
+#!- A series of exponential segments
+#!- Hilbert transform
+#!- 
+class Hilbert extends UGen {
+}
+#!- Reads from standard input.
+#!- 
+#!-     Expects type of SPFLOAT, which by default is a float. If the input data is larger than the number of samples, you will get a complaint about a broken pipe (but it will still work). If there is no input data from STDIN, it will hang.
+#!- 
+#!- 
+#!- 
+#!- 
+#!- The expected use case of sp_in is to utilize pipes from the commandline, like so:
+#!- 
+#!- 
+#!- 
+#!- 
+#!- cat /dev/urandom | ./my_program
+#!- 
+#!- 
+#!- 
+#!- 
+#!- Assuming my_program is using sp_in, this will write /dev/urandom (essentially white noise) to an audio file.
+class In extends UGen {
+}
+#!- Trigger-based Incrementor
+#!- When triggered, this module will increment and decrement a value bounded between a min
+#!- and max. Initially, this was designed for the specific use case of interfacing with the
+#!- griffin knob. 
+class Incr extends UGen {
+  #!- Initial value
+  fun void init(float _val);
+  fun float step();
+  #!- Step value to increment by.
+  fun float step(float _step);
+  fun float min();
+  #!- Minimum value
+  fun float min(float _min);
+  fun float max();
+  #!- Maximum value
+  fun float max(float _max);
+}
+#!- John Chowning reverberator
+#!- 
+#!-     This is was built using the JC reverb implentation found in FAUST. According to the source code, the specifications for
+#!- this implementation were found on an old SAIL DART backup tape.
+#!- 
+#!-   This class is derived from the CLM JCRev function, which is based on the use of
+#!-   networks of simple allpass and comb delay filters.  This class implements three series
+#!-   allpass units, followed by four parallel comb filters, and two decorrelation delay lines in
+#!-   parallel at the output.
+class Jcrev extends UGen {
+}
+#!- A signal with random fluctuations
+#!- 
+#!-      This is useful for emulating jitter found in analogue equipment. 
+class Jitter extends UGen {
+  fun float amp();
+  #!- The amplitude of the line. Will produce values in the range of (+/-)amp.
+  fun float amp(float _amp);
+  fun float cpsMin();
+  #!- The minimum frequency of change in Hz.
+  fun float cpsMin(float _cpsMin);
+  fun float cpsMax();
+  #!- The maximum frequency of change in Hz.
+  fun float cpsMax(float _cpsMax);
+}
+#!- Produce a line segment with linear slope
+#!- This will generate a line from value A to value B in given amount of time. 
+#!- When it reaches it's target, it will stay at that value. 
+class Line extends UGen {
+  fun float a();
+  #!- Inital point.
+  fun float a(float _a);
+  fun float dur();
+  #!- Duration (in seconds)
+  fun float dur(float _dur);
+  fun float b();
+  #!- End point
+  fun float b(float _b);
+}
+#!- A linear predictive coding filter.
+#!- This module is a wrapper for the open source library openlpc, which implements
+#!- the LPC10 audio codec optimized for speech signals. This module takes in an
+#!- input signal, downsamples it, and produces a decoded LPC10 audio signal, which
+#!- has a similar sound to that of a speak and spell. In this context, the LPC
+#!- signal is meant to be more of a audio effect rather than a utility for
+#!- communication. 
+#!- 
+#!- Because the LPC10 encoder
+#!- relies on frames for encoding, the output signal has a few milliseconds of
+#!- delay. The delay can be calculated in seconds as (framesize * 4) / samplerate.
+#!- 
+#!- In addition to using the LPC as a decoder/encoder, this module can also be 
+#!- set to synth mode. Instead of reading from an input signal, the LPC can
+#!- instead read from parameters set directly in a scaled ftable. 
+#!- 
+class Lpc extends UGen {
+  #!- Sets the frame size for the encoder.
+  fun void init(int _framesize);
+}
+#!- 3-pole (18 db/oct slope) Low-Pass filter with resonance and tanh distortion
+class Lpf18 extends UGen {
+  fun float cutoff();
+  #!- Filter cutoff frequency, in Hertz
+  fun float cutoff(float _cutoff);
+  fun float res();
+  #!- Resonance. Expects a value in the range 0-1. A value of 1.0 will self oscillate at the cutoff frequency.
+  fun float res(float _res);
+  fun float dist();
+  #!- Distortion amount.
+  fun float dist(float _dist);
+}
+#!- A randomly open or closed `maybe gate`
+#!- 
+#!-     It takes in a trigger, and then it will randomly decide to turn the gate on or not. One particular application for maygate is to arbitrarily turn on/off sends to effects. One specific example of this could be a randomized reverb throw on a snare.
+class Maygate extends UGen {
+  fun float prob();
+  #!- Probability of maygate. This is a value between 0-1. The closer to 1, the more likely the maygate will let a signal through.
+  fun float prob(float _prob);
+  fun int mode();
+  #!- If mode is nonzero, maygate will output one sample triggers instead of a gate signal.
+  fun int mode(int _mode);
+}
+#!- Metronome
+#!- 
+#!-     Metro produces a series of 1-sample ticks at a regular rate. Typically, this is used alongside trigger-driven modules.
+class Metro extends UGen {
+  fun float freq();
+  #!- The frequency to repeat.
+  fun float freq(float _freq);
+}
+#!- Phase-locked vocoder.
+#!- 
+#!-     Mincer is a phase-locked vocoder. It has the ability to play back an audio 
+#!- file loaded into an ftable like a sampler would. Unlike a typical sampler, mincer allows
+#!- time and pitch to be controlled separately. 
+class Mincer extends UGen {
+  #!- ftable containing an audio file.
+  #!- FFT window size. Should be a power of 2.
+  fun void init(ftbl _ftint _winsize);
+  fun float time();
+  #!- Position in time. When non-changing it will do a spectral freeze of a the current point in time.
+  fun float time(float _time);
+  fun float amp();
+  #!- Amplitude.
+  fun float amp(float _amp);
+  fun float pitch();
+  #!- Pitch ratio. A value of. 1  normal, 2 is double speed, 0.5 is halfspeed, etc.
+  fun float pitch(float _pitch);
+}
+#!- Resonance filter used for modal synthesis
+#!- 
+#!-     Plucked and bell sounds can be created by passing an impulse through a combination of modal filters. 
+class Mode extends UGen {
+  fun float freq();
+  #!- Resonant frequency of the filter.
+  fun float freq(float _freq);
+  fun float q();
+  #!- Quality factor of the filter. Roughly equal to q/freq.
+  fun float q(float _q);
+}
+#!- Low pass resonant filter based on the Moogladder filter
+class Moogladder extends UGen {
+  fun float freq();
+  #!- Filter cutoff frequency.
+  fun float freq(float _freq);
+  fun float res();
+  #!- Filter resonance
+  fun float res(float _res);
+}
+#!- White noise generator
+class Noise extends UGen {
+  fun float amp();
+  #!- Amplitude. (Value between 0-1).
+  fun float amp(float _amp);
+}
+#!- Nanosamp: a tiny sampler built for Soundpipe
+#!- 
+#!-     A nanosamp file is comprised of a mono audio file and an ini file. Nanosamp is geared towards percussive and found sound sample players, and is intended to be combined with soundpipe modules.
+#!- 
+#!- The ini file contains mappings that correspond to the audio file. Such an entry would look like this:
+#!- 
+#!- 
+#!- 
+#!- [keyword]
+#!- 
+#!- pos = 2.3
+#!- 
+#!- size = 3
+#!- 
+#!- 
+#!- </pre>
+#!- In this instance, an entry called `keyword` has been made, starting at 2.3 seconds in the
+#!- audio file, with a length of 3 seconds. An example file oneart.ini has been created in the
+#!- examples folder.
+#!- 
+#!- The SoundPipe implementation of nanosamp will automatically index the entries
+#!- in the order they appear in the INI file and must be selected this way by changing the index
+#!- parameter. Soundpipe will only select the new entry when the trigger input is a non-zero value.
+#!- 
+class Nsmp extends UGen {
+  #!- ftbl of the audio file. It should be mono.
+  #!- samplerate.
+  #!- ini file.
+  fun void init(ftbl _ftint _srstring _init);
+  fun int index();
+  #!- This is an optional parameter. These values are always set to a value by default, and can be set after the init function has been called.
+  fun int index(int _index);
+}
+#!-  Table-lookup oscilator with linear interpolation
+class Osc extends UGen {
+  #!- Wavetable to read from. Note: the size of this table must be a power of 2.
+  #!- Initial phase of waveform, expects a value 0-1
+  fun void init(ftbl _tblfloat _phase);
+  fun float freq();
+  #!- Frequency (in Hz)
+  fun float freq(float _freq);
+  fun float amp();
+  #!- Amplitude (typically a value between 0 and 1).
+  fun float amp(float _amp);
+}
+#!- Wavetable morphing oscillator
+#!- 
+#!- This is an oscillator with linear interpolation that is capable of morphing 
+#!- between an arbitrary number of wavetables. 
+class Oscmorph extends UGen {
+  #!- An array of ftables to read from. Note: the size of these tables must be a power of 2 (and the same size as well).
+  #!- Number of ftbls
+  #!- Initial phase of waveform, expects a value 0-1
+  fun void init(ftbl[] _tblint _nftfloat _phase);
+  fun float freq();
+  #!- Frequency (in Hz)
+  fun float freq(float _freq);
+  fun float amp();
+  #!- Amplitude (typically a value between 0 and 1).
+  fun float amp(float _amp);
+  fun float wtpos();
+  #!- Wavetable position. (scaled 0-1)
+  fun float wtpos(float _wtpos);
+}
+#!- Panner
+class Pan2 extends UGen {
+  fun int type();
+  #!- Panning type. 0 = equal power, 1 = square root, 2 = linear,
+  #!- 3 = alternative equal power. Values outside this range will wrap. 
+  fun int type(int _type);
+  fun float pan();
+  #!- Panning. A value of -1 is hard left, and a value of 1 is hard right, and 0 is center.
+  fun float pan(float _pan);
+}
+#!- Stereo Panner
+class Panst extends UGen {
+  fun int type();
+  #!- Panning type. 0 = equal power, 1 = square root, 2 = linear,
+  #!- 3 = alternative equal power. Values outside this range will wrap. 
+  fun int type(int _type);
+  fun float pan();
+  #!- Panning. A value of -1 is hard left, and a value of 1 is hard right.
+  fun float pan(float _pan);
+}
+#!- Parametric Equalizer
+#!- This is an implementation of Zoelzer's parametric equalizer filter.
+class Pareq extends UGen {
+  fun float fc();
+  #!- Center frequency in peak mode, corner frequency in shelving mode.
+  fun float fc(float _fc);
+  fun float v();
+  #!- Amount at which the center frequency value shall be increased or decreased. A value of 1 is a flat response.
+  fun float v(float _v);
+  fun float q();
+  #!- Q of the filter. sqrt(0.5) is no resonance.
+  fun float q(float _q);
+  fun float mode();
+  #!- EQ mode. 0 = peak, 1 = low shelving, 2 = high shelving
+  fun float mode(float _mode);
+}
+#!- An extreme time-stretching algorithm by Paul Nasca Octavian
+#!- This is an implementation of the popular paulstretch algorithm used for time
+#!- stretching an audio signal to create ambient textures. Ideally, this algorithm 
+#!- is best used for stretching signals by very very long amounts. 
+#!- 
+#!- This version of paulstretch will take an ftable and loop through it, make
+#!- it an ideal means for creating sustained pads. 
+class Paulstretch extends UGen {
+  #!- ftable containing audio data
+  #!- Window size, in seconds.
+  #!- Stretch factor, 1.0 is no stretch.
+  fun void init(ftbl _ftfloat _windowsizefloat _stretch);
+}
+#!- Casio-style phase distortion with `pivot point` on the X axis
+#!- This module is designed to emulate the classic phase distortion synthesis technique.
+#!- From the mid 90's. The technique reads the first and second halves of the ftbl
+#!- at different rates in order to warp the waveform. For example, pdhalf can 
+#!- smoothly transition a sinewave into something approximating a sawtooth wave.
+class Pdhalf extends UGen {
+  fun float amount();
+  #!- Amount of distortion, within the range [-1, 1]. 0 is no distortion.
+  fun float amount(float _amount);
+}
+#!- Peak limiter 
+#!- This is a simple peak limiting algorithm, based off code from the Stanford
+#!- Music-424 class.
+class Peaklim extends UGen {
+  fun float atk();
+  #!- Attack time, in seconds
+  fun float atk(float _atk);
+  fun float rel();
+  #!- Release time, in seconds
+  fun float rel(float _rel);
+  fun float thresh();
+  #!- Threshold, in dB
+  fun float thresh(float _thresh);
+}
+#!- A stereo phaser
+#!- 
+#!- 	This is a stereo phaser, generated from Faust code taken from the 
+#!- Guitarix project.
+class Phaser extends UGen {
+  fun float MaxNotch1Freq();
+  #!- Between 20 and 10000
+  fun float MaxNotch1Freq(float _MaxNotch1Freq);
+  fun float MinNotch1Freq();
+  #!- Between 20 and 5000
+  fun float MinNotch1Freq(float _MinNotch1Freq);
+  fun float Notch_width();
+  #!- Between 10 and 5000
+  fun float Notch_width(float _Notch_width);
+  fun float NotchFreq();
+  #!- Between 1.1 and 4
+  fun float NotchFreq(float _NotchFreq);
+  fun float VibratoMode();
+  #!- 1 or 0
+  fun float VibratoMode(float _VibratoMode);
+  fun float depth();
+  #!- Between 0 and 1
+  fun float depth(float _depth);
+  fun float feedback_gain();
+  #!- Between 0 and 1
+  fun float feedback_gain(float _feedback_gain);
+  fun float invert();
+  #!- 1 or 0
+  fun float invert(float _invert);
+  fun float level();
+  #!- -60 to 10 dB
+  fun float level(float _level);
+  fun float lfobpm();
+  #!- Between 24 and 360
+  fun float lfobpm(float _lfobpm);
+}
+#!- Normalized sawtooth wave from 0 to 1
+#!- 
+#!-     Phasors are often used when building table-lookup oscillators.
+class Phasor extends UGen {
+  #!- initial phase
+  fun void init(float _iphs);
+  fun float freq();
+  #!- Frequency.
+  fun float freq(float _freq);
+}
+#!- Pink pinknoise generator
+class Pinknoise extends UGen {
+  fun float amp();
+  #!- Amplitude. (Value between 0-1).
+  fun float amp(float _amp);
+}
+#!- Pitch detection using AMDF method.
+#!- Pitchamdf tracks the pitch of signal using the AMDF (Average Magnitude Difference Function) method of 
+#!- Pitch following. 
+class Pitchamdf extends UGen {
+  #!- Minimum expected frequency to detect
+  #!- Maximum expected frequency to detect
+  fun void init(float _minfloat _max);
+}
+#!- Karplus-Strong plucked string instrument.
+class Pluck extends UGen {
+  #!- Sets the initial frequency. This frequency is used to allocate all the buffers needed for the delay. This should be the lowest frequency you plan on using.
+  fun void init(float _ifreq);
+  fun float freq();
+  #!- Variable frequency. Values less than the initial 
+  #!- frequency (ifreq) will be doubled until it is greater than or equal to ifreq.
+  fun float freq(float _freq);
+  fun float amp();
+  #!- Amplitude
+  fun float amp(float _amp);
+}
+#!-  Portamento-style control signal smoothing
+#!- 
+#!-     Useful for smoothing out low-resolution signals and applying glissando to filters.
+class Port extends UGen {
+  #!- 
+  fun void init(float _htime);
+  fun float htime();
+  #!- 
+  fun float htime(float _htime);
+}
+#!-  High-precision table-lookup posc3ilator with cubic interpolation
+class Posc3 extends UGen {
+  #!- Wavetable to read from. Note: the size of this table must be a power of 2.
+  fun void init(ftbl _tbl);
+  fun float freq();
+  #!- Frequency (in Hz)
+  fun float freq(float _freq);
+  fun float amp();
+  #!- Amplitude (typically a value between 0 and 1).
+  fun float amp(float _amp);
+}
+#!- A simple progress bar for the commandline
+#!- 
+#!-     Mostly ideal for offline renderings and programs with finite length. Escape characters are used to show/hide the cursor. Interruption before finishing may cause the cursor to disappear.
+class Progress extends UGen {
+  fun int nbars();
+  #!- 
+  fun int nbars(int _nbars);
+  fun int skip();
+  #!- How many samples to skip before checking
+  fun int skip(int _skip);
+}
+#!- Simple rhythmic notation gate generator
+#!- 
+#!-     Creates a gate using a simple rhythmic notation system called prop. When it reaches the end of the prop string, it will loop back to the beginning.
+#!- 
+#!- Prop has a few basic rules:
+#!- 
+#!- 1. A '+' denotes a on. A '-' denotes an off (rest). They each have an equal duration of a quarter note.
+#!- 
+#!- 2. On and off values can be strung together to create equally spaced gates: +-+--
+#!- 
+#!- 3. When notes are enclosed in parantheses '()' following a positive integer N, their duration is reduced N times: ++2(+-)
+#!- 
+#!- 4. When notes are enclosed in brackets '[]' following a positive integer N, their duration is scaled by a factor of N: ++2[++]
+#!- 
+#!- 5. Parenthesis and brackets can be nested: +- 2[3(+2(++)+)]2(++)
+#!- 
+class Prop extends UGen {
+  #!- Prop string to be parsed.
+  fun void init(string _str);
+  fun float bpm();
+  #!- Beats per minute of the prop string.
+  fun float bpm(float _bpm);
+}
+#!- Time-domain pitch shifter.
+class Pshift extends UGen {
+  fun float shift();
+  #!- Pitch shift (in semitones), range -24/24.
+  fun float shift(float _shift);
+  fun float window();
+  #!- Window size (in samples), max 10000
+  fun float window(float _window);
+  fun float xfade();
+  #!- Crossfade (in samples), max 10000
+  fun float xfade(float _xfade);
+}
+#!- Track pitch of a signal.
+#!- Ptrack is a pitch tracker, based on an algorithm originally created by
+#!- Miller Puckette.
+class Ptrack extends UGen {
+  #!- hop size.
+  #!- Number of peaks.
+  fun void init(int _ihopsizeint _ipeaks);
+}
+#!- Random number generator with hold time.
+#!- Randh is loosely based off of the Csound opcode randomh. The design is equivalent
+#!- to scaled noise sent through a classic sample and hold module.
+class Randh extends UGen {
+  fun float min();
+  #!- Minimum value to use.
+  fun float min(float _min);
+  fun float max();
+  #!- Maximum value to use.
+  fun float max(float _max);
+  fun float freq();
+  #!- Frequency of randomization (in Hz)
+  fun float freq(float _freq);
+}
+#!- Line segments between random values within a range
+class Randi extends UGen {
+  fun float min();
+  #!- Minimum value
+  fun float min(float _min);
+  fun float max();
+  #!- Maximum value
+  fun float max(float _max);
+  fun float cps();
+  #!- Frequency to change values.
+  fun float cps(float _cps);
+  fun float mode();
+  #!- Randi mode (not yet implemented yet.)
+  fun float mode(float _mode);
+}
+#!- Random values within a range
+class Random extends UGen {
+  fun float min();
+  #!- Minimum value.
+  fun float min(float _min);
+  fun float max();
+  #!- Maximum value.
+  fun float max(float _max);
+}
+#!- A second-order resonant filter. NOTE: The output for reson appears to be very hot, so take caution when using this module.
+class Reson extends UGen {
+  fun float freq();
+  #!- Center frequency of the filter, or frequency position of the peak response.
+  fun float freq(float _freq);
+  fun float bw();
+  #!- Bandwidth of the filter.
+  fun float bw(float _bw);
+}
+#!- Signal reverser
+#!- 
+#!- 	Reverse will store a signal inside a buffer and play it back reversed.
+class Reverse extends UGen {
+  #!- Delay time in seconds.
+  fun void init(float _delay);
+}
+#!-  8 FDN stereo reverb
+class Revsc extends UGen {
+  fun float feedback();
+  #!- Value between 0-1 that sets feedback value. The larger the value, the longer the decay.
+  fun float feedback(float _feedback);
+  fun float lpfreq();
+  #!- low pass cutoff frequency.
+  fun float lpfreq(float _lpfreq);
+}
+#!- RMS-averaged signal amplitude
+#!- 
+#!-     Perform `root-mean-square` on a signal to get overall amplitude of a signal. The output signal looks similar to that of a classic VU meter.
+class Rms extends UGen {
+  fun float ihp();
+  #!- Half-power point (in Hz) of internal lowpass filter. This parameter is fixed at 10Hz and is not yet mutable.
+  fun float ihp(float _ihp);
+}
+#!- Trigger based beat-repeat stuttering effect
+#!- 
+#!-     When the input is a non-zero value, rpt will load up the buffer and loop a certain number of times. Speed and repeat amounts can be set with the sp_rpt_set function.
+class Rpt extends UGen {
+  #!- Maximum delay duration in seconds. This will set the buffer size.
+  fun void init(float _maxdur);
+}
+#!- Random spline curve generator
+#!- This is a function that generates random spline curves. This signal generator
+#!- is ideal for control signals. Curves are quite smooth when cps_min is not
+#!- too different from cps_max. When the range of these two is big, 
+#!- some discontinuity may occur. Due to the interpolation, the output 
+#!- may be greater than the range values. 
+class Rspline extends UGen {
+  fun float min();
+  #!- Minimum range.
+  fun float min(float _min);
+  fun float max();
+  #!- Maximum range
+  fun float max(float _max);
+  fun float cps_min();
+  #!- 
+  fun float cps_min(float _cps_min);
+  fun float cps_max();
+  #!- 
+  fun float cps_max(float _cps_max);
+}
+#!- Classic sample and hold
+class Samphold extends UGen {
+}
+#!- Soft clip saturating distortion, based on examples from Abel/Berners' Music 424 course at Stanford.
+class Saturator extends UGen {
+  fun float drive();
+  #!- Input gain into the distortion section, in decibels. Controls overall amount of distortion.
+  fun float drive(float _drive);
+  fun float dcoffset();
+  #!- Constant linear offset applied to the signal. A small offset will introduce odd harmonics into the distoration spectrum, whereas a zero offset will have only even harmonics.
+  fun float dcoffset(float _dcoffset);
+}
+#!- Bipolar Scale
+#!- 
+#!-     This module scales from unipolar [0, 1] to another range defined by min and max.
+class Scale extends UGen {
+  fun float min();
+  #!- Minimum value to scale to.
+  fun float min(float _min);
+  fun float max();
+  #!- Maximum value to scale to.
+  fun float max(float _max);
+}
+#!- Delays a signal by a number of samples.
+class Sdelay extends UGen {
+  #!- Size of delay (in samples)
+  fun void init(float _size);
+}
+#!- Yet another slice-based sample player.
+#!- This module takes in an audio buffer and a table with slice points. 
+class Slice extends UGen {
+  #!- A table containing slice points, in samples
+  #!- The buffer containing the audio samples.
+  fun void init(ftbl _valsftbl _buf);
+  fun float id();
+  #!- Value position.
+  fun float id(float _id);
+}
+#!- Smooth variable delay line without varispeed pitch.
+#!- Smooth delay is based off the sdelay module in Faust. The smooth delay 
+#!- algorithm involves a double delay line. Any time the delay time changes, 
+#!- the delay time of buffer not heard changes, then is crossfaded to 
+#!- that buffer.
+class Smoothdelay extends UGen {
+  #!- Maximum delay time (in seconds)
+  #!- interpolation time (in samples)
+  fun void init(float _maxdelint _interp);
+  fun float feedback();
+  #!- 
+  fun float feedback(float _feedback);
+  fun float del();
+  #!- 
+  fun float del(float _del);
+}
+#!- Stream a Soundpipe Audio File
+#!- Similar to sp_diskin, sp_spa will stream a file in the internal soundpipe
+#!- audio format. Such a format is useful for instances where you need to read
+#!- audio files, but can't use libsndfile. 
+class Spa extends UGen {
+  #!- Filename of SPA file
+  fun void init(string _filename);
+}
+#!- Writes signal to spa file.
+class Sparec extends UGen {
+  #!- Filename to write to
+  fun void init(string _filename);
+}
+#!- String resonator filter
+class Streson extends UGen {
+  fun float freq();
+  #!- Fundamental frequency of string.
+  fun float freq(float _freq);
+  fun float fdbgain();
+  #!- Feedback amount (value between 0-1)
+  fun float fdbgain(float _fdbgain);
+}
+#!- Switch between two signals
+#!- 
+#!-     By default, the incoming first signal is selected. When triggered, the output signal will switch to the other signal.
+class Switch extends UGen {
+}
+#!- Table 
+#!-         Read through an sp_ftbl with linear interpolation.
+#!-     
+class Tabread extends UGen {
+  #!- A properly allocated table (using a function like sp_gen_file).
+  #!- 1 = scaled index, 0 = unscaled index
+  fun void init(ftbl _ftfloat _mode);
+  fun float index();
+  #!- index position, either scaled or unscaled with mode parameter
+  fun float index(float _index);
+  fun float offset();
+  #!- Offset from beginning of ftable. If the mode is scaled, then it is in range 0-1, other wise it is the index position.
+  fun float offset(float _offset);
+  fun float wrap();
+  #!- Enable wraparound. 1 = on; 0 = 0ff.
+  fun float wrap(float _wrap);
+}
+#!- Triggerable classic ADSR envelope
+class Tadsr extends UGen {
+  fun float atk();
+  #!- Attack time
+  fun float atk(float _atk);
+  fun float dec();
+  #!- Decay time
+  fun float dec(float _dec);
+  fun float sus();
+  #!- Sustain Level
+  fun float sus(float _sus);
+  fun float rel();
+  #!- release
+  fun float rel(float _rel);
+}
+#!- A high talkbox emulation, simular to a vocoder.
+#!- This is the talkbox plugin ported from the MDA plugin suite. In many ways,
+#!- this Talkbox functions like a vocoder: it takes in a source signal (usually
+#!- speech), which then excites an excitation signal 
+#!- (usually a harmonically rich signal like a saw wave). This particular algorithm
+#!- uses linear-predictive coding (LPC), making speech intelligibility better 
+#!- than most vocoder implementations.
+class Talkbox extends UGen {
+  fun float quality();
+  #!- Quality of the talkbox sound. 0=lowest fidelity. 1=highest fidelity
+  fun float quality(float _quality);
+}
+#!- Record a signal to an ftable.
+#!- This module will write audio-rate signals to a preallocated soundpipe ftable. 
+#!- Every time record is enabled, it will got back to index 0 overwrite any
+#!- previous information that was on it. 
+class Tblrec extends UGen {
+  #!- 
+  fun void init(ftbl _bar);
+}
+#!- Emulation of the Roland TB-303 filter
+class Tbvcf extends UGen {
+  fun float fco();
+  #!- Filter cutoff frequency
+  fun float fco(float _fco);
+  fun float res();
+  #!- Resonance
+  fun float res(float _res);
+  fun float dist();
+  #!- Distortion. Value is typically 2.0; deviation from this can cause stability issues. 
+  fun float dist(float _dist);
+  fun float asym();
+  #!- Asymmetry of resonance. Value is between 0-1
+  fun float asym(float _asym);
+}
+#!- Trigger divider.
+#!- This module will take in a trigger signal, and output a trigger signal
+#!- every N times.
+#!- 
+#!- For instance, when N = 3:
+#!- 
+#!- in: * * * * * * * * *
+#!- 
+#!- out *     *     *   
+#!- 
+class Tdiv extends UGen {
+  fun float num();
+  #!- Triggers every N times.
+  fun float num(float _num);
+  fun float offset();
+  #!- Offset amoutn.
+  fun float offset(float _offset);
+}
+#!- Trigger based linear AHD envelope generator
+class Tenv extends UGen {
+  fun float atk();
+  #!- Attack time, in seconds.
+  fun float atk(float _atk);
+  fun float hold();
+  #!- Hold time, in seconds.
+  fun float hold(float _hold);
+  fun float rel();
+  #!- Release time, in seconds.
+  fun float rel(float _rel);
+}
+#!- Linear 2-stage Attack/Release envelope generator
+#!- 
+#!-     This envelope takes 2 triggers. When triggered once,
+#!- the envelope will rise to 1 according to the attack time. When triggered again, it will decay to 0 according to
+#!- the decay time.
+class Tenv2 extends UGen {
+  fun float atk();
+  #!- Attack time (in seconds).
+  fun float atk(float _atk);
+  fun float rel();
+  #!- Release time (in seconds).
+  fun float rel(float _rel);
+}
+#!- Trigger based exponential AHD envelope generator.
+#!-     This envelope generator emulates the exponential behavior of analogue 
+#!- envelope generators by passing a gate signal (whose duration is specified via
+#!- the hold parameter) through a one-pole filter, whose filter coefficeints are
+#!- calculated in terms of tau.  
+#!-     
+class Tenvx extends UGen {
+  fun float atk();
+  #!- Tau attack time, in seconds. Must be non-zero.
+  fun float atk(float _atk);
+  fun float hold();
+  #!- Hold time, in seconds. The duration of the gate signal.
+  fun float hold(float _hold);
+  fun float rel();
+  #!- Tau release time, in seconds. Must be non-zero.
+  fun float rel(float _rel);
+}
+#!- A triggerable gate.
+class Tgate extends UGen {
+  fun float time();
+  #!- Duration of the gate (in seconds)
+  fun float time(float _time);
+}
+#!- Trigger generator for signals that cross a given threshold. 
+class Thresh extends UGen {
+  fun float thresh();
+  #!- Threshold level
+  fun float thresh(float _thresh);
+  fun int mode();
+  #!- Sets when to detect theshold crossings. 0 = from below. 1 = from above. 2 = from above/below
+  fun int mode(int _mode);
+}
+#!- Tap-tempo like timer
+#!- 
+#!- When triggered, timer will begin an internal stopwatch until it is triggered again.
+#!- The output of the timer will be the time elapsed in seconds.
+class Timer extends UGen {
+}
+#!- Similar to in, tin reads SPFLOATs (by default, this is a 4 byte binary float) from standard input every time it is triggered. behaves like a sample and hold, retaining the previous value (initial set to 0) until triggered. 
+class Tin extends UGen {
+}
+#!- First-order recursive lowpass filter
+class Tone extends UGen {
+  fun float hp();
+  #!- The response curve's half power point (aka cutoff frequency).
+  fun float hp(float _hp);
+}
+#!- Triggered random number generator.
+class Trand extends UGen {
+  fun float min();
+  #!- Minimum value to use.
+  fun float min(float _min);
+  fun float max();
+  #!- Maximum value to use.
+  fun float max(float _max);
+}
+#!- This module creates a series of line segments. 
+class Tseg extends UGen {
+  #!- Beginning value.
+  fun void init(float _ibeg);
+  fun float end();
+  #!- End parameter to go to.
+  fun float end(float _end);
+  fun float dur();
+  #!- duration to rise to (in seconds).
+  fun float dur(float _dur);
+  fun float type();
+  #!- The type of line, which determines slope of line
+  fun float type(float _type);
+}
+#!- Function table looper
+#!- 
+#!-     TSeq runs through values in an ftable. It will change values when the trigger input is a non-zero value, and wrap around when it reaches the end.
+class Tseq extends UGen {
+  #!- An ftable of values
+  fun void init(ftbl _ft);
+  fun int shuf();
+  #!- When shuf is non-zero, randomly pick a value rather than cycle through sequentially.
+  fun int shuf(int _shuf);
+}
+#!- Delay line with cubic interpolation
+class Vdelay extends UGen {
+  #!- The maximum delay time, in seconds.
+  fun void init(float _maxdel);
+  fun float del();
+  #!- Delay time (in seconds) that can be changed during performance. This value must not exceed the maximum delay time.
+  fun float del(float _del);
+  fun float feedback();
+  #!- Amount of feedback in delay line. Should be in range 0-1.
+  fun float feedback(float _feedback);
+}
+#!- A vocal tract physical model.
+#!- 
+#!- Based on the Pink Trombone algorithm by Neil Thapen, Voc implements a physical 
+#!- model of the vocal tract glottal pulse wave. The tract model is based on the 
+#!- classic Kelly-Lochbaum
+#!- segmented cylindrical 1d waveguide model, and the glottal pulse wave is a
+#!- LF glottal pulse model. 
+#!- 
+#!- The soundpipe source code for Voc is generated via ctangle, one half of the
+#!- literate documentation system known CWEB. The CWEB are maintained in a 
+#!- separate repository. They are hosted on github here: 
+#!- http://www.github.com/paulbatchelor/voc
+#!- 
+#!- This documentation is a stub. For a full overview on proper usage, consult
+#!- the `Top-level functions` section of the documented code, a copy of which
+#!- can be found at the Voc project page pbat.ch/proj/voc, or generate the PDF
+#!- from the github page described above.
+class Voc extends UGen {
+}
+#!- 16-band channel vocoder
+class Vocoder extends UGen {
+  fun float atk();
+  #!- Attack time . (Range 0.001 and 0.5 seconds)
+  fun float atk(float _atk);
+  fun float rel();
+  #!- Release time
+  fun float rel(float _rel);
+  fun float bwratio();
+  #!- Coeffecient to adjust the bandwidth of each band (0.1 - 2)
+  fun float bwratio(float _bwratio);
+}
+#!- Simple Time-stretching from repeating wavecyles
+#!- This module looks for zero-crossings and repeats them by a integer factor.
+#!- While a crude means for time stretching, it is a very aesthetically pleasing
+#!- effect to use on sounds and often produces a `wet` sound.
+#!- 
+#!- The waveset algorithm was originally created by Trevor Wishart for the Composer
+#!- Desktop Project (CDP), and was then ported to Csound. 
+class Waveset extends UGen {
+  #!- Length of buffer (in seconds).
+  fun void init(float _ilen);
+  fun float rep();
+  #!- Number of repeats.
+  fun float rep(float _rep);
+}
+#!- Reads a mono WAV file.
+#!- 
+#!- This module reads a mono WAV file from disk. It uses the public-domain 
+#!- dr_wav library for decoding, so it can be a good substitute for libsndfile.
+class Wavin extends UGen {
+  #!- Filename
+  fun void init(string _filename);
+}
+#!- Writes a mono signal to a WAV file.
+#!- This module uses the public-domain dr_wav library to write WAV files
+#!- to disk. This module is ideal for instances where GPL-licensed libsndfile 
+#!- cannot be used for legal reasons.
+class Wavout extends UGen {
+  #!- The filename of the output file.
+  fun void init(string _filename);
+}
+#!-  Analogue model of the Korg 35 Lowpass Filter
+#!- 
+#!- Original port done by Will Pirkle:
+#!- http://www.willpirkle.com/Downloads/AN-5Korg35_V3.pdf
+#!- 
+class Wpkorg35 extends UGen {
+  fun float cutoff();
+  #!- Filter cutoff
+  fun float cutoff(float _cutoff);
+  fun float res();
+  #!- Filter resonance (should be between 0-2)
+  fun float res(float _res);
+  fun float saturation();
+  #!- Filter saturation.
+  fun float saturation(float _saturation);
+}
+#!- 8 FDN stereo zitareverb algorithm, imported from Faust.
+class Zitarev extends UGen {
+  fun float in_delay();
+  #!- Delay in ms before reverberation begins.
+  fun float in_delay(float _in_delay);
+  fun float lf_x();
+  #!- Crossover frequency separating low and middle frequencies (Hz).
+  fun float lf_x(float _lf_x);
+  fun float rt60_low();
+  #!- Time (in seconds) to decay 60db in low-frequency band.
+  fun float rt60_low(float _rt60_low);
+  fun float rt60_mid();
+  #!- Time (in seconds) to decay 60db in mid-frequency band.
+  fun float rt60_mid(float _rt60_mid);
+  fun float hf_damping();
+  #!- Frequency (Hz) at which the high-frequency T60 is half the middle-band's T60.
+  fun float hf_damping(float _hf_damping);
+  fun float eq1_freq();
+  #!- Center frequency of second-order Regalia Mitra peaking equalizer section 1.
+  fun float eq1_freq(float _eq1_freq);
+  fun float eq1_level();
+  #!- Peak level in dB of second-order Regalia-Mitra peaking equalizer section 1
+  fun float eq1_level(float _eq1_level);
+  fun float eq2_freq();
+  #!- Center frequency of second-order Regalia Mitra peaking equalizer section 2.
+  fun float eq2_freq(float _eq2_freq);
+  fun float eq2_level();
+  #!- Peak level in dB of second-order Regalia-Mitra peaking equalizer section 2
+  fun float eq2_level(float _eq2_level);
+  fun float mix();
+  #!- 0 = all dry, 1 = all wet
+  fun float mix(float _mix);
+  fun float level();
+  #!- Output scale factor (in dB).
+  fun float level(float _level);
+}
+```
diff --git a/docs/Reference/Plugins/Std.mdr b/docs/Reference/Plugins/Std.mdr
new file mode 100644
index 00000000..a4d1522d
--- /dev/null
+++ b/docs/Reference/Plugins/Std.mdr
@@ -0,0 +1,25 @@
+# Std
+
+compiler generated documentation
+
+```gwion
+#!+ Std
+fun static int clamp(int valueint minint max);
+fun static float clampf(float valuefloat minfloat max);
+fun static float scale(float valuefloat srcminfloat srcmaxfloat dstminfloat dstmax);
+fun static int setenv(string keystring value);
+fun static int atoi(string keyRef:[ int ] idx);
+fun static float atof(string keyRef:[ int ] idx);
+fun static int atoi(string key);
+fun static float atof(string key);
+fun static int system(string value);
+fun static string getenv(string value);
+fun static float mtof(float value);
+fun static float ftom(float value);
+fun static float powtodb(float value);
+fun static float rmstodb(float value);
+fun static float dbtopow(float value);
+fun static float dbtorms(float value);
+fun static float dbtolin(float value);
+fun static float lintodb(float value);
+```
diff --git a/docs/Reference/Plugins/TinySF.mdr b/docs/Reference/Plugins/TinySF.mdr
new file mode 100644
index 00000000..f9fa011c
--- /dev/null
+++ b/docs/Reference/Plugins/TinySF.mdr
@@ -0,0 +1,12 @@
+# TinySF
+
+compiler generated documentation
+
+```gwion
+#!+ TinySF
+class TinySF extends UGen {
+  operator auto new(string file);
+  fun void noteOn(int notefloat vel);
+  fun void noteOff(int note);
+}
+```
diff --git a/docs/Reference/Plugins/Tuple.mdr b/docs/Reference/Plugins/Tuple.mdr
new file mode 100644
index 00000000..1a0862d9
--- /dev/null
+++ b/docs/Reference/Plugins/Tuple.mdr
@@ -0,0 +1,19 @@
+# Tuple
+
+compiler generated documentation
+
+```gwion
+#!+ Tuple
+class Tuple extends Object {
+}
+primitive @Undefined;
+operator @ctor (Tuple);
+operator Tuple @scan ();
+operator => (Object, Tuple);
+operator $ (Object, Tuple);
+operator @implicit (Object, Tuple);
+operator @array (int, Tuple);
+primitive Unpack;
+operator @ctor (Unpack);
+operator => (Object, Unpack);
+```
diff --git a/docs/Reference/Plugins/list b/docs/Reference/Plugins/list
new file mode 100644
index 00000000..fb00685a
--- /dev/null
+++ b/docs/Reference/Plugins/list
@@ -0,0 +1,14 @@
+Soundpipe
+TinySF
+Analys
+Emoji
+File
+Lsys
+Machine
+Math
+Modules
+Sndfile
+Soundpipe
+Std
+TinySF
+Tuple