WebGPU rgba32float Not Blendable? Check the Device Feature

A capable adapter can still produce a device without the feature

If switching a render target to rgba32float produces a “not blendable” validation error, inspect device initialization. The optional float32-blendable feature enables blending for r32float, rg32float and rgba32float targets.

There are two separate checks. adapter.features describes what the current environment can provide. device.features contains the features requested when that device was created. Passing the first check does not automatically populate the second.

For a renderer that already holds a device, inspect device.features.has("float32-blendable"). Creating an unrelated device with the feature will not change the device your existing renderer uses.

Make the feature part of device creation

This initialization example is for an application that creates its own GPUDevice. It checks WebGPU availability, the adapter and feature support in sequence. Use the returned device for the subsequent textures and pipelines.

async function createFloatBlendDevice() {
  if (!navigator.gpu) {
    throw new Error("WebGPU is unavailable");
  }

  const adapter = await navigator.gpu.requestAdapter();
  if (!adapter) {
    throw new Error("No WebGPU adapter");
  }

  const feature = "float32-blendable";
  if (!adapter.features.has(feature)) {
    throw new Error("32-bit float blending is unavailable");
  }

  return adapter.requestDevice({ requiredFeatures: [feature] });
}

requiredFeatures defaults to an empty array. Requesting an unsupported feature rejects the promise with a TypeError. The caller should handle initialization failure by selecting another rendering path or explaining why that mode is unavailable.

The function initializes a device; it is not a complete renderer. The pipeline’s target formats and blend state still need to match the intended operation. If a framework owns device creation, inspect its initialization path rather than running a second, disconnected initializer.

Float filtering is not float blending

float32-filterable permits filtering when sampling 32-bit floating-point textures. Blending combines a fragment’s output with values in a render target. These are separate capabilities.

Operation	Feature to check
Read a float32 texture using filtering.	float32-filterable
Blend into a float32 render target.	float32-blendable

The supported-features reference lists them independently. A renderer that needs both should check and request both.

Check whether that particular target should blend

Next, inspect the pipeline’s individual fragment targets. An application that writes color and normal data to separate attachments may want color compositing without blending the data output.

1. Missing on the adapter: this environment cannot provide the float32 blending path.
2. Present on the adapter, absent on the device: change the actual renderer’s device request.
3. Unnecessary on the target: reconsider why that output has a blend state.

Removing blend state is a change in rendering behavior, not a way to keep the same compositing result while hiding an error. A transparent color output that must combine with existing values still needs blending. Decide from the purpose of the attachment.

Firefox 158 adds float32-blendable support, but a browser version does not guarantee availability on every GPU configuration. Keep both capability detection and the device request in initialization so a different computer produces an understandable result.