← Back to Portfolio LuvNote →

⚡ Lazor

JUCE / C++ • Octave-Stacked Allpass Dispersion (VST3/AU)

Quick Navigation

✨ Feature Demonstrations

A Rack of Up to 16 Dispersion Units

Dispersion delays different frequencies by different amounts, turning transients into "laser" zaps, chirps and smeared sweeps, which is popular in bass and sound design. Lazor stacks up to 16 dispersion units in series. One master frequency drives them all, with each unit a fixed interval above the previous one (an octave by default), so a single knob sweeps the whole stack.
C++ Allpass Filters Group Delay SIMD (SSE2 / NEON)

Controls per Unit

  1. Amount: 0 to 32 whole allpass stages
  2. Frequency: 20 Hz to 20 kHz (20 × 1000x for knob position x), set by the master and the spacing
  3. Pinch: Q from 0.5 to 16 (0.5 + 15.5 × x4)
  4. Each unit can be switched on or off, and units above the highest usable frequency fade out
  5. Count and Spacing set how many units run and how far apart they sit
Each unit is up to 32 identical second-order allpass stages. Every stage is a topology-preserving (TPT) state-variable filter whose output is input − 2k × bandpass. The left and right channels are processed together as one pair of doubles in a single SSE2 or NEON register where available.

Measured to Match a Reference to Float Precision

Each unit was reverse-engineered to behave exactly like Kilohearts Disperser, a widely used dispersion plugin, down to the knob mappings, the way stage-count changes crossfade and the way knob moves glide inside a host block. A null test against the original confirms it.
Reverse Engineering Null Testing Plugin Hosting Measurement Tooling

How It Was Measured

  1. A development tool, DisperserProbe, hosts the installed reference plugin and measures its response
  2. The knob laws for Amount, Frequency and Pinch were derived from those measurements
  3. Stage-count changes crossfade from the old tap to the new one over the first chunk of the host block, matching the reference
  4. Reference tests null Lazor against real instances under random automation and odd block sizes
  5. One unit nulls at about −110 dB; a four-unit octave rack at about −87 dB, limited by the reference's single precision near 19 kHz
The reference tests are skipped automatically on machines where the reference plugin isn't installed, so the regular unit tests still run on every macOS CI build.

Smooth vs. Classic Sweeps

How knob moves glide matters for a filter this resonant. Lazor offers two Sweep modes: Smooth, which sounds the same at any DAW buffer size, and Classic, which reproduces the reference plugin's behavior exactly.
Parameter Smoothing Block Chunking Coefficient Interpolation

Sweep Modes

  1. Smooth (default): knob moves glide over a fixed 10 ms, with coefficients updated on a 16-sample grid that runs across blocks, so the result doesn't depend on the buffer size
  2. Classic: each host block is split into ceil(n / 64) equal chunks, and knob values glide linearly across the block, read at each chunk's end
  3. Stage counts and unit on/off changes are applied at block starts in both modes
A small Glider type supports both schemes, starting a move across the whole host block (Classic) or retargeting over a fixed number of samples (Smooth), so the engine reads every control the same way in either mode.

Linked, Relative & Per-Unit Control

Amount and Pinch can be set once for the whole rack, trimmed relative to a master value, or set unit by unit. Switching between those modes keeps the sound where it is.
JUCE APVTS Custom Components State Preservation

Link Modes

  1. Linked: one master value drives every unit; unit controls show it dimmed
  2. Relative: each unit keeps its own value and the master trims them all, with the result shown as a ghost
  3. Individual: each unit is edited on its own, and the master knob reads "PER UNIT"
  4. Going from Linked to per-unit copies the master value into every unit; going from Relative to per-unit bakes the trim in
Mode changes made with the LINK and REL buttons carry the values over, while host automation of the mode simply switches it. That way, clicking never causes a jump in the sound, and automation stays predictable.

Keytrack, LFO & Envelope Modulation

Three modulation sources move every unit's frequency together, in octaves, so the spacing between units is kept. Playing MIDI notes lets Lazor follow the melody, which turns it into a pitched instrument for bass and leads.
MIDI Keytracking Tempo-Synced LFO Envelope Follower

Sources

  1. Keytrack: the last held MIDI note relative to C4, scaled by the Keytrack amount, with Glide; the last note is held after release
  2. LFO: seven shapes, free running or synced to the host tempo (locked to the song position while playing), optionally restarted by each note
  3. Envelope: the input level from a peak follower, scaled by Depth
  4. The sum is smoothed over 1 ms so square and sample-and-hold steps don't click
Modulation time is an absolute sample count, and the engine can ask for values up to a chunk past the end of the current block, which lets the Classic sweep scheme read modulation at chunk ends exactly.

Group Delay Display, Testing & Release

The main display plots the whole chain's group delay against frequency: the total, each unit's own curve faintly, and numbered unit markers. Drag it to move the frequency, scroll to change the spacing. Underneath, a test suite covers correctness, stress, CPU and memory.
Analytic Group Delay Stress Testing HMAC Serials GitHub Actions

