Steno | SuperCollider 3.13.0 Help

Description

Steno, a little concatenative live coding language embedded in SuperCollider, makes code for combining synth graphs very short, so that writing endless chains is like writing a single long word. A word is a program. A letter is a synth.¹

Programs look like this:--ab[(ab)(ab)(ab)]c

Syntax:

Steno has a minimal syntax:

"a" one letter equals one synth
abc >> three synths in series, one feeding into the next
"[]" square brackets indicate a parallely nested structure:
[ab]c >> a and b are in parallel to each other, their sum is fed into c
"()" round brackets indicate serially nested structure
[(ab)(ab)] >> both appearances of ab are in series but parallel to each other
"{}" curly brackets open a stack for operators in postfix syntax
{ab*} >> a and b are fed into the operator *{abc*+} >> b and c are fed into the operator *, its result is fed together with a into +
"!" an exclamation mark within the expression forces a full replacement at evaluation time
abc!
line ending comments are ignored
abc // this is a comment
variable names are optional and can be declared explicitly, see: -declareVariables

Semantics:

Steno follows a dual language approach, making it highly suitable for live coding. You can rewrite both the steno program and its sclang interpretation at runtime. So the meaning of each letter, its synthesis definition, can be changed anytime and the corresponding program changes accordingly.
Programs are composed of concurrently running processes. In other words, the whole program has no explicit temporal semantics, instead each component (i.e. character) stands for its own temporal unfolding.
Only those parts of the program that are rewritten are newly (re-)evaluated. Thus, elements are kept, replaced, removed or inserted accoding to the difference between the old and the new program.

NOTE:

This system is experimental, and you may encounter irregular problems.
Steno does not work on Windows because it relies on the unix diff command.
You may have to adapt DiffString.tempFilePath = ... in case the external diff command fails to write a temporary file.

To avoid live coding troubles, some optional simplifications are given (by the -preProcessor):

in the outer scope, words surrounded by spaces and lines are interpreted as parallel to each other: ab ab is equivalent to [(ab)(ab)]
depending on the current scope (() or []), spaces determine either parallel or sequential structuring: [ab ab] -> [(ab)(ab)], and (ab ab) -> ([ab][ab]).
non-matching brackets will be fixed as far as possible: "(ab (ab" will become (ab (ab))

Class Methods

.new

.push

Return a new instance, ready to be specified. If push is used, it is immediately pushed (see -push).

Arguments:

numChannels	The number of channels of the interconnecting busses (this is the same across the whole synth tree).
expand	If set to true, the synth functions are multichannel expanded to numChannels.
maxBracketDepth	The maximum depth of nested brackets. This determines the number of busses that need to be allocated.
server	Server to play on.

.current

The current Steno instance (like e.g. TempoClock: *default).

Instance Methods

.value

Interpret a string of steno code.

Arguments:

string

The program to run (a String).t = Steno.new; t.quelle(\x, { Dust.ar(4 ! 2) }); t.filter(\a, { |input| Ringz.ar(input, LFNoise1.kr(0.01).range(300.0, 1000.0) * [1, 1.01], 0.3) }); t.filter(\g, { |input| CombL.ar(input, 0.2, ExpRand(0.003, 0.1), Rand(0.5, 1.3)) }); t.value("xa"); t.value("xa xa"); t.value("xa xa xa"); t.value("xag xag xag");

.push

Only one instance of steno can be the current one. "push" make this current and allocate necessary busses.t.push(true); --xaf --x[(xaf)(af)(af)]f --x[(xaf)(af)(af)]f! // force resend with the !-operator --!x[(xaf)(af)(af)]f // … or prepended

Arguments:

pushSyntax

If true, modify the sclang interpreter preprocessor to allow to write steno programs directly. Lines that are prefixed with "--" are interpreted as steno code, multiple lines are interpreted as parallel.

.pop

Clears the busses and removes it.t.pop(true);

Arguments:

popSyntax

Reset interpreter to normal

.clear

Free all ressources

.set

