Earlier this month I released my 7th full-length album: generations. The creation of this album took only a few weeks, but the process building up to it took years of thinking about generative music and what I appreciate about it.
Generative or “automatic” music is basically meaning that either composition or performance (or both) is created through some algorithm, recipe, or program. There are many approaches to generative or “automatic” music composition. Approaches range from deep-learning interpretations of music, to clever mapping of musical space to physical coordinates, to musical emergence from mathematical formulas, to developing frameworks of musical structure (composition through decomposition).
I won’t go through them all the possibilities here, suffice to say that there are lot and not all of them sound good (to me! sound is of course subjective, so all this is based on my own preference). To me, the deep-learning music examples are the most artifical sounding and I’d prefer not to listen to them. To me, the methods that sound best are the ones that seek heuristics based on particular musical aesthetics (like the latter example that reconstructs classical music from core paradigms).
How to make music from a toy synthesizer
I first started thinking about generative music when I was trying to make music from a cheap toy synthesizer. I had bought a Korg Monotron Delay and I wanted to make a good sounding album from it but was challenged because it only outputs one note at a time. I decided to make a looper so I could loop notes atop each other and then tried to figure out methods for layering the notes in interesting ways. After hacking the toy synth I created a little looper that would loop the synthesizer onto six loops, with four notes per loop.
So what should the notes be? I wrote a little sequencer and started writing lists of notes. I tried ordering the notes in basic intervals (root, 3rd, tonic, etc) and I tried random ordering. Eventually I settled on this type of “minimal transposition” scheme where you order notes by grouping close notes together. For example: first suppose you chose four chords: Am, F, C, G. acrostic will first determine the notes for each chord in a separate column:
Am F C G --------------- A F C G C A E B E C G D
Then I would rearrange the notes of each chord in each column so that there are minimal changes between different columns.
Am F C G --------------- C C C D A A G G E F E B
Then I would read off, row by row, the notes where each row would be one full loop in my looper script. This is not a new techniique, in fact its a very simple form of voice leading. Eventually these long lists of notes where turned into songs when I put everything together. For example, this list of notes became this song:
A realization about articulation
I recorded the songs with that toy synthsizer two years ago. Since then I’ve been thinking about it - how simple the process was for generating the music and how much I enjoyed the result. Part of the result, though, was not in the pitches themselves but in their articulation - i.e. how loud one series of notes might be.
So I went ahead to write another program. One that would automatically create the matrix of notes and record each row of the matrix, one note at a time, into different loops. I called this program “acrostic” since the note matrix has meaning in its columns (chords) and in its rows (melodies). The key though, was to provide each loop with a specific articulation - basically it would allow each one to get louder and softer randomly over time. This allows different meldies to come in and out of focus, which instantly gives songs their “movement”.
For example, here is a track from my latest album “generations” where the volume of each track is visualized by the vertical position of one of the filled circles:
To me, this sounded great. Not only that, using the same four chords would give greatly different results which is an important part of generative music (to me). The randomness in the process was enough to generative varied performances but not too much to produce noise.
The recipe for generative music
So after this little discovery I had a basic recipe for generative ambient music.:
- Choose chords.
- Create matrix of notes from chords and rearrange rows in each column to minimize distance between columns.
- Render each row, one note at a time, with some instrument/synthesizer into a looper that stores each row as its own track.
- Add articulation to each loop track by modulating its volume with a simple LFO.
I used this to set about recording dozens and dozens of songs for this album. It was easy to record - in my acrostic software, I basically just put the chords I wanted (as input) and then let it go while capturing the output. Afterwards I did a little bit of mastering (normalizing levels, taking off some of the low end) and released it as “generations”. There is one of the title tracks with an animation I made visualizing the articulation of tracks:
(sidenote: this is the code for the art, generated using Processing)
Each track is made the same way - following those four steps above - and using the same sound source (a synthesizer called the Make Noise Strega). But you could easily do the same thing with a toy synthesizer, or any instrument really. There are some other little tricks - I introduced a little variation by adding in random melodies that where interpolations between neighboring columns in that matrix. But that’s something for another story!
My code referenced
Here is a list of repositories I wrote that were mentioned above:
- miti - a text-based music sequencer
- oooooo - a six-loop sampler
- acrostic - a chord sequencer and sampler