usearch 2.26.1 → 2.26.2

package/README.md

@@ -549,7 +549,7 @@ doi = {10.5281/zenodo.7949415},
 author = {Vardanian, Ash},
 title = {{USearch by Unum Cloud}},
 url = {https://github.com/unum-cloud/USearch},
-version = {2.26.1},
+version = {2.26.2},
 year = {2026},
 }
 ```

package/include/usearch/index.hpp

@@ -9,7 +9,7 @@
 
 #define USEARCH_VERSION_MAJOR 2
 #define USEARCH_VERSION_MINOR 26
-#define USEARCH_VERSION_PATCH 1
+#define USEARCH_VERSION_PATCH 2
 
 // Inferring C++ version
 // https://stackoverflow.com/a/61552074
@@ -2084,6 +2084,10 @@ class memory_mapped_file_t {
 
 #if defined(USEARCH_DEFINED_LINUX)
         int descriptor = open(path_, O_RDONLY | O_NOATIME);
+        if (descriptor < 0 && errno == EPERM)
+            // `O_NOATIME` requires owning the file or holding `CAP_FOWNER` (see `open(2)`).
+            // Retry without it instead of failing outright.
+            descriptor = open(path_, O_RDONLY);
 #else
         int descriptor = open(path_, O_RDONLY);
 #endif

package/numkong/CITATION.cff

@@ -3,18 +3,22 @@ title: "NumKong: 2000 Mixed Precision Kernels For All"
 message: "If you use this software, please cite it as below."
 type: software
 license: Apache-2.0
-version: 7.6.0
+version: 7.8.1
 repository-code: https://github.com/ashvardanian/NumKong
 url: https://ashvardanian.com/posts/numkong/
+doi: 10.5281/zenodo.21480519
+identifiers:
+  - type: doi
+    value: 10.5281/zenodo.21839607
+    description: "v7.8.0 — version DOI"
 abstract: >-
-  Portable mixed-precision math, linear-algebra, & retrieval library
-  with 2'000+ SIMD kernels for x86, Arm, RISC-V, LoongArch, Power, & WebAssembly,
-  leveraging rare algebraic transforms with both 1D & 2D registers like AMX & SME,
-  covering 15+ numeric types from 4-bit integers & 6-bit floats to 128-bit complex numbers,
-  validated against 118-bit extended-precision baselines
-  with saturation, casting, & rounding edge-case coverage,
-  in a 5-100x smaller binary than other BLAS-like alternatives,
-  co-designed with Tensor abstractions in C++, Python, Rust, JavaScript, GoLang, & Swift.
+  Portable mixed-precision math, linear-algebra, & retrieval library with 2'000+ SIMD kernels for
+  x86, Arm, RISC-V, LoongArch, Power, & WebAssembly, leveraging rare algebraic transforms with
+  both 1D & 2D registers like AMX & SME, covering 15+ numeric types from 4-bit integers & 6-bit
+  floats to 128-bit complex numbers, validated against 118-bit extended-precision baselines with
+  saturation, casting, & rounding edge-case coverage, in a 5-100x smaller binary than other
+  BLAS-like alternatives, co-designed with Tensor abstractions in C++, Python, Rust, JavaScript,
+  GoLang, & Swift.
 
 authors:
   - family-names: Vardanian

package/numkong/CONTRIBUTING.md

@@ -32,21 +32,20 @@ build_release/nk_bench
 build_release/nk_test
 ```
 
