Challenge: Algoraoke!

Trying to go from tablature to tidal ::phew::

Blue Monday Cover (byo-synthdef's!)

https://soundcloud.com/user7928677/lenny-foret-blue-monday-cover

-- key: D minor
-- bpm 130

setcps (130/60/4)


d2 $ repeatCycles 1 $ degradeBy 0 $ fast 1 $ midinote " {36 46 38 <46 > }%8 " # s " pig " -- oberhiem dmx

d9 $ n ((+"0")  $ (+"2") $ (scale " minor " ((+"0") $ " {2 2 2 3 -1 -1 -1 0 0 ~ 0 0 ~ 0 0 0  }%8 "))) # s " [nine, ten] "  # legato 0.5 -- lead synth

d4 $ n ((+"2")  $ (+"-36") $ (scale " minor " ((+"{5 0 2!2 7 0 2!2}%2") $ " {0 _ 0 0  }%16 "))) # s " six " # legato 0.4 -- bass

d9 $ n ((+"2")  $ (+"-12") $ (scale " minor " ((+"0") $ " {<3!3 5 6!3 3 5> _ <2!3 0 5!3 2 0 > _ <0!3 -1 3!3 0 -1>___  }%4 "))) # s " eight " -- lead vocals

d10 $ n ((+"0")  $ (+"2") $ (scale " minor " ((+"0") $ " {2 2 2 3 -1 -1 -1 0 0 ~ 0 0 ~ 0 0 0  }%8 "))) # s " ten " -- arpy

this is a cool challenge! I love re-making stuff in code recently.

Here's some Britney spears using seqP loop

setcps(110/120/2)

let notePat = toScale [0,7,14,7,12,7,0,12] "0 1 2 3 4 5 6 7"
    notePat2 = toScale [0,7,12,7,12,7,12,7] "0 1 2 3 4 5 6 7"
    notePat3 = toScale [0,3,12,3, 10,3,7,3] "0 1 2 3 4 5 6 7"
    -- soundPat = s "bulmasy:3" #sus 0.4 #rel 0.4
    soundPat = s "midi1"
    -- soundPat = s "superpiano"


-- verse
do
    {
      resetCycles;
      d1 $ slow 1 $ seqPLoop [
      -- right hand
      (0,1, note ("~ [~ g5] g6 [ds6 f6]" ) # soundPat),
      (2,3, note ("~ [~ g5] g6 [ds6 d6]" ) # soundPat),
      -- left hand
      (0, 1, note (notePat ) # soundPat |+| note "ds4"),
      (1, 2, note (notePat ) # soundPat  |+| note "as4" ),
      (2, 3, note (notePat ) # soundPat |+| note "ds4"),
      (3, 4, note (notePat ) # soundPat |+| note "c5" )
      ]
    }


-- prechorus bit
do
    {
      -- resetCycles;
      d1 $ slow 1 $ seqPLoop [
      -- right hand
      (0,1, note ("~ [g5, as5, d6] [as5,d6,g6] [[g5, as5, d6] [g5, as5, ds6]]" ) # soundPat),
      (2,3, note ("~ [g5, as5, d6] [as5,d6,g6] [[g5, as5, d6] [g5, as5, ds6]]" ) # soundPat),
      (3,4, note( "[~ [g5, as5, ds6]] [~ [g5,as5,f6]] [~ [g6 f6]] [ds6 ds6]") #soundPat),
      -- left hand
      (0, 1, note (notePat2) # soundPat |+| note "g3"),
      (1, 2, note (notePat2) # soundPat |+| note "ds3" ),
      (2, 3, note (notePat2) # soundPat |+| note "g3"),
      (3, 4, note (notePat2) # soundPat |+| note "ds3" )
      ]
    }

--- chorus how to transition from the above bit?
do
    {
      resetCycles;
      d1 $ slow 1 $ seqPLoop [
      -- right hand
      (0,1, note ("~ [[ds6,g6,as6] [ds6,g6,as6]] [ds6,g6,as6] [[as5, ds5, g6] [as5, d6, f6]]" ) # soundPat),
      (1,2, note ("~ [[d5,f5,as5] [d5,f5,as5]] [~ g6] [~ [c6, ds6, g6]]" ) # soundPat),
      (2,3, note ("~ [[c6, ds6, g6] [c6, ds6, g6]] [~ [g5,c6,ds6]] [~ [g5,as5,d6]]") # soundPat),
      (3,4, note( "~ [[g5,as5,d6] [g5,as5,d6]] [~ as5] [c6 [ds5, gs5,c6]] ") #soundPat),
      (4,5, note ("~ [~ gs5] [ds5,gs5,c6] [as5, c6, ds6]" )  #soundPat),
      (5,6, note ("[f5, as5, d6] [f5, as5, d6] [as5, c6, ds6] [as5, c6, f6]") #soundPat),
      -- left hand
      (0, 1, note (notePat) # soundPat |+| note "ds4"),
      (1, 2, note (notePat) # soundPat |+| note "as3" ),
      (2, 3, note (notePat) # soundPat |+| note "c4"),
      (3, 4, note (notePat3) # soundPat |+| note "g3" ),
      (4, 5, note (notePat) # soundPat |+| note "gs3") ,
      (5, 6, note (notePat2) # soundPat |+| note "f3")
      ]
    }

Or a 90s rave classic

setcps(140/120/2)

let synthSound = s "bulmasy:2"  #sus 0.2 #rel 0.4 #sp "[1,1.02]" #end (0.07) #phasr (range 2 8 $ slow 8 $ sine) # g (1.3) #phasdp (range 0.1 2 $ slow 8 $ sine) #cutoff (range 800 4000 $ slow 16 $ sine)
    bassSound =  s "GBass:2"  #shape 0.3 # g (1) #hpf 100
    aahSound = s "supercomparator" # vowel "a "
    stringSound = s "supersquare" # vowel "a" # g 0.8


let notePatSynth1 = "b5 ~ ~ ~ [~ <~ as5>]"
    notePatSynth2 = "b5 [b5(7,8) gs5] ~ ~ ~ ~ <fs6*2 e6*2> [~ [ds5 ds6]]"
    notePatSynth3 = "b5 [b5 gs5] [~ b5] [~ b5] [~ as5] [~ fs5] <fs6*2 e6*2> [~ ds6]"
    notePatBass1 = "[~ b4]*4 [~ as4]*4 [~ ds5]*4 [~ cs5]*4"
    notePatBass2 = "[b4 ~ ] b4 ~ [b4 b4] [b4 ~ ] b4 ~ [b4 b4] [as4 ~ ] as4 ~ [as4 as4] [as4 ~ ] as4 ~ [as4 as4] [ds5 ~ ] ds5 ~ [ds5 ds5] [ds5 ~ ] ds5 ~ [ds5 ds5]  [cs5 ~ ] cs5 ~ [cs5 cs5] [cs5 ~ ] cs5 ~ [cs5 cs5]"

-- intro
resetCycles


do
  d1 $ slow 2 $ note (notePatSynth1) # (synthSound)
  d2 $ slow 4 $ note (notePatBass1) # (bassSound)
  d3 $ s "[k ~ ]*4" # shape 0.6 # g 0.9

-- add hihats
do
  d1 $ slow 2 $ note (notePatSynth1) # (synthSound)
  d2 $ slow 4 $ note (notePatBass1) # (bassSound)
  d3 $ s "[k ~ ]*4" # shape 0.6 # g 0.9 # g 0.8
  d4 $ stack [
    s "hh27*8" # g 1.1
    ]


--- some transition sound?
do
  d5 $ s "tekken-upfx:3/2" #sp 0.85 #g 1.2

--- add drums, change synth line
do
  d5 shh
  d1 $ slow 2 $ note (notePatSynth2) # (synthSound)
  d2 $ slow 4 $ note (notePatBass1) # (bassSound)
  d3 $ s "[k ~ ]*4" #end 0.6 # shape 0.1 # g 0.8
  d4
    $ stack [
    sometimes (fast 1 ) $ s "~ als:2" # g 0.96,
    s "~ ~ [808lt <808mt 808ht>] ~" # g 1.2 #shape 0.4,
    fast 1 $ s "hh27 hh27 hh27:2 hh27" # g 0.9
    ]  #coarse "2"

---  add build up snare

do
  all $ (#hpf "900")
  d1 $ slow 2 $ note (notePatSynth2) # (synthSound)
  d2 $ slow 4 $ note (notePatBass1) # (bassSound)
  d3 $ s "[k ~ ]*4" # shape 0.7 # g 0.9
  d4
    $ stack [
    fast 2 $ s "sn:1*8" # g (range 0.9 1.1 $ slowersine),
    sometimes (fast 4 ) $ s "~ als:2" # g 0.9,
    s "~ ~ [808lt <808mt 808ht>] ~" # g 1.2 #shape 0.4,
    fast 4 $ s "hh27 hh27 hh27:2 hh27" # g 0.9
    ]  #coarse "2"

--- break down
do
  d2 shh
  d3 shh
  d4 shh
  d1 $ slow 2 $ note (notePatSynth3) # (synthSound)
  d5 $ slow 4 $ note "gs5 fs5 gs5 as5" # (aahSound)
  d6 $ slow 4 $ note "gs5 fs5 gs5 as5" # (stringSound)

--- break down 2
do
  all $ (#hpf 200)
  d1 $ slow 2 $ note (notePatSynth3) # (synthSound)
  d2 $ slow 4 $ note (notePatBass2) #  (bassSound)
  d4 $ stack [ fast 1 $ s "sn:1*8" # g (range 0.9 1.2 $ slowersine)]


do
  all $ (#hpf "20")
  d5 shh
  d6 shh
  d1 $ slow 2 $ note (notePatSynth3) # (synthSound)
  d2 $ slow 4 $ note (notePatBass2) # (bassSound)
  d3 $ s "[k ~ ]*4" # shape 0.8 # g 0.9
  d4
    $ stack [
    sometimes (fast 4 ) $ s "~ als:2" # g 1.1,
    s "~ ~ [808lt <808mt 808ht>] ~" # g 1.2 #shape 0.4,
    fast 2 $ s "hh27 hh27 hh27:2 hh27" # g 0.9
    ]  #coarse "2" #g 1.1
  d7
    $ slow "<2 4>"
    $ superimpose ((#vowel "a e ").(crushit).(rip 0.5 0.25))
    $ often (#accelerate "-0.6 0.2")
    $ rarely (jux rev)
      $ s "adeej" #n (irand 8) # g 1
      #up "11"
      # cps((range 0.4 0.8 $ slowersine))
      -- #cps (140/120/2)


1 Like

I worked with a more "symphonic" brass-sample of a song you can't normally cover bescause it's so horrible. But it seems that it influenced me in some ways :wink:

Here is the song: mrill_v1.0

Here is the code (with seqPLoop) more like playing automatically DAW-Style.

do
  let mrllbass = n "[[d]!4 ]" # s "supersaw" # octave 3 # sustain 0.2 # gain 0.6 -- bass strophe und ref
  let mrllbassbreak = n "[[d3]!6 [c3]!6 [g2]!6 [f2]!6]/8" # s "superpwm"  # voice 0.2 # sustain 0.2 # octave 5 # gain 0.8 
  let mrllsmplstrophe = splice 8 "[ 8 8 8 6]/8"  $ s "[mrll]"  # gain 1.1 # hpf 555
  let mrllsmplbreak =  splice 4 "[8 7 [5] 5]/8"  $ s "[mrll]"   # begin 0.75 # end 1 # delay 0.7 # delaytime "<h>"  # delayfeedback 0.5 # orbit 1 # lpf (range 222 2222 $ slow 64 tri) # gain 0.9
-- let mrllintro =
  let mrllbassrefrain = n "[[d]!4 ]" # s "supersaw" # octave 3 # sustain 0.2 # gain 0.65
  let mrllsmplrefrain =  splice 4 " [1 2 [2] [4]]/8"  $ s "[mrll]" # hpf 555 # gain 0.95
  let mrlldrumbasic = s "[th127:5]" # legato 0.1 # speed (120/127)  # gain 0.9
  let mrlldrumbreak = stut 4 0.5 0.5 $ brak $ s "[cpu*2 cpu:3]" # legato 0.1 # gain 0.9
  let mrlldrumrefrain = s "[th127:13]" # legato 1 # speed (120/127) # gain 0.9
  let mrlldrumfill = slow 2 $ struct ("1 1 0 1  1 0 1 0  0 1 0 1  1 1 0 0") $ s "[syndrum:3]" # note "4 0 3 1" # cut 1 # room 0.8 # sz 0.6 # orbit 2 # gain 0.6
  let mrllbluemondayhh = stack [slow 2 $ struct ("[1 0 0 1  0 0 1 0  0 1 0 0  0 0 0 0]") $ "cpu:3" # gain 0.95, 
                                                    slow 2 $ struct ("[1 0 0 1  0 0 1 0  0 1 0 0  0 0 0 0]") $ "cpu" # gain 0.9
                                                    ]
  let mrllbluemondaybd = slow 4 $ "cpu!2 [cpu*4] [cpu*4] cpu!4" # hpf 88 # gain 1 -- blue monday bd break
  let mrllwayto = s "[[mrll:1 ~~~] [mrll:1 ~~~]]/4" # speed 1.06 # delay 0.4 # delaytime "q"  # delayfeedback 0.4 # orbit 3 # comb 0.2 # distort 0.9 # shape 0.9 # hpf 777 # phasr 0.9 # gain 0.5
  --song struct
  let mrllstrophe = stack [mrlldrumbasic, mrllbass, mrllsmplstrophe]
  let mrllbreak = stack [mrlldrumbreak, mrllbassbreak, mrllsmplbreak]
  let mrllbluemonday = stack [mrllbluemondaybd, mrllwayto]
  let mrllrefrain = stack [mrlldrumrefrain, mrllbassrefrain, mrllsmplrefrain]
  do 
  {
    resetCycles;
    d1 $ rotL 0 $ seqPLoop [
      (4, 36, mrllstrophe), -- 32 ok
      (36, 68, mrllbreak), -- 32 ok
      (68, 76, mrllbluemonday), -- 8 ok
      (76, 80, mrllbluemondayhh), -- 4 ok
      (80, 112, mrllrefrain), -- 32 ok
      -- effekte
      (0, 8, sound "fx120" # legato 3 # begin 1 # end 0 # gain 0.75), --2
      (34, 36, mrlldrumfill), --2
      (33, 36, sound "fx:2" # legato 4 # gain 0.8), --2
      (66, 68, sound "fx:2" # gain 0.6), --2
      (79 , 80, mrlldrumfill), --2
      (78, 80, sound "fx:2" # gain 0.6)
    ] # room 0.3 # sz 0.1 # orbit 5 # cps (120/120) 
  }
2 Likes

Can you explain 'qtrigger' ? There is no entry in the userbase. Did Alex explain this function?

Very nice, Next challege for me is using ur. What does the 'in' command do exactly? I love playing it at #cps 0.5 an with a bit more #room...

1 Like

not in expert, but AFAIK, the in goes with the let so that the variable april is replace with whatever version you specify (a,b,c,d)

@yaxu in the documentation 'in' stands for 'Live audio input' can you please explain, how it is used with ur? And 'qtrigger' is already undocumented, what does it stand for?

@artheist is right, the in here isn't for live audio input (which is a name of a superdirt synth), but just connects the definitions in a 'let' with a function that uses those definitions.

qtrigger re-triggers a pattern from cycle 0, quantised to the nearest cycle boundary so it's in time with everything else.

1 Like

Sorry @yaxu i should have watched the vídeo week 5 lesson 1 before asking!

1 Like

Excellent!

This seemed really simple upfront, then I think I made it hard for myself...

Anyway, I picked this one cause I like the opening drumbeat
No vocals from me I'm afraid (I'm doing this course at 5:30am with a sleeping household and headphones), but you get google vox :smiley:

setcps 0.34

-- verse perc
do  resetCycles
    d1 $ s "<[[[ab:4*2]*2] . [ab:10 ab:4 ~ ~] . [ ~!3 ab:4 ] . [ab:10 ~!3 ]] [[ab:4*2] . [ab:10 ab:4 ~ ~] . [ ~!3 ab:4 ] . [ab:10 ~!3 ]]>"
    d2 $ s "<[ab:0*8] [[ab:6*2] . [ab:0*2] . [ab:0*2] . [ab:0*2] ] >"
        # cut 1
        # room 0.9
        # size 0.4
    d3 $ s "< [~ . [ ~ breath ~ breath] . [~ breath ~!2 ] . ~] [ ~ . [~!3 breath] . ~ . ~] [[ ~ breath ~ breath] . [~ breath ~!2 ] . ~ . ~]>"
        # legato 1.2
        # up 3


--verse comp + vox
do  d4 $ n " [0*2]*2 . ~ [ 0*2] . [ 0 0 ] [ 0 0 ] . [ 0 6 ] [ 6 6 ] " # s "supersaw"
        # octave 3
        # squiz 2
        # gain 0.6
    d5 $ n "<  [[13 21] [13 12] ] [12*2]*2 [12*2]*2 [12*2]*2 >  . ~ [12*2] . [12 10] [10 10] . [10 12] [12 12]" # s "supersaw"
        # octave 4
        # squiz 2
        # gain 0.6
    d6 $ n " [0*2]*2 . ~ [ 0*2] . [ 0 0 ] [ 0 0 ] . [ 0 6 ] [ 6 6 ] " # s "supersaw"
        # octave 2
        # squiz 2
        # gain 0.6
    -- vox you won't have
    -- d7 $ slow 4 $ n "< ~ 5 4 ~ ~>" # s "cycle0"
    --    # speed 0.75

3 Likes

I did not know you could do that - awesome!

Bit late to the Algoraoke, but I finally found time to start catching up. To continue the Radiohead theme:

setcps 0.22

d1 $ note "<fs4'maj'6 a4'6'6> _ _ <fs4'maj'6 g4'maj7'6> _ _ g4'maj7'6 _ _ _  <a4'6'6 fs4'maj'6> _ _ <a4'6'6 fs4'maj'6> _ _" # s "superpiano" # velocity 0.5 # gain 1.2 # sz 0.3 # room 0.3

d2 $ note "<fs a> _ _ <fs g> _ _ g _ _ _ <a fs> _ _ <a fs> _ _" |- note "24" # s "superpiano" # room 0.4 # sz 0.7 # velocity 0.8 # lpf 300

d3 $ s "[bd(5,16, 3), hh*16, sn:3*4]"

I think this thread needs a bump! No vocals, but feel free to sing along :slight_smile:

setcps (96/120)

--organ [lh, rh]
d1 $ note "[<g4 f4 e4@2>, <d5 d5 c5@2>]" # s "superfm" 
    # djf 0.18
    # shape 0.4
    # squiz 0.4

-- drums
d2 $ stack [
    n "0*2 2" # s "cpu"
    , swingBy (0.125) 4 $ n "< [4 16 4 4] [4 4 4 4]!2 [4 4 4 16]>" # s "gretsch"
]

-- guitar
d3 $ stack [ 
    n "<[g5 d6] [g5@1.5 d6@1.5 g6] [~ g5 ~!2] ~>" # s "supermandolin" #
        sustain 3 #
        release 2
    , n "<~!2 [~!3 [c5 d5]] [f5!3 [f5 g5]]>" # s "supermandolin"
]

-- bass
d4 $ note "<[g*2 ~] [f*2 ~] [e*2 ~] [~@1.25 d . e@1.25 d . g . ~ ]>" # s "superfm"
    # cut 1
    # octave 3
2 Likes

I really enjoyed this one, thanks!

just started the course, so i'm super late to everything...
anyways, here is a little 1 min thing i did with the rockwell tune "please please please".
have fun!

p.s.: lovely stuff going on here! cool, that this all exists!

1 Like

NIce idea! A while ago I made this. It is very minimal, and demonstrates slowcat, a.k.a. < .. >. For full effect, first listen to d1 or d2 in isolation, try to guess the song (very hard with d1 or d2 alone, but quite possible with both) and then add the other tracks one after another (d5 last)

setcps(150/60/4)

d1 $ s "superpiano"
  >| n ( "<0.5 0>" ~>  (scale "major" $ slow 6 $ rev $ run 6) )

d2 $ s "superpiano"
  >| n ( "<0 0.75>" ~> "<<c c g4> <e c ~ >>" )

d3 $ s "supersquare"
  >| n ( "c [c6 f] ~ [~ g]" )
  # gain 0.7

d4  $ s "[bd 808cy 808cy bd]*2" # lpf 4000

d5 $ s "supersaw" >| n "<c3*2 c3>"

I find it very strange that I don't even need a vocoder for d5. I guess that's pre-conditioning - the ear/mind knows what to expect.

1 Like

Wow, this is tricky. I can't guess anyone's song XD
Well... here's my attempt at an EDM "classic" hehe

setcps (126/60/4)

d1 $ stack [
  fast 4 $ n "10" # s "superkick"
    |> hcutoff 5000
    |> accelerate 8
    |> size 0.0
    |> room 0.0,
  fast 4 $ n "0" #  s "super808"
    |> size 0.2
    |> room 0.1
    |> gain 1
    |> cutoff 200,
  n "~ 1 ~ 1" # s "clap"
    |> gain 0.9
    |> hcutoff 5000
    |> room 0.1
    |> delay 0.4
]

let chords =  "fs4'maj . a4'maj . [b4, d5, fs5] . [b4, d5, fs5]"
in
d2 $ stack [
  slow 4 $ n chords |> sound "superhammond"
    # attack 0.15
    # voice 0.01
    # resonance 0
    # room 0.8
    # release 4
    # lfo 0.0
    # size 0.95
    # tremdp 0.7
    # tremr 2
    # gain 1
  ]

Very late to the party but as I am still in the phase of intensive learning this can surely be forgiven. This was a fun experiment and again a valuable learning experience (nevertheless it sounds a bit like a questionable midi rendition of a great song).

One of my favorite oldies (to be started one channel after the other):

setcps (140/60/4)

d1 -- snapper
  $ slow 4 $ s "cpu:1"
  >| speed "[4 [4 3.3 4] 3.3 4 3.3 4 3.3 4]!3 [3.3 4 3.3 4 3.3 4 3.3 4]" # gain 1

d2 -- shacker
  $ s "odx:2" >| end "[0.3 [0.3 0.5]]!2" # gain 0.65

d3 -- cowbell
  $ slow 2 $ s "gretsch:6"
  >| speed "1 ~ ~ ~ ~ 1.3 1.3 1 ~ ~ ~ 1 ~ 2.1 2.1 2.1"
  # gain "1 ~ ~ ~ ~ 1 1 1 ~ ~ ~ 1 ~ 0.85 1 0.9"
  # room 0.5 # sz 0.25

d4 -- congas
  $ s "hi:7"
  >| speed "~ 0.9 [~ 0.4] [0.4 0.4]" # gain "~ 0.8 [~ 0.5] [0.5 0.5]"

d5 -- bass
  $ slow 2 $ n "a2 ~ a3 ~ ~ a2 a3 g2 ~ g3 ~ fs3 ~ e3 fs3 e3" # s "supersaw"
  # legato 0.65 # lpf 500 # gain 0.7

d6 -- guitar
  $ slow 2 $ n "~ ~ cs5 d5 [e5, g5] [d5, fs5] ~ [cs5, e5] ~ cs5 fs4 a4   b4 a4 fs4 e4"
  # s "supermandolin" # sustain 3

d7 -- lead
  $ swingBy (1/12) 4 $ slow 8 $ n "~ ~ ~ ~ cs6 d6 ~ e6   ~ fs6 ~ e6 _ _ ~ ~   ~ ~ ~ ~ e6 fs6 ~ g6   ~ a6 ~ e6 _ _ ~ ~   ~ ~ ~ ~ e6 fs6 ~ g6   ~ a6 ~ b6 _ ~ a6 e6   g6 _ e6 d6 e6 _ _ ~  ~!8"
  # s "superfm" # gain 0.65 # room 0.5 # sz 0.75 # attack 0.0125 # release 0.75

The question remains: At least the cowbell and the melody should be played very much laid back. I did experiment with swing but had not yet success. Anyway, nothing can't beat the original...

2 Likes