Power Up Your MIDI Arpeggiators

Using only the tools built into your DAW, you can turn your arpeggiations into complex, engaging sequences.

MIDI reached its 40th birthday earlier this year, and while there have been developments recently in the form of MIDI 2.0, the underlying technology of the original spec remains a vital part of what glues our modern music‑making systems together. As a self‑confessed music technology geek, I always keep at least one eye on the latest and greatest new products and every year brings along useful tools and exciting toys, but I’m also well aware of just how much good stuff we already have at our disposal... and something I think people often overlook is the power lurking in the MIDI plug‑ins that can be found tucked away in our favourite DAWs. Perhaps it’s because our computers are now so powerful and adept at processing audio, or maybe it’s because our virtual instruments have become so feature‑laden. Whatever the reason, MIDI plug‑ins are well worth exploring!

In this article, I’m going to run through a number of examples that demonstrate just how useful and creative they can be. I’m going to focus on how you can make the most of your MIDI arpeggiator plug‑ins, whether used on their own or in combination with other MIDI plug‑ins.

You can use the arpeggiators built into your synths, of course, but a dedicated MIDI arp plug‑in offers a couple of potential advantages.

Most DAWs include a pretty capable stock arpeggiator. For example, I use Cubase and Logic, which include the Arpache SX and Arpeggiator plug‑ins, respectively. There’s also one in Reaper’s JS plug‑in collection and one amongst Studio One’s Note FX. There are also various third‑party arp plug‑ins too — if your DAW lacks a capable stock one, see the separate box for more about those. “But,” I hear you cry, “I already have arpeggiators in my soft synths!” You can use the arpeggiators built into your synths, of course, but a dedicated MIDI arp plug‑in offers a couple of potential advantages.

• First, it can open up more creative options because you can use it to achieve good results with any virtual instrument, whether it has an arpeggiator built in or not. It could extend the appeal of the simple synth plug‑in you downloaded yesterday, for instance, or allow you to trigger multiple layered instruments from the same arp.
• Second, familiarity with a single arpeggiator means you don’t need to learn or remember the intricacies of different arps, so it should save you time.

In this article, I’ll be using Logic’s Arpeggiator and Cubase’s Arpache SX to illustrate what’s possible. But you should be able to apply the principles using whatever arp plug‑in or DAW you have access to. The initial steps required to use an arpeggiator plug‑in in Logic and Cubase are similar but it may be slightly different in some DAWs; if in doubt, check your DAW’s manual. I’ll focus my examples on real‑time use (where you play in notes using a MIDI keyboard and the arpeggiator transforms that input to ‘drive’ a virtual instrument) and I’ll include scenarios where other MIDI plug‑ins can help you do more with your arpeggiator. Finally, words can only convey so much — so you can hear the kinds of results I’m discussing, I’ve put a few audio examples on the SOS website: https://sosm.ag/midi-fx-1223

Arp Introductions

Start by adding a virtual instrument track to your project and selecting a suitable sound. If in doubt, a ‘plucked’ synth sound will make a good starting point. With this instrument in place, insert a MIDI plug‑in. In Logic, the MIDI insert slots are found between the audio EQ and insert effects slots, while in Cubase they’re in the Project window’s Inspector panel, between the Note Expression and MIDI Modifiers sections. Just click on an empty slot to select the desired plug‑in from a menu. If your DAW hosts MIDI plug‑ins in the same slots as audio ones (eg. Reaper) make sure that the arpeggiator is placed in a slot before the instrument.

The first two screenshots show an arpeggiator loaded in Logic and Cubase. In both cases, I’ve kept things simple, creating a basic upwards arpeggio that triggers a note on every 16th note: it will cycle through any MIDI notes you input (starting with the lowest) when you press down the keys, and then, as you hold it down, the arpeggiator triggers the next up the keyboard a 16th note later, and so on up the ‘chord’ (ie. whatever notes you’ve held down). After that, it returns to the lowest one and repeats the process until you stop holding the note. In my example, I’ve not included any doubling over a second or third octave but you’re welcome to experiment with that!

Screen 1: Logic’s Arpeggiator and MIDI insert slots.

