Arpeggios

Intention

A theory session to understand arpeggios — what they actually are, and how to build one in the modular world out of parts I already know. An arpeggio is just a chord played one note at a time instead of all at once: take the notes that would sound together as a chord and spread them out in time, in some order, looping. The classic keyboard gesture (think a harpsichord run or a synth-pop bassline) is exactly this — the harmony is the same, but the notes arrive in sequence.

The question this patch answers is: if I already have a module that hands me a chord as a bundle of pitches, how do I turn that bundle into a sequence? The answer is a dedicated arpeggiator module, and the interesting part is the clock relationship that drives it — a slow clock changing the chord, a fast clock stepping through its notes.

Starting patch

The signal path reads left to right, but the idea is easiest to follow in three stages: make a chord → arpeggiate it → sound it.

Stage 1 — make a chord that wanders. DiatonicCV (Aaron Static’s Diatonic Chord Generator) is the new harmonic engine. You tell it a scale (Scale In) and it builds chords that stay inside that scale — every note it outputs is a legal scale degree, so nothing it produces can sound wrong against the key. The Chord knob picks which scale degree the chord is rooted on (I, ii, iii, IV…), Type picks the chord quality (triad, seventh…), and Octave, Inversion, and Voicing shape how the notes are spread. Crucially, its Chord Out is a single polyphonic cable — one wire carrying all the chord tones at once, the way a poly cable carried multiple voices back in session 8. That bundle is the raw material the arpeggiator will unpack.

To keep the harmony moving, RANDOM (VCV’s random voltage generator) patches into the Chord CV input (green — modulation). Random outputs a fresh stepped voltage on each clock, so the chord degree jumps around the scale on its own — I, then vi, then IV, wherever the random value lands. Because DiatonicCV constrains everything to the scale, even random chord choices stay diatonic and consonant; the randomness changes which chord, never whether it fits.

Stage 2 — arpeggiate it. The ARP module (Hampton Harmonics) is the heart of the session. It takes the polyphonic chord into its In v/oct, and instead of letting all the notes sound together, it plays them one at a time, advancing one note per clock pulse at its Clock input. Its Out v/oct is therefore a monophonic stream of pitches — the chord, unrolled into a melody. Its Out Gate fires once per note, a trigger for the envelope downstream.

The mode knob sets the order the notes come out in, which is the whole expressive vocabulary of an arpeggiator:

• Up / Down — climb from lowest note to highest, or fall from highest to lowest.
• Inclusive / Exclusive — up-then-down patterns; the difference is whether the top and bottom notes repeat at the turnaround. Inclusive plays the endpoints twice (…C E G G E C…), exclusive plays them once (…C E G E C…), which subtly changes the rhythmic feel of the loop.
• Order — play the notes in the order they arrive in the chord bundle (the voicing’s own order), not sorted by pitch.
• Outside In — alternate from the outer notes inward (lowest, highest, next-lowest, next-highest…).
• Random — pick a chord note at random each step.

Octave extends the pattern across multiple octaves before it loops (a one-octave arp vs. a sweeping two- or three-octave run), and Latch holds the current set of notes so the arp keeps cycling even after the incoming gate releases — useful when the chord source is gated rather than continuous.

The clock relationship — the real lesson. All the timing comes from CLKD (Impromptu’s Clocked), a master clock whose outputs each run at their own ratio of the BPM. Two different ratios do two different jobs:

• A division (slow — e.g. every 4th or 8th beat) clocks RANDOM, so the chord only changes occasionally. That same slow division also hits the ARP’s Reset, so every time a new chord arrives the arpeggio restarts cleanly from the top instead of drifting out of phase with the harmony.
• A multiplication (fast — several pulses per beat) clocks the ARP’s steps, so it races through the chord’s notes many times over while that one chord is held.

That ratio between the two clocks is the arpeggio: the chord is a slow-moving harmonic frame, and the arp scribbles up and down inside it at high speed, resetting to the top each time the frame changes. Clock division and multiplication were introduced as a way to build polyrhythm; here the same tool sets the relationship between harmonic rhythm (how often the chord changes) and note rhythm (how fast the arp moves).

Stage 3 — sound it. The arp’s Out v/oct drives a SINE VCO (Surge XT). The arp’s Out Gate triggers the VC ADSR (Befaco), whose envelope opens an amplitude shape on each note. That envelope controls the level of the STEREO STRIP, which the VCO’s tone passes through, and on into VCA MIX and out to AUDIO. One note in, one envelope per step, one voice out — so the polyphonic chord ends up as a single monophonic line that implies the chord by spelling it out in time.

