SSPACEAGEDOCUMENTATION/
DSP and Instruments

SpaceAge Synth Architecture - Invader-Inspired VA + CSound-Inspired Drum Engines

Updated Aug 27, 2026   |   17.8 KB   |   docs/Synth_Architecture_Invader_CSound.md

SpaceAge Synth Architecture - Invader-Inspired VA + CSound-Inspired Drum Engines

This document captures the next synth direction for SpaceAge by Sample Squad.

The goal is not to clone another product, but to learn from proven workflows and build a synth family that fits SpaceAge: fast, musical, CPU-aware, and useful inside the lane Arranger and Piano Roll.

Reference points:

Current State

The app already has these sound engines:

  • Internal Engine
  • Classic Machines
  • Physical Modeling
  • Redshift
  • Kick Lab
  • Snare Lab
  • Hat Lab
  • Samples, velocity layers, one-shots, and sample/synth blend

Redshift began as the first melodic test engine and still carries some legacy pad-era plumbing, but it is now the core everyday polyphonic synth. For serious Piano Roll and Arranger testing, it needs to keep moving toward a more intentional subtractive-synth architecture.

Product Role

The synth should serve three jobs:

  1. Give the Piano Roll immediate melodic usefulness without VST hosting.
  2. Let the Arranger lanes become musically meaningful: Bass, Harmony, Melody, and user-created lanes.
  3. Give SpaceAge a distinctive sound world: space-age analog, gritty percussion, physical-ish oddities, and quick usable basses/leads/pads.

Architecture Choice

Do not bury the new synth inside the existing drum controls.

Recommended structure:

  • Keep Redshift as the first implementation target.
  • Continue evolving it as the dependable SpaceAge VA voice rather than renaming the engine again.
  • Add a dedicated parameter family for the VA engine instead of reusing too many drum-engine controls.
  • Keep the UI behind the CREATE page so it does not clutter Pads, Sequencers, or Arranger.
  • Continue moving melodic use toward lane-owned Instruments chosen from the Instrument Bay, so Bass/Harmony/Melody lanes can own synth patches independently of pads.

Invader-Inspired Feature Target

The reference synth is attractive because it is direct: knob-per-function, musical defaults, classic subtractive signal flow, and enough modulation to make simple patches feel alive.

Oscillator Section

First pass:

  • Osc 1 waveform: saw, square, pulse, triangle, sine
  • Osc 2 waveform: saw, square, pulse, triangle, sine
  • Osc 2 tune: semitone
  • Osc 2 fine tune: cents
  • Osc 2 level
  • Sub oscillator level
  • Noise level
  • Pulse width
  • Osc mix

Second pass:

  • Sync-ish mode
  • Ring modulation
  • FM amount
  • Phase reset / free-run toggle
  • Drift

Unison And Stereo

First pass:

  • Voice mode: Poly / Mono
  • Glide / portamento
  • Unison voices: Off, 2, 4
  • Detune
  • Stereo spread

CPU caution:

  • Unison multiplies oscillator work. Keep it capped and obvious.
  • Avoid per-pad 8-voice unison across 64 pads as a default.
  • Add a quality/voice cap if users push it hard.

Filter Section

First pass:

  • Filter type: Low-pass, Band-pass, High-pass
  • Cutoff
  • Resonance
  • Drive
  • Key tracking
  • Velocity to cutoff

Second pass:

  • 12 dB / 24 dB slope
  • Dual filter option only if CPU remains calm
  • Character choices such as clean, dirty, rubbery

Envelopes

Minimum:

  • Amp ADSR
  • Filter ADSR
  • Filter envelope amount

Nice-to-have:

  • Velocity to amp
  • Velocity to envelope amount
  • Envelope curve control

LFOs

First pass:

  • LFO 1 rate
  • LFO 1 sync/free toggle
  • LFO 1 waveform
  • LFO 1 depth
  • LFO 1 target: pitch, cutoff, pan, amp, pulse width

Second pass:

  • LFO 2
  • Sample-and-hold
  • Fade-in
  • Per-note retrigger

Effects

Keep these toggleable.

  • Chorus / width
  • Delay send
  • Reverb send
  • Saturation

CPU caution:

  • Reuse global send effects where possible.
  • Per-voice effects should be avoided in first pass.
  • Per-patch chorus is acceptable if lightweight and bypassed when off.

Arp / Sequencer

Do not build this first. The app already has strong sequencer ambitions.

Later:

  • Arp: up, down, up/down, random
  • Rate tied to project tempo
  • Gate length
  • Octave range
  • Simple step-gate pattern

