Motivations behind Kunquat: Musical performance and time resolution

One of my goals as a tracker musician is to bring human-like expression to my music, and I like the way tracker programs provide many different controls for specifying performance details. However, trackers are mostly limited to machine-like steady rhythm, and controls to deviate from this tend to be clunky and they often lack precision.

To illustrate the problem, I would like to give some background on the nature of tracker music notation first. Consider the following comparison between sheet music notation and notation in Impulse Tracker:

An arpeggiated stack of 4ths. Left: sheet music notation, right: Impulse Tracker notation (remember that the time axis is vertical, and each horizontal row represents a duration of a 1/16th note).

Both notation styles represent the same musical idea: an arpeggiated chord. Here is an example of what it might sound like:

The notation styles are suitable for different purposes. Sheet music notation is intended for human players, who often read the notes from printed sheet while playing. Based on their experience, the players add details of natural expression to their performance, so such details can safely be omitted in the notation. This also means that there are several "correct" ways to play the section.

In contrast, tracker notation is ultimately interpreted by software in a very rigid fashion, and the notation specifies exactly how the result should be played. In the example above, all notes have their individual volume levels specified (10, 18, 13 and 10), as well as short time delays (the SD commands with values 1, 2 and 5) so that each note plays in quick succession rather than simultaneously.

Since tracker programs don't interpret music the way humans do (at least not yet) but are nevertheless designed to output music in a listenable form, it makes sense to include a lot of performance details in the notation to bring life to the music. Common such details include portamento and vibrato, and these are specified with a level of accuracy that would be unnecessary for human performers.

To get back to the limitations of typical tracker notation, consider how time is handled in the example above: We need to play each note of the arpeggiated chord with very short time intervals in between. In this case, each row in the tracker layout has a length of a 1/16th note, which is too coarse-grained for our purposes. To remedy this problem, many tracker programs support a delay command that allows more precise control over when the note starts. Still, this only increases the effective time resolution to approximately 50 ticks per second, while some playing techniques on real instruments require much more precision. Also, using separate delay commands feels disconnected from the otherwise very intuitive representation of time in tracker notation.

So, I figured that we could eliminate the concept of rows in the user interface of Kunquat, and allow the user to place their notes and effects at whatever point in time they please. Additionally, we can allow the user to zoom along the time axis in case they need more precision. Thus, our arpeggiated chord example translates to Kunquat notation as follows:

The example above in Kunquat notation. The units in time axis represent beats (4 rows in the Impulse Tracker example). Notice how more accurate positioning in the time axis has eliminated the need for delay commands.

I wanted to practise techniques involving subtle timing details (among other things), so I decided to write a cover of Asturias, a piece well-known among classical guitar players. I found the flexibility of time management in Kunquat very helpful when adjusting all the timing details that are crucial to human-like guitar performance:

Motivations behind Kunquat: Introduction

I have finally decided to write something here (to be honest, I had completely forgotten that we had this blog set up!). I'm going to assume that you are at least somewhat familiar with the concept of tracker music; if not, see the Wikipedia entry for an overview, and Bassoontracker for a quick hands-on experience of old-school tracker concepts inside your browser.

I am going to start with a series of posts that cover some of the motivations behind making a new tracker. I am going to cover features like time resolution, some signal processing details and the tuning system, and possibly some non-technical aspects as well. Some of the ideas were already on the table back in 2007 when I first started working on Kunquat, while others evolved during later years.

Before I get into Kunquat itself, I would like to tell a little bit about where I was at when I decided to write my own tracker. I had gained quite a bit of experience with several popular tracker programs, first on the Amiga with early Soundtracker clones followed by NoiseTracker and Protracker, and later FastTracker II and Impulse Tracker on the PC. Back in 2001, I was still using Impulse Tracker 2, and while it was a very powerful tool, its sound synthesis capabilities were still mostly based on simply manipulating pitch and volume of monophonic sound samples.

One of the last pieces I finished with Impulse Tracker was It Begins After Silence, which serves as a good demonstration of some of the techniques I used to create a rich echoey sound with nothing but manipulating pitch and volume of monophonic samples. Most of the techniques involved playing the same notes more than once: one note for every direction I wanted the sound to come from. In order to create a sound that was spread out wide, I would make very subtle changes to the pitch and/or timing of each copy of a single note. Most of these changes were barely audible in isolation, but when mixed together, they would often create a rather convincing illusion of wide space. However, creating spatial effects this way had a big maintenance cost: changing any details of my melody lines involved updating multiple copies of them in order to keep my spatial effects working as intended, which slowed down the process of writing actual music.

An example of two melody lines spread out to eight channels due to manual simulation of echo.

Another way of adding natural feel to tracker music was to deviate from the perfectly steady pulse of step sequencing. This often involved adding special commands that would delay the start of a note by a small amount. The delay commands made notation messy and often took away space that I would rather have used to specify other details of performance. Additionally, the accuracy of the delay was limited by the low time resolution of old trackers, which was typically around 50 ticks per second.

Despite its limitations, I find tracker notation fundamentally very powerful and convenient for specifying musical performance with great detail. One of the design goals of Kunquat has always been to keep the power of tracker notation without need for hacks to achieve a pleasant sound. The first problem I wanted to solve was the time resolution, something that I will cover in my next post.