usearch 2.21.3 → 2.25.0

package/README.md

@@ -1,7 +1,7 @@
 <h1 align="center">USearch</h1>
 <h3 align="center">
 Smaller & <a href="https://www.unum.cloud/blog/2023-11-07-scaling-vector-search-with-intel">Faster</a> Single-File<br/>
-Similarity Search & Clustering Engine for <a href="https://github.com/ashvardanian/simsimd">Vectors</a> & 🔜 <a href="https://github.com/ashvardanian/stringzilla">Texts</a>
+Similarity Search & Clustering Engine for <a href="https://github.com/ashvardanian/numkong">Vectors</a> & 🔜 <a href="https://github.com/ashvardanian/stringzilla">Texts</a>
 </h3>
 <br/>
 
@@ -14,26 +14,26 @@ Similarity Search & Clustering Engine for <a href="https://github.com/ashvardani
 &nbsp;&nbsp;&nbsp;
 <a href="https://unum.cloud/post"><img height="25" src="https://github.com/unum-cloud/.github/raw/main/assets/blog.svg" alt="Blog"></a>
 &nbsp;&nbsp;&nbsp;
-<a href="https://github.com/unum-cloud/usearch"><img height="25" src="https://github.com/unum-cloud/.github/raw/main/assets/github.svg" alt="GitHub"></a>
+<a href="https://github.com/unum-cloud/USearch"><img height="25" src="https://github.com/unum-cloud/.github/raw/main/assets/github.svg" alt="GitHub"></a>
 </p>
 
 <p align="center">
 Spatial • Binary • Probabilistic • User-Defined Metrics
 <br/>
-<a href="https://unum-cloud.github.io/usearch/cpp">C++11</a> •
-<a href="https://unum-cloud.github.io/usearch/python">Python 3</a> •
-<a href="https://unum-cloud.github.io/usearch/javascript">JavaScript</a> •
-<a href="https://unum-cloud.github.io/usearch/java">Java</a> •
-<a href="https://unum-cloud.github.io/usearch/rust">Rust</a> •
-<a href="https://unum-cloud.github.io/usearch/c">C99</a> •
-<a href="https://unum-cloud.github.io/usearch/objective-c">Objective-C</a> •
-<a href="https://unum-cloud.github.io/usearch/swift">Swift</a> •
-<a href="https://unum-cloud.github.io/usearch/csharp">C#</a> •
-<a href="https://unum-cloud.github.io/usearch/golang">Go</a> •
-<a href="https://unum-cloud.github.io/usearch/wolfram">Wolfram</a>
+<a href="https://unum-cloud.github.io/USearch/cpp">C++11</a> •
+<a href="https://unum-cloud.github.io/USearch/python">Python 3</a> •
+<a href="https://unum-cloud.github.io/USearch/javascript">JavaScript</a> •
+<a href="https://unum-cloud.github.io/USearch/java">Java</a> •
+<a href="https://unum-cloud.github.io/USearch/rust">Rust</a> •
+<a href="https://unum-cloud.github.io/USearch/c">C99</a> •
+<a href="https://unum-cloud.github.io/USearch/objective-c">Objective-C</a> •
+<a href="https://unum-cloud.github.io/USearch/swift">Swift</a> •
+<a href="https://unum-cloud.github.io/USearch/csharp">C#</a> •
+<a href="https://unum-cloud.github.io/USearch/golang">Go</a> •
+<a href="https://unum-cloud.github.io/USearch/wolfram">Wolfram</a>
 <br/>
 Linux • macOS • Windows • iOS • Android • WebAssembly •
-<a href="https://unum-cloud.github.io/usearch/sqlite">SQLite</a>
+<a href="https://unum-cloud.github.io/USearch/sqlite">SQLite</a>
 </p>
 
 <div align="center">
@@ -57,11 +57,11 @@ Linux • macOS • Windows • iOS • Android • WebAssembly •
 - ✅ 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 parallelism.
