Now, what if a tracker could be scripted by some programming language to save time spent on typing and copy-pasting notes/effects in the patterns? Or, what if some AI was trained to construct rhythms and chords and melodies for you?

This is what Fugue is about.

It started as an idea for the ProductHunt hackathon and it is only the beginning of the project. I have hardly written a few pages of code so far. I am using Go because it feels much more productive comparing to C++ or Rust (it’s very subjective, and all these languages are nice, but I feel the most productive with Go).

I will be using github.com/zserge/webview for desktop UI, github.com/thestk/rtaudio for audio playback. Potentially, I am thinking about using gopherjs to get a web version as well as gomobile to support Android/iOS.

So, wish me good luck and stay tuned!

It’s been a month since I last talked about Glitch here, but it has been a very productive time, which has totally changed my vision of Glitch and its future.

And old ox makes a straight furrow

The original Glitch was written in React and ES6 and worked good enough in modern Chrome browsers. It was a quick and “trendy” way to make web apps. I foolishly hoped the same webapp would run on mobile and on desktop (using Electron), I also hoped people would extend it by writing JavaScript plugins.

It’s 2016 here and web is still a disappointment.

But Glitch never worked well even on the most high-end Android phones, Glitch wasn’t capable to using PulseAudio or Jack on Linux to let me play along using other synthesizer apps, Glitch even failed to play more-or-less complex music on some decent multi-core PCs!

That’s where I had to recall that I’m still a good low-level programmer and rewriting Glitch in C should not be that hard. The core of glitch — the expression evaluation engine — has been rewritten in a couple of days, covered with tests and all the memory leaks have been fixed. It’s now available here — https://github.com/zserge/expr.

The library of music functions (instruments, sequencers, effects) took some time, but now all of the original glitch functions are supported. Then I used Emscripten to translate C into JavaScript and it really boosted the performance of the web app, especially on Firefox! Chrome also did a much better job at optimizing asm.js code comparing to the full-featured JavaScript.

As you know, these days JavaScript is not a language that one can write in notepad and press F5 to see the changes. It requires a number of compilers (for JSX, for ES6, for Less/SASS), a build system (webpack) and a heap of other stuff behind the curtains. So after I plugged my new fast JavaScript code into the old Glitch setup — my builds slowed down to ~40 seconds each time.

At this point I started really miss the old-school JavaScript development, but Mithril.js came to the rescue.

I opened vim, started index.html and styles.css, dropped in mithril.js for UI components and then wrote just one big JS file — the identical Glitch web app, written in one day, using no build system and no compilers. Yes, it won’t run on some old browsers, but the original Glitch failed to run there, too, because of its slowness.

So this new Glitch-rewritten-in-C is the app that you can see at http://naivesound.com/glitch. It has the same look, the same functionality, but works much faster. That’s how old school technologies have saved a project.

New features

The general syntax of Glitch remained unchanged, but there are some new things added.

The most important one is constants for notes and drums. These are just variables written in caps that should not be modified as they contain some useful pre-defined values. For example, to define a sequence of notes you may now write their names:

