WebGPU Future Roadmap (2025-2027) | Research

What’s coming to WebGPU and browser graphics over the next few years. Based on GPU Web Working Group discussions and Chromium development.

The Dependency Chain

Everything hinges on bindless resources. The working group notes:

“Folks really want ray and mesh shading but bindless is required for both of them.”

Current priority order:

Bindless resources (prerequisite for everything)
Subgroups (already shipping in some browsers)
Mesh shaders (blocked on bindless)
Ray tracing (blocked on bindless)

Bindless Resources

The missing feature that unlocks modern GPU techniques.

What it enables:

Access any texture/buffer without explicit binding
Dynamic material systems
Efficient scene graphs with arbitrary object counts
Required for ray tracing acceleration structures

Current workaround:

// Today: texture arrays with manual indexing
@group(0) @binding(0) var textures: binding_array<texture_2d<f32>>;
@group(0) @binding(1) var samplers: binding_array<sampler>;

fn sample_material(material_id: u32, uv: vec2<f32>) -> vec4<f32> {
    return textureSample(textures[material_id], samplers[material_id], uv);
}

Timeline: Under active proposal, likely 2025-2026.

Subgroups (Available Now)

Subgroups allow threads within a wave/warp to communicate directly without shared memory. Already shipping behind flags.

Performance impact: One developer reported 10x speedup using subgroup operations for neighboring pixel collaboration in fragment shaders.

Key operations:

// Available in Chrome 131+ with flag
enable subgroups;

fn compute_main(@builtin(subgroup_invocation_id) id: u32) {
    let sum = subgroupAdd(local_value);           // Sum across subgroup
    let broadcast = subgroupBroadcast(value, 0);  // Share from lane 0
    let ballot = subgroupBallot(condition);        // Bitmask of lanes where true
}

Use cases:

Parallel reductions (sum, min, max)
Warp-level voting
Efficient histogram computation
Wave-aware sorting

Mesh Shaders

Replace vertex/geometry shaders with compute-like mesh generation. Not yet in WebGPU spec.

Why they matter:

GPU-driven rendering pipelines
Meshlet culling (reject invisible geometry early)
Variable-rate shading
Procedural geometry without CPU round-trips

Current alternative: Compute shader + indirect draw, which works but less efficient.

Timeline: Blocked on bindless, likely 2026+.

Ray Tracing

Not officially in WebGPU. Two approaches exist:

1. Software Ray Tracing (Available Now)

WebRTX — community project implementing RT via compute shaders:

BVH construction and traversal in WGSL
No hardware acceleration
10-100x slower than hardware RT
Good for prototyping, not production

// WebRTX API (conceptual)
const bvh = await webrtx.buildBVH(geometry);
const result = webrtx.traceRays(bvh, rays);

2. Hardware Ray Tracing (Future)

Would require:

Bindless resources (for acceleration structure access)
New API surface (acceleration structure creation, ray queries)
Driver support across all backends

Timeline: Earliest 2027, if ever. WebGPU working group hasn’t committed to hardware RT.

WebNN + WebGPU Integration

Browser AI inference is converging with WebGPU.

Execution Providers

Provider	Backend	Best For
WASM	CPU	Fallback, small models
WebGL	GPU	Legacy, maintenance mode
WebGPU	GPU	Performance, modern
WebNN	GPU/NPU	Native acceleration

Recommendation: WebGPU for cross-platform, WebNN for Windows with DirectML.

Performance Patterns

// Avoid: CPU↔GPU transfers per inference
const result = await session.run(cpuTensor);

// Better: IO binding keeps data on GPU
const gpuTensor = createGpuTensor(data);
await session.run({ input: gpuTensor }, { output: gpuOutput });

Key optimizations:

Quantization — 8-bit/4-bit models for 2-4x speedup
IO binding — Keep tensors on GPU between operations
Session reuse — Amortize compilation cost
Operator fusion — Combine sequential ops

NPU Support

Intel Core Ultra and Qualcomm Snapdragon X have NPUs accessible via WebNN:

# Enable NPU in Edge
msedge.exe --disable_webnn_for_npu=0

Practical impact: 5-10x better power efficiency for transformer inference vs GPU.

WebGPU 2.0/2.1 Timeline

Based on Chromium development:

Version	Target	Key Features
1.0	Shipped	Core API, compute shaders
1.1	2025 Q1	Subgroups, timestamp queries
2.0	2025 Q3	Bindless, texture compression
2.1	2026	Mesh shaders, advanced features

Practical Implications

For Graphics Applications (2025-2026)

Focus on:

WebGPU compute for non-rendering tasks
Subgroups for performance-critical shaders
WGSL improvements (more built-ins, better tooling)

Avoid:

Waiting for ray tracing (use baked lighting/reflections)
Hardware mesh shaders (use compute + indirect draw)

For AI/ML Applications (2025-2026)

Focus on:

WebGPU execution provider in ONNX Runtime
Quantized models (ONNX, GGUF)
WebNN on Windows for DirectML acceleration

Monitor:

WebNN NPU support expansion
Browser memory limits relaxation

The Browser Graphics Stack (2027)

Predicted mature stack:

┌─────────────────────────────────────────────────┐
│               Application Layer                  │
│     (Figma-like apps, AI tools, games)          │
└─────────────────────┬───────────────────────────┘
                      │
┌─────────────────────▼───────────────────────────┐
│               Rendering Engine                   │
│          Vello / Custom (Rust → WASM)           │
│     • Bindless materials                        │
│     • GPU-driven rendering                      │
│     • Mesh shaders (if available)               │
└─────────────────────┬───────────────────────────┘
                      │
┌─────────────────────▼───────────────────────────┐
│               AI/ML Layer                        │
│            WebNN + ONNX Runtime                 │
│     • NPU inference for transformers            │
│     • GPU compute for vision models             │
│     • Real-time style transfer, segmentation    │
└─────────────────────┬───────────────────────────┘
                      │
┌─────────────────────▼───────────────────────────┐
│               GPU API                            │
│                 WebGPU 2.x                       │
│     • Bindless resources                        │
│     • Subgroups                                 │
│     • Maybe mesh shaders                        │
└─────────────────────────────────────────────────┘

Sources: