Ever since I started using the Polyphonic Multisample algorithm in the Disting Ex, and now the Disting NT, I wanted to do a string patch. For some unexplainable and inexplicable reason I never did. I got a taste of using string samples during a handful of Jamuary patches, particularly Jamuary 2507 and Jamuary 2510, when I experimented with using the very excellent Alexandernaut Fugue Machine and Decent Sampler, but I really wanted to do a string sample patch modular-style. At first I wanted to use the same string samples I used during Jamuary, the DK Solo Cello Spurs from Pianobook, but that did not work at all.1 After quickly pivoting to the LABS Low Strings Long samples included with the Disting NT, I was off.
Much of this patch is a simple altered duplicate of my last patch, so I won’t rehash the entire patch here. Many knob settings are different, and of course I triggered string and not piano samples, but the control and audio paths are largely identical. Because these string samples are inherently longer than piano notes, I had to drastically slow down The Hypster, the initial source for the master clock, in order to compensate and have Stochaos produce fewer gates. This slow down was coupled with using outputs on Stochaos that change much less often. I also tuned in the delay used on the string samples, the Qu-Bit Electronix Nautilus, to what I thought sounded best, thought I can’t recall the settings other than a long delay time with moderately high feedback. The Panharmonium settings were also changed drastically, cutting the number of voices, zeroing in on the desired frequency range, and really tuning the sampling time. Panharmonium is not always instant bliss, but given some gentle massaging it can become transformative. The Dradd(s), however, weren’t changed at all.
But even after being able to hone in on what I had hoped for the strings and the existing sound chain, there was something missing. It needed some kind of ornamentation. Something to juxtapose against the somber sounding string sequence plodding along in C minor. I initially thought of high pitched bells or sparkles of some kind, but then remembered a patch I did last summer as a test shortly before bringing a travel synth on a trip to Alaska. In that patch I used Plaits in the Vowel and Speech Synthesis algorithm (the last Green algorithm) to repeat four colors, Red, Orange, Yellow, Green. In this patch I took a slightly different approach, by using a random output from a Mutable Instruments Marbles to select the spoken color. I was quite happy with the result in the moment, but was carried away a bit during the performance with too many triggers. It should have been an occasional color spoken in a sad-ish voice to reflect the somberness of the strings, though it sometimes ended up being a robot talking over himself. I used a CV output from the Noisy Fruits Lab Lemon to control Marbles’ clock, which had a high amount of Jitter so as to not be regular. When I wanted more from Plaits, I pushed the fader to create more gates with Marbles. However I clearly pushed it too far during a couple of points. Initially I had Plaits running straight to the mixer, but later in the recording used Beads in full wet delay mode, which altered the tone slightly, and added a low number of soft repeats that really only served to add to the confusion. Plaits is simply triggered to often.
The proverbial icing on the cake was the Walrus Audio Slöer in “Light” mode, which is an octave pitch shift. But rather than a standard pitch shift, Slöer adds more of a choir or symphonic strings sound, which is absolutely beautiful. This patch used basic settings. Pitch shift volume at max, and clock speed at the slowest setting. There was a long decay, and a moderate amount of modulation.
Overall I’m quite happy with how this patch turned out. It’s beautiful and not deterministic. That said, the piece could use for some composed string sequences, even if only occasionally, in order to maximize tension and relief. I’m definitely going to try other adaptations, particularly in the timing of gates and pitch. I’m thinking the Addac508 Swell Physics might be a good place to start.
I was getting all sorts of sputtering and general ugliness using these samples. I’m not sure if I was overwhelming the algorithm with too many gates, or whether the sample rate or bit depth of the samples was too high, or perhaps something else, but I quickly abandoned these samples in favor of the stock LABS string samples. ↩︎
Today’s Jamuary is not only a classic patch, it’s a meme in the modular world. With a small twist. That’s right, it’s Marbles > Rings > Beads. Although the true classic is Rings > Clouds, Beads is a fine substitute. I haven’t used any of my Mutable Instruments modules in a long time. I removed that case from the synth a few months ago in order to expand it, and while I was filling it up, it went completely unused. It’s one of the downsides of having a modular modular synth. There’s always something missing. Beads had been a staple in many of my patches until I pulled it out. To the MI case I added several choice modules. Blades, Stages, Tides v2, and am still in the process of adding one last module before the case will be complete. But I decided that today I’d do a patch I haven’t done in a very long time.
Rings into Clouds is a eurorack gateway drug. It’s a patch that many of us try at least once, and for good reason. Some people never venture any further and come up with something new every time. Such is the depth of this venerable duo. But Beads, although borne of, is not Clouds. You can do many similar things, but they are each their own instrument. Like so many Rings > Clouds patches before, this Rings > Beads patch all started with Marbles, and wonderfully musical random CV and gate generator, spitting out random CV to Rings’ v/oct input. With Rings a gate or trigger isn’t necessary. It detects changes in incoming CV and automatically generates notes when the CV has sufficiently changed. It’s a brilliant design, and dead simple to use. It’s no wonder why Rings is one of the first modules so many of us try. I know it was one of my first modules, and despite having other methods of producing the same sounds,1 it will never leave my synth. You needn’t know any fancy synthesis techniques to get incredibly beautiful sounds right out of the gate. Marbles was set to a moderately slow tempo with lots of jitter as to not become regular, and off we went. Set in Sympathetic Strings mode, Rings was left completely unmodulated. As Rings received new pitch information it sent notes to the venerable (and infamous) Beads, Mutable Instruments’ final module before closing shop in 2022.2
I’ve had Beads since its initial release. I’m one of those lucky enough to have been able to get one, as after the second batch was shipped a few months later, all production stopped, prices soared, and for a while became unobtainium. It took me a while, perhaps a year, to come to grips with Beads. The first couple of patches were a cacophony of grains overtaking everything else in the patch. It was messy, unruly, and I couldn’t figure out how to tame it. So I set it aside for a while. Once I became more familiar with the building blocks of granular synthesis (and synthesis in general) and how they worked in concert, I gave it another try and was bewildered by its beauty. Ever since then I’ve been hooked, and it’s become a tool that would be almost inconceivable to lose.
In this patch Beads was set to a moderately low number of randomly generated grains, while fairly heavily modulating Time, scanning the recording buffer, Shape, changing the composition of each grain, and Size from small to moderately large. This modulation allowed grains that were quite plucky to much longer “slides” through the buffer. Long grains can be a very interesting sound, and one I’ve explored some, but will seek to experiment with more in the future. The Quality setting is in Scorched Cassette mode, both for the longer buffer, as well as the saturated goodness it imparts on the audio. A little bit of blowout and compression goes a long way.
Once out of Beads, the audio went to Blades for some light, somewhere-between -Bandpass-and-High Pass Filtering, and the very slightest bit of Drive. Blades is new-to-me module I haven’t used before this patch, and now that the MI case is back in action, I’ll definitely be using it much more.
The bass drone is courtesy of Plaits playing what amounts to a very (very) lightly FM’d sine wave, with some modulation only to the Morph CV input to give it a small bit of motion so as not to become stale. I have no idea what note it is that’s droning away. I simply tuned it to the Rings output by ear and called it a day.
All modulation throughout the patch was done by Tides v2. This was also my first time using Tides, so I have no idea what mode it was in, or generally how it functions. What I do know is that I managed to get a quad of slow LFOs that are all phasing in and out of each other. I’ll have to read the manual to get a better idea of how it works, but it’s hard to mess up slow modulation sources too badly. One frustrating instance during making this patch was that although I had installed Stages in the case as part of the expansion, I hadn’t actually plugged it in. So despite desiring more modulation, I didn’t have access to any inside the MI case other than Tides, and so opted to not use any more modulation at all. I wanted as much as possible done only with this case, only using other modules for getting from the case to the interface.
With one exception.
One module I’ve also had for a very long time is the Qu-Bit Electronix Data Bender. Along with Rings (and Typhoon, one of the many versions of Clouds), it was one of the very first Eurorack modules I bought once I was bit by the bug. I used it a bunch initially to learn how, even if I’ve forgotten most of it after a few years, but haven’t really touched it since, generally favoring granular synthesis for glitchiness. Data Bender has a very unique sound. It’s the sound of failure. CD skipping, digital buffer errors, tape malfunctions, bit and sample reduction, and any other sort of audio failure, analog and/or digital, you can imagine. I’ve tended to enjoy its take on digital errors when I’ve used it and when I hear it in other people’s work. A sort of glitchiness that harkens back to the earliest days of my musical awakening as an adolescent as I was forming my own aesthetic in music. The days of CD players in the 80s that would skip if you farted across the room, and the multitude of buffering errors in the newly emerging internet through players like WinAmp were commonplace. Data Bender makes that failure musical. I would have thought that two different forms of glitch, from Beads and Data Bender might have been too much. But the effects were sufficiently different that they complemented rather than competed against one another.
Since Rings, and all of the Mutable Instruments modules, have been open sourced, several variations have appeared from miniaturized versions like Rangoon and nanoRings, to the software being ported to multifunction modules like the Expert Sleepers Disting Ex and NT. ↩︎
Emilie Gillet, the former head of Mutable Instruments, is said to have created Beads in order to address “flaws” in how most people seemed to use Clouds, or to correct perceived shortcomings in how Clouds functioned. Although it took nearly three years after Clouds’ discontinuation to finally release Beads and was highly anticipated, it initially had a mixed reception. Now it’s the only Mutable Instruments module that hasn’t been released to open source. ↩︎
I like wavetables and I like drones. Jamuary 6 saw both. A modulated quad wavetable LFO modulating the levels of a quad wavetable oscillator. It’s a patch I’ve been wanting to try for a while, and Jamuary is the perfect time to experiment with new techniques.
There are a lot of moving parts in this patch. The base creating the ever-changing drone is four unsynced LFOs from Kermit Mk3 controlling the levels of the four outputs from the E370 in the Intellijel Amps. These four outputs were patched to the ST Modular Sum Mix & Pan and then to the mixer. The pan CV inputs of the latter three channels were modulated by the Addac506 Stochastic Function Generator. The stereo signal from Sum Mix & Pan went to both the output as well as to a second mixer for summing to mono before being routed to the Verbos Multi-Delay Processor. The mono output of the MDP, which only has the dry signal,1 went to the output mixer, while two of the taps were routed to the Verbos Scan & Pan for hard panning left and right. All three of these signals were mixed and sent to the output.
Although I like the drive the MDP created, it largely defeated the panning of the three E370 outputs. I’d have been better served to run the stereo signal from the Sum Mix & Pan to a stereo distortion for some added drive so as not to throw a cover over subtle movement in the stereo space, but I do like the overall result. The MDP is a fantastic source for overdrive, and is a different sort than a full blown distortion like Mimosa. It’s deep and warm, like a fuzzy blanket on a cold winter day.
There’s lots of modulation too, with the bulk of it being supplied by the Nonlinearcircuits The Hypster fed a Let’s Splosh, with its outputs modulating the waves in both the E370, and three of the four channels of Kermit. Let’s Splosh self-modulated both Gain and Damping to keep its outputs in constant flux.
To accompany the drone proper, I sent the panning wavetables from the Sum Mix & Pan and stereo delay taps from the MDP to a pair of unmodulated Dradds. Both are in Grain Mode, and both are time stretching, with the left channel in reverse at about 20% speed and the and the right channel in forward at a slow crawl. It’s a bit difficult to pick out in the mix, but the overall sound is very different without it, and the final result benefits greatly with it.
The final touch to the patch are the drips and crickets. This oscillator and envelope are both from Falistri, sent through the Holocene Non-Linear Memory Machine. Pitch and random triggering was provided by Sapel. The last free channel of the Addac506 controlled both the Freeze and Scanning of the buffer. Its EOF trigger turned Freeze on and off, with the EOR gate output gating the function output in a VCA, which was scanning the buffer. This little sub-patch took a little while to figure out, but the results are rewarding. I’d been wanting to mess with scanning the buffer of the NLMM ever since I heard this patch by Ras Thavas, and today seemed like the day. It was a fun patch that I’ll be sure to explore further in the future.
I’ve used all kinds of slow modulation sources in my patches. Wave simulators, chaos, and slow, free-running LFOs are all staples in my modular practice, and I’ve used all of them as the engine that drives an entire patch. But one thing I’ve never tried in a lead role in a patch is good, old fashioned random modulation. Sure, I’ve used sample and hold or smooth random generators like the Frap Tools Sapél, Mutable Instruments Marbles, or Make Noise Wogglebug for specific tasks within a patch, but outside of Marbles > Rings-type patches, I’ve never based a patch on staochastic movement before.
Random is, well, random, and it’s hard to be intentional when you can’t really expect what’s going to happen next. In some circumstances, that unpredictability is perfect. In other cases, it just makes a really big mess. There are certainly ways to corral in a random signal to fit within particular parameters to allow for more predictability. That’s the basis of stochastics. Sapél has a range probability knob which directs it to choose output values predominantly from a particular range. Marbles has a switch for voltage ranges. Wogglebug similarly has a mechanism for more or less drastic changes. You can even hone random voltage in on your own with a little offset and attenuation. But it’s still random, and even if completely random might work for certain facets of a patch, using it as the main driver becomes difficult while still remaining musical.1 But I was determined to make it work, and I had just the module to help.
The Addac506 Stochastic Function Generator is a powerhouse modulation source made up of four function generators, and most of the bells a whistles one could want. Need cycling envelopes? Check. Slew limiter? Check. One shot envelopes? Check. Audio rate to very slow? Check. EOR and EOC trigger outputs. Check. Offset and attenuation to get your generated functions in the exact range you need it? Check? Some comparator action for related modulation? Check? And this checklist of features goes on and on. But the killer app of the Stochastic Function Generator is its ability to set a very precise range for both Rise and Fall times. This ability allows for some very compelling modulation that changes every cycle, but, particularly when using very slow modulation, does so organically in a way that seems transparent. It can be set to no random generation (standard envelopes), a very wide range with wildly changing Rise and Fall times, or a very narrow range where changes are subtle, and each of these can be done in three modes, slow, medium, or fast (per generator). The Addac506 is a very powerful module with a compelling feature set that can drive entire patches.
I had set out to make another E370 patch using slow modulation to fade the four wavetable oscillators in and out to create a cloud of a chord that is constantly shifting, yet still always the same. I’d been using slow moving bipolar signals for this purpose on several patches of late, but I wanted to try something a little different this time around. I’ve used chaotic systems, and I’d used both free running and synced LFOs, but I’d had problems using cycling unipolar functions in the past because no voice is ever truly out for very long. It’s a constant chord where each note changes volume, but is almost always audible. Mystery, drama, and tension are minimized; each note like a yo-yo rather than a graceful flow in and out and back in again. But the Addac506 is a little different. Unlike most function generators, with the Stochastic Function Generator you can tailor the outputs to any range you want. Those functions needn’t be unipolar, nor with wide ranging levels, and the ability to offset and attenuate signals allows one to shape your function to suit your destination without issue, and it’s this ability to perfectly condition CV before ever leaving the module that enabled me to use it in this slow fading movement I was looking for.
Setting the stochastic functions on the Addac506 is simple: set minimum and maximum Rise and Fall times, and call it a day. At the instantiation of every cycle both Rise and Fall will receive a random value between those set minimum and maximum times, and that stochastically determined envelope will come out. Flick the cycling switch and every cycle is something different. And the Addac506 gives us that, times four. It should be noted that this behavior can be replicated in any function generator that has both End Of Rise and End Of Cycle gate/trigger outputs, plus CV inputs to control the rise and fall times independently. You’ll need to add in a sample and hold or random voltage generator, plus a module for offset and attenuation to define the range of random. All this times four is a lot of patching, and a lot of modules. The Addac506 does it all seamlessly under the panel.
At first I was a little confused. Although I hadn’t initially set any offset, the output was still silent until the voltage as somewhere between 1-2 volts.2 I had anticipated needing to use negative offset to create some space between the fading out of one wave and when it will become audible again, but instead found myself using positive offset to get the flow I was after. Fortunately the flexibility of the Addac506 allowed for quick and easy adjustments to put each wave in the right zone. I added a fair amount of positive offset to the bass note of the chord so that it was always audible, while still having level changes to keep it moving. The other three oscillators used a very slight positive offset. Combining their need to get to somewhere between one and two volts before becoming audible, with the very slow nature of these ever-evolving functions determined the use of positive offset. Up to 40% of their positive range was already inaudible. Giving the functions a bit of a voltage floor rise was in order, lest far too much silence ensue.
Having already decided on my four oscillators for this chord soup, the quad wavetable oscillators of the Synthesis Technology E370, and having had the level control roughly framed out, it was time to look at modulating the wavetables to create movement within each note. The pitch of each oscillator would remain static, and to accompany the change in level, a change in timbre is natural (especially with a morphing wavetable oscillator). Having already used up the outputs of the Addac506, I looked to a familiar module, and one right next to the Stochastic Function Generator, the Addac508 Swell Physics.
Although Swell Physics is definitionally a chaos-based system, and not a random one, the uneven flow up and down of each output was perfect for the job. The bass note oscillator received modulation only on its Detune CV input, while the other three oscillators received both Wave and Detune modulation, the former from Swell Physics and the latter three free running sine wave LFOs from Batumi II. The triangle wave LFOs from Batumi II were used to pan these same three signals slowly through the stereo field with the ST Modular Sum Mix & Pan, while the bass note was planted firmly in the center. Once mixed down to stereo, the four oscillator cloud went to the AI Synthesis 018 Stereo Matrix Mixer.
Once in the matrix mixer it was time to smooth out some of the rough edges with the Holocene Electronics Non-Linear Memory Machine, a favorite of mine since it went in the rack. As a non-clockable delay I found it a wonderful tool for long, drawn out ambient delays, especially with how it can smear repeats into an almost reverb-like sound. Although I tend to pretty heavily modulate the NLMM, I chose to go with no modulation in this patch, with smearing at about 12 o’clock on the knob, and feedback at around 11 o’clock. The NLMM was mixed with the dry signal in the matrix mixer at about a 50:50 ratio, and perhaps even favoring a bit more delay than dry signal.
This mixed signal was sent to both the output mixer and The Dradds for some broken tape machine treatment. Both sides, left and right, or light and dark as it exists in my case, were set to Tape mode at an octave up, with each side behaving slightly differently. The left side tends to randomly switch between forward and backwards playback at double-speed, while the right side randomly switches both direction and speed, although both sides were lightly modulated and sometimes change temporarily. Although I’ve always been enamored by the Dradd(s), it wasn’t until I really started to learn it have my results been what I was always hoping for. Since I sat down to really understand the Dradd(s), my patching has had an opportunity to be more intentional, with my results more satisfying and effective. Plus, having dual Dradds for a stereo field really maximizes the movement and variation it creates.
A heaping portion of distortion, courtesy of the Bizarre Jezabel Mimosa, was also used towards the end of the patch, which created occasional blips and stutters, and a sense of heavy drama. It was only used on the chord cloud and the Dradds, and even then I chose to keep a fair bit of the original dry signal in the mix. I really like the resulting sound, but something is happening that I don’t quite understand. As distortion was introduced into the mix, I did not lower the dry signal. I would have expected the volume would rise, yet it didn’t. The volume got lower, even once the dry and wet distortion signals were nearing full volume in the matrix mixer. It wasn’t until I started to lower the dry signal (the chord, its delayed signal from the NLMM, and the Dradds) that the overall volume started to become louder. My guess is there is some form of phase cancellation happening, although I don’t really know what phenomenon might explain it. You can hear it starting at about the 10 minute mark, with me starting to lower the dry level at about the 11:22 mark, which corresponded in a total output level rise. Curious, that.
Although I was quite happy with my shifting chord after a whole lot of tinkering with envelopes and CV input attenuators, I knew something was missing. I had blips of granular synthesis to break things up, but it needed more. I was hesitant to use SD Multisample as I’ve done a lot of that, but wanted something in a similar vein. Reaching back to one of my very first patches, an attempt at creating a wind chime-like sound and pattern, I decided to add in a randomly created, toy piano sound (or baby R2-D2 sounds as my oldest relayed ). I really enjoyed making that patch when I did it the first time around. It was the first patching technique I’d ever figured out on my own, and a sense of nostalgia pushed me over the edge, even if only to see if I could remember how to replicate it.
This part of the patch started at the Stochastic Function Generator’s “Average” output. This output was patched to the input of the Joranalogue Compare 2. When the Average out from the Addac506 was inside the comparator window, it spat out a gate to the cycling input on a Frap Tools Falistri. While the function was cycling, the End Of Cycle gate triggered Sapel and Quantermain. Sapel sent a value from the N2 output to both Quantermain, in order to send quantized pitch CV, and the Decay CV input of Falistri that would change the envelope length with each note. The VCO changed pitch, and the cycling envelope opened the VCA, each note with a different pitch and length. The sound went from the first VCA to the output mixer, as well as a second VCA which panned the signal to two separate delays, which were then mixed and sent to the output mixer to be mixed with the dry signal and the rest of the patch.
Although the method I ultimately used in this patch is very different than the first time around, the results are similar. The sounds are much higher in pitch, much faster, and much shorter than my original version, but the theory behind creating the sounds was the same, even if I took a different route to get there.3 I wanted short, uneven bursts, and I got them. It’s quite often these days that I realize there are many routes to the same end. Overall, this part of the patch played a very minor role, but an important one. After several listens, I’d probably integrate this part differently were I to do it again. I’d definitely have it more forward for most of the mix rather than hanging around the background. It seems to get lost sometimes, when it should be more prominent. I would also not mess up a patch connection with my second delay, the Qu-Bit Electronix Nautilus, where I plugged into the Right input, and not the left, which, with the feedback pattern chosen, put virtually all of the delay signal from Nautilus on only the Left side. Some might not even notice, but it bothers the shit out of me.
The last part of this patch is the periodic “bubble burst” with accompanying echoes (courtesy of the Xaoc Devices Sarajewo). I stole this idea straight from one of my favorite patches on the Make Noise channel. It’s a simple sound that is both unobtrusive, and only very periodic. The sound was created by pinging (ringing?) CUNSA, which also had its frequency modulated by the highly attenuated HP output of the same filter (another trick I stole from Make Noise – Thanks, Walker!). It was triggered by using a Stackcable to combine three separate gate outputs from the Stochastic Function Generator. These long functions output only very periodic gates at a random interval, so there’s no overcrowding. It also helped provide a sense of scale and depth of the musical space.
Everything ended with a round trip through the Walrus Audio Slöer, which is quickly becoming my favorite reverb. Although I’ve tended towards one of the pitch shifting algorithms, I ultimately decided on using the Dream algorithm, though the Rain algorithm also sounded nice.
I really enjoyed this patch, even if there are a few things I would definitely change. It was both challenging and highly rewarding. It offers answers to some questions, but also to more questions to explore in a future patch.
Although what is or isn’t “musical” is certainly subject to wide interpretation, I think we can still make useful generalizations, while drawing lines between something most would call musical, with yet other examples most would call sound(s) or noise. ↩︎
I’m not sure, but I suspect that the VCA/mixer I was using to process the audio has a logarithmic response, delaying its response with slow(er) signals. The manual doesn’t illuminate the VCA topography, unfortunately. ↩︎
After looking at a patch diagram of the original patch, the methods used between these two patches was quite different, even if it started similarly. It’s nice to know that there is generally more than one way to accomplish some patching goal. ↩︎
I went into this patch with the idea that I was going to see if the Nonlinearcircuits Stochaos was appropriate for inclusion in a travel synth I’ll be taking to Alaska this summer (it’s not). I’m looking for gates. Many gates, actually. And although the Stochaos has many gate outputs, it runs on a clock, and sticks to the grid. It’s an awesome tool for what it is doing, but it’s not what I’m looking for in that synth, unfortunately. But despite not being fit for that particular project, this 8hp wonder is a fantastic Chaos or Random (or Both!) driven sequencer that can drive a whole patch.
This sketch was designed to use chaotically driven gates in order to ping the 4 operator outputs of the Humble Audio Quad Operator. Since they operate on ratios of the base pitch, it would never be out of tune, and all of the 4 operators would always have nice harmonic relationships. These pings would then go through the Venus Instruments Veno-Echo for some rather pedestrian unmodulated stereo delay that was perfect.
Since the point of the patch was to see what I could do with the Stochaos, I used it as the heart of everything. It received a clock from the Xaoc Devices Batumi II, and from there performed its wizardry sending gates to and fro. These gates pinged the 4 operator outputs in the Frap Tools CUNSA, as well as triggered various events all over the patch. Stochaos also provided the sequence which was quantized in Quantermain on the uO_C via one of its four CV outputs.
There was some modulation, but not very much. I used one of the Stochaos gate outputs to trigger the Auza Wave Packets which modulated the ratio of one of the operators on the QO. Two of its gate outputs clocked the Nonlinearcircuits Bindubba which also modulated one of the operator’s ratio. Otherwise the patch is pretty barren of modulation. The delay isn’t modulated at all, and neither is Aurora.
As per many of my recent patches I wanted to use some FFT, but rather than reaching for Panharmonium yet again, I used the Qu-Bit Electronix Aurora. I was sort of happy with the results, but I’ve never really studied Aurora in much depth, and so opted to go with whatever sounded good enough in the moment. It’s not a prominent part of the patch, but it does serve to fill in the space a bit. It’s definitely reminded me that I need to learn a few things before I go on my trip so I’m not busy manual digging instead of making music with the precious little time I’ll have.
I didn’t start this patch with a kick drum in mind. I was originally hoping to get not only random gate outputs, but randomly timed gate outputs. My original intent was to make an ambient piece, but that idea sank quickly, so I pivoted in a more rhythmic direction. Once a couple of things were settled, it was clear that the patch was begging for a kick drum. I’m not a four on the floor kind of guy, so opted for something more erratic. Still on the time grid, but not at all predictable. For this I used a divided output of Batumi II into the always fun CuteLab Missed Opportunities and adjusted the probability to taste. The kick is made with a Joranalogue Generate 8 into a Rabid Elephant Natural Gate. The trigger would go to both Natural Gate’s Hit input, as well as triggering the Joranalogue for a short envelope for both Exponential FM on Generate 8, and the Control input on Natural Gate.
Overall I’m really pleased with this patch. It’s a sketch with lots of room for improvement, but the direction and feel is very good. The biggest change I’d make is toning down the high registers. Not only are they too loud, but there’s too much of it. It’s a matter of better attenuating my CV and watching the initial knob position for ratio to ensure they don’t go that high. This alone would improve my result exponentially. I’d also like to do a better job of shaping the melody notes in CUNSA. I’m not yet pleased with the tail of those notes.
Although the Stochaos didn’t meet my need for inclusion in a travel case, I did find that it’s a fine sequencer that can control entire patches with naught but a clock input. You choose the style of decision making you want it to do, Chaos, Random, or Both, and it happily goes to work with 8 gate outputs along with 4 CV outputs, the fixed chaos signal used by the circuit, and some Pink Noise. If you’re not looking for strict control over sequencing, or you’re looking for a sequence of random gates and CV for always-surprising modulation, the Stochaos deserves a look.
Pinging filters in one of my favorite modular patches. You can get lots of different tones, creating very LPG-ish sounds with beautiful ringing decays, booming drums, or melodic clicks and chirps to color your modular masterpiece.
The traditional way to patch a filter for pinging is really simple. Set the resonance on your filter on the verge of self oscillation, run a trigger or gate into the INPUT of your filter, get some pitch CV into the v/Oct input or the filter cutoff CV input. Now patch the output of your filter to your output (or through any effects you might want), and you’re in business. But there’s an inherent problem in many modern filters when patched in this way.
Traditional pinging patch.
Oftentimes the input will ping on the rising edge of your trigger, then click on the falling edge, which is not ideal. No one wants clicks in their music, except when you do, so we need a work around.
Some filters, in an effort to mitigate the click problem, have a “Strike” or “Ping” input meant for gates and triggers. The Joranalogue Audio Designs Filter 8 and INSTRUō I-ō47 are 2 examples, as well as the 2 filters I used in this patch.
No “Ping” input? No problem.
For filters without a dedicated input for pinging, simply patch your trigger or gate to an envelope generator with a snappy envelope. A very fast (or even no) attack and a short decay work well. Adjust the decay of your envelope and the resonance on your filter to affect the tail of the ping. It may take a bit of fiddling, and a little can go a long way, but your perfect tail is in there. Hopefully. Patch the filter output to your output module, and on every trigger you’ll hear a new note.
Make Note: Some filters are better pingers than others. Some don’t process v/oct well, or maybe the resonance is too finicky to get the ping you’re lusting after, so if you don’t like what you get with your first choice, move on to another. That said, most filters should work well.
But this post isn’t about just pinging a filter. It’s about doing it in stereo. And while I could tell you that this method is possible with just 1 filter (it totally is), this patch uses 2 independent filters for pinging, and a stereo filter for effect.
We start, as we most often do, with the clock. In this patch, we have the clock feeding 2 separate S&H generators, which will put out unrelated, random CV sequences. Both of these sequences then go through a pitch quantizer before being sent to the v/oct inputs on the filters. The sequences may be different, but we at least want them in the same key (unless you really like dissonance) for aural continuity. The clock also sends a trigger to a random gate skipper, which will allow only a subset of those triggers to pass through, ensuring that the 2 filters never receive the same beat sequence, providing stereo movement and depth. The gate skipper also send triggers to the final stereo filter, and an envelope generator, which is also modulating the filter. Yet another clock signal is sent to the delay to ensure our repeats are in time. The final clock signal is being sent to yet another Random Generator so that it can provide modulation to the final stereo effects filter.
Once triggered, the filters will send their quantized pings to a delay (pings seem to beg for delay), before moving on to the final stereo filter before going to the output. Listen to the result below!
