word to include a tag containing the word, -word to exclude. Prefix with m: for modules, kind:(note|control|pitch|val) for call kinds, or type:(val|generator|transformer) for call types.
You can also search by %control, arg default (name-arg), and call kind (note, control, ...).
Search for calls with the browser's text search, "call --" to search by binding, "-- call" to search by name.
Common tags are documented at 'Derive.Call.Tags'.

note

' -- ngoret
bali.gangsa : note generator
'- -- ngoret
'^ -- ngoret
'_ -- ngoret: Insert an intermediate grace note in the "ngoret" style. The grace note moves up for '^, down for '_, or is based on the previous note's pitch for '.
This requires the realize-ngoret postproc.
Tags: inst, ornament, requires-postproc
time :: time signal (default real) = .1 [*-time] — Time between the grace note start and the main note. If there isn't enough room after the previous note, it will be halfway between the previous note and this one.
damp :: time signal (default real) = .15s [*-damp] — Time that the grace note overlaps with this one. So the total duration is time+damp, though it will be clipped to the end of the current note.
dyn :: Signal = .75 [*-dyn] — The grace note's dyn will be this multiplier of the current dyn.
damp-threshold^env :: Signal (RealTime) = .15 [*-damp-threshold] — A grace note with this much time will cause the previous note to be shortened to not overlap. Under the threshold, and the damping of the previous note will be delayed until the end of the grace note.
'n -- ngoret
bali.gangsa : note generator: Insert an intermediate grace note in the "ngoret" style. The grace note moves up for '^, down for '_, or is based on the previous note's pitch for '.
This requires the realize-ngoret postproc.
Tags: inst, ornament, requires-postproc
interval :: Signal (Transposition, default diatonic) [*-interval] — The grace note is this interval from the destination pitch.
time :: time signal (default real) = .1 [*-time] — Time between the grace note start and the main note. If there isn't enough room after the previous note, it will be halfway between the previous note and this one.
damp :: time signal (default real) = .15s [*-damp] — Time that the grace note overlaps with this one. So the total duration is time+damp, though it will be clipped to the end of the current note.
dyn :: Signal = .75 [*-dyn] — The grace note's dyn will be this multiplier of the current dyn.
damp-threshold^env :: Signal (RealTime) = .15 [*-damp-threshold] — A grace note with this much time will cause the previous note to be shortened to not overlap. Under the threshold, and the damping of the previous note will be delayed until the end of the grace note.
cancel-pasang -- cancel-pasang
bali.gangsa : note transformer: This is like the cancel call, except it also knows how to cancel out pasang instruments such that adjacent kotekan calls can have initial and final notes, but won't get doubled notes.
Tags: postproc
final-duration :: Signal (RealTime) = 1s [final-duration] — If there is no following note, infer this duration.
f- -- f- bali.gangsa : note transformer: final = f. Kotekan calls won't emit a final note at the end time.
gnorot -- gender-norot
bali.gangsa : note generator: Gender-style norot.
Tags: inst
kotekan-dur^env :: Signal (ScoreTime) = "(ts s) [kotekan-dur] — Duration of derived notes.
kotekan^env :: untyped signal = .15s [kotekan] — If note durations are below this, divide the parts between polos and sangsih.
inst-polos^env :: Str [inst-polos] — Polos instrument.
inst-sangsih^env :: Str [inst-sangsih] — Sangsih instrument.
initial^env :: Maybe Str (f t) = _ [initial] — If true, include an initial note, which is the same as the final note. This is suitable for the start of a sequence of kotekan calls. If not given, infer false for negative duration, true for positive.
final^env :: Str (f t) = t [final] — If true, include the final note, at the event end.
i+ -- i+ bali.gangsa : note transformer: initial = t. Kotekan calls will emit a note on the initial beat.
i- -- i- bali.gangsa : note transformer: initial = f. Kotekan calls won't emit a note on the initial beat.
k -- kotekan
bali.gangsa : note generator
k^ -- kotekan: Render a kotekan pattern from a kernel representing the polos. The sangsih is inferred.
Kotekan calls perform a pattern with inst-polos and inst-sangsih. They line up at the end of the event but may also emit a note at the start of the event, so use cancel-pasang to cancel the extra notes. Ngubeng kotekan is naturally suited to positive duration, while majalan is suited to negative duration.
Tags: inst
kernel :: Str = k-12-1-21 [kernel, *-kernel] — Polos part in transposition steps. This will be normalized to end on the destination pitch. It should consist of -, 1, and 2. You can start with k to avoid needing quotes. Starting with k will also require the length to be a multiple of 4.
style :: Str (telu pat) = telu [style, *-style] — Kotekan style.
sangsih :: Maybe Str (u d) = _ [sangsih, *-sangsih] — Whether sangsih is above or below polos. If not given, sangsih will be above if the polos ends on a low note or rest, below otherwise.
kotekan-dur^env :: Signal (ScoreTime) = "(ts s) [kotekan-dur] — Duration of derived notes.
kotekan^env :: untyped signal = .15s [kotekan] — If note durations are below this, divide the parts between polos and sangsih.
inst-polos^env :: Str [inst-polos] — Polos instrument.
inst-sangsih^env :: Str [inst-sangsih] — Sangsih instrument.
initial^env :: Maybe Str (f t) = _ [initial] — If true, include an initial note, which is the same as the final note. This is suitable for the start of a sequence of kotekan calls. If not given, infer false for negative duration, true for positive.
final^env :: Str (f t) = t [final] — If true, include the final note, at the event end.
k+ -- kempyung
bali.gangsa : note generator
kempyung -- kempyung: Split part into kempyung, with polos-inst below and sangsih-inst above. If the sangsih would go out of range, it's forced into unison.
If there are notes in child tracks, apply the transformation to them. Otherwise apply the transformation to the null note call.
Tags: postproc, subs
inst-top^env :: Maybe NotePitch = _ [inst-top] — Top pitch this instrument can play. Normally the instrument sets it via the instrument environ.
inst-polos^env :: Str [inst-polos] — Polos instrument.
inst-sangsih^env :: Str [inst-sangsih] — Sangsih instrument.
k+ -- kempyung
bali.gangsa : note transformer
kempyung -- kempyung: Split part into kempyung, with polos-inst below and sangsih-inst above. If the sangsih would go out of range, it's forced into unison.
Tags: postproc
inst-top^env :: Maybe NotePitch = _ [inst-top] — Top pitch this instrument can play. Normally the instrument sets it via the instrument environ.
inst-polos^env :: Str [inst-polos] — Polos instrument.
inst-sangsih^env :: Str [inst-sangsih] — Sangsih instrument.
k-\ -- kotekan
bali.gangsa : note generator
k//\\ -- kotekan
k_\ -- kotekan: Render a kotekan pattern where both polos and sangsih are explicitly specified. This is for irregular patterns.
Kotekan calls perform a pattern with inst-polos and inst-sangsih. They line up at the end of the event but may also emit a note at the start of the event, so use cancel-pasang to cancel the extra notes. Ngubeng kotekan is naturally suited to positive duration, while majalan is suited to negative duration.
Tags: inst
style :: Str (telu pat) = pat [style, *-style] — Kotekan style.
kotekan-dur^env :: Signal (ScoreTime) = "(ts s) [kotekan-dur] — Duration of derived notes.
kotekan^env :: untyped signal = .15s [kotekan] — If note durations are below this, divide the parts between polos and sangsih.
inst-polos^env :: Str [inst-polos] — Polos instrument.
inst-sangsih^env :: Str [inst-sangsih] — Sangsih instrument.
initial^env :: Maybe Str (f t) = _ [initial] — If true, include an initial note, which is the same as the final note. This is suitable for the start of a sequence of kotekan calls. If not given, infer false for negative duration, true for positive.
final^env :: Str (f t) = t [final] — If true, include the final note, at the event end.
k// -- kotekan
bali.gangsa : note generator
k\\ -- kotekan: Render a kotekan pattern where both polos and sangsih are explicitly specified. This is for irregular patterns.
Kotekan calls perform a pattern with inst-polos and inst-sangsih. They line up at the end of the event but may also emit a note at the start of the event, so use cancel-pasang to cancel the extra notes. Ngubeng kotekan is naturally suited to positive duration, while majalan is suited to negative duration.
Tags: inst
style :: Str (telu pat) = telu [style, *-style] — Kotekan style.
kotekan-dur^env :: Signal (ScoreTime) = "(ts s) [kotekan-dur] — Duration of derived notes.
kotekan^env :: untyped signal = .15s [kotekan] — If note durations are below this, divide the parts between polos and sangsih.
inst-polos^env :: Str [inst-polos] — Polos instrument.
inst-sangsih^env :: Str [inst-sangsih] — Sangsih instrument.
initial^env :: Maybe Str (f t) = _ [initial] — If true, include an initial note, which is the same as the final note. This is suitable for the start of a sequence of kotekan calls. If not given, infer false for negative duration, true for positive.
final^env :: Str (f t) = t [final] — If true, include the final note, at the event end.
k//2 -- kotekan
bali.gangsa : note generator
k//^ -- kotekan
k\\2 -- kotekan: Render a kotekan pattern from a kernel representing the polos. The sangsih is inferred.
Kotekan calls perform a pattern with inst-polos and inst-sangsih. They line up at the end of the event but may also emit a note at the start of the event, so use cancel-pasang to cancel the extra notes. Ngubeng kotekan is naturally suited to positive duration, while majalan is suited to negative duration.
Tags: inst
style :: Str (telu pat) = telu [style, *-style] — Kotekan style.
sangsih :: Maybe Str (u d) = _ [sangsih, *-sangsih] — Whether sangsih is above or below polos. If not given, sangsih will be above if the polos ends on a low note or rest, below otherwise.
kotekan-dur^env :: Signal (ScoreTime) = "(ts s) [kotekan-dur] — Duration of derived notes.
kotekan^env :: untyped signal = .15s [kotekan] — If note durations are below this, divide the parts between polos and sangsih.
inst-polos^env :: Str [inst-polos] — Polos instrument.
inst-sangsih^env :: Str [inst-sangsih] — Sangsih instrument.
initial^env :: Maybe Str (f t) = _ [initial] — If true, include an initial note, which is the same as the final note. This is suitable for the start of a sequence of kotekan calls. If not given, infer false for negative duration, true for positive.
final^env :: Str (f t) = t [final] — If true, include the final note, at the event end.
ke -- kotekan
bali.gangsa : note generator: Render a kotekan pattern from explicit polos and sangsih parts.
Tags: inst
polos :: Str [*-polos] — Polos part.
sangsih :: Str [*-sangsih] — Sangsih part.
kotekan-dur^env :: Signal (ScoreTime) = "(ts s) [kotekan-dur] — Duration of derived notes.
inst-polos^env :: Str [inst-polos] — Polos instrument.
inst-sangsih^env :: Str [inst-sangsih] — Sangsih instrument.
kotekan -- kotekan
bali.gangsa : note generator: Render a kotekan pattern from a kernel. The sangsih part is inferred.
Kotekan calls perform a pattern with inst-polos and inst-sangsih. They line up at the end of the event but may also emit a note at the start of the event, so use cancel-pasang to cancel the extra notes. Ngubeng kotekan is naturally suited to positive duration, while majalan is suited to negative duration.
Tags: inst
rotation :: Signal (integral) = 0 [*-rotation] — Rotate kernel to make a different pattern.
style :: Str (telu pat) = telu [style, *-style] — Kotekan style.
sangsih :: Str (u d) = u [sangsih, *-sangsih] — Whether sangsih is above or below polos.
invert^env :: Str (f t) = f [*-invert] — Flip the pattern upside down.
kernel^env :: Str [kernel, *-kernel] — Polos part in transposition steps. This will be normalized to end on the destination pitch. It should consist of -, 1, and 2. You can start with k to avoid needing quotes. Starting with k will also require the length to be a multiple of 4.
kotekan-dur^env :: Signal (ScoreTime) = "(ts s) [kotekan-dur] — Duration of derived notes.
kotekan^env :: untyped signal = .15s [kotekan] — If note durations are below this, divide the parts between polos and sangsih.
inst-polos^env :: Str [inst-polos] — Polos instrument.
inst-sangsih^env :: Str [inst-sangsih] — Sangsih instrument.
initial^env :: Maybe Str (f t) = _ [initial] — If true, include an initial note, which is the same as the final note. This is suitable for the start of a sequence of kotekan calls. If not given, infer false for negative duration, true for positive.
final^env :: Str (f t) = t [final] — If true, include the final note, at the event end.
noltol -- noltol
bali.gangsa : note transformer: Play the transformed notes in noltol style. If the space between notes of the same (instrument, hand) is above a threshold, end the note with a +muted copy of itself. This only happens if the duration of the note is at or below the kotekan-dur.
Tags: delayed
time :: untyped signal = .1 [*-time] — Play noltol if the time available exceeds this threshold.
damp-dyn :: Signal = .65 [*-damp-dyn] — Damped notes are multiplied by this dyn.
kotekan-dur^env :: Signal (ScoreTime) = "(ts s) [kotekan-dur] — Duration of derived notes.
norot -- norot
bali.gangsa : note generator
nt -- norot
nt- -- norot
nt< -- norot
nt<- -- norot: Emit the basic norot pattern. Normally it will prepare for the next pitch if it touches the next note, the nt- variant will suppress that. The nt< variant will also emit a preparation at the note's start.
Tags: inst
style :: Str (default diamond) = default [*-style] — Norot style.
kotekan-dur^env :: Signal (ScoreTime) = "(ts s) [kotekan-dur] — Duration of derived notes.
kotekan^env :: untyped signal = .15s [kotekan] — If note durations are below this, divide the parts between polos and sangsih.
inst-top^env :: Maybe NotePitch = _ [inst-top] — Top pitch this instrument can play. Normally the instrument sets it via the instrument environ.
inst-polos^env :: Str [inst-polos] — Polos instrument.
inst-sangsih^env :: Str [inst-sangsih] — Sangsih instrument.
initial^env :: Maybe Str (f t) = _ [initial] — If true, include an initial note, which is the same as the final note. This is suitable for the start of a sequence of kotekan calls. If not given, infer false for negative duration, true for positive.
final^env :: Str (f t) = t [final] — If true, include the final note, at the event end.
nyog -- nyog
bali.gangsa : note generator: Nyog cag style. Split a single part into polos and sangsih parts by assigning polos and sangsih to alternating notes.
If there are notes in child tracks, apply the transformation to them. Otherwise apply the transformation to the null note call.
Tags: postproc, subs
inst-polos^env :: Str [inst-polos] — Polos instrument.
inst-sangsih^env :: Str [inst-sangsih] — Sangsih instrument.
nyog -- nyog
bali.gangsa : note transformer: Nyog cag style. Split a single part into polos and sangsih parts by assigning polos and sangsih to alternating notes.
Tags: postproc
inst-polos^env :: Str [inst-polos] — Polos instrument.
inst-sangsih^env :: Str [inst-sangsih] — Sangsih instrument.
p+ -- p+ bali.gangsa : note generator
ps+ -- ps+
s+ -- s+: Derive the note with polos, sangsih, or both.
If there are notes in child tracks, apply the transformation to them. Otherwise apply the transformation to the null note call.
Tags: inst, subs
inst-polos^env :: Str [inst-polos] — Polos instrument.
inst-sangsih^env :: Str [inst-sangsih] — Sangsih instrument.
p+ -- p+ bali.gangsa : note transformer
ps+ -- ps+
s+ -- s+: Derive the note with polos, sangsih, or both.
Tags: inst
inst-polos^env :: Str [inst-polos] — Polos instrument.
inst-sangsih^env :: Str [inst-sangsih] — Sangsih instrument.
realize-gangsa -- realize-gangsa
bali.gangsa : note transformer: Combine the gangsa realize calls in the right order.
A static macro for: realize-noltol | cancel-pasang $ | realize-ngoret.
Each $ is lifted to be an argument of this macro.
This directly calls the underlying sub-calls, so it's not dependent on the names they are bound to, which also means the macro text may not be a valid expression.
Tags: postproc
final-duration :: Signal (RealTime) = 1s [final-duration] — If there is no following note, infer this duration.
realize-ngoret -- realize-ngoret
bali.gangsa : note transformer: Realize pitches and positions emited by the ngoret call. This is necessary because it needs to know the positions and pitches of the previous and next notes, and those aren't necessarily available when evaluating the track. This call needs a hand envron to figure out which which note follows which.
Tags: inst, postproc
realize-noltol -- realize-noltol
bali.gangsa : note transformer: Perform the annotations added by noltol.
Tags: realize-delayed
unison -- unison
bali.gangsa : note transformer: Split part into unison polos and sangsih. Emit only polos if only=polos and only sangsih if only=sangsih.
Tags: postproc
inst-polos^env :: Str [inst-polos] — Polos instrument.
inst-sangsih^env :: Str [inst-sangsih] — Sangsih instrument.
' -- ngoret
bali.gender : note generator
'- -- ngoret
'^ -- ngoret
'_ -- ngoret: Insert an intermediate grace note in the "ngoret" style. The grace note moves up for '^, down for '_, or is based on the previous note's pitch for '.
This requires the realize-ngoret postproc.
Tags: inst, ornament, requires-postproc
time :: time signal (default real) = .1 [*-time] — Time between the grace note start and the main note. If there isn't enough room after the previous note, it will be halfway between the previous note and this one.
damp :: time signal (default real) = .5s [*-damp] — Time that the grace note overlaps with this one. So the total duration is time+damp, though it will be clipped to the end of the current note.
dyn :: Signal = .75 [*-dyn] — The grace note's dyn will be this multiplier of the current dyn.
damp-threshold^env :: Signal (RealTime) = .15 [*-damp-threshold] — A grace note with this much time will cause the previous note to be shortened to not overlap. Under the threshold, and the damping of the previous note will be delayed until the end of the grace note.
'n -- ngoret
bali.gender : note generator: Insert an intermediate grace note in the "ngoret" style. The grace note moves up for '^, down for '_, or is based on the previous note's pitch for '.
This requires the realize-ngoret postproc.
Tags: inst, ornament, requires-postproc
interval :: Signal (Transposition, default diatonic) [*-interval] — The grace note is this interval from the destination pitch.
time :: time signal (default real) = .1 [*-time] — Time between the grace note start and the main note. If there isn't enough room after the previous note, it will be halfway between the previous note and this one.
damp :: time signal (default real) = .5s [*-damp] — Time that the grace note overlaps with this one. So the total duration is time+damp, though it will be clipped to the end of the current note.
dyn :: Signal = .75 [*-dyn] — The grace note's dyn will be this multiplier of the current dyn.
damp-threshold^env :: Signal (RealTime) = .15 [*-damp-threshold] — A grace note with this much time will cause the previous note to be shortened to not overlap. Under the threshold, and the damping of the previous note will be delayed until the end of the grace note.
realize-ngoret -- realize-ngoret
bali.gender : note transformer: Realize pitches and positions emited by the ngoret call. This is necessary because it needs to know the positions and pitches of the previous and next notes, and those aren't necessarily available when evaluating the track. This call needs a hand envron to figure out which which note follows which.
Tags: inst, postproc
weak -- weak
bali.gender : note generator: Weak notes are filler notes.
Tags: inst
strength :: Signal = .5 [strength] — From low strength to high, omit the note, then play it muted, and then play it open but softly.
infer-damp-simple -- infer-damp-simple
bali.gender.im : note transformer: Simple gender damping. Duration is extended if the next note on the same hand has the same pitch and the gap is < .15s.
Tags: postproc
insts :: list of Str [*-insts] — Apply damping to these instruments.
C -- calung
bali.gong : note transformer: Add a calung note with 'Derive.Flags.infer_duration' and the same pitch, transposed into the calung range.
Tags: inst, under-invert
octave :: Str (u d) = d [*-octave] — If the pitch exists in multiple octaves, choose this one.
insts^env :: list of Str = (list calung-p calung-s) [*-insts] — Instruments.
cycle -- cycle
bali.gong : note generator: Cycle calls. Align to the end for negative duration.
Tags: inst
strokes :: Str or list of Quoted [*-strokes] — Cycle these strokes.
dur :: Str (section w h q e s t32 t64 t128 t256) or Signal (Time, default score) [*-dur] — Duration of each stroke. A string is taken as a timestep.
J -- jegog
bali.gong : note transformer: Add a jegog note with 'Derive.Flags.infer_duration' and the same pitch, transposed into the jegog range.
Tags: inst, under-invert
octave :: Str (u d) = d [*-octave] — If the pitch exists in multiple octaves, choose this one.
insts^env :: list of Str = (list jegog-p jegog-s) [*-insts] — Instruments.
nruk -- nruk
bali.gong : note transformer: Nruktuk, for kajar or gangsa.
Tags: inst
start :: Signal (Time) = 4s [*-start] — Start speed.
end :: Signal (Time) = 19s [*-end] — End speed.
end-dyn :: Signal = .15 [*-end-dyn] — Dyn multiplier when the stroke duration reaches 0.
hold^env :: Signal (Time, default real) = 0s [hold, *-hold] — Time to hold the first note.
pokok -- pokok
bali.gong : note transformer: Add a pokok note with 'Derive.Flags.infer_duration' and the same pitch, transposed into the appropriate range.
Tags: inst, under-invert
octave :: Str (u d) = d [*-octave] — Which to choose if the pitch exists in multiple octaves.
insts^env :: list of Str [*-insts] — Instruments.
bottom^env :: NotePitch [*-bottom] — Bottom of the range.
top^env :: NotePitch [*-top] — Top of the range.
' -- ngoret
bali.reyong : note generator
'- -- ngoret
'^ -- ngoret
'_ -- ngoret: Insert an intermediate grace note in the "ngoret" style. The grace note moves up for '^, down for '_, or is based on the previous note's pitch for '.
This requires the realize-ngoret postproc.
Tags: inst, ornament, requires-postproc
time :: time signal (default real) = .1 [*-time] — Time between the grace note start and the main note. If there isn't enough room after the previous note, it will be halfway between the previous note and this one.
dyn :: Signal = .75 [*-dyn] — The grace note's dyn will be this multiplier of the current dyn.
damp-threshold^env :: Signal (RealTime) = .15 [*-damp-threshold] — A grace note with this much time will cause the previous note to be shortened to not overlap. Under the threshold, and the damping of the previous note will be delayed until the end of the grace note.
'n -- ngoret
bali.reyong : note generator: Insert an intermediate grace note in the "ngoret" style. The grace note moves up for '^, down for '_, or is based on the previous note's pitch for '.
This requires the realize-ngoret postproc.
Tags: inst, ornament, requires-postproc
interval :: Signal (Transposition, default diatonic) [*-interval] — The grace note is this interval from the destination pitch.
time :: time signal (default real) = .1 [*-time] — Time between the grace note start and the main note. If there isn't enough room after the previous note, it will be halfway between the previous note and this one.
dyn :: Signal = .75 [*-dyn] — The grace note's dyn will be this multiplier of the current dyn.
damp-threshold^env :: Signal (RealTime) = .15 [*-damp-threshold] — A grace note with this much time will cause the previous note to be shortened to not overlap. Under the threshold, and the damping of the previous note will be delayed until the end of the grace note.
+ -- byut
bali.reyong : note generator
- -- byut-loose
/ -- cek-loose
// -- cek-loose
O -- byong
X -- cek
XX -- cek: Reyong articulation. The doubled variants emit two notes, and rely on start time randomization so they're not exactly simultaneous.
Tags: inst
voices^env :: list of Signal (integral) = (list) [voices, *-voices] — Only emit notes for these positions, from 1 to 4. Empty means all of them.
: -- pitches
bali.reyong : note generator: Play notes for each pitch: (list (pitch 4 2) (pitch 5 0)). Really only for 4e and 5i for the penyorog.
Tags: inst
>kilit -- reyong
bali.reyong : note generator
k//\\ -- reyong
k_\ -- reyong
kilit -- reyong: Emit reyong pattern.
Tags: inst
kotekan-dur^env :: Signal (ScoreTime) = "(ts s) [kotekan-dur] — Duration of derived notes.
initial^env :: Maybe Str (f t) = _ [initial] — If true, include an initial note, which is the same as the final note. This is suitable for the start of a sequence of kotekan calls. If not given, infer false for negative duration, true for positive.
final^env :: Str (f t) = t [final] — If true, include the final note, at the event end.
voices^env :: list of Signal (integral) = (list) [voices, *-voices] — Only emit notes for these positions, from 1 to 4. Empty means all of them.
a -- tumpuk-auto
bali.reyong : note generator: A variant of tumpuk that randomly picks a pattern.
Tags: inst
place^env :: Signal (0 <= x <= 1) = 1 [place, *-place] — At 0, grace notes fall before their base note. At 1, grace notes fall on the base note, and the base note is delayed.
cancel-kotekan -- cancel-kotekan
bali.reyong : note transformer: This is like the cancel call, except it understands flags set by kotekan, and cancels based on reyong voice.
Tags: postproc
final-duration :: Signal (RealTime) = 1s [final-duration] — If there is no following note, infer this duration.
hand-damp -- hand-damp
bali.reyong : note transformer: Damping when the parts are already divided by hand.
Tags: postproc
insts :: list of Str [*-insts] — Apply damping to these instruments.
dur :: realtime signal = .15s [*-dur] — There must be at least this much time between the end of a note and the start of the next to damp.
infer-damp -- infer-damp
bali.reyong : note transformer: Add damping for reyong parts based on a simulation of the hand technique. The +damped attribute will force a damp, while +undamped will prevent damping. The latter can cause a previously undamped note to become damped because the hand is now freed up.
The output is additional notes with +mute and zero duration at note end.
Tags: postproc
insts :: list of Str [*-insts] — Apply damping to these instruments.
dur :: realtime signal = .15s [*-dur] — This is how fast the player is able to damp. A note is only damped if there is a hand available which has this much time to move into position for the damp stroke, and then move into position for its next note afterwards.
early :: realtime signal = .025s [*-early] — Damp this much before the next note, if it would be simultaneous with the next start.
k -- kotekan
bali.reyong : note generator
k^ -- kotekan: Render a kotekan pattern from a kernel representing the polos. The sangsih is inferred. This can emit notes at both the beginning and end of the event, so use cancel-kotekan to cancel the extras.
Tags: inst
kernel :: Str = k-12-1-21 [kernel, *-kernel] — Transposition steps for the part that ends on the destination pitch. It should consist of -, 1, and 2. You can start with k to avoid needing quotes. Starting with k will also require the length to be a multiple of 4.
dir :: Str (u d) = u [*-dir] — Inferred part is above or below the explicit one.
kotekan-dur^env :: Signal (ScoreTime) = "(ts s) [kotekan-dur] — Duration of derived notes.
initial^env :: Maybe Str (f t) = _ [initial] — If true, include an initial note, which is the same as the final note. This is suitable for the start of a sequence of kotekan calls. If not given, infer false for negative duration, true for positive.
final^env :: Str (f t) = t [final] — If true, include the final note, at the event end.
voices^env :: list of Signal (integral) = (list) [voices, *-voices] — Only emit notes for these positions, from 1 to 4. Empty means all of them.
k// -- kotekan
bali.reyong : note generator
k\\ -- kotekan: Render a kotekan pattern from a kernel representing the polos. The sangsih is inferred. This can emit notes at both the beginning and end of the event, so use cancel-kotekan to cancel the extras.
Tags: inst
kotekan-dur^env :: Signal (ScoreTime) = "(ts s) [kotekan-dur] — Duration of derived notes.
initial^env :: Maybe Str (f t) = _ [initial] — If true, include an initial note, which is the same as the final note. This is suitable for the start of a sequence of kotekan calls. If not given, infer false for negative duration, true for positive.
final^env :: Str (f t) = t [final] — If true, include the final note, at the event end.
voices^env :: list of Signal (integral) = (list) [voices, *-voices] — Only emit notes for these positions, from 1 to 4. Empty means all of them.
lv -- note with +undamped
bali.reyong : note generator: Add attributes to the notes.
If there are notes in child tracks, apply the transformation to them. Otherwise apply the transformation to the null note call.
Tags: attr, subs
lv -- note with +undamped
bali.reyong : note transformer: Add attributes to the notes.
Tags: attr
norot -- norot
bali.reyong : note generator
nt -- norot: Reyong norot.
Tags: inst
prepare :: Maybe Str (f t) = _ [*-prepare] — Whether or not to prepare for the next pitch. If Nothing, infer based on the next note.
kotekan-dur^env :: Signal (ScoreTime) = "(ts s) [kotekan-dur] — Duration of derived notes.
initial^env :: Maybe Str (f t) = _ [initial] — If true, include an initial note, which is the same as the final note. This is suitable for the start of a sequence of kotekan calls. If not given, infer false for negative duration, true for positive.
final^env :: Str (f t) = t [final] — If true, include the final note, at the event end.
voices^env :: list of Signal (integral) = (list) [voices, *-voices] — Only emit notes for these positions, from 1 to 4. Empty means all of them.
nt- -- norot
bali.reyong : note generator: Reyong norot.
Tags: inst
prepare :: Maybe Str (f t) = f [*-prepare] — Whether or not to prepare for the next pitch. If Nothing, infer based on the next note.
kotekan-dur^env :: Signal (ScoreTime) = "(ts s) [kotekan-dur] — Duration of derived notes.
initial^env :: Maybe Str (f t) = _ [initial] — If true, include an initial note, which is the same as the final note. This is suitable for the start of a sequence of kotekan calls. If not given, infer false for negative duration, true for positive.
final^env :: Str (f t) = t [final] — If true, include the final note, at the event end.
voices^env :: list of Signal (integral) = (list) [voices, *-voices] — Only emit notes for these positions, from 1 to 4. Empty means all of them.
nt> -- norot
bali.reyong : note generator: Reyong norot.
Tags: inst
prepare :: Maybe Str (f t) = t [*-prepare] — Whether or not to prepare for the next pitch. If Nothing, infer based on the next note.
kotekan-dur^env :: Signal (ScoreTime) = "(ts s) [kotekan-dur] — Duration of derived notes.
initial^env :: Maybe Str (f t) = _ [initial] — If true, include an initial note, which is the same as the final note. This is suitable for the start of a sequence of kotekan calls. If not given, infer false for negative duration, true for positive.
final^env :: Str (f t) = t [final] — If true, include the final note, at the event end.
voices^env :: list of Signal (integral) = (list) [voices, *-voices] — Only emit notes for these positions, from 1 to 4. Empty means all of them.
o -- byong
bali.reyong : note generator: Play the byong notes, but only for the current voice, and following normal damping rules.
Tags: inst
realize-ngoret -- realize-ngoret
bali.reyong : note transformer: Realize pitches and positions emited by the ngoret call. This is necessary because it needs to know the positions and pitches of the previous and next notes, and those aren't necessarily available when evaluating the track. This call needs a hand envron to figure out which which note follows which.
Tags: inst, postproc
realize-reyong -- realize-reyong
bali.reyong : note transformer: Combine the reyong realize calls in the right order.
A static macro for: infer-damp $ $ | cancel-kotekan $ | realize-ngoret.
Each $ is lifted to be an argument of this macro.
This directly calls the underlying sub-calls, so it's not dependent on the names they are bound to, which also means the macro text may not be a valid expression.
Tags: postproc
insts :: list of Str [*-insts] — Apply damping to these instruments.
dur :: realtime signal = .15s [*-dur] — This is how fast the player is able to damp. A note is only damped if there is a hand available which has this much time to move into position for the damp stroke, and then move into position for its next note afterwards.
final-duration :: Signal (RealTime) = 1s [final-duration] — If there is no following note, infer this duration.
realize-trompong -- realize-trompong
bali.reyong : note transformer: Combine the reyong realize calls in the right order.
A static macro for: hand-damp $ $ | realize-ngoret.
Each $ is lifted to be an argument of this macro.
This directly calls the underlying sub-calls, so it's not dependent on the names they are bound to, which also means the macro text may not be a valid expression.
Tags: postproc
insts :: list of Str [*-insts] — Apply damping to these instruments.
dur :: realtime signal = .15s [*-dur] — There must be at least this much time between the end of a note and the start of the next to damp.
t -- tumpuk
bali.reyong : note generator: Pile up notes together.
Tags: inst
notes :: Str [*-notes] — Articulations, from -.mnox, pitches from edcba0123456789, or a space for a rest.
dur :: Signal (RealTime) = .1 [*-dur] — Duration of each note.
place^env :: Signal (0 <= x <= 1) = 1 [place, *-place] — At 0, grace notes fall before their base note. At 1, grace notes fall on the base note, and the base note is delayed.
upper -- upper
bali.reyong : note generator: Double a part with t-oct=+1 and "v"=2. If reyong subtracks have v=+1 and v=+2 respectively, they'll wind up with the right voices.
If there are notes in child tracks, apply the transformation to them. Otherwise apply the transformation to the null note call.
Tags: inst, subs
upper -- upper
bali.reyong : note transformer: Double a part with t-oct=+1 and "v"=2. If reyong subtracks have v=+1 and v=+2 respectively, they'll wind up with the right voices.
Tags: inst
vv -- lower-octave-note
bali.reyong : note transformer: Double a note with a single note one octave down, and add 'Derive.Flags.infer_duration'.
Tags: postproc, under-invert
n1 -- solkattu-note
bali.reyong.solkattu : note generator
n14 -- solkattu-note
n2 -- solkattu-note
n3 -- solkattu-note
n4 -- solkattu-note: A pitched note, as generated by reyong solkattu.
Tags: inst
sekar -- sekar
bali.sekar : note generator: Arrange sub-notes according to a pattern.
In the direct substitution style, each note retains its relative duration as it is rearranged by the pattern. A rest is considered a note, but just one note, so you can't have two rests in a row.
Tags: inst, subs
pattern :: list of Str [*-pattern] — If there is a list of patterns, they are for different numbers of notes, starting with 1. A single pattern is applied to all numbers though. The pattern is letters from a-z, where a is the first note and z is the 26th. Capital letters replace that note with a rest. Gaps in the input notes count as rest notes.
arrive^env :: Str (f t) = t [*-arrive] — If true, the last note of the pattern is aligned to the end of the event, and given {infer-duration}.
sekar-e -- sekar
bali.sekar : note generator: Arrange sub-notes according to a pattern.
In the even subdivision style, the range is divided evenly based on the highest index of the pattern (so abcac would divide into 3 parts). The melody is sampled at those points for note attacks, sustains, and rests, which are then rearranged by the pattern. Thus, the output is always notes in a regular tempo determined by the length of the pattern.
Tags: inst, subs
pattern :: Str [*-pattern] — The pattern is letters from a-z, where a is the first note and z is the 26th. Capital letters replace that note with a rest. Gaps in the input notes count as rest notes.
arrive^env :: Str (f t) = t [*-arrive] — If true, the last note of the pattern is aligned to the end of the event, and given {infer-duration}.
bent-string -- bent-string
china.zheng : note transformer: Post-process events to play in a stopped string idiom, where strings must be bent or stopped to reach non-open pitches. Originally it was meant to play in the style of a 古箏 or other zither, but may also be appropriate for stopped strings like the violin family. As a side-effect, events get astring variable.
Further documentation is in 'Derive.Call.Idiom.String'.
Tags: inst, postproc
attack :: typed signal = .15 [*-attack] — Time for a string to bend to its desired pitch. A fast attack sounds like a stopped string.
release :: typed signal = .1 [*-release] — Time for a string to return to its original pitch.
delay :: typed signal = 0 [*-delay] — If the string won't be used for the following note, it will be released after this delay.
open-strings^env :: list of Pitch = (list) [open-strings] — Pitches of open strings.
gliss -- gliss
china.zheng : note generator: Glissando along the open strings. The standard version divides the time among the number of notes, while the -a (absolute) version gives time to each note.
start :: Signal (integral) [*-start] — Start this many strings above or below the destination pitch.
time :: Signal (Time, default real) = .075s [*-time] — Time between each note.
dyn :: Maybe Signal = _ [*-dyn] — Start at this dyn, and interpolate to the destination dyn. If not given, the dyn is constant.
open-strings^env :: list of Pitch = (list) [open-strings] — Pitches of open strings.
gliss-a -- gliss-a
china.zheng : note generator: Glissando along the open strings. The standard version divides the time among the number of notes, while the -a (absolute) version gives time to each note.
start :: Signal (integral) [*-start] — Start this many strings above or below the destination pitch.
time :: Signal (Time, default real) = .25s [*-time] — Time in which to play the glissando.
dyn :: Maybe Signal = _ [*-dyn] — Start at this dyn, and interpolate to the destination dyn. If not given, the dyn is constant.
open-strings^env :: list of Pitch = (list) [open-strings] — Pitches of open strings.
tr -- tr china.zheng : note generator
tr^ -- tr
tr_ -- tr: A trill with smooth transitions.
Tags: ly
neighbor :: transpose signal (default nn) = 1 [*-neighbor] — Alternate with a pitch at this interval.
speed :: time signal (default real) = 20 [*-speed] — Alternate pitches at this speed.
hold^env :: Signal (Time, default real) = 0s [hold, *-hold] — Time to hold the first note.
chord -- chord
europe : note generator
chord^ -- chord
chord_ -- chord: Make a chord based on a specialized chord notation. It's different from the usual kind of chord notation because the base pitch is given separately, and it has to be non-ambiguous, but the idea is the same.
name :: Str = '' [*-name] — Chord name.
time^env :: Signal (Time, default real) = .08s [*-time] — Time between notes, if they aren't unison.
stack -- stack
europe : note generator
stack^ -- stack
stack_ -- stack: Make a chord by stacking intervals on a base pitch. There are variants that arpeggiate upwards or downwards, in addition to playing in unison.
interval^* :: Pitch or Signal (integral) or Str [] — Relative intervals, starting from the base pitch. Can be absolute pitch, diatonic intervals, or a chromatic interval. Chromatic intervals are notated m3, M3, p4 for minor third, major third, and perfect fourth respectively.
time^env :: Signal (Time, default real) = .08s [*-time] — Time between notes, if they aren't unison.
bent-string -- bent-string
idiom.string : note transformer: Post-process events to play in a stopped string idiom, where strings must be bent or stopped to reach non-open pitches. Originally it was meant to play in the style of a 古箏 or other zither, but may also be appropriate for stopped strings like the violin family. As a side-effect, events get astring variable.
Further documentation is in 'Derive.Call.Idiom.String'.
Tags: inst, postproc
attack :: typed signal = .15 [*-attack] — Time for a string to bend to its desired pitch. A fast attack sounds like a stopped string.
release :: typed signal = .1 [*-release] — Time for a string to return to its original pitch.
delay :: typed signal = 0 [*-delay] — If the string won't be used for the following note, it will be released after this delay.
open-strings^env :: list of Pitch = (list) [open-strings] — Pitches of open strings.
gliss -- gliss
idiom.string : note generator: Glissando along the open strings. The standard version divides the time among the number of notes, while the -a (absolute) version gives time to each note.
start :: Signal (integral) [*-start] — Start this many strings above or below the destination pitch.
time :: Signal (Time, default real) = .075s [*-time] — Time between each note.
dyn :: Maybe Signal = _ [*-dyn] — Start at this dyn, and interpolate to the destination dyn. If not given, the dyn is constant.
open-strings^env :: list of Pitch = (list) [open-strings] — Pitches of open strings.
gliss-a -- gliss-a
idiom.string : note generator: Glissando along the open strings. The standard version divides the time among the number of notes, while the -a (absolute) version gives time to each note.
start :: Signal (integral) [*-start] — Start this many strings above or below the destination pitch.
time :: Signal (Time, default real) = .25s [*-time] — Time in which to play the glissando.
dyn :: Maybe Signal = _ [*-dyn] — Start at this dyn, and interpolate to the destination dyn. If not given, the dyn is constant.
open-strings^env :: list of Pitch = (list) [open-strings] — Pitches of open strings.
mute-end -- mute-end
idiom.string : note transformer: Put a note and then +mute note at the end of each note, unless there's another note on the same string. The +ring attr suppresses this.
Tags: inst, postproc
threshold :: Signal (RealTime) [*-threshold] — Mute if the string is free for this long.
dur :: realtime signal [*-dur] — Duration of mute note. If it's zero, its omitted and only the +mute note is emitted.
dyn :: untyped signal [*-dyn] — Dyn of mute note.
o -- harmonic
idiom.string : note generator: Play the given pitch as a harmonic, possibly restricted to a string. Otherwise, pick the lowest harmonic where the pitch fits.
Tags: inst
finger :: Signal = .035 [*-finger] — Weight of the finger touching the string, in newtons.
h1 :: Str (f t) = f [*-h1] — Ok to pick an open string as the 1st harmonic?
string^env :: Maybe Pitch = _ [string] — Play on this string.
open-strings^env :: list of Pitch = (list) [open-strings] — Pitches of open strings.
on -- harmonic
idiom.string : note generator: Play a specific harmonic on a specific string.
Tags: inst
n :: Signal (>0) = 1 [*-n] — Play this harmonic.
finger :: Signal = .035 [*-finger] — Weight of the finger touching the string, in newtons.
string^env :: Pitch [string] — Play on this string.
stopped-string -- stopped-string
idiom.string : note transformer: A specialization of bent-string but for stopped strings, like the violin family, where strings instantly jump to their pitches.
Tags: inst, postproc
delay :: typed signal = 0s [*-delay] — String release delay time.
open-strings^env :: list of Pitch = (list) [open-strings] — Pitches of open strings.
string^env :: Maybe Pitch = _ [string] — Play on this string.
wind-idiom -- wind-idiom
idiom.wind : note transformer: Post-process events to play in a monophonic wind-like idiom.
This tweaks the ends of the pitch signals of notes depending on the following note. When a note is played, a (fundamental, harmonic) pair is chosen that best fits it. When a subsequent note is played, a new pair is chosen for it.
The decay of the note will be shifted to the corresponding harmonic of the the fundamental of the subsequent note. If the fundamentals are the same then the pitch will remain constant, of course.
Tags: inst, postproc
fundamentals^env :: list of Signal (NN) or Pitch = (list) [fundamentals] — Fundamentals for this instrument.
@ -- sequence
india.gamakam2 : note generator: Sequence several pitch calls. Calls are divided into begin ; middle1 ; middle2; ... ; end phases. Calls are pitch generators, and are sequenced such that the middle calls stretch based on the duration of the note. The india.gamakam2.begin, india.gamakam2.middle, and india.gamakam2.end modules are in scope during the begin, middle, and end phases. All calls below the india.gamakam2 module are designed for sequencing. This just means they emit samples at the beginning and end of their range, so the sequence call knows their extent. Normal pitch calls may not do that.
There's a special hack for the -< and -> calls: they have 0 duration, but are overlaid with their neighbors. This is so you can fade in or out without having to flatten the pitch.
arg^* :: Val [] — Expressions separated by ;.
@ -- sequence
india.gamakam2 : note transformer: Sequence several pitch calls. Calls are divided into begin ; middle1 ; middle2; ... ; end phases. Calls are pitch generators, and are sequenced such that the middle calls stretch based on the duration of the note. The india.gamakam2.begin, india.gamakam2.middle, and india.gamakam2.end modules are in scope during the begin, middle, and end phases. All calls below the india.gamakam2 module are designed for sequencing. This just means they emit samples at the beginning and end of their range, so the sequence call knows their extent. Normal pitch calls may not do that.
There's a special hack for the -< and -> calls: they have 0 duration, but are overlaid with their neighbors. This is so you can fade in or out without having to flatten the pitch.
arg^* :: Val [] — Expressions separated by ;.
sahitya -- sahitya
india.gamakam2 : note transformer: Ignore the transformed deriver. Put this on a track to ignore its contents, and put in sahitya.
sahitya -- sahitya
india.gamakam5 : note transformer: Ignore the transformed deriver. Put this on a track to ignore its contents, and put in sahitya.
sahitya -- sahitya
india.gamakam6 : note transformer: Ignore the transformed deriver. Put this on a track to ignore its contents, and put in sahitya.
8n -- sequence
india.mridangam : note generator
tk -- sequence
tknk -- sequence: Play a sequence of mridangam strokes. Each one takes the given dur, and if the event is longer than the sequence, it is repeated to fill up available space. If a whole cycle doesn't fit, clip from the end for a positive event, or from the beginning for a negative one. If dur is 0, then stretch to the sequence to fit the event.
Tags: inst
dur :: Signal (ScoreTime, >=0) = 0t [dur, *-dur] — Duration for each letter in the sequence. If 0, the sequence will stretch to the event's duration.
p -- pattern
india.mridangam : note generator: Like seq, but pick a standard pattern.
Tags: inst
n :: Maybe Signal (integral, >0) [*-n] — Number of strokes. If not given, and dur > 0, then infer the number of strokes as the event_duration / dur.
var :: Str = d [var, *-var] — Variation name. Possibilities are: d, f567-0, f567-1, f567-2, f567-3, f567-4, f567-5, f567-6, f567-7, f567-8, kt_kn_o
dur :: Signal (ScoreTime, >=0) = 0t [dur, *-dur] — Duration for each letter in the sequence. If 0, the sequence will stretch to the event's duration.
seq -- sequence
india.mridangam : note generator: Play a sequence of mridangam strokes. Each one takes the given dur, and if the event is longer than the sequence, it is repeated to fill up available space. If a whole cycle doesn't fit, clip from the end for a positive event, or from the beginning for a negative one. If dur is 0, then stretch to the sequence to fit the event.
Tags: inst
sequence :: Str [sequence] — Single letter stroke names. _ or space is a rest.
dur :: Signal (ScoreTime, >=0) = 0t [dur, *-dur] — Duration for each letter in the sequence. If 0, the sequence will stretch to the event's duration.
tir -- tir
india.mridangam : note generator: Repeat a sequence three times. If the duration is negative, put the first stroke of the karvai at the end time with {strong}.
Tags: inst
sequence :: Str [sequence] — Single letter stroke names. _ or space is a rest.
karvai :: Str = '' [*-karvai] — Separates each sequence. If it's empty or a single non-rest, then the gap can stretch to an integral number of matras.
dur :: Signal (ScoreTime, >=0) = 0t [dur, *-dur] — Duration for each letter in the sequence. If 0, the sequence will stretch to the event's duration.
bols -- bols
india.pakhawaj : note generator: Interpret pakhawaj bols in sub events. Bols: tet / te / ne / re / na / ta / di / din / ka / kat / ki / ge / gen / ga / dha / dhin / dhet / kre / gre / te re ki ta / ki ta ta ka / tr kt / te re ki ta ta ka / tr kt tk / kt tk / ta ki / te ran / dhu ma / tetekata
Tags: inst, subs
flam :: Signal (ScoreTime) = .15 [*-flam] — Time between flam type bols like kre.
capture-null-control -- capture-null-control
internal : note generator: This is an internal call used to capture the control signal at the bottom of a control block.
8va -- ottava
ly : note generator: Emit lilypond ottava mark. If it has duration, end with 8va 0.

