Live Coding Blog

The composition project was a really challenging one but also extremely fun and enjoyable at the same time. Initially, I struggled a lot with the audio and visuals, but slowly it all finally came together! :)) I started working with the sound first. I played around with multiple audio samples, layered them, added variations, and made a list of all the rhythms and patterns I liked. Then I worked on visuals, trying multiple different functions together to create unique and interesting patterns. After having a collection of various sounds and visuals I liked, it was time to get all these individual components into a whole composition.

Having no music knowledge, I started by reading about music and composition and different song structures. The first was to come up with a beat, a base rhythm on which my composition will be built. Then layer in and out sounds to make a composition. I listened to a lot of techno music, video games soundtracks, and other artists to understand how they build up and transition in their songs. The dramatic silence part of my composition is inspired by the song Dance Macabre – one of my favorites. The indie techno vibe and drums are inspired by Coke Studio music.

One very important thing I learned through this composition project is something my professor, Aaron Sherwood says, “Don’t force it.” I had to be very selective in my choices for the audio and visuals and only choose the ones that went with my theme. Some sounds and visuals looked good individually, but I did not use them if they did not add to the composition as a whole.

As I worked on this project, I took extensive notes – notes of what sounded nice, what needed improvement, which track I am playing and which ones to choose next, which sounds I like, and what is the structure and my thought process of getting it all together. Writing it all down was very helpful and I also recorded myself so that I could go back to these later if needed. (A few of my scribbled notes can be found above).

My final live composition project video can be found here:

The Tidal Code for my composition:

-- reset midi values

reset_midi = do {
  d15 $ stack [
    ccv "0*128" # ccn "0" # s "midi",
    ccv "0*128" # ccn "1" # s "midi",
    ccv "0*128" # ccn "2" # s "midi",
    ccv "0*128" # ccn "3" # s "midi",
    ccv "0*128" # ccn "4" # s "midi",
    ccv "0*128" # ccn "5" # s "midi",
    ccv "0*128" # ccn "6" # s "midi",
    ccv "0*128" # ccn "7" # s "midi",
    ccv "0*128" # ccn "8" # s "midi",
    ccv "0*128" # ccn "9" # s "midi",
    ccv "0*128" # ccn "10" # s "midi",
    ccv "0*128" # ccn "11" # s "midi"
  ]
}

reset_midi
d15 silence

hush
d15 $ ccv "0*128" # ccn "11" # s "midi"
d15 silence

-- midi values

segment128 = ccv (segment 128 (range 127 0 saw)) # ccn "0"  # s "midi"
alt0127 = ccv "0 127" # ccn "1"  # s "midi"
alt64127 = ccv "64 127" # ccn "2"  # s "midi"
segment4 = ccv (segment 4 (range 127 0 saw)) # ccn "3"  # s "midi"
triplehalf = ccv "127 127 127 64" # ccn "4" # s "midi"
trigger = ccv "127" # ccn "5" # s "midi"
trigger2 = ccv "127" # ccn "6" # s "midi"
trigger3 = ccv "127" # ccn "7" # s "midi"
ripOff = ccv "[0 127 0] [127 0 127] 0 127" # ccn "9" # s "midi"


-- composition parts

base_gtr = s "gtr"
base_drum = s "~  808bd:1" # room 1.5 # sustain 8
tabla1 = s "<tabla:24(3,8)? tabla:6(3,8)>" # gain "1.5 1" -- put gain for first one
tabla2 = fast 2 $ s "<808ht:1(3,8) 808ht:3(5,8)?>" -- why does it have a weird beat in the beginning?
acoustic = fast 2 $ s "<tabla2:8(3,8) sf(5,8)>" # gain "1 0.5"
playful = sometimesBy 0.9 (fast 2) $ "pluck*4" <| n (run 4) # gain 1.3
honeyComb = sometimesBy 0.2 (  scramble 8 ) $ fast 2 $ s "pluck:2" >| note (arp "updown" (scale "pelog" ("[1,2]"+"<0 2 3>") + "c5")) # gain 1

