Two voice probabilistic sequencer in Axoloti #02

Same general idea, but decided to take a less involves approach.

Patch description

screenshot-from-2016-12-28-23-23-14Full size picture here.

Again using a randomized rotating clock divider to drive each channel.

Instead of micromanaging probabilities tied to a clock division and switching between a “regular” path and a “more triggers” path I use a simple model of cellular automaton to both generate random triggers and random values to be quantized to a scale.


Ch1 triggers Math’s Ch1 which goes to LxD Ch1 that takes waverunner’s wave + sub. Ch2 triggers the same path’s Ch2 with Mangrove’s Formant out instead of the Waverunner. Math’s Ch1 and Ch4 Both In is being modulated by a triangle wave. Three Sisters in self oscillation is also taking the sequencer Ch 2 CV and FMing Mangrove though Math’s Ch2. Some acoustic noise is looped through the Octatrack as well as some processing and semi regular sampling with FXs. No modification of the sequencer was done once it was running, most variation comes from attenuating the envelopes and attenuating / inverting the FM path.

The result has some bad spots and goes on too long, but overall the sequencer worked a lot better than all my previous attempts.

Going forward

Besides choosing which clock divisions we’re taking, how much we attenuate the random signal to be quantized and a few parameters on how the clocks are rotated/inverted/reset in the RCD we don’t have a lot of control over the patch. Ideally I would like to find ways to modify the frequency / density of triggers and an interesting way to change scales in real time, as well as adding some non tonal drift.


Two voice probabilistic sequencer in Axoloti #01

Basically posting this since I’ve spent a month toying around with this in what little free time I’ve had and want to put at least some of it behind me.


A 2-voice sequencer with ~5 controls that’s playable and flexible. I would like to have control of how “on time” the sequence is and how much it stays in a traditional scale, as well as the probability of getting a random n amount of triggers on voice 2 on each fire.

First approach

I started with a classic naive approach, using coin flips, clock divisions and quantized random sources to get some variations. This generally didn’t lead to very interesting results. Using a rotating clock divider and randomly rotating, inverting and resetting the rotation was an enormous improvement on this.  After a lot of iterations I arrived at the example below.

uwnfifaFull sized image here.

The Midi In clock goes through a couple of clock dividers that can be manually controlled and then into the rotating clock divider. Using a Noisering emulation we decide when we rotate and based on that when we reset and invert the divisions.

Channel 1 Trigger is slaved to the /16 division and there’s a coin flip associated with the /2 division that increases the chance of a trigger happening. Without this the lower probability values are close too useless. Every time we get a trigger on Channel 1 we decide which note we want to play in that channel. Right now there’s three predetermined options.

Channel 2 Trigger is slaved to /1 and then goes through a multiplier, in part for ease when repatching. Where a weighted three sided die flip determines if we take triggers from the “Standard in” or the two available random gate generators. The probability of taking the standard in option is the same as the sum of the other two. The Standard option is again a simple coin flip, which is a slight feedback based on the last success probability. Both random options take a multiple of the standard clock in to ensure a high amount of triggers. Another option here would be to just take a high clock multiple, for example x32, and go through an unbiased coin flip to decide triggers.

If we’re taking triggers from the Standard in, we decide which note we’re playing in voice two by random selecting one of three predetermined notes associated to each note option for Channel 1.

If we’re taking triggers from Random #1, we decide which note we’re playing like before but then we’ll add a small random number on each trigger, getting some non standard microtonalities.

Finally, if we’re taking triggers from Random #2, we’ll trigger an envelope that moves around Channel 1’s current note, so again we get some microtonalities until the envelope completely closes. We can determine the width of the interval by changing the constant being multiplied to the envelope.


Channel 1 triggers Channel 1 of Maths and plays Frquency Central Waverider (Wave and Sub Wave mixed, some modulation from Channel 1 going to Wave) which then goes into Channel 1 of the Make Noise LxD modulated by Maths Ch 1. Channel 2 triggers Channel 4 of Maths and the Strike input on Channel 2 of the LxD, while playing Mannequins Mangrove into LxD Ch 2 modulated by Maths Ch 2. Oscillators were tuned by ear before starting to something that sounded ok, before hand but ended up sounding not that great with some modulation added. No change was made to the sequencer once running.

Going forward

