Audio DSP experimentation often gets bogged down in software overhead. Testing a new filter topology, validating a measurement method, or inspecting a frequency curve typically means writing one-off scripts, managing plot windows, and maintaining throwaway scaffolding around the underlying math.
SDA (Software-Defined Audio) is a visual DSP workbench built in Rust designed to remove that friction. Instead of writing procedural glue code for every experiment, processing operations connect on a canvas to form an inspectable, real-time audio pipeline.
Inspired by GNU Radio, Focused on Audio
One of the primary inspirations for SDA is GNU Radio, which demonstrated the power of block-based flowgraphs for complex signal processing. Connecting autonomous processing blocks provides an intuitive, inspectable model for how data moves through a processing system.
However, the goal is not to reproduce GNU Radio. While GNU Radio grew around RF and communications, audio signal processing introduces its own distinct demands: acoustics, sample-rate precision, multi-channel routing, loudspeaker and microphone characterization, and low-latency interactive workflows.
SDA adapts this visual paradigm specifically for audio engineering — rapid filter prototyping, spectral diagnostics, acoustic measurement, and live visualization — without needing to build a dedicated test harness around every algorithm.
Treating processing operations as reusable blocks shifts the focus from managing script boilerplate to shaping the signal path.
How SDA Works
At the center sits a node-based graph environment. Discrete signal processing operations are represented as nodes, while ports govern the directional movement of signal data.
The visual graph maps directly into an executable processing pipeline. Nodes can be connected, parameters adjusted, and intermediate responses visualized live, keeping the signal flow inspectable from excitation to plot.
In Practice: Workflow Examples
The workbench handles everything from basic filter sweeps to multi-stage acoustic characterization pipelines.
Filter Characterization
Evaluating filter responses in real time: a logarithmic frequency sweep drives an adjustable IIR biquad stage, routing directly to an FFT and decibel converter for live magnitude plotting.
Acoustic Impulse Response Estimation
Implementing the Farina swept-sine technique for acoustic measurement. Recorded sweeps are aligned with reference excitation, followed by frequency-domain spectral deconvolution and inverse transformation to extract the system's time-domain impulse response.
Why Rust?
Audio DSP is computationally intensive and latency-sensitive. Numerical accuracy, buffer management, and thread safety are non-negotiable.
Rust provides the right foundation for this type of software: high numerical performance and deterministic memory safety without garbage collection pauses, paired with strong compile-time guarantees across signal boundaries and concurrency threads.
Future Work: Compiling to Hardware
While SDA currently serves as an interactive desktop workbench, the long-term vision extends beyond the workstation. A primary design priority is decoupling signal definitions from the desktop interface to support a dedicated hardware compilation flow.
Future work will bridge interactive design with embedded deployment:
- Design on Desktop: Interactively construct, simulate, and verify DSP graphs on a desktop workstation.
- Compile for Target: Lower the verified graph into an optimized, static execution schedule tailored for target microcontrollers.
- Headless Execution: Run the compiled pipeline directly on embedded hardware (such as an MCU or dedicated DSP) with deterministic latency — completely free from the graphical editor.
The goal: develop a DSP graph on your desktop, and execute it on hardware (e.g. an MCU) without the graphical editor.
Looking Ahead
SDA continues to develop around practical audio engineering workflows: expanded acoustic analysis routines, low-latency device integration, and embedded hardware targets.
The objective is straightforward: a modern environment where audio DSP algorithms can be visually composed, thoroughly inspected, and deployed with confidence.