fix: i % 2 === 0 failing to compile on some GPUs

getType() reported `%` as the left operand's type unless
fixIntegerDivisionAccuracy was set, but `%` never lowers to an integer
operation: both GLSL helpers behind it (modulo, integerCorrectionModulo)
return float, and on cpu it stays a JS `%`. Typing `i % 2` as Integer
therefore emitted a float/int comparison, which GLSL rejects:

  '==' : no operation '==' exists that takes a left-hand operand of type
  'lowp float' and a right operand of type 'const int'

Return Number for `%` regardless of the flag. `/` is untouched: with the
flag off it stays an integer division in GLSL, so the operand type is
right there.

fixIntegerDivisionAccuracy is derived from GPU features, so this only
broke on hardware whose integer division is already accurate — desktop
Chrome/Firefox/Edge on Windows, but never headless-gl or Apple GPUs,
which is why the suite never caught it. The new tests pin both states
explicitly rather than relying on the host's features, and cover the
comparison, index and fractional-operand positions.

Verified on 9 BrowserStack targets, all green; mac node suite unchanged
at its 12 known failures.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

Author: fuzzie360

dist/gpu-browser-core.js

@@ -5,7 +5,7 @@
  * GPU Accelerated JavaScript
  *
  * @version 2.19.7
- * @date Sun Jul 26 2026 23:59:37 GMT+0800 (Singapore Standard Time)
+ * @date Mon Jul 27 2026 00:05:27 GMT+0800 (Singapore Standard Time)
  *
  * @license MIT
  * The MIT License
