Firefox 160 for Developers: Local Speech Recognition and Buffered WebTransportNote · digest for November 11
Macro shot of a sound wave and memory buffer inside the Firefox 160 browser for developers.
Note3 sections≈ 4 min

Firefox 160 for Developers: Local Speech Recognition and Buffered WebTransport

In this note, I'll show how the Firefox 160 release, shipped on November 10, 2026, lets you set up private voice input without sending audio to remote servers and read WebTransport datagrams into a reusable memory buffer.

Let's walk through both features with a concrete task: you are building a desktop web app with voice controls via SpeechRecognition and network data exchange where microphone audio never leaves the computer and frequent packets do not trigger garbage collector pauses.

Local Web Speech API: Voice Commands in 40 Languages Without the Cloud

Until now, voice input in browsers carried a hidden trade-off. You call SpeechRecognition in JavaScript, and the browser streams raw microphone audio to the cloud. On a slow connection that adds latency, and for private data sending voice recordings to third-party servers is unacceptable.

Audio flies off to someone else's cloud while the UI waits on the network.

In the desktop edition of Firefox 160 (spotted in the Веб-стандарты channel), speech synthesis and recognition in the Web Speech API moved to real-time on-device processing across 40 languages. Previously, staying offline meant wiring up local speech recognition in the browser through third-party libraries; now the built-in desktop engine handles it natively.

To capture a single command, simply instantiate SpeechRecognition, set recognition.lang = 'ru-RU', disable drafts with continuous = false and interimResults = false, and call recognition.start(). The decoder processes the utterance locally and returns the string in onresult via event.results[0][0] with zero network requests. Keep the limitation in mind: in Firefox 160, the local engine only works on desktop, with no support on Android or in cloud mode.

Buffered WebTransport: Session Headers and Zero-Allocation Datagram Reads

When exchanging packets with a server over WebTransport on top of HTTP/3 and QUIC, memory becomes the bottleneck. By default, reading transport.datagrams.readable makes the browser allocate a new Uint8Array for every incoming UDP datagram. At hundreds of packets per second, throwaway objects fill the heap and cause garbage collector pauses.

Every packet in the read loop generates unnecessary memory garbage.

Let's configure a WebTransport connection with an authorization header and datagram reads into a pre-allocated 2,048-byte ArrayBuffer:

const transport = new WebTransport('https://example.com:4433/transport', {
    headers: { 'Authorization': 'Bearer token123' },
    datagramsReadableType: 'bytes'
});

await transport.ready;

const reader = transport.datagrams.readable.getReader({ mode: 'byob' });
let buffer = new ArrayBuffer(2048);

async function readDatagrams() {
    while (true) {
        const { value, done } = await reader.read(new Uint8Array(buffer, 0, 2048));
        if (done) break;
        buffer = value.buffer;
    }
}
readDatagrams();

The datagramsReadableType: 'bytes' option switches the stream to byte mode for ReadableStreamBYOBReader (mode: 'byob' — "bring your own buffer"). Just like using a reusable container instead of disposable cups, we allocate ArrayBuffer(2048) once and after each reader.read() hand the same buffer back via buffer = value.buffer for the next loop iteration.

Avoiding extra allocations reflects a broader rule in modern web APIs: real-time apps need direct control over memory and the handshake. For the same reason, WebTransport() also gained a headers option for CONNECT request headers, the transport.responseHeaders property, and queue limits incomingMaxBufferedDatagrams and outgoingMaxBufferedDatagrams.

Style Compatibility and Experimental Rendering Flags

I also checked the layout fixes and about:config flags. The ::-webkit-input-placeholder pseudo-element now acts as an alias for standard ::placeholder. Behind experimental flags, you'll find the blocking="render" attribute for <link>, <script>, and <style> (dom.element.blocking.enabled), lazy loading loading="lazy" for <video> and <audio> (media.lazy_loading.enabled), and the Speculation-Rules header (dom.speculation_rules.enabled).

To compare with the previous release, check out our breakdown of native scroll-driven animations and scoped custom element registries in Firefox 159. There is still no single switch that enables local voice input and the new loading modes across all devices: Android needs a fallback path for speech, while lazy media loading and blocking="render" await default-on status. Still, you now know the capabilities and boundaries of desktop Firefox 160 and can start designing around local SpeechRecognition and buffered WebTransport in your projects.

Want a deep diveVotes help us choose what to break down in detail. This material has 0 votes.
Sources · 2