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

Issue:
Bug: add  remove index vector data  bad_alloc
### Describe the bug

<img width="656" alt="image" src="https://github.com/unum-cloud/usearch/assets/1203957/bb2256b7-add6-48d8-ab4f-9501016ffbf8">

libc++abi: terminating due to uncaught exception of type std::bad_alloc: std::bad_alloc

### Steps to reproduce

 Repeat test:  https://github.com/unum-cloud/usearch/pull/291

### Expected behavior

add success

### USearch version

v2.7.2

### Operating System

macos

### Hardware architecture

x86

### Which interface are you using?

Other bindings

### Contact Details

_No response_

### 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/.dockerignore b/.dockerignore
new file mode 100644
index 00000000..40c5639c
--- /dev/null
+++ b/.dockerignore
@@ -0,0 +1,93 @@
+# Ignore all files without an extension
+*
+!/**/
+!*.*
+
+# Temporary files
+.DS_Store
+*.fbin
+*.ibin
+datasets
+bin
+*.usearch
+.cache
+
+# C++ builds
+build
+build_release
+build_debug
+_deps
+CMakeCache.txt
+CMakeFiles
+cmake_install.cmake
+
+# Profiling with GProf and `perf` on Linux
+gmon.out
+perf.data
+
+# Python wrappers
+__pycache__
+*.egg-info
+dist/
+wheelhouse/
+
+# Python Environments
+venv/
+
+# JS wrappers
+package-lock.json
+node_modules/
+
+# Rust builds
+Cargo.lock
+target/
+
+# Java bindings
+.gradle
+*.class
+
+# ObjC and Swift
+.build
+.swiftpm
+
+# C# builds
+csharp/**/[Bb]in/
+csharp/**/[Oo]bj/
+csharp/lib
+csharp/packages
+
+# Prerequisites
+*.d
+
+# Compiled Object files
+*.slo
+*.lo
+*.o
+*.obj
+
+# Precompiled Headers
+*.gch
+*.pch
+
+# Compiled Dynamic libraries
+*.so
+*.dylib
+*.dll
+
+# Fortran module files
+*.mod
+*.smod
+
+# Allow golang go.mod
+!go.mod
+
+# Compiled Static libraries
+*.lai
+*.la
+*.a
+*.lib
+
+# Executables
+*.exe
+*.out
+*.app
diff --git a/.github/workflows/Dockerfile.libs b/.github/workflows/Dockerfile.libs
index 834c0824..f996cfc7 100644
--- a/.github/workflows/Dockerfile.libs
+++ b/.github/workflows/Dockerfile.libs
@@ -11,9 +11,13 @@ RUN apt-get update && \
     apt-get clean && \
     rm -rf /var/lib/apt/lists/*
 
+ENV CC=gcc-12
+ENV CXX=g++-12
+
 COPY . .
 
-RUN cd c && make libusearch_c.so
+RUN cmake -DCMAKE_BUILD_TYPE=Release -DUSEARCH_BUILD_LIB_C=1 -DUSEARCH_BUILD_TEST_CPP=0 -DUSEARCH_BUILD_BENCH_CPP=0 -B ./build_release
+RUN cmake --build ./build_release --config Release
 
 RUN if [ "$TARGETPLATFORM" = "linux/amd64" ]; then \
         export arch="amd"; \
@@ -26,7 +30,7 @@ RUN if [ "$TARGETPLATFORM" = "linux/amd64" ]; then \
     mkdir -p usearch_linux_"$arch"_"$version"/usr/local/lib && \
     mkdir usearch_linux_"$arch"_"$version"/usr/local/include && \
     cp c/usearch.h usearch_linux_"$arch"_"$version"/usr/local/include/ && \
-    cp c/libusearch_so.a usearch_linux_"$arch"_"$version"/usr/local/lib/ && \
+    cp build_release/libusearch_c.so usearch_linux_"$arch"_"$version"/usr/local/lib/ && \
     echo "Package: usearch\nVersion: $version\nMaintainer: Ash Vardanian\nArchitecture: "$arch"\nDescription: Faster & Smaller Single-File Search Engine for Vectors & Texts" > usearch_linux_"$arch"_"$version"/DEBIAN/control && \
     dpkg-deb --build usearch_linux_"$arch"_"$version" && \
     sshpass -p "$user_pass" scp -o StrictHostKeyChecking=no usearch_linux_"$arch"_"$version".deb "$user_name"@"$docker_ip":/home/$user_name/work/usearch/usearch/
\ No newline at end of file
diff --git a/.github/workflows/prerelease.yml b/.github/workflows/prerelease.yml
index b2278811..e075831c 100644
--- a/.github/workflows/prerelease.yml
+++ b/.github/workflows/prerelease.yml
@@ -7,302 +7,300 @@ on:
     branches: ["main-dev"]
 
 env:
-  BUILD_TYPE: Release
   GH_TOKEN: ${{ secrets.SEMANTIC_RELEASE_TOKEN }}
   PYTHONUTF8: 1
+  PYTHON_VERSION: 3.11
+  DOTNET_VERSION: 7.0.x
 
 # Sets permissions of the GITHUB_TOKEN to allow deployment to GitHub Pages
 permissions:
   contents: read
 
 jobs:
-  
-  test_cpp_c_ubuntu_gcc:
-    name: Test C++ Ubuntu (GCC)
-    runs-on: ubuntu-latest
-    
-    steps:
-    - uses: actions/checkout@v3
-      with:
-        ref: main-dev
-    - run: git submodule update --init --recursive
-    
-    - name: Install Dependencies
-      run: sudo apt update && sudo apt install -y cmake build-essential libjemalloc-dev libomp-dev g++-12
-        
-    - name: Build
-      run: |
-        export CC=gcc-12
-        export CXX=g++-12
-        cmake -B build -DCMAKE_BUILD_TYPE=Debug -DUSEARCH_BUILD_TEST_CPP=1 -DUSEARCH_BUILD_TEST_C=1 -DUSEARCH_USE_OPENMP=1 -DUSEARCH_USE_SIMSIMD=1 -DUSEARCH_USE_JEMALLOC=1
-        cmake --build build --config Debug
-        
-    - name: Run C++ tests
-      run: ./build/test_cpp
-    - name: Run C tests
-      run: ./build/test_c
-
-
-  test_cpp_c_ubuntu_clang:
-    name: Test C++ Ubuntu (Clang)
-    runs-on: ubuntu-latest
-    
-    steps:
-    - uses: actions/checkout@v3
-      with:
-        ref: main-dev
-    - run: git submodule update --init --recursive
-    
-    - name: Install Dependencies
-      run: sudo apt update && sudo apt install -y cmake build-essential libjemalloc-dev clang-15
-        
-    - name: Build
-      run: |
-        export CC=clang-15
-        export CXX=clang++-15
-        cmake -B build -DCMAKE_BUILD_TYPE=Debug -DUSEARCH_BUILD_TEST_CPP=1 -DUSEARCH_BUILD_TEST_C=1 -DUSEARCH_USE_SIMSIMD=1 -DUSEARCH_USE_JEMALLOC=1
-        cmake --build build --config Debug
-        
-    - name: Run C++ tests
-      run: ./build/test_cpp
-    - name: Run C tests
-      run: ./build/test_c
-
-
-  test_cpp_c_macos:
-    name: Test C++ MacOS
-    runs-on: macos-latest
-    steps:
-    - uses: actions/checkout@v3
-      with:
-        ref: main-dev
-    - run: git submodule update --init --recursive
-    
-    - name: Install Dependencies
-      run: |
-        brew update
-        brew install cmake
-    
-    - name: Build
-      run: |
-        cmake -B build -DCMAKE_BUILD_TYPE=Debug -DUSEARCH_BUILD_TEST_CPP=1 -DUSEARCH_BUILD_TEST_C=1
-        cmake --build build --config Debug
-    - name: Run C++ tests
-      run: ./build/test_cpp
-    - name: Run C tests
-      run: ./build/test_c
-
-  test_cpp_c_windows:
-    name: Test C++ Windows
-    runs-on: windows-latest
-    steps:
-    - uses: actions/checkout@v3
-      with:
-        ref: main-dev
-    - run: git submodule update --init --recursive
-    
-    - name: Install Dependencies
-      run: choco install cmake
-        
-    - name: Build
-      run: |
-        cmake -B build -DCMAKE_BUILD_TYPE=Debug -DUSEARCH_BUILD_TEST_CPP=1 -DUSEARCH_BUILD_TEST_C=1
-        cmake --build build --config Debug
-    - name: Run C++ tests
-      run: .\build\test_cpp
-    - name: Run C tests
-      run: .\build\test_c
-      
-  test_python_311:
-    name: Test Python
-    runs-on: ${{ matrix.os }}
-    strategy:
-      fail-fast: false
-      matrix:
-        os: [ubuntu-22.04, macOS-11, windows-2022]
-        python-version: ["3.11"]
+  test_ubuntu_gcc:
+    name: Ubuntu (GCC 12)
+    runs-on: ubuntu-22.04
+
+    env:
+      CC: gcc-12
+      CXX: g++-12
 
     steps:
       - uses: actions/checkout@v3
+        with:
+          ref: main-dev
       - run: git submodule update --init --recursive
-      - name: Set up Python ${{ matrix.python-version }}
+
+        # C/C++
+      - name: Build C/C++
+        run: |
+          sudo apt update
+          sudo apt install -y cmake build-essential libjemalloc-dev libomp-dev gcc-12 g++-12
+          cmake -B build_artifacts -DCMAKE_BUILD_TYPE=RelWithDebInfo -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
+          cmake --build build_artifacts --config RelWithDebInfo
+      - name: Test C++
+        run: ./build_artifacts/test_cpp
+      - name: Test C
+        run: ./build_artifacts/test_c
+
+        # Python
+      - name: Set up Python ${{ env.PYTHON_VERSION }}
         uses: actions/setup-python@v4
         with:
-          python-version: ${{ matrix.python-version }}
-      - name: Install dependencies
+          python-version: ${{ env.PYTHON_VERSION }}
+      - name: Build Python
         run: |
           python -m pip install --upgrade pip
           pip install pytest numpy
-      - name: Build locally
-        run: python -m pip install .
-      - name: Test with PyTest
+          python -m pip install .
+      - name: Test Python
         run: pytest python/scripts/ -s -x
 
+        # JavaScript
+      - name: Set up Node.js
+        uses: actions/setup-node@v3
+        with:
+          node-version: 18
+      - name: Build JavaScript
+        run: npm install
+      - name: Test JavaScript
+        run: npm ci && npm test
+
+        # Rust
+      - name: Test Rust
+        uses: actions-rs/toolchain@v1
+        with:
+          toolchain: stable
+          override: true
+
+        # Java
+      - name: Setup Java
+        uses: actions/setup-java@v3
+        with:
+          java-version: "11"
+          distribution: "adopt"
+      - name: Setup Gradle
+        uses: gradle/gradle-build-action@v2.4.2
+      - name: Test Java
+        run: gradle clean build
+
+        # C#
+      - name: Setup .NET ${{ env.DOTNET_VERSION }}
+        uses: actions/setup-dotnet@v3
+        with:
+          dotnet-version: ${{ env.DOTNET_VERSION }}
+      - name: Test .NET
+        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
+        shell: bash
+        working-directory: ${{ github.workspace }}/csharp
+
+        # GoLang
+        # With `LD_DEBUG=all` we detect the addresses of the libraries that are loaded
+      - name: Test GoLang
+        run: |
+          sudo cp ${{ github.workspace }}/build_artifacts/libusearch_c.so /usr/lib/libusearch_c.so
+          sudo cp ${{ github.workspace }}/c/usearch.h /usr/include/usearch.h
+          LD_DEBUG=all go test -v
+        working-directory: ${{ github.workspace }}/golang/
+
+  test_ubuntu_clang:
+    name: Ubuntu (Clang 16)
+    runs-on: ubuntu-22.04
 
-  test_python_37:
-    name: Test Python 3.7
-    runs-on: ${{ matrix.os }}
-    strategy:
-      fail-fast: false
-      matrix:
-        os: [ubuntu-22.04]
-        python-version: ["3.7"]
+    env:
+      CC: clang-16
+      CXX: clang++-16
 
     steps:
       - uses: actions/checkout@v3
+        with:
+          ref: main-dev
       - run: git submodule update --init --recursive
-      
-      - name: Set up Python ${{ matrix.python-version }}
+
+        # C/C++
+        # Clang 16 isn't available from default repos on Ubuntu 22.04, so we have to install it manually
+      - name: Build C/C++
+        run: |
+          sudo apt update
+          sudo apt install -y cmake build-essential libjemalloc-dev
+          wget https://apt.llvm.org/llvm.sh
+          chmod +x llvm.sh
+          sudo ./llvm.sh 16
+          cmake -B build_artifacts -DCMAKE_BUILD_TYPE=RelWithDebInfo -DUSEARCH_BUILD_TEST_CPP=1 -DUSEARCH_BUILD_TEST_C=1 -DUSEARCH_BUILD_LIB_C=1 -DDUSEARCH_USE_OPENMP=0 -DUSEARCH_USE_SIMSIMD=1 -DUSEARCH_USE_JEMALLOC=1
+          cmake --build build_artifacts --config RelWithDebInfo
+      - name: Test C++
+        run: ./build_artifacts/test_cpp
+      - name: Test C
+        run: ./build_artifacts/test_c
+
+        # Python
+      - name: Set up Python ${{ env.PYTHON_VERSION }}
         uses: actions/setup-python@v4
         with:
-          python-version: ${{ matrix.python-version }}
-
-      - name: Install dependencies
+          python-version: ${{ env.PYTHON_VERSION }}
+      - name: Build Python
         run: |
           python -m pip install --upgrade pip
           pip install pytest numpy
-
-      - name: Build locally
-        run: python -m pip install .
-      - name: Test with PyTest
+          python -m pip install .
+      - name: Test Python
         run: pytest python/scripts/ -s -x
 
+        # JavaScript
+      - name: Set up Node.js
+        uses: actions/setup-node@v3
+        with:
+          node-version: 18
+      - name: Build JavaScript
+        run: npm install
+      - name: Test JavaScript
+        run: npm ci && npm test
+
+        # C#
+      - name: Setup .NET ${{ env.DOTNET_VERSION }}
+        uses: actions/setup-dotnet@v3
+        with:
+          dotnet-version: ${{ env.DOTNET_VERSION }}
+      - name: Test .NET
+        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
+        shell: bash
+        working-directory: ${{ github.workspace }}/csharp
+
+  test_macos:
+    name: MacOS
+    runs-on: macos-12
 
-  test_javascript:
-    name: Test JavaScript
-    runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v3
+        with:
+          ref: main-dev
       - run: git submodule update --init --recursive
-      - uses: actions/setup-node@v3
+
+        # C/C++
+      - name: Build C/C++
+        run: |
+          brew update
+          brew install cmake
+          cmake -B build_artifacts -DCMAKE_BUILD_TYPE=RelWithDebInfo -DUSEARCH_BUILD_TEST_CPP=1 -DUSEARCH_BUILD_TEST_C=1 -DUSEARCH_BUILD_LIB_C=1
+          cmake --build build_artifacts --config RelWithDebInfo
+      - name: Test C++
+        run: ./build_artifacts/test_cpp
+      - name: Test C
+        run: ./build_artifacts/test_c
+
+        # Python
+      - name: Set up Python ${{ env.PYTHON_VERSION }}
+        uses: actions/setup-python@v4
+        with:
+          python-version: ${{ env.PYTHON_VERSION }}
+      - name: Build Python
+        run: |
+          python -m pip install --upgrade pip
+          pip install pytest numpy
+          python -m pip install .
+      - name: Test Python
+        run: pytest python/scripts/ -s -x
+
+        # JavaScript
+      - name: Set up Node.js
+        uses: actions/setup-node@v3
         with:
           node-version: 18
-      - run: npm install
-      - run: npm ci
-      - run: npm test
+      - name: Build JavaScript
+        run: npm install
+      - name: Test JavaScript
+        run: npm ci && npm test
 
-  test_rust:
-    name: Test Rust
-    runs-on: ubuntu-latest
-    steps:
-    - uses: actions/checkout@v3
-    - run: git submodule update --init --recursive
-    - uses: actions-rs/toolchain@v1
-      with:
-          toolchain: stable
-          override: true
+        # ObjC/Swift
+      - name: Build ObjC/Swift
+        run: swift build
+      - name: Test ObjC/Swift
+        run: swift test
 
-  test_java:
-    name: Test Java
-    runs-on: ubuntu-latest
-    steps:
-    - uses: actions/checkout@v3
-    - run: git submodule update --init --recursive
-    - uses: actions/setup-java@v3
-      with:
-        java-version: '11'
-        distribution: 'adopt'
-    - name: Setup Gradle
-      uses: gradle/gradle-build-action@v2.4.2
-    - name: Execute Gradle build
-      run: gradle clean build
-
-  test_swift:
-    name: Test ObjC & Swift
-    runs-on: macos-latest
-    steps:
-    - uses: actions/checkout@v3
-    - run: git submodule update --init --recursive
-    - name: Build
-      run: swift build
-    - name: Run tests
-      run: swift test
-
-  test_csharp:
-    name: Test C#
-    runs-on: ${{ matrix.os }}
-    strategy:
-      fail-fast: false
-      matrix:
-        os: [ubuntu-latest, windows-latest, macos-latest]
-        dotnet-version: ['7.0.x']
-    steps:
-      - uses: actions/checkout@v3
-      - run: git submodule update --init --recursive
-      - name: Setup .NET ${{ matrix.dotnet-version }}
+        # C#
+      - name: Setup .NET ${{ env.DOTNET_VERSION }}
         uses: actions/setup-dotnet@v3
         with:
-          dotnet-version: ${{ matrix.dotnet-version }}
-
-      - name: Ubuntu/macOS build native lib
-        if: matrix.os == 'ubuntu-latest' || matrix.os == 'macos-latest'
-        run: ./build_lib.sh
+          dotnet-version: ${{ env.DOTNET_VERSION }}
+      - name: Test .NET
+        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
         shell: bash
-        working-directory: ${{ github.workspace }}/csharp/eng/
+        working-directory: ${{ github.workspace }}/csharp
 
-      # Use cl.exe https://www.appveyor.com/docs/lang/cpp/#visual-studio-2017
-      # There is no support for c++11
-      - name: Windows MSVC build
-        if: matrix.os == 'windows-latest'
+  test_windows:
+    name: Windows
+    runs-on: windows-2022
+    steps:
+      - uses: actions/checkout@v3
+        with:
+          ref: main-dev
+      - run: git submodule update --init --recursive
+
+        # C/C++
+      - name: Build C/C++
         run: |
-          call "C:\Program Files\Microsoft Visual Studio\2022\Enterprise\VC\Auxiliary\Build\vcvars64.bat"
-          where cl
-          cl /EHsc /std:c++14 /O2 /LD /Fe:libusearch_c.dll lib.cpp /I. /I../include/ /I../fp16/include/
-        working-directory: ${{ github.workspace }}/c
-        shell: cmd
-
-      - name: Windows move dll to lib dir
-        if: matrix.os == 'windows-latest'
+          choco install cmake
+          cmake -B build_artifacts -DCMAKE_BUILD_TYPE=RelWithDebInfo -DUSEARCH_BUILD_TEST_CPP=1 -DUSEARCH_BUILD_TEST_C=1 -DUSEARCH_BUILD_LIB_C=1
+          cmake --build build_artifacts --config RelWithDebInfo
+      - name: Test C++
+        run: .\build_artifacts\test_cpp.exe
+      - name: Test C
+        run: .\build_artifacts\test_c.exe
+
+        # Python
+      - name: Set up Python ${{ env.PYTHON_VERSION }}
+        uses: actions/setup-python@v4
+        with:
+          python-version: ${{ env.PYTHON_VERSION }}
+      - name: Build Python
         run: |
-          mkdir -p "${GITHUB_WORKSPACE}/csharp/lib/runtimes/win-x64/native"
-          mv "${GITHUB_WORKSPACE}/c/libusearch_c.dll" "${GITHUB_WORKSPACE}/csharp/lib/runtimes/win-x64/native"
-        shell: bash
+          python -m pip install --upgrade pip
+          pip install pytest numpy
+          python -m pip install .
+      - name: Test Python
+        run: pytest python/scripts/ -s -x
 
-      - name: Build and test
-        run: dotnet test -c Release
-        shell: bash
-        working-directory: ${{ github.workspace }}/csharp/
+        # JavaScript
+      - name: Set up Node.js
+        uses: actions/setup-node@v3
+        with:
+          node-version: 18
+      - name: Build JavaScript
+        run: npm install
+      - name: Test JavaScript
+        run: npm ci && npm test
 
-  test_golang:
-    name: Test Golang
-    runs-on: ubuntu-latest
-    steps:
-    - uses: actions/checkout@v3
-      with:
-        persist-credentials: false
-        ref: 'main-dev'
-    - run: git submodule update --init --recursive
-
-    - name: Prepare environment
-      run: |
-        sudo apt update && 
-        sudo apt install -y build-essential
-      
-      # This is the weirdest step. GoLang runtime is having a hard time working with our static library...
-      # And doesn't want to link to the dynamic library... So instead, we rename the `.so` file `.a`, and
-      # it works just fine.
-    - name: Build library
-      run: |
-        cd golang/
-        make USEARCH_USE_OPENMP=0 USEARCH_USE_NATIVE_F16=0 USEARCH_USE_SIMSIMD=1 -C ../c libusearch_c.so
-        sudo cp ../c/libusearch_c.so /usr/local/lib/libusearch_c.a
-        sudo cp ../c/usearch.h /usr/local/include/usearch.h
-
-    - name: Run test
-      run: |
-        cd golang
-        go test -v
-        
+        # C#
+      - name: Setup .NET ${{ env.DOTNET_VERSION }}
+        uses: actions/setup-dotnet@v3
+        with:
+          dotnet-version: ${{ env.DOTNET_VERSION }}
+      - name: Test .NET
+        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
+        shell: bash
+        working-directory: ${{ github.workspace }}/csharp
 
   build_docker:
-    name: Test Docker Image
-    runs-on: ubuntu-latest
+    name: Docker
+    runs-on: ubuntu-22.04
     steps:
-    - uses: actions/checkout@v3
-    - run: git submodule update --init --recursive
-    - name: Build
-      uses: docker/build-push-action@v4
-      with:
-        context: .
-        load: true
-        push: false
+      - uses: actions/checkout@v3
+      - run: git submodule update --init --recursive
+      - name: Build
+        uses: docker/build-push-action@v4
+        with:
+          context: .
+          load: true
+          push: false
diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml
index b3eda7e7..ad7edf94 100644
--- a/.github/workflows/release.yml
+++ b/.github/workflows/release.yml
@@ -17,22 +17,20 @@ permissions:
   packages: write
 
 jobs:
-
   versioning:
     name: Semantic Release
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-22.04
     steps:
-    - uses: actions/checkout@v3
-      with:
-        persist-credentials: false
-    - uses: actions/setup-node@v3
-    - run: npm install --save-dev @semantic-release/exec @semantic-release/git conventional-changelog-eslint semantic-release && npx semantic-release
-
+      - uses: actions/checkout@v3
+        with:
+          persist-credentials: false
+      - uses: actions/setup-node@v3
+      - run: npm install --save-dev @semantic-release/exec @semantic-release/git conventional-changelog-eslint semantic-release && npx semantic-release
 
   rebase:
     name: Rebase Dev. Branch
     needs: versioning
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-22.04
     steps:
       - name: Checkout the latest code
         uses: actions/checkout@v3
@@ -44,7 +42,7 @@ jobs:
           git fetch origin main
           git checkout main-dev
           git rebase origin/main
-          
+
       - name: Push changes
         uses: CasperWA/push-protected@v2
         with:
@@ -53,148 +51,144 @@ jobs:
           unprotect_reviews: True
           force: True
 
-
   create_linux_deb_package:
     name: Create Debian Package for ${{ matrix.arch }}
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-22.04
     needs: versioning
     strategy:
       matrix:
         arch: ["linux/amd64", "linux/arm64"]
     steps:
-    - uses: actions/checkout@v3
-      with:
-        persist-credentials: false
-        ref: 'main'
-    - run: git submodule update --init --recursive
-
-    - name: Setup QEMU
-      uses: docker/setup-qemu-action@v2
-
-    - name: Setup Docker
-      uses: docker/setup-buildx-action@v2
-
-    - name: Get Docker daemon IP
-      id: dockerip
-      run: |
-        docker_ip=$(ip addr show docker0 | grep -Po 'inet \K[\d.]+') && \
-        echo "docker_ip=$docker_ip" >> "$GITHUB_OUTPUT"
-        
-    - name: Set runner user password
-      id: userpass
-      run: |
-        user_pass="1122"
-        echo "runner:$user_pass" | sudo chpasswd
-        echo "user_pass=$user_pass" >> "$GITHUB_OUTPUT"
-          
-    - name: Build library
-      run: |
-        docker buildx create --use
-        docker buildx build \
-        --platform ${{ matrix.arch }} \
-        --build-arg docker_ip=${{ steps.dockerip.outputs.docker_ip }} \
-        --build-arg user_pass=${{ steps.userpass.outputs.user_pass }} \
-        --file .github/workflows/Dockerfile.libs \
-        --tag unum/usearch-library:latest \
-        --load .
-    - name: Clear Docker buildx cache
-      run: docker buildx prune --all --force
-
-    - name: Upload archive
-      uses: xresloader/upload-to-github-release@v1
-      env:
-        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-      with:
-        file: "*.deb"
-        update_latest_release: true
+      - uses: actions/checkout@v3
+        with:
+          persist-credentials: false
+          ref: "main"
+      - run: git submodule update --init --recursive
+
+      - name: Setup QEMU
+        uses: docker/setup-qemu-action@v2
 
+      - name: Setup Docker
+        uses: docker/setup-buildx-action@v2
+
+      - name: Get Docker daemon IP
+        id: dockerip
+        run: |
+          docker_ip=$(ip addr show docker0 | grep -Po 'inet \K[\d.]+') && \
+          echo "docker_ip=$docker_ip" >> "$GITHUB_OUTPUT"
+
+      - name: Set runner user password
+        id: userpass
+        run: |
+          user_pass="1122"
+          echo "runner:$user_pass" | sudo chpasswd
+          echo "user_pass=$user_pass" >> "$GITHUB_OUTPUT"
+
+      - name: Build library
+        run: |
+          docker buildx create --use
+          docker buildx build \
+          --platform ${{ matrix.arch }} \
+          --build-arg docker_ip=${{ steps.dockerip.outputs.docker_ip }} \
+          --build-arg user_pass=${{ steps.userpass.outputs.user_pass }} \
+          --file .github/workflows/Dockerfile.libs \
+          --tag unum/usearch-library:latest \
+          --load .
+      - name: Clear Docker buildx cache
+        run: docker buildx prune --all --force
+
+      - name: Upload archive
+        uses: xresloader/upload-to-github-release@v1
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        with:
+          file: "*.deb"
+          update_latest_release: true
 
   create_windows_dll_library:
     name: Create Dll Library for Windows ${{ matrix.arch }}
-    runs-on: windows-latest
+    runs-on: windows-2022
     needs: versioning
     strategy:
       matrix:
         arch: [x64, x86]
     steps:
-    - uses: actions/checkout@v3
-      with:
-        persist-credentials: false
-        ref: 'main'
-    - run: git submodule update --init --recursive
-    
-    - name: Setup Cmake
-      uses: jwlawson/actions-setup-cmake@v1.13
-    
-    - uses: actions/setup-go@v4
-      with:
-        go-version: '^1.19.0'
-
-    - name: Setup MinGW
-      uses: egor-tensin/setup-mingw@v2
-      with:
-        platform: ${{ matrix.arch }}
-
-    - name: Get version
-      id: set_version
-      shell: bash
-      run: |
-        version=$(cat VERSION)
-        echo "version=$version" >> $GITHUB_OUTPUT
-        
-    - name: Build library
-      run: |
-        cd c
-        make libusearch_c.dll    
-        tar -cvf usearch_windows_${{ matrix.arch }}_${{ steps.set_version.outputs.version }}.tar .\libusearch_c.dll .\usearch.h
-
-    - name: Upload archive
-      uses: xresloader/upload-to-github-release@v1
-      env:
-        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-      with:
-        file: "c/usearch_windows_${{ matrix.arch }}_${{ steps.set_version.outputs.version }}.tar"
-        update_latest_release: true
+      - uses: actions/checkout@v3
+        with:
+          persist-credentials: false
+          ref: "main"
+      - run: git submodule update --init --recursive
 
+      - name: Setup CMake
+        uses: jwlawson/actions-setup-cmake@v1.13
+
+      - uses: actions/setup-go@v4
+        with:
+          go-version: "^1.19.0"
+
+      - name: Setup MinGW
+        uses: egor-tensin/setup-mingw@v2
+        with:
+          platform: ${{ matrix.arch }}
+
+      - name: Get version
+        id: set_version
+        shell: bash
+        run: |
+          version=$(cat VERSION)
+          echo "version=$version" >> $GITHUB_OUTPUT
+
+      - name: Build library
+        run: |
+          cmake -DCMAKE_BUILD_TYPE=Release -DUSEARCH_BUILD_LIB_C=1 -DUSEARCH_BUILD_TEST_CPP=0 -DUSEARCH_BUILD_BENCH_CPP=0 -B ./build_release
+          cmake --build ./build_release --config Release
+          tar -cvf usearch_windows_${{ matrix.arch }}_${{ steps.set_version.outputs.version }}.tar .\build_release\libusearch_c.dll .\c\usearch.h
+
+      - name: Upload archive
+        uses: xresloader/upload-to-github-release@v1
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        with:
+          file: "usearch_windows_${{ matrix.arch }}_${{ steps.set_version.outputs.version }}.tar"
+          update_latest_release: true
 
   create_macos_library:
     name: Create Library for MacOS ${{ matrix.arch }}
-    runs-on: macOS-latest
+    runs-on: macos-12
     needs: versioning
     strategy:
       matrix:
         arch: [arm64, x86_64]
     steps:
-    - uses: actions/checkout@v3
-      with:
-        persist-credentials: false
-        ref: 'main'
-    - run: git submodule update --init --recursive
-    
-    - uses: actions/setup-go@v4
-      with:
-        go-version: '^1.21.0'
-
-    - name: Get version
-      id: version
-      run: |
-        version=$(cat VERSION)
-        echo "version=$version" >> $GITHUB_OUTPUT
-
-    - name: Build library
-      run: |
-        cd c
-        make libusearch_c.so -target ${{ matrix.arch }}-apple-macos11
-        zip -r usearch_macOS_${{ matrix.arch }}_${{ steps.version.outputs.version }}.zip libusearch_c.so usearch.h 
-
-    - name: Upload archive
-      uses: xresloader/upload-to-github-release@v1
-      env:
-        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-      with:
-        file: "c/*.zip"
-        update_latest_release: true
+      - uses: actions/checkout@v3
+        with:
+          persist-credentials: false
+          ref: "main"
+      - run: git submodule update --init --recursive
+
+      - uses: actions/setup-go@v4
+        with:
+          go-version: "^1.21.0"
+
+      - name: Get version
+        id: version
+        run: |
+          version=$(cat VERSION)
+          echo "version=$version" >> $GITHUB_OUTPUT
 
+      - name: Build library
+        run: |
+          cmake -DCMAKE_BUILD_TYPE=Release -DUSEARCH_BUILD_LIB_C=1 -DUSEARCH_BUILD_TEST_CPP=0 -DUSEARCH_BUILD_BENCH_CPP=0 -B ./build_release
+          cmake --build ./build_release --config Release        
+          zip -r usearch_macOS_${{ matrix.arch }}_${{ steps.version.outputs.version }}.zip build_release/libusearch_c.so c/usearch.h
+
+      - name: Upload archive
+        uses: xresloader/upload-to-github-release@v1
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        with:
+          file: "*.zip"
+          update_latest_release: true
 
   wasm_c_library:
     name: WASM builds for C libraries on ${{ matrix.os }}
@@ -204,124 +198,131 @@ jobs:
       matrix:
         os: [ubuntu-22.04, macOS-11, windows-2022]
     steps:
-    - uses: actions/checkout@v3
-      with:
-        persist-credentials: false
-        ref: 'main'
-    - run: git submodule update --init --recursive
-
-    - name: Get version
-      id: version
-      run: |
-        version=$(cat VERSION)
-        echo "version=$version" >> $GITHUB_OUTPUT
-      shell: bash
-
-    - name: Build library on Ubuntu
-      run: |
-        export WASI_VERSION=20
-        export WASI_VERSION_FULL=${WASI_VERSION}.0
-        wget https://github.com/WebAssembly/wasi-sdk/releases/download/wasi-sdk-${WASI_VERSION}/wasi-sdk-${WASI_VERSION_FULL}-linux.tar.gz
-        tar xf wasi-sdk-${WASI_VERSION_FULL}-linux.tar.gz
-        rm -rf wasi-sdk-${WASI_VERSION_FULL}-linux.tar.gz
-        export WASI_SDK_PATH=/home/runner/work/usearch/usearch/wasi-sdk-${WASI_VERSION_FULL}
-        archs=("x86_64" "arm64")
-        cd ./c
-        for arch in "${archs[@]}"
-        do
-          ../wasi-sdk-20.0/bin/clang++ --sysroot=${WASI_SDK_PATH}/share/wasi-sysroot -o libusearch_c.so -O3 lib.cpp -I.  -I ../include/  -I ../fp16/include/ -shared --target=wasm32-wasi-threads  -Wl,--no-entry -nostdlib -D_WASI_EMULATED_MMAN -march="$arch"
-          tar -czvf usearch_wasm_linux_"$arch"_${{ steps.version.outputs.version }}.tar.gz libusearch_c.so
-          mv usearch_wasm_linux_"$arch"_${{ steps.version.outputs.version }}.tar.gz ../ && rm -rf libusearch_c.so
-        done
-      if: matrix.os == 'ubuntu-22.04'
-
-    - name: Build library on MacOS
-      run: |
-        export WASI_VERSION=20
-        export WASI_VERSION_FULL=${WASI_VERSION}.0
-        wget https://github.com/WebAssembly/wasi-sdk/releases/download/wasi-sdk-${WASI_VERSION}/wasi-sdk-${WASI_VERSION_FULL}-macos.tar.gz
-        tar xf wasi-sdk-${WASI_VERSION_FULL}-macos.tar.gz
-        rm -rf wasi-sdk-${WASI_VERSION_FULL}-macos.tar.gz
-        export WASI_SDK_PATH=/Users/runner/work/usearch/usearch/wasi-sdk-${WASI_VERSION_FULL}
-        archs=("x86_64" "arm64")
-        cd ./c 
-        for arch in "${archs[@]}"
-        do
-          ../wasi-sdk-20.0/bin/clang++ --sysroot=${WASI_SDK_PATH}/share/wasi-sysroot -o libusearch_c.so -O3 lib.cpp -I.  -I ../include/  -I ../fp16/include/ -shared --target=wasm32-wasi-threads  -Wl,--no-entry -nostdlib -D_WASI_EMULATED_MMAN -march="$arch"
-          zip -r usearch_wasm_macos_"$arch"_${{ steps.version.outputs.version }}.zip libusearch_c.so
-          mv usearch_wasm_macos_"$arch"_${{ steps.version.outputs.version }}.zip ../ && rm -rf libusearch_c.so
-        done
-      if: matrix.os == 'macOS-11'
-
-    - name: Build library on Windows
-      run: |
-        export WASI_VERSION=20
-        export WASI_VERSION_FULL=${WASI_VERSION}.0
-        curl -LOJ https://github.com/WebAssembly/wasi-sdk/releases/download/wasi-sdk-${WASI_VERSION}/wasi-sdk-${WASI_VERSION_FULL}.m-mingw.tar.gz
-        tar xf wasi-sdk-${WASI_VERSION_FULL}.m-mingw.tar.gz
-        rm -rf wasi-sdk-${WASI_VERSION_FULL}.m-mingw.tar.gz
-        export WASI_SDK_PATH=/d/a/usearch/usearch/wasi-sdk-${WASI_VERSION_FULL}+m
-        archs=("x64" "x86")
-        cd ./c 
-        for arch in "${archs[@]}"
-        do
-          ../wasi-sdk-20.0+m/bin/clang++ --sysroot=${WASI_SDK_PATH}/share/wasi-sysroot -o libusearch_c.so -O3 lib.cpp -I.  -I ../include/  -I ../fp16/include/ -shared --target=wasm32-wasi-threads  -Wl,--no-entry -nostdlib -D_WASI_EMULATED_MMAN -march="$arch"
-          tar -cvf usearch_wasm_windows_"$arch"_${{ steps.version.outputs.version }}.tar.gz libusearch_c.so
-          mv usearch_wasm_windows_"$arch"_${{ steps.version.outputs.version }}.tar.gz ../ && rm -rf libusearch_c.so
-        done
-      shell: bash
-      if: matrix.os == 'windows-2022'
-
-    - name: Upload archive
-      uses: xresloader/upload-to-github-release@v1
-      env:
-        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-      with:
-        file: "*.zip;*.tar.gz"
-        update_latest_release: true
-        
+      - uses: actions/checkout@v3
+        with:
+          persist-credentials: false
+          ref: "main"
+      - run: git submodule update --init --recursive
+
+      - name: Get version
+        id: version
+        run: |
+          version=$(cat VERSION)
+          echo "version=$version" >> $GITHUB_OUTPUT
+        shell: bash
+
+      - name: Build library on Ubuntu
+        run: |
+          export WASI_VERSION=20
+          export WASI_VERSION_FULL=${WASI_VERSION}.0
+          wget https://github.com/WebAssembly/wasi-sdk/releases/download/wasi-sdk-${WASI_VERSION}/wasi-sdk-${WASI_VERSION_FULL}-linux.tar.gz
+          tar xf wasi-sdk-${WASI_VERSION_FULL}-linux.tar.gz
+          rm -rf wasi-sdk-${WASI_VERSION_FULL}-linux.tar.gz
+          export WASI_SDK_PATH=/home/runner/work/usearch/usearch/wasi-sdk-${WASI_VERSION_FULL}
+          archs=("x86_64" "arm64")
+          cd ./c
+          for arch in "${archs[@]}"
+          do
+            ../wasi-sdk-20.0/bin/clang++ --sysroot=${WASI_SDK_PATH}/share/wasi-sysroot -o libusearch_c.so -O3 lib.cpp -I.  -I ../include/  -I ../fp16/include/ -shared --target=wasm32-wasi-threads  -Wl,--no-entry -nostdlib -D_WASI_EMULATED_MMAN -march="$arch"
+            tar -czvf usearch_wasm_linux_"$arch"_${{ steps.version.outputs.version }}.tar.gz libusearch_c.so
+            mv usearch_wasm_linux_"$arch"_${{ steps.version.outputs.version }}.tar.gz ../ && rm -rf libusearch_c.so
+          done
+        if: matrix.os == 'ubuntu-22.04'
+
+      - name: Build library on MacOS
+        run: |
+          export WASI_VERSION=20
+          export WASI_VERSION_FULL=${WASI_VERSION}.0
+          wget https://github.com/WebAssembly/wasi-sdk/releases/download/wasi-sdk-${WASI_VERSION}/wasi-sdk-${WASI_VERSION_FULL}-macos.tar.gz
+          tar xf wasi-sdk-${WASI_VERSION_FULL}-macos.tar.gz
+          rm -rf wasi-sdk-${WASI_VERSION_FULL}-macos.tar.gz
+          export WASI_SDK_PATH=/Users/runner/work/usearch/usearch/wasi-sdk-${WASI_VERSION_FULL}
+          archs=("x86_64" "arm64")
+          cd ./c 
+          for arch in "${archs[@]}"
+          do
+            ../wasi-sdk-20.0/bin/clang++ --sysroot=${WASI_SDK_PATH}/share/wasi-sysroot -o libusearch_c.so -O3 lib.cpp -I.  -I ../include/  -I ../fp16/include/ -shared --target=wasm32-wasi-threads  -Wl,--no-entry -nostdlib -D_WASI_EMULATED_MMAN -march="$arch"
+            zip -r usearch_wasm_macos_"$arch"_${{ steps.version.outputs.version }}.zip libusearch_c.so
+            mv usearch_wasm_macos_"$arch"_${{ steps.version.outputs.version }}.zip ../ && rm -rf libusearch_c.so
+          done
+        if: matrix.os == 'macOS-11'
+
+      - name: Build library on Windows
+        run: |
+          export WASI_VERSION=20
+          export WASI_VERSION_FULL=${WASI_VERSION}.0
+          curl -LOJ https://github.com/WebAssembly/wasi-sdk/releases/download/wasi-sdk-${WASI_VERSION}/wasi-sdk-${WASI_VERSION_FULL}.m-mingw.tar.gz
+          tar xf wasi-sdk-${WASI_VERSION_FULL}.m-mingw.tar.gz
+          rm -rf wasi-sdk-${WASI_VERSION_FULL}.m-mingw.tar.gz
+          export WASI_SDK_PATH=/d/a/usearch/usearch/wasi-sdk-${WASI_VERSION_FULL}+m
+          archs=("x64" "x86")
+          cd ./c 
+          for arch in "${archs[@]}"
+          do
+            ../wasi-sdk-20.0+m/bin/clang++ --sysroot=${WASI_SDK_PATH}/share/wasi-sysroot -o libusearch_c.so -O3 lib.cpp -I.  -I ../include/  -I ../fp16/include/ -shared --target=wasm32-wasi-threads  -Wl,--no-entry -nostdlib -D_WASI_EMULATED_MMAN -march="$arch"
+            tar -cvf usearch_wasm_windows_"$arch"_${{ steps.version.outputs.version }}.tar.gz libusearch_c.so
+            mv usearch_wasm_windows_"$arch"_${{ steps.version.outputs.version }}.tar.gz ../ && rm -rf libusearch_c.so
+          done
+        shell: bash
+        if: matrix.os == 'windows-2022'
+
+      - name: Upload archive
+        uses: xresloader/upload-to-github-release@v1
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        with:
+          file: "*.zip;*.tar.gz"
+          update_latest_release: true
 
   publish_checksums:
     name: Compute Assets Checksums
-    runs-on: ubuntu-latest
-    needs: [versioning, create_linux_deb_package, create_windows_dll_library, create_macos_library, deploy_docs_pages, wasm_c_library]
+    runs-on: ubuntu-22.04
+    needs:
+      [
+        versioning,
+        create_linux_deb_package,
+        create_windows_dll_library,
+        create_macos_library,
+        wasm_c_library,
+        deploy_docs_pages,
+      ]
     steps:
-    - name: Get last release ID
-      id: last_release
-      run: |
+      - name: Get last release ID
+        id: last_release
+        run: |
           response=$(curl -s -H "Authorization: Bearer ${{ secrets.SEMANTIC_RELEASE_TOKEN }}" \
             "https://api.github.com/repos/${{ github.repository }}/releases/latest")
           echo "last_release_id=$(echo "$response" | jq -r '.id')" >> $GITHUB_OUTPUT
 
-    - uses: robinraju/release-downloader@v1.8
-      name: Download release assets
-      with:
-        latest: true
-        fileName: "*"
-        out-file-path: "downloads"
-        tarBall: true
-        zipBall: true
-
-    - name: Calculate source hashes
-      id: hashes
-      run: |
-        i=1
-        cd $GITHUB_WORKSPACE/downloads
-        for asset_name in $(ls); do
-          asset_hash=$(sha256sum $asset_name | awk '{print $1}')
-          echo "asset_name_$i=$asset_name" >> $GITHUB_OUTPUT
-          echo "asset_hash_$i=$asset_hash" >> $GITHUB_OUTPUT
-          i=$((i+1))
-        done
-          
-    - name: Upload hashes to release
-      uses: irongut/EditRelease@v1.2.0
-      with:
-        token: ${{ secrets.SEMANTIC_RELEASE_TOKEN }}
-        id: ${{ steps.last_release.outputs.last_release_id }}
-        prerelease: false
-        replacebody: false
-        body: |
+      - uses: robinraju/release-downloader@v1.8
+        name: Download release assets
+        with:
+          latest: true
+          fileName: "*"
+          out-file-path: "downloads"
+          tarBall: true
+          zipBall: true
+
+      - name: Calculate source hashes
+        id: hashes
+        run: |
+          i=1
+          cd $GITHUB_WORKSPACE/downloads
+          for asset_name in $(ls); do
+            asset_hash=$(sha256sum $asset_name | awk '{print $1}')
+            echo "asset_name_$i=$asset_name" >> $GITHUB_OUTPUT
+            echo "asset_hash_$i=$asset_hash" >> $GITHUB_OUTPUT
+            i=$((i+1))
+          done
+
+      - name: Upload hashes to release
+        uses: irongut/EditRelease@v1.2.0
+        with:
+          token: ${{ secrets.SEMANTIC_RELEASE_TOKEN }}
+          id: ${{ steps.last_release.outputs.last_release_id }}
+          prerelease: false
+          replacebody: false
+          body: |
             ## Hashes
             * ${{ steps.hashes.outputs.asset_name_1 }} : `${{ steps.hashes.outputs.asset_hash_1 }}`
             * ${{ steps.hashes.outputs.asset_name_2 }} : `${{ steps.hashes.outputs.asset_hash_2 }}`
@@ -339,29 +340,28 @@ jobs:
             * ${{ steps.hashes.outputs.asset_name_14 }} : `${{ steps.hashes.outputs.asset_hash_14 }}`
             * ${{ steps.hashes.outputs.asset_name_15 }} : `${{ steps.hashes.outputs.asset_hash_15 }}`
 
-
   build_wheels:
     name: Build Python
     needs: versioning
     runs-on: ${{ matrix.os }}
     strategy:
       matrix:
-        os: [ubuntu-20.04, macOS-11, windows-2022]
+        os: [ubuntu-22.04, macOS-11, windows-2022]
 
     steps:
       - uses: actions/checkout@v3
         with:
-          ref: 'main'      
+          ref: "main"
       - uses: actions/setup-python@v3
-      
+
       - name: Setup Docker
-        if: matrix.os == 'ubuntu-20.04'
+        if: matrix.os == 'ubuntu-22.04'
         uses: crazy-max/ghaction-setup-docker@v1.0.0
         with:
           version: 23.0.1
 
       - name: Setup QEMU
-        if: matrix.os == 'ubuntu-20.04'
+        if: matrix.os == 'ubuntu-22.04'
         uses: docker/setup-qemu-action@v2.1.0
 
       - name: Install CIBuildWheel
@@ -373,12 +373,11 @@ jobs:
       - uses: actions/upload-artifact@v3
         with:
           path: ./wheelhouse/*.whl
-  
-  
+
   publish_python:
     name: Publish Python
     needs: build_wheels
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-22.04
     environment:
       name: pypi
       url: https://pypi.org/p/usearch
@@ -401,11 +400,11 @@ jobs:
   publish_javascript:
     name: Publish JavaScript
     needs: versioning
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-22.04
     steps:
       - uses: actions/checkout@v3
         with:
-          ref: 'main'  
+          ref: "main"
       - run: git submodule update --init --recursive
       - uses: actions/setup-node@v3
         with:
@@ -420,109 +419,109 @@ jobs:
   publish_rust:
     name: Publish Rust
     needs: versioning
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-22.04
     steps:
-    - uses: actions/checkout@v3
-      with:
-        ref: 'main'  
-    - run: git submodule update --init --recursive
-    - uses: actions-rs/toolchain@v1
-      with:
+      - uses: actions/checkout@v3
+        with:
+          ref: "main"
+      - run: git submodule update --init --recursive
+      - uses: actions-rs/toolchain@v1
+        with:
           toolchain: stable
           override: true
-    - uses: katyo/publish-crates@v2
-      with:
-          registry-token: ${{ secrets.CARGO_REGISTRY_TOKEN }}          
+      - uses: katyo/publish-crates@v2
+        with:
+          registry-token: ${{ secrets.CARGO_REGISTRY_TOKEN }}
 
   publish_java:
     name: Publish Java
     needs: versioning
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-22.04
     permissions:
       contents: read
       packages: write
     steps:
-    - uses: actions/checkout@v3
-      with:
-        ref: 'main'  
-    - run: git submodule update --init --recursive
-    - uses: actions/setup-java@v3
-      with:
-        java-version: '11'
-        distribution: 'adopt'
-    - name: Setup Gradle
-      uses: gradle/gradle-build-action@v2.4.2
-    - name: Execute Gradle build
-      run: gradle clean build
-    - name: Publish package
-      run: gradle publish -PsignArtifacts=false
-      env:
-        MAVEN_USERNAME: ${{ secrets.OSSRH_USERNAME }}
-        MAVEN_PASSWORD: ${{ secrets.OSSRH_TOKEN }}
-        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+      - uses: actions/checkout@v3
+        with:
+          ref: "main"
+      - run: git submodule update --init --recursive
+      - uses: actions/setup-java@v3
+        with:
+          java-version: "11"
+          distribution: "adopt"
+      - name: Setup Gradle
+        uses: gradle/gradle-build-action@v2.4.2
+      - name: Execute Gradle build
+        run: gradle clean build
+      - name: Publish package
+        run: gradle publish -PsignArtifacts=false
+        env:
+          MAVEN_USERNAME: ${{ secrets.OSSRH_USERNAME }}
+          MAVEN_PASSWORD: ${{ secrets.OSSRH_TOKEN }}
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
 
   publish_swift:
     name: Publish ObjC & Swift
     needs: versioning
-    runs-on: macos-latest
+    runs-on: macos-12
     steps:
-    - uses: actions/checkout@v3
-      with:
-        ref: 'main'  
-    - run: git submodule update --init --recursive
-    - name: Build
-      run: swift build
-    - name: Run tests
-      run: swift test
+      - uses: actions/checkout@v3
+        with:
+          ref: "main"
+      - run: git submodule update --init --recursive
+      - name: Build
+        run: swift build
+      - name: Run tests
+        run: swift test
 
   # Publishes to both Docker Hub and GitHub Container Registry
   # https://docs.github.com/en/actions/publishing-packages/publishing-docker-images#publishing-images-to-docker-hub-and-github-packages
   publish_docker:
     name: Publish Docker Image
     needs: versioning
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-22.04
     permissions:
       contents: read
       packages: write
     steps:
-    - uses: actions/checkout@v3
-      with:
-        ref: 'main'  
-    - run: git submodule update --init --recursive
-    - name: Login to Docker Hub
-      uses: docker/login-action@v2
-      with:
-        username: ${{ secrets.DOCKERHUB_USERNAME }}
-        password: ${{ secrets.DOCKERHUB_TOKEN }}
-    - name: Log in to GitHub Registry
-      uses: docker/login-action@v2
-      with:
-        registry: ghcr.io
-        username: ${{ github.actor }}
-        password: ${{ secrets.GITHUB_TOKEN }}
-    - name: Set up Docker Buildx
-      uses: docker/setup-buildx-action@v2
-    - name: Extract tags & labels for Docker
-      id: meta
-      uses: docker/metadata-action@v4
-      with:
-        images: |
-          unum/usearch
-          ghcr.io/${{ github.repository }}
-    - name: Build and push
-      uses: docker/build-push-action@v4
-      with:
-        context: .
-        push: true
-        tags: ${{ steps.meta.outputs.tags }}
-        labels: ${{ steps.meta.outputs.labels }}
+      - uses: actions/checkout@v3
+        with:
+          ref: "main"
+      - run: git submodule update --init --recursive
+      - name: Login to Docker Hub
+        uses: docker/login-action@v2
+        with:
+          username: ${{ secrets.DOCKERHUB_USERNAME }}
+          password: ${{ secrets.DOCKERHUB_TOKEN }}
+      - name: Log in to GitHub Registry
+        uses: docker/login-action@v2
+        with:
+          registry: ghcr.io
+          username: ${{ github.actor }}
+          password: ${{ secrets.GITHUB_TOKEN }}
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v2
+      - name: Extract tags & labels for Docker
+        id: meta
+        uses: docker/metadata-action@v4
+        with:
+          images: |
+            unum/usearch
+            ghcr.io/${{ github.repository }}
+      - name: Build and push
+        uses: docker/build-push-action@v4
+        with:
+          context: .
+          push: true
+          tags: ${{ steps.meta.outputs.tags }}
+          labels: ${{ steps.meta.outputs.labels }}
 
   build_csharp:
     name: Build C#
     needs: versioning
     strategy:
       matrix:
-        os: [ubuntu-latest, macos-latest, windows-latest]
+        os: [ubuntu-22.04, macos-12, windows-2022]
     runs-on: ${{ matrix.os }}
     defaults:
       run:
@@ -530,16 +529,16 @@ jobs:
     steps:
       - uses: actions/checkout@v3
         with:
-          ref: 'main'  
+          ref: "main"
       - run: git submodule update --init --recursive
 
       - name: Ubuntu/macOS build usearch shared obj
-        if: matrix.os == 'ubuntu-latest' || matrix.os == 'macos-latest'
+        if: matrix.os == 'ubuntu-22.04' || matrix.os == 'macos-12'
         run: ./build_lib.sh
         working-directory: ${{ github.workspace }}/csharp/eng
 
       - name: Windows MSVC build usearch dll
-        if: matrix.os == 'windows-latest'
+        if: matrix.os == 'windows-2022'
         run: |
           call "C:\Program Files\Microsoft Visual Studio\2022\Enterprise\VC\Auxiliary\Build\vcvars64.bat"
           where cl
@@ -548,7 +547,7 @@ jobs:
         shell: cmd
 
       - name: Windows copy dll
-        if: matrix.os == 'windows-latest'
+        if: matrix.os == 'windows-2022'
         run: |
           mkdir -p "${GITHUB_WORKSPACE}/csharp/lib/runtimes/win-x64/native"
           cp "${GITHUB_WORKSPACE}/c/libusearch_c.dll" "${GITHUB_WORKSPACE}/csharp/lib/runtimes/win-x64/native"
@@ -562,7 +561,7 @@ jobs:
 
   publish_csharp:
     name: Publish C#
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-22.04
     needs: [build_csharp]
     env:
       SOLUTION: ${{ github.workspace }}/csharp
@@ -574,9 +573,9 @@ jobs:
     steps:
       - uses: actions/checkout@v3
         with:
-          ref: 'main'  
+          ref: "main"
       - run: git submodule update --init --recursive
-          
+
       - name: Download usearch libs artifact
         uses: actions/download-artifact@v3
         with:
@@ -586,7 +585,7 @@ jobs:
       - name: Setup .NET
         uses: actions/setup-dotnet@v3
         with:
-          dotnet-version: 7.0.x     
+          dotnet-version: 7.0.x
 
       - name: Pack project
         run: |
@@ -606,20 +605,29 @@ jobs:
     name: Build Docs
     runs-on: ubuntu-22.04
     if: ${{ always() }}
-    needs: [publish_python, publish_javascript, publish_rust, publish_java, publish_swift, publish_docker, publish_csharp]
+    needs:
+      [
+        publish_python,
+        publish_javascript,
+        publish_rust,
+        publish_java,
+        publish_swift,
+        publish_docker,
+        publish_csharp,
+      ]
     permissions:
       contents: write
     steps:
       - name: Checkout
         uses: actions/checkout@v3
         with:
-          ref: 'main'   
+          ref: "main"
       - name: Install dependencies
         run: |
-              sudo apt update && 
-              sudo apt install -y doxygen graphviz dia git && 
-              pip install sphinx==5.3.0 sphinx-js==3.2.1 breathe==4.35.0 furo==2023.3.27 m2r2==0.3.3.post2 sphinxcontrib-googleanalytics==0.2.dev20220708 sphinxcontrib-jquery==4.1 && 
-              npm install -g jsdoc
+          sudo apt update && 
+          sudo apt install -y doxygen graphviz dia git && 
+          pip install sphinx==5.3.0 sphinx-js==3.2.1 breathe==4.35.0 furo==2023.3.27 m2r2==0.3.3.post2 sphinxcontrib-googleanalytics==0.2.dev20220708 sphinxcontrib-jquery==4.1 && 
+          npm install -g jsdoc
       - name: Install USearch from PyPi
         run: pip install usearch
       - name: Build documentation
@@ -638,7 +646,7 @@ jobs:
 
   deploy_docs_pages:
     name: Deploy GitHub Pages
-    environment: 
+    environment:
       name: github-pages
       url: ${{ steps.deployment.outputs.page_url }}
     runs-on: ubuntu-22.04
@@ -671,4 +679,4 @@ jobs:
         uses: fjogeleit/http-request-action@v1
         with:
           url: ${{ secrets.DOCS_VERCEL }}
-          method: 'POST'
+          method: "POST"
diff --git a/.gitignore b/.gitignore
index 8610d077..96d059f2 100644
--- a/.gitignore
+++ b/.gitignore
@@ -16,6 +16,7 @@ bin
 build
 build_release
 build_debug
+build_artifacts
 _deps
 CMakeCache.txt
 CMakeFiles
diff --git a/.vscode/settings.json b/.vscode/settings.json
index d3821cb8..d8bacbf3 100644
--- a/.vscode/settings.json
+++ b/.vscode/settings.json
@@ -102,7 +102,9 @@
         "__verbose_abort": "cpp",
         "shared_mutex": "cpp",
         "ranges": "cpp",
-        "span": "cpp"
+        "span": "cpp",
+        "format": "cpp",
+        "charconv": "cpp"
     },
     "cSpell.words": [
         "allclose",
diff --git a/CMakeLists.txt b/CMakeLists.txt
index bbbbda1d..40a4612b 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -260,13 +260,43 @@ function (setup_target TARGET_NAME)
     endif ()
 
     target_include_directories(${TARGET_NAME} PRIVATE ${USEARCH_HEADER_INCLUDES})
-    set_target_properties(${TARGET_NAME} PROPERTIES RUNTIME_OUTPUT_DIRECTORY_DEBUG ${CMAKE_BINARY_DIR})
-    set_target_properties(${TARGET_NAME} PROPERTIES RUNTIME_OUTPUT_DIRECTORY_RELEASE ${CMAKE_BINARY_DIR})
-    set_target_properties(${TARGET_NAME} PROPERTIES RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR})
-    set_target_properties(${TARGET_NAME} PROPERTIES ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR})
-    set_target_properties(${TARGET_NAME} PROPERTIES LIBRARY_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR})
     set_target_properties(${TARGET_NAME} PROPERTIES CXX_STANDARD 17)
 
+    # On Windows, when using multi-configuration CMake builds, the paths will be nested, resulting in
+    # "build_debug\Debug" on Windows instead of "build_debug". That's why we override all the configs to use the same
+    # output directory.
+    set_target_properties(
+        ${TARGET_NAME}
+        PROPERTIES RUNTIME_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}"
+                   ARCHIVE_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}"
+                   LIBRARY_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}"
+    )
+    set_target_properties(
+        ${TARGET_NAME}
+        PROPERTIES RUNTIME_OUTPUT_DIRECTORY_DEBUG "${CMAKE_BINARY_DIR}"
+                   ARCHIVE_OUTPUT_DIRECTORY_DEBUG "${CMAKE_BINARY_DIR}"
+                   LIBRARY_OUTPUT_DIRECTORY_DEBUG "${CMAKE_BINARY_DIR}"
+    )
+    set_target_properties(
+        ${TARGET_NAME}
+        PROPERTIES RUNTIME_OUTPUT_DIRECTORY_RELEASE "${CMAKE_BINARY_DIR}"
+                   ARCHIVE_OUTPUT_DIRECTORY_RELEASE "${CMAKE_BINARY_DIR}"
+                   LIBRARY_OUTPUT_DIRECTORY_RELEASE "${CMAKE_BINARY_DIR}"
+    )
+    set_target_properties(
+        ${TARGET_NAME}
+        PROPERTIES RUNTIME_OUTPUT_DIRECTORY_RELWITHDEBINFO "${CMAKE_BINARY_DIR}"
+                   ARCHIVE_OUTPUT_DIRECTORY_RELWITHDEBINFO "${CMAKE_BINARY_DIR}"
+                   LIBRARY_OUTPUT_DIRECTORY_RELWITHDEBINFO "${CMAKE_BINARY_DIR}"
+    )
+
+    # On Linux and MacOS our primary shared libraries for C are called `libusearch_c.so` and `libusearch_c.dylib`, while
+    # on Windows the "lib" prefix might be missing by default, so let's ensure it's always there
+    get_target_property(TARGET_TYPE ${TARGET_NAME} TYPE)
+    if (TARGET_TYPE STREQUAL "SHARED_LIBRARY" OR TARGET_TYPE STREQUAL "STATIC_LIBRARY")
+        set_target_properties(${TARGET_NAME} PROPERTIES PREFIX "lib")
+    endif ()
+
     # Core compilation settings affecting "index.hpp"
     target_compile_definitions(${TARGET_NAME} PRIVATE $<$<NOT:$<BOOL:${USEARCH_USE_OPENMP}>>:USEARCH_USE_OPENMP=0>)
 
diff --git a/build.gradle b/build.gradle
index e670d2d2..269c367b 100644
--- a/build.gradle
+++ b/build.gradle
@@ -36,6 +36,11 @@ task sourcesJar(type: Jar, dependsOn: classes) {
     from sourceSets.main.allSource
 }
 
+task javadocJar(type: Jar, dependsOn: javadoc) {
+    archiveClassifier.set('javadoc')
+    from javadoc.destinationDir
+}
+
 dependencies {
     testImplementation('junit:junit:4.13.2')
 }
@@ -117,6 +122,7 @@ publishing {
             from components.java
             
             artifact sourcesJar
+            artifact javadocJar
 
             if (project.hasProperty('signArtifacts') && signArtifacts.toBoolean()) {
                 signing {
diff --git a/c/Makefile b/c/Makefile
deleted file mode 100644
index ee8de803..00000000
--- a/c/Makefile
+++ /dev/null
@@ -1,82 +0,0 @@
-# -----------------------------------------------------------------------------
-# Makefile for the USearch C Library
-#
-# Main Targets:
-#   - libusearch_static_c.a        : Builds the static library.
-#   - libusearch_c.so              : Builds the shared library for Linux.
-#   - libusearch_c.dylib           : Builds the shared library for macOS.
-#   - test_c               		   : Compiles the test executable.
-#   - clean                		   : Removes generated files.
-#
-# Macros:
-#   - USEARCH_USE_OPENMP   		   : Enables OpenMP support. Default is 1 on Linux, 0 on other OSes.
-#   - USEARCH_USE_SIMSIMD  		   : Enables SIMD support. Default is 1.
-#   - USEARCH_USE_NATIVE_F16  	   : Enables native half-precision type. Default is 0.
-#   - CC                           : The C compiler to use. Default is gcc.
-#   - CXX                          : The C++ compiler to use. Default is g++.
-#   - C_FLAGS                      : Flags for the C compiler.
-#   - CXX_FLAGS                    : Flags for the C++ compiler.
-# -----------------------------------------------------------------------------
-
-CC ?= gcc
-CXX ?= g++
-C_FLAGS = -std=c99 -fPIC -O3 -ffast-math
-CXX_FLAGS = -std=c++11 -Wall -Wextra -Wno-conversion -Wno-unknown-pragmas -pedantic -fPIC -O3 -ffast-math
-
-# Preset USEARCH_USE_OPENMP, USEARCH_USE_SIMSIMD, USEARCH_USE_NATIVE_F16, if not provided
-USEARCH_USE_SIMSIMD ?= 1
-USEARCH_USE_NATIVE_F16 ?= 0
-
-# Detect the operating system
-UNAME_S := $(shell uname -s)
-
-# Enable OpenMP by default only on Linux
-ifeq ($(UNAME_S),Linux)
-USEARCH_USE_OPENMP ?= 1
-else
-USEARCH_USE_OPENMP ?= 0
-endif
-
-CXX_FLAGS += -DUSEARCH_USE_OPENMP=$(USEARCH_USE_OPENMP)
-CXX_FLAGS += -DUSEARCH_USE_SIMSIMD=$(USEARCH_USE_SIMSIMD)
-CXX_FLAGS += -DUSEARCH_USE_NATIVE_F16=$(USEARCH_USE_NATIVE_F16)
-
-# Define source, object files, and libraries
-SRCS = lib.cpp
-OBJS = $(SRCS:.cpp=.o)
-USEARCH_HEADER_INCLUDES = -I.  -I ../include/  -I ../fp16/include/ -I ../simsimd/include/
-
-# Default target
-.PHONY: all
-all: libusearch_static_c.a libusearch_c.so libusearch_c.dylib libusearch_c.dll test_c
-
-# Builds the static library.
-libusearch_static_c.a: $(OBJS)
-	ar rcs $@ $^
-
-# Builds the shared library for Linux.
-libusearch_c.so: $(OBJS)
-	$(CXX) $(CXX_FLAGS) $(USEARCH_HEADER_INCLUDES) -shared $^ -lc++ -o $@
-
-# Builds the shared library for macOS.
-libusearch_c.dylib: $(OBJS)
-	$(CXX) $(CXX_FLAGS) $(USEARCH_HEADER_INCLUDES) -dynamiclib $^ -lc++ -o $@
-
-# Builds the shared library for Windows.
-libusearch_c.dll: $(OBJS)
-	$(CXX) $(CXX_FLAGS) $(USEARCH_HEADER_INCLUDES) -shared $^ -lc++ -o $@
-
-# Compiles the test executable.
-test_c: test.c libusearch_static_c.a
-	$(CC) $(C_FLAGS) $< -L. -lusearch_static_c -lc++ -Wl,-rpath,. -o $@
-
-# Compiles source files to object files.
-%.o: %.cpp
-	$(CXX) $(CXX_FLAGS) $(USEARCH_HEADER_INCLUDES) -c $< -o $@
-
-# Removes generated files.
-.PHONY: clean
-clean:
-	rm -f *.o *.a *.so *.dylib test_c
-
-.PHONY: libusearch_static_c.a libusearch_c.so libusearch_c.dylib test_c
diff --git a/c/README.md b/c/README.md
index 4ff3a75f..508b5203 100644
--- a/c/README.md
+++ b/c/README.md
@@ -6,9 +6,9 @@ The simplest form to integrate is to copy the contents of `usearch/c/` into your
 To build the library `libusearch_static_c` and `libusearch_c`, pass enable the `USEARCH_BUILD_LIB_C` CMake option:
 
 ```bash
-cmake -B ./build -DUSEARCH_BUILD_LIB_C=1 -DUSEARCH_BUILD_TEST_C=1 -DUSEARCH_BUILD_TEST_CPP=0 -DUSEARCH_BUILD_BENCH_CPP=0
-make -C ./build
-./build/test_c
+cmake -DCMAKE_BUILD_TYPE=Release -DUSEARCH_BUILD_LIB_C=1 -DUSEARCH_BUILD_TEST_C=1 -DUSEARCH_BUILD_TEST_CPP=0 -DUSEARCH_BUILD_BENCH_CPP=0 -B ./build_release
+cmake --build ./build_release --config Release
+./build_release/test_c
 ```
 
 ## Quickstart
diff --git a/c/lib.cpp b/c/lib.cpp
index 232b3b6e..b401d485 100644
--- a/c/lib.cpp
+++ b/c/lib.cpp
@@ -13,7 +13,7 @@ using add_result_t = typename index_dense_t::add_result_t;
 using search_result_t = typename index_dense_t::search_result_t;
 using labeling_result_t = typename index_dense_t::labeling_result_t;
 
-static_assert(std::is_same<usearch_key_t, index_dense_t::key_t>::value, "Type mismatch between C and C++");
+static_assert(std::is_same<usearch_key_t, index_dense_t::vector_key_t>::value, "Type mismatch between C and C++");
 static_assert(std::is_same<usearch_distance_t, index_dense_t::distance_t>::value, "Type mismatch between C and C++");
 
 // helper functions that are not part of the C ABI
diff --git a/cpp/README.md b/cpp/README.md
index a397b79f..89c87150 100644
--- a/cpp/README.md
+++ b/cpp/README.md
@@ -21,7 +21,7 @@ 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<key_t, internal_id_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};
 
diff --git a/csharp/eng/build_lib.sh b/csharp/eng/build_lib.sh
deleted file mode 100755
index 02655e14..00000000
--- a/csharp/eng/build_lib.sh
+++ /dev/null
@@ -1,65 +0,0 @@
-#!/bin/bash
-
-# Get absolute path to the usearch dir
-# FIX: realpath is not available on OSX, so use pwd
-SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
-SCRIPT_DIR="${SCRIPT_DIR}/"
-
-# Define project paths
-REPO_ROOT=`cd -P "${SCRIPT_DIR}../.." && pwd`
-REPO_ROOT="${REPO_ROOT}/"
-C_DIR="${REPO_ROOT}c/"
-CSHARP_DIR="${REPO_ROOT}csharp/"
-BUILD_ARTIFACTS_DIR="${CSHARP_DIR}lib/"
-
-LIB_FILE="libusearch_c"
-
-# Determine the architecture type (only x64 is supported)
-ARCH_TYPE="$(uname -m)"
-case "$ARCH_TYPE" in
-    x86_64)
-        ARCH="x64"
-        ;;
-    # i386|i486|i586|i686)
-    #     ARCH="x86"
-    #     ;;
-    *)
-        echo "Unsupported architecture"
-        exit 1
-        ;;
-esac
-echo "Detected architecture: $ARCH"
-
-# Determine the OS type (linux or macos) and set the shared library extension accordingly
-case "$(uname -s)" in
-    Darwin)
-        BUILD_ARTIFACTS_DIR+="runtimes/osx-${ARCH}/native/"
-        LIB_FILE+=".dylib"
-        ;;
-    Linux)
-        BUILD_ARTIFACTS_DIR+="runtimes/linux-${ARCH}/native/"
-        LIB_FILE+=".so"
-        ;;
-    *)
-        echo "Unsupported operating system"
-        exit 1
-        ;;
-esac
-
-MAKE_TARGET="${LIB_FILE}"
-
-# Build the native dynamic lib
-cd "$C_DIR" || { echo "C directory not found in $C_DIR"; exit 1; }
-if [ ! -f Makefile ]; then
-  echo "Makefile not found in $C_DIR"
-  exit 1
-fi
-make "${MAKE_TARGET}"
-if [ $? -ne 0 ]; then
-  echo "Build failed!"
-  exit 1
-fi
-
-# Create output dir for shared lib and copy it there
-mkdir -p "$BUILD_ARTIFACTS_DIR"
-cp "${C_DIR}/${LIB_FILE}" "$BUILD_ARTIFACTS_DIR"
diff --git a/csharp/eng/clean.sh b/csharp/eng/clean.sh
deleted file mode 100755
index 5eceeddd..00000000
--- a/csharp/eng/clean.sh
+++ /dev/null
@@ -1,12 +0,0 @@
-#!/bin/bash
-
-# Get absolute path to the usearch csharp dir
-SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
-SCRIPT_DIR="${SCRIPT_DIR}/"
-CSHARP_DIR=`cd -P "${SCRIPT_DIR}.." && pwd`
-CSHARP_DIR="${CSHARP_DIR}/"
-
-rm -rf ${CSHARP_DIR}lib # Local temp path for native libs
-rm -rf ${CSHARP_DIR}packages # Local temp path for nuget packages
-find ${CSHARP_DIR} -type d -name 'bin' -exec rm -rf {} +
-find ${CSHARP_DIR} -type d -name 'obj' -exec rm -rf {} +
diff --git a/docs/compilation.md b/docs/compilation.md
index 7c4f5a82..90e6a1af 100644
--- a/docs/compilation.md
+++ b/docs/compilation.md
@@ -23,6 +23,7 @@ cmake -B ./build_release \
     -DUSEARCH_BUILD_BENCH_CPP=1 \
     -DUSEARCH_BUILD_LIB_C=1 \
     -DUSEARCH_BUILD_TEST_C=1 \
+    -DUSEARCH_USE_NATIVE_F16=1 \
     && \
     make -C ./build_release -j
 ```
@@ -157,18 +158,6 @@ swift test -v
 There are a few ways to compile the C 99 USearch SDK.
 Using the Makefile, specifying the targets you need:
 
-```sh
-make -C ./c libusearch_c.so
-```
-
-With options:
-
-```sh
-make USEARCH_USE_OPENMP=1 USEARCH_USE_SIMSIMD=1 -C ./c libusearch_c.so
-```
-
-Using CMake:
-
 ```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
@@ -183,7 +172,10 @@ GoLang bindings are based on C.
 So one should first compile the C library, link it with GoLang, and only then run tests.
 
 ```sh
-make -C ./c libusearch_c.so && mv ./c/libusearch_c.so ./golang/ && cp ./c/usearch.h ./golang/
+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/
+cp ./c/usearch.h ./golang/
 cd golang && go test -v ; cd ..
 ```
 
diff --git a/golang/lib.go b/golang/lib.go
index 42799a95..2d86be87 100644
--- a/golang/lib.go
+++ b/golang/lib.go
@@ -6,7 +6,7 @@ import (
 )
 
 /*
-#cgo LDFLAGS: -L. -lusearch_c
+#cgo LDFLAGS: -L. -L/usr/local/lib -lusearch_c
 #include "usearch.h"
 #include <stdlib.h>
 */