I don’t want to get too bogged down in the more routine settings here, but some details are worth noting. First, the settings shown mean the two plug‑ins deliver identical results. Second, in Logic’s Arpeggiator (Screen 1) I set the Velocity response to 100 percent ‘As Played’, whereas in Cubase’s Arpache SX (Screen 2), I set it to ‘Via Input’. In both cases, this allows you to create some cool performance dynamics (and, depending on the sound you’re using, potentially change the tonal character) by varying how hard you play each note within a chord. Third, both plug‑ins offer a number of different preset arpeggio styles, as described below.

Screen 2: Cubase’s Arpache SX and MIDI insert slots. Note the activated Record Output To Track button within each slot, as discussed in the main text.

In Arpeggiator, the first four main buttons provide conventional choices but the last two, Random (crossed arrows) and As Played (hand icon) can often generate something more interesting. The former does what its name suggests; the arpeggiated pattern’s note order is randomised. For the latter, the order of notes is dictated by the order in which you trigger them — because MIDI’s a serial protocol, even if you think you’re hitting all the notes in your chord at the same time, the timing is fractionally different. The Variation slider offers further note‑order options (there’s a detailed description of these in Logic’s Effects User Guide PDF manual) that are well worth experimenting with.

With Arpache SX, the Direction control provides a whole list of arpeggio styles, and a Sort By control allows you to conjure alternative sequences of notes out of the arpeggiation process; this setting interacts with the Direction parameter in some interesting ways. In short, even used in this most basic of ways, both plug‑ins provide plenty of scope to vary the pitch sequences of the arpeggiated notes.

Auto‑chord Arps

Let’s combine another MIDI plug‑in with an arpeggiator, starting with a simple, practical example: transforming a single note into a full chord. Both Logic (Chord Trigger) and Cubase (Chorder) have dedicated MIDI plug‑ins for this task, and if you place them in a MIDI insert slot before the arpeggiator, you’ll be able to trigger even complex chord voicings, with notes spread over multiple octaves, with ease, and pass the result on to your arpeggiator.

Screen 3: Logic’s Chord Trigger provides a flexible system for triggering chords from single‑note inputs.

Logic’s Chord Trigger plug‑in (Screen 3) includes a Learn feature: you select a Trigger Note on the GUI’s upper keyboard, then specify the notes it will trigger on the lower keyboard. However, this plug‑in also has an extensive set of presets, and useful initial candidates can be found in the Multi (meaning more than one chord type) category. For example, the Songwriter Left (or Right) Hand preset provides all the major and minor chords of a single key, voiced as four‑note chords (one note is doubled). Consequently, the arpeggiator will generate a four‑note repeating pattern. There are triad (three‑note) options available too, and plenty more complex chords to explore.

Cubase’s Chorder (Screen 4) has similar core functionality. Again, the Learn button provides options to define your own trigger note/full chord configurations or you can edit the factory presets, which include both three‑ and four‑note chords. As a starting point, the Octave category provides full chord sets for every scale root note option. If you dig deeper into Chorder, you’ll find options to create multiple layers of chord voicings for a specific trigger note, with velocity control over layer selection when triggering. It may have a less stylish GUI than Chord Trigger, but there is plenty to explore under the hood!

Screen 4: Cubase’s Chorder also lets you play full chords from a single trigger note.

If you’ve followed and combined those first two stages, you should by now have an arp‑friendly synth patch that responds to MIDI velocity, one MIDI plug‑in providing a basic arpeggio pattern, and another MIDI plug‑in that can turn single notes into full chords to feed to the arpeggiator. So let’s now consider some of the more creative ‘extras’ you can add, to create more variety in the arpeggios.

Random Logic

There are a number of possible options, and one avenue to explore is applying random and/or probability‑based changes to the velocity, pitch and density of notes in the arpeggios. The possibilities are endless, but the couple of examples that follow should illustrate the potential.

With Logic’s Randomizer MIDI plug‑in, you can define the degree of randomisation applied to various MIDI note properties, and there are lots of ways you might exploit this. Screen 5 shows an example, using four different instances of the Randomizer plus one instance of the Transposer plug‑in, all placed after Arpeggiator in the MIDI signal chain.

Screen 5: Logic’s Randomizer lets you manipulate MIDI data in real time in all sorts of interesting ways. As shown here, you can chain multiple instances for all sorts of creative purposes.

