Luke Teaford

Introducing Hacker TV

Wed, 18 Mar 2026 00:00:00 GMT

Today I am announcing the release of Hacker TV, a video synthesizer for the world wide web!

One of the things I love so much about audio synthesizers is that they are a tool for creating something from nothing: the signal and its processors are generated entirely by the player from within the machine. The resulting sound is a kind of magic: that something seemingly simple can make something uniquely expressive. I have been playing some of my favorite synthesizers for over a decade and have never once been bored. I have yet to approach exhausting any of the possibilities of these instruments.

Of course, the same creation from nothing is possible with visuals, too, by working in the medium of light. Video synthesizers are even more unusual, though. Few hardware options exist and many of them work in a fundamentally different way: by processing a signal that comes from without. This is cool and can yield impressive results, but philosophically it's much less interesting to me. To work with video is to come into the creative process too late in the game: when thousands of decisions about the image have been made and the material is less flexible. Generating signals directly allows the artist to work on the fundamentals of perception more directly: light and sound.

In any case, video synthesizers require a lot of patching and a collection of unusual adapters to integrate with modern workflows: capturing and recording is a burden and violates an additional philosophical principle: to go from thought to expression as quickly and directly as possible. It seems like software is the best solution, and existing tools have some appeal; especially Max (Jitter), TouchDesigner and Processing but each of them has a learning curve and feature sets I am not interested in. I will likely end up working with these tools in the future, but my third philosophical goal is to prove the value of the Web as an artist's medium.

Minimum Viable Product: Overlapping Rectangles

I began building Hacker TV as a proof-of-concept in January 2026. To align with my design goals, my video synth needed to display and animate three rectangles simultaneously. One rectangle must be red, one green, and one blue. When rectangles overlap, they must create yellow, cyan, magenta and white as appropriate. The UI must be accessible to keyboard users while still being fun, and the animation must run at 60fps (for software quality reasons: not aesthetics; throttling the animation is fine).

I spent a couple hours hacking together the proof of concept. The HTML canvas element was a convenient and obvious choice with its blend modes and fill rectangle methods. Most of the time building the POC was rescuing a custom Slider from an abandoned React project: the React API is nicer to work with than vanilla JS in some ways, but since I am building my website to last I prefer to use Web standards than frameworks. This is not a requirement and I would have used React for this without much objection if it came to it. I would expect AI to make migration from frameworks to Web standards trivial.

Hacker TV was operational but a little bit boring. Fun is not a requirement of the MVP: the first part is purely to understand the technical foundation. Still, it was kind of fun animating rectangles and watching them interact, creating new colors in the overlapping areas. There is something cool about seeing the primary colors of light demonstrated in this way even though it is not surprising.

One always learns something by using a product: the first lesson is the relationship between the UI and its effect. If X and Y origin and Height and Width each corresponds to a slider, it starts to feel almost like it would be better to allow click-and-drag on the canvas itself to define a rectangle. Does the user expect animation to pause while drawing on the canvas with a mouse? How does the user determine which rectangle is being drawn? By counting? By requiring a separate click to select? By using a key press combination (a modal mixture that presents accessibility challenges and becomes impractical on mobile devices anyway). Ultimately, none of these experiments was satisfying. Instead, Height and Width scale exponentially. This allows finer control in the lower part of the range where the sliders are more likely to be set and as it approaches the upper part of the slider, it expands to fill the entire dimension. This is sufficient to break the 1:1 association of the UI control with its effect.

A few hours of looking at the same three rectangles becomes boring, so I added a button to randomize the parameters on page load. In this stage, the animation works entirely by framerate: e.g. the origin is translated by a tiny fraction in each animation frame. The same settings look different on a laptop than on a phone as a result: a clear problem to fix in the next iteration.

Modulation: the Lifeblood of a Synthesizer

Unsurprisingly, the video synth needs modulation in the form of LFOs (low frequency oscillators, for the uninitiated). This solves the timing discrepancy by separating the animation from the frame rate. LFOs are simple enough to make, but programming in the age of AI makes this an interesting challenge. Once I've declared a const lfo1, Copilot knows what to do: it makes an object with keys for saw, square, tri and sine. I cannot resist tab completion when the imperfect code it creates adds immediate value: I can see the result of modulating the x origin right away? Sign me up.

