# 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 minimap 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 * F3: pins or unpin a module so that it stays where it is regardless of the viewports position. only works when not group selecting modules.

## 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
dotsequencer polyphonic note sequencer with adjustable note length and velocity. click and drag horizontally to adjust length. click and drag vertically to adjust the velocity. hover and use the arrow keys to move dots. hover and use the mouse wheel to tweak dot lengths.
clear: clear the contents of the dot grid
cols: number of columns
dotgrid: the dot grid
double: double the length of this sequence
interval: rate to play notes at
notemode: which set of pitches should the rows represent?
octave: octave of the bottom pitch of this sequence
row offset: amount to offset the mapping of row to pitch
rows: number of rows
drumsequencer step sequencer intended for drums. hold shift when dragging on the grid to adjust step velocity, or hover over a step and press the up and down arrow keys to adjust velocity.
<: shift whole pattern one step earlier
>: shift whole pattern one step later
clear: clear sequence
column: current column, to use for visualizing the step on a midi controller
grid: patch a grid in here from a "midicontroller" module
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.
offset*: shift row forward/backward in time. try making your snares a little early, your hats a little late, etc.
offsets: show "offsets" sliders
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.
r den: density of the randomizer output. the higher this is, the busier the random output will be.
r lock*: lock this row so it doesn't get randomized
random*: randomize this row
randomize: randomize the sequence
repeat: repeat input notes at this rate
rowpitch*: output pitch for this row
step: length of each step
vel: velocity to use when setting a step
velocity: patch a grid in here from a "midicontroller" module to control the velocity
velocitytype: velocity to use when setting a step
yoff: vertical offset for grid controller's view of the pattern
accepts: pulses notes
euclideansequencer euclidean sequencer displays a loop as a circle. the notes are calculated using the euclidean rhythm algorithm.
clear: clear all steps, onsets, rotation and offset in all rings
note: randomize notes in all rings
note chance: what is the chance a note gets changed
note*: pitch to use for this ring
o *: in what range is offset created
oct*: in what octave range are notes created
offset: randomize offset in all rings
offset chance: what is the chance that an offset gets changed
offset*: timing offset for this ring
ons *: in what range are onsets created
onset chance: what is the chance that an onset gets changed
onsets: randomize onsets in all rings
onsets*: number of onsets in this ring
random: randomize all steps, onsets and rotation in all rings
random*: randomize steps, onsets and rotation in this ring
rot chance: what is the chance that rotation gets changed
rot hi: in what range is rotation created
rot lo: in what range is rotation created
rotation: randomize rotation in all rings
rotation*: rotation of this ring
step chance: what is the chance a step gets changed
steps: randomize steps in all rings
steps*: number of steps in this ring
stp*: in what range are steps created
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
arrangement: what style of layout should we use?
ch.latch: latch chord button presses
grid: patch a grid in here from a "midicontroller" module
latch: latch key presses, so you press once to play a note, and press again to release a note
layout: keyboard style
octave: base octave
p.root: for chorder, make root note always play
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
interval: interval per step
pitch*: pitch to use for this row
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.
x : delete this connection
14bit: is this a 14-bit midi control, with this control as the LSB and the control 32 less than this as the MSB?
add: add a mapping manually
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
blink: when the targeted control is enabled, send alternating on/off messages, to blink the associated LED
channel: which channel to pay attention to
control: pitch or control to refer to
controller: midi device to use
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
copy: duplicate this connection
feedback: which cc or note should we send the feedback to?
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")
layout: which layout file should we use for this controller? these can be created in your Documents/BespokeSynth/controllers folder.
mappingdisplay: which mapping view to see
messagetype: type of midi message
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.
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.
monome: which monome should we use?
osc input port: port to use for osccontroller input
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
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.
scale: should the output of this midi slider be scaled between "midi off" and "midi on"?
twoway: should we send feedback to the controller? (to control the LEDs associated with the button/knob)
value: the value to set
notecanvas looping note roll
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
clear: delete all elements
delete: delete highlighted elements
drag mode: direction that elements can be dragged
free rec: enable record mode, and extend canvas if we reach the end
interval: interval to quantize to
load midi: import canvas contents from a midi file
loadtrack: which track number to import when using "load midi"
measures: loop length
play: play notes on canvas
quantize: quantize selected notes to interval
rec: record input notes to canvas
save midi: export canvas contents to a midi file
scrollh: horizontal scrollbar
scrollv: vertical scrollbar
show chord intervals: show brackets to indicate chord relationships
timeline: control loop points
view rows: number of visible rows
accepts: notes
notechain trigger a note, followed by a pulse to trigger another note after a delay
duration: duration of note, in measures
next: interval until sending pulse
pitch: pitch to play
trigger: play note for this chain node
velocity: velocity for note
accepts: pulses
notecounter advance through pitches sequentially. useful for driving the "notesequencer" or "drumsequencer" modules.
*: generate a new random seed
<: go to previous seed
>: go to next seed
beat length: length over which the random sequence should deterministically repeat
div: measure division, when using "div" as the interval
interval: rate to advance
length: length of the sequence
random: output random pitches within the range, rather than sequential
seed: number that determines the random sequence
start: pitch at the start of the sequence
sync: if the output pitch should be synchronized to the global transport
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
pitch: output note pitch
trigger: press to trigger note for specified duration
velocity: note velocity
accepts: pulses
notelooper note loop recorder with overdubbing and replacement functionality
canvas: canvas of recorded notes
clear: clear pattern
del/mute: if "write" is enabled, erase notes as the playhead passes over them. otherwise, just mute them.
load*: restore pattern
num bars: set loop length in measures
store*: save pattern
write: should input should be recorded?
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.
<: shift the sequence to the left
>: shift the sequence to the right
clear: clear all steps
grid: patch a grid in here from a "midicontroller" module
interval: note length
len: randomize the length of each step's note.
len*: length for this column
length: length that the sequence below should play. the overall grid length can be changed by adjusting "gridsteps" in the triangle menu.
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.
notemode: which set of pitches should the rows represent?
octave: octave of the bottom pitch of this sequence
pitch: randomize pitches in the sequence. hold shift to constrain the randomization to only pick roots and fifths.
rand len chance: when clicking the random length button, what is the chance that a step gets changed?
rand len range: when clicking the random length button, how much will the length change?
rand pitch chance: when clicking the random pitch button, what is the chance that a step gets changed?
rand pitch variety: how many different random pitches should we generate?
rand vel chance: when clicking the random velocity button, what is the chance that a step gets changed?
rand vel density: when clicking the random velocity button, what are the chances that a step should have a note?
random: randomize pitch, length, and velocity of all steps.
tone*: pitch for this column
vel: randomize the velocity of each step's note.
vel*: velocity for this column
x offset: x offset of attached grid controller
y offset: y offset of attached grid controller
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
grid: patch a grid in here from a "midicontroller" module
interval: the step size
link columns: if the mute/delete control should be shared across the entire column
load*: load the sequence stored in this slot
measures: the loop length
mute/delete*: if write is disabled, mute this row. if write is enabled, clear the steps as the playhead passes them
note repeat: if held notes should repeat every step
store*: store the current sequence to this slot
write: if the current input should be written to the sequence. this will also delete steps if mute/delete is enabled for this row
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
interval: the note length
offset: the amount of time to offset playback within the interval
pitch: the pitch to use
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
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?
time*: time to trigger this element
vel*: velocity of this element