This should integrate with the Piano Roll and Arranger rather than becoming a separate competing workflow.

Suggested Parameter List For First Implementation

Oscillators:

  • Osc 1 Wave
  • Osc 2 Wave
  • Osc 2 Semi
  • Osc 2 Fine
  • Osc 2 Level
  • Sub Level
  • Noise Level
  • Pulse Width
  • Drift

Voice:

  • Mode
  • Glide
  • Unison
  • Detune
  • Stereo Spread

Filter:

  • Type
  • Cutoff
  • Resonance
  • Drive
  • Key Track
  • Velocity Cutoff

Amp:

  • Attack
  • Decay
  • Sustain
  • Release
  • Velocity Amp

Filter Envelope:

  • Attack
  • Decay
  • Sustain
  • Release
  • Amount

LFO:

  • Wave
  • Rate
  • Sync
  • Depth
  • Target

Patch:

  • Output Level
  • Pan
  • Init Patch

UI Strategy

Use tabs or grouped panels inside the existing POLY SYNTH tab:

  • OSC
  • FILTER
  • AMP
  • MOD
  • FX
  • PRESETS

Keep each page readable. The whole synth should not be visible at once.

Immediate presets:

  • 16 basses
  • 16 plucks
  • 16 leads
  • 16 pads
  • 16 keys/stabs
  • 16 weird SpaceAge patches

These should be handcrafted, not random-only.

CPU Strategy

Safe defaults:

  • 8 total melodic voices at first
  • Unison off by default
  • Chorus off by default
  • Oversampling off by default
  • Filter drive lightweight
  • LFO computed per voice only when active

Warn or cap:

  • High unison voice counts
  • Multiple active synth pads playing long releases
  • Heavy per-channel effects stacked with synth voices

CSound-Inspired Drum Synth Direction

The CSound angle should be used as inspiration, not necessarily as an embedded runtime in the first pass.

Why not embed CSound immediately:

  • It adds dependency, packaging, licensing, and preset-state complexity.
  • It may increase CPU and debugging surface.
  • Translating proven synthesis ideas into our JUCE engine keeps the product easier to ship.

What to borrow conceptually:

  • Instrument-as-patch mindset: each drum sound is a small signal graph.
  • Simple oscillators, envelopes, filters, noise, resonators, and waveshapers arranged in musical recipes.
  • Modal/resonant thinking for drums, bells, plates, and metallic percussion.
  • Clear separation between transient, body, resonance, and nonlinear output.

Embedding notes:

  • The requested Csound forum topic points toward using Csound as a C/C++ library. That route is technically plausible, but it should remain a research/prototyping path until SpaceAge's own engine is stable.
  • If we later embed Csound, the likely model is: create an internal Csound instance, compile orchestra/score text or .csd material, process fixed-size control/audio blocks, then bridge audio/MIDI into JUCE.
  • Product risk is not raw possibility; it is state management, crash surface, bundled runtime size, preset serialization, dependency licensing, and user support.
  • Best near-term value: study Csound examples/opcodes, prototype algorithms externally when useful, then translate the musical behavior into original C++ modules.

CSound-Inspired Kick Engine

This should become a dedicated kick module inside Classic Machines or a new DRUM LAB engine.

Signal layers:

  1. Body oscillator

    • Sine or triangle core.
    • Fast exponential pitch drop.
    • Amp envelope with short attack and adjustable decay.

  2. Sub boom

    • Lower sine layer, often less pitch movement.
    • Optional longer decay.
    • Good for sustained orbit-sub kicks.

  3. Click / beater

    • Short impulse or burst of noise.
    • High-pass or band-pass filtered.
    • Adjustable length, tone, and level.

  4. Knock / shell

    • Band-pass resonator around low-mid or mid frequencies.
    • Very short decay.
    • Adds audibility on small speakers.

  5. Air / dirt

    • Short filtered noise or asymmetrical saturation.
    • Optional, toggleable.

  6. Output character

    • Drive before filtering for thickness.
    • Saturation after summing for level and attitude.
    • Soft clip final stage.

First parameter list:

  • Tune
  • Pitch Drop
  • Drop Time
  • Body Decay
  • Sub Level
  • Sub Decay
  • Click Level
  • Click Tone
  • Knock Level
  • Knock Frequency
  • Knock Decay
  • Drive
  • Saturation
  • Output

Second parameter list:

  • Pitch Curve
  • Body Wave
  • Click Type
  • Dirt Type
  • Stereo Width
  • Punch
  • Velocity to Pitch
  • Velocity to Click
  • Velocity to Drive

