usearch 2.21.4 → 2.25.0

package/numkong/cmake/nk_arm_isa_probes.cmake

@@ -0,0 +1,61 @@
+# cmake/nk_arm_isa_probes.cmake — Arm ISA compiler-capability probes
+#
+# Detect which ISA extensions the compiler can emit.
+# Probe source lives in probes/arm_*.c — shared with setup.py and build.rs.
+
+# Apple Clang 21+ recognises M-series CPUs under -mcpu=native and advertises
+# SME/SME2/BF16 feature macros correctly. Older Apple Clang didn't, which is
+# why earlier code hardcoded -mcpu=apple-m4 — but on a pre-M4 runner that
+# hardcode over-reports capabilities and compiles in bfdot/SME kernels that
+# SIGILL at runtime on hardware lacking those features.
+if (APPLE)
+    set(nk_native_flags_ "-mcpu=native")
+else ()
+    set(nk_native_flags_ "-march=native")
+endif ()
+include(cmake/nk_isa_probe.cmake)
+
+nk_isa_probes_begin_()
+
+# NEON base probes — MSVC /arch:armv8.X sets __ARM_ARCH but not __ARM_FEATURE_*
+# macros; the probes accept __ARM_ARCH fallback (e.g., __ARM_ARCH >= 804 for dotprod).
+# FEAT_AdvSIMD (baseline ARM64)
+nk_isa_probe_(nk_target_neon "" "-march=armv8-a+simd" "probes/arm_neon.c")
+# FEAT_FP16: optional from ARMv8.2, mandatory at ARMv9.0 with AdvSIMD
+nk_isa_probe_(nk_target_neonhalf "/arch:armv8.2" "-march=armv8.2-a+simd+fp16" "probes/arm_neon_half.c")
+# FEAT_DotProd: optional from ARMv8.1, mandatory at ARMv8.4 with AdvSIMD
+nk_isa_probe_(nk_target_neonsdot "/arch:armv8.4" "-march=armv8.2-a+dotprod" "probes/arm_neon_sdot.c")
+# FEAT_BF16: optional from ARMv8.2, mandatory at ARMv8.6 with FP
+nk_isa_probe_(nk_target_neonbfdot "/arch:armv8.6" "-march=armv8.6-a+simd+bf16" "probes/arm_neon_bfdot.c")
+# FEAT_FHM: optional from ARMv8.1, mandatory at ARMv8.4 with FP16
+nk_isa_probe_(nk_target_neonfhm "/arch:armv8.4" "-march=armv8.2-a+simd+fp16+fp16fml" "probes/arm_neon_fhm.c")
+
+# SVE probes
+nk_isa_probe_(nk_target_sve "" "-march=armv8.2-a+sve" "probes/arm_sve.c")
+nk_isa_probe_(nk_target_svehalf "" "-march=armv8.2-a+sve+fp16" "probes/arm_sve_half.c")
+nk_isa_probe_(nk_target_svebfdot "" "-march=armv8.2-a+sve+bf16" "probes/arm_sve_bfdot.c")
+nk_isa_probe_(nk_target_svesdot "" "-march=armv8.2-a+sve+dotprod" "probes/arm_sve_sdot.c")
+nk_isa_probe_(nk_target_sve2 "" "-march=armv8.2-a+sve2" "probes/arm_sve2.c")
+nk_isa_probe_(nk_target_sve2p1 "" "-march=armv8.2-a+sve2p1" "probes/arm_sve2p1.c")
+
+# NEON FP8
+nk_isa_probe_(nk_target_neonfp8 "" "-march=armv8-a+simd+fp8dot4" "probes/arm_neonfp8.c")
+
+# SME probes
+nk_isa_probe_(nk_target_sme "" "-march=armv8-a+sme" "probes/arm_sme.c")
+nk_isa_probe_(nk_target_sme2 "" "-march=armv8-a+sme2" "probes/arm_sme2.c")
+nk_isa_probe_(nk_target_sme2p1 "" "-march=armv8-a+sme2p1" "probes/arm_sme2p1.c")
+nk_isa_probe_(nk_target_smef64 "" "-march=armv8-a+sme+sme-f64f64" "probes/arm_sme_f64.c")
+nk_isa_probe_(nk_target_smehalf "" "-march=armv8-a+sme+sme-f16f16" "probes/arm_sme_half.c")
+nk_isa_probe_(nk_target_smebf16 "" "-march=armv8-a+sme2+sme-b16b16" "probes/arm_sme_bf16.c")
+nk_isa_probe_(nk_target_smebi32 "" "-march=armv8-a+sme2" "probes/arm_sme_bi32.c")
+nk_isa_probe_(nk_target_smelut2 "" "-march=armv8-a+sme2+lut" "probes/arm_sme_lut2.c")
+nk_isa_probe_(nk_target_smefa64 "" "-march=armv8-a+sme+sme-fa64" "probes/arm_sme_fa64.c")
+
+nk_isa_probes_end_()
+
+nk_build_isa_defs_(
+    arm
+    "Arm"
+    "NEON;NEONHALF;NEONSDOT;NEONBFDOT;NEONFHM;SVE;SVEHALF;SVEBFDOT;SVESDOT;SVE2;SVE2P1;NEONFP8;SME;SME2;SME2P1;SMEF64;SMEHALF;SMEBF16;SMEBI32;SMELUT2;SMEFA64"
+)

