added example/help files from the rsc3 help directory

rsc3/examples/graph/adso.scm

@@ -0,0 +1,53 @@
+;; adso (rd)
+
+(import (rnrs) (sosc) (rsc3) (rhs))
+
+(define rand-l
+  (lambda (n l r)
+    (replicate-m n (random l r))))
+
+(define adso
+  (lambda (n)
+    (let* ((b-get
+            (lambda (b n)
+              (let ((j (make-mce (enum-from-to 0 (- n 1)))))
+                (buf-rd-n 1 kr b j 0))))
+           (m (sin-osc kr (b-get 3 n) 0))
+           (f (mul (midi-cps (b-get 0 n))
+                   (mul-add m (b-get 4 n) 1))))
+      (mix (pan2 (sin-osc ar f 0)
+                        (b-get 2 n)
+                        (b-get 1 n))))))
+
+(define pattern
+  (lambda (fd n)
+    (lambda (t)
+      (let ((z (map floor
+                    (replicate-m
+                     n (random (random 22 48)
+                               (random 54 122)))))
+            (rn (lambda (i j k)
+                  (send fd (b-setn1 i 0 (rand-l n j k))))))
+        (send fd (b-setn1 0 0 z))
+        (rn 1 0 0.1)
+        (rn 2 -1 1)
+        (rn 3 2 12)
+        (rn 4 0.001 0.0075)
+        (rn 5 1 24)
+        (rn 6 0.05 (random 0.075 2.4))
+        (thread-sleep t)))))
+
+(let ((n 24))
+  (with-sc3
+   (lambda (fd)
+     (for-each
+      (lambda (i)
+        (async fd (b-alloc i n 1)))
+      (enum-from-to 0 6))
+     (play fd (out 0 (adso n)))
+     (map (pattern fd n)
+          (replicate-m
+           32
+           (choose
+            (list 0.025 0.05 0.075 0.1 0.125 2.5))))
+     (reset fd))))

rsc3/examples/graph/aleatoric-quartet.scm

@@ -0,0 +1,32 @@
+;; aleatoric quartet (jmcc)
+
+(import (rnrs) (rsc3) (rhs))
+
+(define aleatoric-quartet
+  (let* ((amp 0.4)
+         (density (mouse-x kr 0.01 1 0 0.1))
+         (dmul (mul (recip density) (mul 0.5 amp)))
+         (dadd (add (neg dmul) amp))
+         (rapf (lambda (i)
+                 (let ((r (mce2 (rand 0 0.05) (rand 0 0.05))))
+                   (allpass-n i 0.05 r 1))))
+         (rapfn (lambda (n i)
+                  ((foldl1 compose (replicate n rapf)) i)))
+         (mk-f (lambda ()
+                 (let* ((i0 (i-rand 0 2))
+                        (r0 (select i0 (mce3 1 0.5 0.25)))
+                        (r1 (rand -30 30))
+                        (n0 (lf-noise0 kr r0))
+                        (m (u:round (mul-add n0 7 (add 66 r1)) 1)))
+                   (midi-cps (lag m 0.2)))))
+         (mk-s (lambda (_)
+                 (let* ((f (recip (mk-f)))
+                        (r (rand -1 1))
+                        (n0 (pink-noise ar))
+                        (n1 (lf-noise1 kr 8))
+                        (x (mul n0 (u:max 0 (mul-add n1 dmul dadd)))))
+                   (pan2 (comb-l x 0.02 f 3) r 1))))
+         (g (mix-fill 4 mk-s)))
+    (leak-dc (rapfn 4 g) 0.995)))
+
+(audition (out 0 aleatoric-quartet))

rsc3/examples/graph/alien-meadow.scm

@@ -0,0 +1,13 @@
+;; alien meadow (jmcc)
+
+(import (rsc3) (rsc3 lang))
+
+(define alien-meadow
+  (let* ((a (rand 0 20))
+         (b (rand 0 5000))
+         (c (rand 0 20))
+         (p (rand -1 1))
+         (f (add (mul3 (sin-osc ar a 0) b 0.1) b)))
+    (pan2 (sin-osc ar f 0) p (mul-add (sin-osc ar c 0) 0.05 0.05))))
+
+(with-sc3 (overlap-texture-u (list 2 6 6 +inf.0) alien-meadow))

rsc3/examples/graph/analog-bubbles.scm

@@ -0,0 +1,11 @@
+;; analog bubbles (jmcc)
+
+(import (rnrs) (rsc3))
+
+(define analog-bubbles
+  (let* ((o (mul-add (lf-saw kr (mce2 8 7.23) 0) 3 80))
+         (f (mul-add (lf-saw kr 0.4 0) 24 o))
+         (s (mul (sin-osc ar (midi-cps f) 0) 0.04)))
+    (comb-n s 0.2 0.2 4)))
+
+(audition (out 0 analog-bubbles))

rsc3/examples/graph/babbling-brook.scm

@@ -0,0 +1,15 @@
+;; babbling brook (jmcc)
+
+(import (rnrs) (rsc3))
+
+(define babbling-brook
+  (let* ((b (lambda (f m a g)
+              (let* ((n1 (brown-noise ar))
+                     (n2 (brown-noise ar))
+                     (n3 (mul-add (lpf n2 f) m a)))
+                (mul (rhpf (one-pole n1 0.99) n3 0.03) g))))
+         (x (clone 2 (b 14 400 500 0.024)))
+         (y (clone 2 (b 20 800 1000 0.040))))
+    (add x y)))
+
+(audition (out 0 babbling-brook))

rsc3/examples/graph/bit-reduction.scm

@@ -0,0 +1,18 @@
+;; bit reduction (adc)
+
+(import (rsc3))
+
+(let* ((f (lf-noise2 kr 8))
+       (nh (lf-noise2 kr 3))
+       (src (blip ar (mul-add f 200 300) (mul-add nh 10 20)))
+       (sr (mouse-x* kr 1000 (mul sample-rate 0.1) 1 0.2)))
+  (audition (out 0 (latch src (impulse ar sr 0)))))
+
+(let* ((f (lf-noise2 kr 8))
+       (nh (lf-noise2 kr 3))
+       (src (blip ar (mul-add f 200 300) (mul-add nh 10 20)))
+       (sr (mouse-x* kr 1000 (mul sample-rate 0.1) 1 0.2))
+       (bit-sz (mouse-y* kr 1 24 1 0.2))
+       (down-sample (latch src (impulse ar sr 0)))
+       (bit-redux (u:round down-sample (pow 0.5 bit-sz))))
+  (audition (out 0 (mce2 down-sample bit-redux))))

rsc3/examples/graph/bottle.scm

@@ -0,0 +1,26 @@
+;; bottle (sc)
+
+(import (rnrs) (rsc3) (rhs))
+
+(define bottle
+  (let* ((freq (rand 220 880))
+         (perc (env-perc 0.1 0.6 1 (list -4 -4)))
+         (flute (ringz (mul (env-gen kr 1 1 0 1 0 perc)
+                            (mul (white-noise ar) 0.02))
+                       freq
+                       0.3))
+         (breath (mul (env-gen kr 1 1 0 1 0 perc)
+                      (resonz (pink-noise ar)
+                              (add 5 (fdiv freq 2))
+                              0.1)))
+         (rapf (lambda (i)
+                 (let ((f (allpass-n i 0.1 (lin-rand 0.001 0.1 -1) 1.0)))
+                   (add i (mul f 0.5)))))
+         (close (lambda (i)
+                  (let* ((l (env-linen 0.01 3.0 1.0 1 (replicate 3 -4)))
+                         (z (mul (add breath i)
+                                 (env-gen kr 1 1 0 1 2 l))))
+                    (mce2 z z)))))
+    (close ((foldl1 compose (replicate 2 rapf)) flute))))
+
+(audition (out 0 bottle))

rsc3/examples/graph/bowed-string.scm

@@ -0,0 +1,27 @@
+;; bowed string (jmcc)
+
+(import (rnrs) (rsc3) (rhs))
+
+(define series
+  (lambda (f n x i)
+    (if (= n 0)
+        nil
+        (cons x (series f (- n 1) (f x i) i)))))
+
+(define bowed-string
+  (let* ((root 5)
+         (scale (map (lambda (n) (+ n root)) (list 0 2 4 5 7 9 11)))
+         (oct (list 24 36 48 60 72 84))
+         (choose (lambda (l) (select (i-rand 0 (length l)) (make-mce l))))
+         (f (midi-cps (add (choose scale) (choose oct))))
+         (n0 (clone 2 (brown-noise ar)))
+         (r0 (exp-rand 0.125 0.5))
+         (n1 (lf-noise1 kr r0))
+         (r1 (rand 0.7 0.9))
+         (r2 (replicate-m 12 (rand 1.0 3.0)))
+         (x (mul3 n0 0.007 (u:max 0 (mul-add n1 0.6 0.4))))
+         (d (klank-data (series add 12 f f) (series mul 12 1 r1) r2))
+         (k (klank x 1 0 1 d)))
+    (soft-clip (mul k 0.1))))
+
+(audition (out 0 bowed-string))

rsc3/examples/graph/ccomb.scm

@@ -0,0 +1,20 @@
+;; ccomb (rd)
+
+(import (rnrs) (rsc3))
+
+(define ccomb
+  (let* ((rng (lambda (u l r) (lin-lin u -1 1 l r)))
+         (lwr 48)
+         (flwr (midi-cps 48))
+         (spart (lambda (t)
+                  (let* ((n (rng (lf-noise2 kr 0.1) lwr 72))
+                         (e (decay2 t 0.01 (t-rand 0.05 0.75 t)))
+                         (x (mul (white-noise ar) e))
+                         (m (lf-noise2 kr 0.1))
+                         (f (lag (midi-cps n) 0.25)))
+                    (comb-c x (recip flwr) (recip f) (rng m 1.0 8.0)))))
+         (t (dust ar (mce2 0.9 0.8))))
+    (mix-fill 7 (lambda (_) (mul (spart t) 0.1)))))
+
+(audition (out 0 ccomb))
+

rsc3/examples/graph/chain-saw.scm

@@ -0,0 +1,48 @@
+;; chain saw (jrhb)
+
+(import (rnrs) (rsc3) (rhs))
+
+;; SimpleNumber.coin (not UGen/Coin)
+(define coin*
+  (lambda (n a b)
+    (if (> (random 0.0 1.0) n) a b)))
+
+(define exp-range
+  (lambda (s l r)
+    (lin-exp s -1 1 l r)))
+
+(define chain
+  (lambda (n fn)
+    (foldl1 compose (replicate n fn))))
+
+(define mce-product
+  (mce-edit (lambda (l) (list (foldl1 mul l)))))
+
+(define clipu
+  (lambda (s) (clip2 s 1)))
+
+(define dup
+  (lambda (a) (mce2 a a)))
+
+(define mk-f
+  (lambda (s1)
+    (let* ((xr (clone 2 (exp-rand 0.1 2)))
+           (n1 (lf-noise1 kr xr))
+           (n2 (lf-noise1 kr xr))
+           (n3 (lf-noise1 kr xr))
+           (f1 (coin* 0.6 (exp-range n1 0.01 10) (exp-range n2 10 50)))
+           (s2 (coin* 0.5 (sub 1 s1) (mce-reverse s1)))
+           (f2 (lin-exp s1 -1 1 f1 (mul f1 (exp-range n3 2 10))))
+           (u1 (lf-saw kr f2 0))
+           (u2 (mul-add (lf-saw kr (mul f1 0.1) 0) 0.1 1)))
+      (clipu (coin* 0.5 (mul u1 s2) (mul u1 u2))))))
+
+(define chain-saw
+  (let* ((inp (lf-saw kr (mul 0.2 (mce2 1 1.1)) 0))
+         (b-freq (make-mce (list 70 800 9000 5242)))
+         (ff ((chain 8 mk-f) inp))
+         (c-saw (mce-product (saw ar (exp-range ff 6 11000))))
+         (b-saw (dup (mix (bpf c-saw b-freq 0.2)))))
+    (mul b-saw 0.3)))
+
+(audition (out 0 chain-saw))

rsc3/examples/graph/chrd.scm

@@ -0,0 +1,22 @@
+;; chrd (rd)
+
+(import (rnrs) (rsc3))
+
+(define chrd
+  (lambda (_)
+    (let* ((m (make-mce (list 60 65 72 77 79 84)))
+           (ds 3)
+           (d (make-mce (map (lambda (x) (* x ds)) (list 5 4 5 7 4 5))))
+           (l (x-line kr m (add m (random 0.05 0.5)) d do-nothing))
+           (f (midi-cps l))
+           (z (env-trapezoid 0 (rand 0.15 0.35) d (rand 0.005 0.01)))
+           (e (env-gen kr 1 1 0 1 do-nothing z))
+           (p (x-line kr (rand -1 1) (rand -1 1) d do-nothing))
+           (o (f-sin-osc ar f 0)))
+      (mix (pan2 o p e)))))
+
+(define chrdn
+  (lambda (n)
+    (mix-fill n chrd)))
+
+(audition (out 0 (chrdn 5)))

rsc3/examples/graph/cricket.scm

@@ -0,0 +1,21 @@
+;; cricket (rd)
+
+(import (rnrs) (rsc3))
+
+(define cricket
+  (let* ((m-rand
+          (lambda (l r)
+            (mce2 (rand l r) (rand l r))))
+         (mt-rand
+          (lambda (l r t)
+            (mce2 (t-rand l r t) (t-rand l r t))))
+         (r1 (m-rand 10 13))
+         (r2 (m-rand 10 13))
+         (r3 (m-rand 4 7))
+         (t (impulse kr 0.7 0))
+         (e (decay2 (impulse kr r1 0) 0.001 0.005))
+         (f (mul3 (sin-osc kr r2 0) e r3))
+         (r4 (mt-rand 2220 2227 t)))
+    (mul3 (sin-osc ar r4 0) f 0.25)))
+
+(audition (out 0 cricket))

rsc3/examples/graph/crotale.scm

@@ -0,0 +1,175 @@
+;; crotale (rd)
+
+(import (rnrs) (rsc3))
+
+(define cf
+  (list 35.45676040649414
+        128.59849548339844
+        346.9721984863281
+        483.5544128417969
+        1049.2449951171875
+        1564.0279541015625
+        1756.3399658203125
+        3391.666015625
+        3451.802001953125
+        3497.261962890625
+        3596.89794921875
+        3696.739013671875
+        3835.235107421875
+        3845.955078125
+        4254.85107421875
+        4407.533203125
+        4415.26416015625
+        4552.865234375
+        5538.076171875
+        5637.73681640625
+        5690.2978515625
+        5728.0068359375
+        5764.27685546875
+        5824.4189453125
+        6377.60498046875
+        6544.35009765625
+        6807.14404296875
+        6994.97021484375
+        7026.84619140625
+        7144.5859375
+        7269.61279296875
+        7393.6708984375
+        7897.259765625
+        8040.4580078125
+        8157.77099609375
+        8225.01953125
+        9126.150390625
+        9488.529296875
+        9916.408203125
+        10155.599609375
+        11715.9599609375
+        12111.830078125
+        12339.990234375
+        12417.669921875
+        12459.2802734375
+        12618.330078125
+        13116.490234375
+        13201.1298828125
+        13297.830078125
+        13533.75))
+
+(define ca
+  (list 0.0012827360769733787
+        0.0008040848188102245
+        0.017361238598823547
+        0.004835359752178192
+        0.004413491114974022
+        0.004110544919967651
+        0.0003338181704748422
+        0.0036140112206339836
+        0.006919348146766424
+        0.0003224937245249748
+        0.0006031467346474528
+        0.06686479598283768
+        0.000605064386036247
+        0.003602313343435526
+        0.0002835785271599889
+        0.015243238769471645
+        0.020536603406071663
+        0.016677580773830414
+        0.0009245267719961703
+        0.20205098390579224
+        0.0012542791664600372
+        0.012705927714705467
+        0.0002523190632928163
+        0.0004866079252678901
+        0.0006429700297303498
+        0.0007763264584355056
+        0.2081160992383957
+        0.0024918108247220516
+        0.00193469924852252
+        0.005231771152466536
+        0.0069242212921381
+        0.001203975174576044
+        0.2050020843744278
+        0.04060448706150055
+        0.0038344631902873516
+        0.002189427148550749
+        0.18056060373783112
+        0.002192433224990964
+        0.006516554858535528
+        0.009982921183109283
+        0.004745401442050934
+        0.046154771000146866
+        0.000510294979903847
+        0.0018905038014054298
+        0.0019782145973294973
+        0.006729386281222105
+        0.0023426134139299393
+        0.0024002245627343655
+        0.03515550494194031
+        0.0014084168942645192))
+
+(define cd
+  (list 5.203680992126465
+        1.7034343481063843
+        40.16516876220703
+        27.282501220703125
+        0.8950523138046265
+        42.84742736816406
+        2.6603667736053467
+        15.7678861618042
+        6.848367214202881
+        3.2325007915496826
+        1.7343382835388184
+        2.0202419757843018
+        4.7279052734375
+        9.400103569030762
+        0.7102512717247009
+        37.494625091552734
+        36.24879455566406
+        29.172658920288086
+        3.891019344329834
+        4.757885456085205
+        3.851426124572754
+        20.90781021118164
+        3.732874870300293
+        2.3834102153778076
+        10.443285942077637
+        8.795611381530762
+        20.98564338684082
+        18.01180076599121
+        25.297883987426758
+        14.819819450378418
+        42.39189910888672
+        2.9485135078430176
+        11.043763160705566
+        49.55165100097656
+        29.882694244384766
+        10.527188301086426
+        23.5572452545166
+        26.55561637878418
+        45.099605560302734
+        22.550390243530273
+        36.46126174926758
+        11.826201438903809
+        16.818185806274414
+        14.903121948242188
+        32.81113815307617
+        43.1389045715332
+        12.289558410644531
+        11.498942375183105
+        10.465788841247559
+        24.93169593811035))
+
+(define crotale
+  (let* ((ps (make-mce (list -12 -5 0 2 4 5 7 12)))
+         (n (pink-noise ar))
+         (t (dust kr 3))
+         (fs (select (ti-rand 0 7 t) ps))
+         (g (t-rand 0 1 t))
+         (fo (t-rand 0 1 t))
+         (ds (t-rand 2 7 t))
+         (p (t-rand -1 1 t))
+         (s (mul3 (decay2 t 0.06 0.01) n g))
+         (kd (klank-data cf ca (map recip cd)))
+         (k (dyn-klank s (midi-ratio fs) fo ds kd)))
+    (pan2 k p 1)))
+
+(audition (out 0 crotale))

