Sounds were created in Nanoloop also on my phone, then sampled and mangled by a Koala

TidalCycles, my favorite algorithmic sampler and sequencer (the code overlay) is sending a clock pulse to my modular to keep things in sync. The modular isn't sampled, it's playing live.

Throughout the video I'm manipulating a cheap delay pedal that is wonderfully lofi and crunchy.

=== Patch notes ===

Tidalcycles audio clock (a clap sample played really loudly) -> modular synth envelople follower -> 40106 schmidt trigger (for cleaning up the clock) -> shift register input

also: clock -> 16 bit fibonacci linear feedback shift register (psuedo-random generator) -> gate combiner (AND circuit)

LFO -> shift register data input

shift register output -> r/2r ladder (a weighted mixer, it generates stepped voltages from the output of the shift register. I think this is the general idea with how the Turing Machine module works) -> High frequency oscillator (HFO) CV input

HFO -> analog/digital triangle wave converter -> 4069 triangle waveshaper -> VCA

that comes out of the modular and goes into a tube preamp. It is then split into two signals: one is dry and goes into my mixer, the other one goes into a cheap delay pedal and then into another mixer channel. The two channels are panned slightly left and right so there is a sort of stereo sound.

Meanwhile, TidalCycles is playing drum samples which is coming into my mixer on two channels: one for the kick and another for the other percussion

• Korg Volca Modular
• Patterning (iOS)
• a tube preamp
• spring reverb
• a delay pedal

All the sounds you hear are coming from my modular synth, with the exception of the reverb (Alesis Microverb II) and delay (VD400 delay pedal). No real mixing or mastering, just a rough "direct to tape" quick session.

The sounds:
BD: short trigger into a vactrol-controlled low pass filter
drum 1: 3 square wave oscillators into a diode-based ring modulator-type thing, then going into a transistor VCA
drum 2: arduino oscillator playing a sampled noise wavetable, then going into a transistor VCA
bassline: pulse oscillator going into a clock divider, then each of the divisions is going into a 4051 multiplexer. The output of that multiplexer goes into a low pass gate. The multiplexer chooses between 8 different inputs, reading 3 gate signals in binary. Various square wave oscillators / clocks are sent to the 3 inputs, so you hear psuedo-random choices of the various sounds. This sounds like an arpeggio, but you're really hearing a separate oscillator for each note.

Everything goes into a few different mixers, then into the computer in stereo.

In the video you can see the modular; the upper-right is VCV Rack, and the lower-right is non-mixer, a fantastic modular mixer for Linux.

more info: chrisbeckstrom.com/the-modular

More info about this synthesizer:
http://chrisbeckstrom.com

No plan or specific ideas, just patching and playing. Most sounds created on my modular synth, drum sounds from Patterning on iOS. Everything in sync using Ableton Link.

Originally streamed via facebook live video.

Technical summary:
Tidal generates midi notes
Those midi notes go into ttymidi, which converts them to serial messages and sends them to my arduino module
The arduino module generates gate/trigger voltages
Those voltages control sequencers, envelopes, and drum sounds on the modular

I'm absolutely enamored with VCV Rack (https://vcvrack.com/) - it's a free and open source Eurorack-style software modular synth. It's incredible. I've been playing with it a bit; here is a patch combining VCV Rack with my homemade (physical/mostly analog) modular, timing supplied via MIDI from Bitwig Studio.

PATCH NOTES (Summary)
Bitwig is sending 16th note MIDI notes out to my modular (via serial messages on an Arduino, which converts the messages into voltage - gate ons), as well as Rack.

Most of the drum-ish sounds are coming from Rack. The MIDI pulse enters Rack and is distributed throughout the patch, triggering a bass drum, hihat, snare, and some other sounds. Lots of psuedo-randomness using Bernoulli gates, shift registers, and other fun things. Download the patch (link above) if you'd like. (I'm using a development version of Rack so you may need to rename the file to funky_json.vcv instead of .json)

The bassline and bleepy stuff is coming from my modular, generated using basically the same methods as in Rack. I use a few logic modules (AND gates) to generate some interesting rhythms from the main clock. The modular goes through a few mixers and ends up in a track in Bitwig, mixed with Rack.

