added 'degradeBy 0.XX' to funStuff()

auto-techno.py

@@ -1,4 +1,8 @@
 #!/usr/bin/env python3
+scriptName = "Auto-Techno Generator"
+version = 0.1
+author = "Chris Beckstrom"
+author_email = "chris@chrisbeckstrom.com"
 # a deterministic techno generator for tidalcycles
 # input an integer value as a seed
 # and it spits out some techno ready to play
@@ -17,7 +21,7 @@ lowestBpm = 92
 highestBpm = 135
 
 # force everything to happen within 1 bar
-oneBar = 1
+oneBar = 0
 
 # stack name
 # this doesn't matter, can be any string
@@ -27,7 +31,8 @@ stackName = "techno"
 ####### PERCUSSION ##############################
 # for euclidean rhythms, define the choices for the 2nd number
 # eg "[t(3,NN)]"
-dividers = [4,8,16]
+#dividers = [4,8,16]
+dividers = [16]
 # how many percussive/rhythmic elements to generate?
 percCount = 5
 percMidiChanStart = 0
@@ -38,7 +43,8 @@ percMidiChanStart = 0
 # set some notes for percussion tracks
 percNotes = [0,1,2,3]
 # perc track names
-percNames = ["kick", "hh", "sd", "cp", "five"]
+# a percussion track will be generated for each item in this list
+percNames = ["kick", "hh", "sd", "cp", "ohh","ride","cymbal"]
 # for use generating sequences of 0's and 1's
 #
 #
@@ -54,8 +60,8 @@ percNames = ["kick", "hh", "sd", "cp", "five"]
 noteRange = [12,24,36]
 # define the shortest and longest sequence you want
 # eg if shortest is 7, there will be no melodic sequences shorter than 7
-shortestMelodic = 4
-longestMelodic = 16
+shortestMelodic = 3
+longestMelodic = 10
 
 # for melodic lines, what divisions do you want to choose from?
 # eg 4 = quarter notes, 8 = eighth notes
@@ -76,24 +82,57 @@ import random
 import math
 import re
 import time
+import decimal
+from decimal import Decimal
 
 
 ##################################################
 # this is the 1st argument given via command line
 # this is used to calculate everything
-# seeds should be 6 digits or longer
-input = sys.argv[1]
-
+rawinput = sys.argv[1]
+
+# let's assume it's a hex value
+# convert to decimal
+#input = int(hex,int(89))
+
+
+################ SEED HEX #####################
+# make sure the seed is a hex value
+# why? it doesn't really matter technically
+# I just think it would be cool
+# plus, hex values for long numbers are shorter
+# and easier to read/type
+# and might be good track names
+# TODO - this is in progress
+# if the input is a hex value, we'll know because it starts with 0x
+if (rawinput.startswith("0x")):
+    # the input is a hex number
+    #print("string starts with 0x")
+    seed = rawinput.upper()
+else:
+    # the input is NOT a hex number
+    # convert to a hex number
+    seed = hex(int(rawinput)).upper()
+
+# by now the seed should start with 0X
+# let's change that X to lowercase
+seed = seed.replace("X","x")
+#print("seed: "+seed)
+
+decimalSeed = int(seed,16)
 
 ### FRONTMATTER ###
-print("-- seed: " + str(input))
+print("-- raw input: " + str(rawinput))
+print("-- hex seed: "+seed)
+print("-- decimal seed: "+str(decimalSeed))
 print("-- generated at "+str(time.time()))
+print("-- "+scriptName+" v"+str(version))
 print("")
 
 
 ########### THIS CHANGES EVERYTHING! #############
 # set the random seed based on user input
-random.seed(input)
+random.seed(decimalSeed)
 ##################################################
 
 indent = "  "
@@ -104,6 +143,7 @@ bpm = "setcps ("+str(random.randrange(lowestBpm, highestBpm, 1))+"/60/4)"
 
 
 ####################### FUNCTIONS ###################
