Cathar

Name: cathar is from Greek katharós (καθαρός), "pure, clean" — the same root as catharsis (κάθαρσις), a cleansing. That's the whole job: take a noisy recording and give back clean audio.

Cathar is a transparent, dependency-free audio restoration toolkit — in pure Rust. It works on a standalone audio file (WAV, MP3, FLAC, OGG, M4A) just as readily as the audio track inside a video (MP4, MKV); video is never required. Every stage is inspectable, tunable DSP — no opaque neural models, no black boxes, so a result you don't like is a knob you can turn rather than a model you have to re-roll. Cathar does three things and writes WAV, FLAC, or AIFF (chosen by the output extension):

• Restore — denoise (phase-coherent stereo), de-hum, de-wind, de-click, de-clip, de-reverb, spectral repair, de-plosive, de-rustle.
• Enhance — de-ess, breath removal, voice isolation, bandwidth extension.
• Level — loudness (LUFS) and peak normalisation for delivery.

No ffmpeg, no C/C++, no system libraries. Decoding is symphonia, the FFT is realfft/rustfft, WAV writing is hound and FLAC is flacenc — all pure Rust, so a single cargo build gives you a self-contained binary. Every effect is also a plain function over &[f32], so the same pipeline drops straight into a Rust program or a larger media-processing pipeline.

Quick start

cargo install cathar-cli                     # from crates.io — installs the `cathar` binary

Or from a checkout:

cargo install --path crates/cathar-cli       # install the binary from source
just setup        # one-time: enable the auto-format pre-commit hook
just build        # build the workspace
just test         # run all tests

# A noisy interview straight off a camera → clean dialogue:
cathar denoise interview.mp4 --out clean.wav

# Learn the room tone from a silent segment, then denoise with it:
cathar noiseprint room_tone.wav --out room.np.json
cathar denoise interview.mp4 --noiseprint room.np.json --out clean.wav

# A restoration chain, one stage at a time:
cathar dehum     recording.wav --freq 60        # kill 60 Hz mains buzz
cathar declick   recording.wav                  # interpolate impulse clicks
cathar declip    recording.wav                  # rebuild clipped peaks
cathar normalize recording.wav --target -16     # to -16 LUFS (podcast)

# Generate a synthetic noisy tone to experiment with:
cathar wave --out test.wav --duration 3 --freq 440 --noise 0.15

The toolkit

Every command reads any supported format and writes WAV (32-bit float), FLAC (24-bit lossless), or AIFF (24-bit) — the container follows the --out extension (.wav / .flac / .aif/.aiff, defaulting to WAV). They are grouped here by what they fix; run them in any order, or chain them.

Reduce — pull noise out of the signal

Repair — reconstruct damaged samples

Enhance & level

Utility

--target for normalize is roughly: -23 broadcast (EBU R128), -16 podcast, -14 streaming.

How denoising works

Cathar decodes to interleaved f32 PCM, then most reduction stages run as an STFT (short-time Fourier transform) → modify the spectrum → inverse STFT loop. The denoiser uses a 2048-point FFT with a 512-sample hop (75 % overlap) and a Hann window on both analysis and synthesis, reconstructed by overlap-add:

Two denoiser flavours share that frame loop:

• Spectral subtraction (default) — estimate the noise magnitude per bin and subtract α × it, held above a spectral floor β·mag so you trade artifacts ("musical noise") against aggressiveness. α from 1→6 goes gentle→aggressive.
• Wiener filter (--wiener) — apply the statistically optimal per-bin gain gain = S / (S + N) from the estimated signal and noise power; smoother on stationary noise.

The noise spectrum comes either from minimum-statistics (the quietest ~15 % of frames are taken as noise) or, for a cleaner result, from a noiseprint learned off a dedicated silent segment.

Inside each tool

Every stage is classic, inspectable DSP — no black boxes.

Library usage