package/numkong/cmake/nk_isa_probe.cmake

@@ -0,0 +1,90 @@
+# cmake/nk_isa_probe.cmake — shared ISA probe infrastructure
+#
+# Provides the two-pass probe macro and result-list builder used by all
+# per-architecture probe files (nk_x86_isa_probes.cmake, etc.).
+#
+# Each architecture file sets `nk_native_flags_` before including this file,
+# then calls `nk_isa_probe_()` for each ISA and `nk_build_isa_defs_()` once
+# to collect the results.
+
+include(CheckSourceCompiles)
+if (CMAKE_VERSION VERSION_GREATER_EQUAL 3.19)
+    include(CheckSourceRuns)
+endif ()
+
+# Save and restore CMAKE_REQUIRED_FLAGS around probes.
+# Force Release config for try_compile to avoid ASAN DLL-not-found failures.
+# Call nk_isa_probes_begin_() before probe calls, nk_isa_probes_end_() after.
+macro (nk_isa_probes_begin_)
+    set(nk_saved_required_flags_ "${CMAKE_REQUIRED_FLAGS}")
+    set(nk_saved_try_compile_config_ "${CMAKE_TRY_COMPILE_CONFIGURATION}")
+    set(CMAKE_TRY_COMPILE_CONFIGURATION "Release")
+endmacro ()
+
+macro (nk_isa_probes_end_)
+    set(CMAKE_REQUIRED_FLAGS "${nk_saved_required_flags_}")
+    set(CMAKE_TRY_COMPILE_CONFIGURATION "${nk_saved_try_compile_config_}")
+endmacro ()
+
+# Two-pass probe: compile with ISA flags (Pass 1) and native flags (Pass 2).
+#   Pass 1 result drives nk_shared (dynamic dispatch — compile all the compiler supports).
+#   Pass 2 result drives nk_test/nk_bench (must actually run on the local CPU).
+#
+# The native flag (`nk_native_flags_`) is set by the caller:
+#   x86/ARM/LoongArch: -march=native
+#   Power:             -mcpu=native
+#   RISC-V:            "" (no equivalent — falls back to Pass 1)
+macro (nk_isa_probe_ var_ msvc_arch_ gcc_flags_ probe_file_)
+    file(READ "${CMAKE_CURRENT_SOURCE_DIR}/${probe_file_}" nk_probe_source_)
+    # Pass 1: can the compiler emit this ISA?
+    if (MSVC)
+        set(CMAKE_REQUIRED_FLAGS "${msvc_arch_}")
+    else ()
+        set(CMAKE_REQUIRED_FLAGS "${gcc_flags_}")
+    endif ()
+    check_source_compiles(C "${nk_probe_source_}" ${var_}_compiles)
+    # Pass 2: does the local CPU support it?
+    if (NOT CMAKE_CROSSCOMPILING AND NOT MSVC AND NOT "${nk_native_flags_}" STREQUAL "")
+        set(CMAKE_REQUIRED_FLAGS "${nk_native_flags_}")
+        check_source_compiles(C "${nk_probe_source_}" ${var_}_native)
+    elseif (NOT CMAKE_CROSSCOMPILING AND MSVC AND ${var_}_compiles AND CMAKE_VERSION VERSION_GREATER_EQUAL 3.19)
+        # MSVC has no -march=native; instead compile with ISA-specific flags and
+        # run the probe.  If the CPU lacks the ISA the process will crash and
+        # check_source_runs() will report failure.
+        set(CMAKE_REQUIRED_FLAGS "${msvc_arch_}")
+        check_source_runs(C "${nk_probe_source_}" ${var_}_native)
+    else ()
+        set(${var_}_native ${${var_}_compiles})
+    endif ()
+endmacro ()
+
+# Build compile-only and native def lists from probe results.
+#   arch_prefix_:  variable prefix, e.g. "x86" → nk_x86_compile_defs_
+#   arch_display_: human-readable name for status messages
+#   isa_list_:     semicolon-separated list of ISA names, e.g. "HASWELL;SKYLAKE;..."
+function (nk_build_isa_defs_ arch_prefix_ arch_display_ isa_list_)
+    set(compile_defs_ "")
+    set(native_defs_ "")
+    foreach (isa_ IN LISTS isa_list_)
+        string(TOLOWER "${isa_}" isa_lower_)
+        if (nk_target_${isa_lower_}_compiles)
+            list(APPEND compile_defs_ "NK_TARGET_${isa_}=1")
+        else ()
+            list(APPEND compile_defs_ "NK_TARGET_${isa_}=0")
+        endif ()
+        if (nk_target_${isa_lower_}_native)
+            list(APPEND native_defs_ "NK_TARGET_${isa_}=1")
+        else ()
+            list(APPEND native_defs_ "NK_TARGET_${isa_}=0")
+        endif ()
+    endforeach ()
+    if (compile_defs_)
+        message(STATUS "${arch_display_} ISA compile probes: ${compile_defs_}")
+    endif ()
+    if (native_defs_)
+        message(STATUS "${arch_display_} ISA native probes: ${native_defs_}")
+    endif ()
+    set(nk_${arch_prefix_}_compile_defs_ "${compile_defs_}" PARENT_SCOPE)
+    set(nk_${arch_prefix_}_native_defs_ "${native_defs_}" PARENT_SCOPE)
+    set(nk_${arch_prefix_}_isa_defs_ "${native_defs_}" PARENT_SCOPE)
+endfunction ()