## note effects

arpeggiator arpeggiates held notes. there are several vestigial features in this module that should be cleaned up.
interval: arpeggiation rate
octaves: how many octaves to step through
step: direction and distance to step through arpeggiation. a value of zero is "pingpong".
accepts: notes
capo shifts incoming notes by semitones
capo: number of semitones to shift
diatonic: should we keep transposed notes in the scale?
retrigger: immediately replay current notes when changing the capo amount
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
chord: chord presets
diatonic: should the grid be chromatic, or locked to the scale only?
inversion: inversion presets
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
vibinterval: rate of vibrato
vibrato: amount of pitch bend
accepts: notes
mpesmoother smooth out MPE parameters
modwheel: amount to smooth incoming modwheel
pitch: amount to smooth incoming pitchbend
pressure: amount to smooth incoming pressure
accepts: notes
mpetweaker adjust incoming MPE modulation values
modwheel mult: amount to multiply incoming modwheel
modwheel offset: amount to offset incoming modwheel
pitchbend mult: amount to multiply incoming pitchbend
pitchbend offset: amount to offset incoming pitchbend
pressure mult: amount to multiply incoming pressure
pressure offset: amount to offset incoming pressure
accepts: notes
notechance randomly allow notes through
*: generate a new random seed
<: go to previous seed
>: go to next seed
beat length: restart the deterministic random sequence at this interval
chance: probability that a note is allowed
deterministic: allow for randomness to be repeated over an interval
seed: number that determines the random sequence
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
*: generate a new random seed
<: go to previous seed
>: go to next seed
beat length: restart the deterministic random sequence at this interval
seed: number that determines the random sequence
weight *: chance that note goes to this destination
accepts: notes
notehumanizer add randomness to timing and velocity
time: amount of timing randomness, in milliseconds.
velocity: amount of velocity randomness
accepts: notes
notelatch use note on messages to toggle notes on and off
accepts: notes
noteoctaver transpose a note by octaves
octave: number of octaves to raise or lower
retrigger: immediately replay current notes when changing the transpose amount
accepts: notes
notepanalternator sets a note's pan, alternating between two values, for the internal synths that support panned notes
one: pan position, .5 is centered
two: 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
center: center pan position
spread: amount of randomness
accepts: notes
noterangefilter only allows notes through within a certain pitch range
max: maximum pitch allowed
min: minimum pitch allowed
wrap: instead of rejecting notes outside of this range, should we wrap them to the range instead?
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
length: length of the sequence
reset: reset to the start
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
clear: clear grid
grid: patch a grid in here from a "midicontroller" module
length: the number of pitches
notemode: which set of pitches should the rows represent?
octave: octave of the bottom pitch of this sequence
rand pitch chance: when clicking the random pitch button, what is the chance that a step gets changed?
rand pitch range: when clicking the random pitch button, how far will the pitch change?
random pitch: randomize pitches in the sequence. hold shift to constrain the randomization to only pick roots and fifths.
tone*: pitch for this column
x offset: x offset of attached grid controller
y offset: y offset of attached grid controller
accepts: notes
notewrap wrap an input pitch to stay within a desired range
min: bottom of pitch range
range: number of semitones before wrapping back down to min pitch
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
left: pitch that represents full left pan
right: pitch that represents full right pan
accepts: notes
pitchremap remap input pitches to different output pitches
from*: pitch to change
to*: desired pitch
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
glide: time to glide, in milliseconds
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
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
vibinterval: vibrato speed
vibrato: amount of vibrato
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
rhythmsequencer repeats held input notes, to turn a sustained note into a rhythm
action *: action for this step. on = play note, hold = sustain note, off = no note
degree *: scale degree offset for this step
interval: rate to play notes at
len act: length of the action column
len deg: length of the scale degree offset column
len oct: length of the octave offset column
len vel: length of the velocity column
length: length of the sequence
link lengths: should there be one global length, or a length for each column?
octave *: octave offset for this step
vel *: velocity for this step
accepts: pulses notes
scaledegree transpose input based on current scale
degree: amount to transpose
diatonic: should we keep transposed notes in the scale?
retrigger: immediately replay current notes when changing the transpose amount
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.
retrigger: immediately replay current notes when changing the transpose root or the scale
root: root to transpose from
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
len: length of sequence
vel*: velocity for this step
accepts: notes
velocitytochance use a note's velocity to determine the chance that the note plays
*: generate a new random seed
<: go to previous seed
>: 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
seed: number that determines the random sequence
accepts: notes
vibrato add rhythmic oscillating pitch bend to notes
vibinterval: speed of pitch bend oscillation
vibrato: amount of pitch bend to add
accepts: notes
voicesetter set a specific Voice channel index for a note
voice index: current set voice channel index
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
bars*: how many measures long are the samples in this slot?
delete *: remove the current sample from the list
double*: enable this to play at double speed
filter*: layer filter. negative values bring in a low pass, positive values bring in a high pass.
pan*: layer panorama
selector*: which sample should we play in this slot? drag samples onto here to add them to this slot.
volume*: layer volume
drumplayer sample player intended for drum playback
aud: scroll to audition samples in the current pad's head category, or a directory last dropped onto a pad
edit: show pads for editing
envelope *: should we apply a volume envelope to the sample?
envelopedisplay *A: envelope attack
envelopedisplay *D: envelope decay
envelopedisplay *R: envelope release
envelopedisplay *S: envelope sustain
full vel: always play drum hits at full velocity
grab *: grab this sample
grid: patch a grid in here from a "midicontroller" module
hitcategory*: folder to choose from, when clicking the "random" button. these folders are found in the data/drums/hits/ directory
linkid *: if linkid is not -1, silence any other sample with a matching linkid (useful for linking open and closed hats)
mono: force output to mono
next *: choose the next sample from the selected hitcategory
pan *: stereo pan position of sample
prev *: choose the previous sample from the selected hitcategory
quantize: quantize input to this interval
random *: choose a random sample from the selected hitcategory
repeat: if quantizing, should held notes repeat at that interval?
shuffle: random is samples, speeds, and pans
single out *: should the sample have its own individual output?
single voice: only play a single drum hit at once, choking all others out (as if they all shared the same linkid)
speed: global sample speed multiplier
speed *: speed of sample
speed rnd: global sample speed randomization amount
start *: start offset percentage of sample
test *: play this sample
view ms *: envelope view length in milliseconds
vol: the output volume
vol *: volume of sample
widen *: stereo delay of sample to create width
accepts: notes
drumsynth oscillator+noise drum synth
cutoffmax*: filter start cutoff frequency
cutoffmin*: filter end cutoff frequency
edit: display parameters for each hit
freqmax*: oscillator start frequency
freqmin*: oscillator end frequency
noise*: noise volume
oversampling: oversampling amount. increases sound quality, but also increases cpu usage.
q*: filter resonance
type*: oscillator type
vol: the output volume
vol*: oscillator volume
accepts: notes
fmsynth polyphonic fm synthesis
harmratio: harmonic ratio of first-order modulator to input pitch
harmratio2: harmonic ratio of second-order modulator to input pitch
mod: amount to modulate first-order modulator
mod2: amount to modulate second-order modulator
phase0: phase offset for base oscillator
phase1: phase offset for first-order modulator
phase2: phase offset for second-order modulator
tweak: multiplier to harmonic ratio for first-order modulator
tweak2: multiplier to harmonic ratio for second-order modulator
vol: the output volume
accepts: notes
karplusstrong polyphonic plucked string physical modeling synth
feedback: amount of feedback for resonance
filter: amount to filter resonance
invert: should the feedback invert?
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.
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.
source type: audio to use for excitation
vel2env: how much velocity should affect excitation attack time
vel2vol: how much velocity should affect voice volume
vol: output volume
x att: fade in time for excitation audio
x dec: fade out time for excitation audio
x freq: frequency of excitation audio
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
adsr len: view length of ADSR controls
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.
envA: volume envelope attack
envD: volume envelope decay
envR: volume envelope release
envS: volume envelope sustain
envfilterA: filter envelope attack
envfilterD: filter envelope decay
envfilterR: filter envelope release
envfilterS: filter envelope sustain
fmax: frequency cutoff of lowpass filter at the max of the envelope. set this slider to the max to disable the filter
fmin: frequency cutoff of lowpass filter at the min of the envelope
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.
mult: multiply frequency of incoming pitch
osc: oscillator type
phase: phase offset of oscillator, and phase offset between unison voices. useful to patch into with a very fast modulator, to achieve phase modulation.
pw: pulse width (or shape for non-square waves)
q: resonance of lowpass filter
shuffle: stretches and squeezes every other cycle of the waveform
soften: soften edges of square and saw waveforms
syncf: frequency to reset the phase, when "syncmode" is set to "freq"
syncmode: turns on sync mode, to reset the phase at a specified frequency
syncratio: ratio of oscillator frequency to reset the phase, when "syncmode" is set to "ratio"
unison: how many oscillators to play for one note
vel2env: how much should the input velocity affect the speed of the volume and filter envelopes?
vel2vol: how much should the input velocity affect the output volume?
vol: this oscillator's volume
width: controls how voices are panned with unison is greater than 1
accepts: notes
samplecanvas sample arranging view
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
clear: delete all elements
delete: delete highlighted elements
drag mode: direction that elements can be dragged
interval: grid subdivision interval
measures: length of canvas in measures
scrollh: horizontal scrollbar
scrollv: vertical scrollbar
timeline: control loop points
view rows: number of visible rows
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.
16: auto-slice 16 slices
32: auto-slice 32 slices
4: auto-slice 4 slices
8: auto-slice 8 slices
append to rec: when recording, append to the previous recording, rather than clearing the sample first
attack: speed at which gate blends open
click sets cue: when true, clicking on the waveform will set the start position of the current cue
cue len: length in seconds of the current cue. a value of zero will play to the end of the sample.
cue speed: playback speed of the current cue
cue start: start point in seconds of the current cue
cue stop: stop playing this cue if a note-off is received
cuepoint: sets the current cue to edit
grabhovered: grab a sample of this cue to drop onto another module
load: show a file chooser to load a sample
loop: wrap playhead to beginning when it reaches end
pause: pause playing and leave playhead where it is
play: start playing from the current playhead
play cue: play the current cue
playhovered: play this cue
record: record audio input into our sample buffer. clears the current sample.
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
release: speed at which gate blends closed
save: save this sample to a file
searchresult*: click to download this youtube search result. downloading long videos may take a while.
select played: when true, any cue point played via incoming notes will become the current cue
show grid: show a quarter note grid (when zoomed in far enough)
speed: current playback speed
stop: stop playing and reset playhead
threshold: volume threshold to open up the gate for recording
trim: discard all audio outside the current zoom range
volume: output gain
youtube: download the audio of the youtube URL currently on your clipboard
yt:: search youtube for this string
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.
env: volume envelope
envA: volume envelope attack
envD: volume envelope decay
envR: volume envelope release
envS: volume envelope sustain
passthrough: should input audio pass through as we're recording?
pitch: should we attempt pitch-correct the audio?
rec: enable to clear the current recording, and record new audio once the input threshold is reached
thresh: when recording is enabled, exceed this threshold with input audio to begin recording
vol: output volume
accepts: notes audio
seaofgrain granular synth, playable with sliders or MPE input
display length: amount of sample to view
gain *: volume of this voice
keyboard base pitch: midi pitch that represents the start of the sample
keyboard num pitches: amount of pitches to assign across the sample
len ms *: length of each grain in milliseconds
load: load a sample file
octaves *: should we add octaves and fifths?
offset: where to start view of the sample
overlap *: number of overlapping grains
pan *: stereo panorama of grain placement
pos *: position of this voice within the sample
pos r *: randomization of grain start point
record: record input as the granular buffer, to use seaofgrain a live granular delay
spacing r*: randomization of time between grains
speed *: speed of grain playback
speed r *: randomization of grain speed
volume: output volume
width *: stereo width of grain placement
accepts: notes audio
signalgenerator basic oscillator signal. send a note into it to set the frequency, and send a pulse to reset the phase.
detune: amount to detune from specified frequency
freq: signal 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
mult: multiplier for frequency
osc: oscillator type
phase: phase offset
pw: pulse width (or shape for non-square waves)
ramp: amount of time to ramp to input frequency
shuffle: stretches and squeezes every other cycle of the waveform
slider: slider to interpolate between last two input pitches
soften: soften edges of square and saw waveforms
syncf: frequency to reset the phase, when "syncmode" is set to "freq"
syncmode: turns on sync mode, to reset the phase at a specified frequency
syncratio: ratio of oscillator frequency to reset the phase, when "syncmode" is set to "ratio"
vol: output volume
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
audiosplitter send an audio signal to multiple destinations
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.
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.
fourtetslices: chunk size to use for "fourtet" effect
freeze input: retain the current buffer, without writing in new input
grid: patch a grid in here from a "midicontroller" module
interval: slice size
num bars: number of bars to capture
playback style: how to play clicked slices. or, with input notes, velocity range determines playback style.
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.
<: move this effect to earlier in the chain
>: move this effect to later in the chain
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
spawn: spawn the currently highlighted effect
volume: output gain
x: delete this effect
accepts: audio
eq multi-band equalizer, to adjust output levels at frequency ranges
enabled*: enable this band?
f*: frequency cutoff for this band
g*: gain for this band
q*: resonance 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
carrier: carrier signal gain
cut: how many bass partials to remove
dry/wet: how much original input vs vocoded signal to output
fric thresh: fricative detection sensitivity, to switch between using the carrier signal and white noise for vocoding
input: input signal gain
phase off: how much we should offset the phase of the carrier signal's partials
volume: output gain
whisper: how much the carrier signal partial's phases should be randomized, which affects how whispery the output sound is
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.
m : take the contents of this looper and merge it into another. click this button on the merge source, then on the merge target.
.5x: make loop play at half speed
2x: make loop play at double speed
apply: shift the contents of the looper so the current offset is the start of the buffer
auto: should pitch shift auto-adjust as the transport tempo adjusts?
b: bake current volume into waveform
capture: when the next loop begins, record input for the duration of the loop
clear: clear the loop audio
commit: commit the current looperrecorder buffer to this loop
copy: take the contents of this looper and copy it onto another. click this button on the copy source, then on the copy target.
decay: amount to lower volume each loop
extend: make loop twice as long
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.
fourtetslices: chunk size to use for "fourtet" effect
mute: silence this looper
num bars: loop length in measures
offset: amount to offset looper's playhead from transport position
passthrough: should we pass incoming audio through to the output? turn off to mute incoming audio.
pitch: amount to pitch shift looper output
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.
save: save this loop to a wav file
scr: allow loop to be scratched by adjusting "scrspd"
scrspd: playback speed, used with "scr" is enabled. modulate quickly for a vinyl-like scratching effect.
swap: swap the contents of this looper and with another. click this button on two loopers to swap them.
undo: undo last loop commit
volume: output volume
write: write input audio to loop buffer
accepts: notes audio
looperrecorder command center to manage recording into multiple loopers, and allow retroactive loop capture (i.e., always-on recording)
.5tempo: halve global transport tempo, while keeping connected loopers sounding the same
1: capture the last measure to the currently-targeted looper
2: capture the last 2 measures to the currently-targeted looper
2xtempo: double global transport tempo, while keeping connected loopers sounding the same
4: capture the last 4 measures to the currently-targeted looper
8: capture the last 8 measures to the currently-targeted looper
auto-advance: automatically advance to the next looper when committing
cancel free rec: if "free rec" is enabled, cancel recording without setting the loop length
clear: clear the recorded buffer
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"
length: length in measures to use when connected loopers use the "commit" button
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
orig speed: reset looper to tempo that loops were recorded at
resample: resample all connected loopers to new tempo
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
snap to pitch: snap tempo to nearest value that matches a key
target: looper to commit audio to when using the on-buffer capture buttons to the left
write*: writes to this looper, with a loop length matching the nearest power of 2 (1, 2, 4, 8, etc) of how long this checkbox was enabled
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
delay *: tap delay time, in milliseconds
display length: length of buffer display, in seconds
dry: how much dry signal to allow through
feedback *: how much delayed audio from this tap should feed back in to the input
gain *: tap delay amount
pan *: stereo pan for this tap
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.
pan: amount to send signal to the left and right channels. a value of 0 is centered.
widen: delay a channel by this many samples. results in a pan-like effect where the sound seems to come from from a direction.
accepts: audio
ringmodulator modulate a signal's amplitude at a frequency
dry/wet: how much of the original audio to use vs modulated audio
freq: frequency to use. can also be set by patching a note input into this module.
glide: how long an input note should take to glide to the desired frequency
volume: volume output
accepts: notes audio
samplergrid record input onto pads, and play back the pads. intended to be used with an 64-pad grid controller.
clear: when enabled, clears any pressed grid squares
duplicate: what enabled, duplicates last pressed sample onto any pressed grid squares
edit: enable controls to adjust recorded sample for last pressed grid square
end: sample end
grid: patch a grid in here from a "midicontroller" module
passthrough: should the incoming audio pass through to the output?
start: sample start
vol: the output volume
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
16th: 16th note stutter
32nd: 32nd note stutter
64th: 64th note stutter
8th: 8th note stutter
dotted eighth: stutter on a dotted eighth interval
double speed: stutter at double speed, high pitched
free: stutter with the settings specified by the following sliders
free length: length in seconds for "free" stutter mode
free speed: rate for "free" stutter mode
grid: patch a grid in here from a "midicontroller" module
half note: half note stutter
half speed: stutter at half speed, low pitched
quarter: quarter note stutter
ramp in: stutter with speed climbing up from zero to one
ramp out: stutter with speed quickly falling to zero
reverse: reversed half note stutter
triplets: stutter on a triplet interval
tumble down: decelerating stutter
tumble up: accelerating 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.
bands: how many frequency bands to use
carrier: carrier signal gain
f base: frequency for lowest band
f range: frequency range to highest band
input: input signal gain
max band: volume limit for each frequency band
mix: how much original input vs vocoded signal to output
q: resonance of the bands
ring: how long it should take the bands to "cool down"
spacing: how frequency bands should be spaced
volume: output gain
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
draw gain: adjust waveform display scale
freq: frequency to sync display to. gets automatically set if you patch a note input into this module
length: number of samples to capture
accepts: notes audio
waveshaper waveshaping with expressions
a: variable to use in expressions
b: variable to use in expressions
c: variable to use in expressions
d: variable to use in expressions
e: 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
value: output value
velocity: amount to accumulate
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.
gain: multiply incoming audio
max: maximum output value
min: minimum output value
accepts: audio
controlrecorder record and play back changes made to a control
clear: clear the recording
length: the interval to quantize to
quantize: should we quantize playback to a specified rhythmic interval?
record: should we be recording input? playback starts after the recording is complete
speed: speed up or slow down playback
controlsequencer modulate a control step-wise at an interval
interval: rate to advance
length: length of the sequence
random: randomize sequence values
record: record targeted value to steps
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
dataprovider provides modulation values normally not easily accessible.
interval: the interval to measure
realtime: if enabled this module will work on the audio thread which is more accurate but also more resource intense
set: click here to send the value (or, send a pulse to this module for the same result)
type: the type of value to provide
accepts: pulses
envelope modulate a value with a triggered envelope
adsr: envelope view
adsrA: envelope attack
adsrD: envelope decay
adsrR: envelope release
adsrS: envelope sustain
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.
has sustain: should this envelope have a sustain stage?
high: output high value
length: length of envelope display
low: output low value
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?
use velocity: should envelope output be scaled by input velocity?
accepts: pulses notes
expression shape modulation with a text-based mathematical expression
a: variable to use in expressions
b: variable to use in expressions
c: variable to use in expressions
d: variable to use in expressions
e: variable to use in expressions
input: input to use as x variable
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.
fubble draw on an X/Y pad and replay the drawing to modulate values. based on a concept proposed by olivia jack
clear: clear the drawing
length: the interval to quantize to
mutate amount: amount to affect drawing by perlin noise field
mutate noise: rate to move through perlin noise field
mutate warp: scale of perlin noise field
quantize: should we quantize playback to a specified rhythmic interval?
reseed: jump to a different location in the perlin noise field
speed: speed up or slow down playback
gravity make a modulation value rise and fall with physics
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)
kick amt: the amount of upward force to apply when kicking
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
attack: rise to the input level at this rate
gain: multiply the input audio by this value
max: output when level is one
min: output when level is zero
release: decay from the input level at this rate
accepts: audio
lfo modulates a slider with a low-frequency oscillator
bias: bias the waveform towards the low or high point
enable: turn on/off modulation
free rate: rate of oscillator running in non-clock-synced time
high: output value at waveform's high point
interval: length of oscillation period
length: proportion of time that should be spent on the waveform cycle
lite cpu: only recalculate some parameters once per buffer, to reduce CPU load. can sound worse in some scenarios, especially with rapid modulation.
low: output value at waveform's low point
offset: phase offset, to make oscillation earlier/later
osc: type of oscillation waveform
pin: make LFO window remain visible
shuffle: adjust the waveoform to have a fast and slow cycle
soften: smooth out the hard edges of square and saw waveforms
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
end*: the output value at the top of the input's range
input: the input value. intended to be a modulation patch target.
start*: the output value at the bottom 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
pitchtovalue output midi pitch value
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
length: length of time to blend over
start: begin blending (or, send a pulse to this module for the same result)
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
set: click here to send the value (or, send a pulse to this module for the same result)
slider: value to set
value: value to set
accepts: pulses
velocitytocv take a note's velocity and convert it to a modulation value
0 at note off: output zero when note is released
max: output for velocity 127
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
*: generate a new random seed
<: go to previous seed
>: go to next seed
chance: chance that pulses are allowed through
deterministic: allow for randomness to be repeated over an interval
seed: number that determines the random sequence. send reset pulses to restart the deterministic random sequence.
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
*: generate a new random seed
<: go to previous seed
>: go to next seed
seed: number that determines the random sequence. send reset pulses to restart the deterministic random sequence.
weight *: chance that pulse goes to this destination
accepts: pulses
pulselimit limit the number of pulses allowed to pass through
limit: limit number of pulses to pass through
reset: reset the counter of seen pulses
accepts: pulses
pulser send pulse messages at an interval
div: measure division, when using "div" as the interval
interval: rate to send pulses
offset: pulse time offset, in fractions of the interval
random: tell pulsed modules to randomize their position
reset: length of sequence before sending reset pulse
restart: restart timer on "free" counter
t: pulse interval in milliseconds
timemode: when to send downbeat pulses, or set to "free" for pulses not locked to the transport
pulserouter allows you to control where pulses are routed to using a UI control. to add destinations to the list, patch them as a target
route: the pulserouter's destination module
accepts: pulses
pulsesequence defines a looping sequence of pulses
- : advance the sequence backwards
+: advance the sequence forward
<: shift sequence to the left
>: shift sequence to the right
interval: length of each step within the sequence
length: length of the sequence
pulse: when enabled will send out pulses as per sequence when advancing with the buttons
accepts: pulses
pulsetrain defines a list of pulses to execute, once pulsed
interval: length of each step within the sequence
length: length of the sequence
accepts: pulses

