# Bespoke Synth Reference

## overview video

Here is a video detailing basic usage of Bespoke, including a bunch of less-obvious shortcuts and workflow features.

There are some things in this video that are slightly out of date (I should make a new video!), but there is still plenty of useful information in there.

## basics

Navigation * space bar + move mouse to pan, or right-click drag in empty space * space bar + mousewheel/trackpad-scroll to zoom, or scroll in empty space * if you get lost, press ~ to bring up the console, type "home", and press enter to reset to the initial position and zoom * if you have enabled the minimap in the settings, you can click on the minimap to directly go to a location -at the bottom of the mimimap you can click on 9 bookmark buttons -hold shift while clicking will store your current location into that bookmark button -use shift+[num] to go to the specified bookmark Creating Modules * drag items out of the top bar menus OR * right-click and select from the popup menu OR * right-click and start typing the name of the module you want, then drag it out of the popup menu OR * hold the first letter of a module and drag them out of the popup menu OR * drag a cable into space and spawn a connecting module from the popup * to delete a module, lasso select + backspace OR use the triangle menu and choose "delete module" * to duplicate a module, hold alt/option and drag from the title bar Patching * drag the circle from the bottom of a module to the target OR click the circle then click the target to patch * drag a cable and press backspace to unpatch * hold shift while grabbing a patch cable circle to split * hold shift while releasing a patch cable on a target to insert * while holding shift, drag a module by the title bar and touch its circle to another module, or the mouse pointer to another module's circle, to quick patch UI Controls * click or drag a slider to adjust its value * hold shift to fine-tune * while hovered: -use mousewheel/trackpad-scroll to adjust (shift to fine-tune) -type a value into a slider (such as 1.5) and press enter -type an expression into a slider (such as 1/16 or +=10) and press enter -press up or down to increase the value by 1 (hold shift for .01) -press [ or ] to halve or double the value -press \ to reset to the initial value * hold alt/option and drag to adjust slew amount (smoothing) * right click a slider to add an LFO -click and drag a green modulated slider vertically to adjust the modulation min, and horizontally to adjust the modulation max * hold ctrl/command and click the lower or upper half of a slider to adjust that slider's minimum or maximum value, to give it increased or reduced range (warning! increasing range can lead to unpredictable behavior in some cases) * press tab to cycle through controls on a module * press ctrl/command+arrows to navigate around controls on a module Saving * "write audio" button: write the last 30 minutes of audio to the /data/recordings folder, perfect for making sure you don't miss any cool moments * "save state" button: save the current layout to a file. shortcut: ctrl-s * "load state" button: load previously saved layouts. shortcut: ctrl-l Key Commands * ctrl/command-'s': save * ctrl/command-'l': load * shift-'p': pause audio processing. this will stop all audio output. press shift-'p' again to resume * F2: toggle displaying all ADSR controls as sliders

## instruments

circlesequencer polyrhythmic sequencer that displays a loop as a circle
length*: number of steps in this ring
note*: pitch to use for this ring
offset*: timing offset for this ring
drumsequencer step sequencer intended for drums. hold shift when dragging on the grid to adjust step velocity.
r lock*: lock this row so it doesn't get randomized
repeat: repeat input notes at this rate
offsets: show "offsets" sliders
column: current column, to use for visualizing the step on a midi controller
randomize: randomize the sequence
clear: clear sequence
measures: length of the sequence in measures
metastep: patch a grid in here from a "midicontroller" module to control the "meta step". I forget what this does. oops.
r den: density of the randomizer output. the higher this is, the busier the random output will be.
r amt: the chance that each step will change when being randomized. low values will only change a small amount of the sequence, high values will replace more of the sequence.
step: length of each step
grid: patch a grid in here from a "midicontroller" module
yoff: vertical offset for grid controller's view of the pattern
velocity: patch a grid in here from a "midicontroller" module to control the velocity
rowpitch*: output pitch for this row
vel: velocity to use when setting a step
random*: randomize this row
<: shift whole pattern one step earlier
offset*: shift row forward/backward in time. try making your snares a little early, your hats a little late, etc.
>: shift whole pattern one step later
accepts: pulses notes
fouronthefloor sends note 0 every beat, to trigger a kick drum
two: sends note only every two beats
gridkeyboard grid-based keyboard, intended primarily for 64-pad grid controllers
layout: keyboard style
p.root: for chorder, make root note always play
arrangement: what style of layout should we use?
grid: patch a grid in here from a "midicontroller" module
octave: base octave
latch: latch key presses, so you press once to play a note, and press again to release a note
ch.latch: latch chord button presses
keyboarddisplay displays input notes on a keyboard, and allows you to click the keyboard to create notes
accepts: notes
m185sequencer sequencer using the unique paradigm of the m185 or intellijel metropolis
gate*: behavior for each row: "repeat" plays every step, "once" plays just the first step, "hold" holds across all steps, "rest" plays no steps
pitch*: pitch to use for this row
interval: interval per step
pulses*: number of steps this row should last
reset step: resets counter to first step
accepts: pulses
midicontroller get midi input from external devices. to get a nice display in the "layout" view, create a .json file with the same name as your controller to describe your controller's layout, and place it in your "data/controllers" directory. look at the other files in that directory for examples.
control: pitch or control to refer to
feedback: which cc or note should we send the feedback to?
blink: when the targeted control is enabled, send alternating on/off messages, to blink the associated LED
controltype: how this control should modify the target. -slider: set the value interpolated between "midi off" and "midi on" to the slider's value -set: set the specified value directly when this button is pressed -release: set the specified value directly when this button is released -toggle: toggle the control's value to on/off when this button is pressed -direct: set the control to the literal midi input value
increment: when "controltype" is "set" or "release", the targeted control is incremented by this amount (and the "value" field is ignored). when "controltype" is "slider", the targeted control is changed by this amount in the direction the control was changed (this setting is useful for "infinite encoders")
scale: should the output of this midi slider be scaled between "midi off" and "midi on"?
layout: which layout file should we use for this controller? these can be created in your Documents/BespokeSynth/controllers folder.
messagetype: type of midi message
add: add a mapping manually
midi on: the upper end of the midi range. send this value when the targeted control is on. if "scale" is enabled, this also controls the upper end of the slider range, and you can set midi off to be higher than midi on to reverse a slider's direction.
osc input port: port to use for osccontroller input
channel: which channel to pay attention to
midi off: the lower end of the midi range. send this value when the targeted control is off. if "scale" is enabled, this also controls the lower end of the slider range, and you can set midi off to be higher than midi on to reverse a slider's direction.
pageless: should this connection work across all pages of the midicontroller?
path: path to the control that should be affected. you can also enter "hover" here, to affect whichever control the mouse is hovering over.
bind (hold shift): when this is enabled, you can map a midi input to a UI control by hovering over a UI control, holding shift, and then using desired midi input
copy: duplicate this connection
monome: which monome should we use?
mappingdisplay: which mapping view to see
x : delete this connection
controller: midi device to use
value: the value to set
twoway: should we send feedback to the controller? (to control the LEDs associated with the button/knob)
page: select which page of midi controls to use. each page acts like an independent midi controller, so you can use pages to allow one midi controller to switch between controlling many things
notecanvas looping note roll
scrollv: vertical scrollbar
canvas: canvas of notes. canvas controls: -shift-click to add a note -hold shift and drag a note to duplicate -hold alt to drag a note without snapping -hold ctrl while dragging to snap to an interval -hold shift and scroll to zoom -hold alt and grab empty space to move slide the canvas view -hold ctrl and grab empty space to zoom the canvas view
measures: loop length
drag mode: direction that elements can be dragged
view rows: number of visible rows
loadtrack: which track number to import when using "load midi"
timeline: control loop points
clear: delete all elements
interval: interval to quantize to
play: play notes on canvas
quantize: quantize selected notes to interval
save midi: export canvas contents to a midi file
load midi: import canvas contents from a midi file
rec: record input notes to canvas
show chord intervals: show brackets to indicate chord relationships
free rec: enable record mode, and extend canvas if we reach the end
scrollh: horizontal scrollbar
delete: delete highlighted elements
accepts: notes
notechain trigger a note, followed by a pulse to trigger another note after a delay
duration: duration of note, in measures
trigger: play note for this chain node
pitch: pitch to play
velocity: velocity for note
next: interval until sending pulse
accepts: pulses
notecounter advance through pitches sequentially. useful for driving the "notesequencer" or "drumsequencer" modules.
interval: rate to advance
random: output random pitches within the range, rather than sequential
sync: if the output pitch should be synchronized to the global transport
start: pitch at the start of the sequence
length: length of the sequence
div: measure division, when using "div" as the interval
accepts: pulses
notecreator create a one-off note
duration: note length when "trigger" button is used
on: turn on to start note, turn off to end note
trigger: press to trigger note for specified duration
velocity: note velocity
pitch: output note pitch
accepts: pulses
notelooper note loop recorder with overdubbing and replacement functionality
canvas: canvas of recorded notes
load*: restore pattern
clear: clear pattern
del/mute: if "write" is enabled, erase notes as the playhead passes over them. otherwise, just mute them.
write: should input should be recorded?
store*: save pattern
num bars: set loop length in measures
accepts: notes
notesequencer looping sequence of notes at an interval. pair with a "pulser" module for more interesting step control. hold "shift" to adjust step length.
len*: length for this column
random: randomize pitch, length, and velocity of all steps.
y offset: y offset of attached grid controller
pitch: randomize pitches in the sequence. hold shift to constrain the randomization to only pick roots and fifths.
rand vel density: when clicking the random velocity button, what are the chances that a step should have a note?
x offset: x offset of attached grid controller
rand pitch chance: when clicking the random pitch button, what is the chance that a step gets changed?
rand vel chance: when clicking the random velocity button, what is the chance that a step gets changed?
tone*: pitch for this column
rand len range: when clicking the random length button, how much will the length change?
rand len chance: when clicking the random length button, what is the chance that a step gets changed?
vel: randomize the velocity of each step's note.
<: shift the sequence to the left
>: shift the sequence to the right
vel*: velocity for this column
len: randomize the length of each step's note.
grid: patch a grid in here from a "midicontroller" module
loop reset: when sequence loops, reset to here instead. send a "downbeat"-style message from a pulser to restart the sequence from the first step.
octave: octave of the bottom pitch of this sequence
notemode: which set of pitches should the rows represent?
clear: clear all steps
interval: note length
rand pitch variety: how many different random pitches should we generate?
length: length that the sequence below should play. the overall grid length can be changed by adjusting "gridsteps" in the triangle menu.
accepts: pulses notes
notesinger output a note based on a detected pitch
oct: octave to adjust output pitch by
accepts: audio
playsequencer drum sequencer that allows you to punch in to record and overdub steps, inspired by the pulsar-23 drum machine
load*: load the sequence stored in this slot
link columns: if the mute/delete control should be shared across the entire column
interval: the step size
measures: the loop length
write: if the current input should be written to the sequence. this will also delete steps if mute/delete is enabled for this row
note repeat: if held notes should repeat every step
grid: patch a grid in here from a "midicontroller" module
mute/delete*: if write is disabled, mute this row. if write is enabled, clear the steps as the playhead passes them
store*: store the current sequence to this slot
accepts: notes
polyrhythms looping sequence with lines on different divisions
length*: number of steps for this line
note*: pitch to use for this line
randomnote play a note at a given interval with a random chance
probability: the chance that a note will play each interval
skip: after a note plays, don't play a note the next n-1 times that it would have played
interval: the note length
offset: the amount of time to offset playback within the interval
pitch: the pitch to use
velocity: the velocity to use
slidersequencer trigger notes along a continuous timeline
division: rate to progress
note*: pitch for this element
playing*: is this element playing?
vel*: velocity of this element
time*: time to trigger this element