+
 def generateBinary(busyness):
     """
     busy-ness (sic)
@@ -159,7 +199,8 @@ def genOnOff(limit,busyness,struct):
     #    ['12', '34', '56', '78', '9']
     #zeroesOnes = re.findall('.{1,2}', zeroesOnes)
     if (struct == 1):
-        zeroesOnes = "struct \"{"+str(zeroesOnes)+"}%16\""
+        #zeroesOnes = "struct \"{"+str(zeroesOnes)+"}%16\""
+        zeroesOnes = "[{"+str(zeroesOnes)+"}%16]"
         return(zeroesOnes)
     else:
         return(zeroesOnes)
@@ -194,7 +235,8 @@ def euclid(divider):
             secondEuclid =  "<"+str(random.choice(dividers))+" "+str(random.choice(dividers))+">"
             # [t(<3 8>,16)]
 
-    return ("struct \"[t("+str(firstEuclid)+","+str(secondEuclid)+")]\"")
+    #return ("struct \"[t("+str(firstEuclid)+","+str(secondEuclid)+")]\"")
+    return ("[t("+str(firstEuclid)+","+str(secondEuclid)+")]")
 
 def genNotes(melodicOneBar):
     """
@@ -212,7 +254,7 @@ def genNotes(melodicOneBar):
     melody = ""
     for i in range(melodyLength):
         melody = str(random.randrange(0,random.choice(noteRange))) + " " + str(melody)
-    return ("n "+"\"{"+melody+"}%"+str(random.choice(melodicDivisions))+"\"")
+    return ("n "+"\"[{"+melody+"}%"+str(random.choice(melodicDivisions))+"]\"")
 
 def offset():
     amounts = ["1/4","1/8","1/16","1/16","1/16"]
@@ -223,6 +265,13 @@ def every():
     bars = random.randint(2,16)
     return (indent+indent+"$ every "+str(bars)+" ")
 
+
+def within():
+    firstnum = random.choice([0,0.25,0.5,0.75])
+    secondnum = random.choice([0.25,0.5,0.75,1])
+    return (indent+indent+"within ("+str(firstnum)+","+str(secondnum)+" ")
+
+
 def scramble():
     divisions = [4,8,16]
     return ("scramble "+str(random.choice(divisions)))
@@ -239,7 +288,7 @@ def stut():
     """
     # choose how many repeats
     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"])
+    time = random.choice([0.125,0.125,0.125,0.0625,0.0625])
     return("stut "+str(repeats)+" 1 \""+str(time)+"\"")
 
 def bite():
@@ -253,7 +302,7 @@ def bite():
     # generate like 1*4 8*4 2*2 1*2 9*1
     repeatChoices = [1,2,4]
     # how long should it be?
-    length = int(random.randint(4,16))
+    length = int(random.randint(4,8))
     bit = ""
     for i in range(length):
        bit = str(random.randint(0,int(number)))+"*"+str(random.choice(repeatChoices))+" "+bit
@@ -267,6 +316,9 @@ def offset():
     offsetChoices = [0.125,0.125,0.125,0.125,0.1875,0.1875,0.1875]
     return ("("+str(random.choice(offsetChoices))+" ~>)")
 
+def degrade():
+    degradeAmt = (decimal.Decimal(random.random())).quantize(Decimal('.01'))
+    return "degradeBy "+str(degradeAmt)
 
 def fills():
     """
@@ -280,22 +332,41 @@ def fills():
     fills = ""
     for i in range(1,10):
         # roll the dice
-        whenmods = ["8 7","4 3","16 15","16 14","32 31"]
+        whenmods = ["8 7","16 15","16 14","32 31","64 62","64 63","32 30"]
         fills = str(random.choice(fillChoices))+" "+fills
         return "whenmod "+str(random.choice(whenmods))+" ("+fills.rstrip()+")"
 