@@ -2635,6 +2635,7 @@ class FunctionNode {
       case 'BinaryExpression':
         switch (ast.operator) {
           case '%':
+            return 'Number';
           case '/':
             if (this.fixIntegerDivisionAccuracy) {
               return 'Number';

dist/gpu-browser-core.min.js

@@ -5,7 +5,7 @@
  * GPU Accelerated JavaScript
  *
  * @version 2.19.7
- * @date Sun Jul 26 2026 23:59:37 GMT+0800 (Singapore Standard Time)
+ * @date Mon Jul 27 2026 00:05:27 GMT+0800 (Singapore Standard Time)
  *
  * @license MIT
  * The MIT License
@@ -8089,6 +8089,7 @@ class FunctionNode {
       case 'BinaryExpression':
         switch (ast.operator) {
           case '%':
+            return 'Number';
           case '/':
             if (this.fixIntegerDivisionAccuracy) {
               return 'Number';

dist/gpu-browser.js

@@ -482,9 +482,14 @@ class FunctionNode {
       case 'LogicalExpression':
         return 'Boolean';
       case 'BinaryExpression':
-        // modulos is Number
         switch (ast.operator) {
           case '%':
+            // `%` never yields an Integer, whatever its operands are: both GLSL
+            // helpers it lowers to (modulo, integerCorrectionModulo) return
+            // float, and on cpu it stays a JS `%`, which is fractional too.
+            // Reporting the left operand's type here made `i % 2 === 0` emit a
+            // float/int comparison that GLSL refuses to compile.
+            return 'Number';
           case '/':
             if (this.fixIntegerDivisionAccuracy) {
               return 'Number';

dist/gpu-browser.min.js

@@ -126,6 +126,7 @@
 <script type="module" src="features/legacy-encoder.js"></script>
 <script type="module" src="features/loops.js"></script>
 <script type="module" src="features/math-object.js"></script>
+<script type="module" src="features/modulo-comparison.js"></script>
 <script type="module" src="features/nested-function.js"></script>
 <script type="module" src="features/offscreen-canvas.js"></script>
 <script type="module" src="features/optimize-float-memory.js"></script>

src/backend/function-node.js

@@ -189,6 +189,22 @@ <h1>GPU.JS smoke test</h1>
         assertClose(kernel()[0], 5, 'loop total');
       });
 
+      test(label('modulo in a comparison'), function (track) {
+        const gpu = track(new GPU({ mode: mode }));
+        // used to fail to compile wherever fixIntegerDivisionAccuracy is off,
+        // since `%` was typed Integer but lowers to a float-returning helper
+        const kernel = gpu.createKernel(function () {
+          let total = 0;
+          for (let i = 0; i < 10; i++) {
+            if (i % 2 === 0) {
+              total += i;
+            }
+          }
+          return total;
+        }, { output: [1] });
+        assertClose(kernel()[0], 20, 'even sum');
+      });
+
       test(label('modulo and division'), function (track) {
         const gpu = track(new GPU({ mode: mode }));
         const kernel = gpu.createKernel(function (a) {

test/all.html

@@ -0,0 +1,101 @@
+const { assert, skip, test, module: describe } = require('qunit');
+const { GPU } = require('../../src');
+
+describe('feature: modulo comparison');
+
+// `%` lowers to a float-returning GLSL helper, but getType() used to report the
+// left operand's type when fixIntegerDivisionAccuracy was off, so `i % 2 === 0`
+// compiled to a float/int comparison and the shader was rejected outright:
+//   '==' : no operation '==' exists that takes a left-hand operand of type
+//   'lowp float' and a right operand of type 'const int'
+// The flag is derived from GPU features, so the break only showed on hardware
+// where integer division is already accurate — desktop Chrome/Firefox on
+// Windows, but not headless-gl or Apple GPUs. Both states are pinned here.
+function testModuloEquality(mode, fixIntegerDivisionAccuracy) {
+  const gpu = new GPU({ mode });
+  const kernel = gpu.createKernel(function () {
+    let total = 0;
+    for (let i = 0; i < 10; i++) {
+      if (i % 2 === 0) {
+        total += i;
+      }
+    }
+    return total;
+  }, { output: [1], fixIntegerDivisionAccuracy });
+  // 0 + 2 + 4 + 6 + 8
+  assert.equal(kernel()[0], 20);
+  gpu.destroy();
+}
+
+function testModuloInequality(mode, fixIntegerDivisionAccuracy) {
+  const gpu = new GPU({ mode });
+  const kernel = gpu.createKernel(function () {
+    let total = 0;
+    for (let i = 0; i < 6; i++) {
+      if (i % 3 !== 0) {
+        total += 1;
+      }
+    }
+    return total;
+  }, { output: [1], fixIntegerDivisionAccuracy });
+  // 1, 2, 4, 5
+  assert.equal(kernel()[0], 4);
+  gpu.destroy();
+}
+
+function testModuloAsIndex(mode, fixIntegerDivisionAccuracy) {
+  const gpu = new GPU({ mode });
+  const kernel = gpu.createKernel(function (a) {
+    return a[this.thread.x % 3];
+  }, { output: [4], fixIntegerDivisionAccuracy });
+  assert.deepEqual(Array.from(kernel([10, 20, 30, 40])), [10, 20, 30, 10]);
+  gpu.destroy();
+}
+
+function testModuloKeepsFraction(mode, fixIntegerDivisionAccuracy) {
+  const gpu = new GPU({ mode });
+  const kernel = gpu.createKernel(function (a) {
+    return a[this.thread.x] % 2.5;
+  }, { output: [4], fixIntegerDivisionAccuracy });
+  const result = Array.from(kernel([1, 3, 6, 9]));
+  [1, 0.5, 1, 1.5].forEach((expected, i) => {
+    assert.ok(Math.abs(result[i] - expected) < 0.01, `index ${i}: expected ${expected}, got ${result[i]}`);
+  });
+  gpu.destroy();
+}
+
+const scenarios = {
+  'modulo equality': testModuloEquality,
+  'modulo inequality': testModuloInequality,
+  'modulo as index': testModuloAsIndex,
+  'modulo keeps fraction': testModuloKeepsFraction,
+};
+
+const modes = {
+  auto: undefined,
+  gpu: 'gpu',
+  webgl: 'webgl',
+  webgl2: 'webgl2',
+  headlessgl: 'headlessgl',
+  cpu: 'cpu',
+};
+
+const supported = {
+  auto: GPU.isGPUSupported,
+  gpu: GPU.isGPUSupported,
+  webgl: GPU.isWebGLSupported,
+  webgl2: GPU.isWebGL2Supported,
+  headlessgl: GPU.isHeadlessGLSupported,
+  cpu: true,
+};
+
+Object.keys(scenarios).forEach(scenario => {
+  Object.keys(modes).forEach(modeName => {
+    [false, true].forEach(fix => {
+      const run = supported[modeName] ? test : skip;
+      run(`${scenario} ${modeName} fixIntegerDivisionAccuracy=${fix}`, () => {
+        scenarios[scenario](modes[modeName], fix);
+      });
+    });
+  });
+});