Download my PD modular here (free and open source!):
https://github.com/chrisbeckstrom/pd_modular_synth

Download this specific patch:
https://github.com/chrisbeckstrom/pd_modular_synth/blob/master/2017-07-05_beeps_bloops_generative.pd

I've been building a modular synth inside the free and open source software Pure Data, and lately I've been experimenting with ways to integrate my physical modular with it. Using a combination of audio, MIDI, arduino, linux tricks, and some other stuff, I got them humming together nicely.

The PD gui lags wildly with everything going on - I'll have to figure out how to prevent that sort of issue. But it sure is fun to hear it in action!

This patch is so complicated I couldn't accurately describe each part of it. Basically there is a master clock (a software VCO) which is routed all over the place, including into my real life modular via an arduino. All the other rhythms divided from that pulse using dividers, random gates, probability modules, etc. Also I plugged a radio into the modular, which gets in the mix and ends up back in Pure Data before everything is mixed and recorded right to the video.

I've been diving deep into techno, especially the kind of techno with beeps and bloops. Big surprise, I know. Yesterday I found a Galcid video on YouTube and have been extremely inspired by their raw and funky approach. I've been devouring all of their stuff and am absolutely loving it!

This video is greatly influenced by that sound, as well as other modular artists like Steevio. If you haven't heard those folks, go check them out!

Want to hear more modular techno? I just released a techno album that features the modular quite a bit! https://chrisbeckstrom.bandcamp.com/album/cycle

Patch notes

This patch consists of 5 voices: a drum machine, a bassline, a wild saw wave, some XOR noise "hihat," and some CMOS noise... Plus a spring reverb and a digital reverb.

Bitwig sends midi clock to my iPad running the incredible Patterning app (drum machine). The iPad is plugged into a little mixer which comes into my big mixer, which in turn comes into my computer in stereo.

A sampler track in Bitwig is playing a 1 sample-long click I generated in Pure Data (with the handy signal~ object) every 16th note. That audio is routed through a $9 audio interface (!!) into a preamp to boost it to modular level (+-9v). The clock goes into an envelope follower on the modular that spits out gate and envelope; the gate goes into a buffered mult and is used to clock a bunch of stuff: A 10-step sequencer modulates the pitch of an oscillator, while the clock feeds a clock divider. The clock divider's divide-by-3 output goes into an AND logic module along with the original clock source (making sure the output of the AND is always in time with the clock. I wonder if this is even necessary...) The output of the AND goes into a gate to trigger module, then to the CV input of a low pass gate (basically a VCA). That goes into a mixer module, then into a rackmounted mixer, then into my big mixer, then into my computer. Whew! That's a lot of mixers.

I really like the rhythmic contrast of the drum machine (swing is turned up to 100) and the modular (it plays everything perfectly straight but a little behind the beat due to some latency in my system). It creates an interesting groove that reminds me of some of the hip-hop I love, especially J Dilla.

The clock also goes into another AND module, which compares the it with a free-running clock (square wave oscillator). Whenever both are HIGH, it spits out a signal, which is sent to another gate-to-trigger module and then an envelope generator. This envelope generator (the pink module with the yellow flashing light) controls the level of a VCA, giving some shape to the sound of a XOR module mixing two square waves. The XOR can do a lot of cool things, but I especially like it as a sort of pseudo-ring modulator. Alas, it really only works on square waves... Good thing I have tons of those! This "hihat" sound goes into the rackmount mixer, then into the big mixer, then into the computer.

Another voice is the wild saw: A square wave oscillator (see, I do have a lot of those) goes into a module of my own design, a square-to-stepped-saw converter. It takes a square wave and spits out a stepped saw wave a few octaves below. I use this to modulate the frequency of the saw oscillator, the sound of which I love more than words can describe. This saw naturally goes into the rackmount mixer, then the big one, then into Bitwig.

The fourth modular voice is my CMOS noise module. Near the end of the video I decide to patch it into the same mixer the bassline is using, and then I play it by tapping the alligator clip to its output. Let's see you do THAT with regular 3.5mm jacks! The CMOS noise module is, guess what? A bunch of square wave oscillators modulating each other. The circuit is loosely based on the Roland TR-808 cymbal circuit. Since this voice is mixed with the bassline in the modular, it heads into the computer through the same path.

