Portable sequence standard (proposal)

Hi @Vortico and fellow developpers,

Richie Hindle (@Richie), Bruce Frazer (@Squinky.Labs) and I have been working on a proposal for allowing the copy/pasting of sequences between sequencers from different “vendors” in VCV Rack. The initial aim is to be able to transport musical content consisting of notes with pitches, gates, probability, etc. from one sequencer (Seq++ for example) to another sequencer (Foundry for example).

Since not all sequencers support all features and time resolutions of notes, this is not expected to be always be a perfect process, but instead should be seen as getting the core musical content from one module to another, even when the modules are from different developers. Between two timeline-type modules, the copy/paste can even potentially be perfect, and it’s up to each module to interpret the Portable sequence format according to its intrinsic architecture.

We are also planning to open a github issue for discussing the proposal, and we will add a link to it when it’s ready. Here is a link to the current draft of the proposal, and any feedback or comments you might have would be greatly appreciated.

As of this writing, the following open source sequencers support the initial draft of the Portable sequence, and can be compiled for those wanting to give it an early try:

  • SquinkyLabs (master branch): Seq++
  • Impromptu Modular (master branch): Foundry, PhraseSeq16/32, SemiModularSynth

Richie is working on something that should be ready within a week or so from now.

Happy sequencing!


This cannot be an official standard because no proposal can cover all use cases, but of course any developer is welcome to make/use any proposal.

1 Like

Indeed, it’s a tough thing to declare since all sequencers have their peculiarities, and some could say that it’s kind of an impossible thing to “solve”, but having a format that is quite general for some minimal common interoperability might be something cool to experiment with. This is what is so cool of the Rack ecosystem, the freedom to try things and see how they work out, so I guess we’ll see how it develops.


For those that will be building Squinky Seq++ (master branch) and Impromptu (master branch) to try this out, the commands in Seq++ for the Portable sequence are Ctrl-A -> Ctrl-C for copying or just Ctrl-V for pasting. In Impromptu, the commands are located in the module’s menu. At all times, since the content is in the clipboard after copy, you can check the contents by pasting the clipboard into any notepad-like app.


We merged the clipboard interop work to our master branch, so just do a git pull and build from the SquinklyVCV repo. As always, cut/copy/paste defaults to ctrl x/c/v. But now we use the interop clipboard format instead of our own proprietary kluge.

1 Like

I’ve opened a GitHub issue for the suggestion, at https://github.com/VCVRack/Rack/issues/1708

If it can’t become an official VCV standard then fair enough, but an unofficial standard supported by the vendors of popular sequencers will still help users.



1 Like

interesting! would it open the door to low HP and cpu sequencer that would be some kind of reciever for pasted content?

That would definitely be possible, and it’s an interesting idea. Use Foundry or Seq++ or other to make the sequences, then paste them into a smaller sequence “player” that would have a minimal UI. Many possibilities! :slight_smile:

1 Like

idea 1: 128 step container

  • 2HP
  • reset input
  • play input
  • gate out
  • seq out
  • a led to show if the container is full or not
  • paste sequence by right click

idea2: song sequencer a 8 or 16 step sequencer, where each value of step is actually a pasted sequence: you start by pasting up to 8 sequences in the container, and then your classic 8 knobs select one of the loaded sequence instead of a V value :slight_smile:


Interesting ideas! For idea 1, it would need a clock input also, but the compactness would definitely be pretty cool! We’d have to check with Antonio on how to make 2 HP modules though, since that’s quite narrow! :stuck_out_tongue: Idea 2 is definitely cool also. I have copy-pasted the ideas into my Impromptu notebook! I even have a non-imaginative name for these sequencers: Paste-Seq-128 and Paste-Seq-8x16 :smile:

1 Like

For what it’s worth, I just implemented Portable sequence copy/paste in BigButtonSeq2, so it’s 6 channels of 128-step sequences in a relatively small package. It will be available in the next update.


I added a list of modules that support portable sequence standard at the bottom of the spec document.


Two new Impromptu modules support this standard, and they aren’t even sequencers. They are ChordKey and FourView. Very pleased to see modules out there showing that anything with some pitches in it can make use of the format.


Indeed! With ChordKey it introduces an interesting dilema: when we do a Copy in ChordKey, should it

A) copy into a 4-step sequence (effectively apeggiating the chord), or

B) copy it as a true chord where all notes at at the same time point

Option A is needed so that the notes can go into conventional step sequences like PhraseSeqs etc, but option B is much more natural for timeline sequencers like Seq++ and Entrian sequencers. I think I might just offer two types of copy operations, to offer both A and B types outlined above. This problem does not happen when pasting into ChordKey, since it just takes the first four notes it sees, regardless of their start times. (@VCVRackIdeas)

Already suggested for your issue tracker to have both of them available for choosing.) It may destroy portable sequence standart but wouldn’t destroy a chord or can transform it to a sequence which is also pretty cool thing to have.

1 Like

There is now support for Portable Sequences in Darius - soon to be added to the library. It’s a rather unusual sequencer, so its implementation is unusual too: upon copying, it copies only one of all the possible random sequences it can generate.


I took a look how they were implemented in Squinky Labs’ and Impromptu’s modules, and since their code was strongly coupled to their way of doing thing, I wrote my own lightweight portable sequence code. It’s not battle-tested at all yet, and does not cover all the corner cases (favoring cleaning up bad input instead), but it’s short and simple to understand, so it might save time for someone who wishes to implement them.


Hi Aria, welcome to the Portable Sequence club :slight_smile: I never took the time to say this, but congrats for all you modules and the cool and original concepts you devlopped! :+1: :grinning:


Very nice. Thank you. Definitely see the value in your implementation code.

1 Like

My next device is a quantizer that doubles as a chord sequencer, and once again I plan to use portable sequences in a slightly off-label way. Thoughts on my planned implementation?

Right-click on a Scene slot: “Copy scene”/“Paste Scene”. It’s copied to a portable sequence of global length 1.0, every valid note of the scale a note of length 1.0 on the C4 (pitch = 0.0) octave. The fact it’s a portable sequence rather than an internal format is not made explicit by the UI, only the docs.

Click on the keyboard button (ignore the paste button, both buttons will be merged in a single button the final version): “Copy portable sequence” / “Paste portable sequence” (among other options, such as entering chords in lead sheet and roman numeral notation).

On exporting: Global length as long as the last non-empty scenes, so up to 16. Every scale/chord same as above: length 1.0, C4 octave.

On importing: Ignore the global length. Every event with the same start time is grouped, up to 16 groups are imported to scene slots, quantized to the chromatic scale and folded to a single octave.