The Feedback knob — harmonics on a dial. The SINE VCO’s Feedback control is the one timbre knob on this voice. A pure sine is only the fundamental — no harmonics, a round, hollow tone — and at zero feedback that’s exactly what sounds. Turning Feedback up routes the oscillator’s output back into its own phase, which folds harmonics into the waveform: the tone brightens and fills out, picking up overtones until the round sine reads as buzzy and reedy, and at the far end it tips into gritty, near-distorted territory. Turning it back down strips those harmonics away again, returning toward the clean sine. So one knob sweeps the voice from pure tone to harmonically rich — adding or removing overtones — without swapping the oscillator or patching a filter, which is how this single-VCO arpeggio gets its brightness dialed in by ear.

Right now it’s a working arpeggiator on autopilot: a randomly-wandering diatonic chord, unrolled into a looping run. The places to push from here are the arp’s mode (how the run moves), its octave range (how far it sweeps), and the clock ratio (how busy it feels against the chord changes).

A bigger arpeggiator: NoteSeq16 → Super Arpeggiator

To go deeper I swapped the chord source and the arpeggiator for two more capable modules. In place of DiatonicCV I put NoteSeq16 (JW-Modules), a 16×16 grid sequencer — the x-axis is 16 time steps, the y-axis is pitch — so instead of a knob picking a chord I draw the notes by hand. And in place of the ARP I put the SUPER ARPEGGIATOR (Count Modula), a programmable arpeggiator with its own pattern grid rather than a single mode knob.

Drawing chords instead of generating them. To feed the arp a chord, I light up several cells in the same column of NoteSeq16 — same time step, different pitch rows — and that column comes out as a polyphonic chord on the V/OCT and GATE outputs, the same kind of poly cable DiatonicCV produced, except now the voicing is whatever I stacked on the grid.

An arpeggiator holds notes; a sequencer hands them out one at a time. The whole struggle of this leg taught me the defining trait of an arpeggiator: it plays the notes whose gates are high at this instant. The STATUS row (lights 1–16) shows how many notes it’s currently holding — not how many are in the sequence, but how many are sounding right now. That’s why DiatonicCV fed it so easily: a generated chord is sustained, every gate high all the time, so the arp always has the full set to work with. NoteSeq16 is a sequencer — it only holds a step’s gates high while the playhead is on that step — so the arp sees notes arriving and leaving as the sequence moves, rather than a stable chord. To get a held chord I have to either stack a column and dwell on it, or use the arp’s HOLD to latch notes as they pass.

The mistake that taught the most. For a long stretch STATUS stubbornly showed 1 even with a column stacked and the gate patched. The cause was a NoteSeq16 setting I’d missed: Polyphonic outputs (the checkbox) and Polyphonic channels (the count) are two different things. The checkbox says “emit a poly cable”; the channel count sets how wide that cable is. With the count left at 1, every stacked chord got squeezed down to a single channel before it ever left the module — so the arp received one note no matter how many I drew. Setting the channel count to match the chord size was the fix, and STATUS jumped to the full count. The lesson: a poly cable is only as wide as both the content and the channel-count setting allow — having notes stacked isn’t enough if the output is throttled to one channel.

Building a polyphonic gate

NoteSeq16 fed the arp cleanly once its channel count matched the chord — and the gate it sent did quiet but essential work: it told the arp how many notes there were. Swap in a chord source without a gate and that hidden requirement surfaces. Patch DiatonicCV’s chord straight into the Super Arpeggiator and only one STATUS light comes on — the arp plays a single note no matter how big the chord is. A gate-based arpeggiator reads how many notes are held from the polyphony of its gate input, not its V/OCT, and DiatonicCV puts the whole chord out as a poly V/OCT but offers no gate at all. So even with every pitch present on the V/OCT, nothing announces “five notes are held,” and the arp falls back to one voice. The pitches alone aren’t enough — the arp needs a gate as wide as the chord to know how many notes to step through.

So the fix is to fabricate a polyphonic gate of the right width and feed it in alongside the V/OCT. Two ways to build one from a single mono signal (a gate, or just the clock):

Bogaudio POLYMULT. Feed a mono signal into IN, set the channel count on CHAN, and its poly output carries that one signal copied across that many channels. Point the clock in and set CHAN to the chord’s note count, and out comes an N-channel poly gate — every channel high together — which reads to the arp as N notes held.

VCV MERGE. Merge stacks up to sixteen mono inputs into one poly cable, one input per channel. Patch copies of the mono gate into the first few MONO IN jacks and set CHAN to match, and the POLY output is a gate that many channels wide. A polyphony visualizer on either confirms the count — the lit channels are exactly the notes the arp will see.

Dropping a POLYMULT between DiatonicCV and the arp does exactly that: the chord’s poly V/OCT goes to the arp’s V/OCT as before, and the multed poly gate goes to its GATE, so STATUS finally lights every note and the arp sequences through the whole chord. A gate-less chord source now drives the gate-based arp the same way NoteSeq16’s built-in poly gate did. The principle underneath both arpeggiators: polyphony is carried by the gate, and the V/OCT just supplies the pitches to fill it.