rsc3/examples/graph/cut-outs.scm

@@ -0,0 +1,19 @@
+;; cut-outs (rd)
+
+(import (rnrs) (rsc3))
+
+(define cut-outs
+  (let* ((t (mul (impulse ar 22 0) (add (sin-osc kr 0.5 0) 1)))
+         (x (mouse-x* kr 0.005 0.12 1 0.1))
+         (y (mouse-y* kr 0.01 0.52 1 0.1))
+         (n (lambda (_)
+              (let* ((n1 (lf-noise0 kr 2))
+                     (n2 (coin-gate (add3 0.05 (mul n1 0.4) y) (mul t 0.5)))
+                     (n3 (t-exp-rand (mce2 500 900) 1600 t)))
+                (ringz n2 n3 x))))
+         (s (mix-fill 3 n))
+         (b (t-rand 0 1 (dust kr 8))))
+    (make-mrg (mul (clip2 s (in 1 kr 0)) 0.25)
+              (out 0 b))))
+
+(audition (out 0 cut-outs))

rsc3/examples/graph/cymbalism.scm

@@ -0,0 +1,21 @@
+;; cymbalism (jmcc)
+
+(import (rnrs) (rsc3) (rhs))
+
+(define cymbalism
+  (let* ((p 15)
+         (f1 (rand 500 2500))
+         (f2 (rand 0 8000))
+         (y
+          (lambda ()
+            (let ((f (replicate-m p (add f1 (rand 0 f2))))
+                  (rt (replicate-m p (rand 1 5)))
+                  (a (replicate p 1)))
+              (klank-data f a rt))))
+         (z (mce2 (y) (y)))
+         (t (impulse ar (rand 0.5 3.5) 0))
+         (n (mul (white-noise ar) 0.03))
+         (s (mul (decay t 0.004) n)))
+    (klank s 1 0 1 (mce-transpose z))))
+
+(audition (out 0 cymbalism))

rsc3/examples/graph/data-space.scm

@@ -0,0 +1,20 @@
+;; data space (jmcc)
+
+(import (rsc3) (rsc3 lang))
+
+(define data-space
+  (let* ((r (lambda (n) (rand 0 n)))
+         (lp (lambda (f m a) (mul-add (lf-pulse kr (r f) 0 (r 1)) m a)))
+         (p0 (lp 200 1 0))
+         (p1 (lp 40 (r 8000) (r 2000)))
+         (p2 (lp 20 1 0))
+         (p3 (lp 4 (r 8000) (r 2000)))
+         (p4 (lp 20 1 0))
+         (p5 (lp 4 (r 8000) (r 2000)))
+         (f (add3 (mul p0 p1) (mul p2 p3) (mul p4 p5)))
+         (dt (rand 0.15 0.35))
+         (o (mul (lf-pulse ar f 0 0.5) 0.04))
+         (l (mul (lf-noise0 kr (r 3)) 0.8)))
+    (comb-l (pan2 o l 1) dt dt 3)))
+
+(with-sc3 (overlap-texture-u (list 1 6 4 +inf.0) data-space))

rsc3/examples/graph/deep-sea.scm

@@ -0,0 +1,28 @@
+;; deep sea (jrhb)
+
+(import (rnrs) (rsc3))
+
+(define range
+  (lambda (s l r)
+    (let ((m (mul (sub r l) 0.5)))
+      (mul-add s m (add m l)))))
+
+(define deep-sea
+  (let* ((amp 1)
+         (pan 0)
+         (variation 0.9)
+         (n (rand 7 46))
+         (dt1 (add 25 (rand -1.7 1.7)))
+         (dt2 (mul3 (add dt1 (lf-noise2 kr 2)) variation 0.001))
+         (freq (add 901 (rand 0 65)))
+         (t (mul (impulse ar (recip dt2) 0) 100))
+         (count (pulse-count t 0))
+         (ml (lt count n))
+         (u1 (mul (bpf (mul ml t) freq 1) 0.1))
+         (freq2 (mul freq
+                     (add (u:mod count (range (lf-noise1 kr 1) 2 20)) 1)))
+         (u2 (mul (bpf u1 freq2 1) 0.2)))
+    (mrg2 (pan2 u2 pan (mul amp 10))
+          (detect-silence u2 0.0001 0.2 remove-synth))))
+
+(audition (out 0 deep-sea))

rsc3/examples/graph/demanding-studies.scm

@@ -0,0 +1,17 @@
+;; demanding studies (jmcc)
+
+(import (rnrs) (rsc3))
+
+(define demanding-studies
+  (let* ((s1 (drand dinf (mce4 72 75 79 82)))
+         (s2 (drand 1 (mce3 82 84 86)))
+         (s3 (dseq dinf (mce4 72 75 79 s2)))
+         (x (mouse-x kr 5 6 0 0.2))
+         (tr (impulse kr x 0))
+         (f (demand tr 0 (mce2 (midi-cps (sub s1 12)) (midi-cps s3))))
+         (o1 (sin-osc ar (add f (mce2 0 0.7)) 0))
+         (o2 (mul (saw ar (add f (mce2 0 0.7))) 0.3))
+         (o3 (cubed (distort (u:log (distort (add o1 o2)))))))
+    (mul o3 0.1)))
+
+(audition (out 0 demanding-studies))

rsc3/examples/graph/dial-history.scm

@@ -0,0 +1,42 @@
+;; dial history (jrhb)
+
+(import (rnrs) (rsc3) (rhs))
+
+(define range
+  (lambda (s l r)
+    (lin-lin s 0 1 l r)))
+
+(define mce-r
+  (lambda (l)
+    (make-mce (map make-mce l))))
+
+(define mce-mrg
+  (lambda (u)
+    (mrg-n (mce-channels u))))
+
+(define dial-history
+  (let* ((mfv (transpose (list (list 697 770 852 941)
+                               (list 1209 1336 1477 1633))))
+         (numbers (transpose (list (list 3 0 0 0 1 1 1 2 2 2)
+                                   (list 1 0 1 2 0 1 2 0 1 2))))
+         (n (dwhite dinf 7 12))
+         (w (dwhite 1 2 7))
+         (b (dbrown n 0.1 0.2 0.01))
+         (rt (dseq dinf (mce2 w b)))
+         (q (dseq dinf (make-mce (enum-from-to 1 10))))
+         (g1 (gray-noise ar))
+         (g2 (gray-noise ar))
+         (d (lfd-noise3 kr 0.5))
+         (tr (trig (t-duty kr rt 0 do-nothing q 1) 0.09))
+         (pat (latch tr tr))
+         (x (mouse-x* kr 0 1 linear 0.2))
+         (h (hasher (mul pat x)))
+         (which (trunc (range h 0 (length numbers)) 1))
+         (both (select which (mce-r numbers)))
+         (dial (select both (mce-r mfv)))
+         (sig (mul3 (sin-osc ar dial 0) 0.05 tr))
+         (dsig (delay-n sig 0.2 (range d 0 0.01)))
+         (hiss (mul-add g1 0.01 (hpf (mul g2 0.02) 3000))))
+    (add dsig hiss)))
+
+(audition (out 0 dial-history))

rsc3/examples/graph/diffraction.scm

@@ -0,0 +1,30 @@
+;; diffraction (rd)
+
+(import (rnrs) (rsc3))
+
+(define mk-p
+  (lambda ()
+    (let* ((x (mouse-x kr 0.001 0.02 1 0.1))
+           (y (mouse-y kr 120 400 1 0.1))
+           (f (mul (lf-noise0 kr 4) (mce2 32 64)))
+           (w (mul (lf-noise0 kr 32) x)))
+      (mul (resonz (pulse ar f w)
+                   (add y (mul (lf-noise0 kr 2) 0.1))
+                   (mul-add (lf-noise0 kr 6) 0.4 0.8))
+           0.5))))
+
+(define diffraction
+  (let* ((q (comb-n (mk-p)
+                    0.2
+                    (mul-add (lf-noise0 kr 128) 0.1 0.1)
+                    3))
+         (r (let* ((x (mouse-x kr 0.75 1.25 1 0.1))
+                   (y (mouse-y kr 0.25 1 1 0.1))
+                   (f (lambda (_)
+                        (mul (sin-osc ar (mul x (rand 50 59)) 0)
+                             (mul y (rand 0.04 0.16))))))
+              (mce2 (mix-fill 16 f)
+                    (mix-fill 12 f)))))
+    (add3 (mk-p) q r)))
+
+(audition (out 0 diffraction))

rsc3/examples/graph/discretion.scm

@@ -0,0 +1,20 @@
+;; discretion (rd)
+
+(import (rnrs) (rsc3) (rhs))
+
+(define discretion
+  (let* ((mkls (lambda (bp t)
+                 (let ((c (replicate (/ (length bp) 2) 1)))
+                   (env-gen kr 1 1 0 1 remove-synth (env-bp bp t 1 c)))))
+         (part (lambda (_)
+                 (let* ((f1 (clone 2 (rand 50 55)))
+                        (f2 (clone 2 (rand 50 65)))
+                        (f3 (clone 2 (rand 50 55)))
+                        (a (clone 2 (rand 0.01 0.035)))
+                        (t 21)
+                        (f (mkls (list 0.0 f1 0.33 f2 1.0 f3) t))
+                        (g (mkls (list 0 0 0.33 a 1 0) t)))
+                   (mul (saw ar f) g)))))
+    (mix-fill 8 part)))
+
+(audition (out 0 discretion))

rsc3/examples/graph/drummer.scm

@@ -0,0 +1,16 @@
+;; drummer (thor magnusson)
+
+(import (rnrs) (rsc3))
+
+(define drummer
+  (let* ((tempo 4)
+         (n (white-noise ar))
+         (tr (impulse ar tempo 0))
+         (tr-2 (pulse-divider tr 4 2))
+         (tr-4 (pulse-divider tr 4 0))
+         (snare (mul n (decay2 tr-2 0.005 0.5)))
+         (bass (mul (sin-osc ar 60 0) (decay2 tr-4 0.005 0.5)))
+         (hihat (mul (hpf n 10000) (decay2 tr 0.005 0.5))))
+    (pan2 (add3 snare bass hihat) 0 0.4)))
+
+(audition (out 0 drummer))

rsc3/examples/graph/e-lamell.scm

@@ -0,0 +1,52 @@
+;; e-lamell (rd)
+
+(import (rnrs) (sosc) (rsc3))
+
+(define e-lamell
+  (letc ((f 440) (n 12) (d 0.1) (p 0) (a 1.0))
+    (let* ((h (line ar n (t-choose 1 (mce2 1 32)) d do-nothing))
+           (s (blip ar f h))
+           (e-d (env-perc 0.005 d 1 (list -4 -4)))
+           (e (env-gen ar 1 a 0 1 remove-synth e-d)))
+      (out 0 (pan2 s p e)))))
+
+(define r-note
+  (lambda (o p)
+    (+ (* (choose o) 12)
+       (choose p))))
+
+(define l-sel
+  (lambda ()
+    (r-note (list 2 3)
+            (list 0))))
+
+(define h-sel
+  (lambda ()
+    (r-note (list 2 3 4)
+            (list 0))))
+
+(define pattern
+  (lambda (fd)
+    (send
+     fd
+     (bundle
+      -1
+      (list (s-new "blip" -1 add-to-tail 1
+                   (list "f" (midi-cps (l-sel))
+                         "n" (i-random 2 36)
+                         "d" (exp-random 0.01 0.4)
+                         "a" (random 0 0.75)
+                         "p" (random -1 1)))
+            (s-new "blip" -1 add-to-tail 1
+                   (list "f" (midi-cps (h-sel))
+                         "n" (i-random 2 36)
+                         "d" (exp-random 0.01 0.4)
+                         "a" (choose (list 0 0.25 0.5 1.0))
+                         "p" (random -1 1))))))
+    (thread-sleep 0.1)
+    (pattern fd)))
+
+(with-sc3
+ (lambda (fd)
+   (send-synth fd "blip" e-lamell)
+   (pattern fd)))

rsc3/examples/graph/eggcrate.scm

@@ -0,0 +1,20 @@
+;; eggcrate (rd)
+
+(import (rnrs) (rsc3))
+
+(define eggcrate-f
+  (lambda (u v)
+    (mul (u:cos (mul u pi)) (u:sin (mul v pi)))))
+
+(define eggcrate
+  (let* ((p (make-mce (list 64 72 96 128 256 6400 7200 8400 9600)))
+         (x (brown-noise kr))
+         (y (brown-noise kr))
+         (t (dust kr 2.4))
+         (f0 (t-choose t p))
+         (f1 (t-choose t p))
+         (f (lin-lin (eggcrate-f x y) -1 1 f0 f1))
+         (a (lin-lin x -1 1 0 0.1)))
+    (pan2 (mix (sin-osc ar f 0)) y a)))
+
+(audition (out 0 eggcrate))

rsc3/examples/graph/f-lets.scm

@@ -0,0 +1,29 @@
+;; f-lets (rd)
+
+(import (rnrs) (rsc3) (rhs))
+
+(define f
+  (lambda (t g j n f)
+    (let ((pd (pulse-divider t j 0)))
+      (mul (formlet pd
+                    (mul f (ti-rand (mce2 2 1) n pd))
+                    (t-rand 0.01 0.04 pd)
+                    (t-rand 0.05 0.10 pd))
+           g))))
+
+(define n
+  (lambda (t)
+    (list (f t 0.15 2 9 (mce2 200 400))
+          (f t 0.25 2 9 (mce2 (add 200 (t-rand 0 1 t))
+                              (add 400 (t-rand 0 1 t))))
+          (f t 0.05 4 5 (mce2 25 50))
+          (f t 0.15 4 5 (mce2 (add 25 (t-rand 0 1 t))
+                              (add 50 (t-rand 0 1 t))))
+          (mul (f t 0.5 1 16 (mce2 300 600))
+               (latch (coin-gate 0.2 t) t)))))
+
+(define f-lets
+  (mul (mul-add (lf-noise0 kr 2) 0.25 0.25)
+       (foldl1 add (n (impulse ar 24 0)))))
+
+(audition (out 0 f-lets))

rsc3/examples/graph/feedr.scm