The first Randomizer processes incoming MIDI note velocity data (the Input Range spans 0 to 127, which means all notes will be processed). Because the Random level is set to zero, the velocity is not randomised, but the Output Offset value is set to ‑127 and this means all velocities will have 127 subtracted from their value. So, in the absence of any other settings, the velocity of every note would be zero! Note, though, that I’ve popped open the extended parameters panel and set Seed to 20 and Probability to 10 percent. The latter means that only 10 percent of any incoming notes will be processed by the plug‑in (so, on average, the velocity of only one in 10 notes will be reduced to zero). The fixed Seed value (the default is Random) ensures the same ‘random’ probability sequence each time (also useful when rendering a project). Together, these settings remove 10 percent of notes from the arpeggio sequence. As an alternative, you could achieve the same effect with the Scripter MIDI plug‑in, which has a Probability Gate preset; I’ll come back to Scripter a little later.

The second Randomizer also processes note velocities, but this time applies a random change of up to 50, but ‘weighted’ towards lower values — the plug‑in is more likely to reduce the incoming velocity than raise it. With the probability value set to 50 percent, only half the notes are subjected to this random change. The combination of these settings (which I exaggerated here for the purposes of demonstration in the audio examples) results in the volume of notes changing constantly, and this can make a performance ‘breathe’ a little. (Note that Randomizer also has a Velocity Humanizer preset, with settings that produce a much more subtle version of the same effect.)

The third and fourth Randomizers apply changes to the MIDI note number (pitch), but in different ways. In the third instance, the pitch of 25 percent of the notes is randomly changed within a ±12‑semitone range, weighted towards the higher notes. In the fourth instance, there’s no random change but a +12‑semitone offset is applied to 25 percent of notes. Both these processes break up the pitch consistency of the arpeggio, adding variety to the note patterns. You can control just how much variety by adjusting the Random level in instance 3 and Probability level in both instances.

Of course, there is no guarantee that the new pitches coming from the third Randomizer instance will fall within the key of our project. So a final MIDI plug‑in in this chain is Transposer. This applies further pitch changes to incoming notes that ensure every note is forced into the selected root note/scale combination. There are plenty of scale presets (major, minor, pentatonic, various modes), so there’s scope to experiment if you want to give your chord‑based arpeggio pattern more of a melodic feel.

Combining these user‑defined randomisation options to the velocity and pitch of your basic arpeggio patterns can certainly add variety to the arpeggiated performance. But as a final step you can also add real‑time ‘direction’ to the processing, with some automation. For example, if you select the probability slider in the first instance of Randomizer and press Command+L, the Controller Assignments dialogue opens with the Learn option already active. Simply move your mod wheel and it will then be linked to the Probability slider for real‑time control. In this case, while playing your chords (triggered with one finger), you can move the mod wheel and essentially control the density of the notes allowed through this first instance of Randomizer. Alternatively, you can link the mod wheel to the Output Offset slider in the fourth instance, so it controls the offset value to ‘push’ the pitch up or down and create a sense of rise or fall in the overall pitch of the arpeggio/melody pattern.

Cubase Modifiers

In Cubase, you’d imagine that the MIDI Modifiers plug‑in would be a good candidate to process the output of Arpache SX in similar fashion. But while some of its features do work on a live MIDI input, the two ‘Random’ slots don’t. There’s a good reason — it allows you to randomise timings by moving notes earlier in time, not just later — but means MIDI Modifiers won’t do what we want here. For the kinds of pitch and velocity randomisation we’ve just performed in Logic, the Transformer MIDI plug‑in is very capable.

Screen 6: A single instance of Cubase’s Transformer allows you to apply multiple transformations to your MIDI data in real time.

It can look a little daunting, but that’s probably because Transformer lets you apply multiple processing stages in a single plug‑in. This is illustrated in Screen 6. In the upper panel, you set conditions to select the MIDI data that will be processed — I kept things very simple for demonstration purposes, selecting all incoming MIDI notes, but there are plenty more sophisticated options to explore. In the lower panel, I’ve tweaked three parameters. For MIDI notes, Value 1 is pitch, so the first entry applies randomisation to the note pitch within the range ‑2 to +3 semitones (relative to the incoming note). For MIDI notes, Value 2 is note velocity, so the second entry applies a degree of randomisation relative to the incoming velocity. The final entry acts on the note pitch (Value 1), adjusting the pitch further to fit the specified scale (there’s an extensive list of scale types to choose from); no duff notes!

