usearch 2.8.7 → 2.8.9

package/CITATION.cff

@@ -5,7 +5,7 @@ authors:
   given-names: "Ash"
   orcid: "https://orcid.org/0000-0002-4882-1815"
 title: "USearch by Unum Cloud"
-version: 2.8.7
+version: 2.8.9
 doi: 10.5281/zenodo.7949416
 date-released: 2023-10-22
 url: "https://github.com/unum-cloud/usearch"

package/CMakeLists.txt

@@ -19,7 +19,7 @@ option(USEARCH_INSTALL "Install CMake targets" OFF)
 option(USEARCH_USE_OPENMP "Use OpenMP for a thread pool" OFF)
 option(USEARCH_USE_SIMSIMD "Use SimSIMD hardware-accelerated metrics" OFF)
 option(USEARCH_USE_JEMALLOC "Use JeMalloc for faster memory allocations" OFF)
-option(USEARCH_USE_NATIVE_F16 "Use native half-precision types" OFF)
+option(USEARCH_USE_FP16LIB "Use software emulation for half-precision types" ON)
 
 option(USEARCH_BUILD_TEST_CPP "Compile a native unit test in C++" ${USEARCH_IS_MAIN_PROJECT})
 option(USEARCH_BUILD_BENCH_CPP "Compile a native benchmark in C++" ${USEARCH_IS_MAIN_PROJECT})
