You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

1126 lines
26 KiB

some seeds I've liked:
1493546251137461290
1781197463452869364
14959707246264745
1411204103099713935
1157315305561367902
2275918688827233254
2209526836267835322 -- electro-ish
644793890351458335
803051260356546356
1061676950143263647
1726268759940563490
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
0x508DFAD3954D1C9 -- cooool
seed: -2138151558308434562
82408580741001929 -- cool bassline
1432897721833003170 -- very chill, cool, rolling
1513084529762492334 -- a little aphex-twin-like, interesting chords in the background
setcps = (18/60/4)
bpm (100/60/4)
setcps (130/60/4)
hush
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 3 (("1/4" ~>))
$ every 4 (rev)
$ struct "{1011000101001100}%16"
$ n 0 # midichan 0,
-- hh -----------------
degradeBy 0
$ every 10 (bite 8 "{4*4 7*1 2*2 4*4 0*4 7*1 4*2 8*1 3*1 3*1 1*1 8*1 1*4 4*2 }%8")
$ struct "[t(15,16)]"
$ n 0 # midichan 1,
-- sd -----------------
degradeBy 0
$ struct "[~ t]*2"
$ n 0 # midichan 2,
-- cp -----------------
degradeBy 0
$ struct "[t(6,16)]"
$ n 0 # midichan 3,
-- ? -----------------
degradeBy 0
$ every 6 (("1/4" ~>))
$ struct "{0100000000000001}%16"
$ n 0 # midichan 4,
-----------------------
degradeBy 0
$ struct "{0111111110111011}%16"
$ 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.75jjjjjjjjjjjjjjjjjjjjjjjG
do
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")
$ 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
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