Quality comparison

This page compares the speech quality of Hush's two engines, NVIDIA RE-USE and DeepFilterNet 3, with the official DeepFilterNet 3 binary and RNNoise. All ran on the same 824 noisy recordings. We scored each output against the clean recording. We did not train or tune any model.

Summary#

• Hush now runs DeepFilterNet 3 (the "Efficient" engine and the new default) with the official scores. Its output equals the official deep-filter binary on all 824 files to within 16-bit rounding, and every metric matches to 0.001.
• DeepFilterNet 3 scores higher than Hush Light on every metric. Hush Light is the lightest RE-USE setting. The largest gap is in PESQ: 3.10 against 2.61. The smallest is DNSMOS SIG, where the gap is within the noise of the measurement.
• With 8 layers, RE-USE has the best DNSMOS scores, but DeepFilterNet 3 still has the best PESQ, STOI, ESTOI and SI-SDR.
• Every RE-USE setting scores higher than RNNoise on every metric.
• Hush matches NVIDIA's published scores. At 16 kHz with 8 layers, our scores are within 0.01 PESQ and 0.1 dB SI-SDR of the paper.
• RE-USE uses much more CPU. On this laptop, Hush Light needs 13 to 15 times the CPU time of DeepFilterNet 3, in Hush or in the official binary.

What we tested#

Hush ran in the same way as live audio: 1000-sample chunks, one stream per file. Both DeepFilterNet 3 rows use the same model file; the binary contains it. DeepFilterNet ran as one process per file, because the binary keeps its state between files.

Method#

