An Arpeggio Sequencer Proposal

Ideas & suggestions
1

Please start at post #8

This first post is a BAD IDEA, lol

This started over here.

But any further talk (if there is any), should happen here. You can read its less lucid beginnings over there if you’re curious, heh.

Let me try to paint a picture:

Imagine you play a chord on your keyboard.

Now imagine that every note in that chord is mapped to a column in the phrase. Not playing in the column, just “assigned” to it, like a parameter. The note even lights up at the top of the column.

Now imagine that the phrase contains a bunch of C-4’s, scattered about the columns.

Now imagine that when you hit that chord, the phrase begins playing, and whenever it encounters one of those C-4’s, it plays the note that’s been assigned to that column – the corresponding note in your chord.

Now imagine moving one finger to another note, leaving the rest of your fingers where they are. It changes the emotional tone of the chord.

Now imagine that the columns automatically update themselves to reflect this new chord. The old note is unassigned and the new note is assigned in its place, displayed at the top of the column.

The phrase keeps playing on loop. But now, when it encounters a C-4 in the new note’s column, it plays the new note instead of the old.

The phrase generally only retriggers after a complete cessation, when you lift all you fingers.

You play chord after chord, sometimes overlapping, sometimes not (retriggering), and that boring scattering of C-4’s in your phrase is generating unbearably beautiful, rhythmically pulsating music from your chord progression. You feel tingly.

That’s the essence of the idea.

Now understand that those C-4’s, currently serving as dumb triggers for the underlying notes in your chords, don’t have to be C-4’s. They could be anything. And their offset from C-4 will transpose the underlying note.

Now imagine that this phrase can be as simple or as complicated as you like. It can have transposed notes and unmodified notes; short notes and long notes; loud notes and quiet notes; a different LPB than the song; phrase effects, sample effects, etc.

And it’s all perfectly musical, because it’s all based on the chords you’re currently playing, and interacting polyrhythmically with the beat.

MIDI-flow-wise, this could live after the Phrase Editor, as a separate, toggleable Arp Editor. Or it could live in the Phrase Editor as an Arp Mode. But they’ll look more or less identical.

danoise is probably right that something like the former is better :slight_smile:

2

I should add that if this were to live after the Phrase Editor (and before the instrument), you could use the phrase editor as a chord generator, which would then be Arped on by the Arp Editor, much the same way Cthulhu is routed (a chord generator into an Arp Sequencer).

Then, in the Pattern Editor, a single note would trigger a chord through the Phrase Editor, which would subsequently be fed through the Arp.

Combining different Phrases and different Arp patterns will generate endlessly various and consistently musical results.

3

I should also add that IMO the Phrase Editor and the Arp Editor would be so similar that they could share keystrokes, in case anyone was worried about key bindings for a whole third separate pattern-style editor.

Like a Phrase/Arp Editor key binding scope.

4

One bad limitation of this proposal is that you can only reliably generate one note at a time from a specific note index in a chord.

Say the root note of the your chord is assigned to the first column. You want to play the root, and the root an octave and a fifth up.

You put C-4 in the first column to trigger the root note, but how do you generate the second second? You can’t know in advance what any of the other notes are.

Given enough columns, the chord will eventually wrap around. So if there are three held notes, the fourth column will have the root +1 octave assigned to it. So you can access a version of the root from there.

But you can’t know in advance how many notes there will be in the chord, so you don’t know which column it wraps at.

This, I think, is probably a fatal flaw.

5

So… Scratch the original idea.

I think a better solution would be something like a new Chord Index command. Say, 0Kxx, for (“Kord”… best I could do), where xx is the index of a note in a held chord.

The actual note column on notes affected by this command would become transposition, relative to C-4 (or some root).

That’s the whole arpeggiator right there, right inside the Phrase Editor.

It’s way simpler than the original idea, way more compact, is backwards compatible with all current phrases, solves the problem in the above post, doesn’t require any new Phrase Editor modes or the addition of an Arp Editor, probably lots more stuff.

Internally, instruments would just have to keep a sorted list of all active notes. Which they might already do, who knows? The devs, I guess.

6

Wait… am I tripping or could we have the most powerful arpeggiator on the planet with the addition of a single command?