The judicious use of AI requires thought and taste. The AI code for this would suit most people, but a discerning synthesizer designer like myself realizes the bipolar LFOs are disgusting. Bipolar LFOs require the artist to set the offset and modulation depth in harmony with each other, meaning that changing one will most often necessitate changing the other. When you have a sufficiently large patch, this becomes a pain to tune and to keep track of. When the modulation depth or offset is itself dynamic, the difficulty spikes and you end up with those wack woo-woo-woo-woo synth effects. LFOs with too much depth and a strictly regular rate become fatiguing in video, too. It's just less obvious.

Sine waves are also horrendous. The smooth undulations seem useful, but the rate of change slows as it nears the peak and the trough. The triangle shape is sufficient for back-and-forth modulation and has the benefit of being constant: more mathematical and somehow less "ideal".

Finally, the square wave modulation is fine, but it's worth adding a configurable threshold to provide a variable pulse width instead. Adjusting the duty cycle of a square wave LFO can create interesting effects and it's a great real-time performance control to shift the balance of modulated/unmodulated signals. I am surprised AI didn't implement it this way initially, but maybe this is an effect of the probabilistic nature of AI. Most people will implement square waves without PWM because it makes a more natural vibrato. Proponents of bipolar LFOs have their reasons, too, but these would be likely stumbling blocks for a vibe coder without expertise and opinions in synthesizer design. If you are such a person, what is it like outside?

Originally, I experimented with making some LFOs bipolar (there are use cases: more on that later). I experimented with tuning each LFO to different rates or adding "random" as a shape. This became unwieldy when comparing one LFO to another in the UI, it seemed that some would be malfunctioning because the rates would be different for similar positions. This makes it difficult to scan and find a suitable LFO for a certain effect. In the end, making each LFO act the same and providing nine of them has created the best experience.

LFOs are a primary modulation tool, but they are periodic and predictable. Flux staggers toward a series of random targets, creating an organic drifting gesture. Sample and Hold selects the instantaneous value of an input signal at its clock pulse and holds that value until the next clock pulse. Track and Hold is similar, but it follows the input signal and holds it when the clock pulse is high. These techniques unlock advanced functionality in Hacker TV. For example, you can patch the Sample and Holds as an Analog Shift Register to create a cascading modulation effect. Hacker TV's modulation system can produce a wide assortment of surprising visual effects and flourishes that are much more captivating than plain LFO movement.

As the variety of modulation grew, new problems emerged: sliders became an impractical way to set modulation depth (having little bits of modulation mixed into everything can create a sort of incoherent noise). Changing one's mind became expensive in patching the synth. The decision to modulate a rectangle's height with LFO 1 meant finding the corresponding slider and moving it to zero in addition to maximizing the LFO 2 mod depth slider. The most obvious solutions are to make routing decisions on behalf of the synthesizer player (a heresy), scale back the variety of modulation (restrictive), or add a modulation matrix (complex to build and to use).

A Modular Video Synthesizer

Since I have no requirement at all to make Hacker TV especially user friendly, I decided on an unusual way to handle modulation. Each destination has an offset and a corresponding Modulation Amount parameter that controls the depth of each modulation. This means that if LFO 1 and LFO 2 are routed to width, the LFOs are affected by the modulation depth and then summed together. Since each modulation is scaled by the same amount, it makes it easy to change routings without having to repatch. Mixing multiple modulations together is easy and if modulation ever starts to "pin" at the top, reducing the modulation amount will bring it down. You can also exploit the pinning for creative effects.

This decision requires that each modulation source have its own routing section, but it provides the advantage that a single source can quickly be routed to multiple destinations. For example, changing color and geometry channels at the same time creates intricate linked effects, but what if you need to make the modulations mirror each other or move against each other?

This required the creation of Processors. The processors are more sophisticated mixers that allow fine-grained control and inversion, but as a result are limited to the number of inputs they can accept. Processors are also the way to create bipolar voltages: by mixing in an offset and an inverted modulation source, you can modulate around the offset. This is useful for situations like causing a stutter or jitter on an otherwise evolving motion. The processors can also attenuate each input: some sources like noise and square waves are much easier to patch when attenuated for subtle effects.

