I drew inspiration from Hans Zimmer’s work in Dune, with the industrial but desert sounds and the deep base. The sounds for the evil side of the track were also insipred by the Sardukar chant from the epilogue of each of the movies. The aesthetics of the hero soundtracks in games I played growing up.

The story being told is of a battle between evil and good a where good win after the beat drops (hopefully on time..). I have attached a video to the composition.

Looking at the video one more time, I realise that you can see the cursor bing visible in the middle of the screen. This is evidence of the p5js visualization shown as a video and there not being a p5 instance created during the performance.

The background visual is made with p5.js by taking muse mind monitors eeg readings of me playing chess and taking time-series data for each type of brain wave (alpha, delta, thetha) which are correlated to different types of emotions. The wave values, while in .csv had lost a lot of information and context where the color pf the particles is the aggregation of the wavetypes and the size is dictated by purely delta waves associated with high stress. The ring in the middle pulses on the heart-rate data from the headband.

The code code was used to generate the p5js video:

let brainData = [];
let headers = [];
let particles = [];
let currentIndex = 0;
let validData = [];
let heartBeatTimer = 0;
let lastHeartRate = 70; //default heart rate

class Particle {
  constructor(x, y, delta, theta, alpha) {
    this.pos = createVector(x, y);
    this.vel = p5.Vector.random2D().mult(map(delta, -2, 2, 0.5, 3));
    this.acc = createVector(0, 0);

    this.r = map(delta, -2, 2, 50, 255);
    this.g = map(theta, -2, 2, 50, 255);
    this.b = map(alpha, -2, 2, 50, 255);

    this.size = map(abs(delta), 0, 2, 2, 10);
    this.lifespan = 255;
  }

  update() {
    this.vel.add(this.acc);
    this.pos.add(this.vel);
    this.acc.mult(0);
    this.vel.add(p5.Vector.random2D().mult(0.1));
    this.lifespan -= 2;
  }

  applyForce(force) {
    this.acc.add(force);
  }

  display() {
    noStroke();
    fill(this.r, this.g, this.b, this.lifespan);
    ellipse(this.pos.x, this.pos.y, this.size, this.size);
  }

  isDead() {
    return this.lifespan < 0;
  }
}

function preload() {
  brainData = loadStrings("mindMonitor_2025-02-26--20-59-08.csv");
}

function setup() {
  createCanvas(windowWidth, windowHeight);
  colorMode(RGB, 255, 255, 255, 255);

  headers = brainData[0].split(",");
//filterinf dataset for valid rows
  validData = brainData.slice(1).filter((row) => {
    let cells = row.split(",");
    return cells.some((cell) => !isNaN(parseFloat(cell)));
  });

  console.log("Total valid data rows:", validData.length);
}

function draw() {
  //trailing effect for particles
  background(0, 20);

  if (validData.length === 0) {
    console.error("No valid data found!");
    noLoop();
    return;
  }

  let currentLine = validData[currentIndex].split(",");

  let hrIndex = headers.indexOf("Heart_Rate");
  let heartRate = parseFloat(currentLine[hrIndex]);

  if (!isNaN(heartRate) && heartRate > 0) {
    lastHeartRate = heartRate;
  }

  let beatInterval = 60000 / lastHeartRate;

  heartBeatTimer += deltaTime;

  if (heartBeatTimer >= beatInterval) {
    heartBeatTimer = 0;

    let deltaIndex = headers.indexOf("Delta");
    let thetaIndex = headers.indexOf("Theta");
    let alphaIndex = headers.indexOf("Alpha");

    let delta = parseFloat(currentLine[deltaIndex]) || 0;
    let theta = parseFloat(currentLine[thetaIndex]) || 0;
    let alpha = parseFloat(currentLine[alphaIndex]) || 0;

    let particleCount = map(abs(delta), 0, 2, 5, 30);
    for (let i = 0; i < particleCount; i++) {
      let p = new Particle(
        width / 2 + random(-100, 100),
        height / 2 + random(-100, 100),
        delta,
        theta,
        alpha
      );
      particles.push(p);
    }

    currentIndex = (currentIndex + 1) % validData.length;
  }

  push();
  noFill();
  stroke(255, 0, 0, 150);
  strokeWeight(3);
  let pulseSize = map(heartBeatTimer, 0, beatInterval, 100, 50);
  ellipse(width / 2, height / 2, pulseSize, pulseSize);
  pop();

  for (let i = particles.length - 1; i >= 0; i--) {
    particles[i].update();
    particles[i].display();

    if (particles[i].isDead()) {
      particles.splice(i, 1);
    }
  }
}

function windowResized() {
  resizeCanvas(windowWidth, windowHeight);
}