The trigger section can be massaged with enough effort to get something acceptable, but random is not really what I’m looking for so I’d like to take a look at generative sequencers and see if those techniques get me closer. The Note section is not working at all and needs to be completely reworked, although it was working better in an earlier iteration.


Octatrack Experiments #02 B: Granular processing

I’ve been recording a lot and very busy with life. Since the last post I’ve tried several different approaches to this idea, and while most of them gave some kind of interesting results I wasn’t very happy with them as granulation. I finally managed to get something I like going though.


The idea is to use three flex machines for a stereo effect and each one goes through a filter going from low pass, to band pass, to high pass. Each of them go into individual reverbs. Rate set to timestretch, loop to on TSTR to off, Len to off.

We’ll use slightly different number for each track so we have something similar going in each, but never quite lock in (not that it’s likely to matter since random modulations are computed independently). Whenever there’s a triangle you could use the inverted triangle to give stereo variations if you use the same values.

Rate in the low teens, RTRIG to infinite, retrigger time set to around 2 on all three but different values.

Randomly modulate RATE at 2x ~37 and ~30 amount. You don’t want to use a continuous function for this I believe, since that ends up sounding too much like pitch bending rather than getting some random grains reversed. If using a continuous function you’ll want to have it go really slow and modulate just enough that you get a small amount of reversed time.

Use a triangle at 1x ~20 and amount ~117 to modular the start time. The idea is that this should “scan” the whole sample forwards and then backwards, catching mostly close grains. The superpositions then comes from varying grain size faster than start time.

Finally, use a triangle at 8x ~52 and amount ~33 to modulate retrigger time. Ideally you’d want to use a triangle with some random added, but there end result is not that different and you would have to give up modulating rate or start. If you go too high on the amount, you’ll mostly get glitchy bleeps. This, I think, is a limitation of using a very small amount of grains and imprecise windowing.

One thing to take into account is that you’ll get better results with a rather short sample with this method, otherwise modulating the start parameter like this is unlikely to evenly cover the entire sample. This could be used in conjunction with the crossfader controlling the start time to have this same effect, but for that to make sense one would have to make a pretty long recording, which I’m trying to avoid.


In this example I used a short sample I recorded from a baglama. I set a couple of scenes to play around with the effects mostly.

The “tape” setup is used through the CUE out and some MS20 is fed thought that. There’s some resampling of the tape track and slicing going on, but it’s not too relevant to the result.

Going forward

I have some ideas left, and some of the stuff I’ve been using these last few weeks can still yield some interesting results. One thing I need to explore more closely is manual scanning of the sample using scenes together with the locking other modulation parameters. For example in that last audio, I have a scene set so I can scan the sample but as I go forward the amount that the start time is modulated diminishes. The results from that are not uninteresting, but need some very fine tuning.

The process of setting this up in general is very finicky. Not all sound sources are good for this kind of granularization and changing the sample means you’ll have to change a decent amount of settings too. Speech samples for one are very easy to setup, since you get a better idea of the whole sample by only listening to small fractions. Long drones are the opposite. Ideally I’d like to develop a range of setting that at least sort of work with most reasonable sound sources.



Octatrack Experiments #02 A: Granular processing

I’ve been busy doing a great Acoustic Noise workshop this week so haven’t had the time to work on this as much as I’d like. Results have been a bit hit and miss but I’m getting some interesting results.


Flex machine set to infinity retrig and ~1.5 RTRIG time. It’s only triggered once and I play around with the start and rate. Time stretch is set to off, which let’s the sample advance quite nicely but doesn’t quite work without infinite retrigs. Rate is being lightly modulated with a slow trig LFO to get an occasional reverse. One very slow LFO is modulating start with depth at around 10 and a random LFO is modulating this depth. The downside to this approach is that it uses up 2 LFOs to get the effect.

Another way to do this is with time stretch enabled, infinite retriggers but modulating retrigs with a slow LFO. You are then free to modular rate and retrig time.

Both result in similar but not quite identical results. I’ll need to keep exploring the differences and see if I can pinpoint exactly what’s different and what advantages are there for each method, if there are actually any.


Repeating again the flex tape machine setup on T1, feeding it some drones from the ms20. This uses two different instances of light distortion, sample rate reduction, bit rate reduction and amplitude modulation.