@@ -0,0 +1,39 @@
+;; feedr (rd)
+;; warning: input/output feedback loop
+
+(import (sosc) (rsc3) (rhs))
+
+(with-sc3
+ (lambda (fd)
+   (let* ((delay-wr
+           (lambda (b in)
+             (record-buf b 0 1 0 1 1 0 in)))
+          (tap
+           (lambda (nc b delay-time)
+             (play-buf nc b 1 0 (mul delay-time (neg sample-rate)) 1)))
+          (dl 6)
+          (ff (* dl (server-sample-rate-actual fd)))
+          (nc 2))
+     (send fd (b-alloc 10 ff nc))
+     (audition
+      (let* ((n 18)
+             (t (replicate-m n (rand 0.0 dl)))
+             (g (replicate-m n (rand 0.4 1.0)))
+             (f (replicate-m n (rand 0.9 0.95)))
+             (d (zip-with
+                 (lambda (t g)
+                   (mul (tap nc 10 t) g))
+                 t g))
+             (x (mouse-x* kr 0.02 1.0 1 0.1)))
+        (make-mrg
+         (out 0 (clip2 (leak-dc (hpf (foldl1 add d) 20) 0.995) 1))
+         (delay-wr 10 (foldl add
+                             (in nc ar num-output-buses)
+                             (map
+                              (lambda (e)
+                                (mul e x))
+                              (zip-with mul d f))))))))))
+
+(with-sc3
+ (lambda (fd)
+   (send fd (b-zero 10))))

rsc3/examples/graph/fm-iter.scm

@@ -0,0 +1,20 @@
+;; fm-iter (rd)
+
+(import (rnrs) (rsc3))
+
+(define fm-iter
+  (let* ((t0 (impulse ar (recip 0.30) 0))
+         (t1 (t-delay t0 0.15))
+         (t (mce2 t0 t1))
+         (k (t-rand 56 57 t))
+         (i (t-rand 40 480 t))
+         (j (t-rand -1 1 t))
+         (c (midi-cps k))
+         (m (midi-cps (add3 k 1 j)))
+         (s (env-perc 0.01 0.9 1 (list -4 -4)))
+         (e (env-gen ar t 0.1 0 1 remove-synth s))
+         (f (mul-add (sin-osc ar c 0) i m)))
+    (mul (sin-osc ar f 0) e)))
+
+(audition (out 0 fm-iter))
+

rsc3/examples/graph/fm-kltr.scm

@@ -0,0 +1,93 @@
+;; fm-kltr (rd)
+
+(import (rnrs) (sosc) (rsc3) (rhs))
+
+(define fm-instr
+  (letc ((bus 0)
+         (trig 0)
+         (amp 0.1)
+         (dur 0.1)
+         (freq 400)
+         (index 40)
+         (pan 0)
+         (freq2 600))
+    (let* ((p (env-perc 0.01 dur 1 (replicate 2 -4)))
+           (e (env-gen ar 1 amp 0 1 remove-synth p))
+           (x (x-line kr freq (mul freq (random 0.975 1.025)) dur 0))
+           (o (sin-osc ar x 0))
+           (l (line kr index (mul freq (random 0.5 1.5)) dur 0))
+           (x2 (x-line kr freq2 (mul freq2 (random 0.975 1.025)) dur 0))
+           (m (mul-add o l x2)))
+      (out bus (pan2 (sin-osc ar m 0)
+                     (line kr pan (mul pan (random 0.75 1.25)) dur 0)
+                     e)))))
+
+(define fm
+  (lambda (fd f ff a d i)
+    (send
+     fd
+     (s-new "fm" -1 1 1
+            (list "freq" (midi-cps f)
+                  "freq2" (+ (midi-cps ff) (random -1 1))
+                  "amp" a
+                  "dur" d
+                  "index" i)))))
+
+(define r-note
+  (lambda (o p)
+    (+ (* (choose o) 12)
+       (choose p))))
+
+(define low-f
+  (lambda (fd)
+    (fm
+     fd
+     (r-note (list 3 5)
+             (list 0 3 7 8))
+     (random 36 72)
+     (random 0.0 0.2)
+     (random 1.2 7.2)
+     (random 240 1480))))
+
+(define high-f
+  (lambda (fd)
+    (fm
+     fd
+     (r-note (list 7 10)
+             (list 0 2 5 10))
+     (random 84 120)
+     (random 0.1 0.6)
+     (random 0.2 1.2)
+     (random 240 1480))))
+
+(define cmp-f
+  (lambda (a b)
+    (compare (car a) (car b))))
+
+(define low-t
+  (integrate
+   (cons 0
+         (replicate-m
+          36
+          (choose (list 0.25 0.5 0.75 1.0 1.5))))))
+
+(define high-t
+  (integrate
+   (cons 0
+         (replicate-m
+          36
+          (choose (list 0.05 0.15 0.25 0.5 0.75))))))
+
+(define fm-kltr
+  (lambda (fd)
+    (send-synth fd "fm" fm-instr)
+    (map1
+     (lambda (x)
+       ((cadr x) fd)
+       (thread-sleep (car x)))
+     (sort-by
+      cmp-f
+      (append2 (map1 (lambda (x) (list x low-f)) low-t)
+               (map1 (lambda (x) (list x high-f)) high-t))))))
+
+(with-sc3 fm-kltr)

rsc3/examples/graph/forest-sounds.scm

@@ -0,0 +1,16 @@
+;; forest sounds (paul jones)
+
+(import (rnrs) (rsc3))
+
+(define insects
+  (lambda (_)
+    (let* ((n1 (brown-noise ar))
+           (n2 (lf-noise2 kr 50))
+           (f (mul-add n2 50 50))
+           (o (mul-add (sin-osc kr f 0) 100 2000)))
+      (mul (bpf n1 o 0.001) 10))))
+
+(define forest-sounds
+  (mce-fill 2 insects))
+
+(audition (out 0 forest-sounds))

rsc3/examples/graph/fwalk.scm

@@ -0,0 +1,32 @@
+;; fwalk (rd)
+
+(import (rnrs) (sosc) (rsc3) (rhs))
+
+(define fwalk-i
+  (lambda (r)
+    (let* ((t (dust kr 3))
+           (r1 (ti-rand 0 6 t))
+           (r2 (t-rand -0.0001 0.0001 t))
+           (f (buf-rd-l 1 kr (mce2 0 1) r1 no-loop))
+           (o1 (blip ar (midi-cps (add r f)) 12))
+           (o2 (blip ar (midi-cps (add3 r f r2)) 12)))
+      (mul3 (add o1 o2) (decay2 t 0.3 1.2) 0.1))))
+
+(define fwalk
+  (let* ((n (list 40.0 47.0 42.0 40.0 50.0
+                  43.0 35.0 43.0 40.0 47.0
+                  45.0 35.0 43.0 42.0 59.0
+                  48.0 40.0 47.0 52.0 45.0))
+         (m (list 40.0 40.0 42.0 47.0 50.0
+                  35.0 43.0 43.0 40.0 45.0
+                  42.0 35.0 48.0 47.0 43.0
+                  40.0 59.0 45.0 47.0 52.0))
+         (a (map (lambda (b) (b-alloc b 20 1)) (list 0 1)))
+         (s (zip-with (lambda (b d) (b-setn1 b 0 d)) (list 0 1) (list n m))))
+    (lambda (fd)
+      (for-each (lambda (m) (async fd m)) a)
+      (for-each (lambda (m) (send fd m)) s)
+      (play fd (out 0 (add (fwalk-i 24) (fwalk-i 36)))))))
+
+(with-sc3 fwalk)
+

rsc3/examples/graph/h-chatter.scm

@@ -0,0 +1,33 @@
+;; h-chatter (rd)
+
+(import (rnrs) (rsc3))
+
+(define wrp
+  (lambda (i l r)
+    (let ((m (fdiv (sub r l) 2)))
+      (mul-add i m (add l m)))))
+
+(define h0
+  (let* ((n (mul-add (lf-noise0 kr 1) 5 5))
+         (a (mul-add (lf-noise2 kr n) 0.20 1.20))
+         (b (mul-add (lf-noise2 kr n) 0.15 0.15))
+         (f 40)
+         (h (henon-n ar (mce2 f (mul f 0.5)) a b 0 0)))
+    (mul (saw ar (mul-add h 3200 1600)) 0.35)))
+
+(define h1
+  (let* ((n0 (lf-noise0 ar 32))
+         (n1 (lf-noise0 ar 2))
+         (a (mouse-x* kr 1.2 1.4 0 0.1))
+         (b (mouse-y* kr 0.2 0.3 0 0.1))
+         (h (wrp n0 1 32))
+         (p (wrp n1 2400 3200))
+         (l (wrp n1 -0.75 0.75))
+         (g (wrp n1 0.55 0.85))
+         (f 40)
+         (o (blip ar (wrp (henon-n ar f a b 0 0) p (mul p 2)) h)))
+    (mul (pan2 o l g) 0.35)))
+
+(define h-chatter (add h0 h1))
+
+(audition (out 0 h-chatter))

rsc3/examples/graph/half-life.scm

@@ -0,0 +1,12 @@
+;; half-life (jrhb)
+
+(import (rnrs) (rsc3))
+
+(define half-life
+  (let* ((t-half 3.92)
+         (n-atoms 1e+5)
+         (n (u:max 0 (sub n-atoms (pulse-count (local-in 2 ar) 0))))
+         (activity (dust ar (mul n (fdiv (log 2) t-half)))))
+    (mrg2 activity (local-out activity))))
+
+(audition (out 0 half-life))

rsc3/examples/graph/harmonic-swimming.scm

@@ -0,0 +1,19 @@
+;; harmonic swimming (jmcc)
+
+(import (rnrs) (rsc3))
+
+(define harmonic-swimming
+  (let* ((a 0.02)
+         (f 50)
+         (p 20)
+         (z 0)
+         (l (line kr 0 (neg a) 60 0))
+         (o (lambda (h)
+              (let* ((r (clone 2 (rand 2 8)))
+                     (n (lf-noise1 kr r))
+                     (e (u:max 0 (mul-add n a l))))
+                (mul (f-sin-osc ar (* f (+ h 1)) 0) e)))))
+    (mix-fill p o)))
+
+(audition (out 0 harmonic-swimming))
+

rsc3/examples/graph/harmonic-tumbling.scm

@@ -0,0 +1,16 @@
+;; harmonic tumbling (jmcc)
+
+(import (rnrs) (rsc3))
+
+(define harmonic-tumbling
+  (let* ((f 80)
+         (p 10)
+         (t (x-line kr (mce2 10 11) 0.1 60 0))
+         (o (lambda (h)
+              (let* ((n (dust kr t))
+                     (r (rand 0.25 0.5))
+                     (e (decay2 (mul n 0.02) 0.005 r)))
+                (mul (f-sin-osc ar (* f (+ h 1)) 0) e)))))
+    (mix-fill p o)))
+
+(audition (out 0 harmonic-tumbling))

rsc3/examples/graph/hh-808.scm

@@ -0,0 +1,42 @@
+;; hh-808 (ryan at wabdo.com)
+
+(import (rnrs) (rhs) (rsc3))
+
+(define hh-808
+  (let* ((time 250)
+         (freqs (list 205.35 304.41 369.64 522.71 540.54 812.21))
+         (pulse-env
+          (let ((e (env (list 1.0 0.6) (list time) (list -0.5) 0 0)))
+            (env-gen ar 1 1 0 (/ 1 1000) do-nothing e)))
+         (s (let ((f (make-mce (map (lambda (x) (mul x 4.09)) freqs))))
+              (mix (lf-pulse ar f 0 0.5))))
+         (f (list
+             (lambda (a)
+               (add3 (mul (eq a 6.0) 0.6)
+                     (mul (eq a 2.0) 0.2)
+                     (mul (eq a 1.0) 0.9)))
+             (lambda (a)
+               (add (mul a pulse-env)
+                    (mul (mix (lf-pulse ar (make-mce freqs) 0 0.55)) 0.9)))
+             (lambda (a)
+               (rlpf a 7000 0.6))
+             (lambda (a)
+               (rhpf a 6800 1.5))
+             (lambda (a)
+               (rhpf a 6800 1.5))
+             (lambda (a)
+               (rhpf a 1200 1.5))
+             (lambda (a)
+               (add a (free-verb a 0.33 0.5 0.5)))
+             (lambda (a)
+               (let* ((c (list 0 -0.5 0 -50))
+                      (e (env (list 0 1 0.4 0 0)
+                              (list 2 time 50 500)
+                              c 0 0)))
+                 (mul a (env-gen ar 1 1 0 (/ 1 1000) remove-synth e))))
+             (lambda (a)
+               (mce2 a (delay-n a 0.005 0.005)))))
+         (>>> (flip compose)))
+    (mul ((foldl1 >>> f) s) 2)))
+
+(audition (out 0 hh-808))

rsc3/examples/graph/implosion.scm

@@ -0,0 +1,29 @@
+;; implosion (rd)
+
+(import (rnrs) (rsc3) (rhs))
+
+(define implosion
+  (let* ((mkls
+          (lambda (bp t)
+            (env-gen kr 1 1 0 1 remove-synth (env-bp-linear bp t 1))))
+         (mkrmp
+          (lambda (l r t)
+            (mkls (list 0 l 1 r) t)))
+         (wrp
+          (lambda (i l r)
+            (let ((m (fdiv (sub r l) 2)))
+              (mul-add i m (add l m)))))
+         (pmr/n
+          (lambda (rt l0 l1 r0 r1 d)
+            (let ((le (mkrmp l0 r0 d))
+                  (re (mkrmp l1 r1 d)))
+              (wrp (white-noise rt) le re))))
+         (d (rand 7.5 13.5))
+         (f0 (rand 10990 16220))
+         (f1 (rand  9440 19550))
+         (f (pmr/n ar 440 f0 f1 f1 d))
+         (l (pmr/n kr (rand -1 0) (rand 0 1) 0 0 d))
+         (a (pmr/n kr 0.1 0.6 0 0 d)))
+    (pan2 (saw ar f) l a)))
+
+(audition (out 0 implosion))

rsc3/examples/graph/k-ppr.scm

@@ -0,0 +1,28 @@
+;; k-ppr (rd)
+
+(import (rnrs) (rsc3))
+
+(define wrp
+  (lambda (i l r)
+    (lin-lin i -1 1 l r)))
+
+(define stream
+  (lambda (y ti t lf rf ld rd g)
+    (lambda (_)
+      (let* ((r1 (rand 9 18))
+             (t* (pulse-divider t r1 0))
+             (r2 (t-rand lf (wrp ti lf rf) t*))
+             (r3 (t-rand ld rd t*)))
+        (mul (ringz (decay2 t* 0.01 0.5) r2 (mul r3 y)) g)))))
+
+(define k-ppr
+  (let* ((x (mouse-x kr 0.05 0.35 0 0.1))
+         (y (mouse-y kr 0.15 0.75 0 0.1))
+         (ti (lf-tri kr x 0))
+         (tf (wrp ti 100 200))
+         (t (impulse ar tf 0))
+         (s1 (stream y ti t 3140 6240 0.050 0.005 0.15))
+         (s2 (stream y ti t 0400 9000 0.005 0.005 0.15)))
+    (add (mce-fill 2 s1) (mce-fill 2 s2))))
+
+(audition (out 0 k-ppr))

rsc3/examples/graph/karplus-strong.scm

@@ -0,0 +1,64 @@
+;; karplus strong (alex mclean)
+
+(import (rnrs) (sosc) (rsc3))
+
+(define a-a
+  (list "a-a"
+        (list 800 1150 2800 3500 4950)
+        (list 0 -4   -20 -36  -60)
+        (list 80 90  120 130 140)))
+
+(define a-u
+  (list "a-u"
+        (list 325 700 2530 3500 4950)
+        (list 0 -12  -30 -40 -64)
+        (list 50 60  170 180 200)))
+
+(define cs
+  (lambda (l)
+    (append (list-ref l 1)
+            (list-ref l 2)
+            (list-ref l 3))))
+
+(define vf
+  (lambda (i s)
+    (let ((f (in 5 kr i))
+          (a (in 5 kr (add i 5)))
+          (b (in 5 kr (add i 10))))
+      (mix (mul (resonz s f (fdiv b f)) (db-amp a))))))
+
+(define ugen-if
+  (lambda (a b c)
+    (add (mul a b) (mul (sub 1 a) c))))
+
+(define prob-switch
+  (lambda (n0 i prob)
+    (ugen-if (gt n0 prob) i (neg i))))
+
+(define ks
+  (lambda (n d)
+    (let* ((x (mouse-x kr 0 0.01 linear 0.1)) ;; {- delay -}
+           (y (mouse-y kr 0.85 1 linear 0.1)) ;; {- blend / gain -}
+           (n0 (add (fdiv n 2) 0.5))
+           (lagged-delay (lag x 0.01))
+           (o (sin-osc ar 200 0))
+           (a0 (mul (decay d 0.025) o))
+           (a1 (add (local-in 1 ar) (mul a0 (sub y 0.25))))
+           (a2 (delay-n a1 0.01 lagged-delay))
+           (a3 (delay1 a2))
+           (a4 (fdiv (add a2 a3) 2.0))
+           (a5 (prob-switch n0 a4 y))
+           (a6 (vf (mul (toggle-ff d) 15) a5))
+           (a7 (mul a6 1.5)))
+      (mrg2 (local-out (mul a5 0.99))
+            (out 0 (mce2 a7 a7))))))
+
+(define karplus-strong
+  (lambda (fd)
+    (send fd (c-setn1 0 (cs a-a)))
+    (send fd (c-setn1 15 (cs a-u)))
+    (let ((n (white-noise ar))
+          (d (dust kr 4)))
+      (play fd (ks n d)))))
+
+(with-sc3 karplus-strong)

rsc3/examples/graph/klink.scm

@@ -0,0 +1,18 @@
+;; klink (rd)
+
+(import (rnrs) (rsc3))
+
+(define klink
+  (let* ((n1 (lf-noise0 kr (mce2 0.5 1.5)))
+         (o (sin-osc kr n1 0))
+         (f (mce2 2 3))
+         (a (mul (u:abs (slope o)) f))
+         (t (impulse ar a 0))
+         (i (decay2 t 0.01 0.1))
+         (x (mouse-x kr 960 3620 1 0.1))
+         (y (mouse-y kr 0.5 2.0 0 0.2))
+         (n2 (t-rand x 3940 t))
+         (n3 (t-rand 0.005 0.275 t)))
+    (ringz i n2 (mul n3 y))))
+
+(audition (out 0 klink))

rsc3/examples/graph/lf-pulses.scm

@@ -0,0 +1,13 @@
+;; lf pulses (rd)
+
+(import (rnrs) (rsc3))
+
+(define lf-pulses
+  (let* ((n0 (lf-noise0 ar (mce2 20 40)))
+         (n1 (lf-noise0 ar (mce2 5 10)))
+         (x (mouse-x kr 0.012 0.19 1 0.1))
+         (f (formlet (blip ar 10 12) (mul-add n0 43 700) 0.005 x))
+         (o (mul (sin-osc ar 40 0) n1)))
+    (clip2 (add f o) 1)))
+
+(audition (out 0 lf-pulses))

rsc3/examples/graph/lfo-modulation.scm

@@ -0,0 +1,11 @@
+;; lfo modulation (jmcc)
+
+(import (rnrs) (rsc3))
+
+(define lfo-modulation
+  (let* ((o (mul-add (f-sin-osc kr 0.05 0) 80 160))
+         (p (mul-add (f-sin-osc kr (mce2 0.6 0.7) 0) 3600 4000))
+         (s (rlpf (mul (lf-pulse ar o 0 0.4) 0.05) p 0.2)))
+    (comb-l s 0.3 (mce2 0.2 0.25) 2)))
+
+(audition (out 0 lfo-modulation))

rsc3/examples/graph/lg-timed.scm

@@ -0,0 +1,25 @@
+;; lg-timed (rd)
+
+(import (rnrs) (rsc3))
+
+(define timed
+  (lambda (r y p)
+    (let* ((d0 (dser r p))
+           (d1 (dcons 0 d0))
+           (d2 (dser r y))
+           (t (t-duty ar d1 0 remove-synth d2 1)))
+      (latch t t))))
+
+(define lg
+  (lambda (u) (lag u 0.03)))
+
+(define lg-timed
+  (let* ((n (make-mce (list 52 76 66 67 68 69)))
+         (a (make-mce (list 0.35 0.15 0.04 0.05 0.16 0.07)))
+         (d (make-mce (list 0.1 0.5 0.09 0.08 0.07 0.3)))
+         (x (mouse-x kr 0.5 1.25 linear 0.2))
+         (tn (lg (timed dinf n (mul d x))))
+         (ta (lg (timed dinf a (mul d x)))))
+    (mul (sin-osc ar (midi-cps tn) 0) ta)))
+
+(audition (out 0 lg-timed))

rsc3/examples/graph/lin-sosc.scm

@@ -0,0 +1,99 @@
+;; lin-sosc (rd)
+
+(import (rnrs) (sosc) (rsc3) (rhs))
+
+(define two-pi (* 2.0 pi))
+
+(define mk-line
+  (lambda (n l r)
+    (enum-from-then-to l (+ l (/ (- r l) n)) r)))
+
+(define geom
+  (lambda (n i s)
+    (if (= n 0)
+        nil
+        (cons i (geom (- n 1) (* i s) s)))))
+
+(define mk-xline
+  (lambda (n l r)
+    (geom n l (expt (/ r l) (/ 1 n)))))
+
+(define rng
+  (lambda (l r)
+    (let ((m (- l r)))
+      (lambda (e)
+        (+ l (* e m))))))
+
+(define s-rng
+  (lambda (l r)
+    (let* ((m (/ (- l r) 2))
+           (n (+ m l)))
+      (lambda (e)
+        (+ n (* e m))))))
+
+(define cmp
+  (lambda (f g)
+    (lambda (n)
+      (f (g n)))))
+
+(define tbl-m
+  (lambda (b)
+    (play-buf 1 b (mul (mouse-x kr 0.001 1.0 0 0.1)
+                       (buf-rate-scale kr b)) 0 0 1)))
+
+(define tbl-c
+  (lambda (b c)
+    (play-buf 1 b (mul (in 1 kr c) (buf-rate-scale kr b)) 0 0 1)))
+
+(define settr
+  (lambda (fd n)
+    (let* ((freq
+            (list
+             (mk-line n 440.0 444.0)
+             (mk-line n 40.0 16000.0)
+             (mk-xline n 40.0 16000.0)
+             (map (cmp (s-rng 20 21000) sin) (mk-line n 0 two-pi))
+             (map (cmp (s-rng 20 12000) cos) (mk-line n 0 two-pi))
+             (map (cmp (s-rng 20 22000) tan) (mk-line n -0.76 0.76))
+             (map (cmp (s-rng 20 90) tan) (mk-line n -0.76 0.76))))
+           (ampl
+            (list
+             (mk-line n 0.1 1.0)
+             (mk-line n 1.0 0.1)
+             (mk-line n 0.5 0.01)
+             (mk-line n 0.01 0.5)
+             (mk-xline n 1.0 0.1)
+             (mk-xline n 0.1 1.0)
+             (map sin (mk-line n 0.0 two-pi))
+             (map cos (mk-line n 0.0 two-pi))
+             (map (lambda (n) (* n 0.001))
+                  (map tan (mk-line n 0.0 two-pi)))))
+           (f (choose freq))
+           (a (choose ampl)))
+      (send fd (b-setn1 0 0 f))
+      (send fd (b-setn1 1 0 a))
+      (send fd (c-set1 0 (choose (list 0.005 0.0075 0.01 0.025 0.05 0.075
+                                       0.1 0.25 0.5 0.75
+                                       0.8 0.85 1.0 1.005))))
+      (choose (list 0.01 0.05 0.1 0.15 0.25 0.5 0.75)))))
+
+(define lsi
+  (clip2 (pan2 (mul (sin-osc ar (tbl-m 0) 0)
+                    (tbl-m 1))
+               (tbl-c 1 0)
+               0.025)
+         0.25))
+
+(define lin-sosc
+  (lambda (n)
+    (lambda (fd)
+      (async fd (b-alloc 0 n 1))
+      (async fd (b-alloc 1 n 1))
+      (play fd (out 0 lsi))
+      (letrec ((pattern
+                (lambda (fd)
+                  (thread-sleep (settr fd n))
+                  (pattern fd))))
+        (pattern fd)))))
+
+(with-sc3 (lin-sosc 1024))

rsc3/examples/graph/lz-bf.scm

@@ -0,0 +1,27 @@
+;; lz-bf (rd)
+
+(import (rnrs) (rsc3))
+
+(define lz-bf-i
+  (let* ((x (mouse-x kr 1 12 0 0.1))
+         (l (lorenz-l ar
+                      sample-rate
+                      (mul-add (lf-noise0 kr x) 2 12)
+                      (mul-add (lf-noise0 kr x) 20 38)
+                      (mul-add (lf-noise0 kr x) 1.5 3)
+                      (mce2 0.025 0.05)
+                      0.1 0.0 0.0))
+         (p (phasor ar
+                    0
+                    (mul3 l 24 (buf-rate-scale kr 0))
+                    0
+                    (buf-frames kr 0) 0)))
+    (buf-rd 1 ar 0 p 0 2)))
+
+(define lz-bf
+   (lambda (fn)
+     (lambda (fd)
+       (async fd (b-alloc-read 0 fn 0 0))
+       (play fd (out 0 lz-bf-i)))))
+
+(with-sc3 (lz-bf "/home/rohan/data/audio/pf-c5.aif"))

rsc3/examples/graph/modal-space.scm

@@ -0,0 +1,24 @@
+;; modal space (jmcc)
+
+(import (rnrs) (sosc) (rsc3))
+
+(define modal-space-i
+  (let* ((x (mouse-x kr 0 15 0 0.1))
+         (k (degree-to-key 0 x 12))
+         (c (lambda (n r)
+              (let* ((o (mul (sin-osc ar (midi-cps (add3 r k n)) 0) 0.1))
+                     (t (lf-pulse ar (midi-cps (mce2 48 55)) 0.15 0.5))
+                     (f (midi-cps (mul-add (sin-osc kr 0.1 0) 10 r)))
+                     (d (mul (rlpf t f 0.1) 0.1))
+                     (m (add o d)))
+                (add (comb-n m 0.31 0.31 2) m))))
+         (n (mul (lf-noise1 kr (mce2 3 3.05)) 0.04)))
+    (mul (add (c n 48) (c n 72)) 0.25)))
+
+(define modal-space
+  (lambda (fd)
+    (async fd (b-alloc 0 7 1))
+    (send fd (b-setn1 0 0 (list 0 2 3.2 5 7 9 10)))
+    (play fd (out 0 modal-space-i))))
+
+(with-sc3 modal-space)

rsc3/examples/graph/moto-rev.scm

@@ -0,0 +1,10 @@
+;; moto rev (jmcc)
+
+(import (rnrs) (rsc3))
+
+(define moto-rev
+  (let* ((f (mul-add (sin-osc kr 0.2 0) 10 21))
+         (s (lf-pulse ar f (mce2 0 0.1) 0.1)))
+    (clip2 (rlpf s 100 0.1) 0.4)))
+
+(audition (out 0 moto-rev))

rsc3/examples/graph/mouse-clatter.scm

@@ -0,0 +1,23 @@
+;; mouse clatter (rd)
+
+(import (rnrs) (rsc3))
+
+(define mouse-clatter
+  (let* ((x (mouse-x kr 100 12000 0 0.1))
+         (y (mouse-y kr 0.01 0.15 0 0.1))
+         (n1 (lf-noise0 kr (mce2 3 3.25)))
+         (t (impulse kr (mul-add n1 16 18) 0))
+         (n2 (t-rand 0.005 y t))
+         (n3 (white-noise ar))
+         (n4 (t-rand 10 x t))
+         (n5 (t-rand 0.0 1.0 t))
+         (n6 (t-exp-rand 0.15 1.0 t))
+         (e (decay2 t 0.01 n2))
+         (o (bpf (mul n3 e) n4 n5))
+         (n7 (pv-rand-comb (fft* 10 o) n6 t)))
+    (add (mul o 0.05) (ifft* n7))))
+
+(with-sc3
+ (lambda (fd)
+   (async fd (b-alloc 10 2048 1))
+   (play fd (out 0 mouse-clatter))))

rsc3/examples/graph/nharm.scm

@@ -0,0 +1,31 @@
+;; nharm (rd)
+
+(import (rnrs) (rsc3) (rhs))
+
+(define nharm
+  (lambda (n f)
+    (if (<= n 0)
+        (list)
+        (cons f (nharm (- n 1) (add f f))))))
+
+(define klg
+  (lambda (m u)
+    (let* ((n (i-random 4 u))
+           (d (i-random 9 12))
+           (a 0.5)
+           (e (env-gen kr 1 0.9 0 1 remove-synth (env-sine d a)))
+           (s (klang-data (nharm n (midi-cps (random m (+ m 2))))
+                          (replicate-m n (random 0.01 0.02))
+                          (replicate n 0))))
+      (pan2 (klang ar 1 0 s)
+            (random -1 1)
+            e))))
+
+(define pattern
+  (lambda (fd)
+    (play fd (out 0 (klg (random 32 92)
+                         (i-random 9 24))))
+    (thread-sleep (random 0.25 0.75))
+    (pattern fd)))
+
+(with-sc3 pattern)

rsc3/examples/graph/noise-burst-sweep.scm

@@ -0,0 +1,13 @@
+;; noise burst sweep (jmcc)
+
+(import (rnrs) (rsc3))
+
+(define noise-burst-sweep
+  (let* ((n (clone 2 (white-noise ar)))
+         (lfo-rate (mouse-x* kr 10 60 1 0.2))
+         (amp (u:max 0 (lf-saw kr lfo-rate -1)))
+         (cfreq (mouse-y* kr 400 8000 1 0.2))
+         (freq (mul-add (sin-osc kr 0.2 0) cfreq (mul 1.05 cfreq))))
+    (resonz (mul n amp) freq 0.1)))
+
+(audition (out 0 noise-burst-sweep))

rsc3/examples/graph/one-line.scm

@@ -0,0 +1,11 @@
+;; one-line (lance putnam)
+
+(import (rnrs) (rsc3))
+
+(define one-line
+  (let* ((lfs (mul-add (lf-saw ar (mce2 1 0.99) (mce2 0 0.6)) 2000 2000))
+         (lfs-t (mul (trunc lfs (mce2 400 600)) (mce2 1 -1)))
+         (f (one-pole (mix lfs-t) 0.98)))
+    (pan2 (sin-osc ar f 0) 0 0.1)))
+
+(audition (out 0 one-line))

rsc3/examples/graph/oscillator-cluster.scm

@@ -0,0 +1,40 @@
+;; oscillator cluster (rd)
+
+(import (rnrs) (rsc3) (rhs))
+
+(define ln
+  (lambda (a b d)
+    (line kr a b d remove-synth)))
+
+(define xln
+  (lambda (a b d)
+    (x-line kr a b d remove-synth)))
+
+(define rln
+  (lambda (r a b d)
+    (line kr (add a (rand 0 r)) b d remove-synth)))
+
+(define rxln
+  (lambda (r a b d)
+    (x-line kr (add a (rand 0 r)) b d remove-synth)))
+
+(define prt
+  (lambda (d a)
+    (lambda (cf)
+      (let* ((r1 (rand cf (add cf 2)))
+             (r2 (rln 1 5 0.01 d))
+             (r3 (rln 10 20 0 d))
+             (r4 (rand 0.1 0.2))
+             (f (add (mce2 cf r1) (mul (sin-osc kr r2 0) r3)))
+             (o (f-sin-osc ar f 0))
+		       (e (mul (decay2 (impulse ar 0 0) r4 d) a)))
+        (mul o e)))))
+
+(define oscillator-cluster
+  (let* ((np 12)
+         (fp (replicate-m np (rand 220 660)))
+         (d (rand 4 7))
+         (a (rand 0.01 0.05)))
+    (foldl add 0 (map (prt d a) fp))))
+
+(audition (out 0 oscillator-cluster))

rsc3/examples/graph/pattern-buffer.scm

@@ -0,0 +1,36 @@
+;; pattern buffer (rd)
+
+(import (rnrs) (sosc) (rsc3) (rhs))
+
+(define tseq
+  (lambda (l)
+    (let ((n (/ (length l) 2)))
+      (select (mul-add (lf-saw kr 0.5 0) n n) (make-mce l)))))
+
+(define rs
+  (lambda (nf fd)
+    (let ((r0 (random 0 nf))
+          (r1 (random 0 1)))
+      (send fd (b-set1 10 r0 r1)))))
+
+(define pattern-buffer
+  (lambda (nf c)
+    (let* ((p (phasor ar 0 (buf-rate-scale kr 10) 0 (buf-frames kr 10) 0))
+           (t (buf-rd-c 1 ar 10 p 1))
+           (r1 (replicate-m c (random 36 96)))
+           (r2 (replicate-m c (random -1 1)))
+           (r3 (i-random 0 2))
+           (n1 (t-rand 0.02 0.08 t))
+           (e (decay2 t 0.01 n1))
+           (f (midi-cps (tseq r1)))
+           (l (tseq r2))
+           (o (list-ref (list (sin-osc ar f 0) (saw ar f)) r3)))
+      (pan2 o l e))))
+
+(with-sc3
+ (lambda (fd)
+   (let ((nf (mul 2 48000))
+         (c 24))
+     (async fd (b-alloc 10 (* nf 2) 1))
+     (replicate-m c (rs nf fd))
+     (play fd (out 0 (pattern-buffer nf c))))))

rsc3/examples/graph/plucked-strings.scm