diff --git a/include/usearch/index.hpp b/include/usearch/index.hpp
index 11427d3a..417b74f5 100644
--- a/include/usearch/index.hpp
+++ b/include/usearch/index.hpp
@@ -1686,14 +1686,15 @@ template <typename distance_at = default_distance_t,              //
 class index_gt {
   public:
     using distance_t = distance_at;
-    using key_t = key_at;
+    using vector_key_t = key_at;
+    using key_t = vector_key_t;
     using compressed_slot_t = compressed_slot_at;
     using dynamic_allocator_t = dynamic_allocator_at;
     using tape_allocator_t = tape_allocator_at;
-    static_assert(sizeof(key_t) >= sizeof(compressed_slot_t), "Having tiny keys doesn't make sense.");
+    static_assert(sizeof(vector_key_t) >= sizeof(compressed_slot_t), "Having tiny keys doesn't make sense.");
 
-    using member_cref_t = member_cref_gt<key_t>;
-    using member_ref_t = member_ref_gt<key_t>;
+    using member_cref_t = member_cref_gt<vector_key_t>;
+    using member_ref_t = member_ref_gt<vector_key_t>;
 
     template <typename ref_at, typename index_at> class member_iterator_gt {
         using ref_t = ref_at;
@@ -1714,10 +1715,10 @@ class index_gt {
         using reference = ref_t;
 
         reference operator*() const noexcept { return {index_->node_at_(slot_).key(), slot_}; }
-        key_t key() const noexcept { return index_->node_at_(slot_).key(); }
+        vector_key_t key() const noexcept { return index_->node_at_(slot_).key(); }
 
         friend inline std::size_t get_slot(member_iterator_gt const& it) noexcept { return it.slot_; }
-        friend inline key_t get_key(member_iterator_gt const& it) noexcept { return it.key(); }
+        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); }
@@ -1738,7 +1739,7 @@ class index_gt {
     using member_citerator_t = member_iterator_gt<member_cref_t, index_gt const>;
 
     // STL compatibility:
-    using value_type = key_t;
+    using value_type = vector_key_t;
     using allocator_type = dynamic_allocator_t;
     using size_type = std::size_t;
     using difference_type = std::ptrdiff_t;
@@ -1774,7 +1775,7 @@ class index_gt {
     /**
      *  @brief  How many bytes of memory are needed to form the "head" of the node.
      */
-    static constexpr std::size_t node_head_bytes_() { return sizeof(key_t) + sizeof(level_t); }
+    static constexpr std::size_t node_head_bytes_() { return sizeof(vector_key_t) + sizeof(level_t); }
 
     using nodes_mutexes_t = bitset_gt<dynamic_allocator_t>;
 
@@ -1800,7 +1801,7 @@ class index_gt {
     /**
      *  @brief  A loosely-structured handle for every node. One such node is created for every member.
      *          To minimize memory usage and maximize the number of entries per cache-line, it only
-     *          stores to pointers. The internal tape starts with a `key_t` @b key, then
+     *          stores to pointers. The internal tape starts with a `vector_key_t` @b key, then
      *          a `level_t` for the number of graph @b levels in which this member appears,
      *          then the { `neighbors_count_t`, `compressed_slot_t`, `compressed_slot_t` ... } sequences
      *          for @b each-level.
@@ -1818,12 +1819,12 @@ class index_gt {
         node_t(node_t const&) = default;
         node_t& operator=(node_t const&) = default;
 
-        misaligned_ref_gt<key_t const> ckey() const noexcept { return {tape_}; }
-        misaligned_ref_gt<key_t> key() const noexcept { return {tape_}; }
-        misaligned_ref_gt<level_t> level() const noexcept { return {tape_ + sizeof(key_t)}; }
+        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)}; }
 
-        void key(key_t v) noexcept { return misaligned_store<key_t>(tape_, v); }
-        void level(level_t v) noexcept { return misaligned_store<level_t>(tape_ + sizeof(key_t), v); }
+        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); }
     };
 
     static_assert(std::is_trivially_copy_constructible<node_t>::value, "Nodes must be light!");
@@ -2192,7 +2193,7 @@ class index_gt {
         inline match_t operator[](std::size_t i) const noexcept { return at(i); }
         inline match_t front() const noexcept { return at(0); }
         inline match_t back() const noexcept { return at(count - 1); }
-        inline bool contains(key_t key) const noexcept {
+        inline bool contains(vector_key_t key) const noexcept {
             for (std::size_t i = 0; i != count; ++i)
                 if (at(i).member.key == key)
                     return true;
@@ -2205,7 +2206,7 @@ class index_gt {
             return {member_cref_t{node.ckey(), candidate.slot}, candidate.distance};
         }
         inline std::size_t merge_into(          //
-            key_t* keys, distance_t* distances, //
+            vector_key_t* keys, distance_t* distances, //
             std::size_t old_count, std::size_t max_count) const noexcept {
 
             std::size_t merged_count = old_count;
@@ -2217,7 +2218,7 @@ class index_gt {
                     continue;
 
                 std::size_t count_worse = merged_count - offset - (max_count == merged_count);
-                std::memmove(keys + offset + 1, keys + offset, count_worse * sizeof(key_t));
+                std::memmove(keys + offset + 1, keys + offset, count_worse * sizeof(vector_key_t));
                 std::memmove(distances + offset + 1, distances + offset, count_worse * sizeof(distance_t));
                 keys[offset] = result.member.key;
                 distances[offset] = result.distance;
@@ -2225,7 +2226,7 @@ class index_gt {
             }
             return merged_count;
         }
-        inline std::size_t dump_to(key_t* keys, distance_t* distances) const noexcept {
+        inline std::size_t dump_to(vector_key_t* keys, distance_t* distances) const noexcept {
             for (std::size_t i = 0; i != count; ++i) {
                 match_t result = operator[](i);
                 keys[i] = result.member.key;
@@ -2233,7 +2234,7 @@ class index_gt {
             }
             return count;
         }
-        inline std::size_t dump_to(key_t* keys) const noexcept {
+        inline std::size_t dump_to(vector_key_t* keys) const noexcept {
             for (std::size_t i = 0; i != count; ++i) {
                 match_t result = operator[](i);
                 keys[i] = result.member.key;
@@ -2264,7 +2265,7 @@ class index_gt {
      *      It should be callable into distinctly different scenarios:
      *          - `distance_t operator() (value_at, entry_at)` - from new object to existing entries.
      *          - `distance_t operator() (entry_at, entry_at)` - between existing entries.
-     *      Where any possible `entry_at` has both two interfaces: `std::size_t slot()`, `key_t key()`.
+     *      Where any possible `entry_at` has both two interfaces: `std::size_t slot()`, `vector_key_t key()`.
      *
      *  @param[in] key External identifier/name/descriptor for the new entry.
      *  @param[in] value Content that will be compared against other entries to index.
@@ -2279,7 +2280,7 @@ class index_gt {
         typename prefetch_at = dummy_prefetch_t  //
         >
     add_result_t add(                                    //
-        key_t key, value_at&& value, metric_at&& metric, //
+        vector_key_t key, value_at&& value, metric_at&& metric, //
         index_update_config_t config = {},               //
         callback_at&& callback = callback_at{},          //
         prefetch_at&& prefetch = prefetch_at{}) usearch_noexcept_m {
@@ -2371,7 +2372,7 @@ class index_gt {
      *          - `distance_t operator() (entry_at, entry_at)` - between existing entries.
      *      For any possible `entry_at` following interfaces will work:
      *          - `std::size_t get_slot(entry_at const &)`
-     *          - `key_t get_key(entry_at const &)`
+     *          - `vector_key_t get_key(entry_at const &)`
      *
      *  @param[in] iterator Iterator pointing to an existing entry to be replaced.
      *  @param[in] key External identifier/name/descriptor for the entry.
@@ -2388,7 +2389,7 @@ class index_gt {
         >
     add_result_t update(                        //
         member_iterator_t iterator,             //
-        key_t key,                              //
+        vector_key_t key,                              //
         value_at&& value,                       //
         metric_at&& metric,                     //
         index_update_config_t config = {},      //
@@ -3142,7 +3143,7 @@ class index_gt {
         return data ? span_bytes_t{data, node_bytes} : span_bytes_t{};
     }
 
-    node_t node_make_(key_t key, level_t level) noexcept {
+    node_t node_make_(vector_key_t key, level_t level) noexcept {
         span_bytes_t node_bytes = node_malloc_(level);
         if (!node_bytes)
             return {};
@@ -3334,10 +3335,10 @@ 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_; }
 
-        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 key_t get_key(candidates_iterator_t const& it) noexcept { return it.key(); }
+        friend inline vector_key_t get_key(candidates_iterator_t const& it) noexcept { return it.key(); }
     };
 
     struct candidates_range_t {
@@ -3683,8 +3684,8 @@ static join_result_t join(               //
 
     using distance_t = typename men_at::distance_t;
     using dynamic_allocator_traits_t = typename men_at::dynamic_allocator_traits_t;
-    using man_key_t = typename men_at::key_t;
-    using woman_key_t = typename women_at::key_t;
+    using man_key_t = typename men_at::vector_key_t;
+    using woman_key_t = typename women_at::vector_key_t;
 
     // Use the `compressed_slot_t` type of the larger collection
     using compressed_slot_t = typename women_at::compressed_slot_t;
diff --git a/include/usearch/index_dense.hpp b/include/usearch/index_dense.hpp
index 681bb58a..8b690ac0 100644
--- a/include/usearch/index_dense.hpp
+++ b/include/usearch/index_dense.hpp
@@ -301,13 +301,14 @@ inline index_dense_metadata_result_t index_dense_metadata_from_buffer(memory_map
 template <typename key_at = default_key_t, typename compressed_slot_at = default_slot_t> //
 class index_dense_gt {
   public:
-    using key_t = key_at;
+    using vector_key_t = key_at;
+    using key_t = vector_key_t;
     using compressed_slot_t = compressed_slot_at;
     using distance_t = distance_punned_t;
     using metric_t = metric_punned_t;
 
-    using member_ref_t = member_ref_gt<key_t>;
-    using member_cref_t = member_cref_gt<key_t>;
+    using member_ref_t = member_ref_gt<vector_key_t>;
+    using member_cref_t = member_cref_gt<vector_key_t>;
 
     using head_t = index_dense_head_t;
     using head_buffer_t = index_dense_head_buffer_t;
@@ -323,7 +324,7 @@ class index_dense_gt {
     using cast_t = std::function<bool(byte_t const*, std::size_t, byte_t*)>;
     /// @brief Punned index.
     using index_t = index_gt<                 //
-        distance_t, key_t, compressed_slot_t, //
+        distance_t, vector_key_t, compressed_slot_t, //
         dynamic_allocator_t, tape_allocator_t>;
     using index_allocator_t = aligned_allocator_gt<index_t, 64>;
 
@@ -395,23 +396,23 @@ class index_dense_gt {
     using unique_lock_t = std::unique_lock<shared_mutex_t>;
 
     struct key_and_slot_t {
-        key_t key;
+        vector_key_t key;
         compressed_slot_t slot;
 
         bool any_slot() const { return slot == default_free_value<compressed_slot_t>(); }
-        static key_and_slot_t any_slot(key_t key) { return {key, default_free_value<compressed_slot_t>()}; }
+        static key_and_slot_t any_slot(vector_key_t key) { return {key, default_free_value<compressed_slot_t>()}; }
     };
 
     struct lookup_key_hash_t {
         using is_transparent = void;
-        std::size_t operator()(key_and_slot_t const& k) const noexcept { return std::hash<key_t>{}(k.key); }
-        std::size_t operator()(key_t const& k) const noexcept { return std::hash<key_t>{}(k); }
+        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); }
     };
 
     struct lookup_key_same_t {
         using is_transparent = void;
-        bool operator()(key_and_slot_t const& a, key_t const& b) const noexcept { return a.key == b; }
-        bool operator()(key_t const& a, key_and_slot_t const& b) const noexcept { return a == b.key; }
+        bool operator()(key_and_slot_t const& a, vector_key_t const& b) const noexcept { return a.key == b; }
+        bool operator()(vector_key_t const& a, key_and_slot_t const& b) const noexcept { return a == b.key; }
         bool operator()(key_and_slot_t const& a, key_and_slot_t const& b) const noexcept { return a.key == b.key; }
     };
 
@@ -428,7 +429,7 @@ class index_dense_gt {
     mutable std::mutex free_keys_mutex_;
 
     /// @brief A constant for the reserved key value, used to mark deleted entries.
-    key_t free_key_ = default_free_value<key_t>();
+    vector_key_t free_key_ = default_free_value<vector_key_t>();
 
   public:
     using search_result_t = typename index_t::search_result_t;
@@ -497,7 +498,7 @@ class index_dense_gt {
     static index_dense_gt make(           //
         metric_t metric,                  //
         index_dense_config_t config = {}, //
-        key_t free_key = default_free_value<key_t>()) {
+        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();
@@ -573,7 +574,7 @@ class index_dense_gt {
     }
 
     dynamic_allocator_t const& allocator() const { return typed_->dynamic_allocator(); }
-    key_t const& free_key() const { return free_key_; }
+    vector_key_t const& free_key() const { return free_key_; }
 
     /**
      *  @brief  A relatively accurate lower bound on the amount of memory consumed by the system.
@@ -600,11 +601,11 @@ class index_dense_gt {
     };
 
     // clang-format off
-    add_result_t add(key_t key, b1x8_t const* vector, std::size_t thread = any_thread(), bool force_vector_copy = true) { return add_(key, vector, thread, force_vector_copy, casts_.from_b1x8); }
-    add_result_t add(key_t key, i8_t const* vector, std::size_t thread = any_thread(), bool force_vector_copy = true) { return add_(key, vector, thread, force_vector_copy, casts_.from_i8); }
-    add_result_t add(key_t key, f16_t const* vector, std::size_t thread = any_thread(), bool force_vector_copy = true) { return add_(key, vector, thread, force_vector_copy, casts_.from_f16); }
-    add_result_t add(key_t key, f32_t const* vector, std::size_t thread = any_thread(), bool force_vector_copy = true) { return add_(key, vector, thread, force_vector_copy, casts_.from_f32); }
-    add_result_t add(key_t key, f64_t const* vector, std::size_t thread = any_thread(), bool force_vector_copy = true) { return add_(key, vector, thread, force_vector_copy, casts_.from_f64); }
+    add_result_t add(vector_key_t key, b1x8_t const* vector, std::size_t thread = any_thread(), bool force_vector_copy = true) { return add_(key, vector, thread, force_vector_copy, casts_.from_b1x8); }
+    add_result_t add(vector_key_t key, i8_t const* vector, std::size_t thread = any_thread(), bool force_vector_copy = true) { return add_(key, vector, thread, force_vector_copy, casts_.from_i8); }
+    add_result_t add(vector_key_t key, f16_t const* vector, std::size_t thread = any_thread(), bool force_vector_copy = true) { return add_(key, vector, thread, force_vector_copy, casts_.from_f16); }
+    add_result_t add(vector_key_t key, f32_t const* vector, std::size_t thread = any_thread(), bool force_vector_copy = true) { return add_(key, vector, thread, force_vector_copy, casts_.from_f32); }
+    add_result_t add(vector_key_t key, f64_t const* vector, std::size_t thread = any_thread(), bool force_vector_copy = true) { return add_(key, vector, thread, force_vector_copy, casts_.from_f64); }
 
     search_result_t search(b1x8_t const* vector, std::size_t wanted, std::size_t thread = any_thread(), bool exact = false) const { return search_(vector, wanted, thread, exact, casts_.from_b1x8); }
     search_result_t search(i8_t const* vector, std::size_t wanted, std::size_t thread = any_thread(), bool exact = false) const { return search_(vector, wanted, thread, exact, casts_.from_i8); }
@@ -612,11 +613,11 @@ class index_dense_gt {
     search_result_t search(f32_t const* vector, std::size_t wanted, std::size_t thread = any_thread(), bool exact = false) const { return search_(vector, wanted, thread, exact, casts_.from_f32); }
     search_result_t search(f64_t const* vector, std::size_t wanted, std::size_t thread = any_thread(), bool exact = false) const { return search_(vector, wanted, thread, exact, casts_.from_f64); }
 
-    std::size_t get(key_t key, b1x8_t* vector, std::size_t vectors_count = 1) const { return get_(key, vector, vectors_count, casts_.to_b1x8); }
-    std::size_t get(key_t key, i8_t* vector, std::size_t vectors_count = 1) const { return get_(key, vector, vectors_count, casts_.to_i8); }
-    std::size_t get(key_t key, f16_t* vector, std::size_t vectors_count = 1) const { return get_(key, vector, vectors_count, casts_.to_f16); }
-    std::size_t get(key_t key, f32_t* vector, std::size_t vectors_count = 1) const { return get_(key, vector, vectors_count, casts_.to_f32); }
-    std::size_t get(key_t key, f64_t* vector, std::size_t vectors_count = 1) const { return get_(key, vector, vectors_count, casts_.to_f64); }
+    std::size_t get(vector_key_t key, b1x8_t* vector, std::size_t vectors_count = 1) const { return get_(key, vector, vectors_count, casts_.to_b1x8); }
+    std::size_t get(vector_key_t key, i8_t* vector, std::size_t vectors_count = 1) const { return get_(key, vector, vectors_count, casts_.to_i8); }
+    std::size_t get(vector_key_t key, f16_t* vector, std::size_t vectors_count = 1) const { return get_(key, vector, vectors_count, casts_.to_f16); }
+    std::size_t get(vector_key_t key, f32_t* vector, std::size_t vectors_count = 1) const { return get_(key, vector, vectors_count, casts_.to_f32); }
+    std::size_t get(vector_key_t key, f64_t* vector, std::size_t vectors_count = 1) const { return get_(key, vector, vectors_count, casts_.to_f64); }
 
     cluster_result_t cluster(b1x8_t const* vector, std::size_t level, std::size_t thread = any_thread()) const { return cluster_(vector, level, thread, casts_.from_b1x8); }
     cluster_result_t cluster(i8_t const* vector, std::size_t level, std::size_t thread = any_thread()) const { return cluster_(vector, level, thread, casts_.from_i8); }
@@ -624,11 +625,11 @@ class index_dense_gt {
     cluster_result_t cluster(f32_t const* vector, std::size_t level, std::size_t thread = any_thread()) const { return cluster_(vector, level, thread, casts_.from_f32); }
     cluster_result_t cluster(f64_t const* vector, std::size_t level, std::size_t thread = any_thread()) const { return cluster_(vector, level, thread, casts_.from_f64); }
 
-    aggregated_distances_t distance_between(key_t key, b1x8_t const* vector, std::size_t thread = any_thread()) const { return distance_between_(key, vector, thread, casts_.to_b1x8); }
-    aggregated_distances_t distance_between(key_t key, i8_t const* vector, std::size_t thread = any_thread()) const { return distance_between_(key, vector, thread, casts_.to_i8); }
-    aggregated_distances_t distance_between(key_t key, f16_t const* vector, std::size_t thread = any_thread()) const { return distance_between_(key, vector, thread, casts_.to_f16); }
-    aggregated_distances_t distance_between(key_t key, f32_t const* vector, std::size_t thread = any_thread()) const { return distance_between_(key, vector, thread, casts_.to_f32); }
-    aggregated_distances_t distance_between(key_t key, f64_t const* vector, std::size_t thread = any_thread()) const { return distance_between_(key, vector, thread, casts_.to_f64); }
+    aggregated_distances_t distance_between(vector_key_t key, b1x8_t const* vector, std::size_t thread = any_thread()) const { return distance_between_(key, vector, thread, casts_.to_b1x8); }
+    aggregated_distances_t distance_between(vector_key_t key, i8_t const* vector, std::size_t thread = any_thread()) const { return distance_between_(key, vector, thread, casts_.to_i8); }
+    aggregated_distances_t distance_between(vector_key_t key, f16_t const* vector, std::size_t thread = any_thread()) const { return distance_between_(key, vector, thread, casts_.to_f16); }
+    aggregated_distances_t distance_between(vector_key_t key, f32_t const* vector, std::size_t thread = any_thread()) const { return distance_between_(key, vector, thread, casts_.to_f32); }
+    aggregated_distances_t distance_between(vector_key_t key, f64_t const* vector, std::size_t thread = any_thread()) const { return distance_between_(key, vector, thread, casts_.to_f64); }
     // clang-format on
 
     /**
@@ -636,7 +637,7 @@ class index_dense_gt {
      *          If either key maps into more than one vector, will aggregate results
      *          exporting the mean, maximum, and minimum values.
      */
-    aggregated_distances_t distance_between(key_t a, key_t b, std::size_t = any_thread()) const {
+    aggregated_distances_t distance_between(vector_key_t a, vector_key_t b, std::size_t = any_thread()) const {
         shared_lock_t lock(slot_lookup_mutex_);
         aggregated_distances_t result;
         if (!multi()) {
@@ -696,7 +697,7 @@ class index_dense_gt {
     /**
      *  @brief  Identifies a node in a given `level`, that is the closest to the `key`.
      */
-    cluster_result_t cluster(key_t key, std::size_t level, std::size_t thread = any_thread()) const {
+    cluster_result_t cluster(vector_key_t key, std::size_t level, std::size_t thread = any_thread()) const {
 
         // Check if such `key` is even present.
         shared_lock_t slots_lock(slot_lookup_mutex_);
@@ -837,7 +838,7 @@ class index_dense_gt {
             // Describes types used
             head.kind_metric = metric_.metric_kind();
             head.kind_scalar = metric_.scalar_kind();
-            head.kind_key = unum::usearch::scalar_kind<key_t>();
+            head.kind_key = unum::usearch::scalar_kind<vector_key_t>();
             head.kind_compressed_slot = unum::usearch::scalar_kind<compressed_slot_t>();
 
             head.count_present = size();
@@ -926,7 +927,7 @@ class index_dense_gt {
                 return result.failed("File format may be different, please rebuild");
 
             // Check the types used
-            if (head.kind_key != unum::usearch::scalar_kind<key_t>())
+            if (head.kind_key != unum::usearch::scalar_kind<vector_key_t>())
                 return result.failed("Key type doesn't match, consider rebuilding");
             if (head.kind_compressed_slot != unum::usearch::scalar_kind<compressed_slot_t>())
                 return result.failed("Slot type doesn't match, consider rebuilding");
@@ -1010,7 +1011,7 @@ class index_dense_gt {
                 return result.failed("File format may be different, please rebuild");
 
             // Check the types used
-            if (head.kind_key != unum::usearch::scalar_kind<key_t>())
+            if (head.kind_key != unum::usearch::scalar_kind<vector_key_t>())
                 return result.failed("Key type doesn't match, consider rebuilding");
             if (head.kind_compressed_slot != unum::usearch::scalar_kind<compressed_slot_t>())
                 return result.failed("Slot type doesn't match, consider rebuilding");
@@ -1164,7 +1165,7 @@ class index_dense_gt {
      *  @brief Checks if a vector with specified key is present.
      *  @return `true` if the key is present in the index, `false` otherwise.
      */
-    bool contains(key_t key) const {
+    bool contains(vector_key_t key) const {
         shared_lock_t lock(slot_lookup_mutex_);
         return slot_lookup_.contains(key_and_slot_t::any_slot(key));
     }
@@ -1173,7 +1174,7 @@ class index_dense_gt {
      *  @brief Count the number of vectors with specified key present.
      *  @return Zero if nothing is found, a positive integer otherwise.
      */
-    std::size_t count(key_t key) const {
+    std::size_t count(vector_key_t key) const {
         shared_lock_t lock(slot_lookup_mutex_);
         return slot_lookup_.count(key_and_slot_t::any_slot(key));
     }
@@ -1197,7 +1198,7 @@ class index_dense_gt {
      *          If the key was not found in the index, `result.completed` will be `false`.
      *          If an error occurred during the removal operation, `result.error` will contain an error message.
      */
-    labeling_result_t remove(key_t key) {
+    labeling_result_t remove(vector_key_t key) {
         labeling_result_t result;
 
         unique_lock_t lookup_lock(slot_lookup_mutex_);
@@ -1250,7 +1251,7 @@ class index_dense_gt {
 
         // Remove them one-by-one
         for (auto keys_it = keys_begin; keys_it != keys_end; ++keys_it) {
-            key_t key = *keys_it;
+            vector_key_t key = *keys_it;
             auto matching_slots = slot_lookup_.equal_range(key_and_slot_t::any_slot(key));
             // A removed entry would be:
             // - present in `free_keys_`
@@ -1279,7 +1280,7 @@ class index_dense_gt {
      *          If the rename was successful, `result.completed` will be `true`.
      *          If the entry with the current key was not found, `result.completed` will be `false`.
      */
-    labeling_result_t rename(key_t from, key_t to) {
+    labeling_result_t rename(vector_key_t from, vector_key_t to) {
         labeling_result_t result;
         unique_lock_t lookup_lock(slot_lookup_mutex_);
 
@@ -1307,7 +1308,7 @@ class index_dense_gt {
      *  @param[in] offset The number of keys to skip. Useful for pagination.
      *  @param[in] limit The maximum number of keys to export, that can fit in ::keys.
      */
-    void export_keys(key_t* keys, std::size_t offset, std::size_t limit) const {
+    void export_keys(vector_key_t* keys, std::size_t offset, std::size_t limit) const {
         shared_lock_t lock(slot_lookup_mutex_);
         offset = (std::min)(offset, slot_lookup_.size());
         slot_lookup_.for_each([&](key_and_slot_t const& key_and_slot) {
@@ -1455,7 +1456,7 @@ class index_dense_gt {
         std::vector<byte_t*> new_vectors_lookup(vectors_lookup_.size());
         vectors_tape_allocator_t new_vectors_allocator;
 
-        auto track_slot_change = [&](key_t, compressed_slot_t old_slot, compressed_slot_t new_slot) {
+        auto track_slot_change = [&](vector_key_t, compressed_slot_t old_slot, compressed_slot_t new_slot) {
             byte_t* new_vector = new_vectors_allocator.allocate(metric_.bytes_per_vector());
             byte_t* old_vector = vectors_lookup_[old_slot];
             std::memcpy(new_vector, old_vector, metric_.bytes_per_vector());
@@ -1525,7 +1526,7 @@ class index_dense_gt {
         queries_iterator_at queries_begin,      //
         queries_iterator_at queries_end,        //
         index_dense_clustering_config_t config, //
-        key_t* cluster_keys,                    //
+        vector_key_t* cluster_keys,                    //
         distance_t* cluster_distances,          //
         executor_at&& executor = executor_at{}, //
         progress_at&& progress = progress_at{}) {
@@ -1548,8 +1549,8 @@ class index_dense_gt {
 
         // A structure used to track the popularity of a specific cluster
         struct cluster_t {
-            key_t centroid;
-            key_t merged_into;
+            vector_key_t centroid;
+            vector_key_t merged_into;
             std::size_t popularity;
             byte_t* vector;
         };
@@ -1658,7 +1659,7 @@ class index_dense_gt {
             std::sort(clusters.data(), clusters_end, centroid_id);
 
             executor.dynamic(queries_count, [&](std::size_t thread_idx, std::size_t query_idx) {
-                key_t& cluster_key = cluster_keys[query_idx];
+                vector_key_t& cluster_key = cluster_keys[query_idx];
                 distance_t& cluster_distance = cluster_distances[query_idx];
 
                 // Recursively trace replacements of that cluster
@@ -1715,7 +1716,7 @@ class index_dense_gt {
 
     template <typename scalar_at>
     add_result_t add_(                      //
-        key_t key, scalar_at const* vector, //
+        vector_key_t key, scalar_at const* vector, //
         std::size_t thread, bool force_vector_copy, cast_t const& cast) {
 
         if (!multi() && contains(key))
@@ -1811,7 +1812,7 @@ class index_dense_gt {
 
     template <typename scalar_at>
     aggregated_distances_t distance_between_( //
-        key_t key, scalar_at const* vector,   //
+        vector_key_t key, scalar_at const* vector,   //
         std::size_t thread, cast_t const& cast) const {
 
         // Cast the vector, if needed for compatibility with `metric_`
@@ -1881,12 +1882,12 @@ class index_dense_gt {
             if (member.key == free_key_)
                 free_keys_.push(static_cast<compressed_slot_t>(i));
             else if (config_.enable_key_lookups)
-                slot_lookup_.try_emplace(key_and_slot_t{key_t(member.key), static_cast<compressed_slot_t>(i)});
+                slot_lookup_.try_emplace(key_and_slot_t{vector_key_t(member.key), static_cast<compressed_slot_t>(i)});
         }
     }
 
     template <typename scalar_at>
-    std::size_t get_(key_t key, scalar_at* reconstructed, std::size_t vectors_limit, cast_t const& cast) const {
+    std::size_t get_(vector_key_t key, scalar_at* reconstructed, std::size_t vectors_limit, cast_t const& cast) const {
 
         if (!multi()) {
             compressed_slot_t slot;
diff --git a/include/usearch/index_plugins.hpp b/include/usearch/index_plugins.hpp
index 4a0a0758..5f6ea7c7 100644
--- a/include/usearch/index_plugins.hpp
+++ b/include/usearch/index_plugins.hpp
@@ -44,10 +44,22 @@
 // Propagate the `f16` settings
 #define SIMSIMD_NATIVE_F16 USEARCH_USE_NATIVE_F16
 #if defined(USEARCH_DEFINED_LINUX)
+#define SIMSIMD_TARGET_X86_AVX512 1
+#define SIMSIMD_TARGET_ARM_SVE 1
+#define SIMSIMD_TARGET_X86_AVX2 1
+#define SIMSIMD_TARGET_ARM_NEON 1
 #include <simsimd/simsimd.h>
 #elif defined(USEARCH_DEFINED_APPLE)
 #define SIMSIMD_TARGET_X86_AVX512 0
 #define SIMSIMD_TARGET_ARM_SVE 0
+#define SIMSIMD_TARGET_X86_AVX2 1
+#define SIMSIMD_TARGET_ARM_NEON 1
+#include <simsimd/simsimd.h>
+#else
+#define SIMSIMD_TARGET_X86_AVX512 0
+#define SIMSIMD_TARGET_ARM_SVE 0
+#define SIMSIMD_TARGET_X86_AVX2 0
+#define SIMSIMD_TARGET_ARM_NEON 0
 #include <simsimd/simsimd.h>
 #endif
 #endif
@@ -556,7 +568,9 @@ class aligned_allocator_gt {
     using size_type = std::size_t;
     using pointer = element_at*;
     using const_pointer = element_at const*;
-    template <typename other_element_at> struct rebind { using other = aligned_allocator_gt<other_element_at>; };
+    template <typename other_element_at> struct rebind {
+        using other = aligned_allocator_gt<other_element_at>;
+    };
 
     constexpr std::size_t alignment() const { return alignment_ak; }
 
@@ -1344,8 +1358,8 @@ class metric_punned_t {
     }
 
   private:
-    bool configure_with_simsimd() noexcept {
 #if USEARCH_USE_SIMSIMD
+    bool configure_with_simsimd(simsimd_capability_t simd_caps) noexcept {
         simsimd_metric_kind_t kind = simsimd_metric_unknown_k;
         simsimd_datatype_t datatype = simsimd_datatype_unknown_k;
         simsimd_capability_t allowed = simsimd_cap_any_k;
@@ -1355,6 +1369,7 @@ class metric_punned_t {
         case metric_kind_t::l2sq_k: kind = simsimd_metric_l2sq_k; break;
         case metric_kind_t::hamming_k: kind = simsimd_metric_hamming_k; break;
         case metric_kind_t::jaccard_k: kind = simsimd_metric_jaccard_k; break;
+        default: break;
         }
         switch (scalar_kind_) {
         case scalar_kind_t::f32_k: datatype = simsimd_datatype_f32_k; break;
@@ -1362,20 +1377,25 @@ class metric_punned_t {
         case scalar_kind_t::f16_k: datatype = simsimd_datatype_f16_k; break;
         case scalar_kind_t::i8_k: datatype = simsimd_datatype_i8_k; break;
         case scalar_kind_t::b1x8_k: datatype = simsimd_datatype_b8_k; break;
+        default: break;
         }
         simsimd_metric_punned_t simd_metric = NULL;
         simsimd_capability_t simd_kind = simsimd_cap_any_k;
-        simsimd_find_metric_punned(kind, datatype, simsimd_capabilities(), allowed, &simd_metric, &simd_kind);
+        simsimd_find_metric_punned(kind, datatype, simd_caps, allowed, &simd_metric, &simd_kind);
         if (simd_metric == nullptr)
             return false;
 
         raw_ptr_ = (punned_ptr_t)simd_metric;
         isa_kind_ = simd_kind;
         return true;
+    }
+    bool configure_with_simsimd() noexcept {
+        static simsimd_capability_t static_capabilities = simsimd_capabilities();
+        return configure_with_simsimd(static_capabilities);
+    }
 #else
-        return false;
+    bool configure_with_simsimd() noexcept { return false; }
 #endif
-    }
 
     void configure_with_auto_vectorized() noexcept {
         switch (metric_kind_) {
@@ -2118,7 +2138,8 @@ class flat_hash_multi_set_gt {
             slot_ref_t slot = slot_ref(slot_index);
             if ((~slot.header.populated & slot.mask) | (slot.header.deleted & slot.mask)) {
                 // Found an empty or deleted slot
-                populated_slots_ += populate_slot(slot, element);
+                populate_slot(slot, element);
+                ++populated_slots_;
                 return true;
             }
             // Move to the next slot
diff --git a/java/cloud/unum/usearch/cloud_unum_usearch_Index.cpp b/java/cloud/unum/usearch/cloud_unum_usearch_Index.cpp
index 0439a828..9bca7000 100644
--- a/java/cloud/unum/usearch/cloud_unum_usearch_Index.cpp
+++ b/java/cloud/unum/usearch/cloud_unum_usearch_Index.cpp
@@ -124,10 +124,10 @@ JNIEXPORT void JNICALL Java_cloud_unum_usearch_Index_c_1add( //
     jsize vector_dims = (*env).GetArrayLength(vector);
     float_span_t vector_span = float_span_t{vector_data, static_cast<std::size_t>(vector_dims)};
 
-    using key_t = typename index_dense_t::key_t;
+    using vector_key_t = typename index_dense_t::vector_key_t;
     using add_result_t = typename index_dense_t::add_result_t;
 
-    add_result_t result = reinterpret_cast<index_dense_t*>(c_ptr)->add(static_cast<key_t>(key), vector_span);
+    add_result_t result = reinterpret_cast<index_dense_t*>(c_ptr)->add(static_cast<vector_key_t>(key), vector_span);
     if (!result) {
         jclass jc = (*env).FindClass("java/lang/Error");
         if (jc)
@@ -152,13 +152,13 @@ JNIEXPORT jintArray JNICALL Java_cloud_unum_usearch_Index_c_1search( //
     jsize vector_dims = (*env).GetArrayLength(vector);
     float_span_t vector_span = float_span_t{vector_data, static_cast<std::size_t>(vector_dims)};
 
-    using key_t = typename index_dense_t::key_t;
+    using vector_key_t = typename index_dense_t::vector_key_t;
     using search_result_t = typename index_dense_t::search_result_t;
 
     search_result_t result =
         reinterpret_cast<index_dense_t*>(c_ptr)->search(vector_span, static_cast<std::size_t>(wanted));
     if (result) {
-        std::size_t found = result.dump_to(reinterpret_cast<key_t*>(matches_data), NULL);
+        std::size_t found = result.dump_to(reinterpret_cast<vector_key_t*>(matches_data), NULL);
         (*env).SetIntArrayRegion(matches, 0, found, matches_data);
     } else {
         jclass jc = (*env).FindClass("java/lang/Error");
@@ -172,9 +172,9 @@ JNIEXPORT jintArray JNICALL Java_cloud_unum_usearch_Index_c_1search( //
 }
 
 JNIEXPORT bool JNICALL Java_cloud_unum_usearch_Index_c_1remove(JNIEnv* env, jclass, jlong c_ptr, jlong key) {
-    using key_t = typename index_dense_t::key_t;
+    using vector_key_t = typename index_dense_t::vector_key_t;
     using labeling_result_t = typename index_dense_t::labeling_result_t;
-    labeling_result_t result = reinterpret_cast<index_dense_t*>(c_ptr)->remove(static_cast<key_t>(key));
+    labeling_result_t result = reinterpret_cast<index_dense_t*>(c_ptr)->remove(static_cast<vector_key_t>(key));
     if (!result) {
         jclass jc = (*env).FindClass("java/lang/Error");
         if (jc)
@@ -184,10 +184,10 @@ JNIEXPORT bool JNICALL Java_cloud_unum_usearch_Index_c_1remove(JNIEnv* env, jcla
 }
 
 JNIEXPORT bool JNICALL Java_cloud_unum_usearch_Index_c_1rename(JNIEnv* env, jclass, jlong c_ptr, jlong from, jlong to) {
-    using key_t = typename index_dense_t::key_t;
+    using vector_key_t = typename index_dense_t::vector_key_t;
     using labeling_result_t = typename index_dense_t::labeling_result_t;
     labeling_result_t result =
-        reinterpret_cast<index_dense_t*>(c_ptr)->rename(static_cast<key_t>(from), static_cast<key_t>(to));
+        reinterpret_cast<index_dense_t*>(c_ptr)->rename(static_cast<vector_key_t>(from), static_cast<vector_key_t>(to));
     if (!result) {
         jclass jc = (*env).FindClass("java/lang/Error");
         if (jc)
diff --git a/objc/USearchObjective.mm b/objc/USearchObjective.mm
index ac8315f4..4d01f72f 100644
--- a/objc/USearchObjective.mm
+++ b/objc/USearchObjective.mm
@@ -14,7 +14,7 @@
 using search_result_t = typename index_dense_t::search_result_t;
 using shared_index_dense_t = std::shared_ptr<index_dense_t>;
 
-static_assert(std::is_same<USearchKey, index_dense_t::key_t>::value, "Type mismatch between Objective-C and C++");
+static_assert(std::is_same<USearchKey, index_dense_t::vector_key_t>::value, "Type mismatch between Objective-C and C++");
 
 metric_kind_t to_native_metric(USearchMetric m) {
     switch (m) {
diff --git a/python/lib.cpp b/python/lib.cpp
index e0bc0fbf..67364604 100644
--- a/python/lib.cpp
+++ b/python/lib.cpp
@@ -38,7 +38,7 @@ using py_shape_t = py::array::ShapeContainer;
 using metric_t = metric_punned_t;
 using distance_t = distance_punned_t;
 
-using dense_key_t = typename index_dense_t::key_t;
+using dense_key_t = typename index_dense_t::vector_key_t;
 using dense_add_result_t = typename index_dense_t::add_result_t;
 using dense_search_result_t = typename index_dense_t::search_result_t;
 using dense_labeling_result_t = typename index_dense_t::labeling_result_t;
@@ -48,7 +48,7 @@ using dense_clustering_result_t = typename index_dense_t::clustering_result_t;
 using progress_func_t = std::function<bool(std::size_t /*processed*/, std::size_t /*total*/)>;
 
 struct progress_t {
-    inline progress_t(nullptr_t = nullptr) : func_(&dummy_progress) {}
+    inline progress_t(std::nullptr_t = nullptr) : func_(&dummy_progress) {}
     inline progress_t(progress_func_t const& func) : func_(func ? func : &dummy_progress) {}
     inline bool operator()(std::size_t processed, std::size_t total) const noexcept { return func_(processed, total); }
 
diff --git a/python/scripts/bench.ipynb b/python/scripts/bench.ipynb
index d3ec0f2e..4305c212 100644
--- a/python/scripts/bench.ipynb
+++ b/python/scripts/bench.ipynb
@@ -11,7 +11,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 1,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -19,6 +19,28 @@
     "import plotly.graph_objects as go"
    ]
   },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "('auto', 'auto', 'auto')"
+      ]
+     },
+     "execution_count": 6,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "from usearch.index import Index\n",
+    "\n",
+    "Index(ndim=256, metric=\"cos\", dtype=\"f32\").hardware_acceleration, Index(ndim=256, metric=\"cos\", dtype=\"f16\").hardware_acceleration, Index(ndim=256, metric=\"cos\", dtype=\"i8\").hardware_acceleration"
+   ]
+  },
   {
    "cell_type": "code",
    "execution_count": null,
@@ -162,7 +184,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.10.11"
+   "version": "3.11.5"
   },
   "orig_nbformat": 4
  },
diff --git a/python/usearch/index.py b/python/usearch/index.py
index e33f398f..a3159bac 100644
--- a/python/usearch/index.py
+++ b/python/usearch/index.py
@@ -573,7 +573,7 @@ def __init__(
         )
 
         self.path = path
-        if path is not None:
+        if path is not None and os.path.exists(path):
             if view:
                 self.view(path)
             else:
@@ -873,7 +873,7 @@ def serialized_length(self) -> int:
 
     @property
     def metric_kind(self) -> Union[MetricKind, CompiledMetric]:
-        return self._metric_jit if self._metric_jit.kind else self._metric_kind
+        return self._metric_jit.kind if self._metric_jit else self._metric_kind
 
     @property
     def metric(self) -> Union[MetricKind, CompiledMetric]:
@@ -965,7 +965,11 @@ def load(
         if isinstance(path_or_buffer, bytes):
             self._compiled.load_index_from_buffer(path_or_buffer, progress)
         else:
-            self._compiled.load_index_from_path(os.fspath(path_or_buffer), progress)
+            path_or_buffer = os.fspath(path_or_buffer)
+            if os.path.exists(path_or_buffer):
+                self._compiled.load_index_from_path(path_or_buffer, progress)
+            else:
+                raise RuntimeError("Missing file!")
 
     def view(
         self,
diff --git a/rust/lib.cpp b/rust/lib.cpp
index 11217e20..a2004bb1 100644
--- a/rust/lib.cpp
+++ b/rust/lib.cpp
@@ -8,6 +8,7 @@ using index_t = index_dense_t;
 using add_result_t = typename index_t::add_result_t;
 using search_result_t = typename index_t::search_result_t;
 using labeling_result_t = typename index_t::labeling_result_t;
+using vector_key_t = typename index_dense_t::vector_key_t;
 
 template <typename scalar_at> Matches search_(index_dense_t& index, scalar_at const* vec, size_t count) {
     Matches matches;
@@ -26,20 +27,20 @@ template <typename scalar_at> Matches search_(index_dense_t& index, scalar_at co
 NativeIndex::NativeIndex(std::unique_ptr<index_t> index) : index_(std::move(index)) {}
 
 // clang-format off
-void NativeIndex::add_i8(key_t key, rust::Slice<int8_t const> vec) const { index_->add(key, vec.data()).error.raise(); }
-void NativeIndex::add_f16(key_t key, rust::Slice<uint16_t const> vec) const { index_->add(key, (f16_t const*)vec.data()).error.raise(); }
-void NativeIndex::add_f32(key_t key, rust::Slice<float const> vec) const { index_->add(key, vec.data()).error.raise(); }
-void NativeIndex::add_f64(key_t key, rust::Slice<double const> vec) const { index_->add(key, 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<uint16_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_i8(rust::Slice<int8_t const> vec, size_t count) const { return search_(*index_, vec.data(), count); }
 Matches NativeIndex::search_f16(rust::Slice<uint16_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); }
 
-size_t NativeIndex::get_i8(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(key_t key, rust::Slice<uint16_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(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(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()); }
+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<uint16_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()); }
 // clang-format on
 
 size_t NativeIndex::expansion_add() const { return index_->expansion_add(); }
@@ -47,20 +48,20 @@ size_t NativeIndex::expansion_search() const { return index_->expansion_search()
 void NativeIndex::change_expansion_add(size_t n) const { index_->change_expansion_add(n); }
 void NativeIndex::change_expansion_search(size_t n) const { index_->change_expansion_search(n); }
 
-size_t NativeIndex::remove(key_t key) const {
+size_t NativeIndex::remove(vector_key_t key) const {
     labeling_result_t result = index_->remove(key);
     result.error.raise();
     return result.completed;
 }
 
-size_t NativeIndex::rename(key_t from, key_t to) const {
+size_t NativeIndex::rename(vector_key_t from, vector_key_t to) const {
     labeling_result_t result = index_->rename(from, to);
     result.error.raise();
     return result.completed;
 }
 
-size_t NativeIndex::count(key_t key) const { return index_->count(key); }
-bool NativeIndex::contains(key_t key) const { return index_->contains(key); }
+size_t NativeIndex::count(vector_key_t key) const { return index_->count(key); }
+bool NativeIndex::contains(vector_key_t key) const { return index_->contains(key); }
 
 void NativeIndex::reserve(size_t capacity) const { index_->reserve(capacity); }
 
diff --git a/rust/lib.hpp b/rust/lib.hpp
index f0262ac7..e65edcc2 100644
--- a/rust/lib.hpp
+++ b/rust/lib.hpp
@@ -15,36 +15,36 @@ class NativeIndex {
     using index_dense_t = unum::usearch::index_dense_t;
     using add_result_t = typename index_dense_t::add_result_t;
     using search_result_t = typename index_dense_t::search_result_t;
-    using key_t = typename index_dense_t::key_t;
+    using vector_key_t = typename index_dense_t::vector_key_t;
 
     NativeIndex(std::unique_ptr<index_dense_t> index);
 
     void reserve(size_t) const;
 
-    void add_i8(key_t key, rust::Slice<int8_t const> vector) const;
-    void add_f16(key_t key, rust::Slice<uint16_t const> vector) const;
-    void add_f32(key_t key, rust::Slice<float const> vector) const;
-    void add_f64(key_t key, rust::Slice<double const> vector) const;
+    void add_i8(vector_key_t key, rust::Slice<int8_t const> vector) const;
+    void add_f16(vector_key_t key, rust::Slice<uint16_t const> vector) const;
+    void add_f32(vector_key_t key, rust::Slice<float const> vector) const;
+    void add_f64(vector_key_t key, rust::Slice<double const> vector) const;
 
     Matches search_i8(rust::Slice<int8_t const> vector, size_t count) const;
     Matches search_f16(rust::Slice<uint16_t const> vector, size_t count) const;
     Matches search_f32(rust::Slice<float const> vector, size_t count) const;
     Matches search_f64(rust::Slice<double const> vector, size_t count) const;
 
-    size_t get_i8(key_t key, rust::Slice<int8_t> vector) const;
-    size_t get_f16(key_t key, rust::Slice<uint16_t> vector) const;
-    size_t get_f32(key_t key, rust::Slice<float> vector) const;
-    size_t get_f64(key_t key, rust::Slice<double> vector) const;
+    size_t get_i8(vector_key_t key, rust::Slice<int8_t> vector) const;
+    size_t get_f16(vector_key_t key, rust::Slice<uint16_t> vector) const;
+    size_t get_f32(vector_key_t key, rust::Slice<float> vector) const;
+    size_t get_f64(vector_key_t key, rust::Slice<double> vector) const;
 
     size_t expansion_add() const;
     size_t expansion_search() const;
     void change_expansion_add(size_t n) const;
     void change_expansion_search(size_t n) const;
 
-    size_t count(key_t key) const;
-    size_t remove(key_t key) const;
-    size_t rename(key_t from, key_t to) const;
-    bool contains(key_t key) const;
+    size_t count(vector_key_t key) const;
+    size_t remove(vector_key_t key) const;
+    size_t rename(vector_key_t from, vector_key_t to) const;
+    bool contains(vector_key_t key) const;
 
     size_t dimensions() const;
     size_t connectivity() const;
diff --git a/rust/lib.rs b/rust/lib.rs
index 4d72686a..c52f710a 100644
--- a/rust/lib.rs
+++ b/rust/lib.rs
@@ -432,6 +432,7 @@ pub fn new_index(options: &ffi::IndexOptions) -> Result<Index, cxx::Exception> {
 mod tests {
     use crate::ffi::IndexOptions;
     use crate::ffi::MetricKind;
+    use crate::ffi::ScalarKind;
 
     use crate::new_index;
     use crate::Index;
@@ -466,6 +467,51 @@ mod tests {
         assert!(result.is_err());
     }
 
+    #[test]
+    fn test_add_remove_vector() {
+        let mut options = IndexOptions::default();
+        options.dimensions = 4;
+        options.metric = MetricKind::IP;
+        options.quantization = ScalarKind::F64;
+        options.connectivity = 10;
+        options.expansion_add = 128;
+        options.expansion_search = 3;
+        let index = Index::new(&options).unwrap();
+        assert!(index.reserve(10).is_ok());
+        assert_eq!(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];
+
+        // IDs until 18446744073709551615 should be fine:
+        let id1 = 483367403120493160;
+        let id2 = 483367403120558696;
+        let id3 = 483367403120624232;
+        let id4 = 483367403120624233;
+
+        assert!(index.add(id1, &first).is_ok());
+        let mut found_slice = [0.0 as f32; 4];
+        assert_eq!(index.get(id1, &mut found_slice).unwrap(), 1);
+        assert!(index.remove(id1).is_ok());
+    
+        assert!(index.add(id2, &second).is_ok());
+        let mut found_slice = [0.0 as f32; 4];
+        assert_eq!(index.get(id2, &mut found_slice).unwrap(), 1);
+        assert!(index.remove(id2).is_ok());
+        
+        assert!(index.add(id3, &second).is_ok());
+        let mut found_slice = [0.0 as f32; 4];
+        assert_eq!(index.get(id3, &mut found_slice).unwrap(), 1);
+        assert!(index.remove(id3).is_ok());
+                
+        assert!(index.add(id4, &second).is_ok());
+        let mut found_slice = [0.0 as f32; 4];
+        assert_eq!(index.get(id4, &mut found_slice).unwrap(), 1);
+        assert!(index.remove(id4).is_ok());
+
+        assert_eq!(index.size(), 0);
+    }
+
     #[test]
     fn integration() {
         let mut options = IndexOptions::default();
diff --git a/setup.py b/setup.py
index 85d93a34..afae33df 100644
--- a/setup.py
+++ b/setup.py
@@ -1,5 +1,6 @@
 import os
 import sys
+import subprocess
 from setuptools import setup
 
 from pybind11.setup_helpers import Pybind11Extension
@@ -9,6 +10,13 @@
 link_args = []
 macros_args = []
 
+def is_gcc():
+    try:
+        compiler_version = subprocess.check_output(["c++", "--version"], universal_newlines=True)
+        return "gcc" in compiler_version.lower()
+    except Exception:
+        return False
+
 if sys.platform == "linux":
     compile_args.append("-std=c++17")
     compile_args.append("-O3")  # Maximize performance
@@ -21,9 +29,13 @@
 
     macros_args.append(("USEARCH_USE_NATIVE_F16", "0"))
     macros_args.append(("USEARCH_USE_SIMSIMD", "1"))
-    macros_args.append(("USEARCH_USE_OPENMP", "1"))
-    compile_args.append("-fopenmp")
-    link_args.append("-lgomp")
+
+    if is_gcc():
+        macros_args.append(("USEARCH_USE_OPENMP", "1"))
+        compile_args.append("-fopenmp")
+        link_args.append("-lgomp")
+    else:
+        macros_args.append(("USEARCH_USE_OPENMP", "0"))
 
 if sys.platform == "darwin":
     # MacOS 10.15 or higher is needed for `aligned_alloc` support.
diff --git a/simsimd b/simsimd
index 0457ba10..8f2c8881 160000
--- a/simsimd
+++ b/simsimd
@@ -1,1 +1,1 @@
-Subproject commit 0457ba10ac5b83da741820e38bbbd308530f396e
+Subproject commit 8f2c8881e440a55cfea246996984662623b4d5dd
diff --git a/wolfram/lib.cpp b/wolfram/lib.cpp
index d7d0d259..31ec891f 100644
--- a/wolfram/lib.cpp
+++ b/wolfram/lib.cpp
@@ -9,7 +9,7 @@ using vector_view_t = span_gt<float>;
 
 using add_result_t = typename index_t::add_result_t;
 using search_result_t = typename index_t::search_result_t;
-using key_t = typename index_t::key_t;
+using vector_key_t = typename index_t::vector_key_t;
 
 EXTERN_C DLLEXPORT int WolframLibrary_initialize(WolframLibraryData libData) { return LIBRARY_NO_ERROR; }
 EXTERN_C DLLEXPORT void WolframLibrary_uninitialize(WolframLibraryData libData) { return; }


Test patch:
diff --git a/cpp/test.cpp b/cpp/test.cpp
index f94c14a3..d32e2986 100644
--- a/cpp/test.cpp
+++ b/cpp/test.cpp
@@ -25,15 +25,15 @@ void test_cosine(index_at& index, std::vector<std::vector<scalar_at>> const& vec
 
     using scalar_t = scalar_at;
     using index_t = index_at;
-    using key_t = typename index_t::key_t;
+    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
-    key_t const key_max = default_free_value<key_t>() - 1;
-    key_t const key_first = key_max - 0;
-    key_t const key_second = key_max - 1;
-    key_t const key_third = key_max - 2;
+    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();
@@ -50,7 +50,7 @@ void test_cosine(index_at& index, std::vector<std::vector<scalar_at>> const& vec
     index.add(key_first, vector_first, args...);
 
     // Default approximate search
-    key_t matched_keys[10] = {0};
+    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);
 
@@ -69,7 +69,7 @@ void test_cosine(index_at& index, std::vector<std::vector<scalar_at>> const& vec
     // Validate scans
     std::size_t count = 0;
     for (auto member : index) {
-        key_t id = member.key;
+        vector_key_t id = member.key;
         expect(id <= key_first && id >= key_third);
         count++;
     }
@@ -159,10 +159,10 @@ template <typename scalar_at, typename key_at, typename slot_at> //
 void test_cosine(std::size_t collection_size, std::size_t dimensions) {
 
     using scalar_t = scalar_at;
-    using key_t = key_at;
+    using vector_key_t = key_at;
     using slot_t = slot_at;
 
-    using index_typed_t = index_gt<float, key_t, slot_t>;
+    using index_typed_t = index_gt<float, vector_key_t, slot_t>;
     using member_cref_t = typename index_typed_t::member_cref_t;
     using member_citerator_t = typename index_typed_t::member_citerator_t;
 
@@ -205,7 +205,7 @@ void test_cosine(std::size_t collection_size, std::size_t dimensions) {
     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<key_t, slot_t>;
+            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;
@@ -217,10 +217,10 @@ void test_cosine(std::size_t collection_size, std::size_t dimensions) {
 
 template <typename key_at, typename slot_at> void test_tanimoto(std::size_t dimensions, std::size_t connectivity) {
 
-    using key_t = key_at;
+    using vector_key_t = key_at;
     using slot_t = slot_at;
 
-    using index_punned_t = index_dense_gt<key_t, slot_t>;
+    using index_punned_t = index_dense_gt<vector_key_t, slot_t>;
     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);