## note effects

arpeggiator arpeggiates held notes. there are several vestigial features in this module that should be cleaned up.
step: direction and distance to step through arpeggiation. a value of zero is "pingpong".
interval: arpeggiation rate
octaves: how many octaves to step through
accepts: notes
capo shifts incoming notes by semitones
capo: number of semitones to shift
retrigger: immediately replay current notes when changing the capo amount
diatonic: should we keep transposed notes in the scale?
accepts: notes
chorddisplayer display which chord is playing, in the context of the current scale
accepts: notes
chorder takes an incoming pitch and plays additional notes to form chords
inversion: inversion presets
chord: chord presets
diatonic: should the grid be chromatic, or locked to the scale only?
accepts: notes
chordholder keeps any notes pressed at the same time sustaining, until new notes are pressed
pulse to play: when enabled, input notes aren't played immediately, but instead wait for an input pulse before playing
stop: stop notes from playing
accepts: pulses notes
gridnotedisplayer use with a gridkeyboard to display currently playing notes, to visualize chords, arpeggiation, etc.
accepts: notes
midicc outputs midi control change messages to route to a "midioutput" module
control: CC control number
value: outputs a CC value when this changes
accepts: notes
midioutput send midi to an external destination, such as hardware or other software
controller: where to send midi to
accepts: notes
modulationvizualizer display MPE modulation values for notes
accepts: notes
modwheel adds an expression value to a note
modwheel: expression level
accepts: notes
modwheeltopressure swaps expression input to midi pressure in the output
accepts: notes
modwheeltovibrato convert note mod wheel input rhythmic pitch bend
vibrato: amount of pitch bend
vibinterval: rate of vibrato
accepts: notes
mpesmoother smooth out MPE parameters
modwheel: amount to smooth incoming modwheel
pressure: amount to smooth incoming pressure
pitch: amount to smooth incoming pitchbend
accepts: notes
mpetweaker adjust incoming MPE modulation values
pressure mult: amount to multiply incoming pressure
modwheel offset: amount to offset incoming modwheel
pitchbend mult: amount to multiply incoming pitchbend
pitchbend offset: amount to offset incoming pitchbend
modwheel mult: amount to multiply incoming modwheel
pressure offset: amount to offset incoming pressure
accepts: notes
notechance randomly allow notes through
*: generate a new random seed
beat length: restart the deterministic random sequence at this interval
deterministic: allow for randomness to be repeated over an interval
chance: probability that a note is allowed
seed: number that determines the random sequence
<: go to next seed
accepts: notes
notedelayer delay input notes by a specified amount
delay: amount of time to delay, in measures
accepts: notes
notedisplayer show input note info
accepts: notes
noteduration sets the length a note will play, ignoring the note-off message
duration: length of the note in measures
accepts: notes
noteecho output incoming notes at specified delays
delay *: amount of time to delay this output, in measures
accepts: notes
noteexpression control where notes are routed based upon evaluated expressions. the variable "p" represents pitch, and "v" represents velocity
expression*: expression to evaluate for this cable. example expression to route notes with pitch greater than 80 and velocity less than 60: "p > 80 && v < 60"
accepts: notes
notefilter only allow a certain pitches through
accepts: notes
noteflusher send a note-off for all notes
flush: click to flush notes
accepts: notes
notegate allow or disallow notes to pass through
open: if notes are allowed to pass
accepts: notes
notehocket sends notes to random destinations
weight *: chance that note goes to this destination
*: generate a new random seed
seed: number that determines the random sequence
<: go to next seed
beat length: restart the deterministic random sequence at this interval
accepts: notes
notehumanizer add randomness to timing and velocity
velocity: amount of velocity randomness
time: amount of timing randomness, in milliseconds.
accepts: notes
notelatch use note on messages to toggle notes on and off
accepts: notes
noteoctaver transpose a note by octaves
retrigger: immediately replay current notes when changing the transpose amount
octave: number of octaves to raise or lower
accepts: notes
notepanalternator sets a note's pan, alternating between two values, for the internal synths that support panned notes
two: pan position, .5 is centered
one: pan position, .5 is centered
accepts: notes
notepanner sets a note's pan, for the internal synths that support panned notes
pan: pan position, .5 is centered
accepts: notes
notepanrandom sets a note's pan to random values, for the internal synths that support panned notes
spread: amount of randomness
center: center pan position
accepts: notes
noterangefilter only allows notes through within a certain pitch range
wrap: instead of rejecting notes outside of this range, should we wrap them to the range instead?
max: maximum pitch allowed
min: minimum pitch allowed
accepts: notes
noteratchet rapidly repeat an input note over a duration
duration: total length of time repeats should last
skip first: don't replay input note. this allows you to more easily separate the initial note from the ratcheted notes.
subdivision: length of each repeat
accepts: notes
noterouter allows you to control where notes are routed to using a UI control. to add destinations to the list, patch them as a target
route: the noterouter's destination module
accepts: notes
notesorter separate notes by pitch. any unmapped pitches go through the standard outlet.
pitch *: pitch to use for this outlet
accepts: notes
notestepper output notes through a round robin of patch cables, to create sequential variety
reset: reset to the start
length: length of the sequence
accepts: notes
notestream view a stream of notes as they're played
reset: reset the pitch range
accepts: notes
notestrummer send a chord into this, and move a slider to strum each note of the chord
strum: move the slider past each note to strum it
accepts: notes
notetable map a pitch (starting from zero) to a scale pitch
x offset: x offset of attached grid controller
rand pitch chance: when clicking the random pitch button, what is the chance that a step gets changed?
clear: clear grid
y offset: y offset of attached grid controller
tone*: pitch for this column
rand pitch range: when clicking the random pitch button, how far will the pitch change?
length: the number of pitches
grid: patch a grid in here from a "midicontroller" module
octave: octave of the bottom pitch of this sequence
random pitch: randomize pitches in the sequence. hold shift to constrain the randomization to only pick roots and fifths.
notemode: which set of pitches should the rows represent?
accepts: notes
notewrap wrap an input pitch to stay within a desired range
range: number of semitones before wrapping back down to min pitch
min: bottom of pitch range
accepts: notes
pitchbender add pitch bend to notes
bend: bend amount, in semitones
accepts: notes
pitchdive use pitchbend to settle into an input pitch from a starting offset
start: semitone offset to start from
time: time in milliseconds to ramp from pitch offset into input pitch
accepts: notes
pitchpanner add pan modulation to notes based upon input pitch, so low pitches are panned in one direction and high pitches are panned in another
right: pitch that represents full right pan
left: pitch that represents full left pan
accepts: notes
pitchremap remap input pitches to different output pitches
to*: desired pitch
from*: pitch to change
accepts: notes
pitchsetter set an incoming note to use a specified pitch
pitch: the pitch to use
accepts: notes
portamento only allows one note to play at a time, and uses pitch bend to glide between notes
mode: always: always glide to new notes retrigger held: bend to notes if the prior note is held, and retrigger bend held: bend to notes if the prior note is held, without retriggering
glide: time to glide, in milliseconds
accepts: notes
pressure add pressure modulation to notes
pressure: pressure amount
accepts: notes
pressuretomodwheel takes midi pressure modulation input and changes it to modwheel modulation
accepts: notes
pressuretovibrato takes midi pressure modulation input and changes it to vibrato, using pitch bend
vibrato: amount of vibrato
vibinterval: vibrato speed
accepts: notes
previousnote when receiving a note on, output the prior note on that we received
accepts: notes
quantizer delay inputs until the next quantization interval
quantize: the quantization interval
repeat: when holding a note, should we repeat it every interval?
accepts: pulses notes
scaledegree transpose input based on current scale
retrigger: immediately replay current notes when changing the transpose amount
diatonic: should we keep transposed notes in the scale?
degree: amount to transpose
accepts: notes
scaledetect detect which scales fit a collection of entered notes. the last played pitch is used as the root.
matches: matching scales for this root
reset: reset the input collection of notes
accepts: notes
sustainpedal keeps input notes sustaining
sustain: should we hold the input notes?
accepts: notes
transposefrom transpose input from a specified root to the root of the current scale. the primary usage of this would be to allow you to play a keyboard in C, but it gets transposed to the current scale.
root: root to transpose from
retrigger: immediately replay current notes when changing the transpose root or the scale
accepts: notes
unstablemodwheel mutate MPE slide with perlin noise
amount: amount of mutation
noise: fast-later mutation rate
warble: slow-layer mutation rate
accepts: notes
unstablepitch mutate MPE pitchbend with perlin noise
amount: amount of mutation
noise: fast-later mutation rate
warble: slow-layer mutation rate
accepts: notes
unstablepressure mutate MPE pressure with perlin noise
amount: amount of mutation
noise: fast-later mutation rate
warble: slow-layer mutation rate
accepts: notes
velocitycurve adjust velocity based upon a curve mapping
accepts: notes
velocityscaler scale a note's velocity to be higher or lower
scale: amount to multiply velocity by
accepts: notes
velocitysetter set a note's velocity to this value
rand: randomness to reduce output velocity by
vel: velocity to use
accepts: notes
velocitystepsequencer adjusts the velocity of incoming notes based upon a sequence
downbeat: should we reset the sequence every downbeat?
interval: speed to advance sequence
vel*: velocity for this step
len: length of sequence
accepts: notes
velocitytochance use a note's velocity to determine the chance that the note plays
*: generate a new random seed
seed: number that determines the random sequence
<: go to next seed
beat length: restart the deterministic random sequence at this interval
full velocity: set velocity to full for notes that pass through
accepts: notes
vibrato add rhythmic oscillating pitch bend to notes
vibrato: amount of pitch bend to add
vibinterval: speed of pitch bend oscillation
accepts: notes
volcabeatscontrol outputs MIDI data to control various aspects of the KORG volca beats drum machine
accepts: notes
whitekeys remap the white keys that correspond to the C major scale to instead play the current global scale
accepts: notes