package/numkong/cmake/nk_loongarch_isa_probes.cmake

@@ -0,0 +1,15 @@
+# cmake/nk_loongarch_isa_probes.cmake — LoongArch ISA compiler-capability probes
+#
+# Detect which ISA extensions the compiler can emit.
+# Probe source lives in probes/loongarch_*.c — shared with setup.py and build.rs.
+
+set(nk_native_flags_ "-march=native")
+include(cmake/nk_isa_probe.cmake)
+
+nk_isa_probes_begin_()
+
+nk_isa_probe_(nk_target_loongsonasx "" "-mlasx" "probes/loongarch_lasx.c")
+
+nk_isa_probes_end_()
+
+nk_build_isa_defs_(loongarch "LoongArch" "LOONGSONASX")

package/numkong/cmake/nk_math_lib.cmake

@@ -0,0 +1,46 @@
+# cmake/nk_math_lib.cmake
+#
+# Detect whether C++ targets need explicit linkage against `libm`.
+# Some Unix toolchains require `-lm` for cmath symbols, while MSVC and
+# WASM/WASI toolchains do not provide a separate math archive.
+#
+# Contract:
+#   Input:  MSVC, NK_IS_WASI_PROJECT_, CMAKE_SYSTEM_NAME
+#   Output: caller-provided output variable with either "" or "m"
+
+include(CheckCXXSourceCompiles)
+
+function (nk_detect_cxx_math_lib_ output_var_)
+    set(${output_var_} "" PARENT_SCOPE)
+
+    if (MSVC OR NK_IS_WASI_PROJECT_ OR CMAKE_SYSTEM_NAME STREQUAL "Emscripten")
+        return()
+    endif ()
+
+    set(nk_cxx_math_probe_src_
+        "
+        #include <cmath>
+        int main() {
+            volatile double x = std::sqrt(2.0);
+            volatile double y = std::sin(x);
+            volatile double z = std::fma(x, y, 1.0);
+            return z == 0.0;
+        }
+        "
+    )
+
+    set(CMAKE_REQUIRED_QUIET ON)
+    set(CMAKE_REQUIRED_LIBRARIES "")
+    check_cxx_source_compiles("${nk_cxx_math_probe_src_}" nk_cxx_links_math_without_libm_)
+
+    if (NOT nk_cxx_links_math_without_libm_)
+        set(CMAKE_REQUIRED_LIBRARIES m)
+        check_cxx_source_compiles("${nk_cxx_math_probe_src_}" nk_cxx_links_math_with_libm_)
+        if (nk_cxx_links_math_with_libm_)
+            set(${output_var_} "m" PARENT_SCOPE)
+        endif ()
+    endif ()
+
+    unset(CMAKE_REQUIRED_LIBRARIES)
+    unset(CMAKE_REQUIRED_QUIET)
+endfunction ()

