Every HISE developer eventually hits the same wall. You want ducking compression inside your plugin — the sound where the kick carves space in the bass, or the vocal pumps the pad underneath it — and HISE doesn't expose a host sidechain input the way a JUCE plugin does. You can't tell the DAW "send me this extra audio track" and read it in your script.

So people give up and do the sidechain in the DAW instead, which defeats the entire point of building it into the plugin.

The fix isn't a hidden HISE feature. It's a signal routing pattern — one that took me two shipped plugins to figure out — that sidesteps the missing host input entirely.

Why HISE doesn't have a host sidechain input

HISE is built on top of JUCE, and JUCE does support multi-bus plugins (which is what a host sidechain input actually is under the hood). But HISE's scripting layer was intentionally designed around single-input plugins to keep the module graph sane. Adding a second host bus means exposing it at every level of the script API — Processors, Modulators, Script Nodes — and Christoph Hart made the call to keep that complexity out.

For most plugin ideas this is fine. You're building a synth, or a rompler, or an FX unit that processes the audio it gets. Sidechain is the one exception where everyone runs into the wall.

What sidechaining actually is, stripped to the mechanic

Before the workaround, it's worth being precise about what sidechaining does. A sidechain compressor has two inputs — the program signal (what you hear) and the key signal (what triggers the compression). The envelope follower watches the key signal's amplitude. When the key crosses the threshold, the compressor clamps the program's gain. When the key goes quiet, the program returns to full volume.

The key signal doesn't have to be audio from another track. It can be anything that produces an amplitude envelope — a MIDI note trigger, an LFO, a transient detector running on the main input, or a pre-computed envelope baked into the plugin.

That last option is the one that opens the door.

The routing trick — internal key generation

Instead of asking the DAW for a sidechain input, your HISE plugin generates its own key signal internally from something the user already sends you. There are three patterns that work:

Pattern 1 — MIDI-triggered envelope. Your plugin receives a MIDI note (or a dedicated CC). That note fires an envelope that modulates the gain of your main audio path. To the user it sounds identical to a kick-triggered sidechain, because they program the MIDI part in the DAW exactly the way they'd program the kick itself.

Pattern 2 — Transient detection on the main input. You analyze the incoming audio for transients and use those detections as the key. This is how "sidechain-style" plugins without an explicit key input (like the ducker in some mastering chains) work. It doesn't give you kick-triggered ducking, but it does give you transient-aware compression that feels similar.

Pattern 3 — Built-in tempo-sync LFO. The plugin runs an LFO locked to host tempo, and that LFO becomes the key. This is how the "ShaperBox"-style pump effect works. Zero audio input required, just a tempo lock.

Pattern 1 is what the VST Development Course walks through in module 5 — it's the one that sounds most like "real" sidechain to a producer, and it's the easiest to implement in HISE.

Step 1 — the signal chain

Drop a Waveform Generator or your synth's main output into a MasterEffects container. Inside that container, add a SimpleGain processor — this is the node whose gain you're going to modulate. Right-click the Gain parameter and choose Edit in Modulator Tree. That gives you a modulator slot attached directly to the gain value.

Into that slot, drop an Envelope Modulator. Specifically, an AHDSR Envelope. Configure it:

This envelope is the key signal. It drives the gain down when triggered, then recovers.

Step 2 — the trigger

Here's where internal key generation earns its keep. You need the envelope to fire whenever a specific MIDI note arrives. A Script Processor at the top of the MIDI chain handles it:

const var DUCK_NOTE = 60; // C3 — reserved for sidechain trigger
const var gainEnvelope = Synth.getModulator("AHDSREnv");

function onNoteOn()
{
    if (Message.getNoteNumber() == DUCK_NOTE)
    {
        gainEnvelope.startNote();
        Message.ignoreEvent(true); // don't let this note become audio
    }
}

function onNoteOff()
{
    if (Message.getNoteNumber() == DUCK_NOTE)
    {
        gainEnvelope.stopNote();
    }
}