+def sometimesBeQuiet():
+    """
+    Generate a gain pattern so that sometimes a track
+    is silent, and other times it isn't
+    """
+    #def genOnOff(limit,busyness,struct):
+    # decide whether to do this at all
+    if (random.randint(0,10) > 5):
+        # for now, 8 bar phrases
+        # (# gain "[0 1 0 0 1]/8")
+        # how many cycles to make?
+        quietCycles = random.choice([2,3,4])
+        quietBinary = genOnOff(quietCycles,2,0)
+        # split 001001 into 0 0 1 0 0 1
+        quietBinary = list(quietBinary)
+        finalQuietBinary =  ""
+        for i in quietBinary:
+            finalQuietBinary = i + " " + finalQuietBinary
+        print(indent+indent+"$ degradeBy \"<"+str(finalQuietBinary).rstrip()+">/8\"")
+
 ########################### LISTS ##########################
 
 # a collection of typical-ish kick drum patterns
-bdPats= ["[t*4]","[t t t t*2]","[t t t t*2?]","t(3,8)","[t~~~ ~~<~t~~>~ ~~t~ ~<~t>~~]"]
-hhPats= ["[t*16]","[t t*2]*4", "[~t]*4","[t*16]"]
-sdPats= ["[~ t]*2","[t(3,8)]","[[~~~t][~t]]*2"]
-cpPats= ["[~ t]*2","[t(3,8)]","[[~~~t][~t]]*2"]
-cyPats = ["[t*4]","[t*8]","[t~~~]","[t~~[~~~t]]","[<t~~~>~~~]"]
-
-
-
+bdPats=["[t*4]","[tttt*2]","[tttt*2?]","t(3,8)","[t~~~~~<~t~~>~~~t~~<~t>~~]"]
+hhPats=["[t*16]","[tt*2]*4","[~t]*4","[t*16]"]
+sdPats=["[~t]*2","[t(3,8)]","[[~~~t][~t]]*2"]
+cpPats=["[~t]*2","[t(3,8)]","[[~~~t][~t]]*2"]
+cyPats=["[t*4]","[t*8]","[t~~~]","[t~~[~~~t]]","[<t~~~>~~~]"]
 
+# a collection of misc rhythms
+rhythmLibrary = ["[1*4]","[1*8]","[1*9]","[01]*2","[0101]","[1*16]","[1*16?]","[111111[1001][01]]/2","[{100}%16]","[{101011010101}%16]","[{10100}%16]","[{10001}%16]","[{10101}%16]","[{1001010}%16]","[{1011010}%16]","[{10101000100}%16]","[{10101001010}%16]","[{10010010010}%16]","[{1010101001010}%16]","[{1001001001010}%16]","[11*2]*4","[100000<0100>000100<01>00]","[1[10000001]]","[1111*2]","[[0001][01]]*2","[0010000100000001]","[[0001][01]]*2","[[01]1[1001][01]]","[[01]1[1001][0001]]","[11000010]*2","[[0001]000]","[[0001]]*4"]
 
 ############### It's assemble time!! ###################
 
@@ -303,9 +374,11 @@ print("do")
 #print("")
 
 # create "let" statements
+print(indent+"let fourToTheFloor = 0")
+print(indent+"    -- control density per track")
 for i in percNames:
     #print("let "+i+"M = \"["+genOnOff(4,5,0)+"]\"")
-    print(indent+"let "+i+"M = \"[1111]\"")
+    print(indent+"    "+i+"M = \"[1111]\"")
 
 #print("")
 
@@ -314,7 +387,7 @@ for i in percNames:
 print(indent+"p \""+stackName+"\" ")
 
 # stack stuff like bite, scramble, etc. will go here
-
+print(indent+indent+"-- fills")
 # roll the dice up to N times
 for i in range(1,8):
    if (random.randint(0,10) > 4):
@@ -323,7 +396,8 @@ for i in range(1,8):
 # how many "fun" things to add?
 # a list of things to do to patterns to make them more interesting
 # these happen BEFORE  struct, note, etc.
