diff --git a/README b/README
new file mode 100644
--- /dev/null
+++ b/README
@@ -0,0 +1,11 @@
+hsc3-graphs - haskell supercollider graphs
+
+hsc3-graphs provides a collection of illustrative 
+unit generator graphs for hsc3.
+
+  http://slavepianos.org/rd/?t=hsc3-graphs
+  http://haskell.org/
+  http://audiosynth.com/
+
+(c) rohan drape and others, 2006-2010
+    gpl, http://gnu.org/copyleft/
diff --git a/Setup.lhs b/Setup.lhs
new file mode 100644
--- /dev/null
+++ b/Setup.lhs
@@ -0,0 +1,3 @@
+#!/usr/bin/env runhaskell
+> import Distribution.Simple
+> main = defaultMain
diff --git a/hsc3-graphs.cabal b/hsc3-graphs.cabal
new file mode 100644
--- /dev/null
+++ b/hsc3-graphs.cabal
@@ -0,0 +1,413 @@
+Name:              hsc3-graphs
+Version:           0.8
+Synopsis:          Haskell SuperCollider Graphs
+Description:       hsc3-graphs provides a collection of illustrative 
+                   unit generator graphs for hsc3.
+License:           GPL
+Category:          Sound
+Copyright:         (c) Rohan Drape and others, 2006-2010
+Author:            Rohan Drape
+Maintainer:        rd@slavepianos.org
+Stability:         Experimental
+Homepage:          http://slavepianos.org/rd/?t=hsc3-graphs
+Tested-With:       GHC == 6.10.3
+Build-Type:        Simple
+Cabal-Version:     >= 1.6
+
+Data-files:        README
+
+Executable         hsc3-adso
+ main-is:          src/adso.lhs
+ build-depends:    base==4.*, hosc==0.8, hsc3==0.8, random
+
+Executable         hsc3-aleatoric-quartet
+ main-is:          src/aleatoric-quartet.lhs
+ build-depends:    base==4.*, hsc3==0.8
+
+Executable         hsc3-analog-bubbles
+ main-is:          src/analog-bubbles.lhs
+ build-depends:    base==4.*, hsc3==0.8
+
+Executable         hsc3-babbling-brook
+ main-is:          src/babbling-brook.lhs
+ build-depends:    base==4.*, hsc3==0.8
+
+Executable         hsc3-birds
+ main-is:          src/birds.lhs
+ build-depends:    base==4.*, hsc3==0.8
+
+Executable         hsc3-bit-reduction
+ main-is:          src/bit-reduction.lhs
+ build-depends:    base==4.*, hsc3==0.8
+
+Executable         hsc3-bottle
+ main-is:          src/bottle.lhs
+ build-depends:    base==4.*, hsc3==0.8
+
+Executable         hsc3-bowed-string
+ main-is:          src/bowed-string.lhs
+ build-depends:    base==4.*, hsc3==0.8
+
+Executable         hsc3-ccomb
+ main-is:          src/ccomb.lhs
+ build-depends:    base==4.*, hsc3==0.8
+
+Executable         hsc3-chain-saw
+ main-is:          src/chain-saw.lhs
+ build-depends:    base==4.*, hsc3==0.8
+
+Executable         hsc3-chrd
+ main-is:          src/chrd.lhs
+ build-depends:    base==4.*, hsc3==0.8
+
+Executable         hsc3-cricket
+ main-is:          src/cricket.lhs
+ build-depends:    base==4.*, hsc3==0.8
+
+Executable         hsc3-crotale
+ main-is:          src/crotale.lhs
+ build-depends:    base==4.*, hsc3==0.8
+
+Executable         hsc3-cut-outs
+ main-is:          src/cut-outs.lhs
+ build-depends:    base==4.*, hsc3==0.8
+
+Executable         hsc3-cymbalism
+ main-is:          src/cymbalism.lhs
+ build-depends:    base==4.*, hsc3==0.8
+
+Executable         hsc3-deep-sea
+ main-is:          src/deep-sea.lhs
+ build-depends:    base==4.*, hsc3==0.8
+
+Executable         hsc3-default
+ main-is:          src/default.lhs
+ build-depends:    base==4.*, hsc3==0.8
+
+Executable         hsc3-demanding-studies
+ main-is:          src/demanding-studies.lhs
+ build-depends:    base==4.*, hsc3==0.8
+
+Executable         hsc3-dial-history
+ main-is:          src/dial-history.lhs
+ build-depends:    base==4.*, hsc3==0.8
+
+Executable         hsc3-diffraction
+ main-is:          src/diffraction.lhs
+ build-depends:    base==4.*, hsc3==0.8
+
+Executable         hsc3-discretion
+ main-is:          src/discretion.lhs
+ build-depends:    base==4.*, hsc3==0.8
+
+Executable         hsc3-drummer
+ main-is:          src/drummer.lhs
+ build-depends:    base==4.*, hsc3==0.8
+
+Executable         hsc3-eggcrate
+ main-is:          src/eggcrate.lhs
+ build-depends:    base==4.*, hsc3==0.8
+
+Executable         hsc3-e-lamell
+ main-is:          src/e-lamell.lhs
+ build-depends:    base==4.*, hsc3==0.8
+
+Executable         hsc3-fbl-fbf
+ main-is:          src/fbl-fbf.lhs
+ build-depends:    base==4.*, hsc3==0.8
+
+Executable         hsc3-feedr
+ main-is:          src/feedr.lhs
+ build-depends:    base==4.*, hsc3==0.8
+
+Executable         hsc3-f-lets
+ main-is:          src/f-lets.lhs
+ build-depends:    base==4.*, hsc3==0.8
+
+Executable         hsc3-fm-iter
+ main-is:          src/fm-iter.lhs
+ build-depends:    base==4.*, hsc3==0.8
+
+Executable         hsc3-fm-kltr
+ main-is:          src/fm-kltr.lhs
+ build-depends:    base==4.*, hsc3==0.8
+
+Executable         hsc3-forest-sounds
+ main-is:          src/forest-sounds.lhs
+ build-depends:    base==4.*, hsc3==0.8
+
+Executable         hsc3-fwalk
+ main-is:          src/fwalk.lhs
+ build-depends:    base==4.*, hsc3==0.8
+
+Executable         hsc3-half-life
+ main-is:          src/half-life.lhs
+ build-depends:    base==4.*, hsc3==0.8
+
+Executable         hsc3-harmonic-swimming
+ main-is:          src/harmonic-swimming.lhs
+ build-depends:    base==4.*, hsc3==0.8
+
+Executable         hsc3-harmonic-tumbling
+ main-is:          src/harmonic-tumbling.lhs
+ build-depends:    base==4.*, hsc3==0.8
+
+Executable         hsc3-h-chatter
+ main-is:          src/h-chatter.lhs
+ build-depends:    base==4.*, hsc3==0.8
+
+Executable         hsc3-hh-808
+ main-is:          src/hh-808.lhs
+ build-depends:    base==4.*, hsc3==0.8
+
+Executable         hsc3-implosion
+ main-is:          src/implosion.lhs
+ build-depends:    base==4.*, hsc3==0.8
+
+Executable         hsc3-insects
+ main-is:          src/insects.lhs
+ build-depends:    base==4.*, hsc3==0.8
+
+Executable         hsc3-karplus-strong
+ main-is:          src/karplus-strong.lhs
+ build-depends:    base==4.*, hsc3==0.8
+
+Executable         hsc3-klink
+ main-is:          src/klink.lhs
+ build-depends:    base==4.*, hsc3==0.8
+
+Executable         hsc3-k-ppr
+ main-is:          src/k-ppr.lhs
+ build-depends:    base==4.*, hsc3==0.8
+
+Executable         hsc3-lfo-modulation
+ main-is:          src/lfo-modulation.lhs
+ build-depends:    base==4.*, hsc3==0.8
+
+Executable         hsc3-lf-pulses
+ main-is:          src/lf-pulses.lhs
+ build-depends:    base==4.*, hsc3==0.8
+
+Executable         hsc3-lg-timed
+ main-is:          src/lg-timed.lhs
+ build-depends:    base==4.*, hsc3==0.8
+
+Executable         hsc3-lin-sosc
+ main-is:          src/lin-sosc.lhs
+ build-depends:    base==4.*, hsc3==0.8
+
+Executable         hsc3-lucier
+ main-is:          src/lucier.hs
+ build-depends:    base==4.*, hsc3==0.8
+
+Executable         hsc3-modal-space
+ main-is:          src/modal-space.lhs
+ build-depends:    base==4.*, hsc3==0.8
+
+Executable         hsc3-moto-rev
+ main-is:          src/moto-rev.lhs
+ build-depends:    base==4.*, hsc3==0.8
+
+Executable         hsc3-mouse-clatter
+ main-is:          src/mouse-clatter.lhs
+ build-depends:    base==4.*, hsc3==0.8
+
+Executable         hsc3-nharm
+ main-is:          src/nharm.lhs
+ build-depends:    base==4.*, hsc3==0.8
+
+Executable         hsc3-noise-burst-sweep
+ main-is:          src/noise-burst-sweep.lhs
+ build-depends:    base==4.*, hsc3==0.8
+
+Executable         hsc3-non-real-time
+ main-is:          src/non-real-time.hs
+ build-depends:    base==4.*, hosc==0.8, hsc3==0.8, process
+
+Executable         hsc3-one-line
+ main-is:          src/one-line.lhs
+ build-depends:    base==4.*, hsc3==0.8
+
+Executable         hsc3-oscillator-cluster
+ main-is:          src/oscillator-cluster.lhs
+ build-depends:    base==4.*, hsc3==0.8
+
+Executable         hsc3-overlap-add
+ main-is:          src/overlap-add.lhs
+ build-depends:    base==4.*, hsc3==0.8
+
+Executable         hsc3-pattern-buffer
+ main-is:          src/pattern-buffer.lhs
+ build-depends:    base==4.*, hsc3==0.8
+
+Executable         hsc3-plucked-strings
+ main-is:          src/plucked-strings.lhs
+ build-depends:    base==4.*, hsc3==0.8
+
+Executable         hsc3-police-state
+ main-is:          src/police-state.lhs
+ build-depends:    base==4.*, hsc3==0.8
+
+Executable         hsc3-pulsing-bottles
+ main-is:          src/pulsing-bottles.lhs
+ build-depends:    base==4.*, hsc3==0.8
+
+Executable         hsc3-record-scratcher
+ main-is:          src/record-scratcher.lhs
+ build-depends:    base==4.*, hsc3==0.8
+
+Executable         hsc3-red-frik
+ main-is:          src/red-frik.lhs
+ build-depends:    base==4.*, hsc3==0.8
+
+Executable         hsc3-reset
+ main-is:          src/reset.hs
+ build-depends:    base==4.*, hsc3==0.8
+
+Executable         hsc3-reverberated-sine-percussion
+ main-is:          src/reverberated-sine-percussion.lhs
+ build-depends:    base==4.*, hsc3==0.8
+
+Executable         hsc3-rm-octaver
+ main-is:          src/rm-octaver.lhs
+ build-depends:    base==4.*, hsc3==0.8
+
+Executable         hsc3-sample-and-hold-liquidities
+ main-is:          src/sample-and-hold-liquidities.lhs
+ build-depends:    base==4.*, hsc3==0.8
+
+Executable         hsc3-s-chirp
+ main-is:          src/s-chirp.lhs
+ build-depends:    base==4.*, hsc3==0.8
+
+Executable         hsc3-scratchy
+ main-is:          src/scratchy.lhs
+ build-depends:    base==4.*, hsc3==0.8
+
+Executable         hsc3-scratchy-m
+ main-is:          src/scratchy-m.lhs
+ build-depends:    base==4.*, hsc3==0.8
+
+Executable         hsc3-scritto
+ main-is:          src/scritto.lhs
+ build-depends:    base==4.*, hsc3==0.8
+
+Executable         hsc3-shepard-tones
+ main-is:          src/shepard-tones.lhs
+ build-depends:    base==4.*, hsc3==0.8
+
+Executable         hsc3-shifting-pulses
+ main-is:          src/shifting-pulses.lhs
+ build-depends:    base==4.*, hsc3==0.8
+
+Executable         hsc3-snare-909
+ main-is:          src/snare-909.lhs
+ build-depends:    base==4.*, hsc3==0.8
+
+Executable         hsc3-sosc-lp
+ main-is:          src/sosc-lp.lhs
+ build-depends:    base==4.*, hsc3==0.8
+
+Executable         hsc3-spe
+ main-is:          src/spe.lhs
+ build-depends:    base==4.*, hsc3==0.8
+
+Executable         hsc3-sprinkler
+ main-is:          src/sprinkler.lhs
+ build-depends:    base==4.*, hsc3==0.8
+
+Executable         hsc3-sprinkler-m
+ main-is:          src/sprinkler-m.lhs
+ build-depends:    base==4.*, hsc3==0.8
+
+Executable         hsc3-strummable-guitar
+ main-is:          src/strummable-guitar.lhs
+ build-depends:    base==4.*, hsc3==0.8
+
+Executable         hsc3-sweepy-noise
+ main-is:          src/sweepy-noise.lhs
+ build-depends:    base==4.*, hsc3==0.8
+
+Executable         hsc3-synthetic-piano
+ main-is:          src/synthetic-piano.lhs
+ build-depends:    base==4.*, hsc3==0.8
+
+Executable         hsc3-tank
+ main-is:          src/tank.lhs
+ build-depends:    base==4.*, hsc3==0.8
+
+Executable         hsc3-tgb
+ main-is:          src/tgb.lhs
+ build-depends:    base==4.*, hsc3==0.8
+
+Executable         hsc3-tgrn
+ main-is:          src/tgrn.lhs
+ build-depends:    base==4.*, hsc3==0.8
+
+Executable         hsc3-tgr-rpr
+ main-is:          src/tgr-rpr.lhs
+ build-depends:    base==4.*, hsc3==0.8
+
+Executable         hsc3-theremin
+ main-is:          src/theremin.lhs
+ build-depends:    base==4.*, hsc3==0.8
+
+Executable         hsc3-three-cpsw
+ main-is:          src/three-cpsw.lhs
+ build-depends:    base==4.*, hsc3==0.8
+
+Executable         hsc3-thx
+ main-is:          src/thx.lhs
+ build-depends:    base==4.*, hsc3==0.8
+
+Executable         hsc3-tipnso
+ main-is:          src/tipnso.lhs
+ build-depends:    base==4.*, hsc3==0.8
+
+Executable         hsc3-train
+ main-is:          src/train.lhs
+ build-depends:    base==4.*, hsc3==0.8
+
+Executable         hsc3-trkl
+ main-is:          src/trkl.lhs
+ build-depends:    base==4.*, hsc3==0.8
+
+Executable         hsc3-tr-out
+ main-is:          src/tr-out.lhs
+ build-depends:    base==4.*, hsc3==0.8
+
+Executable         hsc3-tsort
+ main-is:          src/tsort.lhs
+ build-depends:    base==4.*, hsc3==0.8
+
+Executable         hsc3-vlc-distrtn
+ main-is:          src/vlc-distrtn.lhs
+ build-depends:    base==4.*, hsc3==0.8
+
+Executable         hsc3-waveset
+ main-is:          src/waveset.hs
+ build-depends:    array, base==4.*, hosc==0.8, hsc3==0.8, hsc3-sf==0.8, random
+
+Executable         hsc3-what-was-i-thinking
+ main-is:          src/what-was-i-thinking.lhs
+ build-depends:    base==4.*, hsc3==0.8
+
+Executable         hsc3-wial
+ main-is:          src/wial.lhs
+ build-depends:    base==4.*, hsc3==0.8
+
+Executable         hsc3-wind-metals
+ main-is:          src/wind-metals.lhs
+ build-depends:    base==4.*, hsc3==0.8
+
+Executable         hsc3-xy-interference
+ main-is:          src/xy-interference.lhs
+ build-depends:    base==4.*, hsc3==0.8
+
+Executable         hsc3-xy-interference-m
+ main-is:          src/xy-interference-m.lhs
+ build-depends:    base==4.*, hsc3==0.8
+
+Source-Repository  head
+  Type:            darcs
+  Location:        http://slavepianos.org/~rd/sw/hsc3-graphs/
diff --git a/src/adso.lhs b/src/adso.lhs
new file mode 100644
--- /dev/null
+++ b/src/adso.lhs
@@ -0,0 +1,34 @@
+adso (rd)
+
+> import Sound.OpenSoundControl
+> import Sound.SC3
+> import System.Random
+
+> main =
+>   let { rrand l r = getStdRandom (randomR (l, r))
+>       ; rrand_l j l r = sequence (replicate j (rrand l r))
+>       ; n = 24
+>       ; adso = let { get b j = let k = mce [0 .. constant j - 1]
+>                                in bufRdN 1 kr b k NoLoop
+>                    ; m = sinOsc kr (get 3 n) 0
+>                    ; f = midiCPS (get 0 n) * (m * get 4 n + 1)
+>                    ; l = get 2 n
+>                    ; g = get 1 n }
+>                in out 0 (mix (pan2 (sinOsc ar f 0) l g))
+>       ; pattern fd t = do { z <- do { l <- rrand 22 48
+>                                     ; r <- rrand 54 122
+>                                     ; sequence (replicate n (rrand l r)) }
+>                           ; send fd (b_setn1 0 0 z)
+>                           ; let rn i l r = do { d <- rrand_l n l r
+>                                               ; send fd (b_setn1 i 0 d) }
+>                             in do { 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 2.4 }
+>                           ; pauseThread t } }
+>   in withSC3 (\fd ->   do { mapM_ (\i ->   async fd (b_alloc i n 1)) [0..6]
+>                         ; play fd adso
+>                         ; mapM_ (pattern fd) =<< rrand_l 32 0.025 0.75
+>                         ; reset fd })
diff --git a/src/aleatoric-quartet.lhs b/src/aleatoric-quartet.lhs
new file mode 100644
--- /dev/null
+++ b/src/aleatoric-quartet.lhs
@@ -0,0 +1,52 @@
+aleatoric quartet (jmcc)
+
+> import Sound.SC3.Monadic
+
+> main = 
+>   let { base_mn = control KR "note" 66
+>       ; amp = control KR "ampl" 0.07
+>       ; density = mouseX kr 0.01 1 Linear 0.1
+>       ; dmul = recip density * 0.5 * amp
+>       ; dadd = amp - dmul
+>       ; (>=>) f g = \x ->   f x >>= g
+>       ; chain n f = foldl (>=>) return (replicate n f)
+>       ; rapf i = do { r <- clone 2 (rand 0 0.05)
+>                     ; return (allpassN i 0.05 r 1) }
+>       ; mk_f = do { i0 <- iRand 0 2
+>                   ; let r0 = select i0 (mce [1, 0.5, 0.25])
+>                     in do { r1 <- rand (-30) 30
+>                           ; n0 <- lfNoise0 kr r0
+>                           ; let { m = n0 * 7 + base_mn + r1
+>                                 ; m' = lag (roundE m 1) 0.2 }
+>                             in return (midiCPS m) } }
+>       ; mk_s = do { f <- fmap recip mk_f
+>                   ; r <- rand (-1) 1
+>                   ; x <- do { n0 <- pinkNoise ar
+>                             ; n1 <- lfNoise1 kr 8
+>                             ; return (n0 * max 0 (n1 * dmul + dadd)) }
+>                   ; return (pan2 (combL x 0.02 f 3) r 1) } }
+>   in do { g <- chain 5 rapf =<< fmap sum (sequence (replicate 4 mk_s))
+>         ; audition (out 0 (leakDC g 0.995)) }
+
+{ var amp = 0.07
+; var density = MouseX.kr(0.01, 1, 'linear', 0.1)
+; var dmul = density.reciprocal * 0.5 * amp
+; var dadd = amp - dmul
+; var rapf = { arg i
+             ; var r = Array.fill(2, { Rand(0, 0.05) })
+             ; AllpassN.ar(i, 0.05, r, 1) }
+; var mk_f = { var i0 = IRand.new(0, 2)
+             ; var r0 = Select.kr(i0, [1, 0.5, 0.25])
+             ; var r1 = Rand.new(-30, 30)
+             ; var n0 = LFNoise0.kr(r0)
+             ; var m = Lag.kr((n0 * 7 + 66 + r1).round(1), 0.2)
+             ; m.midicps }
+; var mk_s = { var f = mk_f.value.reciprocal
+             ; var r = Rand.new(-1, 1)
+             ; var n0 = PinkNoise.ar()
+             ; var n1 = LFNoise1.kr(8)
+             ; var x = n0 * 0.max(n1 * dmul + dadd)
+             ; Pan2.ar(CombL.ar(x, 0.02, f, 3), r, 1) }
+; var g = Mix.fill(4, mk_s)
+; 5.do({ g = rapf.value(g) })
+; Out.ar(0, LeakDC.ar(g, 0.995)) }.play
diff --git a/src/analog-bubbles.lhs b/src/analog-bubbles.lhs
new file mode 100644
--- /dev/null
+++ b/src/analog-bubbles.lhs
@@ -0,0 +1,14 @@
+analog bubbles (jmcc)
+
+> import Sound.SC3
+
+> main =
+>   let { o = lfSaw kr (mce2 8 7.23) 0 * 3 + 80
+>       ; f = lfSaw kr 0.4 0 * 24 + o
+>       ; s = sinOsc ar (midiCPS f) 0 * 0.04 }
+>   in audition (out 0 (combN s 0.2 0.2 4))
+
+{ var o = LFSaw.kr([8, 7.23], 0, 3, 80)
+; var f = LFSaw.kr(0.4, 0, 24, o)
+; var s = SinOsc.ar(f.midicps, 0, 0.04)
+; Out.ar(0, CombN.ar(s, 0.2, 0.2, 4)) }.play
diff --git a/src/babbling-brook.lhs b/src/babbling-brook.lhs
new file mode 100644
--- /dev/null
+++ b/src/babbling-brook.lhs
@@ -0,0 +1,23 @@
+babbling brook (jmcc)
+
+> import Sound.SC3.Monadic
+
+> main = 
+>   let b f m a g = do { n1 <- brownNoise ar
+>                      ; n2 <- brownNoise ar
+>                      ; let { n3 = lpf n2 f * m + a
+>                            ; n4 = onePole n1 0.99 }
+>                        in return (rhpf n4 n3 0.03 * g) }
+>   in do { x <- clone 2 (b 14 400 500 0.006)
+>         ; y <- clone 2 (b 20 800 1000 0.010)
+>         ; audition (out 0 (x + y)) }
+
+{ var b = { arg f, m, a, g 
+          ; { var n1 = OnePole.ar(BrownNoise.ar, 0.99)
+            ; var n2 = LPF.ar(BrownNoise.ar, f) 
+            ; RHPF.ar(n1, n2 * m + a, 0.03, g) } }
+; var x = b.value(14, 400, 500, 0.006) ! 2
+; var y = b.value(20, 800, 1000, 0.010) ! 2
+; Out.ar(0, x + y) }.play
+
+http://lists.create.ucsb.edu/pipermail/sc-users/2007-April/033239.html
diff --git a/src/birds.lhs b/src/birds.lhs
new file mode 100644
--- /dev/null
+++ b/src/birds.lhs
@@ -0,0 +1,28 @@
+birds (jmcc)
+
+> import Sound.SC3.Monadic
+
+> main =
+>   let { node = do { r1 <- rand 94.0 102.0
+>                   ; r2 <- rand (-1.5) 1.5
+>                   ; r3 <- rand 0.0 1.0
+>                   ; r4 <- rand 11.0 15.0
+>                   ; r5 <- rand 0.0 1.0
+>                   ; r6 <- rand 12.0 15.6
+>                   ; r7 <- rand 0.0 1.0
+>                   ; r8 <- rand (-1.0) 1.0
+>                   ; let { f = r1 + lag (lfSaw AR (7 + r2) r3 * r4) 0.1
+>                         ; a = lfPulse KR (1.0 / r6) r7 0.16 * 0.05
+>                         ; b = sinOsc AR (midiCPS f) r5 * a } 
+>                     in return (rotate2 b (silent 1) r8) }
+>       ; apf i = do { r1 <- rand 0.0 0.06
+>                    ; r2 <- rand 0.7 2.0
+>                    ; return (allpassL i 0.07 r1 r2) }
+>       ; composeM [] i = return i
+>       ; composeM (f:fs) i = f =<< composeM fs i
+>       ; chainM n f = composeM (replicate n f) }
+>   in do { d <- return . sum =<< sequence (replicate 6 node)
+>         ; w <- chainM 12 apf d
+>         ; audition (out 0 (d * 0.7 + w * 0.3)) }
+
+http://lists.create.ucsb.edu/pipermail/sc-users/2007-April/033239.html
diff --git a/src/bit-reduction.lhs b/src/bit-reduction.lhs
new file mode 100644
--- /dev/null
+++ b/src/bit-reduction.lhs
@@ -0,0 +1,37 @@
+bit reduction (adc)
+
+> import Sound.SC3.Monadic
+
+> sample_rate_decrease =
+>   do { f <- lfNoise2 kr 8
+>      ; nh <- lfNoise2 kr 3
+>      ; let { src = blip ar (f * 200 + 300) (nh * 10 + 20)
+>            ; sr = mouseX kr 1000 (sampleRate * 0.1) Exponential 0.2 }
+>        in audition (out 0 (latch src (impulse ar sr 0))) }
+
+{ var f = LFNoise2.kr(8)
+; var nh = LFNoise2.kr(3)
+; var src = Blip.ar(f * 200 + 300, nh * 10 + 20)
+; var sr = MouseX.kr(1000, s.sampleRate * 0.1, 'exponential', 0.2)
+; Out.ar(0, Latch.ar(src, Impulse.ar(sr, 0))) }.play
+
+> bit_rate_decrease =
+>   do { f <- lfNoise2 kr 8
+>      ; nh <- lfNoise2 kr 3
+>      ; let { src = blip ar (f * 200 + 300) (nh * 10 + 20)
+>            ; sr = mouseX kr 1000 (sampleRate * 0.1) Exponential 0.2
+>            ; bit_sz = mouseY kr 1 24 Exponential 0.2
+>            ; down_sample = latch src (impulse ar sr 0)
+>            ; bit_redux = roundE down_sample (0.5 ** bit_sz) }
+>        in audition (out 0 (mce2 down_sample bit_redux)) }
+
+{ var f = LFNoise2.kr(8)
+; var nh = LFNoise2.kr(3)
+; var src = Blip.ar(f * 200 + 300, nh * 10 + 20)
+; var sr = MouseX.kr(1000, s.sampleRate * 0.1, 'exponential', 0.2)
+; var bit_sz = MouseY.kr(1, 24, 'exponential', 0.2) 
+; var down_sample = Latch.ar(src, Impulse.ar(sr, 0))
+; var bit_redux = down_sample.round(0.5 ** bit_sz)
+; Out.ar(0, [down_sample, bit_redux]) }.play
+
+> main = bit_rate_decrease
diff --git a/src/bottle.lhs b/src/bottle.lhs
new file mode 100644
--- /dev/null
+++ b/src/bottle.lhs
@@ -0,0 +1,23 @@
+bottle (sc)
+
+> import Sound.SC3.Monadic
+
+> main =
+>   do { freq <- rand 220 880
+>      ; wn <- whiteNoise ar
+>      ; pn <- pinkNoise ar
+>      ; let { (>=>) f g = \x -> f x >>= g
+>            ; chain n f = foldl (>=>) return (replicate n f)
+>            ; perc = envPerc 0.1 0.6
+>            ; ex = envGen kr 1 1 0 1 DoNothing perc * wn * 0.02
+>            ; flute = ringz ex freq 0.3
+>            ; r = resonz pn (5 + (freq / 2)) 0.1
+>            ; breath = envGen kr 1 1 0 1 DoNothing perc * r
+>            ; rapf i = do { x <- linRand 0.001 0.1 (-1)
+>                          ; return (i + allpassN i 0.1 x 1.0 * 0.5) }
+>            ; cls i = let { en = let c = EnvNum (-4) in (c,c,c)
+>                          ; l = envLinen' 0.01 3.0 1.0 1 en
+>                          ; z = (breath + i) * envGen kr 1 1 0 1 RemoveSynth l }
+>                      in mce2 z z }
+>        in do { f <- (chain 2 rapf) flute
+>              ; audition (out 0 (cls f)) } }
diff --git a/src/bowed-string.lhs b/src/bowed-string.lhs
new file mode 100644
--- /dev/null
+++ b/src/bowed-string.lhs
@@ -0,0 +1,38 @@
+bowed string (jmcc)
+
+> import Control.Monad
+> import Sound.SC3.Monadic
+> import System.Random
+
+> main =
+>     let { rrand l r = getStdRandom (randomR (l, r))
+>         ; choose l = fmap (l !!) (rrand 0 (length l - 1))
+>         ; root = 5
+>         ; scale = map (+ root) [0, 2, 4, 5, 7, 9, 11]
+>         ; oct = [24, 36, 48, 60, 72, 84] }
+>   in do { n0 <- clone 2 (brownNoise ar)
+>         ; r0 <- expRand 0.125 0.5
+>         ; r1 <- rand 0.7 0.9
+>         ; r2 <- sequence (replicate 12 (rand 1.0 3.0))
+>         ; f <- fmap midiCPS (liftM2 (+) (choose scale) (choose oct))
+>         ; n1 <- lfNoise1 kr r0
+>         ; let { x = n0 * 0.007 * max 0 (n1 * 0.6 + 0.4)
+>               ; geom n i z = take n (iterate (* z) i)
+>               ; iota n i z = take n (iterate (+ z) i)
+>               ; d = klankSpec (iota 12 f f) (geom 12 1 r1) r2
+>               ; k = klank x 1 0 1 d }
+>         in audition (out 0 (softClip (k * 0.1))) }
+
+{ var root = 5
+; var scale = #[0, 2, 4, 5, 7, 9, 11] + root
+; var oct = #[24, 36, 48, 60, 72, 84]
+; var f = (scale.choose + oct.choose).midicps
+; var n0 = BrownNoise.ar().dup
+; var r0 = ExpRand.new(0.125, 0.5)
+; var n1 = LFNoise1.kr(r0)
+; var r1 = Rand.new(0.7,0.9)
+; var r2 = Array.fill(12, { Rand.new(1.0, 3.0) })
+; var x = n0 * 0.007 * max(0, n1 * 0.6 + 0.4)
+; var d = `[Array.series(12, f, f), Array.geom(12, 1, r1), r2]
+; var k = Klank.ar(d, x)
+; Out.ar(0, (k * 0.1).softclip) }.play
diff --git a/src/ccomb.lhs b/src/ccomb.lhs
new file mode 100644
--- /dev/null
+++ b/src/ccomb.lhs
@@ -0,0 +1,28 @@
+ccomb (rd)
+
+> import Sound.SC3.Monadic
+
+> main =
+>   let { rng l r i = linLin i (-1) 1 l r
+>       ; lwr = 48
+>       ; flwr = midiCPS lwr
+>       ; spart t = do { n <- fmap (rng lwr 72.0) (lfNoise2 kr 0.1)
+>                      ; e <- fmap (decay2 t 0.01) (tRand 0.05 0.75 t)
+>                      ; x <- fmap (* e) (whiteNoise ar)
+>                      ; m <- lfNoise2 kr 0.1
+>                      ; let f = lag (midiCPS n) 0.25
+>                        in return (combC x (recip flwr) (recip f) (rng 1 8 m)) } }
+>   in do { t <- dust kr (mce2 0.75 0.35)
+>         ; audition . (out 0) . (* 0.1) . sum =<< sequence (replicate 12 (spart t)) }
+
+{ var lwr = 48
+; var flwr = lwr.midicps
+; var spart = { arg t
+              ; { var n = LFNoise2.kr(0.1).range(lwr, 72.0)
+                ; var e = Decay2.kr(t, 0.01, TRand.kr(0.05, 0.75, t))
+                ; var x = WhiteNoise.ar() * e
+                ; var m = LFNoise2.kr(0.1)
+                ; var f = Lag.kr(n.midicps, 0.25)
+                ; CombC.ar(x, flwr.reciprocal, f.reciprocal, m.range(1, 8)) } }
+; var t = Dust.kr([0.75, 0.35])
+; Out.ar(0, Mix.fill(12, spart.value(t)) * 0.1) }.play
diff --git a/src/chain-saw.lhs b/src/chain-saw.lhs
new file mode 100644
--- /dev/null
+++ b/src/chain-saw.lhs
@@ -0,0 +1,56 @@
+chain saw (jrhb)
+
+[this graph generates long chains of unit generators and may require
+increasing the stack limit of the haskell run time system]
+
+> import Control.Monad
+> import Sound.SC3.Monadic
+> import System.Random
+
+> main =
+>    let { rrand l r = getStdRandom (randomR (l, r)) :: IO Double
+>        ; coin n a b = do { m <- rrand 0.0 1.0
+>                          ; return (if m > n then a else b) }
+>        ; exprange s l r = linExp s (-1) 1 l r
+>        ; chain n fn = foldr (<=<) return (replicate n fn)
+>        ; mceProduct = mceEdit (\l -> [product l])
+>        ; clipu s = clip2 s 1
+>        ; dup a = mce2 a a
+>        ; f s1 = do { xr <- fmap dup (expRand 0.1 2)
+>                    ; n1 <- lfNoise1 kr xr
+>                    ; n2 <- lfNoise1 kr xr
+>                    ; n3 <- lfNoise1 kr xr
+>                    ; f1 <- coin 0.6 (exprange n1 0.01 10) (exprange n2 10 50)
+>                    ; s2 <- coin 0.5 (1 - s1) (mceReverse s1)
+>                    ; let { f2 = linExp s1 (-1) 1 f1 (f1 * exprange n3 2 10)
+>                          ; u1 = lfSaw kr f2 0
+>                          ; u2 = lfSaw kr (f1 * 0.1) 0 * 0.1 + 1 }
+>                   in return . clipu =<< coin 0.5 (u1 * s2) (u1 * u2) }
+>        ; inp = lfSaw kr (0.2 * mce2 1 1.1) 0
+>        ; b_freq = mce [70, 800, 9000, 5242] }
+>   in do { ff <- chain 8 f inp
+>         ; let { c_saw = mceProduct (saw ar (exprange ff 6 11000))
+>               ; b_saw = dup (mix (bpf c_saw b_freq 0.2)) }
+>         in audition (out 0 (b_saw * 0.3)) }
+
+{ var f = { arg s1
+          ; var rate = ExpRand.new(0.1, 2).dup
+          ; var n1 = { LFNoise1.kr(rate).exprange(0.01, 10) }
+          ; var n2 = { LFNoise1.kr(rate).exprange(10, 50) }
+          ; var n3 = LFNoise1.kr(rate).exprange(2, 10)
+          ; var f1 = if(0.6.coin) { n1.value } { n2.value }
+          ; var s2 = [1 - s1, s1.reverse].choose
+          ; var f2 = LinExp.kr(s1, -1, 1, f1, f1 * n3)
+          ; var u1 = LFSaw.kr(f2, 0)
+          ; var u2 = LFSaw.kr(f1 * 0.1, 0, 0.1, 1)
+          ; var u3 = if(0.5.coin) { u1 * s2 } { u1 * u2 }
+          ; u3.clip2(1) }
+; var g = { arg func, n
+          ; n.do { func = func <> func }
+          ; func }
+; var inp = LFSaw.kr(0.2 * [1, 1.1], 0)
+; var b_freq = [70, 800, 9000, 5242]
+; var ff = g.(f, 4).value(inp)
+; var c_saw = Saw.ar(ff.exprange(6, 11000)).product
+; var b_saw = BPF.ar(c_saw, b_freq, 0.2).sum.dup
+; Out.ar(0, b_saw * 0.3) }.play
diff --git a/src/chrd.lhs b/src/chrd.lhs
new file mode 100644
--- /dev/null
+++ b/src/chrd.lhs
@@ -0,0 +1,36 @@
+chrd (rd)
+
+> import Sound.SC3.Monadic
+
+> main =
+>   let chrd = do { r0 <- rand 0.05 0.5
+>                 ; [r1, r2] <- sequence (replicate 2 (rand (-1) 1))
+>                 ; r3 <- rand 0.15 0.35
+>                 ; r4 <- rand 0.005 0.01
+>                 ; let { m = mce [60, 65, 72, 77, 79, 84]
+>                       ; ds = 3
+>                       ; d = mce (map (* ds) [5, 4, 5, 7, 4, 5])
+>                       ; f = midiCPS (xLine kr m (m + r0) d DoNothing)
+>                       ; z = envTrapezoid 0 r3 d r4
+>                       ; e = envGen kr 1 1 0 1 DoNothing z
+>                       ; p = xLine kr r1 r2 d DoNothing
+>                       ; o = fSinOsc ar f 0 }
+>                   in return (mix (pan2 o p e)) }
+>   in audition . out 0 . mix =<< clone 9 chrd
+
+{ var chrd = { var r0 = Rand.new(0.05, 0.5)
+             ; var r1 = Rand.new(-1, 1)
+             ; var r2 = Rand.new(-1, 1)
+             ; var r3 = Rand.new(0.15, 0.35)
+             ; var r4 = Rand.new(0.005, 0.01)
+             ; var m = [60, 65, 72, 77, 79, 84]
+             ; var ds = 3
+             ; var d = [5, 4, 5, 7, 4, 5] * ds
+             ; var f = XLine.kr(m, m + r0, d).midicps
+             ; var z_ = Env.linen(r3 * d, 0, (1 - r3) * d, r4)
+             ; var z = Env.sine(d.maxItem, r4)
+             ; var e = EnvGen.kr(z, 1, 1, 0, 1)
+             ; var p = XLine.kr(r1, r2, d)
+             ; var o = SinOsc.ar(f, 0)
+             ; Mix.ar(Pan2.ar(o, p, e)) }
+; Out.ar(0, Mix.fill(9, chrd)) }.play
diff --git a/src/cricket.lhs b/src/cricket.lhs
new file mode 100644
--- /dev/null
+++ b/src/cricket.lhs
@@ -0,0 +1,22 @@
+cricket (rd)
+
+> import Sound.SC3.Monadic
+
+> main =
+>   do { r1 <- clone 2 (rand 10 13)
+>      ; r2 <- clone 2 (rand 10 13)
+>      ; r3 <- clone 2 (rand 4 7)
+>      ; let { t = impulse kr 0.7 0
+>            ; e = decay2 (impulse kr r1 0) 0.001 0.005
+>            ; f = sinOsc kr r2 0 * e * r3 }
+>        in do { r4 <- clone 2 (tRand 2220 2227 t)
+>              ; audition (out 0 (sinOsc ar r4 0 * f * 0.25)) } }
+
+{ var r1 = Array.fill(2, { Rand.new(10, 13) })
+; var r2 = Array.fill(2, { Rand.new(10, 13) })
+; var r3 = Array.fill(2, { Rand.new(4, 7) })
+; var t = Impulse.kr(0.7, 0)
+; var e = Decay2.kr(Impulse.kr(r1, 0), 0.001, 0.005)
+; var f = SinOsc.kr(r2, 0) * e * r3
+; var r4 = Array.fill(2, { TRand.kr(2220, 2227, t) })
+; Out.ar(0, SinOsc.ar(r4, 0) * f * 0.25) }.play
diff --git a/src/crotale.lhs b/src/crotale.lhs
new file mode 100644
--- /dev/null
+++ b/src/crotale.lhs
@@ -0,0 +1,333 @@
+crotale (rd)
+
+> import Sound.SC3.ID
+
+> main =
+>     let { crotale = ( [ 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 ]
+>                     , [ 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 ]
+>                     , [ 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 ] )
+>         ; (cf, ca, cd) = crotale
+>         ; ps = mce [-12, -5, 0, 2, 4, 5, 7, 12]
+>         ; n = pinkNoise 'a' ar
+>         ; t = dust 'a' kr 3
+>         ; fs = select (tiRand 'a' 0 7 t) ps
+>         ; g = tRand 'a' 0 1 t
+>         ; fo = tRand 'b' 0 1 t
+>         ; ds = tRand 'c' 2 7 t
+>         ; p = tRand 'd' (-1) 1 t
+>         ; s = decay2 t 0.06 0.01 * n * g
+>         ; ks = klankSpec cf ca (map recip cd)
+>         ; k = dynKlank s (midiRatio fs) fo ds ks }
+>   in audition (out 0 (pan2 k p 1))
+
+{ var crotale = [ [ 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 ]
+                , [ 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 ]
+                , [ 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 ] ]
+; var cf = crotale[0]
+; var ca = crotale[1]
+; var cd = crotale[2]
+; var ps = [-12, -5, 0, 2, 4, 5, 7, 12]
+; var n = PinkNoise.ar()
+; var t = Dust.kr(3)
+; var fs = Select.kr(TIRand.kr(0, 7, t), ps)
+; var g = TRand.kr(0, 1, t)
+; var fo = TRand.kr(0, 1, t)
+; var ds = TRand.kr(2, 7, t)
+; var p = TRand.kr(-1, 1, t)
+; var s = Decay2.kr(t, 0.06, 0.01) * n * g
+; var k = DynKlank.ar(`[cf, ca, cd.reciprocal], s, fs.midiratio, fo, ds)
+; Out.ar(0, Pan2.ar(k, p, 1)) }.play
diff --git a/src/cut-outs.lhs b/src/cut-outs.lhs
new file mode 100644
--- /dev/null
+++ b/src/cut-outs.lhs
@@ -0,0 +1,27 @@
+cut-outs (rd)
+
+> import Sound.SC3.Monadic
+
+> main =
+>   let { t = impulse ar 22 0 * (sinOsc kr 0.5 0 + 1)
+>       ; x = mouseX kr 0.005 0.12 Exponential 0.1
+>       ; y = mouseY kr 0.01 0.52 Exponential 0.1 
+>       ; n = do { n1 <- lfNoise0 kr 2
+>                ; n2 <- coinGate (0.05 + n1 + y * 0.4 + t * 0.5) (t * 0.5)
+>                ; n3 <- tExpRand (mce2 500 900) 1600 t
+>                ; return (ringz n2 n3 x) } }
+>   in do { s <- fmap sum (sequence (replicate 3 n))
+>         ; b <- tRand 0 1 =<< dust kr 8
+>         ; audition (mrg [out 0 b, out 0 (clip2 s (in' 1 kr 0) * 0.25)]) }
+
+{ var t = Impulse.ar(22, 0) * (SinOsc.kr(0.5, 0) + 1)
+; var x = MouseX.kr(0.005, 0.12, 'exponential', 0.1)
+; var y = MouseY.kr(0.01, 0.52, 'exponential', 0.1)
+; var n = { var n1 = LFNoise0.kr(2)
+          ; var n2 = CoinGate.ar(0.05 + n1 + (y * 0.4) + (t * 0.5), t * 0.5)
+          ; var n3 = TExpRand.ar([500, 900], 1600, t)
+          ; Ringz.ar(n2, n3, x) }
+; var s = Mix.fill(3, n)
+; var b = TRand.kr(0, 1, Dust.kr(8))
+; Out.kr(0, b)
+; Out.ar(0, s.clip2(In.kr(0, 1)) * 0.25) }.play
diff --git a/src/cymbalism.lhs b/src/cymbalism.lhs
new file mode 100644
--- /dev/null
+++ b/src/cymbalism.lhs
@@ -0,0 +1,30 @@
+cymbalism (jmcc)
+
+> import Sound.SC3.Monadic
+
+> main =
+>   let p = replicate 15
+>   in do { f1 <- rand 500 2500
+>         ; f2 <- rand 0 8000
+>         ; let y = do { f <- sequence (p (rand f1 (f1 + f2)))
+>                      ; rt <- sequence (p (rand 1 5))
+>                      ; return (klankSpec f (p 1) rt) }
+>           in do { z <- clone 2 y
+>                 ; n <- fmap (* 0.03) (whiteNoise ar)
+>                 ; tf <- rand 0.5 3.5
+>                 ; let { t = impulse ar tf 0
+>                       ; s = decay t 0.004 * n
+>                       ; k = klank s 1 0 1 (mceTranspose z) }
+>                   in audition (out 0 k) } }
+
+{ var p = 15
+; var f1 = Rand.new(500, 2500)
+; var f2 = Rand.new(0, 8000)
+; var y = { var f = Array.fill(p, { f1 + Rand.new(0, f2) } )
+          ; var rt = Array.fill(p, { 1 + Rand.new(0, 4) })
+          ; `[f, nil, rt] }
+; var z = Array.fill(2, y)
+; var t = Impulse.ar(Rand.new(0, 3) + 0.5, 0)
+; var n = WhiteNoise.ar() * 0.03
+; var s = Decay.ar(t, 0.004) * n
+; Out.ar(0, Klank.ar(z, s)) }.play
diff --git a/src/deep-sea.lhs b/src/deep-sea.lhs
new file mode 100644
--- /dev/null
+++ b/src/deep-sea.lhs
@@ -0,0 +1,37 @@
+deep sea (jrhb)
+
+> import Sound.SC3.ID
+
+> main =
+>   let { range s l r = let m = (r - l) * 0.5 in mulAdd s m (m + l)
+>       ; amp = 1
+>       ; pan = 0
+>       ; variation = 0.9
+>       ; n = rand 'α' 7 46
+>       ; dt1 = 25.0 + rand 'β' (-1.7) 1.7
+>       ; dt2 = (dt1 + lfNoise2 'γ' kr 2) * variation * 0.001
+>       ; f = 901 + rand 'δ' 0 65
+>       ; t = impulse ar (recip dt2) 0 * 100
+>       ; count = pulseCount t 0
+>       ; mul = count <* n
+>       ; u1 = bpf (mul * t) f 1 * 0.1
+>       ; f2 = f * ((count `modE` range (lfNoise1 'ε' kr 1) 2 20) + 1)
+>       ; u2 = bpf u1 f2 1 * 0.2 }
+>   in audition (mrg [ detectSilence u2 0.0001 0.2 RemoveSynth
+>                    , out 0 (pan2 u2 pan (amp * 10)) ])
+
+{ var amp = 1
+; var pan = 0
+; var variation = 0.9
+; var n = Rand.new(7, 46)
+; var dt1 = 25.0 + Rand.new(-1.7, 1.7)
+; var dt2 = (dt1 + LFNoise2.kr(2)) * variation * 0.001
+; var freq = 901 + Rand.new(0, 65)
+; var t = Impulse.ar(dt2.reciprocal, 0, 100)
+; var count = PulseCount.ar(t, 0)
+; var mul = count < n
+; var u1 = BPF.ar(mul * t, freq, 1) * 0.1
+; var freq2 = freq * ((count % LFNoise1.kr(1).range(2, 20)) + 1)
+; var u2 = BPF.ar(u1, freq2, 1) * 0.2
+; DetectSilence.ar(u2, 0.0001, 0.2, 2)
+; Out.ar(0, Pan2.ar(u2, pan, amp * 10)) }.play
diff --git a/src/default.lhs b/src/default.lhs
new file mode 100644
--- /dev/null
+++ b/src/default.lhs
@@ -0,0 +1,36 @@
+default (jmcc)
+
+> import Sound.SC3.Monadic
+> import Sound.OpenSoundControl
+> import System.Random
+
+> main =
+>   let { def = do { r0 <- rand (-0.4) 0.0
+>                  ; r1 <- rand 0.0 0.4
+>                  ; r2 <- rand 4000 5000
+>                  ; r3 <- rand 2500 3200
+>                  ; let { f = control KR "freq" 440
+>                        ; a = control KR "amp" 0.1
+>                        ; p = control KR "pan" 0
+>                        ; g = control KR "gate" 1
+>                        ; e = linen g 0.01 (a * 0.7) 0.3 RemoveSynth
+>                        ; f3 = mce [f, f + r0, f + r1]
+>                        ; l = xLine KR r2 r3 1 DoNothing
+>                        ; z = lpf (mix (varSaw AR f3 0 0.3)) l * e }
+>                    in return (pan2 z p 1) }
+>       ; rrand lr = getStdRandom (randomR lr)
+>       ; tone fd nid = do { pan <- rrand (-1, 1)
+>                          ; amp <- rrand (0.1, 0.3)
+>                          ; indx <- rrand (0, 7)
+>                          ; let note = [60, 62, 64, 65, 67, 69, 71, 72] !! indx
+>                            in send fd (s_new "default" nid AddToTail 1
+>                                        [("freq", midiCPS note)
+>                                        ,("pan", pan)
+>                                        ,("amp", amp)])
+>                          ; pauseThread 0.075
+>                          ; send fd (n_set nid [("gate", 0)])
+>                          ; pauseThread 0.075 } }
+>   in withSC3 (\fd -> do { u <- def
+>                         ; async fd (d_recv (synthdef "default" (out 0 u)))
+>                         ; reset fd
+>                         ; mapM_ (tone fd) [1024..1036] })
diff --git a/src/demanding-studies.lhs b/src/demanding-studies.lhs
new file mode 100644
--- /dev/null
+++ b/src/demanding-studies.lhs
@@ -0,0 +1,26 @@
+demanding studies (jmcc)
+
+> import Sound.SC3.Monadic
+
+> main =
+>   do { s1 <- drand dinf (mce [72, 75, 79, 82])
+>      ; s2 <- drand 1 (mce [82, 84, 86])
+>      ; s3 <- dseq dinf (mce [72, 75, 79, s2])
+>      ; let { x = mouseX kr 5 13 Linear 0.2
+>            ; tr = impulse kr x 0
+>            ; f = demand tr 0 (mce [midiCPS (s1 - 12), midiCPS s3])
+>            ; o1 = sinOsc ar (f + mce2 0 0.7) 0
+>            ; o2 = saw ar (f + mce2 0 0.7) * 0.3
+>            ; o3 = cubed (distort (log (distort (o1 + o2)))) }
+>        in audition (out 0 (o3 * 0.1)) }
+
+{ var s1 = Drand.new([72, 75, 79, 82], inf)
+; var s2 = Drand.new([82, 84, 86], 1)
+; var s3 = Dseq.new([72, 75, 79, s2], inf)
+; var x = MouseX.kr(5, 13, 'linear', 0.2)
+; var tr = Impulse.kr(x, 0)
+; var f = Demand.kr(tr, 0, [(s1 - 12).midicps, s3.midicps])
+; var o1 = SinOsc.ar(f + [0, 0.7], 0)
+; var o2 = Saw.ar(f + [0, 0.7]) * 0.3
+; var o3 = (o1 + o2).distort.log.distort.cubed
+; Out.ar(0, o3 * 0.1) }.play
diff --git a/src/dial-history.lhs b/src/dial-history.lhs
new file mode 100644
--- /dev/null
+++ b/src/dial-history.lhs
@@ -0,0 +1,52 @@
+dial history (jrhb)
+
+> import Data.List
+> import Sound.SC3.Monadic
+
+> main =
+>   let { mfv = [[697, 770, 852, 941], [1209, 1336, 1477, 1633]]
+>       ; numbers = [[3, 1]] ++ [[a, b] | a <- [0..2], b <- [0..2]]
+>       ; range s l r = linLin s 0 1 l r
+>       ; mce_r = mce . map mce }
+>   in do { n <- dwhite dinf 7 12
+>         ; w <- dwhite 1 2 7
+>         ; b <- dbrown n 0.1 0.2 0.01
+>         ; rate <- dseq dinf (mce2 w b)
+>         ; q <- dseq dinf (mce [1..10])
+>         ; g1 <- grayNoise ar
+>         ; g2 <- grayNoise ar
+>         ; d <- lfdNoise3 kr 0.5
+>         ; let { tr = trig (tDuty kr rate 0 DoNothing q 1) 0.09
+>               ; pat = latch tr tr
+>               ; x = mouseX kr 0 1 Linear 0.2
+>               ; h = hasher (pat * x)
+>               ; which = trunc (range h 0 (constant (length numbers))) 1
+>               ; both = select which (mce_r numbers)
+>               ; dial = select both (mce_r (transpose mfv))
+>               ; sig = sinOsc ar dial 0 * 0.05 * tr
+>               ; dsig = delayN sig 0.2 (range d 0 0.01)
+>               ; hiss = g1 * 0.01 + hpf (g2 * 0.02) 3000 }
+>           in audition (out 0 (dsig + hiss)) }
+
+{ var mfv = [[697, 770, 852, 941], [1209, 1336, 1477, 1633]]
+; var numbers = [[3, 1]] ++ {: [a, b], a <- (0..2), b <- (0..2) }.all
+; var n = Dwhite.new(7, 12, inf)
+; var w = Dwhite.new(2, 7, 1)
+; var b = Dbrown.new(0.1, 0.2, 0.01, n)
+; var rate = Dseq.new([w, b], inf)
+; var q = Dseq.new((1..10), inf)
+; var trig = Trig.kr(TDuty.kr(rate, 0, q), 0.09)
+; var pat = Latch.kr(trig, trig)
+; var x = MouseX.kr(0, 1, 'linear', 0.2)
+; var h = Hasher.kr(pat * x)
+; var which = h.range(0, numbers.size).trunc.(1)
+; var both = Select.kr(which, numbers)
+; var dial = Select.kr(both, mfv.flop)
+; var sig = SinOsc.ar(dial, 0) * 0.05 * trig
+; var d = LFDNoise3.kr(0.5)
+; var dsig = DelayC.ar(sig, 0.2, d.range(0, 0.01))
+; var g1 = GrayNoise.ar
+; var g2 = GrayNoise.ar
+; var z = Silent.ar(1)
+; var hiss = g1 * 0.01 + HPF.ar(g2 * 0.02, 3000)
+; Out.ar(0, [z, dsig + hiss]) }.play
diff --git a/src/diffraction.lhs b/src/diffraction.lhs
new file mode 100644
--- /dev/null
+++ b/src/diffraction.lhs
@@ -0,0 +1,42 @@
+diffraction (rd)
+
+> import Control.Monad
+> import Sound.SC3.Monadic
+
+> main =
+>   let { p = let { x = mouseX kr 0.001 0.02 Exponential 0.1
+>                 ; y = mouseY kr 120 400 Exponential 0.1 }
+>             in do { f <- fmap (* mce2 32 64) (lfNoise0 kr 4)
+>                   ; w <- fmap (* x) (lfNoise0 kr 32)
+>                   ; z <- fmap (* 0.1) (lfNoise0 kr 2)
+>                   ; m <- lfNoise0 kr 6
+>                   ; let s = pulse ar f w
+>                     in return (resonz s (y + z) (m * 0.4 + 0.8) * 0.5) }
+>       ; q = do { n <- lfNoise0 kr 128
+>                ; s <- p
+>                ; return (combN s 0.2 (n * 0.1 + 0.1) 3) }
+>       ; r = let { x = mouseX kr 0.75 1.25 Exponential 0.1
+>                 ; y = mouseY kr 0.25 1 Exponential 0.1
+>                 ; f _ = do { fr <- fmap (* x) (rand 50 59)
+>                            ; am <- fmap (* y) (rand 0.04 0.16)
+>                            ; return (sinOsc ar fr 0 * am) } }
+>             in liftM2 mce2 (mixFillM 16 f) (mixFillM 12 f) }
+>   in audition . (out 0) . sum =<< sequence [p, q, r]
+
+{ var x = MouseX.kr(0.001, 0.02, 'exponential', 0.1)
+; var y = MouseY.kr(120, 400, 'exponential', 0.1)
+; var p = { var f = LFNoise0.kr(4) * [32, 64]
+	      ; var w = LFNoise0.kr(32) * x
+	      ; var z = LFNoise0.kr(2) * 0.1
+          ; var m = LFNoise0.kr(6)
+	      ; var s = Pulse.ar(f, w)
+          ; Resonz.ar(s, y + z, (m * 0.4) + 0.8) * 0.5 }
+; var q = { var n = LFNoise0.kr(128)
+	      ; CombN.ar(p.value, 0.2, (n * 0.1) + 0.1, 3) }
+; var r = { var x1 = MouseX.kr(0.75, 1.25, 'exponential', 0.1)
+          ; var y1 = MouseY.kr(0.25, 1, 'exponential', 0.1)
+	      ; var f = { var fr = Rand(50, 59) * x1
+	                ; var am = Rand(0.04, 0.16) * y1
+                    ; SinOsc.ar(fr, 0) * am }
+          ; [Mix.fill(16, f), Mix.fill(12, f)] }
+; Out.ar(0, p.value + q.value + r.value) }.play
diff --git a/src/discretion.lhs b/src/discretion.lhs
new file mode 100644
--- /dev/null
+++ b/src/discretion.lhs
@@ -0,0 +1,15 @@
+discretion (rd)
+
+> import Sound.SC3.Monadic
+
+> main =
+>   let { mkls bp t = envGen kr 1 1 0 1 RemoveSynth (envCoord bp t 1 EnvLin)
+>       ; part = do { 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)
+>                   ; let { t = 21
+>                         ; f_ = mkls [(0, f1), (0.33, f2), (1, f3)] t
+>                         ; a_ = mkls [(0, 0), (0.33, a), (1, 0)] t }
+>                     in return (saw ar f_ * a_) } }
+>   in audition . out 0 . mix =<< clone 8 part
diff --git a/src/drummer.lhs b/src/drummer.lhs
new file mode 100644
--- /dev/null
+++ b/src/drummer.lhs
@@ -0,0 +1,24 @@
+drummer (thor magnusson)
+
+> import Sound.SC3.ID
+
+> main =
+>   let { n = whiteNoise 'α' AR
+>       ; tempo = 4
+>       ; tr = impulse AR tempo 0
+>       ; tr_2 = pulseDivider tr 4 2
+>       ; tr_4 = pulseDivider tr 4 0
+>       ; snare = n * decay2 tr_2 0.005 0.5
+>       ; bass = sinOsc AR 60 0 * decay2 tr_4 0.005 0.5
+>       ; hihat = hpf n 10000 * decay2 tr 0.005 0.5 }
+>   in audition (out 0 (pan2 (snare + bass + hihat) 0 0.4))
+
+{ var tempo = 4
+; var n = WhiteNoise.ar()
+; var tr = Impulse.ar(tempo, 0)
+; var tr_2 = PulseDivider.ar(tr, 4, 2)
+; var tr_4 = PulseDivider.ar(tr, 4, 0)
+; var snare = n * Decay2.ar(tr_2, 0.005, 0.5)
+; var bass = SinOsc.ar(60, 0) * Decay2.ar(tr_4, 0.005, 0.5)
+; var hihat = HPF.ar(n, 10000) * Decay2.ar(tr, 0.005, 0.5)
+; Out.ar(0, Pan2.ar(snare + bass + hihat, 0, 0.4)) }.play
diff --git a/src/e-lamell.lhs b/src/e-lamell.lhs
new file mode 100644
--- /dev/null
+++ b/src/e-lamell.lhs
@@ -0,0 +1,54 @@
+e-lamell (rd)
+
+> import Control.Monad
+> import Sound.OpenSoundControl
+> import Sound.SC3.Monadic
+> import System.Random
+
+> main =
+>   let { now = NTPi 1
+>       ; rrand l r = getStdRandom (randomR (l, r))
+>       ; exp_rrand a b = do { n <- rrand 0 1
+>                            ; let r = b / a 
+>                              in return ((r ** n) * a) }
+>       ; choose l = return . (l !!) =<< rrand 0 (length l - 1)
+>       ; sendSynth fd n u = async fd (d_recv (synthdef n u))
+>       ; e_lamell = let { ctl s v = control kr s v
+>                        ; f = ctl "f" 440
+>                        ; n = ctl "n" 12
+>                        ; d = ctl "d" 0.1
+>                        ; l = ctl "l" 0
+>                        ; a = ctl "a" 1 }
+>                    in do { t <- tChoose 1 (mce2 1 32)
+>                          ; let { h = line ar n t d DoNothing
+>                                ; s = blip ar f h
+>                                ; e_d = envPerc 0.005 d
+>                                ; e = envGen ar 1 a 0 1 RemoveSynth e_d }
+>                            in return (out 0 (pan2 s l e)) }
+>       ; r_note o p = do { oe <- choose o
+>                         ; pe <- choose p
+>                         ; return (oe * 12 + pe) }
+>       ; l_sel = r_note [2, 3] [0]
+>       ; h_sel = r_note [2, 3, 4] [0]
+>       ; mk_s_new f n d a l = s_new "blip" (-1) AddToTail 1
+>                                    [("f", f)
+>                                    ,("n", n)
+>                                    ,("d", d)
+>                                    ,("a", a)
+>                                    ,("l", l)]
+>       ; pattern fd = do { p <- do { f <- liftM midiCPS l_sel
+>                                   ; n <- rrand 2 36
+>                                   ; d <- exp_rrand 0.01 0.4
+>                                   ; a <- rrand 0 0.75
+>                                   ; l <- rrand (-1) 1
+>                                   ; return (mk_s_new f n d a l) }
+>                         ; q <- do { f <- liftM midiCPS h_sel
+>                                   ; n <- rrand 2 36
+>                                   ; d <- exp_rrand 0.01 0.4
+>                                   ; a <- choose [0, 0.25, 0.5, 1]
+>                                   ; l <- rrand (-1) 1
+>                                   ; return (mk_s_new f n d a l) }
+>                         ; send fd (Bundle now [p, q]) 
+>                         ; pauseThread 0.1 } }
+>   in withSC3 (\fd -> do { sendSynth fd "blip" =<< e_lamell
+>                         ; replicateM_ 64 (pattern fd) })
diff --git a/src/eggcrate.lhs b/src/eggcrate.lhs
new file mode 100644
--- /dev/null
+++ b/src/eggcrate.lhs
@@ -0,0 +1,27 @@
+eggcrate (rd)
+
+> import Sound.SC3.Monadic
+
+> main =
+>   let { cosu = cos . (* pi) 
+>       ; sinu = sin . (* pi)
+>       ; eggcrate u v = cosu u * sinu v
+>       ; p = mce [64, 72, 96, 128, 256, 6400, 7200, 8400, 9600] }
+>   in do { [x, y] <- sequence (replicate 2 (brownNoise kr))
+>         ; t <- dust kr 2.4
+>         ; [f0, f1] <- sequence (replicate 2 (tChoose t p))
+>         ; let { f = linLin (eggcrate x y) (-1) 1 f0 f1
+>               ; a = linLin x (-1) 1 0 0.1 }
+>           in audition (out 0 (pan2 (mix (sinOsc ar f 0)) y a)) }
+
+{ var eggcrate = { arg u, v
+                 ; (u * pi).cos * (v * pi).sin }
+; var p = [64, 72, 96, 128, 256, 6400, 7200, 8400, 9600]
+; var x = BrownNoise.kr()
+; var y = BrownNoise.kr()
+; var t = Dust.kr(2.4)
+; var f0 = TChoose.kr(t, p)
+; var f1 = TChoose.kr(t, p)
+; var f = LinLin.kr(eggcrate.value(x, y), -1, 1, f0, f1)
+; var a = LinLin.kr(x, -1, 1, 0, 0.1)
+; Out.ar(0, Pan2.ar(Mix.ar(SinOsc.ar(f, 0)), y, a)) }.play
diff --git a/src/f-lets.lhs b/src/f-lets.lhs
new file mode 100644
--- /dev/null
+++ b/src/f-lets.lhs
@@ -0,0 +1,26 @@
+f-lets (rd)
+
+> import Sound.SC3.Monadic
+
+> main =
+>   let { f_let t g j n f = 
+>         let pd = pulseDivider t j 0
+>         in do { r0 <- tiRand (mce2 2 1) n pd
+>               ; r1 <- tRand 0.01 0.04 pd
+>               ; r2 <- tRand 0.05 0.10 pd
+>               ; return (formlet pd (f * r0) r1 r2 * g) }
+>       ; mk_n t = do { r0 <- tRand 0 1 t
+>                     ; r1 <- tRand 0 1 t
+>                     ; r2 <- tRand 0 1 t
+>                     ; r3 <- tRand 0 1 t
+>                     ; r4 <- coinGate 0.2 t
+>                     ; sequence
+>                       [ f_let t 0.15 2 9 (mce2 200 400)
+>                       , f_let t 0.25 2 9 (mce2 (200 + r0) (400 + r1))
+>                       , f_let t 0.05 4 5 (mce2 25 50)
+>                       , f_let t 0.15 4 5 (mce2 (25 + r2) (50 + r3))
+>                       , let lr = fmap (* (latch r4 t))
+>                         in lr (f_let t 0.5 1 16 (mce2 300 600)) ] }
+>       ; tr = impulse ar 24 0 }
+>   in do { n <- lfNoise0 kr 2
+>         ; audition . out 0 . (* (n * 0.25 + 0.25)) . sum =<< mk_n tr }
diff --git a/src/fbl-fbf.lhs b/src/fbl-fbf.lhs
new file mode 100644
--- /dev/null
+++ b/src/fbl-fbf.lhs
@@ -0,0 +1,27 @@
+fbl-fbf (rd)
+
+> import Sound.SC3.Monadic
+
+> main =
+>   let { fbl l i d g = let { a0 = l + mce i
+>                           ; a1 = delayL a0 (maximum d) (mce d) }
+>                       in (localOut (a1 * mce g), a1)
+>       ; fbf b i d g = let { a0 = inFeedback 1 (mce b) + mce i
+>                           ; a1 = delayL a0 (maximum d) (mce d) }
+>                       in (offsetOut (mce b) (mce [a1 * mce g]), a1) }
+>   in do { withSC3 reset
+>         ; n <- brownNoise ar
+>         ; let { e = decay (impulse ar 0.3 0) 0.1 * n * 0.2
+>               ; c = 4
+>               ; e' = replicate c e
+>               ; b0 = [24, 26, 28, 30]
+>               ; d0 = [0.1, 0.3, 0.5, 0.7]
+>               ; g0 = [0.8, 0.6, 0.4, 0.2]
+>               ; b1 = [25, 27, 29, 31]
+>               ; d1 = [0.2, 0.3, 0.6, 0.7]
+>               ; g1 = [0.8, 0.7, 0.4, 0.3]
+>               ; (u0, s0) = fbl (localIn c ar) e' d0 g0
+>               ; (u1, s1) = fbf b0 e' d0 g0
+>               ; (u2, s2) = fbf b1 (mceChannels s1) d1 g1
+>               ; o = mce [mix (s0 + s1), mix s2] }
+>           in audition (mrg [u0, u1, u2, offsetOut 0 o]) }
diff --git a/src/feedr.lhs b/src/feedr.lhs
new file mode 100644
--- /dev/null
+++ b/src/feedr.lhs
@@ -0,0 +1,23 @@
+feedr (rd)
+warning: input/output feedback loop
+
+> import Sound.SC3.Monadic
+
+> main =
+>   let { delayWr b i = recordBuf b 0 1 0 1 Loop 0 DoNothing i
+>       ; tap nc b dt = playBuf nc b 1 0 (dt * (- sampleRate)) Loop DoNothing
+>       ; dl = 6
+>       ; feedr n = do { t <- sequence (replicate n (rand 0.0 (constant dl)))
+>                      ; g <- sequence (replicate n (rand 0.4 1.0))
+>                      ; f <- sequence (replicate n (rand 0.9 0.95))
+>                      ; let { d = zipWith (\p q -> tap 2 10 p * q) t g
+>                            ; x = mouseX kr 0.02 1.0 Exponential 0.1
+>                            ; s = clip2 (leakDC (hpf (sum d) 20) 0.995) 1
+>                            ; i = soundIn (mce2 0 1)
+>                            ; r = i + sum (map (* x) (zipWith (*) d f)) }
+>                        in return (mrg [out 0 s, delayWr 10 r]) } }
+>   in withSC3 (\fd -> do { nf <- fmap (* dl) (serverSampleRateActual fd)
+>                         ; send fd (b_alloc 10 (floor nf) 2)
+>                         ; audition =<< feedr 18 })
+
+withSC3 (\fd -> send fd (b_zero 10))
diff --git a/src/fm-iter.lhs b/src/fm-iter.lhs
new file mode 100644
--- /dev/null
+++ b/src/fm-iter.lhs
@@ -0,0 +1,17 @@
+fm-iter (rd)
+
+> import Sound.SC3.Monadic
+
+> main =
+>   let { t0 = impulse ar (recip 0.30) 0
+>       ; t1 = tDelay t0 0.15
+>       ; t = mce2 t0 t1 }
+>   in do { k <- tRand 56 57 t
+>         ; i <- tRand 40 480 t
+>         ; j <- tRand (-1) 1 t
+>         ; let { c = midiCPS k
+>               ; m = midiCPS (k + 1 + j)
+>               ; s = envPerc 0.01 0.9
+>               ; e = envGen ar t 0.1 0 1 RemoveSynth s
+>               ; f = sinOsc ar c 0 * i + m }
+>           in audition (out 0 (sinOsc ar f 0 * e)) }
diff --git a/src/fm-kltr.lhs b/src/fm-kltr.lhs
new file mode 100644
--- /dev/null
+++ b/src/fm-kltr.lhs
@@ -0,0 +1,49 @@
+fm-kltr (rd)
+
+> import Sound.OpenSoundControl
+> import Sound.SC3.Monadic
+> import System.Random
+
+> main =
+>   let { rrand l r = getStdRandom (randomR (l, r))
+>       ; gr =
+>             do { r1 <- rand 0.975 1.025
+>                ; r2 <- rand 0.5 1.5
+>                ; r3 <- rand 0.975 1.025
+>                ; r4 <- rand 0.75 1.25
+>                ; let { o = control ir "out" 0
+>                      ; t = control kr "trig" 0 {- unused -}
+>                      ; a = control kr "amp" 0.1
+>                      ; d = control kr "dur" 0.1
+>                      ; f = control kr "freq" 400.0
+>                      ; i = control kr "index" 40.0
+>                      ; p = control kr "pan" 0.0
+>                      ; f2 = control kr "freq2" 600
+>                      ; ep = envPerc 0.01 d
+>                      ; e = envGen ar 1 a 0 1 RemoveSynth ep
+>                      ; so = sinOsc ar (xLine kr f (f * r1) d DoNothing) 0
+>                      ; xl = xLine kr f2 (f2 * r3) d DoNothing
+>                      ; m = so * line kr i (f * r2) d DoNothing + xl
+>                      ; l = line kr p (p * r4) d DoNothing }
+>                  in return (out o (pan2 (sinOsc ar m 0) l e)) }
+>       ; fm fd f ff a d i =
+>           do { r1 <- rrand (-1) 1
+>              ; r2 <- rrand (-1) 1
+>              ; send fd (s_new "fm" (-1) AddToTail 1
+>                               [("freq", midiCPS f)
+>                               ,("freq2", midiCPS ff + r1)
+>                               ,("amp", a)
+>                               ,("dur", d)
+>                               ,("index", i)
+>                               ,("pan", r2)]) }
+>       ; nd fd =
+>           do { ff <- rrand 48 96
+>              ; a <- rrand 0.1 0.4
+>              ; d <- rrand 1.2 7.2
+>              ; i <- rrand 240 1480
+>              ; t <- rrand 0.15 1.25
+>              ; fm fd 53 ff a d i
+>              ; pauseThread t } }
+>   in withSC3 (\fd -> do { u <- gr
+>                         ; async fd (d_recv (synthdef "fm" u))
+>                         ; sequence (replicate 32 (nd fd)) })
diff --git a/src/forest-sounds.lhs b/src/forest-sounds.lhs
new file mode 100644
--- /dev/null
+++ b/src/forest-sounds.lhs
@@ -0,0 +1,18 @@
+forest sounds (paul jones)
+
+> import Sound.SC3.Monadic
+
+> main =
+>   let insects = do { n1 <- brownNoise ar
+>                    ; n2 <- lfNoise2 kr 50
+>                    ; let o = sinOsc kr (n2 * 50 + 50) 0 * 100 + 2000
+>                      in return (bpf n1 o 0.001 * 10) }
+>   in audition . (out 0) =<< clone 2 insects
+
+{ var insects = { var n1 = BrownNoise.ar
+                ; var n2 = LFNoise2.kr(50)
+                ; var o = SinOsc.kr(n2 * 50 + 50, 0) * 100 + 2000
+                ; BPF.ar(n1, o, 0.001) * 10 }
+; Out.ar(0, Array.fill(2, insects)) }.play
+
+sc-users, 2007-04-06
diff --git a/src/fwalk.lhs b/src/fwalk.lhs
new file mode 100644
--- /dev/null
+++ b/src/fwalk.lhs
@@ -0,0 +1,28 @@
+fwalk (rd)
+
+> import Sound.SC3.Monadic
+
+> main =
+>   let { n = [ 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 = [ 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 (\b -> b_alloc b 20 1) [0, 1]
+>       ; s = map (\(b, d) -> b_setn1 b 0 d) [(0, n), (1, m)]
+>       ; fwalk r = do { t <- dust kr 3
+>                      ; r1 <- tiRand 0 6 t
+>                      ; r2 <- tRand (-0.0001) 0.0001 t
+>                      ; let { f = bufRdL 1 kr (mce2 0 1) r1 NoLoop
+>                            ; f' = f + r2
+>                            ; o1 = blip ar (midiCPS (r + f)) 12
+>                            ; o2 = blip ar (midiCPS (r + f')) 12 }
+>                        in return ((o1 + o2) * decay2 t 0.3 1.2 * 0.1) } }
+>   in withSC3 (\fd -> do { f1 <- fwalk 24
+>                         ; f2 <- fwalk 36
+>                         ; mapM_ (async fd) a
+>                         ; mapM_ (send fd) s
+>                         ; play fd (out 0 (f1 + f2)) })
diff --git a/src/h-chatter.lhs b/src/h-chatter.lhs
new file mode 100644
--- /dev/null
+++ b/src/h-chatter.lhs
@@ -0,0 +1,45 @@
+h-chatter (rd)
+
+> import Control.Monad
+> import Sound.SC3.Monadic
+
+> main =
+>   let { wrp i l r = linLin i (-1) 1 l r
+>       ; mma m a = return . (+ a)  . (* m)
+>       ; h0 = do { n <- mma 5 5 =<< lfNoise0 kr 1
+>                 ; a <- mma 0.2 1.2 =<< lfNoise2 kr n
+>                 ; b <- mma 0.15 0.15 =<< lfNoise2 kr n
+>                 ; let { f = 40
+>                       ; h = henonN ar (mce2 f (f * 0.5)) a b 0 0 }
+>                   in return (saw ar (h * 3200 + 1600) * 0.35) }
+>       ; h1 = do { n0 <- lfNoise0 kr 32
+>                 ; n1 <- lfNoise0 kr 2
+>                 ; let { a = mouseX kr 1.2 1.4 Linear 0.1
+>                       ; b = mouseY kr 0.2 0.3 Linear 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 (henonN ar f a b 0 0) p (p * 2)) h }
+>                   in return (pan2 o l g * 0.35) } }
+>   in audition . out 0 =<< liftM2 (+) h0 h1
+
+{ var h0 = { var n = LFNoise0.kr(1, 5, 5)
+           ; var a = LFNoise0.kr(1, 0.2, 1.2)
+           ; var b = LFNoise0.kr(1, 0.15, 0.15)
+           ; var f = 40
+           ; var h = HenonN.ar([f, f * 0.5], a, b, 0, 0)
+           ; Saw.ar(h * 3200 + 1600) * 0.35 }
+; var h1 = { var n0 = LFNoise0.kr(32)
+           ; var n1 = LFNoise0.kr(2)
+           ; var a = MouseX.kr(1.2, 1.4, 'linear', 0.1)
+           ; var b = MouseY.kr(0.2, 0.3, 'linear', 0.1)
+           ; var h = n0.range(1, 32)
+           ; var p = n1.range(2400, 3200)
+           ; var l = n1.range(-0.75, 0.75)
+           ; var g = n1.range(0.55, 0.85)
+           ; var f = 40
+           ; var o = Blip.ar(HenonN.ar(f, a, b, 0, 0).range(p, p * 2), h)
+           ; Pan2.ar(o, l, g) * 0.35 }
+; Out.ar(0, h0.value + h1.value) }.play
diff --git a/src/half-life.lhs b/src/half-life.lhs
new file mode 100644
--- /dev/null
+++ b/src/half-life.lhs
@@ -0,0 +1,18 @@
+half-life (jrhb)
+
+> import Sound.SC3.Monadic
+
+> main =
+>   let { t_half = 3.92
+>       ; n_atoms = 1e+5
+>       ; n = max 0 (n_atoms - pulseCount (localIn 2 ar) 0) }
+>   in do { activity <- dust ar (n * log 2 / t_half)
+>         ; audition (mrg [ localOut activity
+>                         , out 0 activity ]) }
+
+{ var t_half = 3.92
+; var n_atoms = 1e+5
+; var n = max(0, n_atoms - PulseCount.ar(LocalIn.ar(2), 0))
+; var activity = Dust.ar(n * 2.log / t_half)
+; LocalOut.ar(activity)
+; Out.ar(0, activity) }.play
diff --git a/src/harmonic-swimming.lhs b/src/harmonic-swimming.lhs
new file mode 100644
--- /dev/null
+++ b/src/harmonic-swimming.lhs
@@ -0,0 +1,25 @@
+harmonic swimming (jmcc)
+
+> import Sound.SC3.Monadic
+
+> main =
+>   let { a = 0.02
+>       ; f = 50
+>       ; p = 20
+>       ; l = line kr 0 (- a) 60 DoNothing 
+>       ; o h = do { r <- clone 2 (rand 2 8)
+>                  ; n <- lfNoise1 kr r
+>                  ; let e = max 0 (n * a + l)
+>                    in return (fSinOsc ar (f * (h + 1)) 0 * e) } }
+>   in audition . out 0 . sum =<< mapM o [0..p]
+
+{ var a = 0.02
+; var f = 50
+; var p = 20
+; var l = Line.kr(0, a.neg, 60, 0)
+; var o = { arg h
+          ; var r = 6 + [Rand.new(-4, 4), Rand.new(-4, 4)]
+          ; var n = LFNoise1.kr(r)
+          ; var e = max(0, n * a + l)
+          ; FSinOsc.ar(f * (h + 1), 0) * e }
+; Out.ar(0, (0..p).collect(o).sum) }.play
diff --git a/src/harmonic-tumbling.lhs b/src/harmonic-tumbling.lhs
new file mode 100644
--- /dev/null
+++ b/src/harmonic-tumbling.lhs
@@ -0,0 +1,23 @@
+harmonic tumbling (jmcc)
+
+> import Sound.SC3.Monadic
+
+> main =
+>   let { f = 80
+>       ; p = 10
+>       ; t = xLine kr (mce2 10 11) 0.1 60 DoNothing
+>       ; o h = do { n <- dust kr t
+>                  ; r <- rand 0 0.5
+>                  ; let e = decay2 (n * 0.02) 0.005 r
+>                    in return (fSinOsc ar (f * (h + 1)) 0 * e) } }
+>   in audition . out 0 . sum =<< mapM o [0..p]
+
+{ var f = 80
+; var p = 10
+; var t = XLine.kr([10, 11], 0.1, 60, doneAction: 0)
+; var o = { arg h
+          ; var n = Dust.kr(t)
+          ; var r = Rand.new(0, 0.5)
+          ; var e = Decay2.kr(n * 0.02, 0.005, r)
+          ; FSinOsc.ar(f * (h + 1), 0) * e }
+; Out.ar(0, (0..p).collect(o).sum) }.play
diff --git a/src/hh-808.lhs b/src/hh-808.lhs
new file mode 100644
--- /dev/null
+++ b/src/hh-808.lhs
@@ -0,0 +1,25 @@
+hh-808 (ryan at wabdo.com)
+
+> import Sound.SC3
+
+> main =
+>   let { time = 250
+>       ; freqs = [205.35, 304.41, 369.64, 522.71, 540.54, 812.21]
+>       ; pulseEnv = let e = env [1.0, 0.6] [time] [EnvNum (-0.5)] 0 0
+>                    in envGen ar 1 1 0 (1/1000) DoNothing e
+>       ; s = mix (lfPulse ar (mce (map (* 4.09) freqs)) 0 0.5)
+>       ; f = [ \a -> ((a ==* 6.0) * 0.6) + ((a ==* 2.0) * 0.2) + ((a ==* 1.0) * 0.9)
+>             , \a -> (a * pulseEnv) + ((mix (lfPulse ar (mce freqs) 0 0.55)) * 0.9)
+>             , \a -> rlpf a 7000 0.6
+>             , \a -> rhpf a 6800 1.5
+>             , \a -> rhpf a 6800 1.5
+>             , \a -> rhpf a 1200 1.5
+>             , \a -> a + freeVerb a 0.33 0.5 0.5
+>             , \a -> let { c = map EnvNum [0, -0.5, 0, -50]
+>                         ; e = env [0, 1, 0.4, 0, 0] [2, time, 50, 500] c 0 0 }
+>                     in a * envGen ar 1 1 0 (1/1000) RemoveSynth e
+>             , \a -> mce [a, delayN a 0.005 0.005] ]
+>       ; (>>>) = flip (.) }
+>   in audition (out 0 (foldl1 (>>>) f s * 2))
+
+http://www.create.ucsb.edu/pipermail/sc-users/2007-August/036131.html
diff --git a/src/implosion.lhs b/src/implosion.lhs
new file mode 100644
--- /dev/null
+++ b/src/implosion.lhs
@@ -0,0 +1,22 @@
+implosion (rd)
+
+> import Sound.SC3.Monadic
+
+> main =
+>   let { mkls bp t = let e = envCoord bp t 1 EnvLin
+>                     in envGen kr 1 1 0 1 RemoveSynth e
+>       ; mkrmp l r t = mkls [(0, l), (1, r)] t
+>       ; wrp i l r = linLin i (-1) 1 l r
+>       ; pmr_n rt l0 l1 r0 r1 d = let { le = mkrmp l0 r0 d
+>                                      ; re = mkrmp l1 r1 d }
+>                                  in do { n <- whiteNoise rt
+>                                        ; return (wrp n le re) } }
+>   in do { n0 <- rand (-1) 0
+>         ; n1 <- rand 0 1
+>         ; 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 n0 n1 0 0 d
+>         ; a <- pmr_n kr 0.1 0.6 0 0 d
+>         ; audition (out 0 (pan2 (saw ar f) l a)) }
diff --git a/src/insects.lhs b/src/insects.lhs
new file mode 100644
--- /dev/null
+++ b/src/insects.lhs
@@ -0,0 +1,15 @@
+insects (sam pluta)
+
+> import Sound.SC3.Monadic
+
+> main =
+>   let insect = do { r1 <- rand 2000 3000
+>                   ; r2 <- rand 0.05 0.1
+>                   ; n1 <- lfNoise2 KR (r2 * 50 + 50)
+>                   ; r4 <- rand 1 10
+>                   ; r5 <- rand 0.05 0.1
+>                   ; n2 <- lfNoise2 KR r5
+>                   ; let { a = sinOsc KR r4 0 * 0.5 + 0.5
+>                         ; o = sinOsc AR (r1 + n1) r2 * 0.005 * a }
+>                     in return (pan2 o n2 1) }
+>   in audition . (out 0) . sum =<< sequence (replicate 60 insect)
diff --git a/src/k-ppr.lhs b/src/k-ppr.lhs
new file mode 100644
--- /dev/null
+++ b/src/k-ppr.lhs
@@ -0,0 +1,36 @@
+k-ppr (rd)
+
+> import Control.Monad
+> import Sound.SC3.Monadic
+
+> main =
+>   let { wrp i l r = linLin i (-1) 1 l r
+>       ; x = mouseX kr 0.05 0.35 Linear 0.1
+>       ; y = mouseY kr 0.15 0.75 Linear 0.1
+>       ; ti = lfTri kr x 0
+>       ; tf = wrp ti 100 200
+>       ; t = impulse ar tf 0
+>       ; stream lf rf ld rd g = 
+>           do { r1 <- rand 9 18
+>              ; let t' = pulseDivider t r1 0
+>                in do { r2 <- tRand lf (wrp ti lf rf) t'
+>                      ; r3 <- tRand ld rd t'
+>                      ; return (ringz (decay2 t' 0.01 0.5) r2 (r3 * y) * g) } } 
+>       ; s1 = stream 3140 6240 0.050 0.005 0.15 
+>       ; s2 = stream 0400 9000 0.005 0.005 0.15 }
+>   in audition . out 0 =<< liftM2 (+) (clone 2 s1) (clone 2 s2)
+
+{ var x = MouseX.kr(0.05, 0.35, 'linear', 0.1)
+; var y = MouseY.kr(0.15, 0.75, 'linear', 0.1)
+; var ti = LFTri.kr(x, 0)
+; var tf = ti.range(100, 200)
+; var t = Impulse.ar(tf, 0)
+; var stream = { arg lf, rf, ld, rd, g
+               ; { var r1 = Rand.new(9, 18)
+                 ; var t_ = PulseDivider.ar(t, r1, 0)
+                 ; var r2 = TRand.ar(lf, ti.range(lf, rf), t_)
+                 ; var r3 = TRand.ar(ld, rd, t_)
+                 ; Ringz.ar(Decay2.ar(t_, 0.01, 0.5), r2, r3 * y) * g } }
+; var s1 = stream.value(3140, 6240, 0.050, 0.005, 0.15)
+; var s2 = stream.value(0400, 9000, 0.005, 0.005, 0.15)
+; Out.ar(0, Array.fill(2, s1) + Array.fill(2, s2)) }.play
diff --git a/src/karplus-strong.lhs b/src/karplus-strong.lhs
new file mode 100644
--- /dev/null
+++ b/src/karplus-strong.lhs
@@ -0,0 +1,40 @@
+karplus strong (alex mclean)
+
+> import Sound.SC3.Monadic
+
+> main =
+>   let { aA = ( "aA" 
+>              , [800, 1150, 2800, 3500, 4950]
+>              , [0, -4  , -20, -36 , -60]
+>              , [80, 90,  120, 130, 140] )
+>       ; aU = ( "aU" 
+>              , [325, 700, 2530, 3500, 4950]
+>              , [0, -12 , -30, -40, -64]
+>              , [50, 60,  170, 180, 200] )
+>       ; cs (_, c1, c2, c3) = c1 ++ c2 ++ c3
+>       ; vf i s = let { f = in' 5 kr i
+>                      ; a = in' 5 kr (i + 5)
+>                      ; b = in' 5 kr (i + 10) }
+>                  in mix (resonz s f (b / f) * dbAmp a)
+>       ; ks n d = let { x = mouseX kr 0 0.01 Linear 0.1 {- delay -}
+>                      ; y = mouseY kr 0.85 1 Linear 0.1 {- blend / gain -}
+>                      ; ugenIf a b c = (a * b) + ((1 - a) * c)
+>                      ; n0 = (n / 2) + 0.5
+>                      ; probSwitch i prob = ugenIf (n0 >* prob) i (negate i)
+>                      ; laggedDelay = lag x 0.01
+>                      ; o = sinOsc ar 200 0
+>                      ; a0 = decay d 0.025 * o
+>                      ; a1 = localIn 1 ar + (a0 * (y - 0.25))
+>                      ; a2 = delayN a1 0.01 laggedDelay
+>                      ; a3 = delay1 a2
+>                      ; a4 = (a2 + a3) / 2.0
+>                      ; a5 = probSwitch a4 y
+>                      ; a6 = vf (toggleFF d * 15) a5
+>                      ; a7 = a6 * 1.5 }
+>                 in mrg [localOut (a5 * 0.99), out 0 (mce [a7, a7])] }
+>   in withSC3 (\fd -> do { send fd (c_setn [(0,cs aA), (15, cs aU)])
+>                         ; n <- whiteNoise ar
+>                         ; d <- dust kr 4
+>                         ; play fd (ks n d) })
+
+Variant on http://doc.gold.ac.uk/~ma503am/alex/vocable-source-released/
diff --git a/src/klink.lhs b/src/klink.lhs
new file mode 100644
--- /dev/null
+++ b/src/klink.lhs
@@ -0,0 +1,28 @@
+klink (rd)
+
+> import Sound.SC3.Monadic
+
+> main =
+>   do { n1 <- lfNoise0 kr (mce2 0.5 1.5)
+>      ; let { o = sinOsc kr n1 0
+>            ; f = mce2 2 3
+>            ; a = abs (slope o) * f
+>            ; t = impulse ar a 0
+>            ; i = decay2 t 0.01 0.1
+>            ; x = mouseX kr 960 3620 Exponential 0.2
+>            ; y = mouseY kr 0.5 2.0 Linear 0.2 }
+>        in do { n2 <- tRand x 3940 t
+>              ; n3 <- tRand 0.005 0.275 t
+>              ; audition (out 0 (ringz i n2 (n3 * y))) } }
+
+{ var n1 = LFNoise0.kr([0.5, 1.5])
+; var o = SinOsc.kr(n1, 0)
+; var f = [2, 3]
+; var a = Slope.kr(o).abs * f
+; var t = Impulse.ar(a, 0)
+; var i = Decay2.ar(t, 0.01, 0.1)
+; var x = MouseX.kr(960, 3620, 'exponential', 0.2)
+; var y = MouseY.kr(0.5, 2.0, 'linear', 0.2)
+; var n2 = TRand.ar(x, 3940, t)
+; var n3 = TRand.ar(0.005, 0.275, t)
+; Out.ar(0, Ringz.ar(i, n2, n3 * y)) }.play
diff --git a/src/lf-pulses.lhs b/src/lf-pulses.lhs
new file mode 100644
--- /dev/null
+++ b/src/lf-pulses.lhs
@@ -0,0 +1,18 @@
+lf pulses (rd)
+
+> import Sound.SC3.Monadic
+
+> main =
+>   do { n0 <- lfNoise0 AR (mce2 20 40)
+>      ; n1 <- lfNoise0 AR (mce2 5 10)
+>      ; let { x = mouseX KR 0.012 0.19 Exponential 0.1
+>            ; f = formlet (blip AR 10 12) (n0 * 43 + 700) 0.005 x 
+>            ; o = sinOsc AR 40 0 * n1 }
+>        in audition (out 0 (clip2 (leakDC (f + o) 0.995) 0.75)) }
+
+{ var n0 = LFNoise0.ar([20, 40])
+; var n1 = LFNoise0.ar([5, 10])
+; var x = MouseX.kr(0.012, 0.19, 'exponential', 0.1)
+; var f = Formlet.ar(Blip.ar(10, 12), n0 * 43 + 700, 0.005, x)
+; var o = SinOsc.ar(40, 0) * n1
+; Out.ar(0, LeakDC.ar(f + o, 0.995).clip2(0.75)) }.play
diff --git a/src/lfo-modulation.lhs b/src/lfo-modulation.lhs
new file mode 100644
--- /dev/null
+++ b/src/lfo-modulation.lhs
@@ -0,0 +1,14 @@
+lfo modulation (jmcc)
+
+> import Sound.SC3
+
+> main =
+>   let { o = fSinOsc kr 0.05 0 * 80 + 160
+>       ; p = fSinOsc kr (mce2 0.6 0.7) 0 * 3600 + 4000
+>       ; s = rlpf (lfPulse ar o 0 0.4 * 0.05) p 0.2 }
+>   in audition (out 0 (combL s 0.3 (mce2 0.2 0.25) 2))
+
+{ var o = FSinOsc.kr(0.05, 0, 80, 160)
+; var p = FSinOsc.kr([0.6, 0.7], 0, 3600, 4000)
+; var s = RLPF.ar(LFPulse.ar(o, 0, 0.4, 0.05), p, 0.2)
+; Out.ar(0, CombL.ar(s, 0.3, [0.2, 0.25], 2)) }.play
diff --git a/src/lg-timed.lhs b/src/lg-timed.lhs
new file mode 100644
--- /dev/null
+++ b/src/lg-timed.lhs
@@ -0,0 +1,39 @@
+lg-timed (rd)
+
+> import Sound.SC3.Monadic
+
+> main =
+>   let { timed r y p =
+>         do { d0 <- dser r p
+>            ; d1 <- dcons 0 d0
+>            ; d2 <- dser r y
+>            ; let t = tDuty AR d1 0 RemoveSynth d2 1
+>              in return (latch t t) }
+>       ; lg u = return (lag u 0.03)
+>       ; n = mce [52, 76, 66, 67, 68, 69]
+>       ; a = mce [0.35, 0.15, 0.04, 0.05, 0.16, 0.07]
+>       ; d = mce [0.1, 0.5, 0.09, 0.08, 0.07, 0.3]
+>       ; x = mouseX KR 0.5 1.25 Linear 0.2 }
+>   in do { tn <- lg =<< timed dinf n (d * x)
+>         ; ta <- lg =<< timed dinf a (d * x)
+>         ; audition (out 0 (sinOsc AR (midiCPS tn) 0 * ta)) }
+
+{ var dcons = { arg x, xs
+              ; var i = Dseq.new([0, 1], 1)
+              ; var a = Dseq.new([x, xs], 1)
+              ; Dswitch.new(a, i) }
+; var timed = { arg r, y, p
+              ; var d0 = Dser.new(p, r)
+              ; var d1 = dcons.value(0, d0)
+              ; var d2 = Dser.new(y, r)
+              ; var t = TDuty.ar(d1, 0, d2, 2, 1)
+              ; Latch.ar(t, t) }
+; var lg = { arg u
+           ; Lag.ar(u, 0.03) }
+; var n = [52, 76, 66, 67, 68, 69]
+; var a = [0.35, 0.15, 0.04, 0.05, 0.16, 0.07]
+; var d = [0.1, 0.5, 0.09, 0.08, 0.07, 0.3]
+; var x = MouseX.kr(0.5, 1.25, 'linear', 0.2)
+; var tn = lg.value(timed.value(inf, n, d * x))
+; var ta = lg.value(timed.value(inf, a, d * x))
+; Out.ar(0, SinOsc.ar(tn.midicps, 0) * ta) }.play
diff --git a/src/lin-sosc.lhs b/src/lin-sosc.lhs
new file mode 100644
--- /dev/null
+++ b/src/lin-sosc.lhs
@@ -0,0 +1,58 @@
+lin-sosc (rd)
+
+> import Control.Concurrent
+> import Control.Monad
+> import Sound.OpenSoundControl
+> import Sound.SC3
+> import System.Random
+
+> main =
+>   let { n = 1024
+>       ; x = mouseX KR 0.001 1.0 Linear 0.1
+>       ; tblM b = playBuf 1 b (x * bufRateScale KR b) 0 0 Loop DoNothing
+>       ; tblC b c = playBuf 1 b (in' 1 KR c * bufRateScale KR b) 0 0 Loop DoNothing
+>       ; o = sinOsc AR (tblM 0) 0 * tblM 1 
+>       ; co = clip2 (pan2 o (tblC 1 0) 0.025) 0.25
+>       ; rrand (a, b) = getStdRandom (randomR (a,b))
+>       ; choose l = fmap (l !!) (rrand (0, length l - 1))
+>       ; iota 0 _ _ = []
+>       ; iota n l s = l : iota (n - 1) (l + s) s
+>       ; geom 0 _ _ = []
+>       ; geom n i f = i : geom (n - 1) (i * f) f
+>       ; lineTo n l r = iota n l ((r - l) / n)
+>       ; xlineTo n l r = geom n l ((r / l) ** (1.0 / n))
+>       ; twoPi = pi * 2.0
+>       ; srng l r e = let m = (l - r ) / 2
+>                      in m + l + (e * m) 
+>       ; freq = [ lineTo n 440.0 444.0
+>                , lineTo n 40.0 16000.0
+>                , xlineTo n 40.0 16000.0
+>                , map (srng 20 21000 . sin) (lineTo n 0.0 twoPi)
+>                , map (srng 20 12000 . cos) (lineTo n 0.0 twoPi)
+>                , map (srng 20 22000 . tan) (lineTo n 0.0 twoPi)
+>                , map (srng 20 90 . tan) (lineTo n 0.0 twoPi) ]
+>       ; ampl = [ lineTo n 0.1 1.0
+>                , lineTo n 1.0 0.1
+>                , lineTo n 0.5 0.01
+>                , lineTo n 0.01 0.5
+>                , xlineTo n 1.0 0.1
+>                , xlineTo n 0.1 1.0
+>                , map sin (lineTo n 0.0 twoPi)
+>                , map cos (lineTo n 0.0 twoPi)
+>                , map (* 0.001) (map tan (lineTo n 0 twoPi)) ]
+>       ; sloc = [ 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 ]
+>       ; paus = [0.01, 0.05, 0.1, 0.15, 0.25, 0.5, 0.75]
+>       ; update fd = do { f <- choose freq
+>                        ; a <- choose ampl
+>                        ; s <- choose sloc
+>                        ; p <- choose paus
+>                        ; send fd (b_setn 0 [(0, f)])
+>                        ; send fd (b_setn 1 [(0, a)])
+>                        ; send fd (c_set [(0, s)])
+>                        ; pauseThread p } }
+>   in do { withSC3 (\fd -> do { async fd (b_alloc 0 (floor n) 1)
+>                              ; async fd (b_alloc 1 (floor n) 1)
+>                              ; play fd (out 0 co) })
+>         ; forkIO (withSC3 (\fd -> replicateM_ 128 (update fd))) }
diff --git a/src/lucier.hs b/src/lucier.hs
new file mode 100644
--- /dev/null
+++ b/src/lucier.hs
@@ -0,0 +1,93 @@
+{-
+Alvin Lucier, "Music on a Long Thin Wire, Simulated"
+Chandrasekhar Ramakrishnan
+http://www.listarc.bham.ac.uk/lists/sc-users/msg47539.html
+http://www.listarc.bham.ac.uk/lists/sc-users/msg47540.html
+-}
+
+import Sound.SC3.ID
+
+lucier_wire :: UGen -> IO ()
+lucier_wire freq =
+    let block_size = recip controlRate
+        mk_dt f = recip f - block_size
+	string_delay = mk_dt freq
+	pk1_pos = 0.1 -- pickup one position
+	src_pos = 0.3 -- source position
+	pk2_pos = 0.9 -- pickup two postion
+	max_delay = 1.0 -- maximum delay time (corresponds to a length = c * s)
+	mk_delay i r = lpz1 (delayC i max_delay (r * string_delay))
+	mk_allpass i r dt = lpz1 (allpassC i max_delay (r * string_delay) dt)
+	drv = localIn 1 AR -- driver (source + data stored in the string)
+	pk1_R =
+            let i = drv
+                r = src_pos - pk1_pos
+            in mk_delay i r
+	pk1_L =
+            let i = pk1_R * negate 1
+                r = pk1_pos * 2
+                dt = rand 'α' 0.001 0.11
+            in mk_allpass i r dt
+	pk2_L =
+            let i = pk1_L
+                r = pk2_pos - pk1_pos
+            in mk_delay i r * 0.99
+	stringL =
+            let i = pk2_L
+                r = 1.0 - pk2_pos
+            in mk_delay i r
+	pk2_R =
+            let i = stringL * negate 1
+                r = 1.0 - pk2_pos
+                dt = 2 + rand 'β' 0.001 0.11
+            in mk_allpass i r dt * 0.99
+	stringR =
+            let i = pk2_R
+                r = pk2_pos - src_pos
+            in mk_delay i r
+	source =
+            let s = sinOsc AR 220 0 * 0.01
+                p = pulse AR (60 + amplitude KR drv 0.01 0.01 * 11) 0.5 * 0.1
+                f = rlpf (s + p) 320 0.05
+                e = 1.0 - min (amplitude KR drv 0.01 0.01) 1.0
+	    in normalizer f 0.7 0.01 * e
+	l_out = localOut (source * 0.2 + stringR)
+	outL = pk1_L + pk1_R
+	outR = pk2_L + pk2_R
+    in audition (out 0 (mrg [mce2 outL outR, drv, source, l_out]))
+
+main = lucier_wire 60
+
+{-
+lucier_wire 60
+
+{ var blocksize = ControlRate.ir.reciprocal
+; var mk_dt = { |f| f.reciprocal - blocksize }
+; var string_dt = mk_dt.(60)
+; var c = 425
+; var len = 40
+; var pk1_p = 0.1
+; var src_p = 0.3
+; var pk2_p = 0.9
+; var max_dt = 1
+; var mk_dl = { arg i, r
+                 ; LPZ1.ar(DelayC.ar(i, max_dt, r * string_dt)) }
+; var mk_ap = { arg i, r, dt
+	          ; LPZ1.ar(AllpassC.ar(i, max_dt, r * string_dt, dt)) }
+; var drv = LocalIn.ar(1)
+; var r = { Rand(0.001, 0.11) }
+; var pk1_R = mk_dl.(drv, src_p - pk1_p, 2 + r.())
+; var pk1_L = mk_ap.(pk1_R * -1, pk1_p * 2, r.())
+; var pk2_L = mk_dl.(pk1_L, pk2_p - pk1_p, r.()) * 0.99
+; var strL = mk_dl.(pk2_L, 1 - pk2_p, r.())
+; var pk2_R = mk_ap.(strL * -1, 1 - pk2_p, 2 + r.()) * 0.99
+; var strR = mk_dl.(pk2_R, pk2_p - src_p, 2 + r.())
+; var src = { var a = Amplitude.kr(drv, mul: 11)
+            ; p = Pulse.ar(60 + a, mul: 0.1)
+            ; RLPF.ar((SinOsc.ar(220, 0) * 0.01) + p, 320, 0.05) }
+; var src_n = { var a = Amplitude.kr(drv).min(1.0)
+              ; Normalizer.ar(src, 0.7) * (1.0 - a) }
+; LocalOut.ar(src * 0.2 + strR)
+; [pk1_L + pk1_R, pk2_L + pk2_R, drv, src] }.play
+
+-}
diff --git a/src/modal-space.lhs b/src/modal-space.lhs
new file mode 100644
--- /dev/null
+++ b/src/modal-space.lhs
@@ -0,0 +1,37 @@
+modal space (jmcc)
+
+> import Sound.SC3.Monadic
+
+> main =
+>   let { b = 0
+>       ; p = [0, 2, 3.2, 5, 7, 9, 10] 
+>       ; x = mouseX kr 0 15 Linear 0.1
+>       ; k = degreeToKey 0 x 12
+>       ; c n r = let { o = sinOsc ar (midiCPS (r + k + n * 0.04)) 0 * 0.1
+>                     ; t = lfPulse ar (midiCPS (mce2 48 55)) 0.15 0.5
+>                     ; f = midiCPS (sinOsc kr 0.1 0 * 10 + r)
+>                     ; d = rlpf t f 0.1 * 0.1
+>                     ; m = o + d }
+>                 in combN m 0.31 0.31 2 + m }
+>   in withSC3 (\fd -> do { async fd (b_alloc b (length p) 1)
+>                         ; send fd (b_setn1 b 0 p)
+>                         ; n <- clone 2 (lfNoise1 kr 3)
+>                         ; play fd (out 0 ((c n 48 + c n 72) * 0.25)) })
+
+{ var s = Server.default
+; var b = 0
+; var p = FloatArray[0, 2, 3.2, 5, 7, 9, 10]
+; var x = MouseX.kr(0, 15, 'linear', 0.1)
+; var k = DegreeToKey.kr(b, x, 12)
+; var c = { arg n, r
+          ; var o = SinOsc.ar((r + k + (n * 0.04)).midicps, 0) * 0.1
+          ; var t = LFPulse.ar([48, 55].midicps, 0.15, 0.5)
+          ; var f = (SinOsc.kr(0.1, 0) * 10 + r).midicps
+          ; var d = RLPF.ar(t, f, 0.1) * 0.1
+          ; var m = o + d
+          ; CombN.ar(m, 0.31, 0.31, 2) + m }
+; var n = LFNoise1.kr([3, 3])
+; var b_setn1 = { arg b, i, p
+                ; ["/b_setn", b, i, p.size] ++ p }
+; s.sendMsg("/b_alloc", b, p.size, 1, b_setn1.value(b, 0, p).asRawOSC)
+; Out.ar(0, (c.value(n, 48) + c.value(n, 72)) * 0.25) }.play
diff --git a/src/moto-rev.lhs b/src/moto-rev.lhs
new file mode 100644
--- /dev/null
+++ b/src/moto-rev.lhs
@@ -0,0 +1,12 @@
+moto rev (jmcc)
+
+> import Sound.SC3
+
+> main =
+>   let { f = sinOsc kr 0.2 0 * 10 + 21
+>       ; s = lfPulse ar f (mce2 0 0.1) 0.1 }
+>   in audition (out 0 (clip2 (rlpf s 100 0.1) 0.4))
+
+{ var f = SinOsc.kr(0.2, 0) * 10 + 21
+; var s = LFPulse.ar(f, [0, 0.1], 0.1)
+; Out.ar(0, RLPF.ar(s, 100, 0.1).clip2(0.4)) }.play
diff --git a/src/mouse-clatter.lhs b/src/mouse-clatter.lhs
new file mode 100644
--- /dev/null
+++ b/src/mouse-clatter.lhs
@@ -0,0 +1,55 @@
+mouse clatter (rd)
+
+> import Sound.SC3.Monadic
+
+> main =
+>   let { x = mouseX kr 100 12000 Linear 0.1
+>       ; y = mouseY kr 0.01 0.15 Linear 0.1 }
+>   in do { n1 <- lfNoise0 kr (mce [3, 3.25])
+>         ; let { t = impulse kr (n1 * 16 + 18) 0
+>               ; s = do { n2 <- tRand 0.005 y t
+>                        ; n3 <- whiteNoise ar
+>                        ; n4 <- tRand 10 x t
+>                        ; n5 <- tRand 0 1 t
+>                        ; n6 <- tExpRand 0.15 1 t
+>                        ; o <- let e = decay2 t 0.01 n2
+>                               in return (bpf (n3 * e) n4 n5)
+>                        ; n7 <- pv_RandComb (fft' 10 o) n6 t
+>                        ; return (o * 0.05 + ifft' n7) } }
+>           in withSC3 (\fd -> do { async fd (b_alloc 10 2048 1)
+>                                 ; play fd . out 0 =<< s }) }
+
+s.sendMsg('b_alloc', 10, 2048, 1);
+
+{ var x = MouseX.kr(100, 12000, 'linear', 0.1)
+; var y = MouseY.kr(0.01, 0.15, 'linear', 0.1)
+; var n1 = LFNoise0.kr([3, 3.25])
+; var t = Impulse.kr((n1 * 16) + 18, 0)
+; var n2 = TRand.kr(0.005, y, t)
+; var n3 = WhiteNoise.ar()
+; var n4 = TRand.kr(10, x, t)
+; var n5 = TRand.kr(0, 1, t)
+; var n6 = TExpRand.kr(0.15, 1, t)
+; var o = { var e = Decay2.kr(t, 0.01, n2)
+          ; BPF.ar(n3 * e, n4, n5) }
+; var n7 = PV_RandComb(FFT(10, o), n6, t)
+; var s = (o * 0.05) + IFFT(n7)
+; Out.ar(0, s) }.play
+
+(let* ((x (MouseX kr 100 12000 0 0.1))
+       (y (MouseY kr 0.01 0.15 0 0.1))
+       (n1 (LFNoise0 kr (mce2 3 3.25)))
+       (t (Impulse kr (MulAdd n1 16 18) 0))
+       (n2 (TRand 0.005 y t))
+       (n3 (WhiteNoise ar))
+       (n4 (TRand 10 x t))
+       (n5 (TRand 0.0 1.0 t))
+       (n6 (TExpRand 0.15 1.0 t))
+       (e (Decay2 t 0.01 n2))
+       (o (BPF (Mul n3 e) n4 n5))
+       (n7 (PV_RandComb (FFT* 10 o) n6 t))
+       (s (Add (Mul o 0.05) (IFFT* n7))))
+  (with-sc3
+   (lambda (fd)
+     (async fd (/b_alloc 10 2048 1))
+     (play fd (Out 0 s)))))
diff --git a/src/nharm.lhs b/src/nharm.lhs
new file mode 100644
--- /dev/null
+++ b/src/nharm.lhs
@@ -0,0 +1,26 @@
+nharm (rd)
+
+> import Control.Concurrent
+> import Control.Monad
+> import Sound.SC3.Monadic
+> import System.Random
+
+> main =
+>   let { nharm n f = map ((* f) . fromIntegral) [1..n]
+>       ; rrand l r = getStdRandom (randomR (l, r))
+>       ; threadPause n = when (n>0) (threadDelay (floor (n * 1e6)))
+>       ; klg m u = do { n <- rrand 4 u
+>                      ; d <- rrand 9 12
+>                      ; f <- rrand m (m + 2)
+>                      ; l <- sequence (replicate n (rrand 0.01 0.02))
+>                      ; p <- rrand (-1.0) 1.0
+>                      ; let { a = 0.5
+>                            ; e = envGen kr 1 0.9 0 1 RemoveSynth (envSine d a)
+>                            ; nh = nharm n (midiCPS f)
+>                            ; s = klangSpec nh l (replicate n 0.0) }
+>                        in return (pan2 (klang ar 1 0 s) p e) }
+>       ; ply :: Int -> (Double, Double) -> UGen -> Int -> IO ()
+>       ; ply n (l,r) m u = replicateM_ n (do { threadPause =<< rrand l r
+>                                             ; audition . out 0 =<< klg m u }) }
+>   in do { forkIO (ply 32 (0.25, 0.75) 92 24)
+>         ; forkIO (ply 8 (1.25, 1.75) 12 54) }
diff --git a/src/noise-burst-sweep.lhs b/src/noise-burst-sweep.lhs
new file mode 100644
--- /dev/null
+++ b/src/noise-burst-sweep.lhs
@@ -0,0 +1,18 @@
+noise burst sweep (jmcc)
+
+> import Sound.SC3.Monadic
+
+> main =
+>   do { n <- clone 2 (whiteNoise ar)
+>      ; let { lfoRate = mouseX kr 10 60 Exponential 0.2
+>            ; amp = max 0 (lfSaw kr lfoRate (-1))
+>            ; cfreq = mouseY kr 400 8000 Exponential 0.2
+>            ; freq = sinOsc kr 0.2 0 * cfreq + (1.05 * cfreq) }
+>        in audition (out 0 (resonz (n * amp) freq 0.1)) }
+
+{ var n = WhiteNoise.ar ! 2
+; var lfoRate = MouseX.kr(10, 60, 'exponential', 0.2)
+; var amp = max(0, LFSaw.kr(lfoRate, -1))
+; var cfreq = MouseY.kr(400, 8000, 'exponential', 0.2)
+; var freq = SinOsc.kr(0.2, 0) * cfreq + (1.05 * cfreq)
+; Out.ar(0, Resonz.ar(n * amp, freq, 0.1)) }.play
diff --git a/src/non-real-time.hs b/src/non-real-time.hs
new file mode 100644
--- /dev/null
+++ b/src/non-real-time.hs
@@ -0,0 +1,26 @@
+import Sound.OpenSoundControl {- hosc -}
+import Sound.SC3
+import System.Cmd {- process -}
+
+graph :: UGen
+graph =
+    let f = control KR "freq" 440
+        g = control KR "gain" 0.1
+        e = envGen KR 1 1 0 1 RemoveSynth (envPerc 0.1 1.0)
+        o = sinOsc AR f 0 * e
+    in out 0 (pan2 o 0 g)
+
+score :: [OSC]
+score =
+    let at t m = Bundle (NTPr t) m
+        mk_instr = d_recv (synthdef "test" graph)
+        mk_group = g_new [(1, AddToTail, 0)]
+        mk_node t f = at t [s_new "test" (-1) AddToTail 1 [("freq", f)]]
+        notes = take 128 (zipWith mk_node [0.0, 0.05 ..] [330, 350 ..])
+    in at 0.0 [mk_instr, mk_group] : notes
+
+main :: IO ()
+main = do
+  writeNRT "/tmp/nrt.score" score
+  system "scsynth -N /tmp/nrt.score _ /tmp/nrt.wav 44100 WAVE float"
+  return ()
diff --git a/src/one-line.lhs b/src/one-line.lhs
new file mode 100644
--- /dev/null
+++ b/src/one-line.lhs
@@ -0,0 +1,14 @@
+one-line (lance putnam)
+
+> import Sound.SC3
+
+> main =
+>   let { lfs = lfSaw ar (mce2 1 0.99) (mce2 0 0.6) * 2000 + 2000
+>       ; lfs_t = trunc lfs (mce2 400 600) * mce2 1 (-1)
+>       ; f = onePole (mix lfs_t) 0.98 }
+>   in audition (out 0 (pan2 (sinOsc ar f 0) 0 0.1))
+
+{ var lfs = LFSaw.ar([1, 0.99], [0, 0.6], 2000, 2000)
+; var lfs_t = lfs.trunc([400, 600]) * [1, -1]
+; var f = OnePole.ar(Mix.new(lfs_t), 0.98)
+; Out.ar(0, Pan2.ar(SinOsc.ar(f, 0), 0, 0.1)) }.play
diff --git a/src/oscillator-cluster.lhs b/src/oscillator-cluster.lhs
new file mode 100644
--- /dev/null
+++ b/src/oscillator-cluster.lhs
@@ -0,0 +1,46 @@
+oscillator cluster (rd)
+
+> import Sound.SC3.Monadic
+
+> main =
+>   let { ln a b d = line kr a b d RemoveSynth
+>       ; rln r a b d = fmap (\n -> ln (a + n) b d) (rand 0 r)
+>       ; prt d a cf = do { r1 <- rand cf (cf + 2)
+>                         ; r2 <- rln 1 5 0.01 d
+>                         ; r3 <- rln 10 20 0 d
+>                         ; r4 <- rand 0.1 0.2
+>                         ; let { f = mce2 cf r1 + sinOsc kr r2 0 * r3
+>                               ; o = fSinOsc ar f 0
+>                               ; e = decay2 (impulse ar 0 0) r4 d * a }
+>                          in return (o * e) }
+>       ; np = 12
+>       ; fp = sequence (replicate np (rand 220 660)) }
+>   in do { d <- rand 4 7
+>         ; a <- rand 0.01 0.05
+>         ; audition . (out 0) . sum =<< mapM (prt d a) =<< fp }
+
+{ var ln = { arg a, b, d
+           ; Line.kr(a, b, d, 1) }
+; var xln = { arg a, b, d
+            ; XLine.kr(a, b, d, 1) }
+; var rln = { arg r, a, b, d
+            ; var n = Rand.new(0, r)
+            ; ln.value(a + n, b, d) }
+; var rxln = { arg r, a, b, d
+             ; var n = Rand.new(0, r)
+             ; xln.value(a + n, b, d) }
+; var prt = { arg d, a
+            ; { arg cf
+              ; var r1 = Rand.new(cf, cf + 2)
+              ; var r2 = rln.value(1, 5, 0.01, d)
+              ; var r3 = rln.value(10, 20, 0, d)
+              ; var r4 = Rand.new(0.1, 0.2)
+              ; var f = [cf, r1] + (SinOsc.kr(r2, 0) * r3)
+              ; var o = FSinOsc.ar(f, 0)
+              ; var e = Decay2.ar(Impulse.ar(0, 0), r4, d) * a
+              ; o * e } }
+; var np = 12
+; var fp = Array.fill(np, { Rand.new(220, 660) })
+; var d = Rand.new(4, 7)
+; var a = Rand.new(0.01, 0.05)
+; Out.ar(0, fp.collect(prt.value(d, a)).sum) }.play
diff --git a/src/overlap-add.lhs b/src/overlap-add.lhs
new file mode 100644
--- /dev/null
+++ b/src/overlap-add.lhs
@@ -0,0 +1,41 @@
+overlap-add (jmcc, rd)
+
+> import Control.Concurrent
+> import Sound.OpenSoundControl
+> import Sound.SC3.Monadic
+
+> main =
+>   let { at t f 
+>         = let at' t' f' = do { n <- f' t'
+>                              ; pauseThreadUntil (t' + n)
+>                              ; at' (t' + n) f' }
+>           in do { pauseThreadUntil t
+>                 ; at' t f
+>                 ; return () }
+>       ; mk_env a s 
+>         = let { c = EnvNum 4
+>               ; p = envLinen' a s a 1 (c, c, c) }
+>           in envGen KR 1 1 0 1 RemoveSynth p
+>       ; with_env g a s 
+>         = out 0 (g * (mk_env a s))
+>       ; overlap_add fd n o a s g 
+>         = do { t <- utcr
+>              ; let { g' = with_env g (constant a) (constant s)
+>                    ; dt = (a + s + a) / o 
+>                    ; f _ = do { send fd (s_new n (-1) AddToTail 1 [])
+>                               ; return dt } }
+>                in do { async fd (d_recv (synthdef n g'))
+>                      ; at t f } }
+>       ; oSine fd 
+>         = do { r0 <- expRand 500 1400
+>              ; r1 <- rand (-1) 1
+>              ; let g = pan2 (sinOsc AR r0 0) r1 0.01
+>                in overlap_add fd "random-sines" 4 2 4 g }
+>       ; oNoise fd 
+>         = do { n0 <- whiteNoise AR
+>              ; r0 <- expRand 800 8400
+>              ; r1 <- rand (-1) 1
+>              ; let g = pan2 (resonz (n0 * 0.1) r0 0.05) r1 0.25
+>                in overlap_add fd "random-noise" 4 2 4 g } }
+>   in do { forkIO (withSC3 (\fd -> oSine fd))
+>         ; forkIO (withSC3 (\fd -> oNoise fd)) }
diff --git a/src/pattern-buffer.lhs b/src/pattern-buffer.lhs
new file mode 100644
--- /dev/null
+++ b/src/pattern-buffer.lhs
@@ -0,0 +1,27 @@
+pattern buffer (rd)
+
+> import Sound.SC3.Monadic
+> import System.Random
+
+> main =
+>   let { nf = 2 * 48000
+>       ; c = 24
+>       ; tseq l = let n = fromIntegral (length l) / 2.0
+>                  in select (lfSaw kr 0.5 0 * n + n) (mce l)
+>       ; rrand l r = getStdRandom (randomR (l, r))
+>       ; p = phasor ar 0 (bufRateScale kr 10) 0 (bufFrames kr 10) 0
+>       ; t = bufRdC 1 ar 10 p Loop 
+>       ; rs h = do { r0 <- rrand 0 nf
+>                   ; r1 <- rrand 0.0 1.0
+>                   ; send h (b_set1 10 r0 r1) } }
+>   in do { r1 <- sequence (replicate c (rrand 36 96))
+>         ; r2 <- sequence (replicate c (rrand (-1.0) 1.0))
+>         ; r3 <- rrand 0 1
+>         ; n1 <- tRand 0.02 0.08 t
+>         ; let { e = decay2 t 0.01 n1
+>               ; f = midiCPS (tseq r1)
+>               ; l = tseq r2
+>               ; o = [sinOsc ar f 0, saw ar f] !! r3 }
+>           in withSC3 (\fd -> do { async fd (b_alloc 10 (nf * 2) 1)
+>                                 ; sequence (replicate c (rs fd))
+>                                 ; play fd (out 0 (pan2 o l e)) }) }
diff --git a/src/plucked-strings.lhs b/src/plucked-strings.lhs
new file mode 100644
--- /dev/null
+++ b/src/plucked-strings.lhs
@@ -0,0 +1,23 @@
+plucked strings (jmcc)
+
+> import Sound.SC3.Monadic
+
+> main =
+>   let { s = do { n0 <- pinkNoise ar
+>                ; r1 <- rand (-1) 1
+>                ; im <- i
+>                ; dt' <- dt
+>                ; let t = decay im 0.1 * n0 * 0.1
+>                  in return (pan2 (combL t dt' dt' 4) r1 1) }
+>       ; i = do { r0 <- rand 2 2.2
+>                ; n0 <- dust ar 0.5
+>                ; r1 <- rand 0.05 0.15
+>                ; r2 <- rand 0 (pi * 2)
+>                ; r3 <- iRand 0 2
+>                ; let { s0 = impulse ar r0 0.3
+>                      ; s1 = n0 * 0.3
+>                      ; s2 = impulse ar (sinOsc kr r1 r2 * 5 + 5.2) 0.3 }
+>                  in return (select r3 (mce [s0, s1, s2])) }
+>       ; dt = do { r0 <- rand 60 90
+>                 ; return (1 / (midiCPS (floorE r0))) } }
+>   in audition . out 0 . sum =<< sequence (replicate 5 s)
diff --git a/src/police-state.lhs b/src/police-state.lhs
new file mode 100644
--- /dev/null
+++ b/src/police-state.lhs
@@ -0,0 +1,35 @@
+police state (jmcc)
+
+> import Sound.SC3.Monadic
+
+> main =
+>   let node = do { r0 <- rand 0.02 0.12
+>                 ; r1 <- rand 0 (pi*2)
+>                 ; r2 <- rand 0 600
+>                 ; r3 <- rand 700 1300
+>                 ; r4 <- rand (-1) 1
+>                 ; r5 <- rand 80 120
+>                 ; n0 <- lfNoise2 ar r5
+>                 ; let f = sinOsc kr r0 r1 * r2 + r3
+>                   in return (pan2 (sinOsc ar f 0 * n0 * 0.1) r4 1) }
+>   in do { nodes <- clone 4 node
+>         ; n0 <- clone 2 (lfNoise2 kr 0.4)
+>         ; n1 <- lfNoise2 ar (n0 * 90 + 620)
+>         ; n2 <- lfNoise2 kr (mce2 0.3 0.301)
+>         ; let e = n1 * (n2 * 0.15 + 0.18)
+>           in audition (out 0 (combL (mix nodes + e) 0.3 0.3 3)) }
+
+{ var node = { var r0 = Rand.new(0.02, 0.12)
+             ; var r1 = Rand.new(0, 2pi)
+             ; var r2 = Rand.new(0, 600)
+             ; var r3 = 1000 + Rand.new(-300, 300)
+             ; var r4 = Rand.new(-1, 1)
+             ; var r5 = 100 + Rand.new(-20, 20)
+             ; var n0 = LFNoise2.ar(r5)
+             ; var f = SinOsc.kr(r0, r1, r2, r3)
+             ; Pan2.ar(SinOsc.ar(f, 0) * n0 * 0.1, r4, 1) }
+; var n0 = LFNoise2.kr([0.4, 0.4])
+; var n1 = LFNoise2.ar(n0 * 90 + 620)
+; var n2 = LFNoise2.kr([0.3,0.3])
+; var e = n1 * (n2 * 0.15 + 0.18)
+; Out.ar(0, CombL.ar(Mix.fill(4, node) + e, 0.3, 0.3, 3)) }.play
diff --git a/src/pulsing-bottles.lhs b/src/pulsing-bottles.lhs
new file mode 100644
--- /dev/null
+++ b/src/pulsing-bottles.lhs
@@ -0,0 +1,16 @@
+pulsing bottles (jmcc)
+
+> import Control.Monad
+> import Sound.SC3.Monadic
+
+> main =
+>   let { r = do { n <- whiteNoise ar
+>                ; r0 <- rand 4 14
+>                ; r1 <- rand 0 0.7
+>                ; r2 <- rand 400 7400
+>                ; return (resonz (n * lfPulse kr r0 0 0.25 * r1) r2 0.01) }
+>       ; s = do { f <- rand 0.1 0.5
+>                ; p <- rand 0 (pi * 2)
+>                ; return (sinOsc kr f p) }
+>       ; u = liftM2 (\x y -> pan2 x y 1) r s }
+>   in audition . out 0 . sum =<< sequence (replicate 6 u)
diff --git a/src/record-scratcher.lhs b/src/record-scratcher.lhs
new file mode 100644
--- /dev/null
+++ b/src/record-scratcher.lhs
@@ -0,0 +1,30 @@
+record scratcher (josh parmenter)
+
+> import Sound.SC3
+
+> main =
+>   let { dup a = mce2 a a
+>       ; fn = "/home/rohan/audio/metal.wav"
+>       ; d = env [0, 1, 0] [0.1, 0.1] [EnvSin] 1 0
+>       ; e = envGen kr 1 1 0 1 RemoveSynth d
+>       ; x = mouseX kr (-10) 10 Linear 0.2
+>       ; dx = x - delayN x 0.1 0.1
+>       ; bdx = mouseButton kr 1 0 0.3 + dx
+>       ; bdxr = bdx * bufRateScale kr 0
+>       ; scr = playBuf 1 0 bdxr 0 0 Loop DoNothing }
+>   in withSC3 (\fd -> do { async fd (b_allocRead 0 fn 0 0)
+>                         ; play fd (out 0 (dup (scr * e))) })
+
+{ var fn = "/home/rohan/audio/metal.wav"
+; var b = 0
+; var gate = 1
+; var e = Env.new([0, 1, 0], [0.1, 0.1], \sin, 1, nil)
+; var env = EnvGen.kr(e, gate, doneAction: 2)
+; var x = MouseX.kr(-10, 10, 'linear', 0.2)
+; var dx = x - DelayN.kr(x, 0.1, 0.1)
+; var bdx = MouseButton.kr(1, 0, 0.3) + dx
+; var bdxr = bdx * BufRateScale.kr(b)
+; var scr = PlayBuf.ar(1, b, bdxr, 0, 0, 1)
+; var s = Server.default
+; s.sendMsg("/b_allocRead", b, fn, 0, 0)
+; Out.ar(0, (scr * env).dup ) }.play
diff --git a/src/red-frik.lhs b/src/red-frik.lhs
new file mode 100644
--- /dev/null
+++ b/src/red-frik.lhs
@@ -0,0 +1,32 @@
+red frik (f0)
+
+> import Sound.SC3.Monadic
+
+> main =
+>   let red tr n = 
+>         do { r1 <- tRand 0.3 3 tr
+>            ; r2 <- tRand 0.3 5 tr
+>            ; r3 <- tRand 0 0.5 tr
+>            ; r4 <- tRand 0.49 0.56 tr
+>            ; r5 <- tRand 0.3 0.6 tr
+>            ; r6 <- tRand 0.3 0.5 tr
+>            ; let { o1 = fSinOsc kr r2 0 * r3 + r4
+>                  ; o2 = fSinOsc kr o1 r5 * r6 }
+>              in return (rhpf n r1 o2) }
+>     in do { n <- clone 2 (brownNoise ar)
+>           ; let tr = impulse kr 0.1 0
+>             in audition . out 0 =<< red tr n }
+
+{ var red = { arg tr, n
+            ; var r1 = TRand.kr(0.3, 3, tr)
+            ; var r2 = TRand.kr(0.3, 5, tr)
+            ; var r3 = TRand.kr(0, 0.5, tr)
+            ; var r4 = TRand.kr(0.49, 0.56, tr)
+            ; var r5 = TRand.kr(0.3, 0.6, tr)
+            ; var r6 = TRand.kr(0.3, 0.5, tr)
+            ; var o1 = FSinOsc.kr(r2, 0, r3, r4)
+            ; var o2 = FSinOsc.kr(o1, r5, r6)
+            ; RHPF.ar(n, r1, o2) }
+; var n = [BrownNoise.ar, BrownNoise.ar]
+; var tr = Impulse.kr(0.1, 0)
+; Out.ar(0, red.value(tr, n)) }.play
diff --git a/src/reset.hs b/src/reset.hs
new file mode 100644
--- /dev/null
+++ b/src/reset.hs
@@ -0,0 +1,4 @@
+import Sound.SC3
+
+main :: IO ()
+main = withSC3 reset
diff --git a/src/reverberated-sine-percussion.lhs b/src/reverberated-sine-percussion.lhs
new file mode 100644
--- /dev/null
+++ b/src/reverberated-sine-percussion.lhs
@@ -0,0 +1,38 @@
+reverberated sine percussion (jmcc)
+
+> import Sound.SC3.Monadic
+
+> main =
+>   let { d = 6
+>       ; c = 5
+>       ; a = 4
+>       ; s_ = do { n <- dust ar (2 / constant d)
+>                 ; r <- rand 0 3000
+>                 ; return (resonz (n * 50) (200 + r) 0.003) }
+>       ; x_ i = do { r <- clone 2 (rand 0 0.05)
+>                   ; return (allpassN i 0.05 r 1) } 
+>       ; (>=>) f g = \x -> f x >>= g
+>       ; chain n f = foldl (>=>) return (replicate n f) }
+>   in do { s <- fmap sum (sequence (replicate d s_))
+>         ; y <- let z = delayN s 0.048 0.48
+>                in do { r <- clone c (rand 0 0.1)
+>                      ; n <- lfNoise1 kr r
+>                      ; return (mix (combL z 0.1 (n * 0.04 + 0.05) 15)) }
+>         ; x <- chain a x_ y
+>         ; audition (out 0 (s + x * 0.2)) }
+
+{ var d = 6
+; var c = 5
+; var a = 4
+; var s_ = { var n = Dust.ar(2 / d)
+           ; var r = Rand.new(0, 3000)
+           ; Resonz.ar(n * 50, 200 + r, 0.003) }
+; var s = Mix.ar(Array.fill(d, s_))
+; var z = DelayN.ar(s, 0.048)
+; var y_ = LFNoise1.kr(Array.fill(c, { Rand.new(0, 0.1) }), 0.04, 0.05)
+; var y = Mix.ar(CombL.ar(z, 0.1, y_, 15))
+; var x = y
+; var x_ = { var r = [Rand.new(0, 0.05), Rand.new(0, 0.05)]
+           ; x = AllpassN.ar(x, 0.050, r, 1) }
+; a.do(x_)
+; Out.ar(0, s + (0.2 * x)) }.play
diff --git a/src/rm-octaver.lhs b/src/rm-octaver.lhs
new file mode 100644
--- /dev/null
+++ b/src/rm-octaver.lhs
@@ -0,0 +1,10 @@
+rm-octaver (andrea valle, miller puckette)
+
+> import Sound.SC3
+
+> main =
+>   let { defaultPitch x = pitch x 440 60 4000 100 16 1 0.01 0.5 1
+>       ; i = soundIn 0
+>       ; p = defaultPitch i
+>       ; f = mceChannel 0 p }
+>   in audition (out 0 (sinOsc ar (f * 0.5) 0 * i + i))
diff --git a/src/s-chirp.lhs b/src/s-chirp.lhs
new file mode 100644
--- /dev/null
+++ b/src/s-chirp.lhs
@@ -0,0 +1,23 @@
+s-chirp (rd)
+
+> import Sound.SC3.Monadic
+
+> main =
+>   let { x = mouseX kr 15 0 Linear 0.1
+>       ; y = mouseY kr 15 27 Linear 0.1
+>       ; scl = [0, 2, 3.2, 5, 7, 9, 10] }
+>   in do { t <- dust kr 9
+>         ; b <- tChoose t (mce [36, 48, 60, 72])
+>         ; n <- fmap (* 0.04) (lfNoise1 kr (mce2 3 3.05))
+>         ; d <- tiRand x y t
+>         ; e <- fmap (decay2 t 0.005) (tRand 0.02 0.15 t)
+>         ; o <- let { k = degreeToKey 0 d 12
+>                    ; f = midiCPS (b + k + n)
+>                    ; m = e * sinOsc ar f 0 * 0.2
+>                    ; u = pulseDivider t 9 0 }
+>                in do { r0 <- tRand 0.0075 0.125 u
+>                      ; r1 <- tRand 0.05 0.15 u
+>                      ; return (m * 0.5 + allpassC m 0.15 r0 r1) }
+>         ; withSC3 (\fd -> do { async fd (b_alloc 0 7 1)
+>                              ; send fd (b_setn1 0 0 scl)
+>                              ; play fd (out 0 o) }) }
diff --git a/src/sample-and-hold-liquidities.lhs b/src/sample-and-hold-liquidities.lhs
new file mode 100644
--- /dev/null
+++ b/src/sample-and-hold-liquidities.lhs
@@ -0,0 +1,22 @@
+sample and hold liquidities (jmcc)
+
+> import Sound.SC3.ID
+
+> main =
+>   let { r = mouseX kr 1 200 Exponential 0.1
+>       ; t = recip r
+>       ; c = impulse kr r 0.4
+>       ; cf = mouseY kr 100 8000 Exponential 0.1
+>       ; f = latch (whiteNoise 'α' kr * cf * 0.5 + cf) c
+>       ; p = latch (whiteNoise 'β' kr) c
+>       ; i = pan2 (sinOsc ar f 0 * decay2 c (t * 0.1) (t * 0.9)) p 1 }
+>   in audition (out 0 (combN i 0.3 0.3 2))
+
+{ var r = MouseX.kr(1, 200, 'exponential', 0.1)
+; var t = r.reciprocal
+; var c = Impulse.kr(r, 0.4)
+; var cf = MouseY.kr(100, 8000, 'exponential', 0.1)
+; var f = Latch.kr(WhiteNoise.kr * cf * 0.5 + cf, c)
+; var p = Latch.kr(WhiteNoise.kr, c)
+; var i = Pan2.ar(SinOsc.ar(f, 0, Decay2.kr(c, 0.1 * t, 0.9 * t)), p, 1)
+; Out.ar(0, CombN.ar(i, 0.3, 0.3, 2)) }.play
diff --git a/src/scratchy-m.lhs b/src/scratchy-m.lhs
new file mode 100644
--- /dev/null
+++ b/src/scratchy-m.lhs
@@ -0,0 +1,12 @@
+scratchy-m (jmcc)
+
+> import Sound.SC3.Monadic
+
+> main =
+>   do { n <- clone 2 (brownNoise ar)
+>      ; let f = max (n * 0.5 - 0.49) 0 * 20
+>        in audition (out 0 (rhpf f 5000 1)) }
+
+{ var n = BrownNoise.ar([0.5, 0.5])
+; var f = (n - 0.49).max(0) * 20
+; Out.ar(0, RHPF.ar(f, 5000, 1)) }.play
diff --git a/src/scratchy.lhs b/src/scratchy.lhs
new file mode 100644
--- /dev/null
+++ b/src/scratchy.lhs
@@ -0,0 +1,12 @@
+scratchy (jmcc)
+
+> import Sound.SC3.ID
+
+> main =
+>   let { f m = brownNoise m ar * 0.5 - 0.49
+>       ; n = mce2 (f 'α') (f 'β') }
+>   in audition (out 0 (rhpf (max n 0 * 20) 5000 1))
+
+{ var n = BrownNoise.ar([0.5, 0.5])
+; var f = (n - 0.49).max(0) * 20
+; Out.ar(0, RHPF.ar(f, 5000, 1)) }.play
diff --git a/src/scritto.lhs b/src/scritto.lhs
new file mode 100644
--- /dev/null
+++ b/src/scritto.lhs
@@ -0,0 +1,126 @@
+scritto (rd)
+
+> import Sound.SC3.Monadic
+
+> main =
+>   let { scritto = [ ( "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] ) ]
+>       ; s_msg n (_, f, a, b) = b_setn1 n 0 (f ++ a ++ b)
+>       ; s_alloc fd (s, b) = do { async fd (b_alloc b 15 1)
+>                                ; send fd (s_msg b s) }
+>       ; buf_at b n = bufRd 1 kr b (mce [n .. n + 4]) NoLoop NoInterpolation
+>       ; v_filter i f a b = resonz i f (b / f) * dbAmp a
+>       ; v_filter_b bi i = v_filter i (buf_at bi 0) (buf_at bi 5) (buf_at bi 10)
+>       ; mk_instr bx = do 
+>           { n <- lfNoise2 kr 3
+>           ; let { t = impulse ar (n * 9 + 9) 0
+>                 ; i d = do { n1 <- tRand 0.02 0.06 t
+>                            ; n2 <- tiRand 30 52 t
+>                            ; n3 <- tiRand 16 32 t
+>                            ; let { p = pulseDivider t d 0
+>                                  ; b = blip ar (midiCPS n2) n3 }
+>                              in return (decay2 p 0.01 n1 * b * 12) }
+>                 ; bi = linLin n (-1) 1 0 bx
+>                 ; voice = mix . v_filter_b bi }
+>             in return . out 0 . mce . map voice =<< mapM i [1, 2] } }
+>   in withSC3 (\fd -> do { mapM_ (s_alloc fd) (zip scritto [0..])
+>                         ; let n = constant (length scritto)
+>                           in audition =<< mk_instr n })
diff --git a/src/shepard-tones.lhs b/src/shepard-tones.lhs
new file mode 100644
--- /dev/null
+++ b/src/shepard-tones.lhs
@@ -0,0 +1,42 @@
+shepard tones (alberto de campo)
+
+> import Sound.SC3
+
+> main =
+>   let { indxs n l r = let i = (r - l) / n 
+>                       in [l, l + i .. r - i]
+>       ; hanningWindow n = 
+>             let { lp = pi * (-0.5)
+>                 ; rp = lp + 2 * pi 
+>                 ; hf i = sin i * 0.5 + 0.5 }
+>             in map hf (indxs n lp rp)
+>       ; square x = x * x
+>       ; ampTable = map square (hanningWindow 1024) 
+>       ; amp_f i = (0.5 ** i) * 20000
+>       ; freqTable = map amp_f (indxs 1024 0 10)
+>       ; ratescale = 1024 / 44100 / 10
+>       ; rate = 0.1
+>       ; ph = phasor ar 0 (rate * ratescale) 0 1024 0
+>       ; phases = mce (map (\n -> n * 0.1 * 1024 + ph) [0..9])
+>       ; freqs = bufRdC 1 ar 1 phases Loop
+>       ; amps = bufRdC 1 ar 2 phases Loop
+>       ; tone = mix (sinOsc ar freqs 0 * amps) * 0.1 }
+>   in withSC3 (\fd -> do { async fd (b_alloc 1 1024 1)
+>                         ; async fd (b_alloc 2 1024 1)
+>                         ; send fd (b_setn1 1 0 freqTable)
+>                         ; send fd (b_setn1 2 0 ampTable)
+>                         ; audition (out 0 tone) })
+
+{ var ampTable = Signal.hanningWindow(1024).squared
+; var amp_f = { arg i; 0.5 ** i * 20000 }
+; var freqTable = Signal.newClear(1024).waveFill(amp_f, 0, 10)
+; var b1 = Buffer.loadCollection(s, freqTable)
+; var b2 = Buffer.loadCollection(s, ampTable)
+; var ratescale = 1024 / 44100 / 10
+; var rate = 0.1
+; var ph = Phasor.ar(0, rate * ratescale, 0, 1024, 0)
+; var phases = (0..9) * 0.1 * 1024 + ph
+; var freqs = BufRd.ar(1, b1.bufnum, phases)
+; var amps = BufRd.ar(1, b2.bufnum, phases)
+; var tone = Mix.ar(SinOsc.ar(freqs) * amps) * 0.1 
+; Out.ar(0, tone)}.play
diff --git a/src/shifting-pulses.lhs b/src/shifting-pulses.lhs
new file mode 100644
--- /dev/null
+++ b/src/shifting-pulses.lhs
@@ -0,0 +1,23 @@
+shifting pulses (rd)
+
+> import Sound.SC3.Monadic
+
+> main =
+>   do { [n0, n1, n2] <- sequence (replicate 3 (clone 2 (brownNoise kr)))
+>      ; t <- dust kr 0.75
+>      ; let { warp i = linLin i (-1) 1
+>            ; l = latch t t
+>            ; p = pulse ar (warp n0 2 (mce2 11 15)) 0.01 * 0.1 
+>            ; f = warp n1 300 1800 
+>            ; rq = warp n2 0.01 2 }
+>        in audition (out 0 (l * rlpf p f rq)) }
+
+{ var n0 = BrownNoise.kr.dup
+; var n1 = BrownNoise.kr.dup
+; var n2 = BrownNoise.kr.dup
+; var t = Dust.kr(0.75)
+; var l = Latch.kr(t, t)
+; var p = Pulse.ar(n0.range(2, [11, 15]), 0.01) * 0.1 
+; var f = n1.range(300, 1800)
+; var rq = n2.range(0.01, 2)
+; Out.ar(0, l * RLPF.ar(p, f, rq)) }.play
diff --git a/src/snare-909.lhs b/src/snare-909.lhs
new file mode 100644
--- /dev/null
+++ b/src/snare-909.lhs
@@ -0,0 +1,46 @@
+snare-909 (jmcc)
+
+> import Sound.SC3.Monadic
+
+> main =
+>   let { snr tr n v =
+>         let { e a b = envGen ar tr 1 0 1 DoNothing (envPerc a b)
+>             ; e1 = e 0.0005 0.055
+>             ; e2 = e 0.0005 0.075
+>             ; e3 = e 0.0005 0.4
+>             ; e4 = e 0.0005 0.283
+>             ; t1 = lfTri ar 330 0
+>             ; t2 = lfTri ar 185 0
+>             ; x1 = lpf n 7040 * 0.1 + v
+>             ; x2 = hpf x1 523
+>             ; m1 = t1 * e1 * 0.25 + t2 * e2 * 0.25
+>             ; m2 = x1 * e3 * 0.20 + x2 * e4 * 0.20 }
+>         in m1 + m2
+>       ; x = mouseX kr 1 4 Linear 0.2
+>       ; y = mouseY kr 0.25 0.75 Exponential 0.2
+>       ; t = impulse kr (3 * x) 0 }
+>   in do { n <- whiteNoise ar
+>         ; v <- tRand 0.25 1.0 t
+>         ; audition (out 0 (pan2 (snr t n v) 0 y)) }
+
+{ var snr =
+      { arg tr, n, v
+      ; var e = { arg a, b
+                ; EnvGen.ar(Env.perc(a, b), tr, 1, 0, 1, 0) }
+      ; var e1 = e.value(0.0005, 0.055)
+      ; var e2 = e.value(0.0005, 0.075)
+      ; var e3 = e.value(0.0005, 0.4)
+      ; var e4 = e.value(0.0005, 0.283)
+      ; var t1 = LFTri.ar(330, 0)
+      ; var t2 = LFTri.ar(185, 0)
+      ; var x1 = LPF.ar(n, 7040) * (0.1 + v)
+      ; var x2 = HPF.ar(x1, 523)
+      ; var m1 = (t1 * e1 * 0.25) + (t2 * e2 * 0.25)
+      ; var m2 = (x1 * e3 * 0.20) + (x2 * e4 * 0.20)
+      ; m1 + m2 }
+; var x = MouseX.kr(1, 4, 'linear', 0.2)
+; var y = MouseY.kr(0.25, 0.75, 'exponential', 0.2)
+; var t = Impulse.kr(3 * x, 0)
+; var n = WhiteNoise.ar
+; var v = TRand.kr(0.25, 1.0, t)
+; Out.ar(0, Pan2.ar(snr.value(t, n, v), 0, y)) }.play
diff --git a/src/sosc-lp.lhs b/src/sosc-lp.lhs
new file mode 100644
--- /dev/null
+++ b/src/sosc-lp.lhs
@@ -0,0 +1,34 @@
+sosc-lp (rd)
+
+> import Sound.SC3.Monadic
+
+> main =
+>   let { dustR r lo hi = do { n1 <- dwhite 1 lo hi
+>                            ; n2 <- whiteNoise r
+>                            ; d <- dseq dinf n1
+>                            ; return (tDuty r d 0 DoNothing (abs n2) 1) }
+>       ; a = [60, 71, 89, 65, 36, 57, 92, 97, 92, 97]
+>       ; b = [71, 89, 60, 57, 65, 36, 95, 92, 93, 97]
+>       ; setup fd = do { 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) }
+>       ; d_env t = decay2 t 0.002 2.5
+>       ; idx t = stepper t 0 0 15 1 0
+>       ; f1 t = let { l = (bufRdL 1 kr 10 (idx t) Loop - 24)
+>                    ; r = (bufRdL 1 kr 11 (idx t) Loop - 24) }
+>                in midiCPS (mce2 l r)
+>       ; f2 t n = f1 t + n * 1.2
+>       ; o1 t = sinOsc ar (f1 t) 0 * d_env t
+>       ; o2 t n = sinOsc ar (f2 t n) 0 * d_env t
+>       ; sosc_lp t n = out 0 ((o1 t + o2 t n) * 0.2) }
+>   in do { clk <- dustR kr 0.2 0.9
+>         ; n <- lfNoise0 kr (mce2 1 3)
+>         ; audition (sosc_lp clk n) }
+
+> resetter =
+>   let { a = [71, 60, 65, 89, 36, 57, 95, 97, 92, 97]
+>       ; b = [89, 71, 60, 65, 57, 36, 92, 95, 93, 97]
+>       ; resetup fd = do { send fd (b_setn1 10 0 a)
+>                         ; send fd (b_setn1 11 0 b) } }
+>   in withSC3 resetup
diff --git a/src/spe.lhs b/src/spe.lhs
new file mode 100644
--- /dev/null
+++ b/src/spe.lhs
@@ -0,0 +1,23 @@
+spe (jmcc)
+
+> import Sound.SC3.Monadic
+
+> main =
+>   let { (>=>) f g = \x -> f x >>= g
+>       ; chain n f = foldl (>=>) return (replicate n f)
+>       ; rapf i = do { r <- clone 2 (rand 0 0.05)
+>                     ; return (allpassN i 0.05 r 4) }
+>       ; src = let { t = impulse kr 9 0
+>                   ; e = envGen kr t 0.1 0 1 DoNothing (envPerc 0.1 1)
+>                   ; s = mce [ 00, 03, 02, 07
+>                             , 08, 32, 16, 18
+>                             , 00, 12, 24, 32 ] }
+>               in do { n <- lfNoise1 kr 1
+>                     ; m <- dseq dinf s
+>                     ; let { f = midiCPS (demand t 0 m + 32)
+>                           ; o = lfSaw ar f 0 * e
+>                           ; rq = midiCPS (n * 36 + 110) }
+>                       in return (rlpf o rq 0.1) } }
+>   in audition . (out 0) =<< chain 4 rapf =<< src
+
+[variant of graph in streams & patterns tutorial]
diff --git a/src/sprinkler-m.lhs b/src/sprinkler-m.lhs
new file mode 100644
--- /dev/null
+++ b/src/sprinkler-m.lhs
@@ -0,0 +1,13 @@
+sprinkler-m (jmcc)
+
+> import Sound.SC3.Monadic
+
+> main =
+>   do { n <- whiteNoise ar
+>      ; let { f = lfPulse kr 0.09 0 0.16 * 10 + 7
+>            ; t = lfPulse kr f 0 0.25 * 0.1 }
+>        in audition (out 0 (bpz2 (n * t))) }
+
+{ var f = LFPulse.kr(0.09, 0, 0.16, 10, 7)
+; var t = LFPulse.kr(f, 0, 0.25, 0.1)
+; Out.ar(0, BPZ2.ar(WhiteNoise.ar * t)) }.play
diff --git a/src/sprinkler.lhs b/src/sprinkler.lhs
new file mode 100644
--- /dev/null
+++ b/src/sprinkler.lhs
@@ -0,0 +1,13 @@
+sprinkler (jmcc)
+
+> import Sound.SC3.ID
+
+> main =
+>   let { n = whiteNoise 'α' AR
+>       ; f = lfPulse KR 0.09 0 0.16 * 10 + 7
+>       ; t = lfPulse KR f 0 0.25 * 0.1 }
+>   in audition (out 0 (bpz2 (n * t)))
+
+{ var f = LFPulse.kr(0.09, 0, 0.16, 10, 7)
+; var t = LFPulse.kr(f, 0, 0.25, 0.1)
+; Out.ar(0, BPZ2.ar(WhiteNoise.ar * t)) }.play
diff --git a/src/strummable-guitar.lhs b/src/strummable-guitar.lhs
new file mode 100644
--- /dev/null
+++ b/src/strummable-guitar.lhs
@@ -0,0 +1,27 @@
+strummable guitar (jmcc)
+
+> import Sound.SC3.ID
+
+> main =
+>   let { scale = [ 52, 57, 62, 67, 71, 76 ]
+>       ; str i = let { x = mouseX kr 0 1 Linear 0.2
+>                     ; t = abs (hpz1 (x >* (0.25 + constant i * 0.1)))
+>                     ; e = decay t 0.05
+>                     ; n = pinkNoise i ar * e
+>                     ; dt = 1 / (midiCPS (scale !! i))
+>                     ; s = combL n dt dt 4 }
+>                 in pan2 s (constant i * 0.2 - 0.5) 1
+>       ; strs = mixFill (length scale) str }
+>   in audition (out 0 (leakDC (lpf strs 12000) 0.995))
+
+{ var scale = [ 52, 57, 62, 67, 71, 76 ]
+; var str = { arg i
+            ; var x = MouseX.kr(0, 1, 'linear', 0.2)
+            ; var t = HPZ1.kr(x > (0.25 + (i * 0.1))).abs
+            ; var e = Decay.kr(t, 0.05)
+            ; var n = PinkNoise.ar * e
+            ; var dt = scale.at(i).midicps.reciprocal
+            ; var s = CombL.ar(n, dt, dt, 4)
+            ; Pan2.ar(s, i * 0.2 - 0.5, 1) }
+; var strs = Mix.fill(scale.size, str)
+; Out.ar(0, LeakDC.ar(LPF.ar(strs, 12000), 0.995)) }.play
diff --git a/src/sweepy-noise.lhs b/src/sweepy-noise.lhs
new file mode 100644
--- /dev/null
+++ b/src/sweepy-noise.lhs
@@ -0,0 +1,17 @@
+sweepy noise (jmcc)
+
+> import Sound.SC3.Monadic
+
+> main =
+>   do { n <- clone 2 (whiteNoise ar)
+>      ; let { lfoDepth = mouseY kr 200 8000 Exponential 0.1
+>            ; lfoRate = mouseX kr 4 60 Exponential 0.1
+>            ; freq = lfSaw kr lfoRate 0 * lfoDepth + (lfoDepth * 1.2)
+>            ; filtered = rlpf (n * 0.03) freq 0.1 }
+>        in audition (out 0 (combN filtered 0.3 0.3 2 + filtered)) }
+
+{ var lfoDepth = MouseY.kr(200, 8000, 'exponential', 0.1)
+; var lfoRate = MouseX.kr(4, 60, 'exponential', 0.1)
+; var freq = LFSaw.kr(lfoRate, 0) * lfoDepth + (lfoDepth * 1.2)
+; var filtered = RLPF.ar(WhiteNoise.ar([0.03,0.03]), freq, 0.1)
+; Out.ar(0, CombN.ar(filtered, 0.3, 0.3, 2) + filtered) }.play
diff --git a/src/synthetic-piano.lhs b/src/synthetic-piano.lhs
new file mode 100644
--- /dev/null
+++ b/src/synthetic-piano.lhs
@@ -0,0 +1,33 @@
+synthetic piano (jmcc)
+
+> import Sound.SC3.Monadic
+
+> main =
+>   let p = do { n <- iRand 36 90
+>              ; f <- rand 0.1 0.5
+>              ; ph <- rand 0 (pi * 2)
+>              ; let { s = impulse ar f ph * 0.1
+>                    ; e = decay2 s 0.008 0.04
+>                    ; c i = do { n0 <- lfNoise2 ar 3000
+>                               ; let { o = [-0.05, 0, 0.04] !! i
+>                                     ; dt = 1 / (midiCPS (n + o)) }
+>                                 in return (combL (n0 * e) dt dt 6) }
+>                    ; l = ((n - 36) / 27) - 1 }
+>                in do { c_ <- mixFillM 3 c
+>                      ; return (pan2 c_ l 1) } }
+>   in audition . out 0 =<< mixFillM 6 (const p)
+
+{ var p = { var n = IRand.new(36, 90)
+          ; var f = Rand.new(0.1, 0.5)
+          ; var ph = Rand.new(0, pi * 2)
+          ; var s = Impulse.ar(f, ph) * 0.1
+          ; var e = Decay2.ar(s, 0.008, 0.04)
+          ; var c = { arg i
+                    ; var n0 = LFNoise2.ar(3000)
+                    ; var o = [-0.05, 0, 0.04].at(i)
+                    ; var dt = 1 / (n + o).midicps
+                    ; CombL.ar(n0 * e, dt, dt, 6) }
+          ; var l = ((n - 36) / 27) - 1
+          ; var c_ = Mix.fill(3, c)
+          ; Pan2.ar(c_, l, 1) }
+; Out.ar(0, Mix.fill(6, p)) }.play
diff --git a/src/tank.lhs b/src/tank.lhs
new file mode 100644
--- /dev/null
+++ b/src/tank.lhs
@@ -0,0 +1,64 @@
+tank (jmcc)
+
+> import Control.Monad
+> import Sound.SC3.Monadic
+
+> main =
+>   let { r_allpass i = do { r <- clone 2 (rand 0.005 0.02)
+>                          ; return (allpassN i 0.03 r 1) }
+>       ; chain n f = foldl (>=>) return (replicate n f)
+>       ; pling = do { d <- dust ar 0.2
+>                    ; f <- expRand 300 2200
+>                    ; p <- rand (-1) 1
+>                    ; let { s1 = cubed (fSinOsc ar f 0)
+>                          ; s2 = decay2 d 0.1 0.5 * 0.1 * s1 }
+>                      in return (pan2 s2 p 1) }
+>       ; bang = do { d <- dust ar 0.01
+>                   ; n <- brownNoise ar
+>                   ; return (pan2 (decay2 d 0.04 0.3 * n) 0 1) }
+>       ; tank i = do { r1 <- clone 2 (rand 0.01 0.05)
+>                     ; r2 <- clone 2 (rand 0.03 0.15)
+>                     ; let { l0 = localIn 2 ar * 0.98
+>                           ; l1 = onePole l0 0.33
+>                           ; [l1l, l1r] = mceChannels l1
+>                           ; l2 = rotate2 l1l l1r 0.23
+>                           ; l3 = allpassN l2 0.05 r1 2
+>                           ; l4 = delayN l3 0.3 (mce [0.17, 0.23])
+>                           ; l5 = allpassN l4 0.05 r2 2
+>                           ; l6 = leakDC l5 0.995
+>                           ; l7 = l6 + i }
+>                       in return (mrg [l7, localOut l7]) }
+>       ; signal = do { s <- liftM2 (+) bang (mixFillM 8 (const pling))
+>                     ; chain 4 r_allpass s } }
+>   in audition . out 0 =<< tank =<< signal
+
+{ var r_allpass = { arg signal
+                  ; var r = { Rand.new(0.005, 0.02) }.dup
+                  ; AllpassN.ar(signal, 0.03, r, 1); }
+; var pling = { var d = Dust.ar(0.2)
+              ; var f = ExpRand.new(300, 2200)
+              ; var p = Rand.new(-1, 1)
+              ; var s1 = FSinOsc.ar(f, 0).cubed
+              ; var s2 = Decay2.ar(d, 0.1, 0.5) * 0.1 * s1
+              ; Pan2.ar(s2, p, 1) }
+; var bang = { var d = Dust.ar(0.01)
+             ; var n = BrownNoise.ar
+             ; Pan2.ar(Decay2.ar(d, 0.04, 0.3) * n, 0, 1) }
+; var tank = { arg i
+             ; var r1 = { Rand.new(0.01,0.05) }.dup
+             ; var r2 = { Rand.new(0.03,0.15) }.dup
+             ; var l0 = LocalIn.ar(2) * 0.98
+             ; var l1 = OnePole.ar(l0, 0.33)
+             ; var l2 = Rotate2.ar(l1[0], l1[1], 0.23)
+             ; var l3 = AllpassN.ar(l2, 0.05, r1, 2)
+             ; var l4 = DelayN.ar(l3, 0.3, [0.17,0.23])
+             ; var l5 = AllpassN.ar(l4, 0.05, r2, 2)
+             ; var l6 = LeakDC.ar(l5, 0.995)
+             ; var l7 = l6 + i
+             ; LocalOut.ar(l7)
+             ; l7 }
+; var signal = Mix.fill(12, pling) + bang.value
+; 4.do({ signal = r_allpass.value(signal) })
+; Out.ar(0, tank.value(signal)) }.play
+
+http://create.ucsb.edu/pipermail/sc-users/2004-April/009692.html
diff --git a/src/tgb.lhs b/src/tgb.lhs
new file mode 100644
--- /dev/null
+++ b/src/tgb.lhs
@@ -0,0 +1,33 @@
+tgb (rd)
+
+> import Sound.SC3.Monadic
+> import System.Random
+
+> main =
+>   let { mkls bp t = envGen kr 1 1 0 1 RemoveSynth (envCoord bp t 1 EnvLin)
+>       ; pm_t l r d t = let { le = mkls l d
+>                            ; re = mkls r d }
+>                        in tRand le re t
+>       ; wrp i l r = linLin i (-1) 1 l r
+>       ; pm_n rt l d = let { le = mkls l d
+>                           ; re = mkls l d }
+>                       in do { n <- whiteNoise rt
+>                             ; return (wrp n le re) }
+>       ; gb b d = do { gps <- pm_n ar [(0, 400), (1, 900)] d
+>                     ; let { t = impulse ar gps 0
+>                           ; pm_f (l, r) = pm_t l r d t }
+>                       in do { du <- pm_f ([(0, 0.005), (0.5, 0.015), (1, 0.005)]
+>                                          ,[(0, 0.009), (0.5, 0.020), (1, 0.009)])
+>                             ; pn <- pm_f ([(0, -1.0), (0.5, -0.5), (1, 0.5)]
+>                                          ,[(0, -0.5), (0.5, 0.5), (1, 1.0)])
+>                             ; rt <- pm_f ([(0, 6), (0.5, 12), (1, 6)]
+>                                          ,[(0, 12), (0.5, 12), (1, 12)])
+>                             ; cs <- pm_f ([(0, 0), (1, 0.95)]
+>                                          ,[(0, 0), (1, 1)])
+>                             ; am <- pm_f ([(0, 0.25), (0.5, 0.55), (1, 0.15)]
+>                                          ,[(0, 0.5), (0.5, 0.75), (1, 0.25)])
+>                             ; let cs' = cs * (bufDur kr b)
+>                               in return (tGrains 2 t b rt cs' du pn am 2) } }
+>       ; fn = "/home/rohan/audio/text.snd" }
+>   in withSC3 (\fd -> do { async fd (b_allocRead 10 fn 0 0)
+>                         ; play fd . (out 0) =<< gb 10 12 })
diff --git a/src/tgr-rpr.lhs b/src/tgr-rpr.lhs
new file mode 100644
--- /dev/null
+++ b/src/tgr-rpr.lhs
@@ -0,0 +1,42 @@
+tgr-rpr (rd)
+
+> import Sound.OpenSoundControl
+> import Sound.SC3.Monadic
+> import System.Random
+
+> main =
+>   let { sf = "/home/rohan/audio/text.snd"
+>       ; preset = [ 0.01, 0.02
+>                  , 0.95, 1.05
+>                  , 0.02, 0.06
+>                  , 0.2, 0.3
+>                  , 0.7, 0.9
+>                  , -1.0, 1.0 ]
+>       ; dustR r lo hi = do { n1 <- dwhite 1 lo hi
+>                            ; n2 <- whiteNoise r
+>                            ; d <- dseq dinf n1
+>                            ; return (tDuty r d 0 DoNothing (abs n2) 1) }
+>       ; rpr n t = tRand (in' 1 kr n) (in' 1 kr (n + 1)) t
+>       ; rrand l r = getStdRandom (randomR (l, r))
+>       ; rSet = [ (0.005, 0.025), (0.05, 0.25)
+>                , (0.75,  0.95) , (1.05, 1.25)
+>                , (0.001, 0.01) , (0.02, 0.04)
+>                , (0.1,   0.2)  , (0.2, 0.4)
+>                , (0.0,   0.45) , (0.55, 1.0)
+>                , (-1.0,  0.0)  , (0.0, 1.0) ]
+>       ; edit fd = do { s <- mapM (\(l,r) -> rrand l r) rSet
+>                      ; send fd (c_setn [(0, s)])
+>                      ; pauseThread 0.35 } }
+>   in do { clk <- dustR ar (in' 1 kr 0) (in' 1 kr 1)
+>         ; rat <- rpr 2 clk
+>         ; dur <- rpr 4 clk
+>         ; pos <- fmap (* (bufDur kr 10)) (rpr 8 clk)
+>         ; pan <- rpr 10 clk
+>         ; amp <- rpr 6 clk
+>         ; withSC3 (\fd -> do { async fd (b_allocRead 10 sf 0 0)
+>                              ; send fd (c_setn [(0, preset)])
+>                              ; let o = tGrains 2 clk 10 rat pos dur pan amp 2
+>                                in play fd (out 0 o)
+>                              ; pauseThread 0.3
+>                              ; sequence (replicate 16 (edit fd))
+>                              ; reset fd }) }
diff --git a/src/tgrn.lhs b/src/tgrn.lhs
new file mode 100644
--- /dev/null
+++ b/src/tgrn.lhs
@@ -0,0 +1,20 @@
+tgrn (rd)
+ghci -e main tgrn.lhs
+C-cC-l C-cC-m
+
+> import Sound.SC3.ID
+
+> tgrn b =
+>   let { trate = mouseY kr 2 120 Exponential 0.1
+>       ; dur = 1.2 / trate
+>       ; clk = impulse ar trate 0
+>       ; pos = mouseX kr 0 (bufDur kr b) Linear 0.1
+>       ; pan = whiteNoise 'α' kr * 0.6
+>       ; n = roundE (whiteNoise 'β' kr * 3) 1
+>       ; rate = shiftLeft 1.2 n }
+>   in tGrains 2 clk b rate pos dur pan 0.25 2
+
+> main =
+>   let fn = "/home/rohan/audio/text.snd"
+>   in withSC3 (\fd -> do { async fd (b_allocRead 10 fn 0 0)
+>                         ; audition (out 0 (tgrn 10)) })
diff --git a/src/theremin.lhs b/src/theremin.lhs
new file mode 100644
--- /dev/null
+++ b/src/theremin.lhs
@@ -0,0 +1,22 @@
+theremin (jmcc)
+
+> import Sound.SC3
+
+> main =
+>   let { m = 7
+>       ; detune = 0
+>       ; x = mouseX kr 0 0.9 Linear 0.2
+>       ; y = mouseY kr 4000 200 Exponential 0.8
+>       ; f = y + detune
+>       ; f' = f + f * sinOsc ar m 0 * 0.02
+>       ; a = sinOsc ar f' 0 * x }
+>   in audition (out 0 (pan2 a 0 1))
+
+{ var mod = 7
+; var detune = 0
+; var x = MouseX.kr(0, 0.9, 'linear', 0.2)
+; var y = MouseY.kr(4000, 200, 'exponential', 0.8)
+; var f = y + detune
+; var f_ = f + (f * SinOsc.ar(mod, 0) * 0.02)
+; var a = SinOsc.ar(f_, 0) * x
+; Out.ar(0, (Pan2.ar(a, 0, 1))) }.play
diff --git a/src/three-cpsw.lhs b/src/three-cpsw.lhs
new file mode 100644
--- /dev/null
+++ b/src/three-cpsw.lhs
@@ -0,0 +1,24 @@
+three-cpsw (rd)
+
+> import Sound.SC3.Monadic
+
+> main =
+>   do { t <- dust kr (mce2 12 18)
+>      ; f0 <- tRand 1 64 t
+>      ; f1 <- lfNoise0 kr f0
+>      ; a <- tRand 0.0 0.5 t
+>      ; dt <- tRand 0.975 1.025 t
+>      ; dh <- tRand 0.750 0.7505 t
+>      ; let { f = f1 * mce2 9000 12000 + 9500
+>            ; o = saw ar f + saw ar (f * dh) + saw ar (f * dt) }
+>        in audition (out 0 (clip2 (o * a) 0.75)) }
+
+{ var t = Dust.kr([12, 18])
+; var f0 = TRand.kr(1, 64, t)
+; var f1 = LFNoise0.kr(f0)
+; var a = TRand.kr(0.0, 0.5, t)
+; var dt = TRand.kr(0.975, 1.025, t)
+; var dh = TRand.kr(0.750, 0.7505, t)
+; var f = f1 * [9000, 12000] + 9500
+; var o = Saw.ar(f) + Saw.ar(f * dh) + Saw.ar(f * dt)
+; Out.ar(0, (o * a).clip2(0.75)) }.play
diff --git a/src/thx.lhs b/src/thx.lhs
new file mode 100644
--- /dev/null
+++ b/src/thx.lhs
@@ -0,0 +1,38 @@
+thx (perry cook)
+
+> import Sound.SC3
+> import System.Random
+
+> main =
+>   let { rvb i rT 
+>           = let { d = mce [0.0297, 0.0371, 0.0411, 0.0437]
+>                 ; c = mix (combN i 0.05 d rT * 0.25)
+>                 ; f = (allpassN c 0.01 0.005 0.096835) }
+>             in allpassN f 0.01 0.0017 0.032924
+>       ; mk_env z0 t0 z1 t1 t2 z2 t3 c
+>           = let { z = [z0, z1, z1, z2, z2]
+>                 ; t = [t0, t1, t2, t3]
+>                 ; e = env z t [c, c, c] (-1.0) (-1.0) }
+>             in envGen KR 1 1 0 1 RemoveSynth e
+>       ; mk_node t4 f0 f1 l 
+>           = let { f = mk_env f0 t0 f0 t1 t2 f1 (t3 + t4 + t5 + t5) EnvLin
+>                 ; g = mk_env 0 t0 0.1 (t1 + t2 + t3) t4 0.0 (t5 + t5) EnvLin
+>                 ; s = saw AR f
+>                 ; t0 = 0.035
+>                 ; t1 = 0.2267573696
+>                 ; t2 = 2.2675736061
+>                 ; t3 = 6.8027210884
+>                 ; t5 = 1.75 }
+>             in pan2 s l g
+>       ; thx 
+>           = let { s = foldl1 (+) (zipWith3 (mk_node t4) f0 f1 l)
+>                 ; t4 = 7.9365079365
+>                 ; n = 30
+>                 ; l = take n (randomRs (-1.0, 1.0) (mkStdGen 1))
+>                 ; f = [29, 87.5, 116, 175, 233, 350, 524, 880, 1048, 1760]
+>                 ; f0 = take n (randomRs (200.0, 800.0) (mkStdGen 2))
+>                 ; f1 = take n (cycle f) }
+>             in out 0 (rvb (mce [s]) t4) }
+>   in audition thx
+
+http://ccrma-mail.stanford.edu/pipermail/stk/2007-January/000327.html
diff --git a/src/tipnso.lhs b/src/tipnso.lhs
new file mode 100644
--- /dev/null
+++ b/src/tipnso.lhs
@@ -0,0 +1,15 @@
+tipnso (rd)
+
+> import Sound.SC3.Monadic
+
+> main =
+>   let { x = mouseX kr 1 32 Linear 0.1
+>       ; t = impulse ar x 0 }
+>   in do { n1 <- tiRand 16 72 t
+>         ; n2 <- tiRand 0 1 t
+>         ; n3 <- pinkNoise ar
+>         ; let { e = decay2 t 0.01 (mce2 0.1 0.15)
+>               ; f = midiCPS (n1 + 36 + (12 * n2))
+>               ; s = sinOsc ar f 0 * e
+>               ; b = bpf (n3 * e) (36 + midiCPS n1) (175 / (midiCPS n1)) }
+>           in audition (out 0 ((s + b) * mce2 0.15 0.1)) }
diff --git a/src/tr-out.lhs b/src/tr-out.lhs
new file mode 100644
--- /dev/null
+++ b/src/tr-out.lhs
@@ -0,0 +1,23 @@
+tr-out (rd)
+
+> import Sound.SC3.Monadic
+
+> main =
+>   let node n = do { t <- dust kr 1.6
+>                   ; r1 <- tRand 0 6 t
+>                   ; r2 <- tRand 0 6 t
+>                   ; r3 <- tRand 0 6 t
+>                   ; let { f = midiCPS (bufRdN 1 kr 0 r1 NoLoop)
+>                         ; p = bufRdN 1 kr 1 r2 NoLoop
+>                         ; a = bufRdN 1 kr 2 r3 NoLoop }
+>                     in return ( pan2 (sinOsc ar f 0) p a
+>                               , sendTrig t n (f / 660) ) }
+>   in withSC3 (\fd -> do { async fd (b_alloc 0 6 1)
+>                         ; send fd (b_setn1 0 0 [60, 62, 64, 65, 67, 69])
+>                         ; async fd (b_alloc 1 6 1)
+>                         ; send fd (b_setn1 1 0 [-1, -0.5, 0, 0.25, 0.75, 1.0])
+>                         ; async fd (b_alloc 2 6 1)
+>                         ; send fd (b_setn1 2 0 [0.01, 0.05, 0.1, 0.15, 0.25, 0.35])
+>                         ; ns <- mapM node [1..4]
+>                         ; let o = sum (map fst ns)
+>                           in play fd (out 0 (mrg (o : map snd ns))) })
diff --git a/src/train.lhs b/src/train.lhs
new file mode 100644
--- /dev/null
+++ b/src/train.lhs
@@ -0,0 +1,25 @@
+train (th.list at gmail.com)
+
+> import Sound.SC3.Monadic
+
+> main =
+>   let { time = 24
+>       ; steam n1 n2 = let { piston = lfSaw AR (xLine AR 1 7 time DoNothing) 0
+>                           ; air = lpf (n1 * piston + n2 * piston) 5000 
+>                           ; e = envGen AR 1 1 0 1 DoNothing (envSine time 9) }
+>                       in bpf air 600 (1 + e)
+>       ; whistle n3 = let { f = [800, 600, 1200, 990]
+>                          ; s = klankSpec f [1, 1, 1, 1] [1, 1, 1, 1]
+>                          ; t = [0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 0]
+>                          ; l = [2, 0, 0.2, 0, 0.2, 0, 0.8, 0, 4, 0, 3]
+>                          ; d = env t l (repeat EnvLin) 0 0
+>                          ; e = envGen AR 1 1 0 (time/10) DoNothing d }
+>                      in klank (n3 * 0.004) 1 0 1 s * e
+>       ; loc = let e = env [-0.8, 0.8] [time + 2] [EnvSin, EnvSin] 0 0
+>               in envGen AR 1 1 0 1 RemoveSynth e }
+>   in do { n1 <- whiteNoise AR
+>         ; n2 <- pinkNoise AR
+>         ; n3 <- whiteNoise AR
+>         ; audition (out 0 (pan2 (steam n1 n2 + whistle n3) loc 1)) }
+
+http://www.create.ucsb.edu/pipermail/sc-users/2007-August/035957.html
diff --git a/src/trkl.lhs b/src/trkl.lhs
new file mode 100644
--- /dev/null
+++ b/src/trkl.lhs
@@ -0,0 +1,27 @@
+trkl (rd)
+
+> import Sound.SC3.Monadic
+
+> main =
+>   let trkl d ul fu dy la fy =
+>           let { tf = xLine kr 1 ul d RemoveSynth
+>               ; st = impulse ar (tf * 8) 0
+>               ; t = impulse ar tf 0 }
+>           in do { r0 <- rand (-1) 1
+>                 ; r1 <- rand (-1) 1
+>                 ; r2 <- tRand 0.05 1.0 t
+>                 ; r3 <- tExpRand 0.0 0.25 st 
+>                 ; fh <- tRand 1.75 2.25 t 
+>                 ; let { a = dbAmp (line kr 12 la d RemoveSynth)
+>                       ; f = xLine kr fu 900 d RemoveSynth
+>                       ; p = line kr r0 r1 d RemoveSynth
+>                       ; o1 = mix (ringz (decay2 t 0.01 dy) (mce2 f (f * fh)) fy)
+>                       ; o2 = mix (saw ar (mce2 f (f * fh))) }
+>                  in return (pan2 (o1 + o2 * decay2 t 0.1 r2 * r3) p a) }
+>   in do { d <- rand 0.5 16
+>         ; ul <- rand 16 64
+>         ; fu <- rand 1200 9000
+>         ; dy <- rand 0.005 0.175
+>         ; la <- rand (-60) (-25)
+>         ; fy <- rand 0.015 0.125
+>         ; audition . (out 0) =<< trkl d ul fu dy la fy }
diff --git a/src/tsort.lhs b/src/tsort.lhs
new file mode 100644
--- /dev/null
+++ b/src/tsort.lhs
@@ -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 Sound.SC3
+
+> main =
+>   let { n = 122
+>       ; c = envCoord [(0,0), (0.15, 1), (6, 0)] 1 1 EnvLin
+>       ; e = envGen kr 1 1 0 1 RemoveSynth c
+>       ; f o = sinOsc ar (440 + constant o) 0 * 0.001
+>       ; s = mixFill n f }
+>   in audition (out 0 (s * e))
+
+http://create.ucsb.edu/pipermail/sc-users/2003-March/002807.html
diff --git a/src/vlc-distrtn.lhs b/src/vlc-distrtn.lhs
new file mode 100644
--- /dev/null
+++ b/src/vlc-distrtn.lhs
@@ -0,0 +1,133 @@
+vlc-distrtn (rd)
+caution - audio feedback graph
+
+> import Sound.OpenSoundControl
+> import Sound.SC3.Monadic
+> import System.Random
+
+> main =
+>   let { rrand l r = getStdRandom (randomR (l, r))
+>       ; choose l = return . (l !!) =<< rrand 0 (length l - 1)
+>       ; prep (ampl, phase) = [dbAmp ampl, phase]
+>       ; 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) ]
+>       ; partial b i freq detune fall n =
+>           do { n0 <- lfNoise1 kr 1
+>              ; n1 <- rand 0.75 1.25
+>              ; let { m = n * 2
+>                    ; ampl = bufRdN 1 kr b m NoLoop
+>                    ; f = freq * (n + 1) * (n0 * detune + 1) }
+>                in return (ringz i f (fall * n1) * ampl) }
+>       ; plyr n =
+>           let { ctl j k = control kr j k
+>               ; buf = ctl "buf" 0
+>               ; iamp = ctl "iamp" 0.1
+>               ; ampl = ctl "ampl" 0.1
+>               ; freq = ctl "freq" 129.897
+>               ; fall = ctl "fall" 0.5
+>               ; loc = ctl "loc" 0.0
+>               ; detune = ctl "detune" 0.001
+>               ; i = soundIn 0 * iamp }
+>           in do { s <- mapM (partial buf i freq detune fall) [0 .. n-1]
+>                 ; return (out 0 (clip2 (pan2 (sum s) loc ampl) 0.1)) }
+>       ; degree_to_key degree scale steps =
+>           let scale_n = length scale
+>           in (steps * (degree `div` scale_n)) + (scale !! (degree `mod` scale_n))
+>       ; getCps b =
+>           do { b_ <- choose b
+>              ; d <- choose [0 .. 8]
+>              ; let k = degree_to_key d [0, 2, 3, 5, 7, 8, 10] 12
+>                in return (midiCPS (b_ + realToFrac k)) }
+>       ; pattern fd =
+>           do { f <- getCps [24, 36, 48, 55, 60]
+>              ; ia <- rrand 0.05 0.75
+>              ; l <- rrand (-1) 1
+>              ; a <- rrand 0.05 0.1
+>              ; d <- rrand 0.001 0.005
+>              ; fl <- rrand 1 7
+>              ; send fd (n_set 1002 [("freq", f)
+>                                    ,("iamp", ia)
+>                                    ,("buf", 0)
+>                                    ,("loc", l)
+>                                    ,("ampl", a)
+>                                    ,("detune", d)
+>                                    ,("fall", fl)])
+>              ; pauseThread =<< choose [0.25, 0.5, 0.75, 1.5] } }
+>   in withSC3 (\fd -> do { async fd (b_alloc 0 (length vlc * 2) 1)
+>                         ; send fd (b_setn1 0 0 (concatMap prep vlc))
+>                         ; async fd . d_recv . synthdef "plyr48" =<< plyr 48
+>                         ; send fd (s_new "plyr48" 1002 AddToTail 1 [])
+>                         ; sequence (replicate 32 (pattern fd)) })
diff --git a/src/waveset.hs b/src/waveset.hs
new file mode 100644
--- /dev/null
+++ b/src/waveset.hs
@@ -0,0 +1,155 @@
+{- A simple waveset synthesiser (rd) -}
+
+import Control.Monad
+import qualified Data.Array as A {- array -}
+import Data.List
+import qualified Sound.File.NeXT as F {- hsc3-sf -}
+import Sound.OpenSoundControl {- hosc -}
+import Sound.SC3
+import System.Environment
+import System.Random {- random -}
+
+-- * Score model.
+
+-- | Interval to schedule in advance.
+latency :: Double
+latency = 0.15
+
+-- | Add t to timestamp.
+offset :: Double -> OSC -> OSC
+offset t (Bundle (UTCr t0) m) = Bundle (UTCr (t + t0)) m
+offset _ _ = undefined
+
+-- | Play non-empty set of osc bundles.
+play_set :: Transport t => t -> [OSC] -> IO ()
+play_set _ [] = undefined
+play_set fd (x:xs) = do
+  let (Bundle (UTCr t) _) = x
+  pauseThreadUntil (t - latency)
+  mapM_ (\e -> send fd e) (x:xs)
+
+-- | Play grouped score.
+play_sets :: Transport t => t -> [[OSC]] -> IO ()
+play_sets _ [] = return ()
+play_sets fd s = do
+  t <- utcr
+  mapM_ (play_set fd) (map (\g -> map (offset t) g) s)
+
+-- | Split l into chunks of at most n elements.
+form_sets :: Int -> [a] -> [[a]]
+form_sets _ [] = []
+form_sets n l =
+    let (a,b) = splitAt n l
+    in a : form_sets n b
+
+-- | Play score, send in sets on indicated cardinality.
+play_score :: Transport t => Int -> t -> [OSC] -> IO ()
+play_score n fd s = play_sets fd (form_sets n s)
+
+-- * Waveset analysis
+
+-- | Zero-crossing predicate.
+is_zc :: (Num a, Ord a) => a -> a -> Bool
+is_zc a b = a <= 0 && b > 0
+
+-- | Locate fractional zero-crossing point.
+locate_fzc :: (Ord a, Fractional a) => a -> a -> a
+locate_fzc x y = (1.0 / (y - x)) * abs x
+
+-- | Fractional zero-crossing constructor, n is the initial frame location.
+fzc :: (Ord a, Fractional a) => a -> [a] -> [a]
+fzc _ [] = []
+fzc _ [_] = []
+fzc n (x:y:z) = if is_zc x y
+                then (n + locate_fzc x y) : fzc (n + 2.0) z
+                else fzc (n + 1.0) (y : z)
+
+-- | Remove zero crossings so that no waveset has length less than m.
+prune :: (Ord a, Num a) => a -> a -> [a] -> [a]
+prune _ _ [] = [] -- hmmm....
+prune m n (x:xs) = if (x - n) < m
+                   then prune m n xs
+                   else x : prune m x xs
+
+-- | zc -> ws
+ws :: [a] -> [(a,a)]
+ws [] = []
+ws [_] = []
+ws (x:y:z) = (x,y) : ws (y : z)
+
+-- * Waveset instrument
+
+-- | A trivial waveset instrument with unit envelope.
+waveset :: UGen
+waveset =
+    let k = control KR
+        o = k "out" 0
+        b = k "bufnum" 0
+        s = k "start" 0
+        e = k "end" 0
+        r = k "rate" 1
+        d = k "dur" 1
+        a = k "amp" 0.2
+        rs = bufRateScale KR b * r
+        ph = phasor AR 0 rs 0 (e - s) 0 + s
+        e_data = env [a, a, 0] [d, 0] [EnvLin] (-1) (-1)
+        e_ugen = envGen AR 1 1 0 1 RemoveSynth e_data
+    in offsetOut o (bufRdL 1 AR b ph Loop * e_ugen)
+
+-- * Waveset synthesizer
+
+-- | Construct s_new message for synthesiser.
+mk_msg :: Double -> Double -> Double -> Double -> OSC
+mk_msg b sf ef d =
+    let a = [("bufnum", b), ("start", sf), ("end", ef), ("dur", d)]
+    in s_new "waveset" (-1) AddToTail 1 a
+
+-- | Compare wavesets by duration.
+dur_ord :: (Num t, Ord t) => (t, t) -> (t, t) -> Ordering
+dur_ord (s0, e0) (s1, e1) = compare (e0 - s0) (e1 - s1)
+
+-- | Generate score from waveset data.
+mk_score :: Double -> [Double] -> [(Double, Double)] -> [OSC]
+mk_score sr repeats w =
+    let durations = zipWith (\(s, e) r -> (e - s) * r / sr) w repeats
+        start_times = scanl (+) 0 durations
+        mk_elem (s,e) t d = Bundle (UTCr t) [mk_msg 10 s e d]
+    in zipWith3 mk_elem w start_times durations
+
+-- | n randomly chosen elements of w.
+rchoose :: Int -> [a] -> [a]
+rchoose n w =
+    let (l, r) = (1, length w)
+        a = A.listArray (l,r) w
+    in take n (map (a A.!) (randomRs (l,r) (mkStdGen 1)))
+
+-- | Load waveset instrument, allocate sound file buffer, do waveset
+--   analysis, generate & play scores.
+run_waveset :: Transport t => t -> String -> IO ()
+run_waveset fd fn = do
+  async fd (d_recv (synthdef "waveset" waveset))
+  async fd (b_allocRead 10 fn 0 0)
+  (hdr, cs) <- F.read fn
+  let nc = F.channelCount hdr
+      nf = F.frameCount hdr
+      sr = fromIntegral (F.sampleRate hdr)
+      b = cs !! 0
+      w = ws (prune 64 0 (fzc 0 b))
+      pl s = play_score 10 fd s >> pauseThread 1
+  putStrLn ("#f: " ++ show (nc, nf, sr))
+  putStrLn ("#w: " ++ show (length w)) -- force w
+  pl (mk_score sr (repeat 1) w)
+  pl (mk_score sr (repeat 2) (reverse w))
+  pl (mk_score sr (cycle [2,4,8]) (sortBy dur_ord w))
+  pl (mk_score sr (randomRs (1,24) (mkStdGen 2)) (rchoose 512 w))
+
+main :: IO ()
+main = do
+  a <- getArgs
+  case a of
+    [fn] -> withSC3 (\fd -> run_waveset fd fn)
+    _ -> error "audio file?"
+
+{--
+withSC3 (\fd -> run_waveset fd "/home/rohan/audio/text.snd")
+--}
diff --git a/src/what-was-i-thinking.lhs b/src/what-was-i-thinking.lhs
new file mode 100644
--- /dev/null
+++ b/src/what-was-i-thinking.lhs
@@ -0,0 +1,34 @@
+what was i thinking? (jmcc)
+
+> import Sound.SC3.Monadic
+
+> main =
+>   do { n0 <- lfNoise1 kr 0.2
+>      ; n1 <- lfNoise1 kr 0.157
+>      ; let { p = pulse ar f (n1 * 0.4 + 0.5) * 0.04
+>            ; i = lfPulse ar 0.1 0 0.05 * impulse ar 8 0 * 500
+>            ; d = decay i 2
+>            ; f = max (sinOsc kr 4 0 + 80) d
+>            ; z = rlpf p (n0 * 2000 + 2400) 0.2
+>            ; c x = do { r <- rand 0 0.3
+>                       ; n <- lfNoise1 kr r
+>                       ; return (combL x 0.06 (n * 0.025 + 0.035) 1) }
+>            ; y = z * 0.6 }
+>        in do { z0 <- clone 2 (c y)
+>              ; z1 <- clone 2 (c y)
+>              ; audition (out 0 (z + mce [mix z0, mix z1])) } }
+
+{ var n0 = LFNoise1.kr(0.2, 2000, 2400)
+; var n1 = LFNoise1.kr(0.157, 0.4, 0.5)
+; var i = LFPulse.ar(0.1, 0, 0.05) * Impulse.ar(8, 0) * 500
+; var d = Decay.ar(i, 2)
+; var f = max(SinOsc.kr(4, 0) + 80, d)
+; var p = Pulse.ar(f, n1) * 0.04
+; var z = RLPF.ar(p, n0, 0.2)
+; var c = { arg i
+          ; var r = Rand.new(0, 0.3)
+          ; var n = LFNoise1.kr(r, 0.025, 0.035)
+          ; CombL.ar(i, 0.06, n, 1) }
+; var y = z * 0.6
+; Out.ar(0, z + [ c.value(y) + c.value(y)
+                , c.value(y) + c.value(y) ]) }.play
diff --git a/src/wial.lhs b/src/wial.lhs
new file mode 100644
--- /dev/null
+++ b/src/wial.lhs
@@ -0,0 +1,22 @@
+wial (rd)
+
+> import Sound.SC3.Monadic
+
+> main =
+>   let { pls c d f = let { t = pulseDivider c d 0
+>                         ; e = decay2 t 0.05 0.75
+>                         ; o = sinOsc ar (toggleFF t * f + f * 2) 0 }
+>                      in do { n0 <- tiRand 0 1 t
+>                            ; return (o * e * n0 * 0.5) }
+>       ; smpl f = [ (4, 6, f      , 0.75)
+>                  , (2, 6, f *   2, 0.75)
+>                  , (1, 2, f *  16, 0.025)
+>                  , (1, 5, f *  64, 0.005)
+>                  , (1, 4, f * 128, 0.035)
+>                  , (1, 3, f * 256, 0.15)
+>                  , (2, 3, f * 512, 0.35) ]
+>       ; plss c (d0, d1, f, a) = fmap (* a) (pls c (mce2 d0 d1) f)
+>       ; clk = impulse ar 16 0 }
+>   in do { n0 <- dust kr 2
+>         ; f <- twChoose n0 (mce2 (20 * 0.66) 20) (mce2 0.25 0.75) 0
+>         ; audition . out 0 . sum =<< mapM (plss clk) (smpl f) }
diff --git a/src/wind-metals.lhs b/src/wind-metals.lhs
new file mode 100644
--- /dev/null
+++ b/src/wind-metals.lhs
@@ -0,0 +1,29 @@
+wind metals (jmcc)
+
+> import Sound.SC3.Monadic
+
+> main =
+>   let n = 6
+>   in do { base <- expRand 60 4000
+>         ; range <- rand 500 8000
+>         ; n0 <- clone 2 (brownNoise ar)
+>         ; r0 <- expRand 0.125 0.5
+>         ; n1 <- lfNoise1 kr r0
+>         ; f <- sequence (replicate n (rand base (base + range)))
+>         ; dt <- sequence (replicate n (rand 0.1 2))
+>         ; let { exc = n0 * 0.007 * max 0 (n1 * 0.75 + 0.25)
+>               ; k = klankSpec f (replicate n 1) dt
+>               ; s = klank exc 1 0 1 k }
+>           in audition (out 0 (softClip (s * 0.1))) }
+
+{ var n = 6
+; var base = ExpRand.new(60, 4000)
+; var range = Rand.new(500.0, 8000.0)
+; var n0 = BrownNoise.ar([0.007, 0.007])
+; var r0 = ExpRand.new(0.125, 0.5)
+; var n1 = LFNoise1.kr(r0, 0.75, 0.25)
+; var exc = n0 * max(0, n1)
+; var f = Array.fill(n, { Rand.new(0, range) + base })
+; var dt = Array.fill(n, { Rand.new(0.1, 2.0) })
+; var s = Klank.ar(`[f, nil, dt], exc)
+; Out.ar(0, (s * 0.1).softclip) }.play
diff --git a/src/xy-interference-m.lhs b/src/xy-interference-m.lhs
new file mode 100644
--- /dev/null
+++ b/src/xy-interference-m.lhs
@@ -0,0 +1,20 @@
+xy-interference-m (rd)
+
+> import Sound.SC3.Monadic
+
+> main =
+>   let { x = mouseX KR 20 22000 Linear (mce2 0.005 0.025)
+>       ; y = mouseY KR 20 22000 Linear (mce2 0.005 0.075)
+>       ; nd = do { n <- lfNoise0 KR (mce2 5 9)
+>                 ; let { a = sinOsc AR (x + n) 0
+>                       ; b = sinOsc AR y 0 }
+>                   in return (a * b) } }
+>   in audition . (out 0) . sum =<< sequence (replicate 3 nd)
+
+{ var x = MouseX.kr(20, 22000, 'linear', [0.005, 0.025])
+; var y = MouseY.kr(20, 22000, 'linear', [0.005, 0.075])
+; var nd = { var n = LFNoise0.kr([5, 9])
+           ; var a = SinOsc.ar(x + n, 0)
+           ; var b = SinOsc.ar(y, 0)
+           ; a * b }
+; Out.ar(0, Mix.fill(3, nd)) }.play
diff --git a/src/xy-interference.lhs b/src/xy-interference.lhs
new file mode 100644
--- /dev/null
+++ b/src/xy-interference.lhs
@@ -0,0 +1,20 @@
+xy-interference (rd)
+
+> import Sound.SC3.ID
+
+> main =
+>   let { x = mouseX KR 20 22000 Linear (mce2 0.005 0.025)
+>       ; y = mouseY KR 20 22000 Linear (mce2 0.005 0.075)
+>       ; nd k = let { n = lfNoise0 k KR (mce2 5 9)
+>                    ; a = sinOsc AR (x + n) 0
+>                    ; b = sinOsc AR y 0 }
+>                in a * b }
+>   in audition (out 0 (sum (map nd ['α'..'γ'])))
+
+{ var x = MouseX.kr(20, 22000, 'linear', [0.005, 0.025])
+; var y = MouseY.kr(20, 22000, 'linear', [0.005, 0.075])
+; var nd = { var n = LFNoise0.kr([5, 9])
+           ; var a = SinOsc.ar(x + n, 0)
+           ; var b = SinOsc.ar(y, 0)
+           ; a * b }
+; Out.ar(0, Mix.fill(3, nd)) }.play