The user routes their kick track to your plugin's MIDI input (as notes at C3), and those notes fire the ducker instead of being played as audio. ignoreEvent(true) is critical — without it, C3 becomes a note your synth plays and a ducking trigger. You only want the trigger.

Step 3 — inverting the envelope

There's a subtle gotcha here. An AHDSR envelope outputs 0→1, which when routed to gain means 0dB when triggered and silence at rest. That's backward for ducking. You want full volume at rest and dropped volume when triggered.

Two fixes. The easy one: put a ConstantValueModulator at 1.0 in the same modulator slot in scaled mode, and the envelope in additive inverted mode (-1.0 scale factor). The clean one: use a GlobalModulator pointing at the envelope's output with the invert flag on, so you can reuse the same key across multiple duck points in the plugin.

The clean path is what ships. When you need to duck the reverb return and the delay feedback and the main synth from the same key signal, the GlobalModulator + invert pattern scales. Chaining three inverted envelopes doesn't.

The DAW user's workflow — and why it matters for commercial plugins

The experience from the producer's side looks like this. They drop your plugin on a bus. They route a dedicated MIDI track to the plugin (most DAWs let you target a plugin's MIDI input from any track). On that MIDI track they program a C3 note everywhere they want the bus to duck — usually copying the MIDI from their kick track. Done.

This is important for distribution. When you submit a plugin to Plugin Boutique or ADSR, one of the things they check is whether your plugin's key features are accessible without making the user read a manual. A sidechain that "just works" when the user duplicates their kick MIDI passes that test. A sidechain that requires setting up a special bus in their DAW does not.

Signal routing variants worth knowing

A few related patterns come up once you've built the basic version:

Multiple duckers, one key. Use the GlobalModulator trick from step 3 to drive independent gain nodes across your effect chain. This is what lets you build a "pump everything" preset with a single MIDI trigger.

Frequency-selective ducking. Put a crossover filter before the gain nodes, and only duck the low end (or the mids, or whatever band is clashing). This sounds more professional than a full-spectrum duck and is the technique behind a lot of modern mixing plugins.

Tempo-synced LFO as key. Replace the envelope with a LfoModulator synced to host tempo. The user gets pumping without programming any MIDI — set the rate to 1/4 and it auto-pumps with the kick on every DAW project. This is the cheapest "sidechain vibe" effect and it's a great free preset.

What a real host-sidechain solution would look like

If you truly need host-side key input — for example, if you're building a compressor for mix engineers who want to route the lead vocal into the plugin — then you're outside HISE's native scope and into JUCE territory. You'd expose a second audio bus via JUCE's BusesLayout, write a custom ScriptNode that exposes that bus to HISE, and drop the bus reader node into your graph.

That's the advanced path, covered at the end of the module in the VST Development Course. For the vast majority of plugins — synths, basslines, pads, pumping FX — the internal key pattern from this tutorial covers the use case at a fraction of the engineering cost.

What to avoid

Two anti-patterns I've seen ship:

Running the envelope in audio-rate mode by accident. HISE's modulators default to control rate (44100 / 64 per update). If you force audio rate, the CPU cost quintuples and the sonic difference is nil for an envelope this slow. Leave it at control rate.

Not compensating for the envelope's startup latency. If your Attack isn't 0, the duck lags the trigger by the attack time. For most pump effects this is imperceptible, but for transient-aware use cases you'll want to zero the attack or the duck feels loose.

Ship it

This is one of those HISE techniques that isn't in the official docs but shows up in every commercial plugin I've built for producer brands. The core mechanic is ten lines of script and one correctly-routed modulator. Once you've wired it once, you can drop it into any synth or FX plugin in under an hour.

Module 5 of the VST Development Course walks through three variants — the MIDI-triggered version here, a transient-detection version, and a host-sidechain JUCE extension. Founders' pricing is open through June 1.