## effect chain

basiceq simple multiband EQ
even: reset EQ
accepts: audio
biquad filter using biquad formula
F: frequency cutoff
G: gain
Q: resonance
type: filter type
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
F: frequency cutoff
Q: resonance
accepts: audio
compressor try to keep volume at a certain level
attack: speed to apply gain reduction
drive: rescale input to affect how much compression affects it
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.
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.
output: makeup gain, to increase volume
ratio: how much gain reduction to apply when the single passes the threshold
release: speed to remove gain reduction
threshold: threshold where gain should start to be reduced
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
amount: amount of delay that returns
delay: delay in milliseconds
dry: should the dry signal pass through, or just the delayed signal?
feedback: should the output audio feed back into the delay?
input: should we accept input into the delay?
interval: sets delay length to a musical duration
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.
short: shortcut to shrink the range of the delay slider, to allow for audible-rate delays and comb filter sounds
accepts: audio
distortion waveshaping distortion
center input: remove dc offset from input signal to distort in a more controlled way
clip: cutoff point of distortion, lower values result in more extreme distortion
fuzz: push input signal off-center to distort asymmetrically
preamp: signal gain before feeding into distortion
type: style of distortion to apply
accepts: audio
freeverb reverb using the "freeverb" algorithm
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
dry: amount of untouched signal
room size: controls the length of the reverb, a higher value means longer reverb
wet: amount of reverb signal
width: stereo width of reverb
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.
attack: speed at which gate blends open
release: speed at which gate blends closed
threshold: volume threshold to open up the gate
accepts: audio
granulator granulate live input
autocapture: freeze input at this interval
dry: amount of dry signal to allow through
frz: freeze the current recorded buffer
g oct: should we add octaves and fifths?
len ms: length of each grain in milliseconds
overlap: number of overlapping grains
pos: playback position within the buffer
pos r: randomization of grain start point
spa r: randomization of time between grains
spd r: randomization of grain speed
speed: speed of grain playback
width: stereo width of grain placement
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
amount: amount of noise to apply
width: how frequently a new noise sample should be chosen
accepts: audio
pitchshift shifts a signal's pitch
ratio: amount to pitchshift by (a value of 1 indicates no shift)
ratioselector: shortcuts to useful pitch ratios
accepts: audio
pumper dip the volume of a signal rhythmically, to emulate a "pumping sidechain" effect
amount: amount to lower volume
attack: how sharply the volume drops
curve: how the volume returns
interval: the rate to pump
length: length of pump
accepts: audio
tremolo modulate signal's volume rhythmically
amount: amount to lower volume
duty: pulse width of LFO
interval: speed of LFO
offset: offsets LFO phase
osc: LFO oscillator type
accepts: audio