package/numkong/cmake/nk_power_isa_probes.cmake

@@ -0,0 +1,15 @@
+# cmake/nk_power_isa_probes.cmake — Power ISA compiler-capability probes
+#
+# Detect which ISA extensions the compiler can emit.
+# Probe source lives in probes/power_*.c — shared with setup.py and build.rs.
+
+set(nk_native_flags_ "-mcpu=native")
+include(cmake/nk_isa_probe.cmake)
+
+nk_isa_probes_begin_()
+
+nk_isa_probe_(nk_target_powervsx "" "-mcpu=power9 -mvsx" "probes/power_vsx.c")
+
+nk_isa_probes_end_()
+
+nk_build_isa_defs_(power "Power" "POWERVSX")

package/numkong/cmake/nk_riscv_isa_probes.cmake

@@ -0,0 +1,19 @@
+# cmake/nk_riscv_isa_probes.cmake — RISC-V ISA compiler-capability probes
+#
+# Detect which ISA extensions the compiler can emit.
+# RISC-V has no -march=native, so native falls back to compile result.
+# Probe source lives in probes/riscv_*.c — shared with setup.py and build.rs.
+
+set(nk_native_flags_ "")
+include(cmake/nk_isa_probe.cmake)
+
+nk_isa_probes_begin_()
+
+nk_isa_probe_(nk_target_rvv "" "-march=rv64gcv" "probes/riscv_rvv.c")
+nk_isa_probe_(nk_target_rvvhalf "" "-march=rv64gcv_zvfh" "probes/riscv_rvv_half.c")
+nk_isa_probe_(nk_target_rvvbf16 "" "-march=rv64gcv_zvfbfwma" "probes/riscv_rvv_bf16.c")
+nk_isa_probe_(nk_target_rvvbb "" "-march=rv64gcv_zvbb" "probes/riscv_rvv_bb.c")
+
+nk_isa_probes_end_()
+
+nk_build_isa_defs_(riscv "RISC-V" "RVV;RVVHALF;RVVBF16;RVVBB")

package/numkong/cmake/nk_x86_isa_probes.cmake

@@ -0,0 +1,35 @@
+# cmake/nk_x86_isa_probes.cmake — x86 ISA compiler-capability probes
+#
+# Detect which ISA extensions the compiler can emit.
+# Probe source lives in probes/x86_*.c — shared with setup.py and build.rs.
+
+set(nk_native_flags_ "-march=native")
+include(cmake/nk_isa_probe.cmake)
+
+nk_isa_probes_begin_()
+
+nk_isa_probe_(nk_target_haswell "/arch:AVX2" "-mavx2 -mfma -mf16c" "probes/x86_haswell.c")
+
+nk_isa_probe_(nk_target_skylake "/arch:AVX512" "-mavx512f -mavx512bw -mavx512dq -mavx512vl" "probes/x86_skylake.c")
+
+nk_isa_probe_(nk_target_icelake "/arch:AVX512" "-mavx512vnni -mavx512vl" "probes/x86_icelake.c")
+
+nk_isa_probe_(nk_target_genoa "/arch:AVX512" "-mavx512bf16 -mavx512vl" "probes/x86_genoa.c")
+
+nk_isa_probe_(nk_target_sapphire "/arch:AVX512" "-mavx512fp16 -mavx512vl" "probes/x86_sapphire.c")
+
+nk_isa_probe_(nk_target_sapphireamx "/arch:AVX512" "-mamx-tile -mamx-int8" "probes/x86_sapphireamx.c")
+
+nk_isa_probe_(nk_target_graniteamx "/arch:AVX512" "-mamx-tile -mamx-fp16" "probes/x86_graniteamx.c")
+
+nk_isa_probe_(nk_target_diamond "/arch:AVX10.2" "-mavx10.2-512" "probes/x86_diamond.c")
+
+nk_isa_probe_(nk_target_turin "/arch:AVX512" "-mavx512vp2intersect" "probes/x86_turin.c")
+
+nk_isa_probe_(nk_target_alder "/arch:AVX2" "-mavxvnni" "probes/x86_alder.c")
+
+nk_isa_probe_(nk_target_sierra "/arch:AVX2" "-mavxvnniint8" "probes/x86_sierra.c")
+
+nk_isa_probes_end_()
+
+nk_build_isa_defs_(x86 "x86" "HASWELL;SKYLAKE;ICELAKE;GENOA;SAPPHIRE;SAPPHIREAMX;GRANITEAMX;DIAMOND;TURIN;ALDER;SIERRA")