7

Thinking this through in public is a bad idea.

It would require a Phrase Mode or an Arp Editor or something.

In the Pattern Editor, every note is a whole phrase, so it’d be cacophony.

8

But I do think an Active Note Index column or command for a separate Arp Editor is a sound idea.

The Arp Editor:

  • Would be almost identical, visually, to the Phrase Editor
  • Would live after the Phrase editor (and before the instrument).
  • Would have two modes: Off, and Program (it can be turned off and on)
  • Its Program Mode is similar to the Phrase Editor’s Program mode (you’d select phrases with commands)
  • But incoming notes are just normal notes, rather than each one triggering a new phrase.
  • The Arp would maintain a realtime sorted list of all active notes
  • A command, or the Active Note Index column, would specify the index of active note you want to trigger
  • And the actual note column would transpose the note specified above, relative to C-4 (or some root).

I think this works …

9

From skimming the topic, I think that you’re looking for two things:

  • a chord generator (pointing to Cthulhu as an example)
  • an arpeggiator

As I see it, these are essentially two separate features which complement each other nicely.

But I hear someone saying “chord generator, but wait - what about phrases!”. True, this is basically what phrases are. Switch on harmonic scale for a phrase, and the notes will fit in real-time fit to the selected scale. Automate scale using MIDI CCs, transpose using notes, switch with program change and Zxx…sounds like we have the whole featureset nailed down? Yes, but it could still be improved.

As useful as phrases might be, using them for chord is not without limitations. The problem is that notes are entered as-is, and not by interval. This is good enough for single-note phrases (or octaves), but not actual chords. Because when you define chords using exact notes and then transpose them, you are effectively “shoe-horning” into a scale - sometimes with slightly unexpected results.

But imagine that phrases were extended to allow intervals? Then you could program a phrase like this:

1-3 1-4 3-4 4-4

First number is the interval, second is the octave.
So these four “notes” would translate into something meaningful, no matter what scale was selected.

Of course, some scales contain more keys than others - so any intervals outside the range would simply be skipped on output.

Makes me wonder how natural it would feel to remap the QWERTY to produce numbers instead of letters?!

qwerty-intervals.png?raw=1

The layout could be made to follow the active scale (if any).
Example: pentatonic minor f#

qwerty-intervals-penta_f_sharp.png?raw=1

10

From skimming the topic, I think that you’re looking for two things:

  • a chord generator (pointing to Cthulhu as an example)
  • an arpeggiator

As I see it, these are essentially two separate features which complement each other nicely.

Thanks for your input danoise!

I completely agree that Chord Generator and Arp are complementary features.

If an Arp Editor ever happens, I definitely think it should sit after the Phrase Editor (and before the instrument), so we can use the Phrase Editor as a chord generator, as you mention, to be arped upon by the Arp Editor.

However, in this thread, I’m not looking at the “chord generator”, or really the phrase editor at all. (I personally don’t mind hard-coding chords in the Pattern Editor, I… distrust… filters that force the input to fit a scale, heh :slight_smile: ).

I’m brainstorming purely about this hypothetical arp that will sit after the phrase editor, and how it could work in its most powerful incarnation.

When I say “Chord Index” (a misleading term), what I mean is an index for the Arp Editor to reach inside the chord you’re playing (AKA the sorted list of active notes the Arp has received), to access the nth note.

In the Arp Editor, instead of an instrument column (as in the Pattern Editor), or a Sample Column (as in the Phrase Editor), there would be an “Active Note Index” Column.

Active Note Index

Say you have this in the Arp Editor:

|----+-------|
| 00 | C-400|
|----+-------|

Here, the “00” (In C-400),refers to the lowest note of the chord being held (“Active Note 00”).

And the “C-4” in the note column becomes the transposition, relative to C-4 (or some root). So C-4 in this case would leave Active Note 00 (the lowest note in your chord) untransposed.

Here:

|----+-------|
| 00 |D-401|
|----+-------|

“01” refers to the second lowest note (“Active Note 01”). And D-4 would transpose whatever Active Note 01 happens to be up two semitones (again, relative to C-4 or some other root).

