ProbablyS tutorial - using the newly added memory sequencing

Probably was my first attempt at an 'antidote to step sequencers' - a simple monophonic step sequencer that took a different approach to step sequences by adding probabilistic control over events, as well as legato note lengths.

ProbablyZ added extra time features, a well as separating the octave transposition from the notes in an octave. The controls that you get over time allow probabilistic control over time-warping, which isn't a common feature of sequencers...

Since I first released ProbablyZ, I have fixed the state memories (the little grey squares)(thanks to Cory at Ableton for his help on this!) and improved the sync with Ableton Live's transport. Whilst I was fixing the memories, I tried out one of my further extension ideas, and this is now ready for release...

ProbablyS (available from MaxForLive.com)

ProbablyS adds extra control over the state memories. There are now 12 'State' memories (each grey square can save the state of all the grids to the right - just Shift-Click in one of the grey squares in the black 'Memory' section). To recall a state then just click on the grey square, and it will turn white.

The 'Memory' grid on the left of the vertical bar of memories allows you to sequence thee. Each row corresponds to the associated memory on the right, and so if you set all of the memory cells to the top row only (white cells all along the top of the grid), then ProbablyS will play back just the state stored in that memory. Here's an ASCII text illustration of the layout:

State Grid  OOOOOOOO []  State Memory

            OOOOOOOO [] 

              ... 

The default setting for the state grid should be similar to the basic setting for the other grids - a horizontal line o white 'cells'. (As with the time grid, the 'cells' are round, not squares...). Time scans horizontally across the cells - and this is shown by a darker cursor line.

If you set the 'repeat' to 1 and the length to 2, and set the second grid position to a different memory, then the memory grid will cycle between those two memories. If you set the 'repeats' to 4, then each memory will play for four times, before moving to the next memory. If you set the 'length' to 8, and the 'repeats' to 8, then it will play each memory 8 times.

The two screenshots above show the 2nd and 8th stage of the 8 step state sequencer (which drives the underlying 16 step grids). The 2nd stage is playing the top memory (see the white square in the vertical memory bar in the 'Memory' section?), which has a very simple set of grids, whilst the 8th stage gas chosen one of 9 possibilities, and has chosen a memory four steps lower, with a much more complex set of grids controlling the output.

As with all the other grids in Probably, you can have more than one white cell in a vertical column, and the choice between the two cells will happen at random. This means that you now have probabilistic control over which memory is playing at any time.