-interestingThings = [stut(),bite(),"rev",scramble(),offset()]
+#interestingThings = [stut(),bite(),"rev",scramble(),offset()]
+interestingThings = [stut(),"rev",scramble(),offset(),degrade()]
 def funThings():
     wholeEnchilada = ""
     # add between 1 and 4 "fun" things
@@ -335,25 +409,18 @@ def funThings():
         # for each iteration, choose an interestingThing
         # indent + "every N" + ( rev )
         wholeEnchilada = str(every()+"("+str(random.choice(interestingThings))+")\n"+wholeEnchilada).rstrip()
-
-        # using "every"
-    #return (every()+"("+bite()+")")
     return wholeEnchilada
 
-# uncomment this for some wildness
-#funThings()
-
 # the top of the 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+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")
+print(indent+indent+"degradeBy fourToTheFloor $ struct \"[t*4]\" $ n \"0\" # midichan 0,")
 
 # generate rhythm tracks
+# set the starting midi channel
 percMidiChan = 0
 
 ########################################################
@@ -362,74 +429,98 @@ percMidiChan = 0
 ## will be created
 for i in percNames:
 
-    print(indent+indent+"-- "+percNames[percMidiChan]+" -----------------")
-
+    # print the name of the track (from the percNames list)
+    print(indent+indent+"-------------- "+i+" ---------------")
 
-    # 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+indent+"degradeBy 0 ")
+    # MASK: make this so once the entire thing is generated, it's easy to
+    # alter how dense the pattern is, by altering "let nnM = "[1111]
     print(indent+indent+"mask "+i+"M")
 
-    #### FUN STUFF #####
+    # sometimes be quiet
+    if (i != "kick"):
+        sometimesBeQuiet()
+
+    #### VARIATIONS #####
     # insert some funStuff, maybe
-    if (random.randint(0,10) > 8):
+    if (random.randint(0,10) > 3):
       print(funThings())
 
-      #### OFFSET ####
+
+    #### OFFSET ###
+    # offset the pattern by a certain amount
+    # this can make things much funkier
     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 = ""
-    if (rChoice == 0):
-        # if choice = 0, choose hardcoded rhythms
-        # if this is the first iteration, ie "kick"
-        # choose from some hard-coded kick rhythms
-        # 2nd? same for hh
-        # 3rd? same for sd
-        if (i == 0):
-            rhythm = str(random.choice(bdPats))
-        elif (i == 1):
-            rhythm = str(random.choice(hhPats))
-        elif (i == 2):
-            rhythm = str(random.choice(sdPats))
-        elif (i == 3):
-            rhythm = str(random.choice(cpPats))
-        elif (i == 4):
-            rhythm = str(random.choice(cyPats))
-        else:
-            rhythm = "t*4"
-        rhythm = "struct \""+rhythm+"\""
-
-    elif (rChoice == 1):
-        # GENERATE A SERIES OF 0's and 1's
-        # choose how long the rhythm will be
-        if (oneBar == 1):
-            percLength = 16
+    ##### THE RHYTHMS #####
+    # how many bars to create?
+    rhythmLengthChoices = [1,1,1,1,1,1,2,2]
+    rhythmLength = random.choice(rhythmLengthChoices)
+
+    # for the number of bars, do this:
+    fullRhythm =  ""
+    for i in range(rhythmLength):
+
+        # choose between random, type-specific (bd,hh,etc),
+        # rhythm library, or euclidean rhythms
+        rChoice = random.choice([0,1,1,1,2,3])
+        rhythm = "" # placeholder for the rhythm
+        if (rChoice == 0):
+            # if choice = 0, choose hardcoded rhythms
+            # if this is the first iteration, ie "kick"
+            # choose from some hard-coded kick rhythms
+            # 2nd? same for hh
+            # 3rd? same for sd
+            if (i == 0):
+                rhythm = str(random.choice(bdPats))
+            elif (i == 1):
+                rhythm = str(random.choice(hhPats))
+            elif (i == 2):
+                rhythm = str(random.choice(sdPats))
+            elif (i == 3):
+                rhythm = str(random.choice(cpPats))
+            elif (i == 4):
+                rhythm = str(random.choice(cyPats))
+            else:
+        #     print("LIBRARY")
+                rhythm = str(random.choice(rhythmLibrary))
+            #rhythm = "struct \""+rhythm+"\""
+
+        elif (rChoice == 1):
+            # GENERATE A SERIES OF 0's and 1's
+            # choose how long the rhythm will be
+            # if (oneBar == 1):
+            #     percLength = 16
+            # else:
+            #     percLength = int(random.randrange(4,8))
+            percLength = int(random.randrange(4,10))
+            #percSequence = genOnOff(percLength)
+            #print(","+str(genOnOff(10)))
+            #print(str(percSequence))
+            # how busy will it be?a
+            # choose a random value between 0 and 9
+            busyness = random.randrange(0,7)
+            generateBinary(busyness)
+            rhythm = str(genOnOff(percLength,busyness,1))
+
+        elif (rChoice == 2):
+            # GENERATE EUCLIDEAN RHYTHMS
+            rhythm = str(euclid(random.choice(dividers)))
+            #print(indent+indent+euclid(random.choice(dividers)))
+            #
         else:
-            percLength = int(random.randrange(4,16))
-        #percSequence = genOnOff(percLength)
-        #print(","+str(genOnOff(10)))
-        #print(str(percSequence))
-        # how busy will it be?a
-        # choose a random value between 0 and 9
-        busyness = random.randrange(0,7)
-        generateBinary(busyness)
-        rhythm = str(genOnOff(percLength,busyness,1))
-
-    elif (rChoice == 2):
-        # GENERATE EUCLIDEAN RHYTHMS
-        rhythm = str(euclid(random.choice(dividers)))
-        #print(indent+indent+euclid(random.choice(dividers)))
-        #
-    else:
-        rhythm = "struct [t*4]"
+        # print("LIBRARY")
+            rhythm = str(random.choice(rhythmLibrary))
+            #rhythm = "struct \""+rhythm+"\""
 
-    print(indent+indent+"$ "+rhythm)
+        fullRhythm = str(rhythm) + " " + fullRhythm
+        # remove the trailing space
+        fullRhythm = fullRhythm.rstrip()
+
+    # add "struct" to the beginning
+    # and enclose in < >
+    print(indent+indent+"$ struct \"<"+fullRhythm+">\"")
     print (indent+indent+"$ n "+str(random.choice(percNotes))+" # midichan "+str(percMidiChan)+",")
     percMidiChan = percMidiChan + 1
 
@@ -442,12 +533,15 @@ for i in range(melodyCount):
     #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+indent+"$ "+genOnOff(16,(busyness),1))
+        print(indent+indent+"$ struct \""+genOnOff(16,(busyness),1)+"\"")
         print(indent+indent+"$ "+genNotes(1))
     else:
-        genOnOff(32,(busyness))
-        print(indent+indent+"$ "+genNotes(1))
-    print(indent+indent+"# midichan "+str(melodicMidiChan)+" + n (-36)")
+        # how many 16th notes?
+        thisLength = random.randint(3,16)
+        #genOnOff(8,(busyness))
+        print(indent+indent+"$ struct \""+genOnOff(thisLength,(busyness),1)+"\"")
+        print(indent+indent+"$ "+genNotes(0))
+    print(indent+indent+"# midichan "+str(melodicMidiChan)+" + n (-42)")
     melodicMidiChan = melodicMidiChan + 1
 
 print(indent+indent+"] # sunvox")

deleteme.tidal

