«Cinematic Polyrhythmic Bass Evolution» by po

on 19 Sep'25 06:21 in

autechre-inspired polyrhythmic composition with irregular patterns, granular synthesis, and algo-sequences evolving over 60s

log fork json 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
SynthDef("task_efc57239-5d3d-49fe-9b37-9bf8301cad55", {
      arg out=0, gate=1, freq=220, amp=0.25, tempo=1.0;
      var env, timer, gran, perc1, perc2, seq1, seq2, chaos, filt1, filt2, pan, sig;
      var bassEnv, bass1, bass2, bassFilter, bassLFO, subBass, bassMix, bassChorus;
      
      env = EnvGen.kr(Env([0, 0.3, 1, 0.7, 0], [5, 20, 25, 10], \sin), gate, timeScale: tempo.reciprocal, doneAction: 2);
      timer = LFSaw.kr(tempo * 0.02);
      
      // Deep cinematic bass foundation - Zimmer style
      bassEnv = EnvGen.kr(Env([0, 0.1, 0.8, 1, 0.9, 0], [8, 15, 20, 15, 7], [\sin, \sin, \lin, \sin, \sin]), timeScale: tempo.reciprocal);
      bassLFO = LFNoise1.kr([0.08, 0.12]).range(0.85, 1.15);
      
      // Massive low-end with evolving harmonics
      bass1 = SinOsc.ar(freq * [0.25, 0.251] * bassLFO, 0, 0.6);
      bass2 = Saw.ar(freq * 0.5 * LFNoise2.kr(0.05).range(0.95, 1.05), 0.4);
      subBass = SinOsc.ar(freq * 0.125 * LFNoise1.kr(0.03).range(0.98, 1.02), 0, 0.8);
      
      // Bass filtering with movement
      bassFilter = RLPF.ar(
          bass1 + LPF.ar(bass2, 300) + subBass,
          LFNoise1.kr(0.04).range(40, 180) + (timer.range(0, 60)),
          LFNoise2.kr(0.06).range(0.6, 0.95)
      );
      
      // Subtle chorus/phasing for width
      bassChorus = bassFilter + DelayL.ar(bassFilter, 0.02, LFNoise2.kr([0.3, 0.35]).range(0.005, 0.015)) * 0.3;
      bassMix = bassChorus * bassEnv * 0.35;
      
      // Original granular texture (reduced slightly to make room for bass)
      gran = SinOsc.ar(
          freq * [1, 1.618] * LFNoise1.kr([0.1, 0.13]).range(0.5, 2),
          0,
          Decay.ar(Dust.ar([3, 5, 7] * tempo), 0.05)
      ).sum * 0.15;
      
      // Polyrhythmic percussion layers
      perc1 = Ringz.ar(
          Decay.ar(Impulse.ar([4, 7] * tempo * LFNoise0.kr(0.05).range(0.7, 1.2)), 0.01) * PinkNoise.ar(0.3),
          [400, 800] + LFNoise2.kr(0.3).range(-100, 200),
          0.1
      ).sum * 0.35;
      
      perc2 = HPF.ar(
          Decay.ar(Impulse.ar([11, 13] * tempo * 0.3), 0.08) * Crackle.ar(1.9, 0.2),
          300 + LFNoise1.kr(0.2).range(0, 300)
      ) * 0.25;
      
      // Algorithmic sequences
      chaos = LFNoise0.kr(0.08 * tempo).range(0.5, 1.5);
      
      seq1 = SinOsc.ar(freq * [0.5, 0.75] * chaos, 0,
          LFPulse.ar([3, 5] * tempo, 0, 0.3)
      ) * 0.12;
      
      seq2 = Saw.ar(freq * 2 * LFNoise1.kr(0.1).range(0.8, 1.3), 
          LFPulse.ar([8, 12] * tempo * chaos, 0, 0.2)
      ) * 0.08;
      
      // Complex filtering with movement
      filt1 = RLPF.ar(
          gran + perc1 + seq1.sum,
          LFNoise1.kr(0.15).range(200, 2000) + (timer.range(0, 800)),
          LFNoise2.kr(0.1).range(0.2, 0.8)
      );
      
      filt2 = BPF.ar(
          perc2 + seq2 + (gran * 0.5),
          LFNoise0.kr(0.12).range(400, 1800) + (chaos.range(0, 400)),
          0.4
      );
      
      // Spatial movement
      pan = SinOsc.kr([0.03, 0.05] * tempo, [0, 1.57]) * 0.7;
      
      // Mix bass with existing elements
      sig = [filt1 * pan[0] + filt2 + bassMix.sum, filt1 * pan[1] + filt2 + bassMix.sum];
      sig = sig * amp * env;
      sig = LeakDC.ar(sig).clip(-0.9, 0.9);
      
      Out.ar(out, sig);
  });
raw 3327 chars (focus & ctrl+a+c to copy)
reception
comments