Gradually, Hacker TV became a fully modular video synthesizer: nothing is routed in the default patch. Part of the reason for this is that modular synthesizers are cool, but a more important reason is that it's practical as an "onboarding" exercise to allow users to choose the modulation and see the effect. My hypothesis is that it will be easier to make the synthesizer intuitive than to explain synthesis in general or particulars of Hacker TV.

I am aware that there are a staggering number of parameters and although early prototypes were fun to use on a phone, it became unsustainable as it grew. Full screen mode is unavailable on iPhone. Changing parameters without being able to see the result is not fun... and anyway there is a lot to do. As a compromise to the limited mobile editing functionality and the difficulty of building patches from scratch, I added several presets that are fun to select from the drop-down menu.

Staying True to the Vision

This is the first personal project of substantial complexity I've made partially with AI. I am not one to vibe code anything, but being able to do quick, incorrect things as a proof-of-concept suddenly becomes possible in a way that it wouldn't before since test driving fleeting ideas would require me to write those features. For example, I can compel AI to make the sources support gradients instead of solid colors or to draw shapes other than rectangles and build that out quickly, sloppily, at just-good-enough quality. Each of these and other ideas I can explore are kind of fun, but the complexity continues to grow and eventually the UI itself becomes a limitation. With a two-color gradient, why not adjust the color stops? Why not add more? Why not change hue/chroma/lightness/alpha independently?

Again, the question of "what to build" is up to the human programmer: AI does not grasp concepts like "fun" or "irritating to program" in a meaningful way. It is also evident that engineering skill is essential for prompting AI and knowing what is not worth pursuing. Maybe I could attempt to provide context for fun or how much programming complexity I think users would bear, but this seems pointless to me since I can use the product. AI is a means to an end and of no interest to me in itself.

In general, the user interface is the most important part of software. It does not matter what features software has. It matters what users do with software. Hacker TV users will draw as many as three single-color rectangles. My ambition is to make this activity meaningful and engaging by continued development. The next features will help make patching the video synthesizers easier and preserving its output more practical.

Upcoming features

Record video (to prevent "walled garden" problems)
User presets
Configurable video dimensions
Additional presets demonstrating functionality (clever ways to program Hacker TV from the UI)
MIDI CC implementation (where available)
UI Refinements
Audio reactivity
Webcam/video stream mixing
User manual/tutorial videos
Geometry tweaks and antialiasing (optional)

If you would like to support development of these features, the best ways are:

Share Hacker TV with friends/Internet randos (https://luketeaford.com/software/hacker-tv)
Send me a tip

X-PAN Feedback Loops

Sun, 25 Jan 2026 00:00:00 GMT

The Make Noise X-Pan is extremely useful for feedback patching since it can mix five stereo channels with CV control of the cross fading and panorama on two channels. Many of these patches are theoretically simple, but will require some careful tuning by ear to manage the feedback loops without creating that typical screeching resonance sound (when in doubt, shoot for the other species of feedback sound: weird clicking).

The X-Pan works especially well with Morphagene to route the signals in interesting ways. Individual preferences will apply, but I set Morphagene's inop to 1 to record the input only so that I can mix in X-Pan or similar and choose the ratio myself instead of having to do it solely thru Morphagene.

Building a Multiple Feedback Path

Of course, it wouldn't be a modular synth if there weren't many interesting ways to patch this, but this is a useful way to begin to understand the expressive potential of feedback paths in the instrument. I will assume you are starting with something recorded into Morphagene, but this will also work with "no input" mixing style patches.

Be careful when patching feedback in the audio path: it will be loud.

Patch Morphagene's LEFT and RIGHT outputs to your monitoring system.
- Patch also into X-Pan's AUX input.
- At this point, adjusting X-Pan's AUX LEVEL and Morphagene's SOS will allow you to go from complete silence with AUX LEVEL and SOS fully CCW to gnarly distortion (both knobs somewhere in the middle of their range). With SOS fully CCW and AUX LEVEL set above its minimum position, the famous screeching feedback noise will be created with "no input".

Explore the differences in tone that result from different combinations of the above. I like to set Morphagene's option cvop to 1 for the tempo synced ramp wave: it is useful to use Morphagene's CV OUT patched to one of these controls.

Morphagene LEFT output → QPAS LEFT input
QPAS LEFT HP → X-Pan CH 1 CH A input
Morphagene RIGHT HP → X-Pan CH 2 CH A input
QPAS RIGHT HP → X-Pan CH 2 CH A input
X-PAN CHANNEL 1 PAN fully CCW
X-PAN CHANNEL 2 PAN fully CW

As you adjust the X-FADE balance between the A and B inputs, you will potentially hear the other most-common kind of feedback noise: weird droney clicks. Experiment with the entire patch at this point and observe how many more varieties and textures of noise are available. You may also get sort of trilling whistling or other surprising sounds. The QPAS settings will all make a big effect here especially resonance, cutoff and input level.

QPAS LEFT LP → Mimeophon LEFT input
QPAS RIGHT LP → Mimeophon RIGHT input
Mimeophon LEFT output → X-PAN CH 1 CH B input
Mimeophon RIGHT output → X-PAN CH 2 CH B input

Now the entire patch is a playable surface for feedback exploration. As you change any of the parameters, the effects can be drastic and even if you begin with no other input but the feedback, this patch will generate enough variety to be interesting on its own.

After playing manually for a while, you can develop ideas about which modulation schemes create the desired effects and then control those with CV. Rhythms you make in this way will take on their own shape and in time they tend to overwhelm the source material. This is especially true when re-recording the Morphagene.

Patching Make Noise René V1 as Buchla Easel-style Chromatic Keyboard Arpeggiator

Sun, 24 Aug 2025 00:00:00 GMT

The Make Noise Shared System can be patched as an easel-style keyboard arpeggiator with Pressure Points and Rene V1. The patch works by combining James Cigler's touch sequencer patch with a little bit of programming and extension with Presure Points to add octave shifts and other performance controls.

Rene Settings

Access page: turn all locations off
X gate page: turn all gates off
X fun page: enable SNAKE
X fun page: enable G+MOD
Q page: enable all 12 pitches for chromatic control. Program so that each step increases by one semitone. Optionally you may want to program it in a certain key to have 2 octaves range on a single page or whatever other configuration you desire.

The Patch

CLOCK → XCLK
CLOCK → XMOD
QCV → DPO v/Oct.
G-X → Optomix STRIKE
Pressure points ROW 2 → DPO EXPO input: tune it such that each of the 4 pressure points steps increases by one octave. Combined with the Rene semitone settings, this gives chromatic control over 4 octaves.

Further Explorations

With the basic patch set up, it's fun to arpeggiate chords, but since so much of Pressure Points remains unused, there are lots of ideas left to explore.

Use another row of pressure points to control clock rate.
Use pressure output for CV of clock rate or timbral control of DPO.
Use common gate output of pressure points to clock Wogglebug.
Use common gate to jumble Tempi.

Patching a Chaos Generator with a Slew and a Pulse Wave

Fri, 27 Dec 2024 00:00:00 GMT

This patch tip is inspired by and indebted to Rob Hordijk, whose Nord Modular G2 Pages introduced me to the concept. Regrettably, that site appears to have been removed. My riff on this patch seems to work a little better for contemporary hardware modular synthesizers by working with sub-audio rate pulse waves and slews rather than audio rate squares and low-pass filters which fewer players will have available to use as dedicated chaos signal generators.

Chaos vs. Randomness in Mathematical and Musical Contexts

A fully random signal is non-deterministic. Traditionally, this type of signal would be derived from uniform noise like white or pink noise, and although those kinds of signals would have certain statistical characteristics, at any moment the signal is random. It won't have apparent repetitions or discernible patterns.

Chaotic signals are different because they are complex and sensitive to their initial conditions, but they seem to react more slowly, evolve gradually, and sometimes get trapped into repeating or morphing patterns. This kind of signal is more musically useful and it's also more fun to play since it doesn't necessarily react immediately to changes but gives the performer control of the underlying voltage system. Chaotic signals offer a higher level design of a synthesizer patch and are an excellent technique to explore in modular synthesis.

Here's a riff on a patch I first learned from Rob Hordijk's Nord Modular site. You can patch a chaos generator with the following: a S&H, a square wave oscillator and a low pass filter.

Chaos Generator Patch

Pulse wave LFO → Slew input
Slew output → Sample and Hold (signal) input
Slew output → Pulse wave frequency
Timing pulse (e.g. a clock or manual gate) → Sample and Hold (hold input)

The sample and hold output is the chaotic signal. It may be useful to patch it to an oscillator's pitch control so that the effect is easy to hear (especially while dialing in the settings since the chaos patch can freeze up in some settings-- it relies on finding a range of "sweet spots" where it will be the most active).

Changing any of the parameters will have an effect on the apparent patterns of the chaos. It is typical for a chaos generator to create riffs, staircase shapes, wildly swinging voltages and more. Playing its input parameters in real time can become an interesting performance control as you attempt to navigate the chaos generator into and out of patterns-- you may even choose to "lock it up" deliberately by moving beyond the ranges that keep the patch working.

What to Do with Chaos

Once you're happy with the chaos signal, it can be routed to any parameters you desire. Keep in mind that different parameters will respond differently (e.g. logarithmic vs. exponential responses) and that some parameters will sound most dramatic in different ranges. Of course, the power of modular synthesis is that you can further process the chaotic signal and here are some patches that will reward further exploration:

Slew the sample and hold output.
Patch another slew between the first slew and feeding back the pulse wave frequency.
Patch the chaos into an addressable sequencer such as the location input on Make Noise's Rene. This allows another layer of control since the values in each location can be changed while the chaos is controlled in another part of the patch.

Serge Paperface Sequencer/Programmer Patch Tips

Tue, 24 Dec 2024 00:00:00 GMT

The 50th anniversary Serge Paperface system is an inspiring instrument for players who admire the flexibility a modular synthesizer provides despite what seem initially like limitations. This is especially true of the Tempo di Roma sequencer panel which is a masterclass in patch programming possibilities. These are my notes and observations I made while studying the Serge sequencer/programmer concept and my perspective is informed by playing other modular sequencers and building Gramp Utah, a Max for Live device that brings some of the 1970s step sequencer magic to Ableton Push and contemporary workflows.

The Tempo di Roma panel is, as the saying goes, "more than the sum of its parts" and in order to prove that, let me first explain some of the features and peculiarities of the modules that comprise the panel. Afterward, I'll share some practical patch tips based on this knowledge. Let's grab some bananas and get going!

(One of the fun things about patch programming is that it becomes a game of resource management and in order to play the instrument well, it helps to know multiple ways to patch the functions you want depending on what else is already being used.)

Sequencer

The Sequencer is a simple pulse sequencer. Traditionally, it would be used in conjunction with programmers to create CV sequences. On the Tempo di Roma panel, this is not strictly necessary since the two Sequencer/Programmers have their own CLOCK inputs, but it is still useful for a lot of creative patching and changing the order programmer steps are accessed.

It is helpful to think of Serge sequencers as counters. The sequencer counts pulses and can reset or hold which temporarily suspends counting.

I'll explain some of the more advanced patches in a future post that covers the other panels of the 50th anniversary paperface system, but for now I will call attention to just one idiosyncrasy of the pulse Sequencer: if the CLOCK input is high and the voltage at the HOLD input changes, the changing voltages at the HOLD input act like clocks and advance the pulse sequencer.

For example, this means that you can patch the METRONOME from the Clock to the Sequencer input and use the manual GATE output from a sequencer to run the sequence selectively. This is possible to patch with the Router or Peak and Trough, too, but it takes fewer cables to do it this way and there will be times when this patch is the one to choose.

Sequencer/Programmer

The two Sequencer/Programmers are the most fully featured sequencers on the Tempo di Roma panel and they're the major creative building blocks in the paperface sequencing idiom. Each sequencer can be stage addressed with pulses (for example, the pulse Sequencer's outputs) or clocked. The HOLD input does not exhibit the same behavior as the pulse sequencer: successive toggling of HOLD while the CLOCK input is high does not result in multiple pulses.

