Grilled Cheese

Grilled Cheese is a drum-bus compressor built with JUCE 8 and CMake, intended for drum buses. The signal path is a custom compressor, oversampled soft saturation, a high-shelf air band, and a parallel mix with latency compensation. The default settings are usable without adjustment.

It builds as AU, VST3 and a standalone application on macOS, and as VST3 and a standalone application on Windows.

Signal chain

input trim -> dry capture -> compressor -> oversampled saturation -> air shelf -> parallel mix -> output -> safety clip

1. Input trim. Level into the processor.
2. Dry capture. The trimmed input is copied for the parallel mix.
3. Compressor. A custom design rather than juce::dsp::Compressor. A per-channel high-pass runs on the detection signal only, so kick and low-frequency energy do not over-trigger it. Level detection blends peak and RMS and is stereo-linked. The gain computer uses a quadratic soft knee, and attack and release are smoothed separately on the gain reduction in decibels. The audible low end is left untouched.
4. Oversampled saturation. A drive control feeds a tanh soft saturator running inside juce::dsp::Oversampling at 2x with an FIR half-band filter, so the added harmonics do not alias. Small signals stay at unity gain, and 0 per cent drive is clean.
5. Air shelf. A high-shelf filter (juce::dsp::IIR) at 9 kHz.
6. Parallel mix. A blend of the processed signal with the dry input. The dry path is delayed to match the oversampling latency so the two stay aligned.
7. Output. Output gain followed by an optional safety soft-clip.

An optional auto-makeup stage compensates for the level the compressor removes on the wet path. It adds roughly half the reduction a 0 dBFS signal would see under the current threshold, ratio and knee.

The plugin reports its oversampling latency to the host with setLatencySamples, so a host that compensates for latency keeps it aligned with the rest of the session.

Parameters

Parameter	Range	Default	Notes
Input Trim	-24 to +24 dB	0 dB
Threshold	-60 to 0 dB	-18 dB
Ratio	1 to 20 :1	4 :1
Attack	0.1 to 200 ms	10 ms
Release	5 to 1000 ms	80 ms
Knee	0 to 24 dB	6 dB	soft knee
Det HPF	20 to 500 Hz	90 Hz	detection path only
Drive	0 to 100 %	25 %	oversampled tanh saturation
Air	-6 to +12 dB	+2.5 dB	high shelf at 9 kHz
Mix	0 to 100 % wet	80 % wet	parallel blend
Output	-24 to +24 dB	0 dB
Auto Makeup	on / off	on	compensates the wet path
Safety Clip	on / off	on	soft-clip on the output

Ratio, attack, release and the detector high-pass use skewed ranges, so the musically useful part of each control has more resolution. All parameters use juce::AudioProcessorValueTreeState, are automatable, and are saved and restored with the host session.

Presets

The preset menu is at the bottom-left of the interface. Selecting a preset sets every control and notifies the host. "Random" sets each control to a value within a usable range and can be selected again to re-roll.

Preset	Description
Cheddar Classic	the default state
Sharp Cheddar	brighter and faster, more drive and air
Ham Sandwich	slower, heavier mids, lighter mix
Grilled Cheese	more saturation, longer release
Melty Mozzarella	low ratio, gentle
Swiss	light compression, airy, more dry signal
Club Sandwich	high ratio, fast, output trimmed
Random	randomises every control within range

Presets are defined in source/Presets.h. Add more by appending to the table.

Building

Requirements

• CMake 3.22 or newer and a C++17 compiler.
• macOS: Xcode or the Command Line Tools (xcode-select --install).
• Windows: Visual Studio 2022 with the Desktop C++ workload.
• An internet connection on the first configure. CMake fetches JUCE 8.0.13 with FetchContent, so the Projucer is not needed.

Ninja is optional.

macOS

cmake -S . -B build -G Ninja -DCMAKE_BUILD_TYPE=Release
cmake --build build -j

