NativeDawn plugin

.github/workflows/build-android.yml

@@ -9,6 +9,10 @@ on:
       js-engine:
         required: true
         type: string
+      nativedawn:
+        required: false
+        type: boolean
+        default: false
 
 env:
   NDK_VERSION: '28.2.13676358'
@@ -40,6 +44,7 @@ jobs:
           fi
 
       - name: Build Playground ${{ inputs.js-engine }}
+        if: ${{ !inputs.nativedawn }}
         working-directory: Apps/Playground/Android
         run: |
           chmod +x gradlew
@@ -48,3 +53,20 @@ jobs:
             -PARM64Only \
             -PNDK_VERSION=${{ env.NDK_VERSION }} \
             -PSANITIZERS=OFF
+
+      # NativeDawn (WebGPU/Dawn, Vulkan backend) build: enabling the plugin
+      # force-disables NativeEngine. The Android app native lib has no Dawn code
+      # path, so build only the NativeDawn plugin target (via the -PNativeDawn
+      # gradle property, which also restricts the CMake `targets`) to validate it
+      # compiles/links; the full APK is not assembled.
+      - name: Build NativeDawn ${{ inputs.js-engine }}
+        if: ${{ inputs.nativedawn }}
+        working-directory: Apps/Playground/Android
+        run: |
+          chmod +x gradlew
+          ./gradlew :BabylonNative:externalNativeBuildRelease \
+            -PJSEngine=${{ inputs.js-engine }} \
+            -PARM64Only \
+            -PNDK_VERSION=${{ env.NDK_VERSION }} \
+            -PSANITIZERS=OFF \
+            -PNativeDawn=ON

.github/workflows/build-ios.yml

@@ -14,6 +14,10 @@ on:
         required: false
         type: string
         default: macos-latest
+      nativedawn:
+        required: false
+        type: boolean
+        default: false
 
 # Absorb transient npm registry / CDN flakes during `npm install` in Apps/CMakeLists.txt.
 # npm's default fetch-retries is 2; bump to 5 (npm's own exponential backoff handles spacing).
@@ -32,6 +36,7 @@ jobs:
         run: sudo xcode-select --switch /Applications/Xcode_${{ inputs.xcode-version }}.app/Contents/Developer
 
       - name: Generate iOS solution
+        if: ${{ !inputs.nativedawn }}
         run: |
           cmake -G Xcode -B build/iOS \
             -D IOS=ON \
@@ -40,10 +45,35 @@ jobs:
             -D CMAKE_IOS_INSTALL_COMBINED=NO
 
       - name: Build Playground iOS
+        if: ${{ !inputs.nativedawn }}
         run: |
           xcodebuild \
             -project build/iOS/BabylonNative.xcodeproj \
             -scheme Playground \
             -sdk iphoneos \
             -configuration Release \
             CODE_SIGNING_ALLOWED=NO
+
+      # NativeDawn (WebGPU/Dawn, Metal backend) build: enabling the plugin
+      # force-disables NativeEngine. The iOS Playground host has no Dawn code
+      # path, so build the NativeDawn plugin target (plugin + Dawn) to validate it
+      # compiles/links.
+      - name: Generate iOS solution (NativeDawn)
+        if: ${{ inputs.nativedawn }}
+        run: |
+          cmake -G Xcode -B build/iOS \
+            -D IOS=ON \
+            -D DEPLOYMENT_TARGET=${{ inputs.deployment-target }} \
+            -D BABYLON_DEBUG_TRACE=ON \
+            -D CMAKE_IOS_INSTALL_COMBINED=NO \
+            -D BABYLON_NATIVE_PLUGIN_NATIVEDAWN=ON
+
+      - name: Build NativeDawn iOS
+        if: ${{ inputs.nativedawn }}
+        run: |
+          xcodebuild \
+            -project build/iOS/BabylonNative.xcodeproj \
+            -scheme NativeDawn \
+            -sdk iphoneos \
+            -configuration Release \
+            CODE_SIGNING_ALLOWED=NO

.github/workflows/build-linux.yml

@@ -16,6 +16,10 @@ on:
         required: false
         type: boolean
         default: false
+      nativedawn:
+        required: false
+        type: boolean
+        default: false
 
 env:
   UBSAN_OPTIONS: halt_on_error=1:print_stacktrace=1:symbolize=1
@@ -40,7 +44,12 @@ jobs:
           sudo apt-get update
           sudo apt-get install -y libjavascriptcoregtk-4.1-dev libgl1-mesa-dev libcurl4-openssl-dev libwayland-dev clang ninja-build
 
