cyfaust 0.1.0__cp311-cp311-macosx_15_0_arm64.whl

cyfaust/resources/libraries/examples/gameaudio/fire.dsp

@@ -0,0 +1,46 @@
+import("stdfaust.lib");
+
+//----------------------------`fire`---------------------------
+// fire(is_wet) : produces burning fire sound
+//
+// #### Usage
+//
+// ```
+// fire(is_wet) : _
+// ```
+//
+// Where:
+//
+// * `is_wet`: a binary flag/signal adding wet wood
+//             popping sound
+//
+// #### Example
+//
+// ```
+// checkbox("wet") : fire : _
+// ```
+//
+//------------------------------------------------------------
+
+sq(x) = x * x;
+stretch(ms) = ba.countdown(ma.SR * ms / 1000): >(0);
+
+crackle(dens, rel) = ((no.noise : fi.lowpass(3, 10000)) * 0.77 * os.osc(50 / dens) * 
+                      en.arfe(0.001, release, 0, trigger: >(0)
+                      : stretch(sus)))
+                      : fi.highpass(3, 1000)
+    with {
+        trigger = no.sparse_noise(dens): abs;
+        sus = 2 + (trigger: ba.latch(trigger) * 8);
+        release = rel + (0.3 * (no.noise : abs : ba.latch(trigger)));
+    };
+
+fire(is_wet) = (is_wet * wet) + (base <: (_, fi.lowpass(3, 1000), fi.highpass(3, 10000)) :> _)
+    with {
+        hiss = (no.noise : fi.lowpass(3, 500)) / 5;
+        hiss2 = 0.8 * (no.noise : fi.highpass(3, 3000) / 8) * sq(no.lfnoise(1000));
+        wet = (3 * crackle(0.1, 0.05)) + (2 * crackle(0.2, 0.3));
+        base = hiss + hiss2 + (0.2 * crackle(5, 0.1));
+    };
+
+process = checkbox("wet"): fire;

cyfaust/resources/libraries/examples/gameaudio/insects.dsp