@@ -0,0 +1,22 @@
+;; plucked strings (jmcc)
+
+(import (rnrs) (rsc3))
+
+(define plucked-strings
+  (let ((s (lambda (_)
+             (let* ((r0 (rand 2 2.2))
+                    (n0 (dust ar 0.5))
+                    (r1 (rand 0.05 0.15))
+                    (r2 (rand 0 (* pi 2)))
+                    (r3 (i-rand 0 2))
+                    (s0 (impulse ar r0 0.3))
+                    (s1 (mul n0 0.3))
+                    (f (mul-add (sin-osc kr r1 r2) 5 5.2))
+                    (s2 (impulse ar f 0.3))
+                    (im (select r3 (mce3 s0 s1 s2)))
+                    (dt (fdiv 1 (midi-cps (u:floor (rand 60 90)))))
+                    (t (mul3 (decay im 0.1) (pink-noise ar) 0.1)))
+               (pan2 (comb-l t dt dt 4) (rand -1 1) 1)))))
+    (leak-dc (mix-fill 5 s) 0.96)))
+
+(audition (out 0 plucked-strings))

rsc3/examples/graph/police-state.scm

@@ -0,0 +1,24 @@
+;; police state (jmcc)
+
+(import (rnrs) (rsc3))
+
+(define node
+  (lambda (_)
+    (let* ((r0 (rand 0.02 0.1))
+           (r1 (rand 0 (* pi 2)))
+           (r2 (rand 0 600))
+           (r3 (rand 700 1300))
+           (r4 (rand -1 1))
+           (r5 (rand 80 120))
+           (n0 (lf-noise2 ar r5))
+           (f (mul-add (sin-osc kr r0 r1) r2 r3)))
+      (pan2 (mul (sin-osc ar f 0) n0) r4 0.1))))
+
+(define police-state
+  (let* ((n0 (lf-noise2 kr (mce2 0.4 0.4)))
+         (n1 (lf-noise2 ar (mul-add n0 90 620)))
+         (n2 (lf-noise2 kr (mce2 0.3 0.3)))
+         (e (mul n1 (mul-add n2 0.15 0.18))))
+    (comb-l (add (mix-fill 4 node) e) 0.3 0.3 3)))
+
+(audition (out 0 police-state))

rsc3/examples/graph/pulsing-bottles.scm

@@ -0,0 +1,20 @@
+;; pulsing bottles (jmcc)
+
+(import (rnrs) (rsc3))
+
+(define u
+  (lambda (_)
+    (let* ((n (white-noise ar))
+           (r0 (rand 4 14))
+           (r1 (rand 0 0.7))
+           (r2 (rand 400 7400))
+           (r (resonz (mul3 n (lf-pulse kr r0 0 0.25) r1) r2 0.01))
+           (f (rand 0.1 0.5))
+           (p (rand 0 (mul pi 2)))
+           (s (sin-osc kr f p)))
+      (pan2 r s 1))))
+
+(define pulsing-bottles
+  (mix-fill 6 u))
+
+(audition (out 0 pulsing-bottles))

rsc3/examples/graph/record-scratcher.scm

@@ -0,0 +1,18 @@
+;; record scratcher (josh parmenter)
+
+(import (rnrs) (rsc3))
+
+(define dup (lambda (a) (mce2 a a)))
+
+(define record-scratcher
+  (lambda (b)
+    (let* ((x (mouse-x* kr -10 10 linear 0.2))
+           (dx (sub x (delay-n x 0.1 0.1)))
+           (bdx (add (mouse-button* kr 1 0 0.3) dx))
+           (bdxr (mul bdx (buf-rate-scale kr b))))
+      (dup (play-buf 1 b bdxr 0 0 loop)))))
+
+(with-sc3
+ (lambda (fd)
+   (async fd (b-alloc-read 10 "/home/rohan/data/audio/pf-c5.snd" 0 0))
+   (play fd (out 0 (record-scratcher 10)))))

rsc3/examples/graph/red-frik.scm

@@ -0,0 +1,22 @@
+;; red frik (f0)
+
+(import (rnrs) (rsc3))
+
+(define red
+  (lambda (tr n)
+    (let* ((r1 (t-rand 0.3 3 tr))
+           (r2 (t-rand 0.3 5 tr))
+           (r3 (t-rand 0 0.5 tr))
+           (r4 (t-rand 0.49 0.56 tr))
+           (r5 (t-rand 0.3 0.6 tr))
+           (r6 (t-rand 0.3 0.5 tr))
+           (o1 (mul-add (f-sin-osc kr r2 0) r3 r4))
+           (o2 (mul (f-sin-osc kr o1 r5) r6)))
+      (rhpf n r1 o2))))
+
+(define red-frik
+  (let ((n (clone 2 (brown-noise ar)))
+        (tr (impulse kr 0.1 0)))
+    (red tr n)))
+
+(audition (out 0 red-frik))

rsc3/examples/graph/reset.scm

@@ -0,0 +1,3 @@
+(import (rnrs) (rsc3))
+(with-sc3 reset)
+

rsc3/examples/graph/reverberated-sine-percussion.scm

@@ -0,0 +1,33 @@
+;; reverberated sine percussion (jmcc)
+
+(import (rnrs) (rsc3) (rhs))
+
+(define rallpass
+  (lambda (i)
+    (allpass-n i 0.050 (clone 3 (rand 0 0.05)) 1)))
+
+(define chain-of
+  (lambda (n f)
+    (foldl1 compose (replicate n f))))
+
+(define reverberated-sine-percussion
+  (let* ((d 10)
+         (c 7)
+         (a 4)
+         (s (mix-fill
+             d
+             (lambda (_)
+               (resonz (mul (dust ar (/ 2 d)) 50)
+                       (+ 200 (random 0 3000))
+                       0.003))))
+         (z (delay-n s 0.048 0.48))
+         (y (mix (comb-l z
+                         0.1
+                         (mul-add (lf-noise1 kr (clone c (rand 0 0.1)))
+                                  0.04
+                                  0.05)
+                         15)))
+         (x ((chain-of a rallpass) y)))
+    (add s (mul 0.2 x))))
+
+(audition (out 0 reverberated-sine-percussion))

rsc3/examples/graph/rm-octaver.scm

@@ -0,0 +1,11 @@
+;; rm-octaver (andrea valle, miller puckette)
+
+(import (rnrs) (rsc3))
+
+(let* ((default-pitch
+	 (lambda (i)
+	   (pitch i 440 60 4000 100 16 1 0.01 0.5 1)))
+       (i (sound-in 4))
+       (p (default-pitch i))
+       (f (mce-channel p 0)))
+  (audition (out 0 (mul-add (sin-osc ar (mul f 0.5) 0) i i))))

rsc3/examples/graph/rzblp.scm

@@ -0,0 +1,43 @@
+;; rzblp (rd)
+
+(import (rnrs) (rsc3) (rhs))
+
+(define wrp
+  (lambda (i l r)
+    (let ((m (fdiv (sub r l) 2)))
+      (mul-add i m (add l m)))))
+
+(define lfn
+  (lambda (f l r)
+    (wrp (lf-noise0 kr f) l r)))
+
+(define hpb
+  (lambda (q)
+    (mix-fill
+     2
+     (lambda (_)
+       (let ((f (lfn q 1330 1395))
+             (a (lfn q 0.001 0.007)))
+         (mul (blip ar f 24) a))))))
+
+(define f
+  (lambda (u)
+    (let* ((q (lfn 5.2 5.2 5.21))
+           (a (u dinf (mce5 1 3 2 7 8)))
+           (trig (impulse kr q 0))
+           (freq (mul-add (demand trig 0 a) 30 340)))
+      (foldl1 add
+              (list (mul (blip ar freq 3)
+                         (lfn q 0.001 0.01))
+                    (mul (resonz (impulse ar q (mce2 0 0))
+                                 (lfn 5 30 640)
+                                 (lfn q 0.1 0.5))
+                         (lfn q 0.01 1.8))
+                    (mul (hpb q)
+                         (lfn q 1.2 1.8))
+                    (mul (blip ar (lfn q 16 36) 3)
+                         (mce2 0.03 0.09)))))))
+
+(define rzblp (add (f drand) (f dxrand)))
+
+(audition (out 0 rzblp))

rsc3/examples/graph/s-chirp.scm

@@ -0,0 +1,25 @@
+;; s-chirp (rd)
+
+(import (rnrs) (sosc) (rsc3))
+
+(define s-chirp
+  (let* ((x (mouse-x kr 15 0 0 0.1))
+         (y (mouse-y kr 15 27 0 0.1))
+         (t (dust kr 9))
+         (b (t-choose t (make-mce (list 36 48 60 72))))
+         (n (mul (lf-noise1 kr (mce2 3 3.05)) 0.04))
+         (d (ti-rand x y t))
+         (e (decay2 t 0.005 (t-rand 0.02 0.15 t)))
+         (k (degree-to-key 0 d 12))
+         (f (midi-cps (add3 b k n)))
+         (m (mul3 e (sin-osc ar f 0) 0.2))
+         (u (pulse-divider t 9 0))
+         (r0 (t-rand 0.0075 0.125 u))
+         (r1 (t-rand 0.05 0.15 u)))
+    (mul-add m 0.5 (allpass-c m 0.15 r0 r1))))
+
+(with-sc3
+ (lambda (fd)
+   (async fd (b-alloc 0 7 1))
+   (send fd (b-setn1 0 0 (list 0 2 3.2 5 7 9 10)))
+   (audition (out 0 s-chirp))))

rsc3/examples/graph/sample-and-hold-liquidities.scm

@@ -0,0 +1,16 @@
+;; sample and hold liquidities (jmcc)
+
+(import (rnrs) (rsc3))
+
+(define sahl
+  (let* ((r (mouse-x kr 1 200 1 0.1))
+         (t (recip r))
+         (c (impulse kr r 0.4))
+         (cf (mouse-y kr 100 8000 1 0.1))
+         (f (latch (mul-add (white-noise kr) (mul cf 0.5) cf) c))
+         (p (latch (white-noise kr) c))
+         (e (decay2 c (mul 0.1 t) (mul 0.9 t)))
+         (i (pan2 (mul (sin-osc ar f 0) e) p 1)))
+    (comb-n i 0.3 0.3 2)))
+
+(audition (out 0 sahl))

rsc3/examples/graph/scratchy.scm

@@ -0,0 +1,10 @@
+;; scratchy (jmcc)
+
+(import (rnrs) (rsc3))
+
+(define scratchy
+  (let* ((n (mul (clone 2 (brown-noise ar)) 0.5))
+         (f (mul (u:max (sub n 0.49) 0) 20)))
+    (rhpf f 5000 1)))
+
+(audition (out 0 scratchy))

rsc3/examples/graph/scritto.scm

@@ -0,0 +1,82 @@
+;; scritto (rd)
+
+(import (rnrs) (sosc) (rsc3))
+
+(define putnam
+  '((sA  ((800 1150 2900 3900 4950) (0 -6  -32 -20 -50) (80 90  120 130 140)))
+    (sE  ((350 2000 2800 3600 4950) (0 -20 -15 -40 -56) (60 100 120 150 200)))
+    (sI  ((270 2140 2950 3900 4950) (0 -12 -26 -26 -44) (60 90  100 120 120)))
+    (sO  ((450 800  2830 3800 4950) (0 -11 -22 -22 -50) (70 80  100 130 135)))
+    (sU  ((325 700  2700 3800 4950) (0 -16 -35 -40 -60) (50 60  170 180 200)))
+    (aA  ((800 1150 2800 3500 4950) (0 -4  -20 -36 -60) (80 90  120 130 140)))
+    (aE  ((400 1600 2700 3300 4950) (0 -24 -30 -35 -60) (60 80  120 150 200)))
+    (aI  ((350 1700 2700 3700 4950) (0 -20 -30 -36 -60) (50 100 120 150 200)))
+    (aO  ((450 800  2830 3500 4950) (0 -9  -16 -28 -55) (70 80  100 130 135)))
+    (aU  ((325 700  2530 3500 4950) (0 -12 -30 -40 -64) (50 60  170 180 200)))
+    (ctA ((660 1120 2750 3000 3350) (0 -6  -23 -24 -38) (80 90  120 130 140)))
+    (ctE ((440 1800 2700 3000 3300) (0 -14 -18 -20 -20) (70 80  100 120 120)))
+    (ctI ((270 1850 2900 3350 3590) (0 -24 -24 -36 -36) (40 90  100 120 120)))
+    (ctO ((430 820  2700 3000 3300) (0 -10 -26 -22 -34) (40 80  100 120 120)))
+    (ctU ((370 630  2750 3000 3400) (0 -20 -23 -30 -34) (40 60  100 120 120)))
+    (tA  ((650 1080 2650 2900 3250) (0 -6   -7  -8 -22) (80 90  120 130 140)))
+    (tE  ((400 1700 2600 3200 3580) (0 -14 -12 -14 -20) (70 80  100 120 120)))
+    (tI  ((290 1870 2800 3250 3540) (0 -15 -18 -20 -30) (40 90  100 120 120)))
+    (tO  ((400 800  2600 2800 3000) (0 -10 -12 -12 -26) (40 80  100 120 120)))
+    (tU  ((350 600  2700 2900 3300) (0 -20 -17 -14 -26) (40 60  100 120 120)))
+    (bA  ((600 1040 2250 2450 2750) (0 -7   -9  -9 -20) (60 70  110 120 130)))
+    (bE  ((400 1620 2400 2800 3100) (0 -12  -9 -12 -18) (40 80  100 120 120)))
+    (bI  ((250 1750 2600 3050 3340) (0 -30 -16 -22 -28) (60 90  100 120 120)))
+    (bO  ((400 750  2400 2600 2900) (0 -11 -21 -20 -40) (40 80  100 120 120)))
+    (bU  ((350 600  2400 2675 2950) (0 -20 -32 -28 -36) (40 80  100 120 120)))))
+
+(define v-filter
+  (lambda (in freq ampl bw)
+    (mul (resonz in freq (fdiv bw freq))
+	 (db-amp ampl))))
+
+(define voice-tr
+  (lambda (i t fr amr bwr)
+    (mix (v-filter
+	  i
+	  (mul (in 5 kr 0)  (t-rand (sub 1 fr) (add 1 fr) t))
+	  (mul (in 5 kr 5)  (t-rand (sub 1 amr) (add 1 amr) t))
+	  (mul (in 5 kr 10) (t-rand (sub 1 bwr) (add 1 bwr) t))))))
+
+(define scritto
+  (lambda (rt)
+    (let* ((t (impulse ar (mul-add (lf-noise2 kr 3) 12 12) 0))
+	   (n (ti-rand 30 52 t))
+	   (i (lambda (d)
+		(mul3 (decay2 (pulse-divider t d 0) 0.01 (t-rand 0.005 rt t))
+		      (blip ar (midi-cps n) (t-rand 16 32 t))
+		      12.0)))
+	   (x (mouse-x kr 0 1 0 0.1))
+	   (y (mouse-y kr 0 1 0 0.1)))
+      (mrg2 (send-trig t 0 n)
+	    (out 0 (clip2
+		    (mce2 (voice-tr (i 1)
+				    t
+				    (mul x 1.05)
+				    (mul x 1.25)
+				    (mul x 0.05))
+			  (voice-tr (i 2)
+				    t
+				    (mul y 0.05)
+				    (mul y 0.75)
+				    (mul y 1.00)))
+		    1))))))
+
+(define updater
+  (lambda (fd)
+    (let* ((v (choose putnam))
+	   (data (list-ref v 1))
+	   (freq (list-ref data 0))
+	   (ampl (list-ref data 1))
+	   (bw (list-ref data 2)))
+      (send fd (c-setn1 0 freq))
+      (send fd (c-setn1 5 ampl))
+      (send fd (c-setn1 10 bw)))))
+
+(audition (scritto (mouse-x kr 0.0125 0.35 0 0.1)))
+
+(with-sc3 updater)

rsc3/examples/graph/seqr.scm

@@ -0,0 +1,25 @@
+;; seqr (rd)
+
+(import (rnrs) (rsc3) (rhs))
+
+(define nfreq
+  (lambda (n l r)
+    (map midi-cps (map floor (replicate-m n (random l r))))))
+
+(define seqr-f
+  (lambda (f e)
+    (let ((n (/ (length e) 2)))
+      (select (mul-add (lf-saw kr f 0) n n) (make-mce e)))))
+
+(define seqr
+  (let* ((n (i-random 6 18))
+         (f (/ (i-random 9 18) n)))
+    (mul (blip ar
+               (mce2 (seqr-f f (nfreq n 72 96))
+                     (seqr-f f (nfreq n 72 84)))
+               (mce2 (seqr-f f (replicate-m n (random 1 3)))
+                     (seqr-f f (replicate-m n (random 3 6)))))
+         (mce2 (seqr-f f (replicate-m n (random 0.05 0.10)))
+               (seqr-f f (replicate-m n (random 0.05 0.15)))))))
+
+(audition (out 0 seqr))

