more tweaks; added a choice of 4 midi notes (to later add more than 1 sound source, so the system can choose between different drum sounds for more variation)

auto-techno.py

@@ -35,10 +35,10 @@ percMidiChanStart = 0
 
 
 # perc note
-# set a static note for percussion tracks
-percNote = 0
+# set some notes for percussion tracks
+percNotes = [0,1,2,3]
 # perc track names
-percNames = ["kick", "hh", "sd", "cp", "?", "?", "bassline", "?", "?"]
+percNames = ["kick", "hh", "sd", "cp", "five"]
 # for use generating sequences of 0's and 1's
 #
 #
@@ -75,6 +75,7 @@ import sys
 import random
 import math
 import re
+import time
 
 
 ##################################################
@@ -83,7 +84,11 @@ import re
 # seeds should be 6 digits or longer
 input = sys.argv[1]
 
+
+### FRONTMATTER ###
 print("-- seed: " + str(input))
+print("-- generated at "+str(time.time()))
+print("")
 
 
 ########### THIS CHANGES EVERYTHING! #############
@@ -91,11 +96,11 @@ print("-- seed: " + str(input))
 random.seed(input)
 ##################################################
 
-indent = "      "
+indent = "  "
 # generate a bpm between lowest and highest
 # looks like: cps = (BPM/60/4)
-bpm = "cps = ("+str(random.randrange(lowestBpm, highestBpm, 1))+"/60/4)"
-print(bpm+"\n")
+bpm = "setcps ("+str(random.randrange(lowestBpm, highestBpm, 1))+"/60/4)"
+#print(bpm)
 
 
 ####################### FUNCTIONS ###################
@@ -130,7 +135,7 @@ def generateBinary(busyness):
         binary = [0,0,1,1,1,1,1,1,1,1,1]
     return binary
 
-def genOnOff(limit,busyness):
+def genOnOff(limit,busyness,struct):
     "generate a series of 0's and 1's"
     zeroesOnes = ""
 
@@ -153,8 +158,14 @@ def genOnOff(limit,busyness):
     #    >>> re.findall('.{1,2}', '123456789')
     #    ['12', '34', '56', '78', '9']
     #zeroesOnes = re.findall('.{1,2}', zeroesOnes)
-    zeroesOnes = "struct \"{"+str(zeroesOnes)+"}%16\""
-    return(zeroesOnes)
+    if (struct == 1):
+        zeroesOnes = "struct \"{"+str(zeroesOnes)+"}%16\""
+        return(zeroesOnes)
+    else:
+        return(zeroesOnes)
+
+
+
 
 def euclid(divider):
     "generate a euclidean rhythm for tidalcycles"
@@ -210,7 +221,7 @@ def offset():
 def every():
     # TODO add a switch to choose divisible by 2/4/8 or not
     bars = random.randint(2,16)
-    return ("$ every "+str(bars)+" ")
+    return (indent+indent+"$ every "+str(bars)+" ")
 
 def scramble():
     divisions = [4,8,16]
