Using arpeggios

In this tutorial, we’ll see how to create arpeggios and how to use their related effects in the patterns.

Before reading this, you should have a basic understanding of AT3, which this tutorial will help you get! You should also read about the arpeggio editor.

Arpeggios are among the most expressive tricks in sound-chip music. Not only can it simulate several notes in one channel, it almost gives a composer its personality. Tim Follins, David Whittaker, Dave Rogers all have their trademark arpeggios! Now it’s your turn.

Let’s dive directly into the matter. Start AT3. It opens with a new empty song. A first “Beep” sound is present. Open it and make it loop on the sixth bar:

This simple sound will be the starting point upon which we will make our tests.

Creating a first arpeggio

On the left of the screen is the list of instruments (as you can see above), arpeggios and pitches. Press the second icon from the left to open the arpeggio list (AL). You can also press shift + F4:

There is only one arpeggio, called “None”. It is always present and is used when you want to stop arpeggios, but we’ll see that later.

Just like creating a new instrument, press at the bottom of the list. A dialog opens, prompting you to name your new arpeggio and select a template. Do as the following, and press OK:

“First” now appears in the arpeggio list. Let’s edit it: double-click on it, and the Arpeggio Editor will appear in the center of the screen (you can also press F4 to open the currently selected arpeggio. Note that opening the editor will automatically opens the arpeggio list too, which is a handy shortcut!):

Since the template we selected was “empty”, the arpeggio contains nothing. Only one column, and no value in it (0s are not written to have a clearer interface). Octave adds full octave to the played notes, and Note adds semi-tones to it.

You may not know musical theory (I certainly don’t!), but by adding 4, then 7 semi-tones, you get a major chord. Let’s do that! You should know how to add values in the editors (check this if that’s not the case). Let’s do it the easy way by using the mouse.

Place your mouse above the Note row, go to the second and third rows (named 1 and 2) and, by using ctrl + left-click, modify/add the values 4 and 7. The row 0 should remain as-is. You should have something like this:

Note two things:

  • The loop end automatically set itself to 2, because we actually added values that weren’t there, so AT figured out you probably wanted to include them in your arpeggio.
  • The loop is always on and cannot be turned off. Contrary to instruments, arpeggios (and pitches) always loop!

Testing the arpeggio

Let’s hear our creation! We need a sound upon which the arpeggio is played. The “Beep” instrument should be selected automatically when launching AT, so by playing with your MIDI keyboard, or your computer keyboard (QWERTY or ZXCVBN), you should directly hear it! Press escape to stop it.

How great! “First” is not very evocative, so right-click on it in the AL, select “Rename”, and type “Major” (because, no surprise, it is a major chord).

Note: your arpeggio is used when testing the sound because it is selected in the arpeggio list, which you can also see in the Test Area below, with a “01” just below the arpeggio icon):

More on the test area here.

A second arpeggio

The arpeggio we just did is perfect for accompaniment. But we could make another one for a melody. The most obvious one would be an “octave attack”. That’s nice, AT3 provides a template for this!

Either right-click on the last arpeggio on the AL and select “Create at the bottom”, or click on the icon at the bottom of the list. A dialog opens for our new arpeggio. Name it “Octave attack” and select the like-named template:

Opens the newly created arpeggio:

Playing with it sounds like this:

As you can see and hear, the first frame has an octave higher than the rest, and the arpeggio then loops on the second row, which has no particular data. The sound thus remains bare. We’ve just added an arpeggio that only modifies the start of the sound and lets the remaining unmodified.

Using the arpeggios in a song

All this is nice, but we want to create a song with these arpeggios! Like pitches, arpeggios are used via the effects columns of the Pattern Viewer (explained thoroughly here). By now you must know how to write notes and some effects (as seen in the previous tutorial), but arpeggio effects still remain a mystery. Let’s clear this!

Go to the PV by pressing F2. We are in front on an empty pattern.

Notice in the AL on the left that each arpeggio has a number in front of it:

  • 00 for None
  • 01 for Major
  • 02 for Octave attack

These numbers indicate how arpeggios are referred to in the musical score. Let’s write a simple arrangement with these notes, on the first channel: (Make sure that Record is on: ctrl + space / ctrl + r on Mac, or click on the Record button).

Also, reduce the position size by clicking on its height number at the top-left. Let’s set it to 10 (hex).

Play the song, it should sound like this:

Ok, not very exciting. Now move up to the first line and add the following effect:

Tip: if you go back to the first line where my cursor is, you can see at the top-right an information about what is under the cursor: an “arpeggio from table effect”, with the currently set: 01: Major.

Play again! This time it sounds pretty cool (and reminds me a bit of a famous CPC song from a famous game made by a famous composer (hi BSC!)):

Notice how even though we only added one arpeggio, all the notes are using it. That’s because expressions (arpeggios and pitches) remain on the track they are used, and restarts every time a note is played. So you don’t have to copy/paste the effect on every note, which is very convenient.

This also means that you may want to stop them if you don’t want to use them anymore! How? Simple: simply use the arpeggio 00 (“None”).

Adding a melody

It’s now time to use the second arpeggio we created. Let’s write a small melody on the second track using the “Octave attack” arpeggio:

… which also reminds me of yet another famous melody rendered on CPC by another famous musician (hi Kangaroo!).

Inline arpeggios

