Building the audio
ecosystem in Rust

Open-source Rust libraries for real-time audio processing. Zero-cost abstractions, zero allocations on the audio thread.

$ cargo add fft-convolver audio-blocks audio-file

Projects

audio-lab

Offline audio research toolkit — generate test signals, run DSP experiments, and visualize results.

offlineresearchplotting
main.rs 
use audio_lab::{signal, plot};

// Generate a logarithmic sweep and pink noise
let sweep = signal::generate_sweep(
    48_000,
    20.0..20_000.0,
    &signal::SweepConfig::default(),
)?;
let noise = signal::generate_noise(48_000, &signal::NoiseConfig {
    spectrum: signal::Spectrum::Pink,
    amplitude: 0.2,
    ..Default::default()
})?;

// Mix, inspect, save, and play back
let mixed = audio_lab::mix_time!(sweep, noise)?;
plot::show_freq("spectrum", &mixed.into_freq(), Default::default())?;
npy::write_npy_time(&mixed, "test.npy")?;
playback::play(&mixed)?;
github

audio-blocks

Real-time safe abstractions over audio data with support for all common layouts.

real-time safeno-stdf32/f64
main.rs 
use audio_blocks::*;

// Create a stereo block with 512 samples per channel
let mut block = Planar::<f32>::new(2, 512);

// Process each channel independently
for channel in block.channels_mut() {
    for sample in channel.iter_mut() {
        *sample *= 0.5; // apply gain
    }
}
github crates.io docs.rs

audio-file

Read any audio format and write WAV files with a simple, ergonomic API.

16+ formatssymphoniaresampling
main.rs 
use audio_file::read;

// Read any audio format — MP3, FLAC, WAV, OGG, AAC...
let audio = audio_file::read::<f32>(
    "recording.mp3",
    Default::default(),
)?;

println!("Sample rate: {}", audio.sample_rate);
println!("Channels: {}", audio.num_channels);
println!("Samples: {}", audio.samples_interleaved.len());
github crates.io docs.rs

audio-host

Backend-agnostic library for audio I/O devices — one API for JUCE, CPAL, and RtAudio.

multi-backendreal-timecallback API
main.rs 
use audio_host::*;

let host = AudioHost::new()?;

host.start(
    Config {
        num_input_channels: 2,
        num_output_channels: 2,
        sample_rate: 48000,
        num_frames: 512,
    },
    // Real-time audio callback
    move |input, mut output| {
        output.copy_from_block(&input);
    },
)?;
github

web-audio

Web Audio API bindings for Rust — microphone input, device enumeration, and audio I/O in the browser.

wasmwebasync
main.rs 
use web_audio::WebAudio;

// Request microphone permission
WebAudio::request_permission().await?;

// Enumerate available devices
let (inputs, outputs) = WebAudio::enumerate_devices().await?;

// Create audio context and configure devices
let mut audio = WebAudio::new().await?;
audio.set_input_device(Some(inputs[0].device_id.clone()));
audio.set_output_device(Some(outputs[0].device_id.clone())).await?;

// Start processing — interleaved f32: [L0, R0, L1, R1, ...]
audio.start(1024, 2, |input, output| {
    output.copy_from_slice(input);
}).await?;

audio.stop()?;
github

fft-convolver

Fast, real-time safe FFT convolution — zero allocations during audio processing.

real-time safezero-allocf32/f64partitioned FFT
main.rs 
use fft_convolver::FFTConvolver;

// Load an impulse response (e.g. a room reverb)
let impulse_response: Vec<f32> = load_ir("hall.wav");

let mut convolver = FFTConvolver::default();
convolver.init(512, &impulse_response)?;

// Process audio — real-time safe, no allocations
let mut output = vec![0.0f32; input.len()];
convolver.process(&input, &mut output)?;
github crates.io docs.rs

About

neodsp is created by Stephan Eckes, an audio researcher and Rust enthusiast based in Berlin. With a mission to modernize the audio industry, neodsp is building complete, production-ready audio frameworks entirely in Rust, replacing fragmented C++ toolchains with safe, fast, and ergonomic alternatives.

steck.tech @steckes