Browser Audio Technology: A Complete Survey — Web Audio API, WebAssembly, and the State of the Art
Last updated: May 9, 2026 · Author: Kotaro Asahina (Founder of Kuon, Audio Engineer)
Quick Answer
As of 2026, professional-grade audio processing in the browser is enabled by five technologies: Web Audio API (W3C, 2011), WebAssembly (W3C-standardized 2017, ~90% native speed), AudioWorklet (3–10ms latency), SharedArrayBuffer, and File System Access API (multi-GB file support). Kuon integrates all five to deliver world-first browser-based DDP parsing, DSD-to-PCM conversion, and AI stem separation — workflows previously confined to desktop applications.
Key Specs
- Web Audio API codified
- 2011
- WebAssembly standardized
- 2017
- AudioWorklet latency
- 3–10 ms
- getUserMedia input latency
- 20–50 ms
- WebGPU standardized
- 2023
- Web MIDI API Recommendation
- 2022
- Wasm speed (vs native)
- ~90%
- File System Access max file
- ~tens of GB
What is browser-based audio processing?
Browser-based audio processing is the territory where Web Audio API, WebAssembly, AudioWorklet, the File System Access API, and other web standards combine to deliver audio processing that is install-free, OS-independent, and Privacy First. The same code runs in Chrome, Safari, Firefox, and Edge, on Mac, Windows, Linux, and Chromebook.
Until around 2014, conventional wisdom held that "browsers can only do lightweight processing." The arrival of WebAssembly and AudioWorklet rewrote that assumption: today, professional-grade DAWs, stem separation, mastering, and high-resolution conversion can all be implemented in the browser.
Web Audio API basics
Web Audio API is the JavaScript API W3C began standardizing in 2011 for generating, processing, and analyzing audio in the browser. The three core concepts are:
The revolution WebAssembly brought to audio
WebAssembly (Wasm), standardized by W3C in 2017, is a binary executable format that runs at near-native speed in the browser. Code written in C, C++, or Rust can be compiled to Wasm, which means decades of accumulated audio libraries (FFTW, libsoxr, librosa, and more) can be ported to browsers.
Wasm runs at roughly 90% of native speed and is 5–20× faster than JavaScript. FFTs, resampling, codecs, and stem separation — workloads that simply weren't feasible in JavaScript — became practical with Wasm. Almost every qualitative leap in browser audio processing traces back to Wasm.
Large-file processing via the File System Access API
Traditional Blob/ArrayBuffer file processing capped near 2 GB of memory — insufficient for several CDs of DSD audio or long live recordings. The File System Access API (Chrome 86+, 2020) lifts that barrier by allowing direct on-disk reads and writes.
Kuon DSD CONVERTER uses this API to stream-process DSD512 files exceeding 5 GB directly in the browser — a workflow previously available only in desktop-only software.
Notable examples
What you can do in the browser
- Pitch detection: YIN, pYIN, CREPE — running in the browser (e.g., Kuon INTONATION)
- FFT and spectrum analysis: AnalyserNode supports real-time 8192-point FFT
- Real-time DSP: AudioWorklet enables custom processing at 3–10 ms latency
- Source separation: cloud-backed (Kuon SEPARATOR)
- DSD/PCM conversion: Rust+Wasm high-precision filtering (Kuon DSD CONVERTER)
- Mastering analysis: LUFS, True Peak, Loudness Range measurement
- DDP/SACD analysis: full parsing of industry-standard formats via binary parsers
Benefits of browser-based audio
Four main advantages. First, no installation required — open a URL and use it; switch PCs and pick up where you left off. Second, cross-platform: identical behavior on Mac, Windows, Linux, Chromebook, and iPad. Third, shareability — send a link to share a project or piece. Fourth, Privacy First — files can stay in browser memory and never reach a server.
Constraints
Native DAWs still hold the advantage for professional studio tracking and real-time MIDI performance, but for mastering, analysis, conversion, and education, browser-based platforms are now more than viable.
What's next: WebGPU, WebCodecs, and Audio Worklet
Three technologies will shape the next wave. WebGPU (standardized in 2023) opens GPU parallelism to the browser, accelerating neural source separation, large FFTs, and real-time spectral synthesis. WebCodecs API (since 2022) gives low-level access to video and audio codecs, making real-time encoding and decoding of Opus, FLAC, and AAC more efficient. Continued Audio Worklet evolution, combined with SharedArrayBuffer, makes it possible to build more complex real-time DSP pipelines in the browser.
Kuon's world-first browser features
As of 2026, Kuon has shipped multiple world-firsts in browser audio:
- DDP PLAYER: world's first browser-based DDP-file analysis with the Gap Listen feature
- DSD CONVERTER: Rust+Wasm + Blackman-sinc FIR — DSD-to-PCM conversion at professional-software quality
- INTONATION: real-time cent-precision pitch tracking via the YIN algorithm
- AUDIO MIRROR: reference A/B comparison with Privacy First design
- SEPARATOR: AI stem separation (cloud processing)
- 44 apps plus a free public Journal, available in 4 languages
See Kuon's World-First Technologies page for in-depth technical breakdowns.
Developer references
- W3C Web Audio API specification:
https://www.w3.org/TR/webaudio/ - MDN — Web Audio API:
https://developer.mozilla.org/en-US/docs/Web/API/Web_Audio_API - WebAssembly official:
https://webassembly.org/ - Google Developers — Audio Worklet:
https://developer.chrome.com/blog/audio-worklet/
Frequently Asked Questions
Is professional-grade audio processing really possible in the browser?
Yes. WebAssembly lets you port industry-grade audio libraries written in C/C++ to the browser at over 90% of native speed, and AudioWorklet achieves latencies as low as 3–10 ms. Kuon's SEPARATOR (AI stem separation), DSD CONVERTER, and AUDIO MIRROR all run in the browser at quality on par with desktop-only software.
When did Web Audio API become available?
Standardization at W3C began in 2011, with major browser implementations rolling out from around 2014. It is now available in all modern browsers including Chrome, Safari, Firefox, and Edge. Audio Worklet (for low-latency processing) was implemented progressively from 2018 and is now standard.
What is WebAssembly?
WebAssembly (Wasm) is a binary executable format standardized by W3C in 2017 that runs at near-native speeds in the browser. You can compile code written in C, C++, or Rust to Wasm and run it in the browser. In audio processing it is used for FFTs, filtering, codecs, and other workloads requiring native speed.
What is AudioWorklet?
AudioWorklet is part of Web Audio API and runs on a thread dedicated to audio processing. It can perform real-time work independent of the main thread and achieves latencies of about 3–10 ms. It is the successor to the deprecated ScriptProcessorNode and is the central technology for modern browser audio processing.
Are there file size limits for browser audio processing?
Historically, Blob/ArrayBuffer-based processing was capped near 2 GB of memory. The File System Access API (Chrome 86+, 2020) lifted this limitation by enabling direct read/write of large files (tens of GB) on disk. Kuon DSD CONVERTER uses this API to process files exceeding 5 GB.
What are the downsides of browser audio processing?
Three main ones: (1) real-time performance still trails native DAWs (not ideal for low-latency tracking), (2) GPU-accelerated workflows are still maturing alongside WebGPU, and (3) Web Audio API's sample rate depends on OS settings. For non-real-time work — mastering, analysis, conversion — browsers are competitive with native software.
Are Soundtrap and Splice browser-based audio platforms?
Yes. Soundtrap (Spotify, acquired 2017) and Splice (US) are music-creation platforms that run in the browser. BandLab and Ableton Note Web use similar technology. Kuon belongs to this lineage, with a focus on music education, conversion, and analysis.
How will WebGPU affect browser audio processing?
WebGPU (standardized in Chrome in 2023) enables GPU parallel processing from the browser. In audio, it should accelerate large FFTs, neural source separation, and real-time analysis. Kuon is researching ways to migrate SEPARATOR processing onto WebGPU in the future.
What is SharedArrayBuffer?
SharedArrayBuffer is a memory region that can be shared between multiple JavaScript threads. Combined with AudioWorklet, it enables high-speed data transfer between the main thread and the audio-processing thread. It was temporarily disabled due to Spectre vulnerabilities, but Cross-Origin Isolation (COOP/COEP) headers re-enable it today.
Is MIDI input/output possible in the browser?
Yes. The Web MIDI API (W3C Candidate Recommendation in 2015, formal Recommendation in 2022) lets browsers communicate directly with USB / Bluetooth MIDI devices. Several Kuon music apps make use of this API.
How does the browser handle microphone input?
The getUserMedia API (part of WebRTC) provides access to the microphone with user permission. Latency is roughly 20–50 ms — sufficient for real-time tuners and recording apps. Kuon's TUNER, INTONATION, and recording apps use this API.
Which world-first features has Kuon built in the browser?
Major firsts include (1) browser-based DDP PLAYER (full parsing of CD mastering files plus the Gap Listen feature), (2) browser DSD CONVERTER (Rust+Wasm + Blackman-sinc FIR, on par with professional software), (3) AUDIO MIRROR (reference A/B comparison with Privacy First design), and (4) real-time INTONATION analysis (cent-precision pitch tracking via the YIN algorithm).
参考文献・出典
- W3C Web Audio API 1.1 Specification— Latest spec (2024 revision)
- MDN — Web Audio API— Mozilla's official tutorial set
- WebAssembly Official— Spec and implementation home
- Google Developers — Audio Worklet— Low-latency processing explained
- Web Audio Conference Proceedings— Academic conference papers