package/numkong/cmake/toolchain-aarch64-gnu.cmake

@@ -0,0 +1,86 @@
+# AArch64 GNU toolchain for NumKong.
+#
+# Usage:
+#   cmake -B build_arm64 -D CMAKE_TOOLCHAIN_FILE=cmake/toolchain-aarch64-gnu.cmake
+#   cmake --build build_arm64
+#
+# Prerequisites (choose one):
+#   Option A - Ubuntu/Debian packages:
+#     sudo apt install gcc-aarch64-linux-gnu g++-aarch64-linux-gnu qemu-user
+#   Option B - Arm GNU Toolchain (recommended for latest ISA support):
+#     Download from: https://developer.arm.com/downloads/-/arm-gnu-toolchain-downloads
+#     Set via AARCH64_TOOLCHAIN_PATH
+#
+# Testing with QEMU:
+#   Tests will automatically run under QEMU via CMAKE_CROSSCOMPILING_EMULATOR
+#
+# To customize the architecture, set AARCH64_MARCH before configuring:
+#   cmake -B build_arm64 -D CMAKE_TOOLCHAIN_FILE=cmake/toolchain-aarch64-gnu.cmake -D AARCH64_MARCH=armv8.2-a+sve
+
+set(CMAKE_SYSTEM_NAME Linux)
+set(CMAKE_SYSTEM_PROCESSOR aarch64)
+
+# Cross-compiler detection with fallback chain:
+# 1. AARCH64_TOOLCHAIN_PATH (explicit path to Arm GNU Toolchain)
+# 2. /tmp/aarch64 (default Arm GNU Toolchain location)
+# 3. System packages (aarch64-linux-gnu-)
+if (DEFINED AARCH64_TOOLCHAIN_PATH)
+    set(AARCH64_TOOLCHAIN_PREFIX "${AARCH64_TOOLCHAIN_PATH}/bin/aarch64-none-linux-gnu-")
+    set(CMAKE_SYSROOT "${AARCH64_TOOLCHAIN_PATH}/aarch64-none-linux-gnu/libc")
+elseif (NOT DEFINED AARCH64_TOOLCHAIN_PREFIX)
+    set(AARCH64_TOOLCHAIN_PREFIX "aarch64-linux-gnu-")
+endif ()
+
+set(CMAKE_C_COMPILER ${AARCH64_TOOLCHAIN_PREFIX}gcc)
+set(CMAKE_CXX_COMPILER ${AARCH64_TOOLCHAIN_PREFIX}g++)
+
+# Target architecture with modern Arm extensions
+# Default: Enables all extensions supported by NumKong
+#
+# Architecture hierarchy:
+#   armv8-a      : Base AArch64 (NEON mandatory)
+#   armv8.2-a    : +fp16 (half-precision), +dotprod available
+#   armv8.4-a    : +bf16 (bfloat16) available
+#   armv8.6-a    : +i8mm (int8 matrix multiply) available
+#   armv9-a      : SVE2 mandatory, +sme available
+#   armv9.2-a    : +sme2 available
+#
+# NumKong Arm targets and required extensions:
+#   NK_TARGET_NEON      : Base NEON (automatic with aarch64)
+#   NK_TARGET_NEONHALF  : +fp16
+#   NK_TARGET_NEONBFDOT : +bf16
+#   NK_TARGET_NEONFHM   : +fp16fml (FMLAL/FMLSL widening ops)
+#   NK_TARGET_NEONSDOT  : +dotprod
+#   NK_TARGET_SVE       : +sve
+#   NK_TARGET_SVEHALF   : +sve +fp16
+#   NK_TARGET_SVEBFDOT  : +sve +bf16
+#   NK_TARGET_SVE2      : +sve2
+#   NK_TARGET_SME       : +sme
+#   NK_TARGET_SME2      : +sme2
+#
+# Common CPU profiles:
+#   armv8.2-a+fp16+dotprod                       : Apple M1, Ampere Altra
+#   armv8.4-a+sve+fp16+bf16+i8mm                 : AWS Graviton 3, Neoverse V1
+#   armv9-a+sve2+fp16+bf16+i8mm                  : Neoverse V2, Cortex-X3
+#   armv9.2-a+sve2+sme2+fp16+bf16+i8mm+fp16fml   : Future SME2-capable CPUs
+#
+# Default: armv9-a with SVE2 and common extensions (GCC 13 compatible)
+# For SME/SME2 support, use GCC 14+ and set:
+#   -DAARCH64_MARCH="armv9.2-a+sve2+sme2+fp16+bf16+i8mm+dotprod+fp16fml"
+if (NOT DEFINED AARCH64_MARCH)
+    set(AARCH64_MARCH "armv9-a+sve2+fp16+bf16+i8mm+dotprod+fp16fml")
+endif ()
+
+set(CMAKE_C_FLAGS_INIT "-march=${AARCH64_MARCH}")
+set(CMAKE_CXX_FLAGS_INIT "-march=${AARCH64_MARCH}")
+
+# QEMU user-mode emulation for running tests.
+# -cpu max enables all supported features.
+# For specific CPU emulation: -cpu neoverse-v1, -cpu neoverse-v2, etc.
+set(CMAKE_CROSSCOMPILING_EMULATOR "qemu-aarch64;-cpu;max")
+
+# Search paths for libraries and headers (target system only).
+set(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM NEVER)
+set(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY)
+set(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY)
+set(CMAKE_FIND_ROOT_PATH_MODE_PACKAGE ONLY)