One Flex machine with the first setup described above which then goes through a low pass filter, Q set to noon, and into a spring reverb set at 100% wet. Some of it is being fed back to track 1.

Another flex machine with the second setup goes through a 2 band EQ and a plate reverb. I play around with it a bit and mute it at times.

A static machine is playing some heavily processed sample which produce the occasional glitches and some weirder textures.

I’m reminded of long late train rides back home years ago, with distant conversations and occasional disruptions against the steady sound of the train going forward.

Going forward

I’m working on a granular delay of sorts which I haven’t quite gotten right yet. The idea being that I could trigger one flex machine looking at a recorder X steps after the sound source and have that do the processing. That means fixed delay time, or at least discreet and hand configures but that’s fine to start with I think, once that’s done I can try to find ways to mess with it using different triggers.

One thing that’s very clear to me is that everything is interacting with everything else, so when I find a sweet spot I’ll have to make note of the whole patch. This also means that going light on modulations will probably yield the most consistent results.

I might take a detour after this to explore some of the things we’ve been working on in the workshop and there’s still the idea of looping machines feeding into each other that I’d like to explore too.

Octatrack Experiments #01 C: Tape Machine

I was reading the manual last nigh and realized that another cleaner way of doing this is to just set a pick up machine to overdub and set a negative gain value. Around -2 seems to work fine.

Using this method you can now have 8 tape machines doing their own thing instead of the 1 that the flex machine method limits you to. This also frees up the CUE outs which might come in handy down the line.



First attempt at granular processing. There’s two flex machines with slight panning and similar delays. RTRIG is 1 and 15, RTIM 0.05 and 0.022, RATE slightly above 0. LFOs are modulating RATE, Start and RTIM, mostly random waveforms. Still not sure how RTRIG and RTIM works, specially when the sample is not really triggered but looping.

Aside from that some random slices of the hydrophone field recording can be heard and some ms20 looping with the flex tape machine setup. Patch on the ms20 is pretty straighforward but one cool thing I haven’t done in a while is using the button to trigger EG1, which affects both the filters and the VCA which sends filtered pink noise to EXT IN.

Still a lot of work to be done on this technique.

Octatrack Experiments #01 B: Tape Machine

Apparently Pick Up machines do not record and play at the same time without overdubbing, so after quite a bit of headaches trying to use a flex and a PU to make this work, I realized that I didn’t need a Pick Up machine at all and in fact only need 1 machine total.


Flex machine on T1 set to record AB and CUE for 64 steps. T1 outputs to CUE at around 100.

A playback and a record trigger are placed on step 1, some effects and some modulation can be set up but pitch has to be at 0 and not modulated for some reason. I think setting a small amount of compression, SRR, BRR, AMD or distortion here might help simulate the sound of tape, but finding the right numbers might be tricky.

That’s it. You can now play around, for example sending small amounts of other tracks you have going to incorporate them into the repeats can sound nice, specially if it’s not a static sequence.


After setting up, play a few minutes with the idea and went straight to recording so as before, this is not meant to be an artistic statement of any kind, just an example of the idea in use.

I again used the ringing rocks sample plus a Hydrophone recording with the same setup to fill it up a bit. The “tape” track is looping a mix of drones and short melodies from the ms20. The ms20 runs through a ms 70 cdr with Tape Echo -> Space Hole -> Church reverb. T1 has a compression with some RAT and Lo-Fi with just a bit of everything dialed in.

Going a little heavier on the Lo-Fi would probably be a good idea since the texture is neither close to tape nor really that interesting. Also ending the track 6mins in would have ended up better.

Going forward

Instead of setting T1’s CUE to 100, one could set it to close to 0 and use another muted Flex machine on T2 pointing to R1 and set that track’s CUE high, then you could have effects set #1 on that track and effects set #2 on T1. I’m not sure if that’s any different than having a neighbor track and the effects inverted but one thing this allows is parallel processing by mixing T1 and T2, which might be useful. You could also feed back a small amount of random slices of the loop. It’s a real shame that you can’t assign an LFO to CUE volume nor use p-locks with it.

Another interesting idea is using playback triggers to start the loop before one whole measure is recorded. Some interesting feedback appears but certainly needs to be tamed.

Finally, as I said, more work is needed to match the tape dirtiness or at least find some interesting new texture.