The Sequencer/Programmer has a trick of its own, however: the UP/DOWN input, which may seem counterintuitive since on the panel the lights move horizontally. Recall the counter metaphor and you will realize that the sequencer moves along a number line and UP/DOWN increments or decrements the counter.

A note on RESET

The stage pulse outputs can't be used with the RESET of the Sequencer/Programmer: patching from a pulse output of a Sequncer/Programmer to RESET will "lock it up". Instead, you will need to patch from the pulse output of a Sequencer/Programmer to the pulse input of the stage you wish to reset to. It seems to work in the same way as contemporary Serge sequencers' PRESET input: it resets and runs only when the gate is high. This is a useful design for one-shot sequences among other things. If you want the classic reset behavior, you can always logically invert the signal before patching it to RESET.

Clock

The clock is unsual in the world of Serge modular. In general, Serge modules require patching, have a huge range, and accept control voltage inputs for their parameters. The clock has a narrow range and no CV control, so it is ironic that it is the most confounding piece of the panel. However, it is nice having a stable clock that outputs narrow trigger pulses and that doesn't require patching. The fine tune knob is intentionally subtle and perhaps is best for situations where it is necessary to manually sync the metronome to an external source-- I have fallen into the habit of leaving the fine tune knob around 12 o'clock.

Router