package/numkong/cmake/toolchain-android-arm64.cmake

@@ -0,0 +1,25 @@
+# Android ARM64 toolchain for NumKong.
+#
+# Usage:
+#   export ANDROID_NDK_ROOT=/path/to/android-ndk-r29
+#   cmake -B build_android -D CMAKE_TOOLCHAIN_FILE=cmake/toolchain-android-arm64.cmake \
+#         -D NK_BUILD_SHARED=ON
+#   cmake --build build_android
+#
+# Requires ANDROID_NDK_ROOT or ANDROID_NDK to point to the NDK.
+
+# Locate the NDK.
+if (DEFINED ENV{ANDROID_NDK_ROOT})
+    set(_ndk_root "$ENV{ANDROID_NDK_ROOT}")
+elseif (DEFINED ENV{ANDROID_NDK})
+    set(_ndk_root "$ENV{ANDROID_NDK}")
+else ()
+    message(FATAL_ERROR "Set ANDROID_NDK_ROOT or ANDROID_NDK to the NDK installation path")
+endif ()
+
+# Defaults for ARM64 Android.
+set(ANDROID_ABI "arm64-v8a" CACHE STRING "Android ABI")
+set(ANDROID_PLATFORM "android-28" CACHE STRING "Minimum Android API level")
+
+# Delegate to the NDK's own toolchain.
+include("${_ndk_root}/build/cmake/android.toolchain.cmake")

package/numkong/cmake/toolchain-android-armv7.cmake

@@ -0,0 +1,25 @@
+# Android ARMv7 toolchain for NumKong.
+#
+# Usage:
+#   export ANDROID_NDK_ROOT=/path/to/android-ndk-r29
+#   cmake -B build_android_armv7 -D CMAKE_TOOLCHAIN_FILE=cmake/toolchain-android-armv7.cmake \
+#         -D NK_BUILD_SHARED=ON
+#   cmake --build build_android_armv7
+#
+# Requires ANDROID_NDK_ROOT or ANDROID_NDK to point to the NDK.
+
+# Locate the NDK.
+if (DEFINED ENV{ANDROID_NDK_ROOT})
+    set(_ndk_root "$ENV{ANDROID_NDK_ROOT}")
+elseif (DEFINED ENV{ANDROID_NDK})
+    set(_ndk_root "$ENV{ANDROID_NDK}")
+else ()
+    message(FATAL_ERROR "Set ANDROID_NDK_ROOT or ANDROID_NDK to the NDK installation path")
+endif ()
+
+# Defaults for 32-bit ARM Android with NEON.
+set(ANDROID_ABI "armeabi-v7a" CACHE STRING "Android ABI")
+set(ANDROID_PLATFORM "android-28" CACHE STRING "Minimum Android API level")
+
+# Delegate to the NDK's own toolchain.
+include("${_ndk_root}/build/cmake/android.toolchain.cmake")