-- ✅ [Semantic Search](#usearch--ai--multi-modal-semantic-search) and [Joins](#joins-one-to-one-one-to-many-and-many-to-many-mappings).
+- ✅ [Semantic Search](#usearch--uform--ucall--multimodal-semantic-search) and [Joins](#joins-one-to-one-one-to-many-and-many-to-many-mappings).
 - 🔄 Near-real-time [clustering and sub-clustering](#clustering) for Tens or Millions of clusters.
 
 [faiss]: https://github.com/facebookresearch/faiss
-[usearch-header]: https://github.com/unum-cloud/usearch/blob/main/include/usearch/index.hpp
+[usearch-header]: https://github.com/unum-cloud/USearch/blob/main/include/usearch/index.hpp
 [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
@@ -185,8 +185,8 @@ one_in_many: Matches = search(vectors, vector, 50, MetricKind.L2sq, exact=True)
 many_in_many: BatchMatches = search(vectors, vectors, 50, MetricKind.L2sq, exact=True)
 ```
 
-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)__:
+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 [NumKong](https://github.com/ashvardanian/numkong).
+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__.
 - `usearch.index.search`: __2.54 ms__.
@@ -195,7 +195,7 @@ When compared to FAISS's `IndexFlatL2` in Google Colab, __[USearch may offer up
 
 While most vector search packages concentrate on just two metrics, "Inner Product distance" and "Euclidean distance", USearch allows arbitrary 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, like joint image-text embeddings.
-You can use [Numba][numba], [Cppyy][cppyy], or [PeachPy][peachpy] to define your [custom metric even in Python](https://unum-cloud.github.io/usearch/python#user-defined-metrics-and-jit-in-python):
+You can use [Numba][numba], [Cppyy][cppyy], or [PeachPy][peachpy] to define your [custom metric even in Python](https://unum-cloud.github.io/USearch/python#user-defined-metrics-and-jit-in-python):
 
 ```py
 from numba import cfunc, types, carray
@@ -268,7 +268,7 @@ As part of the quantization process, the vectors are normalized to unit length a
 When quantizing to `b1x8_t` single-bit representations, note that it's only valid for binary metrics like Jaccard, Hamming, etc.
 As part of the quantization process, the scalar components greater than zero are set to `true`, and the rest to `false`.
 
-![USearch uint40_t support](https://github.com/unum-cloud/usearch/blob/main/assets/usearch-neighbor-types.png?raw=true)
+![USearch uint40_t support](https://github.com/unum-cloud/USearch/blob/main/assets/usearch-neighbor-types.png?raw=true)
 
 Using smaller numeric types will save you RAM needed to store the vectors, but you can also compress the neighbors lists forming our proximity graphs.
 By default, 32-bit `uint32_t` is used to enumerate those, which is not enough if you need to address over 4 Billion entries.
@@ -533,15 +533,15 @@ index = Index(ndim=ndim, metric=CompiledMetric(
 - [x] ScyllaDB: [Rust](https://github.com/scylladb/vector-store), [presentation](https://www.slideshare.net/slideshow/vector-search-with-scylladb-by-szymon-wasik/276571548).
 - [x] TiDB & TiFlash: [C++](https://github.com/pingcap/tiflash), [announcement](https://www.pingcap.com/article/introduce-vector-search-indexes-in-tidb/).
 - [x] YugaByte: [C++](https://github.com/yugabyte/yugabyte-db/blob/366b9f5e3c4df3a1a17d553db41d6dc50146f488/src/yb/vector_index/usearch_wrapper.cc).
-- [x] Google: [UniSim](https://github.com/google/unisim), [RetSim](https://arxiv.org/abs/2311.17264) paper.
 - [x] MemGraph: [C++](https://github.com/memgraph/memgraph/blob/784dd8520f65050d033aea8b29446e84e487d091/src/storage/v2/indices/vector_index.cpp), [announcement](https://memgraph.com/blog/simplify-data-retrieval-memgraph-vector-search).
-- [x] LanternDB: [C++](https://github.com/lanterndata/lantern), [Rust](https://github.com/lanterndata/lantern_extras), [docs](https://lantern.dev/blog/hnsw-index-creation).
+- [x] Google: [UniSim](https://github.com/google/unisim), [RetSim](https://arxiv.org/abs/2311.17264) paper.
 - [x] LangChain: [Python](https://github.com/langchain-ai/langchain/releases/tag/v0.0.257) and [JavaScript](https://github.com/hwchase17/langchainjs/releases/tag/0.0.125).
 - [x] Microsoft Semantic Kernel: [Python](https://github.com/microsoft/semantic-kernel/releases/tag/python-0.3.9.dev) and C#.
 - [x] GPTCache: [Python](https://github.com/zilliztech/GPTCache/releases/tag/0.1.29).
 - [x] Sentence-Transformers: Python [docs](https://www.sbert.net/docs/package_reference/quantization.html#sentence_transformers.quantization.semantic_search_usearch).
 - [x] Pathway: [Rust](https://github.com/pathwaycom/pathway).
 - [x] Vald: [GoLang](https://github.com/vdaas/vald).
+- [x] MatrixOne: [GoLang](https://github.com/matrixorigin/matrixone).
   
 
 ## Citations
@@ -551,8 +551,8 @@ index = Index(ndim=ndim, metric=CompiledMetric(
 doi = {10.5281/zenodo.7949416},
 author = {Vardanian, Ash},
 title = {{USearch by Unum Cloud}},
-url = {https://github.com/unum-cloud/usearch},
-version = {2.21.3},
+url = {https://github.com/unum-cloud/USearch},
+version = {2.25.0},
 year = {2023},
 month = oct,
 }

package/binding.gyp

@@ -1,8 +1,16 @@
 {
+    "variables": {
+        "numkong_root": "./numkong",
+    },
+    "includes": ["./numkong/numkong.gypi"],
     "targets": [
         {
             "target_name": "usearch",
-            "sources": ["javascript/lib.cpp", "simsimd/c/lib.c"],
+            "sources": ["javascript/lib.cpp"],
+            "dependencies": [
+                "<!(node -p \"require('node-addon-api').gyp\")",
+                "numkong_lib",
+            ],
             "cflags": [
                 "-fexceptions",
                 "-Wno-unknown-pragmas",
@@ -17,10 +25,11 @@
             "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_NUMKONG=1",
+                "NK_DYNAMIC_DISPATCH=1",
+            ],
             "xcode_settings": {
                 "GCC_ENABLE_CPP_EXCEPTIONS": "YES",
                 "CLANG_CXX_LIBRARY": "libc++",
@@ -31,7 +40,7 @@
             "msvs_settings": {
                 "VCCLCompilerTool": {
                     "ExceptionHandling": 1,
-                    "AdditionalOptions": ["-std:c++17"],
+                    "AdditionalOptions": ["-std:c++17", "/Zc:preprocessor"],
                 }
             },
             "conditions": [
@@ -44,17 +53,6 @@
                         "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_NEON=<!(echo ${SIMSIMD_TARGET_NEON:-1})",
-                            "SIMSIMD_TARGET_NEON_BF16=<!(echo ${SIMSIMD_TARGET_NEON_BF16:-0})",
-                            "SIMSIMD_TARGET_SVE=<!(echo ${SIMSIMD_TARGET_SVE:-1})",
-                            "SIMSIMD_TARGET_SVE_BF16=<!(echo ${SIMSIMD_TARGET_SVE_BF16:-0})",
-                            "SIMSIMD_TARGET_HASWELL=<!(echo ${SIMSIMD_TARGET_HASWELL:-1})",
-                            "SIMSIMD_TARGET_SKYLAKE=<!(echo ${SIMSIMD_TARGET_SKYLAKE:-1})",
-                            "SIMSIMD_TARGET_ICE=<!(echo ${SIMSIMD_TARGET_ICE:-1})",
-                            "SIMSIMD_TARGET_GENOA=<!(echo ${SIMSIMD_TARGET_GENOA:-1})",
-                            "SIMSIMD_TARGET_SAPPHIRE=<!(echo ${SIMSIMD_TARGET_SAPPHIRE:-1})",
                         ],
                     },
                 ],
@@ -62,17 +60,7 @@
                     '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_NEON=<!(echo ${SIMSIMD_TARGET_NEON:-1})",
-                            "SIMSIMD_TARGET_NEON_BF16=<!(echo ${SIMSIMD_TARGET_NEON_BF16:-0})",
-                            "SIMSIMD_TARGET_SVE=<!(echo ${SIMSIMD_TARGET_SVE:-0})",
-                            "SIMSIMD_TARGET_HASWELL=<!(echo ${SIMSIMD_TARGET_HASWELL:-1})",
-                            "SIMSIMD_TARGET_SKYLAKE=<!(echo ${SIMSIMD_TARGET_SKYLAKE:-0})",
-                            "SIMSIMD_TARGET_ICE=<!(echo ${SIMSIMD_TARGET_ICE:-0})",
-                            "SIMSIMD_TARGET_GENOA=<!(echo ${SIMSIMD_TARGET_GENOA:-0})",
-                            "SIMSIMD_TARGET_SAPPHIRE=<!(echo ${SIMSIMD_TARGET_SAPPHIRE:-0})",
+                            "USEARCH_USE_OPENMP=0",
                         ],
                     },
                 ],
@@ -81,16 +69,6 @@
                     {
                         "defines": [
                             "USEARCH_USE_OPENMP=0",
-                            "USEARCH_USE_SIMSIMD=0",
-                            "USEARCH_USE_FP16LIB=1",
-                            "SIMSIMD_TARGET_SKYLAKE=0",
-                            "SIMSIMD_TARGET_ICE=0",
-                            "SIMSIMD_TARGET_SAPPHIRE=0",
-                            "SIMSIMD_TARGET_GENOA=0",
-                            "SIMSIMD_TARGET_SVE=0",
-                            "SIMSIMD_TARGET_HASWELL=0",
-                            "SIMSIMD_TARGET_NEON=0",
-                            "SIMSIMD_TARGET_NEON_BF16=0",
                         ],
                     },
                 ],

package/c/CMakeLists.txt

@@ -1,9 +1,4 @@
-
-# Define the source files conditionally
 set(USEARCH_LIB_SOURCES lib.cpp)
-if (USEARCH_USE_SIMSIMD)
-    list(APPEND USEARCH_LIB_SOURCES ../simsimd/c/lib.c)
-endif ()
 
 if (USEARCH_BUILD_TEST_C)
     add_executable(test_c test.c ${USEARCH_LIB_SOURCES})
@@ -11,6 +6,10 @@ if (USEARCH_BUILD_TEST_C)
     include(CTest)
     enable_testing()
     add_test(NAME test_c COMMAND test_c)
+
+    # Export the dynamic symbol table so `backtrace_symbols_fd` can resolve
+    # function names when the in-test crash handler fires.
+    set_target_properties(test_c PROPERTIES ENABLE_EXPORTS ON)
 endif ()
 
 # This article discusses a better way to allow building either static or shared libraries:

package/c/README.md

@@ -3,7 +3,7 @@
 ## Installation
 
 USearch vector-search engine can be integrated into your project using CMake.
-Alternatively, you can download one of the precompiled binaries from the [releases page](https://github.com/unum-cloud/usearch/releases).
+Alternatively, you can download one of the precompiled binaries from the [releases page](https://github.com/unum-cloud/USearch/releases).
 
 ## Quickstart
 
@@ -89,7 +89,7 @@ usearch_metadata_buffer(buffer, bytes, &opts, &error);
 
 ## Metrics
 
-USearch comes pre-packaged with SimSIMD, bringing over 100 SIMD-accelerated distance kernels for x86 and ARM architectures.
+USearch comes pre-packaged with NumKong, bringing over 100 SIMD-accelerated distance kernels for x86 and ARM architectures.
 That includes:
 
 - `usearch_metric_cos_k` - Cosine Similarity metric, defined as `Cos = 1 - sum(a[i] * b[i]) / (sqrt(sum(a[i]^2) * sqrt(sum(b[i]^2)))`.
@@ -107,7 +107,7 @@ That includes:
 You can also define your own metrics by implementing the `usearch_metric_t` interface:
 
 ```c
-simsimd_distance_t callback(void const* a, void const* b, void* state) {
+usearch_distance_t callback(void const* a, void const* b, void* state) {
     // Your custom metric implementation here
 }
 
@@ -183,15 +183,15 @@ Alternatively, you can benefit from faster thread-pools and priority queues for
 size_t threads = 0;
 size_t top_k = 10;
 size_t dataset_count = 1000, queries_count = 10;
-simsimd_f16_t dataset[dataset_count][dimensions];
-simsimd_f16_t queries[queries_count][dimensions];
+nk_f16_t dataset[dataset_count][dimensions];
+nk_f16_t queries[queries_count][dimensions];
 
 usearch_key_t resulting_keys[queries_count][top_k];
 usearch_distance_t resulting_distances[queries_count][top_k];
 
 usearch_exact_search(
-    &dataset[0][0], dataset_count, dimensions * sizeof(simsimd_f16_t),
-    &queries[0][0], queries_count, dimensions * sizeof(simsimd_f16_t),
+    &dataset[0][0], dataset_count, dimensions * sizeof(nk_f16_t),
+    &queries[0][0], queries_count, dimensions * sizeof(nk_f16_t),
     usearch_scalar_f16_k, top_k, threads,
     &resulting_keys[0][0], sizeof(usearch_key_t) * top_k,
     &resulting_distances[0][0], sizeof(usearch_distance_t) * top_k,

package/c/lib.cpp

@@ -56,11 +56,16 @@ usearch_metric_kind_t metric_kind_to_c(metric_kind_t kind) {
 }
 scalar_kind_t scalar_kind_to_cpp(usearch_scalar_kind_t kind) {
     switch (kind) {
-    case usearch_scalar_f32_k: return scalar_kind_t::f32_k;
     case usearch_scalar_f64_k: return scalar_kind_t::f64_k;
-    case usearch_scalar_f16_k: return scalar_kind_t::f16_k;
+    case usearch_scalar_f32_k: return scalar_kind_t::f32_k;
     case usearch_scalar_bf16_k: return scalar_kind_t::bf16_k;
+    case usearch_scalar_f16_k: return scalar_kind_t::f16_k;
+    case usearch_scalar_e5m2_k: return scalar_kind_t::e5m2_k;
+    case usearch_scalar_e4m3_k: return scalar_kind_t::e4m3_k;
+    case usearch_scalar_e3m2_k: return scalar_kind_t::e3m2_k;
+    case usearch_scalar_e2m3_k: return scalar_kind_t::e2m3_k;
     case usearch_scalar_i8_k: return scalar_kind_t::i8_k;
+    case usearch_scalar_u8_k: return scalar_kind_t::u8_k;
     case usearch_scalar_b1_k: return scalar_kind_t::b1x8_k;
     default: return scalar_kind_t::unknown_k;
     }
@@ -68,11 +73,16 @@ scalar_kind_t scalar_kind_to_cpp(usearch_scalar_kind_t kind) {
 
 usearch_scalar_kind_t scalar_kind_to_c(scalar_kind_t kind) {
     switch (kind) {
-    case scalar_kind_t::f32_k: return usearch_scalar_f32_k;
     case scalar_kind_t::f64_k: return usearch_scalar_f64_k;
-    case scalar_kind_t::f16_k: return usearch_scalar_f16_k;
+    case scalar_kind_t::f32_k: return usearch_scalar_f32_k;
     case scalar_kind_t::bf16_k: return usearch_scalar_bf16_k;
+    case scalar_kind_t::f16_k: return usearch_scalar_f16_k;
+    case scalar_kind_t::e5m2_k: return usearch_scalar_e5m2_k;
+    case scalar_kind_t::e4m3_k: return usearch_scalar_e4m3_k;
+    case scalar_kind_t::e3m2_k: return usearch_scalar_e3m2_k;
+    case scalar_kind_t::e2m3_k: return usearch_scalar_e2m3_k;
     case scalar_kind_t::i8_k: return usearch_scalar_i8_k;
+    case scalar_kind_t::u8_k: return usearch_scalar_u8_k;
     case scalar_kind_t::b1x8_k: return usearch_scalar_b1_k;
     default: return usearch_scalar_unknown_k;
     }
@@ -80,11 +90,12 @@ usearch_scalar_kind_t scalar_kind_to_c(scalar_kind_t kind) {
 
 add_result_t add_(index_dense_t* index, usearch_key_t key, void const* vector, scalar_kind_t kind) {
     switch (kind) {
-    case scalar_kind_t::f32_k: return index->add(key, (f32_t const*)vector);
     case scalar_kind_t::f64_k: return index->add(key, (f64_t const*)vector);
-    case scalar_kind_t::f16_k: return index->add(key, (f16_t const*)vector);
+    case scalar_kind_t::f32_k: return index->add(key, (f32_t const*)vector);
     case scalar_kind_t::bf16_k: return index->add(key, (bf16_t const*)vector);
+    case scalar_kind_t::f16_k: return index->add(key, (f16_t const*)vector);
     case scalar_kind_t::i8_k: return index->add(key, (i8_t const*)vector);
+    case scalar_kind_t::u8_k: return index->add(key, (u8_t const*)vector);
     case scalar_kind_t::b1x8_k: return index->add(key, (b1x8_t const*)vector);
     default: return add_result_t{}.failed("Unknown scalar kind!");
     }
@@ -92,11 +103,12 @@ add_result_t add_(index_dense_t* index, usearch_key_t key, void const* vector, s
 
 std::size_t get_(index_dense_t* index, usearch_key_t key, size_t count, void* vector, scalar_kind_t kind) {
     switch (kind) {
-    case scalar_kind_t::f32_k: return index->get(key, (f32_t*)vector, count);
     case scalar_kind_t::f64_k: return index->get(key, (f64_t*)vector, count);
-    case scalar_kind_t::f16_k: return index->get(key, (f16_t*)vector, count);
+    case scalar_kind_t::f32_k: return index->get(key, (f32_t*)vector, count);
     case scalar_kind_t::bf16_k: return index->get(key, (bf16_t*)vector, count);
+    case scalar_kind_t::f16_k: return index->get(key, (f16_t*)vector, count);
     case scalar_kind_t::i8_k: return index->get(key, (i8_t*)vector, count);
+    case scalar_kind_t::u8_k: return index->get(key, (u8_t*)vector, count);
     case scalar_kind_t::b1x8_k: return index->get(key, (b1x8_t*)vector, count);
     default: return search_result_t(*index).failed("Unknown scalar kind!");
     }
@@ -106,16 +118,18 @@ template <typename predicate_at = dummy_predicate_t>
 search_result_t search_(index_dense_t* index, void const* vector, scalar_kind_t kind, size_t n,
                         predicate_at&& predicate = predicate_at{}) {
     switch (kind) {
-    case scalar_kind_t::f32_k:
-        return index->filtered_search((f32_t const*)vector, n, std::forward<predicate_at>(predicate));
     case scalar_kind_t::f64_k:
         return index->filtered_search((f64_t const*)vector, n, std::forward<predicate_at>(predicate));
-    case scalar_kind_t::f16_k:
-        return index->filtered_search((f16_t const*)vector, n, std::forward<predicate_at>(predicate));
+    case scalar_kind_t::f32_k:
+        return index->filtered_search((f32_t const*)vector, n, std::forward<predicate_at>(predicate));
     case scalar_kind_t::bf16_k:
         return index->filtered_search((bf16_t const*)vector, n, std::forward<predicate_at>(predicate));
+    case scalar_kind_t::f16_k:
+        return index->filtered_search((f16_t const*)vector, n, std::forward<predicate_at>(predicate));
     case scalar_kind_t::i8_k:
         return index->filtered_search((i8_t const*)vector, n, std::forward<predicate_at>(predicate));
+    case scalar_kind_t::u8_k:
+        return index->filtered_search((u8_t const*)vector, n, std::forward<predicate_at>(predicate));
     case scalar_kind_t::b1x8_k:
         return index->filtered_search((b1x8_t const*)vector, n, std::forward<predicate_at>(predicate));
     default: return search_result_t(*index).failed("Unknown scalar kind!");
@@ -133,6 +147,10 @@ USEARCH_EXPORT char const* usearch_version(void) {
     return version;
 }
 
+USEARCH_EXPORT char const* usearch_hardware_acceleration_compiled(void) { return hardware_acceleration_compiled(); }
+
+USEARCH_EXPORT char const* usearch_hardware_acceleration_available(void) { return hardware_acceleration_available(); }
+
 USEARCH_EXPORT usearch_index_t usearch_init(usearch_init_options_t* options, usearch_error_t* error) {
 
     USEARCH_ASSERT(error && "Missing arguments");
@@ -413,7 +431,7 @@ USEARCH_EXPORT size_t usearch_search(
 USEARCH_EXPORT size_t usearch_filtered_search(                                 //
     usearch_index_t index,                                                     //
     void const* query, usearch_scalar_kind_t query_kind, size_t results_limit, //
-    int (*filter)(usearch_key_t key, void* filter_state), void* filter_state,  //
+    usearch_filtered_search_callback_t filter, void* filter_state,             //
     usearch_key_t* found_keys, usearch_distance_t* found_distances, usearch_error_t* error) {
 
     USEARCH_ASSERT(index && query && filter && error && "Missing arguments");
@@ -478,7 +496,7 @@ USEARCH_EXPORT void usearch_exact_search(                             //
 
     metric_punned_t metric(dimensions, metric_kind_to_cpp(metric_kind), scalar_kind_to_cpp(scalar_kind));
     executor_default_t executor(threads);
-    static exact_search_t search;
+    exact_search_t search;
     exact_search_results_t result = search(                    //
         (byte_t const*)dataset, dataset_count, dataset_stride, //
         (byte_t const*)queries, queries_count, queries_stride, //

package/c/test.c

@@ -1,10 +1,91 @@
+/**
+ *  @file       test.c
+ *  @author     Ash Vardanian
+ *  @brief      Unit tests for the pure-C ABI of USearch (`usearch.h`).
+ *  @date       June 25, 2023
+ *
+ *  Exercises the lifecycle of `usearch_index_t` through the public C surface:
+ *  index creation with every supported metric and scalar kind, `add` / `get` /
+ *  `find` / `remove`, on-disk `save` / `load` / `view`, and error propagation
+ *  via `usearch_error_t`. The harness is intentionally dependency-free so it
+ *  can run in the same matrix as the C++ tests and on cross-compilation
+ *  targets where only the C runtime is available.
+ *
+ *  On startup we install a signal handler (see `install_crash_handlers`) that
+ *  prints a native back-trace before re-raising, so CI logs pinpoint the
+ *  faulting frame instead of stopping at a bare exit code.
+ */
 #include <errno.h>
-#include <stdio.h> // `remove`
+#include <signal.h> // `signal`, `raise`, `SIGSEGV`
+#include <stdio.h>  // `remove`
 #include <stdlib.h>
+#include <string.h> // `memset`
 #include <sys/stat.h>
 
+/* Back-trace support for the C test harness. The `signal` API is standard C;
+ * the back-trace itself is taken via an OS-specific facility since C has no
+ * standard stack-introspection API. On Windows, `dbghelp.h` references types
+ * (e.g. `PSTR`) that are only defined after `windows.h`, so the two headers
+ * are separated by a blank line to keep clang-format from re-sorting them
+ * into a single alphabetized block. */
+#if defined(_WIN32)
+#include <windows.h>
+
+#include <dbghelp.h>
+#pragma comment(lib, "Dbghelp.lib")
+#elif defined(__unix__) || defined(__APPLE__)
+#include <execinfo.h>
+#include <unistd.h>
+#endif
+
 #include "usearch.h"
 
+static void usearch_write_backtrace(int signal_number) {
+    fprintf(stderr, "\n[usearch] Fatal signal %d. Back-trace:\n", signal_number);
+#if defined(_WIN32)
+    enum { backtrace_depth_limit = 64 };
+    void* backtrace_frames[backtrace_depth_limit];
+    USHORT backtrace_depth = CaptureStackBackTrace(0, backtrace_depth_limit, backtrace_frames, NULL);
+    HANDLE current_process = GetCurrentProcess();
+    SymInitialize(current_process, NULL, TRUE);
+
+    unsigned char symbol_info_buffer[sizeof(SYMBOL_INFO) + 256 * sizeof(char)];
+    SYMBOL_INFO* symbol_info = (SYMBOL_INFO*)symbol_info_buffer;
+    symbol_info->MaxNameLen = 255;
+    symbol_info->SizeOfStruct = sizeof(SYMBOL_INFO);
+
+    for (USHORT frame_index = 0; frame_index < backtrace_depth; ++frame_index) {
+        if (SymFromAddr(current_process, (DWORD64)backtrace_frames[frame_index], 0, symbol_info))
+            fprintf(stderr, "  #%2u %s + 0x%llx\n", (unsigned)frame_index, symbol_info->Name,
+                    (unsigned long long)((DWORD64)backtrace_frames[frame_index] - symbol_info->Address));
+        else
+            fprintf(stderr, "  #%2u %p\n", (unsigned)frame_index, backtrace_frames[frame_index]);
+    }
+#elif defined(__unix__) || defined(__APPLE__)
+    enum { backtrace_depth_limit = 64 };
+    void* backtrace_frames[backtrace_depth_limit];
+    int backtrace_depth = backtrace(backtrace_frames, backtrace_depth_limit);
+    backtrace_symbols_fd(backtrace_frames, backtrace_depth, STDERR_FILENO);
+#else
+    (void)signal_number;
+    fprintf(stderr, "  <back-trace unavailable on this platform>\n");
+#endif
+    fflush(stderr);
+}
+
+static void usearch_crash_handler(int signal_number) {
+    usearch_write_backtrace(signal_number);
+    /* Restore the default disposition and re-raise so the shell / CI sees the true exit status. */
+    signal(signal_number, SIG_DFL);
+    raise(signal_number);
+}
+
+static void install_crash_handlers(void) {
+    int const fatal_signals[] = {SIGSEGV, SIGABRT, SIGILL, SIGFPE};
+    for (unsigned signal_index = 0; signal_index < sizeof(fatal_signals) / sizeof(fatal_signals[0]); ++signal_index)
+        signal(fatal_signals[signal_index], &usearch_crash_handler);
+}
+
 void expect(bool must_be_true, char const* message) {
     if (must_be_true)
         return;
@@ -368,6 +449,7 @@ void test_view(size_t const collection_size, size_t const dimensions) {
 }
 
 int main(int argc, char const* argv[]) {
+    install_crash_handlers();
     printf("Running tests...\n");
     printf("USearch version: %s\n", usearch_version());
 

package/c/usearch.h

@@ -53,12 +53,17 @@ USEARCH_EXPORT typedef enum usearch_metric_kind_t {
 
 USEARCH_EXPORT typedef enum usearch_scalar_kind_t {
     usearch_scalar_unknown_k = 0,
-    usearch_scalar_f32_k = 1,
     usearch_scalar_f64_k = 2,
+    usearch_scalar_f32_k = 1,
+    usearch_scalar_bf16_k = 6,
     usearch_scalar_f16_k = 3,
+    usearch_scalar_e5m2_k = 7,
+    usearch_scalar_e4m3_k = 8,
+    usearch_scalar_e3m2_k = 11,
+    usearch_scalar_e2m3_k = 10,
     usearch_scalar_i8_k = 4,
+    usearch_scalar_u8_k = 9,
     usearch_scalar_b1_k = 5,
-    usearch_scalar_bf16_k = 6,
 } usearch_scalar_kind_t;
 
 USEARCH_EXPORT typedef struct usearch_init_options_t {
@@ -109,12 +114,26 @@ USEARCH_EXPORT typedef struct usearch_init_options_t {
     bool multi;
 } usearch_init_options_t;
 
+USEARCH_EXPORT typedef int (*usearch_filtered_search_callback_t)(usearch_key_t, void*);
+
 /**
  *  @brief Retrieves the version of the library.
  *  @return The version of the library.
  */
 USEARCH_EXPORT char const* usearch_version(void);
 
+/**
+ *  @brief Retrieves a list of hardware capabilities in this precompiled binary.
+ *  @return A comma-separated string with names of CPU features.
+ */
+USEARCH_EXPORT char const* usearch_hardware_acceleration_compiled(void);
+
+/**
+ *  @brief Retrieves a list of hardware capabilities supported by the current machine.
+ *  @return A comma-separated string with names of CPU features.
+ */
+USEARCH_EXPORT char const* usearch_hardware_acceleration_available(void);
+
 /**
  *  @brief Initializes a new instance of the index.
  *  @param options Pointer to the `usearch_init_options_t` structure containing initialization options.
@@ -391,7 +410,7 @@ USEARCH_EXPORT size_t usearch_search(                                         //
 USEARCH_EXPORT size_t usearch_filtered_search(                                //
     usearch_index_t index,                                                    //
     void const* query_vector, usearch_scalar_kind_t query_kind, size_t count, //
-    int (*filter)(usearch_key_t key, void* filter_state), void* filter_state, //
+    usearch_filtered_search_callback_t filter, void* filter_state,            //
     usearch_key_t* keys, usearch_distance_t* distances, usearch_error_t* error);
 
 /**
@@ -480,6 +499,8 @@ USEARCH_EXPORT void usearch_exact_search(                            //
  */
 USEARCH_EXPORT void usearch_clear(usearch_index_t index, usearch_error_t* error);
 
+extern int goFilteredSearchCallback(usearch_key_t, void*);
+
 #ifdef __cplusplus
 }
 #endif

package/cpp/CMakeLists.txt

@@ -7,6 +7,10 @@ if (USEARCH_BUILD_TEST_CPP)
 
     target_include_directories(test_cpp PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/../stringzilla/include)
 
+    # Export the dynamic symbol table so `backtrace_symbols` / `std::stacktrace`
+    # can resolve function names when the in-test crash handler fires.
+    set_target_properties(test_cpp PROPERTIES ENABLE_EXPORTS ON)
+
     if (CMAKE_CXX_COMPILER_ID STREQUAL "GNU" OR CMAKE_CXX_COMPILER_ID MATCHES "Clang")
         target_compile_options(test_cpp PRIVATE -Wno-vla -Wno-unused-function -Wno-cast-function-type)
     endif ()

package/cpp/README.md

@@ -6,7 +6,7 @@ To use in a C++ project, copy the `include/usearch/*` headers into your project.
 Alternatively, fetch it with CMake:
 
 ```cmake
-FetchContent_Declare(usearch GIT_REPOSITORY https://github.com/unum-cloud/usearch.git)
+FetchContent_Declare(usearch GIT_REPOSITORY https://github.com/unum-cloud/USearch.git)
 FetchContent_MakeAvailable(usearch)
 ```
 
@@ -43,9 +43,9 @@ int main(int argc, char **argv) {
 
 Here we:
 
-- define a metric of kind [`metric_kind_t::l2sq_k`](https://unum-cloud.github.io/usearch/cpp/reference.html#_CPPv413metric_kind_t),
-- to be applied to [`scalar_kind_t::f32_k`](https://unum-cloud.github.io/usearch/cpp/reference.html#_CPPv413scalar_kind_t) floating-point vectors,
-- instantiate an [`index_dense_t`](https://unum-cloud.github.io/usearch/cpp/reference.html#_CPPv4I00EN4unum7usearch14index_dense_gtE) index.
+- define a metric of kind [`metric_kind_t::l2sq_k`](https://unum-cloud.github.io/USearch/cpp/reference.html#_CPPv413metric_kind_t),
+- to be applied to [`scalar_kind_t::f32_k`](https://unum-cloud.github.io/USearch/cpp/reference.html#_CPPv413scalar_kind_t) floating-point vectors,
+- instantiate an [`index_dense_t`](https://unum-cloud.github.io/USearch/cpp/reference.html#_CPPv4I00EN4unum7usearch14index_dense_gtE) index.
 
 The `add` is thread-safe for concurrent index construction.
 It also has an overload for different vector types, casting them under the hood.
@@ -174,7 +174,7 @@ In its high-level interface, USearch supports a variety of metrics, including th
 - `metric_haversine_gt<scalar_t>` for "Haversine" or "Great Circle" distance between coordinates used in GIS applications.
 - `metric_divergence_gt<scalar_t>` for the "Jensen Shannon" similarity between probability distributions.
 
-In reality, for most common types, one of the [SimSIMD](https://github.com/ashvardanian/SimSIMD) backends will be triggered, providing hardware-acceleration for most common CPUs.
+In reality, for most common types, one of the [NumKong](https://github.com/ashvardanian/numkong) backends will be triggered, providing hardware-acceleration for most common CPUs.
 
 If you need a different metric, you can implement it yourself and wrap it into a `metric_punned_t`, which is our alternative to the `std::function`.
 Unlike the `std::function`, it is a trivial type, which is important for performance.