First Notes

Let’s look at how we can play notes

numbers and notes

play notes with numbers

note("48 52 55 59").sound("piano")

Try out different numbers!

Try decimal numbers, like 55.5

play notes with letters

note("c e g b").sound("piano")

Try out different letters (a - g).

Can you find melodies that are actual words? Hint: ☕ 😉 ⚪

add flats or sharps to play the black keys

note("db eb gb ab bb").sound("piano")
note("c# d# f# g# a#").sound("piano")

play notes with letters in different octaves

note("c2 e3 g4 b5").sound("piano")

Try out different octaves (1-8)

If you are not comfortable with the note letter system, it should be easier to use numbers instead. Most of the examples below will use numbers for that reason. We will also look at ways to make it easier to play the right notes later.

changing the sound

Just like with unpitched sounds, we can change the sound of our notes with sound:

note("36 43, 52 59 62 64").sound("piano")

Try out different sounds:

  • gm_electric_guitar_muted
  • gm_acoustic_bass
  • gm_voice_oohs
  • gm_blown_bottle
  • sawtooth
  • square
  • triangle
  • how about bd, sd or hh?
  • remove .sound('...') completely

switch between sounds

note("48 67 63 [62, 58]")
.sound("piano gm_electric_guitar_muted")

stack multiple sounds

note("48 67 63 [62, 58]")
.sound("piano, gm_electric_guitar_muted")

The note and sound patterns are combined!

We will see more ways to combine patterns later..

Longer Sequences

Divide sequences with / to slow them down

note("[36 34 41 39]/4").sound("gm_acoustic_bass")

The /4 plays the sequence in brackets over 4 cycles (=4s).

So each of the 4 notes is 1s long.

Try adding more notes inside the brackets and notice how it gets faster.

Because it is so common to just play one thing per cycle, you can..

Play one per cycle with < >

note("<36 34 41 39>").sound("gm_acoustic_bass")

Try adding more notes inside the brackets and notice how it does not get faster.

Play one sequence per cycle

note("<[36 48]*4 [34 46]*4 [41 53]*4 [39 51]*4>")

Alternate between multiple things

note("60 <63 62 65 63>")

This is also useful for unpitched sounds:

sound("bd*4, [~ <sd cp>]*2, [~ hh]*4")


Finding the right notes can be difficult.. Scales are here to help:

n("0 2 4 <[6,8] [7,9]>")

Try out different numbers. Any number should sound good!

Try out different scales:

  • C:major
  • A2:minor
  • D:dorian
  • G:mixolydian
  • A2:minor:pentatonic
  • F:major:pentatonic

automate scales

Just like anything, we can automate the scale with a pattern:

n("<0 -3>, 2 4 <[6,8] [7,9]>")
.scale("<C:major D:mixolydian>/4")

If you have no idea what these scale mean, don’t worry. These are just labels for different sets of notes that go well together.

Take your time and you’ll find scales you like!

Repeat & Elongate

Elongate with @

note("c@3 eb").sound("gm_acoustic_bass")

Not using @ is like using @1. In the above example, c is 3 units long and eb is 1 unit long.

Try changing that number!

Elongate within sub-sequences

n("<[4@2 4] [5@2 5] [6@2 6] [5@2 5]>*2")
.scale("<C2:mixolydian F2:mixolydian>/4")

This groove is called a shuffle. Each beat has two notes, where the first is twice as long as the second. This is also sometimes called triplet swing. You’ll often find it in blues and jazz.


note("c!2 [eb,<g a bb a>]").sound("piano").cpm(60)

Try switching between !, * and @

What’s the difference?


Let’s recap what we’ve learned in this chapter:

Slow down/
note("[c a f e]/2")
note("c a f <e g>")
note("c@3 e")
note("c!3 e")

New functions:

noteset pitch as number or letter
note("b g e c").sound("piano")
scaleinterpret n as scale degree
n("6 4 2 0").scale("C:minor").sound("piano")
stackplay patterns in parallel (read on)
stack(s("bd sd"),note("c eb g"))


Classy Bassline

note("<[c2 c3]*4 [bb1 bb2]*4 [f2 f3]*4 [eb2 eb3]*4>")
.lpf(800) // <-- we'll learn about this soon

Classy Melody

[~ 0] 2 [0 2] [~ 2]
[~ 0] 1 [0 1] [~ 1]
[~ 0] 3 [0 3] [~ 3]
[~ 0] 2 [0 2] [~ 2]

Classy Drums

sound("bd*4, [~ <sd cp>]*2, [~ hh]*4")

If there just was a way to play all the above at the same time…

It’s called stack 😙

  note("<[c2 c3]*4 [bb1 bb2]*4 [f2 f3]*4 [eb2 eb3]*4>")
  [~ 0] 2 [0 2] [~ 2]
  [~ 0] 1 [0 1] [~ 1]
  [~ 0] 3 [0 3] [~ 3]
  [~ 0] 2 [0 2] [~ 2]
  sound("bd*4, [~ <sd cp>]*2, [~ hh]*4")

This is starting to sound like actual music! We have sounds, we have notes, now the last piece of the puzzle is missing: effects