Positions, patterns, tracks and subsongs

This tutorial explains the concepts about positions, patterns, tracks and subsongs in Arkos Tracker. If you’ve used a tracker before, all these will sound familiar, so you can skip this chapter. However, users of STarKos, AT1 and 2 should read this: things have changed with AT3 (simplified actually. A good thing, right?).

Tracks

Tracks are the building blocks of your song. Consider a track a musical sheet for one musician. A track contains notes, the instrument to use, and possibly effects. The following track…

… sounds like this:

Each symbol (C-4, 01, etc.) are explained thoroughly in the pattern viewer page, so let’s not worry about that for now. Simply accepts that notes are written in tracks.

Tracks are limited, on purpose:

  • First, in size. Basically, they can contain from 1 to 128 notes maximum.
  • Then, tracks contain one note at the time (they are monophonic, so to speak).

Building a whole song with such limitations is impossible, which is why tracks are only used as building blocks. Think of a track as the smallest part of a Lego construction. Tracks are actually contained in…

Patterns

Patterns are simply an array of tracks. How many depends on your hardware: 3 on most (Amstrad CPC, Spectrum, MSX, Atari ST etc.), simply because that’s what the AY/YM can handle. AT allows using custom chips such as PlayCity, Spectrum Next, Darky, increasing the track count per pattern to 6 or 9 (or even more if you want to, as AT itself has no limitation).

Now with 3 tracks, we have polyphony!

Listen to this beauty:

The first track (on the left) is the melody, the second is the bass, the third is the drums. However magnificent this music is, it’s a bit short. Patterns too have limitations:

  • They have the same track amount as your target hardware allows it.
  • Since they just contain tracks, patterns can only be 1 to 128 notes high too.

Must our songs be this short? Of course not. Now positions come to the rescue…

Positions

A song is actually only a sequence of positions. A position is a reference to a pattern, plus other smallish data. Positions are referred to via an increasing number, starting at 0. Your song will start at position 0, then 1, 2 and so on.

How are patterns referred to? Via a number too, starting at 0. Let me show you a bit how the sequencing looks like:

The top numbers are the positions. As you can see, they are increasingly numbered. Don’t bother remembering the position numbers, this would be quite useless.

The big numbers are the pattern numbers. So position 0 refers to pattern 1, position 1 to pattern 1, position 2 to pattern 2, position 3 to pattern 2 once again. This is interesting. Position 2 and 3 highlight the concept of repetitions. Patterns are exactly made for that: it is a sequence of notes that may be reused a certain amount of times without you having to enter the notes again, which would be time consuming and a waste of memory.

You can see this concept even further in the song: position 5 and 7 refer to the same pattern 4. And that lazy musician ended the song with three times the pattern B (this is hexadecimal for 11).

Positions have an interesting set of data, asides the pattern number:

Height

We saw earlier that tracks, and thus patterns, could contain 1 to 128 notes. Positions are actually the ones that tell how long the patterns are. This is a handy feature, because it allows to use the patterns multiple times with different length. Let’s go back to our polyphonic example before. Imagine that I want the first position to play only 8 lines of it, the second position only 4, and a third position, all of it (so, 3 positions but only one pattern). This would look like:

Position 0 (8 lines only):

Position 1 (4 lines only):

Position 2 (17 lines):

… and would sound like:

Though this example is musically dubious, the principle of height is shown: the height of the position is decorrelated from how many notes your tracks may contain, which makes re-usability greater.

Transpositions

The concept of re-usability is even more enhanced with the principle of transposition. In music, a transposition is simply an addition or subtraction of one or more semi-tones to notes.

Transposition in practice: imagine you show someone how to sing a song. But their voice is much higher that your deep baritone voice. So you start singing higher so that it fits their voice better. You added a few semi-tones to the melody, and now the other person can sing it without hassle (but now you may be in trouble because you must sing higher. Ah well).

In AT, each position allows its tracks to use a different transposition setting. This is an awesome feature to save memory: a track can be use multiple times with a different transposition, which costs almost nothing. In the following example, our three previous positions will have various transpositions for the melody and the bass:

… I fully admit this is not very musical in the context, but the principle is applied. Can you guess much transposition is used? (answer: +2 on the melody of position 0, +2 on the bass of position 1, +10 on the melody and -2 on the bass of position 2)

Subsongs

The concept of subsongs appeared in AT2 and is pretty simple. Imagine you work on a game soundtrack. You will probably have several songs: a few long in-game tunes, start-game / game-over jingles, one high-score music, and so on. You could create as many songs as they are music. Or you could use subsongs.

A song can have up to 256 subsongs: each will be a music on its own, but instruments and expressions (arpeggios and pitches) will be shared. This is handy because:

  • Using the same instruments/expressions from one subsong to another save memory.
  • Your sound aesthetic will pass from a music to another naturally, making your soundtrack more cohesive.
  • Technically speaking, it is even possible to split the music files in memory, loading only the parts you need, saving even more memory.

You don’t have to use subsongs. It is only a handy possibility. There is always at least one subsong in a song, created by default.

Conclusion

With all this, I hope you have a better understanding of how to sequencing is done in AT. Other tutorials will show you how to compose a song properly!

AT1/2/STarKos users may be shocked right now: patterns didn’t exist, since tracks were referred to directly, allowing to reuse the latter directly. Well, this has been simplified. Patterns allow you not to get lost with numbers, lost tracks and so on (and managing more than 3 tracks with all these numbers was really a chore). Don’t worry about optimization, this is also taken care of automatically by AT, but you can also make references by yourself (advanced concept presented here).