@@ -0,0 +1,148 @@
+import("stdfaust.lib");
+
+//---------------------------`cricket`-------------------------
+// cricket(f1, f2, trig) : produces a cricket chirp,
+//                         the cricket sound based on examples
+//                         from the book "Designing Sound"
+//                               by Andy Farnell
+//
+// #### Usage
+//
+// ```
+// cricket(f1, f2, trig) : _
+// ```
+//
+// Where:
+//
+// * ` f1 `: frequency of the first harmonic of the chirp
+// * ` f2 `: frequency of the second harmonic of the chirp
+// * `trig`: the trigger impulse
+//
+// #### Examples
+//
+// ```
+// ba.pulse(20000) : cricket(5134, 12342) : _
+// ```
+// or
+// ```
+// button("chirp") : ba.impulsify : cricket(5134, 12342, trig1) : _
+// ```
+//
+//------------------------------------------------------------
+
+//--------------------------`critters`------------------------
+// critters(freqs) : produces background 'critters' sound,
+//                            based on examples
+//                            from the book "Designing Sound"
+//                                  by Andy Farnell
+//
+// #### Usage
+//
+// ```
+// critters(freqs) : _
+// ```
+//
+// Where:
+//
+// * `freqs`: a list with 4 frequencies
+//
+// #### Examples
+//
+// ```
+// critters((2012, 4, 20, 2)) : _
+// ```
+//
+//------------------------------------------------------------
+
+//----------------------------`frog`--------------------------
+// frog(l, f, trig) : produces a frog croaking sound,
+//                             based on examples
+//                             from the book "Designing Sound"
+//                                   by Andy Farnell
+//
+// #### Usage
+//
+// ```
+// frog(l, f, trig) : _
+// ```
+//
+// Where:
+//
+// * ` l  `: length of the croak in [ms]
+// * ` f  `: the frequency of resonance (don't go below ~300Hz)
+// * `trig`: the trigger impulse
+//
+// #### Examples
+//
+// ```
+// button("croak") : ba.impulsify : frog(250, 900) : _
+// ```
+//
+//------------------------------------------------------------
+
+
+wrap(s) = s - int(s);
+normsin(s) = sin(2 * ma.PI * s);
+normcos(s) = cos(2 * ma.PI * s);
+phasor(f) = os.phasor(1, f);
+stretch(ms) = ba.countdown(ma.SR * ms / 1000) : >(0);
+pulsetrain(ms, n, trig) =  (trig: stretch(ms * n)) * ba.pulse(ma.SR * ms / 1000);
+
+cricket(f1, f2, trig) = s1 : *(44) <: ((aa.clip(0, 1.0): wrap), (aa.clip(1.0, 4.0) : wrap)) :> (+):
+               normsin : aa.clip(0.0, 1.0) : *(s2) : *(0.3): *(e)
+               with {
+                   f = 0.8;
+                   sig = phasor(f);
+                   phase = sig : ba.sAndH(trig);
+                   s1 = wrap(sig + (1 - phase));
+                   s2 = os.osc(f1) + os.osc(f2) : *(no.lfnoise(500));
+                   e = trig : stretch(1000 / f);
+               };
+
+water = no.noise : abs : ba.sAndH(no.sparse_noise(250) : abs : >(0)) :
+        *(1200) : +(400) : os.osc : fi.resonhp(850, 15, 1) : *(0.008);
+
+hum = no.noise : fi.resonlp(800, 1, 0.08);
+
+critters(freqs) = freqs : prod(i, ba.count(freqs), phasor: normcos):>
+           fi.resonhp(20, 1, 1) : *(os.osc(0.01)): *(0.025);
+
+frog(l, f, trig) = out
+    with {
+        sq(x) = x * x;
+        src = en.asr(0.0, 1.0, l / 1000, trig);
+        ch1 = 1.0 / (src : max(0.5): *(-1.0): +(ch2): *(3): sq: *(2): -(1) : wrap *(122): sq: +(1));
+        ch2 = src : min(0.5);
+        ch3 = (1 - src) <: ((max(0.9) : *(-1)), min(0.5)) :> *(3) <: ((*(40): +(f)), (*(90): +(2 * f)), (*(240): +(3 * f)));
+        out = ch3 : vcf(ch1, 5), vcf(ch1, 4), vcf(ch1, 3) : (*(0.45), _, *(0.45)) :> fi.resonhp(10, 1, 1): *(0.5);
+        vcf(s, res, f) = s : fi.resonbp(f, res, 1): fi.resonlp(1400, 1, 1);
+    };
+
+process = insects, background : ro.interleave(2, 2) : par(i, 2, sum(j, 2, _))
+    with {
+        N = ba.count(channels);
+        trig_data = ((0.1, 500, 5),  (0.15, 300, 3),
+                     (0.05, 250, 6), (0.0921, 320, 4),
+                     (0.093, 250, 3), (0.09, 300, 2), (0.087, 150, 5));
+        channels = (cricket(5134, 12342),
+                    cricket(3134, 8342),
+                    cricket(8134, 15342),
+                    cricket(6134, 1842),
+                    frog(250, 900),
+                    frog(400, 600),
+                    frog(200, 800));
+        spat(rng1, rng2, trig) = sp.spat(2, r, d)
+            with {
+                r = rng1 : abs : ba.sAndH(trig);
+                d = rng2 : abs : ba.sAndH(trig);
+            };
+        trig(f, ms, n) = no.sparse_noise(f) : abs : >(0) <:  (_, pulsetrain(ms, n));
+        trigsm = trig_data : par(i, N, trig): ro.interleave(2, N);
+        btrigs = trigsm : (si.bus(N), si.block(N));
+        trigs =  trigsm : (si.block(N), si.bus(N));
+        spats = (no.multinoise(2 * N), btrigs, (trigs : channels)) : ro.interleave(N, 4): par(i, N, spat);
+        insects = spats : ro.interleave(2, N) : par(i, 2, sum(j, N, _));
+        background = water + hum +
+                     critters((2012, 4, 20, 2)) +
+                     critters((2134, 4.279, 20.4, 15.5)) : *(0.4) <: (_, _);
+    };

cyfaust/resources/libraries/examples/gameaudio/rain.dsp

@@ -0,0 +1,27 @@
+//----------------------`rain`--------------------------
+// A very simple rain simulator
+//
+// #### Usage
+//
+// ```
+//  rain(d,l) : _,_
+// ```
+//
+// Where:
+//
+// * `d`: is the density of the rain: between 0 and 1
+// * `l`: is the level (volume) of the rain: between 0 and 1
+//
+//----------------------------------------------------------
+
+import("stdfaust.lib");
+
+rain(density,level) = no.multinoise(2) : par(i, 2, drop) : par(i, 2, *(level))
+	with {
+		drop = _ <: @(1), (abs < density) : *;
+	};
+
+process  = 	rain(
+				hslider("v:rain/density", 300, 0, 1000, 1) / 1000,
+				hslider("v:rain/volume", 0.5, 0, 1, 0.01)
+			);