rsc3/examples/graph/shepard-tones.scm

@@ -0,0 +1,48 @@
+;; shepard tones (alberto de campo)
+
+(import (rnrs) (sosc) (rsc3) (rhs))
+
+(define iota
+  (lambda (n l j)
+    (if (= n 0)
+        nil
+        (cons l (iota (- n 1) (+ l j) j)))))
+
+(define indxs
+  (lambda (n l r)
+    (iota n l (/ (- r l) n))))
+
+(define hanning-window
+  (lambda (n)
+    (let* ((lp (* pi -0.5))
+           (rp (+ lp (* 2 pi)))
+           (hf (lambda (i) (+ (* (sin i) 0.5) 0.5))))
+      (map hf (indxs n lp rp)))))
+
+(define square (lambda (x) (* x x)))
+
+(define amp-table (map square (hanning-window 1024)))
+
+(define amp-f (lambda (i) (* (expt 0.5 i) 20000)))
+
+(define freq-table (map amp-f (indxs 1024 0 10)))
+
+(define shepard-tones
+  (let* ((rate-scale (/ (/ 1024 44100) 10))
+         (rate 0.1)
+         (ph (phasor ar 0 (* rate rate-scale) 0 1024 0))
+         (phases (make-mce
+                  (map
+                   (lambda (n) (add (mul3 n 0.1 1024) ph))
+                   (enum-from-to 0 9))))
+         (freqs (buf-rd-c 1 ar 1 phases 1))
+         (amps (buf-rd-c 1 ar 2 phases 1)))
+    (mul (mix (mul (sin-osc ar freqs 0) amps)) 0.1)))
+
+(with-sc3
+ (lambda (fd)
+   (async fd (b-alloc 1 1024 1))
+   (async fd (b-alloc 2 1024 1))
+   (send fd (b-setn1 1 0 freq-table))
+   (send fd (b-setn1 2 0 amp-table))
+   (audition (out 0 shepard-tones))))

rsc3/examples/graph/shifting-pulses.scm

@@ -0,0 +1,44 @@
+;; shifting pulses (rd)
+
+(import (rnrs) (sosc) (rsc3) (rhs))
+
+(define wrp
+  (lambda (i l r)
+    (lin-lin i -1 1 l r)))
+
+(define prt
+  (lambda (f a)
+    (let ((f* (mul f (mul (wrp (sin-osc kr (rand 0.2 0.9) 0) 1 1.01)
+                          (rand 0.95 1.05)))))
+      (mul (sin-osc ar (mce2 f f*) 0)
+           (mul a (clone 2 (rand 0.95 1.05)))))))
+
+;; (audition (out 0 (prts 2 900 0.002)))
+;; (audition (out 0 (prts 9 40 0.006)))
+(define prts
+  (lambda (n f a)
+    (mix
+     (make-mce
+      (map
+       (lambda (f)
+         (prt f a))
+       (enum-from-then-to f (+ f f) (* n f)))))))
+
+(define shifting-pulses
+  (let* ((n1 (clone 2 (brown-noise kr)))
+         (n2 (clone 2 (brown-noise kr)))
+         (n3 (clone 2 (brown-noise kr)))
+         (t (dust kr 0.75))
+         (l (latch t t))
+         (p (mul (pulse ar (wrp n1 2 (mce2 11 15)) 0.01) 0.1))
+         (f (wrp n2 300 1800))
+         (rq (wrp n3 0.01 2)))
+    (mrg2
+     (add4
+      (prts 2 900 0.002)
+      (prts 9 40 0.006)
+      (mul (formant ar (mce2 20 21) (wrp (lf-noise2 kr 2) 10 100) 200) 0.35)
+      (mul l (rlpf p f rq)))
+     (send-trig t 0 t))))
+
+(audition (out 0 shifting-pulses))

rsc3/examples/graph/slly-wlk.scm

@@ -0,0 +1,51 @@
+;; slly-walk (rd)
+
+(import (rnrs) (sosc) (rsc3))
+
+(define o1
+  (let* ((t (dust kr 2))
+         (e (env-bp-linear (list 0 0 (t-rand 0.05 0.5 t) 1 1 0) 1 1))
+         (d (t-rand 0.15 0.25 t))
+         (a (env-gen kr t (t-rand 0.02 0.04 t) 0 d do-nothing e))
+         (p (env-gen kr t (t-rand 1.0 2.0 t) -1.0 d do-nothing e))
+         (n (t-choose t (mce4 0 2 5 7)))
+         (o 72))
+    (pan2 (sin-osc ar (midi-cps (add n o)) 0) p a)))
+
+(define shft
+  (lambda ()
+    (let* ((t (impulse kr 12 0))
+           (e (env-bp-linear (list 0 0 (t-rand 0.25 1.0 t) 1 1 0) 1 1))
+           (d (t-rand 0.05 0.125 t))
+           (a (env-gen kr t (t-rand 0.02 0.04 t) 0 d do-nothing e))
+           (p (env-gen kr t (t-rand 1.0 2.0 t) -1.0 d do-nothing e))
+           (n (t-choose t (make-mce (list 0 0 5 7 7 12 12 19))))
+           (o (add 84 (mul (toggle-ff t) 12))))
+      (pan2 (saw ar (midi-cps (add n o))) p a))))
+
+(define o2
+  (mul (add3 (shft) (shft) (shft)) 0.1))
+
+(define o3
+  (let* ((t (impulse kr 6 0))
+         (e (env-bp-linear (list 0 0 (t-rand 0.25 1.0 t) 1 1 0) 1 1))
+         (d (t-rand 0.05 0.25 t))
+         (a (env-gen kr t (t-rand 0.01 0.02 t) 0 d do-nothing e))
+         (p (env-gen kr t (t-rand 1.0 2.0 t) -1.0 d do-nothing e))
+         (n (demand t 0 (dibrown dinf 0 7 1)))
+         (o 52))
+    (pan2 (saw ar (midi-cps (degree-to-key 0 (add n o) 12))) p a)))
+
+(define o4
+  (mul (rlpf (lf-pulse ar (midi-cps (mce2 36 43)) 0.15 0.5)
+             (midi-cps (mul-add (sin-osc kr 0.1 0) 10 36))
+             0.1)
+       0.1))
+
+(define slly-wlk
+  (lambda (fd)
+    (async fd (b-alloc 0 7 1))
+    (send fd (b-setn1 0 0 (list 0 2 3.2 5 7 9 10)))
+    (play fd (out 0 (add4 o1 o2 o3 o4)))))
+
+(with-sc3 slly-wlk)

rsc3/examples/graph/snare-909.scm

@@ -0,0 +1,31 @@
+;; snare-909 (jmcc)
+
+(import (rnrs) (rsc3))
+
+(define snr
+  (lambda (tr n v)
+    (let* ((mk-e
+            (lambda (a b)
+              (let ((p (env-perc a b 1 (list -4 -4))))
+                (env-gen ar tr 1 0 1 do-nothing p))))
+           (e1 (mk-e 0.0005 0.055))
+           (e2 (mk-e 0.0005 0.075))
+           (e3 (mk-e 0.0005 0.4))
+           (e4 (mk-e 0.0005 0.283))
+           (t1 (lf-tri ar 330 0))
+           (t2 (lf-tri ar 185 0))
+           (x1 (mul-add (lpf n 7040) 0.1 v))
+           (x2 (hpf x1 523))
+           (m1 (add (mul3 t1 e1 0.25) (mul3 t2 e2 0.25)))
+           (m2 (add (mul3 x1 e3 0.20) (mul3 x2 e4 0.20))))
+      (add m1 m2))))
+
+(define snare-909
+  (let* ((x (mouse-x* kr 1 4 linear 0.2))
+         (y (mouse-y* kr 0.25 0.75 exponential 0.2))
+         (t (impulse kr (mul 3 x) 0))
+         (n (white-noise ar))
+         (v (t-rand 0.25 1.0 t)))
+    (pan2 (snr t n v) 0 y)))
+
+(audition (out 0 snare-909))

rsc3/examples/graph/sosc-lp.scm

@@ -0,0 +1,39 @@
+;; sosc-lp (rd)
+
+(import (rnrs) (sosc) (rsc3))
+
+(define dust-r
+  (lambda (r lo hi)
+    (let ((d (dseq dinf (make-mce (list (dwhite 1 lo hi))))))
+      (t-duty r d 0 0 (u:abs (white-noise r)) 1))))
+
+(define sosc-lp
+  (let* ((clk (dust-r kr 0.2 0.9))
+         (env (decay2 clk 0.002 2.5))
+         (idx (stepper clk 0 0 15 1 0))
+         (f1 (midi-cps (mce2 (sub (buf-rd 1 kr 10 idx 1 1) 24)
+                             (sub (buf-rd 1 kr 11 idx 1 1) 24))))
+         (f2 (add f1 (mul (lf-noise0 kr (mce2 1 3)) 1.2)))
+         (o1 (mul (sin-osc ar f1 0) env))
+         (o2 (mul (sin-osc ar f2 0) env)))
+    (mrg2
+     (send-trig clk 0 clk)
+     (mul (add o1 o2) 0.2))))
+
+(with-sc3
+ (lambda (fd)
+   (let ((a (list 60 71 89 65 36 57 92 97 92 97))
+         (b (list 71 89 60 57 65 36 95 92 93 97)))
+     (async fd (b-alloc 10 9 1))
+     (async fd (b-alloc 11 9 1))
+     (send fd (b-setn1 10 0 a))
+     (send fd (b-setn1 11 0 b))
+     (play fd (out 0 sosc-lp)))))
+
+(define alternate
+  (with-sc3
+   (lambda (fd)
+     (let ((a (list 71 60 65 89 36 57 95 97 92 97))
+           (b (list 89 71 60 65 57 36 92 95 93 97)))
+       (send fd (b-setn1 10 0 a))
+       (send fd (b-setn1 11 0 b))))))

rsc3/examples/graph/spe.scm

@@ -0,0 +1,27 @@
+;; spe (jmcc)
+
+(import (rnrs) (rhs) (rsc3))
+
+(define chain-of
+  (lambda (n f)
+    (foldl1 compose (replicate n f))))
+
+(define rapf
+  (lambda (i)
+    (allpass-n i 0.05 (clone 2 (rand 0 0.05)) 4)))
+
+(define spe
+  (let* ((n (lf-noise1 kr 1))
+         (s (make-mce (list 00 03 02 07
+                            08 32 16 18
+                            00 12 24 32)))
+         (m (dseq dinf s))
+         (t (impulse kr 9 0))
+         (f (midi-cps (add (demand t 0 m) 32)))
+         (p (env-perc 0.01 1 1 (list -4 -4)))
+         (e (env-gen kr t 0.1 0 1 do-nothing p))
+         (o (mul (lf-saw ar f 0) e))
+         (rq (midi-cps (mul-add n 36 110))))
+    ((chain-of 4 rapf) (rlpf o rq 0.1))))
+
+(audition (out 0 spe))

rsc3/examples/graph/sprinkler.scm

@@ -0,0 +1,10 @@
+;; sprinkler (jmcc)
+
+(import (rnrs) (rsc3))
+
+(define sprinkler
+  (let* ((f (mul-add (lf-pulse kr 0.09 0 0.16) 10 7))
+         (t (mul (lf-pulse kr f 0 0.25) 0.1)))
+    (bpz2 (mul (white-noise ar) t))))
+
+(audition (out 0 sprinkler))

rsc3/examples/graph/status.scm

@@ -0,0 +1,2 @@
+(import (rnrs) (rsc3))
+(with-sc3 display-server-status)

rsc3/examples/graph/strtchd-scrmbld.scm

@@ -0,0 +1,66 @@
+;; strtchd-scrmbld (rd)
+
+(import (rnrs) (sosc) (rsc3))
+
+(define dust-r
+  (lambda (r lo hi)
+    (let ((d (dseq dinf (dwhite 1 lo hi))))
+      (t-duty r d 0 0 (u:abs (white-noise r)) 1))))
+
+(define rpr
+  (lambda (n t)
+    (let ((i (in 2 kr n)))
+      (t-rand (mce-channel i 0) (mce-channel i 1) t))))
+
+(define strtchd
+  (lambda (b z)
+    (let* ((clk (dust-r ar (in 1 kr 0) (in 1 kr 1)))
+           (rat (rpr 2 clk))
+           (dur (rpr 4 clk))
+           (bdr (buf-dur kr b))
+           (hbd (mul bdr 0.5))
+           (pos (add (mul (rpr 8 clk) bdr)
+                     (mul-add (lf-saw ar z 0) hbd hbd)))
+           (pan (rpr 10 clk))
+           (amp (rpr 6 clk)))
+      (t-grains 2 clk b rat pos dur pan amp 2))))
+
+(define scrmbld
+  (lambda (u b t)
+    (let* ((f (fft* b u))
+           (g (pv-bin-scramble f
+                               (mouse-x kr 0.5 1.0 0 0.1)
+                               (mouse-y kr 0.5 1.0 0 0.1)
+                               t)))
+      (ifft* g))))
+
+(define strtchd-scrmbld
+  (let ((t0 (dust kr 0.01))
+        (t1 (dust kr 0.02))
+        (u (add (strtchd 10 0.015)
+                (strtchd 10 0.0175))))
+    (out 0 (mce2 (scrmbld (mce-channel u 0) 20 t0)
+                 (scrmbld (mce-channel u 1) 30 t1)))))
+
+(define mk-r-set
+  (lambda ()
+    (list (random 0.005 0.001)   (random 0.0075 0.0125)
+          (random 0.90 0.975)    (random 1.025 1.10)
+          (random 0.005 0.075)   (random 0.075 0.125)
+          (random 0.005 0.01)    (random 0.15 0.25)
+          (random -0.015 -0.005) (random 0.005 0.015)
+          (random -1 0)          (random 0 1.0))))
+
+(define pattern
+  (lambda (fd)
+    (send fd (c-setn1 0 (mk-r-set)))
+    (thread-sleep (choose (list 0.05 0.15 0.25 0.5 0.75 1.25)))
+    (pattern fd)))
+
+(with-sc3
+ (lambda (fd)
+   (async fd (b-alloc-read 10 "/home/rohan/data/audio/pf-c5.snd" 0 0))
+   (async fd (b-alloc 20 2048 1))
+   (async fd (b-alloc 30 2048 1))
+   (play fd strtchd-scrmbld)
+   (pattern fd)))

rsc3/examples/graph/strummable-guitar.scm

@@ -0,0 +1,18 @@
+;; strummable guitar (jmcc)
+
+(import (rnrs) (rsc3))
+
+(define sg
+  (let* ((scale (list 52 57 62 67 71 76))
+         (str (lambda (i)
+                (let* ((x (mouse-x kr 0 1 0 0.2))
+                       (t (u:abs (hpz1 (gt x (add 0.25 (mul i 0.1))))))
+                       (e (decay t 0.05))
+                       (n (mul (pink-noise ar) e))
+                       (dt (recip (midi-cps (list-ref scale i))))
+                       (s (comb-l n dt dt 4)))
+                  (pan2 s (sub (mul i 0.2) 0.5) 1))))
+         (strs (mix-fill (length scale) str)))
+    (leak-dc (lpf strs 12000) 0.995)))
+
+(audition (out 0 sg))

rsc3/examples/graph/sweepy-noise.scm

@@ -0,0 +1,15 @@
+;; sweepy noise (jmcc)
+
+(import (rnrs) (rsc3))
+
+(define sn
+  (let* ((n (clone 2 (white-noise ar)))
+         (lfo-depth (mouse-y kr 200 8000 1 0.2))
+         (lfo-rate (mouse-x kr 4 60 1 0.2))
+         (freq (mul-add (lf-saw kr lfo-rate 0)
+                        lfo-depth
+                        (mul lfo-depth 1.2)))
+         (filtered (rlpf (mul n 0.03) freq 0.1)))
+    (add (comb-n filtered 0.3 0.3 2) filtered)))
+
+(audition (out 0 sn))

rsc3/examples/graph/synthetic-piano.scm

@@ -0,0 +1,21 @@
+;; synthetic piano (jmcc)
+
+(import (rnrs) (rsc3))
+
+(define sp
+  (lambda (_)
+    (let* ((n (i-rand 36 90))
+           (f (rand 0.1 0.5))
+           (ph (rand 0 (mul pi 2)))
+           (s (mul (impulse ar f ph) 0.1))
+           (e (decay2 s 0.008 0.04))
+           (c
+            (lambda (i)
+              (let* ((n0 (lf-noise2 ar 3000))
+                     (o (list-ref (list -0.05 0 0.04) i))
+                     (dt (fdiv 1 (midi-cps (add n o)))))
+                (comb-l (mul n0 e) dt dt 6))))
+           (l (sub (fdiv (sub n 36) 27) 1)))
+      (pan2 (mix-fill 3 c) l 1))))
+
+(audition (out 0 (mix-fill 6 sp)))

