260 Drum Machine Patterns

I'm doing a presentation where I take drum machine patterns found in popular music and recreate and mutate them using TidalCycles. The drum machine patterns I'm using as source material comes from the book 260 Drum Machine Patterns. It's from the 80s and has some great pattens in!

For the presentation I've transcribed a few into TidalCycles notation and thought I'd share them here. If anyone wants to transcribe and share others here please do! The book's still available in print and I recommend it.

Note about my transcriptions: mine are flipped i.e. BD is the first line. Also I used a pattern of #gain functions for programming accents. If there's a more efficient way please share. Also also I just googled the tempos but use whatever's comfortable.

-- Funk 13
setcps(90/60/4)

d1
$ stack [
struct ("1 0 0 0 0 0 1 1 0 0 1 0 0 0 0 0") $ sound "bd",
struct ("0 0 1 0 0 1 0 0 0 0 0 0 1 0 1 1") $ sound "sd",
struct ("1 0 1 1 1 0 1 0 1 1 0 1 0 1 1 0") $ sound "hc"
]
# gain "1 1 1.3 1 1 1 1 1 1 1 1 1 1.3 1 1 1"
-- Pop 10
setcps(100/60/4)

d1
$ stack [
struct ("1 0 1 0 0 0 0 0 1 1 0 1 0 1 0 1") $ sound "bd",
struct ("0 0 0 0 1 0 0 1 0 0 0 0 1 0 0 0") $ sound "sd",
struct ("0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 1") $ sound "ho",
struct ("1 1 1 1 1 1 1 1 1 1 1 1 0 0 0 0") $ sound "hc"
]
# gain "1 1 1 1 1.3 1 1 1 1 1 1 1 1.3 1 1 1"
-- Disco 8
setcps(120/60/4)

d1
$ stack [
struct ("1 0 0 0 1 0 0 0 1 0 0 0 1 0 0 0") $ sound "bd",
struct ("1 0 1 0 1 0 0 0 0 0 0 0 1 0 0 0") $ sound "cp",
struct ("0 0 0 0 1 0 0 0 0 0 0 1 1 0 0 0") $ sound "sd",
struct ("0 0 0 1 0 0 0 1 0 0 0 0 0 0 0 1") $ sound "ho",
struct ("1 1 1 0 0 1 1 0 1 1 1 0 0 1 1 0") $ sound "hc"
]
-- Rock 12
setcps(110/60/4)

d1
$ stack [
struct ("1 0 1 0 0 0 1 0 0 0 1 0 0 0 0 0") $ sound "bd",
struct ("0 0 0 0 1 0 0 0 0 1 0 0 1 0 0 0") $ sound "sd",
struct ("1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0") $ sound "hc"
]
# gain "1 1 1 1 1.3 1 1 1 1 1 1 1 1.3 1 1 1"
-- R&B 12
setcps(80/60/4)

d1
$ stack [
struct ("1 0 1 0 0 0 0 1 1 0 1 0 0 1 1 0") $ sound "bd",
struct ("0 0 0 0 1 0 0 0 0 0 0 0 1 0 0 0") $ sound "sd",
struct ("0 0 1 0 0 0 1 0 0 0 1 0 0 0 1 0") $ sound "ho",
struct ("1 1 0 1 1 1 0 1 1 1 0 1 1 1 0 1") $ sound "hc"
]
# gain ("1 1 1 1 1.3 1 1 1 1.3 1 1 1 1.3 1 1 1")
12 Likes

Still very much of a beginner, I did experiment in a similar way with some of these Dance Music Rudiments.

I used set functions to be able to change the drum kit. If this could be done easier or more elegantly I am very much open for suggestions.

Generally I think in case of the representation of drum machine patterns it boils down to a balance between transparency (can you see what will happen) versus economy (can you easily edit and change things) or: can you omit redundancy and explicitness without loosing clarity and flexiblity. In this respect your version, @hellocatfood, is much easier to comprehend.

do
  setI "i" $ 0    -- i = hihat
  setI "s" $ 10   -- s = snare
  setI "k" $ 4    -- k = kick
  setS "f" $ "ab" -- f = kit or folder

do
  setI "i" $ 2
  setI "s" $ 1
  setI "k" $ 0
  setS "f" $ "drum"

do
  setI "i" $ 5 -- 5, 28
  setI "s" $ 2  -- 2, 20, 22, 23
  setI "k" $ 13
  setS "f" $ "gretsch"

setcps (150/60/4)

d1 $ stack [
   (slow 2 $ n "^i ~ ^i ~   ^i ~ ^i ^i   ^i ~ ^i ~   ^i ~ ^i ~   ^i ~ ^i ~   ^i ~ ^i ~   ^i ~ ^i ~   ^i ~ ^i ~ " # s "^f"),
   (slow 2 $ n "~ ~ ~ ~   ^s ~ ~ ~   ~ ^s ~ ~   ~ ~ ^s ~   ~ ~ ~ ~   ~ ~ ^s ~  ~ ^s ~ ~  ^s ~ ~ ~ " # s "^f"),
   (slow 2 $ n "^k ~ ~ ~   ~ ~ ~ ~   ~ ~ ^k ~   ~ ~ ~ ~  ~ ~ ^k ~   ~ ~ ~ ~   ~ ~ ^k ~   ~ ~ ~ ~ " # s "^f")
]

-- or, with some additional randomization and short syntax
-- (which makes it much more dense to understand)

d1 $ stack [
   (n "[^i ~ ^i ~]*4" # s "^f"),
   (n "<~!4   ^s ~!3   ~!4   ^s ~!3 . ~!4   ~ ~ ^s ~   ~!4   ^s ~ ~ ~ >" # gain "1" # s "^f"),
   (n "<~ ~ ^s ~   ~ ~ ~ ~   ^s ~ ~ [^s ^s]   ~ ~ ^s ^s . ~ ~ ~ ~   ^s ~ ~ ~   ~ ~ ^s ~   ~ ~ ~ ~ >" # gain (range 0.35 0.75 rand) # s "^f"),
   (n "<^k ~!3   ~ ~ ^k ~   ~ ~ ^k ~   ~!4 . ~ ~ ^k ~   ~!4   ^k ~!3 ~!4>" # s "^f")
]

5 Likes

I'd love to work through some of this with you folks! Is there a place I can find scans of the book for free? I was curious about why you used super long struct strings to define the rhythms, but then I saw the cover of the book and it made sense lol.

There is a version available at archive.org:

1 Like

Love your idea of transcribing the patterns!

A way to avoid always typing it out would be this function:

    accent :: [Integer] -> Pattern ControlMap
    accent ds = gain accs
            where accs = withEvent (\e -> if elem (eventPartStart e) fracs  then e{value = 1.3 } else e) ("1*16"::Pattern Double)
                  fracs = [(i-1)%16 | i <- ds]

The function takes a list of values from 1 to 16 and will accentuate the notes in the corresponding beats.
So now you could type:

d1
$ stack [
struct ("1 0 0 0 0 0 1 1 0 0 1 0 0 0 0 0") $ sound "bd",
struct ("0 0 1 0 0 1 0 0 0 0 0 0 1 0 1 1") $ sound "sd",
struct ("1 0 1 1 1 0 1 0 1 1 0 1 0 1 1 0") $ sound "hc"
]
# accent [3,13]

Edit: I just tried it with sound and apperently it doesn't work unfortunately. I'll have to think about it some more haha

1 Like

So here is some code that actually works, if someone is interested:

accent ds = gain (fast 16 $ Sound.Tidal.Core.fromList accs)
          where accs = [ f x | x <- [1..16]]
                f x = if elem x ds then 1.3 else 1
3 Likes

Thanks, this works great! I think for the presentation I'm doing I'll stick to the way of transcribing I'm currently using but if I transcribe more and post them here I'll use your method.

Here's the presentation I mentioned where I used the drum patterns

https://www.youtube.com/watch?v=MMTIdAGu0R4

I'll be working on transcribing the rest of the drum patterns into Tidal notation at some point

6 Likes

Hello,

fyi, I've just found that library of drum patterns (almost 500) in SC:
https://github.com/lvm/SuperUtilities/blob/master/classes/DrumLoop.sc
and its equivalent in Tidal (but I have not tested it) :
https://github.com/lvm/tidal-drum-patterns

Christophe

3 Likes

oh wow that's amazing! Thanks for sharing and thanks @mauro for making it!

This is cool!

I did a gist with a collection of popular beats from a drum YouTuber a couple of years back.

Maybe its time to get cracking on the this new book you suggested.

1 Like

Fun experiment. I wanted to play these patterns while retaining the ability to see them in my editor. I am using vim-tidal. I just mapped various shortcuts in my .vimrc that I can summon when editing .tidal files:

autocmd FileType tidal call s:tidal_abbr()
function! s:tidal_abbr()
    inoreabbr billybd "[t ~ ~ ~] [~ ~ ~ ~] [t ~ ~ ~] [~ ~ ~ ~]"
    inoreabbr billysn "[~ ~ ~ ~] [t ~ ~ ~] [~ ~ ~ ~] [t ~ ~ ~]"
    inoreabbr billych "[t ~ t ~] [t ~ t ~] [t ~ t ~] [t ~ t ~]"
    inoreabbr bluemondaybd "[t ~ ~ ~] [~ ~ ~ ~] [t ~ ~ ~] [~ ~ ~ ~]"
    inoreabbr bluemondaysn "[~ ~ ~ ~] [t ~ ~ ~] [~ ~ ~ ~] [t ~ ~ ~]"
    inoreabbr bluemondaycp "[~ ~ ~ ~] [t ~ ~ ~] [~ ~ ~ ~] [t ~ ~ ~]"
    inoreabbr bluemondayoh "[~ ~ t ~] [~ ~ t ~] [~ ~ t ~] [~ ~ t ~]"
    ... etc ...
endfunction

I could have found better names for them but so far so good.

1 Like