Nouveautés de WebGPU (Chrome 153-154)

François Beaufort
François Beaufort
GitHub

Publié le 15 septembre 2026

Extension buffer_view de WGSL

L'extension de langage WGSL buffer_view permet d'interpréter les données d'une variable uniforme, de stockage ou de groupe de travail comme plusieurs types différents. Cela présente un large éventail d'utilisations, allant des usages conventionnels de type-punning à la partition d'une variable en plusieurs variables logiques.

Pour des raisons de sécurité et de simplicité d'implémentation, les types réinterprétés ne sont accessibles qu'à l'aide des fonctions intégrées suivantes :

  • bufferView<T>() interprète la mémoire à un décalage d'octet spécifique comme un pointeur vers le type T.
  • bufferArrayView<T>() crée un pointeur de tableau limité avec un nombre d'éléments explicite.
  • bufferLength() renvoie la taille en octets de la mémoire tampon.

Cette extension de langage peut être détectée dans JavaScript à l'aide de navigator.gpu.wgslLanguageFeatures. Il est recommandé d'utiliser une directive "requires" pour signaler le risque de non-portabilité avec requires buffer_view en haut de votre code de nuanceur WGSL. Consultez l'exemple WGSL suivant et l'intention d'expédition.

requires buffer_view;

//  +-------------------+-----------------------------+----------------------------+
//  | Byte 0 .. 3       | Byte 4 .. (4 + N - 1)       | Byte (4 + N) .. End        |
//  +-------------------+-----------------------------+----------------------------+
//  | indices_size (u32)| indices (array<u32, count>) | vertices (array<f32>)      |
//  +-------------------+-----------------------------+----------------------------+
@group(0) @binding(0) var<storage> indices_and_vertices : buffer;

fn unpack_and_process_geometry() {
  let indices_size = *bufferView<u32>(&indices_and_vertices, 0);

  let indices = bufferArrayView<array<u32>>(&indices_and_vertices, 4, indices_size);
  let vertices = bufferView<array<f32>>(&indices_and_vertices, indices_size + 4);
  ...
}

Pour en savoir plus, consultez la proposition de vue de tampon et testez l'exemple WebGPU de wireframe.

Extension WGSL swizzle_assignment

En réponse à l'une des fonctionnalités les plus demandées par la communauté, l'extension WGSL swizzle_assignment vous permet d'écrire directement dans les swizzles de vecteurs, ce qui vous permet de mettre à jour plusieurs composants en une seule instruction. Il réduit considérablement le code récurrent et améliore la lisibilité des nuanceurs, tout en alignant WGSL sur d'autres langages de nuanceurs.

Cette extension de langage peut être détectée dans JavaScript à l'aide de navigator.gpu.wgslLanguageFeatures. Il est recommandé d'utiliser une directive "requires" pour signaler le risque de non-portabilité avec requires swizzle_assignment en haut de votre code de nuanceur WGSL. Consultez l'exemple WGSL suivant et l'intention d'expédition.

if (!navigator.gpu.wgslLanguageFeatures.has("swizzle_assignment")) {
  throw new Error(`WGSL swizzle assignment is not available`);
}

const adapter = await navigator.gpu.requestAdapter();
const device = await adapter.requestDevice();

const shaderModule = device.createShaderModule({ code: `
  requires swizzle_assignment;

  @vertex
  fn main(@builtin(vertex_index) vertex_index: u32) -> @builtin(position) vec4f {
    var position = vec4f(0.0, 0.0, 0.0, 1.0);
    position.xy = vec2f(10.0, 20.0); // Swizzle assignment

    return position;
  }`,
});

Mises à jour des extensions WGSL

L'extension de langage texture-formats-tier1, bien que compatible avec le code WGSL, n'était pas correctement mappée sur navigator.gpu.wgslLanguageFeatures (en tant que texture_formats_tier1) dans JavaScript. Ce problème de cartographie est désormais résolu. Consultez Chromium CL 8159562.

L'extension de langage subgroups est désormais automatiquement activée lorsque subgroup_size_control est activé dans WGSL. Consultez le problème dawn:545285663.

Nouveautés de l'application Aube

La nouvelle fonctionnalité expérimentale wgpu::FeatureName::BufferMapWriteExtendedUsages vous permet de créer un tampon avec wgpu::BufferUsage::MapWrite combiné à n'importe quel autre wgpu::BufferUsage, à l'exception de wgpu::BufferUsage::MapRead, pour écrire directement dans un tampon mappable qui est également utilisable par le GPU, ce qui élimine le tampon intermédiaire et la copie supplémentaire sur les backends Vulkan et D3D12. Pour en savoir plus, consultez Utilisations étendues de l'écriture de mappage de mémoire tampon et le problème dawn:386255678.

Vous pouvez désormais utiliser les liaisons webgpu_cpp.h sur n'importe quelle implémentation webgpu.h au lieu d'être lié à la saveur de Dawn en utilisant le nouveau webgpu_upstream_cpp_headers. Consultez le problème 596 de webgpu-headers.

Dawn nécessite désormais macOS 13.0 ou version ultérieure. Consultez Dawn CL 334415.

Il ne s'agit que de quelques-uns des principaux points à retenir. Pour en savoir plus, consultez la liste exhaustive des commits.

Nouveautés de WebGPU

Liste de tous les sujets abordés dans la série Nouveautés de WebGPU.

Chrome 153-154

Chrome 151-152

Chrome 149-150

Chrome 147-148

Chrome 146

Chrome 145

Chrome 144

Chrome 143

Chrome 142

Chrome 141

Chrome 140

Chrome 139

Chrome 138

Chrome 137

Chrome 136

Chrome 135

Chrome 134

Chrome 133

Chrome 132

Chrome 131

Chrome 130

Chrome 129

Chrome 128

Chrome 127

Chrome 126

Chrome 125

Chrome 124

Chrome 123

Chrome 122

Chrome 121

Chrome 120

Chrome 119

Chrome 118

Chrome 117

Chrome 116

Chrome 115

Chrome 114

Chrome 113