Denoise

Remove background noise from audio

Overview

Denoise removes background noise from a recording and hands you back a clean version, side by side with the original. Upload or record some audio, click Remove noise, and a moment later you have a crisp WAV with the hiss, hum, and chatter stripped out. It is part of the kimtos new-tab app suite.

The cleanup is done by DeepFilterNet3, a speech-enhancement model that runs entirely in your browser. Your audio is never uploaded — it is decoded, processed, and re-encoded right on the device.

Highlights

• Two ways in — drag-and-drop or click to upload an audio file, or record straight from your microphone (and optionally system audio) with a live timer.
• One-click denoise — press Remove noise and watch a progress bar as the model works through the clip.
• A/B player — the result screen shows a Cleaned player and an Original player so you can compare them back to back.
• Local history — every run is saved to a sidebar (original and cleaned audio), so you can reopen, replay, or re-download past clips. The most recent 30 are kept.
• Download — save any cleaned clip as a 16-bit WAV.
• Multi-select cleanup — drag across clips (or tap Select) to delete several at once, with one-tap undo.
• Hand-off to Voice to Text — if the Voice to Text app is installed, you can send a cleaned clip (or the raw input) straight over for transcription.

Privacy model

Denoise is fully on-device. There is no backend, no account, and no upload:

• The DeepFilterNet3 model runs locally in your browser via WebAssembly (onnxruntime-web). The model file (~16 MB) downloads once from a public host, is cached in the browser's Cache Storage, and works offline after that.
• Your audio is decoded and denoised in memory and never leaves the machine.
• Each run — the original clip, the cleaned WAV, and a little metadata — is stored as blobs and records in your browser's IndexedDB, and is included in the suite's local Export / Import backup.

Because nothing is sent to a server, there are no analytics and no third-party calls beyond that one-time model download.

Getting Started

Open Denoise from the dock. It starts on the input screen, ready for a clip. The sidebar on the left holds your past results — empty until your first run.

1. Add some audio

You can either upload or record:

• Upload — drag an audio file onto the drop zone, or click to pick one. Common formats work (mp3, wav, m4a, ogg, flac, opus, and more).
• Record — click the mic button and speak; a live timer shows the length. Stop when you're done. In Settings ▸ Apps you can set the recording source to just your microphone, or system audio mixed with the mic.

The chosen clip appears in a small player card so you can check it before processing.

2. Remove the noise

Click Remove noise. On the first ever run the model downloads once (~16 MB) — the progress bar notes this, and it's cached for offline use afterwards. Then you'll see:

1. Decoding audio — the clip is converted to mono 48 kHz.
2. Removing noise — DeepFilterNet3 processes the audio frame by frame, in your browser.
3. Finishing — the clean audio is encoded to a WAV.

When it's done, the result opens automatically and is saved to history.

3. Compare with the A/B player

The result screen shows two players:

• Cleaned — the denoised audio.
• Original — the clip you started with.

Play them back to back to judge the difference.

4. Download

Click Download cleaned WAV to save the result to your computer. You can also download any past clip from its sidebar menu (Download cleaned).

5. The history sidebar

Every run is kept in the left sidebar (newest first, up to 30 clips):

• Open — click a clip to reopen its A/B player and download button.
• Right-click a clip for a menu: Open, Download cleaned, and (if available) Extract transcript with Voice to Text.
• Delete several — tap Select, tick the clips, then Delete (N) — or just drag across them. A toast lets you undo for a few seconds.

Hand-off to Voice to Text

If the Voice to Text app is installed, Denoise can pass audio to it:

• From the result screen or a clip's menu — Extract transcript with Voice to Text sends the cleaned clip over for transcription. The button follows the job and shows Transcribing…, then Done ✓.
• From the input screen — Extract transcript with Voice to Text forwards the current clip as-is (without denoising first), in case the recording is already clean enough.

Denoise also receives hand-offs: a clip sent from another app (e.g. Voice to Text) arrives pre-loaded on the input screen, ready for you to denoise.

Architecture

Denoise follows the suite convention: a small UI descriptor plus a self-contained model engine, with all clips stored on-device. The heavy lifting — running the model — happens entirely in the browser via WebAssembly. The app code lives in extension/src/apps/denoise/.

Modules

File	Role
apps/denoise/index.ts	The app descriptor and UI — input screen, progress, the A/B result player, the history sidebar, downloads, and Voice to Text hand-off.
lib/engines/denoise.ts	The model engine — fetches/caches the ONNX model, decodes audio, runs DeepFilterNet3 on onnxruntime-web (WASM), and encodes the cleaned WAV.
components/audioInput.ts	Reusable upload / record input with a live timer and clip preview.
components/audioPlayer.ts	The compact audio player used for the Cleaned and Original tracks.
components/historySidebar.ts	The titled history list — open, right-click menu, multi-select, and delete with undo.
components/progressBar.ts	The download / processing progress bar.
lib/dataStore.ts	On-device storage — records and binary blobs in IndexedDB.
lib/appHandoff.ts	The in-memory baton for passing a clip to another app (e.g. Voice to Text).

Pipeline

The UI never runs the model itself: it calls denoiseAudio(blob) in engines/denoise.ts, which owns the whole audio path. The result is saved through the shared data store and shown in the sidebar.

How the engine works

engines/denoise.ts carries the model I/O contract end to end:

• Model fetch & cache — the ONNX file is requested from Cache Storage first; on a miss it downloads once (with byte progress) and is cached under kimtos-models, so later runs are instant and offline.
• Session — onnxruntime-web is loaded and run single-threaded with the WASM execution provider. In production the .wasm is self-hosted (the extension's CSP blocks CDNs).
• Decode — any browser-supported audio is decoded to mono 48 kHz Float32 via an AudioContext (which resamples and down-mixes for us).
• Inference — the model is an end-to-end graph (PCM in → clean PCM out, with all the STFT / ERB / deep-filter DSP baked in). It runs frame by frame in 10 ms hops (480 samples), carrying a recurrent state vector between frames. Progress is reported periodically.
• Encode — the cleaned samples are written to a minimal 16-bit PCM WAV blob.

DeepFilterNet3 (MIT / Apache-2.0) is exported to a single ONNX graph via torchDF.

Storage

History lives under the history:denoise collection. Each run saves:

• the original clip and the cleaned WAV as separate blobs, and
• a record with { name, at, origKey, cleanKey, from, srcId }.

from and srcId track a clip's provenance — so a clip that came from Voice to Text isn't offered straight back, and re-runs of the same source can be detected. History is capped at the most recent 30 clips; older runs (and their blobs) are pruned automatically. Deleting a clip removes its record and both blobs, and the app's Clear data wipes the whole collection and its blobs.