The router module is composed of four smaller modules: three bi-directional routers ("switches") and a flip flop. The top two switches are momentary: the routing changes when the voltage in the switch is above or below a threshold. The bottom bidirectional router is switched via the flip flop instead, meaning that it toggles its routing on and off: the input dipping below the threshold is not enough to change its state and instead it needs to "wait" for the next high voltage.

This arrangement of the switches is the key to some surprisingly deep sequencing options and is preferrable to having only one kind of switch or another.

Bi-directional routing means that the A0 and A1 inputs could be patched to a common output B or that A0 and A1 can be outputs to a common input B.

Different Inputs/Common Output Examples

Pitch sequences to A0 and A1. B output to oscillator v/oct.
Pulses to A0 and A1. B output to sequencer clock.
White noise to A0. LFO to A1. B output to filter frequency.

Common Input/Different Outputs Examples

Pitch sequence → B.

A0 → Oscillator V/OCT.

A1 → Smooth/Stepped Generator SMOOTH input.
Sawtooth → B.

A0 → Filter 1.

A1 → Filter 2.
Audio signal → B.

A0 → Left output.

A1 → Right output.

Peak and Trough

Finally, the Peak and Trough module which takes two voltages and outputs two voltages: the greatest signal above 0V and the lowest signal above 0V. The Peak and Trough is primarily useful as a control voltage utility. My typical use case is to patch a trigger signal and a control voltage row into the peak and trough inputs. Take the output from TROUGH and it will be a trigger scaled to the maximum amplitude of the step on the sequencer. This voltage is perfect to patch into a negative slew to achieve a CV controlled envelope depth. Similar patches work at audio rate to make a characterful and interesting VCA.

For experimental patching, mixing any two control voltages will make more complicated shapes such as an LFO that sometimes breaks into chaos when combined with a random voltage. Another classic patch is to use it as an automated arranger, sending a value to the "high" voice from PEAK and a low value to a bass voice from TROUGH.

Overview

In the world of Serge modular, possibilities gradually reveal themselves the more you practice patching. At first, it may seem like offering 2 4-stage, 3 channel sequencers and a separate 8-step pulse sequencer imposes pretty serious limitations on the kinds of music that can be made with it, but here are some patches you can use to patch program the Tempo di Roma panel for other popular sequencer features.

Expansion - 8-Stage, 3 channel Sequencer

Of course, the independent Sequencer/Programmers can create a simpler, more typical sequencer like a Moog 960.

Pulse (e.g. METRONOME) → Both Sequencer/Programmer CLOCKs
Both Sequencer/Programmer Stage 1 PULSE OUTs → Bottom Router SWITCH
FLOP → Middle Router SWITCH
FLOP → Top Router SWITCH
Left Sequencer/Programmer A → Top Router A1
Right Sequencer/Programmer A → Top Router A0
Top Router B → Destination (e.g. oscillator V/OCT)
Repeat this process for the other two channels on the middle and bottom routers. Other fun destinations for these sequencer channels are wave shape and decay time (if driving the sequencer with a variable pulse such as from Negative Slew)