## other

abletonlink synchronizes transport with software and devices that support ableton link
offset ms: offset in milliseconds to tweak synchronization
reset next downbeat: resets measure count on the next downbeat, to help synchronize to desired phase in session
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
smoothing: how much to smooth incoming tempo
start offset ms: offset in milliseconds to tweak synchronization between bespoke and gear
clockout sends out clock pulses to synchronize external midi devices
device: device to target
multiplier: tempo multiplier for how the gear should respond to the signals
send start: send a signal to reset the gear to the start of its sequence
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
clear: delete all elements
delete: delete highlighted elements
drag mode: direction that elements can be dragged
interval: grid for snapping events to
measures: length of loop
quantize: quantizes events to grid
record: record connected values as they change
scrollh: horizontal scrollbar
timeline: control loop points
view rows: number of visible rows
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 b: amount of blue in background color
background g: amount of green in background color
background r: amount of red in background color
cable alpha: opacity of the cables
corner radius: how round bespoke's rectangles are
lissajous b: amount of blue in background lissajous curve
lissajous g: amount of green in background lissajous curve
lissajous r: amount of red in background lissajous curve
scroll x: emulate horizontal mouse scrolling
scroll y: emulate vertical mouse scrolling
x pos: horizontal panning position
y pos: vertical panning position
zoom: zoom level
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
label A module to display a label, helpful in marking what is where in large patches
color: The color of the label
font: The font of the label
label: The label that will be displayed
showcontrols: Hide and show the controls to modify the label
size: The font size of the label
loopergranulator use with a "looper" module to play the contents with granular synthesis
freeze: stop advancing looper time
len ms: length of each grain in milliseconds
loop pos: playback position within loop
octaves: should we add octaves and fifths?
on: use granular synthesis for looper playback
overlap: number of overlapping grains
pos rand: randomization of grain start point
spacing rand: randomization of time between grains
speed: speed of grain playback
speed rand: randomization of grain speed
width: stereo width of grain placement
multitrackrecorder record several synchronized tracks of audio, to write to disk for mixing in an external DAW
add track: add an additional track
bounce: write the tracks to your recordings directory
clear: clear the audio in the tracks
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
label*: label to send slider value. the message will be sent in the format /bespoke/[label] [value]
note out address: label to send input notes. the message will be sent in the format /bespoke/[label] [pitch] [velocity]
osc out address: destination to send OSC messages to
osc out port: port to send OSC messages to
slider*: sends a value to the address. try patching a modulator into this, such as a leveltocv module to send audio levels.
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.
disband: free all modules from this prefab
load: load a .pfb
save: save as a .pfb file
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.
grid: patch a grid in here from a "midicontroller" module
interval: rate to advance
length: length of sequence
accepts: pulses notes
samplebrowser browse your system for samples. drag samples from here to your desired targets (sampleplayer, drumplayer, seaofgrain, etc)
< : previous page
> : next page
savestateloader loads other savestate files (and unloads the current savestate). the number of buttons can be adjusted in the triangle menu.
load *: loads specified savestate file. shift-click to choose a new file.
scale controls the global scale used by various modules
PPO: pitches per octave
intonation: which method to use to tune the scale
load KBM: load KBM file to determine keyboard mapping
load SCL: load SCL file to determine scale
note: the pitch that maps to the frequency defined in "tuning"
root: root note of the scale
scale: which set of notes to use
tuning: what frequency does the pitch defined in "note" represent?
script python scripting for livecoding notes and module control
?: show scripting reference
a: variable for the script to use, can be modulation by other sources. access via me.get("a")
b: variable for the script to use, can be modulation by other sources. access via me.get("b")
c: variable for the script to use, can be modulation by other sources. access via me.get("c")
code: write code here. press ctrl-R to execute the code, or ctrl-shift-R to just execute the current block.
d: variable for the script to use, can be modulation by other sources. access via me.get("d")
load: load selected script
loadscript: choose a script from here, then press "load"
run: click here to execute the code, or press ctrl-R
save as: save the current script
stop: cancel any events scheduled by this script
style: choose a text theme, from script_styles.json
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 snapshot to that square, and click on a grid square to load that snapshot. alt/option-click to delete a snapshot, and ctrl/command-click to rename a snapshot.
add: snapshot the currently connected controls to the next available snapshot slot
blend: length of time in milliseconds over which to blend snapshot values
delete: when clicking/selecting a snapshot, delete that slot (alternately: hold the alt/option key)
random: randomize connected controls
snapshot: jump to a snapshot
snapshot label: assign a label to this snapshot
store: when clicking/selecting a snapshot, store into that slot (alternately: hold the shift key)
accepts: notes
songbuilder large-scale organizer to arrange settings into scenes and then sequence them. this is bespoke's "song mode"
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.
add target: add a targeted control for scenes to affect
bars*: length in bars that this scene should play for
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.
checkbox*: value to use for target in this scene
color*: color to theme this target
context*: options for this scene
contextmenu*: options for this step
dropdown*: value to use for target in this scene
go*: play this scene
loop: enable a loop within the sequence
loop end: loop step index that the loop ends
loop start: loop step index to start the loop on
move left: move this target left in the scene
move right: move this target right in the scene
name*: name of this scene
pause: hold the sequence on the current scene
play: play the sequence
play from*: play sequence from this step
scene*: name of scene for this step
stop: stop the sequence
type: change the control display type for this target
use sequencer: show scene sequencer
value*: value to use for target in this scene
accepts: pulses notes
timelinecontrol control global transport position
dock: should we dock this module to the UI layer?
length: length of timeline display, in measures
loop: should we have a looping section?
loop end: measure end of loop
loop start: measure start of loop
measure: current position. click to jump around.
reset: reset to beginning
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
+ : increase tempo by one
- : decrease tempo by one
< : nudge current time backward
> : nudge current time forward
play/pause: stop all audio processing (shift-p)
reset: reset timeline to zero
swing: where the halfway point of musical time within the swing interval should fall. a value of .5 represents no swing.
swing interval: interval over which to apply swing
tempo: global tempo, in beats per minute
timesigbottom: time signature bottom value
timesigtop: time signature top value
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