## synths

beats multi-loop player, for mixing sample layers together
double*: enable this to play at double speed
delete *: remove the current sample from the list
filter*: layer filter. negative values bring in a low pass, positive values bring in a high pass.
selector*: which sample should we play in this slot? drag samples onto here to add them to this slot.
pan*: layer panorama
volume*: layer volume
bars*: how many measures long are the samples in this slot?
drumplayer sample player intended for drum playback
shuffle: random is samples, speeds, and pans
hitcategory*: folder to choose from, when clicking the "random" button. these folders are found in the data/drums/hits/ directory
speed rnd: global sample speed randomization amount
test *: play this sample
quantize: quantize input to this interval
start *: start offset percentage of sample
speed: global sample speed multiplier
envelopedisplay *D: envelope decay
aud: scroll to audition samples in the current pad's head category, or a directory last dropped onto a pad
envelopedisplay *A: envelope attack
vol *: volume of sample
vol: the output volume
view ms *: envelope view length in milliseconds
envelopedisplay *R: envelope release
envelopedisplay *S: envelope sustain
random *: choose a random sample from the selected hitcategory
repeat: if quantizing, should held notes repeat at that interval?
widen *: stereo delay of sample to create width
grab *: grab this sample
grid: patch a grid in here from a "midicontroller" module
next *: choose the next sample from the selected hitcategory
envelope *: should we apply a volume envelope to the sample?
linkid *: if linkid is not -1, silence any other sample with a matching linkid (useful for linking open and closed hats)
edit: show pads for editing
mono: force output to mono
pan *: stereo pan position of sample
speed *: speed of sample
single out *: should the sample have its own individual output?
prev *: choose the previous sample from the selected hitcategory
full vel: always play drum hits at full velocity
accepts: notes
drumsynth oscillator+noise drum synth
vol: the output volume
type*: oscillator type
cutoffmax*: filter start cutoff frequency
q*: filter resonance
freqmin*: oscillator end frequency
freqmax*: oscillator start frequency
oversampling: oversampling amount. increases sound quality, but also increases cpu usage.
vol*: oscillator volume
edit: display parameters for each hit
cutoffmin*: filter end cutoff frequency
noise*: noise volume
accepts: notes
fmsynth polyphonic fm synthesis
harmratio: harmonic ratio of first-order modulator to input pitch
vol: the output volume
tweak: multiplier to harmonic ratio for first-order modulator
tweak2: multiplier to harmonic ratio for second-order modulator
mod2: amount to modulate second-order modulator
mod: amount to modulate first-order modulator
harmratio2: harmonic ratio of second-order modulator to input pitch
phase1: phase offset for first-order modulator
phase0: phase offset for base oscillator
phase2: phase offset for second-order modulator
accepts: notes
karplusstrong polyphonic plucked string physical modeling synth
x freq: frequency of excitation audio
vel2vol: how much velocity should affect voice volume
feedback: amount of feedback for resonance
vol: output volume
invert: should the feedback invert?
x att: fade in time for excitation audio
filter: amount to filter resonance
pitchtone: adjust how pitch influences filter amount. a value of zero gives even filtering across the entire pitch range, higher values filter high pitches less, low values filter low pitches less.
x dec: fade out time for excitation audio
source type: audio to use for excitation
lite cpu: only recalculate some parameters once per buffer, to reduce CPU load. can make pitch bends and rapid modulation sound worse in some scenarios.
vel2env: how much velocity should affect excitation attack time
accepts: notes audio
metronome beeps to the beat
vol: metronome volume
oscillator polyphonic enveloped oscillator. modulations (with MPE support): modwheel closes filter further (if filter is enabled), pressure decreases detune amount
unison: how many oscillators to play for one note
envfilterA: filter envelope attack
shuffle: stretches and squeezes every other cycle of the waveform
envfilterD: filter envelope decay
envS: volume envelope sustain
envR: volume envelope release
sync: turns on "sync" mode, to reset the phase at syncf's frequency
soften: soften edges of square and saw waveforms
envfilterS: filter envelope sustain
envfilterR: filter envelope release
osc: oscillator type
envA: volume envelope attack
envD: volume envelope decay
vel2vol: how much should the input velocity affect the output volume?
pw: pulse width (or shape for non-square waves)
width: controls how voices are panned with unison is greater than 1
vol: this oscillator's volume
syncf: frequency to reset the phase, when "sync" is enabled
lite cpu: only recalculate some parameters once per buffer, to reduce CPU load. can make pitch bends and rapid modulation sound worse in some scenarios.
fmax: frequency cutoff of lowpass filter at the max of the envelope. set this slider to the max to disable the filter
phase: phase offset of oscillator, and phase offset between unison voices. useful to patch into with a very fast modulator, to achieve phase modulation.
vel2env: how much should the input velocity affect the speed of the volume and filter envelopes?
mult: multiply frequency of incoming pitch
adsr len: view length of ADSR controls
q: resonance of lowpass filter
detune: when unison is 1, detunes oscillator by this amount. when unison is 2, one oscillator is tuned normally and the other is detuned by this amount. when unison is >2, oscillators are randomly detuned within this range.
fmin: frequency cutoff of lowpass filter at the min of the envelope
accepts: notes
samplecanvas sample arranging view
scrollv: vertical scrollbar
canvas: canvas of samples. drag and drop samples onto here. canvas controls: -hold shift and drag a sample to duplicate -hold alt to drag a sample without snapping -hold ctrl while dragging to snap to an interval -hold shift and scroll to zoom -hold alt and grab empty space to move slide the canvas view -hold ctrl and grab empty space to zoom the canvas view
interval: grid subdivision interval
drag mode: direction that elements can be dragged
timeline: control loop points
clear: delete all elements
measures: length of canvas in measures
view rows: number of visible rows
scrollh: horizontal scrollbar
delete: delete highlighted elements
sampleplayer sample playback with triggerable cue points, clip extraction, and youtube search/download functionality. resize this module larger to access additional features. if you have a youtube URL in your clipboard, a button will appear to allow you to download the audio.
load: show a file chooser to load a sample
trim: discard all audio outside the current zoom range
select played: when true, any cue point played via incoming notes will become the current cue
cue len: length in seconds of the current cue. a value of zero will play to the end of the sample.
append to rec: when recording, append to the previous recording, rather than clearing the sample first
cue start: start point in seconds of the current cue
play cue: play the current cue
threshold: volume threshold to open up the gate for recording
speed: current playback speed
pause: pause playing and leave playhead where it is
cue stop: stop playing this cue if a note-off is received
attack: speed at which gate blends open
4: auto-slice 4 slices
8: auto-slice 8 slices
save: save this sample to a file
playhovered: play this cue
play: start playing from the current playhead
click sets cue: when true, clicking on the waveform will set the start position of the current cue
stop: stop playing and reset playhead
volume: output gain
searchresult*: click to download this youtube search result. downloading long videos may take a while.
record as clips: when recording, only record when there is enough input to open the gate, and mark up each recorded segment with cue points
grabhovered: grab a sample of this cue to drop onto another module
cuepoint: sets the current cue to edit
yt:: search youtube for this string
16: auto-slice 16 slices
32: auto-slice 32 slices
youtube: download the audio of the youtube URL currently on your clipboard
record: record audio input into our sample buffer. clears the current sample.
cue speed: playback speed of the current cue
release: speed at which gate blends closed
show grid: show a quarter note grid (when zoomed in far enough)
loop: wrap playhead to beginning when it reaches end
accepts: pulses notes audio
sampler very basic polyphonic pitched sample player and recorder. send audio in, and use note input to play the recorded audio.
envS: volume envelope sustain
envR: volume envelope release
pitch: should we attempt pitch-correct the audio?
vol: output volume
thresh: when recording is enabled, exceed this threshold with input audio to begin recording
env: volume envelope
passthrough: should input audio pass through as we're recording?
rec: enable to clear the current recording, and record new audio once the input threshold is reached
envA: volume envelope attack
envD: volume envelope decay
accepts: notes audio
seaofgrain granular synth, playable with sliders or MPE input
load: load a sample file
pos r *: randomization of grain start point
pos *: position of this voice within the sample
speed r *: randomization of grain speed
pan *: stereo panorama of grain placement
offset: where to start view of the sample
speed *: speed of grain playback
keyboard num pitches: amount of pitches to assign across the sample
volume: output volume
len ms *: length of each grain in milliseconds
overlap *: number of overlapping grains
spacing r*: randomization of time between grains
display length: amount of sample to view
gain *: volume of this voice
keyboard base pitch: midi pitch that represents the start of the sample
octaves *: should we add octaves and fifths?
width *: stereo width of grain placement
record: record input as the granular buffer, to use seaofgrain a live granular delay
accepts: notes audio
signalgenerator basic oscillator signal. send a note into it to set the frequency, and send a pulse to reset the phase.
syncf: frequency to reset the phase, when "sync" is enabled
shuffle: stretches and squeezes every other cycle of the waveform
pw: pulse width (or shape for non-square waves)
slider: slider to interpolate between last two input pitches
vol: output volume
ramp: amount of time to ramp to input frequency
sync: turns on "sync" mode, to reset the phase at syncf's frequency
freq mode: what mode should we use for input notes? "instant" changes to the input note's frequency instantly, "ramp" ramps to the frequency over time, and "slider" allows you to use a slider to interpolate between the last two input notes
soften: soften edges of square and saw waveforms
detune: amount to detune from specified frequency
phase: phase offset
freq: signal frequency
osc: oscillator type
mult: multiplier for frequency
accepts: pulses notes