As a bonus, this has the advantage of "nesting" sequences since both sequencer/programmers are counting continuously meaning that you can have access to 6 different 4 step sequences which can be combined in Peak and Trough. The pulse Sequencer and the pulse outputs of the Sequencer/Programmers are also available for expansion.

Sequential Switch

The router can be patched as a sequential switch with the help of a pulse sequencer. This is useful for turning a sequencer/programmer into a selectable arpeggio: allowing the player to select with a button press or CV pulse one of four 3-note chords.

Pulse (e.g. Clock METRONOME) → Sequencer CLOCK
Sequencer stage 2 → Router top SWITCH
Sequencer stage 3 → Router middle SWITCH
Sequencer stage 4 → Sequencer RESET
Sequencer/Programmer A → Router top A0
Sequencer/Programmer B → Router top A1
Router top B → Router middle A0
Sequencer/Programmer C → Router middle A1
Router middle B → Desintation (e.g. Oscillator V/OCT)

Further explorations:

Experiment with new rhythms by patching the sequencer's HOLD or by using irregular pulses
Instead of the pulse Sequencer, use a Sequencer/Programmer pulse stage outputs to the SWITCH inputs. This can be interesting for situations where each chord should have up to 3 channels of related CV (e.g. to change the rate or probability of incoming pulses). It is also easier to reverse directions and patch pendulums using the Sequencer/Programmer since it has a dedicated UP/DOWN input.
Try sequencing the selection of the arpeggios by pulse selecting or clocking the sequencer/programmer whose A/B/C rows are used for pitch programming.
This technique works equally well for things other than pitches and doesn't need to be constrained to offset voltages. Each step of the sequential switch could route different audio sources, for example.
There is probably a watch to patch the pulse voltages necessary using the flip-flop, peak and trough and a positive slew for logical inversion, but I can't quite work it out. This would free up the Sequencer and a Sequencer/Programmer.

Pendulums

Another way to push the sequencers beyond their 4 steps is to patch them for pendulum motion using a Sequencer/Programmer and the flip flop Router.

Pulse (e.g. METRONOME) → Sequencer/Programmer CLOCK
Stage 1 PULSE OUT → Bottom Router SWITCH
Stage 4 PULSE OUT → Bottom Router SWITCH
FLOP → Sequencer/Programmer UP/DOWN

This will create a six-step pendulum: 1-2-3-4-3-2. If you want the other style eight-step pendulum (1-2-3-4-4-3-2-1):

Pulse (the same one driving the Sequencer/Programmer) → pulse Sequencer CLOCK
Pulse Sequencer Stage 1 PULSE OUT → Sequencer/Programmer HOLD
Pulse Sequencer Stage 5 PULSE OUT → pulse Sequencer RESET

With either pendulum motion, it's possible to experiment with different patterns and stop/start points for a range of minimalist sequencing techniques such as irregular sequence length or changing which notes are doubled.

Classic Pulse Sequencer (Ping Pong Pinging)

The traditional pulse sequencer to programmer patch remains an excellent starting point for more experimental patching of your own.

Pulse (e.g. METRONOME) → pulse Sequencer CLOCK
Pulse Sequencer Stage 1 PULSE OUT → Sequencer/Programmer Stage 1 PULSE IN
Repeat this process for the other 7 pulses, freely mixing which pulse Sequencer stages map to which stages on each of the two Sequencer/Programmers
Left Sequencer/Programmer GATE → Filter IN
Adjust the filter resonance so that it rings out but doesn't sustain infinitely
Filter LP → Left Signal OUT
Right Sequencer/Programmer GATE → Filter IN
Adjust the filter resonance so that it rings out but doesn't sustain infinitely
Filter LP → Right Signal OUT

