The Code module and Visual

The Code module, added in 2.49, lets you write a module of your own in a simple expression language built for real-time audio. You can edit the code while it plays. Use it for a bit of custom maths between two modules, or go all the way to your own oscillators, filters, envelopes and effects.

Three functions connect your code to the rest of Drambo. Each one you call adds something to the module.

Two system variables are always there: sampleRate, the current sample rate, and tempo, the current tempo. Because pitch arrives in hertz, you rarely need cvToFreq and freqToCv, which convert between hertz and Drambo’s pitch scale (How pitch works).

There is nothing to declare: a variable exists once you assign to it. Every variable is a number — either a single value or a buffer of samples — and operators work on whole signals at once.

if (…) { … } else { … } blocks work too. In the default block mode, a condition is judged for the whole block, from its first sample; switch to per-sample mode when it has to be judged on every sample (Per-sample mode and feedback). Comments use // for a line and /* … */ for a block.

The language comes with a small standard library. Oscillators, filters, envelopes and delays keep their state from one block to the next.

By default the Code module works on blocks of samples, which is fast. Put #persample on the first line to run the script once per sample instead. It costs more, but it unlocks something nothing else in Drambo allows: reading a variable before it is assigned in the same pass, which gives you its value from the previous sample. Variables start at 0.

That is single-sample feedback — the basis of hand-made filters, physical models and feedback delays — and it’s the way round Drambo’s one-way signal flow (Feedback loops).

#persample
x = input(audio)
amount = param(value, Smooth)
// y still holds last sample’s value here
y = y + (x - y) * (1 - amount * 0.99)
output(y, audio)

These use only the functions listed in Built-in functions. Paste one into a Code module, and its knobs and sockets appear on the module.

x = input(audio)
drive = param(value, Drive)
wet = param(value, Mix)
y = tanh(x * (1 + drive * 5))
out = mix(y, x, wet)
output(out, audio)

x = input(audio)
rate = param(value, Rate)
depth = param(value, Depth)
lfo = oscSin(0.5 + rate * 12)
gain = 1 - depth * (0.5 + lfo * 0.5)
out = x * gain
output(out, audio)

p = input(pitch)
g = input(gate)
decay = param(time, Decay)
s = oscSaw(p) * envD(g, decay)
s = lpf(s, p * 3, 0.3)
output(s, audio)

Put the drive and tremolo on an effect track or inside a Processor rack. The plucked voice needs pitch and gate, so it goes after MIDI to CV on an instrument track; set its Decay knob to taste.

Drambo Visual, introduced in 2.54, is an in-app purchase that adds a modular environment for graphics. You patch visual modules the same way as sound modules, and the two share the same signals — so sequencers, LFOs, envelopes, MIDI, morphs and performance gestures can all drive what you see. You can show the result on an external display over HDMI and export audio and video in sync.

The main visual signal is the texture — an image of RGBA pixels — which flows from sources through processors to the Projector, which displays it. Visual modules can also turn textures back into sound and MIDI: 2.55 added modules that synthesise audio from live textures, and 2.56 added a MIDI Texture Scanner that plays notes from what it scans.

Visual launched with 42 modules and keeps growing. BeepStreet’s Drambo Visual pages document it in depth.