andd_Beginnn = do {
  xfade 1 $ fast 2 $ s "moog:6" >| note (scale "major" "<[1@2 2 3] [1@2 2 1] [1@.5 1@1.5 2 1] [1@.5 1@1.5 2 3]>") # cut 6 # gain (range 0.6 0.75 rand);
  d8 $ qtrigger 8 $ seqP [
    (0, 4, ccv (segment 128 (range 0 127 saw)) # ccn "11"  # s "midi"),
    (4, 6, ccv "127" # ccn "11"  # s "midi")
  ]
}

riseEE = do {
  d9 $ qtrigger 9 $ seqP [
    (0, 2, sometimesBy 1 (fast 2) $ "pluck*2" <| n (run 2) # gain "<1 1.2>"),
    (2, 4, sometimesBy 1 (fast 2) $ "pluck*4" <| n (run 4) # gain "<1.4 1.5>" # room 0.2),
    (4, 8, sometimesBy 1 (fast 2) $ "pluck*8" <| n (run 8) # gain "<1.7 1.8 1.9 2>" # room 0.3)
  ];
  d3 $ qtrigger 3 $ seqP [
    (0, 2, s "bd*4" # gain "<1 1.2>"),
    (2, 4, s "bd:1*8" # gain "<1.4 1.5>" # room 0.2),
    (4, 8, s "bd:2*16" # gain "<1.7 1.8 1.9 2>" # room 0.3)
    --(6, 8, s "bd:4*32")
  ] # room 0.3
}

dRAMAAATIC_SILENCE = do
  hush
  d12 $ trigger2
  d2 $ segment128
  d3 $ fast 1 $ segment4


attack = do
  d2 $ segment128
  d3 $ fast 2 $ segment4
  d8 $ trigger3

are_you_readyyyy = do {
    d6 silence ;
    d3 silence ;
    d1 silence;
    d2 silence ;
    d8 silence ;
    --d12 silence ;
    d4 silence ;
    d5 silence ;
    d11 $ qtrigger 11 $ seqP [
        (0, 1, fast 1 $ "tabla2:24*4" # gain 1 # room 0.2),
        --(0, 1, fast 4 $ ccv "0 127" # ccn "8" # s "midi"),
        (1, 2, rotL 1 $ fast 1 $ palindrome $ degradeBy 0.1 $ s "tabla2:5" <| n "[20 23 22] [15 12 15] [20 12 15] [22 20 23]" # gain ((range 1.1 0.75 rand)) # room 0.3 # gain 1),
        (1, 3, rotR 1 $ fast 2 $ s "tabla2" <| n "[<17 ~@7>]" # room 0.1 # gain 1),
        --(1, 3, fast 32 $ ccv "0 127" # ccn "8" # s "midi"),
        --(2, 24, fast 32 $ ccv "127" # ccn "8" # s "midi"),
        (2, 16, fast 2 $ s "tabla2" <| n "[13 22 13 22,[~ 19]*2,[<17 ~@7>]]" # gain 1 # room 0.1)
        --(2, 24, attack)
    ];
    d12 $ qtrigger 12 $ seqP [
        (0, 1, fast 4 $ ccv "0 127" # ccn "8" # s "midi"),
        (1, 3, fast 32 $ ccv "0 127" # ccn "8" # s "midi"),
        (2, 24, fast 32 $ ccv "127" # ccn "8" # s "midi")
        --(2, 24, attack)
    ];
    attack
}

finalleYYYY = do {
  d9 $ qtrigger 9 $ seqP [
    (0, 8, ccv "0" # ccn "10" # s "midi"),
    (0, 2, sometimesBy 0.9 (fast 2) $ "pluck*2" <| n (run 2) # gain "<1 1.1>"),
    (2, 4, sometimesBy 0.9 (fast 2) $ "pluck*4" <| n (run 4) # gain "<1.2 1.3>"),
    (4, 6, sometimesBy 0.9 (fast 2) $ "pluck*6" <| n (run 6) # gain "<1.5 1.7>"),
    (0, 2, segment4),
    (2, 8, fast 2 $ segment4),
    (4, 6, ripOff),
    (6, 8, fast 2 $ ripOff),
    (4, 6, s "[bd gretsch:9] [bd gretsch:0] gretsch:1 gretsch:1" # gain 2),
    (4, 6, s "~ ~ ~ hh:1" # gain 1.5),
    (6, 8, fast 2 $ palindrome $ degradeBy 0.1 $ s "gretsch" <| n "[20 23 22] [15 12 15] [20 12 15] [22 20 23]" # gain ((range 1.1 0.75 rand)) # room 0.2 # gain 1.5),
    (7, 9, rotR 1 $ fast 2 $ s "gretsch" <| n "[<17 ~@7>]" # room 0.3 # gain 2),
    (8, 9, ccv (segment 128 (range 0 127 saw)) # ccn "10" # s "midi")
  ];
}




-----------------------------------------------------------------------------
-- START PERFORMANCE

do
  d1 $ base_gtr
  d2 $ segment128
  d7 $ trigger3

do
  d3 $ base_drum
  d4 $ alt0127

do
  d5 $ acoustic
  d6 $ alt64127

do
  xfade 7 $ playful
  d8 $ segment4
  d2 silence

do
  clutch 5 $ tabla1
  d9 $ tabla2

d10 $ triplehalf

do
  clutch 7 $ honeyComb
  clutch 5 $ fast 2 $ "hh hh:5 hh:11 hh"
  d11 $ trigger

clutch 9 $ degradeBy 0.2 $ someCyclesBy 0.8 (fast 1) $ fast 2 $ s "pluck:2" >| note (arp "updown" (scale "pelog" ("[1,2,5]"+"<0 6 1>") + "c5")) # gain 1
d3 $ "bd*8 bd*2"

riseEE

dRAMAAATIC_SILENCE

andd_Beginnn

xfade 4 $ fast 2 $ struct "t(5,8)" $ s "dr55" <| n (run (range 10 15 rand))
xfade 5 $ every 4 (fast 2) $ sound "drum*2" # room 0.1
xfade 6 $ fast 2 $ "hh hh:5? hh:11? hh" # room 0.2
xfade 7 $ fast 2 $ "pluck*8" <| n (run 8) # gain 1.2

are_you_readyyyy

finalleYYYY

d7 $ silence

hush

The Hydra Code for my composition:

///////////////////////////////////////////
// Section 1

render(o0)
solid().blend(
  osc(10,0.1,0).color(0.1,0.5,0.3)
    .modulateRotate( osc(10,0.1), ()=>cc[0] )
    .hue(  ()=>cc[2] ).kaleid(10)
    .modulate(o0, ()=>(cc[1]*0.5) )
    .modulate( osc(1,()=>cc[2]*15) )
    .repeat(()=>cc[3]*4+1,()=>cc[3]*4+1)
    .kaleid(5)
    .blend(shape(100)
      .rotate(() => Math.PI /180)
      .repeatX(3)
      .repeatY( ()=>Math.sin(time)*4 )
      .scale(() => Math.PI/4)
      .repeat(()=>cc[3]*4,()=>cc[3]*4)
      .blend(src(o0).color(0.2,1,0))
      .modulate(osc([4,15,25,50].fast(8), 0,.4))
      .kaleid(10), ()=>cc[4])
    .blend( shape( ()=> cc[3]+4 ,0.000001,[0.2,0.7].smooth(1))
      .color(0.2,0.4,0.3)
      .scrollX(()=>Math.sin(time*0.27))
      .add(
        shape( ()=> cc[3]+4, 0.000001,[0.2,0.7,0.5,0.3].smooth(1))
        .color(0.6,0.2,0.5)
        .scrollY(0.35)
        .scrollX(()=>Math.sin(time*0.33)))
      .add(
        shape( ()=> cc[3]+4 ,0.000001,[0.2,0.7,0.3].smooth(1))
        .color(0.2,0.4,0.6)
        .scrollY(-0.35)
        .scrollX(()=>Math.sin(time*0.41)*-1))
      .modulate(voronoi(10,2,2)).rotate(()=>cc[3],2), ()=>cc[5] )
    .modulateRotate(src(o0)).modulateRotate(src(o0))
    .modulateRotate(src(o0)).modulateRotate(src(o0))
    .blend(solid(), ()=>cc[6] )
    ,()=>cc[7])
  .out()

///////////////////////////////////////////
// Section 2

solid().blend(
  osc( ()=>cc[3]*100 ,0.2,1)
  .mult(osc(20,-0.1,1).modulate(noise(3,1)).rotate(0.7))
  .luma(()=>cc[0])
  .mult(osc(5,2,1))
  .modulateRotate( noise(1)  )
  .modulateRotate( o1,1  )
  .blend(o0).blend(o0)
  .rotate(()=>cc[0],()=>cc[3])
  .blend (osc(10,0.1,()=>cc[0])
    .modulateRotate(osc(10,0.1).rotate(),()=>cc[3])
    .hue(0.2).kaleid(4).modulateRotate(noise( ()=>cc[3]*10 ))
    .color(()=>cc[0],0,0.5)
  , ()=>cc[8])
, ()=>cc[11])
.out()

///////////////////////////////////////////
// Finale

osc(10,0.1,1)
    .modulateRotate(osc(10,0.1).rotate(),1)
    .hue(0.2).kaleid(4).modulateRotate(noise( 1*10 ))
    .color(1,0,0.5)
    .out()
shape(30,0.3,1).invert(()=>cc[9]).out(o2)
noise(()=>cc[3]*4,0.2,3)
  .thresh(0.3,0.03)
  .diff(o2).out(o1)
gradient([0.3,3].fast(4)).mult(o0).blend(o1)
  .modulateRotate(o3).modulateRotate(o3).modulateRotate(o3)
  .blend(solid(), ()=>cc[10])
  .out(o3)
render(o3)

hush()
render(o0)

///////////////////////////////////////////

 

Process

As someone who is very indecisive, it’s often difficult to find a starting point, especially when there are no limitations or specific guidelines but I had to start somewhere. I looked over my previous assignments, pasted in some code for hydra, and started experimenting. I started with the visuals first as I wanted to get an idea of how fast or slow I would like to have my audio.

Visuals

For the visuals in this project, I decided to take a more sleek and simple approach relative to my previous assignments. I noticed that in all of my previous assignments I would create visuals that take up the whole screen and have colors all over the place, so I decided to make something different and focus on the use of shapes. I chose to incorporate my personality into the theme by choosing a color palette consisting of my favorite colors; pink and blue, with some transitional colors and shades. I made at least 10 different mini-performances with the visuals, left them, and started working on the audio.

Audios

In regards to the audio, I also wanted to step out of my comfort zone and find and work with my own samples rather than the ones offered by tidal. The longer audios were a bit more difficult to incorporate as I had to figure out how many loops to set them as and add effects to make them sound like the original sample file. I got Aaron’s help for one of them and applied the same logic to the rest. As usual, for me, the audios were more difficult to put together, as I feel that I don’t have a musical ear and so it takes me some time to find different sounds that go together and asked a few of my friends if they sound good. Similar to the visuals, I put together maybe 7 mini-performances until I was satisfied with the results I had. I experimented with different scales of structure, however, I ended up choosing performances that included longer audio files so I didn’t feel that the scales went along with them.

Composition

Next, I had to put the visuals and audio together so I went through them all, and deleted the performances that I either didn’t like or felt that they don’t go with the rest. Testing by mixing and matching different visuals with different audios, I reached 2 of each that I really liked and decided to incorporate them with one another. I separated the performance into 2 phases, fading in and out of the first one, merging into the second one, and lastly fading out with the second one. I connected the visuals and audio through Midi, also testing out several output patterns, and organized everything in a thought-out order of events to put together the composition.

Reflection and Outcome

Out of all of the assignments that we have done since the beginning of the semester, I would say I enjoyed the composition project the most. It gave me the opportunity to explore and experiment but with the goal of having a well-put-together composition that takes into account the sounds as well as the visuals. Ironically, screen recording was a challenge that I had as every time I record something goes wrong; the laptop lags, the audio doesn’t play, I mess up, the audio doesn’t record, …etc. I had to record over 20 times until I finally had a proper recording as could be seen below:

Initially I was just exploring different visual and audio possibilities, until I had a dream about swimming. Therefore, my later intention and concept were to create a sense of dream where one sinks into the water, discovers and experiences a different fantasy. I referred to ABCB structure, but the C part is mainly variation of materials. 

What I wish I have done better is the interaction between audio and visual. For example, I don’t have much visual changes going on for the buildup to increase the intensity. But overall I’m happy with what I have done. 😀

Update: I intended to create a strong contrast visually from B&W to colorful environment with the help of audio. However it turned out a bit abrupt for some viewers, and I can get the point. So I think it’s good to show things to people and get feedback, which can be different, but will provide insights that we as creators couldn’t sense otherwise.

My Code:

Hydra

osc(10,0.1,0).modulate(noise(()=>cc[0]*1,0.04),0.5).thresh().out()
// ()=>cc[0]*1,0.04
// thresh

shape(3).scale(0.4).scale(()=>cc[0]*4).out(o0)

shape(3).scale(()=>cc[0]*1.2).repeat(6,4).out(o0)

//tin
shape(3).scale(()=>cc[0]*1).rotate().repeat(5).scrollX(()=>(-cc[2])*10).scrollY(()=>(-cc[2])*10).out(o0)

shape(4).scale(()=>cc[0]*1).rotate().repeat(5).scrollX(()=>cc[2]*10).scrollY(()=>cc[2]*10).out()

hush()

s1 = osc(10,0.1,0.3).hue(()=>cc[0]*0.3).modulate(noise(()=>cc[0],0.04),0.5).colorama(0.5)
s2 = osc(10,0.1,1).hue(()=>cc[6]*2).modulate(noise(()=>cc[6],0.04),0.5).colorama(1)

//drop
s2.out()

shape(3).scale(0.5).scale(()=>cc[0]*4).repeat(6,4).out(o0)
s1.out(o1)
src(o2).modulate(src(o1).add(solid(1,1),-0.5),0.001).blend(o0,0.1).out(o2)
solid().layer(src(o2).mult(o1),0.5).out(o3)
render(o3)

//ending
tri = shape(3).kaleid(3).scale(0.6)
tri.scale(()=>cc[5]).rotate(()=>(cc[5])).repeat(5).out(o0)
osc(10,0.1,1).hue(.8).modulate(noise(2,0.04),0.5).colorama(2).out(o1)
src(o2).modulate(src(o1).add(solid(1,1),-0.5),0.001).blend(o0,0.1).out(o2)
solid(0.2,()=>cc[1]*0.2,()=>cc[1]*0.2).layer(src(o2).mult(o1).luma(0.01),0.1).out(o3)
render(o3)

hush()

Tidalcycle:

Continue reading “Eadin’s Composition Project” →

Hi everyone!

This is the documentation for my Composition Performance (linked is a recorded draft — the actual piece to be performed with minor improvements in class tomorrow!)

Intro

The theme of my performance is visualizing and sound-narrating a gameplay experience. My intention was to depict the energy, intensity, and old-fashioned vibe of Mario-like 2D games. This is done through heavy use of pixelated graphics, noise, vibrant colors in Hydra, and electronic sounds/chords (mostly from the ‘arpy’ library) as well as some self-recorded samples in Tydal Cycles.

Audio

The overall intention behind the audio in the piece is to take the audience from the start of the game, followed by some progression with earning score points, then culminating and progressing to level 2, and lastly to “losing” the game and the piece ending.

The audio elements that I recorded are the ones saying “level two”, “danger!”, “game over!”, “score”, and “welcome to the game!”:

-- level 2
d1 $ fast 0.5 $ s "amina:2" # room 1
-- danger
d1 $ fast 0.5 $ s "amina:0" # room 1
-- game over
d1 $ fast 0.5 $ s "amina:1" # room 1
-- score
d1 $ fast 0.5 $ s "amina:3" # room 1
-- welcome to the game
d1 $ fast 0.5 $ s "amina:4" # room 1

 

Learning from class examples of musical composition with chords, rhythms, and beat drops, I experimented with different notes, musical elements, and distortions. My piece starts off with a distorted welcome message that I recorded and edited:

d1 $ every 2 ("<0.25 0.125 0.5>" <~) $ s "amina:4"
  # squiz "<1 2.5 2>"
  # room (slow 4 $ range 0 0.2 saw)
  # gain 1.3
  # sz 0.5
  # orbit 1.9

Building upon various game-like sounds, I create different compositions throughout the performance. For example:

-- some sort of electronic noisy beginning
-- i want to add "welcome to the game"
d1 $ fast 0.5 $ s "superhoover" >| note (arp "updown" (scale "minor" ("<5,2,4,6>"+"[0 0 2 5]") + "f4")) # room 0.3 # gain 0.8 -- change to 0.8

-- narration of a game without a game
-- builds up slightly
d3 $ stack [
  s "sine" >| note (scale "major" ("[<2,3>,0,2](3,8)") + "g5") # room 0.4,
  fast 2 $ s "hh*2 hh*2 hh*2 <hh*6 [hh*2]!3>" # room 0.4 # gain (range 1 1.2 rand)
]

Visuals

My visuals rely on the midi output generated in Tydal Cycle and build upon each other. What starts as a black-and-white modulated and pixelated Voronoi noise grows gets color and grows into playful animations throughout.

For example:

voronoi(10,1,5).brightness(()=>Math.random()*0.15)
  .modulatePixelate(noise(()=>cc[1]+20),()=>cc[0]),100)
  .color(()=>cc[0],2.5,3.4).contrast(1.4)
  .out(o0)

// colored
voronoi(10,1,5).brightness(()=>Math.random()*0.15)
  .modulatePixelate(noise(25,()=>cc[0]),100)
  .color(()=>cc[0],2.5,3.4).contrast(1.4)
  .out(o0)

voronoi(10,1,5).brightness(()=>Math.random()*0.15)
  .modulatePixelate(noise(()=>cc[1]+20,()=>cc[0]),100)
  .color(()=>cc[0],()=>cc[1]-1.5,3.4).contrast(0.4)
  .out(o0)

// when adding score
voronoi(10,1,5).brightness(()=>Math.random()*0.15)
  .modulatePixelate(noise(()=>cc[2]*20,()=>cc[0]),100)
  .color(()=>cc[0],5,3.4).contrast(1.4)
  .add(shape(7),[cc[0],cc[1]*0.25,0.5,0.75,1])
  .out(o0)

// when dropping the beat
voronoi(10,1,5).brightness(()=>Math.random()*0.15)
  .modulatePixelate(noise(cc[0]+cc[1],0.5),100)
  .color(()=>cc[0],0.5,0.4).contrast(1.4)
  .out(o0)

 

Challenges

When curating the whole experience, I first started by creating the visuals. When I found something that I liked (distorted Voronoi noise), my intention was to add pixel-like sound, and the idea of games came up. This is how I decided to record audio and connect it to the visuals. What I did not anticipate is how challenging it would be to link transitions on both sides and timing them appropriately.

Final reflections and future improvements

I put a lot of effort into making the sounds cohesive and creating a story that I wanted to tell with the composition. When doing the next assignment in class, I think I will try to make the transitions smoother and make visuals be more powerful in the overall storytelling.

Most importantly, I think I am finally starting to get the hang of live coding. This is my first fully “intentional” performance — although many elements will be done with improv when performing live, this project feels less chaotic in terms of execution and the thought process put behind the experience.

The full code can be found here.

Heyy guys! Some of you asked me how I did the visuals for my previous weekly assignment. Here is the code:

src(o0).modulateHue(src(o0).scale(1.01),1).layer(osc(10,.1,2).mask(osc(200).modulate(noise(3)).thresh(1,0.1))).out()

The above code I used to transition from my previous visual. And the below one is the one connected to midi:

osc(10,.1,2).mask(osc(200).modulate(noise(()=>cc[0]*3+1)).thresh(()=>(cc[0]),0.1)).rotate().out()

Altering the thresh values and noise level made interesting patterns!

Also, I wondered what the difference was between layer and mask. While coming up with the above, I discovered that layer and mask can be used interchangeably in the following way:

// the following 2 codes are same
osc(10,.1,2).layer(osc(200).luma(0.5,0.8).color(0,0,0,1)).out()
osc(10,.1,2).mask(osc(200)).out()

The above 2 lines of code produce the same output. Hope this was helpful! 🙂