Gilbert Lister Research : GoldenPond

About

GoldenPond is an experimental music notation / domain-specific programming language which adds higher level intentions or goals using the concepts from functional harmony. You express music in terms of chord degrees and modifications, rather than mere descriptions of notes. So you can say what the music is trying to do, rather than just what it does.

The aim is to help computer based composers and live-coders, including this author, to understand and apply more "advanced" music theory ideas by making them explicit and easy to express in the language.

GoldenPond was inspired by my frustration at realising that code offered so much expressivity for composing music, but that so much live-coding seemed stuck in replicating the behaviours of equipment designed for minimal loop-based music. We could describe a chord progression in a few keystrokes, but end up continually fiddling with a number representing the cutoff frequency of a low-pass filter. Text is a wonderfully expressive medium, but we're using it as the world's least ergonomically efficient knob!

Ultimately I'm guided by the question: "could a music programming language be expressive enough that it would be possible to live-code music of the complexity of a Mahler Symphony, on the fly?" What abstractions would such a language need? And would such a practice be viable, either technically or artistically?

Try GoldenPond

The easiest way to play with GoldenPond is to try the experimental browser version here.

You can type the chord progression using the Chord Language into the Chord Sequence box. And set the other parameters, and the individual rhythmic / melodic lines in using the Rhythm Language. Then press the [Play] button in the top button bar.

Note : You may need to wait a few seconds before the instrument voices fully download. You can switch on and off various parts. And set their rhythms with the new Rhythm Language.

GoldenPond is also available for FL Studio; as a Piano Roll Script. Get it here. And see this for information of how to install and run piano roll scripts. It comes with a custom UI as shown above.

GoldenPond is now available as a Python library on PyPI : https://pypi.org/project/goldenpond/

You can also get the code on GitHub : https://github.com/interstar/golden-pond. Note that GoldenPond is now written in the Haxe programming language. From which it is transpiled to Python and Javascript. If you want to contribute to the codebase the best option is to work directly on the Haxe code. If you aren't a Haxe programmer but have made improvements directly to the Python or JS code, get in touch and we can talk about maybe moving some of your suggestions into the Haxe codebase.

Tutorial

Chord Language

Basic chord progressions are represented as a list of numbers for the degree of the scale.

Eg 1,4,6,5 is a classic 1-4-6-5 four chord loop.

It's important to note we always interpret this in the context where the key is set. We tell GoldenPond if we're in C-Major or A-flat Minor etc. And the chords are calculated based on that key signature.

Extended chords can be created by adding the digits 7 or 9 to the front. So 74 is the seventh built on the 4th degree. 92 is the ninth built on the 2nd degree.

Chord Inversions are added with a number of i suffixes. Eg. 6ii is the second inversion of the 6 chord. The extension and inversion notation is composable. 73i is the first inversion of the 7th built on the 3rd degree.

Modal Interchange ie. borrowing from the parallel major / minor is done with the -. So if we are in C-major, then -4 means the 4 chord from C-minor. If we were in D minor, then -4 would be the 4 chord from D-major

Again modal interchange is composable. In C-major -93iii is the third inversion of the ninth built on the 3rd degree of C-minor.

Secondary Chords We can temporarily "tonicize" ie. treat as tonic, one of the other degrees of our scale. And then borrow a chord from that key. (5/3) is the secondary dominant, ie the 5 chord of the key where our current 3 chord is the tonic or 1 chord. This is typically used because the dominant of any key is a great chord to lead to the tonic of that key. So (5/3),3 is a really strong way to get to the 3 chord. But we can also try more exotic combinations. (2/4),4 will give us the 2 chord of the key where our current 4 chord is the tonic.

Again, secondary chord notation composes with everything else : -7(6/3)i is the seventh chord on the 6th degree of the scale where our 3 is tonic, but with the opposite mode and in the first inversion. See how we can get some quite complex chords, expressed in a very concise (but not too obscure) way.

Transposition uses a special notation in place of a chord. We use >n and <n to tell the chord sequence to transpose up or down n semi-tones from here on out.

For example if we interpret the progression 1,4,3,>1,6,4,5 in C-major, we'll play the 1, 4 and 3 chords, then set the default key to 1 semitone higher, ie. C#-major, and play the following 6,4,5 sequence in that key.

Note if you are looping, it's most like that the chord sequence is generated once, and looped by the hosting environment. So when you return to the beginning of the loop you will be back in C-major again. There is (currently) no looping notation within GoldenPond.

Rhythm Language

The Rhythm Language is a simple way to extract notes from chords.

It consists of a pattern of Note Selector and rests, followed by a space, and then a density.

For example : 1.1. 2

is a pattern of 4 steps. On the 1 and 3 of these steps we take the first note (the root note) of the current chord. This pattern repeats twice over the chord duration. So, for a four chord progression, we repeat this pattern of 4 steps a total of 8 times.

And play the root of the current chord on the 1 and 3 of the pattern.

Patterns don't have to be regular multiples of 2 or 3, of course.

We could define an arpeggio in a 7 step pattern using 1.2..3.

Because we don't know the exact number of notes in a chord, when writing these patterns, we can also represent arpeggios with > and <, meaning "up" and "down". A simple upward arpeggio might be >.>.>.>. If the chord is a seventh, with four notes, this will play all of them. If it's only a triad, the last > will wrap around to the first note again. We can combine ups and downs with explicit note selections : 2.>.<... plays the second note in the chord, then the third, then the second again.

Some other note selectors

• t : selects the top note of the chord
• r : selects a random note from the chord
• = : repeats the last note that was selected.

with patterns made of explicit numbers, >, <, =, r and t we have a rich vocabularly for defining our riffs.

We can also use the Euclidean rhythm algorithm as a short-hand for generating these patterns. We write this with just two numbers, k and n, separated by a slash. Then this is followed by a space, a note-selector, another space and the density.

For example :

3/8 < 2 means the Eucldidean rhythm of 8 steps (n=8), on which 3 (k=3) notes are played. The notes are all < which is the downward arpeggio selector. So it's a downward arpeggio in the tresillo or son clave rhythm which Euclidean k=3, n=8 corresponds to. Because density is here set to 2, it means we play this whole 8 step pattern twice, in the period of each chord in the pattern. Adjust this density value to find the speed and rhythm that makes sense.

Sometimes our algorithm doesn't give you the spread starting exactly where you want it, so we can also offset the step within the pattern which we start from. 3/8+2 1

Each line in our music can be defined with a separate rhythm pattern like this.

Listen to GoldenPond

Experimental label, Dionysian Industrial Complex recently released an album from Mentufacturer, of experiments with GoldenPond. Each track takes a GoldenPond chord-progression, and then constructs a finished piece by adding melodies to it.