Quality Gates

  1. Stress tests randomize every parameter every block, with random block sizes, sample rates from 44.1 to 192 kHz, and MIDI
  2. Benchmarks: the default rack (4 units × 16 stages) uses about 1.3% of one core; the worst case (16 × 32, stereo) about 6% at 48 kHz
  3. Memory tests check each instance (about 0.4 MB) and each editor, and that closed editors give memory back
  4. A headless snapshot tool renders any UI state to PNG
  5. Offline HMAC-SHA256 serials, the same scheme as DyHamic
Group delay is computed analytically from each stage's transfer function (the bilinear transform of the analog allpass, prewarped at its centre), so the display is exact rather than estimated from audio.

📋 Professional Summary

Octave-Stacked Dispersion — JUCE 8 / C++ / VST3 / AU Lazor is LuvNote's dispersion plugin: a rack of up to 16 allpass dispersion units in series, all driven by one master frequency and spaced at a fixed interval, for laser zaps, chirps and pitched sweeps. It runs as VST3 on Windows and as VST3 and AU on macOS, alongside SingleGrain, DyHamic and DisWhoreTion.

Each unit was measured against Kilohearts Disperser with a purpose-built probe tool and reimplemented to match it to float precision, verified by null tests at about −110 dB under random automation. A second Sweep mode makes the sound independent of the DAW's buffer size, and Linked, Relative and per-unit control modes switch without moving the sound.

The engine processes stereo as SIMD pairs of doubles and is covered by unit, reference, stress, CPU and memory tests. MIDI keytracking, a tempo-synced LFO and an envelope follower move the whole rack, and an analytic group delay display makes the effect visible. Release runs through the same CI, signing and HMAC licensing pipeline as the other LuvNote plugins.

🎯 Most Marketable Skills

Filter DSP

  • TPT state-variable allpass design
  • Analytic group delay computation
  • Bilinear transform with prewarping
  • Crossfaded stage-count changes
  • Click-free coefficient gliding

Measurement & Verification

  • Reverse-engineering a reference plugin
  • Hosting plugins for measurement
  • Null testing under random automation
  • Stress tests across 44.1–192 kHz
  • CPU and memory benchmarks

Performance C++

  • SSE2 / NEON stereo processing
  • Double-precision signal path
  • Buffer-size-independent smoothing
  • Per-block parameter snapshots
  • About 1.3% CPU for the default rack

Plugin UX

  • Interactive group delay display
  • Linked / Relative / per-unit controls
  • MIDI keytracking with glide
  • Tempo-synced LFO and envelope
  • Presets and A/B comparison

🏗️ Architecture

DSP Engine

  • Engine (16 units in series)
  • AllpassCascade (32 stages)
  • DisperserMath (control laws)
  • Glider (Smooth / Classic)
  • Stereo SIMD pairs

Modulation

  • Keytrack with glide
  • LFO (7 shapes, tempo sync)
  • Envelope follower
  • 1 ms output smoothing
  • Absolute sample clock

Interface

  • GroupDelayView
  • UnitStrip (per unit)
  • MasterPanel (LINK / REL)
  • ModPanel
  • PresetBrowser

State

  • APVTS parameters
  • EngineParams block snapshot
  • AbStates (A/B)
  • PresetManager / factory presets
  • Settings and licence file

Tooling & Release

  • DisperserProbe
  • Reference / stress / bench tests
  • Headless snapshot tool
  • CMake + Projucer builds
  • Signed installers, HMAC serials

🏆 Key Achievements

🎯

Float-Precision Match

Matched a widely used reference plugin so closely that one unit nulls against it at about −110 dB under random automation and odd block sizes.

🔬

Custom Measurement Tool

Built DisperserProbe, a host for the reference plugin, to derive its knob laws, crossfades and glide behavior from measurements.

📚

Octave-Stacked Rack

Up to 16 units at a fixed spacing from one master frequency, with Linked, Relative and per-unit control that switches without a jump.

🎚️

Buffer-Independent Sweeps

A Smooth sweep mode on a fixed 16-sample grid gives the same sound at every DAW buffer size, alongside a bit-faithful Classic mode.

⚡

Efficient by Design

SIMD stereo processing keeps the default rack at about 1.3% of one core, and even 512 allpass stages at about 6% at 48 kHz.

🧪

Stress-Tested

Every parameter randomized every block at random block sizes and sample rates up to 192 kHz, plus memory checks per instance and editor.

⚙️ Full Tech Stack

C++ JUCE 8.0.12 VST3 Audio Units (AU) Allpass Dispersion TPT State-Variable Filters Group Delay Analysis SSE2 / NEON SIMD MIDI Keytracking Tempo-Synced LFO Null Testing JUCE APVTS HMAC-SHA256 Licensing CMake Visual Studio 2022 GitHub Actions Apple Notarization Inno Setup pluginval
← Back to Portfolio