(I'm still working on providing a separate way to store the 'State' grid - and I may provide a preset state in the next version, plus some new functions...)

Looking at just the state grid (plus the time grid so you know where the new Memory section is positioned):

The first two stages (which could each be from 1 bar through to 8 bars long), are set to play the top memory. The next two stages play the next memory down, and the same for the firth and sixth stages. The final two stages are different - they each provide a choice of any of the remaining 9 memories for each stage. So the first couple of stages could be simple introductory patterns, the next two could add some extra detail, and the next two might add some more detail. The final two stages are chosen from a range of memories, and could provide lots of variations of the basic patterns. 

In this state grid, the second repeat stage for the first six stages provides a choice of 1 of 3 memories. As you may be realising, the key to using the state memories effectively is to fill them with fried patterns, and to keep track of where you store each pattern, so that you can then sequence them into builds, breaks and other pats of your song structure. 

Hint:

Here's a hint derived from hours of playing with state memories:

"Keep shift-clicking to save your work!"

The sinking feeling you get when you click on another memory and you realise that you have just lost that brilliant pattern you were working on, is not a good one... Save, save, save...

My recommendation is that you start with Probably, then try ProbablyZ, and then ProbablyS - the features increase each time if you try them in this order, and this should give a smoother learning curve. ProbablyS is the most complex step sequencer so far in this series, and I have more ideas in the pipeline. 

New to this?

(If you are new to Probably's way of working, then don't forget to set the transpose by setting the record focus to the track with ProbablyS in it, and then playing a note - otherwise you just get very low MIDI notes. Transpose from a clip in the track can still be used to transpose ProbablyS, of course...)

Tutorial for Probably (1st in the series):
http://synthesizerwriter.blogspot.co.uk/2017/07/probably-antidote-to-step-sequencers.html

Tutorial for ProbablyZ (2nd in the series):
http://synthesizerwriter.blogspot.co.uk/2017/09/probablyz-tutorial.html

SoundCloud demo for ProbablyZ:
https://soundcloud.com/martinruss/probablyz-tutorial-demo-01

ProbablyZ Tutorial - adding time warping

When I released Probably, my Max For Live 'antidote to step sequencers' MIDI Effect for Ableton Live, I included some details on how to use it, particularly the way to use the probabilistic 'more than one white square in a column' interface metaphor that it uses. ProbablyZ, the first 'expanded' version, adds in some new grids, and these extend the control possibilities, so I thought it was about time to produce a tutorial...

Programming ProbablyZ

ProbablyZ is an unusual step sequencer that breaks some of the usual rules. Here are the main features:

*NEW* A 'purple' 'Order' grid that allows time to be re-ordered and repeated, with the usual vertical column probability-based control (one white cell in a column means that note plays every time, two white cells means each plays 50% of the time, three cells equals 33% of the time, etc.). 

The red 'Pitch' grid is the same as in Probably, and allows notes to be entered over a one octave range.

The old orange 'Probability' grid has been moved downwards slightly, to make way for a new grid. It allows the probability of a note being played to be controlled, independently of the pitch, octave, velocity and length, and once again, the choice between possibilities can be controlled by having more than one white cell in a vertical column.

*NEW* The newly added, small, red 'Oct(ave)' grid controls the octave shift of the notes, and it is independent of the 'Pitch' grid. The default white cells in the Oct grid are in the middle of the five octave range, so you can shift the note in the 'Pitch' grid up or down by up to two octaves, and the usual probabilistic column control applies, so if you fill all five cells in  column, then the pitch of that note will be shifted to one of those 5 octaves at random each time the column is scanned. 

Having the Pitch and Octave of the notes controlled independently like this provides very precise adjustments to be made to what actually plays. If you have a fixed Pitch grid, but put a bit of variation in the Oct(ave) grid, then the sequence will play those notes, but the octave can vary. You can use this to create lines where just the leading note plays different octaves, or the 'on the beat' notes play a choice from a set of octaves, etc. If you do it the other way round, and put the variability in the Pitch grid, with  fixed Octave grid, then the notes will only play in the ordinary one-octave range. Remember, that this range can always be transposed sing a MIDI keyboard or the Virtual A-L keyboard on a laptop - or by the notes in a Clip. (Oh, and don't forget that you need to set the transposition when you first start ProbablyZ by sending it a note event, other wise it thinks the transposition is right at the bottom of the MIDI range, and you get very low notes!)

The green 'Velocity' grid controls the velocity of the notes in the sequence, and as usual, is independent of any of the other grids.

The blue 'Length' grid controls the length of the notes produced, and is not only independent of the other grids, but it also allows the length of the notes to be controlled, which means that you can have notes overlapping in the output. This is quite unusual for a step sequencer...

Getting Started

I'm still trying to get ProbablyZ to start up with a special default state, and this doesn't always happen. It should look something like the first screen-shot above...

From that starting position, then edit the Pitch grid so that there is only one white cell in the first column, and the Oct(ave) grid so that there is only one white cell in the first column.

I chose a very basic Electric Piano preset for this track, followed by a little reverb - simple percussive sounds are often good when starting work on a step sequence. If you set Live to play, then you get a 'ting', followed by silence for the rest of the bar, and then another ting. So far, so good, and if not, then you did remember to set the transpose by sending a note event, didn't you?

Next, let's explore the Oct(ave) grid. Add four extra white cells in the first column:

Playing this gives us one of five things, dependent on the octave that ProbablyZ randomly chooses for each repetition. If you are used to ordinary step sequencers that always play exactly the same notes every time, then this is your first glimpse of the hidden depth inside ProbablyZ.

When you are bored with those slow tings, then add in some more notes on the beat in the Pitch grid, and give them the same 5 octave choices in the Oct(ave) grid:

This gives us a ting on each beat, with a random choice of octave. This is probably a little too extreme for most purposes! (Used live, it can give the impression that something is about to happen, and can give you time to set up your next song... In the 80s, some bands used Sample & Hold into VCF for the same sort of tantalising effect. )

Next, change the last two Cs to Fs, and adjust the range in the Oct(ave) grid. this is also a good time to tweak the Velocity grid so that the beats are louder, and alter the Length grid so that the beats are longer too:

Okay, so now we have the start of something that has a bit of variation in it, and we can now add in some choices for the second and fourth beats, adjust the Octave so that it feels like a descending line on average, and make the first and third beats longer:

What we are really doing here is defining probabilities. The Pitch grid has set the first note to be a C (always, so 100% probability), and the Oct(ave) grid provides a choice of the upper four octaves (So each octave will happen 25% of the time on average). The second note can be a C or a D#, with a three octave range that doesn't have the top octave included any longer. The third note is always an F, with the four octaves shifted downwards, and the final note is either an F or an A#, with a three octave choice. Taking the final note as an example, then there are six different notes (two notes, three octaves) that could occur, so a specific note will occur 1/6th of the time, on average. Over the course of six repetitions, you might get all of these, and you might not. It is rather like throwing a die (or several dice): you will eventually throw all of the numbers from 1 to 6, but getting them all in 6 throws, or in a specific order, doesn't happen very often...

When you set this sequence playing, then what you hear might be difficult to reconcile with what you see on the grids. There may not seem to be enough white cells to create the variations that you are hearing! If this happens, then read the previous paragraph again, matching the chosen note that you can hear, with the white cells in the Pitch grid and the Oct(ave) grid. As I said earlier, ProbablyZ has hidden depths that are not immediately obvious, and a little time spent getting familiar with the way it works can be time well spent.

At this point, ProbablyZ is playing stuff that is not quite your typical robotic, repetitive step sequence. Now, let's add in some extra notes away from the beat:

You should be able to figure out that these new notes have a fixed pitch and a fixed octave. The lower velocity makes then sound like grace notes or ornamentation. You can experiment with reducing the velocity, or giving a range of velocities, or making these notes very short.

Bending time

So, far, we haven't explored the new 'Order' grid, so let's add a few extra choices to the ornamentation, tweak the octave choices, and increase the length of the beat notes. Then, let's edit the Order grid so that the diagonal is broken, and add in two 'off-the-diagonal' cells: 

 The ornamentation is now chosen from a D and a D# in the first part of the bar, and an F, G or A# in the second part of the bar... Except that the Order grid changes the order in which time happens in all of the other grids. So the first column plays as normal, but the second column jumps to the ornamentation in the second part of the bar, then jumps back to playing the middle part of the bar, and then swaps back to the first little bit of ornamentation just after the middle beat note, and the back to 'time as usual'.

This means that the time order of the columns in all the grids that you see to the right of the Order grid has been changed. Time no longer scans across the grids evenly. Instead, it now follows the Order grid. Watch the dark vertical cursors jump back and forth when this plays...

In detail, this means that after the first C, we will now get a random choice from F, G or A#, then a C or D#, and then the choice of D or D# that we got before. We then get an F, followed by the ornamentation that used to follow the C at the beginning of the bar.

If you want to, you can replace the standard 'lower left to upper right' diagonal in the Order grid with one that goes from upper left to lower right, and the sequence will play backwards. You can adjust the ordering of the sequence in any way you like, live!

If you don't remove the white cells on the diagonal, then things happen a little differently. (In fact, tings happen a little differently! :) ):

The Order grid has exactly the same probabilistic behaviour as th other grids, so when we put two white cells in a column, then it makes a choice between the values. In the Order grid, this means that we have control over the probability that time will be warped. In the above Order grid, there is a 50% chance that the first ornamentation will be swapped to the later one, and a 50% chance that the later one will be swapped with the earlier one. So there are now four ways that time can be warped in the bar: no warping, early ornamentation repeated later, later ornamentation repeated earlier, and ornamentation swapped in time (early moved the later, later moved to earlier). Thos two extra white cells have a big effect!

(As before, feel free to experiment, and to re-read the previous paragraph whilst listening to the output. ProbablyZ can be tricky to get your head around at first!)

Finally, what happens if we extend the time warping to all of the ornamentation? Here's what it looks like inside Ableton Live:

What we have set ProbablyZ to do here is this: Whenever we have an ornamentation note choice, choose from one of the four possibilities and play that. Because the ornamentation is just two sets of notes, then we are only using half of the available possibilities - you can try changing the fourth and eighth columns to give a different 'pool' of notes if you want, and then listen to the output.

You can listen to the output of the above grid setup on Soundcloud here. Remember, this is a single step sequence, produced using only the setup shown above.

I hope that this quick tutorial has shown you some of the possibilities (!) of ProbablyZ.

Warning - you may find it hard to go back to the step sequence that you used previously...

ProbablyZ can be downloaded from MaxForLive.com. It is FREE!

Using Chromatic Remapping To Generate Musical Inspiration

Previously, I looked in some depth at the Ableton 'Scale' effect, one of the quieter backwaters of the 'built-in' MIDI effects. That blog started out concentrating on how to invert a keyboard, but ended up producing lots of chromatic maps that take incoming notes and map them to different outgoing note pitches. Which led to another investigation, the results of which you are now reading...

While I was producing the variations on chromatic inverted scales for the previous blog, I realised that these were all specific cases of a much more general set: the set of remapping of incoming notes to single outgoing notes on a one-to-one basis. In other words, each and every incoming note is converted to one, and only one, outgoing note. There are a lot of these maps: there are 12 input notes and 12 output notes, so I think that means that there are 12! combinations, which is just under 480 million. So me making 30-odd of them available is a tiny fraction of the whole set! And that's where I realised that I could make them all available in a MaxForLive plug-in utility, and MIDI_ChromatixT_mr was born.

In the screenshot, MIDI_Chromatix_mr is shown in its normal location in the MIDI processing chain - just in front of the Scale effect (Alternatively, you could use any of the many available MIDI Scale-type effects available in MaxForLive). The diagram below shows how everything fits together:

Incoming notes are mapped to different pitches by MIDI_ChromatixT_mr, and then restricted to the chosen notes in the scale set by the Scale effect. In the example screenshot above, the C minor preset scale has been altered so that only 5 output pitches can occur. This constrains the output notes to just the pitches C, D#, F, G# and A#. Incoming notes can be at any pitch, and they will be mapped to new pitches by the map. So an incoming A might be mapped to C, whilst an F could be mapped to a D#, etc. 

The grid in MIDI_ChromatixT_mr sets the mapping of incoming notes. In the screenshot above, the vertical cursor line is showing an incoming D (moving across from left to right), whilst the orange marker is in the A# row (counting up from bottom to top). Now, whilst it is possible to edit the mappings (Click on the 'Auto/Fix' button so it shows 'Fix', and the mapping will be fixed and editable), the 'Generate' button creates new random mappings with a single click. So it is easy to just keep clicking on the 'Generate' button until it has created a random mapping that you like - the usual M4L store/recall buttons on the left can be used to save it if you wish. 

But the really interesting part of MIDI_ChromatixT_mr is the 'Auto' button, when it is set to 'Auto' then the 'Generat' button will be pressed every time the bar count to the left of the 'Auto' button matches the number set in the pop-up selector on the far left. So if the selector is set to 4, then every 4 bars, a new chromatic mapping will be produced, and incoming notes will be mapped using that new mapping instead of the one used in the previous 4 bars. This then repeats every 4 bars.

What this means is that every time the bar count reaches the number of bars shown by the selector, then incoming notes will be mapped differently, using a new one of the millions of possible chromatic mappings. So whatever notes are in the (monophonic is recommended) track sequence that is driving MIDI_ChromatixT_mr, the output will be a scale-constrained version of the remapped versions of them. The D to A# mapping in one set of bars could be replaced with a D to G# in the next set of bars, then a D to F mapping in the next set of bars. 

It's a bit like shuffling cards and then dealing them out for a card game. The shuffling means that you get a different hand of cards each time, but the number of cards you get (and the game you are playing) are fixed. So whilst the notes get remapped to new pitched notes, they are still constrained to just the notes in the scale you have set. 

What this does musically is take a monophonic sequence in a track, and play those notes, remapped to new pitches whilst still being constrained by the scale, and yet the timing and velocity of those new notes remains exactly as it was in the original sequence. So it's a bit like an randomiser and a bit like an arpeggiator, but until that 'Generate' button is activated, the mapping is fixed, so if you find a mapping that you like, click on the 'Auto' button so that it says 'Fix', and then session record the output with the 'doughnut' session record button in Live. Of course, an easy alternative is just to let it free run, generating new mappings every 4 or 8 bars, and to record everything, and then just extract the bits you like. 

In a few minutes, MIDI_ChromatixT_mr will run through lots of variations of your monophonic track sequence, all following the timing and the velocity exactly, but with different pitches every time the 'Generate' happens. It's a bit like having an assistant who can keep running through variations, one after the other, and who never gets tired or bored, and never loses patience. MIDI_ChromatixT_mr is an automatic 'Can you just do that twisted around a bit?' generator.

Demonstration 1

SoundCloud demo 001

The problem with random music generators is the they are often too random, and when they do come up with something interesting, then it has happened and gone almost before you realise. MIDI_ChromatixT_mr repeats each random variation for the number of times that you set the bar selector, and so if it is set to 4 bars, then you will hear the same variation 4 times, before it moves on to the next one. This is probably best heard rather than described in words, so here's a demonstration of a simplee piano and bass duet produced entirely from an 8-note track sequence and a 4 note bass track sequence, with MIDI_ChromtixT_mr producing all the variations every 4 bars. Once the 12 notes have been set in the track sequences, everything else is just a straight recording. 

Demonstration 2

SoundCloud demo 002

This second demonstration has the same bass, and has two independently variations piano lines using the same technique, spaced an octave apart. 

The top line adds a 16 note sequence, but with a random velocity added to provide additional variety. Again, once set running, the recording has had no user manipulation. 

Download

As usual, MIDI_ChromatixT_mr can be downloaded from MaxForLive.com. Enjoy!

The Name?

Why such a weird name? Well, I thought about all sorts of variations (!) on chromatic remapped, or even diffuser (cryptographers call this type of device a 'diffuser') and the first version was completely manual and was 'Chromatix. When I then added the automatic 'every n-bars' generation feature, then it needed something to indicate time, so I added a 'T' at the end. As a result, you aren't likely to forget this M4L device.

Monophonic?

Yep. Try poly tracks and see what happens...

Probably - an antidote to step sequencers...

I've always loved step sequencers. From the ARP Little Brother, to my own modular synths, 8 or 16 step notes metronomically repeated ad infinitum has always been part of my synthesis toolkit. But there's always been a tiny nagging voice whispering in my ear, and recently, I decided to listen to it and see where it took me. The voice told me to break the four rules:

The Rules of Step Sequencers

- Each step is one note.
- Each step has the same length note
- Each step has a find common velocity
- Each note always plays

So MIDI Probably gleefully breaks them! Each step in this M4L add-on can have from one to 13 pitches, spread over an octave. If you have one pitch, then the note played is that pitch. If you have two pitches, then each one will play, on average, for half the number of times that the sequencer loops round. Three notes get a third each. Four notes get a quarter, etc. Just probability really. There's a random number generator inside, and it decides which of the choices that are specified gets to control that note event.

There are four grids that are used to control Probably. From left to right they are:

Pitch, which is arranged paint roll style just like Live. Higher pitches are higher up the screen, lower pitches are lower down the screen. You get a black and white guide to show where the notes are. One octave may seem a bit limiting, but Probably accepts incoming MIDI notes as transpose settings, so you can transpose the playing sequence live with th computer keyboard, an external MIDI keyboard, or a session clip (if you make the session clip several bars long, then you get a transpose sequence that drives Probably...).

Probability, which sets the likelihood of a given step actually playing. The top row is 100%, where the note event always plays, whilst the lowest row is 0%, where the note event never happens. If you put a white square in the top row and the lowest row by clicking on the same step, then you get a 50% probability of that note event happening. If you replace those two square with one in the middle, then you get 50% as well. But if you add a lower square at 25%, then you get half of the notes playing for half of the time, plus a quarter of the notes playing for half of the time. If you have a square in the top, lower and 25%, then each gets a third of the time, which is 100% (33%), 0% (0%) and 25% (8.1%). Don't bother too much with trying to understand the maths: the more and higher the squares you fill in, the more likely it is that a note event will play.

Velocity, which sets the velocity for each note event. Again the top row is maximum velocity (127), and the lowest row is minimum velocity (1). Selecting specific squares gives fixed instances of velocity, whilst selecting a range of squares will give a range of velocities - each chosen at random. Single squares give fixed velocity. So you can have notes on the beat have fixed high velocity, whilst notes off the beat can have lower random velocities to add interest, or the opposite, or any other scheme you can think of.

Length, which sets he length of the note events. Each note event is independent, so if you want to have steps where the notes are longer than the step interval, then you can have them, and so you get chords instead of single notes. Each note can have its own length, and act length can be randomly chosen from a range or set of values. You control the values, and the randomness just make the choices.

If you've never played with a step sequencer that allows control over the length of notes (from staccato, to legato, to overlapping chords), or one where velocity is controlled random choices, the you are in for a treat!

Startup

When you add MIDI Probably to a track, then it starts up in a weird default:

This isn't very useful, and the first thing you need to do is compensate for my laziness in not writing the code to create a sensible default. Here's my suggested starting point:

This has a rising arpeggio for the Pitch grid, a top row full of 100% for the Probability grid, Maximum Velocity, and 16th demis for the Lengths. You need to provide a Pitch reference for the transpose, so arm the track, and play a note on the computer keyboard, on your external keyboard, or in a clip (which could be a slow, multi-bar transpose map for people who love circle of fifths etc.) Playing this gives a simple 8 step sequence:  

Well, nothing spectacular so far!

So let's draw in the opposite arpeggio:

Running this gives a rather more interesting result. You get each of the pairs of notes in each of the columns, selected at random. Every 16 bars or so, you stand a reasonable chance of getting all f the possible variations of each of the two arpeggios. Here's some of the output:

That word 'variations' is very significant here. Two notes have been specified for each of the 8 steps, and Probably dutifully selects at random from each of those pairs, and eventually will play every combination of the notes. The result sounds like someone learning jazz improvisation based on a scale, and most people assume that there's huge amounts of processing behind it... You might want to keep quiet that there's actually just a very simple grid, and probability does all the rest.

The red lower portion of those piano rolls shows the usual boring velocity values of 127, so lets put some ranges into the Velocity grid:

The first note in the arpeggio, plus the middle one, have single velocity values, so they will always play at maximum velocity. The remainder in the first half get quieter on average, and the second half hey get quieter still. There's still a chance that you will get all of the notes at the maximum velocity, but it might take a long time to get to it. Here's a capture:

Notice that the notes are different from the previous example. Not only re the velocity values being chosen according o the white squares for each note, but each note is independent, and so the sequence of jumping between two arpeggios that we got the first time, is different this time. This is randomness, not repetition.

Let's add a bit of control over the Probability, by making the off-beat notes less probable. (This is kind of emulating what real human players tend to do in some circumstances...) And the Length is now set to choose from a range of possibilities, but set exactly the same for each note event (painting across all of the columns is easy, but boring - I prefer the individual control against time that is shown in the probability and velocity grids). This gives us a sequence which has lots of variation across multiple parameters:

...and the result starts to look and sound quite interesting:

There's not very much range to the velocity or the length, so let's increase the amount of white squares and give it a few more pitches to play with:

Which gives us this output:

Now, does this look like a piano roll generated from a few simple choices on a few grids to you?

Lets try a different pair of arpeggios, and make those Lengths a little longer:

Resulting in:

Remember that this is produced by a step sequencer...

Instead of arpeggios, lets's constrain the choices to just a few notes from a scale, and see what happens:

 And let's try making the available note choices much sparser, and make the length of the notes (and the probability) dependent on where we are in the bar:

I'm afraid to say that when you add a piano instrument to the track, this gives results which sound pretty much like a reasonably competent player randomly noodling on the piano. All you need to do it capture it to a MIDI track, and then select the bits you like: either for inspiration, or just 'as is'.

To capture the output of Probably, you just create a new MIDI track, setts input to the output of the track with Probably on, and then use the Session Record button to create a new clip with the output of Probably. (I call the Session Record button the 'new doughnut', because it is a circle next to the 'NEW' button, and it goes red (I think of it as brown) when it is recording).

Notes

When you first insert Probably into a track, you need to provide a note. If you don't, then the transpose function will think you want to transpose way down at the bottom of the MIDI range. Because of the way that Probably works, you also lose the lowest C (C-2) from the output. Sorry. 

And that's MIDI Probably, a kind of 'antidote' to the usual M4L step sequencer. Enjoy playing with randomness!

As always, you can get MIDI Probably from MaxForLive.com

  

Refined Combing...

Things don't always go the way you intend. I had an idea for a phaser effect that was driven from a filtered noise source, and the end result was something rather different. Here's the story...

'Phasers' are just comb filters where the notch frequencies are modulated up and down in frequency by an LFO. (My previous Comber effect was nothing more than a few of these in one place.)

The audible effect for typical 'vibrato/tremolo' LFO rates sounds a bit like detuned oscillators, and so can be used as a simple 'chorus' effect (there are other ways of doing chorus effects as well). At slow LFO rates then the effect is more like several resonant filters sweeping up and down, which is exactly what is going on!

But whilst sine wave shaped LFOs are all very nice, there are many other possible alternative waveforms, and repetition can get a bit boring. So my idea was to got most of the way to the opposite extreme from the pure predictability of a boring sine wave and use noise instead. Filtered noise seemed like the right thing, and so I envisaged an array of resonant high-pass, band-pass and low-pass filters, and perhaps some sort of neat GUI control to create a final 'noisy' modulation for the comb filter.

Unfortunately, the end result was not as interesting as I hoped. High-pass filtered noise just gave a rapid tremolo effect, and not a particularly nice or useful one. Band-pass filtered noise was still too busy. The only really useful noise was heavily low-pass filtered noise, containing exactly the sort of frequencies that you would use for tremolo, vibrato or a phaser! After a bit of experimentation, it turned out that I didn't need any conventional filtering at all, and that just a bit of sample averaging (OK, primitive filtering) produced nice random wobbling that sounded ok - but it wasn't anywhere near as impressive as I'd been hoping.

So I wondered if something combining the LFO and the noise was a better idea, and I added a DJ cross-fade type control to mix between the LFO sine wave and the noise waveform. This seemed to liven up the result and make it a bit more interesting and unpredictable...

But then I realised that I had an alternative source of variation, and so I added a second LFO to drive a Sample/Hold circuit that sampled the original sine wave LFO. Sample/Hold circuits have always fascinated me, right from the days when you put high-input impedance op-amps on Teflon PCBs with polycarbonate capacitors and used reed-relays as input sampling switches, all in the analogue quest for long-term voltage storage (and you still got droop over time!). In the digital domain, things are different (and you add imperfections if you want to model the real world) and so a quick bit of M4L'ing later, I had an LFO with sine waves for high sample rates, and repeated complex patterns for lower sample rates. (The S/H samples when the indicator lights up yellow, btw.)

The DJ slider became a 'Randomness' control, and I added a red indicator to provide visual feedback for when the 'Freq' and 'Depth' controls needed to be adjusted (up and down respectively), and Comber V0.3 was born! I hope you find it a more versatile and inspirational effect for your music. 

Comber V0.3 is available, as always, for download from MaxForLive.com.

Related articles

• Math Photo: Riemannian Shadows
• The Universe Is Our Synthesizer