CPU risk:

  • Low. A kick engine made from a few oscillators, envelopes, simple filters, and waveshaping is cheap.
  • The expensive path would be high-order modal banks or oversampling every kick by default.
  • Keep oversampling optional and per-engine, not always-on.

Unique Drum Synth Opportunities

SpaceAge can stand apart by offering drum synth engines that feel like little laboratories:

  • Kick Lab
  • Snare Lab
  • Hat Lab
  • Metal Lab
  • Noise Lab
  • Impact Lab

Each can use the same mental model:

  • Transient
  • Body
  • Resonance
  • Dirt
  • Motion
  • Output

This is friendlier than exposing raw DSP names and aligns with the app's design goal: simple as possible, not limiting.

Spectral Modeling / Analysis-Resynthesis Direction

Spectral Modeling Synthesis should become a separate research lane rather than being mixed into the first VA or Kick Lab pass.

Core idea:

  • Analyze an imported sound offline.
  • Track prominent partials over time as deterministic sinusoidal components.
  • Model the leftover residual as stochastic/noise energy.
  • Resynthesize from a compact model that can be pitched, stretched, blurred, brightened, or made more percussive.

Why it fits SpaceAge:

  • It supports the "curiosities" identity: imported recordings can become playable spectral objects instead of static samples.
  • It can turn found percussion, short loops, metals, voices, and odd one-shots into new instrument starting points.
  • It gives a future synth engine a unique story without requiring VST hosting.

Recommended product shape:

  • Engine name candidate: SPECTRAL CURIOSITIES.
  • Workflow: choose a sample layer, click ANALYZE, save a spectral model next to the pad/project, then tweak musical controls.
  • First musical controls: Tone, Noise, Transient, Smear, Stretch, Pitch, Formant-ish Shift, Metallic, Randomize Partials, Residual Level.
  • First preset targets: glass, metal, breathy percussion, robotic vocal grains, bowed/struck hybrids, alien shakers, tuned noise bells.

CPU plan:

  • Analysis is offline and can show progress; playback must be bounded and predictable.
  • Cap partial count per voice.
  • Cache analysis files in the project/archive so collaborators do not need to re-analyze.
  • Keep quality modes explicit: Draft, Balanced, High.
  • Avoid real-time spectral analysis per voice unless it is a special offline/render feature.

How this relates to the two upcoming synths:

  • The Invader-inspired VA stays a classic playable subtractive synth: immediate, light, and useful for songs.
  • Kick Lab stays a purpose-built drum module: cheap, punchy, and focused.
  • Spectral Curiosities becomes the experimental third lane: sample analysis, resynthesis, hybrid percussion, and SpaceAge identity.

Implementation Sequence

Phase 1 - Design The VA Parameter Model

  • Add new VA-specific parameter IDs.
  • Preserve existing projects by leaving current shared parameters intact.
  • Add migration defaults for old Redshift/legacy Poly Synth patches.
  • Keep UI behind the current Redshift tab.

Phase 2 - Upgrade The Audio Engine

  • Replace the current simple Redshift voice with a clearer two-oscillator voice path.
  • Add filter and amp envelopes.
  • Add mono/glide.
  • Add unison capped at a safe number.

Phase 3 - Presets

  • Create a factory bank that proves the Piano Roll is useful.
  • Prioritize basses, plucks, leads, pads, stabs, and strange SpaceAge textures.

Phase 4 - Kick Lab

  • Status: first working dedicated engine implemented as Kick Lab.
  • Exposed as a starting-point-driven drum synth, not a scary DSP patchbay.
  • First bank contains 24 kick starting points: tight, huge, short, long, distorted, soft, clicky, subby, knocky, industrial, cinematic, and vintage-console styles.
  • Current parameter surface: sub frequency, pitch drop, drop time, drop curve, sub/body level, body ratio, click amount, click pitch, click length, shell noise, noise decay, noise LPF, drive, punch, saturation, transient, tighten, and body resonance.
  • Current render structure: pitch-envelope oscillator core, sub octave body, harmonic body partial, short click generator, filtered shell noise, comb/body resonance, transient accent, asymmetric saturation, soft clipping, and output safety limiting.
  • Next refinements: pitch-envelope display, quick macros for Soft, Punch, Boom, and Click, mini layer meters, and export-to-sample once the engine is musically stable.