I absolutely love dub music, and love the idea of using a mixer as an instrument. It wasn't until I started devouring YouTube videos of live techno performances I realized this technique wasn't unique to dub; indeed, it's prevalent throughout electronic music! The first channel in the mixer is the iPad. I have my big mixer setup with two effects sends: one is the built-in spring reverb (that has an annoying ground loop I'll have to fix one of these days) and I'm using the "monitor send" to route sound into my Alesis Microverb digital reverb. The reverb comes back into the mixer in stereo. Throughout the video I manipulate the different reverb sends and returns, mostly the returns. At one point I crank up the Microverb's input and output levels, which makes a really nasty distortion I really love.

Once this modular is a bit more user friendly, I'll be releasing it to the public at http://chrisbeckstrom.com. Free and open source, for anybody to use in whatever way they want. In the meantime, here is a sneak peek!

This patch uses two clock dividers plugged straight into the CV input of a VCO, which has a very similar effect to using an analog R/2R ladder with square wave inputs. Then the VCO goes through a VCA modulated by a slope generator, then through a wavefolder, then split into a dry and delayed path, then out the speakers.The output of the VCO is also fed back into itself. Still working on a good way to go that; right now I'm using s~ and r~ objects outside the VCO abstraction.

Oh yeah, also the wavefolder is modulated by a sequencer, and feedback amount is modulated by another sequencer.

All sounds are coming from Pure Data (l2ork fork) and generated in real time.

These glitchy, distorted blips and beeps are a pretty good aural expression of how I feel about 2016.

PATCH NOTES
This patch is based on a bunch of feedback: things modulating other things modulating other things which eventually find their way back and modulate the first thing. When I try to do this on the computer I end up crashing everything. With analog circuits there is nothing to crash: it sounds awesome.

The pitch of an oscillator is modulated by the output of an R/2R resistor ladder, which is receiving gate signals from a 4-step shift register. The shift register is clocked by a square oscillator. The input of the shift register- the thing that gets it going, so to speak- is the output of a clock divider which is listening to the triangle wave coming out of the original oscillator. (It's not really a triangle wave- it's more of a rounded square wave, so the clock divider has no trouble spitting out divisions.) In this way there is a feedback loop: the oscillator speed is controlling its own rate of modulation! This accounts for the periods of silence or relative stasis. A few times throughout the video I make the oscillator go faster, which in turn modulates itself more, causing more activity. Turning the big oscillator knob to the left slows everything down.

Two wave outputs of the main oscillator- square and triangle- are routed into three inputs of a sequential switch. The third input to this sequential switch is the output of a saw wave oscillator. This saw wave oscillator's pitch is modulated by a 10 step sequencer, which in turn is clocked by the pulse output of the main oscillator. The sequential switch is clocked by another divided output of the main oscillator, again causing a feedback loop. The fourth input to the switch is the output of a module I call "space noise," which is really just a bunch of square wave oscillators making clicking sounds. I often use it for random modulation at slower rates; at faster rates, it's just noisy clicking.

As the sequential switch steps through each of its four channels, we're basically hearing each input in order: first the "space noise" clicking, then the main square wave oscillator, then the saw wave, then finally the triangle from the main oscillator. When the sequential switch is clocked slowly, we can hear each wave as if we were muting and unmuting four channels on a mixer in order. At fast speeds (audio rates) we hear the four outputs as a single wave. This phenomenon- things sounding completely different depending how quickly we hear them- never ceases to amaze and entertain me.

Finally, the saw oscillator (step three in the sequential switch) is being modulated by another 10 step sequencer, which is in turn clocked with yet another square wave oscillator. The clock divider which is clocking the sequential switch is receiving reset messages (gates) from the "space noise" module, which causes the clock division to become a bit random and glitchy.