## audio effects

audiometer sets a slider to an audio level's volume. useful to map a midi display value to.
level: the input audio level. hook this up to an LED-display midi control to see the value displayed on your controller.
accepts: audio
audiorouter selector for switching where audio is routed to. connect to targets to add them to the list.
route: audio destination
accepts: audio
buffershuffler use notes to play back slices of a constantly-recording live input buffer. input notes trigger slices, with the pitch mapping to slice index. you can also click with a mouse to trigger slices.
freeze input: retain the current buffer, without writing in new input
playback style: how to play clicked slices. or, with input notes, velocity range determines playback style.
interval: slice size
num bars: number of bars to capture
accepts: notes audio
dcoffset add a constant offset to an audio signal
offset: amount of offset to add
accepts: audio
effectchain container to hold a list of effects, applied in series. the effects can be easily reordered with the < and > buttons, and deleted with the x button. hold shift to expose a x button for all effects.
spawn: spawn the currently highlighted effect
volume: output gain
effect: select which effect to add
exit effect: on push2, back effect control out to the main effectchain controls
mix*: wet/dry slider for this effect
x: delete this effect
<: move this effect to earlier in the chain
>: move this effect to later in the chain
accepts: audio
eq multi-band equalizer, to adjust output levels at frequency ranges
q*: resonance for this band
f*: frequency cutoff for this band
enabled*: enable this band?
g*: gain for this band
type*: what type of filter should this band use
accepts: audio
feedback feed delayed audio back into earlier in the signal chain. use the "feedback out" connector for sending the audio back up the chain, and the primary output connector for sending the resulting audio forward. using feedback can often lead to extreme and difficult-to-control results!
limit: clip the feedback audio to this range, to avoid issues with feedback blowing out too intensely.
accepts: audio
fftvocoder FFT-based vocoder
cut: how many bass partials to remove
phase off: how much we should offset the phase of the carrier signal's partials
whisper: how much the carrier signal partial's phases should be randomized, which affects how whispery the output sound is
dry/wet: how much original input vs vocoded signal to output
volume: output gain
fric thresh: fricative detection sensitivity, to switch between using the carrier signal and white noise for vocoding
carrier: carrier signal gain
input: input signal gain
accepts: audio
freqdelay delay effect with delay length based upon input notes
dry/wet: how much of the effect to apply
accepts: notes audio
gain adjusts volume of audio signal
gain: amount to adjust signal. a value of 1 will cause no change to the signal.
accepts: audio
input get audio from input source, like a microphone
ch: which channel (or channels, if you want stereo) to use
accepts: audio
inverter multiply a signal by -1. enables some pretty interesting effects when used with sends, to subtract out parts of signals when recombined.
accepts: audio
lissajous draw input audio as a lissajous curve. turn off "autocorrelation" in the module's triangle menu to use stereo channels to show stereo width.
scale: visual scale of lissajous image
accepts: audio
looper loop input audio. use with a "looperrecorder" for full functionality.
fourtet: use a textural trick I saw four tet illustrate in a video once: slice the audio into chunks, and for each chunk it at double speed followed by playing it in reverse at double speed. this slider adjusts the mix between the original audio and this "fourtetified" audio.
.5x: make loop play at half speed
mute: silence this looper
passthrough: should we pass incoming audio through to the output? turn off to mute incoming audio.
pitch: amount to pitch shift looper output
apply: shift the contents of the looper so the current offset is the start of the buffer
scr: allow loop to be scratched by adjusting "scrspd"
decay: amount to lower volume each loop
write: write input audio to loop buffer
swap: swap the contents of this looper and with another. click this button on two loopers to swap them.
save: save this loop to a wav file
m : take the contents of this looper and merge it into another. click this button on the merge source, then on the merge target.
extend: make loop twice as long
capture: when the next loop begins, record input for the duration of the loop
auto: should pitch shift auto-adjust as the transport tempo adjusts?
undo: undo last loop commit
offset: amount to offset looper's playhead from transport position
copy: take the contents of this looper and copy it onto another. click this button on the copy source, then on the copy target.
num bars: loop length in measures
resample for tempo: this button appears when the current global tempo no longer matches the tempo that the buffer was recorded at. click this to resample the buffer to match the new tempo.
volume: output volume
b: bake current volume into waveform
clear: clear the loop audio
2x: make loop play at double speed
scrspd: playback speed, used with "scr" is enabled. modulate quickly for a vinyl-like scratching effect.
fourtetslices: chunk size to use for "fourtet" effect
commit: commit the current looperrecorder buffer to this loop
accepts: notes audio
looperrecorder command center to manage recording into multiple loopers, and allow retroactive loop capture (i.e., always-on recording)
orig speed: reset looper to tempo that loops were recorded at
target: looper to commit audio to when using the on-buffer capture buttons to the left
2xtempo: double global transport tempo, while keeping connected loopers sounding the same
cancel free rec: if "free rec" is enabled, cancel recording without setting the loop length
clear: clear the recorded buffer
snap to pitch: snap tempo to nearest value that matches a key
1: capture the last measure to the currently-targeted looper
length: length in measures to use when connected loopers use the "commit" button
2: capture the last 2 measures to the currently-targeted looper
free rec: enable to start recording a loop with no predetermined length. disable to end recording, adjust global transport to match the loop length, and switch the recorder's mode to "loop"
4: capture the last 4 measures to the currently-targeted looper
resample: resample all connected loopers to new tempo
.5tempo: halve global transport tempo, while keeping connected loopers sounding the same
resample & set key: snap tempo to nearest value that matches a key (based upon the current key and the tempo change), resample all connected loopers to that new tempo, and change global scale to the new key
8: capture the last 8 measures to the currently-targeted looper
auto-advance: automatically advance to the next looper when committing
mode: recorder mode: use "record" to record input and allow it to be committed to buffers when you're ready to loop, use "overdub" to record input and play the loop at our specified length, and use "loop" to play the current loop without adding input
accepts: audio
looperrewriter rewrites the contents of a looper with received input, to help you resample your own loops. attach the grey dot to a "looper" module. the ideal way to use this module is to hook the "looper" directly up to a "send", hook the leftmost outlet of the "send" up to your effects processing (like an "effectchain"), hook the effect processing up to this "rewriter", and then also connect the rightmost outlet of the "send" up to this "rewriter"
go: rewrite the connected looper, and if that looper is connected to a send, set that send to output only to the right outlet
new loop: start recording a dynamic loop length. press "go" when you want to rewrite it to the looper. this will also change bespoke's global tempo to match this new loop, so it's quite powerful and scary! click it again to cancel.
accepts: audio
multitapdelay delay with multiple tap points
dry: how much dry signal to allow through
pan *: stereo pan for this tap
delay *: tap delay time, in milliseconds
display length: length of buffer display, in seconds
feedback *: how much delayed audio from this tap should feed back in to the input
gain *: tap delay amount
accepts: notes audio
output route audio in here to send it to an output channel (your speakers or audio interface)
ch: channel (or channels, if you want stereo) to send audio to
accepts: audio
panner pan audio left and right. also, converts a mono input to a stereo output.
widen: delay a channel by this many samples. results in a pan-like effect where the sound seems to come from from a direction.
pan: amount to send signal to the left and right channels. a value of 0 is centered.
accepts: audio
ringmodulator modulate a signal's amplitude at a frequency
volume: volume output
freq: frequency to use. can also be set by patching a note input into this module.
dry/wet: how much of the original audio to use vs modulated audio
glide: how long an input note should take to glide to the desired frequency
accepts: notes audio
samplergrid record input onto pads, and play back the pads. intended to be used with an 64-pad grid controller.
vol: the output volume
end: sample end
edit: enable controls to adjust recorded sample for last pressed grid square
passthrough: should the incoming audio pass through to the output?
clear: when enabled, clears any pressed grid squares
start: sample start
duplicate: what enabled, duplicates last pressed sample onto any pressed grid squares
grid: patch a grid in here from a "midicontroller" module
accepts: notes audio
send duplicate a signal and send it to a second destination
amount: amount to send out the right-side cable
crossfade: when true, output of the left-side cable is reduced as "amount" increases
accepts: audio
signalclamp clamps an audio signal's value within a range
max: maximum output value
min: minimum output value
accepts: audio
spectrum display audio signal's spectral data
accepts: audio
splitter splits a stereo signal into two mono signals, or duplicates a mono signal
accepts: audio
stutter captures and stutters input
free length: length in seconds for "free" stutter mode
reverse: reversed half note stutter
half speed: stutter at half speed, low pitched
ramp in: stutter with speed climbing up from zero to one
triplets: stutter on a triplet interval
32nd: 32nd note stutter
64th: 64th note stutter
tumble up: accelerating stutter
half note: half note stutter
tumble down: decelerating stutter
grid: patch a grid in here from a "midicontroller" module
free: stutter with the settings specified by the following sliders
dotted eighth: stutter on a dotted eighth interval
free speed: rate for "free" stutter mode
double speed: stutter at double speed, high pitched
quarter: quarter note stutter
ramp out: stutter with speed quickly falling to zero
16th: 16th note stutter
8th: 8th note stutter
accepts: notes audio
vocoder frequency band-based vocoder. this must be paired with a "vocodercarrier" module. voice should be routed into this module, and a synth should be patched into the vocodercarrier.
volume: output gain
max band: volume limit for each frequency band
bands: how many frequency bands to use
spacing: how frequency bands should be spaced
f base: frequency for lowest band
q: resonance of the bands
mix: how much original input vs vocoded signal to output
carrier: carrier signal gain
f range: frequency range to highest band
input: input signal gain
ring: how long it should take the bands to "cool down"
accepts: audio
vocodercarrier connect to "vocoder" or "fftvocoder" modules. send the synth audio into this module, and the voice audio into the vocoder module.
accepts: audio
waveformviewer waveform display
length: number of samples to capture
draw gain: adjust waveform display scale
freq: frequency to sync display to. gets automatically set if you patch a note input into this module
accepts: notes audio
waveshaper waveshaping with expressions
a: variable to use in expressions
c: variable to use in expressions
b: variable to use in expressions
e: variable to use in expressions
d: variable to use in expressions
rescale: rescales input before feeding it into expression
y=: waveshaping expression. try something like "x+sin(x*pi*a)". available variables: a,b,c,d,e = the sliders below. t = time. x1,x2,y1,y2 = biquad state storage.
accepts: audio