-| CMake Flag                 | Default            | Description                                            |
-| -------------------------- | ------------------ | ------------------------------------------------------ |
-| `NK_BUILD_TEST`            | `OFF`              | Compile precision tests with ULP error analysis        |
-| `NK_BUILD_BENCH`           | `OFF`              | Compile micro-benchmarks                               |
-| `NK_BUILD_SHARED`          | `ON`, if top-level | Compile dynamic library                                |
-| `NK_BUILD_SHARED_TEST`     | `OFF`              | Compile tests against the shared library               |
-| `NK_COMPARE_TO_BLAS`       | `AUTO`             | Include OpenBLAS into test/bench comparisons           |
-| `NK_COMPARE_TO_ACCELERATE` | `AUTO`             | Include Apple's Accelerate into test/bench comparisons |
-| `NK_COMPARE_TO_MKL`        | `AUTO`             | Include Intel' MKL into test/bench comparisons         |
-| `NK_MARCH_NATIVE`          | `OFF`              | Tune for host CPU with `-march=native`                 |
+| CMake Flag             | Default            | Description                                                                   |
+| ---------------------- | ------------------ | ----------------------------------------------------------------------------- |
+| `NK_BUILD_TEST`        | `OFF`              | Compile precision tests with ULP error analysis                               |
+| `NK_BUILD_BENCH`       | `OFF`              | Compile micro-benchmarks                                                      |
+| `NK_BUILD_SHARED`      | `ON`, if top-level | Compile dynamic library                                                       |
+| `NK_BUILD_SHARED_TEST` | `OFF`              | Compile tests against the shared library                                      |
+| `NK_COMPARE_TO_BLAS`   | `AUTO`             | Include OpenBLAS, or Apple's Accelerate on macOS, into test/bench comparisons |
+| `NK_COMPARE_TO_MKL`    | `AUTO`             | Include Intel' MKL into test/bench comparisons                                |
+| `NK_MARCH_NATIVE`      | `OFF`              | Tune for host CPU with `-march=native`                                        |
 
 ### Target Baseline Policy
 
 `CMakeLists.txt`, `build.rs`, `setup.py`, and `binding.gyp` pin the TU-level baseline to each architecture's ABI floor so distributable artifacts run on any CPU matching the ABI, not just the build host.
-SIMD kernels live inside `#pragma GCC target(...)` regions and are only called after runtime probing — see the README's [Compile-Time and Run-Time Dispatch](../README.md#compile-time-and-run-time-dispatch) section.
+SIMD kernels live inside `#pragma GCC target(...)` regions and are only called after runtime probing — see the README's [Compile-Time and Run-Time Dispatch](README.md#compile-time-and-run-time-dispatch) section.
 
 | Target arch   | GCC/Clang baseline          | MSVC baseline   | Notes                                                       |
 | ------------- | --------------------------- | --------------- | ----------------------------------------------------------- |
@@ -89,19 +88,25 @@ sudo update-alternatives --install /usr/bin/g++ g++ /usr/bin/g++-12 100
 
 ### Cross-Compilation
 
-NumKong ships 8 toolchain files in `cmake/` for cross-compiling to non-native targets.
+NumKong ships 11 toolchain files in `cmake/`, each named `toolchain-<name>.cmake`.
 Tests and benchmarks run transparently under QEMU via `CMAKE_CROSSCOMPILING_EMULATOR`.