Programming the pattern

With a chord reliably held at the input — however its gate is supplied — the Super Arpeggiator’s real power is what it does with those notes. Where the first ARP had a single direction knob, this one runs a programmable pattern through the held set: instead of one behavior for the whole run, I compose what happens on each step. This is where the module earns “super.” The held chord (STATUS shows five notes here) is the pool of pitches, and the three grids decide what the arp does on each individual step of its pattern — each row of a grid is one step, each column a choice.

PROGRAMME — direction per step. The columns are movement types (forward to the next held note, reverse to the previous, jump/reset, hold, and so on), and I pick one per step. So step 1 can step forward through the chord, step 2 reverse, step 3 jump back to the start — the path through the five notes zig-zags according to what I drew rather than marching straight up or down. This is the difference between an arpeggiator that has one contour and one that has a composed contour.

OCTAVE — register per step. Columns are -1 / +0 / +1. Setting a step to +1 throws that note up an octave, -1 drops it down. A run that would sit in one register suddenly leaps — the high note in the middle of the pattern, the low note as a punctuation — which is exactly the “set a step to a high octave” move. It’s how an arpeggio stops sounding like a scale exercise and starts having shape.

MODIFY — articulation per step. Two columns, glide and accent, that change how a step plays rather than which note. Flag a step for glide and the pitch slides into it from the previous note instead of jumping — the GLIDE knob sets how long that slide takes, so a little is a gentle lean and a lot is a full portamento swoop. Flag a step for accent and the arp fires its ACCENT output high on that step — but only if I patch that output somewhere does it do anything. Sent to the envelope or the VCA’s level it makes the step louder; here I patched it to the sine VCO’s Feedback instead, so the accented steps (1, 3 and 5) get a jump in feedback — a burst of extra harmonics on those notes. It’s a timbral accent rather than a loudness one: steps 1, 3 and 5 sound brighter and reedier than the rest, an emphasis you hear as tone-colour. Between glide and accent the pattern gets phrasing and dynamics — some steps slurred, some brightened — instead of every note arriving identical.

LENGTH sets the loop. Here it’s five steps, so the programmed pattern cycles every five — and because that’s a different number from the chord’s note count and from the clock divisions feeding the rest of the patch, the arp’s pattern and the harmony drift against each other instead of locking into a one-bar loop, the same long-cycle idea as mismatched clock divisions.

The result is an arpeggiator I sequence the behavior of: the chord supplies the notes, and PROGRAMME, OCTAVE and MODIFY choreograph how those notes get visited, octave by octave and step by step.

Arpeggios from an LFO

The last idea turns the whole thing inside out: an arpeggio’s defining motion — pitch climbing and falling in steps — can come straight from an LFO, with no arpeggiator and no chord at all. An LFO’s triangle output rises and falls in a steady ramp; read as a pitch (1V per octave) that’s a glide up and back down. Three modules turn that glide into a stepped, in-key arpeggio.

VCA as an attenuator — setting the octave range. Running the LFO through a VCA and turning its gain down scales the voltage — and because pitch is 1V per octave, scaling the voltage directly scales how many octaves the sweep spans. At full range the triangle might cover four or five octaves; attenuated, the same shape covers one or two. The VCA is the “how far does the run reach” control.

QNT quantizer — snapping to a scale. The attenuated ramp is still continuous, so on its own it would glide between pitches. A quantizer snaps it to the nearest note of a chosen scale, turning the smooth slope into a staircase of scale degrees climbing and descending — the notes of the arpeggio.

S&H to lock it to the clock. Even quantized, the pitch would change whenever the ramp happens to cross a note boundary, drifting against the beat. Feeding the signal through a sample & hold — here the RANDOM module’s S&H, triggered by the clock — freezes one value per clock pulse, so the notes step on the beat rather than wherever the LFO crosses a threshold. The same clock that runs the rest of the patch fires the S&H, so the run locks to the shared grid.

The shape of the LFO is the shape of the arpeggio. A triangle climbs then descends — an up-and-down run. A saw ramps the pitch gradually up and then drops straight back to the bottom — a climbing arpeggio that resets each cycle. The two knobs of variation are the LFO frequency — how fast the sweep moves through the range, which sets how many notes land per cycle against the clock — and the quantizer’s selected notes, which set the scale the run walks.

It’s a different philosophy from the arpeggiator modules. Those take a chord and reorder its exact notes; this builds the arpeggio’s contour out of a moving voltage and lets the quantizer pick the notes. No chord is held anywhere — the arpeggio is an emergent shape, the LFO’s slope made musical.