Code module

 

The Code module lets you create custom modules using a simple expression language - a high-performance audio-processing script for real-time synthesis and DSP.

The Expression Engine allows you to define audio signal processing chains using a C-like scripting language. Scripts are compiled to a bytecode or executed via an AST interpreter optimized for SIMD. 

 

You can use it for custom math processing or to build audio synthesizers, audio effects, modulators, pitch processors etc..

The engine supports:

- Vectorized or per sample processing: Operations are performed on buffers of audio samples (fast, almost like native Drambo), per sample: you can write totally custom DSP code, like filters. (about 2-5x slower). 

- Stateful nodes: Oscillators, filters, and envelopes maintain state between blocks.

- Control flow: ternary operator or if / else structures for conditional processing.

 

Please note

- You don't need to use ; at the end of lines :)

- Scientific notation of numbers (e.g. 1e-9) also shortened notation like .1 is not supported yet.

- Don’t break a single expression across multiple lines.

- The code module processes each voice and channel separately, so there is no direct access to stereo channels in the signal (yet).

- Try generating the code using AI (Your favourite agent). Include the link to this page as part of the prompt, or attach a PDF version of the page. It works!

 

Variables are implicitly declared upon assignment. All variables are floating-point numbers (scalars) or buffers of samples (vectors). In per-sample processing mode you may use a variable declared later as a feedback.

 

// Assignment

frequency = 440

amp = 0.5

// Output calculation

out = oscSin(frequency) * amp

 

In Drambo’s Code module, you work with a set of built-in functions (a “standard library”) to build DSP chains quickly - everything from basic math (e.g. sin, abs, pow, clamp ...) to audio primitives like oscillators (oscSin, oscSaw..), filters (lpf,bpf ...), envelopes (envAD,envD...), and delays (delay,delayTuned...). Some functions, like oscillators, filters or delays are stateful, they keep internal state between processing blocks.

Special Input/Output functions define external connectivity to it's Drambo modules.

 

input(type, name [optional])  Declares read-only input buffers provided by the host. 

 

 

param(type, name)  Declares controllable parameters.

 

Param types

 

 

// creates audio input and assigns it to in variable

in = input(audio)

 

// creates gate input named "My gate" - names are optional

in2 = input(gate, My gate)

 

// creates pitch knob named "Tune" and assigns it to pitch variable

pitch = param(pitch, Tune) 

// pitch variable is represented in Hz 20-20000 Hz

 

out = oscSin(10)

output(out, audio)

// creates output of type audio and sends out variable to it

 

#persample

Used in the first line switches the engine from block processing (default) to per-sample processing.

In per-sample mode, you can read a variable before it is assigned in the current cycle, allowing for single-sample feedback loops. Initial variable value is 0.

 

#persample

// Simple feedback filter

out = input - last * 0.9

last = out

#persample

// Simple feedback filter

out = input - out * 0.9

 

 

You may use two variables in your code:

 

- sampleRate  - contains the current system sample rate 

- tempo - contains the current tempo

 

 

The language supports standard arithmetic and comparison operators:

 

+ Addition

- Subtraction

* Multiplication

/ Division

> Greater Than

< Less Than

>= Greater or Equal

<= Less or Equal

== Equal

!= Not Equal

? : Ternary Conditional (condition ? trueVal : falseVal)  e.g.  a = b>c?d:e

 

You can use if and else blocks to control signal flow.

 

if (gate > 0.5) {

env = 1.0

} else {

env = 0.0

}

Important: In block processing (default), the condition is typically evaluated for the entire block (based on the first sample) unless #persample mode is active. 

 

Standard C-style comments are supported.

 

// Single line comment

/*

Multi-line

Block comment

*/

Standard mathematical functions apply element-wise to signals.

sin(x)

cos(x)

tan(x)

tanh(x)

abs(x)

log(x)

exp(x)

sqrt(x)

pow(a, b)

floor(x)

ceil(x)

fract(x)

and(a,b) or(a,b) xor(a,b)

min(a,b) max(a,b)

mix(a,b,m)      - out = m*a + (1-m)*b

clamp( x, min, max)

mod(x,y)

oscSin(freq, phase [[optional]], sync [[optional]])

oscSaw(freq)

oscTri(freq)

oscPulse(freq, width)

noise() 

 

lpf(input, cutoff, res) (12dB/oct) - SVF low pass filter

hpf(input, cutoff, res) (12dB/oct) - SVF high pass filter

bpf(input, cutoff, res) - SVF band pass filter 

notch(input, cutoff, res) - SVF notch filter

 

 

lpf6(input, cutoff) (6dB/oct) - one pole low pass filter

hpf6(input, cutoff) (6dB/oct) - one pole high pass filter

apf6(input, cutoff) (6db/oct) - one pole allpass filter

comb(input, frequency, feedback gain) - comb filter 

 

envAD(gate, attack time, decay time) - Attack/Decay envelope - triggered by rising edge, continues to the end

envD(gate, decay time) - Decay envelope - triggered by rising edge, continues to the end

envAHD(gate,attack time,hold time, decay time) - Attack/Hold/Decay envelope - triggered by rising edge, continues to the end

envAR(gate, attack time, decay time) - Attack/Release envelope. Release phase starts immediately from current state when gate goes to zero.

 

delay(input, timeInSeconds)

delayTuned(input, frequency) (Useful for Karplus-Strong and physical modelling)

 

 

 

 

// per sample processing - we need instant feedback

#persample

// inputs
p = input(pitch)
g = input(gate)

// trigger signal - basic, noise -> envelope
n = noise()
n *= envD(g,0.05)

// feedback loop and basic sample average - filter
ns = n - delayTuned(s,p)*0.995
s = (s+ns)*0.5

output(s,audio)

 

 

 

// per sample, because we need instant feedback

#persample

i=input(audio)

 

// compute beatDuration in seconds from current tempo (system variable)

beatDuration = 60.0/tempo
feedback = 0.9

 

s=i-delay(s,beatDuration)*feedback

output(s,audio)

 

 

 

// pitch and gate inputs

p = input(pitch)
g = input(gate)

// Attack and Decay paramters 
attack = param(time,Attack)
decay = param(time,Decay)

s = noise()

 

// Filter resonance - fixed
r=0.96

 

// Double 12db band pass filters = 24db 
s = bpf(s,p,r)
s = bpf(s,p,r)

 

// Scale output
s = s *0.1

 

// Apply AD envelope 
s = s * envAD(g,attack,decay)

 

// Output s  - default: audio
output(s)