Set and store synth arguments. All synths of that letter will be set to the same value. If you need varaiation between letters, either add some randomness or use the structural arguments passed as controls (see below under -filter and -quelle). You can add your own controls using NamedControls.t = Steno.new; t.set(\a, \amp, 0.2, \zz, 1.286); t.settings; // settings is a dictionary of dictionaries t = Steno.new; t.quelle(\a, { SinOscFB.ar(2 ** LFTri.kr(\modrate.kr(2)) * \freq.kr(300), \feedback.kr(0.5)) * 0.1 }); t.quelle(\b, { SinOscFB.ar(2 ** LFTri.kr(\modrate.kr(2)) * \freq.kr(300), \feedback.kr(0.5)) * 0.1 }); t.value("aaabbb"); t.set(\a, \modrate, 0.4, \freq, 100, \feedback, 2.1); // as settings, any correct synth setting can be used: Ndef(\x, { MouseX.kr(0.1, 10, 1) }); t.set(\b, \modrate, Ndef(\x));

NOTE: when the value is a function, it is called for each synth, and controls are passed in as a dictionary, as to allow arguments to depend on the graph.

NOTE: If the value is a Ref (containing the value), the setting spills over into the subsequent and deeper nested synths (not to the next level up). This allows to uses synths to set parameters for other synths.

A short form is the method -setter, which generates a dummy synth with referenced settings.

Special values are:

fadeTime	cross fade time	default: 0.02
attack	ratio of fadeTime used as attack (for 1, it equals fadeTime)	default: 0
mix	sound level	default: 1
through	for filters: pre vs. post level	default: 0
hangTime	for filters, as a maximum release tail length, unless fadeTime is longer	default: 30

Arguments:

name	Name of the synth definition
... keyValuePairs	Any number of parmeters and values. Values can be anything that can be converted to a synth argument.

.setGlobal

Dictionary of synth arguments for all synth functions (for Special values, see -set).t = Steno.new; t.setGlobal(\fadeTime, 2.0); t.settings.globalSettings; // settings are a global dictionary

Arguments:

... keyValuePairs

Any number of parmeters and values. Values can be anything that can be converted to a synth argument.

NOTE: when the value is a function, it is called for each synth, and controls are passed in, as to allow arguments to depend on the graph

.settings

Instance of class StenoSettings, which provides different levels of synth arguments for all synth functions:

globalSettings	parameters applied to each synth in the graph
synthSettings	parameters applied only to the synths that have a given name

If the value is a Function (or anything that responds to the message value), it is called for each synth, passing in the following informations as a dictionary: synthIndex (the count for each synth), index (the count for each type of synth), depth (the current nesting depth), and the token (name of the synth).

The synthSettings have a special feature: if the value is a Ref (containing the value), the setting spills over into the subsequent and deeper nested synths (not to the next level up). This allows to uses synths to set parameters for other synths.

.numChannels

Set the number of channels of the system - if running, synths defs are rebuilt and synths are restarted. If expand is true, the functions will multichannel expand.

.expand

Set to true to make synth functions multichannel expand.

.freeAll

Free all synths and empty current cmdLine.

.releaseHanging

Free all synths that have been released but which still run as they have a filter input. This will cut long filter tails.

.quant

Specify the moment of changes relative to a temporal grid (see Quant).t = Steno.new; t.quelle(\a, { Ringz.ar(Impulse.ar(1), { Rand(200, 700) } ! 2, 0.3) }); t.quelle(\b, { Ringz.ar(Impulse.ar(2),{ Rand(3000, 7000) } ! 2, 0.1) }); t.filter('&', { |input| DelayN.ar(input, 0.5, Rand(0, 0.5).round(1/6)) * Rand(0.5, 1) + input}); t.filter('.', { |input| Limiter.ar(input) }); // full stop is a limiter here. t.quant = 1; t.("abaaabaa."); t.("aba&aabaa."); t.("aba&aab&a&a.");

.quelle

.filter

These two methods take a Function and convert it into a SynthDef, represented by a letter.