Creating arpeggios via the arpeggio editor is nice, but you can’t help but wondering if there wouldn’t be a way to create simple arpeggio in a simpler way. Well… yes! It’s called “inline arpeggios”. It means you can declare an arpeggio directly in the pattern.

There are two awesome effects for this:

The principle is that all the semi-tones to add are written in the effect parameter. Our “Major” chord arpeggio is composed of 0-4-7 semi-tones. Let’s modify our first track by replacing the a01 effect with these:

Without the melody, it sounds like this:

Whoo, it’s great! But then you ask: since we did in one line what we bothered to do with bars in the AE, why bother with the AE at all!?? A few reasons, my friend!

  • Inline arpeggios are limited to three notes (“b” effect) or four notes (“c” effect). The base note (0), implicit, is always the first, followed by the ones written in the pattern (47 or 57 in the example). You can’t change this order!
  • The semi-tones range is limited from 0 to F, which is more than one octave, but is still not much. Also, there are no negative semi-tones.
  • The speed is always the maximum. Not a huge deal, see below for a neat trick.
  • The loop is forced on all the 3 or 4 notes the inline arpeggio contains. So even a simple arpeggio like “Octave attack” cannot be reproduced.
  • On a low-level technical note, most exported format (AKG, AKM) will convert inline arpeggios to arpeggio tables, which are limited to 255 at best. If you create many different inline arpeggios, the export will fail (don’t worry, I never saw anyone reaching this limitation!).

Changing the speed

You know that arpeggios, just like instruments and pitches, have a speed parameter in the editor, going from 0 (fastest) to 255 (slowest):

This is great, but what if you want, once or at a few specific moments, to change its speed? One possibility is to duplicate the arpeggio only to set a new speed. It is actually a good solution if you use this new arpeggio a lot, but it is inefficient in most cases.

Well, AT got you covered! There is an effect called Set arpeggio speed (“w” effect) you can use to set the speed of the arpeggio that is just before in the same line. Here is an example, using both inline and editor arpeggios:

At slower speed, it sounds like this:

A lot of things can be said on these few lines of score:

  • The “w” effect only works on the line it is put on. The next time the arpeggio is used, it will use its default speed. For example, line 00 has an arpeggio speed of 04, but line 02 comes back to speed 00, as it is the default speed of inline arpeggios.
  • You can use the “w” effect even if no arpeggio is declared (see line 04 and 0E). The triggered arpeggio will use this new speed.
  • The “w” effect works on all kind of arpeggios! Inline and normal ones (see line 0B and 0E).

Two more technical things to bear in mind:

  • If you start using this effect too much on one specific inline arpeggio, it is probably more handy to replace the inline arpeggios with a “real” arpeggio using the arpeggio editor.
  • The same for a “real” arpeggio: you could probably duplicate it and change its speed.

Double arpeggios

This is an slightly advanced topic, but soon you won’t stop using it when you hear what can be done with it. You know there are two ways of using arpeggios:

  • Via effects as explained above (arpeggio table, inline arpeggio).
  • Inside the instruments themselves.

Now, what would happen if you combine both? Would AT explode? Certainly not. The values will add up! The following example will use an instrument that loops its own arpeggio. It looks and sounds like this:

The octave loops till the end of the sound, which itself loops (notice the use of the auto-spread feature in the Arp.octave row).

Now, if we create an arpeggio made of a simple major chord, with a speed of 4, and plays it via an arpeggio table effect, plus the sound above, we would get this:

Wow, isn’t that great? The looping octave of the instrument is added to the simple basic chord of the arpeggio. Yet the sound is much richer. How come? It’s simple: it’s because both the instrument octave and the arpeggio have a different cycle (made possible by the size of their loop, and their different speed), so the sound appears much longer than what it actually is.

Experience shows that it is more flexible to have the instrument arpeggio very simple (like an octave change), and have the more complex arpeggio being done via arpeggio table.

You can experiment with such technique by playing your pattern, and tweaking the instrument speed/loop and the arpeggio table speed/size. There are unlimited possibilities!

Generating arpeggios

This is a slightly more advanced topic, but I feel you’re ready for it :). Sometimes the musician in you has the notes of the arpeggio in mind, but “writing” them in the arpeggio editor via bars or semi-tones is tedious to you. Why decompose them in semi-notes when you can “hear” them?

Well, there is a great feature in AT3 that will help you create arpeggios from notes, and it will also enable you to create very complex arpeggio in a blink of an eye.

The principle is simple: we will write the notes in the PV for them to be generated into an arpeggio.

Delete the first track with the accompaniment, because we will write something better.

Now type the following notes:

They should sound like this:

Nothing fancy, but wait! Select all of them, right-click on the selection and select “Generate arpeggio from selection”

A pop-up shows:

Enter the name “Awesome” (because it is), and let C-5 as the base note (it will be a reference note of our new arpeggio. Most of the time, leave this parameter alone). Click OK!

A new arpeggio has been generated, and it is “Awesome”!

Reduce its speed to 5 to hear it better and have fun with it. Don’t you recognize the notes we’ve just entered?

Now let’s use it in our song! Set its speed to 2, erase the first track notes again, and simply use the Awesome arpeggio:

Let’s hear it!

Isn’t it awesome? Now you can write simple to hyper-rich arpeggios without having to draw these damned bars in the editor! Doesn’t this arpeggio has a “Tim Follin” vibe, mmmh? It sure does, which, I think, is a pretty good sign as to what AT can do for you. Now go create your own arpeggio signature!