Repository: unum-cloud/usearch (language: python)

Issue:
Bug: `nodes_capacity_` is not set in header when saving to stream
### Describe the bug

Ran into an issue when attempting to load from disk that the `capacity` (`nodes_capacity_`) is incorrect and is instead set to the number of slots already storing non-null nodes (`nodes_count_`). Digging into it further it seems that in `save_to_stream(...)` the header (`index_serialized_header_t`) created does not contain `nodes_capacity_`.

Wasn't too sure if this was intentional and thus wanted to raise an issue.

### Steps to reproduce

1. Instantiate with a set number for capacity via `reserve()`
2. Save via `save_to_stream`
3. Load via `load_from_stream`
4. Check capacity and notice that it is different than the normal `reserve()` value

### Expected behavior

Expecting the capacity after load to be the same value as when saved.

### USearch version

v2.12.0

### Operating System

macOS 14.5

### Hardware architecture

x86

### Which interface are you using?

Other bindings

### Contact Details

_No response_

### Are you open to being tagged as a contributor?

- [X] I am open to being mentioned in the project `.git` history as a contributor

### Is there an existing issue for this?

- [X] I have searched the existing issues

### Code of Conduct

- [X] I agree to follow this project's Code of Conduct


Discussion / hints:

Fix patch:
diff --git a/.github/workflows/prerelease.yml b/.github/workflows/prerelease.yml
index 3c457b4f..7877777b 100644
--- a/.github/workflows/prerelease.yml
+++ b/.github/workflows/prerelease.yml
@@ -17,6 +17,38 @@ permissions:
   contents: read
 
 jobs:
+  versioning:
+    name: Update Version
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+          persist-credentials: false
+      - name: Run TinySemVer
+        uses: ashvardanian/tinysemver@v2.0.1
+        with:
+          verbose: "true"
+          version-file: "VERSION"
+          update-version-in: |
+            package.json:"version": "(\d+\.\d+\.\d+)"
+            CITATION.cff:^version: (\d+\.\d+\.\d+)
+            Cargo.toml:^version = "(\d+\.\d+\.\d+)"
+            wasmer.toml:^version = "(\d+\.\d+\.\d+)"
+            conanfile.py:version = "(\d+\.\d+\.\d+)"
+            java/README.md:<version>(\d+\.\d+\.\d+)</version>
+            README.md:version = {(\d+\.\d+\.\d+)}
+            csharp/nuget/nuget-package.props:>(\d+\.\d+\.\d+)</Version>
+            CMakeLists.txt:VERSION (\d+\.\d+\.\d+)
+          update-major-version-in: |
+            include/usearch/index.hpp:^#define USEARCH_VERSION_MAJOR (\d+)
+          update-minor-version-in: |
+            include/usearch/index.hpp:^#define USEARCH_VERSION_MINOR (\d+)
+          update-patch-version-in: |
+            include/usearch/index.hpp:^#define USEARCH_VERSION_PATCH (\d+)
+          dry-run: "true"
+
   test_ubuntu_gcc:
     name: Ubuntu (GCC 12)
     runs-on: ubuntu-22.04
@@ -75,9 +107,9 @@ jobs:
 
         # Java
       - name: Setup Java
-        uses: actions/setup-java@v3
+        uses: actions/setup-java@v4
         with:
-          java-version: "11"
+          java-version: "21"
           distribution: "adopt"
       - name: Setup Gradle
         uses: gradle/gradle-build-action@v2.4.2
@@ -93,7 +125,7 @@ jobs:
         run: |
           mkdir -p "${{ github.workspace }}/csharp/lib/runtimes/linux-x64/native"
           cp "${{ github.workspace }}/build_artifacts/libusearch_c.so" "${{ github.workspace }}/csharp/lib/runtimes/linux-x64/native"
-          dotnet test -c Release
+          dotnet test -c Debug --logger "console;verbosity=detailed"
         shell: bash
         working-directory: ${{ github.workspace }}/csharp
 
@@ -168,7 +200,7 @@ jobs:
         run: |
           mkdir -p "${{ github.workspace }}/csharp/lib/runtimes/linux-x64/native"
           cp "${{ github.workspace }}/build_artifacts/libusearch_c.so" "${{ github.workspace }}/csharp/lib/runtimes/linux-x64/native"
-          dotnet test -c Release
+          dotnet test -c Debug --logger "console;verbosity=detailed"
         shell: bash
         working-directory: ${{ github.workspace }}/csharp
 
@@ -232,7 +264,7 @@ jobs:
         run: |
           mkdir -p "${{ github.workspace }}/csharp/lib/runtimes/osx-x64/native"
           cp "${{ github.workspace }}/build_artifacts/libusearch_c.dylib" "${{ github.workspace }}/csharp/lib/runtimes/osx-x64/native"
-          dotnet test -c Release
+          dotnet test -c Debug --logger "console;verbosity=detailed" --filter "FullyQualifiedName!=Cloud.Unum.USearch.Tests.UsearchIndexTests.PersistAndRestore"
         shell: bash
         working-directory: ${{ github.workspace }}/csharp
 
@@ -288,7 +320,7 @@ jobs:
         run: |
           mkdir -p "${{ github.workspace }}\csharp\lib\runtimes\win-x64\native"
           cp "${{ github.workspace }}\build_artifacts\libusearch_c.dll" "${{ github.workspace }}\csharp\lib\runtimes\win-x64\native"
-          dotnet test -c Release
+          dotnet test -c Debug --logger "console;verbosity=detailed"
         shell: bash
         working-directory: ${{ github.workspace }}/csharp
 
@@ -299,7 +331,7 @@ jobs:
       - uses: actions/checkout@v4
       - run: git submodule update --init --recursive
       - name: Build
-        uses: docker/build-push-action@v4
+        uses: docker/build-push-action@v6
         with:
           context: .
           load: true
diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml
index 4c003117..002200fb 100644
--- a/.github/workflows/release.yml
+++ b/.github/workflows/release.yml
@@ -18,23 +18,44 @@ permissions:
 
 jobs:
   versioning:
-    name: Semantic Release
-    runs-on: ubuntu-22.04
+    name: Update Version
+    runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v4
+      - name: Checkout
+        uses: actions/checkout@v4
         with:
+          fetch-depth: 0
           persist-credentials: false
-      - name: Set up Node.js
-        uses: actions/setup-node@v4
-        with:
-          node-version: 20
       - name: Set up Cargo
         uses: actions-rs/toolchain@v1
         with:
           toolchain: stable
           override: true
-      - name: Bump version
-        run: npm install --save-dev --prefix ./package-ci @semantic-release/exec @semantic-release/git conventional-changelog-eslint semantic-release && npx --prefix ./package-ci semantic-release
+      - name: Run TinySemVer
+        uses: ashvardanian/tinysemver@v2.0.1
+        with:
+          verbose: "true"
+          version-file: "VERSION"
+          update-version-in: |
+            package.json:"version": "(\d+\.\d+\.\d+)"
+            CITATION.cff:^version: (\d+\.\d+\.\d+)
+            Cargo.toml:^version = "(\d+\.\d+\.\d+)"
+            wasmer.toml:^version = "(\d+\.\d+\.\d+)"
+            conanfile.py:version = "(\d+\.\d+\.\d+)"
+            java/README.md:<version>(\d+\.\d+\.\d+)</version>
+            README.md:version = {(\d+\.\d+\.\d+)}
+            csharp/nuget/nuget-package.props:>(\d+\.\d+\.\d+)</Version>
+            CMakeLists.txt:VERSION (\d+\.\d+\.\d+)
+          update-major-version-in: |
+            include/usearch/index.hpp:^#define USEARCH_VERSION_MAJOR (\d+)
+          update-minor-version-in: |
+            include/usearch/index.hpp:^#define USEARCH_VERSION_MINOR (\d+)
+          update-patch-version-in: |
+            include/usearch/index.hpp:^#define USEARCH_VERSION_PATCH (\d+)
+          dry-run: "false"
+          push: "true"
+          create-release: "true"
+          github-token: ${{ secrets.SEMANTIC_RELEASE_TOKEN }}
 
   rebase:
     name: Rebase Dev. Branch
@@ -469,7 +490,8 @@ jobs:
         os:
           - macos-latest
           - ubuntu-22.04
-          - windows-latest
+          # Windows pre-buld is not working
+          # - windows-latest
         exclude:
           - arch: x86
             os: macos-latest
@@ -614,9 +636,9 @@ jobs:
       - name: Pull Git submodules
         run: git submodule update --init --recursive
       - name: Set up Java
-        uses: actions/setup-java@v3
+        uses: actions/setup-java@v4
         with:
-          java-version: "11"
+          java-version: "21"
           distribution: "adopt"
       - name: Setup Gradle
         uses: gradle/gradle-build-action@v2.4.2
@@ -678,7 +700,7 @@ jobs:
             unum/usearch
             ghcr.io/${{ github.repository }}
       - name: Build and push
-        uses: docker/build-push-action@v4
+        uses: docker/build-push-action@v6
         with:
           context: .
           push: true
diff --git a/.github/workflows/update_version.sh b/.github/workflows/update_version.sh
deleted file mode 100755
index 17b2321a..00000000
--- a/.github/workflows/update_version.sh
+++ /dev/null
@@ -1,19 +0,0 @@
-#!/bin/sh
-
-echo $1 > VERSION && 
-    sed -i "s/\"version\": \".*\"/\"version\": \"$1\"/" package.json &&
-    sed -i "s/^version: .*/version: $1/" CITATION.cff &&
-    sed -i "s/version = \".*\"/version = \"$1\"/" Cargo.toml &&
-    sed -i "s/version = '.*'/version = '$1'/" conanfile.py &&
-    sed -i "s/^\(#define USEARCH_VERSION_MAJOR \).*/\1$(echo "$1" | cut -d. -f1)/" ./include/usearch/index.hpp &&
-    sed -i "s/^\(#define USEARCH_VERSION_MINOR \).*/\1$(echo "$1" | cut -d. -f2)/" ./include/usearch/index.hpp &&
-    sed -i "s/^\(#define USEARCH_VERSION_PATCH \).*/\1$(echo "$1" | cut -d. -f3)/" ./include/usearch/index.hpp &&
-    sed -i "s/<version>[0-9]\+\.[0-9]\+\.[0-9]\+/<version>$1/" README.md &&
-    sed -i "s/version = {[0-9]\+\.[0-9]\+\.[0-9]\+}/version = {$1}/" README.md &&
-    sed -i "s/>[0-9]\+\.[0-9]\+\.[0-9]\+<\/Version>/>$1<\/Version>/" ./csharp/nuget/nuget-package.props &&
-    sed -i "s/VERSION [0-9]\+\.[0-9]\+\.[0-9]\+/VERSION $1/" CMakeLists.txt &&
-    sed -i "s/version=\".*\"/version=\"$1\"/" wasmer.toml
-
-# Update the version in the Cargo.lock file, but don't report an error if it fails...
-# as `cargo` may not be available in the current environment.
-cargo update || true
diff --git a/.gitignore b/.gitignore
index 8d85d9a2..5e7a197b 100644
--- a/.gitignore
+++ b/.gitignore
@@ -10,10 +10,12 @@ bin
 .cache
 
 # C++ builds
-build
-build_release
-build_debug
-build_artifacts
+/build
+/build_release
+/build_debug
+/build_relwithdebinfo
+/build_profile
+/build_artifacts
 _deps
 CMakeCache.txt
 CMakeFiles
diff --git a/.vscode/launch.json b/.vscode/launch.json
index 931cd104..4adf3e8c 100644
--- a/.vscode/launch.json
+++ b/.vscode/launch.json
@@ -176,6 +176,19 @@
                 "datasets/wiki_1M/groundtruth.public.100K.ibin",
             ],
             "justMyCode": true
+        },
+        {
+            "name": "Unit Test C#",
+            "type": "coreclr",
+            "request": "launch",
+            "program": "dotnet",
+            "args": [
+                "test",
+                "-c",
+                "Debug"
+            ],
+            "cwd": "${workspaceFolder}/csharp",
+            "stopAtEntry": false
         }
     ]
 }
\ No newline at end of file
diff --git a/.vscode/settings.json b/.vscode/settings.json
index 76339d31..6b8d56f6 100644
--- a/.vscode/settings.json
+++ b/.vscode/settings.json
@@ -120,7 +120,8 @@
     "xstring": "cpp",
     "xtr1common": "cpp",
     "xtree": "cpp",
-    "xutility": "cpp"
+    "xutility": "cpp",
+    "execution": "cpp"
   },
   "cSpell.words": [
     "allclose",
@@ -139,6 +140,7 @@
     "dtype",
     "DUSEARCH",
     "emcmake",
+    "endregion",
     "equi",
     "equidimensional",
     "FAISS",
@@ -151,6 +153,11 @@
     "hnswlib",
     "ibin",
     "jaccard",
+    "Jemalloc",
+    "Kullback",
+    "Leibler",
+    "libjemalloc",
+    "libomp",
     "libusearch",
     "linalg",
     "longlong",
@@ -174,10 +181,13 @@
     "SLOC",
     "Sonatype",
     "sorensen",
+    "Sørensen",
     "sqeuclidean",
+    "stringzilla",
     "Struct",
     "swar",
     "tanimoto",
+    "tparam",
     "tqdm",
     "uninitialize",
     "unumusearch",
diff --git a/.vscode/tasks.json b/.vscode/tasks.json
index 23e5997e..310659ab 100644
--- a/.vscode/tasks.json
+++ b/.vscode/tasks.json
@@ -3,7 +3,7 @@
     "tasks": [
         {
             "label": "Linux Build Debug",
-            "command": "cmake -DCMAKE_CXX_COMPILER=gcc-12 -DCMAKE_CXX_COMPILER=g++-12 -DUSEARCH_BUILD_TEST_CPP=1 -DUSEARCH_BUILD_TEST_C=1 -DUSEARCH_BUILD_LIB_C=1 -DUSEARCH_USE_OPENMP=1 -DUSEARCH_USE_SIMSIMD=1 -DUSEARCH_USE_JEMALLOC=1 -DCMAKE_BUILD_TYPE=Debug -B ./build_debug && cmake --build ./build_debug --config Debug",
+            "command": "cmake -DCMAKE_CXX_COMPILER=gcc-12 -DCMAKE_CXX_COMPILER=g++-12 -DUSEARCH_BUILD_TEST_CPP=1 -DUSEARCH_BUILD_TEST_C=1 -DUSEARCH_BUILD_LIB_C=1 -DUSEARCH_USE_OPENMP=0 -DUSEARCH_USE_SIMSIMD=1 -DUSEARCH_USE_JEMALLOC=1 -DCMAKE_BUILD_TYPE=Debug -B ./build_debug && cmake --build ./build_debug --config Debug",
             "args": [],
             "type": "shell",
             "problemMatcher": [
@@ -12,7 +12,7 @@
         },
         {
             "label": "Linux Build Release",
-            "command": "cmake -DCMAKE_CXX_COMPILER=gcc-12 -DCMAKE_CXX_COMPILER=g++-12 -DUSEARCH_BUILD_TEST_CPP=1 -DUSEARCH_BUILD_TEST_C=1 -DUSEARCH_BUILD_LIB_C=1 -DUSEARCH_USE_OPENMP=1 -DUSEARCH_USE_SIMSIMD=1 -DUSEARCH_USE_JEMALLOC=1 -DCMAKE_BUILD_TYPE=Release -B ./build_release && cmake --build ./build_release --config RelWithDebInfo",
+            "command": "cmake -DCMAKE_CXX_COMPILER=gcc-12 -DCMAKE_CXX_COMPILER=g++-12 -DUSEARCH_BUILD_TEST_CPP=1 -DUSEARCH_BUILD_TEST_C=1 -DUSEARCH_BUILD_LIB_C=1 -DUSEARCH_USE_OPENMP=0 -DUSEARCH_USE_SIMSIMD=1 -DUSEARCH_USE_JEMALLOC=1 -DCMAKE_BUILD_TYPE=Release -B ./build_release && cmake --build ./build_release --config RelWithDebInfo",
             "args": [],
             "type": "shell",
             "problemMatcher": [
diff --git a/BENCHMARKS.md b/BENCHMARKS.md
index aabe10d2..84d082a9 100644
--- a/BENCHMARKS.md
+++ b/BENCHMARKS.md
@@ -61,19 +61,19 @@ Within this repository you will find two commonly used utilities:
 To achieve best highest results we suggest compiling locally for the target architecture.
 
 ```sh
-cmake -B ./build_release -USEARCH_BUILD_BENCH_CPP=1 -DUSEARCH_BUILD_TEST_C=1 -DUSEARCH_USE_OPENMP=1 -DUSEARCH_USE_SIMSIMD=1 
-cmake --build ./build_release --config Release -j
-./build_release/bench_cpp --help
+cmake -USEARCH_BUILD_BENCH_CPP=1 -DUSEARCH_BUILD_TEST_C=1 -DUSEARCH_USE_OPENMP=1 -DUSEARCH_USE_SIMSIMD=1 -DCMAKE_BUILD_TYPE=RelWithDebInfo -B build_profile
+cmake --build build_profile --config RelWithDebInfo -j
+build_profile/bench_cpp --help
 ```
 
 Which would print the following instructions.
 
 ```txt
 SYNOPSIS
-        ./build_release/bench_cpp [--vectors <path>] [--queries <path>] [--neighbors <path>] [-b] [-j
-                                  <integer>] [-c <integer>] [--expansion-add <integer>]
-                                  [--expansion-search <integer>] [--native|--f16quant|--i8quant]
-                                  [--ip|--l2sq|--cos|--haversine] [-h]
+        build_profile/bench_cpp [--vectors <path>] [--queries <path>] [--neighbors <path>] [-b] [-j
+                                <integer>] [-c <integer>] [--expansion-add <integer>]
+                                [--expansion-search <integer>] [--native|--f16quant|--i8quant]
+                                [--ip|--l2sq|--cos|--haversine] [-h]
 
 OPTIONS
         --vectors <path>
@@ -111,12 +111,12 @@ OPTIONS
 Here is an example of running the C++ benchmark:
 
 ```sh
-./build_release/bench_cpp \
+build_profile/bench_cpp \
     --vectors datasets/wiki_1M/base.1M.fbin \
     --queries datasets/wiki_1M/query.public.100K.fbin \
     --neighbors datasets/wiki_1M/groundtruth.public.100K.ibin
 
-./build_release/bench_cpp \
+build_profile/bench_cpp \
     --vectors datasets/t2i_1B/base.1B.fbin \
     --queries datasets/t2i_1B/query.public.100K.fbin \
     --neighbors datasets/t2i_1B/groundtruth.public.100K.ibin \
@@ -201,17 +201,17 @@ With `perf`:
 
 ```sh
 # Pass environment variables with `-E`, and `-d` for details
-sudo -E perf stat -d ./build_release/bench_cpp ...
-sudo -E perf mem -d ./build_release/bench_cpp ...
+sudo -E perf stat -d build_profile/bench_cpp ...
+sudo -E perf mem -d build_profile/bench_cpp ...
 # Sample on-CPU functions for the specified command, at 1 Kilo Hertz:
-sudo -E perf record -F 1000 ./build_release/bench_cpp ...
-perf record -d -e arm_spe// -- ./build_release/bench_cpp ..
+sudo -E perf record -F 1000 build_profile/bench_cpp ...
+perf record -d -e arm_spe// -- build_profile/bench_cpp ..
 ```
 
 ### Caches
 
 ```sh
-sudo perf stat -e 'faults,dTLB-loads,dTLB-load-misses,cache-misses,cache-references' ./build_release/bench_cpp ...
+sudo perf stat -e 'faults,dTLB-loads,dTLB-load-misses,cache-misses,cache-references' build_profile/bench_cpp ...
 ```
 
 Typical output on a 1M vectors dataset is:
diff --git a/CITATION.cff b/CITATION.cff
index c7bd301d..10f83b6a 100644
--- a/CITATION.cff
+++ b/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.12.0
+version: 2.13.0
 doi: 10.5281/zenodo.7949416
 date-released: 2023-10-22
 url: "https://github.com/unum-cloud/usearch"
diff --git a/CMakeLists.txt b/CMakeLists.txt
index 16bd3ef5..0e0e74d6 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -3,7 +3,7 @@
 cmake_minimum_required(VERSION 3.1)
 project(
     usearch
-    VERSION 2.12.0
+    VERSION 2.13.0
     LANGUAGES C CXX
     DESCRIPTION "Smaller & Faster Single-File Vector Search Engine from Unum"
     HOMEPAGE_URL "https://github.com/unum-cloud/usearch"
@@ -151,7 +151,8 @@ function (setup_target TARGET_NAME)
             PRIVATE $<$<CONFIG:RELEASE>:-O3>
                     $<$<CONFIG:RELWITHDEBINFO>:-O3
                     -g>
-                    $<$<CONFIG:DEBUG>:-g
+                    $<$<CONFIG:DEBUG>:-O0
+                    -g
                     -fsanitize=address
                     -fsanitize=leak
                     -fsanitize=alignment
@@ -192,7 +193,8 @@ function (setup_target TARGET_NAME)
             PRIVATE $<$<CONFIG:RELEASE>:-O3>
                     $<$<CONFIG:RELWITHDEBINFO>:-O3
                     -g>
-                    $<$<CONFIG:DEBUG>:-g
+                    $<$<CONFIG:DEBUG>:-O0
+                    -g
                     -fsanitize=address
                     -fsanitize=alignment
                     -fsanitize=undefined
@@ -201,8 +203,6 @@ function (setup_target TARGET_NAME)
                     -fPIC
                     -pedantic
                     -Wfatal-errors
-                    # Don't complain if the for-loops were not vectorzied
-                    -Wpass-failed=transform-warning
                     -fcolor-diagnostics
         )
         target_link_options(
@@ -243,14 +243,14 @@ function (setup_target TARGET_NAME)
         set_property(SOURCE bench.cpp PROPERTY LANGUAGE CUDA)
         set_target_properties(${TARGET_NAME} PROPERTIES POSITION_INDEPENDENT_CODE ON)
         set_target_properties(${TARGET_NAME} PROPERTIES CUDA_ARCHITECTURES "86")
-        
+
     elseif (CMAKE_CXX_COMPILER_ID STREQUAL "IntelLLVM")
         target_compile_options(${TARGET_NAME} PRIVATE -w -ferror-limit=1)
-        
+
     elseif (CMAKE_CXX_COMPILER_ID MATCHES "MSVC")
         target_compile_options(${TARGET_NAME} PRIVATE /wd4068 /wd4996)
         target_compile_options(
-            ${TARGET_NAME} PRIVATE $<$<CONFIG:DEBUG>:/DEBUG> $<$<CONFIG:RELEASE>:/O2> $<$<CONFIG:RELWITHDEBINFO>:/O2
+            ${TARGET_NAME} PRIVATE $<$<CONFIG:DEBUG>:/DEBUG> $<$<CONFIG:RELEASE>:/O3> $<$<CONFIG:RELWITHDEBINFO>:/O3
                                    /DEBUG>
         )
     endif ()
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index cd0c311f..6948ec98 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -33,17 +33,25 @@ brew install libomp llvm # MacOS
 Using modern syntax, this is how you build and run the test suite:
 
 ```sh
-cmake -DUSEARCH_BUILD_TEST_CPP=1 -DCMAKE_BUILD_TYPE=Debug -B ./build_debug
-cmake --build ./build_debug --config Debug
-./build_debug/test_cpp
+cmake -DUSEARCH_BUILD_TEST_CPP=1 -DCMAKE_BUILD_TYPE=Debug -B build_debug
+cmake --build build_debug --config Debug
+build_debug/test_cpp
 ```
 
 If there build mode is not specified, the default is `Release`.
 
 ```sh
-cmake -DUSEARCH_BUILD_TEST_CPP=1 -B ./build_release
-cmake --build ./build_release --config Release
-./build_release/test_cpp
+cmake -DUSEARCH_BUILD_TEST_CPP=1 -B build_release
+cmake --build build_release --config Release
+build_release/test_cpp
+```
+
+For development purposes, you may want to include symbols information in the build:
+
+```sh
+cmake -DUSEARCH_BUILD_TEST_CPP=1 -DCMAKE_BUILD_TYPE=RelWithDebInfo -B build_relwithdebinfo
+cmake --build build_relwithdebinfo --config RelWithDebInfo
+build_relwithdebinfo/test_cpp
 ```
 
 The CMakeLists.txt file has a number of options you can pass:
@@ -57,17 +65,17 @@ The CMakeLists.txt file has a number of options you can pass:
 - Which dependencies to use:
   - `USEARCH_USE_OPENMP` - use OpenMP for parallelism
   - `USEARCH_USE_SIMSIMD` - use SimSIMD for vectorization
-  - `USEARCH_USE_JEMALLOC` - use JeMalloc for memory management
+  - `USEARCH_USE_JEMALLOC` - use Jemalloc for memory management
   - `USEARCH_USE_FP16LIB` - use software emulation for half-precision floating point
 
 Putting all of this together, compiling all targets on most platforms should work with the following snippet:
 
 ```sh
-cmake -DCMAKE_BUILD_TYPE=Release -DUSEARCH_USE_FP16LIB=1 -DUSEARCH_USE_OPENMP=1 -DUSEARCH_USE_SIMSIMD=1 -DUSEARCH_USE_JEMALLOC=1 -DUSEARCH_BUILD_TEST_CPP=1 -DUSEARCH_BUILD_BENCH_CPP=1 -DUSEARCH_BUILD_LIB_C=1 -DUSEARCH_BUILD_TEST_C=1 -DUSEARCH_BUILD_SQLITE=0 -B ./build_release
+cmake -DCMAKE_BUILD_TYPE=Release -DUSEARCH_USE_FP16LIB=1 -DUSEARCH_USE_OPENMP=1 -DUSEARCH_USE_SIMSIMD=1 -DUSEARCH_USE_JEMALLOC=1 -DUSEARCH_BUILD_TEST_CPP=1 -DUSEARCH_BUILD_BENCH_CPP=1 -DUSEARCH_BUILD_LIB_C=1 -DUSEARCH_BUILD_TEST_C=1 -DUSEARCH_BUILD_SQLITE=0 -B build_release
 
-cmake --build ./build_release --config Release
-./build_release/test_cpp
-./build_release/test_c
+cmake --build build_release --config Release
+build_release/test_cpp
+build_release/test_c
 ```
 
 Similarly, to use the most recent Clang compiler version from HomeBrew on MacOS:
@@ -76,8 +84,8 @@ Similarly, to use the most recent Clang compiler version from HomeBrew on MacOS:
 brew install clang++ clang cmake
 cmake \
     -DCMAKE_BUILD_TYPE=Release \
-    -DCMAKE_C_COMPILER="/opt/homebrew/opt/llvm/bin/clang" \
-    -DCMAKE_CXX_COMPILER="/opt/homebrew/opt/llvm/bin/clang++" \
+    -DCMAKE_C_COMPILER="$(brew --prefix llvm)/bin/clang" \
+    -DCMAKE_CXX_COMPILER="$(brew --prefix llvm)/bin/clang++" \
     -DUSEARCH_USE_FP16LIB=1 \
     -DUSEARCH_USE_OPENMP=1 \
     -DUSEARCH_USE_SIMSIMD=1 \
@@ -86,11 +94,11 @@ cmake \
     -DUSEARCH_BUILD_BENCH_CPP=1 \
     -DUSEARCH_BUILD_LIB_C=1 \
     -DUSEARCH_BUILD_TEST_C=1 \
-    -B ./build_release
+    -B build_release
 
-cmake --build ./build_release --config Release
-./build_release/test_cpp
-./build_release/test_c
+cmake --build build_release --config Release
+build_release/test_cpp
+build_release/test_c
 ```
 
 Linting:
@@ -252,8 +260,8 @@ RUN npm install --build-from-source usearch
 To compile to WebAssembly make sure you have `emscripten` installed and run the following script:
 
 ```sh
-emcmake cmake -B ./build -DCMAKE_CXX_FLAGS="${CMAKE_CXX_FLAGS} -s TOTAL_MEMORY=64MB" && emmake make -C ./build
-node ./build/usearch.test.js
+emcmake cmake -B build -DCMAKE_CXX_FLAGS="${CMAKE_CXX_FLAGS} -s TOTAL_MEMORY=64MB" && emmake make -C build
+node build/usearch.test.js
 ```
 
 If you don't yet have `emcmake` installed:
@@ -324,11 +332,11 @@ USearch provides GoLang bindings, that depend on the C library that must be inst
 So one should first compile the C library, link it with GoLang, and only then run tests.
 
 ```sh
-cmake -B ./build_release -DUSEARCH_BUILD_LIB_C=1 -DUSEARCH_BUILD_TEST_C=1 -DUSEARCH_USE_OPENMP=1 -DUSEARCH_USE_SIMSIMD=1 
-cmake --build ./build_release --config Release -j
+cmake -B build_release -DUSEARCH_BUILD_LIB_C=1 -DUSEARCH_BUILD_TEST_C=1 -DUSEARCH_USE_OPENMP=1 -DUSEARCH_USE_SIMSIMD=1 
+cmake --build build_release --config Release -j
 
-mv ./c/libusearch_c.so ./golang/ # or .dylib to install the library on MacOS
-cp ./c/usearch.h ./golang/ # to make the header available to GoLang
+mv c/libusearch_c.so golang/ # or .dylib to install the library on MacOS
+cp c/usearch.h golang/ # to make the header available to GoLang
 
 cd golang && go test -v ; cd ..
 ```
@@ -341,9 +349,10 @@ The compilation settings are controlled by the `build.gradle` and are independen
 To setup the Gradle environment:
 
 ```sh
-sudo apt get install zip unzip
+sudo apt-get install zip
 curl -s "https://get.sdkman.io" | bash
-sdk install java gradle
+sdk install java
+sdk install gradle
 ```
 
 Afterwards, in a new terminal:
@@ -402,8 +411,8 @@ USearch provides CSharp bindings, that depend on the C library that must be inst
 So one should first compile the C library, link it with CSharp, and only then run tests.
 
 ```sh
-cmake -B ./build_artifacts -DUSEARCH_BUILD_LIB_C=1 -DUSEARCH_BUILD_TEST_C=1 -DUSEARCH_USE_OPENMP=1 -DUSEARCH_USE_SIMSIMD=1 
-cmake --build ./build_artifacts --config Release -j
+cmake -B build_artifacts -DUSEARCH_BUILD_LIB_C=1 -DUSEARCH_BUILD_TEST_C=1 -DUSEARCH_USE_OPENMP=1 -DUSEARCH_USE_SIMSIMD=1 
+cmake --build build_artifacts --config Release -j
 ```
 
 Then, on Windows, copy the library to the CSharp project and run the tests:
@@ -416,6 +425,29 @@ dotnet test -c Debug --logger "console;verbosity=detailed"
 dotnet test -c Release
 ```
 
+On Linux, the process is similar:
+
+```sh
+mkdir -p "csharp/lib/runtimes/linux-x64/native" # for x86
+cp "build_artifacts/libusearch_c.so" "csharp/lib/runtimes/linux-x64/native" # for x86
+mkdir -p "csharp/lib/runtimes/linux-arm64/native" # for ARM
+cp "build_artifacts/libusearch_c.so" "csharp/lib/runtimes/linux-arm64/native" # for ARM
+cd csharp
+dotnet test -c Debug --logger "console;verbosity=detailed"
+dotnet test -c Release
+```
+
+On macOS with Arm-based chips:
+
+```sh
+mkdir -p "csharp/lib/runtimes/osx-arm64/native"
+cp "build_artifacts/libusearch_c.dylib" "csharp/lib/runtimes/osx-arm64/native"
+cd csharp
+dotnet test -c Debug --logger "console;verbosity=detailed"
+dotnet test -c Release
+```
+
+
 ## Wolfram
 
 ```sh
diff --git a/Cargo.lock b/Cargo.lock
index 181b7481..36d1079d 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -4,9 +4,9 @@ version = 3
 
 [[package]]
 name = "cc"
-version = "1.0.95"
+version = "1.0.97"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d32a725bc159af97c3e629873bb9f88fb8cf8a4867175f76dc987815ea07c83b"
+checksum = "099a5357d84c4c61eb35fc8eafa9a79a902c2f76911e5747ced4e032edd8d9b4"
 
 [[package]]
 name = "codespan-reporting"
@@ -20,9 +20,9 @@ dependencies = [
 
 [[package]]
 name = "cxx"
-version = "1.0.121"
+version = "1.0.122"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "21db378d04296a84d8b7d047c36bb3954f0b46529db725d7e62fb02f9ba53ccc"
+checksum = "bb497fad022245b29c2a0351df572e2d67c1046bcef2260ebc022aec81efea82"
 dependencies = [
  "cc",
  "cxxbridge-flags",
@@ -32,9 +32,9 @@ dependencies = [
 
 [[package]]
 name = "cxx-build"
-version = "1.0.121"
+version = "1.0.122"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3e5262a7fa3f0bae2a55b767c223ba98032d7c328f5c13fa5cdc980b77fc0658"
+checksum = "9327c7f9fbd6329a200a5d4aa6f674c60ab256525ff0084b52a889d4e4c60cee"
 dependencies = [
  "cc",
  "codespan-reporting",
@@ -47,15 +47,15 @@ dependencies = [
 
 [[package]]
 name = "cxxbridge-flags"
-version = "1.0.121"
+version = "1.0.122"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "be8dcadd2e2fb4a501e1d9e93d6e88e6ea494306d8272069c92d5a9edf8855c0"
+checksum = "688c799a4a846f1c0acb9f36bb9c6272d9b3d9457f3633c7753c6057270df13c"
 
 [[package]]
 name = "cxxbridge-macro"
-version = "1.0.121"
+version = "1.0.122"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ad08a837629ad949b73d032c637653d069e909cffe4ee7870b02301939ce39cc"
+checksum = "928bc249a7e3cd554fd2e8e08a426e9670c50bbfc9a621653cfa9accc9641783"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -79,9 +79,9 @@ checksum = "3fdb12b2476b595f9358c5161aa467c2438859caa136dec86c26fdd2efe17b92"
 
 [[package]]
 name = "proc-macro2"
-version = "1.0.81"
+version = "1.0.82"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3d1597b0c024618f09a9c3b8655b7e430397a36d23fdafec26d6965e9eec3eba"
+checksum = "8ad3d49ab951a01fbaafe34f2ec74122942fe18a3f9814c3268f1bb72042131b"
 dependencies = [
  "unicode-ident",
 ]
@@ -103,9 +103,9 @@ checksum = "a3cf7c11c38cb994f3d40e8a8cde3bbd1f72a435e4c49e85d6553d8312306152"
 
 [[package]]
 name = "syn"
-version = "2.0.60"
+version = "2.0.63"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "909518bc7b1c9b779f1bbf07f2929d35af9f0f37e47c6e9ef7f9dddc1e1821f3"
+checksum = "bf5be731623ca1a1fb7d8be6f261a3be6d3e2337b8a1f97be944d020c8fcb704"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -135,7 +135,7 @@ checksum = "68f5e5f3158ecfd4b8ff6fe086db7c8467a2dfdac97fe420f2b7c4aa97af66d6"
 
 [[package]]
 name = "usearch"
-version = "2.12.0"
+version = "2.13.0"
 dependencies = [
  "cxx",
  "cxx-build",
diff --git a/Cargo.toml b/Cargo.toml
index a2f17cf3..a7834cfd 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "usearch"
-version = "2.12.0"
+version = "2.13.0"
 authors = ["Ash Vardanian <1983160+ashvardanian@users.noreply.github.com>"]
 description = "Smaller & Faster Single-File Vector Search Engine from Unum"
 edition = "2021"
diff --git a/MANIFEST.in b/MANIFEST.in
new file mode 100644
index 00000000..d2fc82a4
--- /dev/null
+++ b/MANIFEST.in
@@ -0,0 +1,1 @@
+include python/usearch/py.typed
diff --git a/README.md b/README.md
index e42f8679..82098e55 100644
--- a/README.md
+++ b/README.md
@@ -49,7 +49,7 @@ Linux • MacOS • Windows • iOS • WebAssembly •
 
 - ✅ __[10x faster][faster-than-faiss]__ [HNSW][hnsw-algorithm] implementation than [FAISS][faiss].
 - ✅ Simple and extensible [single C++11 header][usearch-header] __library__.
-- ✅ [Trusted](#integrations) by giants like Google and databases like [ClickHouse][clickhouse-docs].
+- ✅ [Trusted](#integrations) by giants like Google and DBs like [ClickHouse][clickhouse-docs] & [DuckDB][duckdb-docs].
 - ✅ [SIMD][simd]-optimized and [user-defined metrics](#user-defined-functions) with JIT compilation.
 - ✅ Hardware-agnostic `f16` & `i8` - [half-precision & quarter-precision support](#memory-efficiency-downcasting-and-quantization).
 - ✅ [View large indexes from disk](#serving-index-from-disk) without loading into RAM.
@@ -67,6 +67,7 @@ Linux • MacOS • Windows • iOS • WebAssembly •
 [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
 [clickhouse-docs]: https://clickhouse.com/docs/en/engines/table-engines/mergetree-family/annindexes#usearch
+[duckdb-docs]: https://duckdb.org/2024/05/03/vector-similarity-search-vss.html
 
 __Technical Insights__ and related articles:
 
@@ -136,12 +137,13 @@ assert np.allclose(index[42], vector, atol=0.1) # Ensure high tolerance in mixed
 ```
 
 More settings are always available, and the API is designed to be as flexible as possible.
+The default storage/quantization level is hardware-dependant for efficiency, but `f16` is recommended for most modern CPUs.
 
 ```py
 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'
+    metric='cos', # Choose 'l2sq', 'ip', 'haversine' or other metric, default = 'cos'
+    dtype='f16', # Store as 'f64', 'f32', 'f16', 'i8', 'b1'..., default = None
     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 the search
@@ -360,41 +362,58 @@ In some cases, like Batch operations, feature parity is meaningless, as the host
 
 ## Application Examples
 
-### USearch + AI = Multi-Modal Semantic Search
-
-[![USearch Semantic Image Search](https://github.com/ashvardanian/usearch-images/raw/main/assets/usearch-images-slow.gif)](https://github.com/ashvardanian/usearch-images)
+### USearch + UForm + UCall = Multimodal Semantic Search
 
 AI has a growing number of applications, but one of the coolest classic ideas is to use it for Semantic Search.
-One can take an encoder model, like the multi-modal [UForm](https://github.com/unum-cloud/uform), and a web-programming framework, like UCall, and build a text-to-image search platform in just 20 lines of Python.
+One can take an encoder model, like the multi-modal [UForm](https://github.com/unum-cloud/uform), and a web-programming framework, like [UCall](https://github.com/unum-cloud/ucall), and build a text-to-image search platform in just 20 lines of Python.
 
 ```python
-import ucall
-import uform
-import usearch
+from ucall import Server
+from uform import get_model, Modality
+from usearch.index import Index
 
 import numpy as np
 import PIL as pil
 
-server = ucall.Server()
-model = uform.get_model('unum-cloud/uform-vl-multilingual')
-index = usearch.index.Index(ndim=256)
+processors, models = get_model('unum-cloud/uform3-image-text-english-small')
+model_text = models[Modality.TEXT_ENCODER]
+model_image = models[Modality.IMAGE_ENCODER]
+processor_text = processors[Modality.TEXT_ENCODER]
+processor_image = processors[Modality.IMAGE_ENCODER]
+
+server = Server()
+index = Index(ndim=256)
 
 @server
 def add(key: int, photo: pil.Image.Image):
-    image = model.preprocess_image(photo)
-    vector = model.encode_image(image).detach().numpy()
+    image = processor_image(photo)
+    vector = model_image(image)
     index.add(key, vector.flatten(), copy=True)
 
 @server
 def search(query: str) -> np.ndarray:
-    tokens = model.preprocess_text(query)
-    vector = model.encode_text(tokens).detach().numpy()
+    tokens = processor_text(query)
+    vector = model_text(tokens)
     matches = index.search(vector.flatten(), 3)
     return matches.keys
 
 server.run()
 ```
 
+Similar experiences can also be imlemented in other languages and on the client side, removing the network latency.
+For Swift and iOS, check out the [`ashvardanian/SwiftSemanticSearch`](https://github.com/ashvardanian/SwiftSemanticSearch) repository.
+
+<table>
+  <tr>
+    <td>
+      <img src="https://github.com/ashvardanian/ashvardanian/blob/master/demos/SwiftSemanticSearch-Dog.gif?raw=true" alt="SwiftSemanticSearch demo Dog">
+    </td>
+    <td>
+      <img src="https://github.com/ashvardanian/ashvardanian/blob/master/demos/SwiftSemanticSearch-Flowers.gif?raw=true" alt="SwiftSemanticSearch demo with Flowers">
+    </td>
+  </tr>
+</table>
+
 A more complete [demo with Streamlit is available on GitHub](https://github.com/ashvardanian/usearch-images).
 We have pre-processed some commonly used datasets, cleaned the images, produced the vectors, and pre-built the index.
 
@@ -446,22 +465,73 @@ That method was used to build the ["USearch Molecules"](https://github.com/ashva
 [smiles]: https://en.wikipedia.org/wiki/Simplified_molecular-input_line-entry_system
 [rdkit-fingerprints]: https://www.rdkit.org/docs/RDKit_Book.html#additional-information-about-the-fingerprints
 
-### USearch + POI Coordinates = GIS Applications... on iOS?
+### USearch + POI Coordinates = GIS Applications
 
-[![USearch Maps with SwiftUI](https://github.com/ashvardanian/SwiftSemanticSearch/raw/main/USearch+SwiftUI.gif)](https://github.com/ashvardanian/SwiftSemanticSearch)
+Similar to Vector and Molecule search, USearch can be used for Geospatial Information Systems.
+The Haversine distance is available out of the box, but you can also define more complex relationships, like the Vincenty formula, that accounts for the Earth's oblateness.
 
-With Objective-C and Swift iOS bindings, USearch can be easily used in mobile applications.
-The [SwiftSemanticSearch](https://github.com/ashvardanian/SwiftSemanticSearch) 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.
+```py
+from numba import cfunc, types, carray
+import math
+
+# Define the dimension as 2 for latitude and longitude
+ndim = 2
+
+# Signature for the custom metric
+signature = types.float32(
+    types.CPointer(types.float32),
+    types.CPointer(types.float32))
+
+# WGS-84 ellipsoid parameters
+a = 6378137.0  # major axis in meters
+f = 1 / 298.257223563  # flattening
+b = (1 - f) * a  # minor axis
+
+def vincenty_distance(a_ptr, b_ptr):
+    a_array = carray(a_ptr, ndim)
+    b_array = carray(b_ptr, ndim)
+    lat1, lon1, lat2, lon2 = a_array[0], a_array[1], b_array[0], b_array[1]
+    L, U1, U2 = lon2 - lon1, math.atan((1 - f) * math.tan(lat1)), math.atan((1 - f) * math.tan(lat2))
+    sinU1, cosU1, sinU2, cosU2 = math.sin(U1), math.cos(U1), math.sin(U2), math.cos(U2)
+    lambda_, iterLimit = L, 100
+    while iterLimit > 0:
+        iterLimit -= 1
+        sinLambda, cosLambda = math.sin(lambda_), math.cos(lambda_)
+        sinSigma = math.sqrt((cosU2 * sinLambda) ** 2 + (cosU1 * sinU2 - sinU1 * cosU2 * cosLambda) ** 2)
+        if sinSigma == 0: return 0.0  # Co-incident points
+        cosSigma, sigma = sinU1 * sinU2 + cosU1 * cosU2 * cosLambda, math.atan2(sinSigma, cosSigma)
+        sinAlpha, cos2Alpha = cosU1 * cosU2 * sinLambda / sinSigma, 1 - (cosU1 * cosU2 * sinLambda / sinSigma) ** 2
+        cos2SigmaM = cosSigma - 2 * sinU1 * sinU2 / cos2Alpha if not math.isnan(cosSigma - 2 * sinU1 * sinU2 / cos2Alpha) else 0  # Equatorial line
+        C = f / 16 * cos2Alpha * (4 + f * (4 - 3 * cos2Alpha))
+        lambda_, lambdaP = L + (1 - C) * f * (sinAlpha * (sigma + C * sinSigma * (cos2SigmaM + C * cosSigma * (-1 + 2 * cos2SigmaM ** 2)))), lambda_
+        if abs(lambda_ - lambdaP) <= 1e-12: break
+    if iterLimit == 0: return float('nan')  # formula failed to converge
+    u2 = cos2Alpha * (a ** 2 - b ** 2) / (b ** 2)
+    A = 1 + u2 / 16384 * (4096 + u2 * (-768 + u2 * (320 - 175 * u2)))
+    B = u2 / 1024 * (256 + u2 * (-128 + u2 * (74 - 47 * u2)))
+    deltaSigma = B * sinSigma * (cos2SigmaM + B / 4 * (cosSigma * (-1 + 2 * cos2SigmaM ** 2) - B / 6 * cos2SigmaM * (-3 + 4 * sinSigma ** 2) * (-3 + 4 * cos2SigmaM ** 2)))
+    s = b * A * (sigma - deltaSigma)
+    return s / 1000.0  # Distance in kilometers
+
+# Example usage:
+index = Index(ndim=ndim, metric=CompiledMetric(
+    pointer=vincenty_distance.address,
+    kind=MetricKind.Haversine,
+    signature=MetricSignature.ArrayArray,
+))
+```
 
-## Integrations
+## Integrations & Users
 
-- [x] GPTCache: [Python](https://github.com/zilliztech/GPTCache/releases/tag/0.1.29).
+- [x] ClickHouse: [C++](https://github.com/ClickHouse/ClickHouse/pull/53447), [docs](https://clickhouse.com/docs/en/engines/table-engines/mergetree-family/annindexes#usearch).
+- [x] DuckDB: [post](https://duckdb.org/2024/05/03/vector-similarity-search-vss.html).
+- [x] Google: [UniSim](https://github.com/google/unisim), [RetSim](https://arxiv.org/abs/2311.17264) paper.
+- [x] LanternDB: [C++](https://github.com/lanterndata/lantern), [Rust](https://github.com/lanterndata/lantern_extras), [docs](https://lantern.dev/blog/hnsw-index-creation).
 - [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] ClickHouse: [C++](https://github.com/ClickHouse/ClickHouse/pull/53447).
 - [x] Microsoft Semantic Kernel: [Python](https://github.com/microsoft/semantic-kernel/releases/tag/python-0.3.9.dev) and C#.
-- [x] LanternDB: [C++](https://github.com/lanterndata/lantern) and [Rust](https://github.com/lanterndata/lantern_extras).
+- [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).
 
 ## Citations
 
@@ -471,7 +541,7 @@ doi = {10.5281/zenodo.7949416},
 author = {Vardanian, Ash},
 title = {{USearch by Unum Cloud}},
 url = {https://github.com/unum-cloud/usearch},
-version = {2.12.0},
+version = {2.13.0},
 year = {2023},
 month = oct,
 }
diff --git a/VERSION b/VERSION
index d8b69897..fb2c0766 100644
--- a/VERSION
+++ b/VERSION
@@ -1,1 +1,1 @@
-2.12.0
+2.13.0
diff --git a/binding.gyp b/binding.gyp
index 229f7e95..f5226b68 100644
--- a/binding.gyp
+++ b/binding.gyp
@@ -25,15 +25,9 @@
                 "GCC_ENABLE_CPP_EXCEPTIONS": "YES",
                 "CLANG_CXX_LIBRARY": "libc++",
                 "MACOSX_DEPLOYMENT_TARGET": "11.0",
-                "OTHER_CFLAGS": [
-                    "-arch arm64",
-                    "-arch x86_64"
-                ],
-                "OTHER_LDFLAGS": [
-                    "-arch arm64",
-                    "-arch x86_64" 
-                ]
-           },
+                "OTHER_CFLAGS": ["-arch arm64", "-arch x86_64"],
+                "OTHER_LDFLAGS": ["-arch arm64", "-arch x86_64"],
+            },
             "msvs_settings": {
                 "VCCLCompilerTool": {
                     "ExceptionHandling": 1,
@@ -47,18 +41,19 @@
                         "cflags_cc": [
                             '<!(if [ "$USEARCH_USE_OPENMP" = "1" ]; then echo \'-fopenmp\'; fi)',
                         ],
-                        "ldflags": [
-                            '<!(if [ "$USEARCH_USE_OPENMP" = "1" ]; then echo \'-lgomp\'; 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_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})",
                         ],
                     },
@@ -71,10 +66,12 @@
                             "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})",
                         ],
                     },
@@ -89,9 +86,11 @@
                             "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",
                         ],
                     },
                 ],
diff --git a/build.gradle b/build.gradle
index 36d758a3..899477a1 100644
--- a/build.gradle
+++ b/build.gradle
@@ -10,8 +10,10 @@ plugins {
 group "cloud.unum"
 version = file("VERSION").text.trim()
 
-sourceCompatibility = 1.8
-targetCompatibility = 1.8
+java {
+    sourceCompatibility = JavaVersion.VERSION_18
+    targetCompatibility = JavaVersion.VERSION_18
+}
 
 repositories {
     mavenCentral()
@@ -86,6 +88,7 @@ model {
     }
 
     toolChains {
+        clang(Clang)
         gcc(Gcc) {
             target("linux_aarch64") {
                 cppCompiler.withArguments { args ->
diff --git a/build.rs b/build.rs
index f7d59e45..89e9c3b7 100644
--- a/build.rs
+++ b/build.rs
@@ -62,9 +62,19 @@ fn main() {
 
         let target_arch = std::env::var("CARGO_CFG_TARGET_ARCH").unwrap_or_default();
         let flags_to_try = match target_arch.as_str() {
-            "arm" | "aarch64" => vec!["SIMSIMD_TARGET_NEON", "SIMSIMD_TARGET_SVE"],
-            _ => vec![
+            "arm" | "aarch64" => vec![
+                "SIMSIMD_TARGET_SVE_BF16",
+                "SIMSIMD_TARGET_SVE_F16",
+                "SIMSIMD_TARGET_SVE_I8",
+                "SIMSIMD_TARGET_SVE",
+                "SIMSIMD_TARGET_NEON_BF16", 
+                "SIMSIMD_TARGET_NEON_F16", 
+                "SIMSIMD_TARGET_NEON_I8", 
+                "SIMSIMD_TARGET_NEON", 
+                ],
+                _ => vec![
                 "SIMSIMD_TARGET_SAPPHIRE",
+                "SIMSIMD_TARGET_GENOA",
                 "SIMSIMD_TARGET_ICE",
                 "SIMSIMD_TARGET_SKYLAKE",
                 "SIMSIMD_TARGET_HASWELL",
diff --git a/c/README.md b/c/README.md
index 3180c386..f66482b4 100644
--- a/c/README.md
+++ b/c/README.md
@@ -207,6 +207,9 @@ By default, as many of these structures are created as there are logical cores o
 Then, one can construct the index in parallel using many cores using third-party thread-pools or tools like OpenACC and OpenMP.
 
 ```c
+usearch_change_threads_add(index, omp_get_max_threads(), &error);
+usearch_change_threads_search(index, omp_get_max_threads(), &error);
+
 #pragma omp parallel for
 for (size_t i = 0; i < 1000; i++) {
     usearch_add(index, i, &vector[0], usearch_scalar_f32_k, &error);
diff --git a/c/lib.cpp b/c/lib.cpp
index 06d75ead..d7e0e1d4 100644
--- a/c/lib.cpp
+++ b/c/lib.cpp
@@ -94,7 +94,7 @@ std::size_t get_(index_dense_t* index, usearch_key_t key, size_t count, void* ve
     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::b1x8_k: return index->get(key, (b1x8_t*)vector, count);
-    default: return search_result_t().failed("Unknown scalar kind!");
+    default: return search_result_t(*index).failed("Unknown scalar kind!");
     }
 }
 
@@ -112,7 +112,7 @@ search_result_t search_(index_dense_t* index, void const* vector, scalar_kind_t
         return index->filtered_search((i8_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().failed("Unknown scalar kind!");
+    default: return search_result_t(*index).failed("Unknown scalar kind!");
     }
 }
 
@@ -123,19 +123,32 @@ USEARCH_EXPORT char const* usearch_version(void) {
     int minor = USEARCH_VERSION_MINOR;
     int patch = USEARCH_VERSION_PATCH;
     static char version[32];
-    sprintf(version, "%d.%d.%d", major, minor, patch);
+    std::snprintf(version, sizeof(version), "%d.%d.%d", major, minor, patch);
     return version;
 }
 
 USEARCH_EXPORT usearch_index_t usearch_init(usearch_init_options_t* options, usearch_error_t* error) {
 
-    USEARCH_ASSERT(options && error && "Missing arguments");
+    USEARCH_ASSERT(error && "Missing arguments");
 
-    index_dense_config_t config(options->connectivity, options->expansion_add, options->expansion_search);
+    // The user may want to initialize from a file.
+    // In that case he may pass NULL options, and we will try to load the metadata from the file.
+    if (!options) {
+        index_dense_t* result_ptr = new index_dense_t();
+        if (!result_ptr)
+            *error = "Out of memory!";
+        return result_ptr;
+    }
+
+    index_dense_config_t config;
+    config.connectivity = options->connectivity;
+    config.expansion_add = options->expansion_add;
+    config.expansion_search = options->expansion_search;
     config.multi = options->multi;
+    config.enable_key_lookups = 1;
+
     metric_kind_t metric_kind = metric_kind_to_cpp(options->metric_kind);
     scalar_kind_t scalar_kind = scalar_kind_to_cpp(options->quantization);
-
     metric_punned_t metric = //
         !options->metric ? metric_punned_t::builtin(options->dimensions, metric_kind, scalar_kind)
                          : metric_punned_t::stateless(options->dimensions,                               //
@@ -147,10 +160,18 @@ USEARCH_EXPORT usearch_index_t usearch_init(usearch_init_options_t* options, use
         return NULL;
     }
 
-    index_dense_t index = index_dense_t::make(metric, config);
-    index_dense_t* result_ptr = new index_dense_t(std::move(index));
-    if (!result_ptr || !*result_ptr)
+    using state_result_t = typename index_dense_t::state_result_t;
+    state_result_t state = index_dense_t::make(metric, config);
+    if (!state)
+        *error = state.error.release();
+    index_dense_t* result_ptr = new index_dense_t(std::move(state.index));
+    if (!result_ptr)
         *error = "Out of memory!";
+
+    // Let's immediately make it usable by reserving enough threads for this machine:
+    if (!result_ptr->try_reserve(index_limits_t()))
+        *error = "Out of memory when preparing contexts!";
+
     return result_ptr;
 }
 
@@ -304,6 +325,22 @@ USEARCH_EXPORT void usearch_change_expansion_search(usearch_index_t index, size_
     reinterpret_cast<index_dense_t*>(index)->change_expansion_search(expansion);
 }
 
+USEARCH_EXPORT void usearch_change_threads_add(usearch_index_t index, size_t threads, usearch_error_t* error) {
+    USEARCH_ASSERT(index && error && "Missing arguments");
+    auto& index_dense = *reinterpret_cast<index_dense_t*>(index);
+    index_limits_t limits = index_dense.limits();
+    limits.threads_add = threads;
+    index_dense.try_reserve(limits);
+}
+
+USEARCH_EXPORT void usearch_change_threads_search(usearch_index_t index, size_t threads, usearch_error_t* error) {
+    USEARCH_ASSERT(index && error && "Missing arguments");
+    auto& index_dense = *reinterpret_cast<index_dense_t*>(index);
+    index_limits_t limits = index_dense.limits();
+    limits.threads_search = threads;
+    index_dense.try_reserve(limits);
+}
+
 USEARCH_EXPORT void usearch_change_metric_kind(usearch_index_t index, usearch_metric_kind_t kind,
                                                usearch_error_t* error) {
     USEARCH_ASSERT(index && error && "Missing arguments");
@@ -317,9 +354,9 @@ USEARCH_EXPORT void usearch_change_metric(usearch_index_t index, usearch_metric_
     USEARCH_ASSERT(index && error && "Missing arguments");
     auto& index_dense = *reinterpret_cast<index_dense_t*>(index);
     auto metric_punned =
-        state ? metric_punned_t::statefull(reinterpret_cast<std::uintptr_t>(metric),
-                                           reinterpret_cast<std::uintptr_t>(state), metric_kind_to_cpp(kind),
-                                           index_dense.scalar_kind())
+        state ? metric_punned_t::stateful(reinterpret_cast<std::uintptr_t>(metric),
+                                          reinterpret_cast<std::uintptr_t>(state), metric_kind_to_cpp(kind),
+                                          index_dense.scalar_kind())
               : metric_punned_t::stateless(index_dense.dimensions(), reinterpret_cast<std::uintptr_t>(metric),
                                            metric_punned_signature_t::array_array_k, metric_kind_to_cpp(kind),
                                            index_dense.scalar_kind());
@@ -328,7 +365,7 @@ USEARCH_EXPORT void usearch_change_metric(usearch_index_t index, usearch_metric_
 
 USEARCH_EXPORT void usearch_reserve(usearch_index_t index, size_t capacity, usearch_error_t* error) {
     USEARCH_ASSERT(index && error && "Missing arguments");
-    if (!reinterpret_cast<index_dense_t*>(index)->reserve(capacity))
+    if (!reinterpret_cast<index_dense_t*>(index)->try_reserve(capacity))
         *error = "Out of memory!";
 }
 
diff --git a/c/usearch.h b/c/usearch.h
index 5632aa44..0acce530 100644
--- a/c/usearch.h
+++ b/c/usearch.h
@@ -281,6 +281,22 @@ USEARCH_EXPORT void usearch_change_expansion_add(usearch_index_t index, size_t e
  */
 USEARCH_EXPORT void usearch_change_expansion_search(usearch_index_t index, size_t expansion, usearch_error_t* error);
 
+/**
+ *  @brief Updates the number of threads that would be used to construct the index. Rarely used.
+ *  @param[in] index The handle to the USearch index to be queried.
+ *  @param[in] threads The new limit for the number of concurrent threads.
+ *  @param[out] error Pointer to a string where the error message will be stored, if an error occurs.
+ */
+USEARCH_EXPORT void usearch_change_threads_add(usearch_index_t index, size_t threads, usearch_error_t* error);
+
+/**
+ *  @brief Updates the number of threads that will be performing concurrent traversals. Rarely used.
+ *  @param[in] index The handle to the USearch index to be queried.
+ *  @param[in] threads The new limit for the number of concurrent threads.
+ *  @param[out] error Pointer to a string where the error message will be stored, if an error occurs.
+ */
+USEARCH_EXPORT void usearch_change_threads_search(usearch_index_t index, size_t threads, usearch_error_t* error);
+
 /**
  *  @brief Updates the metric kind used for distance calculation between vectors.
  *  @param[in] index The handle to the USearch index to be queried.
diff --git a/cpp/README.md b/cpp/README.md
index df32e152..63507b39 100644
--- a/cpp/README.md
+++ b/cpp/README.md
@@ -16,21 +16,29 @@ Once included, the high-level C++11 interface is as simple as it gets: `reserve(
 This covers 90% of use cases.
 
 ```cpp
-using namespace unum::usearch;
-
-metric_punned_t metric(256, metric_kind_t::l2sq_k, scalar_kind_t::f32_k);
-
-// If you plan to store more than 4 Billion entries - use `index_dense_big_t`.
-// Or directly instantiate the template variant you need - `index_dense_gt<vector_key_t, internal_id_t>`.
-index_dense_t index = index_dense_t::make(metric);
-float vec[3] = {0.1, 0.3, 0.2};
+#include <usearch/index.hpp>
+#include <usearch/index_dense.hpp>
 
-index.reserve(10); // Pre-allocate memory for 10 vectors
-index.add(42, &vec[0]); // Pass a key and a vector
-auto results = index.search(&vec[0], 5); // Pass a query and limit number of results
+using namespace unum::usearch;
 
-for (std::size_t i = 0; i != results.size(); ++i)
-    results[i].element.key, results[i].element.vector, results[i].distance;
+int main(int argc, char **argv) {
+    metric_punned_t metric(3, metric_kind_t::l2sq_k, scalar_kind_t::f32_k);
+    
+    // If you plan to store more than 4 Billion entries - use `index_dense_big_t`.
+    // Or directly instantiate the template variant you need - `index_dense_gt<vector_key_t, internal_id_t>`.
+    index_dense_t index = index_dense_t::make(metric);
+    float vec[3] = {0.1, 0.3, 0.2};
+    
+    index.reserve(10); // Pre-allocate memory for 10 vectors
+    index.add(42, &vec[0]); // Pass a key and a vector
+    auto results = index.search(&vec[0], 5); // Pass a query and limit number of results
+    
+    for (std::size_t i = 0; i != results.size(); ++i)
+        // You can access the following properties of every match:
+        // results[i].element.key, results[i].element.vector, results[i].distance;
+        std::printf("Found matching key: %zu", results[i].element.key);
+    return 0;
+}
 ```
 
 Here we:
@@ -89,6 +97,19 @@ Aside from the `executor_default_t`, you can take advantage of one of the provid
 - `executor_stl_t`, that will spawn `std::thread` instances.
 - `dummy_executor_t`, that will run everything sequentially.
 
+## Error Handling
+
+Unlike most open-source C++ libraries USearch doesn't use exceptions, as they often lead to corrupted states in concurrent data-structures.
+They are also not suited for systems that always operate on the edge of available memory, and would end up raising `std::bad_alloc` exceptions all the time.
+For that reason, most operations return a "result" object, that can be checked for success or failure.
+
+```cpp
+bool success;
+success = (bool)index.try_reserve(10); // Recommended over `reserve()`
+success = (bool)index.add(42, &vec[0]); // Explicitly convert `add_result_t`
+success = (bool)index.search(&vec[0], 5); // Explicitly convert `search_result_t`
+```
+
 ## Clustering
 
 Aside from basic Create-Read-Update-Delete (CRUD) operations and search, USearch also supports clustering.
diff --git a/cpp/bench.cpp b/cpp/bench.cpp
index fbf70f90..ee086ff1 100644
--- a/cpp/bench.cpp
+++ b/cpp/bench.cpp
@@ -72,6 +72,8 @@ struct alignas(32) persisted_matrix_gt {
     std::uint32_t cols{};
     scalar_t const* scalars{};
 
+    persisted_matrix_gt() {}
+
     persisted_matrix_gt(char const* path) noexcept(false) {
         if (!path || !std::strlen(path))
             throw std::invalid_argument("The file path is empty");
@@ -133,6 +135,11 @@ struct alignas(32) persisted_matrix_gt {
     std::size_t size_bytes() const noexcept { return rows * row_size_bytes(); }
 };
 
+/**
+ *  @brief  A view of a large dataset in external memory, that may or may not contain
+ *          ground-truth queries and their optimal search results. In the second case,
+ *          self-recall is measured.
+ */
 template <typename scalar_at, typename vector_id_at> //
 struct persisted_dataset_gt {
     using scalar_t = scalar_at;
@@ -140,12 +147,21 @@ struct persisted_dataset_gt {
     persisted_matrix_gt<scalar_t> vectors_;
     persisted_matrix_gt<scalar_t> queries_;
     persisted_matrix_gt<compressed_slot_t> neighborhoods_;
+    std::vector<compressed_slot_t> neighborhoods_iota_{};
     std::size_t vectors_to_skip_{};
     std::size_t vectors_to_take_{};
 
+    persisted_dataset_gt(char const* path_vectors, std::size_t vectors_to_skip = 0,
+                         std::size_t vectors_to_take = 0) noexcept(false)
+        : vectors_(path_vectors), queries_(), neighborhoods_(), vectors_to_skip_(vectors_to_skip),
+          vectors_to_take_(vectors_to_take) {
+        neighborhoods_iota_.resize(vectors_.rows);
+        std::iota(neighborhoods_iota_.begin(), neighborhoods_iota_.end(), 0);
+    }
+
     persisted_dataset_gt(char const* path_vectors, char const* path_queries, char const* path_neighbors,
                          std::size_t vectors_to_skip = 0, std::size_t vectors_to_take = 0) noexcept(false)
-        : vectors_(path_vectors), queries_(path_queries), neighborhoods_(path_neighbors),
+        : vectors_(path_vectors), queries_(path_queries), neighborhoods_(path_neighbors), neighborhoods_iota_(),
           vectors_to_skip_(vectors_to_skip), vectors_to_take_(vectors_to_take) {
 
         if (vectors_.cols != queries_.cols)
@@ -154,13 +170,18 @@ struct persisted_dataset_gt {
             throw std::invalid_argument("Number of ground-truth neighborhoods doesn't match number of queries");
     }
 
+    bool search_itself() const noexcept { return vectors_count() && !queries_.rows; }
+
     std::size_t dimensions() const noexcept { return vectors_.cols; }
-    std::size_t queries_count() const noexcept { return queries_.rows; }
-    std::size_t neighborhood_size() const noexcept { return neighborhoods_.cols; }
+    std::size_t queries_count() const noexcept { return search_itself() ? vectors_count() : queries_.rows; }
+    std::size_t neighborhood_size() const noexcept { return search_itself() ? 1 : neighborhoods_.cols; }
     scalar_t const* vector(std::size_t i) const noexcept { return vectors_.row(i + vectors_to_skip_); }
-    scalar_t const* query(std::size_t i) const noexcept { return queries_.row(i); }
-    compressed_slot_t const* neighborhood(std::size_t i) const noexcept { return neighborhoods_.row(i); }
-
+    scalar_t const* query(std::size_t i) const noexcept {
+        return search_itself() ? vectors_view().at(i) : queries_.row(i);
+    }
+    compressed_slot_t const* neighborhood(std::size_t i) const noexcept {
+        return search_itself() ? neighborhoods_iota_.data() + i : neighborhoods_.row(i);
+    }
     std::size_t vectors_count() const noexcept {
         return vectors_to_take_ ? vectors_to_take_ : (vectors_.rows - vectors_to_skip_);
     }
@@ -238,6 +259,8 @@ struct running_stats_printer_t {
         print(new_progress, total);
     }
 
+    void print() { print(progress.load(), total); }
+
     void print(std::size_t progress, std::size_t total) {
 
         constexpr char bars_k[] = "||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||";
@@ -263,8 +286,8 @@ struct running_stats_printer_t {
     }
 };
 
-template <typename index_at, typename vector_id_at, typename real_at>
-void index_many(index_at& index, std::size_t n, vector_id_at const* ids, real_at const* vectors, std::size_t dims) {
+template <typename index_at, typename vector_id_at, typename scalar_at>
+void index_many(index_at& index, std::size_t n, vector_id_at const* ids, scalar_at const* vectors, std::size_t dims) {
 
     running_stats_printer_t printer{n, "Indexing"};
 
@@ -276,18 +299,21 @@ void index_many(index_at& index, std::size_t n, vector_id_at const* ids, real_at
 #if USEARCH_USE_OPENMP
         config.thread = omp_get_thread_num();
 #endif
-        float_span_t vector{vectors + dims * i, dims};
+        span_gt<scalar_at const> vector{vectors + dims * i, dims};
         index.add(ids[i], vector, config.thread);
         printer.progress++;
         if (config.thread == 0)
             printer.refresh();
     }
+
+    // Refresh once again to show 100% completion
+    printer.print();
 }
 
-template <typename index_at, typename vector_id_at, typename real_at>
+template <typename index_at, typename vector_id_at, typename scalar_at, typename distance_at>
 void search_many( //
-    index_at& index, std::size_t n, real_at const* vectors, std::size_t dims, std::size_t wanted, vector_id_at* ids,
-    real_at* distances) {
+    index_at& index, std::size_t n, scalar_at const* vectors, std::size_t dims, std::size_t wanted, vector_id_at* ids,
+    distance_at* distances) {
 
     std::string name = "Search " + std::to_string(wanted);
     running_stats_printer_t printer{n, name.c_str()};
@@ -300,12 +326,15 @@ void search_many( //
 #if USEARCH_USE_OPENMP
         config.thread = omp_get_thread_num();
 #endif
-        float_span_t vector{vectors + dims * i, dims};
+        span_gt<scalar_at const> vector{vectors + dims * i, dims};
         index.search(vector, wanted, config.thread).dump_to(ids + wanted * i, distances + wanted * i);
         printer.progress++;
         if (config.thread == 0)
             printer.refresh();
     }
+
+    // Refresh once again to show 100% completion
+    printer.print();
 }
 
 template <typename dataset_at, typename index_at> //
@@ -346,7 +375,7 @@ static void single_shot(dataset_at& dataset, index_at& index, bool construct = t
     std::size_t join_attempts = 0;
     {
         index_at& men = index;
-        index_at women = index.copy().index;
+        index_at women = index.copy();
         std::fill(man_to_woman.begin(), man_to_woman.end(), missing_key);
         std::fill(woman_to_man.begin(), woman_to_man.end(), missing_key);
         {
@@ -360,6 +389,8 @@ static void single_shot(dataset_at& dataset, index_at& index, bool construct = t
                         printer.print(progress, total);
                     return true;
                 });
+            // Refresh once again to show 100% completion
+            printer.print();
             join_attempts = result.visited_members;
         }
     }
@@ -499,7 +530,7 @@ void run_punned(dataset_at& dataset, args_t const& args, index_config_t config,
 
     std::printf("Will benchmark an on-disk view\n");
 
-    index_at index_view = index.fork().index;
+    index_at index_view = index.fork();
     index_view.view(args.path_output.c_str());
     single_shot(dataset, index_view, false);
 }
@@ -521,6 +552,44 @@ void run_typed(dataset_at& dataset, args_t const& args, index_config_t config, i
     single_shot(dataset, index_view, false);
 }
 
+template <typename dataset_scalar_at> void bench_with_args(args_t const& args) {
+    using dataset_t = persisted_dataset_gt<dataset_scalar_at, compressed_slot_t>;
+    dataset_t dataset = args.path_queries.empty() && args.path_neighbors.empty()
+                            ? dataset_t(args.path_vectors.c_str(), //
+                                        args.vectors_to_skip,      //
+                                        args.vectors_to_take       //
+                                        )
+                            : dataset_t(args.path_vectors.c_str(),   //
+                                        args.path_queries.c_str(),   //
+                                        args.path_neighbors.c_str(), //
+                                        args.vectors_to_skip,        //
+                                        args.vectors_to_take         //
+                              );
+    std::printf("-- Dimensions: %zu\n", dataset.dimensions());
+    std::printf("-- Vectors count: %zu\n", dataset.vectors_count());
+    std::printf("-- Queries count: %zu\n", dataset.queries_count());
+    std::printf("-- Neighbors per query: %zu\n", dataset.neighborhood_size());
+
+    index_dense_config_t config(args.connectivity, args.expansion_add, args.expansion_search);
+    index_limits_t limits;
+    limits.threads_add = limits.threads_search = args.threads;
+    limits.members = dataset.vectors_count();
+
+    std::printf("- Index: \n");
+    std::printf("-- Connectivity: %zu\n", config.connectivity);
+    std::printf("-- Expansion @ Add: %zu\n", config.expansion_add);
+    std::printf("-- Expansion @ Search: %zu\n", config.expansion_search);
+
+    if (args.big)
+#ifdef USEARCH_64BIT_ENV
+        run_punned<index_dense_gt<default_key_t, uint40_t>>(dataset, args, config, limits);
+#else
+        std::printf("Error: Don't use 40 bit identifiers in 32bit environment\n");
+#endif
+    else
+        run_punned<index_dense_gt<default_key_t, std::uint32_t>>(dataset, args, config, limits);
+}
+
 int main(int argc, char** argv) {
 
     // Print backtrace if something goes wrong.
@@ -530,8 +599,8 @@ int main(int argc, char** argv) {
 
     auto args = args_t{};
     auto cli = ( //
-        (option("--vectors") & value("path", args.path_vectors)).doc(".fbin file path to construct the index"),
-        (option("--queries") & value("path", args.path_queries)).doc(".fbin file path to query the index"),
+        (option("--vectors") & value("path", args.path_vectors)).doc(".[fhbd]bin file path to construct the index"),
+        (option("--queries") & value("path", args.path_queries)).doc(".[fhbd]bin file path to query the index"),
         (option("--neighbors") & value("path", args.path_neighbors)).doc(".ibin file path with ground truth"),
         (option("-o", "--output") & value("path", args.path_output)).doc(".usearch output file path"),
         (option("-b", "--big").set(args.big)).doc("Will switch to uint40_t for neighbors lists with over 4B entries"),
@@ -578,39 +647,22 @@ int main(int argc, char** argv) {
     std::printf("-- Query vectors path: %s\n", args.path_queries.c_str());
     std::printf("-- Ground truth neighbors path: %s\n", args.path_neighbors.c_str());
 
-    persisted_dataset_gt<float, compressed_slot_t> dataset{
-        args.path_vectors.c_str(),   //
-        args.path_queries.c_str(),   //
-        args.path_neighbors.c_str(), //
-        args.vectors_to_skip,        //
-        args.vectors_to_take,        //
+    auto ends_with = [](std::string_view stack, std::string_view needle) -> bool {
+        if (needle.empty())
+            return false;
+        return stack.find(needle, stack.size() - needle.size()) != std::string_view::npos;
     };
-    std::printf("-- Dimensions: %zu\n", dataset.dimensions());
-    std::printf("-- Vectors count: %zu\n", dataset.vectors_count());
-    std::printf("-- Queries count: %zu\n", dataset.queries_count());
-    std::printf("-- Neighbors per query: %zu\n", dataset.neighborhood_size());
-
-    // report_alternative_setups();
-    // report_expected_losses(dataset);
-
-    index_dense_config_t config(args.connectivity, args.expansion_add, args.expansion_search);
-    index_limits_t limits;
-    limits.threads_add = limits.threads_search = args.threads;
-    limits.members = dataset.vectors_count();
-
-    std::printf("- Index: \n");
-    std::printf("-- Connectivity: %zu\n", config.connectivity);
-    std::printf("-- Expansion @ Add: %zu\n", config.expansion_add);
-    std::printf("-- Expansion @ Search: %zu\n", config.expansion_search);
 
-    if (args.big)
-#ifdef USEARCH_64BIT_ENV
-        run_punned<index_dense_gt<default_key_t, uint40_t>>(dataset, args, config, limits);
-#else
-        std::printf("Error: Don't use 40 bit identifiers in 32bit environment\n");
-#endif
+    if (ends_with(args.path_vectors, ".fbin"))
+        bench_with_args<f32_t>(args);
+    else if (ends_with(args.path_vectors, ".dbin"))
+        bench_with_args<f64_t>(args);
+    else if (ends_with(args.path_vectors, ".hbin"))
+        bench_with_args<f16_t>(args);
+    else if (ends_with(args.path_vectors, ".bbin"))
+        bench_with_args<b1x8_t>(args);
     else
-        run_punned<index_dense_gt<default_key_t, std::uint32_t>>(dataset, args, config, limits);
+        throw std::runtime_error("Unknown input file path");
 
     return 0;
 }
diff --git a/csharp/nuget/nuget-package.props b/csharp/nuget/nuget-package.props
index b57dbc1d..92abda28 100644
--- a/csharp/nuget/nuget-package.props
+++ b/csharp/nuget/nuget-package.props
@@ -1,7 +1,7 @@
 <?xml version="1.0" encoding="utf-8"?>
 <Project>
   <PropertyGroup>
-    <Version Condition="'$(Version)' == ''">2.12.0</Version>
+    <Version Condition="'$(Version)' == ''">2.13.0</Version>
 
     <Authors>Unum</Authors>
     <Company>Unum</Company>
diff --git a/csharp/src/Cloud.Unum.USearch.Tests/USearchIndexTests.cs b/csharp/src/Cloud.Unum.USearch.Tests/USearchIndexTests.cs
index 0ad98edd..508b119f 100644
--- a/csharp/src/Cloud.Unum.USearch.Tests/USearchIndexTests.cs
+++ b/csharp/src/Cloud.Unum.USearch.Tests/USearchIndexTests.cs
@@ -61,7 +61,7 @@ public void PersistAndRestore()
             expansionSearch: 19 // Control the quality of search, optional
         );
 
-        var vector = new float[] { 0.2f, 0.6f, 0.4f };
+        var vector = new double[] { 0.2f, 0.6f, 0.4f };
         index.Add(42, vector);
         index.Save(savedPath);
 
@@ -69,8 +69,8 @@ public void PersistAndRestore()
         Trace.Assert(File.Exists(Path.Combine(pathUsearch, "tmp.usearch")));
 
         using var indexRestored = new USearchIndex(savedPath);
-        int matches = indexRestored.Search(vector, 10, out ulong[] keys, out float[] distances);
         Trace.Assert(indexRestored.Size() == 1);
+        int matches = indexRestored.Search(vector, 10, out ulong[] keys, out float[] distances);
         Trace.Assert(matches == 1);
         Trace.Assert(keys[0] == 42);
         Trace.Assert(distances[0] <= 0.001f);
@@ -98,7 +98,7 @@ public void USearch_InitializesWithRequiredArgumentsSetToMinimalOrUnknownValue_U
             // Assert
             Assert.Equal(ExpectedDimensions, index.Dimensions());
             Assert.Equal(ExpectedConnectivity, index.Connectivity());
-            Assert.Equal(ExpectedCapacity, index.Capacity());
+            Assert.True(ExpectedCapacity <= index.Capacity());
             Assert.Equal(ExpectedSize, index.Size());
         }
     }
@@ -129,7 +129,7 @@ public void USearch_InitializesWithIndexOptionsWithMinimalOrUnknownValue_Updates
             // Assert
             Assert.Equal(ExpectedDimensions, index.Dimensions());
             Assert.Equal(ExpectedConnectivity, index.Connectivity());
-            Assert.Equal(ExpectedCapacity, index.Capacity());
+            Assert.True(ExpectedCapacity <= index.Capacity());
             Assert.Equal(ExpectedSize, index.Size());
         }
     }
@@ -161,7 +161,7 @@ public void Add_FloatVector_UpdatesIndexOptions()
             Assert.True(index.Contains(AddKey));
             Assert.False(index.Contains(NonExistentKey));
             Assert.Equal(ExpectedSize, index.Size());
-            Assert.Equal(ExpectedCapacity, index.Capacity());
+            Assert.True(ExpectedCapacity <= index.Capacity());
         }
     }
 
@@ -192,7 +192,7 @@ public void Add_DoubleVector_UpdatesIndexOptions()
             Assert.True(index.Contains(AddKey));
             Assert.False(index.Contains(NonExistentKey));
             Assert.Equal(ExpectedSize, index.Size());
-            Assert.Equal(ExpectedCapacity, index.Capacity());
+            Assert.True(ExpectedCapacity <= index.Capacity());
         }
     }
 
@@ -224,7 +224,7 @@ public void Add_ManyFloatVectorsUnderSameKeySeparatelyInMultiKeyIndex_UpdatesInd
             // Assert
             Assert.True(index.Contains(AddKey));
             Assert.Equal((uint)AddFactor, index.Size());
-            Assert.Equal((uint)AddFactor, index.Capacity());
+            Assert.True((uint)AddFactor <= index.Capacity());
         }
     }
 
@@ -256,7 +256,7 @@ public void Add_ManyDoubleVectorsUnderSameKeySeparatelyInMultiKeyIndex_UpdatesIn
             // Assert
             Assert.True(index.Contains(AddKey));
             Assert.Equal((uint)AddFactor, index.Size());
-            Assert.Equal((uint)AddFactor, index.Capacity());
+            Assert.True((uint)AddFactor <= index.Capacity());
         }
     }
 
@@ -288,7 +288,7 @@ public void Add_ManyFloatVectorsUnderSameKeyInBatchInMultiKeyIndex_UpdatesIndexO
             // Assert
             Assert.True(index.Contains(AddKey));
             Assert.Equal(BatchSize, index.Size());
-            Assert.Equal(BatchSize, index.Capacity());
+            Assert.True(BatchSize <= index.Capacity());
             Assert.Equal((int)BatchSize, index.Count(AddKey));
         }
     }
@@ -321,7 +321,7 @@ public void Add_ManyDoubleVectorsUnderSameKeyInBatchInMultiKeyIndex_UpdatesIndex
             // Assert
             Assert.True(index.Contains(AddKey));
             Assert.Equal(BatchSize, index.Size());
-            Assert.Equal(BatchSize, index.Capacity());
+            Assert.True(BatchSize <= index.Capacity());
             Assert.Equal((int)BatchSize, index.Count(AddKey));
         }
     }
diff --git a/csharp/src/Cloud.Unum.USearch/NativeMethods.cs b/csharp/src/Cloud.Unum.USearch/NativeMethods.cs
index 08299e94..1ae42b20 100644
--- a/csharp/src/Cloud.Unum.USearch/NativeMethods.cs
+++ b/csharp/src/Cloud.Unum.USearch/NativeMethods.cs
@@ -6,6 +6,8 @@
 using usearch_error_t = System.IntPtr;
 using size_t = System.UIntPtr;
 using void_ptr_t = System.IntPtr;
+using usearch_key_ptr_t = System.IntPtr;
+using usearch_distance_ptr_t = System.IntPtr;
 
 namespace Cloud.Unum.USearch;
 
@@ -47,19 +49,11 @@ internal static class NativeMethods
     public static extern void usearch_add(
         usearch_index_t index,
         usearch_key_t key,
-        [In] float[] vector,
+        void_ptr_t vector,
         ScalarKind vector_kind,
         out usearch_error_t error
     );
 
-    [DllImport(LibraryName, CallingConvention = CallingConvention.Cdecl)]
-    public static extern void usearch_add(
-        usearch_index_t index,
-        usearch_key_t key,
-        [In] double[] vector,
-        ScalarKind vector_kind,
-        out usearch_error_t error
-    );
 
     [DllImport(LibraryName, CallingConvention = CallingConvention.Cdecl)]
     [return: MarshalAs(UnmanagedType.I1)]
@@ -74,53 +68,21 @@ public static extern size_t usearch_search(
         void_ptr_t query_vector,
         ScalarKind query_kind,
         size_t count,
-        [Out] usearch_key_t[] found_keys,
-        [Out] usearch_distance_t[] found_distances,
-        out usearch_error_t error
-    );
-
-    [DllImport(LibraryName, CallingConvention = CallingConvention.Cdecl)]
-    public static extern size_t usearch_search(
-        usearch_index_t index,
-        [In] float[] query_vector,
-        ScalarKind query_kind,
-        size_t count,
-        [Out] usearch_key_t[] found_keys,
-        [Out] usearch_distance_t[] found_distances,
-        out usearch_error_t error
-    );
-
-    [DllImport(LibraryName, CallingConvention = CallingConvention.Cdecl)]
-    public static extern size_t usearch_search(
-        usearch_index_t index,
-        [In] double[] query_vector,
-        ScalarKind query_kind,
-        size_t count,
-        [Out] usearch_key_t[] found_keys,
-        [Out] usearch_distance_t[] found_distances,
+        usearch_key_ptr_t found_keys,
+        usearch_distance_ptr_t found_distances,
         out usearch_error_t error
     );
 
-
     [DllImport(LibraryName, CallingConvention = CallingConvention.Cdecl)]
     public static extern size_t usearch_get(
         usearch_index_t index,
         usearch_key_t key,
         size_t count,
-        [Out] float[] vector,
+        void_ptr_t vector,
         ScalarKind vector_kind,
         out usearch_error_t error
     );
 
-    [DllImport(LibraryName, CallingConvention = CallingConvention.Cdecl)]
-    public static extern size_t usearch_get(
-        usearch_index_t index,
-        usearch_key_t key,
-        size_t count,
-        [Out] double[] vector,
-        ScalarKind vector_kind,
-        out usearch_error_t error
-    );
 
     [DllImport(LibraryName, CallingConvention = CallingConvention.Cdecl)]
     public static extern size_t usearch_remove(usearch_index_t index, usearch_key_t key, out usearch_error_t error);
diff --git a/csharp/src/Cloud.Unum.USearch/USearchIndex.cs b/csharp/src/Cloud.Unum.USearch/USearchIndex.cs
index 91dd50d0..751edb9b 100644
--- a/csharp/src/Cloud.Unum.USearch/USearchIndex.cs
+++ b/csharp/src/Cloud.Unum.USearch/USearchIndex.cs
@@ -4,12 +4,25 @@
 
 namespace Cloud.Unum.USearch;
 
+/// <summary>
+/// USearchIndex class provides a managed wrapper for the USearch library's index functionality.
+/// </summary>
 public class USearchIndex : IDisposable
 {
     private IntPtr _index;
     private bool _disposedValue = false;
     private ulong _cachedDimensions;
 
+    /// <summary>
+    /// Initializes a new instance of the USearchIndex class with specified options.
+    /// </summary>
+    /// <param name="metricKind">The metric kind used for distance calculation between vectors.</param>
+    /// <param name="quantization">The scalar kind used for quantization of vector data during indexing.</param>
+    /// <param name="dimensions">The number of dimensions in the vectors to be indexed.</param>
+    /// <param name="connectivity">The optional connectivity parameter that limits connections-per-node in the graph.</param>
+    /// <param name="expansionAdd">The optional expansion factor used for index construction when adding vectors.</param>
+    /// <param name="expansionSearch">The optional expansion factor used for index construction during search operations.</param>
+    /// <param name="multi">When set allows multiple vectors to map to the same key.</param>
     public USearchIndex(
         MetricKind metricKind,
         ScalarKind quantization,
@@ -18,7 +31,6 @@ public USearchIndex(
         ulong expansionAdd = 0,
         ulong expansionSearch = 0,
         bool multi = false
-    //CustomDistanceFunction? customMetric = null
     )
     {
         IndexOptions initOptions = new()
@@ -38,6 +50,10 @@ public USearchIndex(
         this._cachedDimensions = dimensions;
     }
 
+    /// <summary>
+    /// Initializes a new instance of the USearchIndex class with specified options.
+    /// </summary>
+    /// <param name="options">The options structure containing initialization parameters.</param>
     public USearchIndex(IndexOptions options)
     {
         this._index = usearch_init(ref options, out IntPtr error);
@@ -45,6 +61,11 @@ public USearchIndex(IndexOptions options)
         this._cachedDimensions = options.dimensions;
     }
 
+    /// <summary>
+    /// Initializes a new instance of the USearchIndex class and loads or views the index from a specified file.
+    /// </summary>
+    /// <param name="path">The file path from where the index will be loaded or viewed.</param>
+    /// <param name="view">If true, creates a view of the index without copying it into memory.</param>
     public USearchIndex(string path, bool view = false)
     {
         IndexOptions initOptions = new();
@@ -65,12 +86,20 @@ public USearchIndex(string path, bool view = false)
         this._cachedDimensions = this.Dimensions();
     }
 
+    /// <summary>
+    /// Saves the index to a specified file.
+    /// </summary>
+    /// <param name="path">The file path where the index will be saved.</param>
     public void Save(string path)
     {
         usearch_save(this._index, path, out IntPtr error);
         HandleError(error);
     }
 
+    /// <summary>
+    /// Gets the current size (number of vectors) of the index.
+    /// </summary>
+    /// <returns>The number of vectors in the index.</returns>
     public ulong Size()
     {
         ulong size = (ulong)usearch_size(this._index, out IntPtr error);
@@ -78,6 +107,10 @@ public ulong Size()
         return size;
     }
 
+    /// <summary>
+    /// Gets the current capacity (number of vectors) of the index.
+    /// </summary>
+    /// <returns>The capacity of the index.</returns>
     public ulong Capacity()
     {
         ulong capacity = (ulong)usearch_capacity(this._index, out IntPtr error);
@@ -85,6 +118,10 @@ public ulong Capacity()
         return capacity;
     }
 
+    /// <summary>
+    /// Gets the number of dimensions in the vectors in the index.
+    /// </summary>
+    /// <returns>The number of dimensions.</returns>
     public ulong Dimensions()
     {
         ulong dimensions = (ulong)usearch_dimensions(this._index, out IntPtr error);
@@ -92,6 +129,10 @@ public ulong Dimensions()
         return dimensions;
     }
 
+    /// <summary>
+    /// Gets the connectivity parameter of the index.
+    /// </summary>
+    /// <returns>The connectivity parameter.</returns>
     public ulong Connectivity()
     {
         ulong connectivity = (ulong)usearch_connectivity(this._index, out IntPtr error);
@@ -99,6 +140,11 @@ public ulong Connectivity()
         return connectivity;
     }
 
+    /// <summary>
+    /// Checks if the index contains a vector with a specific key.
+    /// </summary>
+    /// <param name="key">The key to be checked.</param>
+    /// <returns>True if the index contains the vector with the given key, false otherwise.</returns>
     public bool Contains(ulong key)
     {
         bool result = usearch_contains(this._index, key, out IntPtr error);
@@ -106,6 +152,11 @@ public bool Contains(ulong key)
         return result;
     }
 
+    /// <summary>
+    /// Counts the number of entries in the index under a specific key.
+    /// </summary>
+    /// <param name="key">The key to be checked.</param>
+    /// <returns>The number of vectors found under that key.</returns>
     public int Count(ulong key)
     {
         int count = checked((int)usearch_count(this._index, key, out IntPtr error));
@@ -113,12 +164,21 @@ public int Count(ulong key)
         return count;
     }
 
+    /// <summary>
+    /// Reserves additional capacity in the index.
+    /// </summary>
+    /// <param name="size">The number of new vectors to reserve capacity for.</param>
     private void IncreaseCapacity(ulong size)
     {
         usearch_reserve(this._index, (UIntPtr)(this.Size() + size), out IntPtr error);
         HandleError(error);
     }
 
+    /// <summary>
+    /// Checks if the index has enough capacity to add a specific number of vectors.
+    /// If not, increases the capacity.
+    /// </summary>
+    /// <param name="size_increase">The number of vectors to be added.</param>
     private void CheckIncreaseCapacity(ulong size_increase)
     {
         ulong size_demand = this.Size() + size_increase;
@@ -127,148 +187,301 @@ private void CheckIncreaseCapacity(ulong size_increase)
             this.IncreaseCapacity(size_increase);
         }
     }
-
+    /// <summary>
+    /// Adds a vector with a specific key to the index.
+    /// </summary>
+    /// <param name="key">The key associated with the vector.</param>
+    /// <param name="vector">The vector data to be added.</param>
     public void Add(ulong key, float[] vector)
     {
         this.CheckIncreaseCapacity(1);
-        usearch_add(this._index, key, vector, ScalarKind.Float32, out IntPtr error);
-        HandleError(error);
+        GCHandle handle = GCHandle.Alloc(vector, GCHandleType.Pinned);
+        try
+        {
+            IntPtr vectorPtr = handle.AddrOfPinnedObject();
+            usearch_add(this._index, key, vectorPtr, ScalarKind.Float32, out IntPtr error);
+            HandleError(error);
+        }
+        finally
+        {
+            handle.Free();
+        }
     }
 
+    /// <summary>
+    /// Adds a vector with a specific key to the index.
+    /// </summary>
+    /// <param name="key">The key associated with the vector.</param>
+    /// <param name="vector">The vector data to be added.</param>
     public void Add(ulong key, double[] vector)
     {
         this.CheckIncreaseCapacity(1);
-        usearch_add(this._index, key, vector, ScalarKind.Float64, out IntPtr error);
-        HandleError(error);
+        GCHandle handle = GCHandle.Alloc(vector, GCHandleType.Pinned);
+        try
+        {
+            IntPtr vectorPtr = handle.AddrOfPinnedObject();
+            usearch_add(this._index, key, vectorPtr, ScalarKind.Float64, out IntPtr error);
+            HandleError(error);
+        }
+        finally
+        {
+            handle.Free();
+        }
     }
 
+    /// <summary>
+    /// Adds multiple vectors with specific keys to the index.
+    /// </summary>
+    /// <param name="keys">The keys associated with the vectors.</param>
+    /// <param name="vectors">The vector data to be added.</param>
     public void Add(ulong[] keys, float[][] vectors)
     {
         this.CheckIncreaseCapacity((ulong)vectors.Length);
         for (int i = 0; i < vectors.Length; i++)
         {
-            usearch_add(this._index, keys[i], vectors[i], ScalarKind.Float32, out IntPtr error);
-            HandleError(error);
+            GCHandle handle = GCHandle.Alloc(vectors[i], GCHandleType.Pinned);
+            try
+            {
+                IntPtr vectorPtr = handle.AddrOfPinnedObject();
+                usearch_add(this._index, keys[i], vectorPtr, ScalarKind.Float32, out IntPtr error);
+                HandleError(error);
+            }
+            finally
+            {
+                handle.Free();
+            }
         }
     }
 
+    /// <summary>
+    /// Adds multiple vectors with specific keys to the index.
+    /// </summary>
+    /// <param name="keys">The keys associated with the vectors.</param>
+    /// <param name="vectors">The vector data to be added.</param>
     public void Add(ulong[] keys, double[][] vectors)
     {
         this.CheckIncreaseCapacity((ulong)vectors.Length);
         for (int i = 0; i < vectors.Length; i++)
         {
-            usearch_add(this._index, keys[i], vectors[i], ScalarKind.Float64, out IntPtr error);
-            HandleError(error);
+            GCHandle handle = GCHandle.Alloc(vectors[i], GCHandleType.Pinned);
+            try
+            {
+                IntPtr vectorPtr = handle.AddrOfPinnedObject();
+                usearch_add(this._index, keys[i], vectorPtr, ScalarKind.Float64, out IntPtr error);
+                HandleError(error);
+            }
+            finally
+            {
+                handle.Free();
+            }
         }
     }
 
+
+    /// <summary>
+    /// Retrieves the vector associated with the given key from the index.
+    /// </summary>
+    /// <param name="key">The key of the vector to retrieve.</param>
+    /// <param name="vector">The vector data retrieved from the index.</param>
+    /// <returns>The number of vectors found under that key.</returns>
     public int Get(ulong key, out float[] vector)
     {
         vector = new float[this._cachedDimensions];
-        int foundVectorsCount = checked((int)usearch_get(this._index, key, (UIntPtr)1, vector, ScalarKind.Float32, out IntPtr error));
-        HandleError(error);
-        if (foundVectorsCount < 1)
+        GCHandle handle = GCHandle.Alloc(vector, GCHandleType.Pinned);
+        try
         {
-            vector = null;
-        }
+            IntPtr vectorPtr = handle.AddrOfPinnedObject();
+            int foundVectorsCount = checked((int)NativeMethods.usearch_get(this._index, key, (UIntPtr)1, vectorPtr, ScalarKind.Float32, out IntPtr error));
+            HandleError(error);
+            if (foundVectorsCount < 1)
+            {
+                vector = null;
+            }
 
-        return foundVectorsCount;
+            return foundVectorsCount;
+        }
+        finally
+        {
+            handle.Free();
+        }
     }
 
+    /// <summary>
+    /// Retrieves multiple vectors associated with the given key from the index.
+    /// </summary>
+    /// <param name="key">The key of the vectors to retrieve.</param>
+    /// <param name="count">The number of vectors to retrieve.</param>
+    /// <param name="vectors">The vectors data retrieved from the index.</param>
+    /// <returns>The number of vectors found under that key.</returns>
     public int Get(ulong key, int count, out float[][] vectors)
     {
         var flattenVectors = new float[count * (int)this._cachedDimensions];
-        int foundVectorsCount = checked((int)usearch_get(this._index, key, (UIntPtr)count, flattenVectors, ScalarKind.Float32, out IntPtr error));
-        HandleError(error);
-        if (foundVectorsCount < 1)
-        {
-            vectors = null;
-        }
-        else
+        GCHandle handle = GCHandle.Alloc(flattenVectors, GCHandleType.Pinned);
+        try
         {
-            vectors = new float[foundVectorsCount][];
-            for (int i = 0; i < foundVectorsCount; i++)
+            IntPtr vectorPtr = handle.AddrOfPinnedObject();
+            int foundVectorsCount = checked((int)NativeMethods.usearch_get(this._index, key, (UIntPtr)count, vectorPtr, ScalarKind.Float32, out IntPtr error));
+            HandleError(error);
+            if (foundVectorsCount < 1)
             {
-                vectors[i] = new float[this._cachedDimensions];
-                Array.Copy(flattenVectors, i * (int)this._cachedDimensions, vectors[i], 0, (int)this._cachedDimensions);
+                vectors = null;
+            }
+            else
+            {
+                vectors = new float[foundVectorsCount][];
+                for (int i = 0; i < foundVectorsCount; i++)
+                {
+                    vectors[i] = new float[(int)this._cachedDimensions];
+                    Array.Copy(flattenVectors, i * (int)this._cachedDimensions, vectors[i], 0, (int)this._cachedDimensions);
+                }
             }
-        }
 
-        return foundVectorsCount;
+            return foundVectorsCount;
+        }
+        finally
+        {
+            handle.Free();
+        }
     }
 
+    /// <summary>
+    /// Retrieves the vector associated with the given key from the index.
+    /// </summary>
+    /// <param name="key">The key of the vector to retrieve.</param>
+    /// <param name="vector">The vector data retrieved from the index.</param>
+    /// <returns>The number of vectors found under that key.</returns>
     public int Get(ulong key, out double[] vector)
     {
         vector = new double[this._cachedDimensions];
-        int foundVectorsCount = checked((int)usearch_get(this._index, key, (UIntPtr)1, vector, ScalarKind.Float64, out IntPtr error));
-        HandleError(error);
-        if (foundVectorsCount < 1)
+        GCHandle handle = GCHandle.Alloc(vector, GCHandleType.Pinned);
+        try
         {
-            vector = null;
-        }
+            IntPtr vectorPtr = handle.AddrOfPinnedObject();
+            int foundVectorsCount = checked((int)NativeMethods.usearch_get(this._index, key, (UIntPtr)1, vectorPtr, ScalarKind.Float64, out IntPtr error));
+            HandleError(error);
+            if (foundVectorsCount < 1)
+            {
+                vector = null;
+            }
 
-        return foundVectorsCount;
+            return foundVectorsCount;
+        }
+        finally
+        {
+            handle.Free();
+        }
     }
 
+    /// <summary>
+    /// Retrieves multiple vectors associated with the given key from the index.
+    /// </summary>
+    /// <param name="key">The key of the vectors to retrieve.</param>
+    /// <param name="count">The number of vectors to retrieve.</param>
+    /// <param name="vectors">The vectors data retrieved from the index.</param>
+    /// <returns>The number of vectors found under that key.</returns>
     public int Get(ulong key, int count, out double[][] vectors)
     {
         var flattenVectors = new double[count * (int)this._cachedDimensions];
-        int foundVectorsCount = checked((int)usearch_get(this._index, key, (UIntPtr)count, flattenVectors, ScalarKind.Float64, out IntPtr error));
-        HandleError(error);
-        if (foundVectorsCount < 1)
-        {
-            vectors = null;
-        }
-        else
+        GCHandle handle = GCHandle.Alloc(flattenVectors, GCHandleType.Pinned);
+        try
         {
-            vectors = new double[foundVectorsCount][];
-            for (int i = 0; i < foundVectorsCount; i++)
+            IntPtr vectorPtr = handle.AddrOfPinnedObject();
+            int foundVectorsCount = checked((int)NativeMethods.usearch_get(this._index, key, (UIntPtr)count, vectorPtr, ScalarKind.Float64, out IntPtr error));
+            HandleError(error);
+            if (foundVectorsCount < 1)
             {
-                vectors[i] = new double[this._cachedDimensions];
-                Array.Copy(flattenVectors, i * (int)this._cachedDimensions, vectors[i], 0, (int)this._cachedDimensions);
+                vectors = null;
+            }
+            else
+            {
+                vectors = new double[foundVectorsCount][];
+                for (int i = 0; i < foundVectorsCount; i++)
+                {
+                    vectors[i] = new double[(int)this._cachedDimensions];
+                    Array.Copy(flattenVectors, i * (int)this._cachedDimensions, vectors[i], 0, (int)this._cachedDimensions);
+                }
             }
-        }
 
-        return foundVectorsCount;
+            return foundVectorsCount;
+        }
+        finally
+        {
+            handle.Free();
+        }
     }
 
+    /// <summary>
+    /// Searches for the closest vectors to the query vector.
+    /// </summary>
+    /// <param name="queryVector">The query vector data.</param>
+    /// <param name="count">The number of nearest neighbors to search.</param>
+    /// <param name="keys">The keys of the nearest neighbors found.</param>
+    /// <param name="distances">The distances to the nearest neighbors found.</param>
+    /// <param name="scalarKind">The scalar type used in the query vector data.</param>
+    /// <returns>The number of matches found.</returns>
     private int Search<T>(T[] queryVector, int count, out ulong[] keys, out float[] distances, ScalarKind scalarKind)
     {
         keys = new ulong[count];
         distances = new float[count];
 
         GCHandle handle = GCHandle.Alloc(queryVector, GCHandleType.Pinned);
-        int matches = 0;
+        GCHandle keysHandle = GCHandle.Alloc(keys, GCHandleType.Pinned);
+        GCHandle distancesHandle = GCHandle.Alloc(distances, GCHandleType.Pinned);
         try
         {
             IntPtr queryVectorPtr = handle.AddrOfPinnedObject();
-            matches = checked((int)usearch_search(this._index, queryVectorPtr, scalarKind, (UIntPtr)count, keys, distances, out IntPtr error));
+            IntPtr keysPtr = keysHandle.AddrOfPinnedObject();
+            IntPtr distancesPtr = distancesHandle.AddrOfPinnedObject();
+            int matches = checked((int)NativeMethods.usearch_search(this._index, queryVectorPtr, scalarKind, (UIntPtr)count, keysPtr, distancesPtr, out IntPtr error));
             HandleError(error);
+
+            if (matches < count)
+            {
+                Array.Resize(ref keys, matches);
+                Array.Resize(ref distances, matches);
+            }
+
+            return matches;
         }
         finally
         {
             handle.Free();
+            keysHandle.Free();
+            distancesHandle.Free();
         }
-
-        if (matches < count)
-        {
-            Array.Resize(ref keys, (int)matches);
-            Array.Resize(ref distances, (int)matches);
-        }
-
-        return matches;
     }
 
+    /// <summary>
+    /// Searches for the closest vectors to the query vector.
+    /// </summary>
+    /// <param name="queryVector">The query vector data.</param>
+    /// <param name="count">The number of nearest neighbors to search.</param>
+    /// <param="keys">The keys of the nearest neighbors found.</param>
+    /// <param name="distances">The distances to the nearest neighbors found.</param>
+    /// <returns>The number of matches found.</returns>
     public int Search(float[] queryVector, int count, out ulong[] keys, out float[] distances)
     {
         return this.Search(queryVector, count, out keys, out distances, ScalarKind.Float32);
     }
 
+    /// <summary>
+    /// Searches for the closest vectors to the query vector.
+    /// </summary>
+    /// <param name="queryVector">The query vector data.</param>
+    /// <param="count">The number of nearest neighbors to search.</param>
+    /// <param="keys">The keys of the nearest neighbors found.</param>
+    /// <param="distances">The distances to the nearest neighbors found.</param>
+    /// <returns>The number of matches found.</returns>
     public int Search(double[] queryVector, int count, out ulong[] keys, out float[] distances)
     {
         return this.Search(queryVector, count, out keys, out distances, ScalarKind.Float64);
     }
 
+    /// <summary>
+    /// Removes the vector associated with the given key from the index.
+    /// </summary>
+    /// <param name="key">The key of the vector to be removed.</param>
+    /// <returns>The number of vectors removed.</returns>
     public int Remove(ulong key)
     {
         int removedCount = checked((int)usearch_remove(this._index, key, out IntPtr error));
@@ -276,6 +489,12 @@ public int Remove(ulong key)
         return removedCount;
     }
 
+    /// <summary>
+    /// Renames the vector to map to a different key.
+    /// </summary>
+    /// <param name="keyFrom">The current key of the vector.</param>
+    /// <param name="keyTo">The new key for the vector.</param>
+    /// <returns>The number of vectors renamed.</returns>
     public int Rename(ulong keyFrom, ulong keyTo)
     {
         int foundVectorsCount = checked((int)usearch_rename(this._index, keyFrom, keyTo, out IntPtr error));
@@ -283,6 +502,10 @@ public int Rename(ulong keyFrom, ulong keyTo)
         return foundVectorsCount;
     }
 
+    /// <summary>
+    /// Handles errors by throwing a USearchException if the error pointer is not null.
+    /// </summary>
+    /// <param name="error">The error pointer returned by USearch functions.</param>
     private static void HandleError(IntPtr error)
     {
         if (error != IntPtr.Zero)
@@ -291,6 +514,9 @@ private static void HandleError(IntPtr error)
         }
     }
 
+    /// <summary>
+    /// Frees the resources associated with the index.
+    /// </summary>
     private void FreeIndex()
     {
         if (this._index != IntPtr.Zero)
@@ -301,12 +527,19 @@ private void FreeIndex()
         }
     }
 
+    /// <summary>
+    /// Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources.
+    /// </summary>
     public void Dispose()
     {
         this.Dispose(true);
         GC.SuppressFinalize(this);
     }
 
+    /// <summary>
+    /// Releases the unmanaged resources used by the USearchIndex and optionally releases the managed resources.
+    /// </summary>
+    /// <param name="disposing">If true, release both managed and unmanaged resources; otherwise, release only unmanaged resources.</param>
     protected virtual void Dispose(bool disposing)
     {
         if (!this._disposedValue)
@@ -316,7 +549,9 @@ protected virtual void Dispose(bool disposing)
         }
     }
 
-    ~USearchIndex() => this.Dispose(false);
-
 
+    /// <summary>
+    /// Destructor for the USearchIndex class.
+    /// </summary>
+    ~USearchIndex() => this.Dispose(false);
 }
diff --git a/csharp/src/Cloud.Unum.USearch/USearchTypes.cs b/csharp/src/Cloud.Unum.USearch/USearchTypes.cs
index 4e492693..f66c4a70 100644
--- a/csharp/src/Cloud.Unum.USearch/USearchTypes.cs
+++ b/csharp/src/Cloud.Unum.USearch/USearchTypes.cs
@@ -3,51 +3,161 @@
 
 namespace Cloud.Unum.USearch;
 
+/// <summary>
+/// Specifies the kind of metric to be used for distance calculation between vectors.
+/// </summary>
 public enum MetricKind : uint
 {
+    /// <summary>
+    /// Unknown metric kind.
+    /// </summary>
     Unknown = 0,
+
+    /// <summary>
+    /// Cosine similarity.
+    /// </summary>
     Cos = 1,
+
+    /// <summary>
+    /// Inner product.
+    /// </summary>
     Ip = 2,
+
+    /// <summary>
+    /// Squared Euclidean distance.
+    /// </summary>
     L2sq = 3,
+
+    /// <summary>
+    /// Haversine distance.
+    /// </summary>
     Haversine = 4,
+
+    /// <summary>
+    /// Kullback-Leibler divergence.
+    /// </summary>
     Divergence = 5,
+
+    /// <summary>
+    /// Pearson correlation.
+    /// </summary>
     Pearson = 6,
+
+    /// <summary>
+    /// Jaccard index.
+    /// </summary>
     Jaccard = 7,
+
+    /// <summary>
+    /// Hamming distance.
+    /// </summary>
     Hamming = 8,
+
+    /// <summary>
+    /// Tanimoto coefficient.
+    /// </summary>
     Tanimoto = 9,
+
+    /// <summary>
+    /// Sørensen-Dice coefficient.
+    /// </summary>
     Sorensen = 10,
 }
 
+/// <summary>
+/// Specifies the kind of scalar used for quantization of vector data during indexing.
+/// </summary>
 public enum ScalarKind : uint
 {
+    /// <summary>
+    /// Unknown scalar kind.
+    /// </summary>
     Unknown = 0,
+
+    /// <summary>
+    /// 32-bit floating point.
+    /// </summary>
     Float32 = 1,
+
+    /// <summary>
+    /// 64-bit floating point.
+    /// </summary>
     Float64 = 2,
+
+    /// <summary>
+    /// 16-bit floating point.
+    /// </summary>
     Float16 = 3,
+
+    /// <summary>
+    /// 8-bit integer.
+    /// </summary>
     Int8 = 4,
+
+    /// <summary>
+    /// 1-bit binary.
+    /// </summary>
     Bits1 = 5,
 }
 
-// TODO: implement custom metric delegate
-// Microsoft guides links:
-// 1) https://learn.microsoft.com/en-us/dotnet/standard/native-interop/best-practices
-// 2) https://learn.microsoft.com/en-us/dotnet/framework/interop/marshalling-a-delegate-as-a-callback-method
-// public delegate float CustomMetricFunction(IntPtr a, IntPtr b);
-
+/// <summary>
+/// Represents the initialization options for creating a USearch index.
+/// </summary>
 [StructLayout(LayoutKind.Sequential)]
 public struct IndexOptions
 {
+    /// <summary>
+    /// The metric kind used for distance calculation between vectors.
+    /// </summary>
     public MetricKind metric_kind;
+
+    /// <summary>
+    /// The optional custom metric function for distance calculation between vectors. Not supported yet.
+    /// </summary>
     public IntPtr metric;
+
+    /// <summary>
+    /// The scalar kind used for quantization of vector data during indexing.
+    /// </summary>
     public ScalarKind quantization;
+
+    /// <summary>
+    /// The number of dimensions in the vectors to be indexed.
+    /// </summary>
     public ulong dimensions;
+
+    /// <summary>
+    /// The optional connectivity parameter that limits connections-per-node in the graph.
+    /// </summary>
     public ulong connectivity;
+
+    /// <summary>
+    /// The optional expansion factor used for index construction when adding vectors.
+    /// </summary>
     public ulong expansion_add;
+
+    /// <summary>
+    /// The optional expansion factor used for index construction during search operations.
+    /// </summary>
     public ulong expansion_search;
 
+    /// <summary>
+    /// Indicates whether multiple vectors can map to the same key.
+    /// </summary>
     [MarshalAs(UnmanagedType.Bool)]
     public bool multi;
 
+    /// <summary>
+    /// Initializes a new instance of the IndexOptions struct with specified parameters.
+    /// </summary>
+    /// <param name="metricKind">The metric kind used for distance calculation between vectors.</param>
+    /// <param name="metric">The optional custom metric function for distance calculation between vectors. Not supported yet.</param>
+    /// <param name="quantization">The scalar kind used for quantization of vector data during indexing.</param>
+    /// <param name="dimensions">The number of dimensions in the vectors to be indexed.</param>
+    /// <param name="connectivity">The optional connectivity parameter that limits connections-per-node in the graph.</param>
+    /// <param name="expansionAdd">The optional expansion factor used for index construction when adding vectors.</param>
+    /// <param name="expansionSearch">The optional expansion factor used for index construction during search operations.</param>
+    /// <param name="multi">Indicates whether multiple vectors can map to the same key.</param>
     public IndexOptions(
         MetricKind metricKind = MetricKind.Unknown,
         IntPtr metric = default,
@@ -60,7 +170,7 @@ public IndexOptions(
     )
     {
         this.metric_kind = metricKind;
-        this.metric = default; // TODO: Use actual metric param, when support is added for custom metric delegate
+        this.metric = metric;
         this.quantization = quantization;
         this.dimensions = dimensions;
         this.connectivity = connectivity;
@@ -69,4 +179,3 @@ public IndexOptions(
         this.multi = multi;
     }
 }
-
diff --git a/docs/index.rst b/docs/index.rst
index ff6c2fbf..7daef76c 100644
--- a/docs/index.rst
+++ b/docs/index.rst
@@ -8,11 +8,11 @@ Overview
    :caption: �
 
    cpp/index
+   c/index
    python/index
    rust/index
    javascript/index
    java/index
-   c/index
    swift/index
    objc/index
    csharp/index
diff --git a/docs/java/index.rst b/docs/java/index.rst
index f3b85e0c..a70d62d0 100644
--- a/docs/java/index.rst
+++ b/docs/java/index.rst
@@ -4,8 +4,3 @@ Java SDK
 
 
 .. mdinclude:: ../../java/README.md
-
-.. toctree::
-   :hidden:
-
-   reference
\ No newline at end of file
diff --git a/docs/javascript/index.rst b/docs/javascript/index.rst
index e3bf3660..4e145a1b 100644
--- a/docs/javascript/index.rst
+++ b/docs/javascript/index.rst
@@ -4,8 +4,3 @@ JavaScript SDK
 
 
 .. mdinclude:: ../../javascript/README.md
-
-.. toctree::
-   :hidden:
-
-   reference
\ No newline at end of file
diff --git a/golang/README.md b/golang/README.md
index df4ee33d..5ebe831f 100644
--- a/golang/README.md
+++ b/golang/README.md
@@ -4,7 +4,7 @@
 
 ### Linux
 
-Download and install from the Debian package from the latest release.
+Download and install the Debian package from the latest release.
 Substitute `<release_tag>`, `<arch>`, and `<usearch_version>` with your settings.
 
 ```sh
@@ -14,8 +14,8 @@ dpkg -i usearch_<arch>_<usearch_version>.deb
 
 ### Windows
 
-Run a `winlibinstaller.bat` script from the main repository in the folder where you will run `go run`.
-That will install the USearch library and include in the same folder` where the script was run.
+Run the `winlibinstaller.bat` script from the main repository in the folder where you will run `go run`.
+This will install the USearch library and include it in the same folder where the script was run.
 
 ```sh
 .\usearch\winlibinstaller.bat
@@ -23,13 +23,13 @@ That will install the USearch library and include in the same folder` where the
 
 ### MacOS
 
-Download and unpack a zip archive from the latest release.
+Download and unpack the zip archive from the latest release.
 Move the USearch library and the include file to their respective folders.
 
 ```sh
 wget https://github.com/unum-cloud/usearch/releases/download/<release_tag>/usearch_macos_<arch>_<usearch_version>.zip
 unzip usearch_macos_<arch>_<usearch_version>.zip
-sudo mv libusearch_c.so /usr/local/lib && sudo mv usearch.h /usr/local/include
+sudo mv libusearch_c.dylib /usr/local/lib && sudo mv usearch.h /usr/local/include
 ```
 
 ## Quickstart
@@ -48,26 +48,26 @@ go <go_version>
 package main
 
 import (
-"fmt"
-usearch "github.com/unum-cloud/usearch/golang"
+	"fmt"
+	usearch "github.com/unum-cloud/usearch/golang"
 )
 
 func main() {
 
    	// Create Index
-   	vector_size := 3
-   	vectors_count := 100
-   	conf := usearch.DefaultConfig(uint(vector_size))
-   	index,err := usearch.NewIndex(conf)
+   	vectorSize := 3
+   	vectorsCount := 100
+   	conf := usearch.DefaultConfig(uint(vectorSize))
+   	index, err := usearch.NewIndex(conf)
    	if err != nil {
    		panic("Failed to create Index")
    	}
    	defer index.Destroy()
 
    	// Add to Index
-   	err = index.Reserve(uint(vectors_count))
-   	for i := 0; i < vectors_count; i++ {
-   		err = index.Add(usearch.Key(i), []float32{float32(i), float32(i+1), float32(i+2)})
+   	err = index.Reserve(uint(vectorsCount))
+   	for i := 0; i < vectorsCount; i++ {
+   		err = index.Add(usearch.Key(i), []float32{float32(i), float32(i + 1), float32(i + 2)})
       	if err != nil {
       		panic("Failed to add")
       	}
@@ -93,3 +93,24 @@ go get github.com/unum-cloud/usearch/golang
 ```sh
 go run example.go
 ```
+
+## Serialization
+
+To save and load the index from disk, use the following methods:
+
+```go
+err := index.Save("index.usearch")
+if err != nil {
+    panic("Failed to save index")
+}
+
+err = index.Load("index.usearch")
+if err != nil {
+    panic("Failed to load index")
+}
+
+err = index.View("index.usearch")
+if err != nil {
+    panic("Failed to view index")
+}
+```
diff --git a/golang/lib.go b/golang/lib.go
index dd12fe66..d54f6502 100644
--- a/golang/lib.go
+++ b/golang/lib.go
@@ -12,10 +12,13 @@ import (
 */
 import "C"
 
+// Key represents the type for keys used in the USearch index.
 type Key = uint64
 
+// Metric represents the type for different metrics used in distance calculations.
 type Metric uint8
 
+// Different metric kinds supported by the USearch library.
 const (
 	InnerProduct Metric = iota
 	Cosine
@@ -28,6 +31,7 @@ const (
 	Sorensen
 )
 
+// String returns the string representation of the Metric.
 func (m Metric) String() string {
 	switch m {
 	case L2sq:
@@ -53,8 +57,10 @@ func (m Metric) String() string {
 	}
 }
 
+// Quantization represents the type for different scalar kinds used in quantization.
 type Quantization uint8
 
+// Different quantization kinds supported by the USearch library.
 const (
 	F32 Quantization = iota
 	F16
@@ -63,6 +69,7 @@ const (
 	B1
 )
 
+// String returns the string representation of the Quantization.
 func (a Quantization) String() string {
 	switch a {
 	case F16:
@@ -80,23 +87,18 @@ func (a Quantization) String() string {
 	}
 }
 
+// IndexConfig represents the configuration options for initializing a USearch index.
 type IndexConfig struct {
-	// The scalar kind used for quantization of vector data during indexing.
-	Quantization Quantization
-	// The metric kind used for distance calculation between vectors.
-	Metric Metric
-	// The number of dimensions in the vectors to be indexed.
-	Dimensions uint
-	// The @b optional connectivity parameter that limits connections-per-node in graph.
-	Connectivity uint
-	// The @b optional expansion factor used for index construction when adding vectors.
-	ExpansionAdd uint
-	// The @b optional expansion factor used for index construction during search operations.
-	ExpansionSearch uint
-	// The @b optional multi flag.
-	Multi bool
+	Quantization    Quantization // The scalar kind used for quantization of vector data during indexing.
+	Metric          Metric       // The metric kind used for distance calculation between vectors.
+	Dimensions      uint         // The number of dimensions in the vectors to be indexed.
+	Connectivity    uint         // The optional connectivity parameter that limits connections-per-node in the graph.
+	ExpansionAdd    uint         // The optional expansion factor used for index construction when adding vectors.
+	ExpansionSearch uint         // The optional expansion factor used for index construction during search operations.
+	Multi           bool         // Indicates whether multiple vectors can map to the same key.
 }
 
+// DefaultConfig returns an IndexConfig with default values for the specified number of dimensions.
 func DefaultConfig(dimensions uint) IndexConfig {
 	c := IndexConfig{}
 	c.Dimensions = dimensions
@@ -109,12 +111,13 @@ func DefaultConfig(dimensions uint) IndexConfig {
 	return c
 }
 
+// Index represents a USearch index.
 type Index struct {
 	opaque_handle *C.void
 	config        IndexConfig
 }
 
-// Initializes a new instance of the index.
+// NewIndex initializes a new instance of the index with the specified configuration.
 func NewIndex(conf IndexConfig) (index *Index, err error) {
 	index = &Index{config: conf}
 
@@ -180,6 +183,7 @@ func NewIndex(conf IndexConfig) (index *Index, err error) {
 	return index, nil
 }
 
+// Len returns the number of vectors in the index.
 func (index *Index) Len() (len uint, err error) {
 	var errorMessage *C.char
 	len = uint(C.usearch_size((C.usearch_index_t)(unsafe.Pointer(index.opaque_handle)), (*C.usearch_error_t)(&errorMessage)))
@@ -189,6 +193,7 @@ func (index *Index) Len() (len uint, err error) {
 	return len, err
 }
 
+// Connectivity returns the connectivity parameter of the index.
 func (index *Index) Connectivity() (con uint, err error) {
 	var errorMessage *C.char
 	con = uint(C.usearch_connectivity((C.usearch_index_t)(unsafe.Pointer(index.opaque_handle)), (*C.usearch_error_t)(&errorMessage)))
@@ -198,6 +203,7 @@ func (index *Index) Connectivity() (con uint, err error) {
 	return con, err
 }
 
+// Dimensions returns the number of dimensions of the vectors in the index.
 func (index *Index) Dimensions() (dim uint, err error) {
 	var errorMessage *C.char
 	dim = uint(C.usearch_dimensions((C.usearch_index_t)(unsafe.Pointer(index.opaque_handle)), (*C.usearch_error_t)(&errorMessage)))
@@ -207,6 +213,7 @@ func (index *Index) Dimensions() (dim uint, err error) {
 	return dim, err
 }
 
+// Capacity returns the capacity (maximum number of vectors) of the index.
 func (index *Index) Capacity() (cap uint, err error) {
 	var errorMessage *C.char
 	cap = uint(C.usearch_capacity((C.usearch_index_t)(unsafe.Pointer(index.opaque_handle)), (*C.usearch_error_t)(&errorMessage)))
@@ -216,7 +223,7 @@ func (index *Index) Capacity() (cap uint, err error) {
 	return cap, err
 }
 
-// Frees the resources associated with the index.
+// Destroy frees the resources associated with the index.
 func (index *Index) Destroy() error {
 	if index.opaque_handle == nil {
 		panic("Index is uninitialized")
@@ -232,7 +239,7 @@ func (index *Index) Destroy() error {
 	return nil
 }
 
-// Reserves memory for a specified number of incoming vectors.
+// Reserve reserves memory for a specified number of incoming vectors.
 func (index *Index) Reserve(capacity uint) error {
 	if index.opaque_handle == nil {
 		panic("Index is uninitialized")
@@ -246,7 +253,7 @@ func (index *Index) Reserve(capacity uint) error {
 	return nil
 }
 
-// Adds a vector with a key to the index.
+// Add adds a vector with a specified key to the index.
 func (index *Index) Add(key Key, vec []float32) error {
 	if index.opaque_handle == nil {
 		panic("Index is uninitialized")
@@ -260,7 +267,7 @@ func (index *Index) Add(key Key, vec []float32) error {
 	return nil
 }
 
-// Removes the vector associated with the given key from the index.
+// Remove removes the vector associated with the given key from the index.
 func (index *Index) Remove(key Key) error {
 	if index.opaque_handle == nil {
 		panic("Index is uninitialized")
@@ -274,7 +281,7 @@ func (index *Index) Remove(key Key) error {
 	return nil
 }
 
-// Checks if the index contains a vector with a specific key.
+// Contains checks if the index contains a vector with a specific key.
 func (index *Index) Contains(key Key) (found bool, err error) {
 	if index.opaque_handle == nil {
 		panic("Index is uninitialized")
@@ -288,6 +295,7 @@ func (index *Index) Contains(key Key) (found bool, err error) {
 	return found, nil
 }
 
+// Get retrieves the vectors associated with the given key from the index.
 func (index *Index) Get(key Key, count uint) (vectors []float32, err error) {
 	if index.opaque_handle == nil {
 		panic("Index is uninitialized")
@@ -305,7 +313,7 @@ func (index *Index) Get(key Key, count uint) (vectors []float32, err error) {
 	return vectors, nil
 }
 
-// Performs k-Approximate Nearest Neighbors Search for closest vectors to query.
+// Search performs k-Approximate Nearest Neighbors Search for the closest vectors to the query vector.
 func (index *Index) Search(query []float32, limit uint) (keys []Key, distances []float32, err error) {
 	if index.opaque_handle == nil {
 		panic("Index is uninitialized")
@@ -327,7 +335,7 @@ func (index *Index) Search(query []float32, limit uint) (keys []Key, distances [
 	return keys, distances, nil
 }
 
-// Saves the index to a file.
+// Save saves the index to a specified file.
 func (index *Index) Save(path string) error {
 	if index.opaque_handle == nil {
 		panic("Index is uninitialized")
@@ -344,7 +352,7 @@ func (index *Index) Save(path string) error {
 	return nil
 }
 
-// Loads the index from a file.
+// Load loads the index from a specified file.
 func (index *Index) Load(path string) error {
 	if index.opaque_handle == nil {
 		panic("Index is uninitialized")
@@ -361,7 +369,7 @@ func (index *Index) Load(path string) error {
 	return nil
 }
 
-// Creates a view of the index from a file without loading it into memory.
+// View creates a view of the index from a specified file without loading it into memory.
 func (index *Index) View(path string) error {
 	if index.opaque_handle == nil {
 		panic("Index is uninitialized")
diff --git a/include/usearch/index.hpp b/include/usearch/index.hpp
index ef79586f..971deaac 100644
--- a/include/usearch/index.hpp
+++ b/include/usearch/index.hpp
@@ -8,7 +8,7 @@
 #define UNUM_USEARCH_HPP
 
 #define USEARCH_VERSION_MAJOR 2
-#define USEARCH_VERSION_MINOR 12
+#define USEARCH_VERSION_MINOR 13
 #define USEARCH_VERSION_PATCH 0
 
 // Inferring C++ version
@@ -16,6 +16,9 @@
 #if ((defined(_MSVC_LANG) && _MSVC_LANG >= 201703L) || __cplusplus >= 201703L)
 #define USEARCH_DEFINED_CPP17
 #endif
+#if ((defined(_MSVC_LANG) && _MSVC_LANG >= 202002L) || __cplusplus >= 202002L)
+#define USEARCH_DEFINED_CPP20
+#endif
 
 // Inferring target OS: Windows, MacOS, or Linux
 #if defined(WIN32) || defined(_WIN32) || defined(__WIN32__) || defined(__NT__)
@@ -33,6 +36,14 @@
 #define USEARCH_DEFINED_GCC
 #endif
 
+// The `#pragma region` and `#pragma endregion` are not supported by GCC 12 and older.
+// But they are supported by GCC 13, all recent Clang versions, and MSVC.
+#if defined(__GNUC__) && ((__GNUC__ > 13) || (__GNUC__ == 13 && __GNUC_MINOR__ >= 0))
+#define USEARCH_USE_PRAGMA_REGION
+#elif defined(__clang__) || defined(_MSC_VER)
+#define USEARCH_USE_PRAGMA_REGION
+#endif
+
 // Inferring hardware architecture: x86 vs Arm
 #if defined(__x86_64__)
 #define USEARCH_DEFINED_X86
@@ -84,17 +95,39 @@
 #include <thread>    // `std::thread`
 #include <utility>   // `std::pair`
 
+// Helper macros for concatenation and stringification
+#define usearch_concat_helper_m(a, b) a##b
+#define usearch_concat_m(a, b) usearch_concat_helper_m(a, b)
+#define usearch_stringify_helper_m(x) #x
+#define usearch_stringify_m(x) usearch_stringify_helper_m(x)
+
 // Prefetching
 #if defined(USEARCH_DEFINED_GCC)
 // https://gcc.gnu.org/onlinedocs/gcc/Other-Builtins.html
 // Zero means we are only going to read from that memory.
 // Three means high temporal locality and suggests to keep
 // the data in all layers of cache.
-#define prefetch_m(ptr) __builtin_prefetch((void*)(ptr), 0, 3)
+#define usearch_prefetch_m(ptr) __builtin_prefetch((void*)(ptr), 0, 3)
 #elif defined(USEARCH_DEFINED_X86)
-#define prefetch_m(ptr) _mm_prefetch((void*)(ptr), _MM_HINT_T0)
+#define usearch_prefetch_m(ptr) _mm_prefetch((void*)(ptr), _MM_HINT_T0)
+#else
+#define usearch_prefetch_m(ptr)
+#endif
+
+// Function profiling
+#if defined(usearch_defined_x86)
+#define usearch_profiled_m __attribute__((noinline))
+#define usearch_profile_name_m(name)                                                                                   \
+    __asm__ volatile(".globl " usearch_stringify_m(usearch_concat_m(name, __COUNTER__)) "\n" usearch_stringify_m(      \
+        usearch_concat_m(name, __COUNTER__)) ":")
+#elif defined(usearch_defined_arm)
+#define usearch_profiled_m __attribute__((noinline))
+#define usearch_profile_name_m(name)                                                                                   \
+    __asm__ volatile(".global " usearch_stringify_m(usearch_concat_m(name, __COUNTER__)) "\n" usearch_stringify_m(     \
+        usearch_concat_m(name, __COUNTER__)) ":")
 #else
-#define prefetch_m(ptr)
+#define usearch_profiled_m
+#define usearch_profile_name_m(name)
 #endif
 
 // Alignment
@@ -180,6 +213,13 @@ template <typename at, typename other_at = at> at exchange(at& obj, other_at&& n
     return old_value;
 }
 
+#if defined(USEARCH_DEFINED_CPP20)
+
+template <typename at> void destroy_at(at* obj) { std::destroy_at(obj); }
+template <typename at> void construct_at(at* obj) { std::construct_at(obj); }
+
+#else
+
 /// @brief  The `std::destroy_at` alternative for C++11.
 template <typename at, typename sfinae_at = at>
 typename std::enable_if<std::is_pod<sfinae_at>::value>::type destroy_at(at*) {}
@@ -196,6 +236,8 @@ typename std::enable_if<!std::is_pod<sfinae_at>::value>::type construct_at(at* o
     new (obj) at();
 }
 
+#endif
+
 /**
  *  @brief  A reference to a misaligned memory location with a specific type.
  *          It is needed to avoid Undefined Behavior when dereferencing addresses
@@ -235,27 +277,57 @@ template <typename at> class misaligned_ptr_gt {
     using pointer = misaligned_ptr_gt<element_t>;
     using reference = misaligned_ref_gt<element_t>;
 
+    misaligned_ptr_gt(byte_t* ptr) noexcept : ptr_(ptr) {}
+
     reference operator*() const noexcept { return {ptr_}; }
     reference operator[](std::size_t i) noexcept { return reference(ptr_ + i * sizeof(element_t)); }
     value_type operator[](std::size_t i) const noexcept {
         return misaligned_load<element_t>(ptr_ + i * sizeof(element_t));
     }
 
-    misaligned_ptr_gt(byte_t* ptr) noexcept : ptr_(ptr) {}
-    misaligned_ptr_gt operator++(int) noexcept { return misaligned_ptr_gt(ptr_ + sizeof(element_t)); }
-    misaligned_ptr_gt operator--(int) noexcept { return misaligned_ptr_gt(ptr_ - sizeof(element_t)); }
-    misaligned_ptr_gt operator+(difference_type d) noexcept { return misaligned_ptr_gt(ptr_ + d * sizeof(element_t)); }
-    misaligned_ptr_gt operator-(difference_type d) noexcept { return misaligned_ptr_gt(ptr_ - d * sizeof(element_t)); }
-
-    // clang-format off
-    misaligned_ptr_gt& operator++() noexcept { ptr_ += sizeof(element_t); return *this; }
-    misaligned_ptr_gt& operator--() noexcept { ptr_ -= sizeof(element_t); return *this; }
-    misaligned_ptr_gt& operator+=(difference_type d) noexcept { ptr_ += d * sizeof(element_t); return *this; }
-    misaligned_ptr_gt& operator-=(difference_type d) noexcept { ptr_ -= d * sizeof(element_t); return *this; }
-    // clang-format on
-
-    bool operator==(misaligned_ptr_gt const& other) noexcept { return ptr_ == other.ptr_; }
-    bool operator!=(misaligned_ptr_gt const& other) noexcept { return ptr_ != other.ptr_; }
+    misaligned_ptr_gt& operator++() noexcept {
+        ptr_ += sizeof(element_t);
+        return *this;
+    }
+    misaligned_ptr_gt& operator--() noexcept {
+        ptr_ -= sizeof(element_t);
+        return *this;
+    }
+    misaligned_ptr_gt operator++(int) noexcept {
+        misaligned_ptr_gt tmp = *this;
+        ++(*this);
+        return tmp;
+    }
+    misaligned_ptr_gt operator--(int) noexcept {
+        misaligned_ptr_gt tmp = *this;
+        --(*this);
+        return tmp;
+    }
+    misaligned_ptr_gt operator+(difference_type d) const noexcept {
+        return misaligned_ptr_gt(ptr_ + d * sizeof(element_t));
+    }
+    misaligned_ptr_gt operator-(difference_type d) const noexcept {
+        return misaligned_ptr_gt(ptr_ - d * sizeof(element_t));
+    }
+    difference_type operator-(const misaligned_ptr_gt& other) const noexcept {
+        return (ptr_ - other.ptr_) / sizeof(element_t);
+    }
+
+    misaligned_ptr_gt& operator+=(difference_type d) noexcept {
+        ptr_ += d * sizeof(element_t);
+        return *this;
+    }
+    misaligned_ptr_gt& operator-=(difference_type d) noexcept {
+        ptr_ -= d * sizeof(element_t);
+        return *this;
+    }
+
+    bool operator==(misaligned_ptr_gt const& other) const noexcept { return ptr_ == other.ptr_; }
+    bool operator!=(misaligned_ptr_gt const& other) const noexcept { return ptr_ != other.ptr_; }
+    bool operator<(misaligned_ptr_gt const& other) const noexcept { return ptr_ < other.ptr_; }
+    bool operator<=(misaligned_ptr_gt const& other) const noexcept { return ptr_ <= other.ptr_; }
+    bool operator>(misaligned_ptr_gt const& other) const noexcept { return ptr_ > other.ptr_; }
+    bool operator>=(misaligned_ptr_gt const& other) const noexcept { return ptr_ >= other.ptr_; }
 };
 
 /**
@@ -291,7 +363,8 @@ template <typename scalar_at, typename allocator_at = std::allocator<scalar_at>>
             for (std::size_t i = 0; i != size_; ++i)
                 construct_at(data_ + i);
     }
-    ~buffer_gt() noexcept {
+    ~buffer_gt() noexcept { reset(); }
+    void reset() noexcept {
         if (!std::is_trivially_destructible<scalar_at>::value)
             for (std::size_t i = 0; i != size_; ++i)
                 destroy_at(data_ + i);
@@ -331,7 +404,8 @@ class error_t {
     char const* message_{};
 
   public:
-    error_t(char const* message = nullptr) noexcept : message_(message) {}
+    error_t() noexcept : message_(nullptr) {}
+    error_t(char const* message) noexcept : message_(message) {}
     error_t& operator=(char const* message) noexcept {
         message_ = message;
         return *this;
@@ -344,11 +418,18 @@ class error_t {
         std::swap(message_, other.message_);
         return *this;
     }
+
+    /// @brief Checks if there was an error.
     explicit operator bool() const noexcept { return message_ != nullptr; }
+
+    /// @brief Returns the error message.
     char const* what() const noexcept { return message_; }
+
+    /// @brief Releases the error message, meaning the caller takes ownership.
     char const* release() noexcept { return exchange(message_, nullptr); }
 
 #if defined(__cpp_exceptions) || defined(__EXCEPTIONS)
+    /// @brief Destructor raises an exception if an error was recorded.
     ~error_t() noexcept(false) {
 #if defined(USEARCH_DEFINED_CPP17)
         if (message_ && std::uncaught_exceptions() == 0)
@@ -357,12 +438,17 @@ class error_t {
 #endif
             raise();
     }
+
+    /// @brief Throws an exception using to be caught by `try` / `catch`.
     void raise() noexcept(false) {
         if (message_)
             throw std::runtime_error(exchange(message_, nullptr));
     }
 #else
+    /// @brief Destructor terminates if an error was recorded.
     ~error_t() noexcept { raise(); }
+
+    /// @brief Terminates if an error was recorded.
     void raise() noexcept {
         if (message_)
             std::terminate();
@@ -375,7 +461,7 @@ class error_t {
  *          or an error. It's used to avoid raising exception, and gracefully propagate
  *          the error.
  *
- * @tparam result_at The type of the expected result.
+ *  @tparam result_at The type of the expected result.
  */
 template <typename result_at> struct expected_gt {
     result_at result;
@@ -509,6 +595,64 @@ using bitset_t = bitset_gt<>;
  *  @brief  Similar to `std::priority_queue`, but allows raw access to underlying
  *          memory, in case you want to shuffle it or sort. Good for collections
  *          from 100s to 10'000s elements.
+ *
+ *  In a max-heap, the heap property ensures that the value of each node is greater
+ *  than or equal to the values of its children. This means that the largest element
+ *  is always at the root of the heap.
+ *
+ *  @section    Heap Structures
+ *
+ *  There are several designs of heaps. Binary heaps are the simplest & most common
+ *  variant, that is easy to implement as a succint array. However, they are not the
+ *  most efficient for all operations. Most importantly, @b melding (merging) of
+ *  two heaps has linear complexity in time.
+ *
+ *  +-----------------+---------+-----------+---------+--------------+---------+
+ *  | Operation       | find-max| delete-max| insert  | increase-key | meld    |
+ *  +-----------------+---------+-----------+---------+--------------+---------+
+ *  | Binary          | Θ(1)    | Θ(log n)  | O(log n)| O(log n)     | Θ(n)    |
+ *  | Leftist         | Θ(1)    | Θ(log n)  | O(log n)| Θ(log n)     | Θ(log n)|
+ *  | Binomial        | Θ(1)    | Θ(log n)  | Θ(1)    | Θ(log n)     | O(log n)|
+ *  | Skew binomial   | Θ(1)    | Θ(log n)  | Θ(1)    | O(log n)     | O(log n)|
+ *  | Pairing         | Θ(1)    | O(log n)  | Θ(1)    | o(log n)     | Θ(1)    |
+ *  | Rank-pairing    | Θ(1)    | O(log n)  | Θ(1)    | Θ(1)         | Θ(1)    |
+ *  | Fibonacci       | Θ(1)    | O(log n)  | Θ(1)    | Θ(1)         | Θ(1)    |
+ *  | Strict Fibonacci| Θ(1)    | O(log n)  | Θ(1)    | Θ(1)         | Θ(1)    |
+ *  | Brodal          | Θ(1)    | Θ(log n)  | Θ(1)    | Θ(1)         | Θ(1)    |
+ *  | 2–3 heap        | Θ(1)    | O(log n)  | Θ(1)    | Θ(1)         | O(log n)|
+ *  +-----------------+---------+-----------+---------+--------------+---------+
+ *
+ *  It's well known, that improved priority queue structures translate into better
+ *  graph-transversal algorithms. For example, Dijkstra's algorithm can be sped up
+ *  by using a Fibonacci heap for arbitrary weights. For integer weight bounded
+ *  by L, Schrijver reported following time complexities in 2004:
+ *
+ *  +------------+-------------------------------------+----------------------------+--------------------------+
+ *  | Weights    | Algorithm                           | Time complexity            | Author                   |
+ *  +------------+-------------------------------------+----------------------------+--------------------------+
+ *  | R          |                                     | O(V^2 EL)                  | Ford 1956                |
+ *  | R          | Bellman–Ford algorithm              | O(VE)                      | Shimbel 1955, Bellman    |
+ *  |            |                                     |                            | 1958, Moore 1959         |
+ *  | R          |                                     | O(V^2 log V)               | Dantzig 1960             |
+ *  | R          | Dijkstra's with list                | O(V^2)                     | Leyzorek et al. 1957,    |
+ *  |            |                                     |                            | Dijkstra 1959...         |
+ *  | R          | Dijkstra's with binary heap         | O((E + V) log V)           | Johnson 1977             |
+ *  | R          | Dijkstra's with Fibonacci heap      | O(E + V log V)             | Fredman & Tarjan 1984,   |
+ *  |            |                                     |                            | Fredman & Tarjan 1987    |
+ *  | R          | Quantum Dijkstra                    | O(√VE log^2 V)             | Dürr et al. 2006         |
+ *  | R          | Dial's algorithm (Dijkstra's using  | O(E + LV)                  | Dial 1969                |
+ *  |            | a bucket queue with L buckets)      |                            |                          |
+ *  | N          |                                     | O(E log log L)             | Johnson 1981, Karlsson & |
+ *  |            |                                     |                            | Poblete 1983             |
+ *  | N          | Gabow's algorithm                   | O(E log_E/V L)             | Gabow 1983, Gabow 1985   |
+ *  | N          |                                     | O(E + V √log L)            | Ahuja et al. 1990        |
+ *  | N          | Thorup                              | O(E + V log log V)         | Thorup 2004              |
+ *  +------------+-------------------------------------+----------------------------+--------------------------+
+ *
+ *  Possible improvements:
+ *  - Randomized meldable heaps: https://en.wikipedia.org/wiki/Randomized_meldable_heap
+ *  - D-ary heaps: https://en.wikipedia.org/wiki/D-ary_heap
+ *  - B-heap: https://en.wikipedia.org/wiki/B-heap
  */
 template <typename element_at,                                //
           typename comparator_at = std::less<void>,           // <void> is needed before C++14.
@@ -559,13 +703,25 @@ class max_heap_gt {
     inline bool empty() const noexcept { return !size_; }
     inline std::size_t size() const noexcept { return size_; }
     inline std::size_t capacity() const noexcept { return capacity_; }
+    inline element_t* data() noexcept { return elements_; }
+    inline element_t const* data() const noexcept { return elements_; }
+    inline void clear() noexcept { size_ = 0; }
+    inline void shrink(std::size_t n) noexcept { size_ = (std::min<std::size_t>)(n, size_); }
 
     /// @brief  Selects the largest element in the heap.
     /// @return Reference to the stored element.
     inline element_t const& top() const noexcept { return elements_[0]; }
-    inline void clear() noexcept { size_ = 0; }
 
-    bool reserve(std::size_t new_capacity) noexcept {
+    /// @brief Invalidates the "max-heap" property, transforming into ascending range.
+    inline void sort_ascending() noexcept { std::sort_heap(elements_, elements_ + size_, &less); }
+
+    /**
+     *  @brief Ensures the heap has enough capacity for the specified number of elements.
+     *  @param new_capacity The desired minimum capacity.
+     *  @return True if the capacity was successfully increased, false otherwise.
+     */
+    usearch_profiled_m bool reserve(std::size_t new_capacity) noexcept {
+        usearch_profile_name_m(max_heap_reserve);
         if (new_capacity < capacity_)
             return true;
 
@@ -585,6 +741,11 @@ class max_heap_gt {
         return new_elements;
     }
 
+    /**
+     *  @brief Inserts an element into the heap.
+     *  @param element The element to be inserted.
+     *  @return True if the element was successfully inserted, false otherwise.
+     */
     bool insert(element_t&& element) noexcept {
         if (!reserve(size_ + 1))
             return false;
@@ -593,13 +754,33 @@ class max_heap_gt {
         return true;
     }
 
-    inline void insert_reserved(element_t&& element) noexcept {
+    /**
+     *  @brief Inserts an element into the heap without reserving additional space.
+     *  @param element The element to be inserted.
+     */
+    usearch_profiled_m void insert_reserved(element_t&& element) noexcept {
+        usearch_profile_name_m(max_heap_insert_reserved);
         new (&elements_[size_]) element_t(element);
         size_++;
         shift_up(size_ - 1);
     }
 
-    inline element_t pop() noexcept {
+    /**
+     *  @brief Inserts multiple elements into the heap.
+     *  @param elements Pointer to the elements to be inserted.
+     *  @return True if the elements were successfully inserted, false otherwise.
+     */
+    inline bool insert_many(element_t const* elements) noexcept {
+        // Wikipedia describes a procedure, due to Floyd, which constructs a heap from an array in linear time.
+        // It also mentions a procedure for merging two heaps, of sizes 𝑛 and 𝑘, in time 𝑂(𝑘+log𝑘log𝑛).
+        // Altogether, we can add 𝑘 elements to a heap of length 𝑛 in time 𝑂(𝑘+log𝑘log𝑛): first build a heap containing
+        // 𝑘 elements to be inserted (takes 𝑂(𝑘) time), then merge that with the heap of size 𝑛 (takes 𝑂(𝑘+log𝑘log𝑛)
+        // time). Compare this to repeated insertion, which would run in time 𝑂(𝑘log𝑛).
+        return false;
+    }
+
+    usearch_profiled_m element_t pop() noexcept {
+        usearch_profile_name_m(max_heap_pop);
         element_t result = top();
         std::swap(elements_[0], elements_[size_ - 1]);
         size_--;
@@ -608,24 +789,29 @@ class max_heap_gt {
         return result;
     }
 
-    /** @brief Invalidates the "max-heap" property, transforming into ascending range. */
-    inline void sort_ascending() noexcept { std::sort_heap(elements_, elements_ + size_, &less); }
-    inline void shrink(std::size_t n) noexcept { size_ = (std::min<std::size_t>)(n, size_); }
-
-    inline element_t* data() noexcept { return elements_; }
-    inline element_t const* data() const noexcept { return elements_; }
-
   private:
-    inline std::size_t parent_idx(std::size_t i) const noexcept { return (i - 1u) / 2u; }
-    inline std::size_t left_child_idx(std::size_t i) const noexcept { return (i * 2u) + 1u; }
-    inline std::size_t right_child_idx(std::size_t i) const noexcept { return (i * 2u) + 2u; }
+    static std::size_t parent_idx(std::size_t i) noexcept { return (i - 1u) / 2u; }
+    static std::size_t left_child_idx(std::size_t i) noexcept { return (i * 2u) + 1u; }
+    static std::size_t right_child_idx(std::size_t i) noexcept { return (i * 2u) + 2u; }
     static bool less(element_t const& a, element_t const& b) noexcept { return comparator_t{}(a, b); }
 
+    /**
+     *  @brief Shifts an element up to maintain the heap property.
+     *         This operation is called when a new element is @b added at the end of the heap.
+     *         The element is moved up until the heap property is restored.
+     *  @param i Index of the element to be shifted up.
+     */
     void shift_up(std::size_t i) noexcept {
         for (; i && less(elements_[parent_idx(i)], elements_[i]); i = parent_idx(i))
             std::swap(elements_[parent_idx(i)], elements_[i]);
     }
 
+    /**
+     *  @brief Shifts an element down to maintain the heap property.
+     *         This operation is called when the root element is @b removed and the last element is moved to the root.
+     *         The element is moved down until the heap property is restored.
+     *  @param i Index of the element to be shifted down.
+     */
     void shift_down(std::size_t i) noexcept {
         std::size_t max_idx = i;
 
@@ -748,6 +934,18 @@ class sorted_buffer_gt {
         return true;
     }
 
+    inline bool insert_sorted(element_t const* elements, std::size_t elements_count, std::size_t limit) noexcept {
+        if (!size_) {
+        }
+        // If we are inserting elements, we only perform full-scale binary search once,
+        // and then only compute successive insertion offsets based only on the tail.
+        std::size_t slot = std::lower_bound(elements_, elements_ + size_, elements[0], &less) - elements_;
+        if (slot == limit)
+            return false;
+        std::size_t to_move = size_ - slot - (size_ == limit);
+        std::size_t next_slot = std::lower_bound(elements_ + slot, elements_ + size_, elements[1], &less) - elements_;
+    }
+
     inline element_t pop() noexcept {
         size_--;
         element_t result = elements_[size_];
@@ -770,9 +968,7 @@ class sorted_buffer_gt {
 #endif
 
 /**
- *  @brief Five-byte integer type to address node clouds with over 4B entries.
- *
- * @note Avoid usage in 32bit environment
+ *  @brief  Five-byte integer type to address node clouds with over 4B entries.
  */
 class usearch_pack_m uint40_t {
     unsigned char octets[5];
@@ -784,7 +980,10 @@ class usearch_pack_m uint40_t {
 
   public:
     inline uint40_t() noexcept { broadcast(0); }
-    inline uint40_t(std::uint32_t n) noexcept { std::memcpy(&octets[1], &n, 4); }
+    inline uint40_t(std::uint32_t n) noexcept {
+        std::memcpy(&octets, &n, 4);
+        octets[4] = 0;
+    }
 
 #ifdef USEARCH_64BIT_ENV
     inline uint40_t(std::uint64_t n) noexcept { std::memcpy(octets, &n, 5); }
@@ -801,22 +1000,38 @@ class usearch_pack_m uint40_t {
         std::memcpy(octets, &n, 5);
 #else
         std::memcpy(octets, &n, 4);
-#endif
+        octets[4] = 0;
+#endif // USEARCH_64BIT_ENV
     }
-#endif
+#endif // USEARCH_DEFINED_CLANG && USEARCH_DEFINED_APPLE
 
     inline operator std::size_t() const noexcept {
         std::size_t result = 0;
 #ifdef USEARCH_64BIT_ENV
         std::memcpy(&result, octets, 5);
 #else
-        std::memcpy(&result, octets + 1, 4);
+        std::memcpy(&result, octets, 4);
 #endif
         return result;
     }
 
     inline static uint40_t max() noexcept { return uint40_t{}.broadcast(0xFF); }
     inline static uint40_t min() noexcept { return uint40_t{}.broadcast(0); }
+
+    inline bool operator==(uint40_t const& other) const noexcept { return std::memcmp(octets, other.octets, 5) == 0; }
+    inline bool operator!=(uint40_t const& other) const noexcept { return !(*this == other); }
+    inline bool operator>(uint40_t const& other) const noexcept { return other < *this; }
+    inline bool operator<=(uint40_t const& other) const noexcept { return !(*this > other); }
+    inline bool operator>=(uint40_t const& other) const noexcept { return !(*this < other); }
+    inline bool operator<(uint40_t const& other) const noexcept {
+        for (int i = 0; i < 5; ++i) {
+            if (octets[4 - i] < other.octets[4 - i])
+                return true;
+            if (octets[4 - i] > other.octets[4 - i])
+                return false;
+        }
+        return false;
+    }
 };
 
 #if defined(USEARCH_DEFINED_WINDOWS)
@@ -825,12 +1040,33 @@ class usearch_pack_m uint40_t {
 
 static_assert(sizeof(uint40_t) == 5, "uint40_t must be exactly 5 bytes");
 
-// clang-format off
-template <typename key_at, typename std::enable_if<std::is_integral<key_at>::value>::type* = nullptr> key_at default_free_value() { return std::numeric_limits<key_at>::max(); }
-template <typename key_at, typename std::enable_if<std::is_same<key_at, uint40_t>::value>::type* = nullptr> uint40_t default_free_value() { return uint40_t::max(); }
-template <typename key_at, typename std::enable_if<!std::is_integral<key_at>::value && !std::is_same<key_at, uint40_t>::value>::type* = nullptr> key_at default_free_value() { return key_at(); }
-// clang-format on
+/**
+ *  @brief  Reflection-helper to get the default "unused" value for a given type.
+ *          Needed to initialize hash-sets and bit-sets.
+ */
+template <typename element_at> struct default_free_value_gt {
+    template <typename sfinae_element_at = element_at,
+              typename std::enable_if<std::is_integral<sfinae_element_at>::value>::type* = nullptr>
+    static sfinae_element_at value() noexcept {
+        return std::numeric_limits<element_at>::max();
+    }
+    template <typename sfinae_element_at = element_at,
+              typename std::enable_if<!std::is_integral<sfinae_element_at>::value>::type* = nullptr>
+    static sfinae_element_at value() noexcept {
+        return element_at();
+    }
+};
+
+template <> struct default_free_value_gt<uint40_t> {
+    static uint40_t value() noexcept { return uint40_t::max(); }
+};
 
+template <typename element_at> element_at default_free_value() { return default_free_value_gt<element_at>::value(); }
+
+/**
+ *  @brief  Adapter to allow definining arbitrary hash functions for keys and slots.
+ *          It's added, as overloading `std::hash` is not recommended by the standard.
+ */
 template <typename element_at> struct hash_gt {
     std::size_t operator()(element_at const& element) const noexcept { return std::hash<element_at>{}(element); }
 };
@@ -841,6 +1077,7 @@ template <> struct hash_gt<uint40_t> {
 
 /**
  *  @brief  Minimalistic hash-set implementation to track visited nodes during graph traversal.
+ *          In our primary usecase, its a sparse alternative to a bit-set.
  *
  *  It doesn't support deletion of separate objects, but supports `clear`-ing all at once.
  *  It expects `reserve` to be called ahead of all insertions, so no resizes are needed.
@@ -908,6 +1145,10 @@ class growing_hash_set_gt {
     growing_hash_set_gt(growing_hash_set_gt const&) = delete;
     growing_hash_set_gt& operator=(growing_hash_set_gt const&) = delete;
 
+    /**
+     *  @brief  Checks if the element is already in the hash-set.
+     *  @return `true` if the element is already in the hash-set.
+     */
     inline bool test(element_t const& elem) const noexcept {
         std::size_t index = hasher_(elem) & (capacity_ - 1);
         while (slots_[index] != default_free_value<element_t>()) {
@@ -920,7 +1161,7 @@ class growing_hash_set_gt {
     }
 
     /**
-     *
+     *  @brief  Inserts an element into the hash-set.
      *  @return Similar to `bitset_gt`, returns the previous value.
      */
     inline bool set(element_t const& elem) noexcept {
@@ -937,6 +1178,10 @@ class growing_hash_set_gt {
         return false;
     }
 
+    /**
+     *  @brief  Extends the capacity of the hash-set.
+     *  @return `true` if enough capacity is available, `false` if memory allocation failed.
+     */
     bool reserve(std::size_t new_capacity) noexcept {
         new_capacity = (new_capacity * 5u) / 3u;
         if (new_capacity <= capacity_)
@@ -1019,7 +1264,7 @@ class ring_gt {
     size_t size() const noexcept {
         if (empty_)
             return 0;
-        else if (head_ >= tail_)
+        else if (head_ > tail_)
             return head_ - tail_;
         else
             return capacity_ - (tail_ - head_);
@@ -1064,7 +1309,9 @@ class ring_gt {
         return true;
     }
 
-    void push(element_t const& value) noexcept {
+    void push(element_t const& value) usearch_noexcept_m {
+        usearch_assert_m(capacity() > 0, "Ring buffer is not initialized");
+        usearch_assert_m(size() < capacity(), "Ring buffer is full");
         elements_[head_] = value;
         head_ = (head_ + 1) % capacity_;
         empty_ = false;
@@ -1072,7 +1319,7 @@ class ring_gt {
 
     bool try_push(element_t const& value) noexcept {
         if (head_ == tail_ && !empty_)
-            return false; // elements_ is full
+            return false; // `elements_` is full
 
         return push(value);
         return true;
@@ -1125,20 +1372,49 @@ struct index_config_t {
     std::size_t connectivity_base = default_connectivity() * 2;
 
     inline index_config_t() = default;
-    inline index_config_t(std::size_t c) noexcept
-        : connectivity(c ? c : default_connectivity()), connectivity_base(c ? c * 2 : default_connectivity() * 2) {}
-    inline index_config_t(std::size_t c, std::size_t cb) noexcept
-        : connectivity(c), connectivity_base((std::max)(c, cb)) {}
+    inline index_config_t(std::size_t c, std::size_t cb = 0) noexcept : connectivity(c), connectivity_base(cb) {}
+
+    /**
+     *  @brief  Validates the configuration settings, updating them in-place.
+     *  @return Error message, if any.
+     */
+    inline error_t validate() noexcept {
+        if (connectivity == 0)
+            connectivity = default_connectivity();
+        if (connectivity_base == 0)
+            connectivity_base = connectivity * 2;
+        if (connectivity < 2)
+            return "Connectivity must be at least 2, otherwise the index degenerates into ropes";
+        if (connectivity_base < connectivity)
+            return "Base layer should be at least as connected as the rest of the graph";
+        return {};
+    }
+
+    /**
+     *  @brief  Immutable function to check if the configuration is valid.
+     *  @return `true` if the configuration is valid.
+     */
+    inline bool is_valid() const noexcept { return connectivity >= 2 && connectivity_base >= connectivity; }
 };
 
+/**
+ *  @brief  Growth settings for the index container.
+ *          Includes the upper bound for `::members` capacity,
+ *          and the number of read/write threads expected to work with the index.
+ */
 struct index_limits_t {
+    /// @brief Maximum number of entries in the index.
     std::size_t members = 0;
+    /// @brief Max number of threads simultaneously updating entries.
     std::size_t threads_add = std::thread::hardware_concurrency();
+    /// @brief Max number of threads simultaneously searching entries.
     std::size_t threads_search = std::thread::hardware_concurrency();
 
     inline index_limits_t(std::size_t n, std::size_t t) noexcept : members(n), threads_add(t), threads_search(t) {}
     inline index_limits_t(std::size_t n = 0) noexcept : index_limits_t(n, std::thread::hardware_concurrency()) {}
+    /// @brief Returns the upper limit for the number of threads.
     inline std::size_t threads() const noexcept { return (std::max)(threads_add, threads_search); }
+    /// @brief Returns the concurrency-level of the index - the minimum of thread counts.
     inline std::size_t concurrency() const noexcept { return (std::min)(threads_add, threads_search); }
 };
 
@@ -1416,8 +1692,10 @@ class input_file_t {
     serialization_result_t read(void* begin, std::size_t length) noexcept {
         serialization_result_t result;
         std::size_t read = std::fread(begin, length, 1, file_);
-        if (length && !read)
-            return result.failed(std::feof(file_) ? "End of file reached!" : std::strerror(errno));
+        if (length && !read) {
+            bool reached_eof = std::feof(file_);
+            return result.failed(reached_eof ? "End of file reached!" : std::strerror(errno));
+        }
         return result;
     }
     void close() noexcept {
@@ -1575,6 +1853,14 @@ class memory_mapped_file_t {
     }
 };
 
+/**
+ *  @brief  Metadata header for the serialized index.
+ *
+ *  This structure is very minimalistic by design. It contains no information
+ *  about the capacity of the index, so you'll have to `reserve` after loading.
+ *  It also contains no info on the metric or key types, so you'll have to store
+ *  that information elsewhere, like we do in `index_dense_head_t`.
+ */
 struct index_serialized_header_t {
     std::uint64_t size = 0;
     std::uint64_t connectivity = 0;
@@ -1620,8 +1906,8 @@ template <typename key_at> inline key_at get_key(member_ref_gt<key_at> const& m)
  *          be seen as a network of keys, accelerating approximate @b Value~>Key visited_members.
  *
  *  Unlike most implementations, this one is generic anc can be used for any search,
- *  not just within equi-dimensional vectors. Examples range from texts to similar Chess
- *  positions.
+ *  not just within equi-dimensional vectors. Examples range from Texts to similar Chess
+ *  positions, Geo-Spatial Search, and even Graphs.
  *
  *  @tparam key_at
  *      The type of primary objects stored in the index.
@@ -1707,6 +1993,7 @@ class index_gt {
     using dynamic_allocator_t = dynamic_allocator_at;
     using tape_allocator_t = tape_allocator_at;
     static_assert(sizeof(vector_key_t) >= sizeof(compressed_slot_t), "Having tiny keys doesn't make sense.");
+    static_assert(std::is_signed<distance_t>::value, "Distance must be a signed type, as we use the unary minus.");
 
     using member_cref_t = member_cref_gt<vector_key_t>;
     using member_ref_t = member_ref_gt<vector_key_t>;
@@ -1717,10 +2004,17 @@ class index_gt {
 
         friend class index_gt;
         member_iterator_gt() noexcept {}
-        member_iterator_gt(index_t* index, std::size_t slot) noexcept : index_(index), slot_(slot) {}
+        member_iterator_gt(index_t* index, compressed_slot_t slot) noexcept : index_(index), slot_(slot) {}
+
+        template <int> ref_t call_key(std::true_type) const noexcept {
+            return ref_t{index_->node_at_(slot_).ckey(), slot_};
+        }
+        template <int> ref_t call_key(std::false_type) const noexcept {
+            return ref_t{index_->node_at_(slot_).key(), slot_};
+        }
 
         index_t* index_{};
-        std::size_t slot_{};
+        compressed_slot_t slot_{};
 
       public:
         using iterator_category = std::random_access_iterator_tag;
@@ -1729,22 +2023,21 @@ class index_gt {
         using pointer = void;
         using reference = ref_t;
 
-        reference operator*() const noexcept { return {index_->node_at_(slot_).key(), slot_}; }
-        vector_key_t key() const noexcept { return index_->node_at_(slot_).key(); }
+        reference operator*() const noexcept { return call_key<0>(std::is_const<index_t>()); }
+        vector_key_t key() const noexcept { return index_->node_at_(slot_).ckey(); }
 
-        friend inline std::size_t get_slot(member_iterator_gt const& it) noexcept { return it.slot_; }
+        friend inline compressed_slot_t get_slot(member_iterator_gt const& it) noexcept { return it.slot_; }
         friend inline vector_key_t get_key(member_iterator_gt const& it) noexcept { return it.key(); }
 
-        member_iterator_gt operator++(int) noexcept { return member_iterator_gt(index_, slot_ + 1); }
-        member_iterator_gt operator--(int) noexcept { return member_iterator_gt(index_, slot_ - 1); }
-        member_iterator_gt operator+(difference_type d) noexcept { return member_iterator_gt(index_, slot_ + d); }
-        member_iterator_gt operator-(difference_type d) noexcept { return member_iterator_gt(index_, slot_ - d); }
-
         // clang-format off
-        member_iterator_gt& operator++() noexcept { slot_ += 1; return *this; }
-        member_iterator_gt& operator--() noexcept { slot_ -= 1; return *this; }
-        member_iterator_gt& operator+=(difference_type d) noexcept { slot_ += d; return *this; }
-        member_iterator_gt& operator-=(difference_type d) noexcept { slot_ -= d; return *this; }
+        member_iterator_gt operator++(int) noexcept { return member_iterator_gt(index_, static_cast<compressed_slot_t>(static_cast<std::size_t>(slot_) + 1)); }
+        member_iterator_gt operator--(int) noexcept { return member_iterator_gt(index_, static_cast<compressed_slot_t>(static_cast<std::size_t>(slot_) - 1)); }
+        member_iterator_gt operator+(difference_type d) noexcept { return member_iterator_gt(index_, static_cast<compressed_slot_t>(static_cast<std::size_t>(slot_) + d)); }
+        member_iterator_gt operator-(difference_type d) noexcept { return member_iterator_gt(index_, static_cast<compressed_slot_t>(static_cast<std::size_t>(slot_) - d)); }
+        member_iterator_gt& operator++() noexcept { slot_ = static_cast<compressed_slot_t>(static_cast<std::size_t>(slot_) + 1); return *this; }
+        member_iterator_gt& operator--() noexcept { slot_ = static_cast<compressed_slot_t>(static_cast<std::size_t>(slot_) - 1); return *this; }
+        member_iterator_gt& operator+=(difference_type d) noexcept { slot_ = static_cast<compressed_slot_t>(static_cast<std::size_t>(slot_) + d); return *this; }
+        member_iterator_gt& operator-=(difference_type d) noexcept { slot_ = static_cast<compressed_slot_t>(static_cast<std::size_t>(slot_) - d); return *this; }
         bool operator==(member_iterator_gt const& other) const noexcept { return index_ == other.index_ && slot_ == other.slot_; }
         bool operator!=(member_iterator_gt const& other) const noexcept { return index_ != other.index_ || slot_ != other.slot_; }
         // clang-format on
@@ -1835,8 +2128,10 @@ class index_gt {
         node_t& operator=(node_t const&) = default;
 
         misaligned_ref_gt<vector_key_t const> ckey() const noexcept { return {tape_}; }
-        misaligned_ref_gt<vector_key_t> key() const noexcept { return {tape_}; }
-        misaligned_ref_gt<level_t> level() const noexcept { return {tape_ + sizeof(vector_key_t)}; }
+        misaligned_ref_gt<vector_key_t const> ckey() noexcept { return {tape_}; }
+        misaligned_ref_gt<vector_key_t const> key() const noexcept { return {tape_}; }
+        misaligned_ref_gt<vector_key_t> key() noexcept { return {tape_}; }
+        misaligned_ref_gt<level_t> level() noexcept { return {tape_ + sizeof(vector_key_t)}; }
 
         void key(vector_key_t v) noexcept { return misaligned_store<vector_key_t>(tape_, v); }
         void level(level_t v) noexcept { return misaligned_store<level_t>(tape_ + sizeof(vector_key_t), v); }
@@ -1854,16 +2149,22 @@ class index_gt {
     class neighbors_ref_t {
         byte_t* tape_;
 
-        static constexpr std::size_t shift(std::size_t i = 0) {
+        static constexpr std::size_t shift(std::size_t i = 0) noexcept {
             return sizeof(neighbors_count_t) + sizeof(compressed_slot_t) * i;
         }
 
       public:
+        using iterator = misaligned_ptr_gt<compressed_slot_t>;
+        using const_iterator = misaligned_ptr_gt<compressed_slot_t const>;
+        using value_type = compressed_slot_t;
+
         neighbors_ref_t(byte_t* tape) noexcept : tape_(tape) {}
         misaligned_ptr_gt<compressed_slot_t> begin() noexcept { return tape_ + shift(); }
         misaligned_ptr_gt<compressed_slot_t> end() noexcept { return begin() + size(); }
         misaligned_ptr_gt<compressed_slot_t const> begin() const noexcept { return tape_ + shift(); }
         misaligned_ptr_gt<compressed_slot_t const> end() const noexcept { return begin() + size(); }
+        misaligned_ptr_gt<compressed_slot_t const> cbegin() noexcept { return tape_ + shift(); }
+        misaligned_ptr_gt<compressed_slot_t const> cend() noexcept { return cbegin() + size(); }
         compressed_slot_t operator[](std::size_t i) const noexcept {
             return misaligned_load<compressed_slot_t>(tape_ + shift(i));
         }
@@ -1871,7 +2172,7 @@ class index_gt {
         void clear() noexcept {
             neighbors_count_t n = misaligned_load<neighbors_count_t>(tape_);
             std::memset(tape_, 0, shift(n));
-            // misaligned_store<neighbors_count_t>(tape_, 0);
+            misaligned_store<neighbors_count_t>(tape_, 0);
         }
         void push_back(compressed_slot_t slot) noexcept {
             neighbors_count_t n = misaligned_load<neighbors_count_t>(tape_);
@@ -1891,29 +2192,55 @@ class index_gt {
         visits_hash_set_t visits{};
         std::default_random_engine level_generator{};
         std::size_t iteration_cycles{};
-        std::size_t computed_distances_count{};
+        std::size_t computed_distances{};
+        std::size_t computed_distances_in_refines{};
+        std::size_t computed_distances_in_reverse_refines{};
 
+        /// @brief Heterogeneous distance calculation.
         template <typename value_at, typename metric_at, typename entry_at> //
         inline distance_t measure(value_at const& first, entry_at const& second, metric_at&& metric) noexcept {
             static_assert( //
                 std::is_same<entry_at, member_cref_t>::value || std::is_same<entry_at, member_citerator_t>::value,
                 "Unexpected type");
 
-            computed_distances_count++;
+            computed_distances++;
             return metric(first, second);
         }
 
+        /// @brief Homogeneous distance calculation.
         template <typename metric_at, typename entry_at> //
         inline distance_t measure(entry_at const& first, entry_at const& second, metric_at&& metric) noexcept {
             static_assert( //
                 std::is_same<entry_at, member_cref_t>::value || std::is_same<entry_at, member_citerator_t>::value,
                 "Unexpected type");
 
-            computed_distances_count++;
+            computed_distances++;
             return metric(first, second);
         }
+
+        /// @brief Heterogeneous batch distance calculation.
+        template <typename value_at, typename metric_at, typename entries_at, typename candidate_allowed_at,
+                  typename transform_at,
+                  typename callback_at> //
+        inline void measure_batch(value_at const& first, entries_at const& second_entries, metric_at&& metric,
+                                  candidate_allowed_at&& candidate_allowed, transform_at&& transform,
+                                  callback_at&& callback) noexcept {
+
+            using entry_t = typename std::remove_reference<decltype(second_entries[0])>::type;
+            metric.batch(first, second_entries, candidate_allowed, transform,
+                         [&](entry_t const& entry, distance_t distance) {
+                             callback(entry, distance);
+                             computed_distances++;
+                         });
+        }
     };
 
+    /// @brief  Number of "slots" available for `node_t` objects. Equals to @b `limits_.members`.
+    mutable std::atomic<std::size_t> nodes_capacity_{};
+
+    /// @brief  Number of "slots" already storing non-null nodes.
+    mutable std::atomic<std::size_t> nodes_count_{};
+
     index_config_t config_{};
     index_limits_t limits_{};
 
@@ -1923,12 +2250,6 @@ class index_gt {
     precomputed_constants_t pre_{};
     memory_mapped_file_t viewed_file_{};
 
-    /// @brief  Number of "slots" available for `node_t` objects. Equals to @b `limits_.members`.
-    usearch_align_m mutable std::atomic<std::size_t> nodes_capacity_{};
-
-    /// @brief  Number of "slots" already storing non-null nodes.
-    usearch_align_m mutable std::atomic<std::size_t> nodes_count_{};
-
     /// @brief  Controls access to `max_level_` and `entry_slot_`.
     ///         If any thread is updating those values, no other threads can `add()` or `search()`.
     std::mutex global_mutex_{};
@@ -1941,7 +2262,7 @@ class index_gt {
 
     using nodes_allocator_t = typename dynamic_allocator_traits_t::template rebind_alloc<node_t>;
 
-    /// @brief  C-style array of `node_t` smart-pointers.
+    /// @brief  C-style array of `node_t` smart-pointers. Use `compressed_slot_t` for indexing.
     buffer_gt<node_t, nodes_allocator_t> nodes_{};
 
     /// @brief  Mutex, that limits concurrent access to `nodes_`.
@@ -1960,17 +2281,33 @@ class index_gt {
     index_config_t const& config() const noexcept { return config_; }
     index_limits_t const& limits() const noexcept { return limits_; }
     bool is_immutable() const noexcept { return bool(viewed_file_); }
+    explicit operator bool() const noexcept { return config_.is_valid(); }
 
     /**
+     *  @brief Default index constructor, suitable only for stateless allocators.
+     *  @warning Consider `index_gt::make` instead, or explicitly convert to `bool` to check if the index is valid.
      *  @section Exceptions
-     *      Doesn't throw, unless the ::metric's and ::allocators's throw on copy-construction.
+     *      Doesn't throw, unless the ::dynamic_allocator's and ::tape_allocator's throw on move-construction.
      */
     explicit index_gt( //
-        index_config_t config = {}, dynamic_allocator_t dynamic_allocator = {},
-        tape_allocator_t tape_allocator = {}) noexcept
-        : config_(config), limits_(0, 0), dynamic_allocator_(std::move(dynamic_allocator)),
-          tape_allocator_(std::move(tape_allocator)), pre_(precompute_(config)), nodes_count_(0u), max_level_(-1),
-          entry_slot_(0u), nodes_(), nodes_mutexes_(), contexts_() {}
+        dynamic_allocator_t dynamic_allocator = {}, tape_allocator_t tape_allocator = {}) noexcept(false)
+        : nodes_capacity_(0u), nodes_count_(0u), config_(), limits_(0, 0),
+          dynamic_allocator_(std::move(dynamic_allocator)), tape_allocator_(std::move(tape_allocator)),
+          pre_(precompute_({})), max_level_(-1), entry_slot_(0u), nodes_(), nodes_mutexes_(), contexts_() {}
+
+    /**
+     *  @brief Default index constructor, suitable only for stateless allocators.
+     *  @warning Consider `index_gt::make` instead, or explicitly convert to `bool` to check if the index is valid.
+     *  @section Exceptions
+     *      Doesn't throw, unless the ::dynamic_allocator's and ::tape_allocator's throw on move-construction.
+     */
+    explicit index_gt(index_config_t config, dynamic_allocator_t dynamic_allocator = {},
+                      tape_allocator_t tape_allocator = {}) noexcept(false)
+        : index_gt(dynamic_allocator, tape_allocator) {
+        config.validate();
+        config_ = config;
+        pre_ = precompute_(config);
+    }
 
     /**
      *  @brief  Clones the structure with the same hyper-parameters, but without contents.
@@ -1986,17 +2323,56 @@ class index_gt {
         return *this;
     }
 
-    struct copy_result_t {
-        error_t error;
+    struct state_result_t {
         index_gt index;
+        error_t error;
 
         explicit operator bool() const noexcept { return !error; }
-        copy_result_t failed(error_t message) noexcept {
-            error = std::move(message);
-            return std::move(*this);
+        state_result_t failed(error_t message) noexcept { return {std::move(index), std::move(message)}; }
+        operator index_gt&&() && {
+            if (error)
+                __usearch_raise_runtime_error(error.what());
+            return std::move(index);
         }
     };
+    using copy_result_t = state_result_t;
+
+    /**
+     *  @brief  The recommended way to initialize the index, as unlike the constructor,
+     *          it can fail with an error message, without raising an exception.
+     *
+     *  @param[in] config The configuration specs of the index.
+     *  @param[in] dynamic_allocator The allocator for temporary buffers and thread contexts, like priority queues.
+     *  @param[in] tape_allocator The allocator for the primary allocations of nodes and vectors.
+     */
+    static state_result_t make( //
+        index_config_t config = {}, dynamic_allocator_t dynamic_allocator = {},
+        tape_allocator_t tape_allocator = {}) noexcept {
+
+        state_result_t result;
+        result.error = config.validate();
+        if (result.error)
+            return result;
+
+        index_gt index;
+        index.config_ = std::move(config);
+        index.dynamic_allocator_ = std::move(dynamic_allocator);
+        index.tape_allocator_ = std::move(tape_allocator);
+        index.pre_ = precompute_(index.config_);
+        index.nodes_count_ = 0u;
+        index.max_level_ = -1;
+        index.entry_slot_ = 0u;
+
+        result.index = std::move(index);
+        return result;
+    }
 
+    /**
+     *  @brief  The recommended way to copy the index, as unlike the copy-constructor,
+     *          it can fail with an error message, without raising an exception.
+     *
+     *  @param[in] config The configuration specs for the copy-operation. Currently unused.
+     */
     copy_result_t copy(index_copy_config_t config = {}) const noexcept {
         copy_result_t result;
         index_gt& other = result.index;
@@ -2018,22 +2394,24 @@ class index_gt {
         return result;
     }
 
-    member_citerator_t cbegin() const noexcept { return {this, 0}; }
-    member_citerator_t cend() const noexcept { return {this, size()}; }
-    member_citerator_t begin() const noexcept { return {this, 0}; }
-    member_citerator_t end() const noexcept { return {this, size()}; }
-    member_iterator_t begin() noexcept { return {this, 0}; }
-    member_iterator_t end() noexcept { return {this, size()}; }
+    member_citerator_t cbegin() const noexcept { return {this, static_cast<compressed_slot_t>(0u)}; }
+    member_citerator_t cend() const noexcept { return {this, static_cast<compressed_slot_t>(size())}; }
+    member_citerator_t begin() const noexcept { return {this, static_cast<compressed_slot_t>(0u)}; }
+    member_citerator_t end() const noexcept { return {this, static_cast<compressed_slot_t>(size())}; }
+    member_iterator_t begin() noexcept { return {this, static_cast<compressed_slot_t>(0u)}; }
+    member_iterator_t end() noexcept { return {this, static_cast<compressed_slot_t>(size())}; }
 
-    member_ref_t at(std::size_t slot) noexcept { return {nodes_[slot].key(), slot}; }
-    member_cref_t at(std::size_t slot) const noexcept { return {nodes_[slot].ckey(), slot}; }
-    member_iterator_t iterator_at(std::size_t slot) noexcept { return {this, slot}; }
-    member_citerator_t citerator_at(std::size_t slot) const noexcept { return {this, slot}; }
+    member_ref_t at(compressed_slot_t slot) noexcept { return {nodes_[slot].key(), slot}; }
+    member_cref_t at(compressed_slot_t slot) const noexcept { return {nodes_[slot].ckey(), slot}; }
+    member_iterator_t iterator_at(compressed_slot_t slot) noexcept { return {this, slot}; }
+    member_citerator_t citerator_at(compressed_slot_t slot) const noexcept { return {this, slot}; }
 
     dynamic_allocator_t const& dynamic_allocator() const noexcept { return dynamic_allocator_; }
     tape_allocator_t const& tape_allocator() const noexcept { return tape_allocator_; }
 
+#if defined(USEARCH_USE_PRAGMA_REGION)
 #pragma region Adjusting Configuration
+#endif
 
     /**
      *  @brief Erases all the vectors from the index.
@@ -2101,13 +2479,20 @@ class index_gt {
      *  @brief  Increases the `capacity()` of the index to allow adding more vectors.
      *  @return `true` on success, `false` on memory allocation errors.
      */
-    bool reserve(index_limits_t limits) usearch_noexcept_m {
+    bool try_reserve(index_limits_t limits) usearch_noexcept_m {
 
         if (limits.threads_add <= limits_.threads_add          //
             && limits.threads_search <= limits_.threads_search //
             && limits.members <= limits_.members)
             return true;
 
+        // In some cases, we don't want to update the number of members,
+        // just want to make sure that future reserves use the new thread limits.
+        if (!limits.members && !size()) {
+            limits_ = limits;
+            return true;
+        }
+
         nodes_mutexes_t new_mutexes(limits.members);
         buffer_gt<node_t, nodes_allocator_t> new_nodes(limits.members);
         buffer_gt<context_t, contexts_allocator_t> new_contexts(limits.threads());
@@ -2126,16 +2511,27 @@ class index_gt {
         return true;
     }
 
+    /**
+     *  @brief Increases the `capacity()` of the index to allow adding more vectors.
+     *  @warning Unlike STL, won't throw exceptions on memory allocations, so check the return value.
+     *  @return `true` on success, `false` on memory allocation errors.
+     */
+    bool reserve(index_limits_t limits) usearch_noexcept_m { return try_reserve(limits); }
+
+#if defined(USEARCH_USE_PRAGMA_REGION)
 #pragma endregion
 
 #pragma region Construction and Search
+#endif
 
     struct add_result_t {
         error_t error{};
         std::size_t new_size{};
         std::size_t visited_members{};
         std::size_t computed_distances{};
-        std::size_t slot{};
+        std::size_t computed_distances_in_refines{};
+        std::size_t computed_distances_in_reverse_refines{};
+        compressed_slot_t slot{};
 
         explicit operator bool() const noexcept { return !error; }
         add_result_t failed(error_t message) noexcept {
@@ -2180,15 +2576,15 @@ class index_gt {
         top_candidates_t const* top_{};
 
         friend class index_gt;
-        inline search_result_t(index_gt const& index, top_candidates_t& top) noexcept
-            : nodes_(index.nodes_), top_(&top) {}
+        inline search_result_t(index_gt const& index, top_candidates_t const* top) noexcept
+            : nodes_(index.nodes_), top_(top) {}
 
       public:
-        /** @brief  Number of search results found. */
+        /**  @brief  Number of search results found. */
         std::size_t count{};
-        /** @brief  Number of graph nodes traversed. */
+        /**  @brief  Number of graph nodes traversed. */
         std::size_t visited_members{};
-        /** @brief  Number of times the distances were computed. */
+        /**  @brief  Number of times the distances were computed. */
         std::size_t computed_distances{};
         error_t error{};
 
@@ -2322,57 +2718,76 @@ class index_gt {
 
         // Determining how much memory to allocate for the node depends on the target level
         std::unique_lock<std::mutex> new_level_lock(global_mutex_);
-        level_t max_level_copy = max_level_;      // Copy under lock
-        std::size_t entry_idx_copy = entry_slot_; // Copy under lock
-        level_t target_level = choose_random_level_(context.level_generator);
+        level_t max_level_copy = max_level_;                                             // Copy under lock
+        compressed_slot_t entry_slot_copy = static_cast<compressed_slot_t>(entry_slot_); // Copy under lock
+        level_t new_target_level = choose_random_level_(context.level_generator);
 
         // Make sure we are not overflowing
         std::size_t capacity = nodes_capacity_.load();
-        std::size_t new_slot = nodes_count_.fetch_add(1);
-        if (new_slot >= capacity) {
+        std::size_t old_size = nodes_count_.fetch_add(1);
+        if (old_size >= capacity) {
             nodes_count_.fetch_sub(1);
             return result.failed("Reserve capacity ahead of insertions!");
         }
 
         // Allocate the neighbors
-        node_t node = node_make_(key, target_level);
-        if (!node) {
+        node_t new_node = node_make_(key, new_target_level);
+        if (!new_node) {
             nodes_count_.fetch_sub(1);
             return result.failed("Out of memory!");
         }
-        if (target_level <= max_level_copy)
+        if (new_target_level <= max_level_copy)
             new_level_lock.unlock();
 
-        nodes_[new_slot] = node;
-        result.new_size = new_slot + 1;
-        result.slot = new_slot;
-        callback(at(new_slot));
-        node_lock_t new_lock = node_lock_(new_slot);
+        nodes_[old_size] = new_node;
+        result.new_size = old_size + 1;
+        compressed_slot_t new_slot = result.slot = static_cast<compressed_slot_t>(old_size);
+        callback(at(result.slot));
 
         // Do nothing for the first element
-        if (!new_slot) {
-            entry_slot_ = new_slot;
-            max_level_ = target_level;
+        if (!old_size) {
+            entry_slot_ = result.slot;
+            max_level_ = new_target_level;
             return result;
         }
 
         // Pull stats
-        result.computed_distances = context.computed_distances_count;
+        result.computed_distances = context.computed_distances;
+        result.computed_distances_in_refines = context.computed_distances_in_refines;
+        result.computed_distances_in_reverse_refines = context.computed_distances_in_reverse_refines;
         result.visited_members = context.iteration_cycles;
 
-        connect_node_across_levels_(                                //
-            value, metric, prefetch,                                //
-            new_slot, entry_idx_copy, max_level_copy, target_level, //
-            config, context);
+        // Go down the level, tracking only the closest match
+        compressed_slot_t closest_slot = search_for_one_( //
+            value, metric, prefetch,                      //
+            entry_slot_copy, max_level_copy, new_target_level, context);
+
+        // From `new_target_level` down - perform proper extensive search
+        for (level_t level = (std::min)(new_target_level, max_level_copy); level >= 0; --level) {
+            // TODO: Handle out of memory conditions
+            search_to_insert_(value, metric, prefetch, closest_slot, level, config.expansion, context);
+            candidates_view_t closest_view;
+            {
+                node_lock_t new_lock = node_lock_(new_slot);
+                neighbors_(new_node, level).clear();
+                closest_view = form_links_to_closest_(metric, new_slot, level, context);
+                closest_slot = closest_view[0].slot;
+            }
+            form_reverse_links_(metric, new_slot, closest_view, value, level, context);
+        }
 
         // Normalize stats
-        result.computed_distances = context.computed_distances_count - result.computed_distances;
+        result.computed_distances = context.computed_distances - result.computed_distances;
+        result.computed_distances_in_refines =
+            context.computed_distances_in_refines - result.computed_distances_in_refines;
+        result.computed_distances_in_reverse_refines =
+            context.computed_distances_in_reverse_refines - result.computed_distances_in_reverse_refines;
         result.visited_members = context.iteration_cycles - result.visited_members;
 
         // Updating the entry point if needed
-        if (target_level > max_level_copy) {
+        if (new_target_level > max_level_copy) {
             entry_slot_ = new_slot;
-            max_level_ = target_level;
+            max_level_ = new_target_level;
         }
         return result;
     }
@@ -2380,6 +2795,10 @@ class index_gt {
     /**
      *  @brief  Update an existing entry. Thread-safe. Supports @b heterogeneous lookups.
      *
+     *  ! It's assumed that different threads aren't updating the same entry at the same time.
+     *  ! The state won't be corrupted, but no transactional guarantees are provided and the
+     *  ! resulting value & neighbors list may be inconsistent.
+     *
      *  @tparam metric_at
      *      A function responsible for computing the distance @b (dis-similarity) between two objects.
      *      It should be callable into distinctly different scenarios:
@@ -2417,7 +2836,7 @@ class index_gt {
 
         usearch_assert_m(!is_immutable(), "Can't add to an immutable index");
         add_result_t result;
-        std::size_t old_slot = iterator.slot_;
+        compressed_slot_t updated_slot = iterator.slot_;
 
         // Make sure we have enough local memory to perform this request
         context_t& context = contexts_[config.thread];
@@ -2435,30 +2854,60 @@ class index_gt {
         if (!next.reserve(config.expansion))
             return result.failed("Out of memory!");
 
-        node_lock_t new_lock = node_lock_(old_slot);
-        node_t node = node_at_(old_slot);
+        node_t updated_node = node_at_(updated_slot);
+        level_t updated_node_level = updated_node.level();
 
-        level_t node_level = node.level();
-        span_bytes_t node_bytes = node_bytes_(node);
-        std::memset(node_bytes.data(), 0, node_bytes.size());
-        node.level(node_level);
+        // Copy entry coordinates under locks
+        level_t max_level_copy;
+        compressed_slot_t entry_slot_copy;
+        {
+            std::unique_lock<std::mutex> new_level_lock(global_mutex_);
+            max_level_copy = max_level_;                                   // Copy under lock
+            entry_slot_copy = static_cast<compressed_slot_t>(entry_slot_); // Copy under lock
+        }
 
         // Pull stats
-        result.computed_distances = context.computed_distances_count;
+        result.computed_distances = context.computed_distances;
         result.visited_members = context.iteration_cycles;
 
-        connect_node_across_levels_(                       //
-            value, metric, prefetch,                       //
-            old_slot, entry_slot_, max_level_, node_level, //
-            config, context);
-        node.key(key);
+        // If we are updating the entry node itself, it won't contain any neighbors,
+        // so we should traverse a level down to find the closest match.
+        if (updated_node_level == max_level_copy)
+            updated_node_level--;
+
+        // Go down the level, tracking only the closest match;
+        // It may even be equal to the `updated_slot`
+        compressed_slot_t closest_slot = search_for_one_( //
+            value, metric, prefetch,                      //
+            entry_slot_copy, max_level_copy, updated_node_level, context);
+
+        // From `updated_node_level` down - perform proper extensive search
+        for (level_t level = (std::min)(updated_node_level, max_level_copy); level >= 0; --level) {
+            if (!search_to_update_(value, metric, prefetch, closest_slot, updated_slot, level, config.expansion,
+                                   context))
+                return result.failed("Out of memory!");
+
+            candidates_view_t closest_view;
+            {
+                node_lock_t updated_lock = node_lock_(updated_slot);
+                // TODO: Go through existing neighbors removing reverse links
+                // for (compressed_slot_t slot : neighbors_(updated_node, level))
+                //     remove_link_(slot, updated_slot, level);
+                neighbors_(updated_node, level).clear();
+                closest_view = form_links_to_closest_(metric, updated_slot, level, context);
+                if (closest_view.size())
+                    closest_slot = closest_view[0].slot;
+            }
+            form_reverse_links_(metric, updated_slot, closest_view, value, level, context);
+        }
+        updated_node.key(key);
 
         // Normalize stats
-        result.computed_distances = context.computed_distances_count - result.computed_distances;
+        result.computed_distances = context.computed_distances - result.computed_distances;
         result.visited_members = context.iteration_cycles - result.visited_members;
-        result.slot = old_slot;
+        result.slot = updated_slot;
 
-        callback(at(old_slot));
+        callback(at(updated_slot));
         return result;
     }
 
@@ -2493,14 +2942,18 @@ class index_gt {
         if (!config.expansion)
             config.expansion = default_expansion_search();
 
-        context_t& context = contexts_[config.thread];
-        top_candidates_t& top = context.top_candidates;
-        search_result_t result{*this, top};
-        if (!nodes_count_)
+        // Using references is cleaner, but would result in UBSan false positives
+        context_t* context_ptr = contexts_.data() + config.thread;
+        top_candidates_t* top_ptr = context_ptr ? &context_ptr->top_candidates : nullptr;
+        search_result_t result{*this, top_ptr};
+        if (!nodes_count_.load(std::memory_order_relaxed))
             return result;
 
+        usearch_assert_m(contexts_.size() > config.thread, "Thread index out of bounds");
+        context_t& context = *context_ptr;
+        top_candidates_t& top = *top_ptr;
         // Go down the level, tracking only the closest match
-        result.computed_distances = context.computed_distances_count;
+        result.computed_distances = context.computed_distances;
         result.visited_members = context.iteration_cycles;
 
         if (config.exact) {
@@ -2516,7 +2969,8 @@ class index_gt {
             if (!top.reserve(expansion))
                 return result.failed("Out of memory!");
 
-            std::size_t closest_slot = search_for_one_(query, metric, prefetch, entry_slot_, max_level_, 0, context);
+            compressed_slot_t closest_slot = search_for_one_(
+                query, metric, prefetch, static_cast<compressed_slot_t>(entry_slot_), max_level_, 0, context);
 
             // For bottom layer we need a more optimized procedure
             if (!search_to_find_in_base_(query, metric, predicate, prefetch, closest_slot, expansion, context))
@@ -2527,7 +2981,7 @@ class index_gt {
         top.shrink(wanted);
 
         // Normalize stats
-        result.computed_distances = context.computed_distances_count - result.computed_distances;
+        result.computed_distances = context.computed_distances - result.computed_distances;
         result.visited_members = context.iteration_cycles - result.visited_members;
         result.count = top.size();
         return result;
@@ -2562,7 +3016,7 @@ class index_gt {
             return result.failed("No clusters to identify");
 
         // Go down the level, tracking only the closest match
-        result.computed_distances = context.computed_distances_count;
+        result.computed_distances = context.computed_distances;
         result.visited_members = context.iteration_cycles;
 
         next_candidates_t& next = context.next_candidates;
@@ -2570,21 +3024,24 @@ class index_gt {
         if (!next.reserve(expansion))
             return result.failed("Out of memory!");
 
-        result.cluster.member = at(search_for_one_(query, metric, prefetch, entry_slot_, max_level_,
-                                                   static_cast<level_t>(level - 1), context));
+        result.cluster.member =
+            at(search_for_one_(query, metric, prefetch, static_cast<compressed_slot_t>(entry_slot_), max_level_,
+                               static_cast<level_t>(level <= 0 ? 0 : level - 1), context));
         result.cluster.distance = context.measure(query, result.cluster.member, metric);
 
         // Normalize stats
-        result.computed_distances = context.computed_distances_count - result.computed_distances;
+        result.computed_distances = context.computed_distances - result.computed_distances;
         result.visited_members = context.iteration_cycles - result.visited_members;
 
         (void)predicate;
         return result;
     }
 
+#if defined(USEARCH_USE_PRAGMA_REGION)
 #pragma endregion
 
 #pragma region Metadata
+#endif
 
     struct stats_t {
         std::size_t nodes{};
@@ -2593,6 +3050,9 @@ class index_gt {
         std::size_t allocated_bytes{};
     };
 
+    /**
+     *  @brief  Aggregates stats on the number of nodes, edges, and memory usage across all levels.
+     */
     stats_t stats() const noexcept {
         stats_t result{};
 
@@ -2611,10 +3071,17 @@ class index_gt {
         return result;
     }
 
+    /**
+     *  @brief  Aggregates stats on the number of nodes, edges, and memory usage up to a specific level.
+     *
+     *  The `level` parameter is zero-based, where `0` is the base level.
+     *  For example, `level=1` will include the base level and the first level of connections.
+     */
     stats_t stats(std::size_t level) const noexcept {
         stats_t result{};
-
         std::size_t neighbors_bytes = !level ? pre_.neighbors_base_bytes : pre_.neighbors_bytes;
+        std::size_t max_edges_per_node = !level ? config_.connectivity_base : config_.connectivity;
+
         for (std::size_t i = 0; i != size(); ++i) {
             node_t node = node_at_(i);
             if (static_cast<std::size_t>(node.level()) < level)
@@ -2625,11 +3092,17 @@ class index_gt {
             result.allocated_bytes += node_head_bytes_() + neighbors_bytes;
         }
 
-        std::size_t max_edges_per_node = level ? config_.connectivity_base : config_.connectivity;
         result.max_edges = result.nodes * max_edges_per_node;
         return result;
     }
 
+    /**
+     *  @brief  Aggregates stats on the number of nodes, edges, and memory usage up to a specific level,
+     *          simultaneously exporting the stats for each level into the `stats_per_level` C-style array.
+     *
+     *  The `max_level` parameter is zero-based, where `0` is the base level.
+     *  For example, `max_level=1` will include the base level and the first level of connections.
+     */
     stats_t stats(stats_t* stats_per_level, std::size_t max_level) const noexcept {
 
         std::size_t head_bytes = node_head_bytes_();
@@ -2688,9 +3161,11 @@ class index_gt {
 
     std::size_t memory_usage_per_node(level_t level) const noexcept { return node_bytes_(level); }
 
+#if defined(USEARCH_USE_PRAGMA_REGION)
 #pragma endregion
 
 #pragma region Serialization
+#endif
 
     /**
      *  @brief  Estimate the binary length (in bytes) of the serialized index.
@@ -2757,6 +3232,7 @@ class index_gt {
         serialization_result_t result;
 
         // Remove previously stored objects
+        index_limits_t old_limits = limits_;
         reset();
 
         // Pull basic metadata
@@ -2781,9 +3257,15 @@ class index_gt {
         // Submit metadata
         config_.connectivity = header.connectivity;
         config_.connectivity_base = header.connectivity_base;
+        error_t error = config_.validate();
+        if (error)
+            return result.failed(std::move(error));
+
         pre_ = precompute_(config_);
         index_limits_t limits;
         limits.members = header.size;
+        limits.threads_add = (std::max<std::size_t>)(1, old_limits.threads_add);
+        limits.threads_search = (std::max<std::size_t>)(1, old_limits.threads_search);
         if (!reserve(limits)) {
             reset();
             return result.failed("Out of memory");
@@ -2833,8 +3315,12 @@ class index_gt {
             },
             std::forward<progress_at>(progress));
 
-        if (!stream_result)
+        if (!stream_result) {
+            // Drop generic messages like "end of file reached" in favor
+            // of more specific messages from the stream
+            io_result.error.release();
             return stream_result;
+        }
         return io_result;
     }
 
@@ -2882,8 +3368,12 @@ class index_gt {
             },
             std::forward<progress_at>(progress));
 
-        if (!stream_result)
+        if (!stream_result) {
+            // Drop generic messages like "end of file reached" in favor
+            // of more specific messages from the stream
+            io_result.error.release();
             return stream_result;
+        }
         return io_result;
     }
 
@@ -2922,6 +3412,7 @@ class index_gt {
                                 progress_at&& progress = {}) noexcept {
 
         // Remove previously stored objects
+        index_limits_t old_limits = limits_;
         reset();
 
         serialization_result_t result = file.open_if_not();
@@ -2948,6 +3439,10 @@ class index_gt {
 
         config_.connectivity = header.connectivity;
         config_.connectivity_base = header.connectivity_base;
+        error_t error = config_.validate();
+        if (error)
+            return result.failed(std::move(error));
+
         pre_ = precompute_(config_);
         misaligned_ptr_gt<level_t> levels{(byte_t*)file.data() + offset + sizeof(header)};
         offsets[0u] = offset + sizeof(header) + sizeof(level_t) * header.size;
@@ -2963,6 +3458,8 @@ class index_gt {
         // Submit metadata and reserve memory
         index_limits_t limits;
         limits.members = header.size;
+        limits.threads_add = (std::max<std::size_t>)(1, old_limits.threads_add);
+        limits.threads_search = (std::max<std::size_t>)(1, old_limits.threads_search);
         if (!reserve(limits)) {
             reset();
             return result.failed("Out of memory");
@@ -2981,23 +3478,21 @@ class index_gt {
         return {};
     }
 
+#if defined(USEARCH_USE_PRAGMA_REGION)
 #pragma endregion
+#endif
 
     /**
      *  @brief  Performs compaction on the whole HNSW index, purging some entries
      *          and links to them, while also generating a more efficient mapping,
      *          putting the more frequently used entries closer together.
      *
-     *
-     * Scans the whole collection, removing the links leading towards
-     *          banned entries. This essentially isolates some nodes from the rest
-     *          of the graph, while keeping their outgoing links, in case the node
-     *          is structurally relevant and has a crucial role in the index.
-     *          It won't reclaim the memory.
-     *
-     *  @param[in] allow_member Predicate to mark nodes for isolation.
+     *  @param[in] values A []-subscriptable object, providing access to the values.
+     *  @param[in] metric Callable object measuring distance between any ::values and present objects.
+     *  @param[in] slot_transition Callable object to inform changes in slot assignments.
      *  @param[in] executor Thread-pool to execute the job in parallel.
      *  @param[in] progress Callback to report the execution progress.
+     *  @param[in] prefetch Callable object to prefetch data into the cache.
      */
     template <typename values_at, typename metric_at,                   //
               typename slot_transition_at = dummy_key_to_key_mapping_t, //
@@ -3031,16 +3526,14 @@ class index_gt {
         std::size_t const total = 3 * slots_and_levels.size();
 
         // For every bottom level node, determine its parent cluster
-        executor.dynamic(slots_and_levels.size(), [&](std::size_t thread_idx, std::size_t old_slot) {
+        executor.dynamic(slots_and_levels.size(), [&](std::size_t thread_idx, std::size_t old_slot_as_uint) {
             context_t& context = contexts_[thread_idx];
-            std::size_t cluster = search_for_one_( //
-                values[citerator_at(old_slot)],    //
-                metric, prefetch,                  //
-                entry_slot_, max_level_, 0, context);
-            slots_and_levels[old_slot] = {                                          //
-                                          static_cast<compressed_slot_t>(old_slot), //
-                                          static_cast<compressed_slot_t>(cluster),  //
-                                          node_at_(old_slot).level()};
+            compressed_slot_t old_slot = static_cast<compressed_slot_t>(old_slot_as_uint);
+            compressed_slot_t cluster = search_for_one_( //
+                values[citerator_at(old_slot)],          //
+                metric, prefetch,                        //
+                static_cast<compressed_slot_t>(entry_slot_), max_level_, 0, context);
+            slots_and_levels[old_slot] = {old_slot, cluster, node_at_(old_slot).level()};
             ++processed;
             if (thread_idx == 0)
                 do_tasks = progress(processed.load(), total);
@@ -3223,90 +3716,90 @@ class index_gt {
         return {nodes_mutexes_, slot};
     }
 
-    template <typename value_at, typename metric_at, typename prefetch_at>
-    void connect_node_across_levels_(                                                           //
-        value_at&& value, metric_at&& metric, prefetch_at&& prefetch,                           //
-        std::size_t node_slot, std::size_t entry_slot, level_t max_level, level_t target_level, //
-        index_update_config_t const& config, context_t& context) usearch_noexcept_m {
-
-        // Go down the level, tracking only the closest match
-        std::size_t closest_slot = search_for_one_( //
-            value, metric, prefetch,                //
-            entry_slot, max_level, target_level, context);
-
-        // From `target_level` down perform proper extensive search
-        for (level_t level = (std::min)(target_level, max_level); level >= 0; --level) {
-            // TODO: Handle out of memory conditions
-            search_to_insert_(value, metric, prefetch, closest_slot, node_slot, level, config.expansion, context);
-            closest_slot = connect_new_node_(metric, node_slot, level, context);
-            reconnect_neighbor_nodes_(metric, node_slot, value, level, context);
+    struct node_conditional_lock_t {
+        nodes_mutexes_t& mutexes;
+        std::size_t slot;
+        inline ~node_conditional_lock_t() noexcept {
+            if (slot != std::numeric_limits<std::size_t>::max())
+                mutexes.atomic_reset(slot);
         }
+    };
+
+    inline node_conditional_lock_t node_try_conditional_lock_(std::size_t slot, bool condition,
+                                                              bool& failed_to_acquire) const noexcept {
+        failed_to_acquire = condition ? nodes_mutexes_.atomic_set(slot) : false;
+        return {nodes_mutexes_, failed_to_acquire ? std::numeric_limits<std::size_t>::max() : slot};
     }
 
-    template <typename metric_at>
-    std::size_t connect_new_node_( //
+    template <typename metric_at, bool require_non_empty_ak = false>
+    candidates_view_t form_links_to_closest_( //
         metric_at&& metric, std::size_t new_slot, level_t level, context_t& context) usearch_noexcept_m {
 
         node_t new_node = node_at_(new_slot);
         top_candidates_t& top = context.top_candidates;
+        usearch_assert_m(top.size() || !require_non_empty_ak, "No candidates found");
+        candidates_view_t top_view =
+            refine_(metric, config_.connectivity, top, context, context.computed_distances_in_refines);
+        usearch_assert_m(top_view.size() || !require_non_empty_ak, "This would lead to isolated nodes");
 
         // Outgoing links from `new_slot`:
         neighbors_ref_t new_neighbors = neighbors_(new_node, level);
-        {
-            usearch_assert_m(!new_neighbors.size(), "The newly inserted element should have blank link list");
-            candidates_view_t top_view = refine_(metric, config_.connectivity, top, context);
-
-            for (std::size_t idx = 0; idx != top_view.size(); idx++) {
-                usearch_assert_m(!new_neighbors[idx], "Possible memory corruption");
-                usearch_assert_m(level <= node_at_(top_view[idx].slot).level(), "Linking to missing level");
-                new_neighbors.push_back(top_view[idx].slot);
-            }
+        usearch_assert_m(!new_neighbors.size(), "The newly inserted element should have blank link list");
+        for (std::size_t idx = 0; idx != top_view.size(); idx++) {
+            usearch_assert_m(!new_neighbors[idx], "Possible memory corruption");
+            usearch_assert_m(level <= node_at_(top_view[idx].slot).level(), "Linking to missing level");
+            new_neighbors.push_back(top_view[idx].slot);
         }
 
-        return new_neighbors[0];
+        return top_view;
     }
 
     template <typename value_at, typename metric_at>
-    void reconnect_neighbor_nodes_( //
-        metric_at&& metric, std::size_t new_slot, value_at&& value, level_t level,
-        context_t& context) usearch_noexcept_m {
+    void form_reverse_links_( //
+        metric_at&& metric, compressed_slot_t new_slot, candidates_view_t new_neighbors, value_at&& value,
+        level_t level, context_t& context) usearch_noexcept_m {
 
-        node_t new_node = node_at_(new_slot);
         top_candidates_t& top = context.top_candidates;
-        neighbors_ref_t new_neighbors = neighbors_(new_node, level);
+        std::size_t const connectivity_max = level ? config_.connectivity : config_.connectivity_base;
 
         // Reverse links from the neighbors:
-        std::size_t const connectivity_max = level ? config_.connectivity : config_.connectivity_base;
-        for (compressed_slot_t close_slot : new_neighbors) {
+        for (auto new_neighbor : new_neighbors) {
+            compressed_slot_t close_slot = new_neighbor.slot;
             if (close_slot == new_slot)
                 continue;
             node_lock_t close_lock = node_lock_(close_slot);
             node_t close_node = node_at_(close_slot);
-
             neighbors_ref_t close_header = neighbors_(close_node, level);
-            usearch_assert_m(close_header.size() <= connectivity_max, "Possible corruption");
+
+            // The node may have no neighbors only in one case, when it's the first one in the index,
+            // but that is problematic to track in multi-threaded environments, where the order of insertion
+            // is not guaranteed.
+            // usearch_assert_m(close_header.size() || new_slot == 1, "Possible corruption - isolated node");
+            usearch_assert_m(close_header.size() <= connectivity_max, "Possible corruption - overflow");
             usearch_assert_m(close_slot != new_slot, "Self-loops are impossible");
             usearch_assert_m(level <= close_node.level(), "Linking to missing level");
 
             // If `new_slot` is already present in the neighboring connections of `close_slot`
             // then no need to modify any connections or run the heuristics.
             if (close_header.size() < connectivity_max) {
-                close_header.push_back(static_cast<compressed_slot_t>(new_slot));
+                close_header.push_back(new_slot);
                 continue;
             }
 
             // To fit a new connection we need to drop an existing one.
             top.clear();
-            usearch_assert_m((top.reserve(close_header.size() + 1)), "The memory must have been reserved in `add`");
-            top.insert_reserved(
-                {context.measure(value, citerator_at(close_slot), metric), static_cast<compressed_slot_t>(new_slot)});
+            usearch_assert_m((top.capacity() >= (close_header.size() + 1)),
+                             "The memory must have been reserved in `add`");
+            top.insert_reserved({context.measure(value, citerator_at(close_slot), metric), new_slot});
             for (compressed_slot_t successor_slot : close_header)
                 top.insert_reserved(
                     {context.measure(citerator_at(close_slot), citerator_at(successor_slot), metric), successor_slot});
 
             // Export the results:
             close_header.clear();
-            candidates_view_t top_view = refine_(metric, connectivity_max, top, context);
+            candidates_view_t top_view =
+                refine_(metric, connectivity_max, top, context, context.computed_distances_in_reverse_refines);
+            usearch_assert_m(top_view.size(), "This would lead to isolated nodes");
             for (std::size_t idx = 0; idx != top_view.size(); idx++)
                 close_header.push_back(top_view[idx].slot);
         }
@@ -3348,12 +3841,12 @@ class index_gt {
         using pointer = misaligned_ptr_gt<element_t>;
         using reference = misaligned_ref_gt<element_t>;
 
-        reference operator*() const noexcept { return slot(); }
+        value_type operator*() const noexcept { return neighbors_[current_]; }
         candidates_iterator_t(index_gt const& index, neighbors_ref_t neighbors, visits_hash_set_t& visits,
                               std::size_t progress) noexcept
             : index_(index), neighbors_(neighbors), visits_(visits), current_(progress) {}
         candidates_iterator_t operator++(int) noexcept {
-            return candidates_iterator_t(index_, visits_, neighbors_, current_ + 1).skip_missing();
+            return candidates_iterator_t(index_, neighbors_, visits_, current_ + 1).skip_missing();
         }
         candidates_iterator_t& operator++() noexcept {
             ++current_;
@@ -3363,7 +3856,7 @@ class index_gt {
         bool operator==(candidates_iterator_t const& other) noexcept { return current_ == other.current_; }
         bool operator!=(candidates_iterator_t const& other) noexcept { return current_ != other.current_; }
 
-        vector_key_t key() const noexcept { return index_->node_at_(slot()).key(); }
+        vector_key_t key() const noexcept { return index_.node_at_(slot()).key(); }
         compressed_slot_t slot() const noexcept { return neighbors_[current_]; }
         friend inline std::size_t get_slot(candidates_iterator_t const& it) noexcept { return it.slot(); }
         friend inline vector_key_t get_key(candidates_iterator_t const& it) noexcept { return it.key(); }
@@ -3381,16 +3874,16 @@ class index_gt {
     };
 
     template <typename value_at, typename metric_at, typename prefetch_at = dummy_prefetch_t>
-    std::size_t search_for_one_(                                      //
+    compressed_slot_t search_for_one_(                                //
         value_at&& query, metric_at&& metric, prefetch_at&& prefetch, //
-        std::size_t closest_slot, level_t begin_level, level_t end_level, context_t& context) const noexcept {
+        compressed_slot_t closest_slot, level_t begin_level, level_t end_level, context_t& context) const noexcept {
 
         visits_hash_set_t& visits = context.visits;
         visits.clear();
 
         // Optional prefetching
         if (!is_dummy<prefetch_at>())
-            prefetch(citerator_at(closest_slot), citerator_at(closest_slot + 1));
+            prefetch(citerator_at(closest_slot), citerator_at(closest_slot) + 1);
 
         distance_t closest_dist = context.measure(query, citerator_at(closest_slot), metric);
         for (level_t level = begin_level; level > end_level; --level) {
@@ -3415,6 +3908,7 @@ class index_gt {
                         changed = true;
                     }
                 }
+
                 context.iteration_cycles++;
             } while (changed);
         }
@@ -3429,8 +3923,7 @@ class index_gt {
     template <typename value_at, typename metric_at, typename prefetch_at = dummy_prefetch_t>
     bool search_to_insert_(                                           //
         value_at&& query, metric_at&& metric, prefetch_at&& prefetch, //
-        std::size_t start_slot, std::size_t new_slot, level_t level, std::size_t top_limit,
-        context_t& context) noexcept {
+        compressed_slot_t start_slot, level_t level, std::size_t top_limit, context_t& context) noexcept {
 
         visits_hash_set_t& visits = context.visits;
         next_candidates_t& next = context.next_candidates; // pop min, push
@@ -3439,18 +3932,21 @@ class index_gt {
         visits.clear();
         next.clear();
         top.clear();
+
+        // At the very least we are going to explore the starting node and its neighbors
         if (!visits.reserve(config_.connectivity_base + 1u))
             return false;
 
         // Optional prefetching
         if (!is_dummy<prefetch_at>())
-            prefetch(citerator_at(start_slot), citerator_at(start_slot + 1));
+            prefetch(citerator_at(start_slot), citerator_at(start_slot) + 1);
 
         distance_t radius = context.measure(query, citerator_at(start_slot), metric);
-        next.insert_reserved({-radius, static_cast<compressed_slot_t>(start_slot)});
-        top.insert_reserved({radius, static_cast<compressed_slot_t>(start_slot)});
-        visits.set(static_cast<compressed_slot_t>(start_slot));
+        next.insert_reserved({-radius, start_slot});
+        top.insert_reserved({radius, start_slot});
+        visits.set(start_slot);
 
+        // The primary loop of the graph traversal
         while (!next.empty()) {
 
             candidate_t candidacy = next.top();
@@ -3461,8 +3957,6 @@ class index_gt {
             context.iteration_cycles++;
 
             compressed_slot_t candidate_slot = candidacy.slot;
-            if (new_slot == candidate_slot)
-                continue;
             node_t candidate_ref = node_at_(candidate_slot);
             node_lock_t candidate_lock = node_lock_(candidate_slot);
             neighbors_ref_t candidate_neighbors = neighbors_(candidate_ref, level);
@@ -3481,6 +3975,8 @@ class index_gt {
                 if (visits.set(successor_slot))
                     continue;
 
+                // We don't access the neighbors of the `successor_slot` node,
+                // so we don't have to lock it.
                 // node_lock_t successor_lock = node_lock_(successor_slot);
                 distance_t successor_dist = context.measure(query, citerator_at(successor_slot), metric);
                 if (top.size() < top_limit || successor_dist < radius) {
@@ -3495,6 +3991,95 @@ class index_gt {
         return true;
     }
 
+    /**
+     *  @brief  Traverses a layer of a graph, to find the best neighbors list for updated node.
+     *          Locks the nodes in the process, assuming other threads are updating neighbors lists.
+     *  @return `true` if procedure succeeded, `false` if run out of memory.
+     */
+    template <typename value_at, typename metric_at, typename prefetch_at = dummy_prefetch_t>
+    bool search_to_update_(                                           //
+        value_at&& query, metric_at&& metric, prefetch_at&& prefetch, //
+        compressed_slot_t start_slot, compressed_slot_t updated_slot, level_t level, std::size_t top_limit,
+        context_t& context) noexcept {
+
+        visits_hash_set_t& visits = context.visits;
+        next_candidates_t& next = context.next_candidates; // pop min, push
+        top_candidates_t& top = context.top_candidates;    // pop max, push
+
+        visits.clear();
+        next.clear();
+        top.clear();
+
+        // At the very least we are going to explore the starting node and its neighbors
+        if (!visits.reserve(config_.connectivity_base + 1u))
+            return false;
+
+        // Optional prefetching
+        if (!is_dummy<prefetch_at>())
+            prefetch(citerator_at(start_slot), citerator_at(start_slot) + 1);
+
+        distance_t radius = context.measure(query, citerator_at(start_slot), metric);
+        next.insert_reserved({-radius, start_slot});
+        visits.set(start_slot);
+        if (start_slot != updated_slot)
+            top.insert_reserved({radius, start_slot});
+
+        // The primary loop of the graph traversal
+        while (!next.empty()) {
+
+            candidate_t candidacy = next.top();
+            if ((-candidacy.distance) > radius && top.size() == top_limit)
+                break;
+
+            next.pop();
+            context.iteration_cycles++;
+
+            compressed_slot_t candidate_slot = candidacy.slot;
+            node_t candidate_ref = node_at_(candidate_slot);
+
+            // The trickiest part of update-heavy workloads is mitigating dead-locks
+            // in connected nodes during traversal. A "good enough" solution would be
+            // to skip concurrent access, assuming the other "close" node is gonna add
+            // this one when forming reverse connections.
+            bool failed_to_acquire = false;
+            node_conditional_lock_t candidate_lock =
+                node_try_conditional_lock_(candidate_slot, updated_slot != candidate_slot, failed_to_acquire);
+            if (failed_to_acquire)
+                continue;
+            neighbors_ref_t candidate_neighbors = neighbors_(candidate_ref, level);
+
+            // Optional prefetching
+            if (!is_dummy<prefetch_at>()) {
+                candidates_range_t missing_candidates{*this, candidate_neighbors, visits};
+                prefetch(missing_candidates.begin(), missing_candidates.end());
+            }
+
+            // Assume the worst-case when reserving memory
+            if (!visits.reserve(visits.size() + candidate_neighbors.size()))
+                return false;
+
+            for (compressed_slot_t successor_slot : candidate_neighbors) {
+                if (visits.set(successor_slot))
+                    continue;
+
+                // We don't access the neighbors of the `successor_slot` node,
+                // so we don't have to lock it.
+                // node_conditional_lock_t successor_lock =
+                //     node_try_conditional_lock_(successor_slot, updated_slot != successor_slot);
+                distance_t successor_dist = context.measure(query, citerator_at(successor_slot), metric);
+                if (top.size() < top_limit || successor_dist < radius) {
+                    // This can substantially grow our priority queue:
+                    next.insert({-successor_dist, successor_slot});
+                    // This will automatically evict poor matches:
+                    if (updated_slot != successor_slot)
+                        top.insert({successor_dist, successor_slot}, top_limit);
+                    radius = top.top().distance;
+                }
+            }
+        }
+        return true;
+    }
+
     /**
      *  @brief  Traverses the @b base layer of a graph, to find a close match.
      *          Doesn't lock any nodes, assuming read-only simultaneous access.
@@ -3503,7 +4088,7 @@ class index_gt {
     template <typename value_at, typename metric_at, typename predicate_at, typename prefetch_at>
     bool search_to_find_in_base_(                                                               //
         value_at&& query, metric_at&& metric, predicate_at&& predicate, prefetch_at&& prefetch, //
-        std::size_t start_slot, std::size_t expansion, context_t& context) const usearch_noexcept_m {
+        compressed_slot_t start_slot, std::size_t expansion, context_t& context) const usearch_noexcept_m {
 
         visits_hash_set_t& visits = context.visits;
         next_candidates_t& next = context.next_candidates; // pop min, push
@@ -3518,24 +4103,24 @@ class index_gt {
 
         // Optional prefetching
         if (!is_dummy<prefetch_at>())
-            prefetch(citerator_at(start_slot), citerator_at(start_slot + 1));
+            prefetch(citerator_at(start_slot), citerator_at(start_slot) + 1);
 
         distance_t radius = context.measure(query, citerator_at(start_slot), metric);
         usearch_assert_m(next.capacity(), "The `max_heap_gt` must have been reserved in the search entry point");
-        next.insert_reserved({-radius, static_cast<compressed_slot_t>(start_slot)});
-        visits.set(static_cast<compressed_slot_t>(start_slot));
+        next.insert_reserved({-radius, start_slot});
+        visits.set(start_slot);
 
         // Don't populate the top list if the predicate is not satisfied
         if (is_dummy<predicate_at>() || predicate(member_cref_t{node_at_(start_slot).ckey(), start_slot})) {
             usearch_assert_m(top.capacity(),
                              "The `sorted_buffer_gt` must have been reserved in the search entry point");
-            top.insert_reserved({radius, static_cast<compressed_slot_t>(start_slot)});
+            top.insert_reserved({radius, start_slot});
         }
 
         while (!next.empty()) {
 
             candidate_t candidate = next.top();
-            if ((-candidate.distance) > radius)
+            if ((-candidate.distance) > radius && top.size() == top_limit)
                 break;
 
             next.pop();
@@ -3584,12 +4169,13 @@ class index_gt {
         top.clear();
         top.reserve(count);
         for (std::size_t i = 0; i != size(); ++i) {
+            auto slot = static_cast<compressed_slot_t>(i);
             if (!is_dummy<predicate_at>())
-                if (!predicate(at(i)))
+                if (!predicate(at(slot)))
                     continue;
 
-            distance_t distance = context.measure(query, citerator_at(i), metric);
-            top.insert(candidate_t{distance, static_cast<compressed_slot_t>(i)}, count);
+            distance_t distance = context.measure(query, citerator_at(slot), metric);
+            top.insert(candidate_t{distance, slot}, count);
         }
     }
 
@@ -3599,22 +4185,27 @@ class index_gt {
      *          to keep only the neighbors, that are from each other.
      */
     template <typename metric_at>
-    candidates_view_t refine_( //
-        metric_at&& metric,    //
-        std::size_t needed, top_candidates_t& top, context_t& context) const noexcept {
+    candidates_view_t refine_(                                         //
+        metric_at&& metric,                                            //
+        std::size_t needed, top_candidates_t& top, context_t& context, //
+        std::size_t& refines_counter) const noexcept {
 
-        top.sort_ascending();
+        // Avoid expensive computation, if the set is already small
         candidate_t* top_data = top.data();
         std::size_t const top_count = top.size();
         if (top_count < needed)
             return {top_data, top_count};
 
+        // Sort before processing
+        top.sort_ascending();
+
         std::size_t submitted_count = 1;
         std::size_t consumed_count = 1; /// Always equal or greater than `submitted_count`.
         while (submitted_count < needed && consumed_count < top_count) {
             candidate_t candidate = top_data[consumed_count];
             bool good = true;
-            for (std::size_t idx = 0; idx < submitted_count; idx++) {
+            std::size_t idx = 0;
+            for (; idx < submitted_count; idx++) {
                 candidate_t submitted = top_data[idx];
                 distance_t inter_result_dist = context.measure( //
                     citerator_at(candidate.slot),               //
@@ -3625,6 +4216,7 @@ class index_gt {
                     break;
                 }
             }
+            refines_counter += idx;
 
             if (good) {
                 top_data[submitted_count] = top_data[consumed_count];
@@ -3806,11 +4398,12 @@ static join_result_t join(               //
             bool woman_is_free = husband_slot == missing_slot;
             if (woman_is_free) {
                 // Engagement
-                man_to_woman_slots[free_man_slot] = woman.slot;
+                man_to_woman_slots[free_man_slot] = static_cast<compressed_slot_t>(woman.slot);
                 woman_to_man_slots[woman.slot] = free_man_slot;
                 engagements++;
             } else {
-                distance_t distance_from_husband = women_metric(women_values[woman.slot], men_values[husband_slot]);
+                distance_t distance_from_husband =
+                    women_metric(women_values[static_cast<compressed_slot_t>(woman.slot)], men_values[husband_slot]);
                 distance_t distance_from_candidate = match.distance;
                 if (distance_from_husband > distance_from_candidate) {
                     // Break-up
@@ -3820,7 +4413,7 @@ static join_result_t join(               //
                     men_locks.atomic_reset(husband_slot);
 
                     // New Engagement
-                    man_to_woman_slots[free_man_slot] = woman.slot;
+                    man_to_woman_slots[free_man_slot] = static_cast<compressed_slot_t>(woman.slot);
                     woman_to_man_slots[woman.slot] = free_man_slot;
                     engagements++;
 
@@ -3845,7 +4438,7 @@ static join_result_t join(               //
     for (std::size_t man_slot = 0; man_slot != men.size(); ++man_slot) {
         compressed_slot_t woman_slot = man_to_woman_slots[man_slot];
         if (woman_slot != missing_slot) {
-            man_key_t man = men.at(man_slot).key;
+            man_key_t man = men.at(static_cast<compressed_slot_t>(man_slot)).key;
             woman_key_t woman = women.at(woman_slot).key;
             man_to_woman[man] = woman;
             woman_to_man[woman] = man;
diff --git a/include/usearch/index_dense.hpp b/include/usearch/index_dense.hpp
index 354c5786..adf8ac47 100644
--- a/include/usearch/index_dense.hpp
+++ b/include/usearch/index_dense.hpp
@@ -5,13 +5,9 @@
  *  @date       July 26, 2023
  */
 #pragma once
+#include "index.hpp"
 #include <stdlib.h> // `aligned_alloc`
 
-#include <functional> // `std::function`
-#include <numeric>    // `std::iota`
-#include <thread>     // `std::thread`
-#include <vector>     // `std::vector`
-
 #include <usearch/index.hpp>
 #include <usearch/index_plugins.hpp>
 
@@ -95,10 +91,32 @@ struct index_dense_head_result_t {
     }
 };
 
+/**
+ *  @brief  Configuration settings for the construction of dense
+ *          equidimensional vector indexes.
+ *
+ *  Unlike the underlying `index_gt` class, incroporates the
+ *  `::expansion_add` and `::expansion_search` parameters passed
+ *  separately for the lower-level engine.
+ */
 struct index_dense_config_t : public index_config_t {
     std::size_t expansion_add = default_expansion_add();
     std::size_t expansion_search = default_expansion_search();
+
+    /**
+     *  @brief  Excludes vectors from the serialized file.
+     *          This is handy when you want to store the vectors in a separate file.
+     *
+     *  ! For advanced users only.
+     */
     bool exclude_vectors = false;
+
+    /**
+     *  @brief  Allows you to store multiple vectors per key.
+     *          This is handy when a large document is chunked into many parts.
+     *
+     *  ! May degrade the performance of iterators.
+     */
     bool multi = false;
 
     /**
@@ -107,17 +125,37 @@ struct index_dense_config_t : public index_config_t {
      *          the vectors-to-keys mappings.
      *
      *  ! This configuration parameter doesn't affect the serialized file,
-     *  ! and is not preserved between runs. Makes sense for small vector
-     *  ! representations that fit ina  single cache line.
+     *  ! and is not preserved between runs. Makes sense for smaller vectors
+     *  ! that fit in a couple of cache lines.
+     *
+     *  The trade-off is that some methods won't be available, like `get`, `rename`,
+     *  and `remove`. The basic functionality, like `add` and `search` will work as
+     *  expected even with `enable_key_lookups = false`.
+     *
+     *  If both `!multi && !enable_key_lookups`, the "duplicate entry" checks won't
+     *  be performed and no errors will be raised.
      */
     bool enable_key_lookups = true;
 
-    index_dense_config_t(index_config_t base) noexcept : index_config_t(base) {}
+    inline index_dense_config_t(index_config_t base) noexcept : index_config_t(base) {}
+
+    inline index_dense_config_t(std::size_t c = 0, std::size_t ea = 0, std::size_t es = 0) noexcept
+        : index_config_t(c), expansion_add(ea), expansion_search(es) {}
 
-    index_dense_config_t(std::size_t c = default_connectivity(), std::size_t ea = default_expansion_add(),
-                         std::size_t es = default_expansion_search()) noexcept
-        : index_config_t(c), expansion_add(ea ? ea : default_expansion_add()),
-          expansion_search(es ? es : default_expansion_search()) {}
+    /**
+     *  @brief  Validates the configuration settings, updating them in-place.
+     *  @return Error message, if any.
+     */
+    inline error_t validate() noexcept {
+        error_t error = index_config_t::validate();
+        if (error)
+            return error;
+        if (expansion_add == 0)
+            expansion_add = default_expansion_add();
+        if (expansion_search == 0)
+            expansion_search = default_expansion_search();
+        return {};
+    }
 };
 
 struct index_dense_clustering_config_t {
@@ -169,6 +207,40 @@ struct index_dense_metadata_result_t {
     }
 };
 
+inline scalar_kind_t convert_pre_2_10_scalar_kind(scalar_kind_t scalar_kind) noexcept {
+    // The old enum `scalar_kind_t` is defined without explicit constants from 0
+    switch (static_cast<std::underlying_type<scalar_kind_t>::type>(scalar_kind)) {
+    case 0: return scalar_kind_t::unknown_k;
+    case 1: return scalar_kind_t::b1x8_k;
+    case 2: return scalar_kind_t::u40_k;
+    case 3: return scalar_kind_t::uuid_k;
+    case 4: return scalar_kind_t::f64_k;
+    case 5: return scalar_kind_t::f32_k;
+    case 6: return scalar_kind_t::f16_k;
+    case 7: return scalar_kind_t::f8_k;
+    case 8: return scalar_kind_t::u64_k;
+    case 9: return scalar_kind_t::u32_k;
+    case 10: return scalar_kind_t::u8_k;
+    case 11: return scalar_kind_t::i64_k;
+    case 12: return scalar_kind_t::i32_k;
+    case 13: return scalar_kind_t::i16_k;
+    case 14: return scalar_kind_t::i8_k;
+    default: return scalar_kind;
+    }
+}
+
+inline void fix_pre_2_10_metadata(index_dense_head_t& head) {
+    // deal with incompatibility with pre-2.10 versions: https://github.com/unum-cloud/usearch/issues/423
+    if (head.version_major == 2 && head.version_minor < 10) {
+        head.kind_scalar = convert_pre_2_10_scalar_kind(head.kind_scalar);
+        head.kind_key = convert_pre_2_10_scalar_kind(head.kind_key);
+        head.kind_compressed_slot = convert_pre_2_10_scalar_kind(head.kind_compressed_slot);
+        // update minor versions so that no repeated conversion occurs
+        head.version_minor = 10;
+        head.version_patch = 0;
+    }
+}
+
 /**
  *  @brief  Extracts metadata from a pre-constructed index on disk,
  *          without loading it or mapping the whole binary file.
@@ -186,8 +258,10 @@ inline index_dense_metadata_result_t index_dense_metadata_from_path(char const*
 
     // Check if the file immediately starts with the index, instead of vectors
     result.config.exclude_vectors = true;
-    if (std::memcmp(result.head_buffer, default_magic(), std::strlen(default_magic())) == 0)
+    if (std::memcmp(result.head_buffer, default_magic(), std::strlen(default_magic())) == 0) {
+        fix_pre_2_10_metadata(result.head);
         return result;
+    }
 
     if (std::fseek(file.get(), 0L, SEEK_END) != 0)
         return result.failed("Can't infer file size");
@@ -213,8 +287,10 @@ inline index_dense_metadata_result_t index_dense_metadata_from_path(char const*
 
         result.config.exclude_vectors = false;
         result.config.use_64_bit_dimensions = false;
-        if (std::memcmp(result.head_buffer, default_magic(), std::strlen(default_magic())) == 0)
+        if (std::memcmp(result.head_buffer, default_magic(), std::strlen(default_magic())) == 0) {
+            fix_pre_2_10_metadata(result.head);
             return result;
+        }
     }
 
     // Check if it starts with 64-bit
@@ -228,8 +304,10 @@ inline index_dense_metadata_result_t index_dense_metadata_from_path(char const*
         // Check if it starts with 64-bit
         result.config.exclude_vectors = false;
         result.config.use_64_bit_dimensions = true;
-        if (std::memcmp(result.head_buffer, default_magic(), std::strlen(default_magic())) == 0)
+        if (std::memcmp(result.head_buffer, default_magic(), std::strlen(default_magic())) == 0) {
+            fix_pre_2_10_metadata(result.head);
             return result;
+        }
     }
 
     return result.failed("Not a dense USearch index!");
@@ -324,7 +402,7 @@ class index_dense_gt {
 
   private:
     /// @brief Schema: input buffer, bytes in input buffer, output buffer.
-    using cast_t = std::function<bool(byte_t const*, std::size_t, byte_t*)>;
+    using cast_t = bool (*)(byte_t const*, std::size_t, byte_t*);
     /// @brief Punned index.
     using index_t = index_gt<                        //
         distance_t, vector_key_t, compressed_slot_t, //
@@ -359,7 +437,10 @@ class index_dense_gt {
     index_dense_config_t config_;
     index_t* typed_ = nullptr;
 
-    mutable std::vector<byte_t> cast_buffer_;
+    using cast_buffer_t = buffer_gt<byte_t, dynamic_allocator_t>;
+
+    /// @brief  Temporary memory for every thread to store a casted vector.
+    mutable cast_buffer_t cast_buffer_;
     struct casts_t {
         cast_t from_b1x8;
         cast_t from_i8;
@@ -381,11 +462,17 @@ class index_dense_gt {
     /// @brief Allocator for the copied vectors, aligned to widest double-precision scalars.
     vectors_tape_allocator_t vectors_tape_allocator_;
 
+    using vectors_lookup_allocator_t = aligned_allocator_gt<byte_t*, 64>;
+    using vectors_lookup_t = buffer_gt<byte_t*, vectors_lookup_allocator_t>;
+
     /// @brief For every managed `compressed_slot_t` stores a pointer to the allocated vector copy.
-    mutable std::vector<byte_t*> vectors_lookup_;
+    mutable vectors_lookup_t vectors_lookup_;
+
+    using available_threads_allocator_t = aligned_allocator_gt<std::size_t, 64>;
+    using available_threads_t = ring_gt<std::size_t, available_threads_allocator_t>;
 
-    /// @brief Originally forms and array of integers [0, threads], marking all
-    mutable std::vector<std::size_t> available_threads_;
+    /// @brief Originally forms and array of integers [0, threads], marking all as available.
+    mutable available_threads_t available_threads_;
 
     /// @brief Mutex, controlling concurrent access to `available_threads_`.
     mutable std::mutex available_threads_mutex_;
@@ -408,8 +495,8 @@ class index_dense_gt {
 
     struct lookup_key_hash_t {
         using is_transparent = void;
-        std::size_t operator()(key_and_slot_t const& k) const noexcept { return std::hash<vector_key_t>{}(k.key); }
-        std::size_t operator()(vector_key_t const& k) const noexcept { return std::hash<vector_key_t>{}(k); }
+        std::size_t operator()(key_and_slot_t const& k) const noexcept { return hash_gt<vector_key_t>{}(k.key); }
+        std::size_t operator()(vector_key_t const& k) const noexcept { return hash_gt<vector_key_t>{}(k); }
     };
 
     struct lookup_key_same_t {
@@ -434,13 +521,57 @@ class index_dense_gt {
     /// @brief A constant for the reserved key value, used to mark deleted entries.
     vector_key_t free_key_ = default_free_value<vector_key_t>();
 
+    /// @brief Locks the thread for the duration of the operation.
+    struct thread_lock_t {
+        index_dense_gt const& parent;
+        std::size_t thread_id = 0;
+        bool engaged = false;
+
+        ~thread_lock_t() usearch_noexcept_m {
+            if (engaged)
+                parent.thread_unlock_(thread_id);
+        }
+
+        thread_lock_t(thread_lock_t const&) = delete;
+        thread_lock_t& operator=(thread_lock_t const&) = delete;
+
+        thread_lock_t(index_dense_gt const& parent, std::size_t thread_id, bool engaged = true) noexcept
+            : parent(parent), thread_id(thread_id), engaged(engaged) {}
+        thread_lock_t(thread_lock_t&& other) noexcept
+            : parent(other.parent), thread_id(other.thread_id), engaged(other.engaged) {
+            other.engaged = false;
+        }
+    };
+
   public:
-    using search_result_t = typename index_t::search_result_t;
     using cluster_result_t = typename index_t::cluster_result_t;
     using add_result_t = typename index_t::add_result_t;
     using stats_t = typename index_t::stats_t;
     using match_t = typename index_t::match_t;
 
+    /**
+     *  @brief  A search result, containing the found keys and distances.
+     *
+     *  As the `index_dense_gt` manages the thread-pool on its own, the search result
+     *  preserves the thread-lock to avoid undefined behaviors, when other threads
+     *  start overwriting the results.
+     */
+    struct search_result_t : public index_t::search_result_t {
+        inline search_result_t(index_dense_gt const& parent) noexcept
+            : index_t::search_result_t(), lock_(parent, 0, false) {}
+        search_result_t failed(error_t message) noexcept {
+            this->error = std::move(message);
+            return std::move(*this);
+        }
+
+      private:
+        friend class index_dense_gt;
+        thread_lock_t lock_;
+
+        inline search_result_t(typename index_t::search_result_t result, thread_lock_t lock) noexcept
+            : index_t::search_result_t(std::move(result)), lock_(std::move(lock)) {}
+    };
+
     index_dense_gt() = default;
     index_dense_gt(index_dense_gt&& other)
         : config_(std::move(other.config_)),
@@ -491,51 +622,76 @@ class index_dense_gt {
         typed_ = nullptr;
     }
 
+    struct state_result_t {
+        index_dense_gt index;
+        error_t error;
+
+        explicit operator bool() const noexcept { return !error; }
+        state_result_t failed(error_t message) noexcept {
+            error = std::move(message);
+            return std::move(*this);
+        }
+        operator index_dense_gt&&() && {
+            if (error)
+                __usearch_raise_runtime_error(error.what());
+            return std::move(index);
+        }
+    };
+    using copy_result_t = state_result_t;
+
     /**
      *  @brief Constructs an instance of ::index_dense_gt.
      *  @param[in] metric One of the provided or an @b ad-hoc metric, type-punned.
      *  @param[in] config The index configuration (optional).
      *  @param[in] free_key The key used for freed vectors (optional).
-     *  @return An instance of ::index_dense_gt.
+     *  @return An instance of ::index_dense_gt or error, wrapped in a `state_result_t`.
+     *
+     *  ! If the `metric` isn't provided in this method, it has to be set with
+     *  ! the `change_metric` method before the index can be used. Alternatively,
+     *  ! if you are loading an existing index, the metric will be set automatically.
      */
-    static index_dense_gt make(           //
-        metric_t metric,                  //
+    static state_result_t make(           //
+        metric_t metric = {},             //
         index_dense_config_t config = {}, //
         vector_key_t free_key = default_free_value<vector_key_t>()) {
 
-        scalar_kind_t scalar_kind = metric.scalar_kind();
-        std::size_t hardware_threads = std::thread::hardware_concurrency();
-
-        index_dense_gt result;
-        result.config_ = config;
-        result.cast_buffer_.resize(hardware_threads * metric.bytes_per_vector());
-        result.casts_ = make_casts_(scalar_kind);
-        result.metric_ = metric;
-        result.free_key_ = free_key;
-
-        // Fill the thread IDs.
-        result.available_threads_.resize(hardware_threads);
-        std::iota(result.available_threads_.begin(), result.available_threads_.end(), 0ul);
-
-        // Available since C11, but only C++17, so we use the C version.
+        if (metric.missing())
+            return state_result_t{}.failed("Metric won't be initialized!");
+        error_t error = config.validate();
+        if (error)
+            return state_result_t{}.failed(std::move(error));
         index_t* raw = index_allocator_t{}.allocate(1);
+        if (!raw)
+            return state_result_t{}.failed("Failed to allocate memory for the index!");
+
+        state_result_t result;
+        index_dense_gt& index = result.index;
+        index.config_ = config;
+        index.free_key_ = free_key;
+
+        // In some cases the metric is not provided, and will be set later.
+        if (metric) {
+            scalar_kind_t scalar_kind = metric.scalar_kind();
+            index.casts_ = make_casts_(scalar_kind);
+            index.metric_ = metric;
+        }
+
         new (raw) index_t(config);
-        result.typed_ = raw;
+        index.typed_ = raw;
         return result;
     }
 
-    static index_dense_gt make(char const* path, bool view = false) {
-        index_dense_metadata_result_t meta = index_dense_metadata_from_path(path);
-        if (!meta)
-            return {};
-        metric_punned_t metric(meta.head.dimensions, meta.head.kind_metric, meta.head.kind_scalar);
-        index_dense_gt result = make(metric);
-        if (!result)
-            return result;
-        if (view)
-            result.view(path);
-        else
-            result.load(path);
+    /**
+     *  @brief Constructs an instance of ::index_dense_gt from a serialized binary file.
+     *  @param[in] path The path to the binary file.
+     *  @param[in] view Whether to map the file into memory or load it.
+     *  @return An instance of ::index_dense_gt or error, wrapped in a `state_result_t`.
+     */
+    static state_result_t make(char const* path, bool view = false) {
+        state_result_t result;
+        serialization_result_t serialization_result = view ? result.index.view(path) : result.index.load(path);
+        if (!serialization_result)
+            return result.failed(std::move(serialization_result.error));
         return result;
     }
 
@@ -543,19 +699,23 @@ class index_dense_gt {
     std::size_t connectivity() const { return typed_->connectivity(); }
     std::size_t size() const { return typed_->size() - free_keys_.size(); }
     std::size_t capacity() const { return typed_->capacity(); }
-    std::size_t max_level() const noexcept { return typed_->max_level(); }
+    std::size_t max_level() const { return typed_->max_level(); }
     index_dense_config_t const& config() const { return config_; }
     index_limits_t const& limits() const { return typed_->limits(); }
     bool multi() const { return config_.multi; }
+    std::size_t currently_available_threads() const {
+        std::unique_lock<std::mutex> available_threads_lock(available_threads_mutex_);
+        return available_threads_.size();
+    }
 
     // The metric and its properties
     metric_t const& metric() const { return metric_; }
     void change_metric(metric_t metric) { metric_ = std::move(metric); }
 
-    scalar_kind_t scalar_kind() const noexcept { return metric_.scalar_kind(); }
-    std::size_t bytes_per_vector() const noexcept { return metric_.bytes_per_vector(); }
-    std::size_t scalar_words() const noexcept { return metric_.scalar_words(); }
-    std::size_t dimensions() const noexcept { return metric_.dimensions(); }
+    scalar_kind_t scalar_kind() const { return metric_.scalar_kind(); }
+    std::size_t bytes_per_vector() const { return metric_.bytes_per_vector(); }
+    std::size_t scalar_words() const { return metric_.scalar_words(); }
+    std::size_t dimensions() const { return metric_.dimensions(); }
 
     // Fetching and changing search criteria
     std::size_t expansion_add() const { return config_.expansion_add; }
@@ -565,8 +725,6 @@ class index_dense_gt {
 
     member_citerator_t cbegin() const { return typed_->cbegin(); }
     member_citerator_t cend() const { return typed_->cend(); }
-    member_citerator_t begin() const { return typed_->begin(); }
-    member_citerator_t end() const { return typed_->end(); }
     member_iterator_t begin() { return typed_->begin(); }
     member_iterator_t end() { return typed_->end(); }
 
@@ -647,6 +805,7 @@ class index_dense_gt {
      *          exporting the mean, maximum, and minimum values.
      */
     aggregated_distances_t distance_between(vector_key_t a, vector_key_t b, std::size_t = any_thread()) const {
+        usearch_assert_m(config().enable_key_lookups, "Key lookups are disabled!");
         shared_lock_t lock(slot_lookup_mutex_);
         aggregated_distances_t result;
         if (!multi()) {
@@ -720,9 +879,8 @@ class index_dense_gt {
         cluster_config.thread = lock.thread_id;
         cluster_config.expansion = config_.expansion_search;
         metric_proxy_t metric{*this};
-        auto allow = [free_key_ = this->free_key_](member_cref_t const& member) noexcept {
-            return member.key != free_key_;
-        };
+        vector_key_t free_key_copy = free_key_;
+        auto allow = [free_key_copy](member_cref_t const& member) noexcept { return member.key != free_key_copy; };
 
         // Find the closest cluster for any vector under that key.
         while (key_range.first != key_range.second) {
@@ -742,21 +900,54 @@ class index_dense_gt {
     /**
      *  @brief Reserves memory for the index and the keyed lookup.
      *  @return `true` if the memory reservation was successful, `false` otherwise.
+     *
+     *  ! No update or search operations should be running during this operation.
      */
-    bool reserve(index_limits_t limits) {
-        {
+    bool try_reserve(index_limits_t limits) {
+
+        // The slot lookup system will generally prefer power-of-two sizes.
+        if (config_.enable_key_lookups) {
             unique_lock_t lock(slot_lookup_mutex_);
-            slot_lookup_.reserve(limits.members);
-            vectors_lookup_.resize(limits.members);
+            if (!slot_lookup_.try_reserve(limits.members))
+                return false;
+            limits.members = slot_lookup_.capacity();
+        }
 
-            // During reserve, no insertions may be happening, so we can safely overwrite the whole collection.
-            std::unique_lock<std::mutex> available_threads_lock(available_threads_mutex_);
-            available_threads_.resize(limits.threads());
-            std::iota(available_threads_.begin(), available_threads_.end(), 0ul);
+        // Once the `slot_lookup_` grows, let's use its capacity as the new
+        // target for the `vectors_lookup_` to synchronize allocations and
+        // expensive index re-organizations.
+        if (limits.members != vectors_lookup_.size()) {
+            vectors_lookup_t new_vectors_lookup(limits.members);
+            if (!new_vectors_lookup)
+                return false;
+            if (vectors_lookup_.size() > 0)
+                std::memcpy(new_vectors_lookup.data(), vectors_lookup_.data(),
+                            vectors_lookup_.size() * sizeof(byte_t*));
+            vectors_lookup_ = std::move(new_vectors_lookup);
         }
+
+        // During reserve, no insertions may be happening, so we can safely overwrite the whole collection.
+        std::unique_lock<std::mutex> available_threads_lock(available_threads_mutex_);
+        available_threads_.clear();
+        if (!available_threads_.reserve(limits.threads()))
+            return false;
+        for (std::size_t i = 0; i < limits.threads(); i++)
+            available_threads_.push(i);
+
+        // Allocate a buffer for the casted vectors.
+        cast_buffer_t cast_buffer(limits.threads() * metric_.bytes_per_vector());
+        if (!cast_buffer)
+            return false;
+        cast_buffer_ = std::move(cast_buffer);
+
         return typed_->reserve(limits);
     }
 
+    void reserve(index_limits_t limits) {
+        if (!try_reserve(limits))
+            throw std::bad_alloc();
+    }
+
     /**
      *  @brief Erases all the vectors from the index.
      *
@@ -769,7 +960,7 @@ class index_dense_gt {
         std::unique_lock<std::mutex> free_lock(free_keys_mutex_);
         typed_->clear();
         slot_lookup_.clear();
-        vectors_lookup_.clear();
+        vectors_lookup_.reset();
         free_keys_.clear();
         vectors_tape_allocator_.reset();
     }
@@ -782,19 +973,18 @@ class index_dense_gt {
      *  If the index is memory-mapped - releases the mapping and the descriptor.
      */
     void reset() {
-        unique_lock_t lookup_lock(slot_lookup_mutex_);
 
+        unique_lock_t lookup_lock(slot_lookup_mutex_);
         std::unique_lock<std::mutex> free_lock(free_keys_mutex_);
         std::unique_lock<std::mutex> available_threads_lock(available_threads_mutex_);
-        typed_->reset();
+
+        if (typed_)
+            typed_->reset();
         slot_lookup_.clear();
-        vectors_lookup_.clear();
+        vectors_lookup_.reset();
         free_keys_.clear();
         vectors_tape_allocator_.reset();
-
-        // Reset the thread IDs.
-        available_threads_.resize(std::thread::hardware_concurrency());
-        std::iota(available_threads_.begin(), available_threads_.end(), 0ul);
+        available_threads_.reset();
     }
 
     /**
@@ -873,7 +1063,7 @@ class index_dense_gt {
     /**
      *  @brief  Estimate the binary length (in bytes) of the serialized index.
      */
-    std::size_t serialized_length(serialization_config_t config = {}) const noexcept {
+    std::size_t serialized_length(serialization_config_t config = {}) const {
         std::size_t dimensions_length = 0;
         std::size_t matrix_length = 0;
         if (!config.exclude_vectors) {
@@ -895,6 +1085,7 @@ class index_dense_gt {
                                             progress_at&& progress = {}) {
 
         // Discard all previous memory allocations of `vectors_tape_allocator_`
+        index_limits_t old_limits = typed_ ? typed_->limits() : index_limits_t{};
         reset();
 
         // Infer the new index size
@@ -919,7 +1110,9 @@ class index_dense_gt {
                 matrix_cols = dimensions[1];
             }
             // Load the vectors one after another
-            vectors_lookup_.resize(matrix_rows);
+            vectors_lookup_ = vectors_lookup_t(matrix_rows);
+            if (!vectors_lookup_)
+                return result.failed("Failed to allocate memory to address vectors");
             for (std::uint64_t slot = 0; slot != matrix_rows; ++slot) {
                 byte_t* vector = vectors_tape_allocator_.allocate(matrix_cols);
                 if (!input(vector, matrix_cols))
@@ -938,6 +1131,9 @@ class index_dense_gt {
             if (std::memcmp(buffer, default_magic(), std::strlen(default_magic())) != 0)
                 return result.failed("Magic header mismatch - the file isn't an index");
 
+            // fix pre-2.10 headers
+            fix_pre_2_10_metadata(head);
+
             // Validate the software version
             if (head.version_major != USEARCH_VERSION_MAJOR)
                 return result.failed("File format may be different, please rebuild");
@@ -950,16 +1146,38 @@ class index_dense_gt {
 
             config_.multi = head.multi;
             metric_ = metric_t::builtin(head.dimensions, head.kind_metric, head.kind_scalar);
-            cast_buffer_.resize(available_threads_.size() * metric_.bytes_per_vector());
+            cast_buffer_ = cast_buffer_t(available_threads_.size() * metric_.bytes_per_vector());
+            if (!cast_buffer_)
+                return result.failed("Failed to allocate memory for the casts");
             casts_ = make_casts_(head.kind_scalar);
         }
 
         // Pull the actual proximity graph
+        if (!typed_) {
+            index_t* raw = index_allocator_t{}.allocate(1);
+            if (!raw)
+                return result.failed("Failed to allocate memory for the index");
+            new (raw) index_t(config_);
+            typed_ = raw;
+        }
         result = typed_->load_from_stream(std::forward<input_callback_at>(input), std::forward<progress_at>(progress));
         if (!result)
             return result;
         if (typed_->size() != static_cast<std::size_t>(matrix_rows))
             return result.failed("Index size and the number of vectors doesn't match");
+        old_limits.members = static_cast<std::size_t>(matrix_rows);
+        if (!typed_->try_reserve(old_limits))
+            return result.failed("Failed to reserve memory for the index");
+
+        // After the index is loaded, we may have to resize the `available_threads_` to
+        // match the limits of the underlying engine.
+        available_threads_t available_threads;
+        std::size_t max_threads = old_limits.threads();
+        if (!available_threads.reserve(max_threads))
+            return result.failed("Failed to allocate memory for the available threads!");
+        for (std::size_t i = 0; i < max_threads; i++)
+            available_threads.push(i);
+        available_threads_ = std::move(available_threads);
 
         reindex_keys_();
         return result;
@@ -977,6 +1195,7 @@ class index_dense_gt {
                                 progress_at&& progress = {}) {
 
         // Discard all previous memory allocations of `vectors_tape_allocator_`
+        index_limits_t old_limits = typed_ ? typed_->limits() : index_limits_t{};
         reset();
 
         serialization_result_t result = file.open_if_not();
@@ -1024,6 +1243,9 @@ class index_dense_gt {
             if (std::memcmp(buffer, default_magic(), std::strlen(default_magic())) != 0)
                 return result.failed("Magic header mismatch - the file isn't an index");
 
+            // fix pre-2.10 headers
+            fix_pre_2_10_metadata(head);
+
             // Validate the software version
             if (head.version_major != USEARCH_VERSION_MAJOR)
                 return result.failed("File format may be different, please rebuild");
@@ -1036,24 +1258,48 @@ class index_dense_gt {
 
             config_.multi = head.multi;
             metric_ = metric_t::builtin(head.dimensions, head.kind_metric, head.kind_scalar);
-            cast_buffer_.resize(available_threads_.size() * metric_.bytes_per_vector());
+            cast_buffer_ = cast_buffer_t(available_threads_.size() * metric_.bytes_per_vector());
+            if (!cast_buffer_)
+                return result.failed("Failed to allocate memory for the casts");
             casts_ = make_casts_(head.kind_scalar);
             offset += sizeof(buffer);
         }
 
         // Pull the actual proximity graph
+        if (!typed_) {
+            index_t* raw = index_allocator_t{}.allocate(1);
+            if (!raw)
+                return result.failed("Failed to allocate memory for the index");
+            new (raw) index_t(config_);
+            typed_ = raw;
+        }
         result = typed_->view(std::move(file), offset, std::forward<progress_at>(progress));
         if (!result)
             return result;
         if (typed_->size() != static_cast<std::size_t>(matrix_rows))
             return result.failed("Index size and the number of vectors doesn't match");
+        old_limits.members = static_cast<std::size_t>(matrix_rows);
+        if (!typed_->try_reserve(old_limits))
+            return result.failed("Failed to reserve memory for the index");
 
         // Address the vectors
-        vectors_lookup_.resize(matrix_rows);
+        vectors_lookup_ = vectors_lookup_t(matrix_rows);
+        if (!vectors_lookup_)
+            return result.failed("Failed to allocate memory to address vectors");
         if (!config.exclude_vectors)
             for (std::uint64_t slot = 0; slot != matrix_rows; ++slot)
                 vectors_lookup_[slot] = (byte_t*)vectors_buffer.data() + matrix_cols * slot;
 
+        // After the index is loaded, we may have to resize the `available_threads_` to
+        // match the limits of the underlying engine.
+        available_threads_t available_threads;
+        std::size_t max_threads = old_limits.threads();
+        if (!available_threads.reserve(max_threads))
+            return result.failed("Failed to allocate memory for the available threads!");
+        for (std::size_t i = 0; i < max_threads; i++)
+            available_threads.push(i);
+        available_threads_ = std::move(available_threads);
+
         reindex_keys_();
         return result;
     }
@@ -1186,6 +1432,7 @@ class index_dense_gt {
      *  @return `true` if the key is present in the index, `false` otherwise.
      */
     bool contains(vector_key_t key) const {
+        usearch_assert_m(config().enable_key_lookups, "Key lookups are disabled");
         shared_lock_t lock(slot_lookup_mutex_);
         return slot_lookup_.contains(key_and_slot_t::any_slot(key));
     }
@@ -1195,6 +1442,7 @@ class index_dense_gt {
      *  @return Zero if nothing is found, a positive integer otherwise.
      */
     std::size_t count(vector_key_t key) const {
+        usearch_assert_m(config().enable_key_lookups, "Key lookups are disabled");
         shared_lock_t lock(slot_lookup_mutex_);
         return slot_lookup_.count(key_and_slot_t::any_slot(key));
     }
@@ -1219,6 +1467,7 @@ class index_dense_gt {
      *          If an error occurred during the removal operation, `result.error` will contain an error message.
      */
     labeling_result_t remove(vector_key_t key) {
+        usearch_assert_m(config().enable_key_lookups, "Key lookups are disabled");
         labeling_result_t result;
 
         unique_lock_t lookup_lock(slot_lookup_mutex_);
@@ -1229,7 +1478,8 @@ class index_dense_gt {
         // Grow the removed entries ring, if needed
         std::size_t matching_count = std::distance(matching_slots.first, matching_slots.second);
         std::unique_lock<std::mutex> free_lock(free_keys_mutex_);
-        if (!free_keys_.reserve(free_keys_.size() + matching_count))
+        std::size_t free_count_old = free_keys_.size();
+        if (!free_keys_.reserve(free_count_old + matching_count))
             return result.failed("Can't allocate memory for a free-list");
 
         // A removed entry would be:
@@ -1243,6 +1493,7 @@ class index_dense_gt {
         }
         slot_lookup_.erase(key);
         result.completed = matching_count;
+        usearch_assert_m(free_keys_.size() == free_count_old + matching_count, "Free keys count mismatch");
 
         return result;
     }
@@ -1257,6 +1508,7 @@ class index_dense_gt {
      */
     template <typename keys_iterator_at>
     labeling_result_t remove(keys_iterator_at keys_begin, keys_iterator_at keys_end) {
+        usearch_assert_m(config().enable_key_lookups, "Key lookups are disabled");
 
         labeling_result_t result;
         unique_lock_t lookup_lock(slot_lookup_mutex_);
@@ -1343,17 +1595,6 @@ class index_dense_gt {
         });
     }
 
-    struct copy_result_t {
-        index_dense_gt index;
-        error_t error;
-
-        explicit operator bool() const noexcept { return !error; }
-        copy_result_t failed(error_t message) noexcept {
-            error = std::move(message);
-            return std::move(*this);
-        }
-    };
-
     /**
      *  @brief Copies the ::index_dense_gt @b with all the data in it.
      *  @param config The copy configuration (optional).
@@ -1376,19 +1617,22 @@ class index_dense_gt {
             copy.free_keys_.push(free_keys_[i]);
 
         // Allocate buffers and move the vectors themselves
-        if (!config.force_vector_copy && copy.config_.exclude_vectors)
-            copy.vectors_lookup_ = vectors_lookup_;
-        else {
-            copy.vectors_lookup_.resize(vectors_lookup_.size());
-            for (std::size_t slot = 0; slot != vectors_lookup_.size(); ++slot)
+        copy.vectors_lookup_ = vectors_lookup_t(vectors_lookup_.size());
+        if (!copy.vectors_lookup_)
+            return result.failed("Out of memory!");
+        if (!config.force_vector_copy && copy.config_.exclude_vectors) {
+            std::memcpy(copy.vectors_lookup_.data(), vectors_lookup_.data(), vectors_lookup_.size() * sizeof(byte_t*));
+        } else {
+            std::size_t slots_count = typed_result.index.size();
+            for (std::size_t slot = 0; slot != slots_count; ++slot)
                 copy.vectors_lookup_[slot] = copy.vectors_tape_allocator_.allocate(copy.metric_.bytes_per_vector());
-            if (std::count(copy.vectors_lookup_.begin(), copy.vectors_lookup_.end(), nullptr))
+            if (std::count(copy.vectors_lookup_.begin(), copy.vectors_lookup_.begin() + slots_count, nullptr))
                 return result.failed("Out of memory!");
-            for (std::size_t slot = 0; slot != vectors_lookup_.size(); ++slot)
+            for (std::size_t slot = 0; slot != slots_count; ++slot)
                 std::memcpy(copy.vectors_lookup_[slot], vectors_lookup_[slot], metric_.bytes_per_vector());
         }
 
-        copy.slot_lookup_ = slot_lookup_;
+        copy.slot_lookup_ = slot_lookup_; // TODO: Handle out of memory
         *copy.typed_ = std::move(typed_result.index);
         return result;
     }
@@ -1398,22 +1642,34 @@ class index_dense_gt {
      *  @return A similarly configured ::index_dense_gt instance.
      */
     copy_result_t fork() const {
+
+        cast_buffer_t cast_buffer(cast_buffer_.size());
+        if (!cast_buffer)
+            return state_result_t{}.failed("Failed to allocate memory for the casts!");
+        available_threads_t available_threads;
+        std::size_t max_threads = limits().threads();
+        if (!available_threads.reserve(max_threads))
+            return state_result_t{}.failed("Failed to allocate memory for the available threads!");
+        for (std::size_t i = 0; i < max_threads; i++)
+            available_threads.push(i);
+        index_t* raw = index_allocator_t{}.allocate(1);
+        if (!raw)
+            return state_result_t{}.failed("Failed to allocate memory for the index!");
+
         copy_result_t result;
         index_dense_gt& other = result.index;
-
+        index_limits_t other_limits = limits();
+        other_limits.members = 0;
         other.config_ = config_;
-        other.cast_buffer_ = cast_buffer_;
+        other.cast_buffer_ = std::move(cast_buffer);
         other.casts_ = casts_;
 
         other.metric_ = metric_;
-        other.available_threads_ = available_threads_;
+        other.available_threads_ = std::move(available_threads);
         other.free_key_ = free_key_;
 
-        index_t* raw = index_allocator_t{}.allocate(1);
-        if (!raw)
-            return result.failed("Can't allocate the index");
-
         new (raw) index_t(config());
+        raw->try_reserve(other_limits);
         other.typed_ = raw;
         return result;
     }
@@ -1472,7 +1728,10 @@ class index_dense_gt {
     compaction_result_t compact(executor_at&& executor = executor_at{}, progress_at&& progress = progress_at{}) {
         compaction_result_t result;
 
-        std::vector<byte_t*> new_vectors_lookup(vectors_lookup_.size());
+        vectors_lookup_t new_vectors_lookup(vectors_lookup_.size());
+        if (!new_vectors_lookup)
+            return result.failed("Out of memory!");
+
         vectors_tape_allocator_t new_vectors_allocator;
 
         auto track_slot_change = [&](vector_key_t, compressed_slot_t old_slot, compressed_slot_t new_slot) {
@@ -1709,31 +1968,21 @@ class index_dense_gt {
     }
 
   private:
-    struct thread_lock_t {
-        index_dense_gt const& parent;
-        std::size_t thread_id;
-        bool engaged;
-
-        ~thread_lock_t() {
-            if (engaged)
-                parent.thread_unlock_(thread_id);
-        }
-    };
-
-    thread_lock_t thread_lock_(std::size_t thread_id) const {
+    thread_lock_t thread_lock_(std::size_t thread_id) const usearch_noexcept_m {
         if (thread_id != any_thread())
             return {*this, thread_id, false};
 
         available_threads_mutex_.lock();
-        thread_id = available_threads_.back();
-        available_threads_.pop_back();
+        usearch_assert_m(available_threads_.size(), "No available threads to lock");
+        available_threads_.try_pop(thread_id);
         available_threads_mutex_.unlock();
         return {*this, thread_id, true};
     }
 
-    void thread_unlock_(std::size_t thread_id) const {
+    void thread_unlock_(std::size_t thread_id) const usearch_noexcept_m {
         available_threads_mutex_.lock();
-        available_threads_.push_back(thread_id);
+        usearch_assert_m(available_threads_.size() < available_threads_.capacity(), "Too many threads unlocked");
+        available_threads_.push(thread_id);
         available_threads_mutex_.unlock();
     }
 
@@ -1742,7 +1991,7 @@ class index_dense_gt {
         vector_key_t key, scalar_at const* vector, //
         std::size_t thread, bool force_vector_copy, cast_t const& cast) {
 
-        if (!multi() && contains(key))
+        if (!multi() && config().enable_key_lookups && contains(key))
             return add_result_t{}.failed("Duplicate keys not allowed in high-level wrappers");
 
         // Cast the vector, if needed for compatibility with `metric_`
@@ -1766,8 +2015,10 @@ class index_dense_gt {
         // Perform the insertion or the update
         bool reuse_node = free_slot != default_free_value<compressed_slot_t>();
         auto on_success = [&](member_ref_t member) {
-            unique_lock_t slot_lock(slot_lookup_mutex_);
-            slot_lookup_.try_emplace(key_and_slot_t{key, static_cast<compressed_slot_t>(member.slot)});
+            if (config_.enable_key_lookups) {
+                unique_lock_t slot_lock(slot_lookup_mutex_);
+                slot_lookup_.try_emplace(key_and_slot_t{key, static_cast<compressed_slot_t>(member.slot)});
+            }
             if (copy_vector) {
                 if (!reuse_node)
                     vectors_lookup_[member.slot] = vectors_tape_allocator_.allocate(metric_.bytes_per_vector());
@@ -1805,16 +2056,19 @@ class index_dense_gt {
         search_config.expansion = config_.expansion_search;
         search_config.exact = exact;
 
+        vector_key_t free_key_copy = free_key_;
         if (std::is_same<typename std::decay<predicate_at>::type, dummy_predicate_t>::value) {
-            auto allow = [free_key_ = this->free_key_](member_cref_t const& member) noexcept {
-                return member.key != free_key_;
+            auto allow = [free_key_copy](member_cref_t const& member) noexcept {
+                return (vector_key_t)member.key != free_key_copy;
             };
-            return typed_->search(vector_data, wanted, metric_proxy_t{*this}, search_config, allow);
+            auto typed_result = typed_->search(vector_data, wanted, metric_proxy_t{*this}, search_config, allow);
+            return search_result_t{std::move(typed_result), std::move(lock)};
         } else {
-            auto allow = [free_key_ = this->free_key_, &predicate](member_cref_t const& member) noexcept {
-                return member.key != free_key_ && predicate(member.key);
+            auto allow = [free_key_copy, &predicate](member_cref_t const& member) noexcept {
+                return (vector_key_t)member.key != free_key_copy && predicate(member.key);
             };
-            return typed_->search(vector_data, wanted, metric_proxy_t{*this}, search_config, allow);
+            auto typed_result = typed_->search(vector_data, wanted, metric_proxy_t{*this}, search_config, allow);
+            return search_result_t{std::move(typed_result), std::move(lock)};
         }
     }
 
@@ -1837,9 +2091,8 @@ class index_dense_gt {
         cluster_config.thread = lock.thread_id;
         cluster_config.expansion = config_.expansion_search;
 
-        auto allow = [free_key_ = this->free_key_](member_cref_t const& member) noexcept {
-            return member.key != free_key_;
-        };
+        vector_key_t free_key_copy = free_key_;
+        auto allow = [free_key_copy](member_cref_t const& member) noexcept { return member.key != free_key_copy; };
         return typed_->cluster(vector_data, level, metric_proxy_t{*this}, cluster_config, allow);
     }
 
@@ -1859,6 +2112,7 @@ class index_dense_gt {
         }
 
         // Check if such `key` is even present.
+        usearch_assert_m(config().enable_key_lookups, "Key lookups are disabled!");
         shared_lock_t slots_lock(slot_lookup_mutex_);
         auto key_range = slot_lookup_.equal_range(key_and_slot_t::any_slot(key));
         aggregated_distances_t result;
@@ -1895,7 +2149,8 @@ class index_dense_gt {
         std::size_t count_total = typed_->size();
         std::size_t count_removed = 0;
         for (std::size_t i = 0; i != count_total; ++i) {
-            member_cref_t member = typed_->at(i);
+            auto member_slot = static_cast<compressed_slot_t>(i);
+            member_cref_t member = typed_->at(member_slot);
             count_removed += member.key == free_key_;
         }
 
@@ -1911,11 +2166,12 @@ class index_dense_gt {
         free_keys_.clear();
         free_keys_.reserve(count_removed);
         for (std::size_t i = 0; i != typed_->size(); ++i) {
-            member_cref_t member = typed_->at(i);
+            auto member_slot = static_cast<compressed_slot_t>(i);
+            member_cref_t member = typed_->at(member_slot);
             if (member.key == free_key_)
-                free_keys_.push(static_cast<compressed_slot_t>(i));
+                free_keys_.push(member_slot);
             else if (config_.enable_key_lookups)
-                slot_lookup_.try_emplace(key_and_slot_t{vector_key_t(member.key), static_cast<compressed_slot_t>(i)});
+                slot_lookup_.try_emplace(key_and_slot_t{vector_key_t(member.key), member_slot});
         }
     }
 
@@ -1959,17 +2215,17 @@ class index_dense_gt {
     template <typename to_scalar_at> static casts_t make_casts_() {
         casts_t result;
 
-        result.from_b1x8 = cast_gt<b1x8_t, to_scalar_at>{};
-        result.from_i8 = cast_gt<i8_t, to_scalar_at>{};
-        result.from_f16 = cast_gt<f16_t, to_scalar_at>{};
-        result.from_f32 = cast_gt<f32_t, to_scalar_at>{};
-        result.from_f64 = cast_gt<f64_t, to_scalar_at>{};
+        result.from_b1x8 = &cast_gt<b1x8_t, to_scalar_at>::try_;
+        result.from_i8 = &cast_gt<i8_t, to_scalar_at>::try_;
+        result.from_f16 = &cast_gt<f16_t, to_scalar_at>::try_;
+        result.from_f32 = &cast_gt<f32_t, to_scalar_at>::try_;
+        result.from_f64 = &cast_gt<f64_t, to_scalar_at>::try_;
 
-        result.to_b1x8 = cast_gt<to_scalar_at, b1x8_t>{};
-        result.to_i8 = cast_gt<to_scalar_at, i8_t>{};
-        result.to_f16 = cast_gt<to_scalar_at, f16_t>{};
-        result.to_f32 = cast_gt<to_scalar_at, f32_t>{};
-        result.to_f64 = cast_gt<to_scalar_at, f64_t>{};
+        result.to_b1x8 = &cast_gt<to_scalar_at, b1x8_t>::try_;
+        result.to_i8 = &cast_gt<to_scalar_at, i8_t>::try_;
+        result.to_f16 = &cast_gt<to_scalar_at, f16_t>::try_;
+        result.to_f32 = &cast_gt<to_scalar_at, f32_t>::try_;
+        result.to_f64 = &cast_gt<to_scalar_at, f64_t>::try_;
 
         return result;
     }
@@ -2019,7 +2275,7 @@ static join_result_t join(                                    //
     man_to_woman_at&& man_to_woman = man_to_woman_at{}, //
     woman_to_man_at&& woman_to_man = woman_to_man_at{}, //
     executor_at&& executor = executor_at{},             //
-    progress_at&& progress = progress_at{}) noexcept {
+    progress_at&& progress = progress_at{}) {
 
     return men.join(                                 //
         women, config,                               //
diff --git a/include/usearch/index_plugins.hpp b/include/usearch/index_plugins.hpp
index 1ae5fe95..2d22e919 100644
--- a/include/usearch/index_plugins.hpp
+++ b/include/usearch/index_plugins.hpp
@@ -3,13 +3,9 @@
 #include <float.h>  // `_Float16`
 #include <stdlib.h> // `aligned_alloc`
 
+#include <atomic>  // `std::atomic`
 #include <cstring> // `std::strncmp`
-#include <numeric> // `std::iota`
 #include <thread>  // `std::thread`
-#include <vector>  // `std::vector`
-
-#include <atomic> // `std::atomic`
-#include <thread> // `std::thread`
 
 #include <usearch/index.hpp> // `expected_gt` and macros
 
@@ -49,6 +45,9 @@
 #if !defined(SIMSIMD_NATIVE_F16)
 #define SIMSIMD_NATIVE_F16 !USEARCH_USE_FP16LIB
 #endif
+
+// Overwrite the dynamic dispatch settings
+#undef SIMSIMD_DYNAMIC_DISPATCH
 #define SIMSIMD_DYNAMIC_DISPATCH 0
 // No problem, if some of the functions are unused or undefined
 #pragma GCC diagnostic push
@@ -335,10 +334,13 @@ class f16_bits_t {
     inline explicit operator bool() const noexcept { return f16_to_f32(uint16_) > 0.5f; }
 
     inline f16_bits_t(i8_converted_t) noexcept;
+    inline f16_bits_t(std::int8_t v) noexcept : uint16_(v) {}
     inline f16_bits_t(bool v) noexcept : uint16_(f32_to_f16(v)) {}
     inline f16_bits_t(float v) noexcept : uint16_(f32_to_f16(v)) {}
     inline f16_bits_t(double v) noexcept : uint16_(f32_to_f16(static_cast<float>(v))) {}
 
+    inline bool operator<(const f16_bits_t& other) const noexcept { return float(*this) < float(other); }
+
     inline f16_bits_t operator+(f16_bits_t other) const noexcept { return {float(*this) + float(other)}; }
     inline f16_bits_t operator-(f16_bits_t other) const noexcept { return {float(*this) - float(other)}; }
     inline f16_bits_t operator*(f16_bits_t other) const noexcept { return {float(*this) * float(other)}; }
@@ -382,14 +384,16 @@ class executor_stl_t {
 
     struct jthread_t {
         std::thread native_;
+        bool initialized_ = false;
 
         jthread_t() = default;
         jthread_t(jthread_t&&) = default;
         jthread_t(jthread_t const&) = delete;
-        template <typename callable_at> jthread_t(callable_at&& func) : native_([=]() { func(); }) {}
+        template <typename callable_at>
+        jthread_t(callable_at&& func) : native_([=]() { func(); }), initialized_(true) {}
 
         ~jthread_t() {
-            if (native_.joinable())
+            if (initialized_ && native_.joinable())
                 native_.join();
         }
     };
@@ -414,13 +418,13 @@ class executor_stl_t {
      */
     template <typename thread_aware_function_at>
     void fixed(std::size_t tasks, thread_aware_function_at&& thread_aware_function) noexcept(false) {
-        std::vector<jthread_t> threads_pool;
+        buffer_gt<jthread_t> threads_pool(threads_count_ - 1); // Allocate space for threads minus the main thread
         std::size_t tasks_per_thread = tasks;
         std::size_t threads_count = (std::min)(threads_count_, tasks);
         if (threads_count > 1) {
             tasks_per_thread = (tasks / threads_count) + ((tasks % threads_count) != 0);
             for (std::size_t thread_idx = 1; thread_idx < threads_count; ++thread_idx) {
-                threads_pool.emplace_back([=]() {
+                new (&threads_pool[thread_idx - 1]) jthread_t([=]() {
                     for (std::size_t task_idx = thread_idx * tasks_per_thread;
                          task_idx < (std::min)(tasks, thread_idx * tasks_per_thread + tasks_per_thread); ++task_idx)
                         thread_aware_function(thread_idx, task_idx);
@@ -439,14 +443,14 @@ class executor_stl_t {
      */
     template <typename thread_aware_function_at>
     void dynamic(std::size_t tasks, thread_aware_function_at&& thread_aware_function) noexcept(false) {
-        std::vector<jthread_t> threads_pool;
+        buffer_gt<jthread_t> threads_pool(threads_count_ - 1);
         std::size_t tasks_per_thread = tasks;
         std::size_t threads_count = (std::min)(threads_count_, tasks);
         std::atomic_bool stop{false};
         if (threads_count > 1) {
             tasks_per_thread = (tasks / threads_count) + ((tasks % threads_count) != 0);
             for (std::size_t thread_idx = 1; thread_idx < threads_count; ++thread_idx) {
-                threads_pool.emplace_back([=, &stop]() {
+                new (&threads_pool[thread_idx - 1]) jthread_t([=, &stop]() {
                     for (std::size_t task_idx = thread_idx * tasks_per_thread;
                          task_idx < (std::min)(tasks, thread_idx * tasks_per_thread + tasks_per_thread) &&
                          !stop.load(std::memory_order_relaxed);
@@ -471,9 +475,9 @@ class executor_stl_t {
     void parallel(thread_aware_function_at&& thread_aware_function) noexcept(false) {
         if (threads_count_ == 1)
             return thread_aware_function(0);
-        std::vector<jthread_t> threads_pool;
+        buffer_gt<jthread_t> threads_pool(threads_count_ - 1);
         for (std::size_t thread_idx = 1; thread_idx < threads_count_; ++thread_idx)
-            threads_pool.emplace_back([=]() { thread_aware_function(thread_idx); });
+            new (&threads_pool[thread_idx - 1]) jthread_t([=]() { thread_aware_function(thread_idx); });
         thread_aware_function(0);
     }
 };
@@ -561,7 +565,8 @@ using executor_default_t = executor_stl_t;
 #endif
 
 /**
- *  @brief Uses OS-specific APIs for aligned memory allocations.
+ *  @brief  Uses OS-specific APIs for aligned memory allocations.
+ *          Available since C11, but only C++17, so we wrap the C version.
  */
 template <typename element_at = char, std::size_t alignment_ak = 64> //
 class aligned_allocator_gt {
@@ -578,12 +583,18 @@ class aligned_allocator_gt {
 
     pointer allocate(size_type length) const {
         std::size_t length_bytes = alignment_ak * divide_round_up<alignment_ak>(length * sizeof(value_type));
+        // Avoid overflow
+        if (length > length_bytes)
+            return nullptr;
         std::size_t alignment = alignment_ak;
-        // void* result = nullptr;
-        // int status = posix_memalign(&result, alignment, length_bytes);
-        // return status == 0 ? (pointer)result : nullptr;
 #if defined(USEARCH_DEFINED_WINDOWS)
         return (pointer)_aligned_malloc(length_bytes, alignment);
+#elif defined(USEARCH_DEFINED_APPLE)
+        // Apple Clang keeps complaining that `aligned_alloc` is only available
+        // with macOS 10.15 and newer, so let's use `posix_memalign` there.
+        void* result = nullptr;
+        int status = posix_memalign(&result, alignment, length_bytes);
+        return status == 0 ? (pointer)result : nullptr;
 #else
         return (pointer)aligned_alloc(alignment, length_bytes);
 #endif
@@ -600,6 +611,10 @@ class aligned_allocator_gt {
 
 using aligned_allocator_t = aligned_allocator_gt<>;
 
+/**
+ *  @brief  A simple RAM-page allocator that uses the OS-specific APIs for memory allocation.
+ *          Shouldn't be used frequently, as system calls are slow.
+ */
 class page_allocator_t {
   public:
     static constexpr std::size_t page_size() { return 4096; }
@@ -863,7 +878,7 @@ template <typename mutex_at = unfair_shared_mutex_t> class shared_lock_gt {
  *          avoiding unnecessary conversions.
  */
 template <typename from_scalar_at, typename to_scalar_at> struct cast_gt {
-    inline bool operator()(byte_t const* input, std::size_t dim, byte_t* output) const {
+    static bool try_(byte_t const* input, std::size_t dim, byte_t* output) noexcept {
         from_scalar_at const* typed_input = reinterpret_cast<from_scalar_at const*>(input);
         to_scalar_at* typed_output = reinterpret_cast<to_scalar_at*>(output);
         auto converter = [](from_scalar_at from) { return to_scalar_at(from); };
@@ -873,29 +888,30 @@ template <typename from_scalar_at, typename to_scalar_at> struct cast_gt {
 };
 
 template <> struct cast_gt<f32_t, f32_t> {
-    bool operator()(byte_t const*, std::size_t, byte_t*) const { return false; }
+    static bool try_(byte_t const*, std::size_t, byte_t*) noexcept { return false; }
 };
 
 template <> struct cast_gt<f64_t, f64_t> {
-    bool operator()(byte_t const*, std::size_t, byte_t*) const { return false; }
+    static bool try_(byte_t const*, std::size_t, byte_t*) noexcept { return false; }
 };
 
 template <> struct cast_gt<f16_bits_t, f16_bits_t> {
-    bool operator()(byte_t const*, std::size_t, byte_t*) const { return false; }
+    static bool try_(byte_t const*, std::size_t, byte_t*) noexcept { return false; }
 };
 
 template <> struct cast_gt<i8_t, i8_t> {
-    bool operator()(byte_t const*, std::size_t, byte_t*) const { return false; }
+    static bool try_(byte_t const*, std::size_t, byte_t*) noexcept { return false; }
 };
 
 template <> struct cast_gt<b1x8_t, b1x8_t> {
-    bool operator()(byte_t const*, std::size_t, byte_t*) const { return false; }
+    static bool try_(byte_t const*, std::size_t, byte_t*) noexcept { return false; }
 };
 
 template <typename from_scalar_at> struct cast_gt<from_scalar_at, b1x8_t> {
-    inline bool operator()(byte_t const* input, std::size_t dim, byte_t* output) const {
+    inline static bool try_(byte_t const* input, std::size_t dim, byte_t* output) noexcept {
         from_scalar_at const* typed_input = reinterpret_cast<from_scalar_at const*>(input);
         unsigned char* typed_output = reinterpret_cast<unsigned char*>(output);
+        std::memset(typed_output, 0, dim / CHAR_BIT);
         for (std::size_t i = 0; i != dim; ++i)
             // Converting from scalar types to boolean isn't trivial and depends on the type.
             // The most common case is to consider all positive values as `true` and all others as `false`.
@@ -913,7 +929,7 @@ template <typename from_scalar_at> struct cast_gt<from_scalar_at, b1x8_t> {
 };
 
 template <typename to_scalar_at> struct cast_gt<b1x8_t, to_scalar_at> {
-    inline bool operator()(byte_t const* input, std::size_t dim, byte_t* output) const {
+    static bool try_(byte_t const* input, std::size_t dim, byte_t* output) noexcept {
         unsigned char const* typed_input = reinterpret_cast<unsigned char const*>(input);
         to_scalar_at* typed_output = reinterpret_cast<to_scalar_at*>(output);
         for (std::size_t i = 0; i != dim; ++i)
@@ -953,12 +969,13 @@ class i8_converted_t {
     inline explicit operator std::int32_t() const noexcept { return int8_; }
     inline explicit operator std::int64_t() const noexcept { return int8_; }
 
+    // Even with `f16_t` arguments we may want to use `f32_t` for clamping and comparions.
     inline i8_converted_t(f16_t v)
-        : int8_(usearch::clamp<std::int8_t>(static_cast<std::int8_t>(v * divisor_k), min_k, max_k)) {}
+        : int8_(static_cast<std::int8_t>(usearch::clamp<f32_t>(v * divisor_k, min_k, max_k))) {}
     inline i8_converted_t(f32_t v)
-        : int8_(usearch::clamp<std::int8_t>(static_cast<std::int8_t>(v * divisor_k), min_k, max_k)) {}
+        : int8_(static_cast<std::int8_t>(usearch::clamp<f32_t>(v * divisor_k, min_k, max_k))) {}
     inline i8_converted_t(f64_t v)
-        : int8_(usearch::clamp<std::int8_t>(static_cast<std::int8_t>(v * divisor_k), min_k, max_k)) {}
+        : int8_(static_cast<std::int8_t>(usearch::clamp<f64_t>(v * divisor_k, min_k, max_k))) {}
 };
 
 f16_bits_t::f16_bits_t(i8_converted_t v) noexcept : uint16_(f32_to_f16(v)) {}
@@ -971,6 +988,16 @@ template <> struct cast_gt<f16_t, i8_t> : public cast_gt<f16_t, i8_converted_t>
 template <> struct cast_gt<f32_t, i8_t> : public cast_gt<f32_t, i8_converted_t> {};
 template <> struct cast_gt<f64_t, i8_t> : public cast_gt<f64_t, i8_converted_t> {};
 
+/*  Don't complain if the vectorization of the inner loops fails:
+ *
+ *  > warning: loop not vectorized: the optimizer was unable to perform the requested transformation;
+ *  > the transformation might be disabled or specified as part of an unsupported transformation ordering
+ */
+#if defined(__clang__)
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wpass-failed"
+#endif
+
 /**
  *  @brief  Inner (Dot) Product distance.
  */
@@ -1351,9 +1378,9 @@ class metric_punned_t {
     /// Distance function that takes two arrays and some callback state and returns a scalar.
     using metric_array_array_state_t = result_t (*)(uptr_t, uptr_t, uptr_t);
     /// Distance function callback, like `metric_array_array_size_t`, but depends on member variables.
-    using metric_rounted_t = result_t (metric_punned_t::*)(uptr_t, uptr_t) const;
+    using metric_routed_t = result_t (metric_punned_t::*)(uptr_t, uptr_t) const;
 
-    metric_rounted_t metric_routed_ = nullptr;
+    metric_routed_t metric_routed_ = nullptr;
     uptr_t metric_ptr_ = 0;
     uptr_t metric_third_arg_ = 0;
 
@@ -1447,7 +1474,7 @@ class metric_punned_t {
     }
 
     /**
-     *  @brief  Creates a metric using the provided function pointer for a statefull metric.
+     *  @brief  Creates a metric using the provided function pointer for a stateful metric.
      *          The third argument is the state that will be passed to the metric function.
      *
      *  @param  metric_uintptr  The function pointer to the metric function.
@@ -1456,9 +1483,9 @@ class metric_punned_t {
      *  @param  scalar_kind     The kind of scalar to use.
      *  @return                 A metric object that can be used to compute distances between vectors.
      */
-    inline static metric_punned_t statefull(std::uintptr_t metric_uintptr, std::uintptr_t metric_state,
-                                            metric_kind_t metric_kind = metric_kind_t::unknown_k,
-                                            scalar_kind_t scalar_kind = scalar_kind_t::unknown_k) noexcept {
+    inline static metric_punned_t stateful(std::uintptr_t metric_uintptr, std::uintptr_t metric_state,
+                                           metric_kind_t metric_kind = metric_kind_t::unknown_k,
+                                           scalar_kind_t scalar_kind = scalar_kind_t::unknown_k) noexcept {
         metric_punned_t metric;
         metric.metric_routed_ = &metric_punned_t::invoke_array_array_third;
         metric.metric_ptr_ = metric_uintptr;
@@ -1475,7 +1502,7 @@ class metric_punned_t {
     inline explicit operator bool() const noexcept { return metric_routed_ && metric_ptr_; }
 
     /**
-     *  @brief  Checks fi we've failed to initialized the metric with provided arguments.
+     *  @brief  Checks if we've failed to initialize the metric with provided arguments.
      *
      *  It's different from `operator bool()` when it comes to explicitly uninitialized metrics.
      *  It's a common case, where a NULL state is created only to be overwritten later, when
@@ -1491,7 +1518,13 @@ class metric_punned_t {
         switch (isa_kind_) {
         case simsimd_cap_serial_k: return "serial";
         case simsimd_cap_neon_k: return "neon";
+        case simsimd_cap_neon_i8_k: return "neon_i8";
+        case simsimd_cap_neon_f16_k: return "neon_f16";
+        case simsimd_cap_neon_bf16_k: return "neon_bf16";
         case simsimd_cap_sve_k: return "sve";
+        case simsimd_cap_sve_i8_k: return "sve_i8";
+        case simsimd_cap_sve_f16_k: return "sve_f16";
+        case simsimd_cap_sve_bf16_k: return "sve_bf16";
         case simsimd_cap_haswell_k: return "haswell";
         case simsimd_cap_skylake_k: return "skylake";
         case simsimd_cap_ice_k: return "ice";
@@ -1541,8 +1574,8 @@ class metric_punned_t {
 
         std::memcpy(&metric_ptr_, &simd_metric, sizeof(simd_metric));
         metric_routed_ = metric_kind_ == metric_kind_t::ip_k
-                             ? reinterpret_cast<metric_rounted_t>(&metric_punned_t::invoke_simsimd_reverse)
-                             : reinterpret_cast<metric_rounted_t>(&metric_punned_t::invoke_simsimd);
+                             ? reinterpret_cast<metric_routed_t>(&metric_punned_t::invoke_simsimd_reverse)
+                             : reinterpret_cast<metric_routed_t>(&metric_punned_t::invoke_simsimd);
         isa_kind_ = simd_kind;
         return true;
     }
@@ -1550,9 +1583,14 @@ class metric_punned_t {
         static simsimd_capability_t static_capabilities = simsimd_capabilities();
         return configure_with_simsimd(static_capabilities);
     }
-    result_t invoke_simsimd(uptr_t a, uptr_t b) const noexcept {
+
+#if defined(USEARCH_DEFINED_CLANG) || defined(USEARCH_DEFINED_GCC)
+    __attribute__((no_sanitize("all")))
+#endif
+    result_t
+    invoke_simsimd(uptr_t a, uptr_t b) const noexcept {
         simsimd_distance_t result;
-        // Here `reinterpret_cast` raises warning... we know what we are doing!
+        // Here `reinterpret_cast` raises warning and UBSan reports an issue... we know what we are doing!
         auto function_pointer = (simsimd_metric_punned_t)(metric_ptr_);
         function_pointer(reinterpret_cast<void const*>(a), reinterpret_cast<void const*>(b), metric_third_arg_,
                          &result);
@@ -1649,6 +1687,11 @@ class metric_punned_t {
     }
 };
 
+/* Allow complaining about vectorization after this point. */
+#if defined(__clang__)
+#pragma clang diagnostic pop
+#endif
+
 /**
  *  @brief  View over a potentially-strided memory buffer, containing a row-major matrix.
  */
@@ -1959,6 +2002,7 @@ class flat_hash_multi_set_gt {
         clear(); // Clear all elements
         if (data_)
             allocator_t{}.deallocate(data_, buckets_ * bytes_per_bucket());
+        data_ = nullptr;
         buckets_ = 0;
         populated_slots_ = 0;
         capacity_slots_ = 0;
diff --git a/java/README.md b/java/README.md
index e03e0225..e843acf6 100644
--- a/java/README.md
+++ b/java/README.md
@@ -6,7 +6,7 @@
 <dependency>
   <groupId>cloud.unum</groupId>
   <artifactId>usearch</artifactId>
-  <version>2.8.11</version>
+  <version>2.13.0</version>
 </dependency>
 ```
 
@@ -15,8 +15,59 @@ Add that snippet to your `pom.xml` and hit `mvn install`.
 ## Quickstart
 
 ```java
-Index index = new Index.Config().metric("cos").dimensions(2).build();
-float vec[] = {10, 20};
-index.add(42, vec);
-int[] keys = index.search(vec, 5);
+import cloud.unum.usearch.Index;
+
+public class Main {
+    public static void main(String[] args) {
+        try (Index index = new Index.Config()
+                .metric("cos")
+                .quantization("f32")
+                .dimensions(3)
+                .capacity(100)
+                .build()) {
+            
+            // Add to Index
+            float[] vector = {0.1f, 0.2f, 0.3f};
+            index.add(42, vector);
+
+            // Search
+            int[] keys = index.search(new float[]{0.1f, 0.2f, 0.3f}, 10);
+            for (int key : keys) {
+                System.out.println("Found key: " + key);
+            }
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+}
+```
+
+## Serialization
+
+To save and load the index from disk, use the following methods:
+
+```java
+index.save("index.usearch");
+index.load("index.usearch");
+index.view("index.usearch");
+```
+
+## Extracting, Updating, and Removing Values
+
+It is generally not recommended to use HNSW indexes in case of frequent removals or major distribution shifts.
+For small updates, you can use the following methods:
+
+```java
+float[] vector = index.get(42);
+boolean removed = index.remove(42);
+boolean renamed = index.rename(43, 42);
+```
+
+To obtain metadata:
+
+```java
+long size = index.size();
+long capacity = index.capacity();
+long dimensions = index.dimensions();
+long connectivity = index.connectivity();
 ```
diff --git a/java/cloud/unum/usearch/Index.java b/java/cloud/unum/usearch/Index.java
index 30733030..c7b3519e 100644
--- a/java/cloud/unum/usearch/Index.java
+++ b/java/cloud/unum/usearch/Index.java
@@ -1,4 +1,3 @@
-
 /**
  * Java bindings for Unum USearch vector search library.
  */
@@ -19,7 +18,7 @@
  *      "https://www3.ntu.edu.sg/home/ehchua/programming/java/javanativeinterface.html">Java
  *      Native Interface tutorial</a>
  */
-public class Index {
+public class Index implements AutoCloseable {
 
   private long c_ptr = 0;
 
@@ -39,21 +38,50 @@ public class Index {
    *                         during search operations
    */
   public Index(
-      String metric,
-      String quantization,
-      long dimensions,
-      long capacity,
-      long connectivity,
-      long expansion_add,
-      long expansion_search) {
-    c_ptr = c_create(
-        metric,
-        quantization,
-        dimensions,
-        capacity,
-        connectivity,
-        expansion_add,
-        expansion_search);
+    String metric,
+    String quantization,
+    long dimensions,
+    long capacity,
+    long connectivity,
+    long expansion_add,
+    long expansion_search
+  ) {
+    this(c_create(metric, quantization, dimensions, capacity, connectivity, expansion_add, expansion_search));
+  }
+
+  private Index(long c_ptr) {
+    this.c_ptr = c_ptr;
+  }
+
+  /**
+   * Loads an index from a file into memory.
+   *
+   * @param path path to load from
+   * @return a mutable Index.
+   * @throws {@Error} if any part of loading from path failed.
+   */
+  public static Index loadFromPath(String path) {
+    return new Index(c_createFromFile(path, false));
+  }
+
+  /**
+   * Loads an index view from a file into memory.
+   *
+   * @param path path to load from
+   * @return an immutable Index.
+   * @throws {@Error} if any part of loading from path failed.
+   */
+  public static Index viewFromPath(String path) {
+    return new Index(c_createFromFile(path, true));
+  }
+
+  @Override
+  public void close() {
+    if (c_ptr == 0) {
+      throw new IllegalStateException("Index already closed");
+    }
+    c_destroy(c_ptr);
+    c_ptr = 0;
   }
 
   /**
@@ -62,6 +90,9 @@ public Index(
    * @return the number of vectors currently indexed.
    */
   public long size() {
+    if (c_ptr == 0) {
+      throw new IllegalStateException("Index already closed");
+    }
     return c_size(c_ptr);
   }
 
@@ -71,6 +102,9 @@ public long size() {
    * @return the connectivity parameter that limits connections-per-node in graph.
    */
   public long connectivity() {
+    if (c_ptr == 0) {
+      throw new IllegalStateException("Index already closed");
+    }
     return c_connectivity(c_ptr);
   }
 
@@ -80,6 +114,9 @@ public long connectivity() {
    * @return the number of dimensions in the vectors.
    */
   public long dimensions() {
+    if (c_ptr == 0) {
+      throw new IllegalStateException("Index already closed");
+    }
     return c_dimensions(c_ptr);
   }
 
@@ -89,6 +126,9 @@ public long dimensions() {
    * @return the total capacity including current size.
    */
   public long capacity() {
+    if (c_ptr == 0) {
+      throw new IllegalStateException("Index already closed");
+    }
     return c_capacity(c_ptr);
   }
 
@@ -98,6 +138,9 @@ public long capacity() {
    * @param capacity the desired total capacity including current size.
    */
   public void reserve(long capacity) {
+    if (c_ptr == 0) {
+      throw new IllegalStateException("Index already closed");
+    }
     c_reserve(c_ptr, capacity);
   }
 
@@ -108,6 +151,9 @@ public void reserve(long capacity) {
    * @param vector the vector data
    */
   public void add(int key, float vector[]) {
+    if (c_ptr == 0) {
+      throw new IllegalStateException("Index already closed");
+    }
     c_add(c_ptr, key, vector);
   }
 
@@ -119,15 +165,35 @@ public void add(int key, float vector[]) {
    * @return an array of keys of the nearest neighbors
    */
   public int[] search(float vector[], long count) {
+    if (c_ptr == 0) {
+      throw new IllegalStateException("Index already closed");
+    }
     return c_search(c_ptr, vector, count);
   }
 
+  /**
+   * Return the contents of the vector at key.
+   *
+   * @param key key to lookup.
+   * @return the contents of the vector.
+   * @throws {@link IllegalArgumentException} is key is not available.
+   */
+  public float[] get(int key) {
+    if (c_ptr == 0) {
+      throw new IllegalStateException("Index already closed");
+    }
+    return c_get(c_ptr, key);
+  }
+
   /**
    * Saves the index to a file.
    *
    * @param path the file path where the index will be saved.
    */
   public void save(String path) {
+    if (c_ptr == 0) {
+      throw new IllegalStateException("Index already closed");
+    }
     c_save(c_ptr, path);
   }
 
@@ -137,6 +203,9 @@ public void save(String path) {
    * @param path the file path from where the index will be loaded.
    */
   public void load(String path) {
+    if (c_ptr == 0) {
+      throw new IllegalStateException("Index already closed");
+    }
     c_load(c_ptr, path);
   }
 
@@ -146,6 +215,9 @@ public void load(String path) {
    * @param path the file path from where the view will be created.
    */
   public void view(String path) {
+    if (c_ptr == 0) {
+      throw new IllegalStateException("Index already closed");
+    }
     c_view(c_ptr, path);
   }
 
@@ -157,6 +229,9 @@ public void view(String path) {
    *         otherwise.
    */
   public boolean remove(int key) {
+    if (c_ptr == 0) {
+      throw new IllegalStateException("Index already closed");
+    }
     return c_remove(c_ptr, key);
   }
 
@@ -169,6 +244,9 @@ public boolean remove(int key) {
    *         otherwise.
    */
   public boolean rename(int from, int to) {
+    if (c_ptr == 0) {
+      throw new IllegalStateException("Index already closed");
+    }
     return c_rename(c_ptr, from, to);
   }
 
@@ -192,8 +270,7 @@ public static class Config {
     /**
      * Default constructor for the Config class.
      */
-    public Config() {
-    }
+    public Config() {}
 
     /**
      * Constructs an Index instance based on the current configuration settings.
@@ -202,13 +279,14 @@ public Config() {
      */
     public Index build() {
       return new Index(
-          _metric,
-          _quantization,
-          _dimensions,
-          _capacity,
-          _connectivity,
-          _expansion_add,
-          _expansion_search);
+        _metric,
+        _quantization,
+        _dimensions,
+        _capacity,
+        _connectivity,
+        _expansion_add,
+        _expansion_search
+      );
     }
 
     /**
@@ -296,7 +374,11 @@ public Config expansion_search(long _expansion_search) {
       System.loadLibrary("usearch"); // used for tests. This library in classpath only
     } catch (UnsatisfiedLinkError e) {
       try {
-        NativeUtils.loadLibraryFromJar("/usearch/libusearch.so");
+        if (System.getProperty("os.name").equals("Mac OS X")) {
+          NativeUtils.loadLibraryFromJar("/usearch/libusearch.dylib");
+        } else {
+          NativeUtils.loadLibraryFromJar("/usearch/libusearch.so");
+        }
       } catch (IOException e1) {
         throw new RuntimeException(e1);
       }
@@ -309,19 +391,25 @@ public Config expansion_search(long _expansion_search) {
    * @param args command line arguments (not used in this case)
    */
   public static void main(String[] args) {
-    Index index = new Index.Config().metric("cos").dimensions(100).build();
-    index.size();
+    try (
+      Index index = new Index.Config().metric("cos").dimensions(100).build()
+    ) {
+      index.size();
+    }
     System.out.println("Java tests passed!");
   }
 
   private static native long c_create(
-      String metric,
-      String quantization,
-      long dimensions,
-      long capacity,
-      long connectivity,
-      long expansion_add,
-      long expansion_search);
+    String metric,
+    String quantization,
+    long dimensions,
+    long capacity,
+    long connectivity,
+    long expansion_add,
+    long expansion_search
+  );
+
+  private static native long c_createFromFile(String path, boolean view);
 
   private static native void c_destroy(long ptr);
 
@@ -339,6 +427,8 @@ private static native long c_create(
 
   private static native int[] c_search(long ptr, float vector[], long count);
 
+  private static native float[] c_get(long ptr, int key);
+
   private static native void c_save(long ptr, String path);
 
   private static native void c_load(long ptr, String path);
diff --git a/java/cloud/unum/usearch/cloud_unum_usearch_Index.cpp b/java/cloud/unum/usearch/cloud_unum_usearch_Index.cpp
index e760b81a..995b7343 100644
--- a/java/cloud/unum/usearch/cloud_unum_usearch_Index.cpp
+++ b/java/cloud/unum/usearch/cloud_unum_usearch_Index.cpp
@@ -39,7 +39,7 @@ JNIEXPORT jlong JNICALL Java_cloud_unum_usearch_Index_c_1create( //
         }
 
         index_dense_t index = index_dense_t::make(metric, config);
-        if (!index.reserve(static_cast<std::size_t>(capacity))) {
+        if (!index.try_reserve(static_cast<std::size_t>(capacity))) {
             jclass jc = (*env).FindClass("java/lang/Error");
             if (jc)
                 (*env).ThrowNew(jc, "Failed to reserve desired capacity!");
@@ -60,6 +60,22 @@ JNIEXPORT jlong JNICALL Java_cloud_unum_usearch_Index_c_1create( //
     return result;
 }
 
+JNIEXPORT jlong JNICALL Java_cloud_unum_usearch_Index_c_1createFromFile(JNIEnv *env, jclass, jstring path, jboolean view) {
+    char const* path_cstr = env->GetStringUTFChars(path, 0);
+    index_dense_t::state_result_t make_result = index_dense_t::make(path_cstr, view);
+    env->ReleaseStringUTFChars(path, path_cstr);
+    if (!make_result) {
+        jclass jc = env->FindClass("java/lang/Error");
+        if (jc) {
+            env->ThrowNew(jc, make_result.error.release());
+        }
+    }
+    index_dense_t* result_ptr = new index_dense_t(std::move(make_result.index));
+    jlong result;
+    std::memcpy(&result, &result_ptr, sizeof(jlong));
+    return result;
+}
+
 JNIEXPORT void JNICALL Java_cloud_unum_usearch_Index_c_1save(JNIEnv* env, jclass, jlong c_ptr, jstring path) {
     char const* path_cstr = (*env).GetStringUTFChars(path, 0);
     serialization_result_t result = reinterpret_cast<index_dense_t*>(c_ptr)->save(path_cstr);
@@ -114,7 +130,7 @@ JNIEXPORT jlong JNICALL Java_cloud_unum_usearch_Index_c_1capacity(JNIEnv*, jclas
 }
 
 JNIEXPORT void JNICALL Java_cloud_unum_usearch_Index_c_1reserve(JNIEnv* env, jclass, jlong c_ptr, jlong capacity) {
-    if (!reinterpret_cast<index_dense_t*>(c_ptr)->reserve(static_cast<std::size_t>(capacity))) {
+    if (!reinterpret_cast<index_dense_t*>(c_ptr)->try_reserve(static_cast<std::size_t>(capacity))) {
         jclass jc = (*env).FindClass("java/lang/Error");
         if (jc)
             (*env).ThrowNew(jc, "Failed to grow vector index!");
@@ -141,6 +157,26 @@ JNIEXPORT void JNICALL Java_cloud_unum_usearch_Index_c_1add( //
     (*env).ReleaseFloatArrayElements(vector, vector_data, 0);
 }
 
+JNIEXPORT jfloatArray JNICALL Java_cloud_unum_usearch_Index_c_1get(
+    JNIEnv *env, jclass, jlong c_ptr, jint key) {
+    
+    auto index = reinterpret_cast<index_dense_t*>(c_ptr);
+    size_t dim = index->dimensions();
+    std::unique_ptr<jfloat[]> vector(new jfloat[dim]);
+    if (index->get(key, vector.get()) == 0) {
+        jclass jc = env->FindClass("java/lang/IllegalArgumentException");
+        if (jc) {
+            env->ThrowNew(jc, "key not found");
+        }
+    }
+    jfloatArray jvector = env->NewFloatArray(dim);
+    if (jvector == nullptr) {  // out of memory
+        return nullptr;
+    }
+    env->SetFloatArrayRegion(jvector, 0, dim, vector.get());
+    return jvector;
+}
+
 JNIEXPORT jintArray JNICALL Java_cloud_unum_usearch_Index_c_1search( //
     JNIEnv* env, jclass, jlong c_ptr, jfloatArray vector, jlong wanted) {
 
diff --git a/java/cloud/unum/usearch/cloud_unum_usearch_Index.h b/java/cloud/unum/usearch/cloud_unum_usearch_Index.h
index 554b7669..5a10debb 100644
--- a/java/cloud/unum/usearch/cloud_unum_usearch_Index.h
+++ b/java/cloud/unum/usearch/cloud_unum_usearch_Index.h
@@ -15,6 +15,14 @@ extern "C" {
 JNIEXPORT jlong JNICALL Java_cloud_unum_usearch_Index_c_1create
   (JNIEnv *, jclass, jstring, jstring, jlong, jlong, jlong, jlong, jlong);
 
+/*
+ * Class:     cloud_unum_usearch_Index
+ * Method:    c_createFromFile
+ * Signature: (Ljava/lang/String;Z)J
+ */
+JNIEXPORT jlong JNICALL Java_cloud_unum_usearch_Index_c_1createFromFile
+  (JNIEnv *, jclass, jstring, jboolean);
+
 /*
  * Class:     cloud_unum_usearch_Index
  * Method:    c_destroy
@@ -79,6 +87,14 @@ JNIEXPORT void JNICALL Java_cloud_unum_usearch_Index_c_1add
 JNIEXPORT jintArray JNICALL Java_cloud_unum_usearch_Index_c_1search
   (JNIEnv *, jclass, jlong, jfloatArray, jlong);
 
+/*
+ * Class:     cloud_unum_usearch_Index
+ * Method:    c_get
+ * Signature: (JI)[F
+ */
+JNIEXPORT jfloatArray JNICALL Java_cloud_unum_usearch_Index_c_1get
+  (JNIEnv *, jclass, jlong, jint);
+
 /*
  * Class:     cloud_unum_usearch_Index
  * Method:    c_save
diff --git a/javascript/tsconfig-esm.json b/javascript/tsconfig-esm.json
index d03b8cb8..0e790931 100644
--- a/javascript/tsconfig-esm.json
+++ b/javascript/tsconfig-esm.json
@@ -3,6 +3,7 @@
     "compilerOptions": {
         "module": "esnext",
         "outDir": "dist/esm",
-        "target": "esnext"
+        "target": "esnext",
+        "esModuleInterop": true,
     }
-}
\ No newline at end of file
+}
diff --git a/javascript/usearch.ts b/javascript/usearch.ts
index 1bd5a348..89e8f073 100644
--- a/javascript/usearch.ts
+++ b/javascript/usearch.ts
@@ -609,14 +609,15 @@ function exactSearch(
   }
 }
 
-module.exports = {
-  Index,
-  MetricKind,
-  ScalarKind,
-  Matches,
-  BatchMatches,
-  exactSearch,
+const usearch = {
+    Index,
+    MetricKind,
+    ScalarKind,
+    Matches,
+    BatchMatches,
+    exactSearch,
 };
+export default usearch;
 
 // utility functions to help find native builds
 
diff --git a/objc/USearchObjective.mm b/objc/USearchObjective.mm
index d336fc98..ad235f10 100644
--- a/objc/USearchObjective.mm
+++ b/objc/USearchObjective.mm
@@ -217,7 +217,11 @@ - (void)clear {
 }
 
 - (void)reserve:(UInt32)count {
-    _native->reserve(static_cast<std::size_t>(count));
+    if (!_native->try_reserve(static_cast<std::size_t>(count))) {
+        @throw [NSException exceptionWithName:@"Can't reserve space"
+                                       reason:@"Memory allocation failed"
+                                     userInfo:nil];
+    }
 }
 
 - (Boolean)contains:(USearchKey)key {
@@ -225,7 +229,7 @@ - (Boolean)contains:(USearchKey)key {
 }
 
 - (UInt32)count:(USearchKey)key {
-    return _native->count(key);
+    return static_cast<UInt32>(_native->count(key));
 }
 
 - (void)remove:(USearchKey)key {
diff --git a/package-ci.json b/package-ci.json
deleted file mode 100644
index b8bfbe31..00000000
--- a/package-ci.json
+++ /dev/null
@@ -1,10 +0,0 @@
-{
-    "name": "usearch-ci",
-    "version": "1.0.0",
-    "devDependencies": {
-        "@semantic-release/exec": "^6.0.3",
-        "@semantic-release/git": "^10.0.1",
-        "conventional-changelog-eslint": "^3.0.9",
-        "semantic-release": "^21.1.2"
-    }
-}
\ No newline at end of file
diff --git a/package.json b/package.json
index db1ee2c9..9435f65f 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
     "name": "usearch",
-    "version": "2.12.0",
+    "version": "2.13.0",
     "description": "Smaller & Faster Single-File Vector Search Engine from Unum",
     "author": "Ash Vardanian (https://ashvardanian.com/)",
     "license": "Apache 2.0",
@@ -38,7 +38,7 @@
         "prebuild-single": "prebuildify --napi --strip",
         "prebuild-arm64": "prebuildify --arch arm64 --napi",
         "prebuild-darwin-x64+arm64": "prebuildify --arch arm64+x64 --napi --strip",
-        "build-js": "rm -fr javascript/dist/* && tsc -p javascript/tsconfig-esm.json && tsc -p javascript/tsconfig-cjs.json && cp javascript/dist-package-esm.json javascript/dist/esm/package.json && cp javascript/dist-package-cjs.json javascript/dist/cjs/package.json"
+        "build-js": "tsc -p javascript/tsconfig-esm.json && tsc -p javascript/tsconfig-cjs.json && cp javascript/dist-package-esm.json javascript/dist/esm/package.json && cp javascript/dist-package-cjs.json javascript/dist/cjs/package.json"
     },
     "devDependencies": {
         "@types/bindings": "^1.5.5",
diff --git a/python/lib.cpp b/python/lib.cpp
index 66756a51..112a1a97 100644
--- a/python/lib.cpp
+++ b/python/lib.cpp
@@ -125,7 +125,12 @@ static dense_index_py_t make_index(             //
     if (metric.missing())
         throw std::invalid_argument("Unsupported metric!");
 
-    return index_dense_t::make(metric, config);
+    using index_state_t = typename index_dense_t::state_result_t;
+    index_state_t state = index_dense_t::make(metric, config);
+    if (!state)
+        throw std::invalid_argument(state.error.release());
+
+    return std::move(state.index);
 }
 
 scalar_kind_t numpy_string_to_kind(std::string const& name) {
@@ -231,7 +236,7 @@ static void add_many_to_index(                            //
 
     if (!threads)
         threads = std::thread::hardware_concurrency();
-    if (!index.reserve(index_limits_t(ceil2(index.size() + vectors_count), threads)))
+    if (!index.try_reserve(index_limits_t(ceil2(index.size() + vectors_count), threads)))
         throw std::invalid_argument("Out of memory!");
 
     // clang-format off
@@ -263,7 +268,7 @@ static void search_typed(                                   //
 
     if (!threads)
         threads = std::thread::hardware_concurrency();
-    if (!index.reserve(index_limits_t(index.size(), threads)))
+    if (!index.try_reserve(index_limits_t(index.size(), threads)))
         throw std::invalid_argument("Out of memory!");
 
     // Progress status
@@ -342,7 +347,7 @@ static void search_typed(                                       //
         limits.members = index.size();
         limits.threads_add = 0;
         limits.threads_search = 1;
-        if (!index.reserve(limits)) {
+        if (!index.try_reserve(limits)) {
             atomic_error = "Out of memory!";
             return false;
         }
@@ -716,7 +721,7 @@ static void compact_index(dense_index_py_t& index, std::size_t threads, progress
 
     if (!threads)
         threads = std::thread::hardware_concurrency();
-    if (!index.reserve(index_limits_t(index.size(), threads)))
+    if (!index.try_reserve(index_limits_t(index.size(), threads)))
         throw std::invalid_argument("Out of memory!");
 
     index.compact(executor_default_t{threads}, progress_t{progress});
@@ -1050,7 +1055,7 @@ PYBIND11_MODULE(compiled, m) {
 
             if (!threads)
                 threads = std::thread::hardware_concurrency();
-            if (!index.reserve(index_limits_t(index.size(), threads)))
+            if (!index.try_reserve(index_limits_t(index.size(), threads)))
                 throw std::invalid_argument("Out of memory!");
 
             index.isolate(executor_default_t{threads});
@@ -1069,7 +1074,7 @@ PYBIND11_MODULE(compiled, m) {
 
             if (!threads)
                 threads = std::thread::hardware_concurrency();
-            if (!index.reserve(index_limits_t(index.size(), threads)))
+            if (!index.try_reserve(index_limits_t(index.size(), threads)))
                 throw std::invalid_argument("Out of memory!");
 
             index.isolate(executor_default_t{threads});
diff --git a/python/usearch/py.typed b/python/usearch/py.typed
new file mode 100644
index 00000000..e69de29b
diff --git a/rust/lib.cpp b/rust/lib.cpp
index 268c6d73..60e7a2e9 100644
--- a/rust/lib.cpp
+++ b/rust/lib.cpp
@@ -37,7 +37,10 @@ scalar_kind_t rust_to_cpp_scalar(ScalarKind value) {
 }
 
 template <typename scalar_at, typename predicate_at = dummy_predicate_t>
-Matches search_(index_dense_t& index, scalar_at const* vec, size_t count, predicate_at&& predicate = predicate_at{}) {
+Matches search_(index_dense_t& index, scalar_at const* vec, size_t vec_dims, size_t count,
+                predicate_at&& predicate = predicate_at{}) {
+    if (vec_dims != index.scalar_words())
+        throw std::invalid_argument("Vector length must match index dimensionality");
     Matches matches;
     matches.keys.reserve(count);
     matches.distances.reserve(count);
@@ -51,6 +54,12 @@ Matches search_(index_dense_t& index, scalar_at const* vec, size_t count, predic
     return matches;
 }
 
+template <typename scalar_at> void add_(index_dense_t& index, vector_key_t key, scalar_at const* vec, size_t vec_dims) {
+    if (vec_dims != index.scalar_words())
+        throw std::invalid_argument("Vector length must match index dimensionality");
+    index.add(key, vec).error.raise();
+}
+
 NativeIndex::NativeIndex(std::unique_ptr<index_t> index) : index_(std::move(index)) {}
 
 auto make_predicate(uptr_t metric, uptr_t metric_state) {
@@ -62,29 +71,29 @@ auto make_predicate(uptr_t metric, uptr_t metric_state) {
 }
 
 // clang-format off
-void NativeIndex::add_b1x8(vector_key_t key, rust::Slice<uint8_t const> vec) const { index_->add(key, (b1x8_t const*)vec.data()).error.raise(); }
-void NativeIndex::add_i8(vector_key_t key, rust::Slice<int8_t const> vec) const { index_->add(key, vec.data()).error.raise(); }
-void NativeIndex::add_f16(vector_key_t key, rust::Slice<int16_t const> vec) const { index_->add(key, (f16_t const*)vec.data()).error.raise(); }
-void NativeIndex::add_f32(vector_key_t key, rust::Slice<float const> vec) const { index_->add(key, vec.data()).error.raise(); }
-void NativeIndex::add_f64(vector_key_t key, rust::Slice<double const> vec) const { index_->add(key, vec.data()).error.raise(); }
-
-Matches NativeIndex::search_b1x8(rust::Slice<uint8_t const> vec, size_t count) const { return search_(*index_, (b1x8_t const*)vec.data(), count); }
-Matches NativeIndex::search_i8(rust::Slice<int8_t const> vec, size_t count) const { return search_(*index_, vec.data(), count); }
-Matches NativeIndex::search_f16(rust::Slice<int16_t const> vec, size_t count) const { return search_(*index_, (f16_t const*)vec.data(), count); }
-Matches NativeIndex::search_f32(rust::Slice<float const> vec, size_t count) const { return search_(*index_, vec.data(), count); }
-Matches NativeIndex::search_f64(rust::Slice<double const> vec, size_t count) const { return search_(*index_, vec.data(), count); }
-
-Matches NativeIndex::filtered_search_b1x8(rust::Slice<uint8_t const> vec, size_t count, uptr_t metric, uptr_t metric_state) const { return search_(*index_, (b1x8_t const*)vec.data(), count, make_predicate(metric, metric_state)); }
-Matches NativeIndex::filtered_search_i8(rust::Slice<int8_t const> vec, size_t count, uptr_t metric, uptr_t metric_state) const { return search_(*index_, vec.data(), count, make_predicate(metric, metric_state)); }
-Matches NativeIndex::filtered_search_f16(rust::Slice<int16_t const> vec, size_t count, uptr_t metric, uptr_t metric_state) const { return search_(*index_, (f16_t const*)vec.data(), count, make_predicate(metric, metric_state)); }
-Matches NativeIndex::filtered_search_f32(rust::Slice<float const> vec, size_t count, uptr_t metric, uptr_t metric_state) const { return search_(*index_, vec.data(), count, make_predicate(metric, metric_state)); }
-Matches NativeIndex::filtered_search_f64(rust::Slice<double const> vec, size_t count, uptr_t metric, uptr_t metric_state) const { return search_(*index_, vec.data(), count, make_predicate(metric, metric_state)); }
-
-size_t NativeIndex::get_b1x8(vector_key_t key, rust::Slice<uint8_t> vec) const { if (vec.size() % dimensions()) throw std::invalid_argument("Vector length must be a multiple of index dimensionality"); return index_->get(key, (b1x8_t*)vec.data(), vec.size() / dimensions()); }
-size_t NativeIndex::get_i8(vector_key_t key, rust::Slice<int8_t> vec) const { if (vec.size() % dimensions()) throw std::invalid_argument("Vector length must be a multiple of index dimensionality"); return index_->get(key, vec.data(), vec.size() / dimensions()); }
-size_t NativeIndex::get_f16(vector_key_t key, rust::Slice<int16_t> vec) const { if (vec.size() % dimensions()) throw std::invalid_argument("Vector length must be a multiple of index dimensionality"); return index_->get(key, (f16_t*)vec.data(), vec.size() / dimensions()); }
-size_t NativeIndex::get_f32(vector_key_t key, rust::Slice<float> vec) const { if (vec.size() % dimensions()) throw std::invalid_argument("Vector length must be a multiple of index dimensionality"); return index_->get(key, vec.data(), vec.size() / dimensions()); }
-size_t NativeIndex::get_f64(vector_key_t key, rust::Slice<double> vec) const { if (vec.size() % dimensions()) throw std::invalid_argument("Vector length must be a multiple of index dimensionality"); return index_->get(key, vec.data(), vec.size() / dimensions()); }
+void NativeIndex::add_b1x8(vector_key_t key, rust::Slice<uint8_t const> vec) const { add_(*index_, key, (b1x8_t const*)vec.data(), vec.size()); }
+void NativeIndex::add_i8(vector_key_t key, rust::Slice<int8_t const> vec) const { add_(*index_, key, vec.data(), vec.size()); }
+void NativeIndex::add_f16(vector_key_t key, rust::Slice<int16_t const> vec) const { add_(*index_, key, (f16_t const*)vec.data(), vec.size()); }
+void NativeIndex::add_f32(vector_key_t key, rust::Slice<float const> vec) const { add_(*index_, key, vec.data(), vec.size()); }
+void NativeIndex::add_f64(vector_key_t key, rust::Slice<double const> vec) const { add_(*index_, key, vec.data(), vec.size()); }
+
+Matches NativeIndex::search_b1x8(rust::Slice<uint8_t const> vec, size_t count) const { return search_(*index_, (b1x8_t const*)vec.data(), vec.size(), count); }
+Matches NativeIndex::search_i8(rust::Slice<int8_t const> vec, size_t count) const { return search_(*index_, vec.data(), vec.size(), count); }
+Matches NativeIndex::search_f16(rust::Slice<int16_t const> vec, size_t count) const { return search_(*index_, (f16_t const*)vec.data(), vec.size(), count); }
+Matches NativeIndex::search_f32(rust::Slice<float const> vec, size_t count) const { return search_(*index_, vec.data(), vec.size(), count); }
+Matches NativeIndex::search_f64(rust::Slice<double const> vec, size_t count) const { return search_(*index_, vec.data(), vec.size(), count); }
+
+Matches NativeIndex::filtered_search_b1x8(rust::Slice<uint8_t const> vec, size_t count, uptr_t metric, uptr_t metric_state) const { return search_(*index_, (b1x8_t const*)vec.data(), vec.size(), count, make_predicate(metric, metric_state)); }
+Matches NativeIndex::filtered_search_i8(rust::Slice<int8_t const> vec, size_t count, uptr_t metric, uptr_t metric_state) const { return search_(*index_, vec.data(), vec.size(), count, make_predicate(metric, metric_state)); }
+Matches NativeIndex::filtered_search_f16(rust::Slice<int16_t const> vec, size_t count, uptr_t metric, uptr_t metric_state) const { return search_(*index_, (f16_t const*)vec.data(), vec.size(), count, make_predicate(metric, metric_state)); }
+Matches NativeIndex::filtered_search_f32(rust::Slice<float const> vec, size_t count, uptr_t metric, uptr_t metric_state) const { return search_(*index_, vec.data(), vec.size(), count, make_predicate(metric, metric_state)); }
+Matches NativeIndex::filtered_search_f64(rust::Slice<double const> vec, size_t count, uptr_t metric, uptr_t metric_state) const { return search_(*index_, vec.data(), vec.size(), count, make_predicate(metric, metric_state)); }
+
+size_t NativeIndex::get_b1x8(vector_key_t key, rust::Slice<uint8_t> vec) const { if (vec.size() % dimensions()) throw std::invalid_argument("Vector length must match index dimensionality"); return index_->get(key, (b1x8_t*)vec.data(), vec.size() / dimensions()); }
+size_t NativeIndex::get_i8(vector_key_t key, rust::Slice<int8_t> vec) const { if (vec.size() % dimensions()) throw std::invalid_argument("Vector length must match index dimensionality"); return index_->get(key, vec.data(), vec.size() / dimensions()); }
+size_t NativeIndex::get_f16(vector_key_t key, rust::Slice<int16_t> vec) const { if (vec.size() % dimensions()) throw std::invalid_argument("Vector length must match index dimensionality"); return index_->get(key, (f16_t*)vec.data(), vec.size() / dimensions()); }
+size_t NativeIndex::get_f32(vector_key_t key, rust::Slice<float> vec) const { if (vec.size() % dimensions()) throw std::invalid_argument("Vector length must match index dimensionality"); return index_->get(key, vec.data(), vec.size() / dimensions()); }
+size_t NativeIndex::get_f64(vector_key_t key, rust::Slice<double> vec) const { if (vec.size() % dimensions()) throw std::invalid_argument("Vector length must match index dimensionality"); return index_->get(key, vec.data(), vec.size() / dimensions()); }
 // clang-format on
 
 size_t NativeIndex::expansion_add() const { return index_->expansion_add(); }
@@ -93,10 +102,10 @@ void NativeIndex::change_expansion_add(size_t n) const { index_->change_expansio
 void NativeIndex::change_expansion_search(size_t n) const { index_->change_expansion_search(n); }
 
 void NativeIndex::change_metric(uptr_t metric, uptr_t state) const {
-    index_->change_metric(metric_punned_t::statefull( //
-        reinterpret_cast<std::uintptr_t>(metric),     //
-        reinterpret_cast<std::uintptr_t>(state),      //
-        index_->metric().metric_kind(),               //
+    index_->change_metric(metric_punned_t::stateful( //
+        reinterpret_cast<std::uintptr_t>(metric),    //
+        reinterpret_cast<std::uintptr_t>(state),     //
+        index_->metric().metric_kind(),              //
         index_->scalar_kind()));
 }
 
diff --git a/rust/lib.rs b/rust/lib.rs
index 28a1b567..92c34b58 100644
--- a/rust/lib.rs
+++ b/rust/lib.rs
@@ -1247,7 +1247,7 @@ impl Index {
     ///
     /// # Arguments
     ///
-    /// * `path` - The file path where the index will be saved.
+    /// * `buffer` - The buffer where the index will be saved.
     pub fn save_to_buffer(self: &Index, buffer: &mut [u8]) -> Result<(), cxx::Exception> {
         self.inner.save_to_buffer(buffer)
     }
@@ -1256,7 +1256,7 @@ impl Index {
     ///
     /// # Arguments
     ///
-    /// * `path` - The file path from where the index will be loaded.
+    /// * `buffer` - The buffer from where the index will be loaded.
     pub fn load_from_buffer(self: &Index, buffer: &[u8]) -> Result<(), cxx::Exception> {
         self.inner.load_from_buffer(buffer)
     }
@@ -1265,8 +1265,31 @@ impl Index {
     ///
     /// # Arguments
     ///
-    /// * `path` - The file path from where the view will be created.
-    pub fn view_from_buffer(self: &Index, buffer: &[u8]) -> Result<(), cxx::Exception> {
+    /// * `buffer` - The buffer from where the view will be created.
+    ///
+    /// # Safety
+    ///
+    /// This function is marked as `unsafe` because it stores a pointer to the input buffer.
+    /// The caller must ensure that the buffer outlives the index and is not dropped
+    /// or modified for the duration of the index's use. Dereferencing a pointer to a
+    /// temporary buffer after it has been dropped can lead to undefined behavior,
+    /// which violates Rust's memory safety guarantees.
+    ///
+    /// Example of misuse:
+    ///
+    /// ```rust,ignore
+    /// let index: usearch::Index = usearch::new_index(&usearch::IndexOptions::default()).unwrap();
+    ///
+    /// let temporary = vec![0u8; 100];
+    /// index.view_from_buffer(&temporary);
+    /// std::mem::drop(temporary);
+    ///
+    /// let query = vec![0.0; 256];
+    /// let results = index.search(&query, 5).unwrap();
+    /// ```
+    ///
+    /// The above example would result in use-after-free and undefined behavior.
+    pub unsafe fn view_from_buffer(self: &Index, buffer: &[u8]) -> Result<(), cxx::Exception> {
         self.inner.view_from_buffer(buffer)
     }
 }
@@ -1373,8 +1396,12 @@ mod tests {
 
         let first: [f32; 5] = [0.2, 0.1, 0.2, 0.1, 0.3];
         let second: [f32; 5] = [0.3, 0.2, 0.4, 0.0, 0.1];
+        let too_long: [f32; 6] = [0.3, 0.2, 0.4, 0.0, 0.1, 0.1];
+        let too_short: [f32; 4] = [0.3, 0.2, 0.4, 0.0];
         assert!(index.add(1, &first).is_ok());
         assert!(index.add(2, &second).is_ok());
+        assert!(index.add(3, &too_long).is_err());
+        assert!(index.add(4, &too_short).is_err());
         assert_eq!(index.size(), 2);
 
         // Test using Vec<T>
@@ -1393,6 +1420,27 @@ mod tests {
         let result = index.get(1, &mut found);
         assert!(result.is_err());
     }
+    #[test]
+    fn test_search_vector() {
+        let mut options = IndexOptions::default();
+        options.dimensions = 5;
+        options.quantization = ScalarKind::F32;
+        let index = Index::new(&options).unwrap();
+        assert!(index.reserve(10).is_ok());
+
+        let first: [f32; 5] = [0.2, 0.1, 0.2, 0.1, 0.3];
+        let second: [f32; 5] = [0.3, 0.2, 0.4, 0.0, 0.1];
+        let too_long: [f32; 6] = [0.3, 0.2, 0.4, 0.0, 0.1, 0.1];
+        let too_short: [f32; 4] = [0.3, 0.2, 0.4, 0.0];
+        assert!(index.add(1, &first).is_ok());
+        assert!(index.add(2, &second).is_ok());
+        assert_eq!(index.size(), 2);
+        //assert!(index.add(3, &too_long).is_err());
+        //assert!(index.add(4, &too_short).is_err());
+
+        assert!(index.search(&too_long, 1).is_err());
+        assert!(index.search(&too_short, 1).is_err());
+    }
 
     #[test]
     fn test_add_remove_vector() {
@@ -1405,7 +1453,7 @@ mod tests {
         options.expansion_search = 3;
         let index = Index::new(&options).unwrap();
         assert!(index.reserve(10).is_ok());
-        assert_eq!(index.capacity(), 10);
+        assert!(index.capacity() >= 10);
 
         let first: [f32; 4] = [0.2, 0.1, 0.2, 0.1];
         let second: [f32; 4] = [0.3, 0.2, 0.4, 0.0];
diff --git a/setup.py b/setup.py
index d70b3ff7..4b202938 100644
--- a/setup.py
+++ b/setup.py
@@ -72,10 +72,13 @@ def get_bool_env_w_name(name: str, preference: bool) -> tuple:
         macros_args.extend(
             [
                 get_bool_env_w_name("SIMSIMD_TARGET_NEON", True),
+                get_bool_env_w_name("SIMSIMD_TARGET_NEON_BF16", False),
                 get_bool_env_w_name("SIMSIMD_TARGET_SVE", True),
+                get_bool_env_w_name("SIMSIMD_TARGET_SVE_BF16", False),
                 get_bool_env_w_name("SIMSIMD_TARGET_HASWELL", True),
                 get_bool_env_w_name("SIMSIMD_TARGET_SKYLAKE", True),
                 get_bool_env_w_name("SIMSIMD_TARGET_ICE", True),
+                get_bool_env_w_name("SIMSIMD_TARGET_GENOA", True),
                 get_bool_env_w_name("SIMSIMD_TARGET_SAPPHIRE", True),
             ]
         )
@@ -108,10 +111,13 @@ def get_bool_env_w_name(name: str, preference: bool) -> tuple:
         macros_args.extend(
             [
                 get_bool_env_w_name("SIMSIMD_TARGET_NEON", True),
+                get_bool_env_w_name("SIMSIMD_TARGET_NEON_BF16", False),
                 get_bool_env_w_name("SIMSIMD_TARGET_SVE", False),
+                get_bool_env_w_name("SIMSIMD_TARGET_SVE_BF16", False),
                 get_bool_env_w_name("SIMSIMD_TARGET_HASWELL", True),
                 get_bool_env_w_name("SIMSIMD_TARGET_SKYLAKE", False),
                 get_bool_env_w_name("SIMSIMD_TARGET_ICE", False),
+                get_bool_env_w_name("SIMSIMD_TARGET_GENOA", False),
                 get_bool_env_w_name("SIMSIMD_TARGET_SAPPHIRE", False),
             ]
         )
@@ -127,10 +133,13 @@ def get_bool_env_w_name(name: str, preference: bool) -> tuple:
         macros_args.extend(
             [
                 get_bool_env_w_name("SIMSIMD_TARGET_NEON", True),
+                get_bool_env_w_name("SIMSIMD_TARGET_NEON_BF16", False),
                 get_bool_env_w_name("SIMSIMD_TARGET_SVE", False),
+                get_bool_env_w_name("SIMSIMD_TARGET_SVE_BF16", False),
                 get_bool_env_w_name("SIMSIMD_TARGET_HASWELL", True),
                 get_bool_env_w_name("SIMSIMD_TARGET_SKYLAKE", True),
                 get_bool_env_w_name("SIMSIMD_TARGET_ICE", True),
+                get_bool_env_w_name("SIMSIMD_TARGET_GENOA", False),
                 get_bool_env_w_name("SIMSIMD_TARGET_SAPPHIRE", False),
             ]
         )
@@ -171,6 +180,7 @@ def get_bool_env_w_name(name: str, preference: bool) -> tuple:
     description="Smaller & Faster Single-File Vector Search Engine from Unum",
     author="Ash Vardanian",
     author_email="info@unum.cloud",
+    url="https://github.com/unum-cloud/usearch",
     long_description=long_description,
     long_description_content_type="text/markdown",
     license="Apache-2.0",
diff --git a/simsimd b/simsimd
index 18d17686..91a76d1a 160000
--- a/simsimd
+++ b/simsimd
@@ -1,1 +1,1 @@
-Subproject commit 18d17686124ddebd9fe55eee56b2e0273a613d4b
+Subproject commit 91a76d1ac519b3b9dc8957734a3dabd985f00c26
diff --git a/swift/Test.swift b/swift/Test.swift
index 903ba2d5..c6ebeccc 100644
--- a/swift/Test.swift
+++ b/swift/Test.swift
@@ -39,4 +39,34 @@ class Test: XCTestCase {
         index.remove(key: 49)
         assert(index.count(key: 49) == 0)
     }
+
+    func testIssue399() {
+        let index = USearchIndex.make(
+            metric: USearchMetric.l2sq,
+            dimensions: 1,
+            connectivity: 8,
+            quantization: USearchScalar.F32
+        )
+        index.reserve(3)
+
+        // add 3 entries then ensure all 3 are returned
+        index.add(key: 1, vector: [1.1])
+        index.add(key: 2, vector: [2.1])
+        index.add(key: 3, vector: [3.1])
+        XCTAssertEqual(index.count, 3)
+        XCTAssertEqual(index.search(vector: [1.0], count: 3).0, [1, 2, 3]) // works 😎
+
+        // replace second-added entry then ensure all 3 are still returned
+        index.remove(key: 2)
+        index.add(key: 2, vector: [2.2])
+        XCTAssertEqual(index.count, 3)
+        XCTAssertEqual(index.search(vector: [1.0], count: 3).0, [1, 2, 3]) // works 😎
+
+        // replace first-added entry then ensure all 3 are still returned
+        index.remove(key: 1)
+        index.add(key: 1, vector: [1.2])
+        let afterReplacingInitial = index.search(vector: [1.0], count: 3).0
+        XCTAssertEqual(index.count, 3)
+        XCTAssertEqual(afterReplacingInitial, [1, 2, 3]) // v2.11.7 fails with "[1] != [1, 2, 3]" 😨
+    }
 }
diff --git a/wolfram/CMakeLists.txt b/wolfram/CMakeLists.txt
index 261e0361..cc0fb9d1 100644
--- a/wolfram/CMakeLists.txt
+++ b/wolfram/CMakeLists.txt
@@ -1,12 +1,52 @@
+cmake_minimum_required(VERSION 3.15.0)
 
-if(NOT WOLFRAM_PATH)
+project(usearch)
+
+if (NOT SYSTEMID)
+    # set system id and build platform
+    set(BITNESS 32)
+    if (CMAKE_SIZEOF_VOID_P EQUAL 8)
+        set(BITNESS 64)
+    endif ()
+
+    set(SYSTEMID NOTFOUND)
+
+    # Determine the current machine's systemid.
+    if (CMAKE_SYSTEM_NAME STREQUAL "Linux" AND BITNESS EQUAL 64)
+        if (CMAKE_SYSTEM_PROCESSOR MATCHES "aarch64")
+            set(SYSTEMID Linux-ARM64)
+        else ()
+            set(SYSTEMID Linux-x86-64)
+        endif ()
+    elseif (CMAKE_SYSTEM_NAME STREQUAL "Darwin" AND BITNESS EQUAL 64)
+        if (CMAKE_SYSTEM_PROCESSOR MATCHES "arm*")
+            set(SYSTEMID MacOSX-ARM64)
+        else ()
+            set(SYSTEMID MacOSX-x86-64)
+        endif ()
+    elseif (CMAKE_SYSTEM_NAME STREQUAL "Windows" AND BITNESS EQUAL 64)
+        if (_MSVC_C_ARCHITECTURE_FAMILY STREQUAL "ARM64")
+            set(SYSTEMID Windows-ARM64)
+        else ()
+            set(SYSTEMID Windows-x86-64)
+        endif ()
+    endif ()
+
+    if (NOT SYSTEMID)
+        message(FATAL_ERROR "Unable to determine System ID.")
+    endif ()
+endif ()
+
+if (NOT WOLFRAM_PATH)
     set(WOLFRAM_PATH "/usr/local/Wolfram/Mathematica")
-endif()
+endif ()
 
-set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${WOLFRAM_PATH}/SystemFiles/Links/WSTP/DeveloperKit/Linux-x86-64/CompilerAdditions/")
+set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH}
+                      "${WOLFRAM_PATH}/SystemFiles/Links/WSTP/DeveloperKit/${SYSTEMID}/CompilerAdditions/"
+)
 include(WSTP)
 include_directories("${WOLFRAM_PATH}/SystemFiles/IncludeFiles/C/")
-link_directories("${WOLFRAM_PATH}/SystemFiles/Libraries/Linux-x86-64/")
+link_directories("${WOLFRAM_PATH}/SystemFiles/Libraries/${SYSTEMID}/")
 
 add_library(usearchWFM SHARED lib.cpp)
 
diff --git a/wolfram/lib.cpp b/wolfram/lib.cpp
index 31ec891f..b71f3cd9 100644
--- a/wolfram/lib.cpp
+++ b/wolfram/lib.cpp
@@ -4,18 +4,19 @@
 using namespace unum::usearch;
 
 using distance_t = distance_punned_t;
+using metric_t = metric_punned_t;
 using index_t = index_dense_t;
-using vector_view_t = span_gt<float>;
+using vector_view_t = span_gt<double>;
 
 using add_result_t = typename index_t::add_result_t;
 using search_result_t = typename index_t::search_result_t;
 using vector_key_t = typename index_t::vector_key_t;
+using dense_search_result_t = typename index_t::search_result_t;
 
 EXTERN_C DLLEXPORT int WolframLibrary_initialize(WolframLibraryData libData) { return LIBRARY_NO_ERROR; }
 EXTERN_C DLLEXPORT void WolframLibrary_uninitialize(WolframLibraryData libData) { return; }
 
 EXTERN_C DLLEXPORT int IndexCreate(WolframLibraryData libData, mint Argc, MArgument* Args, MArgument Res) {
-    index_config_t config;
     char* quantization_cstr = nullptr;
     char* metric_cstr = nullptr;
     try {
@@ -23,13 +24,17 @@ EXTERN_C DLLEXPORT int IndexCreate(WolframLibraryData libData, mint Argc, MArgum
         metric_cstr = MArgument_getUTF8String(Args[0]);
         std::size_t dimensions = static_cast<std::size_t>(MArgument_getInteger(Args[2]));
         std::size_t capacity = static_cast<std::size_t>(MArgument_getInteger(Args[3]));
-        config.connectivity = static_cast<std::size_t>(MArgument_getInteger(Args[4]));
-        config.expansion_add = static_cast<std::size_t>(MArgument_getInteger(Args[5]));
-        config.expansion_search = static_cast<std::size_t>(MArgument_getInteger(Args[6]));
+        std::size_t connectivity = static_cast<std::size_t>(MArgument_getInteger(Args[4]));
+        std::size_t expansion_add = static_cast<std::size_t>(MArgument_getInteger(Args[5]));
+        std::size_t expansion_search = static_cast<std::size_t>(MArgument_getInteger(Args[6]));
+
+        index_dense_config_t config(connectivity, expansion_add, expansion_search);
 
         scalar_kind_t quantization = scalar_kind_from_name(quantization_cstr, std::strlen(quantization_cstr));
         metric_kind_t metric_kind = metric_from_name(metric_cstr, std::strlen(metric_cstr));
-        index_t index = make_punned<index_t>(metric_kind, dimensions, quantization, config);
+        metric_t metric = metric_t::builtin(dimensions, metric_kind, quantization);
+        index_t index = index_t::make(metric, config);
+
         index.reserve(capacity);
 
         index_t* result_ptr = new index_t(std::move(index));
@@ -115,12 +120,12 @@ EXTERN_C DLLEXPORT int IndexCapacity(WolframLibraryData libData, mint Argc, MArg
 EXTERN_C DLLEXPORT int IndexAdd(WolframLibraryData libData, mint Argc, MArgument* Args, MArgument Res) {
     char* path_cstr = nullptr;
     index_t* c_ptr = (index_t*)MArgument_getUTF8String(Args[0]);
-    float* vector_data = nullptr;
+    double* vector_data = nullptr;
     try {
         int key = MArgument_getInteger(Args[1]);
         MTensor tens = MArgument_getMTensor(Args[2]);
         std::size_t len = libData->MTensor_getFlattenedLength(tens);
-        vector_data = (float*)libData->MTensor_getRealData(tens);
+        vector_data = (double*)libData->MTensor_getRealData(tens);
         vector_view_t vector_span = vector_view_t{vector_data, len};
         c_ptr->add(key, vector_span);
     } catch (...) {
@@ -132,24 +137,30 @@ EXTERN_C DLLEXPORT int IndexAdd(WolframLibraryData libData, mint Argc, MArgument
 EXTERN_C DLLEXPORT int IndexSearch(WolframLibraryData libData, mint Argc, MArgument* Args, MArgument Res) {
     index_t* c_ptr = (index_t*)MArgument_getUTF8String(Args[0]);
     MTensor matches;
-    mint dims[] = {1};
     int wanted = MArgument_getInteger(Args[2]);
-    float* vector_data = nullptr;
-    int* matches_data = nullptr;
-    std::size_t found = 0;
+    double* vector_data = nullptr;
+    vector_key_t* matches_data = nullptr;
 
     try {
-        libData->MTensor_new(MType_Integer, 1, dims, &matches);
-
         MTensor tens = MArgument_getMTensor(Args[1]);
         std::size_t len = libData->MTensor_getFlattenedLength(tens);
-        vector_data = (float*)libData->MTensor_getRealData(tens);
+        vector_data = (double*)libData->MTensor_getRealData(tens);
         vector_view_t vector_span = vector_view_t{vector_data, len};
+        matches_data = (vector_key_t*)std::malloc(sizeof(vector_key_t) * wanted);
+        dense_search_result_t found = c_ptr->search(vector_span, static_cast<std::size_t>(wanted));
+
+        if (!found) {
+            found.error.release();
+            return LIBRARY_FUNCTION_ERROR;
+        }
+
+        std::size_t count = found.dump_to(matches_data);
+
+        mint dims = static_cast<mint>(count);
+        libData->MTensor_new(MType_Integer, 1, &dims, &matches);
 
-        matches_data = (int*)std::malloc(sizeof(int) * wanted);
-        found = c_ptr->search(vector_span, static_cast<std::size_t>(wanted), matches_data, nullptr);
-        for (mint i = 0; i < found; i++)
-            libData->MTensor_setInteger(matches, &i, matches_data[i]);
+        for (mint i = 1; i <= (mint)count; i++)
+            libData->MTensor_setInteger(matches, &i, static_cast<mint>(matches_data[i - 1]));
 
         MArgument_setMTensor(Res, matches);
     } catch (...) {


Test patch:
diff --git a/c/test.c b/c/test.c
index 2498aa06..dd4a07f0 100644
--- a/c/test.c
+++ b/c/test.c
@@ -5,11 +5,15 @@
 
 #include "usearch.h"
 
-#define ASSERT(must_be_true, message)                                                                                  \
-    if (!(must_be_true)) {                                                                                             \
-        printf("Assert: %s\n", message);                                                                               \
-        exit(-1);                                                                                                      \
-    }
+void expect(bool must_be_true, char const* message) {
+    if (must_be_true)
+        return;
+    message = message ? message : "C unit test failed";
+    printf("Assert: %s\n", message);
+    exit(-1);
+}
+
+#define expect_eq(a, b, message) expect(a == b, message)
 
 /**
  * @brief Creates and initializes vectors with random float values.
@@ -20,7 +24,7 @@
  */
 float* create_vectors(size_t const count, size_t const dimensions) {
     float* data = (float*)malloc(count * dimensions * sizeof(float));
-    ASSERT(data, "Failed to allocate memory");
+    expect(data, "Failed to allocate memory");
     for (size_t index = 0; index < count * dimensions; ++index)
         data[index] = (float)rand() / (float)RAND_MAX;
     return data;
@@ -52,31 +56,31 @@ void test_init(size_t const collection_size, size_t const dimensions) {
     usearch_error_t error = NULL;
     usearch_init_options_t opts = create_options(dimensions);
     usearch_index_t index = usearch_init(&opts, &error);
-    ASSERT(!error, error);
+    expect(!error, error);
     usearch_free(index, &error);
-    ASSERT(!error, error);
+    expect(!error, error);
 
     // Init second time
     index = usearch_init(&opts, &error);
-    ASSERT(!error, error);
+    expect(!error, error);
 
-    ASSERT(usearch_size(index, &error) == 0, error);
-    ASSERT(usearch_capacity(index, &error) == 0, error);
-    ASSERT(usearch_dimensions(index, &error) == dimensions, error);
-    ASSERT(usearch_connectivity(index, &error) == opts.connectivity, error);
+    expect_eq(usearch_size(index, &error), 0, error);
+    expect_eq(usearch_capacity(index, &error), 0, error);
+    expect_eq(usearch_dimensions(index, &error), dimensions, error);
+    expect_eq(usearch_connectivity(index, &error), opts.connectivity, error);
 
     // Reserve
     usearch_reserve(index, collection_size, &error);
-    ASSERT(!error, error);
-    ASSERT(usearch_size(index, &error) == 0, error);
-    ASSERT(usearch_capacity(index, &error) == collection_size, error);
-    ASSERT(usearch_dimensions(index, &error) == dimensions, error);
-    ASSERT(usearch_connectivity(index, &error) == opts.connectivity, error);
-    ASSERT(usearch_hardware_acceleration(index, &error), error);
-    ASSERT(usearch_memory_usage(index, &error), error);
+    expect(!error, error);
+    expect_eq(usearch_size(index, &error), 0, error);
+    expect(usearch_capacity(index, &error) >= collection_size, error);
+    expect_eq(usearch_dimensions(index, &error), dimensions, error);
+    expect_eq(usearch_connectivity(index, &error), opts.connectivity, error);
+    expect(usearch_hardware_acceleration(index, &error), error);
+    expect(usearch_memory_usage(index, &error), error);
 
     usearch_free(index, &error);
-    ASSERT(!error, error);
+    expect(!error, error);
 
     printf("Test: Index Initialization - PASSED\n");
 }
@@ -99,18 +103,18 @@ void test_add_vector(size_t const collection_size, size_t const dimensions) {
     for (size_t i = 0; i < collection_size; ++i) {
         usearch_key_t key = i;
         usearch_add(index, key, data + i * dimensions, usearch_scalar_f32_k, &error);
-        ASSERT(!error, error);
+        expect(!error, error);
     }
 
-    ASSERT(usearch_size(index, &error) == collection_size, error);
-    ASSERT(usearch_capacity(index, &error) == collection_size, error);
+    expect_eq(usearch_size(index, &error), collection_size, error);
+    expect(usearch_capacity(index, &error) >= collection_size, error);
 
     // Check vectors in the index
     for (size_t i = 0; i < collection_size; ++i) {
         usearch_key_t key = i;
-        ASSERT(usearch_contains(index, key, &error), error);
+        expect(usearch_contains(index, key, &error), error);
     }
-    ASSERT(!usearch_contains(index, -1, &error), error); // Non existing key
+    expect(!usearch_contains(index, -1, &error), error); // Non existing key
 
     free(data);
     usearch_free(index, &error);
@@ -133,22 +137,22 @@ void test_find_vector(size_t const collection_size, size_t const dimensions) {
     // Create result buffers
     usearch_key_t* keys = (usearch_key_t*)malloc(collection_size * sizeof(usearch_key_t));
     float* distances = (float*)malloc(collection_size * sizeof(float));
-    ASSERT(keys && distances, "Failed to allocate memory");
+    expect(keys && distances, "Failed to allocate memory");
 
     // Add vectors
     float* data = create_vectors(collection_size, dimensions);
     for (size_t i = 0; i < collection_size; ++i) {
         usearch_key_t key = i;
         usearch_add(index, key, data + i * dimensions, usearch_scalar_f32_k, &error);
-        ASSERT(!error, error);
+        expect(!error, error);
     }
 
     // Find the vectors
     for (size_t i = 0; i < collection_size; i++) {
         size_t found_count = usearch_search(index, data + i * dimensions, usearch_scalar_f32_k, collection_size, keys,
                                             distances, &error);
-        ASSERT(!error, error);
-        ASSERT(found_count >= 1 && found_count <= collection_size, "Vector is missing");
+        expect(!error, error);
+        expect(found_count >= 1 && found_count <= collection_size, "Vector is missing");
     }
 
     free(data);
@@ -174,19 +178,19 @@ void test_get_vector(size_t const collection_size, size_t const dimensions) {
 
     // Create result buffers
     float* vectors = (float*)malloc(collection_size * dimensions * sizeof(float));
-    ASSERT(vectors, "Failed to allocate memory");
+    expect(vectors, "Failed to allocate memory");
 
     // Add multiple vectors with SAME key
     usearch_key_t const key = 1;
     float* data = create_vectors(collection_size, dimensions);
     for (size_t i = 0; i < collection_size; i++) {
         usearch_add(index, key, data + i * dimensions, usearch_scalar_f32_k, &error);
-        ASSERT(!error, error);
+        expect(!error, error);
     }
 
     // Retrieve vectors from index
     size_t found_count = usearch_get(index, key, collection_size, vectors, usearch_scalar_f32_k, &error);
-    ASSERT(found_count == collection_size, "Vector is missing");
+    expect_eq(found_count, collection_size, "Vector is missing");
 
     free(vectors);
     free(data);
@@ -213,14 +217,14 @@ void test_remove_vector(size_t const collection_size, size_t const dimensions) {
     for (size_t i = 0; i < collection_size; ++i) {
         usearch_key_t key = i;
         usearch_add(index, key, data + i * dimensions, usearch_scalar_f32_k, &error);
-        ASSERT(!error, error);
+        expect(!error, error);
     }
 
     // Remove the vectors
     for (size_t i = 0; i < collection_size; i++) {
         usearch_key_t key = i;
         usearch_remove(index, key, &error);
-        ASSERT(!error, "Currently, Remove is not supported");
+        expect(!error, "Currently, Remove is not supported");
     }
 
     free(data);
@@ -256,14 +260,14 @@ void test_save_load(size_t const collection_size, size_t const dimensions) {
         for (size_t i = 0; i < collection_size; ++i) {
             usearch_key_t key = i;
             usearch_add(index, key, data + i * dimensions, usearch_scalar_f32_k, &error);
-            ASSERT(!error, error);
+            expect(!error, error);
         }
 
         // Save and free the index
         usearch_save(index, "tmp.usearch", &error);
-        ASSERT(!error, error);
+        expect(!error, error);
         usearch_free(index, &error);
-        ASSERT(!error, error);
+        expect(!error, error);
     }
 
     // Reset the options
@@ -278,35 +282,36 @@ void test_save_load(size_t const collection_size, size_t const dimensions) {
     // Reinit
     {
 
-        usearch_index_t index = usearch_init(&opts, &error);
-        ASSERT(!error, error);
-        ASSERT(usearch_size(index, &error) == 0, error);
+        usearch_index_t index = usearch_init(NULL, &error);
+        expect(!error, error);
+        // expect(usearch_size(index, &error) == 0, error);
 
         // Load
         usearch_load(index, "tmp.usearch", &error);
-        ASSERT(!error, error);
-        ASSERT(usearch_size(index, &error) == collection_size, error);
-        ASSERT(usearch_capacity(index, &error) == collection_size, error);
-        ASSERT(usearch_dimensions(index, &error) == dimensions, error);
-        ASSERT(usearch_connectivity(index, &error) == weird_ops.connectivity, error);
+        expect(!error, error);
+        expect(usearch_size(index, &error) == collection_size, error);
+        expect(usearch_capacity(index, &error) == collection_size, error);
+        expect(usearch_dimensions(index, &error) == dimensions, error);
+        expect(usearch_connectivity(index, &error) == weird_ops.connectivity, error);
 
         // Check vectors in the index
         for (size_t i = 0; i < collection_size; ++i) {
             usearch_key_t key = i;
-            ASSERT(usearch_contains(index, key, &error), error);
+            expect(usearch_contains(index, key, &error), error);
         }
 
         // Create result buffers
         usearch_key_t* keys = (usearch_key_t*)malloc(collection_size * sizeof(usearch_key_t));
         float* distances = (float*)malloc(collection_size * sizeof(float));
-        ASSERT(keys && distances, "Failed to allocate memory");
+        expect(keys && distances, "Failed to allocate memory");
 
         // Find the vectors
+        usearch_change_threads_search(index, 1, &error);
         for (size_t i = 0; i < collection_size; i++) {
             size_t found_count = usearch_search(index, data + i * dimensions, usearch_scalar_f32_k, collection_size,
                                                 keys, distances, &error);
-            ASSERT(!error, error);
-            ASSERT(found_count >= 1 && found_count <= collection_size, "Vector is missing");
+            expect(!error, error);
+            expect(found_count >= 1 && found_count <= collection_size, "Vector is missing");
         }
 
         free(keys);
@@ -340,22 +345,22 @@ void test_view(size_t const collection_size, size_t const dimensions) {
     for (size_t i = 0; i < collection_size; ++i) {
         usearch_key_t key = i;
         usearch_add(index, key, data + i * dimensions, usearch_scalar_f32_k, &error);
-        ASSERT(!error, error);
+        expect(!error, error);
     }
 
     // Save and free the index
     usearch_save(index, "tmp.usearch", &error);
-    ASSERT(!error, error);
+    expect(!error, error);
     usearch_free(index, &error);
-    ASSERT(!error, error);
+    expect(!error, error);
 
     // Reinit
     index = usearch_init(&opts, &error);
-    ASSERT(!error, error);
+    expect(!error, error);
 
     // View
     usearch_view(index, "tmp.usearch", &error);
-    ASSERT(!error, error);
+    expect(!error, error);
 
     free(data);
     usearch_free(index, &error);
diff --git a/cpp/test.cpp b/cpp/test.cpp
index 409aff15..f8302c34 100644
--- a/cpp/test.cpp
+++ b/cpp/test.cpp
@@ -3,6 +3,14 @@
  *  @author     Ash Vardanian
  *  @brief      Unit-testing vector-search functionality.
  *  @date       June 10, 2023
+ *
+ *
+ *  Key and slot types:
+ *      - 64-bit `std::int64_t` keys and `std::uint32_t` slots are most popular.
+ *      - 64-bit `std::uint64_t` keys and `std::uint40_t` are most space-efficient for
+ *        point clouds 4B+ in size.
+ *      - 128-bit `uuid_t` keys and `enum slot64_t : std::uint64_t` make most sense for
+ *        for database users, implementing portable, concurrent systems.
  */
 #include <algorithm>     // `std::shuffle`
 #include <cassert>       // `assert`
@@ -21,13 +29,44 @@
 using namespace unum::usearch;
 using namespace unum;
 
-void expect(bool must_be_true) {
-    if (!must_be_true)
-        __usearch_raise_runtime_error("Failed!");
+void __expect(bool must_be_true, char const* file, int line, char const* message = nullptr) {
+    if (must_be_true)
+        return;
+    message = message ? message : "C++ unit test failed";
+    char buffer[512];
+    std::snprintf(buffer, sizeof(buffer), "%s at %s:%d", message, file, line);
+    __usearch_raise_runtime_error(buffer);
+}
+
+template <typename value_at>
+void __expect_eq(value_at a, value_at b, char const* file, int line, char const* message = nullptr) {
+    __expect(a == b, file, line, message);
 }
 
+#define expect(cond) __expect((bool)(cond), __FILE__, __LINE__)
+#define expect_eq(a, b) __expect_eq<decltype(a)>((a), (b), __FILE__, __LINE__)
+
 /**
- *  @brief  Convinience wrapper combining combined allocation and construction of an index.
+ *  Less error-prone type definition to differentiate `std::uint32_t` and other native
+ *  types in logs and avoid implicit conversions.
+ */
+enum slot32_t : std::uint32_t {};
+template <> struct unum::usearch::hash_gt<slot32_t> : public unum::usearch::hash_gt<std::uint32_t> {};
+template <> struct unum::usearch::default_free_value_gt<slot32_t> {
+    static slot32_t value() noexcept { return static_cast<slot32_t>(std::numeric_limits<std::uint32_t>::max()); }
+};
+
+/*
+ *  Let's instantiate several templates to make all of their symbols available for testing.
+ *  https://dhashe.com/how-to-build-highly-debuggable-c-binaries.html
+ */
+template class unum::usearch::index_gt<float, std::int64_t, slot32_t>;
+template class unum::usearch::index_gt<float, std::int64_t, uint40_t>;
+template class unum::usearch::index_dense_gt<std::int64_t, slot32_t>;
+template class unum::usearch::index_dense_gt<std::int64_t, uint40_t>;
+
+/**
+ *  @brief  Convenience wrapper combining combined allocation and construction of an index.
  */
 template <typename index_at> struct aligned_wrapper_gt {
     using index_t = index_at;
@@ -56,38 +95,103 @@ template <typename index_at> struct aligned_wrapper_gt {
 };
 
 /**
- * Tests the behavior of various move-constructors and move-assignment operators for the index.
- *
- * Constructs an index and performs tests with it before and after move operations to ensure that the index maintains
- * its integrity and functionality after being moved.
- *
- * @param config Configuration settings for the index.
- * @tparam index_at Type of the index being tested.
+ * Tests the functionality of the custom uint40_t type ensuring consistent
+ * behavior across various constructors from uint32_t, uint64_t, and size_t types,
+ * and validates the relational ordering between various values.
  */
-template <typename index_at> void test_move_constructors(index_config_t const& config) {
-    {
-        index_at index{config};
-        test_sets(index);
+void test_uint40() {
+
+    union uint64_octets_t {
+        std::uint64_t value;
+        std::uint8_t octets[8];
+    };
+
+    // Constants for tests
+    std::uint64_t max_uint40_k = (1ULL << 40) - 1;
+
+    // Set of test numbers
+    std::vector<std::uint64_t> test_numbers = {
+        42ull,            // Typical small number
+        4242ull,          // Larger number still within uint40 range
+        (1ull << 39),     // A high number within range
+        (1ull << 40) - 1, // Maximum value representable in uint40
+        1ull << 40,       // Exactly at the boundary of uint40
+        (1ull << 40) + 1, // Just beyond the boundary of uint40
+        1ull << 63        // Well beyond the uint40 boundary, tests masking
+    };
+
+    for (std::uint64_t input_u64 : test_numbers) {
+        std::uint32_t input_u32 = static_cast<std::uint32_t>(input_u64);
+        std::size_t input_size = static_cast<std::size_t>(input_u64);
+
+        // Create uint40_t instances from different types
+        uint40_t u40_from_u32(input_u32);
+        uint40_t u40_from_u64(input_u64);
+        uint40_t u40_from_size(input_size);
+
+        // Expected value after masking
+        uint64_octets_t input_clamped;
+        input_clamped.value = input_u64 & max_uint40_k;
+
+        // Check if all conversions are equal to the masked value
+        expect_eq(u40_from_u32, input_clamped.value & 0xFFFFFFFF);
+        expect_eq(u40_from_u64, input_clamped.value);
+        expect_eq(u40_from_size, input_clamped.value);
+
+        // Check relative ordering against all other test numbers
+        for (std::uint64_t other_u64 : test_numbers) {
+            uint64_octets_t other_clamped;
+            other_clamped.value = other_u64 & max_uint40_k;
+            uint40_t other_u40(other_clamped.value);
+
+            // Check < and >
+            expect_eq(input_clamped.value < other_clamped.value, u40_from_u64 < other_u40);
+            expect_eq(input_clamped.value > other_clamped.value, u40_from_u64 > other_u40);
+
+            // Check <= and >=
+            expect_eq(input_clamped.value <= other_clamped.value, u40_from_u64 <= other_u40);
+            expect_eq(input_clamped.value >= other_clamped.value, u40_from_u64 >= other_u40);
+        }
     }
-    {
-        index_at index{config};
-        index.reserve(1);
-        test_sets(index_at(std::move(index)));
+
+    // Test equality and inequality operators
+    for (std::uint64_t input_u64 : test_numbers) {
+        uint64_octets_t input_clamped;
+        input_clamped.value = input_u64 & max_uint40_k;
+        uint40_t u40(input_clamped.value);
+
+        expect_eq(u40 == uint40_t(input_clamped.value), true);
+        expect_eq(u40 != uint40_t(input_clamped.value + 1), true);
     }
-    {
-        index_at index{config};
-        index.reserve(1);
-        index_at index_moved = std::move(index);
-        test_sets(index_moved);
+
+    // Test min and max functions
+    expect_eq(uint40_t::min(), uint40_t(0u));
+    expect_eq(uint40_t::max(), uint40_t(max_uint40_k));
+
+    // Test copy and move semantics
+    for (std::uint64_t input_u64 : test_numbers) {
+        uint40_t u40_orig(input_u64);
+
+        uint40_t u40_copy(u40_orig);
+        expect_eq(u40_orig, u40_copy);
+
+        uint40_t u40_move(std::move(u40_orig));
+        expect_eq(u40_copy, u40_move);
     }
+
+    // Test default constructor (zero initialization)
+    uint40_t u40_default;
+    expect_eq(u40_default, uint40_t(0u));
 }
+
 /**
- * Tests the cosine similarity functionality of the given index.
- *
- * This function adds a few vectors to the index and performs searches to check if the vectors can be retrieved
- * accurately. The test covers operations like adding vectors, searching them, verifying results of searches, and
- * checking functionalities like filtering based on a condition, handling duplicates, and serialization/deserialization
- * of the index.
+ *  @brief  Tests the functionality of the custom float16_t type ensuring consistent.
+ */
+void test_float16() {}
+
+/**
+ * The goal of this test is to invoke as many different interfaces as possible, making sure that all code-paths compile.
+ * For that it only uses a tiny set of 3 predefined vectors.
  *
  * @param index Reference to the index where vectors will be stored and searched.
  * @param vectors A collection of vectors to be tested.
@@ -98,57 +202,57 @@ template <typename index_at> void test_move_constructors(index_config_t const& c
  * @tparam extra_args_at Variadic template parameter types for additional configuration.
  */
 template <bool punned_ak, typename index_at, typename scalar_at, typename... extra_args_at>
-void test_cosine(index_at& index, std::vector<std::vector<scalar_at>> const& vectors, extra_args_at&&... args) {
+void test_minimal_three_vectors(index_at& index, //
+                                typename index_at::vector_key_t key_first, std::vector<scalar_at> const& vector_first,
+                                typename index_at::vector_key_t key_second, std::vector<scalar_at> const& vector_second,
+                                typename index_at::vector_key_t key_third, std::vector<scalar_at> const& vector_third,
+                                extra_args_at&&... args) {
 
     using scalar_t = scalar_at;
     using index_t = index_at;
     using vector_key_t = typename index_t::vector_key_t;
     using distance_t = typename index_t::distance_t;
 
-    // Generate some keys starting from end,
-    // for three vectors from the dataset
-    vector_key_t const key_max = default_free_value<vector_key_t>() - 1;
-    vector_key_t const key_first = key_max - 0;
-    vector_key_t const key_second = key_max - 1;
-    vector_key_t const key_third = key_max - 2;
-    scalar_t const* vector_first = vectors[0].data();
-    scalar_t const* vector_second = vectors[1].data();
-    scalar_t const* vector_third = vectors[2].data();
-    std::size_t dimensions = vectors[0].size();
-
     // Try checking the empty state
     if constexpr (punned_ak) {
-        expect(!index.contains(key_first));
-        expect(!index.get(key_first, (f32_t*)nullptr, 1));
+        if (index.config().enable_key_lookups) {
+            expect(!index.contains(key_first));
+            expect(!index.get(key_first, (f32_t*)nullptr, 1));
+        }
     }
 
     // Add data
-    index.reserve(10);
-    index.add(key_first, vector_first, args...);
+    expect(index.try_reserve(10));
+    expect(index.add(key_first, vector_first.data(), args...));
 
     // Default approximate search
     vector_key_t matched_keys[10] = {0};
     distance_t matched_distances[10] = {0};
-    std::size_t matched_count = index.search(vector_first, 5, args...).dump_to(matched_keys, matched_distances);
+    std::size_t matched_count = index.search(vector_first.data(), 5, args...).dump_to(matched_keys, matched_distances);
 
     expect(matched_count == 1);
     expect(matched_keys[0] == key_first);
     expect(std::abs(matched_distances[0]) < 0.01);
 
     // Add more entries
-    index.add(key_second, vector_second, args...);
-    index.add(key_third, vector_third, args...);
+    index.add(key_second, vector_second.data(), args...);
+    index.add(key_third, vector_third.data(), args...);
     expect(index.size() == 3);
 
-    // Perform exact search
-    matched_count = index.search(vector_first, 5, args...).dump_to(matched_keys, matched_distances);
-    expect(matched_count != 0);
+    // Perform single entry search
+    {
+        auto search_result = index.search(vector_first.data(), 5, args...);
+        expect(search_result);
+        matched_count = search_result.dump_to(matched_keys, matched_distances);
+        expect(matched_count != 0);
+    }
 
     // Perform filtered exact search, keeping only odd values
     if constexpr (punned_ak) {
         auto is_odd = [](vector_key_t key) -> bool { return (key & 1) != 0; };
-        matched_count =
-            index.filtered_search(vector_first, 5, is_odd, args...).dump_to(matched_keys, matched_distances);
+        auto search_result = index.filtered_search(vector_first.data(), 5, is_odd, args...);
+        expect(search_result);
+        matched_count = search_result.dump_to(matched_keys, matched_distances);
         expect(matched_count != 0);
         for (std::size_t i = 0; i < matched_count; i++)
             expect(is_odd(matched_keys[i]));
@@ -158,118 +262,317 @@ void test_cosine(index_at& index, std::vector<std::vector<scalar_at>> const& vec
     std::size_t count = 0;
     for (auto member : index) {
         vector_key_t id = member.key;
-        expect(id <= key_first && id >= key_third);
+        expect(id >= key_first && id <= key_third);
         count++;
     }
     expect((count == 3));
     expect((index.stats(0).nodes == 3));
 
     // Check if clustering endpoint compiles
-    index.cluster(vector_first, 0, args...);
+    index.cluster(vector_first.data(), 0, args...);
 
     // Try removals and replacements
     if constexpr (punned_ak) {
-        using labeling_result_t = typename index_t::labeling_result_t;
-        labeling_result_t result = index.remove(key_third);
-        expect(bool(result));
-        expect(index.size() == 2);
-        index.add(key_third, vector_third, args...);
-        expect(index.size() == 3);
+        if (index.config().enable_key_lookups) {
+            using labeling_result_t = typename index_t::labeling_result_t;
+            labeling_result_t result = index.remove(key_third);
+            expect(result);
+            expect(index.size() == 2);
+            index.add(key_third, vector_third.data(), args...);
+            expect(index.size() == 3);
+        }
+    }
+
+    expect(index.save("tmp.usearch"));
+
+    // Perform content and scan validations for a copy
+    {
+        auto copy_result = index.copy();
+        expect(copy_result);
+        index_at copied_index = std::move(copy_result.index);
+
+        // Perform single entry search
+        auto search_result = copied_index.search(vector_first.data(), 5, args...);
+        expect(search_result);
+        matched_count = search_result.dump_to(matched_keys, matched_distances);
+        expect(matched_count != 0);
+
+        // Validate scans
+        std::size_t count = 0;
+        for (auto member : copied_index) {
+            vector_key_t id = member.key;
+            expect(id >= key_first && id <= key_third);
+            count++;
+        }
+        expect_eq(count, 3);
+        expect_eq(copied_index.stats(0).nodes, 3);
+    }
+
+    // Perform content and scan validations for a moved
+    {
+        index_at moved_index(std::move(index));
+
+        // Perform single entry search
+        auto search_result = moved_index.search(vector_first.data(), 5, args...);
+        expect(search_result);
+        matched_count = search_result.dump_to(matched_keys, matched_distances);
+        expect(matched_count != 0);
+
+        // Validate scans
+        std::size_t count = 0;
+        for (auto member : moved_index) {
+            vector_key_t id = member.key;
+            expect(id >= key_first && id <= key_third);
+            count++;
+        }
+        expect_eq(count, 3);
+        expect_eq(moved_index.stats(0).nodes, 3);
+    }
+
+    // Check if metadata is retrieved correctly
+    if constexpr (punned_ak) {
+        auto head_result = index_dense_metadata_from_path("tmp.usearch");
+        expect(head_result);
+        expect_eq(3ull, head_result.head.count_present);
+    }
+
+    // Try loading and move assignment
+    {
+        index_at loaded_index;
+        auto load_result = loaded_index.load("tmp.usearch");
+        expect(load_result);
+        index = std::move(loaded_index);
+    }
+
+    // Check the copy of the restored index
+    {
+        auto copy_result = index.copy();
+        expect(copy_result);
+        index_at copied_index = std::move(copy_result.index);
+        expect_eq(copied_index.size(), 3);
     }
 
     // Search again over reconstructed index
-    index.save("tmp.usearch");
-    index.load("tmp.usearch");
-    matched_count = index.search(vector_first, 5, args...).dump_to(matched_keys, matched_distances);
-    expect(matched_count == 3);
-    expect(matched_keys[0] == key_first);
-    expect(std::abs(matched_distances[0]) < 0.01);
+    {
+        matched_count = index.search(vector_first.data(), 5, args...).dump_to(matched_keys, matched_distances);
+        expect_eq(matched_count, 3);
+        expect_eq(matched_keys[0], key_first);
+        expect(std::abs(matched_distances[0]) < 0.01);
+    }
 
+    // Try retrieving a vector from a deserialized index
     if constexpr (punned_ak) {
-        std::vector<scalar_t> vec_recovered_from_load(dimensions);
-        index.get(key_second, vec_recovered_from_load.data());
-        expect(std::equal(vector_second, vector_second + dimensions, vec_recovered_from_load.data()));
+        if (index.config().enable_key_lookups) {
+            std::size_t dimensions = vector_first.size();
+            std::vector<scalar_t> vector_reloaded(dimensions);
+            expect(index.get(key_second, vector_reloaded.data()));
+            expect(std::equal(vector_second.data(), vector_second.data() + dimensions, vector_reloaded.data()));
+        }
     }
+}
 
-    // Try batch requests, heavily obersubscribing the CPU cores
-    std::size_t executor_threads = std::thread::hardware_concurrency() * 4;
+/**
+ *  @brief  Tests value removals, by repeatedly adding and removing a couple of vectors.
+ *
+ *  @param index Reference to the index where vectors will be stored and searched.
+ *  @param vector_first First vector to be tested.
+ *  @param vector_second Second vector to be tested.
+ *  @param args Additional arguments for configuring search or index operations.
+ */
+template <typename index_at, typename scalar_at>
+void test_punned_add_remove_vector(             //
+    index_at& index,                            //
+    std::vector<scalar_at> const& vector_first, //
+    std::vector<scalar_at> const& vector_second) {
+
+    using index_t = index_at;
+    using vector_key_t = typename index_t::vector_key_t;
+
+    // Creating the index
+    expect(index.try_reserve(10));
+    expect(index.capacity() >= 10);
+
+    // Max 64-bit unsigned key value is: 18446744073709551615
+    vector_key_t key_first = 483367403120493160;
+    vector_key_t key_second = 483367403120558696;
+    vector_key_t key_third = 483367403120624232;
+    vector_key_t key_fourth = 483367403120624233;
+
+    // Adding, getting, and removing vectors
+    expect(index.add(key_first, vector_first.data()));
+    std::vector<float> found_slice(vector_first.size(), 0.0f);
+    expect_eq(index.get(key_first, found_slice.data()), 1);
+    expect(index.remove(key_first));
+
+    expect(index.add(key_second, vector_second.data()));
+    expect_eq(index.get(key_second, found_slice.data()), 1);
+    expect(index.remove(key_second));
+
+    expect(index.add(key_third, vector_second.data()));
+    expect_eq(index.get(key_third, found_slice.data()), 1);
+    expect(index.remove(key_third));
+
+    expect(index.add(key_fourth, vector_second.data()));
+    expect_eq(index.get(key_fourth, found_slice.data()), 1);
+    expect(index.remove(key_fourth));
+
+    expect_eq(index.size(), 0);
+}
+
+/**
+ * Tests the normal operational mode of the library, dealing with a variable length collection
+ * of `vectors` with monotonically increasing keys starting from `start_key`.
+ *
+ * @param index Reference to the index where vectors will be stored and searched.
+ * @param start_key The key for the first `vector`, others are generated with increments.
+ * @param vectors A collection of vectors to be tested.
+ * @param args Additional arguments for configuring search or index operations.
+ * @tparam punned_ak Template parameter that determines specific behaviors or checks in the test based on its value.
+ * @tparam index_at Type of the index being tested.
+ * @tparam scalar_at Data type of the elements in the vectors.
+ * @tparam extra_args_at Variadic template parameter types for additional configuration.
+ */
+template <bool punned_ak, typename index_at, typename scalar_at, typename... extra_args_at>
+void test_collection(index_at& index, typename index_at::vector_key_t const start_key,
+                     std::vector<std::vector<scalar_at>> const& vectors, extra_args_at&&... args) {
+
+    using scalar_t = scalar_at;
+    using index_t = index_at;
+    using vector_key_t = typename index_t::vector_key_t;
+    using distance_t = typename index_t::distance_t;
+    using index_add_result_t = typename index_t::add_result_t;
+    using index_search_result_t = typename index_t::search_result_t;
+
+    // Generate some keys starting from end,
+    // for three vectors from the dataset
+    vector_key_t const key_first = start_key;
+    std::vector<scalar_at> const& vector_first = vectors[0];
+    std::size_t dimensions = vector_first.size();
+
+    // Try batch requests, heavily over-subscribing the CPU cores
+    std::size_t executor_threads = std::thread::hardware_concurrency();
     executor_default_t executor(executor_threads);
-    index.reserve({vectors.size(), executor.size()});
-    executor.fixed(vectors.size() - 3, [&](std::size_t thread, std::size_t task) {
+    expect(index.try_reserve({vectors.size(), executor.size()}));
+    executor.fixed(vectors.size(), [&](std::size_t thread, std::size_t task) {
         if constexpr (punned_ak) {
-            index.add(key_max - task - 3, vectors[task + 3].data(), args...);
+            index_add_result_t result = index.add(start_key + task, vectors[task].data(), args...);
+            expect(result);
         } else {
             index_update_config_t config;
             config.thread = thread;
-            index.add(key_max - task - 3, vectors[task + 3].data(), args..., config);
+            index_add_result_t result = index.add(start_key + task, vectors[task].data(), args..., config);
+            expect(result);
         }
     });
 
-    // Check for duplicates
-    if constexpr (punned_ak) {
-        index.reserve({vectors.size() + 1u, executor.size()});
-        auto result = index.add(key_first, vector_first, args...);
-        expect(!!result == index.multi());
-        result.error.release();
+    // Make sure we didn't lose parallelism settings after reload
+    expect(index.limits().threads_search >= executor.size());
+    if constexpr (punned_ak)
+        expect(index.currently_available_threads() >= executor.size());
 
-        std::size_t first_key_count = index.count(key_first);
-        expect(first_key_count == (1ul + index.multi()));
-    }
+    // Parallel search over the same vectors
+    executor.fixed(vectors.size(), [&](std::size_t thread, std::size_t task) {
+        std::size_t max_possible_matches = vectors.size();
+        std::size_t count_requested = max_possible_matches;
+        std::vector<vector_key_t> matched_keys(count_requested);
+        std::vector<distance_t> matched_distances(count_requested);
+        std::size_t matched_count = 0;
 
-    // Try batch removals and concurrent replacements
-    if constexpr (punned_ak && 0) { // TODO: Fix
-        // Remove all the keys
-        executor.fixed(vectors.size(), [&](std::size_t thread, std::size_t task) {
-            using labeling_result_t = typename index_t::labeling_result_t;
-            vector_key_t key = key_max - task;
-            labeling_result_t result = index.remove(key);
-            expect(bool(result));
-        });
-        expect(index.size() == 0);
+        // Invoke the search kernel
+        if constexpr (punned_ak) {
+            index_search_result_t result = index.search(vectors[task].data(), count_requested, args...);
+            expect(result);
+            matched_count = result.dump_to(matched_keys.data(), matched_distances.data());
+        } else {
+            index_search_config_t config;
+            config.thread = thread;
+            index_search_result_t result = index.search(vectors[task].data(), count_requested, args..., config);
+            expect(result);
+            matched_count = result.dump_to(matched_keys.data(), matched_distances.data());
+        }
 
-        // Add them back
-        executor.fixed(vectors.size(), [&](std::size_t thread, std::size_t task) {
-            vector_key_t key = key_max - task;
-            index.add(key, vectors[task].data(), args...);
-        });
-        expect(index.size() == vectors.size());
-    }
+        // In approximate search we can't always expect the right answer to be found
+        //      expect_eq(matched_count, max_possible_matches);
+        //      expect_eq(matched_keys[0], start_key + task);
+        //      expect(std::abs(matched_distances[0]) < 0.01);
+        expect(matched_count <= max_possible_matches);
+
+        // Check that all the distance are monotonically rising
+        for (std::size_t i = 1; i < matched_count; i++)
+            expect(matched_distances[i - 1] <= matched_distances[i]);
+    });
 
     // Search again over mapped index
-    // file_head_result_t head = index_dense_metadata_from_path("tmp.usearch");
-    // expect(head.size == 3);
-    index.view("tmp.usearch");
-    matched_count = index.search(vector_first, 5, args...).dump_to(matched_keys, matched_distances);
-    expect(matched_count == 3);
-    expect(matched_keys[0] == key_first);
-    expect(std::abs(matched_distances[0]) < 0.01);
+    expect(index.save("tmp.usearch"));
 
-    // Check over-sampling beyond the size of the collection
     {
+        auto copy_result = index.copy();
+        expect(copy_result);
+        index_at copied_index = std::move(copy_result.index);
+        expect_eq(copied_index.size(), vectors.size());
+    }
+
+    // Check for duplicates
+    if constexpr (punned_ak) {
+        if (index.config().enable_key_lookups) {
+            expect(index.try_reserve({vectors.size() + 1u, executor.size()}));
+            index_add_result_t result = index.add(key_first, vector_first.data(), args...);
+            expect_eq(!!result, index.multi());
+            result.error.release();
+
+            std::size_t first_key_count = index.count(key_first);
+            expect_eq(first_key_count, 1ul + index.multi());
+        }
+    }
+
+    // Recover the state before the duplicate insertion
+    expect(index.view("tmp.usearch"));
+
+    // Parallel search over the same vectors
+    executor.fixed(vectors.size(), [&](std::size_t thread, std::size_t task) {
+        // Check over-sampling beyond the size of the collection
         std::size_t max_possible_matches = vectors.size();
-        std::size_t count_requested = max_possible_matches * 4;
+        std::size_t count_requested = max_possible_matches * 10;
         std::vector<vector_key_t> matched_keys(count_requested);
         std::vector<distance_t> matched_distances(count_requested);
+        std::size_t matched_count = 0;
+
+        // Invoke the search kernel
+        if constexpr (punned_ak) {
+            index_search_result_t result = index.search(vectors[task].data(), count_requested, args...);
+            expect(result);
+            matched_count = result.dump_to(matched_keys.data(), matched_distances.data());
+        } else {
+            index_search_config_t config;
+            config.thread = thread;
+            index_search_result_t result = index.search(vectors[task].data(), count_requested, args..., config);
+            expect(result);
+            matched_count = result.dump_to(matched_keys.data(), matched_distances.data());
+        }
 
-        matched_count = index                                               //
-                            .search(vector_first, count_requested, args...) //
-                            .dump_to(matched_keys.data(), matched_distances.data());
+        // In approximate search we can't always expect the right answer to be found
+        //      expect_eq(matched_count, max_possible_matches);
+        //      expect_eq(matched_keys[0], start_key + task);
+        //      expect(std::abs(matched_distances[0]) < 0.01);
         expect(matched_count <= max_possible_matches);
-        expect(matched_keys[0] == key_first);
-        expect(std::abs(matched_distances[0]) < 0.01);
 
         // Check that all the distance are monotonically rising
         for (std::size_t i = 1; i < matched_count; i++)
             expect(matched_distances[i - 1] <= matched_distances[i]);
-    }
+    });
 
+    // Try retrieving a vector from a deserialized index
     if constexpr (punned_ak) {
-        std::vector<scalar_t> vec_recovered_from_view(dimensions);
-        index.get(key_second, vec_recovered_from_view.data());
-        expect(std::equal(vector_second, vector_second + dimensions, vec_recovered_from_view.data()));
+        if (index.config().enable_key_lookups) {
+            expect(index.contains(key_first));
+            expect_eq(index.count(key_first), 1);
+            std::vector<scalar_t> vector_reloaded(dimensions);
+            index.get(key_first, vector_reloaded.data());
+            expect(std::equal(vector_first.data(), vector_first.data() + dimensions, vector_reloaded.data()));
+        }
 
         auto compaction_result = index.compact();
-        expect(bool(compaction_result));
+        expect(compaction_result);
     }
 
     expect(index.memory_usage() > 0);
@@ -278,10 +581,60 @@ void test_cosine(index_at& index, std::vector<std::vector<scalar_at>> const& vec
     // Check metadata
     if constexpr (punned_ak) {
         index_dense_metadata_result_t meta = index_dense_metadata_from_path("tmp.usearch");
-        expect(bool(meta));
+        expect(meta);
     }
 }
 
+/**
+ * Stress-tests the behavior of the type-punned higher-level index under heavy concurrent insertions,
+ * removals and updates.
+ *
+ * @param index Reference to the index where vectors will be stored and searched.
+ * @param start_key The key for the first `vector`, others are generated with increments.
+ * @param vectors A collection of vectors to be tested.
+ * @param executor_threads Number of threads to be used for concurrent operations.
+ * @tparam punned_ak Template parameter that determines specific behaviors or checks in the test based on its value.
+ * @tparam index_at Type of the index being tested.
+ * @tparam scalar_at Data type of the elements in the vectors.
+ * @tparam extra_args_at Variadic template parameter types for additional configuration.
+ */
+template <typename index_at, typename scalar_at, typename... extra_args_at>
+void test_punned_concurrent_updates(index_at& index, typename index_at::vector_key_t const start_key,
+                                    std::vector<std::vector<scalar_at>> const& vectors, std::size_t executor_threads) {
+
+    using index_t = index_at;
+
+    // Try batch requests, heavily oversubscribing the CPU cores
+    executor_default_t executor(executor_threads);
+    expect(index.try_reserve({vectors.size(), executor.size()}));
+    executor.fixed(vectors.size(), [&](std::size_t, std::size_t task) {
+        using add_result_t = typename index_t::add_result_t;
+        add_result_t result = index.add(start_key + task, vectors[task].data());
+        expect(result);
+    });
+    expect_eq(index.size(), vectors.size());
+
+    // Without key lookups we can't do much more
+    if (!index.config().enable_key_lookups)
+        return;
+
+    // Remove all the keys
+    executor.fixed(vectors.size(), [&](std::size_t, std::size_t task) {
+        using labeling_result_t = typename index_t::labeling_result_t;
+        labeling_result_t result = index.remove(start_key + task);
+        expect(result);
+    });
+    expect_eq(index.size(), 0);
+
+    // Add them back, which under the hood will trigger the `update`
+    executor.fixed(vectors.size(), [&](std::size_t, std::size_t task) {
+        using add_result_t = typename index_t::add_result_t;
+        add_result_t result = index.add(start_key + task, vectors[task].data());
+        expect(result);
+    });
+    expect_eq(index.size(), vectors.size());
+}
+
 /**
  * Overloaded function to test cosine similarity index functionality using specific scalar, key, and slot types.
  *
@@ -334,33 +687,81 @@ void test_cosine(std::size_t collection_size, std::size_t dimensions) {
     };
 
     // Template:
-    for (std::size_t connectivity : {3, 13, 50}) {
-        std::printf("- templates with connectivity %zu \n", connectivity);
+    auto run_templated = [&](std::size_t connectivity) {
+        std::printf("-- templates with connectivity %zu \n", connectivity);
         metric_t metric{&vector_of_vectors, dimensions};
         index_config_t config(connectivity);
-        aligned_wrapper_gt<index_typed_t> aligned_index;
-        test_cosine<false>(*aligned_index.index, vector_of_vectors, metric);
-    }
+
+        // Toy example
+        if (vector_of_vectors.size() >= 3) {
+            aligned_wrapper_gt<index_typed_t> aligned_index(config);
+            test_minimal_three_vectors<false, index_typed_t>( //
+                *aligned_index.index,                         //
+                42, vector_of_vectors[0],                     //
+                43, vector_of_vectors[1],                     //
+                44, vector_of_vectors[2], metric);
+        }
+        // Larger collection
+        {
+            aligned_wrapper_gt<index_typed_t> aligned_index(config);
+            test_collection<false, index_typed_t>(*aligned_index.index, 42, vector_of_vectors, metric);
+        }
+    };
+    for (std::size_t connectivity : {3, 13, 50})
+        run_templated(connectivity);
 
     // Type-punned:
-    for (bool multi : {false, true}) {
-        for (std::size_t connectivity : {3, 13, 50}) {
-            std::printf("- punned with connectivity %zu \n", connectivity);
-            using index_t = index_dense_gt<vector_key_t, slot_t>;
-            metric_punned_t metric(dimensions, metric_kind_t::cos_k, scalar_kind<scalar_at>());
-            index_dense_config_t config(connectivity);
-            config.multi = multi;
-            index_t index;
-            {
-                index_t index_tmp1 = index_t::make(metric, config);
-                // move construction
-                index_t index_tmp2 = std::move(index_tmp1);
-                // move assignment
-                index = std::move(index_tmp2);
-            }
-            test_cosine<true>(index, vector_of_vectors);
+    auto run_punned = [&](bool multi, bool enable_key_lookups, std::size_t connectivity) {
+        std::printf("-- punned with connectivity %zu, multi: %s, lookups: %s \n", connectivity, multi ? "yes" : "no",
+                    enable_key_lookups ? "yes" : "no");
+        using index_t = index_dense_gt<vector_key_t, slot_t>;
+        using index_result_t = typename index_t::state_result_t;
+        metric_punned_t metric(dimensions, metric_kind_t::cos_k, scalar_kind<scalar_at>());
+        index_dense_config_t config(connectivity);
+        config.multi = multi;
+        config.enable_key_lookups = enable_key_lookups;
+
+        // Toy example
+        if (vector_of_vectors.size() >= 3) {
+            index_result_t index_result = index_t::make(metric, config);
+            test_minimal_three_vectors<true>( //
+                index_result.index,           //
+                42, vector_of_vectors[0],     //
+                43, vector_of_vectors[1],     //
+                44, vector_of_vectors[2]);
         }
-    }
+        if (vector_of_vectors.size() >= 3 && enable_key_lookups) {
+            index_result_t index_result = index_t::make(metric, config);
+            test_punned_add_remove_vector( //
+                index_result.index,        //
+                vector_of_vectors[0],      //
+                vector_of_vectors[1]);
+        }
+        // Larger collection
+        {
+            index_result_t index_result = index_t::make(metric, config);
+            test_collection<true>(index_result.index, 42, vector_of_vectors);
+        }
+
+        // Try running benchmarks with a different number of threads
+        for (std::size_t threads : {
+                 static_cast<std::size_t>(1),
+                 // TODO: Multithreaded updates should word differently and may involve a search first
+                 //  static_cast<std::size_t>(2),
+                 //  static_cast<std::size_t>(std::thread::hardware_concurrency()),
+                 //  static_cast<std::size_t>(std::thread::hardware_concurrency() * 4),
+                 //  static_cast<std::size_t>(vector_of_vectors.size()),
+             }) {
+            index_result_t index_result = index_t::make(metric, config);
+            index_t& index = index_result.index;
+            test_punned_concurrent_updates(index, 42, vector_of_vectors, threads);
+        }
+    };
+
+    for (bool multi : {false, true})
+        for (bool enable_key_lookups : {true, false})
+            for (std::size_t connectivity : {3, 13, 50})
+                run_punned(multi, enable_key_lookups, connectivity);
 }
 
 /**
@@ -384,14 +785,16 @@ template <typename key_at, typename slot_at> void test_tanimoto(std::size_t dime
     std::size_t words = divide_round_up<CHAR_BIT>(dimensions);
     metric_punned_t metric(words, metric_kind_t::tanimoto_k, scalar_kind_t::b1x8_k);
     index_config_t config(connectivity);
-    index_punned_t index = index_punned_t::make(metric, config);
+    auto index_result = index_punned_t::make(metric, config);
+    expect(index_result);
+    index_punned_t& index = index_result.index;
 
     executor_default_t executor;
     std::size_t batch_size = 1000;
     std::vector<b1x8_t> scalars(batch_size * index.scalar_words());
     std::generate(scalars.begin(), scalars.end(), [] { return static_cast<b1x8_t>(std::rand()); });
 
-    index.reserve({batch_size + index.size(), executor.size()});
+    index.try_reserve({batch_size + index.size(), executor.size()});
     executor.fixed(batch_size, [&](std::size_t thread, std::size_t task) {
         index.add(task + 25000, scalars.data() + index.scalar_words() * task, thread);
     });
@@ -423,14 +826,16 @@ void test_absurd(std::size_t dimensions, std::size_t connectivity, std::size_t e
     using index_punned_t = index_dense_gt<vector_key_t, slot_t>;
     metric_punned_t metric(dimensions, metric_kind_t::cos_k, scalar_kind_t::f32_k);
     index_dense_config_t config(connectivity, expansion_add, expansion_search);
-    index_punned_t index = index_punned_t::make(metric, config);
+    auto index_result = index_punned_t::make(metric, config);
+    expect(index_result);
+    index_punned_t& index = index_result.index;
 
     std::size_t count_max = (std::max)(count_vectors, count_wanted);
     std::size_t needed_scalars = count_max * dimensions;
     std::vector<f32_t> scalars(needed_scalars);
     std::generate(scalars.begin(), scalars.end(), [] { return static_cast<f32_t>(std::rand()); });
 
-    expect(index.reserve({count_vectors, count_max}));
+    expect(index.try_reserve({count_vectors, count_max}));
     index.change_expansion_add(expansion_add);
     index.change_expansion_search(expansion_search);
 
@@ -438,7 +843,7 @@ void test_absurd(std::size_t dimensions, std::size_t connectivity, std::size_t e
     {
         executor_default_t executor(count_vectors);
         executor.fixed(count_vectors, [&](std::size_t thread, std::size_t task) {
-            expect((bool)index.add(task + 25000, scalars.data() + index.scalar_words() * task, thread));
+            expect(index.add(task + 25000, scalars.data() + index.scalar_words() * task, thread));
         });
     }
 
@@ -449,7 +854,7 @@ void test_absurd(std::size_t dimensions, std::size_t connectivity, std::size_t e
             std::vector<vector_key_t> keys(count_wanted);
             std::vector<f32_t> distances(count_wanted);
             auto results = index.search(scalars.data() + index.scalar_words() * task, count_wanted, thread);
-            expect((bool)results);
+            expect(results);
             auto count_found = results.dump_to(keys.data(), distances.data());
             expect(count_found <= count_wanted);
             if (count_vectors && count_wanted)
@@ -459,7 +864,7 @@ void test_absurd(std::size_t dimensions, std::size_t connectivity, std::size_t e
 }
 
 /**
- * Tests the exact search functionality over a dataset of vectors, @b wigthout constructing the index.
+ * Tests the exact search functionality over a dataset of vectors, @b without constructing the index.
  *
  * Generates a dataset of vectors and performs exact search queries to verify that the search results are correct.
  * This function mainly validates the basic functionality of exact searches using a given similarity metric.
@@ -469,7 +874,7 @@ void test_absurd(std::size_t dimensions, std::size_t connectivity, std::size_t e
  * @param wanted_count Number of top matches required from each query.
  */
 void test_exact_search(std::size_t dataset_count, std::size_t queries_count, std::size_t wanted_count) {
-    std::size_t dimensions = 10;
+    std::size_t dimensions = 32;
     metric_punned_t metric(dimensions, metric_kind_t::cos_k);
 
     std::random_device rd;
@@ -505,7 +910,7 @@ void test_sets(std::size_t collection_size, std::size_t min_set_length, std::siz
     /// Jaccard is a fraction, so let's use a some float
     using set_distance_t = double;
 
-    // Aliasis for the index overload
+    // Aliases for the index overload
     using vector_key_t = key_at;
     using slot_t = slot_at;
     using index_t = index_gt<set_distance_t, vector_key_t, slot_t>;
@@ -576,9 +981,9 @@ template <typename key_at, typename slot_at> void test_strings() {
     namespace sz = ashvardanian::stringzilla;
 
     /// Levenshtein distance is an integer
-    using levenshtein_distance_t = std::uint64_t;
+    using levenshtein_distance_t = std::int64_t;
 
-    // Aliasis for the index overload
+    // Aliases for the index overload
     using vector_key_t = key_at;
     using slot_t = slot_at;
     using index_t = index_gt<levenshtein_distance_t, vector_key_t, slot_t>;
@@ -610,10 +1015,10 @@ template <typename key_at, typename slot_at> void test_strings() {
             return between(some_vector, str_at(get_slot(member)));
         }
         levenshtein_distance_t operator()(member_citerator_t const& a, member_citerator_t const& b) const {
-            return between(str_at(get_slot(b)), str_at(get_slot(a)));
+            return between(str_at(get_slot(*b)), str_at(get_slot(*a)));
         }
         levenshtein_distance_t operator()(std::string_view some_vector, member_citerator_t const& member) const {
-            return between(some_vector, str_at(get_slot(member)));
+            return between(some_vector, str_at(get_slot(*member)));
         }
     };
 
@@ -631,7 +1036,69 @@ template <typename key_at, typename slot_at> void test_strings() {
     }
 }
 
+/**
+ * @brief Tests replacing and updating entries in index_dense_gt to ensure consistency after modifications.
+ */
+template <typename key_at, typename slot_at> void test_replacing_update() {
+
+    using vector_key_t = key_at;
+    using slot_t = slot_at;
+
+    using index_punned_t = index_dense_gt<vector_key_t, slot_t>;
+    metric_punned_t metric(1, metric_kind_t::l2sq_k, scalar_kind_t::f32_k);
+    auto index_result = index_punned_t::make(metric);
+    expect(index_result);
+    index_punned_t& index = index_result.index;
+
+    // Reserve space for 3 entries
+    index.try_reserve(3);
+    auto as_ptr = [](float v) {
+        static float value;
+        value = v;
+        return &value;
+    };
+
+    // Add 3 entries
+    index.add(42, as_ptr(1.1f));
+    index.add(43, as_ptr(2.1f));
+    index.add(44, as_ptr(3.1f));
+    expect_eq(index.size(), 3);
+
+    // Assert initial state
+    auto initial_search = index.search(as_ptr(1.0f), 3);
+    expect_eq(initial_search.size(), 3);
+    expect_eq(initial_search[0].member.key, 42);
+    expect_eq(initial_search[1].member.key, 43);
+    expect_eq(initial_search[2].member.key, 44);
+
+    // Replace the second entry
+    index.remove(43);
+    index.add(43, as_ptr(2.2f));
+    expect_eq(index.size(), 3);
+
+    // Assert state after replacing second entry
+    auto post_second_replacement = index.search(as_ptr(1.0f), 3);
+    expect_eq(post_second_replacement.size(), 3);
+    expect_eq(post_second_replacement[0].member.key, 42);
+    expect_eq(post_second_replacement[1].member.key, 43);
+    expect_eq(post_second_replacement[2].member.key, 44);
+
+    // Replace the first entry
+    index.remove(42);
+    index.add(42, as_ptr(1.2f));
+    expect_eq(index.size(), 3);
+
+    // Assert state after replacing first entry
+    auto final_search = index.search(as_ptr(1.0f), 3, 0);
+    expect_eq(final_search.size(), 3);
+    expect_eq(final_search[0].member.key, 42);
+    expect_eq(final_search[1].member.key, 43);
+    expect_eq(final_search[2].member.key, 44);
+}
+
 int main(int, char**) {
+    test_uint40();
+    test_cosine<float, std::int64_t, uint40_t>(10, 10);
 
     // Exact search without constructing indexes.
     // Great for validating the distance functions.
@@ -643,36 +1110,42 @@ int main(int, char**) {
 
     // Make sure the initializers and the algorithms can work with inadequately small values.
     // Be warned - this combinatorial explosion of tests produces close to __500'000__ tests!
-    std::printf("Testing absurd index configs\n");
-    for (std::size_t connectivity : {0, 1, 2, 3})
-        for (std::size_t dimensions : {1, 2, 3}) // TODO: Add zero?
-            for (std::size_t expansion_add : {0, 1, 2, 3})
-                for (std::size_t expansion_search : {0, 1, 2, 3})
-                    for (std::size_t count_vectors : {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10})
-                        for (std::size_t count_wanted : {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10})
-                            test_absurd<std::int64_t, std::uint32_t>(dimensions, connectivity, expansion_add,
-                                                                     expansion_search, count_vectors, count_wanted);
-
-    // Use just one
+    std::printf("Testing allowed, but absurd index configs\n");
+    for (std::size_t connectivity : {2, 3})   // ! Zero maps to default, one degenerates
+        for (std::size_t dimensions : {1, 3}) // ! Zero will raise
+            for (std::size_t expansion : {0, 1, 3})
+                for (std::size_t count_vectors : {0, 1, 2, 17})
+                    for (std::size_t count_wanted : {0, 1, 3, 19}) {
+                        test_absurd<std::int64_t, slot32_t>(dimensions, connectivity, expansion, expansion,
+                                                            count_vectors, count_wanted);
+                        test_absurd<uint40_t, uint40_t>(dimensions, connectivity, expansion, expansion, count_vectors,
+                                                        count_wanted);
+                    }
+
+    // TODO: Test absurd configs that are banned
+    // for (metric_kind_t metric_kind : {metric_kind_t::cos_k, metric_kind_t::unknown_k, metric_kind_t::haversine_k}) {}
+
+    // Test with cosine metric - the most common use case
+    std::printf("Testing common cases\n");
     for (std::size_t collection_size : {10, 500})
         for (std::size_t dimensions : {97, 256}) {
-            std::printf("Indexing %zu vectors with cos: <float, std::int64_t, std::uint32_t> \n", collection_size);
-            test_cosine<float, std::int64_t, std::uint32_t>(collection_size, dimensions);
-            std::printf("Indexing %zu vectors with cos: <float, std::int64_t, uint40_t> \n", collection_size);
+            std::printf("- Indexing %zu vectors with cos: <float, std::int64_t, slot32_t> \n", collection_size);
+            test_cosine<float, std::int64_t, slot32_t>(collection_size, dimensions);
+            std::printf("- Indexing %zu vectors with cos: <float, std::int64_t, uint40_t> \n", collection_size);
             test_cosine<float, std::int64_t, uint40_t>(collection_size, dimensions);
         }
 
-    // Test with binaty vectors
+    // Test with binary vectors
     std::printf("Testing binary vectors\n");
     for (std::size_t connectivity : {3, 13, 50})
         for (std::size_t dimensions : {97, 256})
-            test_tanimoto<std::int64_t, std::uint32_t>(dimensions, connectivity);
+            test_tanimoto<std::int64_t, slot32_t>(dimensions, connectivity);
 
     // Beyond dense equi-dimensional vectors - integer sets
     std::printf("Testing sparse vectors, strings, and sets\n");
     for (std::size_t set_size : {1, 100, 1000})
-        test_sets<std::int64_t, std::uint32_t>(set_size, 20, 30);
-    test_strings<std::int64_t, std::uint32_t>();
+        test_sets<std::int64_t, slot32_t>(set_size, 20, 30);
+    test_strings<std::int64_t, slot32_t>();
 
     return 0;
 }
diff --git a/java/test/IndexTest.java b/java/test/IndexTest.java
index e0e1de05..85750d7b 100644
--- a/java/test/IndexTest.java
+++ b/java/test/IndexTest.java
@@ -1,5 +1,9 @@
+import static org.junit.Assert.assertArrayEquals;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertThrows;
+
 import java.io.File;
-import java.util.Arrays;
+import java.io.IOException;
 
 import org.junit.Test;
 
@@ -20,12 +24,62 @@ public void test() {
         String path = "./tmp/";
         deleteDirectoryFiles(path);
 
+        try (Index index = new Index.Config().metric("cos").dimensions(2).build()) {
+            float vec[] = { 10, 20 };
+            index.reserve(10);
+            index.add(42, vec);
+            int[] keys = index.search(vec, 5);
+        }
+
+        System.out.println("Java Tests Passed!");
+    }
+
+    @Test
+    public void testGetSuccess() {
+        try (Index index = new Index.Config().metric("cos").dimensions(2).build()) {
+            float vec[] = { 10, 20 };
+            index.reserve(10);
+            index.add(42, vec);
+
+            assertArrayEquals(vec, index.get(42), 0.01f);
+        }
+    }
+
+    @Test
+    public void testGetFailed() {
+        try (Index index = new Index.Config().metric("cos").dimensions(2).build()) {
+            float vec[] = { 10, 20 };
+            index.reserve(10);
+            index.add(42, vec);
+
+            assertThrows(IllegalArgumentException.class, () -> index.get(41));
+        }
+    }
+
+    @Test
+    public void testUseAfterClose() {
         Index index = new Index.Config().metric("cos").dimensions(2).build();
         float vec[] = { 10, 20 };
         index.reserve(10);
         index.add(42, vec);
-        int[] keys = index.search(vec, 5);
+        assertEquals(1, index.size());
+        index.close();
+        assertThrows(IllegalStateException.class, () -> index.size());
+    }
 
-        System.out.println("Java Tests Passed!");
+    @Test
+    public void testLoadFromPath() throws IOException {
+        File indexFile = File.createTempFile("test", "uidx");
+
+        float vec[] = { 10, 20 };
+        try (Index index = new Index.Config().metric("cos").dimensions(2).build()) {
+            index.reserve(10);
+            index.add(42, vec);
+            index.save(indexFile.getAbsolutePath());
+        }
+
+        try (Index index = Index.loadFromPath(indexFile.getAbsolutePath())) {
+            assertArrayEquals(vec, index.get(42), 0.01f);
+        }
     }
 }
diff --git a/python/scripts/test_index.py b/python/scripts/test_index.py
index c9f09f81..c32e48a7 100644
--- a/python/scripts/test_index.py
+++ b/python/scripts/test_index.py
@@ -190,6 +190,12 @@ def test_index_save_load_restore_copy(ndim, quantization, batch_size):
         vectors = random_vectors(count=batch_size, ndim=ndim)
         index.add(keys, vectors, threads=threads)
 
+    # Try copying the original
+    copied_index = index.copy()
+    assert len(copied_index) == len(index)
+    if batch_size > 0:
+        assert np.allclose(np.vstack(copied_index.get(keys)), np.vstack(index.get(keys)))
+
     index.save("tmp.usearch")
     index.clear()
     assert len(index) == 0
@@ -208,6 +214,7 @@ def test_index_save_load_restore_copy(ndim, quantization, batch_size):
     if batch_size > 0:
         assert len(index[0].flatten()) == ndim
 
+    # Try copying the restored index
     copied_index = index.copy()
     assert len(copied_index) == len(index)
     if batch_size > 0:
@@ -262,6 +269,7 @@ def test_index_contains_remove_rename(batch_size):
     assert np.sum(index.count(removed_keys)) == len(index)
 
 
+@pytest.mark.skip(reason="Not guaranteed")
 @pytest.mark.parametrize("batch_size", [3, 17, 33])
 @pytest.mark.parametrize("threads", [1, 4])
 def test_index_oversubscribed_search(batch_size: int, threads: int):
diff --git a/python/scripts/test_jit.py b/python/scripts/test_jit.py
index b4041c34..6f683526 100644
--- a/python/scripts/test_jit.py
+++ b/python/scripts/test_jit.py
@@ -17,6 +17,12 @@
 @pytest.mark.parametrize("ndim", dimensions)
 @pytest.mark.parametrize("batch_size", batch_sizes)
 def test_index_numba(ndim: int, batch_size: int):
+    """
+    Uses Numba to show how Python code can be JIT compiled and injected into USearch.
+    Uses the dot-product distance with different function signatures as an example.
+
+    ! Requires the `numba` package to work.
+    """
     try:
         from numba import cfunc, types, carray
     except ImportError:
@@ -80,10 +86,96 @@ def python_inner_product_three_args(a, b, ndim):
         assert all(matches_keys[i] == keys[i] for i in range(batch_size)), f"Received {matches_keys}"
 
 
+@pytest.mark.parametrize("ndim", [20, 50])
+@pytest.mark.parametrize("batch_size", [100])
+def test_index_numba_negative(ndim: int, batch_size: int):
+    """
+    Uses Numba to validate the hypothesis, that HNSW can work fine with arbitrary
+    symmetric similarity measures, and not only with distance metrics.
+    For that we construct a function that only returns negative values, and scales
+    them before returning.
+
+    ! Requires the `numba` package to work.
+    """
+    try:
+        from numba import cfunc, types, carray
+    except ImportError:
+        pytest.skip("Numba is not installed.")
+        return
+
+    # Showcases how to use Numba to JIT-compile similarity measures for USearch.
+    # https://numba.readthedocs.io/en/stable/reference/jit-compilation.html#c-callbacks
+    signature_two_args = types.float32(
+        types.CPointer(types.float32),
+        types.CPointer(types.float32),
+    )
+
+    @cfunc(signature_two_args)
+    def normal_cosine_distance(a, b):
+        a_array = carray(a, ndim)
+        b_array = carray(b, ndim)
+        a2, b2, ab = 0.0, 0.0, 0.0
+        for i in range(ndim):
+            a2 += a_array[i] * a_array[i]
+            b2 += b_array[i] * b_array[i]
+            ab += a_array[i] * b_array[i]
+        return 1 - ab / (np.sqrt(a2) * np.sqrt(b2))
+
+    @cfunc(signature_two_args)
+    def translated_cosine_distance(a, b):
+        return (normal_cosine_distance(a, b) - 3) * 2
+
+    # Create 2 indices
+    normal_metric = CompiledMetric(
+        pointer=normal_cosine_distance.address,
+        kind=MetricKind.Cos,
+        signature=MetricSignature.ArrayArray,
+    )
+    translated_metric = CompiledMetric(
+        pointer=translated_cosine_distance.address,
+        kind=MetricKind.Cos,
+        signature=MetricSignature.ArrayArray,
+    )
+    normal_index = Index(
+        ndim=ndim,
+        metric=normal_metric,
+        dtype=np.float32,
+        # TODO: support `seed=42` for reproducibility
+    )
+    translated_index = Index(
+        ndim=ndim,
+        metric=translated_metric,
+        dtype=np.float32,
+        # TODO: support `seed=42` for reproducibility
+    )
+
+    # Populate them with identical data
+    keys = np.arange(batch_size)
+    vectors = random_vectors(count=batch_size, ndim=ndim)
+    normal_index.add(keys, vectors, threads=1)
+    translated_index.add(keys, vectors, threads=1)
+
+    # Make sure, we receive the same keys
+    count_queries = 10
+    normal_matches = normal_index.search(vectors, count_queries, exact=False)
+    translated_matches = translated_index.search(vectors, count_queries, exact=False)
+
+    for query in keys.tolist():
+        normal_keys = [normal_matches[query][i].key for i in range(count_queries)]
+        translated_keys = [translated_matches[query][i].key for i in range(count_queries)]
+        assert normal_keys == translated_keys, f"Expected {normal_keys} == {translated_keys} for key {query}"
+
+
 # Just one size for Cppyy to avoid redefining kernels in the global namespace
 @pytest.mark.parametrize("ndim", dimensions[-1:])
 @pytest.mark.parametrize("batch_size", batch_sizes[-1:])
 def test_index_cppyy(ndim: int, batch_size: int):
+    """
+    Uses Cppyy to show how C++ code can be JIT compiled and injected into USearch.
+    Uses the dot-product distance with different function signatures as an example.
+
+    ! Requires the `cppyy` package to work.
+    """
     try:
         import cppyy
         import cppyy.ll
@@ -142,6 +234,33 @@ def test_index_cppyy(ndim: int, batch_size: int):
 @pytest.mark.parametrize("ndim", [8])
 @pytest.mark.parametrize("batch_size", batch_sizes)
 def test_index_peachpy(ndim: int, batch_size: int):
+    """
+    Uses PeachPy to show how x86_64 assembly code can be JIT compiled and injected into USearch.
+    For brevety, we only use the dot-product distance with two float arrays of fixed size (8 dimensions)
+    as an example. 8 such values fit perfectly into a single YMM register on x86.
+
+    ! Runs only on x86_64 CPUs with AVX and AVX2 support.
+    ! Requires the `py-cpuinfo` package to check if AVX2 is supported.
+    ! Requires the `peachpy` package to assemble the code.
+    """
+    try:
+        import platform
+
+        arch = platform.machine()
+        if arch != "x86_64":
+            pytest.skip("We only use PeachPy for 64-bit x86.")
+            return
+
+        import cpuinfo
+
+        info = cpuinfo.get_cpu_info()
+        if "avx2" not in info.get("flags", []):
+            pytest.skip("Current CPU doesn't support AVX2.")
+            return
+    except ImportError:
+        pytest.skip("PeachPy tests require `py-cpuinfo` to check if AVX2 is supported.")
+        return
+
     try:
         from peachpy import (
             Argument,