Most of the noise in a voice message is not under the voice. It is the hiss, the hum and the room tone between the words, and a gate can take that down without touching the speech. We built a three-band noise gate for a push-to-talk web app, kept it small and cheap, and gave it a streaming mode so it can run live. We are releasing it: audioblur.js, MIT licensed, on GitHub. Try it live with your own audio, offline or through a real AudioWorklet.

It is a gate, not a neural network. It quiets noise in the gaps between words and in bands without speech. It cannot remove noise that sits under the speech (a fan while you talk, keyboard clatter over a word) the way RNNoise can. We offer it as an alternative to RNNoise for when a small, cheap gate is enough, and not as a replacement for it.

Gate or RNNoise?

RNNoise is a hybrid of classic DSP and a small recurrent neural network, trained on speech, and it does clean noise that sits under a voice. audioblur does less, much more cheaply. We measured both on the same machine, with the same input, in interleaved runs: the Jitsi WebAssembly build of RNNoise (@jitsi/rnnoise-wasm 0.2.1, emscripten -Os, no SIMD) took about 80 ms of CPU per second of 48 kHz audio; audioblur took about 5 to 6 ms. That is about 15 times less. A SIMD or native RNNoise would be faster than the build we timed, and we did not measure one.

audioblur.jsRNNoise (WebAssembly)
Noise under speechnot reduced (the gate is open while you talk)reduced
Noise in the gapsup to reduction dB (default 16)reduced
CPU, 48 kHz, one thread6.5 ms per second of audio (0.65% of one core); 3.8 to 7.7 across runsabout 80 ms per second (58 to 81 across runs)
Sample rates3 to 384 kHz accepted, tested 8 to 96 kHz48 kHz only
Delay17 ms by default, 5 ms with no lookahead10 ms
Setupone 29 KB file (9 KB gzipped), no wasm, no modelwasm binary plus glue code
Tuningreduction, release, attack, sensitivity, ratio, lookahead, bandsnone

Reach for audioblur when the noise is mostly in the pauses (voice messages, push-to-talk, intercoms, call recordings), when CPU or battery is tight, or when you mix many streams on a server. Reach for RNNoise when the noise is there while people talk.

Is there already one?

We looked on npm, GitHub and the web in October 2026 for a small, dependency-free JavaScript multiband gate or expander with a streaming AudioWorklet mode and did not find one; the closest was a single-band Web Audio preset on npm. “We did not find one” describes our search, not a guarantee.

Using it

<script src="audioblur.js"></script>
<script>
  // a whole clip: exact percentiles of the clip's own noise floor and speech level
  const cleaned = audioblur.process(float32Samples, sampleRate, { reduction: 16 });

  // live, in an AudioWorklet (needs https or localhost)
  const gate = await audioblur.createNode(audioContext, { reduction: 16, release: 50 });
  mic.connect(gate).connect(audioContext.destination);
  gate.set({ reduction: 24 });          // change options while it runs

  // live, in your own loop (a Worker, Node, a native bridge)
  const stream = audioblur.createStream(48000, {});
  stream.process(inputBlock, outputBlock);   // output is delayed by stream.latencySamples
</script>

reduction is the main knob: the deepest cut applied to anything below the threshold. release and attack set how fast the gain closes and opens, sensitivity where the gate starts to close, ratio how steeply, lookahead how far ahead of the audio the detector looks, and crossovers where the bands split. Offline and streaming take the same options, every option is checked, and a typo throws.

Four charts: reduction against gap attenuation, release against time to close, attack against word-onset loss, sensitivity against gap attenuation and speech level
Figure 1. The main options, measured on a seeded synthetic recording. Reduction is a ceiling; long attacks clip word starts.

How it works

The signal is split into bands with Linkwitz-Riley crossovers (500 Hz and 3 kHz by default), allpass-compensated so the bands sum back to exactly the input's magnitude. Each band measures its level in 20 ms windows and a tracker estimates its noise floor (the 10th percentile of its levels) and its speech level (the 95th). Below a threshold just above the floor the band is turned down at 4:1, never by more than reduction. The gain opens fast, closes slowly and looks ahead, and a band with no clear gap between speech and floor follows the band below it.

Signal flow: split into bands, then per band level, tracker, gain, smoothing and apply, summed to the output, with adaptive depth capping the gain
Figure 2. One lane per band. Adaptive depth caps the cut when the best band's speech-over-noise gap is small.
Level of a noisy recording before and after the gate, and the gain in each band
Figure 3. Default settings on a 30 dB SNR test recording: the gaps drop 12.3 dB, the speech changes by 0.00 dB. With adaptive depth off the cut is the full 16.0 dB.
Spectrograms of the same 12 seconds before and after the gate
Figure 4. The background between the words goes dark in all three bands; the words are unchanged.

The streaming mode

The offline gate takes percentiles over the whole clip, which a live signal does not have. The stream keeps the same options but is causal: a running noise-floor and speech-level tracker (a 96-bin level histogram per band with exponential forgetting, 20 s by default), stateful filters, and a delay line that implements the lookahead. The first 0.6 s of a stream is not gated while the tracker warms up. The stream follows a 12 dB drop in noise in about 3 s and a 10 dB rise in about 26 s, because the old floor has to age out; a rise that tracks slowly is the safe direction, since the gate stays open until the estimate catches up. A long silence is held for 20 s and then the gate lets go, because a constant level cannot be told from noise.