The cathar crate is the same engine the CLI drives.

use cathar::{AudioData, Denoiser, SpectralDenoiser, dehum};

let audio = AudioData::from_file("interview.mp4")?;   // symphonia decode → f32
let sr = audio.sample_rate;

// Denoise and de-hum per channel via `map_channels`, then normalise to
// -16 LUFS (EBU R128) with a -1 dBTP true-peak ceiling. Loudness is measured
// across all channels jointly, so normalisation is a whole-signal method.
let clean = SpectralDenoiser::default()
    .denoise(&audio)?
    .map_channels(|ch| dehum(ch, sr, 60.0, 5))
    .normalize_r128(-16.0, -1.0);

clean.to_file("clean.wav")?;   // 32-bit float WAV via hound

Learn a noise print once and reuse it for a tighter subtraction:

use cathar::{AudioData, Denoiser, SpectralDenoiser, learn_noise_print};

let print = learn_noise_print(&AudioData::from_file("room_tone.wav")?)?;

let audio = AudioData::from_file("interview.mp4")?;
let clean = SpectralDenoiser::with_noise_print(print, /* alpha */ 3.0, /* beta */ 0.01)
    .denoise(&audio)?;
clean.to_file("clean.wav")?;

The public surface is small and direct:

• AudioData { sample_rate, channels: Vec<Vec<f32>> } — from_file, to_file, map_channels(|&[f32]| -> Vec<f32>) for per-channel effects, normalize_r128(target_lufs, true_peak_ceiling_db) for whole-signal loudness, and resample(target_rate) for the main-path resampler.
• Denoiser trait + SpectralDenoiser (configurable fft_size, hop_size, alpha, beta, noise_frame_ratio, optional noise_print); denoise and denoise_coherent (phase-coherent stereo).
• NoisePrint + learn_noise_print + wiener_denoise.
• Free functions: dehum, dewind, declick, declip, spectral_repair, deplosive, derustle, dereverb, voice_isolate, deesser, deess_multiband, breath_remove, bandwidth_extend, resample, normalize_peak, integrated_loudness, true_peak_dbtp, generate_wave.

Formats & I/O

Architecture

A deliberately small two-crate workspace — a library and the binary that drives it.

cathar/
├─ crates/
│  ├─ cathar/        # the engine: decode (symphonia) · DSP · encode (hound)
│  └─ cathar-cli/    # the `cathar` binary — clap subcommands over the engine
└─ docs/             # banner + assets

Design

Pipeline integration

Because the whole toolbox is a library of &[f32] functions plus a single static binary with no system dependencies, cathar slots cleanly into a larger media pipeline: call it in-process through the cathar crate, or shell out to cathar <stage> … between other steps. Inputs are read straight from the container files, so it can sit immediately after ingest and before encoding.

Roadmap

Cathar is 0.4.x, restoration-first, and growing — before 1.0 — into a general-purpose, pure-Rust audio swiss-army knife (a SoX-class tool with no ffmpeg and no C/C++ FFI). See ROADMAP.md for the full plan and SoX-parity checklist. The 0.2–0.4 foundations are complete:

• True EBU R128 loudness (normalize) — K-weighted gated LUFS with a --true-peak dBTP ceiling.
• Main-path resampling — the resample command + AudioData::resample, a shared anti-aliased Kaiser-windowed sinc any stage can call.
• Encode beyond WAV — 24-bit lossless FLAC and 24-bit AIFF on the pure-Rust default path, selected by the output extension.

Next up is restoration depth (Phase 1 0.5) and the swiss-army expansion (Phase 2) — see ROADMAP.md.

The optional ml feature wires in candle for a learned denoiser (0.6); the neural model itself is not implemented yet.

Development

just check-all runs fmt-check, clippy (-D warnings), tests, and docs — the same gate CI enforces on Linux and macOS.

License

Licensed under either of Apache License, Version 2.0 or MIT license at your option.