Phase 5 - Snare Lab

  • Status: first working dedicated engine implemented as Snare Lab.
  • Exposed as a starting-point-driven snare designer alongside Kick Lab.
  • First bank contains 18 snare starting points: tight studio, fat backbeat, piccolo, nebula-wire, meteor-rim, satellite-paper, brushy, gated, boom-bap, funk, metal-shell, industrial, marching, trap, rim/noise, and SpaceAge styles.
  • Current parameter surface: shell frequency, snap pitch, snap time, snap curve, shell body, shell ratio, stick amount, stick pitch, stick length, wires, wire decay, wire LPF, drive, punch, saturation, transient, tighten, and rattle.
  • Current render structure: pitch-snapped tuned shell, harmonic shell partial, filtered wire noise, stick transient generator, short rattle/comb path, transient emphasis, asymmetric saturation, soft clipping, and output safety limiting.
  • Next refinements: visual shell/wire envelopes, one-knob Dry, Crack, Body, and Rattle macros, snare-family randomizer, and optional export-to-sample.

Phase 6 - Lane Instruments

  • Status: current architecture direction.
  • Let Arranger lanes own or reference an instrument patch.
  • This prevents melodic composition from depending on a specific drum pad.
  • It also makes external MIDI output and future VST hosting cleaner.

Open Questions

  • Resolved direction: Redshift and other melodic engines should be lane-owned Instruments chosen from the Instrument Bay. Pads can still load instruments for MPC-style playing, but non-drum lanes should not depend on pad slots.
  • Should Kick Lab live under Classic Machines, or become its own engine tab?
  • How many melodic voices should be available before CPU warnings appear?
  • Should unison be per patch or global quality-limited?
  • Should factory melodic presets be saved as Pad Vault items, project presets, or a separate synth-preset format?

Recommendation

Next technical step:

Build the VA parameter model and UI grouping first, then replace the Redshift voice path in a contained way.

Next musical step:

Create 20 strong presets immediately after the first engine pass so testing is musical, not theoretical.

Next drum step:

Build Kick Lab as the first CSound-inspired drum module. It is low CPU, high musical value, and directly supports the product identity.

Physical Bass Guitar Synth

The most promising built-in melodic instrument after the VA synth is a physical bass guitar model. It gives the Piano Roll and Arranger something immediately musical to test, and it supports the "microDAW for actual songs" direction better than another abstract synth.

Recommended model:

  • Core: plucked-string waveguide with a fractional delay line.
  • Excitation: short filtered noise/impulse shaped by velocity and attack style.
  • Pitch: MIDI note to delay length, with optional glide.
  • Loss filter: controls damping and brightness decay over time.
  • Pickup position: comb/phase coloration derived from where the string is "heard."
  • Pluck position: controls harmonic emphasis from where the string is "struck."
  • Body: small bank of low-cost resonators for cabinet/wood/body color.
  • Output: DC blocker, soft saturation, and limiter protection.

Csound reference direction:

  • wgpluck is a good conceptual reference because it is explicitly a plucked-string simulation using interpolating delay lines.
  • Other Csound physical modeling and waveguide examples can guide parameter vocabulary, but the SpaceAge implementation should remain original JUCE/C++ code with bounded CPU cost.

First UI controls:

  • Presets
  • String / Pickup model
  • Attack: Finger, Pick, Thumb
  • Pluck Position
  • Pickup Position
  • Damping
  • Body
  • Growl
  • Velocity Brightness
  • Glide
  • Reverb Send

First preset targets:

  • Round Finger Bass
  • Picked Direct
  • Muted Thump
  • Upright-ish Growl
  • Rubber Bass
  • Short Staccato Bass
  • Dark Dub Bass
  • Bright Funk Pick

CPU plan:

  • Start monophonic with legato/glide.
  • Avoid high voice counts until the model is profiled.
  • Keep body resonators optional or very low count.
  • Reuse the shared aux reverb/delay architecture rather than embedding expensive time effects inside the synth.

Current Redshift Expansion

The current Redshift pass makes the instrument more useful for Arranger and Piano Roll testing without turning it into a CPU-heavy science project.

Added or exposed controls:

  • Velocity Filter, so performance velocity can push the low-pass filter open musically.
  • Drift, using slow free-running pitch motion to make static patches feel less frozen.
  • Body Comb, reusing the shared comb/body coloration path for more instrument-like resonance.
  • Metal Shimmer, a small inharmonic modal partial layer for bells, plucks, struck tones, and space-age color.
  • Existing tempo-synced filter LFO remains available as the first reusable motion block concept.

Implementation note:

These changes are CSound-inspired in vocabulary and intent, especially the modal/inharmonic physical-modeling direction, but the implementation remains original native JUCE/C++ code. That keeps licensing clean and CPU behavior predictable while still letting SpaceAge learn from decades of synthesis practice.