quelle converts it to a synth def that produces sound without an input necessary (cross fade will envelope the output). It adds to the signal on the bus.

filter converts it to a synth def that filters a signal input (cross fade will envelope the input and thus maintain decaying signals). It replaces the signal on the bus.t = Steno.new; t.quelle(\a, { Blip.ar(Rand(4, 16)) * 0.2 }); t.quelle(\b, { Saw.ar(Rand(400, 700)) * 0.2 }); t.filter(\f, { |input| CombL.ar(input, 0.2, Rand(0.01, 0.2), Rand(0.4, 2)) }); t.value("baba"); t.value("babaf"); t.value("(ab)f (ab)f");

Arguments:

name	The letter which represents the synth def
func	A UGen function, it takes the arguments below. For more controls to be set by the -set method, use a NamedControl.t = Steno.new; t.quelle(\a, { SinOsc.ar(Rand(0.9, 1.1) * \freq.kr(440)) * 0.2 }); t.("aaa"); t.set(\a, \freq, 800); // this affects all "a" synths, but none else. Arguments passed to the function are: input The input signal for the filtert = Steno.new; t.quelle(\a, { \|input\| SinOsc.ar(ExpRand(400, 7000), input * MouseX.kr(0, 20)) * 0.2 }); t.quelle(\b, { \|input\| Saw.ar(ExpRand(400, 7000)) * input * MouseX.kr(0, 20) * 0.2 }); t.value("baba"); t.value("ab"); controls A dictionary of further control inputs. It passes the following values: gate Optional gate trigger that goes to zero when the synth is freedt = Steno.new; t.quelle(\a, { \|input, controls\| SinOsc.ar(ExpRand(400, 7000)) + (Decay.kr(1 - controls.at(\gate), \fadeTime.kr) * PinkNoise.ar) * 0.2 }); t.value("baba"); t.value("ab"); index index of that specific synth (not counting internal synths needed for parentheses or square brackets).t = Steno.new; t.quelle(\a, { \|input, controls\| SinOsc.ar(controls.at(\index) + 1.3 * 200) * 0.2 }); t.value("a"); t.value("aa"); t.value("aaaaaa"); depth the nesting depth in the codet = Steno.new; t.quelle(\a, { \|input, controls\| SinOsc.ar(controls.at(\index) + 0.5pi * 100) * LFPulse.kr(1 + controls.at(\depth)) * 0.2 }); t.value("aaaaaa"); t.value("(aaa)aaa"); t.value("aa((aa(aaa(a)))a)a(((a)))"); mix the level control of the output signal through (only: filter) controls the ratio previous input to filtered output signal env the envelope that is used to fade in and fade out the input signal.
multiChannelExpand	Specify whether the ugen graph should be expanded o the full number of channels (see: -numChannels and -expand).
update	Specify whether synth should be updated immediately when synth def is changed (MAY CHANGE IN THE FUTURE).
numChannels	Specify a number of channels the function should have (by default, it uses -numChannels).

Discussion:

WARNING: In the filter method, when the synth is replaced by a new one, only the input signal is faded out. So you have to take care that your processed output will become silent after some time. If you add a signal to the output, use the \gate.kr control or controls[\env] to envelope it. There is a synth control input called hangTime that removes hanging notes after some longer time (after 30 sec by default). You can manually release all potentially hanging synths by calling -releaseHanging.

t.quelle(\o, { Impulse.ar(1) }); t.("ox"); // replace this while running – no problem ( t.filter(\x, { |input| CombL.ar(input, 0.2, Rand(0.001, 0.02), 2) }) ); // this will hang, because there is a constant output (the SinOsc) ( t.filter(\x, { |input| CombL.ar(input, 0.2, Rand(0.001, 0.02), 2) + SinOsc.ar(Rand(300, 1000), 0, 0.02) }) ); // this is fine: use the synth envelope to fade out the SinOsc ( t.filter(\x, { |input, controls| CombL.ar(input, 0.2, Rand(0.001, 0.02), 2) + SinOsc.ar(Rand(300, 1000), 0, 0.02 * controls[\env]) }) );