@@ -69,7 +69,7 @@ target_compile_definitions(
 
 # Supplementary compilation settings affecting "index_plugins.hpp"
 target_compile_definitions(
-    ${USEARCH_TARGET_NAME} INTERFACE $<$<NOT:$<BOOL:${USEARCH_USE_NATIVE_F16}>>:USEARCH_USE_NATIVE_F16=0>
+    ${USEARCH_TARGET_NAME} INTERFACE $<$<NOT:$<BOOL:${USEARCH_USE_FP16LIB}>>:USEARCH_USE_FP16LIB=1>
 )
 
 target_compile_definitions(
@@ -302,7 +302,7 @@ function (setup_target TARGET_NAME)
 
     # Supplementary compilation settings affecting "index_plugins.hpp"
     target_compile_definitions(
-        ${TARGET_NAME} PRIVATE $<$<NOT:$<BOOL:${USEARCH_USE_NATIVE_F16}>>:USEARCH_USE_NATIVE_F16=0>
+        ${TARGET_NAME} PRIVATE $<$<NOT:$<BOOL:${USEARCH_USE_FP16LIB}>>:USEARCH_USE_FP16LIB=1>
     )
 
     target_compile_definitions(${TARGET_NAME} PRIVATE $<$<NOT:$<BOOL:${USEARCH_USE_SIMSIMD}>>:USEARCH_USE_SIMSIMD=0>)

package/CONTRIBUTING.md

@@ -49,7 +49,7 @@ The CMakeLists.txt file has a number of options you can pass:
   - `USEARCH_USE_OPENMP` - use OpenMP for parallelism
   - `USEARCH_USE_SIMSIMD` - use SimSIMD for vectorization
   - `USEARCH_USE_JEMALLOC` - use Jemalloc for memory management
-  - `USEARCH_USE_NATIVE_F16` - use native half-precision floating point
+  - `USEARCH_USE_FP16LIB` - use software emulation for half-precision floating point
 
 Putting all of this together on Ubuntu and compiling the "release" version using the GCC 12 compiler:
 
@@ -58,7 +58,7 @@ cmake \
     -DCMAKE_BUILD_TYPE=Release \
     -DCMAKE_C_COMPILER=gcc-12 \
     -DCMAKE_CXX_COMPILER=g++-12 \
-    -DUSEARCH_USE_NATIVE_F16=1 \
+    -DUSEARCH_USE_FP16LIB=1 \
     -DUSEARCH_USE_OPENMP=1 \
     -DUSEARCH_USE_SIMSIMD=1 \
     -DUSEARCH_USE_JEMALLOC=1 \
@@ -80,7 +80,7 @@ cmake \
     -DCMAKE_BUILD_TYPE=Release \
     -DCMAKE_C_COMPILER="/opt/homebrew/opt/llvm/bin/clang" \
     -DCMAKE_CXX_COMPILER="/opt/homebrew/opt/llvm/bin/clang++" \
-    -DUSEARCH_USE_NATIVE_F16=1 \
+    -DUSEARCH_USE_FP16LIB=1 \
     -DUSEARCH_USE_OPENMP=1 \
     -DUSEARCH_USE_SIMSIMD=1 \
     -DUSEARCH_USE_JEMALLOC=1 \
@@ -144,6 +144,29 @@ node --test ./javascript/usearch.test.js
 npm publish
 ```
 
+To compile for AWS Lambda you'd need to recompile the binding.
+You can test the setup locally, overriding some of the compilation variables in Docker image:
+
+```Dockerfile
+FROM public.ecr.aws/lambda/nodejs:18-x86_64
+RUN npm init -y
+RUN yum install tar git python3 cmake gcc-c++ -y && yum groupinstall "Development Tools" -y
+
+# Assuming AWS Linux 2 uses old compilers:
+ENV USEARCH_USE_FP16LIB 1
+ENV DUSEARCH_USE_SIMSIMD 1
+ENV SIMSIMD_TARGET_X86_AVX2 1
+ENV SIMSIMD_TARGET_X86_AVX512 0
+ENV SIMSIMD_TARGET_ARM_NEON 1
+ENV SIMSIMD_TARGET_ARM_SVE 0
+
+# For specific PR:
+# RUN npm install --build-from-source unum-cloud/usearch#pull/302/head
+# For specific version:
+# RUN npm install --build-from-source usearch@2.8.8
+RUN npm install --build-from-source usearch
+```
+
 To compile to WebAssembly make sure you have `emscripten` installed and run the following script:
 
 ```sh

package/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "usearch"
-version = "2.8.7"
+version = "2.8.9"
 authors = ["Ash Vardanian <1983160+ashvardanian@users.noreply.github.com>"]
 description = "Smaller & Faster Single-File Vector Search Engine from Unum"
 edition = "2021"

package/Dockerfile

@@ -0,0 +1,16 @@
+# syntax=docker/dockerfile:1
+
+FROM ubuntu:23.04
+ENV DEBIAN_FRONTEND=noninteractive
+
+RUN apt-get update && \
+    apt-get install -y --no-install-recommends python3.11 python3-pip && \
+    apt-get clean && \
+    rm -rf /var/lib/apt/lists/*
+RUN pip3 install --no-cache-dir --break-system-packages ucall usearch
+
+WORKDIR /usearch
+COPY python/usearch/server.py server.py
+
+ENTRYPOINT ["python3", "./server.py"]
+EXPOSE 8545

package/README.md

@@ -1,6 +1,6 @@
 <h1 align="center">USearch</h1>
 <h3 align="center">
-Smaller & <a href="https://www.unum.cloud/blog/2023-11-11-scaling-vector-search">Faster</a> Single-File<br/>
+Smaller & <a href="https://www.unum.cloud/blog/2023-11-07-scaling-vector-search-with-intel">Faster</a> Single-File<br/>
 Similarity Search Engine for <a href="https://github.com/ashvardanian/simsimd">Vectors</a> & 🔜 <a href="https://github.com/ashvardanian/stringzilla">Texts</a>
 </h3>
 <br/>
@@ -47,7 +47,7 @@ Linux • MacOS • Windows • iOS • WebAssembly
 
 ---
 
-- ✅ 10x faster than [FAISS][faiss] implementation of [HNSW algorithm][hnsw-algorithm].
+- ✅ [20x faster than][faster-than-faiss] [FAISS][faiss] implementation of [HNSW algorithm][hnsw-algorithm].
 - ✅ Simple and extensible [single C++11 header][usearch-header] implementation.
 - ✅ Compatible with a dozen programming languages out of the box.
 - ✅ [SIMD][simd]-optimized and [user-defined metrics](#user-defined-functions) with JIT compilation.
@@ -57,7 +57,7 @@ Linux • MacOS • Windows • iOS • WebAssembly
 - ✅ Variable dimensionality vectors for unique applications, including search over compressed data.
 - ✅ Binary Tanimoto and Sorensen coefficients for [Genomics and Chemistry applications](#usearch--rdkit--molecular-search).
 - ✅ Space-efficient point-clouds with `uint40_t`, accommodating 4B+ size.
-- ✅ Compatible with OpenMP and custom "executors", for fine-grained control over CPU utilization.
+- ✅ Compatible with OpenMP and custom "executors" for fine-grained control over CPU utilization.
 - ✅ Near-real-time [clustering and sub-clustering](#clustering) for Tens or Millions of clusters.
 - ✅ [Semantic Search](#usearch--ai--multi-modal-semantic-search) and [Joins](#joins).
 
@@ -66,6 +66,7 @@ Linux • MacOS • Windows • iOS • WebAssembly
 [obscure-use-cases]: https://ashvardanian.com/posts/abusing-vector-search
 [hnsw-algorithm]: https://arxiv.org/abs/1603.09320
 [simd]: https://en.wikipedia.org/wiki/Single_instruction,_multiple_data
+[faster-than-faiss]: https://www.unum.cloud/blog/2023-11-07-scaling-vector-search-with-intel
 
 ## Comparison with FAISS
 
@@ -73,22 +74,22 @@ FAISS is a widely recognized standard for high-performance vector search engines
 USearch and FAISS both employ the same HNSW algorithm, but they differ significantly in their design principles.
 USearch is compact and broadly compatible without sacrificing performance, primarily focusing on user-defined metrics and fewer dependencies.
 
-|                                              |                         FAISS |                        USearch |              Improvement |
-| :------------------------------------------- | ----------------------------: | -----------------------------: | -----------------------: |
-| Indexing time                                |                               |                                |                          |
-| 100 Million 96d `f32`, `f16`, `i8` vectors   |           2.6 h, 2.6 h, 2.6 h |            0.3 h, 0.2 h, 0.2 h | __9.6x, 10.4x, 10.7x__ ⁰ |
-| 100 Million 1536d `f32`, `f16`, `i8` vectors |           5.0 h, 4.1 h, 3.8 h |            2.1 h, 1.1 h, 0.8 h |    __2.3x 3.6x, 4.4x__ ⁰ |
-|                                              |                               |                                |                          |
-| Codebase length                              | 84 K [SLOC][sloc] in `faiss/` | 3 K [SLOC][sloc] in `usearch/` |           maintainable ¹ |
-| Supported metrics                            |               9 fixed metrics |       any user-defined metrics |             extendible ² |
-| Supported languages                          |                   C++, Python |                   10 languages |               portable ³ |
-| Supported ID types                           |                32-bit, 64-bit |         32-bit, 40-bit, 64-bit |              efficient ⁴ |
-| Required dependencies                        |                  BLAS, OpenMP |                              - |           light-weight ⁵ |
-| Bindings                                     |                          SWIG |                         Native |            low-latency ⁶ |
+|                                              |                         FAISS |                        USearch |            Improvement |
+| :------------------------------------------- | ----------------------------: | -----------------------------: | ---------------------: |
+| Indexing time ⁰                              |                               |                                |                        |
+| 100 Million 96d `f32`, `f16`, `i8` vectors   |           2.6 h, 2.6 h, 2.6 h |            0.3 h, 0.2 h, 0.2 h | __9.6x, 10.4x, 10.7x__ |
+| 100 Million 1536d `f32`, `f16`, `i8` vectors |           5.0 h, 4.1 h, 3.8 h |            2.1 h, 1.1 h, 0.8 h |    __2.3x 3.6x, 4.4x__ |
+|                                              |                               |                                |                        |
+| Codebase length ¹                            | 84 K [SLOC][sloc] in `faiss/` | 3 K [SLOC][sloc] in `usearch/` |           maintainable |
+| Supported metrics ²                          |               9 fixed metrics |       any user-defined metrics |             extendible |
+| Supported languages ³                        |                   C++, Python |                   10 languages |               portable |
+| Supported ID types ⁴                         |                32-bit, 64-bit |         32-bit, 40-bit, 64-bit |              efficient |
+| Required dependencies ⁵                      |                  BLAS, OpenMP |                              - |           light-weight |
+| Bindings ⁶                                   |                          SWIG |                         Native |            low-latency |
 
 [sloc]: https://en.wikipedia.org/wiki/Source_lines_of_code
 
-> ⁰ [Tested][intel-benchmarks] on Intel Sapphire Rapids, with the simplest inner-product distance, equivalent recall, and memory consumption, while also providing far superior search speed.
+> ⁰ [Tested][intel-benchmarks] on Intel Sapphire Rapids, with the simplest inner-product distance, equivalent recall, and memory consumption while also providing far superior search speed.
 > ¹ A shorter codebase makes the project easier to maintain and audit.
 > ² User-defined metrics allow you to customize your search for various applications, from GIS to creating custom metrics for composite embeddings from multiple AI models or hybrid full-text and semantic search.
 > ³ With USearch, you can reuse the same preconstructed index in various programming languages.
@@ -96,12 +97,12 @@ USearch is compact and broadly compatible without sacrificing performance, prima
 > ⁵ Lack of obligatory dependencies makes USearch much more portable.
 > ⁶ Native bindings introduce lower call latencies than more straightforward approaches.
 
-[intel-benchmarks]: https://www.unum.cloud/blog/2023-11-11-scaling-vector-search
+[intel-benchmarks]: https://www.unum.cloud/blog/2023-11-07-scaling-vector-search-with-intel
 
 Base functionality is identical to FAISS, and the interface must be familiar if you have ever investigated Approximate Nearest Neighbors search:
 
 ```py
-$ pip install usearch
+$ pip install numpy usearch
 
 import numpy as np
 from usearch.index import Index
@@ -125,16 +126,16 @@ index = Index(
     ndim=3, # Define the number of dimensions in input vectors
     metric='cos', # Choose 'l2sq', 'haversine' or other metric, default = 'ip'
     dtype='f32', # Quantize to 'f16' or 'i8' if needed, default = 'f32'
-    connectivity=16, # Optional: How frequent should the connections in the graph be
+    connectivity=16, # Optional: Limit number of neighbors per graph node
     expansion_add=128, # Optional: Control the recall of indexing
-    expansion_search=64, # Optional: Control the quality of search
+    expansion_search=64, # Optional: Control the quality of the search
 )
 ```
 
 ## User-Defined Functions
 
-While most vector search packages concentrate on just a couple of metrics - "Inner Product distance" and "Euclidean distance," USearch extends this list to include any user-defined metrics.
-This flexibility allows you to customize your search for a myriad of applications, from computing geo-spatial coordinates with the rare [Haversine][haversine] distance to creating custom metrics for composite embeddings from multiple AI models.
+While most vector search packages concentrate on just a few metrics - "Inner Product distance" and "Euclidean distance," USearch extends this list to include any user-defined metrics.
+This flexibility allows you to customize your search for various applications, from computing geospatial coordinates with the rare [Haversine][haversine] distance to creating custom metrics for composite embeddings from multiple AI models.
 
 ![USearch: Vector Search Approaches](https://github.com/unum-cloud/usearch/blob/main/assets/usearch-approaches-white.png?raw=true)
 
@@ -165,7 +166,7 @@ USearch supports multiple forms of serialization:
 
 - Into a __file__ defined with a path.
 - Into a __stream__ defined with a callback, serializing or reconstructing incrementally.
-- Into a __buffer__ of fixed length, or a memory-mapped file, that supports random access.
+- Into a __buffer__ of fixed length or a memory-mapped file that supports random access.
 
 The latter allows you to serve indexes from external memory, enabling you to optimize your server choices for indexing speed and serving costs.
 This can result in __20x cost reduction__ on AWS and other public clouds.
@@ -198,7 +199,7 @@ one_in_many: Matches = search(vectors, vector, 50, MetricKind.L2sq, exact=True)
 many_in_many: BatchMatches = search(vectors, vectors, 50, MetricKind.L2sq, exact=True)
 ```
 
-By passing the `exact=True` argument, the system bypasses indexing altogether and performs a brute-force search through the entire dataset using SIMD-optimized similarity metrics from [SimSIMD](https://github.com/ashvardanian/simsimd).
+If you pass the `exact=True` argument, the system bypasses indexing altogether and performs a brute-force search through the entire dataset using SIMD-optimized similarity metrics from [SimSIMD](https://github.com/ashvardanian/simsimd).
 When compared to FAISS's `IndexFlatL2` in Google Colab, __[USearch may offer up to a 20x performance improvement](https://github.com/unum-cloud/usearch/issues/176#issuecomment-1666650778)__:
 
 - `faiss.IndexFlatL2`: __55.3 ms__.
@@ -207,7 +208,7 @@ When compared to FAISS's `IndexFlatL2` in Google Colab, __[USearch may offer up
 ## `Indexes` for Multi-Index Lookups
 
 For larger workloads targeting billions or even trillions of vectors, parallel multi-index lookups become invaluable.
-These lookups prevent the need to construct a single, massive index, allowing users to query multiple smaller ones instead.
+Instead of constructing one extensive index, you can build multiple smaller ones and view them together.
 
 ```py
 from usearch.index import Indexes
@@ -223,8 +224,8 @@ multi_index.search(...)
 
 ## Clustering
 
-Once the index is constructed, it can be used to cluster entries much faster.
-In essence, the `Index` itself can be seen as a clustering, and it allows iterative deepening.
+Once the index is constructed, it can cluster entries much faster than using a separate clustering algorithm implementation.
+Essentially, the `Index` itself can be seen as a clustering, allowing iterative deepening.
 
 ```py
 clustering = index.cluster(
@@ -236,7 +237,7 @@ clustering = index.cluster(
 # Get the clusters and their sizes
 centroid_keys, sizes = clustering.centroids_popularity
 
-# Use Matplotlib draw a histogram
+# Use Matplotlib to draw a histogram
 clustering.plot_centroids_popularity()
 
 # Export a NetworkX graph of the clusters
@@ -245,24 +246,26 @@ g = clustering.network
 # Get members of a specific cluster
 first_members = clustering.members_of(centroid_keys[0])
 
-# Deepen into that cluster splitting it into more parts, all same arguments supported
+# Deepen into that cluster, splitting it into more parts, all the same arguments supported
 sub_clustering = clustering.subcluster(min_count=..., max_count=...)
 ```
 
-Using Scikit-Learn, on a 1 Million point dataset, one may expect queries to take anywhere from minutes to hours, depending on the number of clusters you want to highlight. For 50'000 clusters the performance difference between USearch and conventional clustering methods may easily reach 100x.
+The resulting clustering isn't identical to K-Means or other conventional approaches but serves the same purpose.
+Alternatively, using Scikit-Learn on a 1 Million point dataset, one may expect queries to take anywhere from minutes to hours, depending on the number of clusters you want to highlight.
+For 50'000 clusters, the performance difference between USearch and conventional clustering methods may easily reach 100x.
 
 ## Joins, One-to-One, One-to-Many, and Many-to-Many Mappings
 
-One of the big questions these days is how will AI change the world of databases and data management.
+One of the big questions these days is how AI will change the world of databases and data management.
 Most databases are still struggling to implement high-quality fuzzy search, and the only kind of joins they know are deterministic.
-A `join` is different from searching for every entry, as it requires a one-to-one mapping, banning collisions among separate search results.
+A `join` differs from searching for every entry, requiring a one-to-one mapping banning collisions among separate search results.
 
 | Exact Search | Fuzzy Search | Semantic Search ? |
 | :----------: | :----------: | :---------------: |
 |  Exact Join  | Fuzzy Join ? | Semantic Join ??  |
 
-Using USearch one can implement sub-quadratic complexity approximate, fuzzy, and semantic joins.
-This can come in handy in any fuzzy-matching tasks, common to Database Management Software.
+Using USearch, one can implement sub-quadratic complexity approximate, fuzzy, and semantic joins.
+This can be useful in any fuzzy-matching tasks common to Database Management Software.
 
 ```py
 men = Index(...)
@@ -270,7 +273,7 @@ women = Index(...)
 pairs: dict = men.join(women, max_proposals=0, exact=False)
 ```
 
-> Read more in post: [From Dating to Vector Search - "Stable Marriages" on a Planetary Scale 👩‍❤️‍👨](https://ashvardanian.com/posts/searching-stable-marriages)
+> Read more in the post: [Combinatorial Stable Marriages for Semantic Search 💍](https://ashvardanian.com/posts/searching-stable-marriages)
 
 ## Functionality
 
@@ -345,7 +348,7 @@ We have pre-processed some commonly used datasets, cleaned the images, produced
 Comparing molecule graphs and searching for similar structures is expensive and slow.
 It can be seen as a special case of the NP-Complete Subgraph Isomorphism problem.
 Luckily, domain-specific approximate methods exist.
-The one commonly used in Chemistry, is to generate structures from [SMILES][smiles], and later hash them into binary fingerprints.
+The one commonly used in Chemistry is to generate structures from [SMILES][smiles] and later hash them into binary fingerprints.
 The latter are searchable with binary similarity metrics, like the Tanimoto coefficient.
 Below is an example using the RDKit package.
 
@@ -379,7 +382,7 @@ matches = index.search(fingerprints, 10)
 With Objective-C and Swift iOS bindings, USearch can be easily used in mobile applications.
 The [SwiftVectorSearch](https://github.com/ashvardanian/SwiftVectorSearch) project illustrates how to build a dynamic, real-time search system on iOS.
 In this example, we use 2-dimensional vectors—encoded as latitude and longitude—to find the closest Points of Interest (POIs) on a map.
-The search is based on the Haversine distance metric, but can easily be extended to support high-dimensional vectors.
+The search is based on the Haversine distance metric but can easily be extended to support high-dimensional vectors.
 
 ## Integrations
 
@@ -397,7 +400,7 @@ doi = {10.5281/zenodo.7949416},
 author = {Vardanian, Ash},
 title = {{USearch by Unum Cloud}},
 url = {https://github.com/unum-cloud/usearch},
-version = {2.8.7},
+version = {2.8.9},
 year = {2023},
 month = oct,
 }

package/VERSION

@@ -0,0 +1 @@
+2.8.9

package/binding.gyp

@@ -3,14 +3,6 @@
         {
             "target_name": "usearch",
             "sources": ["javascript/lib.cpp"],
-            "include_dirs": [
-                "<!@(node -p \"require('node-addon-api').include\")",
-                "include",
-                "fp16/include",
-                "simsimd/include",
-            ],
-            "dependencies": ["<!(node -p \"require('node-addon-api').gyp\")"],
-            "defines": ["USEARCH_USE_SIMSIMD=1", "USEARCH_USE_NATIVE_F16=0"],
             "cflags": [
                 "-fexceptions",
                 "-Wno-unknown-pragmas",
@@ -22,6 +14,13 @@
                 "-Wno-maybe-uninitialized",
                 "-std=c++17",
             ],
+            "include_dirs": [
+                "<!@(node -p \"require('node-addon-api').include\")",
+                "include",
+                "fp16/include",
+                "simsimd/include",
+            ],
+            "dependencies": ["<!(node -p \"require('node-addon-api').gyp\")"],
             "xcode_settings": {
                 "GCC_ENABLE_CPP_EXCEPTIONS": "YES",
                 "CLANG_CXX_LIBRARY": "libc++",
@@ -33,6 +32,56 @@
                     "AdditionalOptions": ["-std:c++17"],
                 }
             },
+            "conditions": [
+                [
+                    'OS=="linux"',
+                    {
+                        "cflags_cc": [
+                            '<!(if [ "$USEARCH_USE_OPENMP" = "1" ]; then echo \'-fopenmp\'; fi)',
+                        ],
+                        "ldflags": [
+                            '<!(if [ "$USEARCH_USE_OPENMP" = "1" ]; then echo \'-lgomp\'; fi)'
+                        ],
+                        "defines": [
+                            "USEARCH_USE_OPENMP=<!(echo ${USEARCH_USE_OPENMP:-0})",
+                            "USEARCH_USE_SIMSIMD=<!(echo ${USEARCH_USE_SIMSIMD:-1})",
+                            "USEARCH_USE_FP16LIB=<!(echo ${USEARCH_USE_FP16LIB:-1})",
+                            "SIMSIMD_TARGET_X86_AVX512=<!(echo ${SIMSIMD_TARGET_X86_AVX512:-1})",
+                            "SIMSIMD_TARGET_ARM_SVE=<!(echo ${SIMSIMD_TARGET_ARM_SVE:-1})",
+                            "SIMSIMD_TARGET_X86_AVX2=<!(echo ${SIMSIMD_TARGET_X86_AVX2:-1})",
+                            "SIMSIMD_TARGET_ARM_NEON=<!(echo ${SIMSIMD_TARGET_ARM_NEON:-1})",
+                        ],
+                    },
+                ],
+                [
+                    'OS=="mac"',
+                    {
+                        "defines": [
+                            "USEARCH_USE_OPENMP=<!(echo ${USEARCH_USE_OPENMP:-0})",
+                            "USEARCH_USE_SIMSIMD=<!(echo ${USEARCH_USE_SIMSIMD:-0})",
+                            "USEARCH_USE_FP16LIB=<!(echo ${USEARCH_USE_FP16LIB:-1})",
+                            "SIMSIMD_TARGET_X86_AVX512=<!(echo ${SIMSIMD_TARGET_X86_AVX512:-0})",
+                            "SIMSIMD_TARGET_ARM_SVE=<!(echo ${SIMSIMD_TARGET_ARM_SVE:-0})",
+                            "SIMSIMD_TARGET_X86_AVX2=<!(echo ${SIMSIMD_TARGET_X86_AVX2:-1})",
+                            "SIMSIMD_TARGET_ARM_NEON=<!(echo ${SIMSIMD_TARGET_ARM_NEON:-1})",
+                        ],
+                    },
+                ],
+                [
+                    'OS=="win"',
+                    {
+                        "defines": [
+                            "USEARCH_USE_OPENMP=0",
+                            "USEARCH_USE_SIMSIMD=0",
+                            "USEARCH_USE_FP16LIB=1",
+                            "SIMSIMD_TARGET_X86_AVX512=0",
+                            "SIMSIMD_TARGET_ARM_SVE=0",
+                            "SIMSIMD_TARGET_X86_AVX2=0",
+                            "SIMSIMD_TARGET_ARM_NEON=0",
+                        ],
+                    },
+                ],
+            ],
         }
     ]
 }

package/conanfile.py

@@ -7,7 +7,7 @@ required_conan_version = ">=1.53.0"
 class USearchConan(ConanFile):
 
     name = "usearch"
-    version = '2.8.7'
+    version = '2.8.9'
     license = "Apache-2.0"
     description = "Smaller & Faster Single-File Vector Search Engine from Unum"
     homepage = "https://github.com/unum-cloud/usearch"

package/include/usearch/index.hpp

@@ -11,7 +11,7 @@
 
 #define USEARCH_VERSION_MAJOR 2
 #define USEARCH_VERSION_MINOR 8
-#define USEARCH_VERSION_PATCH 7
+#define USEARCH_VERSION_PATCH 9
 
 // Inferring C++ version
 // https://stackoverflow.com/a/61552074

package/include/usearch/index_plugins.hpp

@@ -13,6 +13,10 @@
 
 #include <usearch/index.hpp> // `expected_gt` and macros
 
+#if !defined(USEARCH_USE_OPENMP)
+#define USEARCH_USE_OPENMP 0
+#endif
+
 #if USEARCH_USE_OPENMP
 #include <omp.h> // `omp_get_num_threads()`
 #endif
@@ -21,18 +25,18 @@
 #include <sys/auxv.h> // `getauxval()`
 #endif
 
-#if !defined(USEARCH_USE_NATIVE_F16)
+#if !defined(USEARCH_USE_FP16LIB)
 #if defined(__AVX512F__)
-#define USEARCH_USE_NATIVE_F16 1
+#define USEARCH_USE_FP16LIB 0
 #elif defined(USEARCH_DEFINED_ARM)
 #include <arm_fp16.h> // `__fp16`
-#define USEARCH_USE_NATIVE_F16 1
+#define USEARCH_USE_FP16LIB 0
 #else
-#define USEARCH_USE_NATIVE_F16 0
+#define USEARCH_USE_FP16LIB 1
 #endif
 #endif
 
-#if !USEARCH_USE_NATIVE_F16
+#if USEARCH_USE_FP16LIB
 #include <fp16/fp16.h>
 #endif
 
@@ -41,27 +45,27 @@
 #endif
 
 #if USEARCH_USE_SIMSIMD
+
 // Propagate the `f16` settings
-#define SIMSIMD_NATIVE_F16 USEARCH_USE_NATIVE_F16
-#if defined(USEARCH_DEFINED_LINUX)
+#define SIMSIMD_NATIVE_F16 !USEARCH_USE_FP16LIB
+
+#if !defined(SIMSIMD_TARGET_X86_AVX512) && defined(USEARCH_DEFINED_LINUX)
 #define SIMSIMD_TARGET_X86_AVX512 1
+#endif
+
+#if !defined(SIMSIMD_TARGET_ARM_SVE) && defined(USEARCH_DEFINED_LINUX)
 #define SIMSIMD_TARGET_ARM_SVE 1
+#endif
+
+#if !defined(SIMSIMD_TARGET_X86_AVX2) && (defined(USEARCH_DEFINED_LINUX) || defined(USEARCH_DEFINED_APPLE))
 #define SIMSIMD_TARGET_X86_AVX2 1
+#endif
+
+#if !defined(SIMSIMD_TARGET_ARM_NEON) && (defined(USEARCH_DEFINED_LINUX) || defined(USEARCH_DEFINED_APPLE))
 #define SIMSIMD_TARGET_ARM_NEON 1
-#include <simsimd/simsimd.h>
-#elif defined(USEARCH_DEFINED_APPLE)
-#define SIMSIMD_TARGET_X86_AVX512 0
-#define SIMSIMD_TARGET_ARM_SVE 0
-#define SIMSIMD_TARGET_X86_AVX2 1
-#define SIMSIMD_TARGET_ARM_NEON 1
-#include <simsimd/simsimd.h>
-#else
-#define SIMSIMD_TARGET_X86_AVX512 0
-#define SIMSIMD_TARGET_ARM_SVE 0
-#define SIMSIMD_TARGET_X86_AVX2 0
-#define SIMSIMD_TARGET_ARM_NEON 0
-#include <simsimd/simsimd.h>
 #endif
+
+#include <simsimd/simsimd.h>
 #endif
 
 namespace unum {
@@ -77,7 +81,7 @@ struct uuid_t {
 class f16_bits_t;
 class i8_converted_t;
 
-#if USEARCH_USE_NATIVE_F16
+#if !USEARCH_USE_FP16LIB
 #if defined(USEARCH_DEFINED_ARM)
 using f16_native_t = __fp16;
 #else
@@ -298,7 +302,7 @@ inline expected_gt<metric_kind_t> metric_from_name(char const* name) {
 }
 
 inline float f16_to_f32(std::uint16_t u16) noexcept {
-#if USEARCH_USE_NATIVE_F16
+#if !USEARCH_USE_FP16LIB
     f16_native_t f16;
     std::memcpy(&f16, &u16, sizeof(std::uint16_t));
     return float(f16);
@@ -308,7 +312,7 @@ inline float f16_to_f32(std::uint16_t u16) noexcept {
 }
 
 inline std::uint16_t f32_to_f16(float f32) noexcept {
-#if USEARCH_USE_NATIVE_F16
+#if !USEARCH_USE_FP16LIB
     f16_native_t f16 = f16_native_t(f32);
     std::uint16_t u16;
     std::memcpy(&u16, &f16, sizeof(std::uint16_t));
@@ -1415,7 +1419,7 @@ class metric_punned_t {
         if (simd_metric == nullptr)
             return false;
 
-        raw_ptr_ = (punned_ptr_t)simd_metric;
+        std::memcpy(&raw_ptr_, &simd_metric, sizeof(simd_metric));
         isa_kind_ = simd_kind;
         return true;
     }