## modulators

accum accumulate a value over time
velocity: amount to accumulate
value: output value
add outputs the result of value 1 plus value 2. value 1 and value 2 are intended to be patch targets for modulators.
value 1: value to sum
value 2: value to sum
addcentered outputs the result of value 1 plus value 2, multiplied by range 2. optimized for using to modulation value 1 by range 2 at a frequency. value 1 or value 2 are intended to be patch targets for modulators.
range 2: modulation amount
value 1: center value
value 2: modulation value
audiotocv use an audio signal to modulate a control. allow for audio-rate modulation, to achieve effects such as FM.
max: maximum output value
gain: multiply incoming audio
min: minimum output value
accepts: audio
controlsequencer modulate a control step-wise at an interval
random: randomize sequence values
length: length of the sequence
interval: rate to advance
step *: value for this step
accepts: pulses notes
curve remap an input over its range with a curve. double-click on the curve to add points, right click on points to remove them, drag on lines to bend them.
input: input value (intended as a modulation target)
curvelooper modulate a value over time with a looping curve
length: length of the loop
randomize: create a random curve
envelope modulate a value with a triggered envelope
has sustain: should this envelope have a sustain stage?
adsrD: envelope decay
adsrA: envelope attack
use velocity: should envelope output be scaled by input velocity?
max sustain: what's the maximum length of the sustain, in milliseconds? a value of -1 indicates no maximum
sustain stage: which step of the envelope should have the sustain?
high: output high value
length: length of envelope display
low: output low value
adsrS: envelope sustain
adsrR: envelope release
adsr: envelope view
advanced: switch to advanced envelope editor (allows for a more complicated envelope than just an ADSR). double-click on an advanced envelope line to add stages, right click on points to remove them, drag on lines to bend them.
accepts: pulses notes
expression shape modulation with a text-based mathematical expression
a: variable to use in expressions
c: variable to use in expressions
b: variable to use in expressions
e: variable to use in expressions
d: variable to use in expressions
y=: expression to modify input. try something like "x+sin(x*pi*a)". available variables: a,b,c,d,e = the sliders below. t = time.
input: input to use as x variable
fubble draw on an X/Y pad and replay the drawing to modulate values. based on a concept proposed by olivia jack
mutate amount: amount to affect drawing by perlin noise field
mutate warp: scale of perlin noise field
speed: speed up or slow down playback
clear: clear the drawing
quantize: should we quantize playback to a specified rhythmic interval?
length: the interval to quantize to
mutate noise: rate to move through perlin noise field
reseed: jump to a different location in the perlin noise field
gravity make a modulation value rise and fall with physics
kick amt: the amount of upward force to apply when kicking
drag: the resistance force to apply opposite the velocity
gravity: the gravitational force to apply downwards
kick: click to apply kick force (or, pulse this module for the same result)
accepts: pulses
gridsliders use a grid controller to control multiple sliders
direction: should the grid display the sliders vertically, or horizontally?
grid: patch a grid in here from a "midicontroller" module
leveltocv output a modulation value based on the level of incoming audio
release: decay from the input level at this rate
max: output when level is one
attack: rise to the input level at this rate
gain: multiply the input audio by this value
min: output when level is zero
accepts: audio
lfo modulates a slider with a low-frequency oscillator
enable: turn on/off modulation
shuffle: adjust the waveoform to have a fast and slow cycle
pin: make LFO window remain visible
interval: length of oscillation period
soften: smooth out the hard edges of square and saw waveforms
high: output value at waveform's high point
free rate: rate of oscillator running in non-clock-synced time
length: proportion of time that should be spent on the waveform cycle
bias: bias the waveform towards the low or high point
low: output value at waveform's low point
offset: phase offset, to make oscillation earlier/later
lite cpu: only recalculate some parameters once per buffer, to reduce CPU load. can sound worse in some scenarios, especially with rapid modulation.
osc: type of oscillation waveform
spread: spread the waveform out to be closer to the low and high points
macroslider take a value and send scaled versions of that value to multiple destinations
start*: the output value at the bottom of the input's range
input: the input value. intended to be a modulation patch target.
end*: the output value at the top of the input's range
modwheeltocv take a note's modwheel value and convert it to a modulation value
max: output for modwheel value 127
min: output for modwheel value 0
accepts: notes
mult outputs the result of value 1 multiplier by value 2. value 1 and value 2 are intended to be patch targets for modulators.
notetofreq takes an input note, and outputs that note's frequency in hertz
accepts: notes
notetoms takes an input note, and outputs the period of that note's frequency in milliseconds. useful for setting delay lines to create specific pitches.
accepts: notes
pitchtocv take a note's pitch and convert it to a modulation value
max: output for pitch 127
min: output for pitch 0
accepts: notes
pitchtospeed convert an input pitch to a speed ratio. you could use this to control a sample's playback speed and make it playable with a keyboard.
ref freq: the output is the input frequency divided by this number
accepts: notes
pressuretocv take a note's pressure and convert it to a modulation value
max: output for pressure 127
min: output for pressure 0
accepts: notes
ramper blend a control to a specified value over a specified time
start: begin blending (or, send a pulse to this module for the same result)
length: length of time to blend over
target: the value to arrive at when the ramp is over
accepts: pulses
smoother outputs a smoothed value of the input
input: set a value to smooth, patch a modulator into here
smooth: amount of smoothing to apply
subtract outputs the result of value 2 subtracted from value 1. value 1 and value 2 are intended to be patch targets for modulators.
valuesetter set a specified value on a targeted control
slider: value to set
set: click here to send the value (or, send a pulse to this module for the same result)
value: value to set
accepts: pulses
velocitytocv take a note's velocity and convert it to a modulation value
max: output for velocity 127
0 at note off: output zero when note is released
min: output for velocity 0
accepts: notes
vinylcontrol modulator which outputs a speed value based upon control vinyl input audio. provide it with a stereo signal from control vinyl (like you'd use to control serato) patched in from an "input" module.
control: enable/disable transport control. when you enable it, it will use the current speed as the reference speed (so, the output will output a value of 1 until you change the vinyl's speed)
accepts: audio

## pulse

audiotopulse sends a pulse when the audio level surpasses a specified threshold
release: the cooldown time for the audio signal before a pulse can be triggered again
threshold: send a pulse when the signal hits this threshold
accepts: audio
boundstopulse sends a pulse when its input slider hits its max or min limit
input: the slider to check bounds on
notetopulse trigger a pulse whenever a note is received
accepts: notes
pulsebutton trigger a pulse with a button press
pulse: trigger a pulse
pulsechance randomly allow pulses through, based on chance
deterministic: allow for randomness to be repeated over an interval
chance: chance that pulses are allowed through
*: generate a new random seed
seed: number that determines the random sequence. send reset pulses to restart the deterministic random sequence.
<: go to next seed
accepts: pulses
pulsedelayer delay pulses
delay: time to delay, in fractions of a measure
accepts: pulses
pulsedisplayer see what flags are on pulses
accepts: pulses
pulseflag set properties on pulses
flag: property to add
replace: if disabled, the above flag is appended to the pulse's flags. if enabled, the pulse's flags are replaced by the above flag.
accepts: pulses
pulsegate control if pulses are allowed through
allow: can pulses pass through?
accepts: pulses
pulsehocket sends pulses to randomized destinations
weight *: chance that pulse goes to this destination
*: generate a new random seed
seed: number that determines the random sequence. send reset pulses to restart the deterministic random sequence.
<: go to next seed
accepts: pulses
pulser send pulse messages at an interval
reset: length of sequence before sending reset pulse
interval: rate to send pulses
random: tell pulsed modules to randomize their position
t: pulse interval in milliseconds
offset: pulse time offset, in fractions of the interval
div: measure division, when using "div" as the interval
timemode: when to send downbeat pulses, or set to "free" for pulses not locked to the transport
pulsesequence defines a looping sequence of pulses
length: length of the sequence
interval: length of each step within the sequence
<: shift sequence to the left
>: shift sequence to the right
accepts: pulses
pulsetrain defines a list of pulses to execute, once pulsed
length: length of the sequence
interval: length of each step within the sequence
accepts: pulses

## effect chain

basiceq simple multiband EQ
even: reset EQ
accepts: audio
biquad filter using biquad formula
Q: resonance
type: filter type
G: gain
F: frequency cutoff
accepts: audio
bitcrush reduce sample resolution and sample rate for lo-fi effects
crush: sample resolution reduction
downsamp: sample rate reduction
accepts: audio
butterworth filter using the butterworth formula
Q: resonance
F: frequency cutoff
accepts: audio
compressor try to keep volume at a certain level
ratio: how much gain reduction to apply when the single passes the threshold
lookahead: how much time to "look ahead" to adjust the compression envelope. this necessarily introduces a delay into your output, which could be compensated for by running sequencers slightly early.
drive: rescale input to affect how much compression affects it
mix: amount of compression. lower this value for a "parallel compression" effect. you should use this mix slider instead of the effectchain's mix slider, to compensate for lookahead.
attack: speed to apply gain reduction
threshold: threshold where gain should start to be reduced
release: speed to remove gain reduction
output: makeup gain, to increase volume
accepts: audio
dcremover high pass filter with a 10hz cutoff to remove DC offset, to keep signal from drifting away from zero
accepts: audio
delay echoing delay
dry: should the dry signal pass through, or just the delayed signal?
short: shortcut to shrink the range of the delay slider, to allow for audible-rate delays and comb filter sounds
feedback: should the output audio feed back into the delay?
invert: should the delayed audio have its signal inverted? this can give a different sound, and also cancel out DC offset to prevent it from accumulating with feedback.
interval: sets delay length to a musical duration
delay: delay in milliseconds
amount: amount of delay that returns
input: should we accept input into the delay?
accepts: audio
distortion waveshaping distortion
preamp: signal gain before feeding into distortion
fuzz: push input signal off-center to distort asymmetrically
type: style of distortion to apply
clip: cutoff point of distortion, lower values result in more extreme distortion
center input: remove dc offset from input signal to distort in a more controlled way
accepts: audio
freeverb reverb using the "freeverb" algorithm
dry: amount of untouched signal
room size: controls the length of the reverb, a higher value means longer reverb
damp: high frequency attenuation; a value of zero means all frequencies decay at the same rate, while higher settings will result in a faster decay of the high frequency range
width: stereo width of reverb
wet: amount of reverb signal
accepts: audio
gainstage control volume within an effectchain
gain: volume multiplier
accepts: audio
gate only allow signal in when it's above a certain threshold. useful to eliminate line noise, or just as an effect.
release: speed at which gate blends closed
threshold: volume threshold to open up the gate
attack: speed at which gate blends open
accepts: audio
granulator granulate live input
dry: amount of dry signal to allow through
spd r: randomization of grain speed
g oct: should we add octaves and fifths?
pos r: randomization of grain start point
pos: playback position within the buffer
autocapture: freeze input at this interval
spa r: randomization of time between grains
width: stereo width of grain placement
overlap: number of overlapping grains
frz: freeze the current recorded buffer
speed: speed of grain playback
len ms: length of each grain in milliseconds
accepts: audio
muter mute an incoming signal
ms: ramp time to mute/unmute signal
pass: when true, the signal is allowed through
accepts: audio
noisify multiply input signal by white noise
width: how frequently a new noise sample should be chosen
amount: amount of noise to apply
accepts: audio
pitchshift shifts a signal's pitch
ratioselector: shortcuts to useful pitch ratios
ratio: amount to pitchshift by (a value of 1 indicates no shift)
accepts: audio
pumper dip the volume of a signal rhythmically, to emulate a "pumping sidechain" effect
length: length of pump
amount: amount to lower volume
interval: the rate to pump
curve: how the volume returns
attack: how sharply the volume drops
accepts: audio
tremolo modulate signal's volume rhythmically
duty: pulse width of LFO
amount: amount to lower volume
interval: speed of LFO
osc: LFO oscillator type
offset: offsets LFO phase
accepts: audio

## other

abletonlink synchronizes transport with software and devices that support ableton link
reset next downbeat: resets measure count on the next downbeat, to help synchronize to desired phase in session
offset ms: offset in milliseconds to tweak synchronization
clockin reads in clock pulses from external midi devices to control bespoke's transport
device: device to receive from
rounding: precision to round incoming tempo data
start offset ms: offset in milliseconds to tweak synchronization between bespoke and gear
smoothing: how much to smooth incoming tempo
clockout sends out clock pulses to synchronize external midi devices
device: device to target
send start: send a signal to reset the gear to the start of its sequence
multiplier: tempo multiplier for how the gear should respond to the signals
comment a box to display some text, to explain a section of a patch
comment: type text here
eventcanvas schedule values to set over time
canvas: canvas of events. canvas controls: -shift-click to add an event -hold shift and drag an event to duplicate -hold alt to drag an event without snapping -hold ctrl while dragging to snap to an interval -hold shift and scroll to zoom -hold alt and grab empty space to move slide the canvas view -hold ctrl and grab empty space to zoom the canvas view
interval: grid for snapping events to
drag mode: direction that elements can be dragged
record: record connected values as they change
timeline: control loop points
clear: delete all elements
measures: length of loop
quantize: quantizes events to grid
view rows: number of visible rows
scrollh: horizontal scrollbar
delete: delete highlighted elements
globalcontrols interface controls, intended to allow you to use midi controllers to navigate the canvas. controlling these sliders directly with the mouse is not recommended.
background r: amount of red in background color
scroll x: emulate horizontal mouse scrolling
lissajous g: amount of green in background lissajous curve
lissajous b: amount of blue in background lissajous curve
scroll y: emulate vertical mouse scrolling
zoom: zoom level
background b: amount of blue in background color
x pos: horizontal panning position
background g: amount of green in background color
lissajous r: amount of red in background lissajous curve
y pos: vertical panning position
grid generic grid, to be used by "script" module, to assist in writing scripts that use grid-based midi controllers
grid: patch a grid in here, from a "midicontroller" module
momentary: should clicks be treated as momentary inputs?
accepts: notes
groupcontrol connect to several checkboxes, and control them all with one checkbox
group enabled: controls the connected checkboxes
loopergranulator use with a "looper" module to play the contents with granular synthesis
spacing rand: randomization of time between grains
on: use granular synthesis for looper playback
octaves: should we add octaves and fifths?
speed rand: randomization of grain speed
overlap: number of overlapping grains
freeze: stop advancing looper time
width: stereo width of grain placement
loop pos: playback position within loop
pos rand: randomization of grain start point
speed: speed of grain playback
len ms: length of each grain in milliseconds
multitrackrecorder record several synchronized tracks of audio, to write to disk for mixing in an external DAW
add track: add an additional track
clear: clear the audio in the tracks
bounce: write the tracks to your recordings directory
record: record input to the tracks
notetoggle turn a control on or off depending on if there are any input notes
accepts: notes
oscoutput send OSC messages when slider values change or when notes are received
note out address: label to send input notes. the message will be sent in the format /bespoke/[label] [pitch] [velocity]
slider*: sends a value to the address. try patching a modulator into this, such as a leveltocv module to send audio levels.
label*: label to send slider value. the message will be sent in the format /bespoke/[label] [value]
osc out address: destination to send OSC messages to
osc out port: port to send OSC messages to
accepts: notes
prefab create a collection of modules that can be loaded from the "prefabs" menu. drag and drop modules onto here to add them to the prefab. drag the grey cable to any modules you want to remove from the prefab.
load: load a .pfb
save: save as a .pfb file
disband: free all modules from this prefab
push2control use an ableton push 2 to control bespoke's interface
radiosequencer sequence to only enable one value at a time. patch it to the "enabled" checkbox on several modules to only enable one module at a time. works well in conjunction with "groupcontrol" module.
length: length of sequence
interval: rate to advance
grid: patch a grid in here from a "midicontroller" module
accepts: pulses notes
samplebrowser browse your system for samples. drag samples from here to your desired targets (sampleplayer, drumplayer, seaofgrain, etc)
> : next page
< : previous page
scale controls the global scale used by various modules
scale: which set of notes to use
tuning: what frequency does the pitch defined in "note" represent?
load KBM: load KBM file to determine keyboard mapping
PPO: pitches per octave
note: the pitch that maps to the frequency defined in "tuning"
load SCL: load SCL file to determine scale
intonation: which method to use to tune the scale
root: root note of the scale
script python scripting for livecoding notes and module control
a: variable for the script to use, can be modulation by other sources. access via me.get("a")
load: load selected script
c: variable for the script to use, can be modulation by other sources. access via me.get("c")
b: variable for the script to use, can be modulation by other sources. access via me.get("b")
run: click here to execute the code, or press ctrl-R
d: variable for the script to use, can be modulation by other sources. access via me.get("d")
stop: cancel any events scheduled by this script
style: choose a text theme, from script_styles.json
code: write code here. press ctrl-R to execute the code, or ctrl-shift-R to just execute the current block.
save as: save the current script
loadscript: choose a script from here, then press "load"
?: show scripting reference
accepts: pulses notes
scriptstatus shows everything in the current python scope, for debugging
reset all: resets scope variables
selector radio button control to only enable one value at a time. patch it to the "enabled" checkbox on several modules to only enable one module at a time. works well in conjunction with "groupcontrol" module.
selector: which value should be set to 1
accepts: notes
snapshots save and restore sets of values. connect the grey circle to modules to affect all controls on that module. connect the purple circle to a control to affect only that control. shift-click on the grid to store a preset to that square, and click on a grid square to load that preset.
snapshot label: assign a label to this snapshot
auto-store on switch: when switching to a new slot, automatically store state in the current slot
clear: clear all snapshots
random: randomize connected controls
add: snapshot the currently connected controls to the next available snapshot slot
snapshot: jump to a snapshot
blend: length of time in milliseconds over which to blend snapshot values
store: when clicking/selecting a snapshot, store into that slot (alternately: hold the shift key)
delete: when clicking/selecting a snapshot, delete that slot (alternately: hold the alt/option key)
accepts: notes
songbuilder large-scale organizer to arrange settings into scenes and then sequence them. this is bespoke's "song mode"
move left: move this target left in the scene
play from*: play sequence from this step
add target: add a targeted control for scenes to affect
stop: stop the sequence
activate first scene on stop: when stopping, activate the first scene. it is recommended that you use the first scene as an "off" scene, and have it disable all song elements.
pause: hold the sequence on the current scene
loop end: loop step index that the loop ends
move right: move this target right in the scene
value*: value to use for target in this scene
context*: options for this scene
scene*: name of scene for this step
type: change the control display type for this target
bars*: length in bars that this scene should play for
checkbox*: value to use for target in this scene
loop start: loop step index to start the loop on
name*: name of this scene
dropdown*: value to use for target in this scene
change quantize: when a change should happen after pressing the play button on a scene. "switch" changes immediately, and "jump" changes immediately and also resets the global transport.
play: play the sequence
contextmenu*: options for this step
go*: play this scene
use sequencer: show scene sequencer
loop: enable a loop within the sequence
accepts: pulses notes
timelinecontrol control global transport position
reset: reset to beginning
loop end: measure end of loop
loop start: measure start of loop
dock: should we dock this module to the UI layer?
length: length of timeline display, in measures
measure: current position. click to jump around.
loop: should we have a looping section?
timerdisplay displays a timer to indicate how long a patch has been running
reset: reset timer to zero
transport controls tempo and current time position
reset: reset timeline to zero
+ : increase tempo by one
- : decrease tempo by one
< : nudge current time backward
tempo: global tempo, in beats per minute
swing: where the halfway point of musical time within the swing interval should fall. a value of .5 represents no swing.
timesigtop: time signature top value
timesigbottom: time signature bottom value
swing interval: interval over which to apply swing
play/pause: stop all audio processing (shift-p)
> : nudge current time forward
valuestream displays a control's value over time. connect the cable to a UI control to see how it is changing.
speed: how quickly display should scroll