These are commands i.e. operations to perform on a loop.
[cmd] insert

It inserts new input in place, but always one "cycle" length... QuantizeMode and RoundMode have effects similar to Multiply.

Special Endings
  • Ending with a RECORD press it ends the operation immediately and resets the cycle length to the whole loop.
[cmd] multiply

This similar to overdub, except the original loop is repeated underneath you "multiplying" the loop length until you stop it. Thus it can turn a 1 measure loop into a 2,3, etc measure loop. QuantizeMode and RoundMode affect how the overdubbing starts and stops. QuantizeMode affects when the operation begins, and RoundMode affects if the new audio continues to be added throughthe end of the current cycle after hitting the final record.

Keep in mind that the original loop length is a "cycle" and the loop length will be a multiple of that. You can actually make an already multiplied loop have fewer cycles when using Multiply on loops that have already been multiplied.

Special Endings
  • If you end a MULTIPLY with a RECORD press it ends the loop immediately and resets the cycle length to the whole loop.
  • The MultiIncrease function is implemented which allows you to increment the cycle count ahead of time, without needing to wait until the exact time to finish the multiply. Basically, press Multiply as if you were finishing it, then before the current cycle plays out, press Multiply again repeatedly to add cycles. The multiply will resume and automatically go into playback after the specified number of cycles.
[cmd] mute

Press to mute loop output, press again to un-mute. Dry passthough audio will be unaffected. To continue playing the loop from the top press "[cmd]trig". To play back the loop once and return to mute, press "[cmd] oneshot".

[cmd] mute_off

Press to un-mute loop output.

[cmd] mute_on

Press to mute loop output.

[cmd] mute_trigger

Press to mute. Press again to un-mute and start the loop from the top (like "[cmd] trigger").

[cmd] oneshot

(called "once" on GUI and in the GUI Command Reference) this immediately restarts the loop playing back from the beginning, and goes into MUTE mode at the end of the loop.

[cmd] overdub

This keeps playing the loop and adds whatever you play on top until you stop overdubbing. Very useful.... this is the main tool. The Feedback controls the amount of the original loop that is used every pass. In actuality, when Feedback is set to 100%, it uses a slightly less amount to help prevent clipping on output.

[cmd] pause

Press to pause loop playback, press again to un-pause. Dry passthough audio will be unaffected. To continue playing the loop from the top press "[cmd] trigger". To play back the loop once and return to mute, press "[cmd] oneshot".

[cmd] pause_off

Un-pause the loop playback.

[cmd] pause_on

Pause the loop playback.

[cmd] record

Start here. If the record threshold is all the way down, pressing it once will start recording and pressing again will end the recording.

If the Threshold is set higher the loop recording doesn't start until the audio data is greater than the threshold. When finishing the loop, the threshold value is ignored. See the tips in the EDP manual, it works best if you stop and start recording the moment you hit the downbeat, not before. Trust them.

Special Endings
  • If you end a RECORD with another function (OVERDUB, MULTIPLY, REPLACE, SUBSTITUTE, INSERT, ONCE) it will finish the loop immediately (threshold ignored) and start doing the new function.
  • Ending with REVERSE stops recording and plays the loop backwards once then goes into MUTE mode.
[cmd] record_exclusive

Records one loop exclusively at a time (loop number should be set to something other than all). When you start record on one loop it stop recording on all others.

[cmd] record_exclusive_next

Same as record_exclusive but selects the next loop before starting to record (affected loop will always be the one selected no matter what loop number it is set to). Pressing it while recording will stop recording, switch to the next loop and start recording.

[cmd] record_exclusive_prev

Same as record_exclusive_next but selects the previous loop instead.

[cmd] record_or_overdub

Record if nothing has been recorded, otherwise it overdubs.

[cmd] record_or_overdub_excl

Same as record_exclusive except it records if nothing has been recorded, otherwise it overdubs.

[cmd] record_or_overdub_excl_next

Same as record_exclusive_next except it records if nothing has been recorded on loop it selects , otherwise it overdubs.

[cmd] record_or_overdub_excl_prev

Same as record_exclusive_prev except it records if nothing has been recorded on loop it selects , otherwise it overdubs.

[cmd] record_or_overdub_solo

Same as record_or_overdub but sets the loop to solo too.

[cmd] record_or_overdub_solo_next

Same as record_or_overdub_solo but selects the next loop before beginning recording or overdub. Pressing it a second time will stop recording or overdubbing, select the next loop, set it to solo and begin recording or overdubbing.

[cmd] record_or_overdub_solo_prev

