Composer/Sound Artist

My Music


Download Pulse

Attempting to expand my musical styles a bit, this is an attempt at something a bit less 'classical'. Also my first real attempt at using a modular synth in my work.

The Fates

Download The Fates

Loosely based on the three Fates from greek mythology: Clotho, Lachesis and Atropos. A mixed ensemble piece with intense counterpoint, built up by a canon of increasing complexity.

Sea-shell Wind-Chimes, Dawn

Download Sea-shell Wind-Chimes, Dawn

A while ago we received a gift of a beautiful set of wind-chimes made out of sea-shells found on Fire Island. I set about creating a piece of music incorporating them and, after many months of revisions, this is what I created. The rhythmic pattern of the sea-shell wind-chimes was created via a PD program, as were some of the ambient effects. Vocals were provided by my beautiful wife Juliana.


Download Weaves

Another short piece for Jun Kang. Simple instrument doubling combined with layered effects.


Download Persistence

A piece I've been working on for quite some time. Essentially an electronic percussion ensemble with strings. Trying to find a way to create music in such a way that I can take advantage of all of the power of the computer while not giving up the musicality of traditional classical music.

Sunbeams Through Stained Glass

Download Sunbeams Through Stained Glass

Another piece for Jun Kang. All of the sounds used in the piece were made by convolving alto flute and vocal samples.

Shimmer Pairs

Shimmer Pairs

Another short piece written for director Jun Kang. Just piano and heavily modified tremolo strings.

Sines & Ground Loop


Ground Loop

Two experimentations with sine waves. Both for director Jun Kang.

Creative Commons License

All music and content on this site is licensed under a Creative Commons Attribution-Noncommercial-Share Alike 2.5 License.


I live and work in beautiful Austin, Texas and am always looking to get my music out there. If you are interested in my music or in working with me get in touch at

Audio Software & Programming

Expert Sleepers Disting Quick Reference

The Expert Sleepers Disting is a multi-function Eurorack module that can play many roles. But all that versatility comes with a cost: every time I use it I find myself having to review the manual. And while the online manual is rather good, it's a pain to have to open a web browser to view it each time. So for easy reference i've put together a quick-reference PDF, linked below. Doesn't include the full detail, of course - just a summary of the feature selection.

Expert Sleepers Disting Quick Reference (pdf)

Eurorack Filter Demo: Doepfer A-108 Filter Sweeps

Having recently gotten into Eurorack modular synths (may the Eurorack gods have mercy on my checking account, and my wife on me), I recently bought a Doepfer A-108 filter. It's a "Moog-like" ladder filter with, I think, a great sound. More information: on, and on Doepfer's website. When trying to decide whether or not to buy it I noticed there weren't many demos available for this module (aside from the excellent demo by Andreas Krebs) so I decided to do a quick demo.

The filter sweeps were recorded using the saw wave output on an Intellijel Dixie II, through the A-108 (audio level set to '3' - or roughly "10:00 o-clock" on the pot so as not to distort), into an RME babyface, and recorded into Logic Pro X without any further processing. Five filter sweeps for each of the 5 outputs are recorded, each with different resonance settings (or "emphasis", as labeled on the module). Specifically:


Evolving Melodies

In recent works i’ve had an interest in using the concept of evolution to help with composition. There’s a value in having alternatives presented to you, giving you ideas that you otherwise wouldn’t have thought of. Pure randomness is interesting, but tends to result in far too much variation - at least for my taste. What seems to be ideal is a tool that will vary musical ideas, but only slightly and gradually. This allows for variations on a theme rather than wholesale scrambling.

Enter evolution. Or at least a rough approximation of evolution.

What follows is a relatively simple Python program which can take midi files and create variations of the musical contents. It produces a set of files that are based on the original file, but vary in minor ways. For example: one pitch of a melody will be shifted up or down, notes will be split into two, note durations will be decreased or increased, etc. Disclaimer: I tried to model evolution with this software, but it’s not intended to be an accurate model. I deviated (some might say cheated) where I thought it would produce more interesting musical results.

