W3C

– DRAFT –
WebML WG Teleconference – 24 September 2026

24 September 2026

Attendees

Present
Anssi_Kostiainen, Bryan_Bernhart, Dwayne_Robinson, Ehsan_Toreini, Markus_Tavenrath, Ningxin_Hu, Rafael_Cintron, Reilly_Grant
Regrets
-
Chair
Anssi
Scribe
Anssi, anssik

Meeting minutes

Web Neural Network API

Repository: webmachinelearning/webnn

WebNN-WebGPU interop v2 features

Anssi: initial WebNN-WebGPU interop feature was merged in PR #942

<gb> MERGED PR 942 Add initial WebNN-WebGPU Interop specification (by bbernhar)

Anssi: as discussed last time, we'll enhance this base with v2 features
… first v2 proposal is zero-copy hints, issue #941

<gb> Issue 941 WebNN/WebGPU zero-copy device selection (by bbernhar) [webgpu interop] [Agenda+]

Anssi: we had emerging consensus last time to use the interopDevice option as in createContext({ interopDevice: gpuDevice })
… I see support from Reilly, Bryan and MikeW
… any concerns in resolving to advance with this approach?

Bryan: we wanted to allow use the same dedicated GPU for interop, an improvement from the prior state
… Reilly's proposal is good

Anssi: any implementation plans?

Bryan: there's a plan, multi-adapter not fully fleshed out in WebGPU-land, so we have a dependency on that

MarkusT: would WebGPU [inaudible] device selection?

MarkusT: I will review the issue and come back to it next week

Anssi: MarkusT will share feedback by our next meeting in the issue

Anssi: second v2 proposal, MLTensor export custom usages & flags issue #954

<gb> Issue 954 MLTensor export to GPUBuffer with custom usages? (by mwyrzykowski) [webgpu interop] [Agenda+]

Anssi: Dwayne's flag usage was recast on the Mike's proposed approach

Dwayne: I think that Bryan's latest comment makes sense, just using GPUBufferUsageFlags

Bryan: do we want WebNN usage to match, two different approaches, strongly typed and in WebGPU a different approach

Dwayne: question, any WebGPU flags that would not make sense to inherit?

Reilly: I through are there any flags, because need to allocate to NPU, GPU flags that could't be used to create a GPU buffer out of that buffer

Anssi: notes Dwayne's +1

Reilly: I'm not familiar enough with WebGPU to answer that, an area to look into as we prototype this feature

Bryan: if you create mappable GPU buffer, don't want to always apply that, GPU bandwidth consideration, prefer minimal set of flags
… explicit usages are useful and avoid implicit behavior that requires additional copies

Reilly: exported tensor has less of those than GPU buffer, you already have read tensor and send data to GPU

Bryan: we found mappable buffers useful without interop also, a questions if a developer want to use mappable memory, is interop path mandatory?

Reilly: why you want mappable buffers

Bryan: write and read buffer semantically asks to pass a copy
… workloads that do a lot of initialization can spare that, rather than create a JS buffer or array buffer, also UMA optimization at your disposal
… readback has no dependencies, write implicitly says I want a copy, APIs not great at mapped rights, WebGPU has mapAsync and map APIs separately for this purpose
… do we want to support mapping, GPU usages can be applied when they make sense, maybe in non-interop scenarios too

Reilly: should we have a map on map capability in MLTensor API, obviously we can prototype the benefits to see if it is a thing to add to WebNN directly without going through WebGPU
… there are systems that jump through WebGPU for a buffer that does not exists

Accumulation precision

Anssi: issue #948

<gb> Issue 948 Accumulation precision is unspecified for matmul/gemm and reduction operations (by mtavenrath) [Agenda+]

Anssi: MarkusT wanted to follow up on this issue we discussed last time on our Aug meeting

https://www.w3.org/2026/08/27-webmachinelearning-minutes.html#c2ec

Anssi: two solutions were proposed:
… A) explicit upcast
… B) explicit accumulator type per operation
… Ningxin had a question if we emulate option B
… MarkusT responded that this should be minimum accumulator types, no need to emulate

MarkusT: upcast is what ONNX does by default, I don't like approach A because it requires transmitting the graph to WebNN
… option B, gives default and specifies precision per op
… I initially wrote this in a way we can support certain number of bits for exponent and mantissa
… for example, if we expose precision on NVIDIA hardware, get 32 exponent and only a few bits for mantissa

MarkusT: approach B in #948 reflects my current recommendation on how to address this issue, comments?

Reilly: I see a parallel between this and quantization
… for WebNN, we chose to follow the model of frameworks like ONNX RT with explicitly quantized ops, and dequantized after
… cf. LiteRT with this built-in
… if you combine this with accumulator type being explicit, you could have quantization attached to tensors

<DwayneR> If B, then I'd rather have any accumulator MLDataType exposed publicly as enums than passing raw bit counts for mantissa.

