Add: Relaxed SIMD backend for WASM

With new FMA instructions in Relaxed WASM SIMD,
we can implement fast dot products and spatial metrics
for USearch in the browser & on edge.

Wasmer is about to gain support:
wasmerio/wasmer#6151

Author: ashvardanian

CMakeLists.txt

@@ -62,7 +62,12 @@ project(
 
 set(CMAKE_C_STANDARD 99)
 set(CMAKE_C_STANDARD_REQUIRED YES)
-set(CMAKE_C_EXTENSIONS NO)
+# Enable GNU extensions for WASM (required for EM_ASM runtime detection)
+if(CMAKE_SYSTEM_NAME STREQUAL "Emscripten")
+    set(CMAKE_C_EXTENSIONS YES)
+else()
+    set(CMAKE_C_EXTENSIONS NO)
+endif()
 
 set(CMAKE_CXX_STANDARD 23)
 set(CMAKE_CXX_STANDARD_REQUIRED YES)

cmake/toolchain-wasm.cmake

@@ -0,0 +1,58 @@
+# WASM/Emscripten toolchain for NumKong
+# Usage: cmake -B build-wasm -DCMAKE_TOOLCHAIN_FILE=cmake/toolchain-wasm.cmake
+
+set(CMAKE_SYSTEM_NAME Emscripten)
+set(CMAKE_SYSTEM_PROCESSOR wasm32)
+
+# Verify Emscripten SDK
+if(NOT DEFINED ENV{EMSDK})
+    message(FATAL_ERROR
+        "EMSDK environment variable not set.\n"
+        "Install Emscripten: https://emscripten.org/docs/getting_started/downloads.html\n"
+        "Then run: source $EMSDK/emsdk_env.sh")
+endif()
+
+# Set compilers
+set(EMSCRIPTEN_ROOT "$ENV{EMSDK}/upstream/emscripten")
+set(CMAKE_C_COMPILER "${EMSCRIPTEN_ROOT}/emcc")
+set(CMAKE_CXX_COMPILER "${EMSCRIPTEN_ROOT}/em++")
+set(CMAKE_AR "${EMSCRIPTEN_ROOT}/emar")
+set(CMAKE_RANLIB "${EMSCRIPTEN_ROOT}/emranlib")
+
+# Required WASM SIMD flags
+set(WASM_SIMD_FLAGS "-msimd128 -mrelaxed-simd")
+set(CMAKE_C_FLAGS_INIT "${WASM_SIMD_FLAGS}")
+set(CMAKE_CXX_FLAGS_INIT "${WASM_SIMD_FLAGS}")
+
+# Enable GNU extensions for EM_ASM support (required for runtime detection)
+set(CMAKE_C_EXTENSIONS ON CACHE BOOL "" FORCE)
+set(CMAKE_CXX_EXTENSIONS ON CACHE BOOL "" FORCE)
+
+# Optimization
+set(CMAKE_C_FLAGS_RELEASE "-O3 -DNDEBUG -flto")
+set(CMAKE_CXX_FLAGS_RELEASE "-O3 -DNDEBUG -flto")
+set(CMAKE_C_FLAGS_DEBUG "-O0 -g -s ASSERTIONS=2")
+set(CMAKE_CXX_FLAGS_DEBUG "-O0 -g -s ASSERTIONS=2")
+
+# Linker flags for Node.js execution
+set(CMAKE_EXE_LINKER_FLAGS_INIT
+    "-s ALLOW_MEMORY_GROWTH=1 \
+     -s INITIAL_MEMORY=64MB \
+     -s MAXIMUM_MEMORY=2GB \
+     -s STACK_SIZE=5MB \
+     -s EXPORTED_FUNCTIONS='[\"_main\"]' \
+     -s EXPORTED_RUNTIME_METHODS='[\"ccall\",\"cwrap\"]'")
+
+# Verify Emscripten version (need 3.1.27+ for relaxed SIMD)
+execute_process(
+    COMMAND ${CMAKE_C_COMPILER} --version
+    OUTPUT_VARIABLE EMCC_VERSION_OUTPUT
+    OUTPUT_STRIP_TRAILING_WHITESPACE)
+string(REGEX MATCH "[0-9]+\\.[0-9]+\\.[0-9]+" EMCC_VERSION "${EMCC_VERSION_OUTPUT}")
+
+if(EMCC_VERSION VERSION_LESS "3.1.27")
+    message(WARNING "Emscripten ${EMCC_VERSION} < 3.1.27. Upgrade recommended for relaxed SIMD.")
+endif()
+
+message(STATUS "NumKong WASM: Emscripten ${EMCC_VERSION}")
+message(STATUS "NumKong WASM: Relaxed SIMD enabled")

include/numkong/cast/wasm.h

@@ -0,0 +1,117 @@
+/**
+ *  @file       wasm.h
+ *  @brief      WASM SIMD (v128) type conversion helpers for BF16/F16 to F32.
+ *  @author     Ash Vardanian
+ *  @date       January 31, 2026
+ */
+
+#ifndef NK_CAST_WASM_H
+#define NK_CAST_WASM_H
+
+#if NK_TARGET_V128RELAXED
+#include "numkong/types.h"
+#include "numkong/cast/serial.h" // For scalar fallback
+
+#if defined(__cplusplus)
+extern "C" {
+#endif
+
+NK_INTERNAL nk_b128_vec_t nk_bf16x4_to_f32x4_wasm_(nk_b64_vec_t bf16_vec) {
+    // Load 4x u16 (64 bits) into lower half of v128, zero upper half
+    v128_t bf16_u16x4_in_u64 = wasm_v128_load64_zero(&bf16_vec.u64);
+
+    // Widen u16 → u32: [u16, u16, u16, u16, 0, 0, 0, 0] → [u32, u32, u32, u32]
+    // Uses zero-extension (upper 16 bits of each u32 become 0)
+    v128_t bf16_u32x4_low = wasm_u32x4_extend_low_u16x8(bf16_u16x4_in_u64);
+
+    // Shift left by 16 bits: moves BF16 into F32 position
+    // BF16: [S|EEEEEEEE|MMMMMMM|0000000000000000]
+    // F32:  [S|EEEEEEEE|MMMMMMM00000000000000000]
+    nk_b128_vec_t result;
+    result.v128 = wasm_i32x4_shl(bf16_u32x4_low, 16);
+    return result;
+}
+
+NK_INTERNAL nk_b128_vec_t nk_f16x4_to_f32x4_wasm_(nk_b64_vec_t f16_vec) {
+    // Load 4x u16 into v128, zero-extend to u32x4
+    v128_t f16_u16x4_in_u64 = wasm_v128_load64_zero(&f16_vec.u64);
+    v128_t f16_u32x4 = wasm_u32x4_extend_low_u16x8(f16_u16x4_in_u64);
+
+    // Extract bit fields
+    v128_t sign_u32x4 = wasm_v128_and(f16_u32x4, wasm_i32x4_splat(0x8000));                  // Bit 15
+    v128_t exp_u32x4 = wasm_v128_and(wasm_u32x4_shr(f16_u32x4, 10), wasm_i32x4_splat(0x1F)); // Bits 14-10
+    v128_t mant_u32x4 = wasm_v128_and(f16_u32x4, wasm_i32x4_splat(0x03FF));                  // Bits 9-0
+
+    // Shift sign to F32 position (bit 31)
+    v128_t sign_f32_u32x4 = wasm_i32x4_shl(sign_u32x4, 16);
+
+    // Normal (exp ∈ [1, 30])
+    // Rebias exponent: F16 bias=15, F32 bias=127 → add 112
+    // Shift mantissa: 10 bits → 23 bits (shift left by 13)
+    v128_t exp_rebiased_u32x4 = wasm_i32x4_add(exp_u32x4, wasm_i32x4_splat(112));
+    v128_t normal_exp_u32x4 = wasm_i32x4_shl(exp_rebiased_u32x4, 23);
+    v128_t normal_mant_u32x4 = wasm_i32x4_shl(mant_u32x4, 13);
+    v128_t normal_bits_u32x4 = wasm_v128_or(sign_f32_u32x4, wasm_v128_or(normal_exp_u32x4, normal_mant_u32x4));
+
+    // Zero (exp=0, mant=0)
+    v128_t zero_bits_u32x4 = sign_f32_u32x4; // Just sign bit
+
+    // Infinity/NaN (exp=31)
+    // Infinity: 0x7F800000 | sign
+    // NaN: 0x7F800000 | sign | (mant << 13) [preserves NaN payload]
+    v128_t inf_nan_bits_u32x4 = wasm_v128_or(
+        sign_f32_u32x4, wasm_v128_or(wasm_i32x4_splat(0x7F800000), wasm_i32x4_shl(mant_u32x4, 13)));
+
+    // Denormal (exp=0, mant≠0) - FPU-based normalization
+    // F16 denormal value = 2^-14 × (0.mantissa_bits) = mantissa_bits × 2^-24
+    //
+    // Strategy: Use FPU to normalize by converting to float and multiplying by magic constant
+    // 1. Convert mantissa (integer) to F32: cvt_u32_to_f32(mant)
+    // 2. Multiply by 2^-24 (magic constant 0x33800000 in F32)
+    // 3. FPU normalizes automatically, giving correct F32 representation
+    // 4. Reinterpret as bits and apply sign
+
+    // Convert mantissa u32 → f32 (each lane independently)
+    v128_t mant_f32x4 = wasm_f32x4_convert_u32x4(mant_u32x4);
+
+    // Multiply by 2^-24 (F32 hex: 0x33800000)
+    v128_t magic_f32x4 = wasm_f32x4_splat(0x1p-24f); // 2^-24 in hex float notation
+    v128_t denorm_normalized_f32x4 = wasm_f32x4_mul(mant_f32x4, magic_f32x4);
+
+    // Reinterpret f32x4 as u32x4 bits (v128_t is polymorphic - just assign)
+    v128_t denorm_bits_u32x4 = denorm_normalized_f32x4;
+
+    // Apply sign (OR with sign bit, since denorm result is always positive)
+    denorm_bits_u32x4 = wasm_v128_or(denorm_bits_u32x4, sign_f32_u32x4);
+
+    // Build Masks
+    v128_t exp_zero_mask = wasm_i32x4_eq(exp_u32x4, wasm_i32x4_splat(0));
+    v128_t mant_zero_mask = wasm_i32x4_eq(mant_u32x4, wasm_i32x4_splat(0));
+    v128_t exp_max_mask = wasm_i32x4_eq(exp_u32x4, wasm_i32x4_splat(31));
+
+    v128_t is_zero_mask = wasm_v128_and(exp_zero_mask, mant_zero_mask);        // exp=0 AND mant=0
+    v128_t is_denormal_mask = wasm_v128_andnot(exp_zero_mask, mant_zero_mask); // exp=0 AND mant≠0
+
+    // Blend the results
+    v128_t result_u32x4 = normal_bits_u32x4;
+
+    // Apply zero where exp=0 && mant=0
+    result_u32x4 = wasm_v128_bitselect(zero_bits_u32x4, result_u32x4, is_zero_mask);
+
+    // Apply denormal where exp=0 && mant≠0
+    result_u32x4 = wasm_v128_bitselect(denorm_bits_u32x4, result_u32x4, is_denormal_mask);
+
+    // Apply inf/NaN where exp=31
+    result_u32x4 = wasm_v128_bitselect(inf_nan_bits_u32x4, result_u32x4, exp_max_mask);
+
+    nk_b128_vec_t result;
+    result.v128 = result_u32x4;
+    return result;
+}
+
+#if defined(__cplusplus)
+}
+#endif
+
+#endif // NK_TARGET_V128RELAXED
+#endif // NK_CAST_WASM_H

include/numkong/dot.h

@@ -880,6 +880,21 @@ NK_INTERNAL void nk_dot_i8x32_finalize_sierra(
 
 #endif // NK_TARGET_SIERRA
 
+#if NK_TARGET_V128RELAXED
+/** @copydoc nk_dot_f32 */
+NK_PUBLIC void nk_dot_f32_wasm(nk_f32_t const *a, nk_f32_t const *b, nk_size_t n, nk_f32_t *result);
+/** @copydoc nk_dot_f64 */
+NK_PUBLIC void nk_dot_f64_wasm(nk_f64_t const *a, nk_f64_t const *b, nk_size_t n, nk_f64_t *result);
+/** @copydoc nk_dot_f16 */
+NK_PUBLIC void nk_dot_f16_wasm(nk_f16_t const *a, nk_f16_t const *b, nk_size_t n, nk_f32_t *result);
+/** @copydoc nk_dot_bf16 */
+NK_PUBLIC void nk_dot_bf16_wasm(nk_bf16_t const *a, nk_bf16_t const *b, nk_size_t n, nk_f32_t *result);
+/** @copydoc nk_dot_i8 */
+NK_PUBLIC void nk_dot_i8_wasm(nk_i8_t const *a, nk_i8_t const *b, nk_size_t n, nk_i32_t *result);
+/** @copydoc nk_dot_u8 */
+NK_PUBLIC void nk_dot_u8_wasm(nk_u8_t const *a, nk_u8_t const *b, nk_size_t n, nk_u32_t *result);
+#endif // NK_TARGET_V128RELAXED
+
 /**
  *  @brief  Returns the output dtype for dot products.
  */
@@ -917,11 +932,14 @@ NK_INTERNAL nk_dtype_t nk_dot_output_dtype(nk_dtype_t dtype) {
 #include "numkong/dot/spacemit.h"
 #include "numkong/dot/sifive.h"
 #include "numkong/dot/xuantie.h"
+#include "numkong/dot/wasm.h"
 
 #if !NK_DYNAMIC_DISPATCH
 
 NK_PUBLIC void nk_dot_i8(nk_i8_t const *a, nk_i8_t const *b, nk_size_t n, nk_i32_t *result) {
-#if NK_TARGET_SPACEMIT
+#if NK_TARGET_V128RELAXED
+    nk_dot_i8_wasm(a, b, n, result);
+#elif NK_TARGET_SPACEMIT
     nk_dot_i8_spacemit(a, b, n, result);
 #elif NK_TARGET_NEONSDOT
     nk_dot_i8_neonsdot(a, b, n, result);
@@ -936,7 +954,9 @@ NK_PUBLIC void nk_dot_i8(nk_i8_t const *a, nk_i8_t const *b, nk_size_t n, nk_i32
 #endif
 }
 NK_PUBLIC void nk_dot_u8(nk_u8_t const *a, nk_u8_t const *b, nk_size_t n, nk_u32_t *result) {
-#if NK_TARGET_SPACEMIT
+#if NK_TARGET_V128RELAXED
+    nk_dot_u8_wasm(a, b, n, result);
+#elif NK_TARGET_SPACEMIT
     nk_dot_u8_spacemit(a, b, n, result);
 #elif NK_TARGET_NEONSDOT
     nk_dot_u8_neonsdot(a, b, n, result);
@@ -973,7 +993,9 @@ NK_PUBLIC void nk_dot_u4(nk_u4x2_t const *a, nk_u4x2_t const *b, nk_size_t n, nk
 #endif
 }
 NK_PUBLIC void nk_dot_f16(nk_f16_t const *a, nk_f16_t const *b, nk_size_t n, nk_f32_t *result) {
-#if NK_TARGET_SIFIVE
+#if NK_TARGET_V128RELAXED
+    nk_dot_f16_wasm(a, b, n, result);
+#elif NK_TARGET_SIFIVE
     nk_dot_f16_sifive(a, b, n, result);
 #elif NK_TARGET_SPACEMIT
     nk_dot_f16_spacemit(a, b, n, result);
@@ -992,7 +1014,9 @@ NK_PUBLIC void nk_dot_f16(nk_f16_t const *a, nk_f16_t const *b, nk_size_t n, nk_
 #endif
 }
 NK_PUBLIC void nk_dot_bf16(nk_bf16_t const *a, nk_bf16_t const *b, nk_size_t n, nk_f32_t *result) {
-#if NK_TARGET_GENOA
+#if NK_TARGET_V128RELAXED
+    nk_dot_bf16_wasm(a, b, n, result);
+#elif NK_TARGET_GENOA
     nk_dot_bf16_genoa(a, b, n, result);
 #elif NK_TARGET_SPACEMIT
     nk_dot_bf16_spacemit(a, b, n, result);
@@ -1071,7 +1095,9 @@ NK_PUBLIC void nk_dot_e3m2(nk_e3m2_t const *a, nk_e3m2_t const *b, nk_size_t n,
 #endif
 }
 NK_PUBLIC void nk_dot_f32(nk_f32_t const *a, nk_f32_t const *b, nk_size_t n, nk_f32_t *result) {
-#if NK_TARGET_SPACEMIT
+#if NK_TARGET_V128RELAXED
+    nk_dot_f32_wasm(a, b, n, result);
+#elif NK_TARGET_SPACEMIT
     nk_dot_f32_spacemit(a, b, n, result);
 #elif NK_TARGET_SVE
     nk_dot_f32_sve(a, b, n, result);
@@ -1086,7 +1112,9 @@ NK_PUBLIC void nk_dot_f32(nk_f32_t const *a, nk_f32_t const *b, nk_size_t n, nk_
 #endif
 }
 NK_PUBLIC void nk_dot_f64(nk_f64_t const *a, nk_f64_t const *b, nk_size_t n, nk_f64_t *result) {
-#if NK_TARGET_SPACEMIT
+#if NK_TARGET_V128RELAXED
+    nk_dot_f64_wasm(a, b, n, result);
+#elif NK_TARGET_SPACEMIT
     nk_dot_f64_spacemit(a, b, n, result);
 #elif NK_TARGET_SVE
     nk_dot_f64_sve(a, b, n, result);