WebAudio: Configurable render quantum

at a glance

why it exists

The Web Audio API has always rendered audio in fixed 128-frame chunks (the render quantum). This gives a latency of about 2.9 ms at 44.1 kHz. While 128 frames is fine for most applications, it creates tensions at both ends of the spectrum:

• Low-latency instruments (synthesisers, live effects) would benefit from a smaller quantum (e.g. 32 frames) to cut round-trip latency, even at the cost of more CPU interrupts.
• Batch or background processing (audio fingerprinting, format conversion) runs more efficiently with a larger quantum (e.g. 1024 frames) to amortise callback overhead.

The renderSizeHint option lets the developer express a preference; the browser uses it as a hint, rounding to a supported size if necessary.

Syntax and WebIDL

// WebIDL definitions from the W3C Web Audio API specification:
enum AudioContextRenderSizeCategory {
  "default",
  "hardware"
};

dictionary AudioContextOptions {
  // Existing options omitted...
  (AudioContextRenderSizeCategory or unsigned long) renderSizeHint = "default";
};

dictionary OfflineAudioContextOptions {
  // Existing options omitted...
  (AudioContextRenderSizeCategory or unsigned long) renderSizeHint = "default";
};

partial interface BaseAudioContext {
  readonly attribute unsigned long renderQuantumSize;
};

partial interface AudioWorkletGlobalScope {
  readonly attribute unsigned long renderQuantumSize;
};

Inputs and outputs

Inputs: The renderSizeHint dictionary member accepts an unsigned integer (typically powers of two such as 32, 64, 128, 256, 512, 1024) or the string enum values "default" and "hardware". Passed during context construction via new AudioContext({ renderSizeHint }) or new OfflineAudioContext({ ..., renderSizeHint }).

Outputs: The renderQuantumSize attribute returns an unsigned integer reflecting the active render quantum size for the audio context. Inside an AudioWorkletProcessor, the worklet global scope exposes the identical renderQuantumSize value, determining the length of channel arrays in the process(inputs, outputs, parameters) callback.

Errors and lifecycle

Errors: Per the Web Audio API specification, passing an integer render-quantum size outside the supported range throws a NotSupportedError: §2.5 requires it for values outside the permitted range (1 up to 6× the sample rate). The renderSizeHint categories (AudioContextRenderSizeCategory: "default" or "hardware") are advisory and map onto a supported size. If a value of the wrong type is provided, standard WebIDL type conversion throws a TypeError.

Lifecycle: The render quantum size is fixed at context instantiation time and remains immutable for the lifetime of that AudioContext or OfflineAudioContext. Graph nodes and AudioWorklet processors instantiated within the context operate synchronously on blocks of renderQuantumSize frames throughout execution.

Examples

The following example demonstrates configuring low-latency synthesis, batch offline rendering, and accessing renderQuantumSize in main thread and worklet scopes:

// 1. Low-latency interactive synthesiser: request small quantum (lower latency, more CPU)
const ctx = new AudioContext({ renderSizeHint: 32 });
console.log(`Configured render quantum: ${ctx.renderQuantumSize} frames`);

// 2. Batch processor: request large quantum (less CPU callback overhead)
const offCtx = new OfflineAudioContext({
  numberOfChannels: 2,
  length: 44100 * 10,  // 10 seconds
  sampleRate: 44100,
  renderSizeHint: 1024,
});
console.log(`Offline render quantum: ${offCtx.renderQuantumSize} frames`);

// 3. Requesting hardware-preferred quantum
const hwCtx = new AudioContext({ renderSizeHint: 'hardware' });

// 4. AudioWorkletProcessor handling variable render quantum sizes:
class DynamicQuantumProcessor extends AudioWorkletProcessor {
  process(inputs, outputs) {
    // globalThis.renderQuantumSize specifies frame buffer length per channel
    const output = outputs[0];
    const channelData = output[0];
    for (let i = 0; i < channelData.length; i++) {
      channelData[i] = 0.0;
    }
    return true;
  }
}

browser compatibility

Configurable render quantum is supported enabled by default in Chrome 153 and Chromium derivatives across desktop, Android, and WebView platforms. Other engine positions remain in progress as tracked by W3C Web Audio standards issues:

security and privacy

• Timing resolution and fingerprinting: Audio render quantum sizes provide precise sub-millisecond hardware callback timing. To prevent cross-origin timing attacks and high-resolution fingerprinting, user agents may limit the minimum quantum size or restrict hardware buffer exposure to secure contexts.
• Resource consumption: Very small render quantum sizes (e.g. < 32 frames) increase thread interrupt frequency and CPU load. Implementations enforce lower bounds to prevent audio thread starvation and denial of service.

see also

• Chrome Platform Status — WebAudio: Configurable render quantum
• Web Audio API — renderQuantumSize
• Web Audio API — AudioContextOptions renderSizeHint
• MDN: AudioContext