How would you remake this arpeggiator-powered song, with complex timing & tonality, in VCV?

I wanted to discuss this for a while, but it was hard to do it without it looking like stealth promo for something unrelated to VCV. Since I’ve been around for a while, I think it’s time to talk about this.

Last summer, a few weeks before I started getting into VCV, I made with Reason a song I was really happy with.
My project at the time was to make a series of theme songs, in very disparate styles, for internet friends (without their creative input - only their opt-in consent). I used it as an opportunity to experiment with a variety of ideas and processes.
One of the most popular songs for this project was written in a very modular way: as a series of arpeggiator rules, with various pattern durations and intensities, using a variety of scales.

Let’s listen to the results first:

It resulted into a song with unstable tonality and no clear time signature, yet an easily followed melody with clear variations of intensity. It’s a bit hard to explain, and I know I won’t explain it well, but hopefully still well enough to understand the big idea.

The entire song is driven by a single MIDI track:

The lowest octave picks the scale from 8 options. The second octave selects the pattern (the length of the note block matches the length of the pattern). The third octave selects the intensity. The fourth octave unmutes instruments to play. The notes above C2 are used as the root of the chord that is passed to the arpeggiators powering the song.

Most instruments receive the notes to play from one of those 32 patterns:

There are 4 * 8 patterns in total on 4 Kompulsion devices (only 2 depicted in the screencap above), each with a different melody, operating on abstract chord degrees rather than on known pitches. Each pattern is given 3 notes of a chord to use, and it can play them in octaves. The pattern variations are:

  • 4 Intensities - 1 Kompulsion device per
    • Low intensity (few notes)
    • Normal intensity (more notes)
    • High intensity (very busy)
    • Fills (bridges and segues)
  • 8 durations (in 16th notes) - 1 Kompulsion pattern per
    • 5
    • 9
    • 14
    • 16
    • 22
    • 24
    • 26
    • 28

Some instruments, such as the bass or drums, also had their own built-in patterns, and sometimes used other sequencing devices.

The chords used are provided by my chords dispenser & scale selector - an elaborate piece of Reason patching. I wrote in greater detail about the Reason-related parts in the Reason forums, but it will make no sense if you don’t use Reason. Or even if you use it. I barely understand why it works, honestly. The quick version: it generates chords that work in a variety of related exotic scales rooted in C, and sounds just dissonant enough to my tastes.

The actual songwriting process was not very deliberate. As it’s difficult to remember what every keyswitch does, and how 32 different song patterns sound like, I had to just try out things, hear if they work, and change the intensity, scale, or note if they don’t, then arrange the bits as to make it resemble a song.

I’m happy with the process, and very happy with the resulting song (and the subject of the song was also happy with her theme song). But ultimately, Reason remains a normal DAW with modular aspects: it’s difficult to take the idea further, or to play this song live.
One sequenced performance was frozen in time, and most of the patterns I wrote never made it into the song.

With a better method of control than a sequencer, I am certain it could be performed live - and maybe even conducted live by an untrained performer, conducting the performance at the macro level, allowing you to turn the piece into a participatory art kinda thing, like a player piano you can control at a manageable level of granularity.

My question is, how would you remake this song in VCV, but it’s a difficult question: it would be more useful to pick an individual part of the problem, and discuss how you would implement it. Here’s a non-exhaustive lists of problems we can think about - and each question definitely has more than one good answer:

  • How to generate interesting scales & chords to use in such a workflow? How to require less music theory knowledge from the performer to keep the dissonance under control, without constraining them into a very safe set of chords?
  • How to sequence operations on chord degrees/scale degrees rather than known pitches, arpeggiator-style? How to preview them easily when many variations are possible?
  • How to create a simple system to select a pattern from multiple categories of variations (intensity, duration)? How to dispatch them to various voices?
  • How to sync up sequencers when patterns can have varying note lengths?
  • How to queue up patterns? How to queue up more than one pattern in advance?
  • How to easily conduct this, with a mouse or MIDI controller? How to make it manageable when playing very short patterns?
  • Do any techniques, not directly relevant to this process but still similar, come to mind?