.declareVariables

Add a number of variable names that can be used to store and recall signals.

Arguments:

names

An array of variable names, usually single letters (for exceptions, see: -preProcess). The leftmost appearance of a variable name means that the signal coming from its left is assigned to as well as passed through it. Subsequent appearances of the same name act like a quelle of the captured signal, i.e. the captured signal re-appears and is added to the signal coming form the left.// Adding signal variables. The example uses 0..9 as variable names. s.boot; ( t = Steno.push; t.setGlobal(\fadeTime, 1); t.declareVariables((0..9)); t.quelle(\a, { Impulse.ar(Rand(3, 10) ! 2 * (3 ** LFNoise1.kr(0.2))) }); t.quelle(\b, { Saw.ar(Rand(40, 600 ! 2)) * 0.01 }); t.filter(\f, { |in| BPF.ar(in, LFNoise0.kr(6).exprange(200, 8000), 0.01) * 15 }); t.filter(\x, { |in| LFPulse.kr(ExpRand(0.4, 35)) * in }); t.filter('.', { |in| 0.0 }); // signal sink blocks signal. ) // play into variables but don't listen --bbb0. aaa1. // listen to the filtered sum --bbb0. aaa1. 01f // assign filtered sum to variable and filter it again --bbb0. aaa1. 01f3. 3fx 3fx 3fx // changing the through controls --aaaff afx Tdef(\x, { loop { t.setGlobal(\through, 1.0.rand); 2.wait } }).play;

You can set the following parameters (default values in brackets):

mix (1): How much of the stored signal is forwarded to the right
through (1): How much of the signal to its left is forwarded to the right
feedback (0): An attenuverter ranging between -1.0 and 1.0. Its absolute value determines the amount feedback from the right-most declaration to the left-most. If negative, the feedback is phase-inverted.// Karplus-Strong ( // a filter that creates an impulse t.filter(\i, {|in, ctls| Dust2.ar(10) + DelayL.ar(in.reverse, 0.1, {Rand(0.001, 0.0005)}!2, 1) }); // a variable t.declareVariables([0]); ) // swap between one and more filters -- 0i0 -- 0ii0 // set feedback parameters (negative creates lower octave) t.set(\0, \feedback, 0.9) t.set(\0, \feedback, -0.9)
assignment (1): The number of times a variable can be assigned in succession (left to right). If the number is reached, the signal is not altered anymore. Assigned signals are mixed down to one multichannel stream.

.operator

Define a new operator. Operators take operands (signals) from the stack and combine them. A stack is defined by enclosing an expression in curly brackets, like {ab*}. If operands are left on the stack, they can be combined with the result by subsequent operators, like {abc+*}.

WARNING: You have to take care that your processed output will become silent after some time. If you add a signal to the output, use the \gate.kr control or controls[\env] to envelope it. See above under -filter

Arguments:

name	The letter which represents the synth def
func	A UGen function, which takes a specific number of arguments (given by its arity (see below)). Each argument is a signal of the full number of channels of the steno graph.
arity	The number of operands (e.g. binary, or ternary).
multiChannelExpand	Specify whether the ugen graph should be expanded o the full number of channels (see: -numChannels and -expand).
update	Specify whether synth should be updated immediately when synth def is changed (MAY CHANGE IN THE FUTURE).t = Steno.new; t.quelle(\a, { SinOsc.ar(Rand(0.9, 1.1) * 440) * 0.2 }); t.quelle(\b, { LFPulse.kr(Rand(1, 3), 0, LFNoise0.kr(1).exprange(0.1, 0.6)) }); t.operator('', { \|x, y\| x y }, 2); t.("{ab}"); // gating the output, if signal doesn't end by itself t.operator('', { \|x, y, controls\| x * y + WhiteNoise.ar(controls[\env] * 0.01)}, 2); t.("aaaa");

.setter