The mono output of the modular goes into a mixer and some of the modular is sent to a vintage (90's!) Alesis Microverb II digital reverb, which is brought back into the mixer on two channels for some nice stereo. I like the combination of gritty analog sounds and gritty digital reverb. The Microverb came from a church, and I can guarantee they never put anything like these sounds through it.

The groove gets going around 10:28

I'm no modular virtuoso by any means, but just as with any instrument the key is practice... so here I am!

I've been practicing and preparing for my very first live performance on my modular this Saturday. A part of that practice is transporting it, setting it up, patching it, then tearing it down. I used to play gigs every week on saxophone and keyboards and I know setting up unfamiliar gear in a dark room can be difficult! To practice, I've been moving my synth throughout the house, patching it in all sorts of different locations.

We're just about at peak color here in West Michigan; what better time to take the synth outside and do some patching.

No super detailed patch notes for this one, partially because I forgot what I did, and since I've already moved the modular I can't refer to the patch (it no longer exists!).

Basically, a drum machine I built in Pure Data is running on the fantastic MobMuPlat iOS app, which is sending drum sounds out one side and 16th note clock out the other. The clock goes through an amp and runs the sequencers and a shift register, which is sporadically causing some VCAs to open up. Later on I play with a saw wave being modulated by a few different things, those things routed through my matrix mixer.

I also make use of my arduino digital oscillator, which now has CV control of frequency, wave type, and wave tone (crossfades between different waves). It's a bit quieter because it's only 5 volts but I think it sounds pretty cool... I'm using small wavetables to get a lot of that delicious aliasing, which I happen to think sounds fantastic going through analog circuitry.

The drum sounds from the iPhone are built in a very similar way to the hardware analog circuits on the rest of the synth: basic waves are being generated (in numbers instead of voltage), then used to modulate each other in the software. I also find myself inspired by the stark limitations of an analog-style workflow, so that's how I code as well. That said, I also have a few samples from a TR-909 in there... cause they sound so good!

You can grab the drum machine here (FREE! iPad only for now):
https://github.com/chrisbeckstrom/puredata_drum_machine

The output of the modular goes into an Alesis Microverb for that 90's digital reverb goodness, then right into a recorder.

The groove gets going around 10:28

I'm no modular virtuoso by any means, but just as with any instrument the key is practice... so here I am!

I've been practicing and preparing for my very first live performance on my modular this Saturday. A part of that practice is transporting it, setting it up, patching it, then tearing it down. I used to play gigs every week on saxophone and keyboards and I know setting up unfamiliar gear in a dark room can be difficult! To practice, I've been moving my synth throughout the house, patching it in all sorts of different locations.

We're just about at peak color here in West Michigan; what better time to take the synth outside and do some patching.

No super detailed patch notes for this one, partially because I forgot what I did, and since I've already moved the modular I can't refer to the patch (it no longer exists!).

Basically, a drum machine I built in Pure Data is running on the fantastic MobMuPlat iOS app, which is sending drum sounds out one side and 16th note clock out the other. The clock goes through an amp and runs the sequencers and a shift register, which is sporadically causing some VCAs to open up. Later on I play with a saw wave being modulated by a few different things, those things routed through my matrix mixer.

I also make use of my arduino digital oscillator, which now has CV control of frequency, wave type, and wave tone (crossfades between different waves). It's a bit quieter because it's only 5 volts but I think it sounds pretty cool... I'm using small wavetables to get a lot of that delicious aliasing, which I happen to think sounds fantastic going through analog circuitry.

The drum sounds from the iPhone are built in a very similar way to the hardware analog circuits on the rest of the synth: basic waves are being generated (in numbers instead of voltage), then used to modulate each other in the software. I also find myself inspired by the stark limitations of an analog-style workflow, so that's how I code as well. That said, I also have a few samples from a TR-909 in there... cause they sound so good!

You can grab the drum machine here (FREE! iPad only for now):
https://github.com/chrisbeckstrom/puredata_drum_machine

The output of the modular goes into an Alesis Microverb for that 90's digital reverb goodness, then right into a recorder.

I've been listening to a lot of new-to-me music lately, especially "classical" composers like Pauline Oliveros, Edgard Varese, and Xennakis, as well as a variety of electronic music from Elaine Radigue, Tod Dockstader, Suzanne Ciani, Jorge Antunes, and Josef Anton Riedl, among others.

(Side note: There are so many trailblazers in electronic music who happen to be female! Historically we seem to forget them, but hearing some of the amazing things they made, we should strive to remember them. Let's also support those currently making exceptional music with electronics, like the amazing Kaitlyn Aurelia Smith and Paula Temple. If you haven't heard them, please don't listen to my stuff, go listen to them! They're great.)

But I digress. I'm really interested in making music that is totally different from music I've made in the past; Music that isn't dependent on traditional harmony and regular, repeating rhythms. I'm trying to find some new sounds and new approaches. I suppose that means this is "experimental music."

This patch uses Pure Data, a free and open source graphical programming environment (like Max/MSP, but free- as in beer and freedom- and fully cross-platform), to generate MIDI, which is then sent to software, digital, and analog sound-makers. For the most part it plays itself, but occasionally I jump in to steer it in one direction or another.

Patch notes:
The PD patch generates semi-random MIDI notes on five channels. The level of activity can be either automatically altered or manually changed (I did a bit of both). It's not completely random though; sometimes PD will "save" notes to a 31 step array (a sequencer, basically) and sometimes it will play notes from the array instead of randomness. In other words, the patch sometimes repeats things, which I think makes everything sound a bit more musical... (but only a little bit more musical!).

Five channels of random MIDI are routed into Bitwig Studio. Three of the channels go into Bitwig synths (2 Polysynths and 1 FM synth). One channel gets routed back out into a Korg Volca Keys (not pictured). The final channel goes into the newest module on my modular, an Arduino-based digital oscillator. One of the channels (I forget which one) is copied and sent into a Bitwig drum machine rack, which is half-filled with various bass drum, hihat/cymbal, and other drum sounds. Because the MIDI it receives is fairly random (and only half the slots have sounds in them) we only hear these sounds some of the time. I think that's pretty cool.

On the modular, the MIDI note messages change the pitch of the Arduino oscillator and also generate gate messages. Those gate messages go into a gate-to-trigger converter, which triggers an A/D envelope, which in turn modulates a low pass gate (using it like a VCA). The Arduino oscillator wave is modulated by an analog LFO (and knobs!) and then routed into the audio input of the LPG. I coded the Arduino using the fantastic Mozzi library, and packed the code with about 8 different wavetables, all lofi, crunchy, and modulatable from the front panel.

The Arduino gate also runs the 10 step sequencer, which is modulating the pitch of an analog square oscillator. That oscillator is going into another VCA which is being modulated by the output of a n AND gate. The Arduino gate and a random square LFO are going into the AND gate, which has the effect of randomly letting us hear the square wave, but only when the Arduino is also spitting out a gate signal.

Finally, the output of the LPG is going into a PT2399-based delay module, which is then going into a 3 input mixer with everything else. All that comes out of the modular, goes into an $8 USB audio interface and pops back up in Bitwig.

If anybody is interested in downloading the PD patch, let me know and I'll post it somewhere!

An exercise/improvisation with a drone. Some of the biggest and most epic sounds I've created with the modular yet. At times it sounds like a distorted guitar through a stack of amps, but it's just a bunch of square wave oscillators.

Patch notes:
The main sound is a square oscillator into a clock divider (generating multiple octaves) and then four of those octaves go into the four inputs of a sequential switch. The sequential switch is clocked by another oscillator that can go from audio rates all the way down to clicks (very slow).

When the sequential switch is clocked at audio rates it sounds sort of like frequency modulation, and depending on the clock speed you get various intervals and timbres. I don't really understand why this happens, but I discovered I could create various chord-type sounds by changing the clock speed.

The output of the sequential switch is mixed with one of the other divider outputs (very low suboctave) and a couple higher octave sounds going through semi-randomly-opened VCAs.

All that stuff gets a splash of delay, two channels into the mixer for some spring reverb, then into Bitwig running on Linux. I'd love to hear this on some really big speakers– on my little monitors it shakes the whole basement!

Inspired by the music of Stockhausen, Schoenberg, Babbitt, and Eno

Signal path:
PD generates random MIDI notes and velocities, LinuxSampler takes that MIDI information and plays samples of a grand piano (a free as in beer and freedom sampler instrument by the way), then sends that audio into Bitwig to add a splash of reverb

Created on linux
Software used:
Linux running KXStudio
Bitwig Studio 1.3.1
Catia (JACK router)
Pure Data
LinuxSampler
Cadence (JACK control)
Qsampler (LinuxSampler GUI)