cyfaust/resources/libraries/examples/gameaudio/wind.dsp

@@ -0,0 +1,23 @@
+//----------------------`wind`--------------------------
+// A very simple wind simulator, based on a filtered white noise
+//
+// #### Usage
+//
+// ```
+//  wind(f) : _
+// ```
+//
+// Where:
+//
+// * `f`: is the force of the wind: between 0 and 1
+//
+//----------------------------------------------------------
+
+import("stdfaust.lib");
+
+wind(force) = no.multinoise(2) : par(i, 2, ve.moog_vcf_2bn(force,freq)) : par(i, 2, *(force))
+	with {
+		freq = (force*87)+1 : ba.pianokey2hz;
+	};
+
+process = wind(hslider("v:wind/force",0.66,0,1,0.01) : si.smooth(0.997));

cyfaust/resources/libraries/examples/generator/filterOsc.dsp

@@ -0,0 +1,8 @@
+declare name "filterOSC";
+declare version "0.0";
+declare author "JOS, revised by RM";
+declare description "Simple application demoing filter based oscillators.";
+
+import("stdfaust.lib");
+
+process = dm.oscrs_demo;

cyfaust/resources/libraries/examples/generator/noise.dsp

@@ -0,0 +1,52 @@
+// WARNING: This a "legacy example based on a deprecated library". Check noises.lib
+// for more accurate examples of noise functions
+
+declare name 		"Noise";
+declare version 	"1.1";
+declare author 		"Grame";
+declare license 	"BSD";
+declare copyright 	"(c)GRAME 2009";
+
+//-----------------------------------------------------------------
+// Noise generator and demo file for the Faust math documentation
+//-----------------------------------------------------------------
+
+<mdoc>
+\section{Presentation of the "noise.dsp" Faust program}
+This program describes a white noise generator with an interactive volume, using a random function.
+
+\subsection{The random function}
+The \texttt{random} function describes a generator of random numbers, which equation follows. You should notice hereby the use of an integer arithmetic on 32 bits, relying on integer wrapping for big numbers.
+<equation>random</equation>
+
+\subsection{The noise function}
+The white noise then corresponds to:
+<equation>noise</equation>
+</mdoc>
+
+random  = +(12345)~*(1103515245);
+noise   = random/2147483647.0;
+
+<mdoc>
+\subsection{Just add a user interface element to play volume!}
+Endly, the sound level of this program is controlled by a user slider, which gives the following equation: 
+<equation>process</equation>
+</mdoc>
+
+<mdoc>
+\section{Block-diagram schema of process}
+This process is illustrated on figure 1.
+<diagram>process</diagram>
+</mdoc>
+
+process = noise * vslider("Volume[style:knob][acc: 0 0 -10 0 10]", 0.5, 0, 1, 0.1);
+
+<mdoc>
+\section{Notice of this documentation}
+You might be careful of certain information and naming conventions used in this documentation:
+<notice/>
+
+\section{Listing of the input code}
+The following listing shows the input Faust code, parsed to compile this mathematical documentation.
+<listing/>
+</mdoc>

cyfaust/resources/libraries/examples/generator/noiseMetadata.dsp

