Chords and arpeggios

What’s a piano lick without some chords? So let’s introduce a few different ways of making chords in Tidal, how to introduce random chords, and finally how to use arpeggiation in Tidal to make a melody line out of your chords.

First, if we use our letter-note notation making chords is pretty easy if you know which chords you want. In music theory, different chords have different names. For example, in the major scale your chords are going to be

• c major
• d minor
• e major
• f major
• g major
• a minor
• b diminished

And in Tidal we can represent them like this

d1 $ n "<c'maj d'min e'min f'maj g'maj a'min b'dim>" # s "superpiano" # sustain 4

So we can create a little chord progression like

d2 $ n "<c3'maj e3'min [f3'maj d3'min] g3'maj>"
   # s "superpiano"
   # lpf 1000
   # shape 0.3
   # room 0.6
   # sustain 8
   # gain 0.8

and from here we can use a really common trick when making music: arpeggiation. Arpeggiating means taking the notes of a chord and then playing them separately from each other, a kind of unchording. There are a lot of different ways to arpeggiate: you can play the notes from lowest to highest, from highest to lowest, or even stranger things like playing the notes from low to high while playing the lowest note in between all of them. In Tidal, there’s an arpeggiate transformation called arp that will handle this for you. So we can take our above example and turn it into a melody like this

d1 $ arp "<up down upanddown>" $ n "<c3'maj e3'min [f3'maj d3'min] g3'maj>"
   # s "superpiano"
   # lpf 1000
   # shape 0.3
   # room 0.6
   # sustain 4
   # gain 0.8

There’s an obvious problem, though, if we play these two at the same time: the arpeggiated notes are in the same octave as the chords, but if we want them to feel like a melody they should probably be higher pitched. You could just change all the 3s in the chords to be 4s or 5s but we’ll do it with another transformation instead: (|+)

d1 $ arp "<up down upanddown>" $ (|+ 12) $ n "<c3'maj e3'min [f3'maj d3'min] g3'maj>"
   # s "superpiano"
   # lpf 1000
   # shape 0.3
   # room 0.6
   # sustain 4
   # gain 0.8

The (|+ 12) is a transformation that says “add twelve semitones to the notes in the pattern”. Why twelve? Because that’s one octave up in pitch! So now if you play this and the pattern of chords you’ll hear that they’re different pitches, in a fairly pleasing way.

Now you’re at a point where you can play with the chords, the arpeggiation, and put together a tune that you can drop some kind of slow, chill beat over.

However, there’s one last trick that I want to share with you and that’s making randomized chords. Here we’re going back to our scale transformation instead of our note and chord notation.

So consider a melody like the following

d1 $ slow 2
   $ n (scale "major" $ "[<0 2> [1 [5 0]]? <[2 3]*2 [5 6]> <4 3 2>]")
   # s "superpiano"
   # sustain 4
   # room 0.5
   # gain 0.85
   # lpf 1500

To play a chord we need to know how to play multiple things at the same time, which in Tidal is pretty easy: here’s a polyrhythm made by playing four bass drums and three bass drums at the same time (this is sometimes called the “pass the stinking butter” rhythm, for reasons that are clear when you hear it)

d3 $ s "[bd*4,bd*3]"

If you put commas between things inside a pair of square brackets, Tidal will play them both at the same time. To play a chord, we can then add

We mentioned a few different kinds of chords above: major, minor, diminished, etc. We can simplify things a bit though because actually all these different kinds of chords are really the same thing: you take the root note of the chord, two notes above that, and two more notes above that. In code that looks like |+ [0,2,4].

But we don’t want to always play a chord, just sometimes. Huh, we’ve italicized that word as though it meant something special like in our final code for this section

d1 $ slow 2
   $ n (scale "major" $ sometimes (|+ "[0,2,4]") 
                      $ "[<0 2> [1 [5 0]]? <[2 3]*2 [5 6]> <4 3 2>]")
   # s "superpiano"
   # sustain 4
   # room 0.5
   # gain 0.85
   # lpf 1500

sometimes is a special transformation that eats another transformation and then applies it to half the events in the pattern. This means that about half the time a note is going to get turned into a chord instead.

Pretty cool! And definitely hard to do when you’re not using code to write music.