This plugin can arpeggiate chords by changing the notes' on-times, similar to how the arpeggio element does it, except in a lot more customizable way.

The motivation for this plugin was that the only way MuseScore (as of version 3.5) can arpeggiate chords is by leaving the first-played note on an on-time of 0, while the last-played note is played later. This is undesirable in a lot of cases as it's common to have the last-played note be on an on-time of 0. The usual workaround is manually adjusting the note on-times in the Piano Roll Editor, which gets very painful very fast. This plugin does exactly that automatically and a little more.

For a similar plugin for grace notes, see and

Preliminary notes

This is a dock-type plugin, the plugin will be docked on the left side of the main interface. It's possible that you won't see anything because the default size is kind of unpredictable (or I just haven't figured out how to change it), so you may need to resize it.

The plugin was tested in MuseScore 3.6.2 only.


The plugin can arpeggiate chords (whose notes are in the same voice), whether a MuseScore arpeggio element is applied to the chord or not.
There are two ways the plugin can arpeggiate: by stretch units or by custom duration units.

  • stretch units correspond to the meaning of the Stretch property on a usual arpeggio element. 1 stretch unit represents a constant amount of physical time. It is around the duration of 2/15ths of a beat at 120 bpm. Stretch units are therefore independent of the tempo; an arpeggio created with 1 stretch unit should play the same whatever the tempo was at the time of creation(†).
  • duration units are note values, whose duration evidently depends on the current tempo. A quarter note at 80 bpm has a longer physical duration than a quarter note at 120 bpm. As an example, an arpeggio created with 1/32 = 0.03125 duration units will have the notes separated by 32nd-note-duration. Therefore, such an arpeggio created(†) at different tempos will sound differently.

Plugin options

  1. Arp. units (arpeggiation units): stretch units or duration units, depending on which button you click later
  2. Direction: whether it's an up or down arpeggio (with the usual meaning)
  3. Index of zero: the index of the note which should land on-time (that is, have an on-time of 0). This is usually the top-most note in an up arpeggio and the bottom-most note in a down-arpeggio, so these are the notes an index of 0 refers to. A negative index indexes from the other end of the note list. An out-of-range index is clamped to be in range.
  4. Offset: the final offset applied to all note on-times, as a multiplier of arp. units. Can be negative.
  5. Keep original offtimes: whether the notes of the chord should keep their original offtimes, or have their offtime modified to be what the Offtime property below says.
  6. Offtime: the offtime all notes of the chord should get. Unused if Keep original offtimes is off.


  1. Make a selection in the score that contains at least one note
  2. Modify the options (this and the previous step can be done in any order)
  3. Press the Arpeggiate by stretch units or Arpeggiate by duration units button

Usually the default options are good enough for most use cases. I expect the most commonly changed option will be the arpeggiation units.

The arpeggiation options will be applied to each chord separately in the selection. A chord is considered to be in the selection if at least on of its notes is selected. Nothing happens if no chord is selected.

Planned features

  • Enter a duration unit as a fraction, the current way is imprecise and painful
  • Include selecting an arpeggio element as a way of selecting a chord (and maybe autofill the arp. units option with its Stretch property)
  • Option profiles for quick switching between different sets of options
  • Arpeggiating by a fixed physical time duration
  • Detecting tempo changes and updating plugin-arpeggiated chords where needed

Known issues

  • † Notice that I mention in both cases the time of creation of the arpeggio. Arpeggios are still a finicky subject, even with this plugin, because certain annoying details of arpeggios are hard to overcome. Creating an arpeggio at one tempo, and later changing the tempo to something else, leaves the on-times of the notes unchanged. This means the arpeggio will either speed up or slow down. This is probably not a problem if an arpeggio was created with duration units, as that is the intention behind this option. However, with stretch units, the intention is that the arpeggio should sound the same regardless of tempo, which will not be the case after a change of tempo. A MuseScore arpeggio element automatically takes care of updating the on-times of the notes when the tempo is changed, however this plugin cannot detect tempo changes and update the affected arpeggios. A chord with an attached arpeggio element which was then also arpeggiated with the plugin also won't get updated in the future.
  • Arpeggiating a chord at the very beginning of the score (tick 0) is pretty much impossible as notes can't start before tick 0. The workaround is leaving the initial measure empty.
  • If the index of zero or offset is not 0, arpeggiating by stretch units at a tempo change boundary will have the the chord's notes before and after the tempo change play at a different speed.

Related threads

Issue Tracker

API compatibility
Plugin categories
Batch processing
Notes & Rests
Attachment Size
arpeggiator.qml 17.36 KB