+      - name: Install Vulkan packages (NativeDawn)
+        if: ${{ inputs.nativedawn }}
+        run: sudo apt-get install -y libvulkan-dev libx11-xcb-dev
+
       - name: Build X11
+        if: ${{ !inputs.nativedawn }}
         run: |
           cmake -G Ninja -B build/Linux \
             -D JAVASCRIPTCORE_LIBRARY=/usr/lib/x86_64-linux-gnu/libjavascriptcoregtk-4.1.so \
@@ -53,30 +62,50 @@ jobs:
             -D ENABLE_SANITIZERS=${{ inputs.enable-sanitizers && 'ON' || 'OFF' }} .
           ninja -C build/Linux
 
+      # NativeDawn (WebGPU/Dawn, Vulkan backend) build: enabling the plugin
+      # force-disables NativeEngine. The Linux Playground host has no Dawn code
+      # path, so build the NativeDawn plugin target (plugin + Dawn) to validate it
+      # compiles/links; the bgfx validation/unit tests don't apply.
+      - name: Build NativeDawn
+        if: ${{ inputs.nativedawn }}
+        run: |
+          cmake -G Ninja -B build/Linux \
+            -D JAVASCRIPTCORE_LIBRARY=/usr/lib/x86_64-linux-gnu/libjavascriptcoregtk-4.1.so \
+            -D NAPI_JAVASCRIPT_ENGINE=${{ inputs.js-engine }} \
+            -D CMAKE_BUILD_TYPE=RelWithDebInfo \
+            -D BX_CONFIG_DEBUG=ON \
+            -D OpenGL_GL_PREFERENCE=GLVND \
+            -D BABYLON_DEBUG_TRACE=ON \
+            -D BABYLON_NATIVE_PLUGIN_NATIVEDAWN=ON .
+          ninja -C build/Linux NativeDawn
+
       - name: Enable Core Dump
+        if: ${{ !inputs.nativedawn }}
         run: sudo sysctl -w kernel.core_pattern=core.%p
 
       - name: Validation Tests
+        if: ${{ !inputs.nativedawn }}
         run: |
           cd build/Linux/Apps/Playground
           ulimit -c unlimited
           xvfb-run ./Playground app:///Scripts/validation_native.js
 
       - name: Unit Tests
+        if: ${{ !inputs.nativedawn }}
         run: |
           cd build/Linux/Apps/UnitTests
           ulimit -c unlimited
           xvfb-run ./UnitTests
 
       - name: Module Load Test
-        if: ${{ !inputs.enable-sanitizers }}
+        if: ${{ !inputs.enable-sanitizers && !inputs.nativedawn }}
         run: |
           cd build/Linux/Apps/ModuleLoadTest
           ulimit -c unlimited
           xvfb-run ./ModuleLoadTest
 
       - name: Upload Rendered Pictures
-        if: always()
+        if: ${{ always() && !inputs.nativedawn }}
         uses: actions/upload-artifact@v6
         with:
           name: ${{ inputs.cc }}-${{ inputs.js-engine }}${{ inputs.enable-sanitizers && '-sanitizer' || '' }}-rendered-pictures

.github/workflows/build-macos.yml

@@ -23,6 +23,10 @@ on:
         required: false
         type: string
         default: ''
+      nativedawn:
+        required: false
+        type: boolean
+        default: false
 
 env:
   UBSAN_OPTIONS: halt_on_error=1:print_stacktrace=1:symbolize=1
@@ -43,6 +47,7 @@ jobs:
         run: sudo xcode-select --switch /Applications/Xcode_${{ inputs.xcode-version }}.app/Contents/Developer
 
       - name: Generate macOS solution
+        if: ${{ !inputs.nativedawn }}
         run: |
           cmake -G "${{ inputs.generator }}" -B build/macOS \
             ${{ inputs.js-engine != '' && format('-D NAPI_JAVASCRIPT_ENGINE={0}', inputs.js-engine) || '' }} \
@@ -51,25 +56,42 @@ jobs:
             -D BABYLON_NATIVE_TESTS_USE_NOOP_METAL_DEVICE=ON
 
       - name: Build Playground macOS
+        if: ${{ !inputs.nativedawn }}
         run: cmake --build build/macOS --target Playground --config RelWithDebInfo
 
       - name: Build UnitTests macOS
+        if: ${{ !inputs.nativedawn }}
         run: cmake --build build/macOS --target UnitTests --config RelWithDebInfo
 
       - name: Build ModuleLoadTest macOS