@@ -0,0 +1,74 @@
+-- raw input: 268982558670766555
+-- hex seed: 0x3BB9E364458C1DB
+-- decimal seed: 268982558670766555
+-- generated at 1633539511.09
+-- Auto-Techno Generator v0.1
+
+do
+  let fourToTheFloor = 0
+      -- control density per track
+      kickM = "[1111]"
+      hhM = "[1111]"
+      sdM = "[1111]"
+      cpM = "[1111]"
+      ohhM = "[1111]"
+      rideM = "[1111]"
+      cymbalM = "[1111]"
+  p "techno"
+    -- fills
+    $ whenmod 32 30 (rev)
+    $ whenmod 32 31 (stut 2 1 "0.125")
+    $ whenmod 32 30 (scramble 16)
+    $ whenmod 16 15 (rev)
+    $ whenmod 64 62 (rev)
+    $ stack [
+    -- four to the floor
+    degradeBy fourToTheFloor $ struct "[t*4]" $ n "0" # midichan 0,
+    -------------- kick ---------------
+    mask kickM
+    $ every 6 ((0.125 ~>))
+    $ (0.125 ~>)
+    $ struct "<[{0101011}%16]>"
+    $ n 1 # midichan 0,
+    -------------- hh ---------------
+    mask hhM
+    $ every 16 (scramble 8)
+    $ every 15 ((0.125 ~>))
+    $ struct "<[1*16]>"
+    $ n 3 # midichan 1,
+    -------------- sd ---------------
+    mask sdM
+    $ every 15 (stut 5 1 "0.0625")
+    $ (0.125 ~>)
+    $ struct "<[t(15,16)]>"
+    $ n 2 # midichan 2,
+    -------------- cp ---------------
+    mask cpM
+    $ degradeBy "[0 0 1]/8"
+    $ struct "<[{0000100}%16]>"
+    $ n 3 # midichan 3,
+    -------------- ohh ---------------
+    mask ohhM
+    $ struct "<[tt*2]*4 [[0001]]*4>"
+    $ n 0 # midichan 4,
+    -------------- ride ---------------
+    mask rideM
+    $ every 10 (scramble 8)
+    $ every 5 (rev)
+    $ every 13 (scramble 8)
+    $ (0.1875 ~>)
+    $ struct "<[t(4,16)]>"
+    $ n 0 # midichan 5,
+    -------------- cymbal ---------------
+    mask cymbalM
+    $ every 8 (rev)
+    $ every 7 (rev)
+    $ every 12 (stut 5 1 "0.0625")
+    $ struct "<[{10011000}%16]>"
+    $ n 3 # midichan 6,
+    -----------------------
+    degradeBy 0
+    $ struct "[{0010100000000000}%16]"
+    $ n "[{18 6 8 7 19 35 8 24 11 7 7 8 3 23 8 33 }%16]"
+    # midichan 7 + n (-42)
+    ] # sunvox

test.tidal

@@ -13,7 +13,11 @@ some seeds I've liked:
 1035561506162950173 -- groovy
 231920015948102138 -- funky
 7138151558308434562 -- funky
-
+2154183685935315319 -- vaguely arabic
+1880041842519425526
+1014891741240181557 -- pretty funky
+850750894594826640 -- great if the kick is t(3,8) instead of t(3,4)
+2195224328517994763 -- funnnnkkky
 -- seed: -2138151558308434562
 
 setcps = (18/60/4)
@@ -644,18 +648,19 @@ $ whenmod 8 7 (rev)
 
 
 -- seed: -863274151192537696
--- generated at 1633468522.75
+
+-- generated at 1633468522.75jjjjjjjjjjjjjjjjjjjjjjjG
 
 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]"
+let kickM = "[0000]"
+let hhM = "[0000]"
+let sdM = "[0000]"
+let cpM = "[0000]"
+let fiveM = "[0000]"
+let sixM = "[0000]"
+let basslineM = "[0000]"
+let eightM = "[0000]"
+let nineM = "[0000]"
 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")
@@ -857,3 +862,260 @@ $ stack [
     $ n "{8 19 11 33 8 8 10 18 2 8 3 2 17 8 8 1 }%8"
     # midichan 7 + n (-36)
   ] # sunvox