@@ -0,0 +1,74 @@
+// WARNING: This a "legacy example based on a deprecated library". Check noises.lib
+// for more accurate examples of noise functions
+
+<mdoc>
+\title{<metadata>name</metadata>}
+\author{<metadata>author</metadata>}
+\date{\today}
+\maketitle
+
+\begin{tabular}{ll}
+	\hline
+	\textbf{name}		& <metadata>name</metadata> \\
+	\textbf{version} 	& <metadata>version</metadata> \\
+	\textbf{author} 	& <metadata>author</metadata> \\
+	\textbf{license} 	& <metadata>license</metadata> \\
+	\textbf{copyright} 	& <metadata>copyright</metadata> \\
+	\hline
+\end{tabular}
+\bigskip
+</mdoc>
+//-----------------------------------------------------------------
+// Noise generator and demo file for the Faust math documentation
+//-----------------------------------------------------------------
+
+declare name 		"noiseMetadata"; // avoid same name as in noise.dsp
+declare version 	"1.1";
+declare author 		"Grame";
+declare author 		"Yghe";
+declare license 	"BSD";
+declare copyright 	"(c)GRAME 2009";
+
+<mdoc>
+\section{Presentation of the "noise.dsp" Faust program}
+This program describes a white noise generator with an interactive volume, using a random function.
+
+\subsection{The random function}
+</mdoc>
+
+random  = +(12345)~*(1103515245);
+
+<mdoc>
+The \texttt{random} function describes a generator of random numbers, which equation follows. You should notice hereby the use of an integer arithmetic on 32 bits, relying on integer wrapping for big numbers.
+<equation>random</equation>
+
+\subsection{The noise function}
+</mdoc>
+
+noise   = random/2147483647.0;
+
+<mdoc>
+The white noise then corresponds to:
+<equation>noise</equation>
+
+\subsection{Just add a user interface element to play volume!}
+</mdoc>
+
+process = noise * vslider("Volume[style:knob]", 0, 0, 1, 0.1);
+
+<mdoc>
+Endly, the sound level of this program is controlled by a user slider, which gives the following equation: 
+<equation>process</equation>
+
+\section{Block-diagram schema of process}
+This process is illustrated on figure 1.
+<diagram>process</diagram>
+
+\section{Notice of this documentation}
+You might be careful of certain information and naming conventions used in this documentation:
+<notice />
+
+\section{Listing of the input code}
+The following listing shows the input Faust code, parsed to compile this mathematical documentation.
+<listing mdoctags="false" dependencies="false" distributed="false" />
+</mdoc>

cyfaust/resources/libraries/examples/generator/osc.dsp

@@ -0,0 +1,17 @@
+declare name 		"osc";
+declare version 	"1.0";
+declare author 		"Grame";
+declare license 	"BSD";
+declare copyright 	"(c)GRAME 2009";
+
+//-----------------------------------------------
+// 		Sinusoidal Oscillator
+//-----------------------------------------------
+
+import("stdfaust.lib");
+
+vol = hslider("volume [unit:dB]", 0, -96, 0, 0.1) : ba.db2linear : si.smoo;
+freq = hslider("freq [unit:Hz]", 1000, 20, 24000, 1);
+
+process = vgroup("Oscillator", os.osc(freq) * vol);
+

cyfaust/resources/libraries/examples/generator/osci.dsp

@@ -0,0 +1,17 @@
+declare name 		"osci";
+declare version 	"1.0";
+declare author 		"Grame";
+declare license 	"BSD";
+declare copyright 	"(c)GRAME 2009";
+
+//-----------------------------------------------
+// 		  Sinusoidal Oscillator
+//		(with linear interpolation)
+//-----------------------------------------------
+
+import("stdfaust.lib");
+
+vol = hslider("volume [unit:dB]", 0, -96, 0, 0.1) : ba.db2linear : si.smoo ;
+freq = hslider("freq [unit:Hz]", 1000, 20, 24000, 1);
+
+process = vgroup("Oscillator", os.osci(freq) * vol);

cyfaust/resources/libraries/examples/generator/sawtoothLab.dsp

@@ -0,0 +1,8 @@
+declare name "sawtoothLab";
+declare version "0.0";
+declare author "JOS, revised by RM";
+declare description "An application demonstrating the different sawtooth oscillators of Faust.";
+
+import("stdfaust.lib");
+
+process = dm.sawtooth_demo;

cyfaust/resources/libraries/examples/generator/virtualAnalog.dsp

@@ -0,0 +1,8 @@
+declare name "VirtualAnalog";
+declare version "0.0";
+declare author "JOS, revised by RM";
+declare description "Virtual analog oscillator demo application.";
+
+import("stdfaust.lib");
+
+process = dm.virtual_analog_oscillator_demo;

cyfaust/resources/libraries/examples/generator/virtualAnalogLab.dsp

@@ -0,0 +1,10 @@
+declare name "virtualAnalogLab";
+
+import("stdfaust.lib");
+
+process = 
+ vgroup("[1]", dm.virtual_analog_oscillator_demo) : 
+ vgroup("[2]", dm.moog_vcf_demo) : 
+ vgroup("[3]", dm.spectral_level_demo)
+ // See also: vgroup("[3]", dm.fft_spectral_level_demo(32))
+  <: _,_;

cyfaust/resources/libraries/examples/misc/UITester.dsp