The Active Note Index Column is the “necessary abstraction” or “sequencing by pointer” thing I was talking about in the other thread.

It’s a way for the Arp Editor to have realtime access to the chord being played – i.e. the sorted list of active notes the Arp has received.

This simple building block would single-handedly give Renoise (in my not uninformed opinion), the most powerful Arp on the planet.

It would allow you to build complicated Arp phrases with the full power of the Renoise Phrase Editor;

Phrases that generate realtime output from the chords being played, whether those chords come from your hands, or the Pattern Editor or the Phrase editor.

An extremely simple Arp Editor phrase might look something like this:

|----+-------|
| 00 | C-400 | <- Loop start
| 01 | C-401 |
| 02 | C-402 |
|----+-------| <- Loop end

This would loop monophonically over the lowest three notes in any chord you play (an extremely common arp pattern).

I am absolutely certain that any powerful arp sequencer needs a way to address the nth active note.

11

As another example, say you wanted to generate two notes from one note in the chord you’re holding:

|----+-------+-------|
| 00 | C-400 | G-500 |
|----+-------+-------|

This would play the lowest note in your chord, and that same low note transposed up an octave and a fifth.

C-400 means the first note in your chord (00), untransposed (C4 - C4 = 0).

G-500 means the first note in your chord (00), transposed up 19 semitones (G5 - C4 = 19).

Even something this simple is impossible in most arps.

“Arpeggiator” is a loaded term that recalls a lot of limited old stuff.

Modern arps are more like “meta sequencers” – the “meta” being the mapping of active notes to rows, bottom up, in the step sequencer. Triggers in those rows trigger the assigned note.

Renoise could do everything these can do, and so much more, with an “Active Note Index” column (or command).

12

Here’s a slightly more complicated example:

|----+-------+-------+-------|
| 00 | C-400 | G-500 | C-600 |
| 01 | ---.. | ---.. | C-601 |
| 02 | ---.. | ---.. | C-602 |
| 03 | ---.. | ---.. | C-600 | <- Loop start
| 04 | ---.. | ---.. | C-601 |
| 05 | ---.. | ---.. | C-602 |
|----+-------+-------+-------| <- Loop end

C-400 plays and holds the 1st note in the chord, untransposed.

G-500 plays and holds the 1st note in the chord (again), transposed 19 semitones up.

All while looping monophonically over the 1st, 2nd and 3rd notes in your chord, each transposed up 2 octaves (C-600, C-601 andC-602).

I’m pretty sure this is impossible in any existing Arp [1].

And yet look at it sitting there. It’d be a cinch to lay out in Renoise.

[1] If it is possible in some current arp, it would be simple to write an arp pattern that’s definitely not.

Edit: I should add that the “list of active notes” maintained by the Arp is always current, and always sorted (probably by lowest to highest pitch). So if the finger holding the note at index 02 moves to a different key, the list is immediately updated and sorted, and the next time a C-602 (or C-402, or whatever) is encountered in the phrase, the new note plays instead of the old.

13

The reason I distrust “conform to scale” filters, is that many of the “chords” you hold when fiddling with one of these VSTi arps, aren’t real chords at all, and might not conform to any scale.

The notes held are merely a “palette” of notes you happen to like, and the arp sequencer plucks notes from this palette according to its current pattern.

TBH, I don’t think it would be incorrect to say that in DAWs with “musical intelligence” features built-in, those features are rarely used.

People mostly just choose the notes they want, and the Arp sequencer should be able to operate on those notes, whether they conform to music theory or not.

14

***** Let me also state again for the record that my first post in this thread is a BAD IDEA, and is no longer what I’m talking about, hahaha! *****

The present working concept started in post #8.

15

And to assuage the devs’ fears a bit (if they’re still actually reading this, or care :slight_smile: ), I want to reiterate that this Arp Editor is barely different from the Phrase Editor.

It exists after the Phrase Editor, because it makes the most sense to put it there (a phrase/chord generator feeding an arp).

But it’s really an offshoot of the Phrase Editor.

They’d look alike, share keybinding scopes, have Program modes.

The Arp Editor is like a second instance of the Phrase Editor, existing downstream, that operates differently on notes.