@@ -227,7 +238,7 @@ def stut():
     stut REPEATS VOLUME TIME
     """
     # choose how many repeats
-    repeats = random.choice([1,1,1,1,1,1,2,2,2,3,3,3,4,4,4,4,4,45])
+    repeats = random.choice([1,1,1,1,1,1,2,2,2,3,3,3,4,4,4,4,4,5])
     time = random.choice(["1/4","1/8","1/16","1/16","1/16"])
     return("stut "+str(repeats)+" 1 \""+str(time)+"\"")
 
@@ -252,6 +263,26 @@ def bite():
     # we don't need to prepend with $ or ,
     return ("bite "+number+ " \"{"+bit+"}%"+number+"\"")
 
+def offset():
+    offsetChoices = [0.125,0.125,0.125,0.125,0.1875,0.1875,0.1875]
+    return ("("+str(random.choice(offsetChoices))+" ~>)")
+
+
+def fills():
+    """
+    Generate some things that would be cool at the end of phrases,
+    eg whenmod 8 7 (do something)
+    But nothing too intense
+    """
+    # like whenmod 8 7
+    fillChoices = [stut(),"rev",scramble()]
+    # how many filles do we want?
+    fills = ""
+    for i in range(1,10):
+        # roll the dice
+        whenmods = ["8 7","4 3","16 15","16 14","32 31"]
+        fills = str(random.choice(fillChoices))+" "+fills
+        return "whenmod "+str(random.choice(whenmods))+" ("+fills.rstrip()+")"
 
 ########################### LISTS ##########################
 
@@ -267,12 +298,27 @@ cyPats = ["[t*4]","[t*8]","[t~~~]","[t~~[~~~t]]","[<t~~~>~~~]"]
 
 
 ############### It's assemble time!! ###################
+
+print("do")
+#print("")
+
+# create "let" statements
+for i in percNames:
+    #print("let "+i+"M = \"["+genOnOff(4,5,0)+"]\"")
+    print(indent+"let "+i+"M = \"[1111]\"")
+
+#print("")
+
+
 # actually assemble the stack!
-print("p \""+stackName+"\" ")
+print(indent+"p \""+stackName+"\" ")
 
 # stack stuff like bite, scramble, etc. will go here
 
-print("$ whenmod 8 7 (scramble 4)") #
+# roll the dice up to N times
+for i in range(1,8):
+   if (random.randint(0,10) > 4):
+    print(indent+indent+"$ "+fills())
 
 # how many "fun" things to add?
 # a list of things to do to patterns to make them more interesting
@@ -288,7 +334,7 @@ def funThings():
 
         # for each iteration, choose an interestingThing
         # indent + "every N" + ( rev )
-        wholeEnchilada = indent+str(every()+"("+str(random.choice(interestingThings))+")\n"+wholeEnchilada).rstrip()
+        wholeEnchilada = str(every()+"("+str(random.choice(interestingThings))+")\n"+wholeEnchilada).rstrip()
 
         # using "every"
     #return (every()+"("+bite()+")")
@@ -298,12 +344,12 @@ def funThings():
 #funThings()
 
 # the top of the stack
-print("$ stack [")
+print(indent+indent+"$ stack [")
 
 # this is an empty track to make dealing with commas easier
 # just 4 to the floor in case you want it
-print(indent+"-- four to the floor")
-print(indent+"(#gain 0) $ struct \"[t*4]\" $ n \"0\" # midichan 0,")
+print(indent+indent+"-- four to the floor")
+print(indent+indent+"(#gain 0) $ struct \"[t*4]\" $ n \"0\" # midichan 0,")
 
 #print(",struct \"[t*4]\" $ n 0 # midichan 0")
 
@@ -314,20 +360,28 @@ percMidiChan = 0
 ## this is where each "track" is generated
 ## percCount = how many rhythmic (non-melodic) tracks
 ## will be created
-for i in range(percCount):
+for i in percNames:
 
-    print(indent+"-- "+percNames[percMidiChan]+" -----------------")
+    print(indent+indent+"-- "+percNames[percMidiChan]+" -----------------")
 
 
     # this is here so there is the same thing at the start of
     # each new track (so we know "whenmod" for instance always
     # starts with $ and not ,)
-    print(indent+"degradeBy 0 ")
+    #print(indent+indent+"degradeBy 0 ")
+    print(indent+indent+"mask "+i+"M")
 
+    #### FUN STUFF #####
     # insert some funStuff, maybe
-    if (random.randint(0,10) > 2):
+    if (random.randint(0,10) > 8):
       print(funThings())
 
+      #### OFFSET ####
+    if (random.randint(0,10) > 6):
+      print(indent+indent+"$ "+offset())
+
+
+      ##### THE RHYTHMS #####
     # choose between random, hardcoded, or euclidean rhythms
     rChoice = random.choice([0,1,2])
     rhythm = ""
@@ -348,7 +402,7 @@ for i in range(percCount):
         elif (i == 4):
             rhythm = str(random.choice(cyPats))
         else:
-            rhythm = "t*16"
+            rhythm = "t*4"
         rhythm = "struct \""+rhythm+"\""
 
     elif (rChoice == 1):
@@ -365,35 +419,35 @@ for i in range(percCount):
         # choose a random value between 0 and 9
         busyness = random.randrange(0,7)
         generateBinary(busyness)
-        rhythm = str(genOnOff(percLength,busyness))
+        rhythm = str(genOnOff(percLength,busyness,1))
 
     elif (rChoice == 2):
         # GENERATE EUCLIDEAN RHYTHMS
         rhythm = str(euclid(random.choice(dividers)))
-        #print(indent+euclid(random.choice(dividers)))
+        #print(indent+indent+euclid(random.choice(dividers)))
         #
     else:
         rhythm = "struct [t*4]"
 
-    print(indent+"$ "+rhythm)
-    print (indent+"$ n "+str(percNote)+" # midichan "+str(percMidiChan)+",")
+    print(indent+indent+"$ "+rhythm)
+    print (indent+indent+"$ n "+str(random.choice(percNotes))+" # midichan "+str(percMidiChan)+",")
     percMidiChan = percMidiChan + 1
 
 # generate melodic tracks
 melodicMidiChan = melodyMidiChanStart
 #melodyMidiChanStart = 7
 for i in range(melodyCount):
-    print(indent+"-----------------------")
-    print(indent+"degradeBy 0 ")
+    print(indent+indent+"-----------------------")
+    print(indent+indent+"degradeBy 0 ")
     #print(", ")
     busyness = random.choice([0,1,2,3,4,5,6,6,6,6,7,7,7,7,8,8,8,9,9])
     if (oneBar == 1):
-        print(indent+"$ "+genOnOff(16,(busyness)))
-        print(indent+"$ "+genNotes(1))
+        print(indent+indent+"$ "+genOnOff(16,(busyness),1))
+        print(indent+indent+"$ "+genNotes(1))
     else:
         genOnOff(32,(busyness))
-        print(indent+"$ "+genNotes(1))
-    print(indent+"# midichan "+str(melodicMidiChan)+" + n (-36)")
+        print(indent+indent+"$ "+genNotes(1))
+    print(indent+indent+"# midichan "+str(melodicMidiChan)+" + n (-36)")
     melodicMidiChan = melodicMidiChan + 1
 
-print("] # sunvox")
+print(indent+indent+"] # sunvox")

test.tidal

@@ -9,14 +9,21 @@ some seeds I've liked:
 644793890351458335
 803051260356546356
 1061676950143263647
-
 1726268759940563490
 1035561506162950173 -- groovy
-2138151558308434562 -- funky
+231920015948102138 -- funky
+7138151558308434562 -- funky
 
 -- seed: -2138151558308434562
-do
-let cps = (90/60/4)
+
+setcps = (18/60/4)
+
+bpm (100/60/4)
+
+setcps (130/60/4)
+
+hush
+
 p "techno"
 $ whenmod 8 7 (scramble 4)
 $ stack [
@@ -52,3 +59,801 @@ $ stack [
       $ n "{28 15 3 6 21 21 22 16 2 34 9 6 0 35 23 28 }%16"
       # midichan 7 + n (-36)
 ] # sunvox
+
+hush
+
+
+-- seed: -1128205447549990176
+cps = (98/60/4)
+
+p "techno"
+$ whenmod 8 7 (scramble 4)
+$ stack [
+      -- four to the floor
+      (#gain 0) $ struct "[t*4]" $ n "0" # midichan 0,
+      -- kick -----------------
+      $ every 5 (stut 3 1 "1/4")
+      $ every 2 (rev)
+      $ every 2 (rev)
+      $ struct "[t t t t*2]"
+      $ n 0 # midichan 0,
+] # sunvox
+
+d1 $ s "bd"
+
+hush
+
+-- seed: 319200159481021387
+setcps  (94/60/4)
+
+p "techno"
+$ whenmod 8 7 (scramble 4)
+$ stack [
+      -- four to the floor
+      (#gain 0) $ struct "[t*4]" $ n "0" # midichan 0,
+      -- kick -----------------
+      degradeBy 0
+      $ every 8 (rev)
+      $ every 9 (rev)
+      $ every 5 (stut 2 1 "1/4")
+      $ struct "{0000000011100100}%16"
+      $ n 0 # midichan 0,
+      -- hh -----------------
+      degradeBy 0
+      $ struct "[t(3,4)]"
+      $ n 0 # midichan 1,
+      -- sd -----------------
+      degradeBy 0
+      $ every 12 (rev)
+      $ every 13 (rev)
+      $ struct "{0000101001001011}%16"
+      $ n 0 # midichan 2,
+      -- cp -----------------
+      degradeBy 0
+      $ every 13 (stut 2 1 "1/4")
+      $ struct "{0101101100111111}%16"
+      $ n 0 # midichan 3,
+      -- ? -----------------
+      degradeBy 0
+      $ every 13 (scramble 16)
+      $ every 14 (("1/8" ~>))
+      $ every 9 (bite 4 "{1*1 4*1 4*4 3*1 0*1 1*2 4*4 4*1 3*1 3*4 3*4 1*1 }%4")
+      $ struct "[<t~~~>~~~]"
+      $ n 0 # midichan 4,
+      -----------------------
+      degradeBy 0
+      $ struct "{1100101001010010}%16"
+      $ n "{0 7 3 2 3 1 20 11 6 17 5 6 20 16 20 6 }%16"
+      # midichan 7 + n (-36)
+] # sunvox
+
+hush
+
+
+-- seed: -1054995728480467182
+cps = (123/60/4)
+
+p "techno"
+$ whenmod 8 7 (scramble 4)
+$ stack [
+      -- four to the floor
+      (#gain 0) $ struct "[t*4]" $ n "0" # midichan 0,
+      -- kick -----------------
+      degradeBy 0
+      $ (0.125 ~>)
+      $ struct "[t~~~ ~~<~t~~>~ ~~t~ ~<~t>~~]"
+      $ n 0 # midichan 0,
+      -- hh -----------------
+      degradeBy 0
+      $ struct "[t*16]"
+      $ n 0 # midichan 1,
+      -- sd -----------------
+      degradeBy 0
+      $ (0.1875 ~>)
+      $ struct "[[~~~t][~t]]*2"
+      $ n 0 # midichan 2,
+      -- cp -----------------
+      degradeBy 0
+      $ struct "[t(3,8)]"
+      $ n 0 # midichan 3,
+      -- ? -----------------
+      degradeBy 0
+      $ struct "[t*8]"
+      $ n 0 # midichan 4,
+      -----------------------
+      degradeBy 0
+      $ struct "{0111111111101100}%16"
+      $ n "{33 14 2 25 10 23 4 11 11 1 25 7 10 6 8 33 }%16"
+      # midichan 7 + n (-36)
+
+] # sunvox
+
+hush
+
+
+do
+setcps (120)
+let something = "hello"
+d1 $ s "bd"
+
+
+-- seed: 2104142091522455394
+-- generated at 1633463772.53
+
+hush
+-- seed: 197507295067074279
+-- generated at 1633463837.81
+
+-- seed: 485348289655373702
+-- generated at 1633463949.6
+-- seed: -1703565451078464692
+-- generated at 1633464313.44
+
+do
+p "techno"
+$ whenmod 2 1 (bite 4 "0 0 0 4")
+$ stack [
+      -- four to the floor
+      (#gain 0) $ struct "[t*4]" $ n "0" # midichan 0,
+      -- kick -----------------
+      degradeBy 0
+      $ every 8 (scramble 16)
+      $ every 10 ((0.1875 ~>))
+      $ every 14 (rev)
+      $ struct "[t*4]"
+      $ n 0 # midichan 0,
+      -- hh -----------------
+      degradeBy 0
+      $ struct "[t(4,8)]"
+      $ n 0 # midichan 1,
+      -- sd -----------------
+      degradeBy 0
+      $ struct "[t(4,8)]"
+      $ n 0 # midichan 2,
+      -- cp -----------------
+      degradeBy 0
+      $ struct "{0010000000000000}%16"
+      $ n 0 # midichan 3,
+      -- ? -----------------
+      degradeBy 0
+      $ struct "{0000100010000000}%16"
+      $ n 0 # midichan 4,
+      -----------------------
+      degradeBy 0
+      $ struct "{1111101101111110}%16"
+      $ n "{20 20 1 0 10 8 5 8 25 0 9 23 21 30 8 9 }%8"
+      # midichan 7 + n (-36)
+] # sunvox
+-- seed: 563969774834715115
+-- generated at 1633465467.85
+
+
+
+-- seed: 456859454801594881
+-- generated at 1633467293.87
+hush
+
+
+
+
+
+
+do
+        let hello = "[t*8]"
+        p "techno" $ stack [
+        struct hello $ s "bd"
+                        ]
+
+-- seed: 315014084723179620
+-- generated at 1633467476.05
+
+
+hush
+-- seed: 412835948404765370
+-- generated at 1633467827.68
+
+do
+let kickM = "[1]"
+let hhM = "[0111]"
+let sdM = "[1100]"
+let cpM = "[1110]"
+let fiveM = "[1011]"
+let sixM = "[1100]"
+let basslineM = "[1011]"
+let eightM = "[1000]"
+let nineM = "[1000]"
+p "techno"
+$ whenmod 32 31 (bite 4 "{2*2 2*1 1*4 3*4 2*4 2*1 1*1 3*2 }%4")
+$ whenmod 16 15 (stut 3 1 "1/16")
+$ whenmod 8 7 (scramble 16)
+$ whenmod 16 15 (stut 1 1 "1/16")
+$ whenmod 32 31 (scramble 16)
+$ whenmod 16 15 (scramble 4)
+$ stack [
+        -- four to the floor
+        (#gain 0) $ struct "[t*4]" $ n "0" # midichan 0,
+        -- kick -----------------
+        mask "[0]"
+        $ (0.1875 ~>)
+        $ struct "{1011000100100100}%16"
+        $ n 0 # midichan 0,
+        -- hh -----------------
+        mask hhM
+        $ (0.1875 ~>)
+        $ struct "t*16"
+        $ n 0 # midichan 1,
+        -- sd -----------------
+        mask sdM
+        $ every 12 (rev)
+        $ every 2 (bite 4 "{2*1 0*2 4*2 1*1 }%4")
+        $ every 7 (rev)
+        $ (0.125 ~>)
+        $ struct "t*16"
+        $ n 0 # midichan 2,
+        -- cp -----------------
+        mask cpM
+        $ (0.1875 ~>)
+        $ struct "[t(2,4)]"
+        $ n 0 # midichan 3,
+        -- five -----------------
+        mask fiveM
+        $ struct "{1010010001001000}%16"
+        $ n 0 # midichan 4,
+        -- six -----------------
+        mask sixM
+        $ struct "t*16"
+        $ n 0 # midichan 5,
+        -- bassline -----------------
+        mask basslineM
+        $ struct "t*16"
+        $ n 0 # midichan 6,
+        -- eight -----------------
+        mask eightM
+        $ (0.1875 ~>)
+        $ struct "[t(11,16)]"
+        $ n 0 # midichan 7,
+        -- nine -----------------
+        mask nineM
+        $ (0.125 ~>)
+        $ struct "{0010001011101101}%16"
+        $ n 0 # midichan 8,
+        -----------------------
+        degradeBy 0
+        $ struct "{1110100111101110}%16"
+        $ n "{8 18 18 34 8 34 0 17 13 3 4 7 4 17 1 0 }%16"
+        # midichan 7 + n (-36)
+] # sunvox
+
+
+
+-- seed: -944805744933000927
+-- generated at 1633468178.51
+
+-- seed: -639917386321814739
+-- generated at 1633468248.95
+
+do
+let kickM = "[0001]"
+let hhM = "[0001]"
+let sdM = "[1110]"
+let cpM = "[0010]"
+let fiveM = "[0111]"
+let sixM = "[0011]"
+let basslineM = "[0011]"
+let eightM = "[1110]"
+let nineM = "[1001]"
+  p "techno"
+  $ whenmod 16 15 (scramble 8)
+  $ whenmod 16 15 (bite 4 "{1*2 1*4 1*2 2*4 0*2 4*2 0*1 2*1 2*2 3*4 3*2 1*4 }%4")
+  $ whenmod 8 7 (stut 4 1 "1/16")
+  $ whenmod 4 3 (scramble 8)
+  $ stack [
+    -- four to the floor
+    (#gain 0) $ struct "[t*4]" $ n "0" # midichan 0,
+    -- kick -----------------
+    mask kickM
+    $ struct "t*16"
+    $ n 0 # midichan 0,
+    -- hh -----------------
+    mask hhM
+    $ (0.1875 ~>)
+    $ struct "[t(7,8)]"
+    $ n 0 # midichan 1,
+    -- sd -----------------
+    mask sdM
+    $ (0.125 ~>)
+    $ struct "{1011011100011100}%16"
+    $ n 0 # midichan 2,
+    -- cp -----------------
+    mask cpM
+    $ (0.125 ~>)
+    $ struct "[t(15,16)]"
+    $ n 0 # midichan 3,
+    -- five -----------------
+    mask fiveM
+    $ struct "t*16"
+    $ n 0 # midichan 4,
+    -- six -----------------
+    mask sixM
+    $ every 13 (stut 2 1 "1/16")
+    $ every 5 (rev)
+    $ every 9 ((0.1875 ~>))
+    $ (0.1875 ~>)
+    $ struct "{0111100111000101}%16"
+    $ n 0 # midichan 5,
+    -- bassline -----------------
+    mask basslineM
+    $ (0.125 ~>)
+    $ struct "t*16"
+    $ n 0 # midichan 6,
+    -- eight -----------------
+    mask eightM
+    $ every 10 (stut 2 1 "1/16")
+    $ every 15 ((0.1875 ~>))
+    $ struct "t*16"
+    $ n 0 # midichan 7,
+    -- nine -----------------
+    mask nineM
+    $ struct "[t(3,4)]"
+    $ n 0 # midichan 8,
+    -----------------------
+    degradeBy 0
+    $ struct "{0001100111101001}%16"
+    $ n "{4 21 12 15 2 16 5 22 8 20 4 8 1 23 14 27 }%8"
+    # midichan 7 + n (-36)
+  ] # sunvox
+
+
+-- seed: -1022362753540599887
+-- generated at 1633468290.41
+
+do
+let kickM = "[1101]"
+let hhM = "[1001]"
+let sdM = "[1110]"
+let cpM = "[0111]"
+let fiveM = "[1010]"
+let sixM = "[1100]"
+let basslineM = "[1110]"
+let eightM = "[1100]"
+let nineM = "[1000]"
+Traceback (most recent call last):
+  File "/home/chris/tidal-auto-techno/auto-techno.py", line 313, in <module>
+    print(+"p \""+stackName+"\" ")
+TypeError: bad operand type for unary +: 'str'
+
+
+-- seed: -1667571548371307357
+-- generated at 1633468363.94
+
+hush
+-- seed: -1728339397765061981
+-- generated at 1633468433.83
+
+do
+let kickM = "[1111]"
+let hhM = "[1111]"
+let sdM = "[1111]"
+let cpM = "[1111]"
+let fiveM = "[1111]"
+let sixM = "[1111]"
+let basslineM = "[1111]"
+let eightM = "[1111]"
+let nineM = "[1111]"
+p "techno"
+  $ whenmod 16 14 (scramble 4)
+  $ whenmod 16 15 (bite 4 "{2*1 4*4 1*1 1*4 3*2 0*2 4*2 2*1 }%4")
+  $ stack [
+    -- four to the floor
+    (#gain 0) $ struct "[t*4]" $ n "0" # midichan 0,
+    -- kick -----------------
+    mask kickM
+    $ (0.1875 ~>)
+    $ struct "[t(4,8)]"
+    $ n 0 # midichan 0,
+    -- hh -----------------
+    mask hhM
+    $ every 14 (rev)
+    $ every 15 (bite 4 "{0*4 2*4 4*2 2*4 2*2 1*1 4*2 0*2 1*2 4*4 3*1 2*1 2*1 0*1 0*2 0*4 }%4")
+    $ every 6 (stut 1 1 "1/16")
+    $ (0.1875 ~>)
+    $ struct "{0001000000000000}%16"
+    $ n 0 # midichan 1,
+    -- sd -----------------
+    mask sdM
+    $ (0.125 ~>)
+    $ struct "t*16"
+    $ n 0 # midichan 2,
+    -- cp -----------------
+    mask cpM
+    $ (0.1875 ~>)
+    $ struct "[t(5,16)]"
+    $ n 0 # midichan 3,
+    -- five -----------------
+    mask fiveM
+    $ struct "{0101010100000101}%16"
+    $ n 0 # midichan 4,
+    -- six -----------------
+    mask sixM
+    $ struct "{1101001011110010}%16"
+    $ n 0 # midichan 5,
+    -- bassline -----------------
+    mask basslineM
+    $ struct "[t(2,4)]"
+    $ n 0 # midichan 6,
+    -- eight -----------------
+    mask eightM
+    $ every 14 (scramble 8)
+    $ struct "[t(7,8)]"
+    $ n 0 # midichan 7,
+    -- nine -----------------
+    mask nineM
+    $ struct "{0010000000000000}%16"
+    $ n 0 # midichan 8,
+    -----------------------
+    degradeBy 0
+    $ struct "{0110110101100110}%16"
+    $ n "{19 0 15 19 15 19 14 34 23 0 5 10 13 23 17 16 }%16"
+    # midichan 7 + n (-36)
+  ] # sunvox
+
+
+-- seed: -925754403333800332
+-- generated at 1633468492.63
+
+do
+let kickM = "[1111]"
+let hhM = "[1111]"
+let sdM = "[1111]"
+let cpM = "[1111]"
+let fiveM = "[1111]"
+let sixM = "[1111]"
+let basslineM = "[1111]"
+let eightM = "[1111]"
+let nineM = "[1111]"
+p "techno"
+$ whenmod 8 7 (scramble 16)
+$ whenmod 16 15 (rev)
+$ whenmod 16 15 (stut 3 1 "1/16")
+$ whenmod 16 15 (bite 4 "{4*1 3*4 0*4 4*1 3*1 1*1 2*2 0*4 3*4 }%4")
+$ whenmod 32 31 (scramble 8)
+  $ stack [
+    -- four to the floor
+    (#gain 0) $ struct "[t*4]" $ n "0" # midichan 0,
+    -- kick -----------------
+    mask kickM
+    $ struct "[t(3,4)]"
+    $ n 0 # midichan 0,
+    -- hh -----------------
+    mask hhM
+  $ every 13 (stut 1 1 "1/8")
+  $ every 5 (bite 8 "{2*4 7*4 6*2 5*2 2*4 2*2 8*1 2*1 0*1 6*1 1*2 5*1 0*2 6*2 7*2 6*2 }%8")
+    $ struct "[t(2,4)]"
+    $ n 0 # midichan 1,
+    -- sd -----------------
+    mask sdM
+    $ (0.125 ~>)
+    $ struct "[t(6,8)]"
+    $ n 0 # midichan 2,
+    -- cp -----------------
+    mask cpM
+    $ struct "t*16"
+    $ n 0 # midichan 3,
+    -- five -----------------
+    mask fiveM
+    $ (0.1875 ~>)
+    $ struct "[t(4,8)]"
+    $ n 0 # midichan 4,
+    -- six -----------------
+    mask sixM
+    $ struct "t*16"
+    $ n 0 # midichan 5,
+    -- bassline -----------------
+    mask basslineM
+    $ struct "[t(9,16)]"
+    $ n 0 # midichan 6,
+    -- eight -----------------
+    mask eightM
+    $ (0.1875 ~>)
+    $ struct "[t(2,16)]"
+    $ n 0 # midichan 7,
+    -- nine -----------------
+    mask nineM
+    $ (0.125 ~>)
+    $ struct "t*16"
+    $ n 0 # midichan 8,
+    -----------------------
+    degradeBy 0
+    $ struct "{0011101101100110}%16"
+    $ n "{8 34 9 4 9 0 10 15 30 7 29 18 18 20 19 27 }%8"
+    # midichan 7 + n (-36)
+  ] # sunvox
+
+
+-- seed: -296151779328239296
+-- generated at 1633468506.28
+
+do
+let kickM = "[1111]"
+let hhM = "[1111]"
+let sdM = "[1111]"
+let cpM = "[1111]"
+let fiveM = "[1111]"
+let sixM = "[1111]"
+let basslineM = "[1111]"
+let eightM = "[1111]"
+let nineM = "[1111]"
+p "techno"
+$ whenmod 8 7 (scramble 8)
+$ whenmod 32 31 (scramble 4)
+$ whenmod 4 3 (scramble 8)
+$ whenmod 8 7 (bite 8 "{0*2 6*1 8*2 2*1 8*2 7*1 6*1 2*1 3*4 }%8")
+$ whenmod 16 15 (stut 2 1 "1/16")
+$ whenmod 8 7 (rev)
+  $ stack [
+    -- four to the floor
+    (#gain 0) $ struct "[t*4]" $ n "0" # midichan 0,
+    -- kick -----------------
+    mask kickM
+    $ (0.1875 ~>)
+    $ struct "t*16"
+    $ n 0 # midichan 0,
+    -- hh -----------------
+    mask hhM
+  $ every 9 (bite 8 "{1*4 3*4 3*1 5*2 5*1 3*4 8*2 3*2 7*2 4*4 6*4 6*2 7*2 0*2 0*4 }%8")
+    $ (0.1875 ~>)
+    $ struct "{1111001000001110}%16"
+    $ n 0 # midichan 1,
+    -- sd -----------------
+    mask sdM
+    $ struct "[t(12,16)]"
+    $ n 0 # midichan 2,
+    -- cp -----------------
+    mask cpM
+    $ (0.125 ~>)
+    $ struct "[t(15,16)]"
+    $ n 0 # midichan 3,
+    -- five -----------------
+    mask fiveM
+    $ (0.125 ~>)
+    $ struct "t*16"
+    $ n 0 # midichan 4,
+    -- six -----------------
+    mask sixM
+    $ (0.125 ~>)
+    $ struct "[t(2,8)]"
+    $ n 0 # midichan 5,
+    -- bassline -----------------
+    mask basslineM
+    $ struct "[t(7,16)]"
+    $ n 0 # midichan 6,
+    -- eight -----------------
+    mask eightM
+    $ struct "t*16"
+    $ n 0 # midichan 7,
+    -- nine -----------------
+    mask nineM
+    $ struct "t*16"
+    $ n 0 # midichan 8,
+    -----------------------
+    degradeBy 0
+    $ struct "{0101010011101010}%16"
+    $ n "{0 8 0 6 10 8 6 9 4 18 6 4 1 6 35 30 }%8"
+    # midichan 7 + n (-36)
+  ] # sunvox
+
+
+-- seed: -863274151192537696
+-- generated at 1633468522.75
+
+do
+let kickM = "[1111]"
+let hhM = "[1111]"
+let sdM = "[1111]"
+let cpM = "[1111]"
+let fiveM = "[1111]"
+let sixM = "[1111]"
+let basslineM = "[1111]"
+let eightM = "[1111]"
+let nineM = "[1111]"
+p "techno"
+$ whenmod 4 3 (scramble 4)
+$ whenmod 16 14 (bite 8 "{7*4 1*2 7*4 8*2 4*2 5*2 2*4 0*2 7*1 8*4 4*4 1*1 7*2 5*1 2*2 }%8")
+$ whenmod 32 31 (stut 3 1 "1/16")
+$ whenmod 16 15 (stut 1 1 "1/16")
+$ whenmod 8 7 (rev)
+$ whenmod 32 31 (stut 1 1 "1/16")
+  $ stack [
+    -- four to the floor
+    (#gain 0) $ struct "[t*4]" $ n "0" # midichan 0,
+    -- kick -----------------
+    mask kickM
+    $ struct "t*16"
+    $ n 0 # midichan 0,
+    -- hh -----------------
+    mask hhM
+    $ struct "{0001100001001011}%16"
+    $ n 0 # midichan 1,
+    -- sd -----------------
+    mask sdM
+    $ (0.125 ~>)
+    $ struct "{0000000010000000}%16"
+    $ n 0 # midichan 2,
+    -- cp -----------------
+    mask cpM
+    $ (0.1875 ~>)
+    $ struct "[t(3,4)]"
+    $ n 0 # midichan 3,
+    -- five -----------------
+    mask fiveM
+    $ struct "[t(14,16)]"
+    $ n 0 # midichan 4,
+    -- six -----------------
+    mask sixM
+  $ every 4 (scramble 8)
+  $ every 12 (rev)
+    $ struct "{1011110000111001}%16"
+    $ n 0 # midichan 5,
+    -- bassline -----------------
+    mask basslineM
+    $ (0.125 ~>)
+    $ struct "[t(2,4)]"
+    $ n 0 # midichan 6,
+    -- eight -----------------
+    mask eightM
+    $ struct "[t(7,8)]"
+    $ n 0 # midichan 7,
+    -- nine -----------------
+    mask nineM
+    $ struct "{0010000000000100}%16"
+    $ n 0 # midichan 8,
+    -----------------------
+    degradeBy 0
+    $ struct "{0111001111011110}%16"
+    $ n "{1 5 26 24 6 4 35 21 5 8 30 11 6 1 15 5 }%16"
+    # midichan 7 + n (-36)
+  ] # sunvox
+
+-- seed: -1900899368135846569
+-- generated at 1633468554.75
+
+do
+let kickM = "[0]"
+let hhM = "[1111]"
+let sdM = "[1111]"
+let cpM = "[1111]"
+let fiveM = "[1111]"
+let sixM = "[1111]"
+let basslineM = "[1111]"
+let eightM = "[1111]"
+let nineM = "[1111]"
+p "techno"
+$ whenmod 16 15 (stut 1 1 "1/16")
+$ whenmod 8 7 (scramble 16)
+$ whenmod 4 3 (scramble 8)
+$ whenmod 4 3 (scramble 8)
+$ whenmod 32 31 (rev)
+  $ stack [
+    -- four to the floor
+    (#gain 0) $ struct "[t*4]" $ n "0" # midichan 0,
+    -- kick -----------------
+    mask kickM
+  $ every 9 (stut 3 1 "1/8")
+    $ struct "{1000101110111001}%16"
+    $ n 0 # midichan 0,
+    -- hh -----------------
+    mask hhM
+    $ struct "{0000000000000000}%16"
+    $ n 0 # midichan 1,
+    -- sd -----------------
+    mask sdM
+  $ every 8 (bite 4 "{2*1 4*2 0*1 3*2 3*4 0*4 0*4 }%4")
+  $ every 4 (bite 4 "{2*1 4*2 0*1 3*2 3*4 0*4 0*4 }%4")
+    $ (0.125 ~>)
+    $ struct "[t(3,4)]"
+    $ n 0 # midichan 2,
+    -- cp -----------------
+    mask cpM
+  $ every 5 ((0.125 ~>))
+  $ every 16 ((0.125 ~>))
+    $ struct "{0000010000000101}%16"
+    $ n 0 # midichan 3,
+    -- five -----------------
+    mask fiveM
+    $ struct "{0000000000000100}%16"
+    $ n 0 # midichan 4,
+    -- six -----------------
+    mask sixM
+  $ every 5 (scramble 4)
+    $ struct "t*4"
+    $ n 0 # midichan 5,
+    -- bassline -----------------
+    mask basslineM
+    $ struct "[t(5,8)]"
+    $ n 0 # midichan 6,
+    -- eight -----------------
+    mask eightM
+    $ struct "t*4"
+    $ n 0 # midichan 7,
+    -- nine -----------------
+    mask nineM
+    $ struct "t*4"
+    $ n 0 # midichan 8,
+    -----------------------
+    degradeBy 0
+    $ struct "{0111111111111111}%16"
+    $ n "{5 9 6 7 6 22 22 22 13 2 3 7 10 16 24 8 }%16"
+    # midichan 7 + n (-36)
+  ] # sunvox
+
+
+-- seed: 221325860405508199
+-- generated at 1633468703.57
+
+do
+let kickM = "[0]"
+let hhM = "[1111]"
+let sdM = "[1111]"
+let cpM = "[1111]"
+let fiveM = "[1111]"
+let sixM = "[1111]"
+let basslineM = "[1111]"
+let eightM = "[1111]"
+let nineM = "[1111]"
+p "techno"
+$ whenmod 4 3 (bite 8 "{8*2 4*4 1*2 3*4 5*4 5*4 4*2 5*1 6*1 7*4 }%8")
+$ whenmod 16 14 (bite 8 "{2*2 3*2 0*1 5*2 }%8")
+$ whenmod 8 7 (stut 4 1 "1/16")
+$ whenmod 16 14 (scramble 8)
+$ whenmod 4 3 (bite 4 "{1*2 1*1 1*1 1*4 3*2 3*2 1*2 4*4 3*2 3*4 2*4 }%4")
+$ stack [
+    -- four to the floor
+    (#gain 0) $ struct "[t*4]" $ n "0" # midichan 0,
+    -- kick -----------------
+    mask kickM
+    $ struct "[t(14,16)]"
+    $ n 0 # midichan 0,
+    -- hh -----------------
+    mask hhM
+  $ every 3 (scramble 4)
+    $ struct "{1000100000001010}%16"
+    $ n 0 # midichan 1,
+    -- sd -----------------
+    mask sdM
+  $ every 12 (bite 4 "{2*4 1*1 3*1 3*2 0*2 4*2 }%4")
+  $ every 10 (scramble 4)
+    $ struct "{0000101000000010}%16"
+    $ n 0 # midichan 2,
+    -- cp -----------------
+    mask cpM
+    $ struct "[t(3,4)]"
+    $ n 0 # midichan 3,
+    -- five -----------------
+    mask fiveM
+    $ (0.1875 ~>)
+    $ struct "{0000000000000100}%16"
+    $ n 0 # midichan 4,
+    -- six -----------------
+    mask sixM
+    $ struct "{0000000001000110}%16"
+    $ n 0 # midichan 5,
+    -- bassline -----------------
+    mask basslineM
+    $ struct "{0101011011010001}%16"
+    $ n 0 # midichan 6,
+    -- eight -----------------
+    mask eightM
+    $ struct "{0011111011101100}%16"
+    $ n 0 # midichan 7,
+    -- nine -----------------
+    mask nineM
+  $ every 11 (stut 1 1 "1/16")
+    $ (0.125 ~>)
+    $ struct "{0110010001110101}%16"
+    $ n 0 # midichan 8,
+    -----------------------
+    degradeBy 0
+    $ struct "{0011101011110111}%16"
+    $ n "{8 19 11 33 8 8 10 18 2 8 3 2 17 8 8 1 }%8"
+    # midichan 7 + n (-36)
+  ] # sunvox