@@ -0,0 +1,71 @@
+declare name "UITester";
+declare version "1.0";
+declare author "O. Guillerminet";
+declare license "BSD";
+declare copyright "(c) O. Guillerminet 2012";
+
+vbox = vgroup("vbox", 
+    checkbox("check1"),
+    checkbox("check2"),
+     nentry("knob0[style:knob]", 60, 0, 127, 0.1));
+
+sliders = hgroup("sliders",
+        vslider("vslider1", 60, 0, 127, 0.1),
+        vslider("vslider2", 60, 0, 127, 0.1),
+        vslider("vslider3", 60, 0, 127, 0.1));
+
+knobs = hgroup("knobs",
+        vslider("knob1[style:knob]", 60, 0, 127, 0.1),
+        vslider("knob2[style:knob]", 60, 0, 127, 0.1),
+        vslider("knob3[style:knob]", 60, 0, 127, 0.1));
+
+smallhbox1 = hgroup("small box 1",
+            vslider("vslider5 [unit:Hz]", 60, 0, 127, 0.1),
+            vslider("vslider6 [unit:Hz]", 60, 0, 127, 0.1),
+            vslider("knob4[style:knob]", 60, 0, 127, 0.1),
+            nentry("num1 [unit:f]", 60, 0, 127, 0.1),
+            vbargraph("vbar1", 0, 127));
+
+smallhbox2 = hgroup("small box 2",
+            vslider("vslider7 [unit:Hz]", 60, 0, 127, 0.1),
+            vslider("vslider8 [unit:Hz]", 60, 0, 127, 0.1),
+            vslider("knob5[style:knob]", 60, 0, 127, 0.1),
+            nentry("num2 [unit:f]", 60, 0, 127, 0.1),
+            vbargraph("vbar2", 0, 127));
+
+smallhbox3 = hgroup("small box 3",
+            vslider("vslider9 [unit:Hz]", 60, 0, 127, 0.1),
+            vslider("vslider10 [unit:m]", 60, 0, 127, 0.1),
+            vslider("knob6[style:knob]", 60, 0, 127, 0.1),
+            nentry("num3 [unit:f]", 60, 0, 127, 0.1),
+            vbargraph("vbar3", 0, 127));
+
+subhbox1 = hgroup("sub box 1",
+        smallhbox2,
+        smallhbox3);
+
+vmisc = vgroup("vmisc",
+        vslider("vslider4 [unit:Hz]", 60, 0, 127, 0.1),
+        button("button"),
+        hslider("hslider [unit:Hz]", 60, 0, 127, 0.1),
+        smallhbox1,
+        subhbox1,
+        hbargraph("hbar", 0, 127));
+
+hmisc = hgroup("hmisc",
+        vslider("vslider4 [unit:f]", 60, 0, 127, 0.1),
+        button("button"),
+        hslider("hslider", 60, 0, 127, 0.1),
+        nentry("num [unit:f]", 60, 0, 127, 0.1),
+        vbargraph("vbar", 0, 127),
+        hbargraph("hbar", 0, 127));
+
+//------------------------- Process --------------------------------
+
+process = tgroup("grp 1",
+        vbox,
+        sliders,
+        knobs,
+        vmisc,
+        hmisc);
+

cyfaust/resources/libraries/examples/misc/autopan.dsp

