The Nord Modular contains some modules that are useful for composition. Some of these, such as the Sequencer modules, require human interaction to define the notes and rhythms. Others, such as the pattern generators, can run on their own. There are many Nord Modular patches in the archives, often referred to as "noodles", which need no human interaction to produce interesting music. Most of these noodles are carefully hand-crafted, however, and the music is clearly man-made. The noodles are often of a fixed nature, and cannot generate radically different musical creations. But, in spite of this, the Nord Modular IS capable of pure algorithmic composition, which can generate radically different music with little human intervention beyond setting a few parameters. In this chapter we will look at a few different types of algorithmic composition that can be implemented on the Nord Modular.
The patterns produced by chaotic systems bear some similarities to
random noise, such as we use to make snare drums and so forth, but
tend to have much more structure. The chaotic patterns tend to be
"quasi-periodic", that is, the output of the system follows a regular
pattern, but not exaclty. From cycle to cycle, the patterns are slightly
different. Obviously, totally random noise is not too useful for
specifying melodies and rhythms (although some may argue to the contrary).
But chaotic patterns seem to have just the right mix of randomness
and repeatability to produce interesting music. In the following section
we present two Nord Modular patches which use different chaotic
systems to produce self-generated music.
The first patch we will look at was designed by Rob Hordijk. It
implements four simple non-linear ecosystems, defined by the
formula that Mitchell Feigenbaum used to come to his
'Chaos'-theory. The equation that governs this chaotic system is
What does all this animal husbandry have to do with the dog-eat-dog
world of musical synthesis? Well, the chaotic behaviour exhibited by
the logistic function can be used to produce interesting music.
In the patch below the X values are used to play notes,
but they could be used to control anything.
In the patch there are four separate chaotic systems implemented.
The systems can
influence each other. They can be helped by their right neighbours to
become more alive while their growth can be suppressed by their left
neighbours. Sounds like real life, don't it? Well, actually it sounds like
the Nord Modular, so don't worry, no need for peace keeping forces in your machine.
Some settings can make all four systems slowly succumb, others
can result in chaotic behaviour, and somewhere in between there should be
"easy livin'". In figure 10.1 we show the behaviour of the logistic
equation for various settings of the G parameter.
10.1 Chaos and Fractal Music
Mathematic chaos is a study of rather simple systems that produce
rather complicated behaviour. This is perfect for making music on
modular synthesizers, since we all know interesting music is complicated,
but we can't implement very complicated equations with the limited
resources of modular synths.
Figure 10.1. The behaviour of the logistic equation for various settings of the G parameter. For G less than 3, the system quickly settles to a fixed value. For G between 3 and 3.53 oscillations occur. For G greater than 3.53 chaotic dynamics result.
The patterns produced by chaotic systems bear some similarities to random noise, such as we use to make snare drums and so forth, but tend to have much more structure. The chaotic patterns tend to be "quasi-periodic", that is, the output of the system follows a regular pattern, but not exaclty. From cycle to cycle, the patterns are slightly different. Obviously, totally random noise is not too useful for specifying melodies and rhythms (although some may argue to the contrary). But chaotic patterns seem to have just the right mix of randomness and repeatability to produce interesting music. In the following section we present two Nord Modular patches which use different chaotic systems to produce self-generated music.
The first patch we will look at was designed by Rob Hordijk. It implements four simple non-linear ecosystems, defined by the formula that Mitchell Feigenbaum used to come to his 'Chaos'-theory. The equation that governs this chaotic system is
What does all this animal husbandry have to do with the dog-eat-dog world of musical synthesis? Well, the chaotic behaviour exhibited by the logistic function can be used to produce interesting music. In the patch below the X values are used to play notes, but they could be used to control anything. In the patch there are four separate chaotic systems implemented. The systems can influence each other. They can be helped by their right neighbours to become more alive while their growth can be suppressed by their left neighbours. Sounds like real life, don't it? Well, actually it sounds like the Nord Modular, so don't worry, no need for peace keeping forces in your machine. Some settings can make all four systems slowly succumb, others can result in chaotic behaviour, and somewhere in between there should be "easy livin'". In figure 10.1 we show the behaviour of the logistic equation for various settings of the G parameter.
In the figure below we show 1/4 of the entire patch, corresponding to one of the four chaotic systems (clicking on the figure will give the entire patch, however).
For the equation to work it can not start with a zero value for X, as nothing can grow out of nothing unless some "Act of God" is involved. So a provision is made that a small value is automatically added to X, only in the first cycle when X is zero due to patch loading conditions.
The following patch implements another type of Chaotic system, this one termed the Henon strange attractor. This system was discovered by the French astronomer Michel Henon while studying the dynamics of stars moving within galaxies. The equations for this system are:
The following patch uses the Henon equations to generate a quasi-periodic melody (in Eb major, but you can change this by changing the notes selected in the key quantizers).
Knob 1 controls the dynamics, and determines whether
the pattern is repetitive or chaotic.
Knob 2 controls the level of a LFO that adjusts the attractor parameter (Knob 1) to provide a constantly (slowly changing) dynamic. Turn knob 2 to zero to maintain a steady attractor type.
Knob 3 sets the tempo.
Knob 4 sets the delay in the triggering of the second voice.
Knob 5 is used to turn on or off the syncing of the master clock with the second voice trigger. Turning this on causes a change in the beat pattern.
Knob 6 is used to select one of three different modes for generating the second voice trigger.
You can try to play along with the pattern with your piano instead of doing all those tedious Hanon piano exercises!
There is a wealth of information on Chaos on the web and in the libraries. A good starting point would be to read the very accessible book "Chaos: making a new science" from James Gleick. It's a good introduction into chaotic behaviour.
The chaotic systems that we have talked about so far are of a class known as iterative systems, in which an operation is repeatedly applied in discrete times. One can also obtain chaotic behavior in continuous dynamical systems. These are much harder to analyze mathematically, but they are just as easy to use. While there is a great variety of dynamical systems that exhibit chaos, from the point of view of modular music synthesis one of the most useful is the coupling of three voltage controlled oscillators, connected in a ring. The idea is to have oscillator 1 frequency modulate oscillator 2, oscillator 2 frequency modulate oscillator 3, and oscillator 3 being fed back to frequency modulate oscillator 1. Depending on the modulation amount settings, such a circuit produces chaotic outputs for each of the oscillators. This approach can be used for audio-rate oscillators as well as for LFOs. The audio-rate circuit produces sounds that sound like (rather sickly) noise, which may be useful for some percussive sounds or simulating broken steam radiators. For algorithmic synthesis, however, chaotic LFO chains are much more useful. The outputs of the LFOs can be used to control sound parameters (pitch, filter cutoff, amplitude, etc) or to trigger events. An example is shown in the following patch:
In this patch the outputs of the LFOs are used to control (through a note quantizer) the note pitches, the pulse-widths of 2 audio oscillators, and the FM amount for one audio oscillator. Thus the pitch seems to warble in a quasi-random fashion, as does the timbre of the notes (due to the time-varying PWM and FM).
Cellular automata are instances of Finite State Machines, where the state of the system is represented as binary values in a set of cells. The cell values are updated regularly based on the values in neighboring cells, according to some rule. Perhaps the most famous example of a cellular automaton is that used in the "game of life", devised by Princeton mathematician John Conway.
In a "game of life" cellular automaton each cell carries a binary (0 or 1) value. If the value is 0 the cell is said to be "dead", otherwise if its value is "1", the cell is said to be "alive". Updates of cell values are based on the number of "living" neighbors. A typical rule for the updating process is to set a cell to the "alive" state is the number of living neighbors is less than a certain high threshold (not too crowded) and greater than a certain low threshold (not too lonely). Otherwise the cell is set to the "dead" state. For certain choices of the thresholds and initial population patterns, dynamic and persistent behaviour can arise in the state values of the overall cellular automata.
An example of the evolution of a simple 1-dimensional cellular automaton is shown in figure 10.5. The behaviour of the automata is set by a rule which maps the local state (the value of a cell and those of its neighbors) into a new state value. The rule can be described in a look-up table that gives a value of either 0 or 1 for every possible combination of neighborhood cell values. The automaton shown in figure 10.5 has 2 neighbors for each cell. The complexity that can be obtained from such simple rules is clearly evident.
If we implement a cellular automata in the Nord Modular we can use cell state values to control various parameters and generate interesting (?) music. The following patch illustrates the implementation of a simple Cellular Automaton. It implements a 1-D array, with each cell have 2 neighbors. A "Life" type of rule is used, where a cell state is set to one if there is only one active cell in its neighborhood (which includes itself). This is basically the same rule that was used to generate the pattern shown in figure 10.5. The cell state is stored in a Sample-Hold module and cells are updated whenever the Sample-Hold modules are clocked. The update values are computed by the logic gates attached to the S/H outputs. In this case the logic merely determines when there is exactly one logically high output in a neighborhood of three S/H outputs. The patch implements 6 cells, connected in a circular ring. The outputs of each cell are used to trigger an envelope generator. Of course, you could use these outputs for anything. I used them to trigger the envelope generators since the gate LEDs on the envelope generators gives a visual indication of the cellular automata states. The keyboard gate is used to briefly set one of the cells states to one. For the particular rule that is used, the cellular automaton will go through 4 active states and then stick and hold on the "all-zeroes" state. By changing the logic circuits that are used to update the state you can get different patterns.
The cellular automata patch shown above uses logic gates to implement the state updating. This approach is rather inflexible, as changing the update rule requires changing the logic circuitry. Thus, one can't change rules on the fly, as it were. In most software implementations of cellular automata the updating is done via a look-up table, wherein the neighborhood state is used to index a look-up table memory which stores the appropriate update value. Changing the update procedure simply requires changing the values in the look-up table memory, something which could be done on the fly. Unfortunately, the Nord Modular does not contain any random-access, re-programmable memory modules that could be used for a look-up table. One could cobble together something out of sample-hold modules, but it would be very cumbersome. So, what to do? How can we make a programmable cellular automaton on the Nord Modular? Well, the always resourceful Rob Hordijk came up with a solution, which uses the knobs on the front panel of the Nord Modular as the programmable lookup table! His implementation is shown in the following figure. It doesn't immediately look like a cellular automaton, as the neighborhood structure is hidden away, but the overall behaviour is that of a cellular automaton.
In this patch, four-bit 'nibbles', implicitly representing a neighborhood state, are used to address sixteen memory locations. These locations themselves each hold a nibble, which represent the updated neighborhood values. These locations are examined (looked up) on every clockpulse, to be used as the address in the next iteration. There are three usable nibbles in this patch, each with the same set of 'rules', that is they share the same lookup memory locations. The contents of the sixteen memory locations are in practise the sixteen knob values.
The 'nibbles' are conveniently stored in S&H modules. The nibbles are decoded using one-of-sixteen circuits (the group of compare and XOR modules) and used to address one of the sixteen knobs. Each knob delivers a new 'nibble' to store in the S&H on the next clockpulse. Also the sixteen outputs of the one-of-sixteen circuit are coded back to the real four bits of a nibble, using so called 'mickey mouse'-logic (the four eight-input mixers). We now have three types of output to work with, (1) the sixteen separate logic outputs of the XOR-modules, only one of these can be on, (2) the three S&H's that can have sixteen values between 0 and 64, in steps of 4, and (3) the four discrete bits that form the 'nibble' at the outputs of the eight-input mixers, whose values must be interpreted as 0 or anything greater than 0. What to do with the output values is up to you. The patch shown above uses the outputs to trigger envelope generators attached to sine wave oscillators of various frequencies, thereby producing different melodies.
To program a pattern in this patch follow these rules:
If knob1 is closed the next selected knob will be knob1 again. If knob1 points to knob2, that one will be the next knob and if that one points to knob5, which on it's turn points to knob1, the pattern will be knob1 -> knob2 -> knob5 -> knob1 -> knob2 -> knob5 -> knob1, etc. So here repetition occurs after three clockpulses, but in general the longest pattern will be sixteen clocks. So to make it more interesting knob16 is replaced by a randomvalue. If in a pattern knob16 is reached it jumps randomly to one of the other knobs. Now it starts to get interesting as in the example the patterns would never use knob3 and knob4 and all knobs after knob5. But if knob3 points to knob4 and knob4 points to knob16, and we will also let knob5 point to knob16 instead of knob1, and all other knobs point to either knob1 or knob 3, the pattern goes random, but not completely random, it starts to randomly play the small fragments all ending with knob16, sometimes preceded by a randomly chosen knob and sometimes jumping into the middle of the first two fragments. There is one 'disallowed' state in the knobsettings, if a knob points to itself the pattern 'hangs' on that knob -> the 'population' sadly dies and it's game over.
On loading the patch in a NM slot, the S&H modules will be initialised with values of zero, so the three nibbles all point to knob1. But for every nibble, when knob16 is reached a different random value for each nibble is generated, so the combination of the three nibbles gives a more varied pattern than only one nibble, but still fragments will be more or less recognizable according to the knobsettings. So knob16 can actually be deassigned in this particular patch, as tweaking it doesn't do anything since it is replaced by a random value.
The 'rule'-values or 'to what value should a knob be set to make it jump to which other one' are:
Jump to Knob1: 0-7
Jump to Knob2: 8-15
Jump to Knob3: 16-23
Jump to Knob4: 24-31
Jump to Knob5: 32-39
Jump to Knob6: 40-47
Jump to Knob7: 48-55
Jump to Knob8: 56-63
Jump to Knob9: 64-71
Jump to Knob10: 72-79
Jump to Knob11: 80-87
Jump to Knob12: 88-95
Jump to Knob13: 96-103
Jump to Knob14: 104-111
Jump to Knob15: 112-119
Jump to Knob16: 120-127
In this section I will try to give some tips for creating your own noodles, but these should only be considered as examples, and shouldn't limit your own creative explorations!.
First off, you should decide what sort of noodle you want to create. That is, do you want a melodic noodle? Do you want a rythmic noodle? Do you want a timbral noodle? A combination of these? None of the above? This will tell you what type of parameters will be time-varying. Time-variation is the key in cooking noodles. As Jan Punter, one of the master noodle chefs for the Nord Modular, says, noodle makers should concentrate on the "blue wires" in the Nord Modular patch. That is, the control structures are paramount. The actual sound generation is less important, although of course you do want to have interesting sounds for the most part.
You will need to have some mechanism(s) for producing the temporal variations in the control signals. The most basic ways of doing this are to use LFOs, Sample-Hold modules sampling noise, the Sequencer modules, and the Random generators. By themselves, these modules give uninteresting noodles, as they are either too static (e.g. with the sequencer or LFO modules) or too random (e.g. with the random generators or with sample-hold noise). Such noodles sound stereotyped and trite. Rise above the masses! More interesting variation can be obtained using the chaotic control signal generation techniques described earlier in this chapter.
Some slow variation is possible by working with the audio-chain as well. Feedback, as we have seen in the case of three coupled oscillators, can give rise to chaotic behavior. This is not limited to feedback to frequency modulation inputs, however. Chaotic and unpredictable behaviour can result from all sorts of feedback, whether it be amplitude modulation feedback, filter cutoff modulation, etc. Especially good for creating unpredictable havoc are the delay module (inserted into feedback paths or use feedback to control delay times) and feedback of audio signals to sync inputs on oscillators. These provide very interesting timbral variations that seem to occur in bursts.
Another useful technique is to use crossfade modules to dynamically select different control signals or audio pathways. The crossfade modules themselves can be controlled by chaotic or semi-periodic signals to give noodles that are locally quite well-behaved but from time-to-time change character abruptly. Logic circuits can be used to control the crossfaders as well, for example using counters, flip-flops or even event sequencers, to control the evolution of the noodle. Sample-Hold modules can be used to "freeze" certain control signals for a time.
Experiment with every module and with every type of parameter. For example, I find that using the AHD and MOD envelope modules can be very effective in noodling, since they have modulatable timing parameters. The digitizer module also finds its way into many noodles. Noodle cookers should have an aversion to leaving any input unconnected. An unconnected input is a wasted opportunity for interesting variation!
Most good noodles have a certain "feel" to them. Some are jazzy, some bluesy, and others have a middle-eastern feel. You need to keep tight control over such noodles, to ensure that they don't stray from their intended groove. To do this, use mixers and attenuators to keep levels in a certain range, and employ quantizers. Note quantizers can be used to impose scales (e.g. the blues scale) on a noodle. Digitizer modules can be used to limit the range of control signal levels. The following patch shows a noodle that has a definite feel to it, that of an aging 70's prog-rocker aimlessly noodling away on his synth. This patch is an expansion of the patch shown in figure 10.5. A chain of 3 coupled LFOs is used to generate three chaotic control signals, which are used to control the pitch and timbre of the notes. One of the chaotic control signals is used to trigger the amplitude envelope, thereby impose a quasi-random rythm. The 70's synth feel is created through the use of portamento and resonant filtering, as well as by the imposition of a minor scale through use of a note quantizer.
One of my most frequently employed methods for getting interesting noodles is to take somebody else's posted noodle patch and "mod" it (modify, hack, deconstruct,...) to yield something completely different (yes, I know, I am lazy). I usually do this by re-wiring some of the control signals, changing some of the parameters (e.g. cutoff frequencies, osc frequencies, etc), adding in osc sync, and inserting feedback paths. If there are sequencer modules in the original patch their settings should be altered (e.g. melodies and rhythms changed). An example of this is shown in the following patch, which is a mod of K. Lex. Pattyrson's patch KrypixMia.pch. K. Lex (who goes by many on-line aliases) is one of the masters of noodle programming, and it is worth the time to download his patches and give them a listen.
You can see by the mess of wires in this patch that noodles can be quite complex. In fact this noodle patch is one of the simpler ones out there. Most are even more complex. Even so, the best way to learn how to create your own noodles is to look at other people's noodle and see how they do it. Because of their complexity it can be difficult to understand what is going on. You should try to focus on the control signal structure and see what is modulating what. Also look for feedback, as this can also significantly affect the temporal variations. The sound generation chain itself is not so important from the perspective of the noodle maker.