My process so far has been to run this program once or twice a day, picking the variation that I prefer from those generated, and using it as the input to the next iteration. In a literal and evolutionary sense the user of the program is the ‘selection mechanism’. Each running of the program is somewhat like a ‘generation’ of offspring. Starting with a very basic melody (the same pitch repeated as quarter notes), each progressive ‘generation’ gets more and more diverse and interesting. The initial melodies are very very basic, almost unlistenable. But out of that monotony, gradually, you get some interesting musical ideas. The results are still dependent on my tastes (again, i’m the “selection mechanism”, choosing the variations I like best) and another person would get different results, but it’s unlikely that I would have created these melodies from scratch; doubtful these exact variations would have come to mind.

'Evolving Melodies' Source Code (right-click and "save as...")

Initial melody:

Fifth iteration:

Tenth iteration:

Final iteration (13th):

Easy Convolution with SoundHack.

SoundHack, a freeware program by Tom Erbe, has some terrific and unique functionality for manipulating sound - including convolution.

Convolution, a type of analysis-based sound file manipulation often used for reverb, can be used to generate some extremely interesting sounds by "cross-breeding" two source sound files. This can be done programatically with a number of music programming languages like CSound and Max/MSP, but SoundHack makes it quite easy (and free).

SoundHack user interface.

Markov Chains in Ruby

So the plan for a piece i’m writing is this: a set of very simple melodies, each with some set of probabilities of progressing to one of the other melodies; in other words - markov chains. Each of the melodies will have a set of possible doublings/harmonizations, and as the piece progresses the chance of those doublings/harmonizations occurring will increase - the piece will ‘thicken’ over time. This gradual process will repeat a few times, each repetition forming a major unit of the piece, probably three in all.

One of my goals is to see if the piece (and the process of writing it) can ‘evolve’ over time; by generating many versions of each major unit of the piece and choosing the one I like best - perhaps one per day - I hope to gradually improve the melodies and the probabilities to make better versions; constrained randomness generating a kind of feed-back into the compositional process. In the end i’m hoping this will be something better (or a least different) from what I would have created just sitting down and deliberately selecting each note. At the same time, though, I don’t want to dive into something totally aleatoric - I still want some control. I’m not hoping for something radically different to come about because of all this - just for the way that I write music to be altered enough so that what I create is a variant of what I would have created.

At any rate, I needed some code to do this and this post shows the beginnings of that effort. So here’s the ruby code to generate a sequence of melodies - using a markov chain of course. It only spits out the array index number of each melody in the sequence (5 in all) - it’s designed to tell me what order the melodies should be played in, always starts on 0, and will append melody numbers to the sequence until it reaches the maximum value passed into the initialization method. A lot of the inspiration for this code plus some other (probably superior) ways of accomplishing this can be found at

class RiffSelector
  def initialize(riffCount)
    # define the markov chain for the riffs...
    @chain = [[0, 1, 0, 0, 1], [0, 0, 1, 2, 0], [0, 1, 0, 1, 0], [0, 0, 2, 0, 1], [1, 0, 1, 0, 0]]
    # the starting state...
    @current = 0
    # the eventual list of riffs (with doublings)...
    @result = "0"
    # loop through, appending the next riff in the chain...
    (1..riffCount).each do
      nextState = getNext()
      @result += ', ' + nextState.to_s

  def getNext()
    probs = @chain[@current]  # the array of probabilities of what state will be chosen next given the current state
    total_prob = 0# the sum of all the probabilites
    probs.each { |prob| total_prob += prob }
    random = rand(total_prob.to_i) + 1# pick a random number within the range of 1..[sum of probabilities]
    likelihood = 0
    for state in (0..(probs.length - 1))# loop through each of the states
      likelihood +=  # sum probabilities as we go so that we'll eventually have a high enough number to equal the total_prob
      for iter in (0..likelihood)
        if random < = iter  # iterate through until we reach or exceed the random number chosen earlier or until we run out of 'likelihood'
          @current = state
          return state

  def getChain()
    return @result

foo =  # pass in the number of riffs to put into the chain
puts foo.getChain()