examples/demonstrations/SC2-examples_1.scd

   1 //////////////////////////////////////////////////////////////////////////
   2
   3 (
   4 // analog bubbles
   5 {
   6         f = LFSaw.kr(0.4, 0, 24, LFSaw.kr([8,7.23], 0, 3, 80)).midicps; // glissando function
   7         CombN.ar(SinOsc.ar(f, 0, 0.04), 0.2, 0.2, 4) // echoing sine wave
   8 }.play)
   9
  10 //////////////////////////////////////////////////////////////////////////
  11
  12 (
  13 // LFO modulation of Pulse waves and resonant filters
  14 play({
  15         CombL.ar(
  16                 RLPF.ar(LFPulse.ar(FSinOsc.kr(0.05,0,80,160),0,0.4,0.05),
  17                    FSinOsc.kr([0.6,0.7],0,3600,4000), 0.2),
  18                 0.3, [0.2,0.25], 2)
  19 }))
  20
  21 //////////////////////////////////////////////////////////////////////////
  22
  23 (
  24 // moto rev
  25 {
  26         RLPF.ar(LFPulse.ar(SinOsc.kr(0.2, 0, 10, 21), 0.1), 100, 0.1).clip2(0.4)
  27 }.play)
  28
  29 //////////////////////////////////////////////////////////////////////////
  30
  31 (
  32 // scratchy
  33 play({  RHPF.ar(BrownNoise.ar([0.5,0.5], -0.49).max(0) * 20, 5000, 1)  })
  34 )
  35
  36 //////////////////////////////////////////////////////////////////////////
  37
  38 (
  39 // sprinkler
  40 play({
  41         BPZ2.ar(WhiteNoise.ar(LFPulse.kr(LFPulse.kr(0.09, 0, 0.16, 10, 7), 0, 0.25, 0.1)))
  42 }))
  43
  44 (
  45 play({
  46         BPZ2.ar(WhiteNoise.ar(LFPulse.kr(MouseX.kr(0.2,50), 0, 0.25, 0.1)))
  47 }))
  48
  49 //////////////////////////////////////////////////////////////////////////
  50
  51 (
  52 // harmonic swimming
  53 play({
  54         var f, p, z, offset;
  55         f = 50;         // fundamental frequency
  56         p = 20;         // number of partials per channel
  57         z = 0.0;                // start of oscil daisy chain
  58         offset = Line.kr(0, -0.02, 60); // causes sound to separate and fade
  59         p.do({ arg i;
  60                 z = FSinOsc.ar(
  61                                 f * (i+1),              // freq of partial
  62                                 0,
  63                                 max(0,                  // clip negative amplitudes to zero
  64                                         LFNoise1.kr(
  65                                                 6 + [4.0.rand2, 4.0.rand2],     // amplitude rate
  66                                                 0.02,                                   // amplitude scale
  67                                                 offset                                  // amplitude offset
  68                                         )
  69                                 ),
  70                                 z
  71                 )
  72         });
  73         z
  74 }))
  75
  76 //////////////////////////////////////////////////////////////////////////
  77
  78 (
  79 // harmonic tumbling
  80 play({
  81         var f, p, z, trig;
  82         f = 80; // fundamental frequency
  83         p = 10; // number of partials per channel
  84         z = 0.0;        // start of oscil daisy chain
  85         trig = XLine.kr([10,10], 0.1, 60);      // trigger probability decreases over time
  86         p.do({ arg i;
  87                 z = FSinOsc.ar(
  88                                 f * (i+1),              // freq of partial
  89                                 0,
  90                                 Decay2.kr(
  91                                         Dust.kr(
  92                                                 trig,           // trigger rate
  93                                                 0.02            // trigger amplitude
  94                                         ),
  95                                         0.005,  // grain attack time
  96                                         0.5.rand        // grain decay time
  97                                 ),
  98                                 z
  99                 )
 100         });
 101         z
 102 }))
 103
 104 //////////////////////////////////////////////////////////////////////////
 105
 106 (
 107 {
 108 // Klank - bank of resonators excited by impulses
 109 var n, p, z;
 110 n = 5;  // number of simultaneous instruments
 111 p = 15; // number of partials per instrument
 112         z = `[  // filter bank specification :
 113                                 Array.fill(p, { 80 + 10000.0.linrand} ),        // frequencies
 114                                 Array.fill(p, { 1.0.rand2 }),                   // amplitudes
 115                                 Array.fill(p, { 0.2 + 8.0.rand } )              // ring times
 116                         ];
 117                 Pan2.ar(
 118                         Klank.ar(z, Dust.ar(0.7, 0.04)),
 119                         1.0.rand2
 120                 )
 121 }.play;
 122 )
 123
 124 //////////////////////////////////////////////////////////////////////////
 125
 126 (
 127 {
 128 // Klank - excited by noise bursts
 129 var n, p;
 130 var exciter, spec;
 131 n = 5;  // number of simultaneous instruments
 132 p = 8;  // number of partials per instrument
 133                 exciter = Decay.ar(Dust.ar(0.6, 0.001), 3.1, WhiteNoise.ar);
 134                 spec = Array.fill(2, {
 135                         `[
 136                                 Array.fill(p, { 80 + 10000.0.linrand} ),
 137                                 nil,
 138                                 Array.fill(p, { 0.2 + 4.0.rand } )
 139                         ]
 140                 });
 141                 Klank.ar(spec, exciter)
 142 }.play;
 143 )
 144
 145 //////////////////////////////////////////////////////////////////////////
 146
 147 (
 148 // what was I thinking?
 149 {
 150         z = RLPF.ar(
 151                 Pulse.ar(
 152                         max( SinOsc.kr(4, 0, 1, 80),
 153                                 Decay.ar(LFPulse.ar(0.1, 0, 0.05, Impulse.ar(8, 0, 500)), 2)
 154                         ),
 155                         LFNoise1.kr(0.157, 0.4, 0.5),
 156                         0.04),
 157                 LFNoise1.kr(0.2, 2000, 2400),
 158                 0.2);
 159         y = z * 0.6;
 160         z +  [
 161                           CombL.ar(y, 0.06, LFNoise1.kr(0.3.rand, 0.025, 0.035), 1)
 162                         + CombL.ar(y, 0.06, LFNoise1.kr(0.3.rand, 0.025, 0.035), 1)
 163                 ,
 164                           CombL.ar(y, 0.06, LFNoise1.kr(0.3.rand, 0.025, 0.035), 1)
 165                         + CombL.ar(y, 0.06, LFNoise1.kr(0.3.rand, 0.025, 0.035), 1)
 166                 ]
 167 }.play;
 168 )
 169
 170 //////////////////////////////////////////////////////////////////////////
 171
 172 (
 173 // police state
 174 var n;
 175 n = 4;  // number of sirens
 176 play({
 177         CombL.ar(
 178                 Mix.arFill(n, {
 179                         Pan2.ar(
 180                                 SinOsc.ar(
 181                                         SinOsc.kr(0.1.rand + 0.02, 2pi.rand, 600.rand, 1000 + 300.rand2),
 182                                         0,
 183                                         LFNoise2.ar(100 + 20.0.rand2, 0.1)
 184                                 ),
 185                                 1.0.rand2
 186                         )
 187                 })
 188                 + LFNoise2.ar(LFNoise2.kr([0.4,0.4], 90, 620), LFNoise2.kr([0.3,0.3], 0.15, 0.18)),
 189                 0.3, 0.3, 3)
 190 }))
 191
 192 //////////////////////////////////////////////////////////////////////////
 193
 194 (
 195 {
 196 // cymbalism
 197 var p;
 198                 var z, f1, f2;
 199 p = 15; // number of partials per channel per 'cymbal'.
 200                 f1 = 500 + 2000.0.rand;
 201                 f2 = 8000.0.rand;
 202                 z = Array.fill(2, {
 203                         `[      // sine oscil bank specification :
 204                                 y = Array.fill(p, { f1 + f2.rand} ), // frequencies
 205                                 nil,                                                    // amplitudes default to 1.0
 206                                 Array.fill(p, { 1.0 + 4.0.rand })       // ring times
 207                         ]
 208                 });
 209                 Klank.ar(z, Decay.ar(Impulse.ar(3.0.rand + 0.5), 0.004, WhiteNoise.ar(0.03)));
 210 }.play;
 211 )
 212
 213 //////////////////////////////////////////////////////////////////////////
 214
 215 (
 216 // synthetic piano
 217 var n;
 218 n = 6;  // number of keys playing
 219 play({
 220         Mix.ar(Array.fill(n, {  // mix an array of notes
 221                 var delayTime, pitch, detune, strike, hammerEnv, hammer;
 222
 223                 // calculate delay based on a random note
 224                 pitch = (36 + 54.rand);
 225                 strike = Impulse.ar(0.1+0.4.rand, 2pi.rand, 0.1); // random period for each key
 226                 hammerEnv = Decay2.ar(strike, 0.008, 0.04); // excitation envelope
 227                 Pan2.ar(
 228                         // array of 3 strings per note
 229                         Mix.ar(Array.fill(3, { arg i;
 230                                 // detune strings, calculate delay time :
 231                                 detune = #[-0.05, 0, 0.04].at(i);
 232                                 delayTime = 1 / (pitch + detune).midicps;
 233                                 // each string gets own exciter :
 234                                 hammer = LFNoise2.ar(3000, hammerEnv); // 3000 Hz was chosen by ear..
 235                                 CombL.ar(hammer,                // used as a string resonator
 236                                         delayTime,              // max delay time
 237                                         delayTime,                      // actual delay time
 238                                         6)                              // decay time of string
 239                         })),
 240                         (pitch - 36)/27 - 1 // pan position: lo notes left, hi notes right
 241                 )
 242         }))
 243 })
 244 )
 245
 246 //////////////////////////////////////////////////////////////////////////
 247
 248 (
 249 var a, c, d, s, z, y;
 250 // reverberated sine percussion
 251 d = 6; // number of percolators
 252 c = 5; // number of comb delays
 253 a = 4; // number of allpass delays
 254
 255 play({
 256                 // sine percolation sound :
 257         s = Mix.ar(Array.fill(d, { Resonz.ar(Dust.ar(2/d, 50), 200 + 3000.0.rand, 0.003)}) );
 258
 259                 // reverb predelay time :
 260         z = DelayN.ar(s, 0.048);
 261
 262                 // 7 length modulated comb delays in parallel :
 263         y = Mix.ar(CombL.ar(z, 0.1, LFNoise1.kr(Array.fill(c,{0.1.rand}), 0.04, 0.05), 15));
 264
 265                 // chain of 4 allpass delays on each of two channels (8 total) :
 266         a.do({ y = AllpassN.ar(y, 0.050, [0.050.rand,0.050.rand], 1) });
 267
 268                 // add original sound to reverb and play it :
 269         s+(0.2*y)
 270 }))
 271
 272 //////////////////////////////////////////////////////////////////////////
 273
 274 (
 275 // reverberated noise bursts
 276 var a, c, d, s, z, y;
 277 play({
 278                 // pink noise percussion sound :
 279         s = Decay.ar(Dust.ar(0.6, 0.2), 0.15, PinkNoise.ar);
 280
 281                 // reverb predelay time :
 282         z = DelayN.ar(s, 0.048);
 283
 284                 // 6 modulated comb delays in parallel :
 285         y = Mix.ar(CombL.ar(z, 0.1, LFNoise1.kr(Array.fill(6,{0.1.rand}), 0.04, 0.05), 15));
 286
 287                 // chain of 4 allpass delays on each of two channels (8 total) :
 288         4.do({ y = AllpassN.ar(y, 0.050, [0.050.rand,0.050.rand], 1) });
 289
 290                 // add original sound to reverb and play it :
 291         s+y
 292 }))
 293
 294 //////////////////////////////////////////////////////////////////////////
 295
 296 (
 297         // sample and hold liquidities
 298         // mouse x controls clock rate, mouse y controls center frequency
 299 {
 300         var clockRate, clockTime, clock, centerFreq, freq, panPos, patch;
 301
 302         clockRate = MouseX.kr(1, 200, 1);
 303         clockTime = clockRate.reciprocal;
 304         clock = Impulse.kr(clockRate, 0.4);
 305
 306         centerFreq = MouseY.kr(100, 8000, 1);
 307         freq = Latch.kr(WhiteNoise.kr(centerFreq * 0.5, centerFreq), clock);
 308         panPos = Latch.kr(WhiteNoise.kr, clock);
 309         patch = CombN.ar(
 310                         Pan2.ar(
 311                                 SinOsc.ar(
 312                                         freq,
 313                                         0,
 314                                         Decay2.kr(clock, 0.1 * clockTime, 0.9 * clockTime)
 315                                 ),
 316                                 panPos
 317                         ),
 318                         0.3, 0.3, 2
 319                 );
 320         patch
 321 }.play;
 322 )
 323
 324 //////////////////////////////////////////////////////////////////////////
 325
 326 (
 327 // sweepy noise - mouse controls LFO
 328 {
 329         var lfoDepth, lfoRate, freq, filtered;
 330         lfoDepth = MouseY.kr(200, 8000, 'exponential');
 331         lfoRate = MouseX.kr(4, 60, 'exponential');
 332         freq = LFSaw.kr(lfoRate, 0, lfoDepth, lfoDepth * 1.2);
 333         filtered = RLPF.ar(WhiteNoise.ar([0.03,0.03]), freq, 0.1);
 334         CombN.ar(filtered, 0.3, 0.3, 2, 1, filtered);
 335 }.play
 336 )
 337
 338 //////////////////////////////////////////////////////////////////////////
 339
 340 (
 341 {
 342                 var a, a0, a1, b, c, pan;
 343                 a0 = 200.0.rand + 40;
 344                 a1 = a0 + 1.0.rand2;
 345                 a = [a0, a1];
 346                 b = 2000.0.rand;
 347                 c = [a0 + 1.0.rand2, a1 + 1.0.rand2];
 348                 SinOsc.ar(SinOsc.ar(a, 0, 1.0.rand * b, b), 0, SinOsc.kr(c, 0, 0.05, 0.05))
 349 }.play;
 350 )
 351
 352 //////////////////////////////////////////////////////////////////////////
 353
 354 (
 355
 356 // aleatoric quartet
 357 // mouse x controls density
 358
 359 play({
 360         var amp, density, dmul, dadd, signal;
 361         amp = 0.07;
 362         density = MouseX.kr(0.01,1); // mouse determines density of excitation
 363
 364         // calculate multiply and add for excitation probability
 365         dmul = density.reciprocal * 0.5 * amp;
 366         dadd = dmul.neg + amp;
 367
 368         signal = Mix.ar(        // mix an array of 4 instruments
 369                 Array.fill(4, {
 370                         var excitation, freq;
 371
 372                         excitation = PinkNoise.ar(
 373                                 // if amplitude is below zero it is clipped
 374                                 // density determines the probability of being above zero
 375                                 max(0, LFNoise1.kr(8, dmul, dadd))
 376                         );
 377
 378                         freq = Lag.kr(                  // lag the pitch so it glissandos between pitches
 379                                 LFNoise0.kr(                            // use low freq step noise as a pitch control
 380                                         [1, 0.5, 0.25].choose,  // choose a frequency of pitch change
 381                                         7,                                      // +/- 7 semitones
 382                                         66 + 30.rand2                   // random center note
 383                                 ).round(1),             // round to nearest semitone
 384                                 0.2                             // gliss time
 385                         ).midicps;                      // convert to hertz
 386
 387                         Pan2.ar(        // pan each intrument
 388                                 CombL.ar(excitation, 0.02, freq.reciprocal, 3), // comb delay simulates string
 389                                 1.0.rand2               // random pan position
 390                         );
 391         }));
 392
 393         // add some reverb via allpass delays
 394         5.do({ signal = AllpassN.ar(signal, 0.05, [0.05.rand,0.05.rand], 1) });
 395         LeakDC.ar( signal, 0.995);              // delays build up a lot of DC, so leak it out here.
 396 })
 397 )
 398
 399 ////////////////////////////////////////////////////////////////////////////////////////////////
 400
 401 (
 402 {
 403                 var mix, out, n=8;
 404                 r = LFNoise0.kr(rrand(0.2,1.0), 1,1).squared * MouseX.kr;
 405                 mix = Klank.ar(
 406                         `[
 407                                 Array.fill(n, { exprand(1.0,20.0) }),
 408                                 nil,
 409                                 Array.fill(n, { 0.2.rand })
 410                         ],
 411                         Blip.ar(r, [rrand(2,5),rrand(2,5)], 0.1)
 412                 ).fold2(0.2).cubed * 12;
 413                 mix = Mix.arFill(3, { CombL.ar(mix, 0.1, 0.03.linrand, 4.0.linrand) });
 414                 out = mix.distort * 0.5;
 415                 6.do({ out = AllpassN.ar(out, 0.05, [0.05.rand, 0.05.rand], 3) });
 416                 out = LeakDC.ar(out);
 417 }.play
 418 )
 419
 420 ////////////////////////////////////////////////////////////////////////////////////////////////
 421
 422 (
 423 {
 424         var root, scale;
 425
 426         // struck string
 427         var trig, p, exc, x, freq, s;
 428         root = rrand(3,6);
 429         scale = #[0,2,4,5,7,9,11];
 430
 431         freq = (scale.choose + #[24,36,48,60,72,84].choose + root).midicps;
 432         exc = BrownNoise.ar(
 433                 Decay2.kr(
 434                         Impulse.kr(#[0.125,0.25,0.375,0.5,0.75,1,1.5,2,3,4].choose,0,[0.05,0.05]
 435                 ), 0.005, 0.05));
 436         s = (Klank.ar(`[
 437                         Array.series(16, freq, freq),
 438                         Array.geom(16,1,rrand(0.7,0.999)),
 439                         Array.fill(16, {rrand(0.1,2.5)})
 440                 ], exc) * 0.1).softclip;
 441 }.play
 442 )
 443
 444 ///////////////////////////////////////////////////////////////////////////////////////////////
 445
 446 (
 447 {
 448         var root, scale, s;
 449                         // wind chords
 450         var trig, p, n, exc, x, base, range;
 451                 //root = rrand(3,6);
 452                 root = 5;
 453                 scale = #[0,2,4,5,7,9,11];
 454                 n = 5;
 455                 exc = BrownNoise.ar([0.007,0.007]) * max(0, LFNoise1.kr(exprand(0.125,0.5), 1.25, -0.25));
 456                 s = (Klank.ar(`[Array.fill(n, {(scale.choose + #[36,48,60,72,84].choose + root).midicps}),nil,Array.fill(n, {rrand(0.1,2.0)})], exc) * 0.1).softclip;
 457 }.play;
 458 )
 459
 460 ///////////////////////////////////////////////////////////////////////////////////////////////
 461
 462 (
 463 {
 464
 465                         // wind metals
 466                         var trig, s, p, n, exc, x, base, range;
 467                         n = 6;
 468                         base = exprand(60,4000);
 469                         range = rrand(500.0,8000.0);
 470                         exc = BrownNoise.ar([0.007,0.007]) * max(0, LFNoise1.kr(exprand(0.125,0.5), 0.75, 0.25));
 471                         s = (Klank.ar(`[Array.fill(n, {linrand(range)+base}),nil,Array.fill(n, {rrand(0.1,2.0)})], exc) * 0.1).softclip;
 472 }.play;
 473 )
 474
 475 ///////////////////////////////////////////////////////////////////////////////////////////////
 476
 477 (
 478 {
 479 var root, scale;
 480                         // bowed string
 481                 var trig, p, s, exc, x, freq;
 482                 //root = rrand(3,6);
 483                 root = 5;
 484                 scale = #[0,2,4,5,7,9,11];
 485                         freq = (scale.choose + #[24,36,48,60,72,84].choose + root).midicps;
 486                         exc = BrownNoise.ar([0.007,0.007]) * max(0, LFNoise1.kr(exprand(0.125,0.5), 0.6, 0.4));
 487                         s = (Klank.ar(`[
 488                                         Array.series(12, freq, freq),
 489                                         Array.geom(12,1,rrand(0.7,0.9)),
 490                                         Array.fill(12, {rrand(1.0,3.0)})
 491                                 ], exc) * 0.1).softclip;
 492 }.play;
 493 )
 494
 495 ///////////////////////////////////////////////////////////////////////////////////////////////
 496
 497 (
 498 {
 499         var root, scale, s;
 500         // whistle
 501         var trig, p, exc, x, freq;
 502                 root = 5;
 503                 scale = #[0,2,4,5,7,9,11];
 504                         freq = (scale.choose + #[84,96].choose + root).midicps;
 505                         exc = BrownNoise.ar([0.05,0.05]) * max(0, SinOsc.kr(exprand(0.125,0.5), 2pi.rand));
 506                         s = (Klank.ar(`[
 507                                         Array[freq],
 508                                         nil,
 509                                         Array[0.3]
 510                                 ], exc) * 0.1).softclip;
 511 }.play
 512 )
 513
 514 ///////////////////////////////////////////////////////////////////////////////////////////////
 515
 516 (
 517 {
 518
 519         // metallic
 520         var trig, p, exc, x, s;
 521         exc = BrownNoise.ar(Decay2.kr(Impulse.kr(#[0.125,0.25,0.375,0.5,0.75,1,1.5,2].choose,0,[0.04,0.04]), 0.005, 0.05));
 522         s = (Klank.ar(`[Array.fill(16, {linrand(8000.0)+60}),nil,Array.fill(16, {rrand(0.1,2.0)})], exc) * 0.1).softclip;
 523 }.play
 524 )
 525
 526 ///////////////////////////////////////////////////////////////////////////////////////////////
 527
 528 (
 529 {
 530         var x, r, f;
 531         x = Mix.fill(4, {
 532                 LFSaw.ar((LFPulse.kr(0.06,0,0.5,2,34 + {0.1.rand2}.dup)).midicps, 0, 0.01)
 533         });
 534         r = MouseY.kr(0.1,0.7);
 535         f = LinExp.kr(SinOsc.kr(0.07),-1,1,300,5000);
 536         x = RLPF.ar(x, f, r).softclip;
 537         x = RLPF.ar(x, f, r).softclip;
 538 }.play;
 539 )
 540
 541 (
 542 {
 543 Pan2.ar(
 544         SinOsc.ar(rrand(24,108).midicps, 2pi.rand,
 545
 546                 Mix.ar(SinOsc.ar(exprand(0.3,8) * [rrand(0.7,1.3),1], [2pi.rand,2pi.rand], 0.1)).max(0)
 547                 * Mix.ar(SinOsc.ar(exprand(6,24) * [rrand(0.7,1.3),1], [2pi.rand,2pi.rand], 0.1)).abs
 548         ), 1.0.rand2);
 549
 550 }.play;
 551 )
 552
 553
 554 (
 555 {
 556                 Pan2.ar(
 557         HPZ1.ar(LFTri.ar(rrand(24,128).midicps, 2pi.rand,
 558
 559                 Mix.ar(SinOsc.ar(exprand(0.3,8) * [rrand(0.7,1.3),1], [2pi.rand,2pi.rand], 0.04)).max(0)
 560                 * Mix.ar(SinOsc.ar(exprand(6,24) * [rrand(0.7,1.3),1], [2pi.rand,2pi.rand])).abs
 561         )), 1.0.rand2);
 562 }.play;
 563 )
 564
 565 (
 566 {
 567
 568                 x = Pan2.ar(
 569                 LPZ2.ar(LFPulse.ar(80 * rrand(1,32), 2pi.rand, 0.1,
 570
 571                         Mix.ar(SinOsc.ar(exprand(0.3,8) * [rrand(0.7,1.3),1], [2pi.rand,2pi.rand], 0.04)).max(0)
 572                         * Mix.ar(SinOsc.ar(exprand(6,24) * [rrand(0.7,1.3),1], [2pi.rand,2pi.rand])).abs
 573
 574                 )), 1.0.rand2);
 575                 2.do({ x = AllpassN.ar(x, 0.05, [0.05.rand,0.05.rand], 3.0.rand, 2); });
 576                 x
 577
 578 }.play
 579 )
 580
 581
 582 (
 583 {
 584                 x = Pan2.ar(
 585                 LPZ2.ar(LFPulse.ar(80 * (1 + 32.linrand), 2pi.rand, 0.1,
 586
 587                         Mix.ar(SinOsc.ar(0.125 * [2**rrand(0,6),2**rrand(0,6)], [2pi.rand,2pi.rand], 0.04)).max(0)
 588                         * Mix.ar(SinOsc.ar(4 * [rrand(1,6),rrand(1,6)], [2pi.rand,2pi.rand])).abs
 589
 590                 )), 1.0.rand2);
 591                 2.do({ x = AllpassN.ar(x, 0.05, [0.05.rand,0.05.rand], 4.0.rand, 2); });
 592                 x
 593
 594         }.play;
 595 )
 596
 597 (
 598 {
 599
 600                 Pan2.ar(
 601         BPZ2.ar(LFPulse.ar(120 * 100.rand, 2pi.rand, 0.5,
 602
 603                 Mix.ar(SinOsc.ar(exprand(0.3,8) * [rrand(0.7,1.3),1], [2pi.rand,2pi.rand], 0.04)).max(0)
 604                 * Mix.ar(SinOsc.ar(exprand(6,24) * [rrand(0.7,1.3),1], [2pi.rand,2pi.rand])).abs
 605         )), 1.0.rand2);
 606 }.play
 607 )
 608
 609 (
 610 {
 611
 612                 Pan2.ar(
 613         Resonz.ar(LFPulse.ar(exprand(50,600), 2pi.rand, 0.5,
 614
 615                 Mix.ar(SinOsc.ar(exprand(0.3,8) * [rrand(0.7,1.3),1], [2pi.rand,2pi.rand], 0.1)).max(0)
 616                 * Mix.ar(SinOsc.ar(exprand(6,24) * [rrand(0.7,1.3),1], [2pi.rand,2pi.rand])).abs
 617         ), exprand(100,2000), 0.2), 1.0.rand2);
 618 }.play
 619 )
 620
 621 (
 622 {
 623
 624                 Pan2.ar(
 625         RLPF.ar(LFPulse.ar(exprand(50,600), 2pi.rand, 0.5,
 626
 627                 Mix.ar(SinOsc.ar(exprand(0.3,8) * [rrand(0.7,1.3),1], [2pi.rand,2pi.rand], 0.1)).max(0)
 628                 * Mix.ar(SinOsc.ar(exprand(6,24) * [rrand(0.7,1.3),1], [2pi.rand,2pi.rand])).abs
 629         ), exprand(100,2000), 0.2), 1.0.rand2);
 630 }.play
 631 )
 632
 633 {  SinOsc.ar(exprand(100,6000), 0, LFNoise2.ar(exprand(4,24),[0.07,0.07])) }.play;
 634
 635 (
 636 {
 637
 638                 Pan2.ar(
 639                 RLPF.ar(LFPulse.ar(exprand(50,600), 2pi.rand, 0.5,
 640
 641                         Mix.ar(SinOsc.ar(exprand(0.3,8) * [rrand(0.7,1.3),1], [2pi.rand,2pi.rand], 0.1)).max(0)
 642                         * Mix.ar(SinOsc.ar(exprand(6,24) * [rrand(0.7,1.3),1], [2pi.rand,2pi.rand])).abs
 643                 ), exprand(100,2000), 0.2), 1.0.rand2);
 644 }.play;
 645 )
 646
 647 /////////////////////////////////////////////////////////////////////////////////
 648
 649
 650 (
 651 {
 652                 var freq, x;
 653                 freq = LFPulse.kr(20.0.rand, 0, 1.0.rand,
 654                         LFPulse.kr(4.0.rand, 0, 1.0.rand, 8000.rand, 2000.rand));
 655                 freq = freq + LFPulse.kr(20.0.rand, 0, 1.0.rand,
 656                         LFPulse.kr(4.0.rand, 0, 1.0.rand, 8000.rand, 2000.rand));
 657                 x = LFPulse.ar(freq+[0.5,0.5].rand2, 0, 0.5, 0.15, -0.05);
 658                 AllpassN.ar(x, 0.05, [0.05,0.05].rand, 0.3);
 659 }.play
 660 )
 661
 662 (
 663 {
 664         var out, lfoDepth, lfoRate, freq, filtered;
 665         lfoDepth = MouseY.kr(200, 8000, 1);
 666         lfoRate = MouseX.kr(4, 60, 1);
 667         freq = LFSaw.kr(lfoRate, 0, lfoDepth, lfoDepth * 1.2);
 668         filtered = RLPF.ar({WhiteNoise.ar(0.03)}.dup, freq, 0.1);
 669         out = CombN.ar(filtered, 0.3, 0.3, 2, 1, filtered);
 670         out
 671 }.play;
 672 )
 673
 674 /////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 675
 676
 677 // adding many things to the top level spawn.
 678 (
 679 {
 680         var exc, amp;
 681         amp = LFPulse.kr(4,0,0.1,0.002);
 682         exc = LPZ1.ar(GrayNoise.ar([amp,amp]));
 683         Klank.ar(`[FloatArray.fill(4, { rrand(80.0,400.0) }),
 684                         nil,
 685                         FloatArray[1, 1, 1, 1]], exc);
 686 }.play;
 687 )
 688
 689 (
 690 {
 691         var exc, amp;
 692         amp = LFPulse.kr(8,0,0.1,0.002);
 693         exc = LPZ1.ar(GrayNoise.ar([amp,amp]));
 694         Klank.ar(`[FloatArray.fill(4, { rrand(80.0,400.0) }),
 695                         nil,
 696                         FloatArray[1, 1, 1, 1]], exc).abs;
 697 }.play;
 698 )
 699
 700 (
 701 {
 702         CombN.ar(LPF.ar(LFNoise0.ar(MouseX.kr([300,2200])*[1,1.1],LFPulse.kr(1,0,0.3,0.1)), 800).abs, 0.2, [0.2,0.17], 5);
 703 }.play;
 704 )
 705
 706 (
 707 {
 708         var amp, my;
 709         amp = LFPulse.kr(0.5,0,0.5);
 710         my = MouseY.kr(400,3200);
 711         Mix.arFill(8, {
 712                 var x;
 713                 x = Formlet.ar(Dust.ar(12,[0.05,0.05]) * amp, my * exprand(0.5,2.0), 0.005, 0.1);
 714                 AllpassN.ar(x, 0.05,0.05.rand, 8);
 715         });
 716 }.play;
 717 )