-
-| Target                    | Toolchain File                  | Emulator                | Prerequisites                                                                                    |
-| ------------------------- | ------------------------------- | ----------------------- | ------------------------------------------------------------------------------------------------ |
-| ARM64 Linux               | `toolchain-aarch64-gnu.cmake`   | `qemu-aarch64 -cpu max` | `gcc-aarch64-linux-gnu`, `qemu-user`                                                             |
-| RISC-V 64 GCC             | `toolchain-riscv64-gnu.cmake`   | `qemu-riscv64 -cpu max` | [riscv-gnu-toolchain](https://github.com/riscv-collab/riscv-gnu-toolchain/releases), `qemu-user` |
-| RISC-V 64 LLVM            | `toolchain-riscv64-llvm.cmake`  | `qemu-riscv64 -cpu max` | LLVM 17+, `RISCV_SYSROOT`                                                                        |
-| Android ARM64             | `toolchain-android-arm64.cmake` | —                       | `ANDROID_NDK_ROOT`                                                                               |
-| x86_64 from Apple Silicon | `toolchain-x86_64-llvm.cmake`   | `arch -x86_64`          | Homebrew LLVM                                                                                    |
-| WASM Emscripten           | `toolchain-wasm.cmake`          | Node.js                 | Emscripten 3.1.27+                                                                               |
-| WASM64 Memory64           | `toolchain-wasm64.cmake`        | Node.js                 | Emscripten 3.1.35+                                                                               |
-| WASI                      | `toolchain-wasi.cmake`          | Wasmtime / Wasmer       | WASI SDK 24+                                                                                     |
+Targets with a `qemu-*` emulator additionally require `qemu-user`.
+
+| Target                  | Toolchain         | Emulator                    | Prerequisites                  |
+| ----------------------- | ----------------- | --------------------------- | ------------------------------ |
+| ARM64 Linux             | `aarch64-gnu`     | `qemu-aarch64 -cpu max`     | `gcc-aarch64-linux-gnu`        |
+| RISC-V 64 GCC           | `riscv64-gnu`     | `qemu-riscv64 -cpu max`     | [`riscv-gnu-toolchain`][riscv] |
+| RISC-V 64 LLVM          | `riscv64-llvm`    | `qemu-riscv64 -cpu max`     | LLVM 17+, `RISCV_SYSROOT`      |
+| ppc64le Linux           | `ppc64le-gnu`     | `qemu-ppc64le -cpu power9`  | `gcc-powerpc64le-linux-gnu`    |
+| LoongArch 64            | `loongarch64-gnu` | `qemu-loongarch64 -cpu max` | `LOONGARCH_TOOLCHAIN_PATH`     |
+| Android ARM64           | `android-arm64`   | —                           | `ANDROID_NDK_ROOT`             |
+| Android ARMv7           | `android-armv7`   | —                           | `ANDROID_NDK_ROOT`             |
+| x86_64 on Apple Silicon | `x86_64-llvm`     | `arch -x86_64`              | Homebrew LLVM                  |
+| WASM Emscripten         | `wasm`            | Node.js                     | Emscripten 3.1.27+             |
+| WASM64 Memory64         | `wasm64`          | Node.js                     | Emscripten 3.1.35+             |
+| WASI                    | `wasi`            | Wasmtime / Wasmer           | WASI SDK 24+                   |
+
+[riscv]: https://github.com/riscv-collab/riscv-gnu-toolchain/releases
 
 Set `NK_IN_QEMU=1` to relax half-precision accuracy thresholds under emulation.
 
@@ -236,7 +241,7 @@ See [test/README.md](test/README.md) for test framework details and [bench/READM
 Once done editing the code, please run analyzers and formatters:
 
 ```bash
-git ls-files '*.h' '*.c' '*.hpp' '*.cpp' | xargs clang-format -i # Use Clang Format 21 or newer
+git ls-files '*.h' '*.c' '*.hpp' '*.cpp' | xargs clang-format -i # Use Clang Format 22 or newer
 ```
 
 ## Python

package/numkong/Cargo.toml

@@ -19,7 +19,7 @@ name = "numkong"
 readme = "rust/README.md"
 repository = "https://github.com/ashvardanian/NumKong" 
 rust-version = "1.64" # Introduced Core C FFI in stable Rust
-version = "7.6.0" 
+version = "7.8.1" 
 
 [lib]
 name = "numkong"

package/numkong/README.md

@@ -68,12 +68,12 @@ A broader throughput comparison is maintained in [NumWars](https://github.com/as
 | Python   | `pip install`              | Linux, macOS, Windows          | [python/README.md](python/README.md)         |
 | Rust     | `cargo add`                | Linux, macOS, Windows          | [rust/README.md](rust/README.md)             |
 | JS       | `npm install` & `import`   | Node.js, Bun, Deno & browsers  | [javascript/README.md](javascript/README.md) |
-| Swift    | Swift Package Manager      | macOS, iOS, tvOS, watchOS      | [swift/README.md](swift/README.md)           |
+| Swift    | Swift Package Manager      | Apple platforms & Linux        | [swift/README.md](swift/README.md)           |
 | Go       | `go get`                   | Linux, macOS, Windows via cGo  | [golang/README.md](golang/README.md)         |
 
 ## What's Inside
 
-NumKong covers 17 numeric types — from 6-bit floats to 64-bit complex numbers — across dozens of operations and 30+ SIMD backends, with hardware-aware defaults: Arm prioritizes `f16`, x86 prioritizes `bf16`.
+NumKong covers 17 numeric types — from 6-bit floats to 128-bit complex numbers — across dozens of operations and 30+ SIMD backends, with hardware-aware defaults: Arm prioritizes `f16`, x86 prioritizes `bf16`.
 
 ### Language Bindings
 
@@ -215,7 +215,7 @@ The [GIL](https://docs.python.org/3/glossary.html#term-global-interpreter-lock)
 import concurrent.futures, numkong as nk, numpy as np
 
 vectors, num_threads = np.random.randn(1000, 768).astype(np.float32), 4
-output = nk.zeros((1000, 1000), dtype="float32")
+output = nk.zeros((1000, 1000), dtype="float64")
 
 def compute_slice(t):
     start = t * (len(vectors) // num_threads)
@@ -320,7 +320,7 @@ Every such decision — saturation thresholds, Newton-Raphson iteration counts,
 
 ### Calling Convention & Error Handling
 
-NumKong never throws exceptions, never sets `errno`, and never calls `setjmp`/`longjmp` — [exceptions bloat call sites with unwind tables](https://monkeywritescode.blogspot.com/p/c-exceptions-under-hood.html) and are invisible to C, Python, Rust, Swift, Go, and JavaScript FFI; `errno` is thread-local state whose [storage model varies across C runtimes](https://en.cppreference.com/w/c/error/errno).
+NumKong never throws exceptions, never sets `errno`, and never calls `setjmp`/`longjmp` on any kernel path — [exceptions bloat call sites with unwind tables](https://monkeywritescode.blogspot.com/p/c-exceptions-under-hood.html) and are invisible to C, Python, Rust, Swift, Go, and JavaScript FFI; `errno` is thread-local state whose [storage model varies across C runtimes](https://en.cppreference.com/w/c/error/errno).
 Instead, every function takes inputs as `const` pointers, writes outputs through caller-provided pointers, and returns `void`:
 
 ```c
@@ -352,7 +352,7 @@ nk_capability_t used = nk_cap_serial_k;
 nk_find_kernel_punned(
     nk_kernel_angular_k, nk_f32_k,            // what functionality? for which input type?
     nk_capabilities(),                        // which capabilities are viable?
-    (nk_kernel_punned_t *)&angular, &used);   // the kernel found and capabilties used!
+    (nk_kernel_punned_t *)&angular, &used);   // the kernel found and capabilities used!
 ```
 
 The first call to `nk_capabilities()` initializes the dispatch table; all subsequent calls are lock-free.
@@ -489,8 +489,8 @@ On Arm, NEON FHM extensions bring widening `FMLAL` dot-products for Float16 —
 > On NEON+FP8DOT, E3M2 is first promoted to E5M2 and E2M3 to E4M3 before the hardware `FDOT` instruction.
 > Sierra Forest and Alder Lake use native `VPDPBSSD` (signed×signed) and `VPDPBUSD` (unsigned×signed) respectively for E2M3.
 
-E4M3 and E5M2 cannot use the integer path.
-E4M3 scaled by 16 reaches 7,680 — too large for Int8, barely fitting Int16 with a 128-entry table.
+E4M3 and E5M2 cannot use the same 32-entry LUT integer path.
+E4M3 scaled by 16 reaches 7,168 — too large for Int8, barely fitting Int16 with a 128-entry table.
 E5M2's range (±57,344) makes the scaled product exceed Int32 entirely.
 Without the integer path, E5M2 falls back to Float32 accumulation — where its [2-bit mantissa (only 4 values per binade)](https://developer.nvidia.com/blog/floating-point-8-an-introduction-to-efficient-lower-precision-ai-training/) creates a [catastrophic cancellation risk](https://www.ac.uma.es/arith2024/papers/Fused%20FP8%204-Way%20Dot%20Product%20with%20Scaling%20and%20FP32%20Accumulation.pdf) that E2M3's integer path avoids completely:
 
@@ -564,6 +564,20 @@ Beyond the READMEs in this repository, there are several standalone articles cov
 - [Accelerating JavaScript arrays by 10x for Vector Search](https://ashvardanian.com/posts/javascript-ai-vector-search/)
 - [SciPy distances... up to 200x faster with AVX-512 & SVE](https://ashvardanian.com/posts/simsimd-faster-scipy/)
 
+## Citation
+
+If NumKong helps your research or product, please cite it:
+
+```bibtex
+@software{Vardanian_NumKong,
+  author = {Vardanian, Ash},
+  title = {{NumKong: 2000 Mixed Precision Kernels For All}},
+  doi = {10.5281/zenodo.21480519},
+  url = {https://github.com/ashvardanian/NumKong},
+  license = {Apache-2.0}
+}
+```
+
 ## License
 
 Feel free to use the project under Apache 2.0 or the Three-clause BSD license at your preference.

package/numkong/binding.gyp

@@ -1,6 +1,8 @@
 {
     "variables": {
-        "openssl_fips": ""
+        "openssl_fips": "",
+        # `NK_MARCH_NATIVE=1` opts into a host-tuned, non-portable build, as in CMakeLists.txt.
+        "nk_march_native%": "<!(node -p \"['1','true','TRUE'].includes(process.env.NK_MARCH_NATIVE||'')?1:0\")"
     },
     "targets": [
         {
@@ -8,6 +10,7 @@
             "sources": [
                 "javascript/numkong.c",
                 "c/numkong.c",
+                "c/parallel.c",
                 "c/dispatch_f64.c",
                 "c/dispatch_f32.c",
                 "c/dispatch_f16.c",
@@ -34,18 +37,17 @@
                 "c/dispatch_e3m2.c",
             ],
             "include_dirs": [
-                "include"
+                "include",
+                "c"
             ],
             "defines": [
                 "NK_NATIVE_F16=0",
                 "NK_NATIVE_BF16=0",
-                "NK_DYNAMIC_DISPATCH=1",
-                "NK_USE_OPENMP=1"
+                "NK_DYNAMIC_DISPATCH=1"
             ],
             "cflags": [
                 "-std=c11",
                 "-O3",
-                "-fopenmp",
                 "-Wno-unknown-pragmas",
                 "-Wno-maybe-uninitialized",
                 "-Wno-cast-function-type",
@@ -54,25 +56,35 @@
                 "-include",
                 "<(module_root_dir)/nk_probes.h",
             ],
-            "ldflags": [
-                "-fopenmp"
-            ],
             "msvs_settings": {
                 "VCCLCompilerTool": {
                     "ForcedIncludeFiles": [
                         "<(module_root_dir)/nk_probes.h"
                     ],
                     "AdditionalOptions": [
-                        "/Zc:preprocessor",
-                        "/openmp:llvm"
+                        "/Zc:preprocessor"
                     ],
                 },
             },
             "conditions": [
+                # Only this branch gets OpenMP; macOS and Windows use their own pools.
+                [
+                    "OS!='mac' and OS!='win'",
+                    {
+                        "cflags": [
+                            "-fopenmp"
+                        ],
+                        "ldflags": [
+                            "-fopenmp"
+                        ]
+                    }
+                ],
                 # Pin TU baseline to each arch's ABI floor; SIMD kernels use per-function pragmas.
-                # Keep per-arch table in sync with cmake/nk_compiler_flags.cmake, build.rs, setup.py.
+                # Keep per-arch table in sync with CMakeLists.txt, build.rs, setup.py.
+                # macOS is excluded: `-arch` already pins the slice, and a per-arch `-march=`
+                # conflicts with the other slice of a universal build.
                 [
-                    "OS!='win' and target_arch=='arm64'",
+                    "nk_march_native==0 and OS!='win' and OS!='mac' and target_arch=='arm64'",
                     {
                         "cflags": [
                             "-march=armv8-a"
@@ -80,7 +92,7 @@
                     }
                 ],
                 [
-                    "OS!='win' and target_arch=='x64'",
+                    "nk_march_native==0 and OS!='win' and OS!='mac' and target_arch=='x64'",
                     {
                         "cflags": [
                             "-march=x86-64"
@@ -88,7 +100,7 @@
                     }
                 ],
                 [
-                    "OS!='win' and target_arch=='riscv64'",
+                    "nk_march_native==0 and OS!='win' and OS!='mac' and target_arch=='riscv64'",
                     {
                         "cflags": [
                             "-march=rv64gc"
@@ -96,7 +108,7 @@
                     }
                 ],
                 [
-                    "OS!='win' and target_arch=='ppc64'",
+                    "nk_march_native==0 and OS!='win' and OS!='mac' and target_arch=='ppc64'",
                     {
                         "cflags": [
                             "-mcpu=power8"
@@ -104,7 +116,7 @@
                     }
                 ],
                 [
-                    "OS!='win' and target_arch=='loong64'",
+                    "nk_march_native==0 and OS!='win' and OS!='mac' and target_arch=='loong64'",
                     {
                         "cflags": [
                             "-march=loongarch64",
@@ -112,6 +124,14 @@
                         ]
                     }
                 ],
+                [
+                    "nk_march_native==1 and OS!='win' and OS!='mac'",
+                    {
+                        "cflags": [
+                            "-march=native"
+                        ]
+                    }
+                ],
                 # Forbid auto-vectorization so serial fallbacks don't get silently
                 # promoted to NEON/SSE2/VSX. SIMD kernels use explicit intrinsics
                 # and per-function `target` pragmas; unaffected. MSVC has no
@@ -125,27 +145,23 @@
                         ]
                     }
                 ],
+                # gyp ignores `cflags` on the mac flavor, so every flag above must be
+                # repeated here or the addon builds unoptimized and without the probes.
                 [
                     "OS=='mac'",
                     {
                         "xcode_settings": {
                             "MACOSX_DEPLOYMENT_TARGET": "11.0",
-                            # Apple Clang ships no `omp.h`; the CI step
-                            # `brew install libomp` makes it keg-only under
-                            # `/opt/homebrew/opt/libomp` (arm64) or
-                            # `/usr/local/opt/libomp` (x86_64). Clang silently
-                            # ignores `-I` / `-L` dirs that don't exist, so
-                            # listing both keeps the file arch-agnostic.
                             "OTHER_CFLAGS": [
-                                "-Xpreprocessor",
-                                "-fopenmp",
-                                "-I/opt/homebrew/opt/libomp/include",
-                                "-I/usr/local/opt/libomp/include"
-                            ],
-                            "OTHER_LDFLAGS": [
-                                "-lomp",
-                                "-L/opt/homebrew/opt/libomp/lib",
-                                "-L/usr/local/opt/libomp/lib"
+                                "-std=c11",
+                                "-O3",
+                                "-fno-tree-vectorize",
+                                "-fno-tree-slp-vectorize",
+                                "-Wno-unknown-pragmas",
+                                "-Wno-cast-function-type",
+                                "-Wno-switch",
+                                "-include",
+                                "<(module_root_dir)/nk_probes.h"
                             ]
                         }
                     }

package/numkong/build.rs

@@ -376,21 +376,31 @@ fn build_numkong() -> Result<HashMap<String, bool>, String> {
 
     // Pin TU baseline to each arch's ABI floor; SIMD kernels carry per-function pragmas.
     // `NK_MARCH_NATIVE=1` opts into a host-tuned, non-portable build (ignored on MSVC).
-    // Keep per-arch table in sync with cmake/nk_compiler_flags.cmake, setup.py, binding.gyp.
-    let march_native = env::var("NK_MARCH_NATIVE").is_ok_and(|v| v == "1" || v == "true");
+    // Keep per-arch table in sync with CMakeLists.txt, setup.py, binding.gyp.
+    let target_os = env::var("CARGO_CFG_TARGET_OS").unwrap_or_default();
+    let is_apple = target_os == "macos" || target_os == "ios";
+    let is_cross = env::var("HOST").unwrap_or_default() != env::var("TARGET").unwrap_or_default();
+    let march_native = env::var("NK_MARCH_NATIVE").is_ok_and(|v| v == "1" || v == "true" || v == "TRUE");
     // Portable baseline: pin TU ISA floor + forbid auto-vectorization so serial
     // fallbacks don't get silently promoted to NEON/SSE2/VSX. SIMD kernels use
     // explicit intrinsics; unaffected. MSVC has no command-line vectorizer
     // toggle; `NK_MARCH_NATIVE=1` opts out for host-tuned builds.
-    if march_native && !is_msvc {
-        println!("cargo:warning=NK_MARCH_NATIVE=1: building -march=native, result will not run on older CPUs");
-        build.flag_if_supported("-march=native");
+    if march_native && !is_msvc && !is_cross {
+        println!("cargo:warning=NK_MARCH_NATIVE=1: building host-tuned, result will not run on older CPUs");
+        // Apple Clang's `-march=native` advertises only a subset of host features
+        // (no SME/SME2/FP16_FML); `-mcpu=native` is the complete knob on macOS.
+        build.flag_if_supported(if is_apple { "-mcpu=native" } else { "-march=native" });
     } else if is_msvc {
         match target_arch.as_str() {
             "x86_64"  => { build.flag_if_supported("/arch:SSE2"); }
             "aarch64" => { build.flag_if_supported("/arch:armv8.0"); }
             _ => {}
         }
+    } else if is_apple {
+        // `-arch` already pins the ABI floor per slice, and a universal build passes both
+        // to one clang invocation, where a per-arch `-march=` conflicts with the other slice.
+        build.flag_if_supported("-fno-tree-vectorize");
+        build.flag_if_supported("-fno-tree-slp-vectorize");
     } else {
         build.flag_if_supported("-fno-tree-vectorize");
         build.flag_if_supported("-fno-tree-slp-vectorize");

package/numkong/c/dispatch.h

@@ -33,7 +33,6 @@
 extern "C" {
 #endif
 
-// Forward declaration of dispatch table type (same structure as in numkong.c)
 typedef struct {
     // Dot products
     nk_metric_dense_punned_t dot_f64c;

package/numkong/c/parallel.c

@@ -0,0 +1,139 @@
+/**
+ *  @brief Tile-parallel execution for NumKong language bindings.
+ *  @file c/parallel.c
+ *  @author Ash Vardanian
+ *  @date August 6, 2026
+ *
+ *  One shared tile counter drives every backend, so dynamic scheduling and the
+ *  thread-count cap behave identically no matter which pool runs the tiles.
+ */
+#include "parallel.h"
+
+#if defined(__APPLE__)
+#include <dispatch/dispatch.h> // `dispatch_apply_f`, part of libSystem
+#include <unistd.h>            // `sysconf`
+#elif defined(_WIN32)
+#include <windows.h> // `CreateThreadpoolWork`, part of kernel32
+#else
+#include <unistd.h> // `sysconf`
+#if defined(_OPENMP)
+#include <omp.h>
+#endif
+#endif
+
+/*  OpenMP schedules tiles itself, so the counter below is for the other pools. */
+#if !defined(__APPLE__) && !defined(_WIN32) && defined(_OPENMP)
+#define NK_PARALLEL_VIA_OPENMP 1
+#else
+#define NK_PARALLEL_VIA_OPENMP 0
+#endif
+
+#if !NK_PARALLEL_VIA_OPENMP
+
+#pragma region Tile Queue
+
+/** @brief Tiles remaining, plus the body that consumes them. */
+typedef struct nk_tile_queue_t {
+    nk_tile_body_t body;
+    void *context;
+    nk_size_t tile_count;
+#if defined(_MSC_VER)
+    volatile long long next_tile;
+#else
+    nk_size_t next_tile;
+#endif
+} nk_tile_queue_t;
+
+/** @brief Claim and run tiles until the queue is empty. Safe to call from every worker at once. */
+static void nk_tile_queue_drain_(nk_tile_queue_t *queue) {
+    for (;;) {
+#if defined(_MSC_VER)
+        nk_size_t const tile_index = (nk_size_t)_InterlockedExchangeAdd64(&queue->next_tile, 1);
+#else
+        nk_size_t const tile_index = __atomic_fetch_add(&queue->next_tile, 1, __ATOMIC_RELAXED);
+#endif
+        if (tile_index >= queue->tile_count) return;
+        queue->body(tile_index, queue->context);
+    }
+}
+
+#pragma endregion Tile Queue
+
+#endif // !NK_PARALLEL_VIA_OPENMP
+
+#pragma region Platform Pools
+
+#if defined(__APPLE__)
+
+/** @brief libdispatch hands each worker its index; the queue decides what it runs. */
+static void nk_tile_worker_dispatch_(void *context, size_t worker_index) {
+    (void)worker_index;
+    nk_tile_queue_drain_((nk_tile_queue_t *)context);
+}
+
+#elif defined(_WIN32)
+
+static void CALLBACK nk_tile_worker_threadpool_(PTP_CALLBACK_INSTANCE instance, PVOID context, PTP_WORK work) {
+    (void)instance;
+    (void)work;
+    nk_tile_queue_drain_((nk_tile_queue_t *)context);
+}
+
+#endif
+
+nk_size_t nk_parallel_concurrency(void) {
+#if defined(_WIN32)
+    DWORD const count = GetActiveProcessorCount(ALL_PROCESSOR_GROUPS);
+    return count ? (nk_size_t)count : 1;
+#elif defined(_SC_NPROCESSORS_ONLN)
+    long const count = sysconf(_SC_NPROCESSORS_ONLN);
+    return count > 0 ? (nk_size_t)count : 1;
+#else
+    return 1;
+#endif
+}
+
+void nk_parallel_for_tiles(nk_size_t tile_count, nk_size_t threads, nk_tile_body_t body, void *context) {
+    if (!tile_count) return;
+    if (threads == 0) threads = nk_parallel_concurrency();
+    if (threads > tile_count) threads = tile_count;
+
+    // A single worker needs no pool, no atomics, and no launch latency.
+    if (threads <= 1) {
+        for (nk_size_t tile_index = 0; tile_index < tile_count; ++tile_index) body(tile_index, context);
+        return;
+    }
+
+#if NK_PARALLEL_VIA_OPENMP
+    // OpenMP's own dynamic queue beats draining a shared counter.
+    long long const tile_limit = (long long)tile_count;
+#pragma omp parallel for schedule(dynamic, 1) num_threads((int)threads)
+    for (long long tile_index = 0; tile_index < tile_limit; ++tile_index) body((nk_size_t)tile_index, context);
+#else
+    nk_tile_queue_t queue;
+    queue.body = body;
+    queue.context = context;
+    queue.tile_count = tile_count;
+    queue.next_tile = 0;
+
+#if defined(__APPLE__)
+    dispatch_apply_f((size_t)threads, dispatch_get_global_queue(QOS_CLASS_USER_INITIATED, 0), &queue,
+                     nk_tile_worker_dispatch_);
+#elif defined(_WIN32)
+    PTP_WORK work = CreateThreadpoolWork(nk_tile_worker_threadpool_, &queue, NULL);
+    if (!work) {
+        nk_tile_queue_drain_(&queue); // Out of pool resources — the caller still needs the result
+        return;
+    }
+    // The calling thread takes a share too, so only the extra workers are submitted.
+    for (nk_size_t worker = 1; worker < threads; ++worker) SubmitThreadpoolWork(work);
+    nk_tile_queue_drain_(&queue);
+    WaitForThreadpoolWorkCallbacks(work, FALSE);
+    CloseThreadpoolWork(work);
+#else
+    nk_tile_queue_drain_(&queue);
+#endif
+#endif // NK_PARALLEL_VIA_OPENMP
+}
+
+#pragma endregion Platform Pools

package/numkong/c/parallel.h

@@ -0,0 +1,47 @@
+/**
+ *  @brief Tile-parallel execution for NumKong language bindings.
+ *  @file c/parallel.h
+ *  @author Ash Vardanian
+ *  @date August 6, 2026
+ *
+ *  Compiled only by `setup.py` and `binding.gyp`, never by CMake or Cargo.
+ *  Each platform's own pool runs the tiles, so no binding ships a `libomp`.
+ */
+#ifndef NUMKONG_PARALLEL_H
+#define NUMKONG_PARALLEL_H
+
+#include <numkong/types.h> // `nk_size_t`
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*  Row-tile sizes: 2 kernel tile blocks per chunk, packed blocking 2×2 rows of 16. */
+#define NK_PARALLEL_PACKED_TILE    64
+#define NK_PARALLEL_SYMMETRIC_TILE 32
+
+/**
+ *  @brief Work for one tile. Must be reentrant and confine writes to its own tile.
+ *  @param tile_index Zero-based index below the `tile_count` passed to the scheduler.
+ *  @param context Caller-owned state, shared unsynchronized across all tiles.
+ */
+typedef void (*nk_tile_body_t)(nk_size_t tile_index, void *context);
+
+/** @brief Logical processors available to this process, or 1 when undetectable. */
+nk_size_t nk_parallel_concurrency(void);
+
+/**
+ *  @brief Run @p tile_count independent tiles, at most @p threads of them at a time.
+ *
+ *  Tiles are claimed from a shared counter, giving the dynamic scheduling uneven
+ *  workloads need. @p threads of 0 means every logical processor, and 1 runs the
+ *  tiles inline on the calling thread with no pool involved. Returns once every
+ *  tile has completed. The caller must release the GIL if the bodies do not need it.
+ */
+void nk_parallel_for_tiles(nk_size_t tile_count, nk_size_t threads, nk_tile_body_t body, void *context);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // NUMKONG_PARALLEL_H