Plugins

Resonon’s built-in effects and samplers cover a lot of ground, but sometimes you want a specific third-party reverb, or a synth you already know. Resonon loads CLAP and VST3 plugins — as effects in a track’s chain, or as the instrument on a track — and lets you read, set, and modulate their parameters from code.

Two reverb plugins ship bundled with Resonon and load instantly, with no setup. Drop one on a track with Effect:

use "std/instruments" { Sampler, Kit };

let drums = AudioTrack("drums");
drums.load_instrument(Sampler(Kit("CR-78")));
drums << [bd sd bd sd];

let reverb = Effect("resonon-reverb");     // bundled — no scan needed
reverb.param_set("Room", 0.8);
drums.load_effect(reverb);

PLAY;

Effect("resonon-reverb") loads the plugin; param_set dials a parameter; load_effect puts it in the chain like any built-in effect. The other bundled plugin is "resonon-reverb-plate", a lusher plate reverb.

Note

The everyday effects from Effects — Delay, the filters, Overdrive — are native DSP, not plugins, and need no scan. Reach for Effect() and Instrument() when you want a third-party CLAP or VST3 plugin.

Finding Plugins

Bundled plugins aside, Resonon needs to know what’s installed before it can load a plugin by name. plugin_scan() searches the standard CLAP and VST3 folders for your OS and caches what it finds, so you only re-scan after installing or removing plugins:

let plugins = plugin_scan();
show(plugins.length());        // how many were found
PRINT plugins;                 // formatted table

let reverbs = plugins.filter("reverb");   // narrow by name substring
PRINT reverbs;

plugin_scan() returns a PluginList with .length(), .filter(name), .get(index), and .data (the raw entries, each carrying name, id, vendor, and format).

Loading Plugins

Effect(name) loads an effect; Instrument(name) loads an instrument. Both resolve the name the same way, in order: a full path ending in .clap/.vst3; a filename found in your plugin folders; or a display name from the scan cache. If nothing matches, Resonon lists the locations it searched and the plugins it knows about.

let shimmer = Effect("Valhalla Shimmer");      // by display name (after a scan)
let fx      = Effect("/path/to/plugin.clap");  // by full path
let synth   = Instrument("Surge XT");          // an instrument plugin

A track hosts a plugin instrument exactly like a built-in one:

let synth = Instrument("Surge XT");
let lead = AudioTrack("lead");
lead.load_instrument(synth);
lead << [C4 E4 G4 C5];

When a single bundle contains several plugins, pass the plugin ID as a second argument to pick one — Effect("Multi-FX", "com.vendor.multi-fx.chorus"). CLAP is tried before VST3 by default; you can change that in config.toml.

Parameters

.params() prints every parameter with its range, default, and current value; pass a substring to filter a plugin with a long list:

let reverb = Effect("resonon-reverb");
reverb.params();              // all of them
reverb.params("room");        // just the matching ones

Read a value with .param_get(name), and set one with .param_set(name, value), which returns the plugin so calls chain:

let reverb = Effect("resonon-reverb");

reverb.param_set("Room", 0.8)
      .param_set("Damp", 0.4)
      .param_set("Mix", 0.5);

show(reverb.param_get("Room"));      // 0.8

When you’d rather work in normalised terms, .param_set_norm(name, 0..1) maps a 0..1 value across the parameter’s real range — including any non-linear VST3 curve.

The << shorthand sets a parameter too, and it’s the one that also accepts a moving signal — so the same syntax that sets a value can modulate it:

use "std/signals" { Sine };

let reverb = Effect("resonon-reverb");
reverb.param("Mix") << 0.4;                       // set a value
reverb.param("Room") << Sine(0.2).range(0.3, 0.9);  // ...or modulate it

See Signals & Automation for the full set of modulation sources.

Plugin GUI

Many third-party plugins have a graphical editor. Check with .supports_gui(), then open and close the window with .show_gui() and .hide_gui():

let synth = Instrument("Surge XT");
if synth.supports_gui() {
    synth.show_gui();
}

The bundled Resonon reverbs have no GUI — .supports_gui() returns false — so you drive them with .params() and param_set / <<. Most third-party plugins do.

Saving State

.save_state(path) writes a plugin’s full state — every parameter plus internal data — to a file, and .load_state(path) reads it back into an instance. Both are chainable:

synth.save_state("presets/my_lead.preset");

let synth2 = Instrument("Surge XT");
synth2.load_state("presets/my_lead.preset");

Note

A .preset file holds opaque, plugin-specific binary state. Loading one into a different plugin prints a warning and may not produce anything useful — presets only round-trip with the plugin that wrote them.

Next Steps

You can scan, load, and control external instruments and effects. Next, bring external sound into Resonon.

• Recording & Input — live audio input and capturing your output
• Effects — the native DSP effects that need no plugin
• Signals & Automation — modulate plugin parameters with LFOs and envelopes