+
+
+hush
+
+
+do
+  let masky = "[0]"
+  p "techno"
+    $ whenmod 8 7 (fast 2)
+    $ stack [
+    mask masky
+    $ s "bd*16"
+                     ]
+-- seed: -844672810981675420
+-- generated at 1633469145.73
+
+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 32 31 (scramble 4)
+    $ whenmod 32 31 (scramble 4)
+    $ whenmod 16 14 (bite 4 "{3*4 2*1 0*1 0*1 1*2 3*2 2*4 2*1 3*4 2*1 4*1 0*1 0*2 4*4 4*2 3*1 }%4")
+    $ stack [
+    -- four to the floor
+    (#gain 0) $ struct "[t*4]" $ n "0" # midichan 0,
+    -- kick -----------------
+    mask kickM
+    $ (0.125 ~>)
+    $ struct "t*4"
+    $ n 0 # midichan 0,
+    -- hh -----------------
+    mask hhM
+    $ every 9 (stut 2 1 "1/4")
+    $ every 4 (bite 4 "{4*2 4*2 2*2 4*4 1*1 2*1 2*4 0*4 3*2 0*4 3*1 0*1 3*2 1*2 }%4")
+    $ struct "t*4"
+    $ n 0 # midichan 1,
+    -- sd -----------------
+    mask sdM
+    $ (0.1875 ~>)
+    $ struct "{0011010110101101}%16"
+    $ n 0 # midichan 2,
+    -- cp -----------------
+    mask cpM
+    $ struct "[t(7,8)]"
+    $ n 0 # midichan 3,
+    -- five -----------------
+    mask fiveM
+    $ (0.125 ~>)
+    $ struct "{0000000000000001}%16"
+    $ n 0 # midichan 4,
+    -- six -----------------
+    mask sixM
+    $ struct "t*4"
+    $ n 0 # midichan 5,
+    -- bassline -----------------
+    mask basslineM
+    $ (0.125 ~>)
+    $ struct "t*4"
+    $ n 0 # midichan 6,
+    -- eight -----------------
+    mask eightM
+    $ struct "t*4"
+    $ n 0 # midichan 7,
+    -- nine -----------------
+    mask nineM
+    $ struct "[t(4,8)]"
+    $ n 0 # midichan 8,
+    -----------------------
+    degradeBy 0
+    $ struct "{0111101111101011}%16"
+    $ n "{17 2 23 15 29 35 8 20 5 19 2 9 34 2 1 5 }%8"
+    # midichan 7 + n (-36)
+
+
+
+    ] # sunvox
+
+
+
+-- seed: 2235447325725207626
+-- generated at 1633469239.66
+
+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 15 (scramble 16)
+    $ whenmod 4 3 (stut 4 1 "1/16")
+    $ whenmod 32 31 (rev)
+    $ whenmod 16 14 (stut 3 1 "1/4")
+    $ whenmod 16 15 (scramble 16)
+    $ stack [
+    -- four to the floor
+    (#gain 0) $ struct "[t*4]" $ n "0" # midichan 0,
+    -- kick -----------------
+    mask kickM
+    $ (0.125 ~>)
+    $ struct "[t(2,16)]"
+    $ n 0 # midichan 0,
+    -- hh -----------------
+    mask hhM
+    $ struct "[t(2,4)]"
+    $ n 0 # midichan 1,
+    -- sd -----------------
+    mask sdM
+    $ struct "[t(9,16)]"
+    $ n 0 # midichan 2,
+    -- cp -----------------
+    mask cpM
+    $ struct "[t(2,4)]"
+    $ n 0 # midichan 3,
+    -- five -----------------
+    mask fiveM
+    $ (0.125 ~>)
+    $ struct "[t(2,4)]"
+    $ n 0 # midichan 4,
+    -- six -----------------
+    mask sixM
+    $ every 9 (scramble 8)
+    $ struct "{1100101000001100}%16"
+    $ n 0 # midichan 5,
+    -- bassline -----------------
+    mask basslineM
+    $ struct "[t(11,16)]"
+    $ n 0 # midichan 6,
+    -- eight -----------------
+    mask eightM
+    $ every 4 ((0.1875 ~>))
+    $ every 4 ((0.1875 ~>))
+    $ every 13 ((0.1875 ~>))
+    $ (0.1875 ~>)
+    $ struct "[t(3,4)]"
+    $ n 0 # midichan 7,
+    -- nine -----------------
+    mask nineM
+    $ every 2 (scramble 8)
+    $ struct "t*4"
+    $ n 0 # midichan 8,
+    -----------------------
+    degradeBy 0
+    $ struct "{0010100101000001}%16"
+    $ n "{9 4 9 4 18 18 8 13 11 8 0 5 5 12 1 21 }%16"
+    # midichan 7 + n (-36)
+    ] # sunvox
+
+-- seed: 590111300892224819
+-- generated at 1633469475.43
+
+do
+  let kickM = "[1111]"
+  let hhM = "[1111]"
+  let sdM = "[1111]"
+  let cpM = "[100]"
+  let fiveM = "[1111]"
+  p "techno"
+    $ whenmod 32 31 (rev)
+    $ whenmod 16 14 (stut 4 1 "1/16")
+    $ whenmod 8 7 (scramble 16)
+    $ stack [
+    -- four to the floor
+    (#gain 1) $ struct "[t*4]" $ n "0" # midichan 0,
+    -- kick -----------------
+    mask kickM
+    $ (0.1875 ~>)
+    $ struct "[t(3,4)]"
+    $ n 0 # midichan 0,
+    -- hh -----------------
+    mask hhM
+    $ struct "[t(3,4)]"
+    $ n 0 # midichan 1,
+    -- sd -----------------
+    mask sdM
+    $ struct "{0000000010000000}%16"
+    $ n 0 # midichan 2,
+    -- cp -----------------
+    mask cpM
+    $ struct "[t(10,16)]"
+    $ n 0 # midichan 3,
+    -- five -----------------
+    mask fiveM
+    $ struct "[t(7,8)]"
+    $ n 0 # midichan 4,
+    -----------------------
+    degradeBy 0
+    $ struct "{0100101101100010}%16"
+    $ n "{15 3 21 25 5 7 3 2 15 7 13 3 0 3 13 10 }%16"
+    # midichan 7 + n (-36)
+    ] # sunvox
+utouto
+
+
+-- seed: 493703295080029503
+-- generated at 1633469804.11
+
+do
+  let kickM = "[1111]"
+  let hhM = "[1111]"
+  let sdM = "[1111]"
+  let cpM = "[1111]"
+  let fiveM = "[1111]"
+  p "techno"
+    $ whenmod 8 7 (rev)
+    $ whenmod 4 3 (stut 4  1 0.125)
+    $ whenmod 32 31 (scramble 16)
+    $ stack [
+    -- four to the floor
+    (#gain 0) $ struct "[t*4]" $ n "0" # midichan 0,
+    -- kick -----------------
+    mask kickM
+    $ (0.125 ~>)
+    $ struct "t*4"
+    $ n 0 # midichan 0,
+    -- hh -----------------
+    mask hhM
+    $ struct "{1000011101010000}%16"
+    $ n 0 # midichan 1,
+    -- sd -----------------
+    mask sdM
+    $ (0.1875 ~>)
+    $ struct "t*4"
+    $ n 0 # midichan 2,
+    -- cp -----------------
+    mask cpM
+    $ every 13 (scramble 4)
+    $ struct "[t(7,8)]"
+    $ n 0 # midichan 3,
+    -- five -----------------
+    mask fiveM
+    $ (0.1875 ~>)
+    $ struct "t*4"
+    $ n 0 # midichan 4,
+    -----------------------
+    degradeBy 0
+    $ struct "{1111100110011111}%16"
+    $ n "{11 7 5 10 15 7 0 24 5 14 11 11 0 20 22 24 }%16"
+    # midichan 7 + n (-36)
+    ] # sunvox
+
+hush
+
+
+hush