rsc3/examples/graph/tank.scm

@@ -0,0 +1,35 @@
+;; tank (jmcc)
+
+(import (rnrs) (rhs) (rsc3))
+
+(define bang
+  (let ((d (dust ar 0.01))
+        (n (brown-noise ar)))
+    (pan2 (mul (decay2 d 0.04 0.3) n) 0 1)))
+
+(define pling
+  (lambda (_)
+    (let ((o (f-sin-osc ar (exp-rand 300 2200) 0))
+          (d (decay2 (dust ar 0.5) 0.1 0.5)))
+      (pan2 (mul (mul d 0.1) (cubed o)) (rand -1 1) 1))))
+
+(define rallpass
+  (lambda (i)
+    (allpass-n i 0.03 (clone 2 (rand 0.005 0.02)) 1)))
+
+(define rallpasses
+  (foldl1 compose (replicate 4 rallpass)))
+
+(define tank
+  (lambda (i)
+    (let* ((l0 (mul (local-in 2 ar) 0.98))
+           (l1 (one-pole l0 0.33))
+           (l2 (rotate2 (mce-channel l1 0) (mce-channel l1 1) 0.23))
+           (l3 (allpass-n l2 0.05 (clone 2 (rand 0.01 0.05)) 2))
+           (l4 (delay-n l3 0.3 (mce2 0.17 0.23)))
+           (l5 (allpass-n l4 0.05 (clone 2 (rand 0.03 0.15)) 2))
+           (l6 (leak-dc l5 0.995))
+           (l7 (add l6 i)))
+      (mrg2 l7 (local-out l7)))))
+
+(audition (out 0 (tank (rallpasses (add bang (mix-fill 8 pling))))))

rsc3/examples/graph/tgb.scm

@@ -0,0 +1,61 @@
+;; tgb (rd)
+
+(import (rnrs) (rsc3))
+
+(define mkls
+  (lambda (bp t)
+    (env-gen kr 1 1 0 1 remove-synth (env-bp-linear bp t 1))))
+
+(define pm/t
+  (lambda (l r d t)
+    (let ((le (mkls l d))
+          (re (mkls r d)))
+      (t-rand le re t))))
+
+(define wrp
+  (lambda (i l r)
+    (let ((m (fdiv (sub r l) 2)))
+      (mul-add i m (add l m)))))
+
+(define pm/n
+  (lambda (rt l r d)
+    (let ((le (mkls l d))
+          (re (mkls r d)))
+      (wrp (white-noise rt) le re))))
+
+(define gb
+  (lambda (b d)
+    (let* ((gps (pm/n ar
+                      (list 0 400 1 0900)
+                      (list 0 600 1 1200)
+                      d))
+           (t (impulse ar gps 0))
+           (dur (pm/t (list 0 0.005 0.5 0.015 1 0.005)
+                      (list 0 0.009 0.5 0.020 1 0.009)
+                      d
+                      t))
+           (pan (pm/t (list 0 -1.0 0.5 -0.5 1 0.5)
+                      (list 0 -0.5 0.5 +0.5 1 1.0)
+                      d
+                      t))
+           (rate (pm/t (list 0 06 0.5 12 1 06)
+                       (list 0 12 0.5 12 1 12)
+                       d
+                       t))
+           (cpos (pm/t (list 0 0 1 0.95)
+                       (list 0 0 1 1.00)
+                       d
+                       t))
+           (amp (pm/t (list 0 0.25 0.5 0.55 1.0 0.15)
+                      (list 0 0.50 0.5 0.75 1.0 0.25)
+                      d
+                      t)))
+      (t-grains 2 t b rate (mul cpos (buf-dur kr b)) dur pan amp 2))))
+
+(define tgb
+  (lambda (fn)
+    (lambda (fd)
+      (async fd (b-alloc-read 10 fn 0 0))
+      (play fd (out 0 (gb 10 7))))))
+
+(with-sc3 (tgb "/home/rohan/data/audio/pf-c5.snd"))

rsc3/examples/graph/tgr-rpr.scm

@@ -0,0 +1,51 @@
+;; tgr-rpr (rd)
+
+(import (rnrs) (sosc) (rsc3))
+
+(define dust-r
+  (lambda (r lo hi)
+    (let ((d (dseq dinf (dwhite 1 lo hi))))
+      (t-duty r d 0 0 (u:abs (white-noise r)) 1))))
+
+(define rpr
+  (lambda (n t)
+    (let ((i (in 2 kr n)))
+      (t-rand (mce-channel i 0) (mce-channel i 1) t))))
+
+(define r-set
+  (lambda (r)
+    (if (> r 0.5)
+        (list (random 0.005 0.025) (random 0.05 0.25)
+              (random 0.75 0.95)   (random 1.05 1.25)
+              (random 0.001 0.01)  (random 0.02 0.04)
+              (random 0.1 0.2)     (random 0.2 0.4)
+              (random 0.0 0.45)    (random 0.55 1.0)
+              (random -1 0)        (random 0 1.0))
+        (list (random 0.005 0.025) (random 0.05 0.25)
+              (random -1.25 -1.05) (random -0.95 -0.75)
+              (random 0.001 0.01)  (random 0.02 0.04)
+              (random 0.1 0.2)     (random 0.2 0.4)
+              (random 0.0 0.45)    (random 0.55 1.0)
+              (random -1 0)        (random 0 1.0)))))
+
+(define tgr-rpr
+  (lambda (b)
+    (let* ((clk (dust-r ar (in 1 kr 0) (in 1 kr 1)))
+           (rat (rpr 2 clk))
+           (dur (rpr 4 clk))
+           (pos (mul (rpr 8 clk) (buf-dur kr b)))
+           (pan (rpr 10 clk))
+           (amp (rpr 6 clk)))
+      (t-grains 2 clk b rat pos dur pan amp 2))))
+
+(define pattern
+  (lambda (fd)
+    (send fd (c-setn1 0 (r-set (random 0 1))))
+    (thread-sleep (choose (list 0.25 0.75 1.5)))
+    (pattern fd)))
+
+(with-sc3
+ (lambda (fd)
+   (async fd (b-alloc-read 10 "/home/rohan/data/audio/pf-c5.snd" 0 0))
+   (play fd (out 0 (tgr-rpr 10)))
+   (pattern fd)))

rsc3/examples/graph/theremin.scm

@@ -0,0 +1,15 @@
+;; theremin (jmcc)
+
+(import (rnrs) (rsc3))
+
+(define theremin
+  (let* ((mod 7)
+         (detune 0)
+         (x (mouse-x kr 0 0.9 0 0.2))
+         (y (mouse-y kr 4000 200 1 0.8))
+         (f (add y detune))
+         (f* (add f (mul3 f (sin-osc ar mod 0) 0.02)))
+         (a (mul (sin-osc ar f* 0) x)))
+    (pan2 a 0 1)))
+
+(audition (out 0 theremin))

rsc3/examples/graph/three-cpsw.scm

@@ -0,0 +1,16 @@
+;; three-cpsw (rd)
+
+(import (rnrs) (rsc3))
+
+(define three-cpsw
+  (let* ((t (dust kr (mce2 12 18)))
+         (f0 (t-rand 1 64 t))
+         (f1 (lf-noise0 kr f0))
+         (a  (t-rand 0.0 0.5 t))
+         (dt (t-rand 0.975 1.025 t))
+         (dh (t-rand 0.750 0.7505 t))
+         (f (mul-add f1 (mce2 9000 12000) 9500))
+         (o (add3 (saw ar f) (saw ar (mul f dh)) (saw ar (mul f dt)))))
+    (clip2 (mul o a) 0.75)))
+
+(audition (out 0 three-cpsw))

rsc3/examples/graph/tipnso.scm

@@ -0,0 +1,17 @@
+;; tipnso.scm (rd)
+
+(import (rnrs) (rsc3))
+
+(define tipnso
+  (let* ((t (impulse ar (mouse-x kr 1 32 0 0.1) 0))
+         (e (decay2 t 0.01 (mce2 0.1 0.15)))
+         (n (ti-rand 16 72 t))
+         (f (midi-cps (add n (add 36 (mul 12 (ti-rand 0 1 t)))))))
+    (mrg2 (mul (add (mul (sin-osc ar f 0) e)
+                    (bpf (mul (pink-noise ar) e)
+                         (add 36 (midi-cps n))
+                         (fdiv 175 (midi-cps n))))
+               (mce2 0.15 0.1))
+          (send-trig t 0 n))))
+
+(audition (out 0 tipnso))

rsc3/examples/graph/tr-out.scm

@@ -0,0 +1,26 @@
+;; tr-out (rd)
+
+(import (rnrs) (rhs) (sosc) (rsc3))
+
+(define tr-out
+  (let* ((node
+          (lambda (n)
+            (let* ((t (dust kr 1.6))
+                   (f (midi-cps (buf-rd-n 1 kr 0 (t-rand 0 6 t) 0)))
+                   (p (buf-rd-n 1 kr 1 (t-rand 0 6 t) 0))
+                   (a (buf-rd-n 1 kr 2 (t-rand 0 6 t) 0)))
+              (tuple2 (pan2 (sin-osc ar f 0) p a)
+                      (send-trig t n (fdiv f 660))))))
+         (ns (map node (enum-from-to 1 4))))
+    (mrg-n (cons (foldl1 add (map fst ns))
+                 (map snd ns)))))
+
+(with-sc3
+ (lambda (fd)
+   (async fd (b-alloc 0 6 1))
+   (send fd (b-setn1 0 0 (list 60 62 64 65 67 69)))
+   (async fd (b-alloc 1 6 1))
+   (send fd (b-setn1 1 0 (list -1 -0.5 0 0.25 0.75 1.0)))
+   (async fd (b-alloc 2 6 1))
+   (send fd (b-setn1 2 0 (list 0.01 0.05 0.1 0.15 0.25 0.35)))
+   (play fd (out 0 tr-out))))

rsc3/examples/graph/trkl.scm

@@ -0,0 +1,26 @@
+;; trkl (rd)
+
+(import (rnrs) (rsc3))
+
+(define trkl
+  (lambda (d ul fu dy la fy)
+    (let* ((tf (x-line kr 1 ul d remove-synth))
+           (st (impulse ar (mul tf 8) 0))
+           (t  (impulse ar tf 0))
+           (a  (db-amp (line kr 12 la d remove-synth)))
+           (f  (x-line kr fu 900 d remove-synth))
+           (p  (line kr (rand -1 1) (rand -1 1) d remove-synth))
+           (fh (t-rand 1.75 2.25 t)))
+      (pan2 (add (mix (ringz (decay2 t 0.01 dy) (mce2 f (mul f fh)) fy))
+                 (mix (mul3 (saw ar (mce2 f (mul f fh)))
+                            (decay2 t 0.1 (t-rand 0.05 1.0 t))
+                            (t-exp-rand 0.001 0.25 st))))
+            p a))))
+
+(audition
+ (out 0 (trkl (rand 0.5 16)
+              (rand 16 64)
+              (rand 1200 9000)
+              (rand 0.005 0.175)
+              (rand -60 -25)
+              (rand 0.015 0.125))))

rsc3/examples/graph/trmlo.scm

@@ -0,0 +1,56 @@
+;; trmlo (rd)
+
+(import (rnrs) (rsc3))
+
+(define m-wrp
+  (lambda (i l r)
+    (lin-lin i -1 1 (midi-cps l) (midi-cps r))))
+
+(define m-wrp1
+  (lambda (i m)
+    (m-wrp i m (add m 1))))
+
+(define m-wrp-n
+  (lambda (i m n)
+    (m-wrp i m (add m n))))
+
+(define o1
+  (let* ((f 5)
+         (d 3)
+         (s (env-sine d 0.1))
+         (e (env-gen kr 1 1 0 1 do-nothing s))
+         (n 65)
+         (m (sin-osc kr f 0)))
+    (pan2 (sin-osc ar (m-wrp1 m n) 0) m e)))
+
+(define o2
+  (let* ((f (i-rand 5 9))
+         (d (i-rand 5 9))
+         (s (env-sine d (rand 0.1 0.2)))
+         (e (env-gen kr 1 1 0 1 do-nothing s))
+         (n (i-rand 69 72))
+         (m (sin-osc kr f 0)))
+    (pan2 (sin-osc ar (m-wrp1 m n) 0) m e)))
+
+(define o3
+  (let* ((f (i-rand 5 9))
+         (d (i-rand 9 12))
+         (s (env-sine d (rand 0.1 0.2)))
+         (e (env-gen kr 1 1 0 1 do-nothing s))
+         (n (i-rand 69 72))
+         (m (sin-osc kr f 0))
+         (l (line kr 0 (i-rand 1 5) d do-nothing)))
+    (pan2 (blip ar (m-wrp1 m (add n l)) (lin-lin m -1 1 1 2)) m e)))
+
+(define o4
+  (let* ((f (i-rand 5 18))
+         (d (i-rand 12 15))
+         (s (env-sine d (rand 0.1 0.2)))
+         (e (env-gen kr 1 0.05 0 1 do-nothing s))
+         (n (i-rand 69 72))
+         (m (sin-osc kr f 0))
+         (l (line kr 0 (i-rand 1 5) d remove-synth))
+         (fr (m-wrp-n m (add n l) (i-rand 1 5))))
+    (pan2 (blip ar fr (lin-lin m -1 1 1 (i-rand 2 24))) m e)))
+
+(audition (out 0 (add4 o1 o2 o3 o4)))

rsc3/examples/graph/tsort.scm

@@ -0,0 +1,22 @@
+;; tsort (jmcc)
+
+;; This simple graph tests the topological sort of the unit generator
+;; graph, it ought only to use a minimal number of interconnect buffers.
+
+;; The below 369 node graph works with 'scsynth -u 57110 -w 2'.
+
+;; (Note that graphs loaded from disk during startup will grow the number
+;; of interconnect buffers, so to test this we must delete all graphs that
+;; would otherwise be loaded.)
+
+(import (rnrs) (rsc3))
+
+(define tsort
+  (let* ((n 122)
+         (c (env-bp '(0 0 0.15 1 6 0) 1 1 '(1 1 1)))
+         (e (env-gen kr 1 1 0 1 remove-synth c))
+         (f (lambda (o) (mul (sin-osc ar (add 440 o) 0) 0.001)))
+         (s (mix-fill n f)))
+  (mul s e)))
+
+(audition (out 0 tsort))

rsc3/examples/graph/vla-adttn.scm