+        if: ${{ !inputs.nativedawn }}
         run: cmake --build build/macOS --target ModuleLoadTest --config RelWithDebInfo
 
+      # NativeDawn (WebGPU/Dawn, Metal backend) build: enabling the plugin
+      # force-disables NativeEngine. The macOS Playground host has no Dawn code
+      # path, so build the NativeDawn plugin target (plugin + Dawn) to validate it
+      # compiles/links; the bgfx unit tests don't apply.
+      - name: Build NativeDawn macOS
+        if: ${{ inputs.nativedawn }}
+        run: |
+          cmake -G "${{ inputs.generator }}" -B build/macOS \
+            -D BABYLON_DEBUG_TRACE=ON \
+            -D BABYLON_NATIVE_PLUGIN_NATIVEDAWN=ON
+          cmake --build build/macOS --target NativeDawn --config RelWithDebInfo
+
       - name: Enable Core Dump
+        if: ${{ !inputs.nativedawn }}
         run: sudo sysctl -w kern.corefile=%N.core.%P
 
       - name: Run UnitTests macOS
+        if: ${{ !inputs.nativedawn }}
         run: |
           cd build/macOS/Apps/UnitTests/RelWithDebInfo
           ulimit -c unlimited
           ./UnitTests
 
       - name: Run ModuleLoadTest macOS
-        if: ${{ !inputs.enable-sanitizers }}
+        if: ${{ !inputs.enable-sanitizers && !inputs.nativedawn }}
         run: |
           cd build/macOS/Apps/ModuleLoadTest/RelWithDebInfo
           ulimit -c unlimited

.github/workflows/build-win32.yml

@@ -18,6 +18,10 @@ on:
         required: false
         type: boolean
         default: false
+      nativedawn:
+        required: false
+        type: boolean
+        default: false
 
 # Absorb transient npm registry / CDN flakes during `npm install` in Apps/CMakeLists.txt.
 # npm's default fetch-retries is 2; bump to 5 (npm's own exponential backoff handles spacing).
@@ -55,6 +59,16 @@ jobs:
           echo "js_define=$JS_DEFINE" >> "$GITHUB_OUTPUT"
           echo "solution_name=Win32_${{ inputs.platform }}${SUFFIX}" >> "$GITHUB_OUTPUT"
           echo "sanitizer_flag=${{ inputs.enable-sanitizers && 'ON' || 'OFF' }}" >> "$GITHUB_OUTPUT"
+          # NativeDawn (WebGPU/Dawn) build: enable the plugin (which force-disables
+          # NativeEngine) and build only the Playground target, since the
+          # bgfx-based validation/unit/module tests don't apply to this backend.
+          if [ "${{ inputs.nativedawn }}" = "true" ]; then
+            echo "dawn_flag=-D BABYLON_NATIVE_PLUGIN_NATIVEDAWN=ON" >> "$GITHUB_OUTPUT"
+            echo "build_target=--target Playground" >> "$GITHUB_OUTPUT"
+          else
+            echo "dawn_flag=" >> "$GITHUB_OUTPUT"
+            echo "build_target=" >> "$GITHUB_OUTPUT"
+          fi
 
       - name: Generate solution
         shell: cmd
@@ -63,6 +77,7 @@ jobs:
             -B build/${{ steps.vars.outputs.solution_name }} ^
             -A ${{ inputs.platform }} ^
             ${{ steps.vars.outputs.js_define }} ^
+            ${{ steps.vars.outputs.dawn_flag }} ^
             -D BX_CONFIG_DEBUG=ON ^
             -D GRAPHICS_API=${{ inputs.graphics-api }} ^
             -D BGFX_CONFIG_MAX_FRAME_BUFFERS=256 ^
@@ -72,7 +87,7 @@ jobs:
       - name: Build
         shell: cmd
         run: |
-          cmake --build build/${{ steps.vars.outputs.solution_name }} --config RelWithDebInfo -- /m
+          cmake --build build/${{ steps.vars.outputs.solution_name }} --config RelWithDebInfo ${{ steps.vars.outputs.build_target }} -- /m
 
       - name: Enable Crash Dumps
         shell: cmd
@@ -104,14 +119,14 @@ jobs:
           )
 
       - name: Validation Tests
-        if: ${{ inputs.graphics-api != 'D3D12' }}
+        if: ${{ inputs.graphics-api != 'D3D12' && !inputs.nativedawn }}
         shell: cmd
         run: |
           cd build\${{ steps.vars.outputs.solution_name }}\Apps\Playground\RelWithDebInfo
           Playground app:///Scripts/validation_native.js
 
       - name: Upload Rendered Pictures