package/numkong/cmake/toolchain-loongarch64-gnu.cmake

@@ -0,0 +1,68 @@
+# LoongArch 64 GNU toolchain for NumKong.
+#
+# Usage:
+#   cmake -B build_loongarch -D CMAKE_TOOLCHAIN_FILE=cmake/toolchain-loongarch64-gnu.cmake
+#   cmake --build build_loongarch
+#
+# Optional inputs:
+#   -D LOONGARCH_TOOLCHAIN_PATH=/path/to/loongarch-gnu-toolchain
+#   -D LOONGARCH_SYSROOT=/path/to/loongarch64/sysroot
+#
+# Prerequisites:
+#   sudo apt install gcc-loongarch64-linux-gnu g++-loongarch64-linux-gnu qemu-user
+#
+# Testing with QEMU:
+#   Tests will automatically run under QEMU via CMAKE_CROSSCOMPILING_EMULATOR
+
+set(CMAKE_SYSTEM_NAME Linux)
+set(CMAKE_SYSTEM_PROCESSOR loongarch64)
+
+# Cross-compiler.
+# Set LOONGARCH_TOOLCHAIN_PATH to override the default location.
+if (NOT DEFINED LOONGARCH_TOOLCHAIN_PATH)
+    if (DEFINED ENV{LOONGARCH_TOOLCHAIN_PATH})
+        set(LOONGARCH_TOOLCHAIN_PATH "$ENV{LOONGARCH_TOOLCHAIN_PATH}")
+    else ()
+        set(LOONGARCH_TOOLCHAIN_PATH "/tmp/loongarch")
+    endif ()
+endif ()
+set(LOONGARCH_TOOLCHAIN_PATH "${LOONGARCH_TOOLCHAIN_PATH}" CACHE PATH "LoongArch GNU toolchain root")
+set(ENV{LOONGARCH_TOOLCHAIN_PATH} "${LOONGARCH_TOOLCHAIN_PATH}")
+
+set(CMAKE_C_COMPILER "${LOONGARCH_TOOLCHAIN_PATH}/bin/loongarch64-unknown-linux-gnu-gcc")
+set(CMAKE_CXX_COMPILER "${LOONGARCH_TOOLCHAIN_PATH}/bin/loongarch64-unknown-linux-gnu-g++")
+
+# Sysroot for the target system.
+if (NOT DEFINED LOONGARCH_SYSROOT)
+    if (DEFINED ENV{LOONGARCH_SYSROOT})
+        set(LOONGARCH_SYSROOT "$ENV{LOONGARCH_SYSROOT}")
+    else ()
+        set(LOONGARCH_SYSROOT "${LOONGARCH_TOOLCHAIN_PATH}/sysroot")
+    endif ()
+endif ()
+set(LOONGARCH_SYSROOT "${LOONGARCH_SYSROOT}" CACHE PATH "LoongArch sysroot for GNU cross-compilation")
+set(ENV{LOONGARCH_SYSROOT} "${LOONGARCH_SYSROOT}")
+set(CMAKE_SYSROOT "${LOONGARCH_SYSROOT}")
+
+# Forward custom variables to nested try_compile() projects.
+list(APPEND CMAKE_TRY_COMPILE_PLATFORM_VARIABLES LOONGARCH_TOOLCHAIN_PATH LOONGARCH_SYSROOT)
+
+# Toolchain validation only needs to prove the project compiles.
+set(CMAKE_TRY_COMPILE_TARGET_TYPE STATIC_LIBRARY)
+
+# Enable LASX (256-bit SIMD) by default.
+# The base ABI is lp64d (64-bit pointers, double-precision floats in FP registers).
+set(CMAKE_C_FLAGS_INIT "-mlasx")
+set(CMAKE_CXX_FLAGS_INIT "-mlasx")
+
+# QEMU user-mode emulation for running tests.
+# -L sysroot provides the dynamic linker path.
+# -cpu max enables all supported extensions.
+set(CMAKE_CROSSCOMPILING_EMULATOR "qemu-loongarch64;-L;${LOONGARCH_SYSROOT};-cpu;max")
+
+# Search paths for libraries and headers (target system only).
+set(CMAKE_FIND_ROOT_PATH "${LOONGARCH_SYSROOT}")
+set(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM NEVER)
+set(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY)
+set(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY)
+set(CMAKE_FIND_ROOT_PATH_MODE_PACKAGE ONLY)