This either be placed in a separate track as a zero-dur event, or it can be attached to an individual note as a transformer.
Tags: ly
octave :: Signal (integral) = 0 [*-octave] — Transpose this many octaves up or down.
8va -- ottava
ly : note transformer: Emit lilypond ottava mark. If it has duration, end with 8va 0.

This either be placed in a separate track as a zero-dur event, or it can be attached to an individual note as a transformer.
Tags: ly
octave :: Signal (integral) = 0 [*-octave] — Transpose this many octaves up or down.
clef -- clef
ly : note generator: Emit lilypond clef change.

This either be placed in a separate track as a zero-dur event, or it can be attached to an individual note as a transformer.
Tags: ly
clef :: Str [*-clef] — Should be bass, treble, etc.
clef -- clef
ly : note transformer: Emit lilypond clef change.

This either be placed in a separate track as a zero-dur event, or it can be attached to an individual note as a transformer.
Tags: ly
clef :: Str [*-clef] — Should be bass, treble, etc.
dyn -- dyn
ly : note generator: Emit a lilypond dynamic. If there are notes below, they are derived unchanged.

This either be placed in a separate track as a zero-dur event, or it can be attached to an individual note as a transformer.
Tags: ly
dynamic :: Str [*-dynamic] — Should be p, ff, etc.
dyn -- dyn
ly : note transformer: Emit a lilypond dynamic. If there are notes below, they are derived unchanged.