Cubase’s Density MIDI plug‑in can be used to add probability‑based variation. Once inserted, if you adjust the slider below 100 percent this will randomly remove a proportion of the notes. It’s super‑simple to use, but two things are worth noting. First, you can set Density values over 100 percent — in principle, this generates additional notes by repeating some of those played earlier, but the results can be a bit unpredictable when used in real time rather than on playback of recorded MIDI. Second, the Density setting can be automated, for example via Cubase’s Quick Control system, so you could easily adjust this in real time while triggering your single‑finger chord/arpeggio performance.

Make A Record

Screen 7: From Logic 10.7.5 onwards, you can use the Record MIDI To Track Here option to capture the results of your MIDI plug‑ins in real time at any point in the signal chain, as indicated by the orange arrows.Exploring this combination of one‑finger triggers of chord‑based arpeggios and randomisation possibilities can be a lot of fun and, as you improvise through a sequence of chords, eventually, something cool should grab your ear. To ensure that you capture such moments for posterity, it’s a good idea to simply record your musical musings as they happen. This can be achieved easily in any version of Logic, but with v10.7.5 or later, you can simply right‑click on the arrows at the right of the final MIDI plug‑in in your signal chain to open the MIDI Plug‑ins pop‑up menu (Screen 7). From here, select the Record MIDI To Track Here option. When you then activate record in your Project, and play some MIDI notes to generate a performance, the complete set of MIDI notes generated by your MIDI plug‑in processing chain gets recorded to the track rather than just your trigger notes.

In Cubase, recording the output from your chain of MIDI plug‑ins is also relatively straightforward. Each plug‑in slot has a Record Output To Track button, and these can be activated from top to bottom through the strip of insert slots. In this case, with our sequence of Chorder, Arpache SX, Transformer and Density, activate all these buttons. Then, when you enable recording, you can ‘perform’ using your single‑finger note triggers, but record the full chord arpeggio performance, with all the randomisation included, as a MIDI clip on your virtual instrument track.

Once done, you can listen back and find the bits you like — and delete those you don’t. Of course, you can also fine‑tune the captured performance with the full suite of MIDI editing tools provided by your DAW of choice.

Stick To The Script?

What I’ve described above just hints at what can be achieved with MIDI effects plug‑ins. There’s plenty more to explore even if you stick with the plug‑ins I’ve used here, but that’s just the tip of the iceberg in terms of what MIDI plug‑ins and/or processing make possible. So if you’ve been inspired to dig a little deeper, where do you take it from here? Well, you could start by checking out everything your DAW has to offer, of course. But lots of DAWs also offer some sort of ‘scripting’ facility, which allows you to take things much further.

If you use Logic, the first candidate for your experiments should be the Scripter MIDI plug‑in. This opens up all sorts of interesting possibilities for manipulating MIDI data and, again, comes with useful presets that you can simply load and use. These include things like the Drum Probability Sequencer, Stutter, and Guitar Strummer. Under the hood, Scripter is essentially a tool for creating your own MIDI processing tools, and includes a Script Editor window. Yes, there’s a learning curve if you’re to get the most from this one, but there are also a lot of places you can go online to find user‑created examples and tutorials.

Cubase’s Transformer MIDI plug‑in, which I used in a fairly simple example earlier, is also a sort of scripting platform. In fact, it’s a real‑time version of Cubase’s Logical Editor (the latter is intended for processing already recorded MIDI data offline and includes an extensive array of filter and command options that can be combined in almost endless ways). Again, Transformer ships with some very useful presets that can introduce you to what’s possible but, as with Scripter, there’s a learning curve to travel before you can fully exploit its potential. However, it’s worth me noting here that if you just want to add more instances of Transformer and have run out of MIDI plug‑in insert slots, you can also utilise the Input Transformer. This is available to every MIDI‑based track in Cubase, and effectively provides up to four instances of Transformer that can be stacked in sequence to process your MIDI data in real time. It’s easily accessed from the Inspector Panel and can be set to operate at the Track or Project level.

As I hope the above examples demonstrate, while MIDI can sometimes seem a little opaque — things don’t always seem to do what you think they ought to be doing — it continues to be an amazingly sophisticated and powerful protocol that presents all sorts of technical, practical and creative ways to support your music‑making efforts — not least when you start to combine MIDI processing with your arpeggiators. So happy birthday, MIDI: here’s to the next 40 years!