Reilly: most explicit way to express for each value
… agree with Dwayne's comment above, all data types should be well defined
… passing explicit mantissa makes an assumption it is floating point that no each operator wants

MarkusT: I read this you are saying option B and enhancing quantization?
… and backends do upcast as required?
… Reilly, do you agree with option B?

Reilly: I agree with option B but it raises questions around how we represent quantization
… given the quantization design, I wonder whether we lose expressive power by using that design, and what we lose to just use upcast for accumulator precision
… question to MarkusT, in TensorRT, I assume there's some compiler optimization pass that happens where the cast is moved inside the op?
… accumulator only affected, not the precision of the in-memory tensors?

MarkusT: correct
… I think operator casting is not so nice design

Reilly: I appreciate the specificity of approach B, and generalizability of specifying just precision bits
… only question is, if we choose approach B, should consider the same design for quantized tensors

Dwayne: option B would cascade through the whole API
… for quantization, if we bundle that to every MLTensor this can become complicated

Reilly: quantization information in the tensor makes data types checks more complicated
… we can define it in WebNN, quantization tensor passed to operator not supporting operation on such tensor, every operator can operate on quantized data
… quantizations only make sense on float value, so implicitly those won't take quantization values
… those ops don't take floats, 16, 32, others
… this implementation complexity is in implementation already, due to fusing, e,.g. in LiteRT we have quantized tensors, and similarly ONNX has code to do the same in reverse when we see quantized operators
… adds complexity to API but minimal implementation complexity increase
… e.g. in matMul, specify both accumulator precision and preferred output quantization, those end up on the operator, not sure if that'd be a bad thing, makes things explicit

MarkusT: I don't think we need to add this information every op, e.g. min/max, only to those that reduce values in the end

Reilly: memory movement ops would be defined passing thought any data type they get

MarkusT: gemm and convolutions most affected, other option to state this globally
… in TensorRT, fp32 gemms drop some bits from internal floats to get faster maths

Ningxin: a question regarding discoverability, two parts, i) implementability, the proposal is to add accumulator type to each op that support this
… per the table this is not per op granularity, rather a global type
… ii) developer's perspective, developer checks accummulator type and it is not supported, what to do, use cast instead?

MarkusT: for (ii) if not supported and developer uses cast, can we do the same thing that the Chromium backend does?
… depending on the backend, either upcast or pass the accumulator type to the underlying implementation

MarkusT: developer can specify the desired accumulator type, implementation detail how this is applied
… we don't define accumulator type at all, if the developer wants to go higher, need to upcast
… don't force the developer to use upcast, but allow use an appropriate accumulator type

Ningxin: question about discoverability

Ningxin: if the backend is browser can always do casting

MarkusT: a different explicit way, instead of upcast to float32

MarkusT: if no objection, can do a detailed explainer for approach B to address feedback

<ningxin> +1

RESOLUTION: Create an explainer for accumulator precision based on approach B that addresses feedback from the group. (issue #948)

<ningxin> are we ready to merge the dynamic shape PR?

Dynamic shapes

Anssi: issue #883

<gb> Issue 883 Support flexible input sizes (by huningxin) [feature request] [operator specific]

Anssi: this meeting was the last call for comments
… thank you Dwayne for your final review and suggestions for humanization of the text
… it really shows the value of a human review
… my expectation is all contributors will conduct a human review before submitting to catch word salad issues but for non-English speakers this might be particularly challenging, so appreciate native speakers' help
… after Dwayne's final review comments are addressed, the editors can merge this PR
… thank you Miao for swift handling of the review comments

<ningxin> +1

RESOLUTION: The group will merge the Dynamic Shape Explainer PR after addressing final review comments and proceeds to implementation experience and spec PR phase next. (issue #883)

TPAC WIP agenda

<gb> Issue 39 WebML WG/CG F2F Agenda - TPAC 2026 (Dublin, Ireland) (by anssiko)

Summary of resolutions

  1. Create an explainer for accumulator precision based on approach B that addresses feedback from the group. (issue #948)
  2. The group will merge the Dynamic Shape Explainer PR after addressing final review comments and proceeds to implementation experience and spec PR phase next. (issue #883)
Minutes manually created (not a transcript), formatted by scribe.perl version 248 (Mon Oct 27 20:04:16 2025 UTC).

Diagnostics

Succeeded: s/those buffers/mappable buffers

Succeeded: s/kills/drop

Succeeded: s/Reilly proposal/Reilly's proposal

Succeeded: s/two different approach/two different approaches

Succeeded: s/through/thought

Succeeded: s/no no/no

Succeeded: s/like A/like approach A

Succeeded: s/give default and specify/gives default and specifies

Succeeded: s/is raises/it raises

Succeeded: s/can become/this can become

Succeeded: s/into the/in the

Maybe present: Anssi, Bryan, Dwayne, MarkusT, Ningxin, Reilly

All speakers: Anssi, Bryan, Dwayne, MarkusT, Ningxin, Reilly

Active on IRC: anssik, DwayneR, ningxin, reillyg