Lazy kicks and eager snares

Programming drums can be an addictive activity. In this first part of Beatmaker Recipes, we'll have a look at a simple pattern for funky drums that can serve as the foundation of any beat and be extended infinitely.

The classic MPC swing is a mythical unicorn, said to be a defining factor for the sound of hiphop in the past three decades, and rumored to be the result of a calculation mistake. Some clowns still claim its greatness can never be matched or repeated, and some say trying is a failure on its own.

The truth is, I was never a big fan of the automatic swing setting on my drum machines. The mechanics are simple: a single value, pushing or pulling the half-beats. But I've always wished for more depth and control, moving most notes to fit the groove, not bound by a predefined algorithm.

In this guide, we'll take a straight drum loop and use a simple, manual technique for creating swing: apply some pushing and pulling to end up with a sequence of lazy and eager notes.

The examples below are made using Dilla, a small library I made for scheduling Web Audio notes. To learn the basics of how to use it, have a look at Making a boombap beat with Dilla and the Web Audio API and Using expressions in Dilla.

The straight loop

A rhythm familiar to most ears and usually the best place to start messing with new techniques.

dilla.set('drums', [
  ['*.odd.01', { sound: 'kick' }],
  ['*.even.01', { sound: 'snare' }],
  ['*.*.%48', { sound: 'hihat' }]
]);

Play straight loop example

Basic swing

We begin by pulling the snares back, which adds a tiny bit of swing to the straight drum pattern.

dilla.set('drums', [
  ['*.odd.01', { sound: 'kick' }],
  ['*.odd.91', { sound: 'snare' }],
  ['*.*.%48', { sound: 'hihat' }]
]);

Play "eager snare" example

Next move is to push the hihats forward, bringing the effect of the eager snares to light.

dilla.set('drums', [
  ['*.odd.01', { sound: 'kick' }],
  ['*.odd.91', { sound: 'snare' }],
  ['*.*.4%48', { sound: 'hihat' }]
]);

Play "lazy hihat" example

Crafting the rhythm

Then add another kick, lazy and slightly lighter volume.

dilla.set('drums', [
  ['*.1.01', { sound: 'kick' }],
  ['*.1.52', { sound: 'kick', gain: 0.7 }],
  ['*.3.01', { sound: 'kick' }],
  ['*.odd.91', { sound: 'snare' }],
  ['*.*.4%48', { sound: 'hihat' }]
]);

Play "lazy kick" example

Pull the middle kick back, letting it hit well before the next beat and then handing over the rhythm to the slightly lazy hihat.

dilla.set('drums', [
  ['*.1.01', { sound: 'kick' }],
  ['*.1.52', { sound: 'kick', gain: 0.7 }],
  ['*.2.88', { sound: 'kick' }],
  ['*.odd.91', { sound: 'snare' }],
  ['*.*.4%48', { sound: 'hihat' }]
]);

Play "eager kick" example

Although a hihat on every beat is definitely in the boombap cook book, I'm a big fan of minimalism, the quest to do more with less. With that in mind, let's scale back the hihats.

dilla.set('drums', [
  ['*.1.01', { sound: 'kick' }],
  ['*.1.52', { sound: 'kick', gain: 0.7 }],
  ['*.2.88', { sound: 'kick' }],
  ['*.odd.91', { sound: 'snare' }],
  ['*.odd.02', { sound: 'hihat' }],
  ['*.even.04', { sound: 'hihat' }],
  ['*.04.54', { sound: 'hihat', gain: 0.5 }]
]);

Play "less hihat" example

With less hihats, we could add another kick to further point the groove towards the even beats.

dilla.set('drums', [
  ['*.1.01', { sound: 'kick' }],
  ['*.1.52', { sound: 'kick', gain: 0.7 }],
  ['*.2.88', { sound: 'kick' }],
  ['*.3.80', { sound: 'kick', gain: 0.7 }],
  ['*.odd.91', { sound: 'snare' }],
  ['*.odd.02', { sound: 'hihat' }],
  ['*.even.04', { sound: 'hihat' }],
  ['*.04.54', { sound: 'hihat', gain: 0.5 }]
]);

Play "another kick" example

Final variations

There is of course an opportunity to take things too far, and mess up the rhythm so badly that you're not able to build your beat around it. But it could also happen that once you start tweaking your drums with this technique, you might find yourself liking patterns with programming far from normal, and almost broken. As with everything, balance is key.

dilla.set('drums', [
  ['*.1.01', { sound: 'kick' }],
  ['*.1.56', { sound: 'kick', gain: 0.7 }],
  ['*.2.86', { sound: 'kick' }],
  ['2.3.45', { sound: 'kick', gain: 0.5 }],
  ['*.3.74', { sound: 'kick', gain: 0.7 }],
  ['2.4.18', { sound: 'kick', gain: 0.5 }],
  ['*.odd.85', { sound: 'snare' }],
  ['*.odd.02', { sound: 'hihat' }],
  ['*.even.04', { sound: 'hihat' }],
  ['*.*.52', { sound: 'hihat', gain: 0.5 }]
]);

Play "extreme" example

Our final example, back in a more nuanced territory. Here we add some more hihats in a triplet-like flow to pick up the pace at the end of the loop.

dilla.set('drums', [
  ['*.1.01', { sound: 'kick' }],
  ['*.1.52', { sound: 'kick', gain: 0.7 }],
  ['1.2.88', { sound: 'kick' }],
  ['2.3.52', { sound: 'kick' }],
  ['*.3.80', { sound: 'kick', gain: 0.7 }],
  ['*.odd.91', { sound: 'snare' }],
  ['*.odd.02', { sound: 'hihat' }],
  ['*.even.04', { sound: 'hihat' }],
  ['1.4.54', { sound: 'hihat', gain: 0.5 }],
  ['2.4.32', { sound: 'hihat', gain: 0.2 }],
  ['2.4.66', { sound: 'hihat', gain: 0.5 }]
]);

Play "triplet variation" example

Remember, the simplest and best judge of how well a drum pattern works is your head and neck - if you can nod your head to a simple loop, you are on the right track. If you can't stop swinging it back and forth, you might have struck gold and should proceed to add chopped samples and bass.

What techniques do you use to give life to simple drums, and what do you think of this pattern? Hit me up on Twitter and say your piece.