Skip to content
Blog

WebGPU in 2026: Support Matrix, Detection, and Fallback for Flutter Web

Where WebGPU actually ships across browsers and platforms in 2026, how to detect it without fooling yourself, and how a Flutter web app should fall back to WebGL2.

Published on • November 11, 2026

AI Assistant

WebGPU crossed the line from experimental to shipped: all four engines now enable it by default somewhere, and Google’s November 2025 milestone post declared it supported across Chrome, Edge, Firefox, and Safari. “Somewhere” is the operative word. Support is platform-conditional, so a Flutter web app that assumes WebGPU will break on real users — this post is the honest matrix, the detection code, and the fallback plan.

The real support matrix in 2026

Chromium covers Windows, macOS, and ChromeOS since 113, Android 12+ since 121, and Linux on Intel Gen12+ since 144 (NVIDIA on Wayland landed in 147); Windows on ARM64 is still behind a flag, and some Android GPUs — Samsung Xclipse is the usual example — are not enabled yet. Safari shipped WebGPU in 26 across macOS, iOS, iPadOS, and visionOS. Firefox covers Windows since 141, Apple Silicon Macs on macOS 26 since 145, and all macOS versions since 147, while Linux remains Nightly-only and Android is gated behind an about:config flag.

Add it up and Can I Use reports roughly 89% of users covered as of October 2026 — high, but that means one in eleven visitors needs your fallback. Missing platforms cluster in specific places: Linux desktops, Windows on ARM, older Android hardware.

Feature detection that actually works

Two separate checks, both required: navigator.gpu existing only means the API is present, and requestAdapter() resolving to null means the browser has no usable GPU behind it (blocked driver, blocklisted device, headless environment). Treat either as “no WebGPU”, and remember the API only exists in secure contexts:

// web/gpu.js — run once at startup, cache the result
async function detectWebGPU() {
  if (!navigator.gpu) return null;
  try {
    const adapter = await navigator.gpu.requestAdapter();
    if (!adapter) return null;
    return await adapter.requestDevice();
  } catch (err) {
    console.warn('WebGPU adapter failed', err);
    return null;
  }
}

Expose the outcome to Dart as a plain boolean so widgets can branch without re-running detection:

Future<bool> get webGpuReady async {
  final bridge = web.window.getProperty('gpuBridge'.toJS)! as JSObject;
  final pending = bridge.callMethod('detect'.toJS)! as JSPromise;
  return (await pending.toDart as JSBoolean).toDart;
}

No user-agent sniffing anywhere in this path — UA strings lie about exactly these platform gaps.

Where WebGPU actually pays off

WebGL is a graphics API: it draws, it does not compute. WebGPU adds first-class compute pipelines and the WGSL shading language, which is why ML runtimes moved: ONNX Runtime Web’s WebGPU execution provider, TensorFlow.js backends, and Transformers.js all run inference on it, and Google’s milestone post names both ONNX Runtime and Transformers.js as adopters. The three.js WebGPURenderer and Babylon.js cover the 3D side.

For Flutter web, be clear about the boundary: Flutter’s own widget rendering runs through its CanvasKit and Skwasm renderers on WebGL and WebGPU — that pipeline is the framework’s business and hands you no compute. Your practical routes are a library behind an HtmlElementView (a three.js scene, a Babylon canvas) or raw WGSL through dart:js_interop. Keep app UI in Flutter, hand heavy GPU work to JavaScript.

A first compute pass through the bridge

Keep the WGSL and the dispatch on the JavaScript side; Dart only moves buffers in and reads results out, which keeps the interop surface down to two calls:

// web/compute.js
export async function initCompute() {
  const adapter = await navigator.gpu.requestAdapter();
  const device = await adapter.requestDevice();
  const module = device.createShaderModule({ code: SQUARE_WGSL });
  return device.createComputePipeline({
    layout: 'auto',
    compute: { module, entryPoint: 'main' },
  });
}

Dispatch, await the mapped result buffer, and hand the floats back to Dart — the same JSPromise pattern the detection bridge already uses, so one bridge file can carry both.

Fall back to WebGL2 without regressing

WebGL2 is effectively universal — Chrome 56, Firefox 51, Safari 15 — so it is the correct fallback target, not WebGL1. Branch once, log the branch, and ship:

export async function createRenderer(canvas) {
  const device = await detectWebGPU();
  if (device) return { backend: 'webgpu', device };

  const gl = canvas.getContext('webgl2');
  if (gl) return { backend: 'webgl2', gl };

  return { backend: 'cpu' }; // rare, but handle it
}

Log which branch users actually land on. Your analytics will show whether the 11% without WebGPU is concentrated on one platform, and that tells you where to spend effort on the fallback.

Isolation is for threads, not GPUs

One common confusion: multi-threaded WebAssembly and SharedArrayBuffer require cross-origin isolation (COOP and COEP headers), and runtimes like ONNX Runtime gate numThreads on it. WebGPU needs none of that — only a secure context. So do not gate your WebGPU detection on crossOriginIsolated, and do not add those headers hoping they will speed up a WebGPU path; add them for the WASM threads, and enjoy WebGPU either way.

Takeaway: WebGPU is default-on across four engines but platform-conditional at ~89% coverage — detect navigator.gpu and a non-null adapter, fall back to universal WebGL2, and reach WebGPU from Flutter web through libraries and interop rather than expecting it from the widget pipeline.

Sources