The running tracker following a noise floor that drops by 12 dB and rises by 10 dB
Figure 5. The mid-band level, the tracker's noise-floor and speech estimates, and the gate threshold, through a 12 dB drop (top) and a 10 dB rise (bottom) in the noise.
The low-band gain opening within about 20 milliseconds of an abrupt word start; the first sample leaves the delay line 17 milliseconds after it arrived
Figure 6. Lookahead. The detector sees the input at once; the audio it controls leaves the delay line 17 ms later, when the gain is nearly open (an abrupt word start: −2.5 dB on the first sample, −0.50 dB over the first 30 ms).
Gap attenuation against signal to noise ratio with adaptive depth on and off
Figure 7. Adaptive depth eases the cut on a noisy recording, where soft speech sits at the noise level. Switch it off to always cut the full amount.

The numbers

Measured in Node 24 on one Windows PC (an Intel i7-4790 from 2014) with seeded synthetic signals; npm run measure regenerates every number and figure. That machine also runs other heavy work, so timings vary by about 2x between runs: the figures below are the best of 9 to 15 runs, and the medians are in results.json. It is a desktop CPU, not a phone, and we did not measure energy use.

WhatResult
Stream, 3 bands, 128-sample blocks1.9 ms per second of audio at 16 kHz (0.19% of one core, 527x real time); 6.5 ms at 48 kHz (0.65%, 155x)
Whole clip, process()3.3 ms per second at 16 kHz; 9.4 ms at 48 kHz
Band count (stream, 48 kHz)1 band 1.2 ms, 3 bands 6.3 ms, 5 bands 10.5 ms, 7 bands 16.4 ms per second
Memory per stream22 KiB at 16 kHz, 39 KiB at 48 kHz; no heap growth over 20,000 blocks
Latency17 ms by default (12 ms lookahead plus one 5 ms hop)
Gaps, 30 dB SNR test recording−12.3 dB by default, −16.0 dB with adaptive depth off; speech level 0.00 dB; worst word-onset loss −0.33 dB offline, −0.51 dB streaming
CPU time per second of audio for audioblur streaming at 16 and 48 kilohertz, audioblur on a whole clip and RNNoise WebAssembly, and how cost grows with the band count
Figure 8. CPU time per second of audio. The RNNoise bar is the Jitsi WebAssembly build measured on the same machine in the same runs.

One bug the measurements found: after speech ended and the input went to digital silence, the filter states decayed into subnormal numbers and the stream ran about 20 times slower (72 ms per second instead of 5.6). The filter state is now flushed to zero below 1e-30, and a check in the test suite guards it.

How we tested it — and what we have not

The test page in the download runs 50 checks in your own browser, offline (49 of the same checks run in Node): the options and their errors; the band split against the analytic Linkwitz-Riley response (within 0.0008 dB) and the bands summing to unity; gap attenuation equal to reduction; word onsets; bit-exact bypass; identical stream output for chunk sizes from 1 to 4096 samples; the running tracker against the exact clip percentiles (within 1.5 dB in every band); a noise floor that drops and rises; long pauses; NaN and Infinity input; eight sample rates from 8 to 96 kHz; and the AudioWorklet processor, run against a stub of the worklet scope, matching the stream sample for sample. All passed in Node 24 and Chromium. The offline path was ported from the gate we built for our push-to-talk app and, with the allpass compensation off, reproduces that code's output bit for bit on ten synthetic comparisons.

The honest limits: it is a gate, so noise under speech passes; it needs a contrast between speech and pauses, and music counts as speech; a loud click in a pause passes; a stream is mono (multichannel means independent streams); the first 0.6 s is not gated; and it has only been run in Node and Chromium, not in Firefox, Safari or on a phone. All the numbers come from a synthetic signal, so they are measurements of a test, not a claim about how it sounds on your recordings, and we did not compare noise-suppression quality with RNNoise: it is trained on real speech and our signals are not.

Download

The source is on GitHub: github.com/dialersapps/audioblur (issues and pull requests welcome). The downloads below are plain files with nothing to build, no tracking and no outside requests:

  • audioblur-1.0.0.zip — everything in one file (library, ES module, demo, tests, figure tools, figures, README, licence)
  • audioblur.js — the library (plain script tag, require() and Workers)
  • audioblur.mjs — the same code as an ES module
  • demo.html — process your own audio offline or through an AudioWorklet (everything stays in your browser)
  • test.html — the in-browser test suite
  • README.md — API, options, limits
  • LICENSE — MIT, copyright Dialer's Apps 2026

The code was written by Dialer's Apps. The band structure, thresholds and timings follow the gate we tuned for our own app; this release adds the streaming mode, the allpass compensation and the AudioWorklet wrapper, and it contains no code copied from another project. RNNoise is a separate project by Jean-Marc Valin and contributors; audioblur is not affiliated with it.