Paid VCV modules are not off-limits, but please keep answers constrained to a VCV Rack + generic MIDI controller setup: avoid third party software that can’t be kept all in the box.

If the discussion generates any interest and people post their ideas, I’ll follow up with some of my own, but for now I’d like to hear how you would patch parts of it, and learn about the capabilities of modules I had not explored in sufficient depth. And don’t hesitate to post techniques you already saw me use in a video - documenting them might benefit others reading the thread.
I hope this thread makes sense at all! Please don’t feel you have to understand how it works in detail to reply, it’s hard to explain and I’m explaining it poorly, using weird off-label patching tricks in software you probably don’t use.

A lot of the focus of my slowly growing module collection is to allow exploring these kinds of processes - and make them work live. QQQQ in particular is a building block for future modules in my system. Hopefully the discussion will also help me think about the next pieces for my module collection.


I am also quite interested in many of the topics presented, and there’s a lot to discuss here (so I’m excited to read what ideas come up).

I will present the first concept that comes to mind on the general topic, though, which is Markov chains. There are at least two in the VCV library I’ve seen that seem to employ Markov methods (Mr Chainkov and another one I of course cannot recall the name of right now). Here’s a blog post about the concept:

1 Like

Hello! I’m new around here (I’ll introduce myself properly on the forum later) and a few days ago I started experimenting with vcv. I love everything that can be done with it. It is difficult for me to express myself here since I do not speak English and my knowledge is limited.

How to queue up patterns? How to queue up more than one pattern in advance?

Something similar to the multiplexer would be good for this, in the example that I leave I use it to introduce random notes on the left side and I take them out on the right side at a slightly higher speed so that there is some repetition. If you could do the same with patterns (Information about note height and time) it would be great. Sorry for not expressing myself better, I leave you the vcv file.


I’m hoping to write a kind of Hidden Markov Model sequencer at some point, unless someone beats me to it. One thing missing from a standard HMM (at least without using a lot of states) is the ability to constrain the state sequence in ways that would be nice if using it for music, which is part of what I would like to try to do. For VCV, I think making the interface for HMMs both intuitive and flexible is a major challenge. Another thing that is tricky, which relates a bit to what Aria is asking, is how to combine the interaction of choosing both notes and note durations in an HMM.

I had a master’s student a few years ago do a project on musical HMMs that might be interesting in this context:


While I personally make heavy use of it in other works and it’s an interesting topic, I want to stress that this specific example makes no use of randomization whatsoever - it’s already difficult enough to think about as it is while being fully deterministic!


I just want to say that Keffie is cool and this recording is a worthy tribute

1 Like

Ah OK - although maybe there are overlaps in the interface. For a live performance, maybe it would be good if certain choices had default probabilities that could be manually over-ridden on the fly. I am thinking of something like this:

(My apologies to RCM for highjacking the piano roll.). The crude square buttons would force a particular choice in the next sequence, the dials above could give fallback probabilities if nothing is chosen live. Ideally for each current sequence the next sequence could be of variable length (not sure how that would work, it would need some per-sequence indicator of the sequence end).

1 Like

If the performance should continue to evolve unattended, I think it’d be just as important to provide motion to the patterns, their intensity variation, and the underlying chord progressions, but limiting the frequency at which multiple elements change simultaneously. Which seems a bit tricky to automate (unless we cheat and whip out Prototype, haha).

Progressions would be particularly amenable to a heuristic route approach, like hooktheory does:

1 Like

Just a part, but my 4x4 sequencer lets you queue sequences up in advance. Seq++ gives it a traditional midi piano roll. The xform operations do a lot of scale relative goodness, with limited arpeggiation.

Unfortunately, it would need to be able to do automate them - given the pace of the song you’d be clicking the menus every two seconds. It’s sequencing the member of an unknown changing sequence rather than known pitches with predictable transpositions rules.

1 Like