@@ -0,0 +1,145 @@
+;; vla-adttn (rd)
+
+(import (rnrs) (rhs) (sosc) (rsc3))
+
+(define vla
+  '((-49.43290 1.99165)
+    (0.00000 1.09187)
+    (-2.53835 -2.73340)
+    (-8.55317 0.73919)
+    (-7.58952 -0.75267)
+    (-8.48353 1.70372)
+    (-13.92700 1.64759)
+    (-39.93130 -2.25142)
+    (-19.87800 -3.12024)
+    (-34.19660 -1.58899)
+    (-18.82040 -1.39847)
+    (-21.22520 2.04672)
+    (-21.33070 -0.14754)
+    (-31.08620 2.05345)
+    (-42.51880 -0.55890)
+    (-41.19730 0.23896)
+    (-46.80570 1.71249)
+    (-47.17510 2.37942)
+    (-37.97520 -0.83005)
+    (-38.32750 -2.49358)
+    (-44.79280 -1.16301)
+    (-49.11850 1.33082)
+    (-45.26480 -0.45146)
+    (-46.27050 -0.15578)
+    (-63.14360 -3.13979)
+    (-44.27590 -2.59826)
+    (-40.19680 -2.16540)
+    (-56.83330 0.48774)
+    (-56.62160 -0.84155)
+    (-55.76370 1.59076)
+    (-59.36050 -0.99090)
+    (-55.42520 -0.58264)
+    (-64.99020 0.00110)
+    (-63.45910 1.55117)
+    (-64.77610 2.68228)
+    (-68.27080 -1.82120)
+    (-71.90240 1.80545)
+    (-79.13910 2.99369)
+    (-64.94640 -3.12388)
+    (-59.41810 1.84679)
+    (-86.33570 1.81713)
+    (-88.53500 1.01834)
+    (-64.17470 -1.52081)
+    (-61.24430 1.45757)
+    (-69.88980 -0.47708)
+    (-65.39420 0.82882)
+    (-73.84740 0.41623)
+    (-72.26330 0.31856)
+    (-73.88560 2.64035)
+    (-70.86610 -0.43802)
+    (-67.86130 -0.43389)
+    (-80.76020 -2.50016)
+    (-66.44520 2.26219)
+    (-83.49810 2.57825)
+    (-66.01220 -2.08254)
+    (-65.30220 -2.83644)
+    (-74.05780 0.21665)
+    (-72.69060 -2.78729)
+    (-75.49700 2.96210)
+    (-69.45200 0.72293)
+    (-75.36160 0.14687)
+    (-70.21110 1.42155)
+    (-79.34420 0.76044)
+    (-81.56200 2.16997)
+    (-84.20670 3.11095)
+    (-74.40450 -2.98094)
+    (-76.67820 1.96564)
+    (-79.95980 2.68183)
+    (-77.31420 -1.92260)
+    (-74.60450 -1.89189)
+    (-67.98670 1.99457)
+    (-80.17960 -1.95013)
+    (-79.44400 -2.70955)
+    (-81.89010 3.12971)
+    (-80.18220 1.76888)
+    (-82.94420 2.77531)))
+
+(define prep
+  (lambda (p)
+    (let ((ampl (list-ref p 0))
+          (phase (list-ref p 1)))
+      (list (s:db-amp ampl) phase))))
+
+(define vla-partial
+  (lambda (freq rise fall detune)
+    (lambda (n)
+      (let* ((m (* n 2))
+             (ampl (buf-rd 1 kr 0 m 0 0))
+             (phase (buf-rd 1 kr 0 (+ m 1) 0 0)))
+        (mul (f-sin-osc ar
+                        (mul3 freq
+                              (+ n 1)
+                              (mul-add (lf-noise1 kr 1) detune 1.0))
+                        phase)
+             (linen (impulse kr 0 0)
+                    (mul rise (rand 0.75 1.25))
+                    ampl
+                    (mul fall (rand 0.75 1.25))
+                    do-nothing))))))
+
+(define vla-plyr
+  (lambda (n)
+    (letc ((buf 0)
+           (ampl 0.1)
+           (freq 129.897)
+           (rise 0.1)
+           (fall 0.5)
+           (loc 0.0)
+           (detune 0.001))
+      (let ((s (foldl1 add (map (vla-partial freq rise fall detune)
+                                (enum-from-to 0 (- n 1))))))
+        (mrg2 (detect-silence s 0.001 0.2 remove-synth)
+              (out 0 (pan2 s loc ampl)))))))
+
+(define vla-get-cps
+  (lambda (b)
+    (midi-cps (+ (choose b)
+                 (s:degree-to-key (choose (list 0 1 2 3 4 5 6 7 8))
+                                  (list 0 2 3 5 7 8 10)
+                                  12)))))
+
+(define pattern
+  (lambda (fd)
+    (send fd (s-new "plyr36" -1 add-to-tail 1
+                    (list "buf" 0
+                          "loc" (random -1 1)
+                          "ampl" (random 0.05 0.1)
+                          "freq" (vla-get-cps (list 24 36))
+                          "detune" (random 0.001 0.005)
+                          "rise" (random 1 2)
+                          "fall" (random 4 7))))
+    (thread-sleep 5)
+    (pattern fd)))
+
+(with-sc3
+ (lambda (fd)
+   (async fd (b-alloc 0 (* (length vla) 2) 1))
+   (send fd (b-setn1 0 0 (flatten (map prep vla))))
+   (send-synth fd "plyr36" (vla-plyr 36))
+   (pattern fd)))

rsc3/examples/graph/vlc-distrtn.scm

@@ -0,0 +1,143 @@
+;; vlc-distrtn (rd)
+;; caution - audio feedback graph
+
+(import (rnrs) (rhs) (sosc) (rsc3))
+
+(define prep
+  (lambda (p)
+    (let ((ampl (list-ref p 0))
+          (phase (list-ref p 1)))
+      (list (s:db-amp ampl) phase))))
+
+(define vlc
+  '((0.00000 1.85550)
+    (-9.92383 -0.65147)
+    (-8.74205 -0.74728)
+    (-3.70464 -1.39796)
+    (-9.43435 -1.14812)
+    (-25.84790 -1.03375)
+    (-16.99500 -2.41724)
+    (-29.17040 2.67419)
+    (-26.82750 -1.61810)
+    (-18.59870 1.34568)
+    (-19.72160 -2.85972)
+    (-29.43650 0.54603)
+    (-23.63120 -1.47813)
+    (-28.20100 -1.98501)
+    (-41.20700 -1.11808)
+    (-33.14310 -2.19369)
+    (-31.54010 1.43134)
+    (-47.62740 1.28571)
+    (-28.79740 -1.03754)
+    (-34.97950 0.37740)
+    (-39.05770 -0.57557)
+    (-38.84060 2.34836)
+    (-40.18090 -0.96978)
+    (-47.32150 2.14768)
+    (-45.49290 2.52100)
+    (-40.57100 -1.39905)
+    (-47.19530 -2.23994)
+    (-50.80920 2.97853)
+    (-48.13640 0.46815)
+    (-58.56890 -1.01821)
+    (-57.81200 -3.08971)
+    (-47.96870 -0.48657)
+    (-43.96100 -0.10311)
+    (-50.49810 -2.80977)
+    (-50.61640 -0.17212)
+    (-60.64640 -1.02433)
+    (-58.03410 1.06921)
+    (-55.46390 -2.04501)
+    (-54.31000 -1.53512)
+    (-52.78670 -1.49875)
+    (-57.99380 0.17697)
+    (-56.76990 2.28241)
+    (-54.17450 -1.85553)
+    (-62.58220 -2.40971)
+    (-59.86460 1.04782)
+    (-61.58570 1.56183)
+    (-52.62080 1.68360)
+    (-49.82940 -1.11019)
+    (-56.18160 -0.78538)
+    (-57.73320 -2.23918)
+    (-49.87560 3.09604)
+    (-51.00100 -0.53762)
+    (-59.71530 0.99017)
+    (-65.73280 2.43855)
+    (-73.01270 -0.90664)
+    (-61.81450 -0.53346)
+    (-65.58980 1.51174)
+    (-75.94320 -3.06072)
+    (-65.22210 -1.49937)
+    (-70.79970 -2.96199)
+    (-64.72450 1.78172)
+    (-73.24130 0.26939)
+    (-66.17110 -0.23305)
+    (-61.32910 -3.12592)
+    (-66.98180 0.64700)
+    (-65.23060 -2.94395)
+    (-70.13430 1.29805)
+    (-68.43470 -1.35906)
+    (-71.33000 -2.71582)
+    (-86.90080 2.11646)
+    (-74.97450 2.76118)
+    (-68.02520 0.94979)
+    (-67.32960 3.05994)
+    (-67.32140 -2.79905)
+    (-68.22010 -2.33831)))
+
+(define vlc-partial
+  (lambda (in freq detune fall)
+    (lambda (n)
+      (let* ((m (* n 2))
+             (ampl (buf-rd 1 kr 0 m 0 0)))
+        (mul (ringz in
+                    (mul3 freq
+                          (+ n 1)
+                          (mul-add (lf-noise1 kr 1) detune 1.0))
+                    (mul fall (rand 0.75 1.25)))
+             ampl)))))
+
+(define vlc-plyr
+  (lambda (n)
+    (letc ((buf 0)
+           (iamp 0.1)
+           (ampl 0.1)
+           (freq 129.897)
+           (fall 0.5)
+           (loc 0.0)
+           (detune 0.001))
+      (let* ((i (mul (sound-in 4) iamp))
+             (s (foldl1 add
+                        (map (vlc-partial i freq detune fall)
+                             (enum-from-to 0 (- n 1))))))
+        (mrg2 (detect-silence s 0.001 0.2 remove-synth)
+              (out 0 (clip2 (pan2 s loc ampl) 0.1)))))))
+
+(define vlc-get-cps
+  (lambda (b)
+    (midi-cps (+ (choose b)
+                 (s:degree-to-key (choose (list 0 1 2 3 4 5 6 7 8))
+                                  (list 0 2 3 5 7 8 10)
+                                  12)))))
+
+(define pattern
+  (lambda (fd)
+    (send fd (n-set1 1002 "freq" (vlc-get-cps (list 24 36 48 60))))
+    (send fd (n-set1 1002 "iamp" (random 0.5 0.75)))
+    (thread-sleep (choose (list 0.5 0.75 1.5 3.0)))
+    (pattern fd)))
+
+(with-sc3
+ (lambda (fd)
+   (async fd (b-alloc 0 (* (length vlc) 2) 1))
+   (send fd (b-setn1 0 0 (flatten (map prep vlc))))
+   (send-synth fd "vlc-plyr48" (vlc-plyr 48))
+   (send fd (s-new "vlc-plyr48" 1002 add-to-tail 1
+                   (list "buf" 0
+                         "loc" (random -1 1)
+                         "ampl" (random 0.05 0.1)
+                         "freq" (vlc-get-cps (list 48 55 60))
+                         "detune" (random 0.001 0.005)
+                         "fall" (random 1 7))))
+   (pattern fd)))

rsc3/examples/graph/voscil.scm

@@ -0,0 +1,33 @@
+;; voscil (rd)
+
+(import (rnrs) (rhs) (sosc) (rsc3))
+
+(define voscil
+  (lambda (b)
+    (let* ((hb (/ (- b 1) 2))
+           (r 6)
+           (f 600))
+      (add
+       (pan2 (add (v-osc ar (mul-add (lf-noise0 kr r) hb hb) (* f 2) 0)
+                  (mul (blip ar
+                             (mul-add (lf-noise0 kr r) 40 600)
+                             (mul-add (lf-noise0 kr r) 16 24))
+                       (mul-add (lf-noise0 kr r) 0.1 0.1)))
+             (lf-noise0 kr r)
+             (mul-add (lf-noise0 kr r) 0.5 0.5))
+       (pan2 (v-osc ar (mul-add (lf-saw kr (/ 1 r) 0) hb hb) f 0)
+             (lf-noise0 kr r)
+             (mul-add (lf-noise0 kr r) 0.5 0.5))))))
+
+(let ((n (* 8192 4))
+      (b 32))
+  (with-sc3
+   (lambda (fd)
+     (for-each
+      (lambda (i)
+        (async fd (b-alloc i n 1))
+        (replicate-m
+         (i-random 2 512)
+         (send fd (b-set1 i (i-random 0 n) (random -1 1)))))
+      (enum-from-to 0 (- b 1)))
+     (play fd (out 0 (voscil b))))))

rsc3/examples/graph/what-was-i-thinking.scm

@@ -0,0 +1,21 @@
+;; what was i thinking? (jmcc)
+
+(import (rnrs) (rsc3))
+
+(define what-was-i-thinking
+  (let* ((n0 (mul-add (lf-noise1 kr 0.2) 2000 2400))
+         (n1 (mul-add (lf-noise1 kr 0.157) 0.4 0.5))
+         (i (mul3 (lf-pulse ar 0.1 0 0.05) (impulse ar 8 0) 500))
+         (d (decay i 2))
+         (f (u:max (add (sin-osc kr 4 0) 80) d))
+         (p (mul (pulse ar f n1) 0.04))
+         (z (rlpf p n0 0.2))
+         (c (lambda (x)
+              (let* ((r (rand 0 0.3))
+                     (n (mul-add (lf-noise1 kr r) 0.025 0.035)))
+                (comb-l x 0.06 n 1))))
+         (y (mul z 0.6)))
+    (add z (mce2 (add (c y) (c y))
+                 (add (c y) (c y))))))
+
+(audition (out 0 what-was-i-thinking))

rsc3/examples/graph/wial.scm

@@ -0,0 +1,43 @@
+;; wial (rd)
+
+(import (rnrs) (rhs) (rsc3))
+
+(define pls
+  (lambda (clk div frq)
+    (let* ((t (pulse-divider clk div 0))
+           (e (decay2 t 0.05 0.75))
+           (f (mul-add (toggle-ff t) frq (mul 2 frq))))
+      (foldl1 mul (list (sin-osc ar f 0)
+                        e
+                        (ti-rand 0 1 t)
+                        0.5)))))
+
+(define plss
+  (lambda (clk descr)
+    (mix
+     (make-mce
+      (map (lambda (l)
+             (let ((d (list-ref l 0))
+                   (f (list-ref l 1))
+                   (a (list-ref l 2)))
+               (mul (pls clk d f) a)))
+           descr)))))
+
+(define smpl
+ (lambda (f)
+   (list (list (mce2 4 6)          f  0.75)
+         (list (mce2 2 6) (mul f   2) 0.75)
+         (list (mce2 1 2) (mul f  16) 0.025)
+         (list (mce2 1 5) (mul f  64) 0.005)
+         (list (mce2 1 3) (mul f 128) 0.035)
+         (list (mce2 1 4) (mul f 256) 0.15)
+         (list (mce2 2 3) (mul f 512) 0.35))))
+
+(define wial
+  (let ((clk (impulse ar 16 0)))
+    (plss clk (smpl (tw-choose (dust kr 1)
+                               (mce2 (* 20 2/3) 20)
+                               (mce2 0.25 0.75)
+                               0)))))
+
+(audition (out 0 wial))

rsc3/examples/graph/wind-metals.scm

@@ -0,0 +1,19 @@
+;; wind-metals (jmcc)
+
+(import (rnrs) (rhs) (rsc3))
+
+(define wind-metals
+  (let* ((n 6)
+         (base (exp-rand 60 4000))
+         (range (rand 500 8000))
+         (n0 (clone 2 (brown-noise ar)))
+         (r0 (exp-rand 0.125 0.5))
+         (n1 (lf-noise1 kr r0))
+         (f (replicate-m n (rand base (add base range))))
+         (dt (replicate-m n (rand 0.1 2)))
+         (exc (mul3 n0 0.007 (u:max 0 (mul-add n1 0.75 0.25))))
+         (k (klank-data f (replicate n 1) dt))
+         (s (klank exc 1 0 1 k)))
+    (soft-clip (mul s 0.1))))
+
+(audition (out 0 wind-metals))

rsc3/examples/graph/xy-interference.scm

@@ -0,0 +1,15 @@
+;; xy-interference (rd)
+
+(import (rnrs) (rsc3))
+
+(define xy-interference
+  (let* ((x (mouse-x kr 20 22000 1 (mce2 0.005 0.025)))
+         (y (mouse-y kr 20 22000 1 (mce2 0.005 0.075)))
+         (nd (lambda (_)
+               (let* ((n (lf-noise0 kr (mce2 5 9)))
+                      (a (sin-osc ar (add x n) 0))
+                      (b (sin-osc ar y 0)))
+                 (mul a b)))))
+    (mix-fill 3 nd)))
+
+(audition (out 0 xy-interference))

rsc3/examples/server-command/b-alloc.help.scm

@@ -0,0 +1,10 @@
+; /b_alloc                                Allocate buffer space.
+
+; int - buffer number
+; int - number of frames
+; int - number of channels (optional. default = 1 channel)
+; bytes - an OSC message to execute upon completion. (optional)
+
+; Allocates zero filled buffer to number of channels and samples.
+
+; Asynchronous. Replies to sender with /done when complete.

rsc3/examples/server-command/b-allocRead.help.scm

@@ -0,0 +1,16 @@
+; /b_allocRead           Allocate buffer space and read a sound file.
+
+; int - buffer number
+; string - path name of a sound file.
+; int - starting frame in file (optional. default = 0)
+; int - number of frames to read (optional. default = 0, see below)
+; bytes - an OSC message to execute upon completion. (optional)
+
+; Allocates buffer to number of channels of file and number of samples
+; requested, or fewer if sound file is smaller than requested. Reads
+; sound file data from the given starting frame in the file. If the
+; number of frames argument is less than or equal to zero, the entire
+; file is read.
+
+; Asynchronous. Replies to sender with /done when complete.
+

rsc3/examples/server-command/b-close.help.scm

@@ -0,0 +1,6 @@
+; /b_close
+
+; int - buffer number
+	
+; After using a buffer with DiskOut, close the soundfile and write
+; header information.

rsc3/examples/server-command/b-fill.help.scm

@@ -0,0 +1,13 @@
+; /b_fill                              Fill ranges of sample value(s)
+
+; int - buffer number
+; [
+;  int - sample starting index
+;  int - number of samples to fill (M)
+;  float - value
+; ] * N
+	
+; Set contiguous ranges of sample indices to single values. For each
+; range, the starting sample index is given followed by the number of
+; samples to change, followed by the value to fill. This is only meant
+; for setting a few samples, not whole buffers or large sections.

rsc3/examples/server-command/b-free.help.scm

@@ -0,0 +1,8 @@
+; /b_free                                    Free buffer data.
+
+; int - buffer number
+; bytes - an OSC message to execute upon completion. (optional)
+
+; Frees buffer space allocated for this buffer.
+
+; Asynchronous. Replies to sender with /done when complete.