@@ -0,0 +1,59 @@
+//--------------------------autopan----------------------------
+//
+// For a stereo input, adjust the left and right gains
+// according to rate-synced sine oscillators. This example is
+// reverse-engineered from Ableton Live's "Auto Pan" audio
+// effect. We don't implement the "spin" feature in which
+// the two LFOs could have different frequencies.
+// We also don't use other LFOs such as triangle/square/noise.
+//
+// #### Usage
+//
+// ```
+// si.bus(2) : autopan(amount, rate, phase, shape) : si.bus(2)
+// ```
+//
+// Where:
+//
+// * `amount`: adjusts the amount of LFO modulation that is
+//    applied to incoming signals
+// * `rate`: sets the frequency of the LFO in Hertz
+// * `phase`: adjusts the amount of the offset between the
+//    waveforms for the left and right channel. At 180,
+//    the LFOs will be perfectly out of phase. For other
+//    values, you will hear more moments where the
+//    overall volume is reduced
+// * `shape`: turning `shape` up pushes the waveforms to their
+//    upper and lower limits, "hardening" their shape
+//------------------------------------------------------------
+import("stdfaust.lib");
+
+autopan(amount, rate, phase, shape) = _*gainLeft, _*gainRight
+with {
+
+    // A saturator
+    // Assume `x` is a signal between -1 and 1. This function
+    // pushes the output towards -1 and 1. As the shape
+    // parameter goes from 0 to 1, an input sine will become
+    // closer to a square. If `shape` is zero, then the
+    // function doesn't change the input signal.
+    saturator(shape, x) = result
+    with {
+        // It's ok to replace tanh with another saturator
+        result = x, ma.tanh(x*10.) : it.interpolate_linear(shape);
+    };
+
+    phase2Gain(phase) = os.oscp(rate, phase)
+        : saturator(shape) // comment out this line to remove the saturator
+        : it.remap(-1., 1., 1.-amount, 1.);
+
+    gainLeft = 0. : phase2Gain;
+    gainRight = phase : ma.deg2rad : phase2Gain;
+};
+
+amount = hslider("[0]Amount[style:knob]", 0., 0., 1., .001);
+rate = hslider("[1]Rate[style:knob][unit:Hz][scale:log]", 1., .05, 90., .001);
+phase = hslider("[2]Phase[style:knob][unit:°]", 180., 0., 360., 15) : si.smoo;
+shape = hslider("[3]Shape[style:knob]", 0., 0., 1., 0.001) : si.smoo;
+
+process = hgroup("Auto Pan", autopan(amount, rate, phase, shape));

cyfaust/resources/libraries/examples/misc/capture.dsp

@@ -0,0 +1,24 @@
+declare name        "capture";
+declare version     "1.0";
+declare author      "Grame";
+declare license     "BSD";
+declare copyright   "(c)GRAME 2006";
+
+//-------------------------------------------------
+//       Capture : record up to 8s of sound and
+//        playback the recorded sound in loop
+//-------------------------------------------------
+
+import("stdfaust.lib");
+
+B = button("Capture");    // Capture sound while pressed
+I = int(B);               // convert button signal from float to integer
+R = (I-I') <= 0;          // Reset capture when button is pressed
+D = (+(I):*(R))~_;        // Compute capture duration while button is pressed: 0..NNNN0..MMM
+
+capture = *(B) : (+ : de.delay(8*65536, D-1)) ~ *(1.0-B);
+
+level = hslider("level (db)", 0, -96, 4, 0.1) : ba.db2linear : si.smoo;
+
+process = vgroup("Audio Capture", capture : *(level));
+

cyfaust/resources/libraries/examples/misc/drumkit.dsp

@@ -0,0 +1,36 @@
+
+//-------------------------------------------------
+//    A simple, fully generative
+//    drum machine
+//-------------------------------------------------
+
+import("stdfaust.lib");
+
+drumkit(gate, ks, ss, hs) = k_seq, s_seq, h_seq :> /(3)
+    with {
+        N = outputs(ks);
+        env = en.ar(0.001, 0.05);
+        kick(g) = g : env : *(os.osc(100));
+        snare(g) = g : env : *(no.noise : fi.low_shelf(-60, 3000));
+        hihat(g) = g : env : *(no.noise : fi.highpass(3, 10000));
+        sequencer(t) = t : ba.selectn(N, gate : ba.pulse_countup_loop(N - 1, 1)) : *(gate : mem);
+        k_seq = sequencer(ks) : kick;
+        s_seq = sequencer(ss) : snare;
+        h_seq = sequencer(hs) : hihat;
+    };
+
+drumkit_ui(n) = drumkit(attach(gate, nn), ks, ss, hs)
+    with {
+        gate = ba.pulse(ba.tempo(bpm));
+        ks = par(i, n, checkbox("v:Drum kit/h:[0]kick/%2i"));
+        ss = par(i, n, checkbox("v:Drum kit/h:[1]snare/%2i"));
+        hs = par(i, n, checkbox("v:Drum kit/h:[2]hihat/%2i"));
+        bpm = hslider("v:Drum kit/[4]BPM", 350, 10, 800, 1);
+        mon = par(i, n, hbargraph("v:Drum kit/h:[3]seq/%2i[style:led]", 0, 1));
+        nn = 1 : ba.selectoutn(n, gate : ba.pulse_countup_loop(n - 1, 1)) : mon :> _;
+    };
+
+drumkit_ui_demo = drumkit_ui(15) <: (_, _);
+
+process = drumkit_ui_demo;
+