This either be placed in a separate track as a zero-dur event, or it can be attached to an individual note as a transformer.
Tags: ly
dynamic :: Str [*-dynamic] — Should be p, ff, etc.
if-ly -- if-ly
ly : note generator: Conditional for lilypond.
Tags: ly
is-ly :: Quoted [*-is-ly] — Evaluated in lilypond mode.
not-ly :: Quoted [*-not-ly] — Evaluated when not in lilypond mode.
ly- -- ly-articulation
ly : note generator: Append a -articulation to notes.
If there are notes in child tracks, apply the transformation to them. Otherwise apply the transformation to the null note call.
Tags: ly, subs
text :: Str [*-text] — Code to attach. A - is prepended.
ly- -- ly-articulation
ly : note transformer: Append a -articulation to notes.
Tags: ly
text :: Str [*-text] — Code to attach. A - is prepended.
ly-! -- ly-reminder-accidental
ly : note generator: Force this note to display an accidental.
Lilypond code: (SetEnviron "ly-append-pitch", "!")
If there are notes in child tracks, apply the transformation to them. Otherwise apply the transformation to the null note call.
Tags: ly, subs
ly-! -- ly-reminder-accidental
ly : note transformer: Force this note to display an accidental.
Lilypond code: (SetEnviron "ly-append-pitch", "!")
Tags: ly
ly-( -- ly-begin-slur
ly : note generator: Separately mark a lilypond slur, when ( isn't cutting it.
Lilypond code: (CodePosition Chord Append First, "(")
If there are notes in child tracks, apply the transformation to them. Otherwise apply the transformation to the null note call.
Tags: ly, subs
ly-( -- ly-begin-slur
ly : note transformer: Separately mark a lilypond slur, when ( isn't cutting it.
Lilypond code: (CodePosition Chord Append First, "(")
Tags: ly
ly-) -- ly-end-slur
ly : note generator: Separately mark a lilypond slur, when ( isn't cutting it.
Lilypond code: (CodePosition Chord Append Last, ")")
If there are notes in child tracks, apply the transformation to them. Otherwise apply the transformation to the null note call.
Tags: ly, subs
ly-) -- ly-end-slur
ly : note transformer: Separately mark a lilypond slur, when ( isn't cutting it.
Lilypond code: (CodePosition Chord Append Last, ")")
Tags: ly
ly-< -- ly-hairpin
ly : note generator
ly-> -- ly-hairpin: Start a crescendo or diminuendo hairpin. If it has non-zero duration, stop at the event's end, otherwise it will stop at the next hairpin or dynamic marking.

This either be placed in a separate track as a zero-dur event, or it can be attached to an individual note as a transformer.
Tags: ly
ly-< -- ly-hairpin
ly : note transformer
ly-> -- ly-hairpin: Start a crescendo or diminuendo hairpin. If it has non-zero duration, stop at the event's end, otherwise it will stop at the next hairpin or dynamic marking.

This either be placed in a separate track as a zero-dur event, or it can be attached to an individual note as a transformer.
Tags: ly
ly-<> -- ly-crescendo-diminuendo
ly : note generator: Crescendo followed by diminuendo, on one note.
Lilypond code: (FreeAppend, "\espressivo")

This either be placed in a separate track as a zero-dur event, or it can be attached to an individual note as a transformer.
Tags: ly
ly-<> -- ly-crescendo-diminuendo
ly : note transformer: Crescendo followed by diminuendo, on one note.
Lilypond code: (FreeAppend, "\espressivo")

This either be placed in a separate track as a zero-dur event, or it can be attached to an individual note as a transformer.
Tags: ly
ly-? -- ly-cautionary-accidental
ly : note generator: Force this note to display a cautionary accidental.
Lilypond code: (SetEnviron "ly-append-pitch", "?")
If there are notes in child tracks, apply the transformation to them. Otherwise apply the transformation to the null note call.
Tags: ly, subs
ly-? -- ly-cautionary-accidental
ly : note transformer: Force this note to display a cautionary accidental.
Lilypond code: (SetEnviron "ly-append-pitch", "?")
Tags: ly
ly-[ -- ly-begin-beam
ly : note generator: Begin a beam. Override lilypond's automatic beaming.
Lilypond code: (CodePosition Chord Append First, "[")
If there are notes in child tracks, apply the transformation to them. Otherwise apply the transformation to the null note call.
Tags: ly, subs
ly-[ -- ly-begin-beam
ly : note transformer: Begin a beam. Override lilypond's automatic beaming.
Lilypond code: (CodePosition Chord Append First, "[")
Tags: ly
ly-] -- ly-end-beam
ly : note generator: End a beam. Override lilypond's automatic beaming.
Lilypond code: (CodePosition Chord Append First, "]")
If there are notes in child tracks, apply the transformation to them. Otherwise apply the transformation to the null note call.
Tags: ly, subs
ly-] -- ly-end-beam
ly : note transformer: End a beam. Override lilypond's automatic beaming.
Lilypond code: (CodePosition Chord Append First, "]")
Tags: ly
ly-^~ -- ly-tie-direction
ly : note generator: Force the note's tie to go either up or down.
Lilypond code: (SetEnviron "ly-tie-direction", "^")
If there are notes in child tracks, apply the transformation to them. Otherwise apply the transformation to the null note call.
Tags: ly, subs
ly-^~ -- ly-tie-direction
ly : note transformer: Force the note's tie to go either up or down.
Lilypond code: (SetEnviron "ly-tie-direction", "^")
Tags: ly
ly-_~ -- ly-tie-direction
ly : note generator: Force the note's tie to go either up or down.
Lilypond code: (SetEnviron "ly-tie-direction", "_")
If there are notes in child tracks, apply the transformation to them. Otherwise apply the transformation to the null note call.
Tags: ly, subs
ly-_~ -- ly-tie-direction
ly : note transformer: Force the note's tie to go either up or down.
Lilypond code: (SetEnviron "ly-tie-direction", "_")
Tags: ly
ly-attach -- ly-attach
ly : note generator: Attach lilypond code to each transformed note.
If there are notes in child tracks, apply the transformation to them. Otherwise apply the transformation to the null note call.
Tags: ly, subs
code :: Str [*-code] — Attach this code.
pos :: Str (chord-append-all chord-append-first chord-append-last chord-prepend-all chord-prepend-first chord-prepend-last note-append-all note-append-first note-append-last note-prepend-all note-prepend-first note-prepend-last) = chord-append-last [*-pos] — Where to put it: 'Derive.Call.Ly.CodePosition'.
ly-attach -- ly-attach
ly : note transformer: Attach lilypond code to each transformed note.
Tags: ly
code :: Str [*-code] — Attach this code.
pos :: Str (chord-append-all chord-append-first chord-append-last chord-prepend-all chord-prepend-first chord-prepend-last note-append-all note-append-first note-append-last note-prepend-all note-prepend-first note-prepend-last) = chord-append-last [*-pos] — Where to put it: 'Derive.Call.Ly.CodePosition'.
ly-emit -- ly-emit
ly : note generator: Emit a single fragment of freestanding lilypond code.

This either be placed in a separate track as a zero-dur event, or it can be attached to an individual note as a transformer.
Tags: ly
code :: Str [*-code] — Emit this code.
pos :: Str (prepend append) = append [*-pos] — Where to put it: 'Derive.Call.Ly.CodePosition'.
ly-emit -- ly-emit
ly : note transformer: Emit a single fragment of freestanding lilypond code.

This either be placed in a separate track as a zero-dur event, or it can be attached to an individual note as a transformer.
Tags: ly
code :: Str [*-code] — Emit this code.
pos :: Str (prepend append) = append [*-pos] — Where to put it: 'Derive.Call.Ly.CodePosition'.
ly-global -- ly-global
ly : note transformer: Evaluate the deriver only when in lilypond mode, like when-ly, but also set the ly-global instrument.
Tags: ly
ly-key -- ly-key
ly : note generator: Emit a key change. This only emits a lilypond key change, it doesn't actually set the key. This means diatonic operations won't work as expected. Also, you have to add it to every staff manually. On the up side, it doesn't force a structural change like = does.

This either be placed in a separate track as a zero-dur event, or it can be attached to an individual note as a transformer.
Tags: ly
key :: Str [*-key] — You can use any of the keys from the Twelve scale.
ly-key -- ly-key
ly : note transformer: Emit a key change. This only emits a lilypond key change, it doesn't actually set the key. This means diatonic operations won't work as expected. Also, you have to add it to every staff manually. On the up side, it doesn't force a structural change like = does.

This either be placed in a separate track as a zero-dur event, or it can be attached to an individual note as a transformer.
Tags: ly
key :: Str [*-key] — You can use any of the keys from the Twelve scale.
ly-post -- ly-post
ly : note generator: Emit arbitrary lilypond code that will go after concurrent notes.

This either be placed in a separate track as a zero-dur event, or it can be attached to an individual note as a transformer.
Tags: ly
code :: Str [*-code] — A leading \ will be prepended.
ly-post -- ly-post
ly : note transformer: Emit arbitrary lilypond code that will go after concurrent notes.

This either be placed in a separate track as a zero-dur event, or it can be attached to an individual note as a transformer.
Tags: ly
code :: Str [*-code] — A leading \ will be prepended.
ly-pre -- ly-pre
ly : note generator: Emit arbitrary lilypond code that will go before concurrent notes.

This either be placed in a separate track as a zero-dur event, or it can be attached to an individual note as a transformer.
Tags: ly
code :: Str [*-code] — A leading \ will be prepended.
ly-pre -- ly-pre
ly : note transformer: Emit arbitrary lilypond code that will go before concurrent notes.

This either be placed in a separate track as a zero-dur event, or it can be attached to an individual note as a transformer.
Tags: ly
code :: Str [*-code] — A leading \ will be prepended.
ly-span -- ly-span
ly : note generator: Emit a bit of text followed by a dashed line until the end of the event. This is useful for things like accel. or cresc. If it has a a zero duration, emit the start if the text is given, or the end if it's not.

This either be placed in a separate track as a zero-dur event, or it can be attached to an individual note as a transformer.
Tags: ly
text :: Maybe Str [*-text] — Text.
ly-span -- ly-span
ly : note transformer: Emit a bit of text followed by a dashed line until the end of the event. This is useful for things like accel. or cresc. If it has a a zero duration, emit the start if the text is given, or the end if it's not.

This either be placed in a separate track as a zero-dur event, or it can be attached to an individual note as a transformer.
Tags: ly
text :: Maybe Str [*-text] — Text.
ly-sus -- ly-sus
ly : note generator: Emit \sustainOn and \sustainOff markup.

This either be placed in a separate track as a zero-dur event, or it can be attached to an individual note as a transformer.
Tags: ly
state :: Str (f t ft) [*-state] — t for \sustainOn, f for \sustainOff, ft for \sustainOff\sustainOn.
ly-sus -- ly-sus
ly : note transformer: Emit \sustainOn and \sustainOff markup.

This either be placed in a separate track as a zero-dur event, or it can be attached to an individual note as a transformer.
Tags: ly
state :: Str (f t ft) [*-state] — t for \sustainOn, f for \sustainOff, ft for \sustainOff\sustainOn.
ly-track -- ly-track
ly : note transformer: Evaluate the deriver only when in lilypond mode, otherwise ignore this track but evaluate its subtracks. Apply this to a track to omit lilypond-only articulations, or to apply different articulations to lilypond and non-lilypond output. Only use it in the track title!
Tags: ly
ly-tr~ -- ly-tr-span
ly : note generator: Emit a \startTrillSpan - \stopTrillSpan pair.

This either be placed in a separate track as a zero-dur event, or it can be attached to an individual note as a transformer.
Tags: ly
ly-tr~ -- ly-tr-span
ly : note transformer: Emit a \startTrillSpan - \stopTrillSpan pair.

This either be placed in a separate track as a zero-dur event, or it can be attached to an individual note as a transformer.
Tags: ly
ly^ -- ly-text
ly : note generator
ly_ -- ly-text: Attach text above or below the note.
If there are notes in child tracks, apply the transformation to them. Otherwise apply the transformation to the null note call.
Tags: ly, subs
text :: Str [*-text] — Text to attach.
ly^ -- ly-text
ly : note transformer
ly_ -- ly-text: Attach text above or below the note.
Tags: ly
text :: Str [*-text] — Text to attach.
meter -- meter
ly : note generator: Emit lilypond meter change. It will be interpreted as global no matter where it is. Simultaneous different meters aren't supported yet, but subdivision supports simultaneous different spellings.

This either be placed in a separate track as a zero-dur event, or it can be attached to an individual note as a transformer.
Tags: ly
meter :: Str [*-meter] — Should be 4/4, 6/8, etc. An ambiguous meter like 6/8 will default to 3+3, but you can explicitly set the subdivision, e.g. 2+2+2/8.
meter -- meter
ly : note transformer: Emit lilypond meter change. It will be interpreted as global no matter where it is. Simultaneous different meters aren't supported yet, but subdivision supports simultaneous different spellings.

This either be placed in a separate track as a zero-dur event, or it can be attached to an individual note as a transformer.
Tags: ly
meter :: Str [*-meter] — Should be 4/4, 6/8, etc. An ambiguous meter like 6/8 will default to 3+3, but you can explicitly set the subdivision, e.g. 2+2+2/8.
movement -- movement
ly : note generator: Start a new movement with the given title.

This either be placed in a separate track as a zero-dur event, or it can be attached to an individual note as a transformer.
Tags: ly
title :: Str [*-title] — Title of this movement.
movement -- movement
ly : note transformer: Start a new movement with the given title.

This either be placed in a separate track as a zero-dur event, or it can be attached to an individual note as a transformer.
Tags: ly
title :: Str [*-title] — Title of this movement.
not-ly-track -- not-ly-track
ly : note transformer: The inverse of ly-track, evaluate the track only when not in lilypond mode. Only use it in the track title!
Tags: ly
subdivision -- subdivision
ly : note generator: Emit a subdivision change. This is the same format as meter, but it affects the subdivision for this instrument only, instead of setting the global meter. This is useful when instruments are playing cross-rhythms and should beam accordingly.

This either be placed in a separate track as a zero-dur event, or it can be attached to an individual note as a transformer.
Tags: ly
meter :: Maybe Str [*-meter] — Same as meter call.
subdivision -- subdivision
ly : note transformer: Emit a subdivision change. This is the same format as meter, but it affects the subdivision for this instrument only, instead of setting the global meter. This is useful when instruments are playing cross-rhythms and should beam accordingly.

This either be placed in a separate track as a zero-dur event, or it can be attached to an individual note as a transformer.
Tags: ly
meter :: Maybe Str [*-meter] — Same as meter call.
tempo -- tempo
ly : note generator: Emit tempo marking.

This either be placed in a separate track as a zero-dur event, or it can be attached to an individual note as a transformer.
Tags: ly
text :: Str [*-text] — 4 = 120, etc.
tempo -- tempo
ly : note transformer: Emit tempo marking.

This either be placed in a separate track as a zero-dur event, or it can be attached to an individual note as a transformer.
Tags: ly
text :: Str [*-text] — 4 = 120, etc.
unless-ly -- unless-ly
ly : note transformer: The inverse of when-ly, evaluate the deriver or apply the args only when not in lilypond mode.
Tags: ly
arg^* :: Val [] — Call expression.
when-ly -- when-ly
ly : note transformer: With no arguments, evaluate the deriver only when in lilypond mode. Unlike ly-track, this doesn't evaluate subtracks, so you can use it to emit an entirely different set of tracks.
With arguments, evaluate them as a transformer and apply it only when in lilypond mode. Otherwise, the deriver is unchanged.
Tags: ly
arg^* :: Val [] — Call expression.
xstaff -- xstaff
ly : note generator: Emit lilypond to put the notes on a different staff.

This either be placed in a separate track as a zero-dur event, or it can be attached to an individual note as a transformer.
Tags: ly
staff :: Str (u d) [*-staff] — Switch to this staff.
xstaff -- xstaff
ly : note transformer: Emit lilypond to put the notes on a different staff.

This either be placed in a separate track as a zero-dur event, or it can be attached to an individual note as a transformer.
Tags: ly
staff :: Str (u d) [*-staff] — Switch to this staff.
xstaff-a -- xstaff-around
ly : note generator: Emit lilypond to put the notes on a different staff.
This either be placed in a separate track as a zero-dur event, or it can be attached to an individual note as a transformer. The transformer will wrap each event in (start, end) pairs. This way you can wrap all notes on a certain track with complementary bits of lilypond code.
Tags: ly
staff :: Str (u d) [*-staff] — Switch to this staff.
xstaff-a -- xstaff-around
ly : note transformer: Emit lilypond to put the notes on a different staff.
This either be placed in a separate track as a zero-dur event, or it can be attached to an individual note as a transformer. The transformer will wrap each event in (start, end) pairs. This way you can wrap all notes on a certain track with complementary bits of lilypond code.
Tags: ly
staff :: Str (u d) [*-staff] — Switch to this staff.
"" -- note
prelude : note generator
NOTE -- note: The note call is the default note generator, and will emit a single score event. Usually this is bound to the null call, "", which is therefore the most syntactically convenient note generator.
This should probably remain bound to note-track symbol, which is used internally by many other calls when they want a plain note. This is so you can bind "" to one of those other calls without getting recursion.
( -- legato
prelude : note generator
^( -- legato
_( -- legato: Play the transformed notes legato. This just makes all but the last overlap slightly.
You can combine this with other controls to get fancier phrasing. For example, you can be detached by default but have legato connect notes, by setting %legato-overlap = .05 | %sus-abs = -.05.
Otherwise, you can use the detach and dyn args.
The ^ and _ variants are the same in normal performance, but force lilypond slurs to go above or below, respectively.
Tags: attr, ly, subs
overlap :: Signal (RealTime) = .1s [*-overlap] — All notes but the last have their durations extended by this amount.
detach :: Maybe Signal (RealTime) = _ [*-detach] — Shorten the final note by this amount, by setting %sus-abs. The distinction between not given and 0 is important, because 0 will still override %sus-abs, which you may not want.
dyn :: Signal = 1 [*-dyn] — Scale dyn for notes after the first one by this amount.
+ -- lengthen
prelude : note generator
- -- shorten: Lengthen or Shorten a note duration, by adding to or subtracting from sus-abs.
If there are notes in child tracks, apply the transformation to them. Otherwise apply the transformation to the null note call.
Tags: subs
time :: Signal = .15 [*-time] — Subtract this duration.
+ -- lengthen
prelude : note transformer
- -- shorten: Lengthen or Shorten a note duration, by adding to or subtracting from sus-abs.
time :: Signal = .15 [*-time] — Subtract this duration.
. -- note with +stac
prelude : note generator
m -- note with +mute
{ -- note with +porta
pattern:attribute starting with `+` or `=` -- note with +example-attr: Add attributes to the notes.
If there are notes in child tracks, apply the transformation to them. Otherwise apply the transformation to the null note call.
Tags: attr, subs
. -- note with +stac
prelude : note transformer
m -- note with +mute
{ -- note with +porta: Add attributes to the notes.
Tags: attr
< -- track-integrate
prelude : note transformer: Integrate the output into new tracks. Events will be split into tracks based on source track, instrument, and scale, as documented in 'Cmd.Integrate.Convert'.
Unlike block integrate, this doesn't return the events. While an integrated block's output is likely to be playable, and you can chose whether or not to play it, an integrated track is part of a block, so it plays whether you want it or not.
keep-controls :: list of Control ([a-z][a-z0-9.-]*) = (list dyn) [*-keep-controls] — Keep only these controls. Transposers are always kept.
<< -- block-integrate
prelude : note transformer: Integrate the output into a new block. The events are returned as-is so the block can still be played normally.
keep-controls :: list of Control ([a-z][a-z0-9.-]*) = (list dyn) [*-keep-controls] — Keep only these controls. Transposers are always kept.
= -- equal
prelude : note generator: Similar to the transformer, this will evaluate the notes below in a transformed environ.
Tags: subs
lhs :: Str [] — Assign to this. This looks like a Str, but can actualy contain any characters except =, due to the special infix parsing for =. Symbolic prefixes determine what is assigned, and the valid types for the rhs.
rhs :: Val [] — Source of the assignment.
merge :: Str = set [*-merge] — Merge operator. This can be default to use the default for the control, set to replace the old signal, or one of the operators from 'Derive.Deriver.Monad.mergers': add, mul, scale, set, sub. There are also symbolic aliases, to support =+ syntax: {"*": "mul", "+": "add", "-": "sub", "@": "scale"}
= -- equal
prelude : note transformer: Evaluate the deriver with a value set. Special parser support means this can be called infix. The arguments can take many forms to set different kinds of values.
Set an environ value by setting a plain symbol or unset it by assigning to _: x = 42 or x = _.
Prefixes:
- >> - Create a note transformer, whose name will be prefixed with >. This is used to set an instrument transformer, which can apply a transformer when an instrument is set by the title of a note track, as implemented by by note-track.
- -val - Bind a val call.
- ^note, *pitch, .control - Bind the respective call type generator.
- ^-note, *-pitch, .-control - As above, but bind transformer.
- >alias = >inst - alias instrument name
E.g.: set note generator: ^phrase = some-block, note transformer: ^-mute = +mute+loose, control transfomrer: .-i = t, val call: -4c = (5c).
You can bypass all this cryptic prefix garbage by using a ky file. It has more space available so it can use a more readable syntax.
If you bind a call to a quoted expression, this creates a new call: ^abc = "(a b c) will create a abc call, which is a macro for a b c. The created call does not take arguments.
Set the default pitch signal with #, e.g. # = (4c) or # = 45nn. Control signal assignment also supports the same merge functions as the control track: a = .5 add or a = %b add. However, the second example throws an error if %b is a ControlFunction. a = .5 default will combine with a's default merge function. Assigning to _ unsets the control, and any ControlFunction.
The = operator can be suffixed with symbol, which will become the last argument, so %x=+1 becomes %x = 1 '+'. Note that the order is backwards from the usual +=, which is ultimately because the first word can have almost any character except space and =. Also, x=-1 is ambiguous, and parsed as x =- 1.
Tags: subs
lhs :: Str [] — Assign to this. This looks like a Str, but can actualy contain any characters except =, due to the special infix parsing for =. Symbolic prefixes determine what is assigned, and the valid types for the rhs.
rhs :: Val [] — Source of the assignment.
merge :: Str = set [*-merge] — Merge operator. This can be default to use the default for the control, set to replace the old signal, or one of the operators from 'Derive.Deriver.Monad.mergers': add, mul, scale, set, sub. There are also symbolic aliases, to support =+ syntax: {"*": "mul", "+": "add", "-": "sub", "@": "scale"}
^ -- weak
prelude : note generator: Weaken the note by multiplying its dynamic.
If there are notes in child tracks, apply the transformation to them. Otherwise apply the transformation to the null note call.
Tags: subs
dyn :: Signal = .35 [*-dyn] — Multiply dynamic.
^ -- weak
prelude : note transformer: Weaken the note by multiplying its dynamic.
dyn :: Signal = .35 [*-dyn] — Multiply dynamic.
`arp-down` -- arp
prelude : note generator
`arp-rnd` -- arp
`arp-up` -- arp: Arpeggiate the transformed notes. This shifts each note's start time by a different amount, increasing to the right for arp-up, to the left for arp-down, and randomly for arp-rnd. Since it transforms score and not events, it doesn't know the pitches of the sub notes (they may not have a single pitch) so it's not actually "up" or "down".
Tags: subs
time :: Signal = .1 [*-time] — This much RealTime between each note.
random :: Signal = .5 [*-random] — Each note can vary randomly by +- time/2 * random.
`mordent` -- mordent
prelude : note generator: Like g, but hardcoded to play pitch, neighbor, pitch.
Tags: ornament
neighbor :: Signal (Transposition, default diatonic) = 1d [*-neighbor] — Neighbor pitch.
grace-dyn^env :: Signal (>=0) = .5 [grace-dyn] — Scale the dyn of the grace notes.
dur^env :: Signal (Time, default real) = .083s [dur, *-dur] — Duration of grace notes.
place^env :: Signal (0 <= x <= 1) = 0 [place, *-place] — At 0, grace notes fall before their base note. At 1, grace notes fall on the base note, and the base note is delayed.
`rmordent` -- mordent
prelude : note generator: Like g, but hardcoded to play pitch, neighbor, pitch.
Tags: ornament
neighbor :: Signal (Transposition, default diatonic) = -1d [*-neighbor] — Neighbor pitch.
grace-dyn^env :: Signal (>=0) = .5 [grace-dyn] — Scale the dyn of the grace notes.
dur^env :: Signal (Time, default real) = .083s [dur, *-dur] — Duration of grace notes.
place^env :: Signal (0 <= x <= 1) = 0 [place, *-place] — At 0, grace notes fall before their base note. At 1, grace notes fall on the base note, and the base note is delayed.
add-flag -- add-flag
prelude : note transformer: Add the given flags to transformed events. Mostly for debugging and testing.
Tags: postproc
flag⁺ :: Str [] — Add these flags.
alt -- alternate
prelude : note generator: Pick one of several expressions and evaluate it.
Tags: random
expr⁺ :: Quoted [] — Expression to evaluate.
alt-t -- alternate-tracks
prelude : note generator: Evaluate notes from one of the sub-tracks.
Tags: random, subs
weight^* :: Signal [] — Likelihood to choose each child track. Each number is a relative weight, and tracks without a number default to 1. It's an error to have more numbers than tracks.
alt-w -- alternate-weighted
prelude : note generator: Pick one of several expressions and evaluate it.
Tags: random
expr⁺ :: (Signal, Quoted) [] — (weight, expr) pairs.
ap -- ap prelude : note generator: Derive sub events with no changes. This is used to apply a transformer to sub events.
Tags: subs
apply-attributes -- apply-attributes
prelude : note transformer: Apply attributes by control signal. This looks for controls with a attr- prefix. A control named attr-a-b will, when non-zero, add the +a+b attributes to its events.
Tags: postproc
apply-start-offset -- apply-start-offset
prelude : note transformer: Apply the start-offset-val env var. This is set by note deriver from the start-s and start-t controls, so if you want those controls to have an effect, you have to use this postproc.
Tags: postproc
min-duration :: Maybe Signal (RealTime) = _ [*-min-duration] — If given, notes on the same hand won't be moved closer than this time. Otherwise, hand and instrument is ignored.
attr -- note
prelude : note generator: A note with attributes or instrument.
If there are notes in child tracks, apply the transformation to them. Otherwise apply the transformation to the null note call.
Tags: subs
attr^* :: Str or Attributes [] — Set instrument or add attributes.
attr -- note
prelude : note transformer: A note with attributes or instrument.
attr^* :: Str or Attributes [] — Set instrument or add attributes.
avoid-overlap -- avoid-overlap
prelude : note transformer: Notes with the same instrument and starting pitch are shortened so they don't overlap with each other. This simulates keyboard instruments, where you have to release a key before striking the same key again. This also happens to be what MIDI expects, since it's based on keyboards.
Tags: inst, postproc
time :: Signal (RealTime) = .1 [*-time] — Ensure at least this much time between two notes of the same pitch.
cancel -- cancel
prelude : note transformer: Process the 'Derive.Flags.strong' and 'Derive.Flags.weak' flags. This will cause notes to be dropped.
Tags: postproc
final-duration :: Signal (RealTime) = 1s [final-duration] — If there is no following note, infer this duration.
cf-sample -- cf-sample
prelude : note transformer: Sample the given control functions and insert them as constants in the control map. The default note call expects continuous signals, so it takes slices out of the control map. This transfers control functions to the control map, so you can e.g. use randomized controls.
Tags: control-function
control⁺ :: Control ([a-z][a-z0-9.-]*) [] — Sample these control functions.
Clip -- Clip
prelude : note transformer: Like clip, but align the named block to the end of the event instead of the beginning. Events that then lie before the start are clipped.
clip -- clip
prelude : note transformer: Unstretch the deriver to its natural duration, and clip events that lie beyond the end of the event. Notes that overlap the end of the event will be cut short.
This is only useful with calls that have a natural duration apart from whatever their calling event's duration, e.g. block calls.
cycle -- cycle
prelude : note generator: Apply transformers in a cycle to the sub events.
Tags: subs
transformer⁺ :: Quoted [] — Transformers to apply.
cycle-t -- cycle-t
prelude : note generator: Apply transformers in a cycle to the sub events. This is like 'cycle', except that it also gets a duration for each transformer, and cycles in the given rhythm, rather than for each event.
Tags: subs
transformer⁺ :: (Quoted, Signal) [] — Transformers to apply, and the ScoreTime duration for each transformer.
d -- delay
prelude : note transformer: Simple abstract delay. As with echo, abstract means it happens in the score, so events may not be delayed evenly if the tempo is changing.
Tags: ly
time :: time signal (default real) = .1s [*-time] — Delay time.
debug -- debug
prelude : note transformer: Save the events at this point in a special log msg. This is useful to inspect events at a certain point in a pipeline. You can extract them later by looking at the Log.msg_data of a log msg with the given tag.
tag :: Str [*-tag] — Log msg has this text.
default-merge -- default-merge
prelude : note transformer: Set the default merge operators for controls. These apply when the control track doesn't have an explicit operator.
merge :: Str [*-merge] — Merge operator. This can be default to use the default for the control, set to replace the old signal, or one of the operators from 'Derive.Deriver.Monad.mergers': add, mul, scale, set, sub. There are also symbolic aliases, to support =+ syntax: {"*": "mul", "+": "add", "-": "sub", "@": "scale"}
control⁺ :: Control ([a-z][a-z0-9.-]*) [] — Control names.
drop -- drop
prelude : note transformer: Drop pitch and dyn at the end of the note.
Tags: under-invert
interval :: Signal (Transposition) or Pitch = 7c [*-interval] — Interval or destination pitch.
time :: Signal (Time, default real) = .25s [*-time] — Time to the destination pitch.
fade :: Maybe Signal (Time, default real) = _ [*-fade] — Time to fade from or to nothing. If the fade is longer than the pitch time, the pitch will finish moving before the dyn has faded out.
curve^env :: PFunction = curve-linear [curve, *-curve] — Curve function.
Drop -- Drop
prelude : note transformer: Like Lift, but attack the note from a higher neighbor.
Tags: under-invert
interval :: Signal (Transposition) or Pitch = 7c [*-interval] — Interval or destination pitch.
time :: Signal (Time, default real) = .25s [*-time] — Time to the destination pitch.
fade :: Maybe Signal (Time, default real) = _ [*-fade] — Time to fade from or to nothing. If the fade is longer than the pitch time, the pitch will finish moving before the dyn has faded out.
curve^env :: PFunction = curve-linear [curve, *-curve] — Curve function.
e-echo -- e-echo
prelude : note transformer: Concrete echo. All events are delayed by the same amount. Also, the parameter signals are sampled at every event, so they can vary over the course of the echo.
Tags: postproc
delay :: untyped signal = 1s [*-delay] — Delay time.
feedback :: untyped signal = .4 [*-feedback] — The dyn of each echo is multiplied by this amount.
times :: untyped signal = 1 [*-times] — Number of echoes, not counting the original.
e-interpolate -- e-interpolate
prelude : note generator: Interpolate rhythms of the transformed sequence.
Tags: subs
notes :: Maybe Quoted = _ [*-notes] — source deriver
model :: Maybe Quoted = _ [*-model] — rhythm model
at :: untyped signal = 0 [at, *-at] — interpolate position
echo -- echo
prelude : note transformer: Abstract echo. This means the echoes happen in score time, so they will change tempo with the rest of the score, and their derivation may change due to different dynamics.
The controls are only sampled at the beginning of the echo, so you can't vary them over the scope of the echo like you can with e-echo.
delay :: Signal (ScoreTime) = 1t [*-delay] — Delay time.
feedback :: Signal = .4 [*-feedback] — The %dyn of each echo is multiplied by this amount.
times :: Signal (integral) = 1 [*-times] — Number of echoes, not counting the original.
extend-duration -- extend-duration
prelude : note transformer: Extend the duration of notes with certain attributes. This is appropriate for attributes like +stac, which might already have their own built-in duration, and sound better when given as much time to ring as possible.
Tags: postproc
attrs :: list of Attributes [*-attrs] — Extend durations of notes with these attrs.
dur :: Signal (RealTime) = 2s [*-dur] — Extend to a minimum of this duration.
g -- grace
prelude : note generator: Emit grace notes. The grace notes go through the ( call, so they will overlap or apply a keyswitch, or do whatever ( does.
Tags: ly, ornament
pitch^* :: Pitch or Signal [] — Grace note pitches. If they are numbers, they are taken as transpositions and must all be the same type, defaulting to diatonic.
grace-dyn^env :: Signal (>=0) = .5 [grace-dyn] — Scale the dyn of the grace notes.
dur^env :: Signal (Time, default real) = .083s [dur, *-dur] — Duration of grace notes.
place^env :: Signal (0 <= x <= 1) = 0 [place, *-place] — At 0, grace notes fall before their base note. At 1, grace notes fall on the base note, and the base note is delayed.
g- -- grace
prelude : note generator: Like g, but doesn't use (, and all notes are held to the duration of the event.
Tags: ly, ornament
pitch^* :: Pitch or Signal [] — Grace note pitches. If they are numbers, they are taken as transpositions and must all be the same type, defaulting to diatonic.
grace-dyn^env :: Signal (>=0) = .5 [grace-dyn] — Scale the dyn of the grace notes.
dur^env :: Signal (Time, default real) = .083s [dur, *-dur] — Duration of grace notes.
place^env :: Signal (0 <= x <= 1) = 0 [place, *-place] — At 0, grace notes fall before their base note. At 1, grace notes fall on the base note, and the base note is delayed.
g_ -- grace
prelude : note generator: Grace notes realized as one note with a pitch curve, rather than separate notes.
Tags: ly, ornament
pitch^* :: Pitch or Signal [] — Grace note pitches. If they are numbers, they are taken as transpositions and must all be the same type, defaulting to diatonic.
dur^env :: Signal (Time, default real) = .083s [dur, *-dur] — Duration of grace notes.
place^env :: Signal (0 <= x <= 1) = 0 [place, *-place] — At 0, grace notes fall before their base note. At 1, grace notes fall on the base note, and the base note is delayed.
grace -- basic-grace
prelude : note generator: This a grace call where all arguments are required. The idea is that this will be used as the implementation of more specific ornaments, perhaps defined in a definitions file.
Tags: ly, ornament
pitches :: list of Pitch or Signal [] — Grace note pitches. If they are numbers, they are taken as transpositions and must all be the same type, defaulting to diatonic.
dur :: Signal (Time) [] — Duration of grace notes.
place :: Signal (0 <= x <= 1) [] — At 0, grace notes fall before their base note. At 1, grace notes fall on the base note, and the base note is delayed.
transformer :: Maybe Quoted = _ [] — Apply a transformer to grace notes.
h -- hold
prelude : note transformer: Set the 'Derive.EnvKey.hold' environ variable.
time :: Signal (Time, default real) = .25s [*-time] — Hold this long.
highlight -- highlight
prelude : note transformer: Add a highlight color.
highlight :: Str (nohighlight notice warning error) [*-highlight] — Highlight code.
highlight-out-of-range -- highlight-out-of-range
prelude : note transformer: Error on notes whose initial pitch is below inst-bottom or above inst-top. The range must be in NNs.
highlight-strings -- highlight-strings
prelude : note transformer: Highlight any notes whose initial pitch either is or isn't in open-strings.
open^env :: Str (f t) = f [*-open] — If true, put Info on open strings, else put Warning on non-open ones.
if-c< -- if-c<
prelude : note generator
if-c> -- if-c<: Derive based on the value of a control.
control :: Control ([a-z][a-z0-9.-]*) [*-control] — Test this control.
tests⁺ :: Val [] — (value, expr) pairs.
if-e -- if-e
prelude : note generator: Derive based on the value of an environment variable.
name :: Str [*-name] — Environ key.
value :: Maybe Val = _ [*-value] — Environ value. If not given, require only that the environ key is set.
true :: Quoted [*-true] — Eval if true.
false :: Quoted [*-false] — Eval if false.
import -- import
prelude : note transformer: Import the given modules into scope. Calls of all types (note, control, pitch, val) are imported. If names clash, the ones from later modules win.
module⁺ :: Str [] — Import these modules.
imports -- import-symbol
prelude : note transformer: Import a single symbol, or list of symbols. This imports from all namespaces simultaneously: note, control, pitch, and val. TODO fix it if it's a problem.
module :: Str [*-module] — Import this module.
symbol⁺ :: Str [] — Import these symbols.
infer-dur -- infer-dur
prelude : note transformer: Add 'Derive.Flags.infer_duration' to the events.
Tags: postproc
infer-hands -- infer-hands
prelude : note transformer: Infer hand=l and hand=r for the two tracks explicitly named with the same instrument. >2 tracks is an error. This only sets hand if it isn't already set.
infer-negative -- infer-negative
prelude : note transformer: Infer durations for negative events, by instrument.
Tags: postproc
heuristic :: Str = note [*-heuristic] — doc
final-duration :: Signal (RealTime) = 1s [final-duration] — If there is no following note, infer this duration.
initialize -- initialize
prelude : note transformer: Emit initialization controls for im instruments.
inst :: Str [*-inst] — Instrument to initialize.
control,val^* :: (Control ([a-z][a-z0-9.-]*), list of Signal or Pitch) [] — (control, val) pairs. If the val is a list, expect the instrument to have that many elements, and set the control for each element.
interpolate -- interpolate
prelude : note generator: Interpolate between multiple sub-tracks, each of which must have the same number of events. This interpolates rhythm only. To interpolate pitch and controls, it would need to work at the score event level, rather than ui events.
Tags: subs
at :: untyped signal = 0 [at, *-at] — interpolate position
Lift -- Lift
prelude : note transformer: Attack the note from a lower neighbor. This is like the n pitch call, but it's a note call, and it fades in dyn at the same time.
Tags: under-invert
interval :: Signal (Transposition) or Pitch = 7c [*-interval] — Interval or destination pitch.
time :: Signal (Time, default real) = .25s [*-time] — Time to the destination pitch.
fade :: Maybe Signal (Time, default real) = _ [*-fade] — Time to fade from or to nothing. If the fade is longer than the pitch time, the pitch will finish moving before the dyn has faded out.
curve^env :: PFunction = curve-linear [curve, *-curve] — Curve function.
lift -- lift
prelude : note transformer: Raise pitch and drop dyn at the end of the note. Same as the drop note call, except it defaults to going up instead of down.
Tags: under-invert
interval :: Signal (Transposition) or Pitch = 7c [*-interval] — Interval or destination pitch.
time :: Signal (Time, default real) = .25s [*-time] — Time to the destination pitch.
fade :: Maybe Signal (Time, default real) = _ [*-fade] — Time to fade from or to nothing. If the fade is longer than the pitch time, the pitch will finish moving before the dyn has faded out.
curve^env :: PFunction = curve-linear [curve, *-curve] — Curve function.
log-seed -- log-seed
prelude : note transformer: Emit a log message with the seed at this point. If you like how a generator realized, and want to freeze it, then you can use this to get the seed, and then hardcode it with seed=xyz.
loop -- loop
prelude : note transformer: This is similar to clip, but when the called note runs out, it is repeated.
mapc -- mapc
prelude : note transformer: Apply a signal transformer to the pitch or control signals of each event.
Tags: postproc
control :: Control ([a-z][a-z0-9.-]*) or PControl (#[a-z][a-z0-9.-]*) [*-control] — Apply to this control. Pitch signals start with #.
transformer :: Quoted [*-transformer] — Transformer to apply.
multiple -- multiple
prelude : note transformer: Derive the transformed score under different transformers.
transformer⁺ :: Quoted [] — Derive under each transformer.
note-track -- note-track
prelude : note transformer: This is the implicit call at the top of every note track. The first argument is the instrument named after the note track's >. If there is a note transformer of the same name as the instrument, starting with >, it will be called after setting the instrument. This way, you can set instrument-specific variables or transformations.
inst :: Maybe Str = _ [] — Set this instrument and run the transformer, if it exists.
o -- harmonic
prelude : note generator: Harmonic, with lilypond for natural and artificial harmonic notation.
If there are notes in child tracks, apply the transformation to them. Otherwise apply the transformation to the null note call.
Tags: attr, ly, subs
type :: Maybe Str (nat art) = _ [*-type] — Type of harmonic.
open-strings^env :: list of Pitch = (list) [open-strings] — Pitches of open strings.
string^env :: Maybe Pitch = _ [string] — Play on this string.
harmonic-force-diamond^env :: Str (f t) = f [harmonic-force-diamond] — If true, use string+diamond notation even for the 2nd natural harmonic.
o -- harmonic
prelude : note transformer: Harmonic, with lilypond for natural and artificial harmonic notation.
Tags: attr, ly
type :: Maybe Str (nat art) = _ [*-type] — Type of harmonic.
open-strings^env :: list of Pitch = (list) [open-strings] — Pitches of open strings.
string^env :: Maybe Pitch = _ [string] — Play on this string.
harmonic-force-diamond^env :: Str (f t) = f [harmonic-force-diamond] — If true, use string+diamond notation even for the 2nd natural harmonic.
omit -- omit
prelude : note transformer: Omit the derived call a certain percentage of the time.
Tags: random
chance :: Signal = .5 [*-chance] — Chance, from 0 to 1, that the transformed note will be omitted.
on-repeat -- on-repeat
prelude : note generator: Derive the argument indexed by the repeat variable, where an out of range index is clamped to be in range.
repeat⁺ :: Quoted [] — Eval on nth repeat.
parallel -- parallel
prelude : note generator: Run the given calls in parallel.
call⁺ :: Quoted [] — Generator calls.
pattern:attribute starting with `+` or `=` -- note with +example-attr
prelude : note transformer: Add attributes to the notes.
If there are notes in child tracks, apply the transformation to them. Otherwise apply the transformation to the null note call.
Tags: attr, subs
pattern:block name -- block (bid "example/block")
prelude : note generator: Substitute the named block into the score. If the symbol doesn't contain a /, the default namespace is applied. If it starts with a -, this is a relative call and the calling block's namespace and name are prepended.
Tags: prio-block
pizz-arp -- pizz-arp
prelude : note transformer: Arpeggiate simultaneous notes with +pizz. The order is arbitrary but probably in track order. TODO sort by pitch?
Tags: inst, postproc
time :: Signal (RealTime) = .02s [*-time] — Insert this much time between each note.
randomize-start -- randomize-start
prelude : note transformer: A static macro for: apply-start-offset | equal start-s (cf-rnd-a $).
Each $ is lifted to be an argument of this macro.
This directly calls the underlying sub-calls, so it's not dependent on the names they are bound to, which also means the macro text may not be a valid expression.
Tags: postproc
range :: Signal [*-range] — Range this far from the center.
repeat -- repeat
prelude : note transformer: Repeat the score multiple times, fitted within the note duration.
times :: Signal (integral, >0) [*-times] — Repeat this many times.
reverse -- reverse
prelude : note transformer: Reverse the events.
Tags: postproc
roll -- roll
prelude : note generator: These are like grace notes, but they all have the same pitch. The extra notes always fall before the main one, because trem covers the afterwards case.
Tags: ornament
times :: Signal = 1 [*-times] — Number of grace notes.
time :: Signal (Time, default real) = .083s [*-time] — Time between the strokes.
dyn :: Signal = .5 [*-dyn] — Dyn scale for the grace notes.
scale -- scale
prelude : note transformer: Bring a scale into scope.
scale :: Str [scale] — Look up scale by name.
args^* :: Val [] — Scale arguments.
sequence -- sequence
prelude : note generator: Run the given calls in sequence. If they each have have an intrinsic CallDuration (usually this means block calls), they will get that amount of time, at least proportial to the duration of the event. Otherwise, if none of them do, they are given equal duration. If some do and some don't, you probably get confusing results.
call⁺ :: Quoted [] — Generator calls.
sequence-rt -- sequence-rt
prelude : note generator: Run the given block calls in sequence. Each call gets its natural real time duration. Unlike sequence, each block gets its natural RealTime duration, rather than being normalized to 1 and then expanded to its ScoreTime duration. TODO I can't get the RealTime duration without deriving, at which point it's too late to stretch, so the event duration has no effect.
call⁺ :: Quoted [] — Generator calls.
slur-dur -- slur-dur
prelude : note transformer: Merge groups of notes into one note, where the pitch is taken from each merged note. The groups are by duration.
Tags: postproc
dur :: Signal (Time, default score) [*-dur] — How long each group is.
offset :: Signal (Time, default score) = 0t [*-offset] — Groups start at this time.
slur-n -- slur-n
prelude : note transformer: Merge groups of notes into one note, where the pitch is taken from each merged note. The groups are of a fixed size.
Tags: postproc
group :: Signal (integral) [*-group] — How many notes in a group.
solo -- solo
prelude : note transformer: Only derive if inst is set to the given value. This is a specialized version of when-e.
inst :: Str [*-inst] — Instrument.
strong -- strong
prelude : note transformer: Add the 'Derive.Flags.strong' flag, which will cancel coincident non-strong notes.
Tags: postproc
sus -- sus
prelude : note transformer: Simple legato, extend the duration of the transformed notes by the given amount. This works by setting sus.
amount :: Signal = 1.5 [*-amount] — Multiply the note's duration by this.
sus-a -- sus-a
prelude : note transformer: Simple legato, extend the duration of the transformed notes by the given amount. This works by setting sus-abs.
time :: Signal (Time, default real) = .25s [*-time] — Add this duration to the note.
t -- tuplet
prelude : note generator
tup -- tuplet: A generalized tuplet. The notes within its scope are stretched so that their collective duration is the same as the tuplet's duration.
This doesn't work so well for zero duration notes. The last note winds up at the end of the tuplet, which is not very useful. But zero duration is common for percussion, so there's a hack to cover this case: if there are >1 equidistant zero duration sub events, the distance between them is considered their implicit duration.
If there are multiple note tracks, they get the stretch of the longest one. This is so the timing will come out right if some of the notes are chords.
subtrack^* :: note deriver [] — Subtrack to stretch.
t-alt -- tempo-alternate
prelude : note generator: Derive alternate calls depending on the tempo, for Javanese-style wirama transitions. For instance, a 1/8 b 1/4 c will play a when an 8th note is between 0 and 1/8s, b when it's between 1/8s and 1/4s, and c when it's above 1/4s.
bottom :: Quoted [] — Default alternate.
threshold,expr^* :: (Signal (RealTime), Quoted) [] — Evaluate the expr if the tempo is above the threshold. The thresholds should be in ascending order, so the fastest alternate is at the left.
timestep^env :: Str (section w h q e s t32 t64 t128 t256) = e [*-timestep] — Use the duration of this timestep, in seconds.
t-alt-c -- tempo-alternate-continuous
prelude : note generator: Derive alternate calls depending on the tempo, for Javanese-style wirama transitions. For instance, a 1/8 b 1/4 c will play a when an 8th note is between 0 and 1/8s, b when it's between 1/8s and 1/4s, and c when it's above 1/4s.
This variant will switch between the alternates even in the middle of the call. Long notes will be clipped at the transition point.
bottom :: Quoted [] — Default alternate.
threshold,expr^* :: (Signal (RealTime), Quoted) [] — Evaluate the expr if the tempo is above the threshold. The thresholds should be in ascending order, so the fastest alternate is at the left.
timestep^env :: Str (section w h q e s t32 t64 t128 t256) = e [*-timestep] — Use the duration of this timestep, in seconds.
interval^env :: Str (section w h q e s t32 t64 t128 t256) = q [*-interval] — Switch between alternates at this time interval.
tile -- tile
prelude : note transformer: This is like loop, but it can start the looped call in its middle instead of starting from 0. The effect is as if the loop is tiled from the beginning of the called block, and is only "let through" during the tile call. This is useful for patterns that are tied to the meter, but may be interrupted at arbitrary times, e.g. sarvalaghu patterns.
tr -- tr prelude : note generator: Generate a note with a trill.
Unlike a trill on a pitch track, this generates events for each note of the trill. This is more appropriate for fingered trills, or monophonic instruments that use legato to play slurred notes.
Instruments that support +trill attributes should enable the attributes version, which emits a single note with +trill+half, +trill+whole, or all the notes with +trill, depending on the interval.
Tags: ly
neighbor :: transpose signal (default diatonic) or Pitch = 1 [*-neighbor] — Alternate with an interval or pitch.
speed :: time signal (default real) = 14 [*-speed] — Trill at this speed. If it's a RealTime, the value is the number of cycles per second, which will be unaffected by the tempo. If it's a ScoreTime, the value is the number of cycles per ScoreTime unit, and will stretch along with tempo changes. In either case, this will emit only whole notes, i.e. it will end sooner to avoid emitting a cut-off note at the end.
tr-start^env :: Maybe Str (high low) = _ [tr-start] — Which note the trill starts with. If not given, it will start the unison note, which means it may move up or down.
tr-end^env :: Maybe Str (high low) = _ [tr-end] — Which note the trill ends with. If not given, it can end with either.
hold^env :: Signal (Time, default real) = 0s [hold, *-hold] — Time to hold the first note.
adjust^env :: Str (shorten stretch) = shorten [adjust, *-adjust] — How to adjust a trill to fulfill its start and end pitch restrictions.
tr-bias^env :: Signal (-1 <= x <= 1) = 0 [tr-bias] — Offset every other transition by this amount.
tr-style^env :: Str (tr span tremolo) = tr [tr-style] — Notation variant: tr symbol, tr~, or tremolo.
tr-^ -- tr prelude : note generator
tr-_ -- tr: Generate a note with a trill.
Unlike a trill on a pitch track, this generates events for each note of the trill. This is more appropriate for fingered trills, or monophonic instruments that use legato to play slurred notes.
Instruments that support +trill attributes should enable the attributes version, which emits a single note with +trill+half, +trill+whole, or all the notes with +trill, depending on the interval.
A ^ suffix makes the trill starts on the higher value, while _ makes it start on the lower value. A second suffix causes it to end on the higher or lower value, e.g. ^_ starts high and ends low. -_ has start unspecified, and ends low. No suffix causes it to obey the settings in scope.
Tags: ly
neighbor :: transpose signal (default diatonic) or Pitch = 1 [*-neighbor] — Alternate with an interval or pitch.
speed :: time signal (default real) = 14 [*-speed] — Trill at this speed. If it's a RealTime, the value is the number of cycles per second, which will be unaffected by the tempo. If it's a ScoreTime, the value is the number of cycles per ScoreTime unit, and will stretch along with tempo changes. In either case, this will emit only whole notes, i.e. it will end sooner to avoid emitting a cut-off note at the end.
tr-start^env :: Maybe Str (high low) = _ [tr-start] — Which note the trill starts with. If not given, it will start the unison note, which means it may move up or down.
hold^env :: Signal (Time, default real) = 0s [hold, *-hold] — Time to hold the first note.
adjust^env :: Str (shorten stretch) = shorten [adjust, *-adjust] — How to adjust a trill to fulfill its start and end pitch restrictions.
tr-bias^env :: Signal (-1 <= x <= 1) = 0 [tr-bias] — Offset every other transition by this amount.
tr-style^env :: Str (tr span tremolo) = tr [tr-style] — Notation variant: tr symbol, tr~, or tremolo.
tr^ -- tr prelude : note generator
tr_ -- tr: Generate a note with a trill.
Unlike a trill on a pitch track, this generates events for each note of the trill. This is more appropriate for fingered trills, or monophonic instruments that use legato to play slurred notes.
Instruments that support +trill attributes should enable the attributes version, which emits a single note with +trill+half, +trill+whole, or all the notes with +trill, depending on the interval.
A ^ suffix makes the trill starts on the higher value, while _ makes it start on the lower value. A second suffix causes it to end on the higher or lower value, e.g. ^_ starts high and ends low. -_ has start unspecified, and ends low. No suffix causes it to obey the settings in scope.
Tags: ly
neighbor :: transpose signal (default diatonic) or Pitch = 1 [*-neighbor] — Alternate with an interval or pitch.
speed :: time signal (default real) = 14 [*-speed] — Trill at this speed. If it's a RealTime, the value is the number of cycles per second, which will be unaffected by the tempo. If it's a ScoreTime, the value is the number of cycles per ScoreTime unit, and will stretch along with tempo changes. In either case, this will emit only whole notes, i.e. it will end sooner to avoid emitting a cut-off note at the end.
tr-end^env :: Maybe Str (high low) = _ [tr-end] — Which note the trill ends with. If not given, it can end with either.
hold^env :: Signal (Time, default real) = 0s [hold, *-hold] — Time to hold the first note.
adjust^env :: Str (shorten stretch) = shorten [adjust, *-adjust] — How to adjust a trill to fulfill its start and end pitch restrictions.
tr-bias^env :: Signal (-1 <= x <= 1) = 0 [tr-bias] — Offset every other transition by this amount.
tr-style^env :: Str (tr span tremolo) = tr [tr-style] — Notation variant: tr symbol, tr~, or tremolo.
tr^^ -- tr prelude : note generator
tr^_ -- tr
tr_^ -- tr
tr__ -- tr: Generate a note with a trill.
Unlike a trill on a pitch track, this generates events for each note of the trill. This is more appropriate for fingered trills, or monophonic instruments that use legato to play slurred notes.
Instruments that support +trill attributes should enable the attributes version, which emits a single note with +trill+half, +trill+whole, or all the notes with +trill, depending on the interval.
A ^ suffix makes the trill starts on the higher value, while _ makes it start on the lower value. A second suffix causes it to end on the higher or lower value, e.g. ^_ starts high and ends low. -_ has start unspecified, and ends low. No suffix causes it to obey the settings in scope.
Tags: ly
neighbor :: transpose signal (default diatonic) or Pitch = 1 [*-neighbor] — Alternate with an interval or pitch.
speed :: time signal (default real) = 14 [*-speed] — Trill at this speed. If it's a RealTime, the value is the number of cycles per second, which will be unaffected by the tempo. If it's a ScoreTime, the value is the number of cycles per ScoreTime unit, and will stretch along with tempo changes. In either case, this will emit only whole notes, i.e. it will end sooner to avoid emitting a cut-off note at the end.
hold^env :: Signal (Time, default real) = 0s [hold, *-hold] — Time to hold the first note.
adjust^env :: Str (shorten stretch) = shorten [adjust, *-adjust] — How to adjust a trill to fulfill its start and end pitch restrictions.
tr-bias^env :: Signal (-1 <= x <= 1) = 0 [tr-bias] — Offset every other transition by this amount.
tr-style^env :: Str (tr span tremolo) = tr [tr-style] — Notation variant: tr symbol, tr~, or tremolo.
trem -- trem
prelude : note generator: Repeat a single note. Or, if there are sub-notes, alternate with each of the sub-notes in turn.
Tags: ly
speed :: time signal (default real) = 10 [speed, *-speed] — Repeat at this speed. If it's a RealTime, the value is the number of repeats per second, which will be unaffected by the tempo. If it's a ScoreTime, the value is the number of repeats per ScoreTime unit, and will stretch along with tempo changes.
hold^env :: Signal (Time, default real) = 0s [hold, *-hold] — Time to hold the first note.
trem -- trem
prelude : note transformer: Repeat the transformed note. The generator is creating the notes so it can set them to the appropriate duration, but this one has to stretch them to fit.
Tags: subs
speed :: time signal (default real) = 10 [speed, *-speed] — Repeat at this speed. If it's a RealTime, the value is the number of repeats per second, which will be unaffected by the tempo. If it's a ScoreTime, the value is the number of repeats per ScoreTime unit, and will stretch along with tempo changes.
hold^env :: Signal (Time, default real) = 0s [hold, *-hold] — Time to hold the first note.
unless-c -- when-c
prelude : note transformer
when-c -- when-c: Only derive if the control has the given value. E.g., you can use a %var control to select among different variations.
val :: Signal (integral) [*-val] — Value.
control :: Signal = 0 [*-control] — Control.
unless-e -- when-e
prelude : note transformer
when-e -- when-e: Only derive if environ value is set to the given value. In a block derived multiple times by different instruments, this can be used to solo a bit of score to one particular instrument.
name :: Str [*-name] — Environ key.
value :: Maybe Val = _ [*-value] — Environ value. If not given, require only that the environ key is set.
v -- accent
prelude : note generator: Accent the note by multiplying its dynamic.
If there are notes in child tracks, apply the transformation to them. Otherwise apply the transformation to the null note call.
Tags: ly, subs
dyn :: Signal = 1.5 [*-dyn] — Multiply dynamic.
v -- accent
prelude : note transformer: Accent the note by multiplying its dynamic.
Tags: ly
dyn :: Signal = 1.5 [*-dyn] — Multiply dynamic.
weak -- weak
prelude : note transformer: Add the 'Derive.Flags.weak' flag, which will cause this to be cancelled by coincident non-weak notes.
Tags: postproc
zero-duration-mute -- zero-duration-mute
prelude : note transformer: Add attributes to zero duration events.
Tags: inst, postproc
attr :: Attributes = +mute [*-attr] — Add this attribute.
dyn :: Signal = .75 [*-dyn] — Scale dynamic by this amount.
realize-retune -- retune-realize
retune : note transformer: Perform annotations added by retune.
Tags: realize-delayed
retune -- retune
retune : note transformer: Notes start with some detuning, and adjust to the desired pitch. This effect is scaled by the time and pitch distance from the previous note, as documeneted in 'Derive.Call.Post.Retune.pitch_scale'.
Tags: delayed
time :: Signal (RealTime) = .15 [*-time] — RealTime to get to the intended pitch.
dist :: Signal (NN) = .15 [*-dist] — Out of tune distance, in NNs. Presumably this should be set to a control function with a bimodal distribution.

control

^kam -- kam
india.gamakam : control generator
^kam^ -- kam
^kam_ -- kam
_kam -- kam
_kam^ -- kam
_kam_ -- kam
kam -- kam
kam^ -- kam
kam_ -- kam: This is a trill with smooth transitions between the notes. It's intended for the microtonal vocal trills common in Carnatic music. ^ is high and _ is low, so ^kam_ starts on the upper note, and ends on the lower one. Otherwise, it starts on the unison note and ends on either.
neighbor :: untyped signal = 1 [*-neighbor] — Alternate between 0 and this value.
speed :: time signal (default real) = 6 [*-speed] — Alternate pitches at this speed.
transition :: Signal (RealTime) = .08s [transition, *-transition] — Time for each slide.
hold^env :: Signal (Time, default real) = 0s [hold, *-hold] — Time to hold the first note.
lilt^env :: Signal = 0 [lilt, *-lilt] — Lilt is a horizontal bias to the vibrato. A lilt of 1 would place each neighbor on top of the following unison, while -1 would place it on the previous one. So it should range from -1 < lilt < 1.
adjust^env :: Str (shorten stretch) = shorten [adjust, *-adjust] — How to adjust a trill to fulfill its start and end pitch restrictions.
^nkam -- nkam
india.gamakam : control generator
^nkam^ -- nkam
^nkam_ -- nkam
_nkam -- nkam
_nkam^ -- nkam
_nkam_ -- nkam
nkam -- nkam
nkam^ -- nkam
nkam_ -- nkam: kam with a set number of cycles. The speed adjusts to fit the cycles in before the next event.
neighbor :: untyped signal = 1 [*-neighbor] — Alternate between 0 and this value.
cycles :: Signal (>0) = 1 [*-cycles] — Number of cycles.
lilt^env :: Signal = 0 [lilt, *-lilt] — Lilt is a horizontal bias to the vibrato. A lilt of 1 would place each neighbor on top of the following unison, while -1 would place it on the previous one. So it should range from -1 < lilt < 1.
hold^env :: Signal (Time, default real) = 0s [hold, *-hold] — Time to hold the first note.
transition^env :: Signal (RealTime) = .08s [transition, *-transition] — Time for each slide.
dip -- dip
india.gamakam : control generator: Alternate two intervals, dropping dyn on the second. This is useful when avoiding a swaram, since it doesn't necessarily emit the base pitch.
high :: Signal = 1 [*-high] — High interval.
low :: Signal = -1 [*-low] — Low interval.
speed :: time signal (default real) = 6 [*-speed] — Alternate pitches at this speed.
dyn :: Signal = .5 [*-dyn] — Multiply dyn by this amount.
transition^env :: Signal (RealTime) = .08s [transition, *-transition] — Time for each slide.
j) -- j) india.gamakam : control generator: This is a series of grace notes with relative pitches.
interval⁺ :: Signal [] — Intervals from base pitch.
time^env :: Signal (RealTime) = .15s [time, *-time] — Time for each note.
transition^env :: Maybe Signal (RealTime) = _ [transition, *-transition] — Time for each slide, defaults to time.
j] -- j] india.gamakam : control generator: This is a series of grace notes with relative pitches.
interval⁺ :: Signal [] — Intervals from base pitch.
time^env :: Signal (RealTime) = .15s [time, *-time] — Time for each note.
transition^env :: Maybe Signal (RealTime) = .075s [transition, *-transition] — Time for each slide.
sgr -- jaru
india.gamakam : control generator: This is jaru hardcoded to [-1, 1].
time :: Signal (RealTime) = .15s [*-time] — Time for each note.
transition :: Maybe Signal (RealTime) = _ [*-transition] — Time for each slide, defaults to time.
dyn -- dyn
india.gamakam5 : control transformer: Import calls for a dyn track.
gamak -- gamak
india.gamakam5 : control transformer: Import calls for a gamakam track.
! -- dyn-sequence
india.gamakam5.dyn : control generator: This is a mini-language, where each one or two characters is a call. Each character can take an argument, which can only be a single digit. Typically this represents a dyn level / 9, so 0 is 0 and 9 is 1. Calls:. - Move to dyn.
< - Attack from 0.
= - No movement.
> - Decay to 0, with curve weights: (.8, 0)
T - Set from dyn.
a - Attack from previous value.
d - Decay to 0, with curve weights: (0, .8)

sequence :: Str [*-sequence] — Dyn calls.
! -- sequence
india.gamakam5.pitch : control generator: This is a mini-language, where each one or two characters is a call. An upper-case call will take a single character argument. A special parsing rule means that - and its following character is considered a single character, so -1 is a valid call or argument. Most of these calls represent a pitch movement:& - Set from pitch to next. (dur 0)
- - Negative relative motion.
. - Postfix call that modifies the duration of the previous call. _ adds 1 to it, . divides by 2. (dur 0)
0 - Relative motion.
1 - Relative motion.
2 - Relative motion.
3 - Relative motion.
4 - Relative motion.
5 - Relative motion.
6 - Relative motion.
7 - Relative motion.
8 - Relative motion.
9 - Relative motion.
< - Set from pitch to previous. (dur 0)
= - Hold flat pitch.
F - Fast transition time. (dur 0)
M - Medium transition time. (dur 0)
S - Slow transition time. (dur 0)
T - Set from pitch relative to swaram. (dur 0)
^ - Set from pitch to current. (dur 0)
_ - Postfix call that modifies the duration of the previous call. _ adds 1 to it, . divides by 2. (dur 0)
a - Negative relative motion.
b - Negative relative motion.
c - Negative relative motion.
e - Pitch up by 1nn.
f - Pitch down by 1nn.
g - Pitch up by .5nn.
h - Pitch down by .5nn.
n - Pitch up by 1nn. (dur .5); Pitch down by 1nn. (dur .5)
u - Pitch down by 1nn. (dur .5); Pitch up by 1nn. (dur .5)
v - Absolute motion to next pitch.
Currently the transition curve is hardcoded to a sigmoid curve, but I could add a curve env var if necessary.
sequence :: Str [*-sequence] — Pitch calls.
transition^env :: Signal (0 <= x <= 1) = .5 [transition, *-transition] — Time for each pitch movement, in proportion of the total time available.
gamakam-above^env :: Str (f t) = f [gamakam-above] — Expect pitch and gamakam tracks above the note track.
gamak -- gamak
india.gamakam6 : control transformer: Import calls for a gamakam track.
! -- sequence
india.gamakam6.pitch : control generator: This is a mini-language that describes a transposition curve. The grammar is a sequence of Pitch Duration | ']' Pitch | Alias. A plain Pitch moves to that pitch, ] Pitch sets the From running pitch to the given Pitch, but has zero duration, and Alias is a single letter, which is itself mapped to a sequence.
Pitch is [=<>][+\^v]? | #?[-9-9a-d]? [+\^v]?. =<> are the running From pitch, Prev pitch, or Next pitch, and [+\^v] add or subtract 1nn, or .5nn, respectively. A number is steps from the current swaram, and a-d are shorthand for -1 to -4.
Duration is a sequence of _ or ., where each one doubles or halves the duration. : and ; stand for short or long absolute duration.
Default aliases:
C - ]0
N - #0+.#0\
U - #0\.#0+.
n - #0^.#0v.
u - #0v.#0^.

sequence :: Str [*-sequence] — Pitch calls.
transition^env :: Signal (0 <= x <= 1) = .5 [transition, *-transition] — Time for each pitch movement, in proportion of the total time available.
' -- set-prev
prelude : control generator: Re-set the previous value. This can be used to extend a breakpoint.
Tags: prev
-> -- redirect
prelude : control transformer: Redirect a signal to another control, using the control modifier hack. The control is combined with the default merger for the control.
Tags: cmod
control :: Control ([a-z][a-z0-9.-]*) [*-control] — Redirect to this control.
->+ -- redirect
prelude : control transformer: Redirect a signal to another control, using the control modifier hack. The control is combined with add.
Tags: cmod
control :: Control ([a-z][a-z0-9.-]*) [*-control] — Redirect to this control.
= -- equal
prelude : control transformer: Evaluate the deriver with a value set. Special parser support means this can be called infix. The arguments can take many forms to set different kinds of values.
Set an environ value by setting a plain symbol or unset it by assigning to _: x = 42 or x = _.
Prefixes:
- >> - Create a note transformer, whose name will be prefixed with >. This is used to set an instrument transformer, which can apply a transformer when an instrument is set by the title of a note track, as implemented by by note-track.
- -val - Bind a val call.
- ^note, *pitch, .control - Bind the respective call type generator.
- ^-note, *-pitch, .-control - As above, but bind transformer.
- >alias = >inst - alias instrument name
E.g.: set note generator: ^phrase = some-block, note transformer: ^-mute = +mute+loose, control transfomrer: .-i = t, val call: -4c = (5c).
You can bypass all this cryptic prefix garbage by using a ky file. It has more space available so it can use a more readable syntax.
If you bind a call to a quoted expression, this creates a new call: ^abc = "(a b c) will create a abc call, which is a macro for a b c. The created call does not take arguments.
Set the default pitch signal with #, e.g. # = (4c) or # = 45nn. Control signal assignment also supports the same merge functions as the control track: a = .5 add or a = %b add. However, the second example throws an error if %b is a ControlFunction. a = .5 default will combine with a's default merge function. Assigning to _ unsets the control, and any ControlFunction.
The = operator can be suffixed with symbol, which will become the last argument, so %x=+1 becomes %x = 1 '+'. Note that the order is backwards from the usual +=, which is ultimately because the first word can have almost any character except space and =. Also, x=-1 is ambiguous, and parsed as x =- 1.
Tags: subs
lhs :: Str [] — Assign to this. This looks like a Str, but can actualy contain any characters except =, due to the special infix parsing for =. Symbolic prefixes determine what is assigned, and the valid types for the rhs.
rhs :: Val [] — Source of the assignment.
merge :: Str = set [*-merge] — Merge operator. This can be default to use the default for the control, set to replace the old signal, or one of the operators from 'Derive.Deriver.Monad.mergers': add, mul, scale, set, sub. There are also symbolic aliases, to support =+ syntax: {"*": "mul", "+": "add", "-": "sub", "@": "scale"}
`ped` -- pedal
prelude : control generator
ped -- pedal: Unlike most control events, this uses a duration. Set the control to the given value for the event's duration, and reset to the old value afterwards.
val :: Signal = 1 [*-val] — Set to this value.
dur^env :: Signal (RealTime) = .05 [*-dur] — Use this duration if the event duration is 0.
abs -- abs
prelude : control generator: Set the control to an absolute value, provided this control is combined via multiplication.
val :: Signal [*-val] — Set to this value.
alt -- alternate
prelude : control generator: Pick one of several expressions and evaluate it.
Tags: random
expr⁺ :: Quoted [] — Expression to evaluate.
alt-w -- alternate-weighted
prelude : control generator: Pick one of several expressions and evaluate it.
Tags: random
expr⁺ :: (Signal, Quoted) [] — (weight, expr) pairs.
bp> -- breakpoint
prelude : control generator: Interpolate between the given values. Breakpoints start at this event and end at the next one.
val⁺ :: Signal [] — Breakpoints are distributed evenly between this event and the next event.
bpm -- bpm
prelude : control generator: Set a tempo value for the given bpm, which is just (/60).
bpm :: Signal [*-bpm]
d -- d prelude : control generator: Descend at the given speed until the value reaches a limit or the next event.
Tags: prev
speed :: Signal = 1 [*-speed] — Descend this amount per second.
limit :: Signal = 0 [*-limit] — Stop at this value.
from^env :: Maybe Signal = _ [from, *-from] — Start from this value. If unset, use the previous value.
d -- delay
prelude : control transformer: Simple delay for control and pitch tracks.
time :: Signal (Time, default real) = .1s [*-time] — Delay time.
default-merge -- default-merge
prelude : control transformer: Set the default merge operators for controls. These apply when the control track doesn't have an explicit operator.
merge :: Str [*-merge] — Merge operator. This can be default to use the default for the control, set to replace the old signal, or one of the operators from 'Derive.Deriver.Monad.mergers': add, mul, scale, set, sub. There are also symbolic aliases, to support =+ syntax: {"*": "mul", "+": "add", "-": "sub", "@": "scale"}
control⁺ :: Control ([a-z][a-z0-9.-]*) [] — Control names.
df -- df prelude : control generator: Drop from a certain value. This is like d with from, but more convenient to write.
from :: Signal = 1 [*-from] — Start at this value.
speed :: Signal = 1 [*-speed] — Descend this amount per second.
limit :: Signal = 0 [*-limit] — Stop at this value.
dyn-f -- f prelude : control generator: Set the control to an absolute value. This is useful for the dyn control, so a part can override the dynamic in scope.
val :: Signal = .75 [*-val] — Set to this value.
dyn-ff -- ff prelude : control generator: Set the control to an absolute value. This is useful for the dyn control, so a part can override the dynamic in scope.
val :: Signal = .95 [*-val] — Set to this value.
dyn-mf -- mf prelude : control generator: Set the control to an absolute value. This is useful for the dyn control, so a part can override the dynamic in scope.
val :: Signal = .5 [*-val] — Set to this value.
dyn-p -- p prelude : control generator: Set the control to an absolute value. This is useful for the dyn control, so a part can override the dynamic in scope.
val :: Signal = .25 [*-val] — Set to this value.
dyn-pp -- pp prelude : control generator: Set the control to an absolute value. This is useful for the dyn control, so a part can override the dynamic in scope.
val :: Signal = .05 [*-val] — Set to this value.
e -- expon
prelude : control generator: Interpolate from the previous value to the given one. If the event's duration is 0, interpolate from the previous event to this one.
Tags: prev
to :: Signal [*-to] — Destination value.
expon :: Signal = 2 [*-expon] — Slope of an exponential curve. Positive n is taken as x^n and will generate a slowly departing and rapidly approaching curve. Negative -n is taken as x^1/n, which will generate a rapidly departing and slowly approaching curve.
from^env :: Maybe Signal = _ [from, *-from] — Start from this value. If unset, use the previous value.
e<< -- expon-prev-const
prelude : control generator: Interpolate from the previous value to the given one.
Tags: prev
to :: Signal [*-to] — Destination value.
time :: Signal (Time, default real) = .1s [*-time] — Time to reach destination, starting before the event.
expon :: Signal = 2 [*-expon] — Slope of an exponential curve. Positive n is taken as x^n and will generate a slowly departing and rapidly approaching curve. Negative -n is taken as x^1/n, which will generate a rapidly departing and slowly approaching curve.
from^env :: Maybe Signal = _ [from, *-from] — Start from this value. If unset, use the previous value.
e> -- expon-next
prelude : control generator: Interpolate from the previous value to the given one. If the event's duration is 0, interpolate from this event to the next.
Tags: prev
to :: Signal [*-to] — Destination value.
expon :: Signal = 2 [*-expon] — Slope of an exponential curve. Positive n is taken as x^n and will generate a slowly departing and rapidly approaching curve. Negative -n is taken as x^1/n, which will generate a rapidly departing and slowly approaching curve.
from^env :: Maybe Signal = _ [from, *-from] — Start from this value. If unset, use the previous value.
e>> -- expon-next-const
prelude : control generator: Interpolate from the previous value to the given one.
Tags: prev
to :: Signal [*-to] — Destination value.
time :: Signal (Time, default real) = .1s [*-time] — Time to reach destination.
expon :: Signal = 2 [*-expon] — Slope of an exponential curve. Positive n is taken as x^n and will generate a slowly departing and rapidly approaching curve. Negative -n is taken as x^1/n, which will generate a rapidly departing and slowly approaching curve.
from^env :: Maybe Signal = _ [from, *-from] — Start from this value. If unset, use the previous value.
h -- hold
prelude : control transformer: Set the 'Derive.EnvKey.hold' environ variable.
time :: Signal (Time, default real) = .25s [*-time] — Hold this long.
i -- linear
prelude : control generator: Interpolate from the previous value to the given one. If the event's duration is 0, interpolate from the previous event to this one.
Tags: prev
to :: Signal [*-to] — Destination value.
from^env :: Maybe Signal = _ [from, *-from] — Start from this value. If unset, use the previous value.
i<< -- linear-prev-const
prelude : control generator: Interpolate from the previous value to the given one.
Tags: prev
to :: Signal [*-to] — Destination value.
time :: Signal (Time, default real) = .1s [*-time] — Time to reach destination, starting before the event.
from^env :: Maybe Signal = _ [from, *-from] — Start from this value. If unset, use the previous value.
i> -- linear-next
prelude : control generator: Interpolate from the previous value to the given one. If the event's duration is 0, interpolate from this event to the next.
Tags: prev
to :: Signal [*-to] — Destination value.
from^env :: Maybe Signal = _ [from, *-from] — Start from this value. If unset, use the previous value.
i>> -- linear-next-const
prelude : control generator: Interpolate from the previous value to the given one.
Tags: prev
to :: Signal [*-to] — Destination value.
time :: Signal (Time, default real) = .1s [*-time] — Time to reach destination.
from^env :: Maybe Signal = _ [from, *-from] — Start from this value. If unset, use the previous value.
if-c< -- if-c<
prelude : control generator
if-c> -- if-c<: Derive based on the value of a control.
control :: Control ([a-z][a-z0-9.-]*) [*-control] — Test this control.
tests⁺ :: Val [] — (value, expr) pairs.
if-e -- if-e
prelude : control generator: Derive based on the value of an environment variable.
name :: Str [*-name] — Environ key.
value :: Maybe Val = _ [*-value] — Environ value. If not given, require only that the environ key is set.
true :: Quoted [*-true] — Eval if true.
false :: Quoted [*-false] — Eval if false.
import -- import
prelude : control transformer: Import the given modules into scope. Calls of all types (note, control, pitch, val) are imported. If names clash, the ones from later modules win.
module⁺ :: Str [] — Import these modules.
imports -- import-symbol
prelude : control transformer: Import a single symbol, or list of symbols. This imports from all namespaces simultaneously: note, control, pitch, and val. TODO fix it if it's a problem.
module :: Str [*-module] — Import this module.
symbol⁺ :: Str [] — Import these symbols.
log-seed -- log-seed
prelude : control transformer: Emit a log message with the seed at this point. If you like how a generator realized, and want to freeze it, then you can use this to get the seed, and then hardcode it with seed=xyz.
n -- neighbor
prelude : control generator: Emit a slide from a value to 0 in absolute time. This is the control equivalent of the neighbor pitch call.
neighbor :: Signal = 1 [*-neighbor] — Start at this value.
time :: Signal (Time, default real) = .1s [*-time] — Time taken to get to 0.
curve^env :: PFunction = curve-linear [curve, *-curve] — Curve function.
omit -- omit
prelude : control transformer: Omit the derived call a certain percentage of the time.
Tags: random
chance :: Signal = .5 [*-chance] — Chance, from 0 to 1, that the transformed note will be omitted.
on-repeat -- on-repeat
prelude : control generator: Derive the argument indexed by the repeat variable, where an out of range index is clamped to be in range.
repeat⁺ :: Quoted [] — Eval on nth repeat.
p -- porta
prelude : control generator: Interpolate between two values. This is similar to i>>, but intended to be higher level, in that instruments or scores can override it to represent an idiomatic portamento.
to :: Signal [*-to] — Destination value.
time :: Signal (Time, default real) = .1s [*-time] — Time to reach destination.
place :: Signal (0 <= x <= 1) = 1 [place, *-place] — Placement, from before to after the call.
from^env :: Maybe Signal = _ [from, *-from] — Start from this value. If unset, use the previous value.
curve^env :: PFunction = curve-linear [curve, *-curve] — Curve function.
pattern:block name -- control-block
prelude : control generator: Substitute the control signal from the named control block. A control block should consist of a single branch ending in a track named %. The signal from that track will be substituted.
pattern:numbers and hex -- set
prelude : control generator: Emit a sample with no interpolation. This accepts either decimal numbers or hex numbers that look like `0x`xx. The hex is divided by 255, so they represent a number between 0 and 1.
pattern:numbers and hex -- set
prelude : control transformer: Prepend a sample to a signal. This is useful to create a discontinuity, e.g. interpolate to a value and then jump to another one.
quantize -- quantize
prelude : control transformer: Quantize a control signal.
val :: Signal [*-val] — Quantize to multiples of this value.
s -- sigmoid
prelude : control generator: Interpolate from the previous value to the given one. If the event's duration is 0, interpolate from the previous event to this one.
Tags: prev
to :: Signal [*-to] — Destination value.
w1 :: Signal = .5 [*-w1] — Start weight.
w2 :: Signal = .5 [*-w2] — End weight.
from^env :: Maybe Signal = _ [from, *-from] — Start from this value. If unset, use the previous value.
s<< -- sigmoid-prev-const
prelude : control generator: Interpolate from the previous value to the given one.
Tags: prev
to :: Signal [*-to] — Destination value.
time :: Signal (Time, default real) = .1s [*-time] — Time to reach destination, starting before the event.
w1 :: Signal = .5 [*-w1] — Start weight.
w2 :: Signal = .5 [*-w2] — End weight.
from^env :: Maybe Signal = _ [from, *-from] — Start from this value. If unset, use the previous value.
s> -- sigmoid-next
prelude : control generator: Interpolate from the previous value to the given one. If the event's duration is 0, interpolate from this event to the next.
Tags: prev
to :: Signal [*-to] — Destination value.
w1 :: Signal = .5 [*-w1] — Start weight.
w2 :: Signal = .5 [*-w2] — End weight.
from^env :: Maybe Signal = _ [from, *-from] — Start from this value. If unset, use the previous value.
s>> -- sigmoid-next-const
prelude : control generator: Interpolate from the previous value to the given one.
Tags: prev
to :: Signal [*-to] — Destination value.
time :: Signal (Time, default real) = .1s [*-time] — Time to reach destination.
w1 :: Signal = .5 [*-w1] — Start weight.
w2 :: Signal = .5 [*-w2] — End weight.
from^env :: Maybe Signal = _ [from, *-from] — Start from this value. If unset, use the previous value.
saw -- saw
prelude : control generator: Emit a sawtooth. By default it has a downward slope, but you can make an upward slope by setting from and to.
speed :: time signal (default real) = 10 [speed, *-speed] — Repeat at this speed. If it's a RealTime, the value is the number of repeats per second, which will be unaffected by the tempo. If it's a ScoreTime, the value is the number of repeats per ScoreTime unit, and will stretch along with tempo changes.
from :: Signal = 1 [*-from] — Start from this value.
to :: Signal = 0 [*-to] — End at this value.
scale -- scale
prelude : control transformer: Bring a scale into scope.
scale :: Str [scale] — Look up scale by name.
args^* :: Val [] — Scale arguments.
set -- set
prelude : control generator: Emit a sample with no interpolation.
to :: Signal [*-to] — Destination value.
sh -- sh prelude : control transformer: Sample & hold. Hold values at the given speed.
speed :: time signal (default real) = 10 [speed, *-speed] — Repeat at this speed. If it's a RealTime, the value is the number of repeats per second, which will be unaffected by the tempo. If it's a ScoreTime, the value is the number of repeats per ScoreTime unit, and will stretch along with tempo changes.
sine -- sine
prelude : control generator
sine+ -- sine
sine- -- sine: Emit a sine wave. The default version is centered on the offset, and the + and - variants are above and below it, respectively.
speed :: time signal (default real) = 1s [*-speed] — Frequency.
amp :: Signal = 1 [*-amp] — Amplitude, measured center to peak.
offset :: Signal = 0 [*-offset] — Center point.
slew -- slew
prelude : control transformer: Smooth a signal by interpolating such that it doesn't exceed the given slope.
slope :: Signal [*-slope] — Maximum allowed slope, per second.
smooth -- smooth
prelude : control transformer: Smooth a signal by interpolating between discontinuities.
time :: Signal (Time, default real) [*-time] — Amount of time to reach to the next sample. If negative, it will end on the destination sample rather than start on it. The time will be compressed if the samples are too close, so unlike slew, this will always reach the samples in the source.
curve :: PFunction = curve-linear [*-curve] — Curve function.
swell -- swell
prelude : control generator: Start at the given value, interpolate to a peak, then back to the original value. Uses duration.
val :: Signal [*-val] — Start value.
peak :: Signal = 1 [*-peak] — Interpolate to this value.
bias :: Signal = .5 [*-bias] — 0 puts the peak at the start, 1 at the end.
tr -- tr prelude : control generator: The control version of the pitch trill. It generates a signal of values alternating with 0, which can be used as a transposition signal.
neighbor :: untyped signal = 1 [*-neighbor] — Alternate with this value.
speed :: time signal (default real) = 14 [*-speed] — Trill at this speed. If it's a RealTime, the value is the number of cycles per second, which will be unaffected by the tempo. If it's a ScoreTime, the value is the number of cycles per ScoreTime unit, and will stretch along with tempo changes. In either case, this will emit only whole notes, i.e. it will end sooner to avoid emitting a cut-off note at the end.
tr-start^env :: Maybe Str (high low) = _ [tr-start] — Which note the trill starts with. If not given, it will start the unison note, which means it may move up or down.
tr-end^env :: Maybe Str (high low) = _ [tr-end] — Which note the trill ends with. If not given, it can end with either.
hold^env :: Signal (Time, default real) = 0s [hold, *-hold] — Time to hold the first note.
adjust^env :: Str (shorten stretch) = shorten [adjust, *-adjust] — How to adjust a trill to fulfill its start and end pitch restrictions.
tr-bias^env :: Signal (-1 <= x <= 1) = 0 [tr-bias] — Offset every other transition by this amount.
tr-transition^env :: untyped signal = 0 [tr-transition] — Take this long to reach the neighbor, as a proportion of time available.
tr-^ -- tr prelude : control generator
tr-_ -- tr: The control version of the pitch trill. It generates a signal of values alternating with 0, which can be used as a transposition signal.
A ^ suffix makes the trill starts on the higher value, while _ makes it start on the lower value. A second suffix causes it to end on the higher or lower value, e.g. ^_ starts high and ends low. -_ has start unspecified, and ends low. No suffix causes it to obey the settings in scope.
neighbor :: untyped signal = 1 [*-neighbor] — Alternate with this value.
speed :: time signal (default real) = 14 [*-speed] — Trill at this speed. If it's a RealTime, the value is the number of cycles per second, which will be unaffected by the tempo. If it's a ScoreTime, the value is the number of cycles per ScoreTime unit, and will stretch along with tempo changes. In either case, this will emit only whole notes, i.e. it will end sooner to avoid emitting a cut-off note at the end.
tr-start^env :: Maybe Str (high low) = _ [tr-start] — Which note the trill starts with. If not given, it will start the unison note, which means it may move up or down.
hold^env :: Signal (Time, default real) = 0s [hold, *-hold] — Time to hold the first note.
adjust^env :: Str (shorten stretch) = shorten [adjust, *-adjust] — How to adjust a trill to fulfill its start and end pitch restrictions.
tr-bias^env :: Signal (-1 <= x <= 1) = 0 [tr-bias] — Offset every other transition by this amount.
tr-transition^env :: untyped signal = 0 [tr-transition] — Take this long to reach the neighbor, as a proportion of time available.
tr^ -- tr prelude : control generator
tr_ -- tr: The control version of the pitch trill. It generates a signal of values alternating with 0, which can be used as a transposition signal.
A ^ suffix makes the trill starts on the higher value, while _ makes it start on the lower value. A second suffix causes it to end on the higher or lower value, e.g. ^_ starts high and ends low. -_ has start unspecified, and ends low. No suffix causes it to obey the settings in scope.
neighbor :: untyped signal = 1 [*-neighbor] — Alternate with this value.
speed :: time signal (default real) = 14 [*-speed] — Trill at this speed. If it's a RealTime, the value is the number of cycles per second, which will be unaffected by the tempo. If it's a ScoreTime, the value is the number of cycles per ScoreTime unit, and will stretch along with tempo changes. In either case, this will emit only whole notes, i.e. it will end sooner to avoid emitting a cut-off note at the end.
tr-end^env :: Maybe Str (high low) = _ [tr-end] — Which note the trill ends with. If not given, it can end with either.
hold^env :: Signal (Time, default real) = 0s [hold, *-hold] — Time to hold the first note.
adjust^env :: Str (shorten stretch) = shorten [adjust, *-adjust] — How to adjust a trill to fulfill its start and end pitch restrictions.
tr-bias^env :: Signal (-1 <= x <= 1) = 0 [tr-bias] — Offset every other transition by this amount.
tr-transition^env :: untyped signal = 0 [tr-transition] — Take this long to reach the neighbor, as a proportion of time available.
tr^^ -- tr prelude : control generator
tr^_ -- tr
tr_^ -- tr
tr__ -- tr: The control version of the pitch trill. It generates a signal of values alternating with 0, which can be used as a transposition signal.
A ^ suffix makes the trill starts on the higher value, while _ makes it start on the lower value. A second suffix causes it to end on the higher or lower value, e.g. ^_ starts high and ends low. -_ has start unspecified, and ends low. No suffix causes it to obey the settings in scope.
neighbor :: untyped signal = 1 [*-neighbor] — Alternate with this value.
speed :: time signal (default real) = 14 [*-speed] — Trill at this speed. If it's a RealTime, the value is the number of cycles per second, which will be unaffected by the tempo. If it's a ScoreTime, the value is the number of cycles per ScoreTime unit, and will stretch along with tempo changes. In either case, this will emit only whole notes, i.e. it will end sooner to avoid emitting a cut-off note at the end.
hold^env :: Signal (Time, default real) = 0s [hold, *-hold] — Time to hold the first note.
adjust^env :: Str (shorten stretch) = shorten [adjust, *-adjust] — How to adjust a trill to fulfill its start and end pitch restrictions.
tr-bias^env :: Signal (-1 <= x <= 1) = 0 [tr-bias] — Offset every other transition by this amount.
tr-transition^env :: untyped signal = 0 [tr-transition] — Take this long to reach the neighbor, as a proportion of time available.
trs -- tr prelude : control generator: The control version of the pitch trill. It generates a signal of values alternating with 0, which can be used as a transposition signal.
neighbor :: untyped signal = 1 [*-neighbor] — Alternate with this value.
speed :: time signal (default real) = 14 [*-speed] — Trill at this speed. If it's a RealTime, the value is the number of cycles per second, which will be unaffected by the tempo. If it's a ScoreTime, the value is the number of cycles per ScoreTime unit, and will stretch along with tempo changes. In either case, this will emit only whole notes, i.e. it will end sooner to avoid emitting a cut-off note at the end.
tr-start^env :: Maybe Str (high low) = _ [tr-start] — Which note the trill starts with. If not given, it will start the unison note, which means it may move up or down.
tr-end^env :: Maybe Str (high low) = _ [tr-end] — Which note the trill ends with. If not given, it can end with either.
hold^env :: Signal (Time, default real) = 0s [hold, *-hold] — Time to hold the first note.
adjust^env :: Str (shorten stretch) = shorten [adjust, *-adjust] — How to adjust a trill to fulfill its start and end pitch restrictions.
tr-bias^env :: Signal (-1 <= x <= 1) = 0 [tr-bias] — Offset every other transition by this amount.
trs-^ -- tr prelude : control generator
trs-_ -- tr: The control version of the pitch trill. It generates a signal of values alternating with 0, which can be used as a transposition signal.
A ^ suffix makes the trill starts on the higher value, while _ makes it start on the lower value. A second suffix causes it to end on the higher or lower value, e.g. ^_ starts high and ends low. -_ has start unspecified, and ends low. No suffix causes it to obey the settings in scope.
neighbor :: untyped signal = 1 [*-neighbor] — Alternate with this value.
speed :: time signal (default real) = 14 [*-speed] — Trill at this speed. If it's a RealTime, the value is the number of cycles per second, which will be unaffected by the tempo. If it's a ScoreTime, the value is the number of cycles per ScoreTime unit, and will stretch along with tempo changes. In either case, this will emit only whole notes, i.e. it will end sooner to avoid emitting a cut-off note at the end.
tr-start^env :: Maybe Str (high low) = _ [tr-start] — Which note the trill starts with. If not given, it will start the unison note, which means it may move up or down.
hold^env :: Signal (Time, default real) = 0s [hold, *-hold] — Time to hold the first note.
adjust^env :: Str (shorten stretch) = shorten [adjust, *-adjust] — How to adjust a trill to fulfill its start and end pitch restrictions.
tr-bias^env :: Signal (-1 <= x <= 1) = 0 [tr-bias] — Offset every other transition by this amount.
trs^ -- tr prelude : control generator
trs_ -- tr: The control version of the pitch trill. It generates a signal of values alternating with 0, which can be used as a transposition signal.
A ^ suffix makes the trill starts on the higher value, while _ makes it start on the lower value. A second suffix causes it to end on the higher or lower value, e.g. ^_ starts high and ends low. -_ has start unspecified, and ends low. No suffix causes it to obey the settings in scope.
neighbor :: untyped signal = 1 [*-neighbor] — Alternate with this value.
speed :: time signal (default real) = 14 [*-speed] — Trill at this speed. If it's a RealTime, the value is the number of cycles per second, which will be unaffected by the tempo. If it's a ScoreTime, the value is the number of cycles per ScoreTime unit, and will stretch along with tempo changes. In either case, this will emit only whole notes, i.e. it will end sooner to avoid emitting a cut-off note at the end.
tr-end^env :: Maybe Str (high low) = _ [tr-end] — Which note the trill ends with. If not given, it can end with either.
hold^env :: Signal (Time, default real) = 0s [hold, *-hold] — Time to hold the first note.
adjust^env :: Str (shorten stretch) = shorten [adjust, *-adjust] — How to adjust a trill to fulfill its start and end pitch restrictions.
tr-bias^env :: Signal (-1 <= x <= 1) = 0 [tr-bias] — Offset every other transition by this amount.
trs^^ -- tr prelude : control generator
trs^_ -- tr
trs_^ -- tr
trs__ -- tr: The control version of the pitch trill. It generates a signal of values alternating with 0, which can be used as a transposition signal.
A ^ suffix makes the trill starts on the higher value, while _ makes it start on the lower value. A second suffix causes it to end on the higher or lower value, e.g. ^_ starts high and ends low. -_ has start unspecified, and ends low. No suffix causes it to obey the settings in scope.
neighbor :: untyped signal = 1 [*-neighbor] — Alternate with this value.
speed :: time signal (default real) = 14 [*-speed] — Trill at this speed. If it's a RealTime, the value is the number of cycles per second, which will be unaffected by the tempo. If it's a ScoreTime, the value is the number of cycles per ScoreTime unit, and will stretch along with tempo changes. In either case, this will emit only whole notes, i.e. it will end sooner to avoid emitting a cut-off note at the end.
hold^env :: Signal (Time, default real) = 0s [hold, *-hold] — Time to hold the first note.
adjust^env :: Str (shorten stretch) = shorten [adjust, *-adjust] — How to adjust a trill to fulfill its start and end pitch restrictions.
tr-bias^env :: Signal (-1 <= x <= 1) = 0 [tr-bias] — Offset every other transition by this amount.
u -- u prelude : control generator: Ascend at the given speed until the value reaches a limit or the next event.
Tags: prev
speed :: Signal = 1 [*-speed] — Ascend this amount per second.
limit :: Maybe Signal = _ [*-limit] — Stop at this value.
from^env :: Maybe Signal = _ [from, *-from] — Start from this value. If unset, use the previous value.
control-gt-0^env :: Str (f t) = f [control-gt-0] — Whether or not to limit to 1 by default.
uf -- uf prelude : control generator: Like df, but up.
from :: Signal = 0 [*-from] — Start at this value.
speed :: Signal = 1 [*-speed] — Ascend this amount per second.
limit :: Signal = 1 [*-limit] — Stop at this value.
unless-c -- when-c
prelude : control transformer
when-c -- when-c: Only derive if the control has the given value. E.g., you can use a %var control to select among different variations.
val :: Signal (integral) [*-val] — Value.
control :: Signal = 0 [*-control] — Control.
unless-e -- when-e
prelude : control transformer
when-e -- when-e: Only derive if environ value is set to the given value. In a block derived multiple times by different instruments, this can be used to solo a bit of score to one particular instrument.
name :: Str [*-name] — Environ key.
value :: Maybe Val = _ [*-value] — Environ value. If not given, require only that the environ key is set.
xcut -- xcut
prelude : control generator
xcut-h -- xcut: Cross-cut between two signals. The -h variant holds the value at the beginning of each transition.
fst :: Signal = 1 [*-fst] — First value.
snd :: Signal = 0 [*-snd] — Second value.
speed :: time signal (default real) = 14 [*-speed] — Speed.

pitch

tr -- tr china.zheng : pitch generator
tr^ -- tr
tr_ -- tr: A trill with smooth transitions.
pitch :: Pitch [*-pitch] — Base pitch.
neighbor :: transpose signal (default nn) = 1 [*-neighbor] — Alternate with a pitch at this interval.
speed :: time signal (default real) = 20 [*-speed] — Alternate pitches at this speed.
hold^env :: Signal (Time, default real) = 0s [hold, *-hold] — Time to hold the first note.
^kam -- kam
india.gamakam : pitch generator
^kam^ -- kam
^kam_ -- kam
_kam -- kam
_kam^ -- kam
_kam_ -- kam
kam -- kam
kam^ -- kam
kam_ -- kam: This is a kind of trill, but its interval defaults to NNs, and transitions between the notes are smooth. It's intended for the vocal microtonal trills common in Carnatic music.
pitch :: Pitch [*-pitch] — Base pitch.
neighbor :: transpose signal (default nn) = 1 [*-neighbor] — Alternate with a pitch at this interval.
speed :: time signal (default real) = 6 [*-speed] — Alternate pitches at this speed.
transition :: Signal (RealTime) = .08s [transition, *-transition] — Time for each slide.
hold^env :: Signal (Time, default real) = 0s [hold, *-hold] — Time to hold the first note.
lilt^env :: Signal = 0 [lilt, *-lilt] — Lilt is a horizontal bias to the vibrato. A lilt of 1 would place each neighbor on top of the following unison, while -1 would place it on the previous one. So it should range from -1 < lilt < 1.
adjust^env :: Str (shorten stretch) = shorten [adjust, *-adjust] — How to adjust a trill to fulfill its start and end pitch restrictions.
dip -- dip
india.gamakam : pitch generator: Alternate two intervals, dropping dyn on the second. This is useful when avoiding a swaram, since it doesn't necessarily emit the base pitch.
pitch :: Pitch [*-pitch] — Base pitch.
high :: Signal (Transposition, default diatonic) = 1d [*-high] — High interval.
low :: Signal = -1 [*-low] — Low interval.
speed :: time signal (default real) = 6 [*-speed] — Alternate pitches at this speed.
dyn :: Signal = .5 [*-dyn] — Multiply dyn by this amount.
transition^env :: Signal (RealTime) = .08s [transition, *-transition] — Time for each slide.
jaru -- jaru
india.gamakam : pitch generator: This is a series of grace notes whose pitches are relative to the given base pitch.
pitch :: Pitch [*-pitch] — Base pitch.
interval⁺ :: Signal (Transposition, default diatonic) [] — Intervals from base pitch.
time^env :: Signal (RealTime) = .15s [time, *-time] — Time for each note.
transition^env :: Maybe Signal (RealTime) = _ [transition, *-transition] — Time for each slide, defaults to time.
sgr -- jaru
india.gamakam : pitch generator: This is jaru hardcoded to [-1, 1].
pitch :: Pitch [*-pitch] — Base pitch.
time :: Signal (RealTime) = .15s [*-time] — Time for each note.
transition :: Maybe Signal (RealTime) = _ [*-transition] — Time for each slide, defaults to time.
cur -- from
india.gamakam2 : pitch generator
cur< -- from: Come from a pitch, and possibly fade in.
from :: Maybe Pitch or Signal (Transposition) = _ [*-from] — Come from this pitch, or the previous one.
transition :: Signal (Time, default real) = .12s [*-transition] — Time to destination.
to :: Maybe Pitch or Signal (Transposition) = _ [*-to] — Go to this pitch, or the current one.
curve^env :: PFunction = curve-linear [curve, *-curve] — Curve function.
fade-in -- fade
india.gamakam2 : pitch generator: Fade in. This will overlap with the pitch part of the next call.
time :: Signal (Time, default real) = .15s [*-time] — Time to fade.
fade-out -- fade
india.gamakam2 : pitch generator: Fade out. This will overlap with the pitch part of the previous call.
time :: Signal (Time, default real) = .15s [*-time] — Time to fade.
flat -- flat
india.gamakam2 : pitch generator: Emit a flat pitch.
pitch :: Maybe Pitch or Signal (Transposition) = _ [*-pitch] — Emit this pitch, or continue the previous pitch if not given.
flat-end -- flat-end
india.gamakam2 : pitch generator
flat-start -- flat-start: Emit a flat pitch for the given duration.
pitch :: Maybe Pitch or Signal (Transposition) = _ [*-pitch] — Emit this pitch, or continue the previous pitch if not given.
time :: Signal (Time, default real) = .15s [*-time] — Pitch lasts for this duration.
jaru -- jaru
india.gamakam2 : pitch generator
jaru0 -- jaru: This is a series of grace notes whose pitches are relative to the base pitch. The 0 variant appends a 0 on the end.
interval⁺ :: Signal (Transposition, default diatonic) [] — Intervals from base pitch.
time^env :: Signal (Time, default real) = .12s [time, *-time] — Time for each note.
transition^env :: Maybe Signal (RealTime) = _ [transition, *-transition] — Time for each slide, defaults to time.
curve^env :: PFunction = curve-linear [curve, *-curve] — Curve function.
kam -- kam
india.gamakam2 : pitch generator
kam^ -- kam
kam_ -- kam: This is a kind of trill, but its interval defaults to NNs, and transitions between the notes are smooth. It's intended for the vocal microtonal trills common in Carnatic music.
neighbor :: transpose signal (default nn) = 1 [*-neighbor] — Alternate with a pitch at this interval.
speed :: time signal (default real) = 6 [*-speed] — Alternate pitches at this speed.
transition :: Signal (RealTime) = .12s [transition, *-transition] — Time for each slide.
hold^env :: Signal (Time, default real) = 0s [hold, *-hold] — Time to hold the first note.
lilt^env :: Signal = 0 [*-lilt] — Lilt is a horizontal bias to the vibrato. A lilt of 1 would place each neighbor on top of the following unison, while -1 would place it on the previous one. So it should range from -1 < lilt < 1.
adjust^env :: Str (shorten stretch) = shorten [adjust, *-adjust] — How to adjust a trill to fulfill its start and end pitch restrictions.
curve^env :: PFunction = curve-linear [curve, *-curve] — Curve function.
kam2 -- kam
india.gamakam2 : pitch generator
kam2^ -- kam
kam2_ -- kam: This is a kind of trill, but its interval defaults to NNs, and transitions between the notes are smooth. It's intended for the vocal microtonal trills common in Carnatic music.
pitch1 :: transpose signal (default nn) = 0 [*-pitch1] — First interval.
pitch2 :: transpose signal (default nn) = 1 [*-pitch2] — Second interval.
speed :: time signal (default real) = 6 [*-speed] — Alternate pitches at this speed.
transition :: Signal (RealTime) = .12s [transition, *-transition] — Time for each slide.
hold^env :: Signal (Time, default real) = 0s [hold, *-hold] — Time to hold the first note.
lilt^env :: Signal = 0 [*-lilt] — Lilt is a horizontal bias to the vibrato. A lilt of 1 would place each neighbor on top of the following unison, while -1 would place it on the previous one. So it should range from -1 < lilt < 1.
adjust^env :: Str (shorten stretch) = shorten [adjust, *-adjust] — How to adjust a trill to fulfill its start and end pitch restrictions.
curve^env :: PFunction = curve-linear [curve, *-curve] — Curve function.
nkam -- nkam
india.gamakam2 : pitch generator
nkam^ -- nkam
nkam_ -- nkam: kam with a set number of cycles. The speed adjusts to fit the cycles in before the next event.
cycles :: Signal (>0) = 1 [*-cycles] — Number of cycles.
neighbor :: transpose signal (default nn) = 1 [*-neighbor] — Alternate with a pitch at this interval.
transition :: Signal (RealTime) = .12s [transition, *-transition] — Time for each slide.
hold^env :: Signal (Time, default real) = 0s [hold, *-hold] — Time to hold the first note.
lilt^env :: Signal = 0 [*-lilt] — Lilt is a horizontal bias to the vibrato. A lilt of 1 would place each neighbor on top of the following unison, while -1 would place it on the previous one. So it should range from -1 < lilt < 1.
adjust^env :: Str (shorten stretch) = shorten [adjust, *-adjust] — How to adjust a trill to fulfill its start and end pitch restrictions.
curve^env :: PFunction = curve-linear [curve, *-curve] — Curve function.
nkam2 -- nkam
india.gamakam2 : pitch generator
nkam2^ -- nkam
nkam2_ -- nkam: kam with a set number of cycles. The speed adjusts to fit the cycles in before the next event.
cycles :: Signal (>0) = 1 [*-cycles] — Number of cycles.
pitch1 :: transpose signal (default nn) = 0 [*-pitch1] — First interval.
pitch2 :: transpose signal (default nn) = 1 [*-pitch2] — Second interval.
transition :: Signal (RealTime) = .12s [transition, *-transition] — Time for each slide.
hold^env :: Signal (Time, default real) = 0s [hold, *-hold] — Time to hold the first note.
lilt^env :: Signal = 0 [*-lilt] — Lilt is a horizontal bias to the vibrato. A lilt of 1 would place each neighbor on top of the following unison, while -1 would place it on the previous one. So it should range from -1 < lilt < 1.
adjust^env :: Str (shorten stretch) = shorten [adjust, *-adjust] — How to adjust a trill to fulfill its start and end pitch restrictions.
curve^env :: PFunction = curve-linear [curve, *-curve] — Curve function.
prev -- from
india.gamakam2 : pitch generator
prev< -- from: Come for the previous pitch, and possibly fade in.
transition :: Signal (Time, default real) = .12s [*-transition] — Time to destination.
to :: Maybe Pitch or Signal (Transposition) = _ [*-to] — Go to this pitch, or the current one.
curve^env :: PFunction = curve-linear [curve, *-curve] — Curve function.
set-pitch -- set-pitch
india.gamakam2 : pitch generator: Emit the current pitch. Sequence pitch calls normally use the previous pitch, and this is an implicit begin call so a sequence missing a begin doesn't inherit the previous pitch.
to -- to india.gamakam2 : pitch generator
to> -- to: Go to a pitch, and possibly fade out.
pitch :: Pitch or Signal (Transposition) [*-pitch] — Go to this pitch or interval.
transition :: Signal (Time, default real) = .12s [*-transition] — Time to destination pitch.
- -- flat-start
india.gamakam2.begin : pitch generator: Emit a flat pitch for the given duration.
pitch :: Maybe Pitch or Signal (Transposition) = _ [*-pitch] — Emit this pitch, or continue the previous pitch if not given.
time :: Signal (Time, default real) = .15s [*-time] — Pitch lasts for this duration.
-< -- fade
india.gamakam2.begin : pitch generator: Fade in. This will overlap with the pitch part of the next call.
time :: Signal (Time, default real) = .15s [*-time] — Time to fade.
c -- from
india.gamakam2.begin : pitch generator
c< -- from: Come from a pitch, and possibly fade in.
from :: Maybe Pitch or Signal (Transposition) = _ [*-from] — Come from this pitch, or the previous one.
transition :: Signal (Time, default real) = .12s [*-transition] — Time to destination.
to :: Maybe Pitch or Signal (Transposition) = _ [*-to] — Go to this pitch, or the current one.
curve^env :: PFunction = curve-linear [curve, *-curve] — Curve function.
J -- jaru
india.gamakam2.begin : pitch generator
j -- jaru: This is a series of grace notes whose pitches are relative to the base pitch. The 0 variant appends a 0 on the end.
interval⁺ :: Signal (Transposition, default diatonic) [] — Intervals from base pitch.
time^env :: Signal (Time, default real) = .12s [time, *-time] — Time for each note.
transition^env :: Maybe Signal (RealTime) = _ [transition, *-transition] — Time for each slide, defaults to time.
curve^env :: PFunction = curve-linear [curve, *-curve] — Curve function.
p -- from
india.gamakam2.begin : pitch generator
p< -- from: Come for the previous pitch, and possibly fade in.
transition :: Signal (Time, default real) = .12s [*-transition] — Time to destination.
to :: Maybe Pitch or Signal (Transposition) = _ [*-to] — Go to this pitch, or the current one.
curve^env :: PFunction = curve-linear [curve, *-curve] — Curve function.
- -- flat-end
india.gamakam2.end : pitch generator: Emit a flat pitch for the given duration.
pitch :: Maybe Pitch or Signal (Transposition) = _ [*-pitch] — Emit this pitch, or continue the previous pitch if not given.
time :: Signal (Time, default real) = .15s [*-time] — Pitch lasts for this duration.
-> -- fade
india.gamakam2.end : pitch generator: Fade out. This will overlap with the pitch part of the previous call.
time :: Signal (Time, default real) = .15s [*-time] — Time to fade.
t -- to india.gamakam2.end : pitch generator
t> -- to: Go to a pitch, and possibly fade out.
pitch :: Pitch or Signal (Transposition) [*-pitch] — Go to this pitch or interval.
transition :: Signal (Time, default real) = .12s [*-transition] — Time to destination pitch.
- -- flat
india.gamakam2.middle : pitch generator: Emit a flat pitch.
pitch :: Maybe Pitch or Signal (Transposition) = _ [*-pitch] — Emit this pitch, or continue the previous pitch if not given.
k -- kam
india.gamakam2.middle : pitch generator
k^ -- kam
k_ -- kam: This is a kind of trill, but its interval defaults to NNs, and transitions between the notes are smooth. It's intended for the vocal microtonal trills common in Carnatic music.
neighbor :: transpose signal (default nn) = 1 [*-neighbor] — Alternate with a pitch at this interval.
speed :: time signal (default real) = 6 [*-speed] — Alternate pitches at this speed.
transition :: Signal (RealTime) = .12s [transition, *-transition] — Time for each slide.
hold^env :: Signal (Time, default real) = 0s [hold, *-hold] — Time to hold the first note.
lilt^env :: Signal = 0 [*-lilt] — Lilt is a horizontal bias to the vibrato. A lilt of 1 would place each neighbor on top of the following unison, while -1 would place it on the previous one. So it should range from -1 < lilt < 1.
adjust^env :: Str (shorten stretch) = shorten [adjust, *-adjust] — How to adjust a trill to fulfill its start and end pitch restrictions.
curve^env :: PFunction = curve-linear [curve, *-curve] — Curve function.
k2 -- kam
india.gamakam2.middle : pitch generator
k2^ -- kam
k2_ -- kam: This is a kind of trill, but its interval defaults to NNs, and transitions between the notes are smooth. It's intended for the vocal microtonal trills common in Carnatic music.
pitch1 :: transpose signal (default nn) = 0 [*-pitch1] — First interval.
pitch2 :: transpose signal (default nn) = 1 [*-pitch2] — Second interval.
speed :: time signal (default real) = 6 [*-speed] — Alternate pitches at this speed.
transition :: Signal (RealTime) = .12s [transition, *-transition] — Time for each slide.
hold^env :: Signal (Time, default real) = 0s [hold, *-hold] — Time to hold the first note.
lilt^env :: Signal = 0 [*-lilt] — Lilt is a horizontal bias to the vibrato. A lilt of 1 would place each neighbor on top of the following unison, while -1 would place it on the previous one. So it should range from -1 < lilt < 1.
adjust^env :: Str (shorten stretch) = shorten [adjust, *-adjust] — How to adjust a trill to fulfill its start and end pitch restrictions.
curve^env :: PFunction = curve-linear [curve, *-curve] — Curve function.
nk -- nkam
india.gamakam2.middle : pitch generator
nk^ -- nkam
nk_ -- nkam: kam with a set number of cycles. The speed adjusts to fit the cycles in before the next event.
cycles :: Signal (>0) = 1 [*-cycles] — Number of cycles.
neighbor :: transpose signal (default nn) = 1 [*-neighbor] — Alternate with a pitch at this interval.
transition :: Signal (RealTime) = .12s [transition, *-transition] — Time for each slide.
hold^env :: Signal (Time, default real) = 0s [hold, *-hold] — Time to hold the first note.
lilt^env :: Signal = 0 [*-lilt] — Lilt is a horizontal bias to the vibrato. A lilt of 1 would place each neighbor on top of the following unison, while -1 would place it on the previous one. So it should range from -1 < lilt < 1.
adjust^env :: Str (shorten stretch) = shorten [adjust, *-adjust] — How to adjust a trill to fulfill its start and end pitch restrictions.
curve^env :: PFunction = curve-linear [curve, *-curve] — Curve function.
nk2 -- nkam
india.gamakam2.middle : pitch generator
nk2^ -- nkam
nk2_ -- nkam: kam with a set number of cycles. The speed adjusts to fit the cycles in before the next event.
cycles :: Signal (>0) = 1 [*-cycles] — Number of cycles.
pitch1 :: transpose signal (default nn) = 0 [*-pitch1] — First interval.
pitch2 :: transpose signal (default nn) = 1 [*-pitch2] — Second interval.
transition :: Signal (RealTime) = .12s [transition, *-transition] — Time for each slide.
hold^env :: Signal (Time, default real) = 0s [hold, *-hold] — Time to hold the first note.
lilt^env :: Signal = 0 [*-lilt] — Lilt is a horizontal bias to the vibrato. A lilt of 1 would place each neighbor on top of the following unison, while -1 would place it on the previous one. So it should range from -1 < lilt < 1.
adjust^env :: Str (shorten stretch) = shorten [adjust, *-adjust] — How to adjust a trill to fulfill its start and end pitch restrictions.
curve^env :: PFunction = curve-linear [curve, *-curve] — Curve function.
no* -- nkam
india.gamakam2.middle : pitch generator
no^ -- nkam
no_ -- nkam: kam with a set number of cycles. The speed adjusts to fit the cycles in before the next event.
These are hardcoded k variants:
o^ touches the swaram from above, like k2^ 1 0.
o_ touches the swaram from below, like k2_ -1 0.
o* avoids the swaram, like k2_ -1 1.

cycles :: Signal (>0) = 1 [*-cycles] — Number of cycles.
transition :: Signal (RealTime) = .12s [transition, *-transition] — Time for each slide.
hold^env :: Signal (Time, default real) = 0s [hold, *-hold] — Time to hold the first note.
lilt^env :: Signal = 0 [*-lilt] — Lilt is a horizontal bias to the vibrato. A lilt of 1 would place each neighbor on top of the following unison, while -1 would place it on the previous one. So it should range from -1 < lilt < 1.
adjust^env :: Str (shorten stretch) = shorten [adjust, *-adjust] — How to adjust a trill to fulfill its start and end pitch restrictions.
curve^env :: PFunction = curve-linear [curve, *-curve] — Curve function.
o* -- kam
india.gamakam2.middle : pitch generator
o^ -- kam
o_ -- kam: This is a kind of trill, but its interval defaults to NNs, and transitions between the notes are smooth. It's intended for the vocal microtonal trills common in Carnatic music.
These are hardcoded k variants:
o^ touches the swaram from above, like k2^ 1 0.
o_ touches the swaram from below, like k2_ -1 0.
o* avoids the swaram, like k2_ -1 1.

speed :: time signal (default real) = 6 [*-speed] — Alternate pitches at this speed.
transition :: Signal (RealTime) = .12s [transition, *-transition] — Time for each slide.
hold^env :: Signal (Time, default real) = 0s [hold, *-hold] — Time to hold the first note.
lilt^env :: Signal = 0 [*-lilt] — Lilt is a horizontal bias to the vibrato. A lilt of 1 would place each neighbor on top of the following unison, while -1 would place it on the previous one. So it should range from -1 < lilt < 1.
adjust^env :: Str (shorten stretch) = shorten [adjust, *-adjust] — How to adjust a trill to fulfill its start and end pitch restrictions.
curve^env :: PFunction = curve-linear [curve, *-curve] — Curve function.
' -- set-prev
prelude : pitch generator: Re-set the previous pitch. This can be used to extend a breakpoint.
Tags: prev
* -- multiply
prelude : pitch generator: Emit the given pitch multiplied by a factor.
pitch :: Pitch [*-pitch] — Source pitch.
interval :: Signal or Str = 0 [*-interval] — Multiply this interval with the note's frequency. Negative numbers divide, so while 3/2 goes up a fifth, -3/2 goes down a fifth. Can be either a ratio or a symbol drawn from: M2, M2-, M3, M6, M7, P4, P5, m2, m2-, m3, m6, m7, tt, tt11, tt7+, tt7-, wolf
= -- equal
prelude : pitch transformer: Evaluate the deriver with a value set. Special parser support means this can be called infix. The arguments can take many forms to set different kinds of values.
Set an environ value by setting a plain symbol or unset it by assigning to _: x = 42 or x = _.
Prefixes:
- >> - Create a note transformer, whose name will be prefixed with >. This is used to set an instrument transformer, which can apply a transformer when an instrument is set by the title of a note track, as implemented by by note-track.
- -val - Bind a val call.
- ^note, *pitch, .control - Bind the respective call type generator.
- ^-note, *-pitch, .-control - As above, but bind transformer.
- >alias = >inst - alias instrument name
E.g.: set note generator: ^phrase = some-block, note transformer: ^-mute = +mute+loose, control transfomrer: .-i = t, val call: -4c = (5c).
You can bypass all this cryptic prefix garbage by using a ky file. It has more space available so it can use a more readable syntax.
If you bind a call to a quoted expression, this creates a new call: ^abc = "(a b c) will create a abc call, which is a macro for a b c. The created call does not take arguments.
Set the default pitch signal with #, e.g. # = (4c) or # = 45nn. Control signal assignment also supports the same merge functions as the control track: a = .5 add or a = %b add. However, the second example throws an error if %b is a ControlFunction. a = .5 default will combine with a's default merge function. Assigning to _ unsets the control, and any ControlFunction.
The = operator can be suffixed with symbol, which will become the last argument, so %x=+1 becomes %x = 1 '+'. Note that the order is backwards from the usual +=, which is ultimately because the first word can have almost any character except space and =. Also, x=-1 is ambiguous, and parsed as x =- 1.
Tags: subs
lhs :: Str [] — Assign to this. This looks like a Str, but can actualy contain any characters except =, due to the special infix parsing for =. Symbolic prefixes determine what is assigned, and the valid types for the rhs.
rhs :: Val [] — Source of the assignment.
merge :: Str = set [*-merge] — Merge operator. This can be default to use the default for the control, set to replace the old signal, or one of the operators from 'Derive.Deriver.Monad.mergers': add, mul, scale, set, sub. There are also symbolic aliases, to support =+ syntax: {"*": "mul", "+": "add", "-": "sub", "@": "scale"}
`mordent` -- mordent
prelude : pitch generator: Like g, but hardcoded to play pitch, neighbor, pitch.
Tags: ornament
pitch :: Pitch [*-pitch] — Base pitch.
neighbor :: Signal (Transposition, default diatonic) = 1d [*-neighbor] — Neighbor pitch.
dur^env :: Signal (Time, default real) = .083s [dur, *-dur] — Duration of grace notes.
`rmordent` -- mordent
prelude : pitch generator: Like g, but hardcoded to play pitch, neighbor, pitch.
Tags: ornament
pitch :: Pitch [*-pitch] — Base pitch.
neighbor :: Signal (Transposition, default diatonic) = -1d [*-neighbor] — Neighbor pitch.
dur^env :: Signal (Time, default real) = .083s [dur, *-dur] — Duration of grace notes.
a -- approach
prelude : pitch generator: Slide to the next pitch.
Tags: next
time :: Signal (Time, default real) = .2s [*-time] — Time to get to destination.
curve^env :: PFunction = curve-linear [curve, *-curve] — Curve function.
ad -- approach-dyn
prelude : pitch generator: Like approach, slide to the next pitch, but also drop the dyn.
Tags: cmod, next
time :: Signal (Time, default real) = .2s [*-time] — Time to get to destination pitch and dyn.
dyn :: Signal = .25 [*-dyn] — Drop dyn by this factor.
curve^env :: PFunction = curve-linear [curve, *-curve] — Curve function.
alt -- alternate
prelude : pitch generator: Pick one of several expressions and evaluate it.
Tags: random
expr⁺ :: Quoted [] — Expression to evaluate.
alt-w -- alternate-weighted
prelude : pitch generator: Pick one of several expressions and evaluate it.
Tags: random
expr⁺ :: (Signal, Quoted) [] — (weight, expr) pairs.
d -- down
prelude : pitch generator: Descend at the given speed until the next event.
Tags: prev
slope :: Signal (Transposition) = 1c [*-slope] — Descend this many steps per second.
from^env :: Maybe Pitch = _ [from, *-from] — Start from this pitch. If unset, use the previous pitch.
curve^env :: PFunction = curve-linear [curve, *-curve] — Curve function.
d -- delay
prelude : pitch transformer: Simple delay for control and pitch tracks.
time :: Signal (Time, default real) = .1s [*-time] — Delay time.
default-merge -- default-merge
prelude : pitch transformer: Set the default merge operators for controls. These apply when the control track doesn't have an explicit operator.
merge :: Str [*-merge] — Merge operator. This can be default to use the default for the control, set to replace the old signal, or one of the operators from 'Derive.Deriver.Monad.mergers': add, mul, scale, set, sub. There are also symbolic aliases, to support =+ syntax: {"*": "mul", "+": "add", "-": "sub", "@": "scale"}
control⁺ :: Control ([a-z][a-z0-9.-]*) [] — Control names.
drop -- drop
prelude : pitch generator: Drop pitch and dyn.
Tags: cmod
interval :: Signal (Transposition) or Pitch = 7c [*-interval] — Interval or destination pitch.
time :: Signal (Time, default real) = .25s [*-time] — Time to the destination pitch.
fade :: Maybe Signal (Time, default real) = _ [*-fade] — Time to fade from or to nothing. If the fade is longer than the pitch time, the pitch will finish moving before the dyn has faded out.
curve^env :: PFunction = curve-linear [curve, *-curve] — Curve function.
e -- expon
prelude : pitch generator: Interpolate from the previous value to the given one. If the event's duration is 0, interpolate from the previous event to this one.
Tags: prev
pitch :: Pitch or Signal (Transposition) [*-pitch] — Destination pitch, or a transposition from the previous one.
expon :: Signal = 2 [*-expon] — Slope of an exponential curve. Positive n is taken as x^n and will generate a slowly departing and rapidly approaching curve. Negative -n is taken as x^1/n, which will generate a rapidly departing and slowly approaching curve.
from^env :: Maybe Pitch = _ [from, *-from] — Start from this pitch. If unset, use the previous pitch.
e<< -- expon-prev-const
prelude : pitch generator: Interpolate from the previous value to the given one.
Tags: prev
pitch :: Pitch or Signal (Transposition) [*-pitch] — Destination pitch, or a transposition from the previous one.
time :: Signal (Time, default real) = .1s [*-time] — Time to reach destination, starting before the event.
expon :: Signal = 2 [*-expon] — Slope of an exponential curve. Positive n is taken as x^n and will generate a slowly departing and rapidly approaching curve. Negative -n is taken as x^1/n, which will generate a rapidly departing and slowly approaching curve.
from^env :: Maybe Pitch = _ [from, *-from] — Start from this pitch. If unset, use the previous pitch.
e> -- expon-next
prelude : pitch generator: Interpolate from the previous value to the given one. If the event's duration is 0, interpolate from this event to the next.
Tags: prev
pitch :: Pitch or Signal (Transposition) [*-pitch] — Destination pitch, or a transposition from the previous one.
expon :: Signal = 2 [*-expon] — Slope of an exponential curve. Positive n is taken as x^n and will generate a slowly departing and rapidly approaching curve. Negative -n is taken as x^1/n, which will generate a rapidly departing and slowly approaching curve.
from^env :: Maybe Pitch = _ [from, *-from] — Start from this pitch. If unset, use the previous pitch.
e>> -- expon-next-const
prelude : pitch generator: Interpolate from the previous value to the given one.
Tags: prev
pitch :: Pitch or Signal (Transposition) [*-pitch] — Destination pitch, or a transposition from the previous one.
time :: Signal (Time, default real) = .1s [*-time] — Time to reach destination.
expon :: Signal = 2 [*-expon] — Slope of an exponential curve. Positive n is taken as x^n and will generate a slowly departing and rapidly approaching curve. Negative -n is taken as x^1/n, which will generate a rapidly departing and slowly approaching curve.
from^env :: Maybe Pitch = _ [from, *-from] — Start from this pitch. If unset, use the previous pitch.
g -- grace
prelude : pitch generator: Generate grace note pitches. They start on the event and have the given duration, but are shortened if the available duration is too short. The destination pitch is first, even though it plays last, so g (c) (a) (b) produces a b c.
Tags: ornament
pitch :: Pitch [*-pitch] — Base pitch.
pitch^* :: Pitch or Signal [] — Grace note pitches. If they are numbers, they are taken as transpositions and must all be the same type, defaulting to diatonic.
dur^env :: Signal (Time, default real) = .083s [dur, *-dur] — Duration of grace notes.
h -- hold
prelude : pitch transformer: Set the 'Derive.EnvKey.hold' environ variable.
time :: Signal (Time, default real) = .25s [*-time] — Hold this long.
i -- linear
prelude : pitch generator: Interpolate from the previous value to the given one. If the event's duration is 0, interpolate from the previous event to this one.
Tags: prev
pitch :: Pitch or Signal (Transposition) [*-pitch] — Destination pitch, or a transposition from the previous one.
from^env :: Maybe Pitch = _ [from, *-from] — Start from this pitch. If unset, use the previous pitch.
i<< -- linear-prev-const
prelude : pitch generator: Interpolate from the previous value to the given one.
Tags: prev
pitch :: Pitch or Signal (Transposition) [*-pitch] — Destination pitch, or a transposition from the previous one.
time :: Signal (Time, default real) = .1s [*-time] — Time to reach destination, starting before the event.
from^env :: Maybe Pitch = _ [from, *-from] — Start from this pitch. If unset, use the previous pitch.
i> -- linear-next
prelude : pitch generator: Interpolate from the previous value to the given one. If the event's duration is 0, interpolate from this event to the next.
Tags: prev
pitch :: Pitch or Signal (Transposition) [*-pitch] — Destination pitch, or a transposition from the previous one.
from^env :: Maybe Pitch = _ [from, *-from] — Start from this pitch. If unset, use the previous pitch.
i>> -- linear-next-const
prelude : pitch generator: Interpolate from the previous value to the given one.
Tags: prev
pitch :: Pitch or Signal (Transposition) [*-pitch] — Destination pitch, or a transposition from the previous one.
time :: Signal (Time, default real) = .1s [*-time] — Time to reach destination.
from^env :: Maybe Pitch = _ [from, *-from] — Start from this pitch. If unset, use the previous pitch.
if-c< -- if-c<
prelude : pitch generator
if-c> -- if-c<: Derive based on the value of a control.
control :: Control ([a-z][a-z0-9.-]*) [*-control] — Test this control.
tests⁺ :: Val [] — (value, expr) pairs.
if-e -- if-e
prelude : pitch generator: Derive based on the value of an environment variable.
name :: Str [*-name] — Environ key.
value :: Maybe Val = _ [*-value] — Environ value. If not given, require only that the environ key is set.
true :: Quoted [*-true] — Eval if true.
false :: Quoted [*-false] — Eval if false.
import -- import
prelude : pitch transformer: Import the given modules into scope. Calls of all types (note, control, pitch, val) are imported. If names clash, the ones from later modules win.
module⁺ :: Str [] — Import these modules.
imports -- import-symbol
prelude : pitch transformer: Import a single symbol, or list of symbols. This imports from all namespaces simultaneously: note, control, pitch, and val. TODO fix it if it's a problem.
module :: Str [*-module] — Import this module.
symbol⁺ :: Str [] — Import these symbols.
lift -- lift
prelude : pitch generator: Lift pitch and drop dyn. This is the same as drop, except that it defaults to going up instead of down.
Tags: cmod
interval :: Signal (Transposition) or Pitch = 7c [*-interval] — Interval or destination pitch.
time :: Signal (Time, default real) = .25s [*-time] — Time to the destination pitch.
fade :: Maybe Signal (Time, default real) = _ [*-fade] — Time to fade from or to nothing. If the fade is longer than the pitch time, the pitch will finish moving before the dyn has faded out.
curve^env :: PFunction = curve-linear [curve, *-curve] — Curve function.
log-seed -- log-seed
prelude : pitch transformer: Emit a log message with the seed at this point. If you like how a generator realized, and want to freeze it, then you can use this to get the seed, and then hardcode it with seed=xyz.
n -- neighbor
prelude : pitch generator: Emit a slide from a neighboring pitch to the given one.
pitch :: Pitch [*-pitch] — Destination pitch.
neighbor :: Signal (Transposition) = 1c [*-neighbor] — Neighobr interval.
time :: Signal (Time, default real) = .1s [*-time] — Time to get to destination.
curve^env :: PFunction = curve-linear [curve, *-curve] — Curve function.
omit -- omit
prelude : pitch transformer: Omit the derived call a certain percentage of the time.
Tags: random
chance :: Signal = .5 [*-chance] — Chance, from 0 to 1, that the transformed note will be omitted.
on-repeat -- on-repeat
prelude : pitch generator: Derive the argument indexed by the repeat variable, where an out of range index is clamped to be in range.
repeat⁺ :: Quoted [] — Eval on nth repeat.
p -- porta
prelude : pitch generator: Interpolate between two pitches. This is similar to i>>, but intended to be higher level, in that instruments or scores can override it to represent an idiomatic portamento.
pitch :: Pitch or Signal (Transposition) [*-pitch] — Destination pitch, or a transposition from the previous one.
time :: Signal (Time, default real) = .1s [*-time] — Time to reach destination.
place :: Signal (0 <= x <= 1) = 1 [place, *-place] — Placement, from before to after the call.
from^env :: Maybe Pitch = _ [from, *-from] — Start from this pitch. If unset, use the previous pitch.
curve^env :: PFunction = curve-linear [curve, *-curve] — Curve function.
s -- sigmoid
prelude : pitch generator: Interpolate from the previous value to the given one. If the event's duration is 0, interpolate from the previous event to this one.
Tags: prev
pitch :: Pitch or Signal (Transposition) [*-pitch] — Destination pitch, or a transposition from the previous one.
w1 :: Signal = .5 [*-w1] — Start weight.
w2 :: Signal = .5 [*-w2] — End weight.
from^env :: Maybe Pitch = _ [from, *-from] — Start from this pitch. If unset, use the previous pitch.
s<< -- sigmoid-prev-const
prelude : pitch generator: Interpolate from the previous value to the given one.
Tags: prev
pitch :: Pitch or Signal (Transposition) [*-pitch] — Destination pitch, or a transposition from the previous one.
time :: Signal (Time, default real) = .1s [*-time] — Time to reach destination, starting before the event.
w1 :: Signal = .5 [*-w1] — Start weight.
w2 :: Signal = .5 [*-w2] — End weight.
from^env :: Maybe Pitch = _ [from, *-from] — Start from this pitch. If unset, use the previous pitch.
s> -- sigmoid-next
prelude : pitch generator: Interpolate from the previous value to the given one. If the event's duration is 0, interpolate from this event to the next.
Tags: prev
pitch :: Pitch or Signal (Transposition) [*-pitch] — Destination pitch, or a transposition from the previous one.
w1 :: Signal = .5 [*-w1] — Start weight.
w2 :: Signal = .5 [*-w2] — End weight.
from^env :: Maybe Pitch = _ [from, *-from] — Start from this pitch. If unset, use the previous pitch.
s>> -- sigmoid-next-const
prelude : pitch generator: Interpolate from the previous value to the given one.
Tags: prev
pitch :: Pitch or Signal (Transposition) [*-pitch] — Destination pitch, or a transposition from the previous one.
time :: Signal (Time, default real) = .1s [*-time] — Time to reach destination.
w1 :: Signal = .5 [*-w1] — Start weight.
w2 :: Signal = .5 [*-w2] — End weight.
from^env :: Maybe Pitch = _ [from, *-from] — Start from this pitch. If unset, use the previous pitch.
scale -- scale
prelude : pitch transformer: Bring a scale into scope.
scale :: Str [scale] — Look up scale by name.
args^* :: Val [] — Scale arguments.
set -- set
prelude : pitch generator: Emit a pitch with no interpolation.
pitch :: Signal (NN) or Pitch [*-pitch] — Set this pitch.
set -- set
prelude : pitch transformer: Prepend a pitch to a signal. This is useful to create a discontinuity, e.g. interpolate to a pitch and then jump to another one.
pitch :: Signal (NN) or Pitch [*-pitch] — Set this pitch.
set-or-move -- set-or-move
prelude : pitch generator: Emit a pitch with no interpolation if it coincides with a note attack, and interpolate otherwise.
pitch :: Signal (NN) or Pitch [*-pitch] — Set this pitch.
time :: Signal (Time, default real) = .15s [*-time] — Time to move to the pitch.
sh -- sh prelude : pitch transformer: Sample & hold. Hold values at the given speed.
speed :: time signal (default real) = 10 [speed, *-speed] — Repeat at this speed. If it's a RealTime, the value is the number of repeats per second, which will be unaffected by the tempo. If it's a ScoreTime, the value is the number of repeats per ScoreTime unit, and will stretch along with tempo changes.
tr -- tr prelude : pitch generator: Generate a pitch signal of alternating pitches.
note :: Pitch [*-note] — Base pitch.
neighbor :: transpose signal (default diatonic) or Pitch = 1 [*-neighbor] — Alternate with an interval or pitch.
speed :: time signal (default real) = 14 [*-speed] — Trill at this speed. If it's a RealTime, the value is the number of cycles per second, which will be unaffected by the tempo. If it's a ScoreTime, the value is the number of cycles per ScoreTime unit, and will stretch along with tempo changes. In either case, this will emit only whole notes, i.e. it will end sooner to avoid emitting a cut-off note at the end.
tr-start^env :: Maybe Str (high low) = _ [tr-start] — Which note the trill starts with. If not given, it will start the unison note, which means it may move up or down.
tr-end^env :: Maybe Str (high low) = _ [tr-end] — Which note the trill ends with. If not given, it can end with either.
hold^env :: Signal (Time, default real) = 0s [hold, *-hold] — Time to hold the first note.
adjust^env :: Str (shorten stretch) = shorten [adjust, *-adjust] — How to adjust a trill to fulfill its start and end pitch restrictions.
tr-bias^env :: Signal (-1 <= x <= 1) = 0 [tr-bias] — Offset every other transition by this amount.
curve^env :: PFunction = curve-linear [curve, *-curve] — Curve function.
tr-transition^env :: untyped signal = 0 [tr-transition] — Take this long to reach the neighbor, as a proportion of time available.
tr-^ -- tr prelude : pitch generator
tr-_ -- tr: Generate a pitch signal of alternating pitches.
A ^ suffix makes the trill starts on the higher value, while _ makes it start on the lower value. A second suffix causes it to end on the higher or lower value, e.g. ^_ starts high and ends low. -_ has start unspecified, and ends low. No suffix causes it to obey the settings in scope.
note :: Pitch [*-note] — Base pitch.
neighbor :: transpose signal (default diatonic) or Pitch = 1 [*-neighbor] — Alternate with an interval or pitch.
speed :: time signal (default real) = 14 [*-speed] — Trill at this speed. If it's a RealTime, the value is the number of cycles per second, which will be unaffected by the tempo. If it's a ScoreTime, the value is the number of cycles per ScoreTime unit, and will stretch along with tempo changes. In either case, this will emit only whole notes, i.e. it will end sooner to avoid emitting a cut-off note at the end.
tr-start^env :: Maybe Str (high low) = _ [tr-start] — Which note the trill starts with. If not given, it will start the unison note, which means it may move up or down.
hold^env :: Signal (Time, default real) = 0s [hold, *-hold] — Time to hold the first note.
adjust^env :: Str (shorten stretch) = shorten [adjust, *-adjust] — How to adjust a trill to fulfill its start and end pitch restrictions.
tr-bias^env :: Signal (-1 <= x <= 1) = 0 [tr-bias] — Offset every other transition by this amount.
curve^env :: PFunction = curve-linear [curve, *-curve] — Curve function.
tr-transition^env :: untyped signal = 0 [tr-transition] — Take this long to reach the neighbor, as a proportion of time available.
tr^ -- tr prelude : pitch generator
tr_ -- tr: Generate a pitch signal of alternating pitches.
A ^ suffix makes the trill starts on the higher value, while _ makes it start on the lower value. A second suffix causes it to end on the higher or lower value, e.g. ^_ starts high and ends low. -_ has start unspecified, and ends low. No suffix causes it to obey the settings in scope.
note :: Pitch [*-note] — Base pitch.
neighbor :: transpose signal (default diatonic) or Pitch = 1 [*-neighbor] — Alternate with an interval or pitch.
speed :: time signal (default real) = 14 [*-speed] — Trill at this speed. If it's a RealTime, the value is the number of cycles per second, which will be unaffected by the tempo. If it's a ScoreTime, the value is the number of cycles per ScoreTime unit, and will stretch along with tempo changes. In either case, this will emit only whole notes, i.e. it will end sooner to avoid emitting a cut-off note at the end.
tr-end^env :: Maybe Str (high low) = _ [tr-end] — Which note the trill ends with. If not given, it can end with either.
hold^env :: Signal (Time, default real) = 0s [hold, *-hold] — Time to hold the first note.
adjust^env :: Str (shorten stretch) = shorten [adjust, *-adjust] — How to adjust a trill to fulfill its start and end pitch restrictions.
tr-bias^env :: Signal (-1 <= x <= 1) = 0 [tr-bias] — Offset every other transition by this amount.
curve^env :: PFunction = curve-linear [curve, *-curve] — Curve function.
tr-transition^env :: untyped signal = 0 [tr-transition] — Take this long to reach the neighbor, as a proportion of time available.
tr^^ -- tr prelude : pitch generator
tr^_ -- tr
tr_^ -- tr
tr__ -- tr: Generate a pitch signal of alternating pitches.
A ^ suffix makes the trill starts on the higher value, while _ makes it start on the lower value. A second suffix causes it to end on the higher or lower value, e.g. ^_ starts high and ends low. -_ has start unspecified, and ends low. No suffix causes it to obey the settings in scope.
note :: Pitch [*-note] — Base pitch.
neighbor :: transpose signal (default diatonic) or Pitch = 1 [*-neighbor] — Alternate with an interval or pitch.
speed :: time signal (default real) = 14 [*-speed] — Trill at this speed. If it's a RealTime, the value is the number of cycles per second, which will be unaffected by the tempo. If it's a ScoreTime, the value is the number of cycles per ScoreTime unit, and will stretch along with tempo changes. In either case, this will emit only whole notes, i.e. it will end sooner to avoid emitting a cut-off note at the end.
hold^env :: Signal (Time, default real) = 0s [hold, *-hold] — Time to hold the first note.
adjust^env :: Str (shorten stretch) = shorten [adjust, *-adjust] — How to adjust a trill to fulfill its start and end pitch restrictions.
tr-bias^env :: Signal (-1 <= x <= 1) = 0 [tr-bias] — Offset every other transition by this amount.
curve^env :: PFunction = curve-linear [curve, *-curve] — Curve function.
tr-transition^env :: untyped signal = 0 [tr-transition] — Take this long to reach the neighbor, as a proportion of time available.
trs -- trs
prelude : pitch generator: Generate a pitch signal of alternating pitches. Like tr, but with defaults for smooth transitions.
note :: Pitch [*-note] — Base pitch.
neighbor :: transpose signal (default diatonic) or Pitch = 1 [*-neighbor] — Alternate with an interval or pitch.
speed :: time signal (default real) = 14 [*-speed] — Trill at this speed. If it's a RealTime, the value is the number of cycles per second, which will be unaffected by the tempo. If it's a ScoreTime, the value is the number of cycles per ScoreTime unit, and will stretch along with tempo changes. In either case, this will emit only whole notes, i.e. it will end sooner to avoid emitting a cut-off note at the end.
tr-start^env :: Maybe Str (high low) = _ [tr-start] — Which note the trill starts with. If not given, it will start the unison note, which means it may move up or down.
tr-end^env :: Maybe Str (high low) = _ [tr-end] — Which note the trill ends with. If not given, it can end with either.
hold^env :: Signal (Time, default real) = 0s [hold, *-hold] — Time to hold the first note.
adjust^env :: Str (shorten stretch) = shorten [adjust, *-adjust] — How to adjust a trill to fulfill its start and end pitch restrictions.
tr-bias^env :: Signal (-1 <= x <= 1) = 0 [tr-bias] — Offset every other transition by this amount.
trs-^ -- trs
prelude : pitch generator
trs-_ -- trs: Generate a pitch signal of alternating pitches. Like tr, but with defaults for smooth transitions.
A ^ suffix makes the trill starts on the higher value, while _ makes it start on the lower value. A second suffix causes it to end on the higher or lower value, e.g. ^_ starts high and ends low. -_ has start unspecified, and ends low. No suffix causes it to obey the settings in scope.
note :: Pitch [*-note] — Base pitch.
neighbor :: transpose signal (default diatonic) or Pitch = 1 [*-neighbor] — Alternate with an interval or pitch.
speed :: time signal (default real) = 14 [*-speed] — Trill at this speed. If it's a RealTime, the value is the number of cycles per second, which will be unaffected by the tempo. If it's a ScoreTime, the value is the number of cycles per ScoreTime unit, and will stretch along with tempo changes. In either case, this will emit only whole notes, i.e. it will end sooner to avoid emitting a cut-off note at the end.
tr-start^env :: Maybe Str (high low) = _ [tr-start] — Which note the trill starts with. If not given, it will start the unison note, which means it may move up or down.
hold^env :: Signal (Time, default real) = 0s [hold, *-hold] — Time to hold the first note.
adjust^env :: Str (shorten stretch) = shorten [adjust, *-adjust] — How to adjust a trill to fulfill its start and end pitch restrictions.
tr-bias^env :: Signal (-1 <= x <= 1) = 0 [tr-bias] — Offset every other transition by this amount.
trs^ -- trs
prelude : pitch generator
trs_ -- trs: Generate a pitch signal of alternating pitches. Like tr, but with defaults for smooth transitions.
A ^ suffix makes the trill starts on the higher value, while _ makes it start on the lower value. A second suffix causes it to end on the higher or lower value, e.g. ^_ starts high and ends low. -_ has start unspecified, and ends low. No suffix causes it to obey the settings in scope.
note :: Pitch [*-note] — Base pitch.
neighbor :: transpose signal (default diatonic) or Pitch = 1 [*-neighbor] — Alternate with an interval or pitch.
speed :: time signal (default real) = 14 [*-speed] — Trill at this speed. If it's a RealTime, the value is the number of cycles per second, which will be unaffected by the tempo. If it's a ScoreTime, the value is the number of cycles per ScoreTime unit, and will stretch along with tempo changes. In either case, this will emit only whole notes, i.e. it will end sooner to avoid emitting a cut-off note at the end.
tr-end^env :: Maybe Str (high low) = _ [tr-end] — Which note the trill ends with. If not given, it can end with either.
hold^env :: Signal (Time, default real) = 0s [hold, *-hold] — Time to hold the first note.
adjust^env :: Str (shorten stretch) = shorten [adjust, *-adjust] — How to adjust a trill to fulfill its start and end pitch restrictions.
tr-bias^env :: Signal (-1 <= x <= 1) = 0 [tr-bias] — Offset every other transition by this amount.
trs^^ -- trs
prelude : pitch generator
trs^_ -- trs
trs_^ -- trs
trs__ -- trs: Generate a pitch signal of alternating pitches. Like tr, but with defaults for smooth transitions.
A ^ suffix makes the trill starts on the higher value, while _ makes it start on the lower value. A second suffix causes it to end on the higher or lower value, e.g. ^_ starts high and ends low. -_ has start unspecified, and ends low. No suffix causes it to obey the settings in scope.
note :: Pitch [*-note] — Base pitch.
neighbor :: transpose signal (default diatonic) or Pitch = 1 [*-neighbor] — Alternate with an interval or pitch.
speed :: time signal (default real) = 14 [*-speed] — Trill at this speed. If it's a RealTime, the value is the number of cycles per second, which will be unaffected by the tempo. If it's a ScoreTime, the value is the number of cycles per ScoreTime unit, and will stretch along with tempo changes. In either case, this will emit only whole notes, i.e. it will end sooner to avoid emitting a cut-off note at the end.
hold^env :: Signal (Time, default real) = 0s [hold, *-hold] — Time to hold the first note.
adjust^env :: Str (shorten stretch) = shorten [adjust, *-adjust] — How to adjust a trill to fulfill its start and end pitch restrictions.
tr-bias^env :: Signal (-1 <= x <= 1) = 0 [tr-bias] — Offset every other transition by this amount.
u -- up prelude : pitch generator: Ascend at the given speed until the next event.
Tags: prev
slope :: Signal (Transposition) = 1c [*-slope] — Ascend this many steps per second.
from^env :: Maybe Pitch = _ [from, *-from] — Start from this pitch. If unset, use the previous pitch.
curve^env :: PFunction = curve-linear [curve, *-curve] — Curve function.
unless-c -- when-c
prelude : pitch transformer
when-c -- when-c: Only derive if the control has the given value. E.g., you can use a %var control to select among different variations.
val :: Signal (integral) [*-val] — Value.
control :: Signal = 0 [*-control] — Control.
unless-e -- when-e
prelude : pitch transformer
when-e -- when-e: Only derive if environ value is set to the given value. In a block derived multiple times by different instruments, this can be used to solo a bit of score to one particular instrument.
name :: Str [*-name] — Environ key.
value :: Maybe Val = _ [*-value] — Environ value. If not given, require only that the environ key is set.
xcut -- xcut
prelude : pitch generator
xcut-h -- xcut: Cross-cut between two pitches. The -h variant holds the value at the beginning of each transition.
fst :: PSignal [*-fst] — First pitch.
snd :: PSignal [*-snd] — Second pitch.
speed :: time signal (default real) = 14 [*-speed] — Speed.