sin(hz(seq(240, C4, D#4, F4, D#4)))

Also, for TR808 drums you may not keep in memory drum numbers, you can use abbreviations — BD (bass drum), SD (snare drum), MT (middle tom), HH (high-hat), OH (open hat), RS (rimshot), CP (clap), MA (maracas):

mix(tr808(BD, seq(120,1,0)), tr808(SD, seq(120,0,1)), tr808(HH,seq(120*2,1)))

Next, sequencers now can take a pair of values for tempo — the optional first number would be the initial offset in beats. That’s how the drum pattern above could be rewritten as shown below (snare drum is offset by half of a beat from the bass drum):

mix(tr808(BD,seq(60,1)), tr808(SD,seq((0.5,60),1)),tr808(HH,seq(240,1)))

I’ve also added the hpf(signal, cutoff) function. Although it can be implemented by subtracting the low-pass filter output from the original signal, I find it too long to type.

Finally, I’ve added the great delay(signal, time, level, feedback) function, which enriches sound a lot. It takes a current signal value, delay time in seconds, a delay mixer level (0..1) and a feedback amount (0..1) which affects the repetition of the delayed signal.

You can hear delay in action — try moving your mouse to modify delay level and feedback parameters.

What’s next?

Well, I had to give up on Electron version because it wouldn’t support JavaScript plugins and it would be too slow. I’m waiting for WebAssembly to become a mainstream, that would make web version of Glitch even faster.

Meanwhile, I’m working on a desktop version of Glitch. It’s a command-line app at the moment and it runs well on Linux, Window and Mac, using low-level audio libraries. I was able to make the beat and bass in Glitch and played the piano using Pianoteq at the same time without any sound lags.

But the major difference of desktop Glitch comparing to the web app is that you can use your own samples — each sample would appear as a Glitch function, samples can be grouped in folders and a function parameter can pick one of the sample variants. So Glitch is now a programmable sampler!

Also I find it much more convenient to use a decent text editor that updates the playback when I save the file, than using a browser.

I’m thinking about adding live MIDI input and output capabilities to Glitch, as well as maybe live audio input so Glitch could be used to process guitar sound or voice. Also, I can’t stop thinking about Glitch on mobile, I think that would be a nice toy to play with.

And of course I’m looking forward for the feedback from Glitch users! If you miss some sound effects or some helpful functions — please file an issue on Github or submit a pull request.

So, what would you like to see in the next version of Glitch? Or what would you like to hear in the next post?

At the beginning there were drums

Let’s define the tempo of the song and drop in some drum synthesizers like the ones created in the previous article.

bpm=120,

kicks=seq(bpm, 1, 0),
snares=seq(bpm, 0, 1),
hats=seq(bpm*4, 0.1, 0.2, 0.1, 0.2, 0.1, 0.2, 0.2, 0.1),

kick=env(0.01, 0.12, 0.3, 0.1, 0, (sin(83)-128)*kicks+128),

snaretone=env(0.005, 0.02, 0.3, 0.05, 0, (sin(220)-128)*snares+128),
snarenoise=env(0.02, 0.03, 0.2, 0.04, 0, (r(15)*snares)+128),
snare = (snaretone + snarenoise + 128 — lpf(snarenoise, 100))/2,

hat=env(0.01, 0.05, 0.2, 0.05, 0, r(30)*hats+128),
hat=hat+128-lpf(hat, 10000),

mix(kick,hat,snare)

The tempo is a common one, 120 beats per minute. Every even beat is a kick, every odd beat is a snare. It’s a typical pattern for a very simple drum track, boom-tsch-boom-tsch-…

Adding the quiet percussive sound of hi-hats makes our drum track less monotonic.

The drums are synthesized using sine wave and white noise. Kick is a low-pitch sine wave that simulates the membrane of a kick drum quickly fading out after it’s kicked. Hi-hats is just a short impulse of noise. Snare is both, tone of a drum at the beginning and noise at the end mixed together.

You can hear the result here.

The present has no rhythm

Let’s implement the chord progression of the song. Quick googling shows that it’s Bm, D, F#m, E changing in a loop. Each chord is being played during 4 beats.

Here chords are simple triads, meaning that each of them consists of three notes — the root, the third and the fifth. Glitch uses numbers for note positions where zero is A4 (note A of 4th octave):

A  A# B  C  C# D  D# E  F  F# G   G#  A   A#  B   C   C#
0  1  2  3  4  5  6  7  8  9  10  11  12  13  14  15  16

There are some cheatsheets to look up the notes of a chord quickly.

Bm chord includes B, D and F#. That is [2, 5, 9]. D chord includes D, F# and A, or [5, 9, 12]. F#m chord includes F#, A, C#, or [9, 12, 16]. Finally, E chord includes E, G#and B. That is [7, 11, 14].

bpm=120,

i  =seq(bpm/4, 2, 5,  9,  7)-12,
iii=seq(bpm/4, 5, 9,  12, 11)-12,
v  =seq(bpm/4, 9, 12, 16, 14)-12,
pad=(sin(hz(i))+sin(hz(iii))+sin(hz(v)))/3,
pad=0.5*env(0.01, 0.45, 0.7, 1.3, 0, pad)

Here we have three sequences for root notes, triads and fifths of each chord. Each column is a chord. We transpose each chord one octave down to make it sound lower. Each note is played with a sine oscillator which has a soft sound. Oscillators are mixed by adding the amplitudes and dividing the sum by three to normalize the range. Resulting signal is wrapped into an envelope with fast attack and slow release. You can hear it here.

Arpeggio

Just strumming chords one at a time is boring, but we can easily add some arpeggios. We already have the notes of each chord in the given order. Let’s play them quickly: root, third, fifth, third, root, third etc. Let’s use an FM-synthesizer as an instrument — it’s very easy to setup and it still sounds more interesting than a single oscillator:

bpm=120,

i  =seq(bpm/4, 2, 5,  9,  7)-12,
iii=seq(bpm/4, 5, 9,  12, 11)-12,
v  =seq(bpm/4, 9, 12, 16, 14)-12,
pad=(sin(hz(i))+sin(hz(iii))+sin(hz(v)))/3,
pad=0.5*env(0.01, 0.45, 0.7, 1.3, 0, pad),

arp=0.2*fm(hz(seq(bpm*2, i, iii, v, iii)), 1, 0.2)+127,

mix(pad, arp)

As you can see it’s the same code we used for chords with one more arpeggio sequence. You may try to adjust some parameters. For example, changing arpeggio tempo from bpm*2 to bpm*4 or bpm*3 gives interesting results. Also try changing FM operator parameters from 1 and 0.2 to some other numbers and see how the sound changes.

Bass

Our bass line will be simple, it will be using the same notes from the chords, as we did with arpeggios. Let’s use the root (i) and the fifth (v) notes only and let’s use different oscillators, sine and triangular. Here we transpose the notes two octaves down because bass is a low-pitch instrument and should sound lower than chords or arpeggios:

bass=(tri(hz(i-24))+sin(hz(v-24)))/2

Mixing bass to pad and arpeggio adds some solid bass sound, but we definitely can improve it. Let’s add some tremolo effect like if someone quickly picks the bass string with fingers.

This means that for each bass note in the bass line we need to play it several times, quickly, wrapping it with some quickly fading envelope:

tremolo = env(0.01, 0.1, 0.03, 0.1, 0, bass*seq(bpm*4, 1, 0.5, 0.6, 0.8))

Here we use the bass signal and modulate its amplitude using sequence of volumes (1, 0.5, 0.6, 0.8) for each note. Using slightly different (or even random) volumes for notes is an easy way to avoid “artificial” or “robotic” sound in algorithmic music. The tempo is four times higher, so each note is played four times with its own envelope as if it were four separate notes.

Let’s hear chords, arpeggio and bass mixed together.

Ends with beginnings

Our song now has a drum track, a synth pad track with chords, FM-synth doing arpeggio and a tremolo bass. The final touch would be to turn this four-chord loop into a full song. Let’s add the instruments one by one and then slowly remove them.

Such layering is a very popular orchestration technique, not only limited to electronic sequencer music. You can hear it in Wim Mertens’ works, in many canons and rounds, even in Ravel’s “Bolero”.

To implement layering we could write lots of if/else operators (in glitch they are && and ||), but this is a perfect case for bit-wise arithmetic to shine in all its glory.

Let’s assign a number to each part. Drums would be zero, synth pad - 1, arpeggio - 2 and bass would be 3. If a corresponding bit in a number is set — the instrument is playing, otherwise it’s muted. For example, if a song part code is 5 (or 101 in binary), it should play drums and arpeggio, but if the song part code is 6 (or 110 in binary), it should play chords and arpeggio with no drums or bass. We can now create a sequence of song parts and use mixer to mute/unmute certain instruments.

Here’s the full code of the song:

bpm=120,

part=seq(bpm/4/4, 1, 3, 7, 15, 15, 15, 15, 10, 3),

kicks=seq(bpm, 1, 0),
snares=seq(bpm, 0, 1),
hats=seq(bpm*4, 0.1, 0.2, 0.1, 0.2, 0.1, 0.2, 0.2, 0.1),

kick=env(0.01, 0.12, 0.3, 0.1, 0, (sin(83)-128)*kicks+128),
snaretone=env(0.005, 0.02, 0.3, 0.05, 0, (sin(220)-128)*snares+128),
snarenoise=env(0.02, 0.03, 0.2, 0.04, 0, (r(15)*snares)+128),
snare = (snaretone + snarenoise + 128 — lpf(snarenoise, 100))/2,
hat=env(0.01, 0.05, 0.2, 0.05, 0, r(30)*hats+128),
hat=hat+128-lpf(hat, 10000),

i =seq(bpm/4, 2, 5, 9, 7)-12,
iii=seq(bpm/4, 5, 9, 12, 11)-12,
v =seq(bpm/4, 9, 12, 16, 14)-12,
pad=(sin(hz(i))+sin(hz(iii))+sin(hz(v)))/3,
pad=0.5*env(0.01, 0.45, 0.7, 1.3, 0, pad),

arp=0.2*fm(hz(loop(bpm*2, i, iii, v, iii)), 1, 0.2)+127,

bass=(tri(hz(i-24))+sin(hz(v-24)))/2,
tremolo = env(0.01, 0.1, 0.03, 0.1, 0, bass*seq(bpm*4, 1, 0.5, 0.6, 0.8)),

mix((part&1,kick), (part&1,snare), (part&1,hat), ((part>>1)&1,pad), ((part>>2)&1,arp), ((part>>3)&1,tremolo))

It starts with just drums, then chords are added, then arpeggio, then bass. Then after a few bars it goes back to drums+bass+chords, drums+chords and just drums again.

You can hear or tweak the final version of the song here.

Glitch is a minimal open source algorithmic music composer that uses simple mathematical formulas to describe music. It’s easy to learn (it’s all just arithmetic expressions), easy to use (runs in your browser), easy to share (just send a link).

But moving from bytebeat and oscillators to actual music might be difficult for newcomers. Let’s see how you can make synthesized kick drum, snare and hi-hats with just a few lines of Glitch.

Hi-hats

Hi-hats are probably the easiest ones to synthesize because they are basically white noise. It can be generated by the r() function (a random number generator). Adding an envelope to the white noise makes it sound more like a drum. But white noise contains some low frequencies in it, so to make our hats sound higher we will subtract a low-pass filter signal from it:

hat=env(r(128), (0.01, 1), (0.01, 0.1), (0.05, 0))
hpf(hat, 10000)

Here’s an example of playing some sequence of beats with hi-hats:

bpm = 120
hats = seq(bpm*4, 0.1, 0.2)
hat=env(r(128)*hats, (0.01, 0.1), (0.05, 0))
hpf(hat, 10000)

You can try it here.

Kick

Kick (bass drum) has a low pitch. Let’s start with sin(50) as a drum oscillator. Now let’s make a contour of the sound similar to a real kick drum. It should have a fast attack and a short release tail (click the link to play it in Glitch):

kickhz=50, env(sin(kickhz), (0.001, 1), (0.1, 0))

A slightly better sound can be achieved if we an envelope curved:

bpm=80,
kicks=seq(bpm*4, 1, 0, 0, 0.6),
kickhz=50,
kick=env(kicks*sin(kickhz), (0.1, 0.3), (0.1, 0)),
kick=lpf(kick, 250)

It wouldn’t hurt to add a low-pass filter to make our bass sound deeper. You can try it here.

Snare

It’s an interesting drum because it starts with a short clear pitch that is quickly mixed with some high-pitch noise. It’s loud and has staccato sound which means it’s short and sharp.

Let’s start with a tone, say 220 Hz. I picked it randomly, I think snares are tuned somewhere in the range 200..300 Hz.

snarehz=220
snaretone=env(sin(snarehz), (0.005, 1), (0.01, 0.2), (0.03, 0))

You’re right, it sounds more like kick (because we used a similar envelope and the same oscillator). Now let’s add some noise to it. Noise will have slower attack:

snarehz=220
snaretone=env(sin(snarehz), (0.005, 1), (0.01, 0.2), (0.03, 0))
snarenoise=env(r(), (0.02, 1), (0.03, 0.2), (0.04, 0))
(snaretone + snarenoise)/2

A better sound can be achieved by tweaking the envelope curve and filtering out the low frequencies from the noise:

bpm=120
snarehz=220
snares=seq(bpm*2, 0.5, 0.1, 0.5, 0.2)
snaretone=env(snares*sin(snarehz), (0.005, 1), (0.01, 0.2), (0.03, 0))
snarenoise=env(snares*r(), (0.001, 1), (0.02, 0.01), (0.01, 0))
snare = (snaretone + snarenoise)/2

The resulting drum can be heard here.

Example

Here I combined all three drums into a simple drum pattern used in many rock songs. It’s built upon the same formulas, just with slightly different coefficients:

bpm=80
kicks=seq(bpm*4, 1, 0, 0, 0.6, 1, 0, 0, 1, 0, 0, 0, 0.2, 1, 0, 0, 0)
kickhz=50
kick=env(kicks*sin(kickhz), (0.001, 1), (0.05, 0.3), (0.1, 0))
kick=lpf(kick, 150)
hats=seq(bpm*4, 0.7, 0.5, 1, 0.5, 0.7, 0.5, 1, 0.5, 0.7, 0.5, 1, 0.7, 0.7, 0.5, 0.7, 0.5)
hatfilters=seq(bpm*4, 1, 1, 2, 1, 1, 1, 2, 1, 1, 2, 2.5, 1, 1, 2, 1)
hat=env(r()*hats, (0.01, 1), (0.03, 0.2), (0.02, 0))
hat=hpf(hat, 1000*hatfilters)
snares=seq(bpm*4, 0, 0, 0.5, 0)
snarehz=220
snaretone=env(sin(snarehz)*snares, (0.005, 1), (0.01, 0.2), (0.03, 0))
snarenoise=env(r()*snares,(0.02, 1), (0.03, 0.2), (0.04, 0))
snare = (snaretone + snarenoise)/2
mix(kick, 0.3*hat, snare)

You can open it in Glitch and adjust to your own taste. Or would you like to build your own drum pattern with Glitch?

Glitch is a minimal open source algorithmic music composer that uses simple mathematical formulas. It’s easy to learn (it’s all just arithmetic expressions), easy to use (runs in your browser), easy to share (just send a link).

Many curious minds today experiment with algorithmic music composition and programmable music. In most cases this means configuring some software and learning some new programming languages.

Glitch aims to combine the simplicity of Bytebeat with the flexibility of a full-featured programmable music environment.

The core idea of Glitch is borrowed from Bytebeat — a musician enters a math expression, then Glitch evaluates it for each discrete time frame and the returned values describe the amplitude of the waveform. Output is assumed to be in the range [-1..1] and it is clipped if it goes beyond the given range. You can use mathematical expressions, variables and some functions. Everything is a number, which means you can combine things easily by passing numbers from one function to another. Now, how many functions shall we add to turn Glitch into a real music programming tool?

Oscillators

With Bytebeat techniques turning input time variable t into a waveform is likely to result in a saw-tooth or square wave and that’s why you get that buzzing sound. To get something more melodic we would probably need to have sine and triangular oscillators. So, Glitch now has some oscillator functions:

• sin(freq) — generates sine wave of the given frequency
• tri(freq) — generates triangular wave of the given frequency
• saw(freq) — generates saw-tooth wave of the given frequency
• sqr(freq, [width]) — generates square wave of the given frequency. Pulse width can be specified, too. By default it’s 0.5.

All these functions advance the oscillator phase internally and apply the frequency changes in a smart way to reduce clicks. For example, the formula w=(t>>10)&7,(tri(w*220)+sin(w*220))/2 (click it to open in Glitch) mixes together triangular and sine oscillators playing the same frequency (which varies as time t increases). Here we normalize the volume dividing it by two to avoid buzzing when amplitude overflows.

Oscillators can be combined in parallel (like in the example above when amplitude values are added) or sequentially, when output of one oscillator becomes the input of another one, e.g. w=(t>>7)&31,sin(100*tri(w*4)+400). Here the w value (which varies in time in the range 0..31) is an input to the triangular oscillator which generates a signal with some low frequency. The output of that oscillator modifies the frequency of the outer sine oscillator and it results in a frequency-modulated sound in the diapason 400..500 Hz.

Don’t forget that there is also a special r([max]) function which returns a random number in the range [0..max). It can be used as an oscillator in some cases (e.g. synthesizing drums).

FM synthesizer

A better way to build frequency-modulated sound is to use a special function fm(freq, [f1, a1, f2, a2, f3, a3]). The function imitates a 3-operator FM-synth with the following topology:

If you’re unfamiliar with how FM synthesis works — you can read more here.

The fm function is a roughly equivalent of sin(freq + a1*sin(freq*f1 + a3*sin(freq*f3)) + a2*sin(freq*f2)).

Don’t panic if this formula looks complicated. Let’s see what happens if all parameters except for the frequency are set to zero. In this case fm(440) is identical to sin(440) and you will hear a simple sine wave. Now, let’s configure the first operator. It affects the frequency of the main (carrier) oscillator. The first parameter f1 is the frequency multiplier. Let’s set it to 2 so that our oscillator #1 will be running at frequency 2*440= 480 Hz. Also, to make it audible let’s set amplitude gain a1 to 1. We get fm(440, 2, 1) function which is identical to sin(440 + sin(880)) and you can hear how the sound gets some higher pitches and how it varies in time. Try tweaking f1 and a1 parameters to hear how they affect the main oscillator.

Now you can enhance your synthesizer by adding another oscillator in parallel (changing f2 and a2). In this case the output of those two oscillators will be summed and used to shift the frequency of the main oscillator. Or you can set f2 and a2 to zero using f3 and a3 instead. The output of the third oscillator will be forwarded into the first oscillator that controls the main oscillator. Compare how fm(440, 0.5, 0.5, 0, 0, 0.5, 0.8) differs from fm(440, 0.5, 0.5). Of course nothing stops you from setting parameters to all three oscillators, so feel free to share if you get an interesting sound!

This FM topology is simple enough to understand and allows to build a basic single-operator FM synth, two-operator FM synths O1+O2 and O1(O3), and a more complex O1(O3)+O2 variant. Did I mention that you can combine multiple FM synths as well since they are just functions?

Notes

Playing a single tone is boring. Let’s play some tunes. But how can we write a melody without notes? Well, we can use frequencies… In the first version of Glitch there was a special “array” function a(index, [a0, a1, a2, …]) which returns its argument defined by the index. Index will overflow if it goes out of the array range and it is the most simple sequencer you can build — for example sin(a(t>>10, 440, 523, 659)) plays a simple arpeggio looping though A4, C5 and E5 notes.

But nobody wants to remember all note frequencies. That’s why new Glitch has a helper hz(note) that returns note frequency for a given note. Zero stands for A note of the 4th octave. You can also use floating point note values to get microtonal music.

Another helper function is scale(note, [mode]) which returns the note at the given position in the given scale. Default mode is Ionian mode, which is a traditional major scale. Modes 1..6 are dorian, phrygian, lydian, mixolydian, aeolian and locrian modes. If you’re unfamiliar with music theory just remember that zero is major scale and five is minor scale. There are two other minor scales — harmonic minor which is mode #7 and melodic minor mode #8. Guitar players may probably check out the pentatonic scales: #9 is major pentatonic and #10 is minor pentatonic. #11 is a blues scale. #12 is whole tone scale and #13 is octatonic scale. Values above 13 fall back to the chromatic scale, the one that includes all 12 notes in a row.

Sequencers

Thinking in notes instead of pitches simplifies things, but we also want to think about rhythmic patterns, not just arrays of numbers. So here two sequencer functions:

• loop(bpm, …) — loops though its arguments at the given tempo
• seq(bpm, …) — very similar to loop, but evaluates arguments only once per beat

You might be confused with the difference, so let’s see some examples.

sin(hz(seq(240, 0, 5, 9, 5))) — plays arpeggio from the major scale at a tempo of 240 beats per minute.

Now let’s play nested sequences, for example playing two arpeggios changing each other. If you write sin(hz(seq(30, seq(240, 0, 5, 9, 5), seq(240, 1, 6, 10, 6)))) you won’t hear the expected result. That’s because seq function evaluates the arguments only once and stores it for the rest of the beat. Changing the outermost seq to loop fixes it.

As a rule of thumb — use seq for sequencing plain notes, use loop for scheduling inner sequences.

Inside seq you’re safe to use r() function because it will be evaluated once and will not produce the white noise. Instead it will return a single random number for each beat. Using loop and seq also produces an interesting side effect when the inner sequence is longer than the time granted by the outer loop. In this case the inner sequence will be rolled on each call. You may experiment with irregular tempo ratios to get interesting rhythmic patterns.

Shape of sound

Now we can play tunes but our oscillators have constant volume. You can provide an envelope to your signal to make it sound like a real instrument — with attack (rapid volume rise), release (volume fade out) and other parameters. There is a special variadic function env(signal, (dt, val), (dt, val)…) that wraps signal into some envelope shape. Without parameters env(sin(440)) plays an unaltered sine wave.

It’s quite common to use so-called percussive envelopes (the ones with attack and release only). In Glitch env(sin(440), (0.5, 0)) becomes a fading out beep of 500 milliseconds, env(sin(440), (0.5, 1), (0.1, 0)) has attack time of 0.5 second and release time of 0.1 second which sounds like fade-in and cutoff. You can give a more complex envelope, for example env(sin(440), (0.01, 1), (0.1, 0.7), (0.1, 0.3), (0.1, 0)) which results in quick attack (10ms), at 110ms the volume will be 70%, at 210ms it will be 30% and at 310ms it will be back to zero.

Now, you may have noticed that an envelope is played only once. How to reset it? All functions in Glitch take numeric parameters and return numbers. However there is a special “not-a-number” value that has very specific meaning, namely — to reset envelops, effects and oscillators. Not-a-number value is returned by the sequencers automatically when the beat changes and this value is propagated from one function to another so the envelope function will definitely receive it.

Effects

To keep Glitch simple there is only one sound effect available at the moment — a low pass filter. The function lpf(signal, [freq]) cuts off all the frequencies below the given one (which defaults to 200 Hz) and returns a modified signal. What about high-pass filters? Since lpf returns a signal without high pitch frequencies — you can build high-pass filters by subtracting the lpf value from the main signal. You can nest low pass filters and apply them multiple times. You can also vary the cutoff frequency value with some low-frequency oscillator and get some interesting vibrato effect.

Mixing signals

In your music you are likely to have a number of instruments and parts. If you just add their signals, you can also divide the sum of signals to normalize them, but there is a special helper function mix(…) that does it for you. Depending on the number of inputs, mix adds them and normalizes. It also softly clips the output signal to avoid the unexpected overdrive effect.

Summary

Here’s a full list of all Glitch functions available. We’ve added 15 functions which are easy to remember and to use:

• Oscillators: sin(freq), tri(freq), saw(freq), sqr(freq, [width]), fm(freq, …)
• Sequencers: loop(bpm, …), seq(bpm, …), slide(bpm, …)
• Utilities: a(index, …), scale(index, [mode]), r([max]), hz(note), lpf(signal, [freq]), env(signal, …), mix(…)

To sum up my theoretical story — here’s a quick demo song I’ve recently made with Glitch:

Glitch is a minimal open source algorithmic music composer that uses simple mathematical formulas. It’s easy to learn (it’s all just arithmetic expressions), easy to use (runs in your browser), easy to share (just send a link).

Bytebeat (sometimes known as glitch music) is a relatively new experimental genre of electronic music. If you are familiar with retro “chiptune” music you can imagine how it sounds — triangular or square waves making rhythmical scratching noises.

What’s so cool about Bytebeat music if it sounds so harsh? Mathematics. If numbers and formulas is a hard subject to you — most likely you will find Bytebeat music boring. Otherwise, let’s start making sound.

Audio engine

Glitch has no conventional musical notation — there are no notes or chords or even instruments. All you have is a mathematical expression that is evaluated for each time frame to generate the next amplitude value of the sound wave.

Historically, Bytebeat sound is created using the uint8_t data type, which is an unsigned 8-bit integer. It means the lowest possible amplitude level would be zero, and the highest possible would be 255. If you attempt to put values outside of this range — there will be an overflow (256 becomes 1, 257 becomes 2, -1 becomes 255, -2 becomes 254 etc).

Since Glitch was designed to create different kinds of music, it uses a range from -1 to 1 which is typical for the digital sound. In order to convert the historical [0, 255] range to a common [-1, 1] range one can use the built-in “byte()” function, which also controls the overflow if needed.

Glitch provides you with a special variable “t” that gets increased for each evaluation cycle. A simple expression of “byte(t)” produces a sound wave that linearly increases in time and overflows once it reaches the upper limit of 255. That’s how you can play a saw-tooth sound wave.

The frequency of the wave depends on how fast the “t” variable is increased. Most Bytebeat songs are played at 8000 Hz sample rate, so “t” is increased once in every 1/8000 sec = 0.125 ms. The maximum allowed amplitude will be reached in 256 steps, so “t” will reach the overflow point in 256*0.125 ms=0.032 sec. Which means the frequency of the sound wave will be 1/0.032=31.25 Hz. It’s within the audible range, but most likely will sound more like a low-frequency clicking rather than an oscillating sound. You may multiply “t” by some constant value to speed up the increment making the overflows happening more often and increasing the frequency of the sound. For example, “byte(t*8)” results in the saw-tooth wave at 32.25*8=250 Hz.

Saw-tooth wave is probably the most common oscillator function used in Bytebeat music. Now, how can we put a melody into a formula?

Bitwise magic

Probably Bytebeat music gained its popularity when SIGINT13 gave this talk “Making music with C compiler”. He has shown a really minimal approach of making digital music on a computer without any audio workstations or other traditional audio software. He wrote a short C program, ran it and redirected its output into a command-line audio player (aplay). Here’s the sample program:

main(t) {
  for(t=0;;t++)
    putchar(t*(((t>>12)|(t>>8))&(63&(t>>4))));
}

And here’s how it sounds:

The formula looks like magic, but it produces rhythmic pattern and even some kind of a polyphonic melody!

There have been some great attempts to create the theory of Bytebeat music but it’s still more about random discovery rather than logical step-by-step composition.

What is known is that the pitch depends on the multiplier of “t”. If the multiplier also depends on “t” somehow — you get a pitch that changes in time. “byte(t*t)” still sounds like instant buzz, but “byte(t*(t/100))” is a loop where pitch is increasing and decreasing. Restricting the pitch multiplier to certain integer values (using bitwise shift instead of the division operator and using a bitwise mask to put it into a valid range) one can get predictable multipliers.

Now, there are some “good” ratios in frequencies. For example, the frequency ratio between octaves is 1:2:4:8 etc, and the ratio between the notes in a major chord is 4:5:6.

Let’s make a major chord arpeggio (a chord broken into a sequence of notes like C, E, F, E). The tempo should be slow enough to hear the individual notes. We will be using “t>>11” as our note index. It will result in a number that increases ~4 times per second. We need to put it into a range of [4, 5, 6]. A simple approach is to make a bitwise AND with 3 then add 4. Bitwise AND will return a sequence of [0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2, 3…], while adding 4 to each number gives a sequence of [4, 5, 6, 7, 4, 5, 6, 7, 4, 5, 6, 7…]. Seven is a bit out of the chord notes range, but for the sake of simplicity we will keep it, hopefully it won’t break our melody too much. Finally, we will multiply “t” by some constant pitch multiplier and then by our variable note multiplier:

You may learn much more about different concepts of Bytebeat formulas here: http://countercomplex.blogspot.sg/2011/10/some-deep-analysis-of-one-line-music.html

Sequencer

If a melody can be represented as a sequence of algorithmically generated numbers — great, but if not — there should be a more traditional way to encode a sequence of numbers. Some composers used arrays or C strings (that are no different from arrays, really). Glitch has an array function for that — “a(index, a0, a1, a2, a3, …)” — which returns an element at the given index by modulo of the array length. For example a(t>>11, 4, 5, 6) will return a sequence of [4, 5, 6, 4, 5, 6, 4, …].

But to make our formulas look more obfuscated (and more in the spirit of Bytebeat) let’s try to encode note numbers as 4-bit parts of a 32-bit number. For example a major scale would be [0, 2, 4, 5, 7, 9, 11, 12], when written in hexadecimal it becomes 0x024579bc (or 38107580 converted back to a decimal number).

Glitch allows you to use variables and to separate multiple expressions with comma, and commas can be omitted at the end of line, so I will take advantage of this syntax to simplify the expressions. Let’s use “n” variable to denote our “sequence-encoded-as-a-number”.

Now we can take a certain 4-bit nibble at the certain offset (increased as time goes): “p=n>>(((t>>11)&7)<<2)”. Offset is ((t>>11)&7) and we multiply it by 4 because each nibble takes 4 bits.

Remember, this is a note index, not a note frequency. There is a simple way to convert note index into a frequency — (2**(1/12))**note, where “**” is a power operation. The note of 49 is A4 (fourth octave A). And 2**(1/12) is ~1.059. So the frequency of note “p” would be “t*(1.059**(p+51))”.

Easy, huh? Each 32-bit number is an 8-step sequencer where each note is in the range of 16 semi-tones, which is a bit more than one octave. Now we can juggle the sequences and make complex melodies. This is where our array function can be handy, but one can also use a short-circuit operator (&&, ||) to simulate if/then/else. For example “((t>>14)&1)&&verse||chorus” toggles verse and chorus signals every 2 seconds.

Here’s an example of four 8-step sequencers that play some C-major scale tunes:

You may listen to the result here (just click the play button).

Synthesizers

So far it’s been mostly saw-tooth waves as they are the easiest ones to implement. For your convenience Glitch also has a sine function “s(t)”. It takes a phase value in the range [0..1] and returns a sine value for the given phase. The sine wave “s(t/256)” has the same frequency as a saw-tooth wave “byte(t)”.

If you take the last formula and replace “t*(1.059**p)” with “s(t/256*(1.059**p))” — you will hear a pretty sine wave playing the same melody. You can mix multiple waves by adding them. For example “w=t*(1.059**p)/256,(s(w)+s(w/2)+s(w*4))/4” is a mix of three sine waves playing in different octaves.

You may also use “r(x)” function to get random numbers in the range [0..x] — this is how you can simulate some drums.

Using only basic arithmetics you can build complex instruments such as FM synthesizer. Here’s an example built with a regular sine wave and some rhythmic but chirpy noise along with the main melody:

Here’s a link to the formula above.

Glitch expression language

Glitch expression language is very simple and supports the following operations:

• Basic math: +, -, *, /, % (modulo) and ** (power)
• Bitwise math: &, |, ^ (XOR or unary negation), <<, >>
• Logical operations: <, >, <=, >=, ==, !=, &&, ||
• Others: comma to separate expressions, assignment to modify the value of the variables, parenthesis to group subexpressions.

There are many build-in function, but only 4 of them are likely to be used in Bytebeat: s(t) — sine wave, r(x) — random values, a(i, …) — get array element at a specific index and l(i) — binary logarithm (can be used to convert frequency back into a note).

Glitch works with floating-point numbers and operates at a higher sample rate (normally 44100Hz) which makes it possible to create sound of higher quality than 8-bit at 8 kHz. However “t” increment speed always matches the 8000Hz sample rate (it often takes rational values depending on your native sample rate). Same about the output values. It can be any floating point number in the range [-1..1] so technically it’s higher sound quality than 8-bit unless you truncate it.

Bytebeat changes the way you think about music. Instead of classical notes, instruments and effects you start thinking about signal functions and try to decode the sound you want to hear into a mathematical expression. You’re a music decomposer now.

Spend some time exploring Glitch library and try to modify existing tunes:

Or try your luck and put random operations with random values (that’s how most great Bytebeat pieces have been composed). Or write repetitive sequences of notes and play them with manually written synthesizers. Then share your creations via Twitter or by simply sending a link.

Future of Glitch

I find it very impressive when simple things turn into a complex beauty when carefully combined. Forth programming language, lambda calculus, UNIX tools and now Bytebeat music.

That’s why I want to keep Glitch clean and minimal. But what are the features you would like to see in the future versions of Glitch? Or perhaps you found a glitch in Glitch — then feel free to report it on Github: https://github.com/naivesound/glitch/issues

If you still think that Glitch might be too limited for you — check out the update.