• Data: VoiceBank-DEMAND test set: 824 files, 34.5 minutes, 2 speakers (p232, p257), 5 noise types, input SNR 2.5, 7.5, 12.5 and 17.5 dB, 48 kHz (Valentini-Botinhao, 2017, CC BY 4.0).
• Input: every system got the same 48 kHz file with 100 ms of silence added at the end. This lets each system output the full utterance. The 16 kHz inputs come from these files.
• Resampling: one resampler for every signal: ffmpeg with soxr, to 32-bit float.
• Scoring rate: all metrics use 16 kHz audio. So they do not see sound above 8 kHz.
• Alignment: we found each system's delay from the cross-correlation peak with the clean file, on 24 files spread over the set. All 24 files gave the same delay for each system. We removed this delay and cut each output to the clean length.
• Metrics: PESQ wide-band (ITU-T P.862.2, pesq 0.0.4, which wraps the ITU C code); STOI and ESTOI (pystoi 0.4.1); SI-SDR (zero-mean, scale-invariant); DNSMOS P.835 SIG, BAK and OVRL (Microsoft's sig_bak_ovr.onnx and the logic of dnsmos_local.py, not personalized, from microsoft/DNS-Challenge, MIT).
• Statistics: the mean over all 824 files, ± the 95% confidence interval (1.96 × std / √n). For the Hush–DeepFilterNet gaps we use paired differences, because the files are the same.

The noisy row matches the published noisy scores (PESQ 1.97, STOI 0.921, ESTOI 0.79, SI-SDR 8.4 dB). This confirms the scoring chain.

Results#

Mean ± 95% confidence interval. Bold: best processed system in the column. Higher is better.

Paired difference, Hush minus the official DeepFilterNet 3 binary (negative: the binary is better):

PESQ-WB by input SNR:

Published results#

These numbers come from the papers. We did not measure them, and they use other code and model versions. "–" means not reported.

Notes on these numbers:

• The RE-USE paper does not say which PESQ it uses or at which rate. Its noisy row and its DeepFilterNet3 row are equal to the 16 kHz wide-band numbers of Welker et al.
• The RE-USE paper reports only 8 layers on this test set. It does not report 3 layers.
• NVIDIA's model card says that the released checkpoint differs from the one in the paper. Hush uses the released checkpoint.
• The DeepFilterNet 3 paper does not say which PESQ it uses.

Observations#

• Hush's DeepFilterNet 3 engine is the official model, unchanged. Its 48 kHz output equals the deep-filter output on every file to within one step of 16-bit rounding (the binary writes 16-bit files; Hush writes float). The binary keeps a 30 ms delay in its files; Hush removes it. The metrics differ by at most 0.001 on average.
• Hush reproduces NVIDIA's paper. With 8 layers at 16 kHz we measured PESQ 2.77, ESTOI 0.859 and SI-SDR 18.5 dB. The paper reports 2.76, 0.86 and 18.6 dB.
• We could not reproduce the DeepFilterNet3 row in the RE-USE paper. We measured PESQ 3.10 with the official binary at 48 kHz. Its own paper reports 3.17. The RE-USE paper uses 2.71 from Welker et al. With our numbers, DeepFilterNet 3 is ahead of RE-USE with 8 layers on PESQ, STOI, ESTOI and SI-SDR. We do not know why the two DeepFilterNet3 results differ.
• RE-USE wins on DNSMOS only with 8 layers. DNSMOS estimates a listener's opinion without the clean file. With 8 layers, RE-USE is ahead of DeepFilterNet 3 by 0.055 OVRL. With 3 layers (Light), it is behind by 0.022 OVRL. The SIG difference is less than 0.01.
• DeepFilterNet 3 keeps its lead at every input SNR. The PESQ gap to Hush Light is 0.34 at 2.5 dB and 0.57 at 17.5 dB.
• Studio does not score higher than Light on most metrics. Studio has higher PESQ (+0.08) but lower SI-SDR (−1.0 dB) and DNSMOS. The metrics use 16 kHz audio, so they cannot show what Studio adds above 8 kHz.
• RNNoise improves the least. It removes some noise (DNSMOS BAK 3.13 → 3.85), but its STOI and ESTOI are slightly below the noisy input.
• Delay: see the table below. At look-ahead 0, RE-USE and DeepFilterNet 3 have the same algorithmic latency: 40 ms. The Hush app adds 20 ms of output prefill to both, so each engine adds about 60 ms. DeepFilterNet 3 has the higher quality at this latency on this test set.

For DeepFilterNet 3, the measured 30 ms plus one 10 ms frame gives the published 40 ms. RNNoise is not a 10 ms system: the 10 ms is its frame step and the look-ahead given on the 2017 demo page. The tested library also applies each frame's gains to the previous frame (delayed_X in src/denoise.c), so its file delay is 20 ms.

Caveats#

• One dataset. VoiceBank-DEMAND has two speakers, five noise types and synthetic mixtures without reverberation. Real microphones are harder. Do not generalize these numbers.
• The test speech is in the training data of two models. The clean test files are VCTK recordings: the VCTK 0.92 file p232_001_mic1 matches the clean test file p232_001 with a correlation of 0.999998. NVIDIA's model card lists VCTK (about 80 hours) in the RE-USE training data. DeepFilterNet 3 trains on DNS4 and repeats VCTK 10 times (paper). The DNS4 paper lists 110 VCTK talkers in its English clean speech and noise clips from DEMAND. So this test set is close to the training domain of DeepFilterNet 3 for both speech and noise. The RE-USE model card does not list DEMAND. The RNNoise training list (datasets.txt) does not list VCTK.
• RE-USE ran in its low-latency streaming setting: look-ahead 0, and 3 layers for Light and Studio. More layers and look-ahead give higher scores and cost more CPU or delay.
• Objective metrics only. We did no listening test. PESQ, STOI and SI-SDR compare the waveform with the clean file. DNSMOS is a neural estimate of a listener's score.
• 48 kHz output was scored at 16 kHz. The metrics ignore the 8–24 kHz band.
• DeepFilterNet's binary writes 16-bit output. Hush and RNNoise outputs are 32-bit float.

CPU cost (approximate)#

One process at a time on a 30 s clip (the first test files joined), median of 3 runs. The laptop (8-core x64, 16 logical CPUs) ran other work at the same time, so treat these numbers as rough. "Time" is processing time divided by audio time; below 1.0 is faster than real time. The CPU column is CPU time divided by audio time.

This run (2026-11-03, with the DeepFilterNet 3 engine) had more background load than the first one. The first run measured 0.79 CPU for Hush Light on 1 thread and 0.059 for deep-filter: Hush Light needed 13 to 15 times the CPU of DeepFilterNet 3 in both runs.

Hush threads are set with RAYON_NUM_THREADS; DeepFilterNet 3 always uses one. The deep-filter CPU time includes model loading; Hush's excludes it. The RNNoise time includes one Python call per 10 ms frame. Performance has the frame times and the live CPU use.

Reproduce#

Windows x64, from the repository root. You need Rust, Python 3.13 and ffmpeg built with libsoxr. Use a work folder outside the repository: it receives about 3 GB of audio.

WORK=/c/temp/hush-compare
python -m venv $WORK/venv
$WORK/venv/Scripts/python -m pip install -r benchmarks/compare/requirements.txt
cargo build --release -p hush-core --example enhance_dir
$WORK/venv/Scripts/python -I benchmarks/compare/compare.py --work $WORK --jobs 8 all

compare.py downloads the data, the deep-filter binary, the DeepFilterNet 3 model and the DNSMOS model, and checks their SHA-256. Then it runs every system, scores every file and writes results.json. Each step is also a sub-command (download, prepare, process, score, timing, report). The full run took about 2.5 hours on this laptop. The deep-filter binary and the RNNoise wheel in the script are the Windows builds.