package/numkong/cmake/toolchain-ppc64le-gnu.cmake

@@ -0,0 +1,74 @@
+# Power ppc64le GNU toolchain for NumKong.
+#
+# Usage:
+#   cmake -B build_ppc -D CMAKE_TOOLCHAIN_FILE=cmake/toolchain-ppc64le-gnu.cmake
+#   cmake --build build_ppc
+#
+# Optional inputs:
+#   -D PPC_TOOLCHAIN_PATH=/path/to/powerpc64le-linux-gnu
+#   -D PPC_SYSROOT=/path/to/ppc64le/sysroot
+#   -D PPC_MCPU=power10
+#
+# Prerequisites:
+#   sudo apt install gcc-powerpc64le-linux-gnu g++-powerpc64le-linux-gnu libc6-dev-ppc64el-cross qemu-user
+#
+# Testing with QEMU:
+#   Tests will automatically run under QEMU via CMAKE_CROSSCOMPILING_EMULATOR
+
+set(CMAKE_SYSTEM_NAME Linux)
+set(CMAKE_SYSTEM_PROCESSOR ppc64le)
+
+# Cross-compiler from the system package (gcc-powerpc64le-linux-gnu).
+set(CMAKE_C_COMPILER powerpc64le-linux-gnu-gcc)
+set(CMAKE_CXX_COMPILER powerpc64le-linux-gnu-g++)
+
+# Sysroot for the target system.
+if (NOT DEFINED PPC_SYSROOT)
+    if (DEFINED ENV{PPC_SYSROOT})
+        set(PPC_SYSROOT "$ENV{PPC_SYSROOT}")
+    else ()
+        # Default: derive from the cross-compiler
+        execute_process(
+            COMMAND powerpc64le-linux-gnu-gcc -print-sysroot OUTPUT_VARIABLE PPC_SYSROOT
+            OUTPUT_STRIP_TRAILING_WHITESPACE ERROR_QUIET
+        )
+        if (NOT PPC_SYSROOT OR PPC_SYSROOT STREQUAL "")
+            set(PPC_SYSROOT "/usr/powerpc64le-linux-gnu")
+        endif ()
+    endif ()
+endif ()
+set(PPC_SYSROOT "${PPC_SYSROOT}" CACHE PATH "ppc64le sysroot for GNU cross-compilation")
+set(CMAKE_SYSROOT "${PPC_SYSROOT}")
+
+# Target CPU microarchitecture.
+# power9:  VSX + vec_xl_len + vec_cmpne + f16 conversion (minimum for NumKong powervsx backend).
+# power10: adds MMA + native bf16 conversions (future powermma backend).
+if (NOT DEFINED PPC_MCPU)
+    if (DEFINED ENV{PPC_MCPU})
+        set(PPC_MCPU "$ENV{PPC_MCPU}")
+    else ()
+        set(PPC_MCPU "power9")
+    endif ()
+endif ()
+set(PPC_MCPU "${PPC_MCPU}" CACHE STRING "Power CPU target for cross-compilation")
+
+# Forward settings to nested try_compile() invocations.
+list(APPEND CMAKE_TRY_COMPILE_PLATFORM_VARIABLES PPC_SYSROOT PPC_MCPU)
+
+# Toolchain validation only needs to prove the project compiles.
+set(CMAKE_TRY_COMPILE_TARGET_TYPE STATIC_LIBRARY)
+
+set(CMAKE_C_FLAGS_INIT "-mcpu=${PPC_MCPU} -mvsx")
+set(CMAKE_CXX_FLAGS_INIT "-mcpu=${PPC_MCPU} -mvsx")
+
+# QEMU user-mode emulation for running tests.
+# -L sysroot provides the dynamic linker path.
+# -cpu power9 matches our POWER9+ baseline (older QEMU lacks "-cpu max" for ppc64le).
+set(CMAKE_CROSSCOMPILING_EMULATOR "qemu-ppc64le;-L;${PPC_SYSROOT};-cpu;power9")
+
+# Search paths for libraries and headers (target system only).
+set(CMAKE_FIND_ROOT_PATH "${PPC_SYSROOT}")
+set(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM NEVER)
+set(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY)
+set(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY)
+set(CMAKE_FIND_ROOT_PATH_MODE_PACKAGE ONLY)