-        if: ${{ inputs.graphics-api != 'D3D12' && !cancelled() }}
+        if: ${{ inputs.graphics-api != 'D3D12' && !inputs.nativedawn && !cancelled() }}
         uses: actions/upload-artifact@v6
         with:
           name: ${{ steps.vars.outputs.solution_name }}-${{ inputs.graphics-api }}${{ inputs.enable-sanitizers && '-sanitizer' || '' }}-rendered-pictures
@@ -134,14 +149,14 @@ jobs:
           Copy-Item -Path "build\${{ steps.vars.outputs.solution_name }}\Apps\Playground\RelWithDebInfo\Playground.*" -Destination "$env:RUNNER_TEMP\Dumps\" -ErrorAction SilentlyContinue
 
       - name: Unit Tests
-        if: ${{ inputs.graphics-api != 'D3D12' }}
+        if: ${{ inputs.graphics-api != 'D3D12' && !inputs.nativedawn }}
         shell: cmd
         run: |
           cd build\${{ steps.vars.outputs.solution_name }}\Apps\UnitTests\RelWithDebInfo
           UnitTests
 
       - name: Module Load Test
-        if: ${{ !inputs.enable-sanitizers }}
+        if: ${{ !inputs.enable-sanitizers && !inputs.nativedawn }}
         shell: cmd
         run: |
           cd build\${{ steps.vars.outputs.solution_name }}\Apps\ModuleLoadTest\RelWithDebInfo

.github/workflows/ci.yml

@@ -198,3 +198,44 @@ jobs:
 
   Win32_Installation:
     uses: ./.github/workflows/test-install-win32.yml
+
+  # ── NativeDawn (WebGPU / Dawn backend, replaces NativeEngine) ──
+  # These build with BABYLON_NATIVE_PLUGIN_NATIVEDAWN=ON, which force-disables
+  # NativeEngine. Dawn is fetched (git) only for these jobs. Win32 builds the
+  # full WebGPU Playground; the other platforms build the NativeDawn plugin
+  # target (plugin + Dawn) since only the Win32 host has a Dawn code path.
+  Win32_x64_NativeDawn:
+    uses: ./.github/workflows/build-win32.yml
+    with:
+      platform: x64
+      nativedawn: true
+
+  MacOS_NativeDawn:
+    uses: ./.github/workflows/build-macos.yml
+    with:
+      runs-on: macos-26
+      xcode-version: "26.4"
+      nativedawn: true
+
+  iOS_NativeDawn:
+    uses: ./.github/workflows/build-ios.yml
+    with:
+      runs-on: macos-26
+      xcode-version: "26.4"
+      deployment-target: '18.0'
+      nativedawn: true
+
+  Ubuntu_NativeDawn:
+    uses: ./.github/workflows/build-linux.yml
+    with:
+      cc: clang
+      cxx: clang++
+      js-engine: JavaScriptCore
+      nativedawn: true
+
+  Android_NativeDawn:
+    uses: ./.github/workflows/build-android.yml
+    with:
+      runs-on: ubuntu-latest
+      js-engine: V8
+      nativedawn: true

Apps/Playground/Android/BabylonNative/build.gradle

@@ -37,6 +37,15 @@ if (project.hasProperty("importHostCompilers")) {
     cmakeArguments.add("-DIMPORT_HOST_COMPILERS=${project.property('importHostCompilers')}")
 }
 
+// NativeDawn (WebGPU/Dawn, Vulkan backend) build: enabling the plugin
+// force-disables NativeEngine. The Android app native lib has no Dawn code
+// path, so restrict the CMake build to the NativeDawn plugin target (see the
+// `targets` call below) to validate it compiles/links.
+def nativeDawn = project.hasProperty("NativeDawn") && project.property("NativeDawn") == "ON"
+if (nativeDawn) {
+    cmakeArguments.add("-DBABYLON_NATIVE_PLUGIN_NATIVEDAWN=ON")
+}
+
 configurations { natives }
 
 android {
@@ -56,6 +65,9 @@ android {
             cmake {
                 abiFilters "arm64-v8a", "armeabi-v7a", "x86", "x86_64"
                 arguments(*cmakeArguments)
+                if (nativeDawn) {
+                    targets "NativeDawn"
+                }
                 cppFlags += ["-Wno-deprecated-literal-operator"]
             }
         }