Octatrack Ideas: Granular Processing

I’ve looked a bit into people trying to make the Octatrack do some granular processing  and there’s a few ideas floating around that seem interesting.

Granularesque Ambiance

There’s a post by user Nikofeyn on Elektronauts where he processes guitar and gets some nice atmospheric results.

I’ll try to go through what he did and see if that sparks any new idea. He’s using 4 main tracks (not OT tracks, but audio tracks) and T8 was setup as a master with more dark reverb:

  • T1 (flex) samples 1 bar of guitar, applies filter and dark reverb while modulating pitch and rate. He says there are various playback triggers, which reminds me I have to take a closer look at them.
  • T2 is a thru with filter and lo-fi (distortion, srr and heavy amp mod), the filter being modulated by an LFO. T3 is a neighbor that applies reverb at 70% so that the live guitar doesn’t affect the sound that much. This is a pretty cool idea which I’ve played around with myself but never got much out of it. I was just fooling around with the idea though, while he’s using it to get more ambiance out of the same input.
  • T4 (flex) plays back a single note sample of the guitar, with pitch shift and rate set negative, filtered and into heavy reverb at 70%. The audio seems to be previously sampled.
  • T5 and T6 are thru and neighbor for an A4 arp with a high q filter, lots of delay, another filter and reverb.
  • T7 has a flex machine that plays back the recording buffer in R1 with rate reduction and delay. I’m not sure if this is any different than copying the same recording and playback trigs that are on T1 to T7 and having it sample the guitar, I don’t think so but would need to check. It obviously saves memory but that’s irrelevant in this case since it’s only 1 bar samples.

So, this was cool to me, although it doesn’t really have the textures I associate with granular synthesis, which to be fair might be my own lacking more than anything else. To be fair, he does reference MI Clouds as a motivation to do this and the Oliverb is probably as much a staple of the Clouds sound as the granular processing, and this does sound like something that could come out of Clouds.

Using short samples to form a cloud

On the subject of Granular synthesis hardware user teacherofstalker at Elektron-users comments:

So, Granular Synthesis, as Xenakis has described it, is all about composing a complex sound using smaller particles of pure, elementary waveforms, like very short sinewaves.

So you load your MM tracks with sinewaves that have a very short envelope, fire up the ARP at small speeds (i.e., 1x – 3x), and start randomizing (using the LFOs and, of course, manually):

– amplitude
– length
– pitch
– panning

Add some delay, effects etc.

Mass-control the cloud pitch using Pattern Transposition.

With sinewaves it can become a bit monotonous pretty quickly, so try blending different waveforms.

This seems like something that can be approximated in the OT, using the crossfader as a sort of ribbon controller. This technique reminds me of Sonic Encounters 11 – Swarm of the nanobots, where Mark Mosher tried to approximate a Swarmatron with the OT. That article was one of the things that showed me the complex setups that can be achieved with the OT and since I’m planning to explore the swarm idea down the line I’ll leave this approach until then. It’s worth mentioning that this is actually trying to replicate granular synthesis, rather than granular processing.

Close to real granulation

This thread, also at Elektron-users, explore using the MachineDrum UW for granulation too. User stiiiiiiive writes:

I’m going to post some SYSEX and/or audio example but for now, here are some settings -obviously tempo dependant. However, only the RAMPLAY track (and the optional low-attack-LFO track) need to be triggered.

Track 2: just for LFO purpose; LFO is modulating Tr10 START parameter.
Shapes: RAMP DOWN and RAMP UP.
Update: Free
Speed: 1*
Depth: 64**
Mix: 127=normal pla, 0=reverse normal speed (if speed=1; else, plays faster)

Track 6: optional, just for LFO purpose; used to get a softer attack, LFO modulates Tr10 volume.

Track 10: RAM PLAY machine.
PITCH: to taste!
HOLD: enough to allow re-triggering.
START: 64**
END: 128
RETRIG TIME: to taste, determines the grain size*
LFO modulates START parameter with a random shape.
SPEED: 127 so that it’s faster than RETRIG TIME
UPDATE: free
DEPTH:to taste*
MIX: full random

Track 14: CTRL-8P machine for control convenience
P1: Tr2 LFOM –> timestretch
P2: Tr2 LFOS –> speed factor for timestretch
P3: Tr10 LFOD –> time jitter
P4: Tr10 RTRIG TIME –>grain duration

