usearch 2.26.0 → 2.26.2

package/README.md

@@ -545,11 +545,11 @@ index = Index(ndim=ndim, metric=CompiledMetric(
 
 ```bibtex
 @software{Vardanian_USearch,
-doi = {10.5281/zenodo.7949416},
+doi = {10.5281/zenodo.7949415},
 author = {Vardanian, Ash},
 title = {{USearch by Unum Cloud}},
 url = {https://github.com/unum-cloud/USearch},
-version = {2.26.0},
+version = {2.26.2},
 year = {2026},
 }
 ```

package/cpp/test.cpp

@@ -1112,9 +1112,6 @@ template <typename key_at, typename slot_at> void test_strings() {
     }
 }
 
-/**
- * @brief Tests replacing and updating entries in index_dense_gt to ensure consistency after modifications.
- */
 /**
  *  @brief  Churns a tightly-reserved index, so `slot_lookup_` accumulates tombstones.
  *
@@ -1181,6 +1178,10 @@ template <typename key_at, typename slot_at> void test_slot_lookup_churn() {
         expect(copy.contains(key));
 }
 
+/**
+ *  @brief  Tests replacing and updating entries in `index_dense_gt`, to ensure consistency
+ *          after modifications.
+ */
 template <typename key_at, typename slot_at> void test_replacing_update() {
 
     using vector_key_t = key_at;
@@ -1427,6 +1428,67 @@ void test_load_after_metric_make() {
     std::remove(path);
 }
 
+/**
+ *  @brief  Feeds `view` a truncated index file.
+ *
+ *  The matrix dimensions and the node count come from the file itself, so a short file
+ *  describes a matrix and a level array that reach past the mapping. Both must be rejected
+ *  rather than walked, and a caller-supplied offset past the end must fail the same way.
+ */
+void test_view_of_truncated_file() {
+    std::printf("Testing view of a truncated index file\n");
+
+    using index_t = index_dense_gt<std::int64_t, std::uint32_t>;
+    std::size_t const dimensions = 64;
+    std::size_t const collection = 2048;
+    char const* path = "tmp_truncated.usearch";
+
+    metric_punned_t metric(dimensions, metric_kind_t::l2sq_k, scalar_kind<f32_t>());
+    index_t::state_result_t built = index_t::make(metric);
+    expect(built);
+    expect(built.index.try_reserve(collection));
+    std::vector<float> vector(dimensions);
+    for (std::size_t i = 0; i != collection; ++i) {
+        for (std::size_t d = 0; d != dimensions; ++d)
+            vector[d] = static_cast<float>((i * 31 + d) % 997) / 997.f;
+        expect(built.index.add(static_cast<std::int64_t>(i), vector.data()));
+    }
+    expect(built.index.save(path));
+
+    std::vector<char> prefix;
+    {
+        std::FILE* file = std::fopen(path, "rb");
+        expect(file != nullptr);
+        std::fseek(file, 0, SEEK_END);
+        long const bytes = std::ftell(file);
+        std::fseek(file, 0, SEEK_SET);
+        prefix.resize(static_cast<std::size_t>(bytes) / 8);
+        expect(std::fread(prefix.data(), 1, prefix.size(), file) == prefix.size());
+        std::fclose(file);
+    }
+    {
+        std::FILE* file = std::fopen(path, "wb");
+        expect(file != nullptr);
+        std::fwrite(prefix.data(), 1, prefix.size(), file);
+        std::fclose(file);
+    }
+
+    index_t::state_result_t viewed = index_t::make(metric);
+    expect(viewed);
+    serialization_result_t truncated = viewed.index.view(path);
+    expect(!truncated);
+    truncated.error.release();
+
+    // A caller-supplied offset past the end must fail the same way.
+    index_t::state_result_t offset_viewed = index_t::make(metric);
+    expect(offset_viewed);
+    serialization_result_t beyond = offset_viewed.index.view(memory_mapped_file_t(path), prefix.size() * 4);
+    expect(!beyond);
+    beyond.error.release();
+
+    std::remove(path);
+}
+
 int main(int, char**) {
     install_crash_handlers();
 
@@ -1523,5 +1585,6 @@ int main(int, char**) {
     test_filtered_search();
     test_isolate();
     test_load_after_metric_make();
+    test_view_of_truncated_file();
     return 0;
 }

package/include/usearch/index.hpp

@@ -9,7 +9,7 @@
 
 #define USEARCH_VERSION_MAJOR 2
 #define USEARCH_VERSION_MINOR 26
-#define USEARCH_VERSION_PATCH 0
+#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
@@ -3970,6 +3974,10 @@ class index_gt {
                                                  : checked_size_overflow();
         if (!first_offset)
             return result.failed("Index is too large");
+        if (file.size() < first_offset.value) {
+            reset();
+            return result.failed("File is corrupted and can't fit the node levels");
+        }
         offsets[0u] = first_offset.value;
         for (std::size_t i = 1; i < header_size.value; ++i) {
             checked_size_result_t next_offset = checked_add(offsets[i - 1], node_bytes_(levels[i - 1]));

package/include/usearch/index_dense.hpp

@@ -1050,17 +1050,18 @@ class index_dense_gt {
      */
     bool try_reserve(index_limits_t limits) {
 
+        // Reserving is monotonic: reducing thread limits must not shrink member-addressed storage.
+        limits.members = (std::max)(limits.members, typed_->capacity());
+        limits.members = (std::max)(limits.members, vectors_lookup_.size());
+
         // The slot lookup system will generally prefer power-of-two sizes.
         if (config_.enable_key_lookups) {
             unique_lock_t lock(slot_lookup_mutex_);
             if (!slot_lookup_.try_reserve(limits.members))
                 return false;
-            limits.members = slot_lookup_.capacity();
         }
 
-        // Once the `slot_lookup_` grows, let's use its capacity as the new
-        // target for the `vectors_lookup_` to synchronize allocations and
-        // expensive index re-organizations.
+        // Hash-table load-factor slack does not need corresponding vector or graph slots.
         if (limits.members != vectors_lookup_.size()) {
             vectors_lookup_t new_vectors_lookup(limits.members);
             if (!new_vectors_lookup)
@@ -1358,6 +1359,11 @@ class index_dense_gt {
         if (!result)
             return result;
 
+        // `offset` is caller-supplied, so every `file.size() - offset` below would
+        // otherwise underflow into a huge span instead of failing.
+        if (offset > file.size())
+            return result.failed("File is corrupted and lacks matrix dimensions");
+
         // Infer the new index size
         std::uint64_t matrix_rows = 0;
         std::uint64_t matrix_cols = 0;
@@ -1383,7 +1389,12 @@ class index_dense_gt {
                 matrix_cols = dimensions[1];
                 offset += sizeof(dimensions);
             }
-            vectors_buffer = {file.data() + offset, static_cast<std::size_t>(matrix_rows * matrix_cols)};
+            // bound the vectors matrix span against the file (overflow-safe; offset <= file.size() holds here)
+            checked_size_result_t vectors_bytes =
+                checked_mul(static_cast<std::size_t>(matrix_rows), static_cast<std::size_t>(matrix_cols));
+            if (!vectors_bytes || file.size() - offset < vectors_bytes.value)
+                return result.failed("File is corrupted: vectors matrix exceeds file size");
+            vectors_buffer = {file.data() + offset, vectors_bytes.value};
             offset += vectors_buffer.size();
         }
 

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;