I encapsulated the tidal code so that i would only have to excute few lines during the performance which didn’t go the way I wanted:( , so in a way i feel like when it comes to live coding performance, having a few refactored functions work while working with code blocks lives gives a better setup for performing and debuggin on the fly.

Below is the tidal code:


-----------------hehe----

setcps (135/60/4)

-- harkonnen type beat
evilPad = slow 8
$ n (cat [
"0 3 7 10",
"3 6 10 13",
"5 8 12 15",
"7 14 17 21"
])
# s "sax"
# room 0.8
# size 0.9
# gain (range 0.7 0.9 $ slow 4 $ sine)

--shardukar type beat
evilBass = slow 8
$ sometimesBy 0.4 (rev)
$ n "0 5 2 7"
# s "sax:2"
# orbit 1
# room 0.7
# gain 0.75
# lpf 800
# shape 0.3

--geidi prime type beat
evilAtmosphere = slow 16
$ sometimes (|+ n 12)
$ n "14 ~ 19 ~"
# s "sax"
# gain 0.8
# room 0.9
# size 0.95
# orbit 2

--shardukar chant type pattern chpped
evilPercussion = slow 4
$ striate "<8 4>"
$ n (segment 16 $ range 6 8 $ slow 8 $ perlin)
# s "speechless"
# legato 2
# gain 1.2
# krush 4

--shardukar chant type pattern 2 chopped
evilVoice = slow 4
$ density "<1 1 2 4>/8"
$ striate "<2 4 8 16>/4"
$ n (segment 32 $ range 0 6 $ slow 8 $ sine)
# s "speech"
# legato (segment 8 $ range 2 3 $ slow 16 $ sine)
# gain (segment 32 $ range 0.8 1.2 $ slow 4 $ sine)
# pan (range 0.3 0.7 $ rand)
# crush 8

hush

evilRhythm = stack [
s "~ arp ~ ~" # room 0.5 # krush 9 # gain 1.2,
fast 2 $ s "moog2 moog2 moog2 moog3 moog:1 moog2" # room 0.7 # krush 5, fast 4 $ s "wobble8" # gain 0.8 # lpf 1200
]

d1 $ evilRhythm
hush

-- Build-up to drop
evilBuildUp = do {
d1 $ qtrigger $ filterWhen (>=0) $ seqP [
(0, 1, s "moog:14"), (1, 2, s "moog:18"),
(2, 3, s "moog:116"), (3, 4, s "moog:132")
] # room 0.3 # krush 9 # lpf (slow 4 (3000saw + 200)); d2 $ qtrigger $ filterWhen (>=0) $ seqP [ (0, 1, s "bass1:74"),
(1, 2, s "bass1:88"), (2, 3, s "bass1:916"),
(3, 4, s "bass1:932") ] # room 0.3 # lpf (slow 4 (1000saw + 100)) # speed (slow 4 (range 1 4 saw)) # gain 1.3;
d3 $ qtrigger $ filterWhen (>=0) $ seqP [
(0, 4, evilVoice # gain (slow 4 (range 0.8 1.5 saw)))
];
d4 $ qtrigger $ filterWhen (>=0) $ seqP [
(3, 4, s "crash:2*16" # gain (slow 1 (range 0.7 1.3 saw)) # room 0.9)
]
}

d1 $ silence
d2 $ silence
d3 silence
d4 silence

theDrop = do {
d1 silence;
d2 silence;
d3 silence;
d4 silence
}

heroBassDrum = s "[808bd:3(3,8), 808bd:4(5,16)]" # gain 1.3 # room 0.4 # shape 0.4 #krush 9

heroSnare = s "~ sd:2 ~ sd:2" # room 0.6 # gain 1.1 # squiz 0.8 #krush 6

heroHiHats = fast 2 $ s "hh*4" # gain (range 0.8 1.0 $ rand) # pan (range 0.2 0.8 $ slow 3 $ sine) #krush 5

heroTom = s "~ ~ ~ [~ lt:1 lt:2 lt:3*2]" # gain 1.0 # room 0.5 # speed 0.9 #krush 9

heroCymbal = s "[~ ~ ~ crash:4]" # gain 0.95 # room 0.7 # size 0.8

heroicFill = s "[feel:14, [~ ~ ~ feel:64], [~ ~ ~ ~ crash]]"
# gain 1.2
# room 0.7
# speed (range 1.5 0.9 $ saw)
# crush 8

dramaticEntrance = do {
d1 $ s "808bd:3 ~ ~ ~ ~ ~ ~ ~" # gain 1.4 # room 0.9 # size 0.9;
d2 $ s "~ ~ ~ crash:4" # gain 1.3 # room 0.9;
d3 silence;
d4 silence
}

heroPattern = do {
d1 $ stack [
heroBassDrum,
heroSnare,
heroHiHats
];
d2 $ stack [
heroTom,
heroCymbal
] # shape 0.3;
d3 $ s "sine:3" >| note (scale "mixolydian" ("0,4,7") + "c4")
# gain 0.65 # room 0.7;
d4 silence
}

heroExpanded = do {
d1 $ stack [
heroBassDrum # gain 1.4,
heroSnare # gain 1.2,
heroHiHats # gain 1.1
];
d2 $ stack [
heroTom,
heroCymbal # gain 1.1
] # shape 0.3;
d3 $ s "sine:3" >| note (scale "mixolydian" ("0,4,7") + "")
# gain 0.75 # room 0.7 # lpf 3000;
d4 $ s "[~ ~ ~ [feel:6 feel:7]]" # gain 0.9 # room 0.6
}

heroEpic = do {
d1 $ stack [
s "[808bd:3(3,8), 808bd:4(5,16)]" # gain 1.4 # room 0.4,
s "~ sd:2 ~ [sd:2 sd:4]" # room 0.6 # gain 1.2,
fast 2 $ s "hh4" # gain (range 0.9 1.1 $ rand) ]; d2 $ stack [ s "~ ~ mt:1 [~ lt:1 lt:2 lt:32]" # gain 1.1 # room 0.5,
s "[~ ~ ~ crash:4]" # gain 1.0 # room 0.7
] # shape 0.4;
d3 $ s "sine:3" >| note (scale "mixolydian" ("0,4,7,9") + "")
# gain 0.8 # room 0.8 # lpf 4000;
d4 $ s "feel:6(3,8)" # gain 0.9 # room 0.6 # speed 1.2
}

evilIntro = do {
d1 $ evilPad;
d2 silence;
d3 silence;
d4 silence
}

evilBuilds = do {
d1 $ evilPad;
d2 $ evilBass;
d3 $ evilAtmosphere;
d4 silence
}

evilIntensifies = do {
d1 $ evilPad;
d2 $ evilBass;
d3 $ evilAtmosphere;
d4 $ evilPercussion
}

d9 $ ccv "0 40 60 120" # ccn "0" # s "midi"

evilFullPower = do {
d1 $ evilPad # gain 0.6;
d3 $ evilVoice;
d4 $ evilPercussion # gain 1.3
}

--for evil full power
d6 $ s "~ arp ~ ~" # room 0.5 # krush 9 # gain 1.2
d7 $ fast 2 $ s "moog2 moog2 moog2 moog3 moog:1 moog2" # room 0.7 # krush 5 d8 $ fast 4 $ s "wobble8" # gain 0.8 # lpf 1200

evilIntro
evilBuilds
evilIntensifies
evilFullPower

evilBuildUp
theDrop

dramaticEntrance
heroPattern
heroExpanded
heroEpic

hush

Below is the hydra code:

s0.initVideo("/Users/janindu/Documents/liveCoding/p5_demo/p5_js_eegViz.mp4")

src(s0)
  .blend(o1, () => cc[1])
  .out()

  src(o0)
    .blend(src(o0).diff(s0).scale(.99),1.1)
    .modulatePixelate(noise(2,0.8).pixelate(160,160),1024)
    .out(o1)



  src(o0)
    .blend(
      src(o0)
        .diff(s0)
        .scale(() => 0.99 + 0.1 * Math.sin(time * 0.1))
        .rotate(() => cc[1] * 0.1),
      () => 1.1 + cc[1] * 0.5
    )
    .modulatePixelate(
      noise(() => 2 + cc[1] * 3, () => 0.01 + cc[1] * 0.05)
        .pixelate(() => 16 - cc[1] * 8, () => 16 - cc[1] * 8),
      () => 1024 * (1 - cc[1] * 0.5)
    )
    .modulate(
      o0,
      () => cc[1] * 0.3
    )
    .kaleid(() => Math.floor(cc[1] * 4) + 1)
    .colorama(() => cc[1] * 0.1)
    .out(o1)


//---
    hush()

Im really happ something came out of the eeg pipieline but I honestly feel that that that time culd have been better spent relying on noise to generate visuals.

But nevertheless, I’m happy I could (pun intended..) leave my heart and soul on the screen.

Also this is how it looks like. from p5js:

Following the words of the famed producer Kanye West, I wanted to incorporate a lot of the human voice into my project. My overall theme was a transition from happy, serene sounds with the backdrop of the phrase “I love live coding” spelled out, into a transition with a countdown and then a descent into madness with the phrase “pain” spelled out in repeat and it ends with the word “help” spelled out rather lifelessly. 

The visuals then had to match this sequence, where I wanted the initial scenery to be colorful with pretty shapes. For the transition, I wanted the shapes to get a bit more distorted, and for the number of shapes to match the countdown so you can both see and hear the countdown for the beat drop. Right after, comes a brief moment of serenity before a descent into chaos, untilizing a lot of dark libraries as a backdrop to the prominent “pain” repeated throughout. 

Making this project was a lot of fun and I am excited to see everyone’s project.

Tidalcycles:


setcps (135/60/4)  -- 1. Set global tempo


happyComplex = do {
  hush;
  d1 $ slow 4 $ s "alphabet" <| n "~ ~ 8 ~ ~ 11 14 21 4 ~ ~ 11 8 21 4 ~~ 2 14 3  8 13 6 ~ ~"
       # speed "1.2"
       # gain (range 1.5 1 (slow 64 sine))   -- starts loud then fades over time
       # room "0.1"
       # pan (slow 8 "0 1");
  d2 $ stack [
         fast 2 $ s "arpy" >| note (arp "updown" (scale "major" ("[0,2,4,6]" + "c5")))
              # gain (range 1.2 0.8 (slow 64 sine)),
         s "arpy" >| note (scale "major" ("[<-7 -5 -3 -1>,0,2](3,8)" + "c5"))
              # gain (range 1.2 0.8 (slow 64 sine))
       ];
  -- Light percussion: gentle claps and hi-hats.
  d3 $ stack [ s "~ cp" # room 0.5,
              fast 2 $ s "hh*2 hh*2 hh*2 <hh*6 [hh*2]!3>"
                   # gain (range 1 0.5 (slow 64 sine))
                   # room 0.7
            ];
  -- Ambient textures: acoustic drum loop and soft piano.
  d4 $ loopAt 8 $ chop 100  $ s "bev:1"  # room 0.8 # legato 12; -- # gain (range 1 0.3 (slow 64 sine));
  d5 $ slow 8 $ s "superpiano" <| n "c d f g a c6 d6 f6"
       # gain (range 1 0.3 (slow 64 sine))
};



happyComplex

d8 $ ccv (segment 128 (range 127 0 saw)) # ccn "0" # s "midi" -- 5.
d9 $ ccv (segment 128 (range 127 0 saw)) # ccn "1" # s "midi" -- 6.

d1 $ qtrigger $ slow 2 $ s "numbers" # n "<3 2 1>" # gain 1.5
--ctrl 4
d1 silence 

d10 $ ccv "0 127 0 127" # ccn "2" # s "midi" -- 8.
d11 $ ccv "<127 0 127 0>" # ccn "0" # s "midi" -- 8.

scaryComplex2

d1 $ slow 2 $ s "alphabet" <| n "~ 15 0 8 13 ~"
     # speed "0.6"
     # legato 2
     # gain (range 1.3 2 (slow 64 saw))
     # room "0.1"
     # pan (slow 8 "0 1")

 d1 $ s "alphabet" <| n "7 4 11 15" --19
   # gain 1.5  -- 21, 23, 25 change to 1, 0.5 0


hush
-- transitionComplex = do {
--   -- # hush;
--   d5 silence;
--   d1 $ qtrigger $ seqP [
--       (0.01, 1.01, s "numbers" <| n "3" # gain 1.5),
--       (1,    2,    s "off"),
--       (2,    3,    s "off"),
--       (3,    4,    s "numbers" <| n "2" # gain 1.5),
--       (4,    5,    s "off"),
--       (5,    6,    s "off"),
--       (6,    7,    s "numbers" <| n "1" # gain 1.5),
--       (7,    8,    s "off"),
--       (8,    9,    s "off")
--     ];
--   d2 $ fast 2 $ s "hh" <| n (run 6)
--        # gain 0.8
--        # speed (slow 4 (range 1 2 saw));
--   d3 $ loopAt 16 $ s "sheffield" # gain (range 0.2 0.4 (slow 32 sine)) # room 0.9;
--   xfadeIn 4 2 silence
-- };


hush

scaryComplex2 = do {
  clutch 2 $ s "ades3" <| n (run 7) # gain (range 1.2 0.8 (slow 64 sine)) # room 0.2;
  clutch 3 $ loopAt 1 $ s "dist:1" # gain 1.0;
  clutch 4 $ slow 8 $ s "bass1" <| n (run 30)
       # gain (range 1.0 0.7 (slow 64 sine))
       # up "-2" # room 0.3;
  clutch 5 $ stack [
         fast 2 $ s "arpy" >| note (arp "updown" (scale "minor" ("[0,2,3,5]" + "c4")))
              # gain 0.8,
         s "arpy" >| note (scale "minor" ("[0,1,3,5]" + "c4"))
              # gain 0.8
       ] # room 0.5;
  clutch 6 $ slow 4 $ s "industrial" <| n (run 32) # gain 1.0 # hpf 800
};







d1 $ s "alphabet" <| n "7 4 11 15" --19
  # gain 1.5  -- 21, 23, 25 change to 1, 0.5 0



hush --27

Hydra:

//S1

gradient(0.1)
  .colorama(0.1 + cc[0] * 0.7)         
  .mult(
    voronoi(5, 0.2 + cc[1] * 0.5, 0.7)
  )
  .modulateRotate(osc(10, 0.05, Math.PI / 2), cc[0])
  .modulate(noise(()=>(cc[0]+cc[1])*3,.1))
  //7. change to 3 -> 30 -> 300 -> 3000 
  .out(o0); // 4.

//S2
  osc(20, 0.1, 0)
    .modulate(noise(3, 0.1))
    .add(
      osc(10, 0.1, Math.PI / 2)
        .modulateRotate(noise(2, 0.05), 0.05)
    )
    .colorama(0.1 + cc[0] * 0.1).colorama(0.1).colorama(0.1).colorama(0.1).colorama(0.1)          // Subtle hue shift modulated by CC0
    .mult(
      shape(4, 0.2 + cc[2]*0.03)
        .repeat(3,3)
        //.repeat(2,2) // 11.
        //.repeat(1,1) // 12.
        //.repeat(3000,3000) // 13.
    )
    .modulate(noise(()=>(cc[0]+cc[1]) * 3, 0.1)) // 14. change to 3
    .out(o0); //10. play with the 3


  osc(200, 0.01, 4)
    .rotate(2 + cc[2]*20)
    .layer(
      osc(30, 0, 1)
        .luma(0.1, 0.1)
        .color(0, 0, 0, 1)
    )
    .layer(
      osc(300, 0.8, 1)
        .luma(0.1, 0.01)
    )
    .modulate(noise(() => (cc[2] + cc[2]) * 20, 0.5)) // 0 1
    .colorama(0.05 + cc[2] * 0.05).colorama(0.1).colorama(0.1).colorama(0.1)          // Modulated hue via CC2
    .mult(
      voronoi(5, 3, 0.7) //17. change to 30, 300
    )
    .out(o0); //16
    

shape(2, 0.01).thresh().out() //22
hush() //26


Link to video.

I started this project with one goal in mind: incorporating one of my favorite memes—the “Is that hyperpigmentation?” meme that’s been going viral recently. I didn’t have a specific or fixed vision from the start; instead, I approached it by experimenting over and over again until I found something that felt right.

One thing I really love is experimental music production. Lately, I’ve been listening to a lot of NewJeans and NMIXX, and I wanted to try a “switch-up” style beat—where the entire vibe of the music shifts suddenly while still transitioning smoothly between phases. I’ve composed music like this before, but never through coding.

For this project, I imported the “Is that hyperpigmentation?” and “It is fantastic” lines from the original meme as samples. Initially, I wasn’t planning on incorporating a beat drop, but after last week’s class, I was inspired to experiment with the beat drop example we studied. I wouldn’t necessarily call what I created a traditional beat drop—it’s more of a buildup leading to an underwhelming yet oddly satisfying drop (at least in my opinion). I do think I could have executed the buildup better, as I struggled to align the audio with my initial vision despite multiple attempts. However, I really like how the buildup transitions into the final section.

For the visuals, I wanted them to match the vibe of the music while also conveying emotion. The piece starts with a simple line that moves to the beat, set against a dark background to complement the bass-heavy intro. During this section, I subtly tease the “Is that hyperpigmentation?” and “It is fantastic” samples—just enough to keep the audience intrigued and a little confused. As the composition progresses, I introduce hi-hats, a Casio sample, and glitch effects layered with drums. When the Casio sample speeds up, I color in the lines and shift them to light blue, reinforcing the energy shift.

Next comes the buildup, featuring the phrase “It is fantastic” repeating and intensifying, ultimately cutting out to silence just before the full sample plays. At this point, the sound transitions into an ethereal yet mysterious atmosphere, and the visuals suddenly become vibrant and overwhelming—which I love. I also introduce a simple, looping “It is fantastic,” which enhances the vibe. This is followed by a complex beat sequence before the piece gradually winds down, ending with the full sample playing in silence alongside the “hyperpigmentation” drawing from the original meme.

Tidal Code:


-- Part 1
sTart = do 
  d16 $ s "~ ~ ~ bass1" # room 5 # legato 1 # gain 1
  d2 $ ccv "127 ~ ~ 0 " # ccn "0" # s "midi"

sTart 

once $ s "tastic" # gain 0.5

d15 $ s "bleep" # room 0.6 # gain 1

once $ "pigment" # gain 0.5

d9 $ s "~cp" # gain 1.2 # room 0.3

boop_boop = do
  d1 $ qtrigger $ filterWhen (>= 0) $ fast 4 $ s "casio" <| n (run 2) # room 0.8
  d2 $ ccv "0 70 90 127" # ccn "0" # s "midi"

boop_boop

-- Part 2
d3 $ degradeBy 0.01 $ sound "hh*8" + "hh!"# gain "1.5 0.75 0.75 1.5 0.6 0.9 0.9" # speed 2 #gain 1.5

glitchity_boop = do
  d8 $ qtrigger $ filterWhen (>= 0) $ sound "<glitch:5 glitch:3> bd bd [~ bd]" # gain 2  # room 0.01
  d4 $ ccv "<2 127> 30 40 [~ 10]" # ccn "0" # s "midi"

glitchity_boop


-- part 3
tASTIC = do
  d3 $ qtrigger $ filterWhen (>=0) $ seqP
    [ (0, 1, s "tastic:2*4")
    , (1, 2, s "tastic:2*8")
    , (2, 3, s "tastic:2*16")
    , (3, 4, s "tastic:2*32")
    ]
    # room 0.3
    # hpf (slow 4 (1000 * saw + 100))
    # speed (slow 4 (range 1 4 saw))
    # gain 2
    # legato 0.5

  d4 $ qtrigger $ filterWhen (>=0) $ seqP
    [ (4, 5, s "tastic") ]
    # gain 2
    # room 0.3

  d8 $ silence  


tASTIC

hush



-- part 4
d1va_Bo0ts = do
  d10 $ qtrigger $ filterWhen (>= 0) $ slow 2 $ s "superzow"  >| note (scale "<minor hexSus major>" ("[<-5 -3 -1 1> 0,2,4,8] * <1 8 16 32>") + "[f5,f6,f7]")  # legato 1   # lpfbus 1 (segment 1000 (slow 4 (range 100 3000 saw)))

  d5 $ struct "[t(1,2) t(2,4) t(4,10) t(10,16)]" $ ccv (segment 16 (slow 1 (range 120 0 saw))) # ccn "1" # s "midi"

d1va_Bo0ts

once $ s "pigment"  # room 1.5  # gain 5

d13 $ qtrigger $ filterWhen (>= 0) $ fast 2 $ s "tastic" # gain 3 # room 1.5  #legato 0.5 # gain (range 1 1.2 rand)


d1 $ qtrigger $ filterWhen (>= 0) $ s "[bleep(5,16), cp(1,4), feel(7,8), bass1:(9,16)]" # legato 0.2 # gain 2

d1 silence
d8 silence
d10 silence
eNding
eNding = do
  once $ qtrigger $ filterWhen (>= 0) $ s "tastic" # gain 2
  hush

Hydra Code:

// Part 2
src(o0)
  .modulate(noise(()=>(cc[0]+cc[1])*3,.1))
  .hue(0.003)
  .layer(shape(2,0.0125)
    .luma()
    .color(0,2,1))
    .modulateRotate(noise(2,4),0.05)
    .kaleid(3)
  .out(o0)

//Part 3
  s0.initImage("https://tr.rbxcdn.com/180DAY-a6ac7d0bfcabf9b03cb3bcecbd0bd6d1/420/420/Hat/Webp/noFilter")

  src(o0)
    .modulate(noise(() => (cc[0] + cc[1]) * 3, 0.1))
    .hue(0.003)
    .layer(
      shape(2, 0.0125)
        .luma()
        .color(0, 2, 1)
    )
    .modulateRotate(noise(2, 5), 0.05)
    .layer(
      src(s0)
    //.kaleid(2)
    .modulate(noise(() => (cc[0] + cc[1]) * 3, 0.1)))
    .out(o0)

hush()

//part 1
  src(o0)
    .modulate(noise(() => (cc[0] + cc[1]) * 3, 0.05))
    .hue(0.003)
    .layer(osc(20,0,2).luma(3,8).color(0,0,1))
    .layer(
      shape(2, 0.0125)
        .luma()
        .color(0, 2, 1)
        )
    .out(o0)



hush()





s0.initImage("https://tr.rbxcdn.com/180DAY-a6ac7d0bfcabf9b03cb3bcecbd0bd6d1/420/420/Hat/Webp/noFilter")
src(s0).out()







solid().out()

I really enjoy the sound of drums and low-pitched tones because they feel closer to a heartbeat. Throughout this project, I spent a lot of time searching for different low-pitched sounds to combine with each other. Initially, it was quite difficult to find the right combination because many of the sounds were too similar. To add more variation, I applied heavy distortion effects (using krush and squiz) to most of them. This helped create distinct textures and added more character to the overall composition.

I started the project using a Tidal file and then tried to connect the sound with Hydra. Since many of the music blocks were built from various rhythms, it was quite difficult to represent them visually in Hydra. One solution I came up with was to make each sound trigger a different visual change in Hydra. I especially enjoyed experimenting with basic shapes and movements, and I tried out different ways to make those shapes move in response to the sound.

It was quite challenging to bring everything together into a cohesive composition because I wasn’t sure how to create a strong drop. I ended up starting with a verse, which repeats a few times throughout the piece, then gradually layered in different drums and bass sounds to build the chorus. To create a bridge, I used a variation of the verse, which helped lead into the buildup and eventually the drop. I finished the piece by working backwards, transitioning from the drop back into the chorus, and ending with a softer, more minimal sound to bring the composition to a close.

Hydra code:

noise(20)
  .pixelate(50, 50) //()=>ccActual[4]
  .blend(
    osc(10, 0.001, 1)
      .hue(() => cc[4])
  ).blend(solid(), 0.5) //()=>cc[3]
  .out(o1)

gradient([1,2,4])
  .mult(osc(40, 0, 1).color(()=>cc[1]*2, ()=>cc[1], 1))
  .modulate(noise(()=>cc[1] + cc[0]*3))
  .brightness(0.4)
  .mask(shape(3, 0.2, 0.1).rotate(()=>cc[0]).scrollY(-0.25)) //()=>cc[2]/3
  .modulate(voronoi(25, 2, 0.5), 0.1)
  .add(
    shape(3, 0.2, 0.1) //()=>cc[2]/3
      .rotate(()=>(-(1-cc[0])))
      .color(()=>cc[1], ()=>cc[1], ()=>cc[1])
      .scrollY(0.25)
      .modulate(voronoi(25, 2, 0.5), 0.1)
  )
  .luma(0.05)
  .out(o0)

src(o1).layer(src(o2)).out(o0)

TidalCycle Code:

d1 $ slow 4 $ note "c3*4 d4*4 a3*8 g3*4" # s "superhammond:5" # legato 0.5
d4 $ ccv "[50 120] [50 120] [100 80 60 40] [50 120]" # ccn "0" # s "midi"

do
  d5 $ s "clubkick*4" # gain 0.8 # legato 1 # speed (slow 4 $ range 0.5 1 saw)
  d6 $ ccv "80 20 50 120" # ccn "1" # s "midi"

do
  d4 $ note "c3*2 d4*2 a3*4 g3*2" # s "arpy" # room 0.95 # gain 0.8 # speed "1.5 1"
  d3 $ ccv "80 40 [100 40] 120" # ccn "0" # s "midi"

do
  d1 $ s "~ cp" # gain 1.2 # room 0.5
  d4 $ s "<coins(3,8) hh(5,8,1)>" # room 1.2 # speed "2 1" # gain 1.3 # squiz 1.1 # up "-2"
  d3 $ struct "<t(3,8) t(5,8,1)>" $ ccv ((segment 128 (range 127 0 saw))) # ccn "0" # s "midi"

do
  d1 $ s "[glitch*4(3,8)]" # n (run 5) # vowel "a e i o" # room 0.45 # speed (slow 4 ("<2.5 1>")) # gain 1.2
  d6 $ ccv "[50 ~ ~ 120 ~ ~ 70 ~](3,8)" # ccn "0" # s "midi"
  d4 $ s "[sd <sd cp> ~ cp, hh*8]" # room 0.45 # speed (slow 4 ("<2.5 1>"))
  d7 $ ccv "50 <100 70> ~ 40" # ccn "1" # s "midi"

--verse 2 ADD cc[2] in hydra
do
  d1 $ degradeBy 0.4 $ s "808bd:1*8" # legato 1 # speed "1.5 1" # room 0.75
  d3 $ slow 4 $ note "c3*4 d4*4 a3*8 g3*4" # s "superhammond:5" # legato 0.5 # gain 1.1
  d4 $ ccv "[100 50] [100 50] [100 80 60 40] [100 50]" # ccn "2" # s "midi"
  d7 $ struct "t*8" $ ccv ((segment 128 (range 127 0 saw))) # ccn "0" # s "midi"
  d6 $ ccv "120" # ccn "1" # s "midi"

built_up = do {
  d3 $ qtrigger $ filterWhen (>=0) $ seqP [
  (0,1, s "[drum:5*4, hh*8]" # room 0.55),
  (1,2, s "[drum:5*4, hh*8]" # room 0.65),
  (2,3, s "[drum:5*4, hh*8]" # room 0.75),
  (3,4, s "[drum:5*4, hh*8]" # room 0.85),
  (4,5, s "[drum:5*4, hh*8]" # room 0.95)
] # speed (slow 5 (range 2 3 saw)) # gain (slow 5 (range 0.5 1.5 saw));
  d4 $ qtrigger $ filterWhen (>=0) $ seqP [
  (0, 5, struct "[t*50]" $ ccv (range 127 0 $ slow 5 saw) # ccn "3" # s "midi")
  ]
}

-- change hydra to cc[3]
built_up

bass = (stack[s "clubkick:5(3,8)", s "bassdm:22(3,8)"] # room 0.95 # speed ("<1 1.5>") # gain 1.2 # squiz 2 # up "-2" # krush 10)

do
  d2 $ bass
  d3 $ s "<bassdm:22(5,8) drumtraks:2(3,8,1)>" # room 0.95 # speed (slow 4 ("<1 1.5>")) # gain 1.1 # squiz 1.1
  d1 $ slow 4 $ note "c3*4 d4*4 a3*8 g3*4" # s "arpy:5" # legato 0.5 # gain 1.2
  d5 $ struct "<t(3,8) t(5,8,1)>" $ ccv ((segment 128 (range 127 20 saw))) # ccn "4" # s "midi"
  d4 $ ccv "[100 50] [100 50] [100 80 60 40] [100 50]" # ccn "2" # s "midi"

do
  d1 $ s "[<drumtraks:6(3,8)>, hh(5,8,1)]" # room 0.95 # krush 4 # speed (slow 4 ("<2 2.5>")) # up "-2"
  d2 $ s "stomp:5*4" # room 0.55 # krush 5 # speed (slow 4 "<2 1 1.5 2>")
  d3 $ struct "<t(3,8)>" $ ccv ((segment 128 (range 127 0 saw))) # ccn "2" # s "midi"
  d4 $ ccv "0 20 100 70" # ccn "0" # s "midi"

do
  d1 silence
  d5 $ s "clubkick*4" # gain 0.8 # legato 1 # speed (slow 4 $ range 0.5 1 saw)
  d6 $ ccv "80 20 50 120" # ccn "1" # s "midi"

do
  d4 $ note "c3*2 d4*2 a3*4 g3*2" # s "arpy" # room 0.95 # gain 0.8 # speed "1.5 1"
  d3 $ ccv "80 40 [100 40] 120" # ccn "4" # s "midi"

hush
d1 silence
d2 silence
d3 silence
d4 silence

Demo

Sorry, I can not get the embedding to work. Here is the link.

This is a version I did after class, with the right progression of the visuals:

This version is the spontaneous version; I played lines by lines without a specific order, the overall music sounds a little bit unstructured compared to the first video I posted.

For this version, I put everything into cycles with the purpose of timing everything rather than playing patterns one by one, so that’s why it’s a bit faster.

Inspiration:

My inspiration came a little bit randomly. A few days before the composition progress update, I stumbled upon this song from the electronic band Cash Cash called “How To Love” and the song, especially the synth riff, was stuck in my head for a while. I thought to myself, this riff sounds really cool and nostalgic, so let me try to create a composition piece inside TidalCycle based on it. Figuring out the code for the RHYTHM of the riff inside TidalCycle was challenging — it is easy to hum but not to construct them in codes — so I had to ask professor Aaron on Tuesday.

The time signature is a 4 4 so putting all the elements together was not too challenging. I enjoyed the process of writing the elements. The mixing, arranging, adding filters and effects part took me a lot of time. I had to make sure at least everything fit together and nothing gets left behind.

Hydra code — I experimented mainly with the concept of painting the canvas, from line to color:

solid().out()

s0.initImage("https://upload.wikimedia.org/wikipedia/commons/8/88/Hieronymus_Bosch_-_The_Garden_of_Earthly_Delights_-_Garden_of_Earthly_Delights_%28Ecclesia%27s_Paradise%29.jpg")
src(s0).out()

gradient(1)

.diff(src(s0),1)
.modulate(noise(()=>(cc[1])*4,.1))
.kaleid(2).kaleid(3)
.colorama (0.4)
.diff(noise(10,.10).thresh(.12,.12).rotate(()=>(cc[2])*14,.1))

.thresh(.2)

.out()

TidalCycles code — structured version:

hush
--40 80
--0 40 80 120
--0 20 40 60 80 100 127  

  d2 $ ccv "0 20 40 60 80 100 120 127" # ccn "1" # s "midi"
  d1 $ qtrigger $ filterWhen (>=0) $ seqP [
  --verse
  (0,16, s "arpy" >| note ((scale "major" "<[2@3 2@3 2@3 2@2 2@1 4@4] [1@3 1@3 1@3 1@2 1@2 4@4] [0@3 0@3 0@3 0@2 0@2 4@4] [-2@3 -2@3 -2@3 -2@2 -2@2 4@4]>")) # room 0.8 #lpf 1500),
  (4,23, s "~ hand:15 ~ hand:15" # gain 2 #room 0.1 #lpf 5000),
  (8,24, slow 4 $ s "superpiano" <| note "c'maj g'maj a'min f'sus2" #room 0.5),
  (16,24, s "superpiano" <| note "<[f'maj*4] [a'min*4] [g'maj*4] [g'maj*4]>" #room 0.1 #gain 1 #lpf 1500),
  (16,24, slow 4 $ s"superpiano" <|note "c6 c6 d6 g5" #room 0.1 # gain 1.5),
  (12,24, s "bassdm:14*4" #gain 1.5),
  (12,24, slow 2 $ sound "bassdm*4" #gain 1.5),

  --build-up
  (24,32, s "superpiano" <| note "<[f'maj*4] [a'min*4] [g'maj*4] [c'maj*4]>" #lpf 150 #gain 3),

  --riser-
  (24,29, s "bassdm:14*4" # room 0.5 #gain 1.5),
  (29,30, s "bassdm:14*8" # room 0.5 #gain 1.5),
  (30,31, s "bassdm:14*16" # room 0.5 #gain 1.5),
  (31,32, s "bassdm:14*32" # room 0.5 #gain 1.5),

  --drop
  (32,48, s "arpy" >| note ((scale "major" "<[2@3 2@3 2@3 2@2 2@2 4@4] [1@3 1@3 1@2 1@2 1@2 4@4] [0@3 0@3 0@3 0@2 0@2 4@4] [-1@3 -1@3 -1@3 -1@2 -1@2 4@4] [-2@3 -2@3 -2@3 -2@2 -2@2 4@4] [-1@3 -1@3 -1@3 -1@2 -1@2 4@4] [0 1 2 4 5] [4 5 7 8 7 8]>")) # room 0.8 #lpf 2000),
  (32,48, sound "clubkick:5*4" # room 0.5),
  (40,48, struct "<t(4,8) t(4,8)>" $ s "[arpy]" # note "<[c'maj*4] [g'maj*4] [a'min*4] [f'sus2*4]>" # gain 1.2 # orbit 5),
  (40,48, struct "<t(4,8) t(4,8,3)>" $ s "[reverbkick]" # note "f'maj a'min g'maj g'maj" #krush 0.5 # orbit 6 #speed 0.5)
]

TidalCycles code — unstructured version:

hush

  d10 $ ccv "40 80" # ccn "1" # s "midi"

do
  d1 $ s "arpy" >| note ((scale "major" "<[2@3 2@3 2@3 2@2 2@1 4@4] [1@3 1@3 1@3 1@2 1@2 4@4] [0@3 0@3 0@3 0@2 0@2 4@4] [-2@3 -2@3 -2@3 -2@2 -2@2 4@4]>")) # room 0.8 #lpf 1500

  d2 $ s "~ hand:15 ~ hand:15" # gain 2 #room 0.1 #lpf 5000

  d3 $ slow 4 $ s "superpiano" <| note "c'maj g'maj a'min f'sus2" #room 0.5

  d4 $ s "bassdm:14*4" #gain 1.5

  d5 $ slow 2 $ sound "bassdm*4" #gain 1.5

  d6 $ s "superpiano" <| note "<[f'maj*4] [a'min*4] [g'maj*4] [g'maj*4]>" #room 0.1 #gain 1 #lpf 1500

  d7 $ slow 4 $ s"superpiano" <|note "c6 c6 d6 g5" #room 0.1 # gain 1.5

d1 silence
d2 silence
d3 silence
d4 silence
d5 silence
d6 silence
d7 silence

    d11 $ ccv "0 40 80 120" # ccn "1" # s "midi"

do
  d1 $ s "superpiano" <| note "<[f'maj*4] [a'min*4] [g'maj*4] [c'maj*4]>" #lpf 150 #gain 3

  d2 $ s "bassdm:14*4" # room 0.5 #gain 1.5

  --riser--
  d3 $ qtrigger $ filterWhen (>=0) $ seqP [
  (0,1, s "bassdm:14*4" # room 0.5 #gain 1.5),
  (1,2, s "bassdm:14*8" # room 0.5 #gain 1.5),
  (2,3, s "bassdm:14*16" # room 0.5 #gain 1.5),
  (3,4, s "bassdm:14*32" # room 0.5 #gain 1.5),

  --buildup--
  (4,240, s "arpy" >| note ((scale "major" "<[2@3 2@3 2@3 2@2 2@2 4@4] [1@3 1@3 1@2 1@2 1@2 4@4] [0@3 0@3 0@3 0@2 0@2 4@4] [-1@3 -1@3 -1@3 -1@2 -1@2 4@4] [-2@3 -2@3 -2@3 -2@2 -2@2 4@4] [-1@3 -1@3 -1@3 -1@2 -1@2 4@4] [0 1 2 4 5] [4 5 7 8 7 8]>")) # room 0.8 #lpf 2000),
  (4,240, sound "clubkick:5*4" # room 0.5)]


    d12 $ ccv "0 20 40 60 80 100 127" # ccn "1" # s "midi"

  d4 $ struct "<t(4,8) t(4,8)>" $ s "[arpy]" # note "<[c'maj*4] [g'maj*4] [a'min*4] [f'sus2*4]>" # gain 1.2 # orbit 5

  d5 $ struct "<t(4,8) t(4,8,3)>" $ s "[reverbkick]" # note "f'maj a'min g'maj g'maj" #krush 0.5 # orbit 6 #speed 0.5

d1 silence
d2 silence
d3 silence
d4 silence
d5 silence

Composition Project Video: https://youtu.be/q6csr5kvDCk

Visual Code:

Sound Code:

Code – Part 1.

Code – Part 2.

I found this composition project particularly challenging, especially since we had to create a sound piece that evolves like a song while simultaneously developing visuals. Visuals, in particular, have always been a struggle for me. I think I got a bit blindsided by my motivation to create something that looked cool rather than ensuring it aligned with the overall vibe and tone of my sound.

In terms of the sound, the process was incredibly draining. I had structured the first section as the initial verse and the second section as the buildup, intending to include a transition between the two and then a beat drop after the buildup. However, I hit a wall—I was completely burnt out and couldn’t figure out a smooth way to transition between them. Eventually, I decided to make the second section the beat drop instead. That still left me struggling to find the right transition, though, because while the first and second sections felt similar in some ways, I also found them to be vastly different. I would just stare at my screen for hours, unsure of how to bridge them. Lines I initially planned to use for the transition ended up working better as supplementary elements for either section. In the end, I found that gradually fading out sounds one by one and then reintegrating and layering them into the second section was the best solution.

I knew that sound was my stronger suit, so I definitely put more time and effort into it. Looking back, I wish I had managed my time better so I could have balanced both the sound and visuals more equally. I also think the transition could still be improved—right now, when all the sounds in the second part are introduced, the superhoover sound is too overpowering, which diminishes the effect of a transition. Despite the challenges, I always find coding music really fun. That said, with all the midterm assignments piling up, I’m glad we’re getting a break from coding this week!

I started this project by focusing on the sound first and then creating visuals to match. I had a bunch of ideas—I wanted some acid 303s, amen break drums, and to incorporate elements from my first demo in class. But I also wanted it to have a techno feel. So, I built all these sounds and then started stitching them together into a composition.

The biggest challenge was that some of the sounds didn’t really fit together. To fix that, I made some ambient sounds and drums that suited the composition better, which ended up making the track slower than I originally planned. I was aiming for more of an ambient techno vibe—something faster. I also wanted to use the amen break throughout the whole track, but it didn’t quite fit, so I just included it right before the chorus.

For me, the defining sound of this piece is the 303s—I’m a huge fan of them. They have this raw, chaotic energy, which is what I love about them. That’s also why I wanted the visuals to feel chaotic. The visuals have three sections, all messy and intense, which was exactly what I was going for. I usually focus more on sound, but this time, I actually had more fun working on the visuals.

Overall I am very happy with the composition. As for the sound, the drop right now feels a little too “stiff” (if that makes sense) but I find it to be a good transition to the superhoover.

Here is the code:

Tidal

setcps(120/60/4)


start = fast 2 $ s "feelfx"
  >| note (scale "<india>" ("[<-7 -3 -1>,0,2]*<1>") + "[c1,c2]")
  #legato 1
  #end 0.3
  #lpf(segment(100/0.75) $ fast (8/0.75) $ range 200 400 $ sine) #lpq 0.3 #hpf 200

start2 = slow 4 $ swingBy (1/10) 8 $ s "<dbs*198 dbs*386 dbs*780>" # gain "[1 0.8 1.3 0.8]*4" #lpf (segment(100/0.75) $ fast (8/0.75) $ range 200 400 $ sine) # amp 2
hush
--drums
sdrums = stack[struct ("1 1 1 [1 0 <0 0 1 0> <0 1>]") $ s "dbs:3" # gain 1.2 #room 2, whenmod 16 15 (stut 4 1 0.065) $ n "~ 12 ~ 10" # s "dbs:2" # legato (choose[0.2,1]) # gain 1] # gain 1.2
d12 $ fast 4 $ ccn "2*128" # ccv "<100 0 8 0 10 0>" # s "midi"

sfx = stack[sound "808bd [bd [bd dbs:1]] <dbs:1 dbs:1:2> [~ ~ <~ bd> bd]" # n "1" # speed "<1 1 1 0.8>",sound "~ glitch ~ [dbs:3 [glitch glitch]]" # n "2 2 2 4 " # speed "1.3" # pan sine,sound "[~ glitch ~ glitch] [~ hc] [~ [hc hc]] [glitch hc] " # n "[0 <9 7> 0 <8 9>] 0 0 [1 3] ",sound "glitch(<9 5 12>,16)" # n "0 1 2 3 4 5 6 7" #speed "<3 1> 2 1 1 <5 2>" # pan saw] #shape 0.2 # hpf 2000 #krush 4

acidfx =  whenmod 24 20 (# speed "1.2") $ every 2 (rev) $ whenmod 8 6 (stut' 6 0.065 (|* speed 0.2)) $ sometimesBy 0.1 (# room 0.9) $ struct ("1(5,16,<0 1 2>)") $ randslice 2 $ s "<acid:1 acid:0 acid:2>" |+ n "5!6 <14 0>" # legato (choose[0.6,0.8]) # sz 0.3 #room 0.3 #hpf 400 #gain 1
d13 $ ccn "3*128"  # ccv "< 50 127 <100 127> 10 100 12 45 25 90 >"  # s "midi"


--ambient
do{
d1 $ start;
d10 $ slow 12 $ ccn "0*128" # ccv (segment(100/0.75) $ fast (8/0.75) $ range 200 400 $ sine) # s "midi"
}

hush

--dbs
do{
d2 $ start2;
d11 $ slow 64 $ ccn "1*128" # ccv (segment(100/0.75) $ fast (8/0.75) $ range 200 400 $ saw) # s "midi"
}

d2 silence

--DRUMS
do{
d3 $ sdrums;
d12 $ fast 4 $ ccn "2*128" # ccv "<100 0 8 0 10 0>" # s "midi"
}

hush

--acid fx
do{
d4 $ acidfx;
d13 $ ccn "3*128"  # ccv "< 50 127 <100 127> 10 100 12 45 25 90 >"  # s "midi"
}

--sfx
 d5 $ sfx

-- takeout drums
do{
d3 $ silence;
d12 $ silence
}

--takeout sfx
d5 $ silence

-- takeout  dbs
do{
d2 $ silence;
d11 $ silence
}

--takeout acid (not before riser)
do{
d4 $ silence;
d13 $ silence
}

-- superhoover (last)
 d15 $ silence

--takeout acid + riser
do{
  d1 $ silence; 
  d9 $ qtrigger $ filterWhen (>=0) $ seqP [
    (0, 1, randslice 2 $striate 8 $ s "acid:0"),
    (1, 2, randslice 2 $striate 8 $ s "acid:0"),
    (2, 3, randslice 2 $striate 8 $ s "acid:0*2"),
    (3, 4, randslice 2 $striate 8 $ s "acid:0*4"),
    (4, 5, randslice 2 $striate 8 $ s "acid:0*8"),
    (5, 7, randslice 2 $striate 8 $ s "acid:0*16" #pan saw),
    (7,18, slow 2 $ s "amenbrother:1" #gain 1.2)
  ]  #cut 5;
}

-- This is drop part I
 d15 $ s "superhoover" >| note ((scale "major" "<2 4 0 6>" + "f4")) #distort 1
 #lpf(range 200 600 $ sine) #hpq 1


-- Drop part II
do{
  d10 $ slow 12 $ ccn "0*128" # ccv (segment(100/0.75) $ fast (8/0.75) $ range 200 400 $ sine) # s "midi";
  --dbs
  --d2 $ start2;
  d11 $ slow 64 $ ccn "1*128" # ccv (segment(100/0.75) $ fast (8/0.75) $ range 200 400 $ saw) # s "midi";
  --DRUMS
  d3 $ sdrums;
  d12 $ fast 4 $ ccn "2*128" # ccv "<100 0 8 0 10 0>" # s "midi";
  --acid fx
  d4 $ acidfx;
  d13 $ ccn "3*128"  # ccv "< 50 127 <100 127> 10 100 12 45 25 90 >"  # s "midi";
  --sfx
   d5 $ sfx;
}

d1 $ silence


hush

Hydra



//start without dbs
speed = 0.5
shape(2,0.2,0.9)
.color(10,0,()=>cc[0],100)
.scale(0.4)
.repeat(1.0009)
.modulateRotate(o0, ()=>cc[0]*-5)
.scale(0.9).modulate(noise(()=>cc[0],2))
.rotate(3) // DBS ->>>.diff(src(o0).scale(0.9).mask(shape(4,0.9,0.01)).rotate(()=>cc[1]**2))
.out(o0)

hush()

//DRUMS
s0.initImage('C:/Users/Zakarya/Downloads/LARRY.gif')
src(s0).blend(src(s0).diff(o1).scale(1.01),1.0005)
.layer(
  src(s0)
  .scale(()=> 0.09 + ccActual[2]*0.01)
  .luma(.2)
  .invert()
  .contrast(2)
  .scrollX(.1, -0.01)
  //.modulatePixelate(src(s0), [250, 500, 10001]
)
.out(o0);

hush()

//ACID
speed = 0.5
shape(2,0.02)
.modulate(noise(1, 10))
.color(10,0,()=>Math.random(),100)
.scale(0.09) //interesting (0.09) & scale (100)
.repeat(1.9)
.modulateRotate(s0,()=>ccActual[3]*-50)
.scale(10).modulate(noise(()=>cc[3]**1001,1))
.rotate(1)
.diff(src(o0).scale(0.9).mask(shape(2,0.999,0.01)).rotate(()=>cc[3]*0.01))
//.pixelate(1,1000)
.out(o0)


hush()