* These parameters are referenced by the CTRL-8P machine.
** These values shall stay constant.

I’m not very familiar with the MDUW so let’s try to deconstruct what’s going on here.

  • Load a sample and set retrig time to the grain size of your liking.
  • Set a random LFO, faster than the retrig time, to modulate the Start time.
  • You then set a mix of slow up ramp and down ramp LFO modulating the start parameter. When mix is at 127, the playback is normal, when it’s set a 0 it reverses the playback direction. I’m not sure how this behavior could be replicated on the OT, maybe using a ramp to modulate rate is a close enough. This LFO mixing business seems really interesting and should probably look into it more.

Changing the Mix then results in timestretch, and changing the LFOs speed varies the speed factor for timestretch. Changing the depth of the random LFO modulating the start parameter modifies how much the grains jump around (time jitter). Changing retrig time changes the grain size.

The audio sample has some very interesting textures, some of which certainly sound like what I associate with granular processing, so if this can be replicated with the OT I would be quite happy. There would be max 8 grains possible, but I’m sure a lot can be done with a couple of grains.

Final thoughts

My original idea was to have two flex machines pointing to the same audio recorded by a PU machine, sliced to very short slices, playing random slices thru slightly different effects. This could be done by recording a very short loop, say between 1 and 4 steps, and making 32 slices which would make them sub 0.06 seconds long. This, I think, would approximate a granular delay with fixed grain size, but lacks true superposition of the grains.

One way to avoid the fixed grain size an have possible superposition might be to not slice the audio and instead use p-locks to set an approximate starting position on the loop and a short length. Then using lfos to modulate this parameters would make each grain have different size and grains in different tracks could then overlap. Good starting values would be those corresponding to the position and length if we were to make slices.

I might still try  to make this setup work, but I realize that it’s trying to do too much of the work by hand and will probably end in a very rigid results. For example grains would always fire at the same time, and while one could modulate the attack to simulate slight triggering differences, it’s again trying to do a lot of tricks to cover the shortcomings of this method and I’m likely to ran out of LFOs (start, end, attack already use all three).

Instead, I’ll try to make the MDUW method work which seems like it should be pretty straightforward.

Octatrack Experiments #01: Tape Machine


I started thinking about ways to use the Octatrack as a tape machine of sorts, mainly to explore the idea of degrading loops. For this I started looking into pick up machines whic I’ve never used before.

First try

I set up two PU machines in T1 and T2, a flex on T5 pointing to Track recorder 1 and one on T6 pointing to the next one. T1 is set to record for 64 steps, and T5 has sliced audio and linear triggers assigned. Similar setup for T2 and T6 but only 32 steps, starting on bar 2. Scenes 9 and 10 control the modulation amount of a random LFO to the slice parameter plus the Transition Trick. Different effects are set for each track and IN AB is set to 127 to monitor what’s being recorded.

I realize this isn’t very close to what a tape machine does and is just looping and mangling, but figuring out how pick up machines worked took more than I expected so I’m calling this step 1.


For flavor I set a static machine on T6 and sliced the Montana ringing rocks sample by Richard Devine, placed a couple of triggers and a random LFO modulating the slice parameter.

General idea was to have some kind of high pitch clean tone with minor movement on T1, as background, and some slow lead type of sound with much reverb on T2. Then record over T1 to get a thicker background and work some kind of progression over the second loop.

The better tries didn’t get recorded and I’m left with this one, which is certainly no great artistic statement.

In this instance, I had some trouble sticking with the concept since I struggled to find the sweet spots I wanted. More planning would have been necessary if I wanted consistency between tries but at this point I was a little frustrated after losing previous recordings and I’d rather just keep moving.

Going forward

Slicing both tracks is most likely excessive, which makes me question the need for two flex machines entirely unless I find more uses for them.

One possibility would be to set T5 to record from CUE and route some amount of T1 and T5 itself there, something along the lines of 100/60. That way, each time a new sample is made in T1 I get a new recording in T5 where the previous recordings are present at lower volumes, actually approximating the behavior of tape. Levels could take some messing around to get right, but would actually get me where I wanted to be. A similar setup could be made on the T2 – T6 pair, and triggering the recording without input would push the sample back. This seems like a good way to go forward.