Windows

cmake -S . -B build -G "Visual Studio 17 2022" -A x64
cmake --build build --config Release

To build a single format, pass its target, for example --target GrilledCheese_VST3 (or GrilledCheese_AU, or GrilledCheese_Standalone).

Output locations

Builds appear under build/GrilledCheese_artefacts/<config>/:

• Standalone/Grilled Cheese.app on macOS, Standalone/Grilled Cheese.exe on Windows
• VST3/Grilled Cheese.vst3
• AU/Grilled Cheese.component on macOS only

COPY_PLUGIN_AFTER_BUILD is on, so the VST3 and AU are also copied to the user plugin folders:

• macOS VST3: ~/Library/Audio/Plug-Ins/VST3/
• macOS AU: ~/Library/Audio/Plug-Ins/Components/
• Windows VST3: %COMMONPROGRAMFILES%\VST3\

Set COPY_PLUGIN_AFTER_BUILD FALSE in CMakeLists.txt to turn that off.

On Apple Silicon the build targets the host architecture (arm64) by default. For a universal binary, configure with -DCMAKE_OSX_ARCHITECTURES="arm64;x86_64".

Loading in a host

Grilled Cheese is an effect, so it belongs on a bus or mixer track rather than an instrument channel. After building on macOS the VST3 and AU are installed for you.

In FL Studio, open Options then Manage plugins, run the plugin scan, and add Grilled Cheese to a mixer insert slot. FL Studio hosts VST3 but not AU, so use the VST3 there. A host keeps a loaded plugin in memory, so after a rebuild, remove and re-add the instance or restart the host to load the new binary.

Validation

With pluginval installed, the plugin can be checked across sample rates and block sizes, including NaN and Inf checks and parameter and thread-safety tests:

/Applications/pluginval.app/Contents/MacOS/pluginval \
  --strictness-level 8 \
  --validate "$HOME/Library/Audio/Plug-Ins/VST3/Grilled Cheese.vst3"

The build passes pluginval at strictness level 8.

Implementation notes

• juce::ScopedNoDenormals wraps processBlock.
• The output stage replaces any non-finite sample with zero, so the plugin cannot emit NaN or Inf regardless of upstream state.
• The compressor, filters and oversampling hold state across blocks and are reset in prepareToPlay.
• Processing is in place and supports mono or stereo, with matching input and output layouts.

Project layout

CMakeLists.txt              JUCE via FetchContent, juce_add_plugin, embedded artwork
resources/
  grilled-cheese-drip.png   UI artwork, embedded with juce_add_binary_data
source/
  Parameters.h              APVTS layout and parameter IDs (defaults live here)
  Presets.h                 presets and the Random roll
  PluginProcessor.{h,cpp}   DSP chain, latency, state
  PluginEditor.{h,cpp}      custom rotary look and feel, GR meter, cheese banner, preset menu
  dsp/
    Compressor.h            detector high-pass and peak/RMS compressor
    Saturation.h            tanh saturator and safety soft-clip

Customising

• Saturation oversampling factor: osFactorLog2 in source/PluginProcessor.h (1 is 2x, 2 is 4x).
• Cheese banner height: cheeseBandH in drawCheese() in source/PluginEditor.cpp.
• Colours and knob styling: the kCheddar, kTang and related colours, and CheeseLookAndFeel, at the top of source/PluginEditor.cpp.
• Presets: source/Presets.h.

Licence

The Grilled Cheese source in this repository is released under the MIT licence. See LICENSE.

This project builds against JUCE, which has its own licence (GPLv3 or a commercial JUCE licence). The MIT licence here covers this repository's source only. Any binary you build and distribute must also comply with the JUCE licence you build under. See https://juce.com/get-juce for the current terms.

The dripping-cheese image in resources/ is part of the user interface. If you fork or redistribute the project, make sure you have the right to use that image, or replace it with one of your own.