Same as record_or_overdub_solo_next but selects the previous loop instead.

[cmd] record_or_overdub_solo_trig

Same as record_or_overdub_solo but re-triggers loop if it was muted.

[cmd] record_overdub_end_solo

Like record_or_overdub_solo but goes straight out of record into overdub on the second press.

[cmd] record_overdub_end_solo_trig

Same as record_overdub_end_solo but re-triggers the loop if it was muted.

[cmd] record_solo

Like record but solos the loop. Effectively mutes everything while you are recording.

[cmd] record_solo_next

Like record_solo but switches to the next loop before recording. Pressing it while recording will stop recording, switch to next loop, mute all other loops and then start recording.

[cmd] record_solo_prev

Like record_solo_next but switches to the previous loop instead.

[cmd] redo

Redoes the previous undo if it can (if you haven't done a new operation since your last undo). Taken together UNDO and REDO allow you to do some neat things: record a verse part, then hit record to do a chorus part. To get back to the verse, press UNDO... to get to the chorus press REDO.

[cmd] redo_all

Redoes as many undos as possible. Doing something else after an undo will make it impossible to redo it.

[cmd] replace

Replaces the audio in the loop for the duration of the command. The existing loop audio is not heard during the operation.

When Quantize mode is set, this operation will be quantized on start and finish with the current sync and quantize parameters.

[cmd] reset_sync_pos

Resets the sync position, the place where trigger will start playing when invoked, to 0.

[cmd] reverse

Reverses playback direction. Can be used in play mode, and even during an OVERDUB, which makes for some pretty interesting stuff. Can also be used in DELAY mode. If Quantize is on, the reversal doesn't happen until the next sync boundary, thus keeping the loop in time.

[cmd] scratch

("SCRATCH MODE" in the GUI Command Reference) By default the Scratch Rate Active is toggled off which means it ignores the Scratch Rate parameter. Changes in the Scratch Position parameter over time define the rate of playback (position unit is ratio of current loop length). The implementation is still pretty rough sounding.

I've personally used a theremin (the PAIA Theremax) with CV output through my MIDI pedal, although the scratching code needs some work.

[cmd] set_sync_pos

Sets, the sync position to the current position. The sync position is where the loop will start to play from when trigger is pressed.

[cmd] solo

Pressing SOLO will mute all other looper instances. Pressing it again will revert to the previous state before solo was pressed (eg, loops that were muted before the first press will stay muted). Pressing solo for a different loop will cause that loop to be the new soloed loop, only one loop may be soloed currently.

[cmd] solo_next

Select the next loop and solo it

[cmd] solo_prev

Select the previous loop and solo it

[cmd] substitute

Is like Replace except you still hear the current underlying loop audio as it records new audio into the loop. On the next time around, only the newly recorded audio will be heard. This helps maintain the groove when recording a replacement section, because you can play with what was there.

When Quantize mode is set, this operation will be quantized on start and finish.

[cmd] trigger

this immediately restarts the loop playing back from the beginning.

[cmd] undo

Restores the playing loop to the state before the last operation. It maintains the current time position if the current loop was based on the previous loop (eg, not newly recorded). You can go all the way back to the first one still intact within the loop memory. As more operations are done, more of the available loop memory is used, and it will eventually start reclaiming the oldest versions.

Note that to undo all existing state, do a long-press of Undo.

Pressing Undo when an operation is waiting for sync or quantization will cancel the pending operation.

[cmd] undo_all

Undoes everything restoring the loop to an empty state.


These are controls i.e. parameters, set per loop.
[ctrl] autoset_latency

This toggles the option for automatically disabling latency compensation when the input monitor i.e. "dry" control is not -infinity.

[ctrl] delay_trigger

("Delay" on the GUI "DELAY MODE" in the GUI Command Reference) Pressing the Delay control triggers Delay Mode. The time between the most recent two presses is the new delay time. While in DELAY mode, you can toggle Hold Mode (by pressing Replace), or Reverse at any time for a cool effect. To get out of delay mode press any other function or UNDO. You will probably want to adjust Feedback down from 1 before you enter delay mode or you'll build up a nice cacophony fast.

[ctrl] dry

("in mon" and "main in mon" (if set to global) on GUI and in GUI Command Reference) Sets the level of any incoming audio for passthrough monitoring to the common outputs.

[ctrl] fade_samples

("xfade" on GUI and in the GUI Command Reference) The xfade control sets the length in samples that is used to crossfade the audio on loop operations. Useful to prevent unwanted clicks caused by waveform discontinuities. However, if you want them set this value to 0. The control in the GUI affects all loops.

[ctrl] feedback

Controls the percent feedback that is recorded back to the loop on overdub.

[ctrl] input_gain

The input gain control sets a gain attenuation of the incoming main input audio. This affect the input into the loops only, not the main passthrough monitoring.

[ctrl] input_latency

Controls the amount of input latency.

[ctrl] jack_timebase_master

Toggles whether SL is the jack timebase master.

[ctrl] mute_quantized

Toggles if mute operations are quantized.

[ctrl] output_latency

Controls output latency.

[ctrl] overdub_quantized

Toggles if overdub operations are quantized.

[ctrl] pan_1

Controls the pan of Channel 1.

[ctrl] pan_2

Controls the pan of Channel 2.

[ctrl] pan_3

Controls the pan of Channel 3.

[ctrl] pan_4

Controls the pan of Channel 4.

[ctrl] pitch_shift

Sets the pitch shift amount.

[ctrl] playback_sync

Toggles whether playback is synced i.e. quantized.

[ctrl] quantize

Toggles if any quantize operations apply to this loop.

[ctrl] rate

("Rate Adjustement" in GUI Command Reference) The rate can be adjusted anytime (even during Recording) and will affect both the underlying loop and any new incoming audio recorded onto the loop, reminiscent of tape delay systems. Altering the Rate during recording/overdubbing, etc can result in interesting recorded audio. The GUI has buttons for easy access to 1/2 speed, double speed, and normal (1x) speed. MIDI bindings can be created to act like these buttons by specifying the range min and max to equal the target rate.

[ctrl] rec_thresh

Set's the recording threshold for this loop.

[ctrl] redo_is_tap

Toggles whether the redo command is also the tap timer for the delay function.

[ctrl] relative_sync

Toggles releative sync. See the sync documentation.

[ctrl] replace_quantized

Toggles whether replace operation quantized for this loop.

[ctrl] round

Toggles round mode. When round is on it keeps recording you input until the next quantize boundary after you finish the operation.

[ctrl] round_integer_tempo

Toggles whether the tempo is rounded to integer values.

[ctrl] scratch_pos

Controls the position of the scratch operation.

[ctrl] stretch_ratio

Controls the ratio of the stretch operation.

[ctrl] sync

Toggles whether this loop's sync to any of the quantize options.

[ctrl] tempo_stretch

Controls the stretch amount.

[ctrl] trigger_latency

Sets the latency for trigger operations.

[ctrl] use_common_ins

Toggles whether this loop connects to the common inputs.

[ctrl] use_common_outs

Toggles whether this loop connects to the common outputs.

[ctrl] use_feedback_play

[ctrl] use_rate

[ctrl] use_safety_feedback

Toggles whether this loop's feedback will be 100% when set to 100% rather than just below (which prevents clipping).

[ctrl] wet

("main out" on the GUI and the GUI Command Reference) The main wet control sets master level of all loop audio being sent out the main output ports. It does not affect the passthrough level from the main inputs, use the main in mon control for that.


These are global controls.
[g.ctrl] auto_disable_latency

Toggle whether latency compensation auto disables if the main in mon is higher than -infinity.

[g.ctrl] eighth_per_cycle

Controls the number of eighths per cycle.

[g.ctrl] output_midi_clock

Toggle whether to output a midi clock.

[g.ctrl] save_loop

Save the loop to a WAV file.

[g.ctrl] select_all_loops

Select all the loops in the session.

[g.ctrl] select_next_loop

Select the loop after the currently selected one. When it reaches the last it loops back to the first.

[g.ctrl] select_prev_loop

Select the loop previous to the one currently selected. When it reaches the first loop it goes to the last loop.

[g.ctrl] selected_loop_num

Select a specific loop number. The target range field specifies the the loop number starting from 0 for the first loop. If you set both target range fields to a specific loop number then that number will always be selected when the command triggers.

[g.ctrl] send_midi_start_on_trigger

Toggle whether a midi start message is sent on trigger.

[g.ctrl] smart_eighths

Toggle whether SL figures out the number of eights in a loop.

[g.ctrl] sync_source

Select the sync source for tempo. -3 = internal, -2 = midi, -1 = jack, 0 = none, # > 0 = loop number (1 indexed)

[g.ctrl] tap_tempo

Tap tempo to control the tempo.

[g.ctrl] tempo

Set the tempo.

[g.ctrl] use_midi_start

Toggle whether SL listens to midi start messages.

[g.ctrl] use_midi_stop

Toggle whether SL listens to midi stop messages.