{"id":946,"date":"2026-05-21T05:42:31","date_gmt":"2026-05-20T21:42:31","guid":{"rendered":"https:\/\/connectword.dpdns.org\/?p=946"},"modified":"2026-05-21T05:42:31","modified_gmt":"2026-05-20T21:42:31","slug":"meet-turbovec-a-rust-vector-index-with-python-bindings-and-built-on-googles-turboquant-algorithm","status":"publish","type":"post","link":"https:\/\/connectword.dpdns.org\/?p=946","title":{"rendered":"Meet Turbovec: A Rust Vector Index with Python Bindings, and Built on Google\u2019s TurboQuant Algorithm"},"content":{"rendered":"

Vector search underpins most retrieval-augmented generation (RAG) pipelines. At scale, it gets expensive. Storing 10 million document embeddings in float32 consumes 31 GB of RAM. For dev teams running local or on-premise inference, that number creates real constraints.<\/p>\n

A new open-source library called turbovec<\/a><\/strong> addresses this directly. It is a vector index written in Rust with Python bindings. It is built on TurboQuant<\/strong>, a quantization algorithm from Google Research. The same 10-million-document corpus fits in 4 GB with turbovec. On ARM hardware, search speed beats FAISS IndexPQFastScan by 12\u201320%.<\/p>\n

The TurboQuant Paper<\/strong><\/h2>\n

TurboQuant<\/a> was introduced by Google\u2019s research team. The Google team proposes TurboQuant as a data-oblivious quantizer. It achieves near-optimal distortion rates across all bit-widths and dimensions. It requires zero training and zero passes over the data.<\/p>\n

Most production-grade vector quantizers, including FAISS\u2019s Product Quantization, requires a codebook training step. You must run k-means over a representative sample of your vectors before indexing begins. If your corpus grows or shifts, you may need to retrain and rebuild the index entirely. TurboQuant skips all of that. It uses an analytical property of rotated vectors instead of a data-dependent calibration.<\/p>\n

How turbovec Quantizes Vectors<\/strong><\/h2>\n

The quantization pipeline has four steps<\/strong>:<\/p>\n

(1) Each vector is normalized<\/em>.<\/strong> The length (norm) is stripped and stored as a single float. Every vector becomes a unit direction on a high-dimensional hypersphere.<\/p>\n

(2) A random rotation<\/em> is applied.<\/strong> All vectors are multiplied by the same random orthogonal matrix. After rotation, each coordinate independently follows a Beta distribution. In high dimensions, this converges to Gaussian N(0, 1\/d). This holds for any input data \u2014 the rotation makes the coordinate distribution predictable.<\/p>\n

(3) Lloyd-Max scalar quantization<\/em> is applied.<\/strong> Because the distribution is known analytically, the optimal bucket boundaries and centroids can be precomputed from the math alone. For 2-bit quantization, that means 4 buckets per coordinate. For 4-bit, it means 16 buckets. No data passes are needed.<\/p>\n

(4) The quantized coordinates are bit-packed<\/em> into bytes<\/strong>. A 1536-dimensional vector shrinks from 6,144 bytes in FP32 to 384 bytes at 2-bit. That is a 16x compression ratio.<\/p>\n

At search time, the query is rotated once into the same domain. Scoring happens directly against the codebook values. The scoring kernel uses SIMD intrinsics \u2014 NEON on ARM and AVX-512BW on modern x86, with an AVX2 fallback \u2014 with nibble-split lookup tables for throughput.<\/p>\n

TurboQuant achieves distortion within approximately 2.7x of the information-theoretic Shannon lower bound.<\/p>\n

Recall and Speed: The Numbers<\/strong><\/h2>\n

All benchmarks use 100K vectors, 1,000 queries, k=64, and report the median of 5 runs.<\/strong><\/p>\n

For recall, turbovec compares against FAISS IndexPQ<\/code> (LUT256, nbits=8, float32 LUT). This is a strong baseline: FAISS uses a higher-precision LUT at scoring time and k-means++ for codebook training. Despite this, TurboQuant and FAISS are within 0\u20131 point at R@1 for OpenAI embeddings at d=1536 and d=3072. Both converge to 1.0 recall by k=4\u20138. GloVe at d=200 is harder. At that dimension, TurboQuant trails FAISS by 3\u20136 points at R@1, closing by k\u224816\u201332. <\/p>\n

On speed, ARM results (Apple M3 Max) show turbovec beating FAISS IndexPQFastScan by 12\u201320% across every configuration. On x86 (Intel Xeon Platinum 8481C \/ Sapphire Rapids, 8 vCPUs), turbovec wins every 4-bit configuration by 1\u20136%. It runs within ~1% of FAISS on 2-bit single-threaded. Two configurations sit slightly behind FAISS: 2-bit multi-threaded at d=1536 and d=3072. There, the inner accumulate loop is too short for unrolling amortization. FAISS\u2019s AVX-512 VBMI path holds the edge in those two cases (2\u20134%).<\/p>\n

Python API<\/strong><\/h2>\n

Installation is a single command: pip install turbovec<\/code>. The primary class is TurboQuantIndex<\/code>, initialized with a dimension and bit width.<\/p>\n

\n
\n
\n
\n
<\/div>\n
<\/div>\n
<\/div>\n<\/div>\n
Copy Code<\/span>Copied<\/span>Use a different Browser<\/span><\/a><\/div>\n<\/div>\n
from turbovec import TurboQuantIndex\n\nindex = TurboQuantIndex(dim=1536, bit_width=4)\nindex.add(vectors)\nscores, indices = index.search(query, k=10)\nindex.write(\"my_index.tq\")<\/code><\/pre>\n<\/div>\n<\/div>\n
A second class, IdMapIndex<\/code>, supports stable external uint64 IDs that survive deletes. Removal is O(1) by ID. This is useful for document stores where vectors are frequently updated or deleted.<\/p>\n
turbovec integrates with LangChain (pip install turbovec[langchain]<\/code>), LlamaIndex (pip install turbovec[llama-index]<\/code>), and Haystack (pip install turbovec[haystack]<\/code>). The Rust crate is available via cargo add turbovec<\/code>.<\/p>\n
Marktechpost\u2019s Visual Explainer<\/strong><\/h2>\n
\n
\n
\n      turbovec<\/span>\n
<\/div>\n
\n
How to Use turbovec<\/div>\n
TurboQuant vector search \u2014 Rust + Python<\/div>\n<\/div>\n<\/div>\n
    01 \/ 07<\/span>\n  <\/p><\/div>\n
\n
<\/div>\n<\/div>\n
\n
\n
\n
\n
<\/div>\n
Overview<\/span><\/p><\/div>\n
What is turbovec?<\/div>\n
turbovec is a vector index written in Rust with Python bindings. It is built on Google Research\u2019s TurboQuant algorithm \u2014 a data-oblivious quantizer that requires zero codebook training. A 10 million document corpus that occupies 31 GB as float32 fits in 4 GB with turbovec.<\/div>\n
\n
\"\u26a1\"<\/span> 16x compression at 2-bit<\/div>\n
\"\ud83d\udca8\"<\/span> Beats FAISS on ARM by 12\u201320%<\/div>\n
\"\ud83d\udd12\"<\/span> Fully local \u2014 no data egress<\/div>\n
\"\ud83d\udce6\"<\/span> MIT licensed<\/div>\n<\/div>\n
\n
<\/div>\n
          Guide created by<\/span>
\n          Marktechpost<\/a>
\n          \u2014 AI & ML Research News<\/span>\n        <\/p><\/div>\n<\/div>\n
\n
\n
<\/div>\n
Step 1<\/span><\/p><\/div>\n
Installation<\/div>\n
Install the Python package from PyPI with a single command. For Rust, add the crate via Cargo.<\/div>\n
\n
\n
<\/span><\/span><\/span><\/div>\n
            terminal<\/span>
\n