Of course, there is no reaason to treat each pulse Sequencer output the same-- each pulse can be used in different ways from the others since there are no common outputs like more typical sequencer designs have. This means you can trigger sample and holds, ping filters, clock, reset or hold sequencers, toggle the flip flop, start an envelope cycle, and any combination is available to the player to explore. I will share more ideas in future installments that detail the other two Paperface 50 Panels, but in the mean time hopefully this inspires you to patch in new ways.

Patching René v2 as a Powerful Arpeggiator

Mon, 03 Jun 2024 00:00:00 GMT

Many popular keyboard synthesizers include arpeggiators: the sound of staccato chords is evocative of 1980s soundtracks, cheesy ballads and one-finger keyboard virtuosity. The tell-tale electronic pulsing sounds undeniably cool and it's fun to let the arpeggiator work its hypnotic magic while tweaking knobs to add real time expressivity. Arpeggios are practically a genre of electronic music by themselves or as part of a larger composition.

For the modular synth player, there are many interesting ways to patch arpeggiators with step sequencers and touch interfaces. Though the basic patch will work with most sequencers, Make Noise's René 2 sequencer allows some especially creative techniques.

High-Level Arpeggiator Theory

Let's think about what an arpeggiator does in order to understand how to patch it. An arpeggiator iterates thru a sequence of notes with a predetermined rhythm, repeating as the notes are held. On a keyboard, one might play a C Major 7 chord and let the arpeggiator play each note individually. Some arpeggiators have a chord memory so the chord can be transposed by simply playing a different key (D would play a D Major 7 chord, for example).

With a modular synthesizer, a keyboard with this kind of functionality might not be available and you don't need a specialized module for this: it can be patched. In the most basic sense, there are three ingredients: the notes to arpeggiate, whether or not the arpeggiator is running and a transposition of the arpeggio. This is easily modeled in a modular synthesizer by mixing the step sequencer pitch output with an offset voltage from a touch controller (or keyboard, or another sequencer... you get the idea).

The next level of sophistication includes resetting the step sequencer so that the arpeggiator begins on the same root note each time. Most step sequeners have a reset input that is useful for this sort of thing.

Finally, we need a way to run the sequencer when a touch control is activated or to let it run automatically. Running on its own is typically called "latching" in synth jargon. If you have a touch controller that is capable of generating a manual gate, that will be sufficient for run/stop behavior and reset.

The Patch Generalized

Clock to step sequencer.
Manual gate to sequencer reset.
Manual gate to sequencer run/stop/hold. You may need to logically invert the gate depending on your sequencer. For example, if your sequencer has HOLD instead of run, you may need to patch a low gate into it to stop it instead of a high gate to make it run.
Sequencer cv output (v/oct if applicable) to oscillator pitch input.
Voltage from a touch controller to oscillator pitch input (to transpose).
Patch oscillator to a VCA in the usual way and use an envelope triggered by the sequencer's clock or gate programming outputs.

Patching with René 2

Clock → René 2 X Clock in.
Pressure Points common gate output → René 2 X Mod in.
Pressure Points row output → René 2 X CV in.
René 2 X CV out → DPO v/oct.
René 2 X Gate output → Optomix channel 1 strike input.
DPO Final output → Optomix channel 1 input.
Monitor Optomix channel 1 output.

René Settings

On the X Access page, enable at least a few steps. You will most likely want to tune these to a chord or whatever other intervals you're arpeggiating.
On the X Fun page, enable Fun.Mod.Reset, Fun.Mod.Run/Stop and Fun.CV.Add.
On the X Gate page, enable gate on each step (at least for now).

Further Exploration

Elaborate arpeggios can be created by using René 2's numerous advanced features. Gate programming enables more interesting rhythms than a typical per-step trigger. The Y channel can be used in tandem to arpeggiate a different sequence or use different gate programming, for example, choosing some gate events on the X channel to trigger a square wave in Optomix channel 2 and gate programming in Y to trigger the sine wave output. This could be any variety of sequencing controls: using one gate pattern to clock a stepped random voltage used for timbre of effect related parameters leads to surprisingly musical effects.

State programming allows even deeper exploration of the space of possibilities with touch or CV control. Changing snake patterns reorders the notes in the arpeggiator and of course lengths and directions and even run stop behavior can be programmed with states. This is useful for example if you want to take your hand off the manual gate and enable latch mode for some states but not others.