A convenience method that generates a dummy synth with a setting that spills over to subsequent synths (see comment at -set).t = Steno.new; t.quelle(\n, { Dust.ar(\density.kr(1000) ! 2, 0.1) }); t.filter(\f, { |in| BPF.ar(in * 10, \freq.kr(600), \rq.kr(0.1)) }); t.setter(\u, \freq, { exprand(4000, 10000) }); t.setter(\a, \freq, { exprand(400, 1000) }); t.setter(\i, \density, { exprand(4, 20) }); t.set(\z, \rq, 0.05); t.value("nf nf nf"); t.value("nuf naf nuf"); t.value("inuf inaf inuf");

NOTE: as the synths are kept running, in fact this doesn't work as well as it should. We'd need to reset the synth parameters to make them forget the values that have been passed in.

.variables

Returns a dictionary of variables, if defined.

.resendSynths

Restart all synths and release hanging notes.

.rebuild

Generate new SynthDefs and restart all synths.

.bus

The output bus.

.busIndices

An array of contiguous bus indices used internally for signal routing

.monitor

Returns the monitor synth which maps the last output to the output bus (default: 0).

.cmdLine

Return most recently compiled code, after preprocessing.t.("ab ab"); t.rawCmdLine; // returns "[(ab)(ab)]" t.cmdLine;

.rawCmdLine

Return most recently evaluated code.t.("ab ab"); t.rawCmdLine; // returns "ab ab"

.prevTokens

Returns the most recent tokens (the cmdLine split into separate elements, by default letters, but this could also be otherwise, see -preProcessor).

.argList

.synthList

.diff

.encyclopedia

.server

.synthList

.maxBracketDepth

Introspection: returns internal representations of busses, synthdefs, synths, and synth ressources.

.preProcess

Specify whether the internal preProcessor is used or not. In situation where efficiency is important, it can be omitted by just writing 'correct' code.

.preProcessor

Set the preProcessor

Steno uses a DiffString parser to interpret code. You can change its tokenizer to fit your own language:t = Steno.new; t.quelle(\hello, { |input| SinOsc.ar(SinOsc.ar(SinOsc.ar(0.1, 0, 1, 2), (input * 10), 400, 800), 0, 0.1) }); t.quelle(\word, { |input| SinOsc.ar(Saw.ar(SinOsc.ar(0.1 * (input * 3), 0, 1, 2), 300, 800 * (input * 100)), 0, 0.1) }); t.preProcessor = nil; // remove default shortcuts t.diff.tokenizer = { |str| str.split($ ) }; t.verbosity = 2; t.value("hello word word"); t.value("hello"); t.value("hello word hello word");

Other things to do

BNF for standard Steno

<letter> is any printable letter
<synth> ::== <letter>
<op> ::== <letter>
<exp> ::== { <exp> | <synth> | <ser> | <par> | <app> }
<ser> ::== `(` <exp> `)`
<par> ::== `[` <exp> `]`
<app> ::== `{` <exp> { <op> } `}`

[1] - This little language was developed together with the students of the music informatics seminar 2013 at the IMM, in particular Armin Badde, Raffael Seyfried, and Florian Zeeh. It has been further developed together with Till Bovermann and Ron Kuivila. Special thanks also to Hans W. Koch, who moderated the seminar together with me.

helpfile source: HelpSource/Classes/Steno.schelp
link::Steno/Classes/Steno::

StenoExtension

Description

Class Methods

.new

.push

Arguments:

.current

Instance Methods

.value

Arguments:

.push

Arguments:

.pop

Arguments:

.clear

.set

Arguments:

.setGlobal

Arguments:

.settings

.numChannels

.expand

.freeAll

.releaseHanging

.quant

.quelle

.filter

Arguments:

Discussion:

.declareVariables

Arguments:

.operator

Arguments:

.setter

.variables

.resendSynths

.rebuild

.bus

.busIndices

.monitor

.cmdLine

.rawCmdLine

.prevTokens

.argList

.synthList

.diff

.encyclopedia

.server

.synthList

.maxBracketDepth

.preProcess

.preProcessor

Other things to do

BNF for standard Steno

Steno
Extension