A composition for the "Dare to Fail" project
Autopilot: Audio File MIDI
Autopilot is a composition I did for the second round of the
"Dare to Fail" project. It's fascinating to
hear the incredible variety of compositions that people can come up with,
all starting from a common point.
a detailed description of the process I followed when composing Autopilot.
To display full-resolution versions of the screen dumps shown below, just
click on each image.
I first read in the basic
track that was the starting point of the project. In the first
screen dump below, the basic track is shown in the large horizontal window
at the top of the screen. I then started auditioning it, and copying
little pieces of it into separate windows (known as tools).
I usually use the group tool - a multi-track editor with dozens
of algorithmic editing operations. The music is represented in piano-roll
style, and can contain any number of tracks (though not all of the tracks
need be visible). In the screen dump below, there are 8 such tools
on the screen.
At the bottom of the screen is a command prompt, which I rarely use - most
operations are performed with the mouse. Pull-off menus and pull-off
buttons make repetitive operations convenient. For example, in the
screen dump you can see a number of buttons (small grey rectangles) that
have been pulled off and placed in convenient locations.My goal in the
first phase of the composition was to build up a large collection of interesting
phrases, using the basic track as the starting point. I would grab
a small section of the basic track, and (in a separate group tool) start
manipulating it - flipping it, reversing it, stepping it (making all notes
the same duration), shuffling it (like a deck of cards, horizontally),
etc. If I found a phrase that sounded interesting, I would move that
tool's window to the side and start working on a new on. Sometimes
I would work on manipulating a small phrase, and sometimes on a large one.
When working on a large phrase, I would often find a interesting measure
within it, and copy it out into a separate tool. I have certain manipulation
techniques that I use a lot, but the pallette of algorithmic editing operations
is large enough so that I can always find something new to try.
In this next screen dump, you can see that I ended up with about two
dozen "interesting" phrases that I produced by manipulating the
basic track. At no point in the process (up to this point) did I
touch a musical keyboard - everything was done with the mouse.
Some of the phrases became drum tracks, by changing the MIDI channel to
10 (the General MIDI drum track). Once converted to channel 10, I
would then transpose the entire phrase up and down until I got a drum pattern
that I liked. It was at this point that I started piecing some of
the smaller phrases into larger phrases - you can see in the screen dump
that some of the tools contain larger pieces of music. Since many
of the manipulations were in the same key (because some manipulations involve
forcing notes to a particular scale), they often sounded good when played
together. At some point I decided I had a big enough phrase to start
building a composition around, and so the largest window (toward the upper
left, showing 5 tracks) became the beginning of the final piece.
At no point in the process did I have any idea where I was headed - the
evolution of the composition was entirely guided by whatever sounded good
as I played around. When I had sections (both melodic and with drums) that
sounded good, I then started repeating them. I also started transposing
the repetitions, so that it wasn't always in the same key. I then
set up a new track that had the "root" note for each measure
- this root note was then used to control a special algorithm I have that
produces melodic material. This algorithm, which I call beat step,
produces melodies whose key is determined by one set of notes, and whose
general direction is "guided" by another set of notes. Another
algorithmic manipulation I used (in two places) is a "fade in"
- a phrase is repeated (say) 8 times, starting with only a few notes, and
gradually including more and more notes until the complete phrase is being
repeated. This technique is used at the beginning of the piece, and
again in the middle. The notes selected for the fade in are random,
however I do not blindly accept whatever is produced - if I don't like
the way it sounds, I merely use "undo" and repeat the operation
until I get something that sounds good.
The screen dump below shows the state of my screen as the composition
neared completion. I finally resorted to using my musical keyboard
and played a melody on top of one of the sections (at the beginning of
I originally played this melody using a flute sound. However, I found
that a bass sound was a smoother way of starting the piece, and I took
the same melody and repeated it later with a synth lead sound. Other
than this single melody, the entire piece was composed with the mouse and
algorithmic manipulation. The words "algorithmic composition"
could be used to describe this process, however it's important to realize
that, at least in my process, I throw out 95% of the algorithmic manipulations
- the composition process becomes an algorithmic improvisation and
filtering process, using my personal taste as the filter.
I also do more normal composition, where I compose a complete piece at
the keyboard and then arrange and record it on the computer. However,
the composition process I have described here allows me to explore and
produce things that I could never conceive of or execute without the help
of the algorithmic manipulations enabled by a computer. For example,
the drum patterns I do manually are pathetic compared to the ones I produce
algorithmically. Melodies are often better done manually (and so
I don't hesitate to add them manually, as I did in this piece), however
within the algorithmically generated melodic material of Autopilot there
are lots of interesting twists and turns. Here are the final Audio and MIDI
Autopilot: Audio File MIDI
The software I use to compose with is called KeyKit - it's a multi-tasking
programming language designed specifically for MIDI work, and I've used
it to build an entire multi-window GUI for MIDI experimentation and composition.
You can get the source code and executables from the KeyKit