diff --git a/src/core/algorithm/hnsw/hnsw_context.cc b/src/core/algorithm/hnsw/hnsw_context.cc
index b930e4189..3d64d2ff1 100644
--- a/src/core/algorithm/hnsw/hnsw_context.cc
+++ b/src/core/algorithm/hnsw/hnsw_context.cc
@@ -18,15 +18,26 @@
 namespace zvec {
 namespace core {
 
-HnswContext::HnswContext(size_t dimension, const IndexMetric::Pointer &metric,
+HnswContext::HnswContext(size_t dimension,
+                         zvec::turbo::Quantizer::Pointer quantizer,
+                         IndexMeta::DataType qmeta_data_type,
+                         const IndexMetric::Pointer &metric,
                          const HnswEntity::Pointer &entity)
     : IndexContext(metric),
       entity_(entity),
-      dc_(entity_.get(), metric, dimension) {}
+      dc_(entity_.get(), std::move(quantizer), metric, dimension,
+          qmeta_data_type) {
+  metric_ = metric;
+}
 
-HnswContext::HnswContext(const IndexMetric::Pointer &metric,
+HnswContext::HnswContext(zvec::turbo::Quantizer::Pointer quantizer,
+                         const IndexMetric::Pointer &metric,
                          const HnswEntity::Pointer &entity)
-    : IndexContext(metric), entity_(entity), dc_(entity_.get(), metric) {}
+    : IndexContext(metric),
+      entity_(entity),
+      dc_(entity_.get(), std::move(quantizer), metric) {
+  metric_ = metric;
+}
 
 HnswContext::~HnswContext() {
   visit_filter_.destroy();
@@ -200,6 +211,7 @@ int HnswContext::update(const ailego::Params &params) {
 }
 
 int HnswContext::update_context(ContextType type, const IndexMeta &meta,
+                                zvec::turbo::Quantizer::Pointer quantizer,
                                 const IndexMetric::Pointer &metric,
                                 const HnswEntity::Pointer &entity,
                                 uint32_t magic_num) {
@@ -251,7 +263,9 @@ int HnswContext::update_context(ContextType type, const IndexMeta &meta,
   }
 
   entity_ = entity;
-  dc_.update(entity_.get(), metric, meta.dimension());
+  dc_.update(entity_.get(), std::move(quantizer), metric, meta.dimension(),
+             meta.data_type());
+  metric_ = metric;
   magic_ = magic_num;
   level_topks_.clear();
 
diff --git a/src/core/algorithm/hnsw/hnsw_context.h b/src/core/algorithm/hnsw/hnsw_context.h
index e776b81a7..e67c42f56 100644
--- a/src/core/algorithm/hnsw/hnsw_context.h
+++ b/src/core/algorithm/hnsw/hnsw_context.h
@@ -34,12 +34,16 @@ class HnswContext : public IndexContext {
     kStreamerContext = 3
   };
 
-  //! Construct
-  HnswContext(size_t dimension, const IndexMetric::Pointer &metric,
+  //! Construct with an explicit turbo quantizer (used for building the
+  //! internal HnswDistCalculator).
+  HnswContext(size_t dimension, zvec::turbo::Quantizer::Pointer quantizer,
+              IndexMeta::DataType qmeta_data_type,
+              const IndexMetric::Pointer &metric,
               const HnswEntity::Pointer &entity);
 
-  //! Construct
-  HnswContext(const IndexMetric::Pointer &metric,
+  //! Construct without dimension (lazy init via update_context).
+  HnswContext(zvec::turbo::Quantizer::Pointer quantizer,
+              const IndexMetric::Pointer &metric,
               const HnswEntity::Pointer &entity);
 
   //! Destructor
@@ -113,6 +117,7 @@ class HnswContext : public IndexContext {
 
   //! Update context, the context may be shared by different searcher/streamer
   int update_context(ContextType type, const IndexMeta &meta,
+                     zvec::turbo::Quantizer::Pointer quantizer,
                      const IndexMetric::Pointer &metric,
                      const HnswEntity::Pointer &entity, uint32_t magic_num);
 
@@ -444,10 +449,20 @@ class HnswContext : public IndexContext {
     return debug_mode_;
   }
 
-  inline void update_dist_caculator_distance(
-      const IndexMetric::MatrixDistance &distance,
-      const IndexMetric::MatrixBatchDistance &batch_distance) {
-    dc_.update_distance(distance, batch_distance);
+  //! Swap the turbo quantizer used by the dist calculator (e.g. when
+  //! switching between add/search metrics). Caller must then invoke
+  //! reset_query before using the calculator.
+  inline void update_dist_caculator_quantizer(
+      zvec::turbo::Quantizer::Pointer quantizer) {
+    dc_.update_quantizer(std::move(quantizer));
+  }
+
+  //! Swap the IndexMetric fallback used by the dist calculator (e.g. when
+  //! switching between add/search metrics for MipsSquaredEuclidean, whose
+  //! query-time metric is InnerProduct). Caller must then invoke
+  //! reset_query before using the calculator.
+  inline void update_dist_caculator_metric(IndexMetric::Pointer metric) {
+    dc_.update_metric(std::move(metric));
   }
 
   //! Get topk
diff --git a/src/core/algorithm/hnsw/hnsw_dist_calculator.h b/src/core/algorithm/hnsw/hnsw_dist_calculator.h
index 2e4b22d1f..803a3a822 100644
--- a/src/core/algorithm/hnsw/hnsw_dist_calculator.h
+++ b/src/core/algorithm/hnsw/hnsw_dist_calculator.h
@@ -13,12 +13,20 @@
 // limitations under the License.
 #pragma once
 
+#include <turbo/quantizer/quantizer.h>
 #include <zvec/core/framework/index_meta.h>
+#include <zvec/core/framework/index_metric.h>
 #include "hnsw_entity.h"
 
 namespace zvec {
 namespace core {
 
+//! Dist calculator used by HNSW. Prefers the turbo Quantizer's
+//! DistanceImpl when it is available for the current metric/dtype;
+//! otherwise falls back to IndexMetric's distance / batch_distance
+//! handles. This keeps HNSW functional for metric/dtype combos that
+//! turbo does not yet implement (e.g. MipsSquaredEuclidean, Cosine
+//! with cached norm, non-FP32 converter pipelines).
 class HnswDistCalculator {
  public:
   typedef std::shared_ptr<HnswDistCalculator> Pointer;
@@ -32,65 +40,113 @@ class HnswDistCalculator {
   };
 
  public:
-  //! Constructor
+  //! Constructor with a turbo quantizer and an IndexMetric fallback.
+  //! `dim` is the dimension of the stored vectors. `qmeta_data_type`
+  //! is the data type of the raw query accepted by `reset_query`.
   HnswDistCalculator(const HnswEntity *entity,
-                     const IndexMetric::Pointer &metric, uint32_t dim)
+                     zvec::turbo::Quantizer::Pointer quantizer,
+                     IndexMetric::Pointer metric, uint32_t dim,
+                     IndexMeta::DataType qmeta_data_type)
       : entity_(entity),
-        distance_(metric->distance()),
-        batch_distance_(metric->batch_distance()),
+        quantizer_(std::move(quantizer)),
+        metric_(std::move(metric)),
         query_(nullptr),
         dim_(dim),
-        compare_cnt_(0) {}
-
-  //! Constructor
-  HnswDistCalculator(const HnswEntity *entity,
-                     const IndexMetric::Pointer &metric, uint32_t dim,
-                     const void *query)
-      : entity_(entity),
-        distance_(metric->distance()),
-        batch_distance_(metric->batch_distance()),
-        query_(query),
-        dim_(dim),
-        compare_cnt_(0) {}
+        compare_cnt_(0) {
+    qmeta_.set_meta(qmeta_data_type, dim);
+    if (metric_) {
+      distance_ = metric_->distance();
+      batch_distance_ = metric_->batch_distance();
+    }
+  }
 
-  //! Constructor
+  //! Constructor without dimension (for lazy init via update()).
   HnswDistCalculator(const HnswEntity *entity,
-                     const IndexMetric::Pointer &metric)
+                     zvec::turbo::Quantizer::Pointer quantizer,
+                     IndexMetric::Pointer metric)
       : entity_(entity),
-        distance_(metric->distance()),
-        batch_distance_(metric->batch_distance()),
+        quantizer_(std::move(quantizer)),
+        metric_(std::move(metric)),
         query_(nullptr),
         dim_(0),
-        compare_cnt_(0) {}
+        compare_cnt_(0) {
+    if (metric_) {
+      distance_ = metric_->distance();
+      batch_distance_ = metric_->batch_distance();
+    }
+  }
 
-  void update(const HnswEntity *entity, const IndexMetric::Pointer &metric) {
+  void update(const HnswEntity *entity,
+              zvec::turbo::Quantizer::Pointer quantizer,
+              IndexMetric::Pointer metric) {
     entity_ = entity;
-    distance_ = metric->distance();
-    batch_distance_ = metric->batch_distance();
+    quantizer_ = std::move(quantizer);
+    metric_ = std::move(metric);
+    dist_impl_ = zvec::turbo::DistanceImpl{};
+    if (metric_) {
+      distance_ = metric_->distance();
+      batch_distance_ = metric_->batch_distance();
+    } else {
+      distance_ = nullptr;
+      batch_distance_ = nullptr;
+    }
   }
 
-  void update(const HnswEntity *entity, const IndexMetric::Pointer &metric,
-              uint32_t dim) {
+  void update(const HnswEntity *entity,
+              zvec::turbo::Quantizer::Pointer quantizer,
+              IndexMetric::Pointer metric, uint32_t dim,
+              IndexMeta::DataType qmeta_data_type) {
     entity_ = entity;
-    distance_ = metric->distance();
-    batch_distance_ = metric->batch_distance();
+    quantizer_ = std::move(quantizer);
+    metric_ = std::move(metric);
     dim_ = dim;
+    qmeta_.set_meta(qmeta_data_type, dim);
+    dist_impl_ = zvec::turbo::DistanceImpl{};
+    if (metric_) {
+      distance_ = metric_->distance();
+      batch_distance_ = metric_->batch_distance();
+    } else {
+      distance_ = nullptr;
+      batch_distance_ = nullptr;
+    }
+  }
+
+  //! Replace the quantizer used by this calculator. Invalidates the
+  //! cached DistanceImpl; caller should follow up with reset_query.
+  inline void update_quantizer(zvec::turbo::Quantizer::Pointer quantizer) {
+    quantizer_ = std::move(quantizer);
+    dist_impl_ = zvec::turbo::DistanceImpl{};
   }
 
-  inline void update_distance(
-      const IndexMetric::MatrixDistance &distance,
-      const IndexMetric::MatrixBatchDistance &batch_distance) {
-    distance_ = distance;
-    batch_distance_ = batch_distance;
+  //! Replace the IndexMetric fallback.
+  inline void update_metric(IndexMetric::Pointer metric) {
+    metric_ = std::move(metric);
+    if (metric_) {
+      distance_ = metric_->distance();
+      batch_distance_ = metric_->batch_distance();
+    } else {
+      distance_ = nullptr;
+      batch_distance_ = nullptr;
+    }
   }
 
-  //! Reset query vector data
+  //! Reset query vector data. Quantizes the query via the turbo
+  //! quantizer and caches a DistanceImpl for subsequent `dist(...)`
+  //! calls. Falls back to IndexMetric's raw query when turbo does not
+  //! support this metric/dtype combination.
   inline void reset_query(const void *query) {
     error_ = false;
     query_ = query;
+    if (quantizer_) {
+      dist_impl_ = quantizer_->distance(query, qmeta_);
+    } else {
+      dist_impl_ = zvec::turbo::DistanceImpl{};
+    }
   }
 
-  //! Returns distance
+  //! Returns distance between two already-quantized vectors (pairwise).
+  //! Uses the scalar DistanceFunc bound by the last reset_query when
+  //! available; otherwise falls back to IndexMetric.
   inline dist_t dist(const void *vec_lhs, const void *vec_rhs) {
     if (ailego_unlikely(vec_lhs == nullptr || vec_rhs == nullptr)) {
       LOG_ERROR("Nullptr of dense vector");
@@ -98,18 +154,43 @@ class HnswDistCalculator {
       return 0.0f;
     }
 
-    float score{0.0f};
-
+    float score = 0.0f;
+    const auto &func = dist_impl_.func();
+    if (func) {
+      // dist_impl_ holds the RAW dim expected by the turbo distance
+      // function. The metric-side dim_ is the inflated storage dim and
+      // would point past the data into the per-record extras.
+      func(vec_lhs, vec_rhs, dist_impl_.dim(), &score);
+      return score;
+    }
+    if (ailego_unlikely(!distance_)) {
+      LOG_ERROR("No distance handle available");
+      error_ = true;
+      return 0.0f;
+    }
     distance_(vec_lhs, vec_rhs, dim_, &score);
-
     return score;
   }
 
   //! Returns distance between query and vec.
   inline dist_t dist(const void *vec) {
     compare_cnt_++;
-
-    return dist(vec, query_);
+    if (ailego_unlikely(vec == nullptr)) {
+      LOG_ERROR("Nullptr of dense vector");
+      error_ = true;
+      return 0.0f;
+    }
+    if (dist_impl_.valid()) {
+      return dist_impl_(vec);
+    }
+    if (ailego_unlikely(!distance_ || query_ == nullptr)) {
+      LOG_ERROR("No distance handle or query available");
+      error_ = true;
+      return 0.0f;
+    }
+    float score = 0.0f;
+    distance_(vec, query_, dim_, &score);
+    return score;
   }
 
   //! Return distance between query and node id.
@@ -128,15 +209,23 @@ class HnswDistCalculator {
       error_ = true;
       return 0.0f;
     }
-
-    return dist(feat, query_);
+    if (dist_impl_.valid()) {
+      return dist_impl_(feat);
+    }
+    if (ailego_unlikely(!distance_ || query_ == nullptr)) {
+      LOG_ERROR("No distance handle or query available");
+      error_ = true;
+      return 0.0f;
+    }
+    float score = 0.0f;
+    distance_(feat, query_, dim_, &score);
+    return score;
   }
 
   //! Return dist node lhs between node rhs
   inline dist_t dist(node_id_t lhs, node_id_t rhs) {
     compare_cnt_++;
 
-
     IndexStorage::MemoryBlock vec_block_feat;
     int ret = entity_->get_vector(lhs, vec_block_feat);
     if (ailego_unlikely(ret != 0)) {
@@ -177,8 +266,19 @@ class HnswDistCalculator {
 
   void batch_dist(const void **vecs, size_t num, dist_t *distances) {
     compare_cnt_++;
-
-    batch_distance_(vecs, query_, num, dim_, distances);
+    if (dist_impl_.batch_valid()) {
+      dist_impl_.batch(vecs, num, distances);
+      return;
+    }
+    if (batch_distance_ && query_ != nullptr) {
+      batch_distance_(vecs, query_, num, dim_, distances);
+      return;
+    }
+    // Last-resort scalar fallback using whatever single-distance path
+    // is available.
+    for (size_t i = 0; i < num; ++i) {
+      distances[i] = dist(vecs[i]);
+    }
   }
 
   inline dist_t batch_dist(node_id_t id) {
@@ -197,10 +297,19 @@ class HnswDistCalculator {
       error_ = true;
       return 0.0f;
     }
-    dist_t score = 0;
-    batch_distance_(&feat, query_, 1, dim_, &score);
-
-    return score;
+    if (dist_impl_.batch_valid()) {
+      dist_t score = 0;
+      const void *feats[1] = {feat};
+      dist_impl_.batch(feats, 1, &score);
+      return score;
+    }
+    if (batch_distance_ && query_ != nullptr) {
+      dist_t score = 0;
+      const void *feats[1] = {feat};
+      batch_distance_(feats, query_, 1, dim_, &score);
+      return score;
+    }
+    return dist(feat);
   }
 
   inline void clear() {
@@ -225,6 +334,12 @@ class HnswDistCalculator {
     return dim_;
   }
 
+  //! Expose the underlying turbo quantizer (for clients that need to
+  //! reach lower-level turbo APIs).
+  inline const zvec::turbo::Quantizer::Pointer &quantizer() const {
+    return quantizer_;
+  }
+
  private:
   HnswDistCalculator(const HnswDistCalculator &) = delete;
   HnswDistCalculator &operator=(const HnswDistCalculator &) = delete;
@@ -232,14 +347,18 @@ class HnswDistCalculator {
  private:
   const HnswEntity *entity_;
 
-  IndexMetric::MatrixDistance distance_;
-  IndexMetric::MatrixBatchDistance batch_distance_;
+  zvec::turbo::Quantizer::Pointer quantizer_{};
+  IndexMetric::Pointer metric_{};
+  zvec::turbo::DistanceImpl dist_impl_{};
+  IndexQueryMeta qmeta_{};
+
+  IndexMetric::MatrixDistance distance_{nullptr};
+  IndexMetric::MatrixBatchDistance batch_distance_{nullptr};
 
   const void *query_;
   uint32_t dim_;
 
   uint32_t compare_cnt_;  // record distance compute times
-  // uint32_t compare_cnt_batch_;  // record batch distance compute time
   bool error_{false};
 };
 
diff --git a/src/core/algorithm/hnsw/hnsw_params.h b/src/core/algorithm/hnsw/hnsw_params.h
index 4caa148d5..4d1309a0f 100644
--- a/src/core/algorithm/hnsw/hnsw_params.h
+++ b/src/core/algorithm/hnsw/hnsw_params.h
@@ -111,5 +111,10 @@ static const std::string PARAM_HNSW_REDUCER_EFCONSTRUCTION(
 static const std::string PARAM_HNSW_STREAMER_USE_CONTIGUOUS_MEMORY(
     "proxima.hnsw.streamer.use_contiguous_memory");
 
+//! Turbo quantizer class name used by HnswStreamer. Defaults to
+//! "Fp32Quantizer" to preserve the legacy FP32 distance path.
+static const std::string PARAM_HNSW_STREAMER_TURBO_QUANTIZER_CLASS(
+    "proxima.hnsw.streamer.turbo_quantizer_class");
+
 }  // namespace core
 }  // namespace zvec
diff --git a/src/core/algorithm/hnsw/hnsw_streamer.cc b/src/core/algorithm/hnsw/hnsw_streamer.cc
index 935cae5d4..1830f52e7 100644
--- a/src/core/algorithm/hnsw/hnsw_streamer.cc
+++ b/src/core/algorithm/hnsw/hnsw_streamer.cc
@@ -21,6 +21,7 @@
 #include "hnsw_context.h"
 #include "hnsw_dist_calculator.h"
 #include "hnsw_index_provider.h"
+#include "hnsw_params.h"
 
 namespace zvec {
 namespace core {
@@ -71,6 +72,13 @@ int HnswStreamer::init(const IndexMeta &imeta, const ailego::Params &params) {
   params.get(PARAM_HNSW_STREAMER_USE_CONTIGUOUS_MEMORY,
              &use_contiguous_memory_);
 
+  turbo_quantizer_class_ = "Fp32Quantizer";
+  params.get(PARAM_HNSW_STREAMER_TURBO_QUANTIZER_CLASS,
+             &turbo_quantizer_class_);
+  if (turbo_quantizer_class_.empty()) {
+    turbo_quantizer_class_ = "Fp32Quantizer";
+  }
+
   params.get(PARAM_HNSW_STREAMER_DOCS_SOFT_LIMIT, &docs_soft_limit_);
   if (docs_soft_limit_ > 0 && docs_soft_limit_ > docs_hard_limit_) {
     LOG_ERROR("[%s] must be >= [%s]",
@@ -183,6 +191,8 @@ int HnswStreamer::cleanup(void) {
 
   meta_.clear();
   metric_.reset();
+  add_quantizer_.reset();
+  search_quantizer_.reset();
   stats_.clear();
   if (entity_) {
     entity_->cleanup();
@@ -314,16 +324,36 @@ int HnswStreamer::open(IndexStorage::Pointer stg) {
     return IndexError_InvalidArgument;
   }
 
-  add_distance_ = metric_->distance();
-  add_batch_distance_ = metric_->batch_distance();
-
-  search_distance_ = add_distance_;
-  search_batch_distance_ = add_batch_distance_;
-
+  // Create and initialize the turbo quantizer used by HnswDistCalculator.
+  add_quantizer_ = IndexFactory::CreateQuantizer(turbo_quantizer_class_);
+  if (!add_quantizer_) {
+    LOG_ERROR("Failed to create turbo quantizer '%s'",
+              turbo_quantizer_class_.c_str());
+    return IndexError_NoExist;
+  }
+  ret = add_quantizer_->init(meta_, meta_.streamer_params());
+  if (ret != 0) {
+    LOG_ERROR("Failed to init turbo quantizer '%s', ret=%d",
+              turbo_quantizer_class_.c_str(), ret);
+    return ret;
+  }
+  // Default: use the same quantizer for search. When the underlying
+  // metric exposes a query-side variant (e.g. MipsSquaredEuclidean) we
+  // still keep the add_quantizer_ as a conservative choice here. Any
+  // specialized handling can be layered on top later.
+  search_quantizer_ = add_quantizer_;
+
+  // Resolve the search-side metric. For metrics like MipsSquaredEuclidean
+  // the index distance (used while building the graph) is not the same as
+  // the user-facing query distance: the metric exposes a `query_metric`
+  // (e.g. InnerProduct) which should be used at search time so that the
+  // top-k results reflect the intended ranking. Fall back to `metric_`
+  // when no usable query metric is provided.
   if (metric_->query_metric() && metric_->query_metric()->distance() &&
       metric_->query_metric()->batch_distance()) {
-    search_distance_ = metric_->query_metric()->distance();
-    search_batch_distance_ = metric_->query_metric()->batch_distance();
+    search_metric_ = metric_->query_metric();
+  } else {
+    search_metric_ = metric_;
   }
 
   // Create algorithm based on entity storage mode
@@ -410,8 +440,8 @@ IndexStreamer::Context::Pointer HnswStreamer::create_context(void) const {
     LOG_ERROR("CreateContext clone init failed");
     return Context::Pointer();
   }
-  HnswContext *ctx =
-      new (std::nothrow) HnswContext(meta_.dimension(), metric_, entity);
+  HnswContext *ctx = new (std::nothrow) HnswContext(
+      meta_.dimension(), add_quantizer_, meta_.data_type(), metric_, entity);
   if (ailego_unlikely(ctx == nullptr)) {
     LOG_ERROR("Failed to new HnswContext");
     return Context::Pointer();
@@ -465,8 +495,8 @@ int HnswStreamer::update_context(HnswContext *ctx) const {
   ctx->set_min_scan_limit(min_scan_limit_);
   ctx->set_max_scan_ratio(max_scan_ratio_);
   ctx->set_bruteforce_threshold(bruteforce_threshold_);
-  return ctx->update_context(HnswContext::kStreamerContext, meta_, metric_,
-                             entity, magic_);
+  return ctx->update_context(HnswContext::kStreamerContext, meta_,
+                             add_quantizer_, metric_, entity, magic_);
 }
 
 //! Add a vector with id into index
@@ -511,7 +541,8 @@ int HnswStreamer::add_with_id_impl(uint32_t id, const void *query,
   AILEGO_DEFER([&]() { shared_mutex_.unlock_shared(); });
 
   ctx->clear();
-  ctx->update_dist_caculator_distance(add_distance_, add_batch_distance_);
+  ctx->update_dist_caculator_quantizer(add_quantizer_);
+  ctx->update_dist_caculator_metric(metric_);
   ctx->reset_query(query);
   ctx->check_need_adjuct_ctx(entity_->doc_cnt());
 
@@ -591,7 +622,8 @@ int HnswStreamer::add_impl(uint64_t pkey, const void *query,
   AILEGO_DEFER([&]() { shared_mutex_.unlock_shared(); });
 
   ctx->clear();
-  ctx->update_dist_caculator_distance(add_distance_, add_batch_distance_);
+  ctx->update_dist_caculator_quantizer(add_quantizer_);
+  ctx->update_dist_caculator_metric(metric_);
   ctx->reset_query(query);
   ctx->check_need_adjuct_ctx(entity_->doc_cnt());
 
@@ -663,7 +695,8 @@ int HnswStreamer::search_impl(const void *query, const IndexQueryMeta &qmeta,
   }
 
   ctx->clear();
-  ctx->update_dist_caculator_distance(search_distance_, search_batch_distance_);
+  ctx->update_dist_caculator_quantizer(search_quantizer_);
+  ctx->update_dist_caculator_metric(search_metric_);
   ctx->resize_results(count);
   ctx->check_need_adjuct_ctx(entity_->doc_cnt());
   for (size_t q = 0; q < count; ++q) {
@@ -733,7 +766,8 @@ int HnswStreamer::search_bf_impl(
   }
 
   ctx->clear();
-  ctx->update_dist_caculator_distance(search_distance_, search_batch_distance_);
+  ctx->update_dist_caculator_quantizer(search_quantizer_);
+  ctx->update_dist_caculator_metric(search_metric_);
   ctx->resize_results(count);
 
   if (ctx->group_by_search()) {
@@ -827,7 +861,8 @@ int HnswStreamer::search_bf_by_p_keys_impl(
   }
 
   ctx->clear();
-  ctx->update_dist_caculator_distance(search_distance_, search_batch_distance_);
+  ctx->update_dist_caculator_quantizer(search_quantizer_);
+  ctx->update_dist_caculator_metric(search_metric_);
   ctx->resize_results(count);
 
   if (ctx->group_by_search()) {
diff --git a/src/core/algorithm/hnsw/hnsw_streamer.h b/src/core/algorithm/hnsw/hnsw_streamer.h
index 3f4511ab1..8aaea0cd2 100644
--- a/src/core/algorithm/hnsw/hnsw_streamer.h
+++ b/src/core/algorithm/hnsw/hnsw_streamer.h
@@ -14,6 +14,7 @@
 #pragma once
 
 #include <ailego/parallel/lock.h>
+#include <turbo/quantizer/quantizer.h>
 #include <zvec/core/framework/index_framework.h>
 #include "hnsw_algorithm.h"
 #include "hnsw_streamer_entity.h"
@@ -199,12 +200,19 @@ class HnswStreamer : public IndexStreamer {
   HnswAlgorithmBase::UPointer alg_;
   IndexMeta meta_{};
   IndexMetric::Pointer metric_{};
-
-  IndexMetric::MatrixDistance add_distance_{};
-  IndexMetric::MatrixDistance search_distance_{};
-
-  IndexMetric::MatrixBatchDistance add_batch_distance_{};
-  IndexMetric::MatrixBatchDistance search_batch_distance_{};
+  //! Search-side metric, used as fallback when the search-side turbo
+  //! quantizer does not implement a distance for the current metric/dtype
+  //! (e.g. MipsSquaredEuclidean's query_metric is InnerProduct).
+  IndexMetric::Pointer search_metric_{};
+
+  //! Turbo quantizers bound to this streamer. `add_quantizer_` is used
+  //! when inserting vectors (mirrors the old `metric_->distance()`).
+  //! `search_quantizer_` is used for queries and falls back to
+  //! `add_quantizer_` when the metric does not expose a query-side
+  //! variant.
+  zvec::turbo::Quantizer::Pointer add_quantizer_{};
+  zvec::turbo::Quantizer::Pointer search_quantizer_{};
+  std::string turbo_quantizer_class_{};
 
   Stats stats_{};
   std::mutex mutex_{};
diff --git a/src/core/framework/index_factory.cc b/src/core/framework/index_factory.cc
index 69fe0e98d..e93f57bc7 100644
--- a/src/core/framework/index_factory.cc
+++ b/src/core/framework/index_factory.cc
@@ -257,5 +257,18 @@ std::vector<std::string> IndexFactory::AllRefiners(void) {
   return ailego::Factory<IndexRefiner>::Classes();
 }
 
+std::shared_ptr<turbo::Quantizer> IndexFactory::CreateQuantizer(
+    const std::string &name) {
+  return ailego::Factory<zvec::turbo::Quantizer>::MakeShared(name.c_str());
+}
+
+bool IndexFactory::HasQuantizer(const std::string &name) {
+  return ailego::Factory<turbo::Quantizer>::Has(name.c_str());
+}
+
+std::vector<std::string> IndexFactory::AllQuantizers(void) {
+  return ailego::Factory<turbo::Quantizer>::Classes();
+}
+
 }  // namespace core
 }  // namespace zvec
diff --git a/src/core/framework/index_meta.cc b/src/core/framework/index_meta.cc
index 11d54cb63..d0eadb02d 100644
--- a/src/core/framework/index_meta.cc
+++ b/src/core/framework/index_meta.cc
@@ -30,7 +30,8 @@ struct IndexMetaFormatHeader {
   uint32_t space_id;
   uint32_t attachment_offset;
   uint32_t attachment_size;
-  uint8_t reserved_[4092];
+  uint32_t extra_meta_size;
+  uint8_t reserved_[4088];
 };
 
 static_assert(sizeof(IndexMetaFormatHeader) % 32 == 0,
@@ -47,6 +48,7 @@ void IndexMeta::serialize(std::string *out) const {
   format.dimension = dimension_;
   format.unit_size = unit_size_;
   format.space_id = space_id_;
+  format.extra_meta_size = extra_meta_size_;
 
   if (!metric_name_.empty()) {
     ailego::Params item;
diff --git a/src/core/metric/quantized_integer_metric.cc b/src/core/metric/quantized_integer_metric.cc
index e4db83146..6fa492d75 100644
--- a/src/core/metric/quantized_integer_metric.cc
+++ b/src/core/metric/quantized_integer_metric.cc
@@ -98,22 +98,41 @@ class QuantizedIntegerMetric : public IndexMetric {
         if (meta_.data_type() == IndexMeta::DataType::DT_INT8) {
           auto turbo_ret = turbo::get_distance_func(
               turbo::MetricType::kSquaredEuclidean, turbo::DataType::kInt8,
-              turbo::QuantizeType::kDefault);
+              static_cast<turbo::QuantizeType>(quantize_type_));
           if (turbo_ret && m == 1 && n == 1) {
-            return turbo_ret;
+            return wrap_turbo_distance(std::move(turbo_ret));
           }
+
           return DistanceMatrixCompute<SquaredEuclidean, int8_t>(m, n);
         }
         if (meta_.data_type() == IndexMeta::DataType::DT_INT4) {
+          auto turbo_ret = turbo::get_distance_func(
+              turbo::MetricType::kSquaredEuclidean, turbo::DataType::kInt4,
+              static_cast<turbo::QuantizeType>(quantize_type_));
+          if (turbo_ret && m == 1 && n == 1) {
+            return wrap_turbo_distance(std::move(turbo_ret));
+          }
           return DistanceMatrixCompute<SquaredEuclidean, uint8_t>(m, n);
         }
         break;
 
       case MetricType::kInnerProduct:
         if (meta_.data_type() == IndexMeta::DataType::DT_INT8) {
+          auto turbo_ret = turbo::get_distance_func(
+              turbo::MetricType::kInnerProduct, turbo::DataType::kInt8,
+              static_cast<turbo::QuantizeType>(quantize_type_));
+          if (turbo_ret && m == 1 && n == 1) {
+            return wrap_turbo_distance(std::move(turbo_ret));
+          }
           return DistanceMatrixCompute<MinusInnerProduct, int8_t>(m, n);
         }
         if (meta_.data_type() == IndexMeta::DataType::DT_INT4) {
+          auto turbo_ret = turbo::get_distance_func(
+              turbo::MetricType::kInnerProduct, turbo::DataType::kInt4,
+              static_cast<turbo::QuantizeType>(quantize_type_));
+          if (turbo_ret && m == 1 && n == 1) {
+            return wrap_turbo_distance(std::move(turbo_ret));
+          }
           return DistanceMatrixCompute<MinusInnerProduct, uint8_t>(m, n);
         }
         break;
@@ -139,13 +158,19 @@ class QuantizedIntegerMetric : public IndexMetric {
         if (meta_.data_type() == IndexMeta::DataType::DT_INT8) {
           auto turbo_ret = turbo::get_distance_func(
               turbo::MetricType::kCosine, turbo::DataType::kInt8,
-              turbo::QuantizeType::kDefault);
+              static_cast<turbo::QuantizeType>(quantize_type_));
           if (turbo_ret) {
-            return turbo_ret;
+            return wrap_turbo_distance(std::move(turbo_ret));
           }
           return DistanceMatrixCompute<CosineMinusInnerProduct, int8_t>(m, n);
         }
         if (meta_.data_type() == IndexMeta::DataType::DT_INT4) {
+          auto turbo_ret = turbo::get_distance_func(
+              turbo::MetricType::kCosine, turbo::DataType::kInt4,
+              static_cast<turbo::QuantizeType>(quantize_type_));
+          if (turbo_ret) {
+            return wrap_turbo_distance(std::move(turbo_ret));
+          }
           return DistanceMatrixCompute<CosineMinusInnerProduct, uint8_t>(m, n);
         }
         break;
@@ -160,15 +185,21 @@ class QuantizedIntegerMetric : public IndexMetric {
         if (meta_.data_type() == IndexMeta::DataType::DT_INT8) {
           auto turbo_ret = turbo::get_batch_distance_func(
               turbo::MetricType::kSquaredEuclidean, turbo::DataType::kInt8,
-              turbo::QuantizeType::kDefault);
+              static_cast<turbo::QuantizeType>(quantize_type_));
           if (turbo_ret) {
-            return turbo_ret;
+            return wrap_turbo_batch_distance(std::move(turbo_ret));
           }
           return reinterpret_cast<IndexMetric::MatrixBatchDistanceHandle>(
               BaseDistanceBatchWithScoreUnquantized<SquaredEuclidean, int8_t,
                                                     12, 2>::ComputeBatch);
         }
         if (meta_.data_type() == IndexMeta::DataType::DT_INT4) {
+          auto turbo_ret = turbo::get_batch_distance_func(
+              turbo::MetricType::kSquaredEuclidean, turbo::DataType::kInt4,
+              static_cast<turbo::QuantizeType>(quantize_type_));
+          if (turbo_ret) {
+            return wrap_turbo_batch_distance(std::move(turbo_ret));
+          }
           return reinterpret_cast<IndexMetric::MatrixBatchDistanceHandle>(
               BaseDistanceBatchWithScoreUnquantized<SquaredEuclidean, uint8_t,
                                                     12, 2>::ComputeBatch);
@@ -177,11 +208,23 @@ class QuantizedIntegerMetric : public IndexMetric {
 
       case MetricType::kInnerProduct:
         if (meta_.data_type() == IndexMeta::DataType::DT_INT8) {
+          auto turbo_ret = turbo::get_batch_distance_func(
+              turbo::MetricType::kInnerProduct, turbo::DataType::kInt8,
+              static_cast<turbo::QuantizeType>(quantize_type_));
+          if (turbo_ret) {
+            return wrap_turbo_batch_distance(std::move(turbo_ret));
+          }
           return reinterpret_cast<IndexMetric::MatrixBatchDistanceHandle>(
               BaseDistanceBatchWithScoreUnquantized<MinusInnerProduct, int8_t,
                                                     12, 2>::ComputeBatch);
         }
         if (meta_.data_type() == IndexMeta::DataType::DT_INT4) {
+          auto turbo_ret = turbo::get_batch_distance_func(
+              turbo::MetricType::kInnerProduct, turbo::DataType::kInt4,
+              static_cast<turbo::QuantizeType>(quantize_type_));
+          if (turbo_ret) {
+            return wrap_turbo_batch_distance(std::move(turbo_ret));
+          }
           return reinterpret_cast<IndexMetric::MatrixBatchDistanceHandle>(
               BaseDistanceBatchWithScoreUnquantized<MinusInnerProduct, uint8_t,
                                                     12, 2>::ComputeBatch);
@@ -215,15 +258,21 @@ class QuantizedIntegerMetric : public IndexMetric {
         if (meta_.data_type() == IndexMeta::DataType::DT_INT8) {
           auto turbo_ret = turbo::get_batch_distance_func(
               turbo::MetricType::kCosine, turbo::DataType::kInt8,
-              turbo::QuantizeType::kDefault);
+              static_cast<turbo::QuantizeType>(quantize_type_));
           if (turbo_ret) {
-            return turbo_ret;
+            return wrap_turbo_batch_distance(std::move(turbo_ret));
           }
           return reinterpret_cast<IndexMetric::MatrixBatchDistanceHandle>(
               BaseDistanceBatchWithScoreUnquantized<
                   CosineMinusInnerProduct, int8_t, 12, 2>::ComputeBatch);
         }
         if (meta_.data_type() == IndexMeta::DataType::DT_INT4) {
+          auto turbo_ret = turbo::get_batch_distance_func(
+              turbo::MetricType::kCosine, turbo::DataType::kInt4,
+              static_cast<turbo::QuantizeType>(quantize_type_));
+          if (turbo_ret) {
+            return wrap_turbo_batch_distance(std::move(turbo_ret));
+          }
           return reinterpret_cast<IndexMetric::MatrixBatchDistanceHandle>(
               BaseDistanceBatchWithScoreUnquantized<
                   CosineMinusInnerProduct, uint8_t, 12, 2>::ComputeBatch);
@@ -290,7 +339,12 @@ class QuantizedIntegerMetric : public IndexMetric {
           turbo::MetricType::kCosine, turbo::DataType::kInt8,
           turbo::QuantizeType::kDefault);
       if (turbo_ret) {
-        return turbo_ret;
+        // Turbo's batch distance function preprocesses the query internally
+        // (per-call, into a thread-local buffer) so the single-distance path
+        // can keep receiving raw int8 queries. Return nullptr here to avoid
+        // a global shift that would corrupt the symmetric single-distance
+        // contract used by node-vs-node calls.
+        return nullptr;
       }
       return CosineMinusInnerProductDistanceBatchWithScoreUnquantized<
           int8_t, 1, 1>::GetQueryPreprocessFunc();
@@ -300,7 +354,8 @@ class QuantizedIntegerMetric : public IndexMetric {
           turbo::MetricType::kSquaredEuclidean, turbo::DataType::kInt8,
           turbo::QuantizeType::kDefault);
       if (turbo_ret) {
-        return turbo_ret;
+        // See comment above: turbo handles query preprocessing internally.
+        return nullptr;
       }
       return SquaredEuclideanDistanceBatchWithScoreUnquantized<
           int8_t, 1, 1>::GetQueryPreprocessFunc();
@@ -310,6 +365,48 @@ class QuantizedIntegerMetric : public IndexMetric {
 
 
  private:
+  //! Extras embedded in each quantized record by the converter/reformer.
+  //! The HnswStreamer (and friends) inflate the meta dimension by these
+  //! "extra" units so element_size() reflects per-vector storage. Turbo
+  //! distance funcs expect the *raw* original dim, so we need to subtract.
+  //!
+  //! Layouts:
+  //!  - IntegerStreamingReformer (IP/L2):
+  //!      INT8: data + 20 bytes extras   (extra_units = 20)
+  //!      INT4: data + 32 nibbles extras (extra_units = 32 == 16 bytes)
+  //!  - CosineConverter (Cosine):
+  //!      INT8: data + 20 bytes extras + 4 bytes norm  (extra_units = 24)
+  //!      INT4: data + 32 nibbles extras + 8 nibbles norm (extra_units = 40)
+  size_t extra_dim() const {
+    bool is_cosine = (origin_metric_type_ == MetricType::kCosine ||
+                      origin_metric_type_ == MetricType::kNormalizedCosine);
+    if (meta_.data_type() == IndexMeta::DataType::DT_INT8) {
+      return is_cosine ? 24 : 20;
+    }
+    if (meta_.data_type() == IndexMeta::DataType::DT_INT4) {
+      return is_cosine ? 40 : 32;
+    }
+    return 0;
+  }
+
+  //! Wrap a turbo distance function so callers can keep passing the inflated
+  //! dim from IndexMeta::dimension(); turbo expects the raw original dim.
+  MatrixDistance wrap_turbo_distance(turbo::DistanceFunc f) const {
+    size_t extra = extra_dim();
+    return [f = std::move(f), extra](const void *m, const void *q, size_t dim,
+                                     float *out) { f(m, q, dim - extra, out); };
+  }
+
+  //! Wrap a turbo batch distance function with the same dim adjustment.
+  MatrixBatchDistance wrap_turbo_batch_distance(
+      turbo::BatchDistanceFunc f) const {
+    size_t extra = extra_dim();
+    return [f = std::move(f), extra](const void **m, const void *q, size_t num,
+                                     size_t dim, float *out) {
+      f(m, q, num, dim - extra, out);
+    };
+  }
+
   //! Returns m x n distance matrix compute function.
   template <template <typename, size_t, size_t> class DistanceMatrix,
             typename T>
diff --git a/src/core/quantizer/cosine_converter.cc b/src/core/quantizer/cosine_converter.cc
index dd5cbbd0d..86cc71afa 100644
--- a/src/core/quantizer/cosine_converter.cc
+++ b/src/core/quantizer/cosine_converter.cc
@@ -308,6 +308,13 @@ class CosineConverter : public IndexConverter {
     }
 
     meta_.set_meta(dst_type_, meta_.dimension() + ExtraDimension(dst_type_));
+    // Mark the extra meta bytes appended to each vector (the norm float for
+    // FP32/FP16, plus quantization params for INT4/INT8). Downstream
+    // consumers (e.g. Fp32Quantizer) use meta.extra_meta_size() to detect
+    // that the dimension has been inflated and recover the raw dim.
+    meta_.set_extra_meta_size(
+        ExtraDimension(dst_type_) *
+        static_cast<uint32_t>(IndexMeta::UnitSizeof(dst_type_)));
 
     return 0;
   }
diff --git a/src/core/utility/buffer_storage.cc b/src/core/utility/buffer_storage.cc
index 62d442a5b..90a4261e4 100644
--- a/src/core/utility/buffer_storage.cc
+++ b/src/core/utility/buffer_storage.cc
@@ -89,6 +89,7 @@ class BufferStorage : public IndexStorage {
       }
       auto *data = raw + offset;
       memmove(buf, data, len);
+      owner_->release_buffer(segment_id_);
       return len;
     }
 
@@ -214,6 +215,10 @@ class BufferStorage : public IndexStorage {
     return buffer_pool_handle_->get_block(offset, length, block_id);
   }
 
+  void release_buffer(size_t block_id) const {
+    buffer_pool_handle_->release_one(block_id);
+  }
+
   int get_meta(size_t offset, size_t length, char *out) {
     return buffer_pool_handle_->get_meta(offset, length, out);
   }
@@ -472,6 +477,18 @@ class BufferStorage : public IndexStorage {
     segments_.clear();
     memset(&header_, 0, sizeof(header_));
     memset(&footer_, 0, sizeof(footer_));
+    // Release all remaining buffer pool block references before destroying the
+    // pool.  The raw-pointer read() variant acquires blocks without providing a
+    // release path, so we clean up any leftover refs here to satisfy the
+    // VecBufferPool destructor assertion.
+    if (buffer_pool_ && buffer_pool_handle_) {
+      auto &page_table = buffer_pool_->page_table_;
+      for (size_t i = 0; i < page_table.entry_num(); ++i) {
+        while (!page_table.is_released(i)) {
+          buffer_pool_handle_->release_one(i);
+        }
+      }
+    }
     buffer_pool_handle_.reset();
     buffer_pool_.reset();
     max_segment_size_ = 0;
diff --git a/src/include/zvec/core/framework/index_factory.h b/src/include/zvec/core/framework/index_factory.h
index d891eaa5a..00e77894c 100644
--- a/src/include/zvec/core/framework/index_factory.h
+++ b/src/include/zvec/core/framework/index_factory.h
@@ -14,6 +14,7 @@
 
 #pragma once
 
+#include <turbo/quantizer/quantizer.h>
 #include <zvec/ailego/pattern/factory.h>
 #include <zvec/core/framework/index_builder.h>
 #include <zvec/core/framework/index_cluster.h>
@@ -167,6 +168,16 @@ struct IndexFactory {
 
   //! Retrieve all refiner classes
   static std::vector<std::string> AllRefiners(void);
+
+  //! Create a quantizer by name
+  static std::shared_ptr<zvec::turbo::Quantizer> CreateQuantizer(
+      const std::string &name);
+
+  //! Test if the quantizer exists
+  static bool HasQuantizer(const std::string &name);
+
+  //! Retrieve all quantizer classes
+  static std::vector<std::string> AllQuantizers(void);
 };
 
 //! Register Index Metric
@@ -283,5 +294,13 @@ struct IndexFactory {
 #define INDEX_FACTORY_REGISTER_REFINER(__IMPL__, ...) \
   INDEX_FACTORY_REGISTER_REFINER_ALIAS(__IMPL__, __IMPL__, ##__VA_ARGS__)
 
+//! Register Quantizer
+#define INDEX_FACTORY_REGISTER_QUANTIZER_ALIAS(__NAME__, __IMPL__, ...) \
+  AILEGO_FACTORY_REGISTER(__NAME__, turbo::Quantizer, __IMPL__, ##__VA_ARGS__)
+
+//! Register Quantizer
+#define INDEX_FACTORY_REGISTER_QUANTIZER(__IMPL__, ...) \
+  INDEX_FACTORY_REGISTER_QUANTIZER_ALIAS(__IMPL__, __IMPL__, ##__VA_ARGS__)
+
 }  // namespace core
 }  // namespace zvec
diff --git a/src/include/zvec/core/framework/index_meta.h b/src/include/zvec/core/framework/index_meta.h
index 3a09aaefb..808c3ad6a 100644
--- a/src/include/zvec/core/framework/index_meta.h
+++ b/src/include/zvec/core/framework/index_meta.h
@@ -40,6 +40,7 @@ class IndexMeta {
     DT_BINARY64 = 8,
   };
 
+
   /*! Major Orders
    */
   enum MajorOrder {
@@ -102,6 +103,7 @@ class IndexMeta {
         reducer_params_(rhs.reducer_params_),
         searcher_params_(rhs.searcher_params_),
         streamer_params_(rhs.streamer_params_),
+        extra_meta_size_(rhs.extra_meta_size_),
         attributes_(rhs.attributes_) {}
 
   //! Constructor
@@ -137,6 +139,7 @@ class IndexMeta {
         reducer_params_(std::move(rhs.reducer_params_)),
         searcher_params_(std::move(rhs.searcher_params_)),
         streamer_params_(std::move(rhs.streamer_params_)),
+        extra_meta_size_(rhs.extra_meta_size_),
         attributes_(std::move(rhs.attributes_)) {}
 
   //! Assignment
@@ -173,6 +176,7 @@ class IndexMeta {
     searcher_params_ = std::move(rhs.searcher_params_);
     streamer_params_ = std::move(rhs.streamer_params_);
     attributes_ = std::move(rhs.attributes_);
+    extra_meta_size_ = rhs.extra_meta_size_;
 
     return *this;
   }
@@ -211,6 +215,7 @@ class IndexMeta {
     searcher_params_ = std::move(rhs.searcher_params_);
     streamer_params_ = std::move(rhs.streamer_params_);
     attributes_ = std::move(rhs.attributes_);
+    extra_meta_size_ = rhs.extra_meta_size_;
 
     return *this;
   }
@@ -249,6 +254,7 @@ class IndexMeta {
     searcher_params_.clear();
     streamer_params_.clear();
     attributes_.clear();
+    extra_meta_size_ = 0;
   }
 
   //! Retrieve major order information
@@ -281,6 +287,11 @@ class IndexMeta {
     return element_size_;
   }
 
+  //! Retrieve extra meta size in bytes
+  uint32_t extra_meta_size(void) const {
+    return extra_meta_size_;
+  }
+
   //! Retrieve space id
   uint64_t space_id(void) const {
     return space_id_;
@@ -451,6 +462,11 @@ class IndexMeta {
     this->set_meta(data_type, UnitSizeof(data_type), dim);
   }
 
+  //! Set extra meta size
+  void set_extra_meta_size(uint32_t size) {
+    extra_meta_size_ = size;
+  }
+
   //! Set information of metric
   template <typename TName, typename TParams>
   void set_metric(TName &&name, uint32_t rev, TParams &&params) {
@@ -586,6 +602,7 @@ class IndexMeta {
   uint32_t dimension_{0};
   uint32_t unit_size_{0};
   uint32_t element_size_{0};
+  uint32_t extra_meta_size_{0};
   uint64_t space_id_{0};
   uint32_t metric_revision_{0};
   uint32_t converter_revision_{0};
@@ -632,6 +649,19 @@ class IndexQueryMeta {
         unit_size_(unit),
         element_size_(IndexMeta::ElementSizeof(data_type, unit, dim)) {}
 
+  //! Constructor
+  IndexQueryMeta(IndexMeta::MetaType meta_type, IndexMeta::DataType data_type,
+                 uint32_t unit, uint32_t dim, uint32_t quantize_type,
+                 uint32_t extra_meta_size)
+      : meta_type_(meta_type),
+        data_type_(data_type),
+        dimension_(dim),
+        unit_size_(unit),
+        quantize_type_(quantize_type),
+        extra_meta_size_(extra_meta_size),
+        element_size_(IndexMeta::ElementSizeof(data_type, unit, dim) +
+                      extra_meta_size_) {}
+
   //! Constructor
   IndexQueryMeta(IndexMeta::DataType data_type, uint32_t dim)
       : IndexQueryMeta{IndexMeta::MetaType::MT_DENSE, data_type,
@@ -676,7 +706,8 @@ class IndexQueryMeta {
   //! Set dimension of feature
   void set_dimension(uint32_t dim) {
     dimension_ = dim;
-    element_size_ = IndexMeta::ElementSizeof(data_type_, unit_size_, dim);
+    element_size_ = IndexMeta::ElementSizeof(data_type_, unit_size_, dim) +
+                    extra_meta_size_;
   }
 
   //! Set meta type
@@ -694,7 +725,8 @@ class IndexQueryMeta {
     data_type_ = data_type;
     dimension_ = dim;
     unit_size_ = unit;
-    element_size_ = IndexMeta::ElementSizeof(data_type, unit, dim);
+    element_size_ =
+        IndexMeta::ElementSizeof(data_type, unit, dim) + extra_meta_size_;
   }
 
   //! Set meta information of feature
@@ -702,11 +734,25 @@ class IndexQueryMeta {
     this->set_meta(data_type, IndexMeta::UnitSizeof(data_type), dim);
   }
 
+  //! Set meta information of feature with quantize type and extra meta size
+  void set_meta(IndexMeta::DataType data_type, uint32_t dim,
+                uint32_t quantize_type, uint32_t extra_meta_size) {
+    data_type_ = data_type;
+    dimension_ = dim;
+    unit_size_ = IndexMeta::UnitSizeof(data_type);
+    quantize_type_ = quantize_type;
+    extra_meta_size_ = extra_meta_size;
+    element_size_ =
+        IndexMeta::ElementSizeof(data_type, unit_size_, dim) + extra_meta_size_;
+  }
+
  private:
   IndexMeta::MetaType meta_type_{IndexMeta::MetaType::MT_DENSE};
   IndexMeta::DataType data_type_{IndexMeta::DataType::DT_UNDEFINED};
   uint32_t dimension_{0};
   uint32_t unit_size_{0};
+  uint32_t quantize_type_{0};
+  uint32_t extra_meta_size_{0};
   uint32_t element_size_{0};
 };
 
diff --git a/src/include/zvec/core/framework/index_metric.h b/src/include/zvec/core/framework/index_metric.h
index 24d772362..3610671af 100644
--- a/src/include/zvec/core/framework/index_metric.h
+++ b/src/include/zvec/core/framework/index_metric.h
@@ -137,6 +137,9 @@ struct IndexMetric : public IndexModule {
   virtual DistanceBatchQueryPreprocessFunc get_query_preprocess_func() const {
     return nullptr;
   }
+
+ protected:
+  int quantize_type_{0};
 };
 
 }  // namespace core
diff --git a/src/include/zvec/turbo/turbo.h b/src/include/zvec/turbo/turbo.h
index 6ecbfdd1e..f07ace8c6 100644
--- a/src/include/zvec/turbo/turbo.h
+++ b/src/include/zvec/turbo/turbo.h
@@ -28,28 +28,51 @@ using QueryPreprocessFunc =
 enum class MetricType {
   kSquaredEuclidean,
   kCosine,
+  kInnerProduct,
   kMipsSquaredEuclidean,
   kUnknown,
 };
 
 enum class DataType {
+  kInt4,
   kInt8,
+  kFp16,
+  kFp32,
   kUnknown,
 };
 
 enum class QuantizeType {
   kDefault,
+  kRecordInt8,
+  kRecordInt4,
+  kInt8,
+  kInt4,
+  kFp16,
+  kPQ,
+  kRabit
+};
+
+enum class CpuArchType {
+  kAuto,
+  kScalar,
+  kSSE,
+  kAVX,
+  kAVX2,
+  kAVX512,
+  kAVX512VNNI,
+  kAVX512FP16
 };
 
 DistanceFunc get_distance_func(MetricType metric_type, DataType data_type,
-                               QuantizeType quantize_type);
+                               QuantizeType quantize_type,
+                               CpuArchType cpu_arch_type = CpuArchType::kAuto);
 
-BatchDistanceFunc get_batch_distance_func(MetricType metric_type,
-                                          DataType data_type,
-                                          QuantizeType quantize_type);
+BatchDistanceFunc get_batch_distance_func(
+    MetricType metric_type, DataType data_type, QuantizeType quantize_type,
+    CpuArchType cpu_arch_type = CpuArchType::kAuto);
 
-QueryPreprocessFunc get_query_preprocess_func(MetricType metric_type,
-                                              DataType data_type,
-                                              QuantizeType quantize_type);
+QueryPreprocessFunc get_query_preprocess_func(
+    MetricType metric_type, DataType data_type, QuantizeType quantize_type,
+    CpuArchType cpu_arch_type = CpuArchType::kAuto);
 
 }  // namespace zvec::turbo
diff --git a/src/turbo/CMakeLists.txt b/src/turbo/CMakeLists.txt
index 9cbb2fac7..5b916cc66 100644
--- a/src/turbo/CMakeLists.txt
+++ b/src/turbo/CMakeLists.txt
@@ -13,24 +13,112 @@ endif()
 
 file(GLOB_RECURSE ALL_SRCS *.cc *.c *.h)
 
-# Set per-file compile flags for AVX512-VNNI sources.
-# set_source_files_properties is directory-scoped, so it must be called in the
-# same directory that adds the sources to a target (i.e. here, not in a
-# subdirectory).
 if(NOT ANDROID AND AUTO_DETECT_ARCH)
     if (HOST_ARCH MATCHES "^(x86|x64)$")
-        file(GLOB_RECURSE AVX512_VNNI_SRCS ${CMAKE_CURRENT_SOURCE_DIR}/avx512_vnni/*.cc)
+        # Exclude ARM sources on x86 builds
+        file(GLOB_RECURSE ARM_SRCS
+          ${CMAKE_CURRENT_SOURCE_DIR}/*/armv8/*.cc
+          ${CMAKE_CURRENT_SOURCE_DIR}/*/armv8/*.c
+          ${CMAKE_CURRENT_SOURCE_DIR}/*/armv8/*.h)
+        list(LENGTH ARM_SRCS ARM_SRCS_LEN)
+        if(ARM_SRCS_LEN GREATER 0)
+            list(REMOVE_ITEM ALL_SRCS ${ARM_SRCS})
+        endif()
+
+        file(GLOB_RECURSE AVX512_AVX512FP16_SRCS 
+          ${CMAKE_CURRENT_SOURCE_DIR}/*/avx512_fp16/*.cc
+          ${CMAKE_CURRENT_SOURCE_DIR}/*/avx512_fp16/*.c)
+        set_source_files_properties(
+            ${AVX512_AVX512FP16_SRCS}
+            PROPERTIES
+            COMPILE_FLAGS "${TURBO_MARCH_FLAG_AVX512FP16}"
+        )
+
+        # Set per-file compile flags for AVX512-VNNI sources.
+        # set_source_files_properties is directory-scoped, so it must be called in the
+        # same directory that adds the sources to a target (i.e. here, not in a
+        # subdirectory).
+        file(GLOB_RECURSE AVX512_VNNI_SRCS 
+          ${CMAKE_CURRENT_SOURCE_DIR}/*/avx512_vnni/*.cc
+          ${CMAKE_CURRENT_SOURCE_DIR}/*/avx512_vnni/*.c)
         set_source_files_properties(
             ${AVX512_VNNI_SRCS}
             PROPERTIES
             COMPILE_FLAGS "${TURBO_MARCH_FLAG_AVX512}"
         )
+
+        file(GLOB_RECURSE AVX512_SRCS 
+          ${CMAKE_CURRENT_SOURCE_DIR}/*/avx512/*.cc
+          ${CMAKE_CURRENT_SOURCE_DIR}/*/avx512/*.c)
+        set_source_files_properties(
+            ${AVX512_SRCS}
+            PROPERTIES
+            COMPILE_FLAGS "${TURBO_MARCH_FLAG_AVX512}"
+        )
+    
+        file(GLOB_RECURSE AVX2_SRCS 
+          ${CMAKE_CURRENT_SOURCE_DIR}/*/avx2/*.cc 
+          ${CMAKE_CURRENT_SOURCE_DIR}/*/avx2/*.c
+          ${CMAKE_CURRENT_SOURCE_DIR}/*/avx/*.cc
+          ${CMAKE_CURRENT_SOURCE_DIR}/*/avx/*.c)
+        set_source_files_properties(
+            ${AVX2_SRCS}
+            PROPERTIES
+            COMPILE_FLAGS "${TURBO_MARCH_FLAG_AVX2}"
+        )
+
+        file(GLOB_RECURSE SSE_SRCS 
+          ${CMAKE_CURRENT_SOURCE_DIR}/*/sse/*.cc
+          ${CMAKE_CURRENT_SOURCE_DIR}/*/sse/*.c)
+        set_source_files_properties(
+            ${SSE_SRCS}
+            PROPERTIES
+            COMPILE_FLAGS "${TURBO_MARCH_FLAG_SSE}"
+        )
+    elseif (HOST_ARCH MATCHES "^(arm|arm64)$")
+        # Exclude x86 sources on ARM builds
+        file(GLOB_RECURSE X86_SRCS
+          ${CMAKE_CURRENT_SOURCE_DIR}/*/avx/*.cc
+          ${CMAKE_CURRENT_SOURCE_DIR}/*/avx/*.c
+          ${CMAKE_CURRENT_SOURCE_DIR}/*/avx/*.h
+          ${CMAKE_CURRENT_SOURCE_DIR}/*/avx2/*.cc
+          ${CMAKE_CURRENT_SOURCE_DIR}/*/avx2/*.c
+          ${CMAKE_CURRENT_SOURCE_DIR}/*/avx2/*.h
+          ${CMAKE_CURRENT_SOURCE_DIR}/*/avx512/*.cc
+          ${CMAKE_CURRENT_SOURCE_DIR}/*/avx512/*.c
+          ${CMAKE_CURRENT_SOURCE_DIR}/*/avx512/*.h
+          ${CMAKE_CURRENT_SOURCE_DIR}/*/avx512_fp16/*.cc
+          ${CMAKE_CURRENT_SOURCE_DIR}/*/avx512_fp16/*.c
+          ${CMAKE_CURRENT_SOURCE_DIR}/*/avx512_fp16/*.h
+          ${CMAKE_CURRENT_SOURCE_DIR}/*/avx512_vnni/*.cc
+          ${CMAKE_CURRENT_SOURCE_DIR}/*/avx512_vnni/*.c
+          ${CMAKE_CURRENT_SOURCE_DIR}/*/avx512_vnni/*.h
+          ${CMAKE_CURRENT_SOURCE_DIR}/sse/*.cc
+          ${CMAKE_CURRENT_SOURCE_DIR}/sse/*.c
+          ${CMAKE_CURRENT_SOURCE_DIR}/sse/*.h)
+        list(LENGTH X86_SRCS X86_SRCS_LEN)
+        if(X86_SRCS_LEN GREATER 0)
+            list(REMOVE_ITEM ALL_SRCS ${X86_SRCS})
+        endif()
+
+        set(TURBO_MARCH_FLAG_NEON "-march=armv8-a")
+
+        file(GLOB_RECURSE NEON_SRCS
+          ${CMAKE_CURRENT_SOURCE_DIR}/*/armv8/*.cc
+          ${CMAKE_CURRENT_SOURCE_DIR}/*/armv8/*.c
+        )
+
+        set_source_files_properties(
+            ${NEON_SRCS}
+            PROPERTIES
+            COMPILE_FLAGS "${TURBO_MARCH_FLAG_NEON}"
+        )
     endif()
 endif()
 
 cc_library(
-    NAME zvec_turbo STATIC STRICT PACKED
+    NAME zvec_turbo STATIC STRICT PACKED ALWAYS_LINK
     SRCS ${ALL_SRCS}
     LIBS zvec_ailego
-    INCS ${CMAKE_CURRENT_SOURCE_DIR} ${PROJECT_ROOT_DIR}/src/include
+    INCS ${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_CURRENT_SOURCE_DIR}/distance ${PROJECT_ROOT_DIR}/src/include ${PROJECT_ROOT_DIR}/src
 )
diff --git a/src/turbo/distance/armv8/float32/cosine.cc b/src/turbo/distance/armv8/float32/cosine.cc
new file mode 100644
index 000000000..4f23dabe1
--- /dev/null
+++ b/src/turbo/distance/armv8/float32/cosine.cc
@@ -0,0 +1,65 @@
+// Copyright 2025-present the zvec project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "armv8/float32/cosine.h"
+#include "armv8/float32/inner_product.h"
+#include "armv8/float32/inner_product_common.h"
+
+namespace zvec::turbo::armv8 {
+
+void cosine_fp32_distance(const void *a, const void *b, size_t dim,
+                          size_t extra_size, float *distance) {
+#if defined(__ARM_NEON)
+  constexpr size_t extra_dim = 2;
+  size_t original_dim = dim - extra_dim;
+
+  // inner_product_fp32_armv8 returns -real_IP; cosine = 1 - real_IP = 1 + ip.
+  float ip;
+  internal::inner_product_fp32_armv8(a, b, original_dim, &ip);
+
+  *distance = 1 + ip;
+#else
+  (void)a;
+  (void)b;
+  (void)dim;
+  (void)distance;
+#endif  // __ARM_NEON
+}
+
+void cosine_fp32_batch_distance(const void *const *vectors, const void *query,
+                                size_t n, size_t dim, float *distances) {
+#if defined(__ARM_NEON)
+  const int original_dim = dim - 1;
+  if (original_dim <= 0) {
+    return;
+  }
+
+  internal::inner_product_fp32_batch_armv8(vectors, query, n, original_dim,
+                                           distances);
+
+  // inner_product batch returns -real_IP per element; cosine = 1 - real_IP = 1
+  // + d.
+  for (int i = 0; i < n; ++i) {
+    distances[i] = 1 + distances[i];
+  }
+#else
+  (void)vectors;
+  (void)query;
+  (void)n;
+  (void)dim;
+  (void)distances;
+#endif  //__ARM_NEON
+}
+
+}  // namespace zvec::turbo::armv8
\ No newline at end of file
diff --git a/src/turbo/distance/armv8/float32/cosine.h b/src/turbo/distance/armv8/float32/cosine.h
new file mode 100644
index 000000000..529e11ef3
--- /dev/null
+++ b/src/turbo/distance/armv8/float32/cosine.h
@@ -0,0 +1,30 @@
+// Copyright 2025-present the zvec project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#pragma once
+
+#include <cstddef>
+
+namespace zvec::turbo::armv8 {
+
+// Compute cosine distance (negative inner product after normalization) between
+// a single quantized FP32 vector pair.
+void cosine_fp32_distance(const void *a, const void *b, size_t dim,
+                          float *distance);
+
+// Batch version of cosine_fp32_distance.
+void cosine_fp32_batch_distance(const void *const *vectors, const void *query,
+                                size_t n, size_t dim, float *distances);
+
+}  // namespace zvec::turbo::armv8
\ No newline at end of file
diff --git a/src/turbo/distance/armv8/float32/inner_product.cc b/src/turbo/distance/armv8/float32/inner_product.cc
new file mode 100644
index 000000000..7cfbd7784
--- /dev/null
+++ b/src/turbo/distance/armv8/float32/inner_product.cc
@@ -0,0 +1,52 @@
+// Copyright 2025-present the zvec project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include <cstddef>
+
+#if defined(__ARM_NEON)
+#include <arm_neon.h>
+#include <zvec/ailego/utility/float_helper.h>
+#include "armv8/float32/inner_product.h"
+#include "armv8/float32/inner_product_common.h"
+
+using namespace zvec::turbo::armv8::internal;
+#endif
+
+namespace zvec::turbo::armv8 {
+
+// Compute squared Euclidean distance between a single quantized FP32
+// vector pair.
+void inner_product_fp32_distance(const void *a, const void *b, size_t dim,
+                                 float *distance) {
+#if defined(__ARM_NEON)
+  inner_product_fp32_armv8(a, b, dim, distance);
+#endif
+}
+
+// Batch version of inner_product_fp16_distance.
+void inner_product_fp32_batch_distance(const void *const *vectors,
+                                       const void *query, size_t n, size_t dim,
+                                       float *distances) {
+#if defined(__ARM_NEON)
+  inner_product_fp32_batch_armv8(vectors, query, n, dim, distances);
+#else
+  (void)vectors;
+  (void)query;
+  (void)n;
+  (void)dim;
+  (void)distances;
+#endif  // __ARM_NEON
+}
+
+}  // namespace zvec::turbo::armv8
\ No newline at end of file
diff --git a/src/turbo/distance/armv8/float32/inner_product.h b/src/turbo/distance/armv8/float32/inner_product.h
new file mode 100644
index 000000000..a1d8b612f
--- /dev/null
+++ b/src/turbo/distance/armv8/float32/inner_product.h
@@ -0,0 +1,31 @@
+// Copyright 2025-present the zvec project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#pragma once
+
+#include <cstddef>
+
+namespace zvec::turbo::armv8 {
+
+// Compute inner product distance between a single quantized FP32
+// vector pair.
+void inner_product_fp32_distance(const void *a, const void *b, size_t dim,
+                                 float *distance);
+
+// Batch version of inner_product_fp32_distance.
+void inner_product_fp32_batch_distance(const void *const *vectors,
+                                       const void *query, size_t n, size_t dim,
+                                       float *distances);
+
+}  // namespace zvec::turbo::armv8
diff --git a/src/turbo/distance/armv8/float32/inner_product_common.h b/src/turbo/distance/armv8/float32/inner_product_common.h
new file mode 100644
index 000000000..26ad45d21
--- /dev/null
+++ b/src/turbo/distance/armv8/float32/inner_product_common.h
@@ -0,0 +1,142 @@
+// Copyright 2025-present the zvec project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#pragma once
+
+#if defined(__ARM_NEON)
+#include <array>
+#include <cstdint>
+#include <arm_neon.h>
+#include <zvec/ailego/utility/float_helper.h>
+
+using namespace zvec::ailego;
+
+//! Calculate Fused-Multiply-Add (GENERAL)
+#define FMA_FP32_GENERAL(m, q, sum) sum += (m * q);
+
+namespace zvec::turbo::armv8::internal {
+
+static __attribute__((always_inline)) void inner_product_fp32_armv8(
+    const void *a, const void *b, size_t size, float *distance) {
+  const float *lhs = reinterpret_cast<const float *>(a);
+  const float *rhs = reinterpret_cast<const float *>(b);
+
+  const float *last = lhs + size;
+  const float *last_aligned = lhs + ((size >> 3) << 3);
+
+  float32x4_t v_sum_0 = vdupq_n_f32(0);
+  float32x4_t v_sum_1 = vdupq_n_f32(0);
+
+  for (; lhs != last_aligned; lhs += 8, rhs += 8) {
+    v_sum_0 = vfmaq_f32(v_sum_0, vld1q_f32(lhs + 0), vld1q_f32(rhs + 0));
+    v_sum_1 = vfmaq_f32(v_sum_1, vld1q_f32(lhs + 4), vld1q_f32(rhs + 4));
+  }
+  if (last >= last_aligned + 4) {
+    v_sum_0 = vfmaq_f32(v_sum_0, vld1q_f32(lhs), vld1q_f32(rhs));
+    lhs += 4;
+    rhs += 4;
+  }
+
+  float result = vaddvq_f32(vaddq_f32(v_sum_0, v_sum_1));
+  switch (last - lhs) {
+    case 3:
+      FMA_FP32_GENERAL(lhs[2], rhs[2], result)
+      /* FALLTHRU */
+    case 2:
+      FMA_FP32_GENERAL(lhs[1], rhs[1], result)
+      /* FALLTHRU */
+    case 1:
+      FMA_FP32_GENERAL(lhs[0], rhs[0], result)
+  }
+  *distance = -result;
+}
+
+template <size_t batch_size>
+static __attribute__((always_inline)) void inner_product_fp32_batch_armv8_impl(
+    const void *query, const void *const *vectors,
+    const std::array<const void *, batch_size> &prefetch_ptrs,
+    size_t dimensionality, float *distances) {
+  float32x4_t v_sum[batch_size] for (size_t i = 0; i < batch_size; ++i) {
+    v_sum[i] = vdupq_n_f32(0);
+  }
+
+  size_t dim = 0;
+  for (; dim + 64 <= dimensionality; dim += 4) {
+    for (size_t i = 0; i < batch_size; ++i) {
+      v_sum[i] = vfmaq_f32(
+          v_sum[i], vld1q_f32(reinterpret_cast<const float *>(query) + dim),
+          vld1q_f32(reinterpret_cast<const float *>(vectors[i]) + dim));
+    }
+  }
+
+  if (dim >= dimensionality + 4) {
+    for (size_t i = 0; i < batch_size; ++i) {
+      v_sum[i] = vfmaq_f32(v_sum[i], vld1q_f32(reinterpret_cast<const float *>(query)+dim), vld1q_f32(reinterpret_cast<const float *>(vectors[i])+dim)));
+    }
+
+    dim += 4;
+  }
+
+  for (size_t i = 0; i < batch_size; ++i) {
+    float result = vaddvq_f32(v_sum[i]);
+    switch (last - lhs) {
+      case 3:
+        FMA_FP32_GENERAL(reinterpret_cast<const float *>(query)[dim + 2],
+                         reinterpret_cast<const float *>(vectors[i])[dim + 2],
+                         result)
+        /* FALLTHRU */
+      case 2:
+        FMA_FP32_GENERAL(reinterpret_cast<const float *>(query)[dim + 1],
+                         reinterpret_cast<const float *>(vectors[i])[dim + 1],
+                         result)
+        /* FALLTHRU */
+      case 1:
+        FMA_FP32_GENERAL(reinterpret_cast<const float *>(query)[dim + 0],
+                         reinterpret_cast<const float *>(vectors[i])[dim + 0],
+                         result)
+    }
+
+    distances[i] = -result;
+  }
+}
+
+// Dispatch batched inner product over all `n` vectors with prefetching.
+static __attribute__((always_inline)) void inner_product_fp32_batch_armv8(
+    const void *const *vectors, const void *query, size_t n, size_t dim,
+    float *distances) {
+  static constexpr size_t batch_size = 2;
+  static constexpr size_t prefetch_step = 2;
+  size_t i = 0;
+  for (; i + batch_size <= n; i += batch_size) {
+    std::array<const void *, batch_size> prefetch_ptrs;
+    for (size_t j = 0; j < batch_size; ++j) {
+      if (i + j + batch_size * prefetch_step < n) {
+        prefetch_ptrs[j] = vectors[i + j + batch_size * prefetch_step];
+      } else {
+        prefetch_ptrs[j] = nullptr;
+      }
+    }
+    inner_product_fp32_batch_armv8_impl<batch_size>(
+        query, &vectors[i], prefetch_ptrs, dim, distances + i);
+  }
+  for (; i < n; i++) {
+    std::array<const void *, 1> prefetch_ptrs{nullptr};
+    inner_product_fp32_batch_armv8_impl<1>(query, &vectors[i], prefetch_ptrs,
+                                           dim, distances + i);
+  }
+}
+
+}  // namespace zvec::turbo::armv8::internal
+
+#endif  // defined(__ARM_NEON)
diff --git a/src/turbo/distance/armv8/float32/squared_euclidean.cc b/src/turbo/distance/armv8/float32/squared_euclidean.cc
new file mode 100644
index 000000000..b39fdac2e
--- /dev/null
+++ b/src/turbo/distance/armv8/float32/squared_euclidean.cc
@@ -0,0 +1,54 @@
+// Copyright 2025-present the zvec project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include <cstddef>
+
+#if defined(__ARM_NEON)
+#include <arm_neon.h>
+#include <zvec/ailego/utility/float_helper.h>
+#include "armv8/float32/squared_euclidean.h"
+#include "armv8/float32/squared_euclidean_common.h"
+
+using namespace zvec::turbo::armv8::internal;
+#endif
+
+namespace zvec::turbo::armv8 {
+
+void squared_euclidean_fp32_distance(const void *a, const void *b, size_t dim,
+                                     float *distance) {
+#if defined(__ARM_NEON)
+  squared_euclidean_fp32_armv8(a, b, dim, distance);
+#else
+  (void)a;
+  (void)b;
+  (void)dim;
+  (void)distance;
+#endif  // __ARM_NEON
+}
+
+void squared_euclidean_fp32_batch_distance(const void *const *vectors,
+                                           const void *query, size_t n,
+                                           size_t dim, float *distances) {
+#if defined(__ARM_NEON)
+  squared_euclidean_fp32_batch_armv8(vectors, query, n, dim, distances);
+#else
+  (void)vectors;
+  (void)query;
+  (void)n;
+  (void)dim;
+  (void)distances;
+#endif  //
+}
+
+}  // namespace zvec::turbo::armv8
\ No newline at end of file
diff --git a/src/turbo/distance/armv8/float32/squared_euclidean.h b/src/turbo/distance/armv8/float32/squared_euclidean.h
new file mode 100644
index 000000000..3df75f17a
--- /dev/null
+++ b/src/turbo/distance/armv8/float32/squared_euclidean.h
@@ -0,0 +1,31 @@
+// Copyright 2025-present the zvec project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#pragma once
+
+#include <cstddef>
+
+namespace zvec::turbo::armv8 {
+
+// Compute squared euclidean distance between a single quantized FP32
+// vector pair.
+void squared_euclidean_fp32_distance(const void *a, const void *b, size_t dim,
+                                     float *distance);
+
+// Batch version of squared euclidean FP32.
+void squared_euclidean_fp32_batch_distance(const void *const *vectors,
+                                           const void *query, size_t n,
+                                           size_t dim, float *distances);
+
+}  // namespace zvec::turbo::armv8
diff --git a/src/turbo/distance/armv8/float32/squared_euclidean_common.h b/src/turbo/distance/armv8/float32/squared_euclidean_common.h
new file mode 100644
index 000000000..4f3419c56
--- /dev/null
+++ b/src/turbo/distance/armv8/float32/squared_euclidean_common.h
@@ -0,0 +1,150 @@
+// Copyright 2025-present the zvec project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#pragma once
+
+#if defined(__ARM_NEON)
+#include <array>
+#include <cstdint>
+#include <arm_neon.h>
+#include <zvec/ailego/utility/float_helper.h>
+
+using namespace zvec::ailego;
+
+//! Calculate Sum-of-Squared-Differences (GENERAL)
+#define SSD_FP32_GENERAL(m, q, sum) \
+  {                                 \
+    float x = m - q;                \
+    sum += (x * x);                 \
+  }
+
+namespace zvec::turbo::armv8::internal {
+
+static __attribute__((always_inline)) void squared_euclidean_fp32_armv8(
+    const void *a, const void *b, size_t size, float *distance) {
+  const float *lhs = reinterpret_cast<const float *>(a);
+  const float *rhs = reinterpret_cast<const float *>(b);
+
+  const float *last = lhs + size;
+  const float *last_aligned = lhs + ((size >> 3) << 3);
+
+  float32x4_t v_sum_0 = vdupq_n_f32(0);
+  float32x4_t v_sum_1 = vdupq_n_f32(0);
+
+  for (; lhs != last_aligned; lhs += 8, rhs += 8) {
+    float32x4_t v_d_0 = vsubq_f32(vld1q_f32(lhs + 0), vld1q_f32(rhs + 0));
+    float32x4_t v_d_1 = vsubq_f32(vld1q_f32(lhs + 4), vld1q_f32(rhs + 4));
+    v_sum_0 = vfmaq_f32(v_sum_0, v_d_0, v_d_0);
+    v_sum_1 = vfmaq_f32(v_sum_1, v_d_1, v_d_1);
+  }
+  if (last >= last_aligned + 4) {
+    float32x4_t v_d = vsubq_f32(vld1q_f32(lhs), vld1q_f32(rhs));
+    v_sum_0 = vfmaq_f32(v_sum_0, v_d, v_d);
+    lhs += 4;
+    rhs += 4;
+  }
+
+  float result = vaddvq_f32(vaddq_f32(v_sum_0, v_sum_1));
+  switch (last - lhs) {
+    case 3:
+      SSD_FP32_GENERAL(lhs[2], rhs[2], result)
+      /* FALLTHRU */
+    case 2:
+      SSD_FP32_GENERAL(lhs[1], rhs[1], result)
+      /* FALLTHRU */
+    case 1:
+      SSD_FP32_GENERAL(lhs[0], rhs[0], result)
+  }
+  *distance = result;
+}
+
+template <size_t batch_size>
+static __attribute__((always_inline)) void
+squared_euclidean_fp32_batch_armv8_impl(
+    const void *query, const void *const *vectors,
+    const std::array<const void *, batch_size> &prefetch_ptrs,
+    size_t dimensionality, float *distances) {
+  float32x4_t v_sum[batch_size] for (size_t i = 0; i < batch_size; ++i) {
+    v_sum[i] = vdupq_n_f32(0);
+  }
+
+  size_t dim = 0;
+  for (; dim + 64 <= dimensionality; dim += 4) {
+    for (size_t i = 0; i < batch_size; ++i) {
+      v_sum[i] = vfmaq_f32(
+          v_sum[i], vld1q_f32(reinterpret_cast<const float *>(query) + dim),
+          vld1q_f32(reinterpret_cast<const float *>(vectors[i]) + dim));
+    }
+  }
+
+  if (dim >= dimensionality + 4) {
+    for (size_t i = 0; i < batch_size; ++i) {
+      v_sum[i] = vfmaq_f32(v_sum[i], vld1q_f32(reinterpret_cast<const float *>(query)+dim), vld1q_f32(reinterpret_cast<const float *>(vectors[i])+dim)));
+    }
+
+    dim += 4;
+  }
+
+  for (size_t i = 0; i < batch_size; ++i) {
+    float result = vaddvq_f32(v_sum[i]);
+    switch (last - lhs) {
+      case 3:
+        FMA_FP32_GENERAL(reinterpret_cast<const float *>(query)[dim + 2],
+                         reinterpret_cast<const float *>(vectors[i])[dim + 2],
+                         result)
+        /* FALLTHRU */
+      case 2:
+        FMA_FP32_GENERAL(reinterpret_cast<const float *>(query)[dim + 1],
+                         reinterpret_cast<const float *>(vectors[i])[dim + 1],
+                         result)
+        /* FALLTHRU */
+      case 1:
+        FMA_FP32_GENERAL(reinterpret_cast<const float *>(query)[dim + 0],
+                         reinterpret_cast<const float *>(vectors[i])[dim + 0],
+                         result)
+    }
+
+    distances[i] = -result;
+  }
+}
+
+// Dispatch batched inner product over all `n` vectors with prefetching.
+static __attribute__((always_inline)) void squared_euclidean_fp32_batch_armv8(
+    const void *const *vectors, const void *query, size_t n, size_t dim,
+    float *distances) {
+  static constexpr size_t batch_size = 2;
+  static constexpr size_t prefetch_step = 2;
+  size_t i = 0;
+  for (; i + batch_size <= n; i += batch_size) {
+    std::array<const void *, batch_size> prefetch_ptrs;
+    for (size_t j = 0; j < batch_size; ++j) {
+      if (i + j + batch_size * prefetch_step < n) {
+        prefetch_ptrs[j] = vectors[i + j + batch_size * prefetch_step];
+      } else {
+        prefetch_ptrs[j] = nullptr;
+      }
+    }
+    squared_euclidean_fp32_batch_armv8_impl<batch_size>(
+        query, &vectors[i], prefetch_ptrs, dim, distances + i);
+  }
+  for (; i < n; i++) {
+    std::array<const void *, 1> prefetch_ptrs{nullptr};
+    squared_euclidean_fp32_batch_armv8_impl<1>(
+        query, &vectors[i], prefetch_ptrs, dim, distances + i);
+  }
+}
+
+}  // namespace zvec::turbo::armv8::internal
+
+#endif  // defined(__ARM_NEON)
diff --git a/src/turbo/distance/armv8/half_float/cosine.cc b/src/turbo/distance/armv8/half_float/cosine.cc
new file mode 100644
index 000000000..baf39c702
--- /dev/null
+++ b/src/turbo/distance/armv8/half_float/cosine.cc
@@ -0,0 +1,62 @@
+// Copyright 2025-present the zvec project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "armv8/half_float/cosine.h"
+#include "armv8/half_float/inner_product.h"
+#include "armv8/half_float/inner_product_common.h"
+
+namespace zvec::turbo::armv8 {
+
+void cosine_fp16_distance(const void *a, const void *b, size_t dim,
+                          float *distance) {
+#if defined(__ARM_NEON)
+  constexpr size_t extra_dim = 2;
+  size_t original_dim = dim - extra_dim;
+
+  float ip;
+  inner_product_fp16_distance(a, b, original_dim, &ip);
+
+  *distance = 1 - ip;
+#else
+  (void)a;
+  (void)b;
+  (void)dim;
+  (void)distance;
+#endif  // __ARM_NEON
+}
+
+void cosine_fp16_batch_distance(const void *const *vectors, const void *query,
+                                size_t n, size_t dim, float *distances) {
+#if defined(__ARM_NEON)
+  constexpr size_t extra_dim = 2;
+  const int original_dim = dim - extra_dim;
+  if (original_dim <= 0) {
+    return;
+  }
+
+  inner_product_fp16_batch_armv8(vectors, query, n, original_dim, distances);
+
+  for (size_t i = 0; i < n; ++i) {
+    distances[i] = 1 - distances[i];
+  }
+#else
+  (void)vectors;
+  (void)query;
+  (void)n;
+  (void)dim;
+  (void)distances;
+#endif  //__ARM_NEON
+}
+
+}  // namespace zvec::turbo::armv8
\ No newline at end of file
diff --git a/src/turbo/distance/armv8/half_float/cosine.h b/src/turbo/distance/armv8/half_float/cosine.h
new file mode 100644
index 000000000..7d79f7bd7
--- /dev/null
+++ b/src/turbo/distance/armv8/half_float/cosine.h
@@ -0,0 +1,30 @@
+// Copyright 2025-present the zvec project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#pragma once
+
+#include <cstddef>
+
+namespace zvec::turbo::armv8 {
+
+// Compute cosine distance (negative inner product after normalization) between
+// a single quantized FP32 vector pair.
+void cosine_fp16_distance(const void *a, const void *b, size_t dim,
+                          float *distance);
+
+// Batch version of cosine_fp32_distance.
+void cosine_fp16_batch_distance(const void *const *vectors, const void *query,
+                                size_t n, size_t dim, float *distances);
+
+}  // namespace zvec::turbo::armv8
\ No newline at end of file
diff --git a/src/turbo/distance/armv8/half_float/inner_product.cc b/src/turbo/distance/armv8/half_float/inner_product.cc
new file mode 100644
index 000000000..7e0dcc448
--- /dev/null
+++ b/src/turbo/distance/armv8/half_float/inner_product.cc
@@ -0,0 +1,58 @@
+// Copyright 2025-present the zvec project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include <cstddef>
+
+#if defined(__ARM_NEON)
+#include <arm_neon.h>
+#include <zvec/ailego/utility/float_helper.h>
+#include "armv8/half_float/inner_product.h"
+#include "armv8/half_float/inner_product_common.h"
+
+using namespace zvec::turbo::armv8::internal;
+#endif
+
+namespace zvec::turbo::armv8 {
+
+// Compute squared Euclidean distance between a single quantized FP16
+// vector pair.
+void inner_product_fp16_distance(const void *a, const void *b, size_t dim,
+                                 float *distance) {
+#if defined(__ARM_NEON)
+  const zvec::ailego::Float16 *lhs =
+      reinterpret_cast<const zvec::ailego::Float16 *>(a);
+  const zvec::ailego::Float16 *rhs =
+      reinterpret_cast<const zvec::ailego::Float16 *>(b);
+
+  ACCUM_FP16_1X1_NEON(lhs, rhs, dim, distance, 0ull, )
+
+#endif
+}
+
+// Batch version of inner_product_fp16_distance.
+void inner_product_fp16_batch_distance(const void *const *vectors,
+                                       const void *query, size_t n, size_t dim,
+                                       float *distances) {
+#if defined(__ARM_NEON)
+  inner_product_fp16_batch_armv8(vectors, query, n, dim, distances);
+#else
+  (void)vectors;
+  (void)query;
+  (void)n;
+  (void)dim;
+  (void)distances;
+#endif  //__ARM_NEON
+}
+
+}  // namespace zvec::turbo::armv8
diff --git a/src/turbo/distance/armv8/half_float/inner_product.h b/src/turbo/distance/armv8/half_float/inner_product.h
new file mode 100644
index 000000000..cfd824459
--- /dev/null
+++ b/src/turbo/distance/armv8/half_float/inner_product.h
@@ -0,0 +1,31 @@
+// Copyright 2025-present the zvec project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#pragma once
+
+#include <cstddef>
+
+namespace zvec::turbo::armv8 {
+
+// Compute inner product distance between a single quantized FP16
+// vector pair.
+void inner_product_fp16_distance(const void *a, const void *b, size_t dim,
+                                 float *distance);
+
+// Batch version of inner_product_fp16_distance.
+void inner_product_fp16_batch_distance(const void *const *vectors,
+                                       const void *query, size_t n, size_t dim,
+                                       float *distances);
+
+}  // namespace zvec::turbo::armv8
diff --git a/src/turbo/distance/armv8/half_float/inner_product_common.h b/src/turbo/distance/armv8/half_float/inner_product_common.h
new file mode 100644
index 000000000..54c3072ff
--- /dev/null
+++ b/src/turbo/distance/armv8/half_float/inner_product_common.h
@@ -0,0 +1,210 @@
+// Copyright 2025-present the zvec project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#pragma once
+
+#if defined(__ARM_NEON)
+#include <array>
+#include <cstdint>
+#include <arm_neon.h>
+#include <zvec/ailego/utility/float_helper.h>
+
+using namespace zvec::ailego;
+
+namespace zvec::turbo::armv8::internal {
+
+#define MATRIX_VAR_INIT_1X1(_VAR_TYPE, _VAR_NAME, _VAR_INIT) \
+  _VAR_TYPE _VAR_NAME##_0_0 = (_VAR_INIT);
+
+#define MATRIX_VAR_INIT(_M, _N, _VAR_TYPE, _VAR_NAME, _VAR_INIT) \
+  MATRIX_VAR_INIT_##_M##X##_N(_VAR_TYPE, _VAR_NAME, _VAR_INIT)
+
+//! Scalar fused multiply-add for inner product (FP16 general)
+#define ACCUM_FP16_STEP_GENERAL(m, q, sum) sum += (m * q);
+
+#if defined(__ARM_FEATURE_FP16_VECTOR_ARITHMETIC)
+
+//! NEON fused multiply-add for inner product (FP16)
+#define ACCUM_FP16_STEP_NEON(v_m, v_q, v_sum) \
+  v_sum = vfmaq_f16(v_sum, v_m, v_q);
+
+//! Iterative process of computing distance (FP16, M=1, N=1)
+#define MATRIX_FP16_ITER_1X1_NEON(m, q, _RES, _PROC)   \
+  {                                                    \
+    float16x8_t v_m = vld1q_f16((const float16_t *)m); \
+    float16x8_t v_q = vld1q_f16((const float16_t *)q); \
+    _PROC(v_m, v_q, _RES##_0_0)                        \
+  }
+
+//! Compute the distance between matrix and query (FP16, M=1, N=1)
+#define ACCUM_FP16_1X1_NEON(m, q, dim, out, _MASK, _NORM)                    \
+  MATRIX_VAR_INIT(1, 1, float16x8_t, v_sum, vdupq_n_f16(0))                  \
+  const Float16 *qe = q + dim;                                               \
+  const Float16 *qe_aligned = q + ((dim >> 3) << 3);                         \
+  for (; q != qe_aligned; m += 8, q += 8) {                                  \
+    MATRIX_FP16_ITER_1X1_NEON(m, q, v_sum, ACCUM_FP16_STEP_NEON)             \
+  }                                                                          \
+  if (qe >= qe_aligned + 4) {                                                \
+    float16x8_t v_m =                                                        \
+        vcombine_f16(vld1_f16((const float16_t *)m),                         \
+                     vreinterpret_f16_u64(vdup_n_u64((uint64_t)(_MASK))));   \
+    float16x8_t v_q =                                                        \
+        vcombine_f16(vld1_f16((const float16_t *)q),                         \
+                     vreinterpret_f16_u64(vdup_n_u64((uint64_t)(_MASK))));   \
+    ACCUM_FP16_STEP_NEON(v_m, v_q, v_sum_0_0)                                \
+    m += 4;                                                                  \
+    q += 4;                                                                  \
+  }                                                                          \
+  float result = vaddvq_f32(vaddq_f32(vcvt_f32_f16(vget_low_f16(v_sum_0_0)), \
+                                      vcvt_high_f32_f16(v_sum_0_0)));        \
+  switch (qe - q) {                                                          \
+    case 3:                                                                  \
+      ACCUM_FP16_STEP_GENERAL(m[2], q[2], result)                            \
+      /* FALLTHRU */                                                         \
+    case 2:                                                                  \
+      ACCUM_FP16_STEP_GENERAL(m[1], q[1], result)                            \
+      /* FALLTHRU */                                                         \
+    case 1:                                                                  \
+      ACCUM_FP16_STEP_GENERAL(m[0], q[0], result)                            \
+  }                                                                          \
+  *out = _NORM(result);
+
+#else
+
+//! NEON fused multiply-add for inner product (FP32)
+#define ACCUM_FP32_STEP_NEON(v_m, v_q, v_sum) \
+  v_sum = vfmaq_f32(v_sum, v_m, v_q);
+
+//! Iterative process of computing distance (FP16, M=1, N=1)
+#define MATRIX_FP16_ITER_1X1_NEON(m, q, _RES, _PROC)     \
+  {                                                      \
+    float16x8_t v_m = vld1q_f16((const float16_t *)m);   \
+    float16x8_t v_q = vld1q_f16((const float16_t *)q);   \
+    float32x4_t v_m_0 = vcvt_f32_f16(vget_low_f16(v_m)); \
+    float32x4_t v_q_0 = vcvt_f32_f16(vget_low_f16(v_q)); \
+    _PROC(v_m_0, v_q_0, _RES##_0_0)                      \
+    v_m_0 = vcvt_high_f32_f16(v_m);                      \
+    v_q_0 = vcvt_high_f32_f16(v_q);                      \
+    _PROC(v_m_0, v_q_0, _RES##_0_0)                      \
+  }
+
+//! Compute the distance between matrix and query (FP16, M=1, N=1)
+#define ACCUM_FP16_1X1_NEON(m, q, dim, out, _MASK, _NORM)           \
+  MATRIX_VAR_INIT(1, 1, float32x4_t, v_sum, vdupq_n_f32(0))         \
+  const Float16 *qe = q + dim;                                      \
+  const Float16 *qe_aligned = q + ((dim >> 3) << 3);                \
+  for (; q != qe_aligned; m += 8, q += 8) {                         \
+    MATRIX_FP16_ITER_1X1_NEON(m, q, v_sum, ACCUM_FP32_STEP_NEON)    \
+  }                                                                 \
+  if (qe >= qe_aligned + 4) {                                       \
+    float32x4_t v_m = vcvt_f32_f16(vld1_f16((const float16_t *)m)); \
+    float32x4_t v_q = vcvt_f32_f16(vld1_f16((const float16_t *)q)); \
+    ACCUM_FP32_STEP_NEON(v_m, v_q, v_sum_0_0)                       \
+    m += 4;                                                         \
+    q += 4;                                                         \
+  }                                                                 \
+  float result = vaddvq_f32(v_sum_0_0);                             \
+  switch (qe - q) {                                                 \
+    case 3:                                                         \
+      ACCUM_FP16_STEP_GENERAL(m[2], q[2], result)                   \
+      /* FALLTHRU */                                                \
+    case 2:                                                         \
+      ACCUM_FP16_STEP_GENERAL(m[1], q[1], result)                   \
+      /* FALLTHRU */                                                \
+    case 1:                                                         \
+      ACCUM_FP16_STEP_GENERAL(m[0], q[0], result)                   \
+  }                                                                 \
+  *out = _NORM(result);
+
+#endif  // __ARM_FEATURE_FP16_VECTOR_ARITHMETIC
+
+
+template <size_t batch_size>
+static __attribute__((always_inline)) void inner_product_fp16_batch_armv8_impl(
+    const void *query, const void *const *vectors,
+    const std::array<const void *, batch_size> &prefetch_ptrs,
+    size_t dimensionality, float *distances) {
+  float32x4_t v_sum[batch_size] for (size_t i = 0; i < batch_size; ++i) {
+    v_sum[i] = vdupq_n_f32(0);
+  }
+
+  size_t dim = 0;
+  for (; dim + 64 <= dimensionality; dim += 4) {
+    for (size_t i = 0; i < batch_size; ++i) {
+      v_sum[i] = vfmaq_f32(
+          v_sum[i], vld1q_f32(reinterpret_cast<const float *>(query) + dim),
+          vld1q_f32(reinterpret_cast<const float *>(vectors[i]) + dim));
+    }
+  }
+
+  if (dim >= dimensionality + 4) {
+    for (size_t i = 0; i < batch_size; ++i) {
+      v_sum[i] = vfmaq_f32(v_sum[i], vld1q_f32(reinterpret_cast<const float *>(query)+dim), vld1q_f32(reinterpret_cast<const float *>(vectors[i])+dim)));
+    }
+
+    dim += 4;
+  }
+
+  for (size_t i = 0; i < batch_size; ++i) {
+    float result = vaddvq_f32(v_sum[i]);
+    switch (last - lhs) {
+      case 3:
+        FMA_FP32_GENERAL(reinterpret_cast<const float *>(query)[dim + 2],
+                         reinterpret_cast<const float *>(vectors[i])[dim + 2],
+                         result)
+        /* FALLTHRU */
+      case 2:
+        FMA_FP32_GENERAL(reinterpret_cast<const float *>(query)[dim + 1],
+                         reinterpret_cast<const float *>(vectors[i])[dim + 1],
+                         result)
+        /* FALLTHRU */
+      case 1:
+        FMA_FP32_GENERAL(reinterpret_cast<const float *>(query)[dim + 0],
+                         reinterpret_cast<const float *>(vectors[i])[dim + 0],
+                         result)
+    }
+
+    distances[i] = -result;
+  }
+}
+
+// Dispatch batched inner product over all `n` vectors with prefetching.
+static __attribute__((always_inline)) void inner_product_fp16_batch_armv8(
+    const void *const *vectors, const void *query, size_t n, size_t dim,
+    float *distances) {
+  static constexpr size_t batch_size = 2;
+  static constexpr size_t prefetch_step = 2;
+  size_t i = 0;
+  for (; i + batch_size <= n; i += batch_size) {
+    std::array<const void *, batch_size> prefetch_ptrs;
+    for (size_t j = 0; j < batch_size; ++j) {
+      if (i + j + batch_size * prefetch_step < n) {
+        prefetch_ptrs[j] = vectors[i + j + batch_size * prefetch_step];
+      } else {
+        prefetch_ptrs[j] = nullptr;
+      }
+    }
+    inner_product_fp16_batch_armv8_impl<batch_size>(
+        query, &vectors[i], prefetch_ptrs, dim, distances + i);
+  }
+  for (; i < n; i++) {
+    std::array<const void *, 1> prefetch_ptrs{nullptr};
+    inner_product_fp16_batch_armv8_impl<1>(query, &vectors[i], prefetch_ptrs,
+                                           dim, distances + i);
+  }
+}
+
+}  // namespace zvec::turbo::armv8::internal
+
+#endif  // defined(__ARM_NEON)
diff --git a/src/turbo/distance/armv8/half_float/squared_euclidean.cc b/src/turbo/distance/armv8/half_float/squared_euclidean.cc
new file mode 100644
index 000000000..5f6ac829b
--- /dev/null
+++ b/src/turbo/distance/armv8/half_float/squared_euclidean.cc
@@ -0,0 +1,59 @@
+// Copyright 2025-present the zvec project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include <cstddef>
+
+#if defined(__ARM_NEON)
+#include <arm_neon.h>
+#include <zvec/ailego/utility/float_helper.h>
+#include "armv8/half_float/squared_euclidean.h"
+#include "armv8/half_float/squared_euclidean_common.h"
+
+using namespace zvec::turbo::armv8::internal;
+#endif
+
+namespace zvec::turbo::armv8 {
+
+void squared_euclidean_fp16_distance(const void *a, const void *b, size_t dim,
+                                     float *distance) {
+#if defined(__ARM_NEON)
+  const zvec::ailego::Float16 *lhs =
+      reinterpret_cast<const zvec::ailego::Float16 *>(a);
+  const zvec::ailego::Float16 *rhs =
+      reinterpret_cast<const zvec::ailego::Float16 *>(b);
+
+  ACCUM_FP16_1X1_NEON(lhs, rhs, dim, distance, 0ull, )
+#else
+  (void)a;
+  (void)b;
+  (void)dim;
+  (void)distance;
+#endif  // __ARM_NEON
+}
+
+void squared_euclidean_fp16_batch_distance(const void *const *vectors,
+                                           const void *query, size_t n,
+                                           size_t dim, float *distances) {
+#if defined(__ARM_NEON)
+  squared_euclidean_fp16_batch_armv8(vectors, query, n, dim, distances);
+#else
+  (void)vectors;
+  (void)query;
+  (void)n;
+  (void)dim;
+  (void)distances;
+#endif  //__ARM_NEON
+}
+
+}  // namespace zvec::turbo::armv8
\ No newline at end of file
diff --git a/src/turbo/distance/armv8/half_float/squared_euclidean.h b/src/turbo/distance/armv8/half_float/squared_euclidean.h
new file mode 100644
index 000000000..5a540b590
--- /dev/null
+++ b/src/turbo/distance/armv8/half_float/squared_euclidean.h
@@ -0,0 +1,31 @@
+// Copyright 2025-present the zvec project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#pragma once
+
+#include <cstddef>
+
+namespace zvec::turbo::armv8 {
+
+// Compute squared euclidean distance between a single quantized FP16
+// vector pair.
+void squared_euclidean_fp16_distance(const void *a, const void *b, size_t dim,
+                                     float *distance);
+
+// Batch version of squared euclidean FP16.
+void squared_euclidean_fp16_batch_distance(const void *const *vectors,
+                                           const void *query, size_t n,
+                                           size_t dim, float *distances);
+
+}  // namespace zvec::turbo::armv8
diff --git a/src/turbo/distance/armv8/half_float/squared_euclidean_common.h b/src/turbo/distance/armv8/half_float/squared_euclidean_common.h
new file mode 100644
index 000000000..df3807e61
--- /dev/null
+++ b/src/turbo/distance/armv8/half_float/squared_euclidean_common.h
@@ -0,0 +1,219 @@
+// Copyright 2025-present the zvec project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#pragma once
+
+#if defined(__ARM_NEON)
+#include <array>
+#include <cstdint>
+#include <arm_neon.h>
+#include <zvec/ailego/utility/float_helper.h>
+
+using namespace zvec::ailego;
+
+namespace zvec::turbo::armv8::internal {
+
+#define MATRIX_VAR_INIT_1X1(_VAR_TYPE, _VAR_NAME, _VAR_INIT) \
+  _VAR_TYPE _VAR_NAME##_0_0 = (_VAR_INIT);
+
+#define MATRIX_VAR_INIT(_M, _N, _VAR_TYPE, _VAR_NAME, _VAR_INIT) \
+  MATRIX_VAR_INIT_##_M##X##_N(_VAR_TYPE, _VAR_NAME, _VAR_INIT)
+
+//! Scalar sum of squared difference (FP16 general)
+#define ACCUM_FP16_STEP_GENERAL(m, q, sum) \
+  {                                        \
+    float x = m - q;                       \
+    sum += (x * x);                        \
+  }
+
+#if defined(__ARM_FEATURE_FP16_VECTOR_ARITHMETIC)
+
+//! NEON sum of squared difference (FP16)
+#define ACCUM_FP16_STEP_NEON(v_m, v_q, v_sum) \
+  {                                           \
+    float16x8_t v_d = vsubq_f16(v_m, v_q);    \
+    v_sum = vfmaq_f16(v_sum, v_d, v_d);       \
+  }
+
+//! Iterative process of computing distance (FP16, M=1, N=1)
+#define MATRIX_FP16_ITER_1X1_NEON(m, q, _RES, _PROC)   \
+  {                                                    \
+    float16x8_t v_m = vld1q_f16((const float16_t *)m); \
+    float16x8_t v_q = vld1q_f16((const float16_t *)q); \
+    _PROC(v_m, v_q, _RES##_0_0)                        \
+  }
+//! Compute the distance between matrix and query (FP16, M=1, N=1)
+#define ACCUM_FP16_1X1_NEON(m, q, dim, out, _MASK, _NORM)                    \
+  MATRIX_VAR_INIT(1, 1, float16x8_t, v_sum, vdupq_n_f16(0))                  \
+  const Float16 *qe = q + dim;                                               \
+  const Float16 *qe_aligned = q + ((dim >> 3) << 3);                         \
+  for (; q != qe_aligned; m += 8, q += 8) {                                  \
+    MATRIX_FP16_ITER_1X1_NEON(m, q, v_sum, ACCUM_FP16_STEP_NEON)             \
+  }                                                                          \
+  if (qe >= qe_aligned + 4) {                                                \
+    float16x8_t v_m =                                                        \
+        vcombine_f16(vld1_f16((const float16_t *)m),                         \
+                     vreinterpret_f16_u64(vdup_n_u64((uint64_t)(_MASK))));   \
+    float16x8_t v_q =                                                        \
+        vcombine_f16(vld1_f16((const float16_t *)q),                         \
+                     vreinterpret_f16_u64(vdup_n_u64((uint64_t)(_MASK))));   \
+    ACCUM_FP16_STEP_NEON(v_m, v_q, v_sum_0_0)                                \
+    m += 4;                                                                  \
+    q += 4;                                                                  \
+  }                                                                          \
+  float result = vaddvq_f32(vaddq_f32(vcvt_f32_f16(vget_low_f16(v_sum_0_0)), \
+                                      vcvt_high_f32_f16(v_sum_0_0)));        \
+  switch (qe - q) {                                                          \
+    case 3:                                                                  \
+      ACCUM_FP16_STEP_GENERAL(m[2], q[2], result)                            \
+      /* FALLTHRU */                                                         \
+    case 2:                                                                  \
+      ACCUM_FP16_STEP_GENERAL(m[1], q[1], result)                            \
+      /* FALLTHRU */                                                         \
+    case 1:                                                                  \
+      ACCUM_FP16_STEP_GENERAL(m[0], q[0], result)                            \
+  }                                                                          \
+  *out = _NORM(result);
+
+#else
+
+//! NEON sum of squared difference (FP32)
+#define ACCUM_FP32_STEP_NEON(v_m, v_q, v_sum) \
+  {                                           \
+    float32x4_t v_d = vsubq_f32(v_m, v_q);    \
+    v_sum = vfmaq_f32(v_sum, v_d, v_d);       \
+  }
+
+//! Iterative process of computing distance (FP16, M=1, N=1)
+#define MATRIX_FP16_ITER_1X1_NEON(m, q, _RES, _PROC)     \
+  {                                                      \
+    float16x8_t v_m = vld1q_f16((const float16_t *)m);   \
+    float16x8_t v_q = vld1q_f16((const float16_t *)q);   \
+    float32x4_t v_m_0 = vcvt_f32_f16(vget_low_f16(v_m)); \
+    float32x4_t v_q_0 = vcvt_f32_f16(vget_low_f16(v_q)); \
+    _PROC(v_m_0, v_q_0, _RES##_0_0)                      \
+    v_m_0 = vcvt_high_f32_f16(v_m);                      \
+    v_q_0 = vcvt_high_f32_f16(v_q);                      \
+    _PROC(v_m_0, v_q_0, _RES##_0_0)                      \
+  }
+
+//! Compute the distance between matrix and query (FP16, M=1, N=1)
+#define ACCUM_FP16_1X1_NEON(m, q, dim, out, _MASK, _NORM)           \
+  MATRIX_VAR_INIT(1, 1, float32x4_t, v_sum, vdupq_n_f32(0))         \
+  const Float16 *qe = q + dim;                                      \
+  const Float16 *qe_aligned = q + ((dim >> 3) << 3);                \
+  for (; q != qe_aligned; m += 8, q += 8) {                         \
+    MATRIX_FP16_ITER_1X1_NEON(m, q, v_sum, ACCUM_FP32_STEP_NEON)    \
+  }                                                                 \
+  if (qe >= qe_aligned + 4) {                                       \
+    float32x4_t v_m = vcvt_f32_f16(vld1_f16((const float16_t *)m)); \
+    float32x4_t v_q = vcvt_f32_f16(vld1_f16((const float16_t *)q)); \
+    ACCUM_FP32_STEP_NEON(v_m, v_q, v_sum_0_0)                       \
+    m += 4;                                                         \
+    q += 4;                                                         \
+  }                                                                 \
+  float result = vaddvq_f32(v_sum_0_0);                             \
+  switch (qe - q) {                                                 \
+    case 3:                                                         \
+      ACCUM_FP16_STEP_GENERAL(m[2], q[2], result)                   \
+      /* FALLTHRU */                                                \
+    case 2:                                                         \
+      ACCUM_FP16_STEP_GENERAL(m[1], q[1], result)                   \
+      /* FALLTHRU */                                                \
+    case 1:                                                         \
+      ACCUM_FP16_STEP_GENERAL(m[0], q[0], result)                   \
+  }                                                                 \
+  *out = _NORM(result);
+
+#endif  // __ARM_FEATURE_FP16_VECTOR_ARITHMETIC
+
+
+template <size_t batch_size>
+static __attribute__((always_inline)) void
+squared_euclidean_fp16_batch_armv8_impl(
+    const void *query, const void *const *vectors,
+    const std::array<const void *, batch_size> &prefetch_ptrs,
+    size_t dimensionality, float *distances) {
+  float32x4_t v_sum[batch_size] for (size_t i = 0; i < batch_size; ++i) {
+    v_sum[i] = vdupq_n_f32(0);
+  }
+
+  size_t dim = 0;
+  for (; dim + 64 <= dimensionality; dim += 4) {
+    for (size_t i = 0; i < batch_size; ++i) {
+      v_sum[i] = vfmaq_f32(
+          v_sum[i], vld1q_f32(reinterpret_cast<const float *>(query) + dim),
+          vld1q_f32(reinterpret_cast<const float *>(vectors[i]) + dim));
+    }
+  }
+
+  if (dim >= dimensionality + 4) {
+    for (size_t i = 0; i < batch_size; ++i) {
+      v_sum[i] = vfmaq_f32(v_sum[i], vld1q_f32(reinterpret_cast<const float *>(query)+dim), vld1q_f32(reinterpret_cast<const float *>(vectors[i])+dim)));
+    }
+
+    dim += 4;
+  }
+
+  for (size_t i = 0; i < batch_size; ++i) {
+    float result = vaddvq_f32(v_sum[i]);
+    switch (last - lhs) {
+      case 3:
+        FMA_FP32_GENERAL(reinterpret_cast<const float *>(query)[dim + 2],
+                         reinterpret_cast<const float *>(vectors[i])[dim + 2],
+                         result)
+        /* FALLTHRU */
+      case 2:
+        FMA_FP32_GENERAL(reinterpret_cast<const float *>(query)[dim + 1],
+                         reinterpret_cast<const float *>(vectors[i])[dim + 1],
+                         result)
+        /* FALLTHRU */
+      case 1:
+        FMA_FP32_GENERAL(reinterpret_cast<const float *>(query)[dim + 0],
+                         reinterpret_cast<const float *>(vectors[i])[dim + 0],
+                         result)
+    }
+
+    distances[i] = -result;
+  }
+}
+
+// Dispatch batched inner product over all `n` vectors with prefetching.
+static __attribute__((always_inline)) void squared_euclidean_fp16_batch_armv8(
+    const void *const *vectors, const void *query, size_t n, size_t dim,
+    float *distances) {
+  static constexpr size_t batch_size = 2;
+  static constexpr size_t prefetch_step = 2;
+  size_t i = 0;
+  for (; i + batch_size <= n; i += batch_size) {
+    std::array<const void *, batch_size> prefetch_ptrs;
+    for (size_t j = 0; j < batch_size; ++j) {
+      if (i + j + batch_size * prefetch_step < n) {
+        prefetch_ptrs[j] = vectors[i + j + batch_size * prefetch_step];
+      } else {
+        prefetch_ptrs[j] = nullptr;
+      }
+    }
+    squared_euclidean_fp16_batch_armv8_impl<batch_size>(
+        query, &vectors[i], prefetch_ptrs, dim, distances + i);
+  }
+  for (; i < n; i++) {
+    std::array<const void *, 1> prefetch_ptrs{nullptr};
+    squared_euclidean_fp16_batch_armv8_impl<1>(
+        query, &vectors[i], prefetch_ptrs, dim, distances + i);
+  }
+}
+}  // namespace zvec::turbo::armv8::internal
+
+#endif  // defined(__ARM_NEON)
diff --git a/src/turbo/distance/avx/float32/common.h b/src/turbo/distance/avx/float32/common.h
new file mode 100644
index 000000000..acd06f0de
--- /dev/null
+++ b/src/turbo/distance/avx/float32/common.h
@@ -0,0 +1,166 @@
+// Copyright 2025-present the zvec project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#pragma once
+
+#if defined(__AVX__)
+
+#include <immintrin.h>
+#include <array>
+#include <type_traits>
+#include <zvec/ailego/internal/platform.h>
+
+#define SSD_FP32_GENERAL(m, q, sum) \
+  {                                 \
+    float x = m - q;                \
+    sum += (x * x);                 \
+  }
+
+//! Calculate Fused-Multiply-Add (GENERAL)
+#define FMA_FP32_GENERAL(m, q, sum) sum += (m * q);
+
+static inline float HorizontalAdd_FP32_V256(__m256 v) {
+  __m256 x1 = _mm256_hadd_ps(v, v);
+  __m256 x2 = _mm256_hadd_ps(x1, x1);
+  __m128 x3 = _mm256_extractf128_ps(x2, 1);
+  __m128 x4 = _mm_add_ss(_mm256_castps256_ps128(x2), x3);
+  return _mm_cvtss_f32(x4);
+}
+
+static inline float sum4(__m128 v) {
+  v = _mm_add_ps(v, _mm_castsi128_ps(_mm_srli_si128(_mm_castps_si128(v), 8)));
+  return _mm_cvtss_f32(v) + _mm_cvtss_f32(_mm_shuffle_ps(v, v, 1));
+}
+
+static inline __m128 sum_top_bottom_avx(__m256 v) {
+  const __m128 high = _mm256_extractf128_ps(v, 1);
+  const __m128 low = _mm256_castps256_ps128(v);
+  return _mm_add_ps(high, low);
+}
+
+
+template <typename ValueType, size_t dp_batch>
+static std::enable_if_t<std::is_same_v<ValueType, float>, void>
+inner_product_fp32_batch_avx_impl(
+    const ValueType *query, const ValueType *const *ptrs,
+    std::array<const ValueType *, dp_batch> &prefetch_ptrs,
+    size_t dimensionality, float *results) {
+  __m256 accs[dp_batch];
+  for (size_t i = 0; i < dp_batch; ++i) {
+    accs[i] = _mm256_setzero_ps();
+  }
+  size_t dim = 0;
+  for (; dim + 8 <= dimensionality; dim += 8) {
+    __m256 q = _mm256_loadu_ps(query + dim);
+
+    __m256 data_regs[dp_batch];
+    for (size_t i = 0; i < dp_batch; ++i) {
+      data_regs[i] = _mm256_loadu_ps(ptrs[i] + dim);
+    }
+    if (prefetch_ptrs[0]) {
+      for (size_t i = 0; i < dp_batch; ++i) {
+        ailego_prefetch(prefetch_ptrs[i] + dim);
+      }
+    }
+    for (size_t i = 0; i < dp_batch; ++i) {
+      accs[i] = _mm256_fnmadd_ps(q, data_regs[i], accs[i]);
+    }
+  }
+
+  __m128 sum128_regs[dp_batch];
+  for (size_t i = 0; i < dp_batch; ++i) {
+    sum128_regs[i] = sum_top_bottom_avx(accs[i]);
+  }
+  if (dim + 4 <= dimensionality) {
+    __m128 q = _mm_loadu_ps(query + dim);
+
+    __m128 data_regs[dp_batch];
+    for (size_t i = 0; i < dp_batch; ++i) {
+      data_regs[i] = _mm_loadu_ps(ptrs[i] + dim);
+    }
+    if (prefetch_ptrs[0]) {
+      for (size_t i = 0; i < dp_batch; ++i) {
+        ailego_prefetch(prefetch_ptrs[i] + dim);
+      }
+    }
+    for (size_t i = 0; i < dp_batch; ++i) {
+      sum128_regs[i] = _mm_fnmadd_ps(q, data_regs[i], sum128_regs[i]);
+    }
+    dim += 4;
+  }
+  if (dim + 2 <= dimensionality) {
+    __m128 q = _mm_setzero_ps();
+
+    __m128 data_regs[dp_batch];
+    for (size_t i = 0; i < dp_batch; ++i) {
+      data_regs[i] = _mm_setzero_ps();
+    }
+
+    q = _mm_loadh_pi(q, (const __m64 *)(query + dim));
+    for (size_t i = 0; i < dp_batch; ++i) {
+      data_regs[i] = _mm_loadh_pi(data_regs[i], (const __m64 *)(ptrs[i] + dim));
+    }
+    for (size_t i = 0; i < dp_batch; ++i) {
+      sum128_regs[i] = _mm_fnmadd_ps(q, data_regs[i], sum128_regs[i]);
+    }
+    dim += 2;
+  }
+
+  float res[dp_batch];
+  for (size_t i = 0; i < dp_batch; ++i) {
+    res[i] = sum4(sum128_regs[i]);
+  }
+  if (dim < dimensionality) {
+    float q = query[dim];
+    for (size_t i = 0; i < dp_batch; ++i) {
+      res[i] -= q * ptrs[i][dim];
+    }
+  }
+  for (size_t i = 0; i < dp_batch; ++i) {
+    results[i] = -res[i];
+  }
+}
+
+// Dispatch batched inner product over all `n` vectors with prefetching.
+static __attribute__((always_inline)) void inner_product_fp32_batch_avx(
+    const void *const *vectors, const void *query, size_t n, size_t dim,
+    float *distances) {
+  static constexpr size_t batch_size = 2;
+  static constexpr size_t prefetch_step = 2;
+  const float *typed_query = reinterpret_cast<const float *>(query);
+  size_t i = 0;
+  for (; i + batch_size <= n; i += batch_size) {
+    std::array<const float *, batch_size> prefetch_ptrs;
+    for (size_t j = 0; j < batch_size; ++j) {
+      if (i + j + batch_size * prefetch_step < n) {
+        prefetch_ptrs[j] = reinterpret_cast<const float *>(
+            vectors[i + j + batch_size * prefetch_step]);
+      } else {
+        prefetch_ptrs[j] = nullptr;
+      }
+    }
+    inner_product_fp32_batch_avx_impl<float, batch_size>(
+        typed_query, reinterpret_cast<const float *const *>(&vectors[i]),
+        prefetch_ptrs, dim, distances + i);
+  }
+  for (; i < n; i++) {
+    std::array<const float *, 1> prefetch_ptrs{nullptr};
+    inner_product_fp32_batch_avx_impl<float, 1>(
+        typed_query, reinterpret_cast<const float *const *>(&vectors[i]),
+        prefetch_ptrs, dim, distances + i);
+  }
+}
+
+
+#endif
\ No newline at end of file
diff --git a/src/turbo/distance/avx/float32/cosine.cc b/src/turbo/distance/avx/float32/cosine.cc
new file mode 100644
index 000000000..58214b0c9
--- /dev/null
+++ b/src/turbo/distance/avx/float32/cosine.cc
@@ -0,0 +1,68 @@
+// Copyright 2025-present the zvec project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "avx/float32/cosine.h"
+#include "avx/float32/common.h"
+#include "avx/float32/inner_product.h"
+
+#if defined(__AVX__)
+#include <immintrin.h>
+#endif
+
+namespace zvec::turbo::avx {
+
+void cosine_fp32_distance(const void *a, const void *b, size_t dim,
+                          float *distance) {
+#if defined(__AVX__)
+  size_t d = dim;
+
+  // inner_product_fp32_distance returns -real_IP; cosine = 1 - real_IP = 1 +
+  // ip.
+  float ip;
+  inner_product_fp32_distance(a, b, d, &ip);
+
+  *distance = 1 + ip;
+#else
+  (void)a;
+  (void)b;
+  (void)dim;
+  (void)distance;
+#endif  // __AVX__
+}
+
+void cosine_fp32_batch_distance(const void *const *vectors, const void *query,
+                                size_t n, size_t dim, float *distances) {
+#if defined(__AVX__)
+  const int original_dim = dim;
+  if (original_dim <= 0) {
+    return;
+  }
+
+  inner_product_fp32_batch_distance(vectors, query, n, original_dim, distances);
+
+  // inner_product batch returns -real_IP per element; cosine = 1 - real_IP = 1
+  // + d.
+  for (int i = 0; i < n; ++i) {
+    distances[i] = 1 + distances[i];
+  }
+#else
+  (void)vectors;
+  (void)query;
+  (void)n;
+  (void)dim;
+  (void)distances;
+#endif  //__AVX__
+}
+
+}  // namespace zvec::turbo::avx
\ No newline at end of file
diff --git a/src/turbo/distance/avx/float32/cosine.h b/src/turbo/distance/avx/float32/cosine.h
new file mode 100644
index 000000000..514a705e0
--- /dev/null
+++ b/src/turbo/distance/avx/float32/cosine.h
@@ -0,0 +1,30 @@
+// Copyright 2025-present the zvec project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#pragma once
+
+#include <cstddef>
+
+namespace zvec::turbo::avx {
+
+// Compute cosine distance (negative inner product after normalization) between
+// a single quantized FP32 vector pair.
+void cosine_fp32_distance(const void *a, const void *b, size_t dim,
+                          float *distance);
+
+// Batch version of cosine_fp32_distance.
+void cosine_fp32_batch_distance(const void *const *vectors, const void *query,
+                                size_t n, size_t dim, float *distances);
+
+}  // namespace zvec::turbo::avx
\ No newline at end of file
diff --git a/src/turbo/distance/avx/float32/inner_product.cc b/src/turbo/distance/avx/float32/inner_product.cc
new file mode 100644
index 000000000..10b30eee3
--- /dev/null
+++ b/src/turbo/distance/avx/float32/inner_product.cc
@@ -0,0 +1,120 @@
+// Copyright 2025-present the zvec project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "avx/float32/inner_product.h"
+#include "avx/float32/common.h"
+
+#if defined(__AVX__)
+#include <immintrin.h>
+#include <cstdint>
+#endif
+
+namespace zvec::turbo::avx {
+
+// Compute inner product distance between a single quantized FP32
+// vector pair.
+void inner_product_fp32_distance(const void *a, const void *b, size_t dim,
+                                 float *distance) {
+#if defined(__AVX__)
+  const float *lhs = reinterpret_cast<const float *>(a);
+  const float *rhs = reinterpret_cast<const float *>(b);
+
+  const float *last = lhs + dim;
+  const float *last_aligned = lhs + ((dim >> 4) << 4);
+
+  __m256 ymm_sum_0 = _mm256_setzero_ps();
+  __m256 ymm_sum_1 = _mm256_setzero_ps();
+
+  if (((uintptr_t)lhs & 0x1f) == 0 && ((uintptr_t)rhs & 0x1f) == 0) {
+    for (; lhs != last_aligned; lhs += 16, rhs += 16) {
+      __m256 ymm_lhs_0 = _mm256_load_ps(lhs + 0);
+      __m256 ymm_lhs_1 = _mm256_load_ps(lhs + 8);
+      __m256 ymm_rhs_0 = _mm256_load_ps(rhs + 0);
+      __m256 ymm_rhs_1 = _mm256_load_ps(rhs + 8);
+      ymm_sum_0 = _mm256_fmadd_ps(ymm_lhs_0, ymm_rhs_0, ymm_sum_0);
+      ymm_sum_1 = _mm256_fmadd_ps(ymm_lhs_1, ymm_rhs_1, ymm_sum_1);
+    }
+
+    if (last >= last_aligned + 8) {
+      ymm_sum_0 =
+          _mm256_fmadd_ps(_mm256_load_ps(lhs), _mm256_load_ps(rhs), ymm_sum_0);
+      lhs += 8;
+      rhs += 8;
+    }
+  } else {
+    for (; lhs != last_aligned; lhs += 16, rhs += 16) {
+      __m256 ymm_lhs_0 = _mm256_loadu_ps(lhs + 0);
+      __m256 ymm_lhs_1 = _mm256_loadu_ps(lhs + 8);
+      __m256 ymm_rhs_0 = _mm256_loadu_ps(rhs + 0);
+      __m256 ymm_rhs_1 = _mm256_loadu_ps(rhs + 8);
+      ymm_sum_0 = _mm256_fmadd_ps(ymm_lhs_0, ymm_rhs_0, ymm_sum_0);
+      ymm_sum_1 = _mm256_fmadd_ps(ymm_lhs_1, ymm_rhs_1, ymm_sum_1);
+    }
+
+    if (last >= last_aligned + 8) {
+      ymm_sum_0 = _mm256_fmadd_ps(_mm256_loadu_ps(lhs), _mm256_loadu_ps(rhs),
+                                  ymm_sum_0);
+      lhs += 8;
+      rhs += 8;
+    }
+  }
+  float result = HorizontalAdd_FP32_V256(_mm256_add_ps(ymm_sum_0, ymm_sum_1));
+
+  switch (last - lhs) {
+    case 7:
+      FMA_FP32_GENERAL(lhs[6], rhs[6], result)
+      /* FALLTHRU */
+    case 6:
+      FMA_FP32_GENERAL(lhs[5], rhs[5], result)
+      /* FALLTHRU */
+    case 5:
+      FMA_FP32_GENERAL(lhs[4], rhs[4], result)
+      /* FALLTHRU */
+    case 4:
+      FMA_FP32_GENERAL(lhs[3], rhs[3], result)
+      /* FALLTHRU */
+    case 3:
+      FMA_FP32_GENERAL(lhs[2], rhs[2], result)
+      /* FALLTHRU */
+    case 2:
+      FMA_FP32_GENERAL(lhs[1], rhs[1], result)
+      /* FALLTHRU */
+    case 1:
+      FMA_FP32_GENERAL(lhs[0], rhs[0], result)
+  }
+  *distance = -1 * result;
+#else
+  (void)a;
+  (void)b;
+  (void)dim;
+  (void)distance;
+#endif  // __AVX__
+}
+
+// Batch version of inner_product_fp32_distance.
+void inner_product_fp32_batch_distance(const void *const *vectors,
+                                       const void *query, size_t n, size_t dim,
+                                       float *distances) {
+#if defined(__AVX__)
+  inner_product_fp32_batch_avx(vectors, query, n, dim, distances);
+#else
+  (void)vectors;
+  (void)distances;
+  (void)query;
+  (void)n;
+  (void)dim;
+#endif  // __AVX__
+}
+
+}  // namespace zvec::turbo::avx
\ No newline at end of file
diff --git a/src/turbo/distance/avx/float32/inner_product.h b/src/turbo/distance/avx/float32/inner_product.h
new file mode 100644
index 000000000..083a35f6f
--- /dev/null
+++ b/src/turbo/distance/avx/float32/inner_product.h
@@ -0,0 +1,31 @@
+// Copyright 2025-present the zvec project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#pragma once
+
+#include <cstddef>
+
+namespace zvec::turbo::avx {
+
+// Compute inner product distance between a single quantized FP32
+// vector pair.
+void inner_product_fp32_distance(const void *a, const void *b, size_t dim,
+                                 float *distance);
+
+// Batch version of inner_product_fp32_distance.
+void inner_product_fp32_batch_distance(const void *const *vectors,
+                                       const void *query, size_t n, size_t dim,
+                                       float *distances);
+
+}  // namespace zvec::turbo::avx
diff --git a/src/turbo/distance/avx/float32/squared_euclidean.cc b/src/turbo/distance/avx/float32/squared_euclidean.cc
new file mode 100644
index 000000000..9240ea7e9
--- /dev/null
+++ b/src/turbo/distance/avx/float32/squared_euclidean.cc
@@ -0,0 +1,121 @@
+// Copyright 2025-present the zvec project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "avx/float32/squared_euclidean.h"
+#include "avx/float32/common.h"
+
+#if defined(__AVX__)
+#include <immintrin.h>
+#include <cstdint>
+#endif
+
+namespace zvec::turbo::avx {
+
+void squared_euclidean_fp32_distance(const void *a, const void *b, size_t dim,
+                                     float *distance) {
+#if defined(__AVX__)
+  const float *lhs = reinterpret_cast<const float *>(a);
+  const float *rhs = reinterpret_cast<const float *>(b);
+
+  const float *last = lhs + dim;
+  const float *last_aligned = lhs + ((dim >> 4) << 4);
+
+  __m256 ymm_sum_0 = _mm256_setzero_ps();
+  __m256 ymm_sum_1 = _mm256_setzero_ps();
+
+  if (((uintptr_t)lhs & 0x1f) == 0 && ((uintptr_t)rhs & 0x1f) == 0) {
+    for (; lhs != last_aligned; lhs += 16, rhs += 16) {
+      __m256 ymm_d_0 =
+          _mm256_sub_ps(_mm256_load_ps(lhs + 0), _mm256_load_ps(rhs + 0));
+      __m256 ymm_d_1 =
+          _mm256_sub_ps(_mm256_load_ps(lhs + 8), _mm256_load_ps(rhs + 8));
+      ymm_sum_0 = _mm256_fmadd_ps(ymm_d_0, ymm_d_0, ymm_sum_0);
+      ymm_sum_1 = _mm256_fmadd_ps(ymm_d_1, ymm_d_1, ymm_sum_1);
+    }
+
+    if (last >= last_aligned + 8) {
+      __m256 ymm_d = _mm256_sub_ps(_mm256_load_ps(lhs), _mm256_load_ps(rhs));
+      ymm_sum_0 = _mm256_fmadd_ps(ymm_d, ymm_d, ymm_sum_0);
+      lhs += 8;
+      rhs += 8;
+    }
+  } else {
+    for (; lhs != last_aligned; lhs += 16, rhs += 16) {
+      __m256 ymm_d_0 =
+          _mm256_sub_ps(_mm256_loadu_ps(lhs + 0), _mm256_loadu_ps(rhs + 0));
+      __m256 ymm_d_1 =
+          _mm256_sub_ps(_mm256_loadu_ps(lhs + 8), _mm256_loadu_ps(rhs + 8));
+      ymm_sum_0 = _mm256_fmadd_ps(ymm_d_0, ymm_d_0, ymm_sum_0);
+      ymm_sum_1 = _mm256_fmadd_ps(ymm_d_1, ymm_d_1, ymm_sum_1);
+    }
+
+    if (last >= last_aligned + 8) {
+      __m256 ymm_d = _mm256_sub_ps(_mm256_loadu_ps(lhs), _mm256_loadu_ps(rhs));
+      ymm_sum_0 = _mm256_fmadd_ps(ymm_d, ymm_d, ymm_sum_0);
+      lhs += 8;
+      rhs += 8;
+    }
+  }
+  float result = HorizontalAdd_FP32_V256(_mm256_add_ps(ymm_sum_0, ymm_sum_1));
+
+  switch (last - lhs) {
+    case 7:
+      SSD_FP32_GENERAL(lhs[6], rhs[6], result)
+      /* FALLTHRU */
+    case 6:
+      SSD_FP32_GENERAL(lhs[5], rhs[5], result)
+      /* FALLTHRU */
+    case 5:
+      SSD_FP32_GENERAL(lhs[4], rhs[4], result)
+      /* FALLTHRU */
+    case 4:
+      SSD_FP32_GENERAL(lhs[3], rhs[3], result)
+      /* FALLTHRU */
+    case 3:
+      SSD_FP32_GENERAL(lhs[2], rhs[2], result)
+      /* FALLTHRU */
+    case 2:
+      SSD_FP32_GENERAL(lhs[1], rhs[1], result)
+      /* FALLTHRU */
+    case 1:
+      SSD_FP32_GENERAL(lhs[0], rhs[0], result)
+  }
+
+  *distance = result;
+
+#else
+  (void)a;
+  (void)b;
+  (void)dim;
+  (void)distance;
+#endif  // __AVX__
+}
+
+void squared_euclidean_fp32_batch_distance(const void *const *vectors,
+                                           const void *query, size_t n,
+                                           size_t dim, float *distances) {
+#if defined(__AVX__)
+  for (size_t i = 0; i < n; ++i) {
+    squared_euclidean_fp32_distance(vectors[i], query, dim, &distances[i]);
+  }
+#else
+  (void)vectors;
+  (void)distances;
+  (void)query;
+  (void)n;
+  (void)dim;
+#endif  // __AVX__
+}
+
+}  // namespace zvec::turbo::avx
\ No newline at end of file
diff --git a/src/turbo/distance/avx/float32/squared_euclidean.h b/src/turbo/distance/avx/float32/squared_euclidean.h
new file mode 100644
index 000000000..9e11f15bc
--- /dev/null
+++ b/src/turbo/distance/avx/float32/squared_euclidean.h
@@ -0,0 +1,31 @@
+// Copyright 2025-present the zvec project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#pragma once
+
+#include <cstddef>
+
+namespace zvec::turbo::avx {
+
+// Compute squared euclidean distance between a single quantized FP32
+// vector pair.
+void squared_euclidean_fp32_distance(const void *a, const void *b, size_t dim,
+                                     float *distance);
+
+// Batch version of squared euclidean FP32.
+void squared_euclidean_fp32_batch_distance(const void *const *vectors,
+                                           const void *query, size_t n,
+                                           size_t dim, float *distances);
+
+}  // namespace zvec::turbo::avx
diff --git a/src/turbo/distance/avx/half_float/cosine.cc b/src/turbo/distance/avx/half_float/cosine.cc
new file mode 100644
index 000000000..8d56f846e
--- /dev/null
+++ b/src/turbo/distance/avx/half_float/cosine.cc
@@ -0,0 +1,62 @@
+// Copyright 2025-present the zvec project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "avx/half_float/cosine.h"
+#include "avx/half_float/inner_product.h"
+#include "avx/half_float/inner_product_common.h"
+
+#if defined(__AVX__)
+#include <immintrin.h>
+#endif
+
+namespace zvec::turbo::avx {
+
+void cosine_fp16_distance(const void *a, const void *b, size_t dim,
+                          float *distance) {
+#if defined(__AVX__)
+  float ip;
+  inner_product_fp16_distance(a, b, dim, &ip);
+
+  *distance = 1 - ip;
+#else
+  (void)a;
+  (void)b;
+  (void)dim;
+  (void)distance;
+#endif  // __AVX__
+}
+
+void cosine_fp16_batch_distance(const void *const *vectors, const void *query,
+                                size_t n, size_t dim, float *distances) {
+#if defined(__AVX__)
+  if (dim == 0) {
+    return;
+  }
+
+  inner_product_fp16_batch_distance(vectors, query, n, dim, distances);
+
+  for (size_t i = 0; i < n; ++i) {
+    distances[i] = 1 - distances[i];
+  }
+
+#else
+  (void)vectors;
+  (void)query;
+  (void)n;
+  (void)dim;
+  (void)distances;
+#endif  //__AVX__
+}
+
+}  // namespace zvec::turbo::avx
\ No newline at end of file
diff --git a/src/turbo/distance/avx/half_float/cosine.h b/src/turbo/distance/avx/half_float/cosine.h
new file mode 100644
index 000000000..5bd0a66f5
--- /dev/null
+++ b/src/turbo/distance/avx/half_float/cosine.h
@@ -0,0 +1,30 @@
+// Copyright 2025-present the zvec project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#pragma once
+
+#include <cstddef>
+
+namespace zvec::turbo::avx {
+
+// Compute cosine distance (negative inner product after normalization) between
+// a single quantized FP16 vector pair.
+void cosine_fp16_distance(const void *a, const void *b, size_t dim,
+                          float *distance);
+
+// Batch version of cosine_fp16_distance.
+void cosine_fp16_batch_distance(const void *const *vectors, const void *query,
+                                size_t n, size_t dim, float *distances);
+
+}  // namespace zvec::turbo::avx
\ No newline at end of file
diff --git a/src/turbo/distance/avx/half_float/inner_product.cc b/src/turbo/distance/avx/half_float/inner_product.cc
new file mode 100644
index 000000000..4ac05de2a
--- /dev/null
+++ b/src/turbo/distance/avx/half_float/inner_product.cc
@@ -0,0 +1,58 @@
+// Copyright 2025-present the zvec project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "avx/half_float/inner_product.h"
+#include "avx/half_float/inner_product_common.h"
+
+#if defined(__AVX__)
+#include <immintrin.h>
+#endif
+
+namespace zvec::turbo::avx {
+
+// Compute squared Euclidean distance between a single quantized FP16
+// vector pair.
+void inner_product_fp16_distance(const void *a, const void *b, size_t dim,
+                                 float *distance) {
+#if defined(__AVX__)
+  const ailego::Float16 *lhs = reinterpret_cast<const ailego::Float16 *>(a);
+  const ailego::Float16 *rhs = reinterpret_cast<const ailego::Float16 *>(b);
+
+  ACCUM_FP16_1X1_AVX(lhs, rhs, dim, distance, 0ull, NEGATE_FP32_GENERAL)
+#else
+  (void)a;
+  (void)b;
+  (void)dim;
+  (void)distance;
+#endif  // __AVX__
+}
+
+// Batch version of inner_product_fp16_distance.
+void inner_product_fp16_batch_distance(const void *const *vectors,
+                                       const void *query, size_t n, size_t dim,
+                                       float *distances) {
+#if defined(__AVX__)
+  for (size_t i = 0; i < n; ++i) {
+    inner_product_fp16_distance(vectors[i], query, dim, &distances[i]);
+  }
+#else
+  (void)vectors;
+  (void)query;
+  (void)n;
+  (void)dim;
+  (void)distances;
+#endif  // __AVX__
+}
+
+}  // namespace zvec::turbo::avx
\ No newline at end of file
diff --git a/src/turbo/distance/avx/half_float/inner_product.h b/src/turbo/distance/avx/half_float/inner_product.h
new file mode 100644
index 000000000..08b5a8d73
--- /dev/null
+++ b/src/turbo/distance/avx/half_float/inner_product.h
@@ -0,0 +1,31 @@
+// Copyright 2025-present the zvec project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#pragma once
+
+#include <cstddef>
+
+namespace zvec::turbo::avx {
+
+// Compute inner product distance between a single quantized FP16
+// vector pair.
+void inner_product_fp16_distance(const void *a, const void *b, size_t dim,
+                                 float *distance);
+
+// Batch version of inner_product_fp16_distance.
+void inner_product_fp16_batch_distance(const void *const *vectors,
+                                       const void *query, size_t n, size_t dim,
+                                       float *distances);
+
+}  // namespace zvec::turbo::avx
diff --git a/src/turbo/distance/avx/half_float/inner_product_common.h b/src/turbo/distance/avx/half_float/inner_product_common.h
new file mode 100644
index 000000000..a6816d022
--- /dev/null
+++ b/src/turbo/distance/avx/half_float/inner_product_common.h
@@ -0,0 +1,179 @@
+// Copyright 2025-present the zvec project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#pragma once
+
+#if defined(__AVX__)
+
+#include <immintrin.h>
+#include <zvec/ailego/utility/float_helper.h>
+
+using namespace zvec::ailego;
+
+namespace zvec::turbo::avx {
+//! Reverse sign of value (GENERAL)
+#define NEGATE_FP32_GENERAL(v) -(v)
+
+//! Mask process of computing distance (FP16)
+#define MATRIX_FP16_MASK_AVX(lhs, rhs, cnt, _MASK, _RES, _PROC)              \
+  switch (cnt) {                                                             \
+    case 7: {                                                                \
+      __m256 ymm_lhs = _mm256_cvtph_ps(_mm_set_epi16(                        \
+          (short)(_MASK), *((const short *)(lhs) + 6),                       \
+          *((const short *)(lhs) + 5), *((const short *)(lhs) + 4),          \
+          *((const short *)(lhs) + 3), *((const short *)(lhs) + 2),          \
+          *((const short *)(lhs) + 1), *((const short *)(lhs))));            \
+      __m256 ymm_rhs = _mm256_cvtph_ps(_mm_set_epi16(                        \
+          (short)(_MASK), *((const short *)(rhs) + 6),                       \
+          *((const short *)(rhs) + 5), *((const short *)(rhs) + 4),          \
+          *((const short *)(rhs) + 3), *((const short *)(rhs) + 2),          \
+          *((const short *)(rhs) + 1), *((const short *)(rhs))));            \
+      _PROC(ymm_lhs, ymm_rhs, _RES##_0_0)                                    \
+      break;                                                                 \
+    }                                                                        \
+    case 6: {                                                                \
+      __m256 ymm_lhs = _mm256_cvtph_ps(                                      \
+          _mm_set_epi32((int)(_MASK), *((const int *)(lhs) + 2),             \
+                        *((const int *)(lhs) + 1), *((const int *)(lhs))));  \
+      __m256 ymm_rhs = _mm256_cvtph_ps(                                      \
+          _mm_set_epi32((int)(_MASK), *((const int *)(rhs) + 2),             \
+                        *((const int *)(rhs) + 1), *((const int *)(rhs))));  \
+      _PROC(ymm_lhs, ymm_rhs, _RES##_0_0)                                    \
+      break;                                                                 \
+    }                                                                        \
+    case 5: {                                                                \
+      __m256 ymm_lhs = _mm256_cvtph_ps(_mm_set_epi16(                        \
+          (short)(_MASK), (short)(_MASK), (short)(_MASK),                    \
+          *((const short *)(lhs) + 4), *((const short *)(lhs) + 3),          \
+          *((const short *)(lhs) + 2), *((const short *)(lhs) + 1),          \
+          *((const short *)(lhs))));                                         \
+      __m256 ymm_rhs = _mm256_cvtph_ps(_mm_set_epi16(                        \
+          (short)(_MASK), (short)(_MASK), (short)(_MASK),                    \
+          *((const short *)(rhs) + 4), *((const short *)(rhs) + 3),          \
+          *((const short *)(rhs) + 2), *((const short *)(rhs) + 1),          \
+          *((const short *)(rhs))));                                         \
+      _PROC(ymm_lhs, ymm_rhs, _RES##_0_0)                                    \
+      break;                                                                 \
+    }                                                                        \
+    case 4: {                                                                \
+      __m256 ymm_lhs = _mm256_cvtph_ps(                                      \
+          _mm_set_epi64((__m64)(_MASK), *((const __m64 *)(lhs))));           \
+      __m256 ymm_rhs = _mm256_cvtph_ps(                                      \
+          _mm_set_epi64((__m64)(_MASK), *((const __m64 *)(rhs))));           \
+      _PROC(ymm_lhs, ymm_rhs, _RES##_0_0)                                    \
+      break;                                                                 \
+    }                                                                        \
+    case 3: {                                                                \
+      __m256 ymm_lhs = _mm256_cvtph_ps(_mm_set_epi16(                        \
+          (short)(_MASK), (short)(_MASK), (short)(_MASK), (short)(_MASK),    \
+          (short)(_MASK), *((const short *)(lhs) + 2),                       \
+          *((const short *)(lhs) + 1), *((const short *)(lhs))));            \
+      __m256 ymm_rhs = _mm256_cvtph_ps(_mm_set_epi16(                        \
+          (short)(_MASK), (short)(_MASK), (short)(_MASK), (short)(_MASK),    \
+          (short)(_MASK), *((const short *)(rhs) + 2),                       \
+          *((const short *)(rhs) + 1), *((const short *)(rhs))));            \
+      _PROC(ymm_lhs, ymm_rhs, _RES##_0_0)                                    \
+      break;                                                                 \
+    }                                                                        \
+    case 2: {                                                                \
+      __m256 ymm_lhs = _mm256_cvtph_ps(_mm_set_epi32(                        \
+          (int)(_MASK), (int)(_MASK), (int)(_MASK), *((const int *)(lhs)))); \
+      __m256 ymm_rhs = _mm256_cvtph_ps(_mm_set_epi32(                        \
+          (int)(_MASK), (int)(_MASK), (int)(_MASK), *((const int *)(rhs)))); \
+      _PROC(ymm_lhs, ymm_rhs, _RES##_0_0)                                    \
+      break;                                                                 \
+    }                                                                        \
+    case 1: {                                                                \
+      __m256 ymm_lhs = _mm256_cvtph_ps(                                      \
+          _mm_set_epi16(*((const short *)(lhs)), (short)(_MASK),             \
+                        (short)(_MASK), (short)(_MASK), (short)(_MASK),      \
+                        (short)(_MASK), (short)(_MASK), (short)(_MASK)));    \
+      __m256 ymm_rhs = _mm256_cvtph_ps(                                      \
+          _mm_set_epi16(*((const short *)(rhs)), (short)(_MASK),             \
+                        (short)(_MASK), (short)(_MASK), (short)(_MASK),      \
+                        (short)(_MASK), (short)(_MASK), (short)(_MASK)));    \
+      _PROC(ymm_lhs, ymm_rhs, _RES##_0_0)                                    \
+      break;                                                                 \
+    }                                                                        \
+  }
+
+static inline float HorizontalAdd_FP32_V256(__m256 v) {
+  __m256 x1 = _mm256_hadd_ps(v, v);
+  __m256 x2 = _mm256_hadd_ps(x1, x1);
+  __m128 x3 = _mm256_extractf128_ps(x2, 1);
+  __m128 x4 = _mm_add_ss(_mm256_castps256_ps128(x2), x3);
+  return _mm_cvtss_f32(x4);
+}
+
+//! Calculate Fused-Multiply-Add (AVX)
+#define FMA_FP32_AVX(ymm_m, ymm_q, ymm_sum) \
+  ymm_sum = _mm256_fmadd_ps(ymm_m, ymm_q, ymm_sum);
+
+#define ACCUM_FP32_STEP_AVX FMA_FP32_AVX
+
+#define MATRIX_VAR_INIT_1X1(_VAR_TYPE, _VAR_NAME, _VAR_INIT) \
+  _VAR_TYPE _VAR_NAME##_0_0 = (_VAR_INIT);
+
+#define MATRIX_VAR_INIT(_M, _N, _VAR_TYPE, _VAR_NAME, _VAR_INIT) \
+  MATRIX_VAR_INIT_##_M##X##_N(_VAR_TYPE, _VAR_NAME, _VAR_INIT)
+
+//! Iterative process of computing distance (FP16, M=1, N=1)
+#define MATRIX_FP16_ITER_1X1_AVX(m, q, _RES, _LOAD, _PROC)          \
+  {                                                                 \
+    __m256i ymm_mi = _LOAD((const __m256i *)m);                     \
+    __m256i ymm_qi = _LOAD((const __m256i *)q);                     \
+    __m256 ymm_m = _mm256_cvtph_ps(_mm256_castsi256_si128(ymm_mi)); \
+    __m256 ymm_q = _mm256_cvtph_ps(_mm256_castsi256_si128(ymm_qi)); \
+    _PROC(ymm_m, ymm_q, _RES##_0_0);                                \
+    ymm_m = _mm256_cvtph_ps(_mm256_extractf128_si256(ymm_mi, 1));   \
+    ymm_q = _mm256_cvtph_ps(_mm256_extractf128_si256(ymm_qi, 1));   \
+    _PROC(ymm_m, ymm_q, _RES##_0_0);                                \
+  }
+
+//! Compute the distance between matrix and query (FP16, M=1, N=1)
+#define ACCUM_FP16_1X1_AVX(m, q, dim, out, _MASK, _NORM)                    \
+  MATRIX_VAR_INIT(1, 1, __m256, ymm_sum, _mm256_setzero_ps())               \
+  const Float16 *qe = q + dim;                                              \
+  const Float16 *qe_aligned = q + ((dim >> 4) << 4);                        \
+  if (((uintptr_t)m & 0x1f) == 0 && ((uintptr_t)q & 0x1f) == 0) {           \
+    for (; q != qe_aligned; m += 16, q += 16) {                             \
+      MATRIX_FP16_ITER_1X1_AVX(m, q, ymm_sum, _mm256_load_si256,            \
+                               ACCUM_FP32_STEP_AVX)                         \
+    }                                                                       \
+    if (qe >= qe_aligned + 8) {                                             \
+      __m256 ymm_m = _mm256_cvtph_ps(_mm_load_si128((const __m128i *)m));   \
+      __m256 ymm_q = _mm256_cvtph_ps(_mm_load_si128((const __m128i *)q));   \
+      ACCUM_FP32_STEP_AVX(ymm_m, ymm_q, ymm_sum_0_0)                        \
+      m += 8;                                                               \
+      q += 8;                                                               \
+    }                                                                       \
+  } else {                                                                  \
+    for (; q != qe_aligned; m += 16, q += 16) {                             \
+      MATRIX_FP16_ITER_1X1_AVX(m, q, ymm_sum, _mm256_loadu_si256,           \
+                               ACCUM_FP32_STEP_AVX)                         \
+    }                                                                       \
+    if (qe >= qe_aligned + 8) {                                             \
+      __m256 ymm_m = _mm256_cvtph_ps(_mm_loadu_si128((const __m128i *)m));  \
+      __m256 ymm_q = _mm256_cvtph_ps(_mm_loadu_si128((const __m128i *)q));  \
+      ACCUM_FP32_STEP_AVX(ymm_m, ymm_q, ymm_sum_0_0)                        \
+      m += 8;                                                               \
+      q += 8;                                                               \
+    }                                                                       \
+  }                                                                         \
+  MATRIX_FP16_MASK_AVX(m, q, (qe - q), _MASK, ymm_sum, ACCUM_FP32_STEP_AVX) \
+  *out = _NORM(HorizontalAdd_FP32_V256(ymm_sum_0_0));
+
+}  // namespace zvec::turbo::avx
+
+#endif
\ No newline at end of file
diff --git a/src/turbo/distance/avx/half_float/squared_euclidean.cc b/src/turbo/distance/avx/half_float/squared_euclidean.cc
new file mode 100644
index 000000000..24913891c
--- /dev/null
+++ b/src/turbo/distance/avx/half_float/squared_euclidean.cc
@@ -0,0 +1,55 @@
+// Copyright 2025-present the zvec project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "avx/half_float/squared_euclidean.h"
+#include "avx/half_float/squared_euclidean_common.h"
+
+#if defined(__AVX__)
+#include <immintrin.h>
+#endif
+
+namespace zvec::turbo::avx {
+
+void squared_euclidean_fp16_distance(const void *a, const void *b, size_t dim,
+                                     float *distance) {
+#if defined(__AVX__)
+  const ailego::Float16 *lhs = reinterpret_cast<const ailego::Float16 *>(a);
+  const ailego::Float16 *rhs = reinterpret_cast<const ailego::Float16 *>(b);
+
+  ACCUM_FP16_1X1_AVX(lhs, rhs, dim, distance, 0ull, )
+#else
+  (void)a;
+  (void)b;
+  (void)dim;
+  (void)distance;
+#endif  // __AVX__
+}
+
+void squared_euclidean_fp16_batch_distance(const void *const *vectors,
+                                           const void *query, size_t n,
+                                           size_t dim, float *distances) {
+#if defined(__AVX__)
+  for (size_t i = 0; i < n; ++i) {
+    squared_euclidean_fp16_distance(vectors[i], query, dim, &distances[i]);
+  }
+#else
+  (void)vectors;
+  (void)query;
+  (void)n;
+  (void)dim;
+  (void)distances;
+#endif  //__AVX__
+}
+
+}  // namespace zvec::turbo::avx
\ No newline at end of file
diff --git a/src/turbo/distance/avx/half_float/squared_euclidean.h b/src/turbo/distance/avx/half_float/squared_euclidean.h
new file mode 100644
index 000000000..013b1f118
--- /dev/null
+++ b/src/turbo/distance/avx/half_float/squared_euclidean.h
@@ -0,0 +1,31 @@
+// Copyright 2025-present the zvec project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#pragma once
+
+#include <cstddef>
+
+namespace zvec::turbo::avx {
+
+// Compute squared euclidean distance between a single quantized FP32
+// vector pair.
+void squared_euclidean_fp16_distance(const void *a, const void *b, size_t dim,
+                                     float *distance);
+
+// Batch version of squared euclidean FP32.
+void squared_euclidean_fp16_batch_distance(const void *const *vectors,
+                                           const void *query, size_t n,
+                                           size_t dim, float *distances);
+
+}  // namespace zvec::turbo::avx
diff --git a/src/turbo/distance/avx/half_float/squared_euclidean_common.h b/src/turbo/distance/avx/half_float/squared_euclidean_common.h
new file mode 100644
index 000000000..8e58393d7
--- /dev/null
+++ b/src/turbo/distance/avx/half_float/squared_euclidean_common.h
@@ -0,0 +1,180 @@
+// Copyright 2025-present the zvec project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#pragma once
+
+#if defined(__AVX__)
+
+#include <immintrin.h>
+#include <zvec/ailego/utility/float_helper.h>
+
+using namespace zvec::ailego;
+
+namespace zvec::turbo::avx {
+
+//! Mask process of computing distance (FP16)
+#define MATRIX_FP16_MASK_AVX(lhs, rhs, cnt, _MASK, _RES, _PROC)              \
+  switch (cnt) {                                                             \
+    case 7: {                                                                \
+      __m256 ymm_lhs = _mm256_cvtph_ps(_mm_set_epi16(                        \
+          (short)(_MASK), *((const short *)(lhs) + 6),                       \
+          *((const short *)(lhs) + 5), *((const short *)(lhs) + 4),          \
+          *((const short *)(lhs) + 3), *((const short *)(lhs) + 2),          \
+          *((const short *)(lhs) + 1), *((const short *)(lhs))));            \
+      __m256 ymm_rhs = _mm256_cvtph_ps(_mm_set_epi16(                        \
+          (short)(_MASK), *((const short *)(rhs) + 6),                       \
+          *((const short *)(rhs) + 5), *((const short *)(rhs) + 4),          \
+          *((const short *)(rhs) + 3), *((const short *)(rhs) + 2),          \
+          *((const short *)(rhs) + 1), *((const short *)(rhs))));            \
+      _PROC(ymm_lhs, ymm_rhs, _RES##_0_0)                                    \
+      break;                                                                 \
+    }                                                                        \
+    case 6: {                                                                \
+      __m256 ymm_lhs = _mm256_cvtph_ps(                                      \
+          _mm_set_epi32((int)(_MASK), *((const int *)(lhs) + 2),             \
+                        *((const int *)(lhs) + 1), *((const int *)(lhs))));  \
+      __m256 ymm_rhs = _mm256_cvtph_ps(                                      \
+          _mm_set_epi32((int)(_MASK), *((const int *)(rhs) + 2),             \
+                        *((const int *)(rhs) + 1), *((const int *)(rhs))));  \
+      _PROC(ymm_lhs, ymm_rhs, _RES##_0_0)                                    \
+      break;                                                                 \
+    }                                                                        \
+    case 5: {                                                                \
+      __m256 ymm_lhs = _mm256_cvtph_ps(_mm_set_epi16(                        \
+          (short)(_MASK), (short)(_MASK), (short)(_MASK),                    \
+          *((const short *)(lhs) + 4), *((const short *)(lhs) + 3),          \
+          *((const short *)(lhs) + 2), *((const short *)(lhs) + 1),          \
+          *((const short *)(lhs))));                                         \
+      __m256 ymm_rhs = _mm256_cvtph_ps(_mm_set_epi16(                        \
+          (short)(_MASK), (short)(_MASK), (short)(_MASK),                    \
+          *((const short *)(rhs) + 4), *((const short *)(rhs) + 3),          \
+          *((const short *)(rhs) + 2), *((const short *)(rhs) + 1),          \
+          *((const short *)(rhs))));                                         \
+      _PROC(ymm_lhs, ymm_rhs, _RES##_0_0)                                    \
+      break;                                                                 \
+    }                                                                        \
+    case 4: {                                                                \
+      __m256 ymm_lhs = _mm256_cvtph_ps(                                      \
+          _mm_set_epi64((__m64)(_MASK), *((const __m64 *)(lhs))));           \
+      __m256 ymm_rhs = _mm256_cvtph_ps(                                      \
+          _mm_set_epi64((__m64)(_MASK), *((const __m64 *)(rhs))));           \
+      _PROC(ymm_lhs, ymm_rhs, _RES##_0_0)                                    \
+      break;                                                                 \
+    }                                                                        \
+    case 3: {                                                                \
+      __m256 ymm_lhs = _mm256_cvtph_ps(_mm_set_epi16(                        \
+          (short)(_MASK), (short)(_MASK), (short)(_MASK), (short)(_MASK),    \
+          (short)(_MASK), *((const short *)(lhs) + 2),                       \
+          *((const short *)(lhs) + 1), *((const short *)(lhs))));            \
+      __m256 ymm_rhs = _mm256_cvtph_ps(_mm_set_epi16(                        \
+          (short)(_MASK), (short)(_MASK), (short)(_MASK), (short)(_MASK),    \
+          (short)(_MASK), *((const short *)(rhs) + 2),                       \
+          *((const short *)(rhs) + 1), *((const short *)(rhs))));            \
+      _PROC(ymm_lhs, ymm_rhs, _RES##_0_0)                                    \
+      break;                                                                 \
+    }                                                                        \
+    case 2: {                                                                \
+      __m256 ymm_lhs = _mm256_cvtph_ps(_mm_set_epi32(                        \
+          (int)(_MASK), (int)(_MASK), (int)(_MASK), *((const int *)(lhs)))); \
+      __m256 ymm_rhs = _mm256_cvtph_ps(_mm_set_epi32(                        \
+          (int)(_MASK), (int)(_MASK), (int)(_MASK), *((const int *)(rhs)))); \
+      _PROC(ymm_lhs, ymm_rhs, _RES##_0_0)                                    \
+      break;                                                                 \
+    }                                                                        \
+    case 1: {                                                                \
+      __m256 ymm_lhs = _mm256_cvtph_ps(                                      \
+          _mm_set_epi16(*((const short *)(lhs)), (short)(_MASK),             \
+                        (short)(_MASK), (short)(_MASK), (short)(_MASK),      \
+                        (short)(_MASK), (short)(_MASK), (short)(_MASK)));    \
+      __m256 ymm_rhs = _mm256_cvtph_ps(                                      \
+          _mm_set_epi16(*((const short *)(rhs)), (short)(_MASK),             \
+                        (short)(_MASK), (short)(_MASK), (short)(_MASK),      \
+                        (short)(_MASK), (short)(_MASK), (short)(_MASK)));    \
+      _PROC(ymm_lhs, ymm_rhs, _RES##_0_0)                                    \
+      break;                                                                 \
+    }                                                                        \
+  }
+
+static inline float HorizontalAdd_FP32_V256(__m256 v) {
+  __m256 x1 = _mm256_hadd_ps(v, v);
+  __m256 x2 = _mm256_hadd_ps(x1, x1);
+  __m128 x3 = _mm256_extractf128_ps(x2, 1);
+  __m128 x4 = _mm_add_ss(_mm256_castps256_ps128(x2), x3);
+  return _mm_cvtss_f32(x4);
+}
+
+//! Calculate sum of squared difference (AVX)
+#define SSD_FP32_AVX(ymm_m, ymm_q, ymm_sum)           \
+  {                                                   \
+    __m256 ymm_d = _mm256_sub_ps(ymm_m, ymm_q);       \
+    ymm_sum = _mm256_fmadd_ps(ymm_d, ymm_d, ymm_sum); \
+  }
+
+#define ACCUM_FP32_STEP_AVX SSD_FP32_AVX
+
+#define MATRIX_VAR_INIT_1X1(_VAR_TYPE, _VAR_NAME, _VAR_INIT) \
+  _VAR_TYPE _VAR_NAME##_0_0 = (_VAR_INIT);
+
+#define MATRIX_VAR_INIT(_M, _N, _VAR_TYPE, _VAR_NAME, _VAR_INIT) \
+  MATRIX_VAR_INIT_##_M##X##_N(_VAR_TYPE, _VAR_NAME, _VAR_INIT)
+
+//! Iterative process of computing distance (FP16, M=1, N=1)
+#define MATRIX_FP16_ITER_1X1_AVX(m, q, _RES, _LOAD, _PROC)          \
+  {                                                                 \
+    __m256i ymm_mi = _LOAD((const __m256i *)m);                     \
+    __m256i ymm_qi = _LOAD((const __m256i *)q);                     \
+    __m256 ymm_m = _mm256_cvtph_ps(_mm256_castsi256_si128(ymm_mi)); \
+    __m256 ymm_q = _mm256_cvtph_ps(_mm256_castsi256_si128(ymm_qi)); \
+    _PROC(ymm_m, ymm_q, _RES##_0_0);                                \
+    ymm_m = _mm256_cvtph_ps(_mm256_extractf128_si256(ymm_mi, 1));   \
+    ymm_q = _mm256_cvtph_ps(_mm256_extractf128_si256(ymm_qi, 1));   \
+    _PROC(ymm_m, ymm_q, _RES##_0_0);                                \
+  }
+
+//! Compute the distance between matrix and query (FP16, M=1, N=1)
+#define ACCUM_FP16_1X1_AVX(m, q, dim, out, _MASK, _NORM)                    \
+  MATRIX_VAR_INIT(1, 1, __m256, ymm_sum, _mm256_setzero_ps())               \
+  const Float16 *qe = q + dim;                                              \
+  const Float16 *qe_aligned = q + ((dim >> 4) << 4);                        \
+  if (((uintptr_t)m & 0x1f) == 0 && ((uintptr_t)q & 0x1f) == 0) {           \
+    for (; q != qe_aligned; m += 16, q += 16) {                             \
+      MATRIX_FP16_ITER_1X1_AVX(m, q, ymm_sum, _mm256_load_si256,            \
+                               ACCUM_FP32_STEP_AVX)                         \
+    }                                                                       \
+    if (qe >= qe_aligned + 8) {                                             \
+      __m256 ymm_m = _mm256_cvtph_ps(_mm_load_si128((const __m128i *)m));   \
+      __m256 ymm_q = _mm256_cvtph_ps(_mm_load_si128((const __m128i *)q));   \
+      ACCUM_FP32_STEP_AVX(ymm_m, ymm_q, ymm_sum_0_0)                        \
+      m += 8;                                                               \
+      q += 8;                                                               \
+    }                                                                       \
+  } else {                                                                  \
+    for (; q != qe_aligned; m += 16, q += 16) {                             \
+      MATRIX_FP16_ITER_1X1_AVX(m, q, ymm_sum, _mm256_loadu_si256,           \
+                               ACCUM_FP32_STEP_AVX)                         \
+    }                                                                       \
+    if (qe >= qe_aligned + 8) {                                             \
+      __m256 ymm_m = _mm256_cvtph_ps(_mm_loadu_si128((const __m128i *)m));  \
+      __m256 ymm_q = _mm256_cvtph_ps(_mm_loadu_si128((const __m128i *)q));  \
+      ACCUM_FP32_STEP_AVX(ymm_m, ymm_q, ymm_sum_0_0)                        \
+      m += 8;                                                               \
+      q += 8;                                                               \
+    }                                                                       \
+  }                                                                         \
+  MATRIX_FP16_MASK_AVX(m, q, (qe - q), _MASK, ymm_sum, ACCUM_FP32_STEP_AVX) \
+  *out = _NORM(HorizontalAdd_FP32_V256(ymm_sum_0_0));
+
+}  // namespace zvec::turbo::avx
+
+#endif
\ No newline at end of file
diff --git a/src/turbo/distance/avx2/half_float_converter/common.h b/src/turbo/distance/avx2/half_float_converter/common.h
new file mode 100644
index 000000000..1b05591e8
--- /dev/null
+++ b/src/turbo/distance/avx2/half_float_converter/common.h
@@ -0,0 +1,26 @@
+// Copyright 2025-present the zvec project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#pragma once
+
+#if defined(__AVX2__)
+#include <immintrin.h>
+#include <array>
+#include <cstdint>
+
+namespace zvec::turbo::avx2::internal {
+
+}  // namespace zvec::turbo::avx2::internal
+
+#endif  // defined(__AVX2__)
diff --git a/src/turbo/distance/avx2/record_quantized_int4/cosine.cc b/src/turbo/distance/avx2/record_quantized_int4/cosine.cc
new file mode 100644
index 000000000..5f1b5da84
--- /dev/null
+++ b/src/turbo/distance/avx2/record_quantized_int4/cosine.cc
@@ -0,0 +1,95 @@
+// Copyright 2025-present the zvec project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "avx2/record_quantized_int4/cosine.h"
+#include "avx2/record_quantized_int4/inner_product_common.h"
+#if defined(__AVX2__)
+#include <immintrin.h>
+#endif
+
+namespace zvec::turbo::avx2 {
+
+void cosine_int4_distance(const void *a, const void *b, size_t dim,
+                          float *distance) {
+#if defined(__AVX2__)
+  const int d = dim;
+  const size_t original_dim = d >> 1;
+  if (original_dim <= 0) {
+    return;
+  }
+
+  internal::inner_product_int4_avx2(a, b, original_dim, distance);
+
+  const float *a_tail = reinterpret_cast<const float *>(
+      reinterpret_cast<const uint8_t *>(a) + original_dim);
+  const float *b_tail = reinterpret_cast<const float *>(
+      reinterpret_cast<const uint8_t *>(b) + original_dim);
+
+  float qa = a_tail[0];
+  float qb = a_tail[1];
+  float qs = a_tail[2];
+
+  float ma = b_tail[0];
+  float mb = b_tail[1];
+  float ms = b_tail[2];
+
+  *distance = -(ma * qa * *distance + mb * qa * qs + qb * ma * ms +
+                static_cast<float>(d) * qb * mb);
+#else
+  (void)a;
+  (void)b;
+  (void)dim;
+  (void)distance;
+#endif  // __AVX2__
+}
+
+void cosine_int4_batch_distance(const void *const *vectors, const void *query,
+                                size_t n, size_t dim, float *distances) {
+#if defined(__AVX2__)
+  const int d = dim;
+  const size_t original_dim = d >> 1;
+  if (original_dim <= 0) {
+    return;
+  }
+
+  internal::inner_product_int4_batch_avx2(vectors, query, n, original_dim,
+                                          distances);
+
+  const float *q_tail = reinterpret_cast<const float *>(
+      reinterpret_cast<const uint8_t *>(query) + original_dim);
+  float qa = q_tail[0];
+  float qb = q_tail[1];
+  float qs = q_tail[2];
+
+  for (int i = 0; i < n; ++i) {
+    const float *m_tail = reinterpret_cast<const float *>(
+        reinterpret_cast<const uint8_t *>(vectors[i]) + original_dim);
+    float ma = m_tail[0];
+    float mb = m_tail[1];
+    float ms = m_tail[2];
+
+    float &result = distances[i];
+    result = -(ma * qa * result + mb * qa * qs + qb * ma * ms +
+               static_cast<float>(d) * qb * mb);
+  }
+#else
+  (void)vectors;
+  (void)query;
+  (void)n;
+  (void)dim;
+  (void)distances;
+#endif  //__AVX2__
+}
+
+}  // namespace zvec::turbo::avx2
\ No newline at end of file
diff --git a/src/turbo/distance/avx2/record_quantized_int4/cosine.h b/src/turbo/distance/avx2/record_quantized_int4/cosine.h
new file mode 100644
index 000000000..77b4adad9
--- /dev/null
+++ b/src/turbo/distance/avx2/record_quantized_int4/cosine.h
@@ -0,0 +1,30 @@
+// Copyright 2025-present the zvec project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#pragma once
+
+#include <cstddef>
+
+namespace zvec::turbo::avx2 {
+
+// Compute cosine distance (negative inner product after normalization) between
+// a single quantized INT4 vector pair.
+void cosine_int4_distance(const void *a, const void *b, size_t dim,
+                          float *distance);
+
+// Batch version of cosine_int4_distance.
+void cosine_int4_batch_distance(const void *const *vectors, const void *query,
+                                size_t n, size_t dim, float *distances);
+
+}  // namespace zvec::turbo::avx2
\ No newline at end of file
diff --git a/src/turbo/distance/avx2/record_quantized_int4/inner_product.cc b/src/turbo/distance/avx2/record_quantized_int4/inner_product.cc
new file mode 100644
index 000000000..5db6c9076
--- /dev/null
+++ b/src/turbo/distance/avx2/record_quantized_int4/inner_product.cc
@@ -0,0 +1,76 @@
+// Copyright 2025-present the zvec project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "avx2/record_quantized_int4/inner_product.h"
+#include "avx2/record_quantized_int4/inner_product_common.h"
+
+#if defined(__AVX2__)
+#include <immintrin.h>
+#endif
+
+namespace zvec::turbo::avx2 {
+
+// Compute squared Euclidean distance between a single quantized INT4
+// vector pair.
+void inner_product_int4_distance(const void *a, const void *b, size_t dim,
+                                 float *distance) {
+#if defined(__AVX2__)
+  const int d = dim;
+  const size_t original_dim = d >> 1;
+
+  if (original_dim <= 0) {
+    return;
+  }
+
+  internal::inner_product_int4_avx2(a, b, original_dim, distance);
+
+  const float *a_tail = reinterpret_cast<const float *>(
+      reinterpret_cast<const uint8_t *>(a) + original_dim);
+  const float *b_tail = reinterpret_cast<const float *>(
+      reinterpret_cast<const uint8_t *>(b) + original_dim);
+
+  float qa = a_tail[0];
+  float qb = a_tail[1];
+  float qs = a_tail[2];
+
+  float ma = b_tail[0];
+  float mb = b_tail[1];
+  float ms = b_tail[2];
+
+  *distance =
+      -(ma * qa * *distance + mb * qa * qs + qb * ma * ms + d * qb * mb);
+#else
+  (void)a;
+  (void)b;
+  (void)dim;
+  (void)distance;
+#endif  //__AVX2__
+}
+
+// Batch version of inner_product_int4_distance.
+void inner_product_int4_batch_distance(const void *const *vectors,
+                                       const void *query, size_t n, size_t dim,
+                                       float *distances) {
+#if defined(__AVX2__)
+  internal::inner_product_int4_batch_avx2(vectors, query, n, dim, distances);
+#else
+  (void)vectors;
+  (void)query;
+  (void)n;
+  (void)dim;
+  (void)distances;
+#endif  //__AVX2__
+}
+
+}  // namespace zvec::turbo::avx2
\ No newline at end of file
diff --git a/src/turbo/distance/avx2/record_quantized_int4/inner_product.h b/src/turbo/distance/avx2/record_quantized_int4/inner_product.h
new file mode 100644
index 000000000..0e9e69d63
--- /dev/null
+++ b/src/turbo/distance/avx2/record_quantized_int4/inner_product.h
@@ -0,0 +1,31 @@
+// Copyright 2025-present the zvec project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#pragma once
+
+#include <cstddef>
+
+namespace zvec::turbo::avx2 {
+
+// Compute inner product distance between a single quantized INT4
+// vector pair.
+void inner_product_int4_distance(const void *a, const void *b, size_t dim,
+                                 float *distance);
+
+// Batch version of inner_product_int4_distance.
+void inner_product_int4_batch_distance(const void *const *vectors,
+                                       const void *query, size_t n, size_t dim,
+                                       float *distances);
+
+}  // namespace zvec::turbo::avx2
diff --git a/src/turbo/distance/avx2/record_quantized_int4/inner_product_common.h b/src/turbo/distance/avx2/record_quantized_int4/inner_product_common.h
new file mode 100644
index 000000000..8c96f5fb0
--- /dev/null
+++ b/src/turbo/distance/avx2/record_quantized_int4/inner_product_common.h
@@ -0,0 +1,250 @@
+// Copyright 2025-present the zvec project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#pragma once
+
+#if defined(__AVX2__)
+#include <immintrin.h>
+#include <array>
+#include <cstdint>
+#include <zvec/ailego/internal/platform.h>
+
+namespace zvec::turbo::avx2::internal {
+
+
+/*! Four-bits Integer Multiplication Table
+ */
+static const AILEGO_ALIGNED(64) int8_t Int4MulTable[256] = {
+    0, 0,  0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+    0, 1,  2,   3,   4,   5,   6,   7,   -8,  -7,  -6,  -5,  -4,  -3,  -2,  -1,
+    0, 2,  4,   6,   8,   10,  12,  14,  -16, -14, -12, -10, -8,  -6,  -4,  -2,
+    0, 3,  6,   9,   12,  15,  18,  21,  -24, -21, -18, -15, -12, -9,  -6,  -3,
+    0, 4,  8,   12,  16,  20,  24,  28,  -32, -28, -24, -20, -16, -12, -8,  -4,
+    0, 5,  10,  15,  20,  25,  30,  35,  -40, -35, -30, -25, -20, -15, -10, -5,
+    0, 6,  12,  18,  24,  30,  36,  42,  -48, -42, -36, -30, -24, -18, -12, -6,
+    0, 7,  14,  21,  28,  35,  42,  49,  -56, -49, -42, -35, -28, -21, -14, -7,
+    0, -8, -16, -24, -32, -40, -48, -56, 64,  56,  48,  40,  32,  24,  16,  8,
+    0, -7, -14, -21, -28, -35, -42, -49, 56,  49,  42,  35,  28,  21,  14,  7,
+    0, -6, -12, -18, -24, -30, -36, -42, 48,  42,  36,  30,  24,  18,  12,  6,
+    0, -5, -10, -15, -20, -25, -30, -35, 40,  35,  30,  25,  20,  15,  10,  5,
+    0, -4, -8,  -12, -16, -20, -24, -28, 32,  28,  24,  20,  16,  12,  8,   4,
+    0, -3, -6,  -9,  -12, -15, -18, -21, 24,  21,  18,  15,  12,  9,   6,   3,
+    0, -2, -4,  -6,  -8,  -10, -12, -14, 16,  14,  12,  10,  8,   6,   4,   2,
+    0, -1, -2,  -3,  -4,  -5,  -6,  -7,  8,   7,   6,   5,   4,   3,   2,   1,
+};
+
+//! Calculate Fused-Multiply-Add (GENERAL)
+#define FMA_INT4_GENERAL(m, q, sum)                               \
+  sum += Int4MulTable[(((m) << 4) & 0xf0) | (((q) >> 0) & 0xf)] + \
+         Int4MulTable[(((m) >> 0) & 0xf0) | (((q) >> 4) & 0xf)];
+
+static inline int32_t HorizontalAdd_INT32_V256(__m256i v) {
+  __m256i x1 = _mm256_hadd_epi32(v, v);
+  __m256i x2 = _mm256_hadd_epi32(x1, x1);
+  __m128i x3 = _mm256_extractf128_si256(x2, 1);
+  __m128i x4 = _mm_add_epi32(_mm256_castsi256_si128(x2), x3);
+  return _mm_cvtsi128_si32(x4);
+}
+
+#define MASK_INT4_SSE _mm_set1_epi32(0x0f0f0f0f)
+#define ONES_INT16_SSE _mm_set1_epi32(0x00010001)
+
+#define MASK_INT4_AVX _mm256_set1_epi32(0xf0f0f0f0)
+#define ONES_INT16_AVX _mm256_set1_epi32(0x00010001)
+
+static const AILEGO_ALIGNED(32) int8_t Int4ConvertTable[32] = {
+    0, 1, 2, 3, 4, 5, 6, 7, -8, -7, -6, -5, -4, -3, -2, -1,
+    0, 1, 2, 3, 4, 5, 6, 7, -8, -7, -6, -5, -4, -3, -2, -1};
+
+#define INT4_LOOKUP_AVX _mm256_load_si256((const __m256i *)Int4ConvertTable)
+
+#define INT4_LOOKUP_AVX _mm256_load_si256((const __m256i *)Int4ConvertTable)
+
+#define INT4_LOOKUP_SSE _mm_load_si128((const __m128i *)Int4ConvertTable)
+
+//! Compute the distance between matrix and query
+#define FMA_INT4_ITER_SSE(xmm_lhs, xmm_rhs, xmm_sum)                       \
+  {                                                                        \
+    __m128i xmm_lhs_0 = _mm_shuffle_epi8(                                  \
+        INT4_LOOKUP_SSE, _mm_and_si128((xmm_lhs), MASK_INT4_SSE));         \
+    __m128i xmm_rhs_0 = _mm_shuffle_epi8(                                  \
+        INT4_LOOKUP_SSE, _mm_and_si128((xmm_rhs), MASK_INT4_SSE));         \
+    __m128i xmm_lhs_1 = _mm_shuffle_epi8(                                  \
+        INT4_LOOKUP_SSE,                                                   \
+        _mm_and_si128(_mm_srli_epi32((xmm_lhs), 4), MASK_INT4_SSE));       \
+    __m128i xmm_rhs_1 = _mm_shuffle_epi8(                                  \
+        INT4_LOOKUP_SSE,                                                   \
+        _mm_and_si128(_mm_srli_epi32((xmm_rhs), 4), MASK_INT4_SSE));       \
+    xmm_lhs_0 = _mm_sign_epi8(xmm_lhs_0, xmm_rhs_0);                       \
+    xmm_lhs_1 = _mm_sign_epi8(xmm_lhs_1, xmm_rhs_1);                       \
+    xmm_rhs_0 = _mm_abs_epi8(xmm_rhs_0);                                   \
+    xmm_rhs_1 = _mm_abs_epi8(xmm_rhs_1);                                   \
+    xmm_lhs_0 = _mm_madd_epi16(_mm_maddubs_epi16(xmm_rhs_0, xmm_lhs_0),    \
+                               ONES_INT16_SSE);                            \
+    xmm_lhs_1 = _mm_madd_epi16(_mm_maddubs_epi16(xmm_rhs_1, xmm_lhs_1),    \
+                               ONES_INT16_SSE);                            \
+    xmm_sum = _mm_add_epi32(_mm_add_epi32(xmm_lhs_0, xmm_lhs_1), xmm_sum); \
+  }
+
+#define FMA_INT4_ITER_AVX(ymm_lhs, ymm_rhs, ymm_sum)                          \
+  {                                                                           \
+    __m256i ymm_lhs_0 = _mm256_shuffle_epi8(                                  \
+        INT4_LOOKUP_AVX, _mm256_and_si256((ymm_lhs), MASK_INT4_AVX));         \
+    __m256i ymm_rhs_0 = _mm256_shuffle_epi8(                                  \
+        INT4_LOOKUP_AVX, _mm256_and_si256((ymm_rhs), MASK_INT4_AVX));         \
+    __m256i ymm_lhs_1 = _mm256_shuffle_epi8(                                  \
+        INT4_LOOKUP_AVX,                                                      \
+        _mm256_and_si256(_mm256_srli_epi32((ymm_lhs), 4), MASK_INT4_AVX));    \
+    __m256i ymm_rhs_1 = _mm256_shuffle_epi8(                                  \
+        INT4_LOOKUP_AVX,                                                      \
+        _mm256_and_si256(_mm256_srli_epi32((ymm_rhs), 4), MASK_INT4_AVX));    \
+    ymm_lhs_0 = _mm256_sign_epi8(ymm_lhs_0, ymm_rhs_0);                       \
+    ymm_lhs_1 = _mm256_sign_epi8(ymm_lhs_1, ymm_rhs_1);                       \
+    ymm_rhs_0 = _mm256_abs_epi8(ymm_rhs_0);                                   \
+    ymm_rhs_1 = _mm256_abs_epi8(ymm_rhs_1);                                   \
+    ymm_lhs_0 = _mm256_madd_epi16(_mm256_maddubs_epi16(ymm_rhs_0, ymm_lhs_0), \
+                                  ONES_INT16_AVX);                            \
+    ymm_lhs_1 = _mm256_madd_epi16(_mm256_maddubs_epi16(ymm_rhs_1, ymm_lhs_1), \
+                                  ONES_INT16_AVX);                            \
+    ymm_sum =                                                                 \
+        _mm256_add_epi32(_mm256_add_epi32(ymm_lhs_0, ymm_lhs_1), ymm_sum);    \
+  }
+
+#if defined(__SSE2__)
+static inline int32_t HorizontalAdd_INT32_V128(__m128i v) {
+#ifdef __SSE3__
+  __m128i x1 = _mm_hadd_epi32(v, v);
+  __m128i x2 = _mm_hadd_epi32(x1, x1);
+  return _mm_cvtsi128_si32(x2);
+#else
+  __m128i x1 = _mm_shuffle_epi32(v, _MM_SHUFFLE(0, 0, 3, 2));
+  __m128i x2 = _mm_add_epi32(v, x1);
+  __m128i x3 = _mm_shuffle_epi32(x2, _MM_SHUFFLE(0, 0, 0, 1));
+  __m128i x4 = _mm_add_epi32(x2, x3);
+  return _mm_cvtsi128_si32(x4);
+#endif
+}
+#endif  // __SSE2__
+
+//! Compute the distance between matrix and query
+static __attribute__((always_inline)) void inner_product_int4_avx2(
+    const void *a, const void *b, size_t size, float *distance) {
+  const uint8_t *lhs = reinterpret_cast<const uint8_t *>(a);
+  const uint8_t *rhs = reinterpret_cast<const uint8_t *>(b);
+  const uint8_t *last = lhs + size;
+  const uint8_t *last_aligned = lhs + ((size >> 4) << 4);
+  __m128i xmm_sum = _mm_setzero_si128();
+
+  if (((uintptr_t)lhs & 0xf) == 0 && ((uintptr_t)rhs & 0xf) == 0) {
+    for (; lhs != last_aligned; lhs += 16, rhs += 16) {
+      __m128i xmm_lhs = _mm_load_si128((const __m128i *)(lhs));
+      __m128i xmm_rhs = _mm_load_si128((const __m128i *)(rhs));
+      FMA_INT4_ITER_SSE(xmm_lhs, xmm_rhs, xmm_sum)
+    }
+  } else {
+    for (; lhs != last_aligned; lhs += 16, rhs += 16) {
+      __m128i xmm_lhs = _mm_loadu_si128((const __m128i *)(lhs));
+      __m128i xmm_rhs = _mm_loadu_si128((const __m128i *)(rhs));
+      FMA_INT4_ITER_SSE(xmm_lhs, xmm_rhs, xmm_sum)
+    }
+  }
+  float result = static_cast<float>(HorizontalAdd_INT32_V128(xmm_sum));
+
+  switch (last - lhs) {
+    case 15:
+      FMA_INT4_GENERAL(lhs[14], rhs[14], result)
+      /* FALLTHRU */
+    case 14:
+      FMA_INT4_GENERAL(lhs[13], rhs[13], result)
+      /* FALLTHRU */
+    case 13:
+      FMA_INT4_GENERAL(lhs[12], rhs[12], result)
+      /* FALLTHRU */
+    case 12:
+      FMA_INT4_GENERAL(lhs[11], rhs[11], result)
+      /* FALLTHRU */
+    case 11:
+      FMA_INT4_GENERAL(lhs[10], rhs[10], result)
+      /* FALLTHRU */
+    case 10:
+      FMA_INT4_GENERAL(lhs[9], rhs[9], result)
+      /* FALLTHRU */
+    case 9:
+      FMA_INT4_GENERAL(lhs[8], rhs[8], result)
+      /* FALLTHRU */
+    case 8:
+      FMA_INT4_GENERAL(lhs[7], rhs[7], result)
+      /* FALLTHRU */
+    case 7:
+      FMA_INT4_GENERAL(lhs[6], rhs[6], result)
+      /* FALLTHRU */
+    case 6:
+      FMA_INT4_GENERAL(lhs[5], rhs[5], result)
+      /* FALLTHRU */
+    case 5:
+      FMA_INT4_GENERAL(lhs[4], rhs[4], result)
+      /* FALLTHRU */
+    case 4:
+      FMA_INT4_GENERAL(lhs[3], rhs[3], result)
+      /* FALLTHRU */
+    case 3:
+      FMA_INT4_GENERAL(lhs[2], rhs[2], result)
+      /* FALLTHRU */
+    case 2:
+      FMA_INT4_GENERAL(lhs[1], rhs[1], result)
+      /* FALLTHRU */
+    case 1:
+      FMA_INT4_GENERAL(lhs[0], rhs[0], result)
+  }
+
+  *distance = result;
+}
+
+// Compute raw integer inner products for a batch of int8 vectors against a
+// single query. Uses AVX512-VNNI dpbusd instruction.
+// `query` is treated as uint8 (preprocessed), `vectors[i]` as int8.
+template <size_t batch_size>
+__attribute__((always_inline)) void inner_product_int4_batch_avx2_impl(
+    const void *query, const void *const *vectors,
+    const std::array<const void *, batch_size> &prefetch_ptrs,
+    size_t dimensionality, float *distances) {}
+
+static __attribute__((always_inline)) void inner_product_int4_batch_avx2(
+    const void *const *vectors, const void *query, size_t n, size_t dim,
+    float *distances) {
+  static constexpr size_t batch_size = 2;
+  static constexpr size_t prefetch_step = 2;
+  size_t i = 0;
+  for (; i + batch_size <= n; i += batch_size) {
+    std::array<const void *, batch_size> prefetch_ptrs;
+    for (size_t j = 0; j < batch_size; ++j) {
+      if (i + j + batch_size * prefetch_step < n) {
+        prefetch_ptrs[j] = vectors[i + j + batch_size * prefetch_step];
+      } else {
+        prefetch_ptrs[j] = nullptr;
+      }
+    }
+    inner_product_int4_batch_avx2_impl<batch_size>(
+        query, &vectors[i], prefetch_ptrs, dim, distances + i);
+  }
+  for (; i < n; i++) {
+    std::array<const void *, 1> prefetch_ptrs{nullptr};
+    inner_product_int4_batch_avx2_impl<1>(query, &vectors[i], prefetch_ptrs,
+                                          dim, distances + i);
+  }
+}
+
+}  // namespace zvec::turbo::avx2::internal
+
+#endif  // defined(__AVX2__)
diff --git a/src/turbo/distance/avx2/record_quantized_int4/squared_euclidean.cc b/src/turbo/distance/avx2/record_quantized_int4/squared_euclidean.cc
new file mode 100644
index 000000000..17aabf385
--- /dev/null
+++ b/src/turbo/distance/avx2/record_quantized_int4/squared_euclidean.cc
@@ -0,0 +1,111 @@
+// Copyright 2025-present the zvec project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "avx2/record_quantized_int4/squared_euclidean.h"
+#include "avx2/record_quantized_int4/inner_product_common.h"
+
+#if defined(__AVX2__)
+#include <immintrin.h>
+#endif
+
+namespace zvec::turbo::avx2 {
+
+void squared_euclidean_int4_distance(const void *a, const void *b, size_t dim,
+                                     float *distance) {
+#if defined(__AVX2__)
+  const int d = dim;
+  const size_t original_dim = d >> 1;
+
+  if (original_dim <= 0) {
+    return;
+  }
+
+  internal::inner_product_int4_avx2(a, b, original_dim, distance);
+
+  const float *a_tail = reinterpret_cast<const float *>(
+      reinterpret_cast<const uint8_t *>(a) + original_dim);
+  const float *b_tail = reinterpret_cast<const float *>(
+      reinterpret_cast<const uint8_t *>(b) + original_dim);
+
+  float qa = a_tail[0];
+  float qb = a_tail[1];
+  float qs = a_tail[2];
+  float qs2 = a_tail[3];
+
+  const float sum = qa * qs;
+  const float sum2 = qa * qa * qs2;
+
+  float ma = b_tail[0];
+  float mb = b_tail[1];
+  float ms = b_tail[2];
+  float ms2 = b_tail[3];
+
+  *distance = ma * ma * ms2 + sum2 - 2 * ma * qa * *distance +
+              (mb - qb) * (mb - qb) * d + 2 * (mb - qb) * (ms * ma - sum);
+#else
+  (void)a;
+  (void)b;
+  (void)dim;
+  (void)distance;
+#endif  // __AVX2__
+}
+
+void squared_euclidean_int4_batch_distance(const void *const *vectors,
+                                           const void *query, size_t n,
+                                           size_t dim, float *distances) {
+#if defined(__AVX2__)
+  const int d = dim;
+  const size_t original_dim = d >> 1;
+
+  if (original_dim <= 0) {
+    return;
+  }
+
+  internal::inner_product_int4_batch_avx2(vectors, query, n, original_dim,
+                                          distances);
+
+  const float *q_tail = reinterpret_cast<const float *>(
+      reinterpret_cast<const int8_t *>(query) + original_dim);
+
+  float qa = q_tail[0];
+  float qb = q_tail[1];
+  float qs = q_tail[2];
+  float qs2 = q_tail[3];
+
+  const float sum = qa * qs;
+  const float sum2 = qa * qa * qs2;
+
+  for (int i = 0; i < n; ++i) {
+    const float *m_tail = reinterpret_cast<const float *>(
+        reinterpret_cast<const int8_t *>(vectors[i]) + original_dim);
+
+    float ma = m_tail[0];
+    float mb = m_tail[1];
+    float ms = m_tail[2];
+    float ms2 = m_tail[3];
+
+    float &result = distances[i];
+    result = ma * ma * ms2 + sum2 - 2 * ma * qa * result +
+             (mb - qb) * (mb - qb) * d + 2 * (mb - qb) * (ms * ma - sum);
+  }
+#else
+  (void)vectors;
+  (void)query;
+  (void)n;
+  (void)dim;
+  (void)distances;
+#endif  //__AVX2__
+}
+
+}  // namespace zvec::turbo::avx2
\ No newline at end of file
diff --git a/src/turbo/distance/avx2/record_quantized_int4/squared_euclidean.h b/src/turbo/distance/avx2/record_quantized_int4/squared_euclidean.h
new file mode 100644
index 000000000..b6d15f698
--- /dev/null
+++ b/src/turbo/distance/avx2/record_quantized_int4/squared_euclidean.h
@@ -0,0 +1,31 @@
+// Copyright 2025-present the zvec project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#pragma once
+
+#include <cstddef>
+
+namespace zvec::turbo::avx2 {
+
+// Compute squared euclidean distance between a single quantized INT4
+// vector pair.
+void squared_euclidean_int4_distance(const void *a, const void *b, size_t dim,
+                                     float *distance);
+
+// Batch version of squared euclidean  INT4.
+void squared_euclidean_int4_batch_distance(const void *const *vectors,
+                                           const void *query, size_t n,
+                                           size_t dim, float *distances);
+
+}  // namespace zvec::turbo::avx2
diff --git a/src/turbo/distance/avx2/record_quantized_int8/cosine.cc b/src/turbo/distance/avx2/record_quantized_int8/cosine.cc
new file mode 100644
index 000000000..73de456b3
--- /dev/null
+++ b/src/turbo/distance/avx2/record_quantized_int8/cosine.cc
@@ -0,0 +1,69 @@
+// Copyright 2025-present the zvec project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "avx2/record_quantized_int8/cosine.h"
+#include "avx2/record_quantized_int8/inner_product_common.h"
+#if defined(__AVX2__)
+#include <immintrin.h>
+#endif
+
+namespace zvec::turbo::avx2 {
+
+void cosine_int8_distance(const void *a, const void *b, size_t dim,
+                          float *distance) {
+#if defined(__AVX2__)
+  const int original_dim = dim;
+  if (original_dim <= 0) {
+    return;
+  }
+
+  internal::inner_product_int8_avx2(a, b, original_dim, distance);
+
+  const float *a_tail = reinterpret_cast<const float *>(
+      reinterpret_cast<const int8_t *>(a) + original_dim);
+  const float *b_tail = reinterpret_cast<const float *>(
+      reinterpret_cast<const int8_t *>(b) + original_dim);
+
+  float qa = a_tail[0];
+  float qb = a_tail[1];
+  float qs = a_tail[2];
+
+  float ma = b_tail[0];
+  float mb = b_tail[1];
+  float ms = b_tail[2];
+
+  *distance = -(ma * qa * *distance + mb * qa * qs + qb * ma * ms +
+                static_cast<float>(original_dim) * qb * mb);
+#else
+  (void)a;
+  (void)b;
+  (void)dim;
+  (void)distance;
+#endif  // __AVX2__
+}
+
+void cosine_int8_batch_distance(const void *const *vectors, const void *query,
+                                size_t n, size_t dim, float *distances) {
+#if defined(__AVX2__)
+
+#else
+  (void)vectors;
+  (void)query;
+  (void)n;
+  (void)dim;
+  (void)distances;
+#endif  //__AVX2__
+}
+
+}  // namespace zvec::turbo::avx2
\ No newline at end of file
diff --git a/src/turbo/distance/avx2/record_quantized_int8/cosine.h b/src/turbo/distance/avx2/record_quantized_int8/cosine.h
new file mode 100644
index 000000000..6074ea428
--- /dev/null
+++ b/src/turbo/distance/avx2/record_quantized_int8/cosine.h
@@ -0,0 +1,30 @@
+// Copyright 2025-present the zvec project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#pragma once
+
+#include <cstddef>
+
+namespace zvec::turbo::avx2 {
+
+// Compute cosine distance (negative inner product after normalization) between
+// a single quantized int8 vector pair.
+void cosine_int8_distance(const void *a, const void *b, size_t dim,
+                          float *distance);
+
+// Batch version of cosine_int8_distance.
+void cosine_int8_batch_distance(const void *const *vectors, const void *query,
+                                size_t n, size_t dim, float *distances);
+
+}  // namespace zvec::turbo::avx2
\ No newline at end of file
diff --git a/src/turbo/distance/avx2/record_quantized_int8/inner_product.cc b/src/turbo/distance/avx2/record_quantized_int8/inner_product.cc
new file mode 100644
index 000000000..d83bbccff
--- /dev/null
+++ b/src/turbo/distance/avx2/record_quantized_int8/inner_product.cc
@@ -0,0 +1,75 @@
+// Copyright 2025-present the zvec project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "avx2/record_quantized_int8/inner_product.h"
+#include "avx2/record_quantized_int8/inner_product_common.h"
+
+#if defined(__AVX2__)
+#include <immintrin.h>
+#endif
+
+namespace zvec::turbo::avx2 {
+
+// Compute squared Euclidean distance between a single quantized int8
+// vector pair.
+void inner_product_int8_distance(const void *a, const void *b, size_t dim,
+                                 float *distance) {
+#if defined(__AVX2__)
+  const size_t original_dim = dim;
+
+  if (original_dim <= 0) {
+    return;
+  }
+
+  internal::inner_product_int8_avx2(a, b, original_dim, distance);
+
+  const float *a_tail = reinterpret_cast<const float *>(
+      reinterpret_cast<const int8_t *>(a) + original_dim);
+  const float *b_tail = reinterpret_cast<const float *>(
+      reinterpret_cast<const int8_t *>(b) + original_dim);
+
+  float qa = a_tail[0];
+  float qb = a_tail[1];
+  float qs = a_tail[2];
+
+  float ma = b_tail[0];
+  float mb = b_tail[1];
+  float ms = b_tail[2];
+
+  *distance = -(ma * qa * *distance + mb * qa * qs + qb * ma * ms +
+                original_dim * qb * mb);
+#else
+  (void)a;
+  (void)b;
+  (void)dim;
+  (void)distance;
+#endif  //__AVX2__
+}
+
+// Batch version of inner_product_int8_distance.
+void inner_product_int8_batch_distance(const void *const *vectors,
+                                       const void *query, size_t n, size_t dim,
+                                       float *distances) {
+#if defined(__AVX2__)
+
+#else
+  (void)vectors;
+  (void)query;
+  (void)n;
+  (void)dim;
+  (void)distances;
+#endif  //__AVX2__
+}
+
+}  // namespace zvec::turbo::avx2
\ No newline at end of file
diff --git a/src/turbo/distance/avx2/record_quantized_int8/inner_product.h b/src/turbo/distance/avx2/record_quantized_int8/inner_product.h
new file mode 100644
index 000000000..249bafd00
--- /dev/null
+++ b/src/turbo/distance/avx2/record_quantized_int8/inner_product.h
@@ -0,0 +1,31 @@
+// Copyright 2025-present the zvec project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#pragma once
+
+#include <cstddef>
+
+namespace zvec::turbo::avx2 {
+
+// Compute inner product distance between a single quantized int8
+// vector pair.
+void inner_product_int8_distance(const void *a, const void *b, size_t dim,
+                                 float *distance);
+
+// Batch version of inner_product_int8_distance.
+void inner_product_int8_batch_distance(const void *const *vectors,
+                                       const void *query, size_t n, size_t dim,
+                                       float *distances);
+
+}  // namespace zvec::turbo::avx2
diff --git a/src/turbo/distance/avx2/record_quantized_int8/inner_product_common.h b/src/turbo/distance/avx2/record_quantized_int8/inner_product_common.h
new file mode 100644
index 000000000..0176f277a
--- /dev/null
+++ b/src/turbo/distance/avx2/record_quantized_int8/inner_product_common.h
@@ -0,0 +1,236 @@
+// Copyright 2025-present the zvec project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#pragma once
+
+#if defined(__AVX2__)
+#include <immintrin.h>
+#include <array>
+#include <cstdint>
+#include <zvec/ailego/internal/platform.h>
+
+namespace zvec::turbo::avx2::internal {
+
+#define ONES_INT16_SSE _mm_set1_epi32(0x00010001)
+#define ONES_INT16_AVX _mm256_set1_epi32(0x00010001)
+
+//! Calculate Fused-Multiply-Add (GENERAL)
+#define FMA_INT8_GENERAL(m, q, sum) sum += static_cast<float>(m * q);
+
+static inline int32_t HorizontalAdd_INT32_V256(__m256i v) {
+  __m256i x1 = _mm256_hadd_epi32(v, v);
+  __m256i x2 = _mm256_hadd_epi32(x1, x1);
+  __m128i x3 = _mm256_extractf128_si256(x2, 1);
+  __m128i x4 = _mm_add_epi32(_mm256_castsi256_si128(x2), x3);
+  return _mm_cvtsi128_si32(x4);
+}
+
+static __attribute__((always_inline)) void inner_product_int8_avx2(
+    const void *a, const void *b, size_t size, float *distance) {
+  const int8_t *lhs = reinterpret_cast<const int8_t *>(a);
+  const int8_t *rhs = reinterpret_cast<const int8_t *>(b);
+
+  const int8_t *last = lhs + size;
+  const int8_t *last_aligned = lhs + ((size >> 6) << 6);
+  float result = 0.0;
+
+  __m256i ymm_sum_0 = _mm256_setzero_si256();
+  __m256i ymm_sum_1 = _mm256_setzero_si256();
+
+  if (((uintptr_t)lhs & 0x1f) == 0 && ((uintptr_t)rhs & 0x1f) == 0) {
+    for (; lhs != last_aligned; lhs += 64, rhs += 64) {
+      __m256i ymm_lhs_0 = _mm256_load_si256((const __m256i *)(lhs + 0));
+      __m256i ymm_lhs_1 = _mm256_load_si256((const __m256i *)(lhs + 32));
+      __m256i ymm_rhs_0 = _mm256_load_si256((const __m256i *)(rhs + 0));
+      __m256i ymm_rhs_1 = _mm256_load_si256((const __m256i *)(rhs + 32));
+
+      ymm_lhs_0 = _mm256_sign_epi8(ymm_lhs_0, ymm_rhs_0);
+      ymm_lhs_1 = _mm256_sign_epi8(ymm_lhs_1, ymm_rhs_1);
+      ymm_rhs_0 = _mm256_abs_epi8(ymm_rhs_0);
+      ymm_rhs_1 = _mm256_abs_epi8(ymm_rhs_1);
+
+      ymm_sum_0 = _mm256_add_epi32(
+          _mm256_madd_epi16(_mm256_maddubs_epi16(ymm_rhs_0, ymm_lhs_0),
+                            ONES_INT16_AVX),
+          ymm_sum_0);
+      ymm_sum_1 = _mm256_add_epi32(
+          _mm256_madd_epi16(_mm256_maddubs_epi16(ymm_rhs_1, ymm_lhs_1),
+                            ONES_INT16_AVX),
+          ymm_sum_1);
+    }
+
+    if (last >= last_aligned + 32) {
+      __m256i ymm_lhs = _mm256_load_si256((const __m256i *)lhs);
+      __m256i ymm_rhs = _mm256_load_si256((const __m256i *)rhs);
+      ymm_lhs = _mm256_sign_epi8(ymm_lhs, ymm_rhs);
+      ymm_rhs = _mm256_abs_epi8(ymm_rhs);
+      ymm_sum_0 = _mm256_add_epi32(
+          _mm256_madd_epi16(_mm256_maddubs_epi16(ymm_rhs, ymm_lhs),
+                            ONES_INT16_AVX),
+          ymm_sum_0);
+      lhs += 32;
+      rhs += 32;
+    }
+
+    if (last >= lhs + 16) {
+      __m128i xmm_lhs = _mm_load_si128((const __m128i *)lhs);
+      __m128i xmm_rhs = _mm_load_si128((const __m128i *)rhs);
+      xmm_lhs = _mm_sign_epi8(xmm_lhs, xmm_rhs);
+      xmm_rhs = _mm_abs_epi8(xmm_rhs);
+      ymm_sum_0 = _mm256_add_epi32(
+          _mm256_set_m128i(_mm_setzero_si128(),
+                           _mm_madd_epi16(_mm_maddubs_epi16(xmm_rhs, xmm_lhs),
+                                          ONES_INT16_SSE)),
+          ymm_sum_0);
+      lhs += 16;
+      rhs += 16;
+    }
+  } else {
+    for (; lhs != last_aligned; lhs += 64, rhs += 64) {
+      __m256i ymm_lhs_0 = _mm256_loadu_si256((const __m256i *)(lhs + 0));
+      __m256i ymm_lhs_1 = _mm256_loadu_si256((const __m256i *)(lhs + 32));
+      __m256i ymm_rhs_0 = _mm256_loadu_si256((const __m256i *)(rhs + 0));
+      __m256i ymm_rhs_1 = _mm256_loadu_si256((const __m256i *)(rhs + 32));
+
+      ymm_lhs_0 = _mm256_sign_epi8(ymm_lhs_0, ymm_rhs_0);
+      ymm_lhs_1 = _mm256_sign_epi8(ymm_lhs_1, ymm_rhs_1);
+      ymm_rhs_0 = _mm256_abs_epi8(ymm_rhs_0);
+      ymm_rhs_1 = _mm256_abs_epi8(ymm_rhs_1);
+
+      ymm_sum_0 = _mm256_add_epi32(
+          _mm256_madd_epi16(_mm256_maddubs_epi16(ymm_rhs_0, ymm_lhs_0),
+                            ONES_INT16_AVX),
+          ymm_sum_0);
+      ymm_sum_1 = _mm256_add_epi32(
+          _mm256_madd_epi16(_mm256_maddubs_epi16(ymm_rhs_1, ymm_lhs_1),
+                            ONES_INT16_AVX),
+          ymm_sum_1);
+    }
+
+    if (last >= last_aligned + 32) {
+      __m256i ymm_lhs = _mm256_loadu_si256((const __m256i *)lhs);
+      __m256i ymm_rhs = _mm256_loadu_si256((const __m256i *)rhs);
+      ymm_lhs = _mm256_sign_epi8(ymm_lhs, ymm_rhs);
+      ymm_rhs = _mm256_abs_epi8(ymm_rhs);
+      ymm_sum_0 = _mm256_add_epi32(
+          _mm256_madd_epi16(_mm256_maddubs_epi16(ymm_rhs, ymm_lhs),
+                            ONES_INT16_AVX),
+          ymm_sum_0);
+      lhs += 32;
+      rhs += 32;
+    }
+
+    if (last >= lhs + 16) {
+      __m128i xmm_lhs = _mm_loadu_si128((const __m128i *)lhs);
+      __m128i xmm_rhs = _mm_loadu_si128((const __m128i *)rhs);
+      xmm_lhs = _mm_sign_epi8(xmm_lhs, xmm_rhs);
+      xmm_rhs = _mm_abs_epi8(xmm_rhs);
+      ymm_sum_0 = _mm256_add_epi32(
+          _mm256_set_m128i(_mm_setzero_si128(),
+                           _mm_madd_epi16(_mm_maddubs_epi16(xmm_rhs, xmm_lhs),
+                                          ONES_INT16_SSE)),
+          ymm_sum_0);
+      lhs += 16;
+      rhs += 16;
+    }
+  }
+  result = static_cast<float>(
+      HorizontalAdd_INT32_V256(_mm256_add_epi32(ymm_sum_0, ymm_sum_1)));
+
+  switch (last - lhs) {
+    case 15:
+      FMA_INT8_GENERAL(lhs[14], rhs[14], result)
+      /* FALLTHRU */
+    case 14:
+      FMA_INT8_GENERAL(lhs[13], rhs[13], result)
+      /* FALLTHRU */
+    case 13:
+      FMA_INT8_GENERAL(lhs[12], rhs[12], result)
+      /* FALLTHRU */
+    case 12:
+      FMA_INT8_GENERAL(lhs[11], rhs[11], result)
+      /* FALLTHRU */
+    case 11:
+      FMA_INT8_GENERAL(lhs[10], rhs[10], result)
+      /* FALLTHRU */
+    case 10:
+      FMA_INT8_GENERAL(lhs[9], rhs[9], result)
+      /* FALLTHRU */
+    case 9:
+      FMA_INT8_GENERAL(lhs[8], rhs[8], result)
+      /* FALLTHRU */
+    case 8:
+      FMA_INT8_GENERAL(lhs[7], rhs[7], result)
+      /* FALLTHRU */
+    case 7:
+      FMA_INT8_GENERAL(lhs[6], rhs[6], result)
+      /* FALLTHRU */
+    case 6:
+      FMA_INT8_GENERAL(lhs[5], rhs[5], result)
+      /* FALLTHRU */
+    case 5:
+      FMA_INT8_GENERAL(lhs[4], rhs[4], result)
+      /* FALLTHRU */
+    case 4:
+      FMA_INT8_GENERAL(lhs[3], rhs[3], result)
+      /* FALLTHRU */
+    case 3:
+      FMA_INT8_GENERAL(lhs[2], rhs[2], result)
+      /* FALLTHRU */
+    case 2:
+      FMA_INT8_GENERAL(lhs[1], rhs[1], result)
+      /* FALLTHRU */
+    case 1:
+      FMA_INT8_GENERAL(lhs[0], rhs[0], result)
+  }
+
+  *distance = result;
+}
+
+template <size_t batch_size>
+__attribute__((always_inline)) void inner_product_int8_batch_avx2_impl(
+    const void *query, const void *const *vectors,
+    const std::array<const void *, batch_size> &prefetch_ptrs,
+    size_t dimensionality, float *distances) {
+  // TBD
+}
+
+static __attribute__((always_inline)) void inner_product_int8_batch_avx2(
+    const void *const *vectors, const void *query, size_t n, size_t dim,
+    float *distances) {
+  static constexpr size_t batch_size = 2;
+  static constexpr size_t prefetch_step = 2;
+  size_t i = 0;
+  for (; i + batch_size <= n; i += batch_size) {
+    std::array<const void *, batch_size> prefetch_ptrs;
+    for (size_t j = 0; j < batch_size; ++j) {
+      if (i + j + batch_size * prefetch_step < n) {
+        prefetch_ptrs[j] = vectors[i + j + batch_size * prefetch_step];
+      } else {
+        prefetch_ptrs[j] = nullptr;
+      }
+    }
+    inner_product_int8_batch_avx2_impl<batch_size>(
+        query, &vectors[i], prefetch_ptrs, dim, distances + i);
+  }
+  for (; i < n; i++) {
+    std::array<const void *, 1> prefetch_ptrs{nullptr};
+    inner_product_int8_batch_avx2_impl<1>(query, &vectors[i], prefetch_ptrs,
+                                          dim, distances + i);
+  }
+}
+
+}  // namespace zvec::turbo::avx2::internal
+
+#endif  // defined(__AVX2__)
diff --git a/src/turbo/distance/avx2/record_quantized_int8/squared_euclidean.cc b/src/turbo/distance/avx2/record_quantized_int8/squared_euclidean.cc
new file mode 100644
index 000000000..425f5f788
--- /dev/null
+++ b/src/turbo/distance/avx2/record_quantized_int8/squared_euclidean.cc
@@ -0,0 +1,76 @@
+// Copyright 2025-present the zvec project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "avx2/record_quantized_int8/squared_euclidean.h"
+#include "avx2/record_quantized_int8/inner_product_common.h"
+
+#if defined(__AVX2__)
+#include <immintrin.h>
+#endif
+
+namespace zvec::turbo::avx2 {
+
+void squared_euclidean_int8_distance(const void *a, const void *b, size_t dim,
+                                     float *distance) {
+#if defined(__AVX2__)
+  const int original_dim = dim;
+  if (original_dim <= 0) {
+    return;
+  }
+  internal::inner_product_int8_avx2(a, b, original_dim, distance);
+
+  const float *a_tail = reinterpret_cast<const float *>(
+      reinterpret_cast<const int8_t *>(a) + original_dim);
+  const float *b_tail = reinterpret_cast<const float *>(
+      reinterpret_cast<const int8_t *>(b) + original_dim);
+
+  float ma = a_tail[0];
+  float mb = a_tail[1];
+  float ms = a_tail[2];
+  float ms2 = a_tail[3];
+
+  float qa = b_tail[0];
+  float qb = b_tail[1];
+  float qs = b_tail[2];
+  float qs2 = b_tail[3];
+
+  const float sum = qa * qs;
+  const float sum2 = qa * qa * qs2;
+
+  *distance = ma * ma * ms2 + sum2 - 2 * ma * qa * *distance +
+              (mb - qb) * (mb - qb) * original_dim +
+              2 * (mb - qb) * (ms * ma - sum);
+#else
+  (void)a;
+  (void)b;
+  (void)dim;
+  (void)distance;
+#endif  // __AVX2__
+}
+
+void squared_euclidean_int8_batch_distance(const void *const *vectors,
+                                           const void *query, size_t n,
+                                           size_t dim, float *distances) {
+#if defined(__AVX2__)
+
+#else
+  (void)vectors;
+  (void)query;
+  (void)n;
+  (void)dim;
+  (void)distances;
+#endif  //__AVX2__
+}
+
+}  // namespace zvec::turbo::avx2
\ No newline at end of file
diff --git a/src/turbo/distance/avx2/record_quantized_int8/squared_euclidean.h b/src/turbo/distance/avx2/record_quantized_int8/squared_euclidean.h
new file mode 100644
index 000000000..1bbfa6676
--- /dev/null
+++ b/src/turbo/distance/avx2/record_quantized_int8/squared_euclidean.h
@@ -0,0 +1,31 @@
+// Copyright 2025-present the zvec project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#pragma once
+
+#include <cstddef>
+
+namespace zvec::turbo::avx2 {
+
+// Compute squared euclidean distance between a single quantized INT8
+// vector pair.
+void squared_euclidean_int8_distance(const void *a, const void *b, size_t dim,
+                                     float *distance);
+
+// Batch version of squared euclidean  INT8.
+void squared_euclidean_int8_batch_distance(const void *const *vectors,
+                                           const void *query, size_t n,
+                                           size_t dim, float *distances);
+
+}  // namespace zvec::turbo::avx2
diff --git a/src/turbo/distance/avx2/record_quantized_int8/squared_euclidean_common.h b/src/turbo/distance/avx2/record_quantized_int8/squared_euclidean_common.h
new file mode 100644
index 000000000..e460ade68
--- /dev/null
+++ b/src/turbo/distance/avx2/record_quantized_int8/squared_euclidean_common.h
@@ -0,0 +1,250 @@
+// Copyright 2025-present the zvec project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#pragma once
+
+#if defined(__AVX2__)
+#include <immintrin.h>
+#include <array>
+#include <cstdint>
+#include <zvec/ailego/internal/platform.h>
+
+namespace zvec::turbo::avx2::internal {
+
+
+/*! Four-bits Integer Multiplication Table
+ */
+static const AILEGO_ALIGNED(64) int8_t Int4MulTable[256] = {
+    0, 0,  0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+    0, 1,  2,   3,   4,   5,   6,   7,   -8,  -7,  -6,  -5,  -4,  -3,  -2,  -1,
+    0, 2,  4,   6,   8,   10,  12,  14,  -16, -14, -12, -10, -8,  -6,  -4,  -2,
+    0, 3,  6,   9,   12,  15,  18,  21,  -24, -21, -18, -15, -12, -9,  -6,  -3,
+    0, 4,  8,   12,  16,  20,  24,  28,  -32, -28, -24, -20, -16, -12, -8,  -4,
+    0, 5,  10,  15,  20,  25,  30,  35,  -40, -35, -30, -25, -20, -15, -10, -5,
+    0, 6,  12,  18,  24,  30,  36,  42,  -48, -42, -36, -30, -24, -18, -12, -6,
+    0, 7,  14,  21,  28,  35,  42,  49,  -56, -49, -42, -35, -28, -21, -14, -7,
+    0, -8, -16, -24, -32, -40, -48, -56, 64,  56,  48,  40,  32,  24,  16,  8,
+    0, -7, -14, -21, -28, -35, -42, -49, 56,  49,  42,  35,  28,  21,  14,  7,
+    0, -6, -12, -18, -24, -30, -36, -42, 48,  42,  36,  30,  24,  18,  12,  6,
+    0, -5, -10, -15, -20, -25, -30, -35, 40,  35,  30,  25,  20,  15,  10,  5,
+    0, -4, -8,  -12, -16, -20, -24, -28, 32,  28,  24,  20,  16,  12,  8,   4,
+    0, -3, -6,  -9,  -12, -15, -18, -21, 24,  21,  18,  15,  12,  9,   6,   3,
+    0, -2, -4,  -6,  -8,  -10, -12, -14, 16,  14,  12,  10,  8,   6,   4,   2,
+    0, -1, -2,  -3,  -4,  -5,  -6,  -7,  8,   7,   6,   5,   4,   3,   2,   1,
+};
+
+//! Calculate Fused-Multiply-Add (GENERAL)
+#define FMA_INT4_GENERAL(m, q, sum)                               \
+  sum += Int4MulTable[(((m) << 4) & 0xf0) | (((q) >> 0) & 0xf)] + \
+         Int4MulTable[(((m) >> 0) & 0xf0) | (((q) >> 4) & 0xf)];
+
+static inline int32_t HorizontalAdd_INT32_V256(__m256i v) {
+  __m256i x1 = _mm256_hadd_epi32(v, v);
+  __m256i x2 = _mm256_hadd_epi32(x1, x1);
+  __m128i x3 = _mm256_extractf128_si256(x2, 1);
+  __m128i x4 = _mm_add_epi32(_mm256_castsi256_si128(x2), x3);
+  return _mm_cvtsi128_si32(x4);
+}
+
+#define MASK_INT4_SSE _mm_set1_epi32(0x0f0f0f0f)
+#define ONES_INT16_SSE _mm_set1_epi32(0x00010001)
+
+#define MASK_INT4_AVX _mm256_set1_epi32(0xf0f0f0f0)
+#define ONES_INT16_AVX _mm256_set1_epi32(0x00010001)
+
+static const AILEGO_ALIGNED(32) int8_t Int4ConvertTable[32] = {
+    0, 1, 2, 3, 4, 5, 6, 7, -8, -7, -6, -5, -4, -3, -2, -1,
+    0, 1, 2, 3, 4, 5, 6, 7, -8, -7, -6, -5, -4, -3, -2, -1};
+
+#define INT4_LOOKUP_AVX _mm256_load_si256((const __m256i *)Int4ConvertTable)
+
+#define INT4_LOOKUP_AVX _mm256_load_si256((const __m256i *)Int4ConvertTable)
+
+#define INT4_LOOKUP_SSE _mm_load_si128((const __m128i *)Int4ConvertTable)
+
+//! Compute the distance between matrix and query
+#define FMA_INT4_ITER_SSE(xmm_lhs, xmm_rhs, xmm_sum)                       \
+  {                                                                        \
+    __m128i xmm_lhs_0 = _mm_shuffle_epi8(                                  \
+        INT4_LOOKUP_SSE, _mm_and_si128((xmm_lhs), MASK_INT4_SSE));         \
+    __m128i xmm_rhs_0 = _mm_shuffle_epi8(                                  \
+        INT4_LOOKUP_SSE, _mm_and_si128((xmm_rhs), MASK_INT4_SSE));         \
+    __m128i xmm_lhs_1 = _mm_shuffle_epi8(                                  \
+        INT4_LOOKUP_SSE,                                                   \
+        _mm_and_si128(_mm_srli_epi32((xmm_lhs), 4), MASK_INT4_SSE));       \
+    __m128i xmm_rhs_1 = _mm_shuffle_epi8(                                  \
+        INT4_LOOKUP_SSE,                                                   \
+        _mm_and_si128(_mm_srli_epi32((xmm_rhs), 4), MASK_INT4_SSE));       \
+    xmm_lhs_0 = _mm_sign_epi8(xmm_lhs_0, xmm_rhs_0);                       \
+    xmm_lhs_1 = _mm_sign_epi8(xmm_lhs_1, xmm_rhs_1);                       \
+    xmm_rhs_0 = _mm_abs_epi8(xmm_rhs_0);                                   \
+    xmm_rhs_1 = _mm_abs_epi8(xmm_rhs_1);                                   \
+    xmm_lhs_0 = _mm_madd_epi16(_mm_maddubs_epi16(xmm_rhs_0, xmm_lhs_0),    \
+                               ONES_INT16_SSE);                            \
+    xmm_lhs_1 = _mm_madd_epi16(_mm_maddubs_epi16(xmm_rhs_1, xmm_lhs_1),    \
+                               ONES_INT16_SSE);                            \
+    xmm_sum = _mm_add_epi32(_mm_add_epi32(xmm_lhs_0, xmm_lhs_1), xmm_sum); \
+  }
+
+#define FMA_INT4_ITER_AVX(ymm_lhs, ymm_rhs, ymm_sum)                          \
+  {                                                                           \
+    __m256i ymm_lhs_0 = _mm256_shuffle_epi8(                                  \
+        INT4_LOOKUP_AVX, _mm256_and_si256((ymm_lhs), MASK_INT4_AVX));         \
+    __m256i ymm_rhs_0 = _mm256_shuffle_epi8(                                  \
+        INT4_LOOKUP_AVX, _mm256_and_si256((ymm_rhs), MASK_INT4_AVX));         \
+    __m256i ymm_lhs_1 = _mm256_shuffle_epi8(                                  \
+        INT4_LOOKUP_AVX,                                                      \
+        _mm256_and_si256(_mm256_srli_epi32((ymm_lhs), 4), MASK_INT4_AVX));    \
+    __m256i ymm_rhs_1 = _mm256_shuffle_epi8(                                  \
+        INT4_LOOKUP_AVX,                                                      \
+        _mm256_and_si256(_mm256_srli_epi32((ymm_rhs), 4), MASK_INT4_AVX));    \
+    ymm_lhs_0 = _mm256_sign_epi8(ymm_lhs_0, ymm_rhs_0);                       \
+    ymm_lhs_1 = _mm256_sign_epi8(ymm_lhs_1, ymm_rhs_1);                       \
+    ymm_rhs_0 = _mm256_abs_epi8(ymm_rhs_0);                                   \
+    ymm_rhs_1 = _mm256_abs_epi8(ymm_rhs_1);                                   \
+    ymm_lhs_0 = _mm256_madd_epi16(_mm256_maddubs_epi16(ymm_rhs_0, ymm_lhs_0), \
+                                  ONES_INT16_AVX);                            \
+    ymm_lhs_1 = _mm256_madd_epi16(_mm256_maddubs_epi16(ymm_rhs_1, ymm_lhs_1), \
+                                  ONES_INT16_AVX);                            \
+    ymm_sum =                                                                 \
+        _mm256_add_epi32(_mm256_add_epi32(ymm_lhs_0, ymm_lhs_1), ymm_sum);    \
+  }
+
+#if defined(__SSE2__)
+static inline int32_t HorizontalAdd_INT32_V128(__m128i v) {
+#ifdef __SSE3__
+  __m128i x1 = _mm_hadd_epi32(v, v);
+  __m128i x2 = _mm_hadd_epi32(x1, x1);
+  return _mm_cvtsi128_si32(x2);
+#else
+  __m128i x1 = _mm_shuffle_epi32(v, _MM_SHUFFLE(0, 0, 3, 2));
+  __m128i x2 = _mm_add_epi32(v, x1);
+  __m128i x3 = _mm_shuffle_epi32(x2, _MM_SHUFFLE(0, 0, 0, 1));
+  __m128i x4 = _mm_add_epi32(x2, x3);
+  return _mm_cvtsi128_si32(x4);
+#endif
+}
+#endif  // __SSE2__
+
+//! Compute the distance between matrix and query
+static __attribute__((always_inline)) void squared_euclidean_int4_avx2(
+    const void *a, const void *b, size_t size, float *distance) {
+  const uint8_t *lhs = reinterpret_cast<const uint8_t *>(a);
+  const uint8_t *rhs = reinterpret_cast<const uint8_t *>(b);
+  const uint8_t *last = lhs + size;
+  const uint8_t *last_aligned = lhs + ((size >> 4) << 4);
+  __m128i xmm_sum = _mm_setzero_si128();
+
+  if (((uintptr_t)lhs & 0xf) == 0 && ((uintptr_t)rhs & 0xf) == 0) {
+    for (; lhs != last_aligned; lhs += 16, rhs += 16) {
+      __m128i xmm_lhs = _mm_load_si128((const __m128i *)(lhs));
+      __m128i xmm_rhs = _mm_load_si128((const __m128i *)(rhs));
+      FMA_INT4_ITER_SSE(xmm_lhs, xmm_rhs, xmm_sum)
+    }
+  } else {
+    for (; lhs != last_aligned; lhs += 16, rhs += 16) {
+      __m128i xmm_lhs = _mm_loadu_si128((const __m128i *)(lhs));
+      __m128i xmm_rhs = _mm_loadu_si128((const __m128i *)(rhs));
+      FMA_INT4_ITER_SSE(xmm_lhs, xmm_rhs, xmm_sum)
+    }
+  }
+  float result = static_cast<float>(HorizontalAdd_INT32_V128(xmm_sum));
+
+  switch (last - lhs) {
+    case 15:
+      FMA_INT4_GENERAL(lhs[14], rhs[14], result)
+      /* FALLTHRU */
+    case 14:
+      FMA_INT4_GENERAL(lhs[13], rhs[13], result)
+      /* FALLTHRU */
+    case 13:
+      FMA_INT4_GENERAL(lhs[12], rhs[12], result)
+      /* FALLTHRU */
+    case 12:
+      FMA_INT4_GENERAL(lhs[11], rhs[11], result)
+      /* FALLTHRU */
+    case 11:
+      FMA_INT4_GENERAL(lhs[10], rhs[10], result)
+      /* FALLTHRU */
+    case 10:
+      FMA_INT4_GENERAL(lhs[9], rhs[9], result)
+      /* FALLTHRU */
+    case 9:
+      FMA_INT4_GENERAL(lhs[8], rhs[8], result)
+      /* FALLTHRU */
+    case 8:
+      FMA_INT4_GENERAL(lhs[7], rhs[7], result)
+      /* FALLTHRU */
+    case 7:
+      FMA_INT4_GENERAL(lhs[6], rhs[6], result)
+      /* FALLTHRU */
+    case 6:
+      FMA_INT4_GENERAL(lhs[5], rhs[5], result)
+      /* FALLTHRU */
+    case 5:
+      FMA_INT4_GENERAL(lhs[4], rhs[4], result)
+      /* FALLTHRU */
+    case 4:
+      FMA_INT4_GENERAL(lhs[3], rhs[3], result)
+      /* FALLTHRU */
+    case 3:
+      FMA_INT4_GENERAL(lhs[2], rhs[2], result)
+      /* FALLTHRU */
+    case 2:
+      FMA_INT4_GENERAL(lhs[1], rhs[1], result)
+      /* FALLTHRU */
+    case 1:
+      FMA_INT4_GENERAL(lhs[0], rhs[0], result)
+  }
+
+  *distance = result;
+}
+
+// Compute raw integer inner products for a batch of int8 vectors against a
+// single query. Uses AVX512-VNNI dpbusd instruction.
+// `query` is treated as uint8 (preprocessed), `vectors[i]` as int8.
+template <size_t batch_size>
+__attribute__((always_inline)) void inner_product_int4_batch_avx2_impl(
+    const void *query, const void *const *vectors,
+    const std::array<const void *, batch_size> &prefetch_ptrs,
+    size_t dimensionality, float *distances) {}
+
+static __attribute__((always_inline)) void inner_product_int4_batch_avx2(
+    const void *const *vectors, const void *query, size_t n, size_t dim,
+    float *distances) {
+  static constexpr size_t batch_size = 2;
+  static constexpr size_t prefetch_step = 2;
+  size_t i = 0;
+  for (; i + batch_size <= n; i += batch_size) {
+    std::array<const void *, batch_size> prefetch_ptrs;
+    for (size_t j = 0; j < batch_size; ++j) {
+      if (i + j + batch_size * prefetch_step < n) {
+        prefetch_ptrs[j] = vectors[i + j + batch_size * prefetch_step];
+      } else {
+        prefetch_ptrs[j] = nullptr;
+      }
+    }
+    inner_product_int4_batch_avx2_impl<batch_size>(
+        query, &vectors[i], prefetch_ptrs, dim, distances + i);
+  }
+  for (; i < n; i++) {
+    std::array<const void *, 1> prefetch_ptrs{nullptr};
+    inner_product_int4_batch_avx2_impl<1>(query, &vectors[i], prefetch_ptrs,
+                                          dim, distances + i);
+  }
+}
+
+}  // namespace zvec::turbo::avx2::internal
+
+#endif  // defined(__AVX2__)
diff --git a/src/turbo/distance/avx512/float32/common.h b/src/turbo/distance/avx512/float32/common.h
new file mode 100644
index 000000000..af04d0e41
--- /dev/null
+++ b/src/turbo/distance/avx512/float32/common.h
@@ -0,0 +1,42 @@
+// Copyright 2025-present the zvec project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#pragma once
+
+#if defined(__AVX512F__)
+#include <immintrin.h>
+#include <array>
+#include <cstdint>
+
+//! Calculate Fused-Multiply-Add (AVX512)
+#define FMA_FP32_AVX512(zmm_m, zmm_q, zmm_sum) \
+  zmm_sum = _mm512_fmadd_ps(zmm_m, zmm_q, zmm_sum);
+
+
+static inline float HorizontalAdd_FP32_V256(__m256 v) {
+  __m256 x1 = _mm256_hadd_ps(v, v);
+  __m256 x2 = _mm256_hadd_ps(x1, x1);
+  __m128 x3 = _mm256_extractf128_ps(x2, 1);
+  __m128 x4 = _mm_add_ss(_mm256_castps256_ps128(x2), x3);
+  return _mm_cvtss_f32(x4);
+}
+
+static inline float HorizontalAdd_FP32_V512(__m512 v) {
+  __m256 low = _mm512_castps512_ps256(v);
+  __m256 high =
+      _mm256_castpd_ps(_mm512_extractf64x4_pd(_mm512_castps_pd(v), 1));
+  return HorizontalAdd_FP32_V256(_mm256_add_ps(low, high));
+}
+
+#endif  // __AVX512F__
\ No newline at end of file
diff --git a/src/turbo/distance/avx512/float32/cosine.cc b/src/turbo/distance/avx512/float32/cosine.cc
new file mode 100644
index 000000000..63eb4507f
--- /dev/null
+++ b/src/turbo/distance/avx512/float32/cosine.cc
@@ -0,0 +1,70 @@
+// Copyright 2025-present the zvec project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "avx512/float32/cosine.h"
+#include "avx512/float32/common.h"
+#include "avx512/float32/inner_product.h"
+
+#if defined(__AVX512F__)
+#include <immintrin.h>
+#endif
+
+namespace zvec::turbo::avx512 {
+
+void cosine_fp32_distance(const void *a, const void *b, size_t dim,
+                          float *distance) {
+#if defined(__AVX512F__)
+  size_t d = dim;
+
+  // inner_product_fp32_distance returns -real_IP; cosine = 1 - real_IP = 1 +
+  // ip.
+  float ip;
+  inner_product_fp32_distance(a, b, d, &ip);
+
+  *distance = 1 + ip;
+#else
+  (void)a;
+  (void)b;
+  (void)dim;
+  (void)distance;
+#endif  // __AVX512F__
+}
+
+void cosine_fp32_batch_distance(const void *const *vectors, const void *query,
+                                size_t n, size_t dim, float *distances) {
+#if defined(__AVX512F__)
+  // `dim` is the full encoded size; the original vector occupies dim-24 bytes.
+  const int original_dim = dim - 1;
+  if (original_dim <= 0) {
+    return;
+  }
+
+  inner_product_fp32_batch_distance(vectors, query, n, original_dim, distances);
+
+  // inner_product batch returns -real_IP per element; cosine = 1 - real_IP = 1
+  // + d.
+  for (size_t i = 0; i < n; ++i) {
+    distances[i] = 1 + distances[i];
+  }
+
+#else
+  (void)vectors;
+  (void)query;
+  (void)n;
+  (void)dim;
+  (void)distances;
+#endif  //__AVX512F__
+}
+
+}  // namespace zvec::turbo::avx512
\ No newline at end of file
diff --git a/src/turbo/distance/avx512/float32/cosine.h b/src/turbo/distance/avx512/float32/cosine.h
new file mode 100644
index 000000000..7e11de89f
--- /dev/null
+++ b/src/turbo/distance/avx512/float32/cosine.h
@@ -0,0 +1,30 @@
+// Copyright 2025-present the zvec project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#pragma once
+
+#include <cstddef>
+
+namespace zvec::turbo::avx512 {
+
+// Compute cosine distance (negative inner product after normalization) between
+// a single quantized FP32 vector pair.
+void cosine_fp32_distance(const void *a, const void *b, size_t dim,
+                          float *distance);
+
+// Batch version of cosine_fp32_distance.
+void cosine_fp32_batch_distance(const void *const *vectors, const void *query,
+                                size_t n, size_t dim, float *distances);
+
+}  // namespace zvec::turbo::avx512
\ No newline at end of file
diff --git a/src/turbo/distance/avx512/float32/inner_product.cc b/src/turbo/distance/avx512/float32/inner_product.cc
new file mode 100644
index 000000000..b28ef2e6a
--- /dev/null
+++ b/src/turbo/distance/avx512/float32/inner_product.cc
@@ -0,0 +1,104 @@
+// Copyright 2025-present the zvec project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "avx512/float32/inner_product.h"
+#include "avx512/float32/common.h"
+
+#if defined(__AVX512F__)
+#include <immintrin.h>
+#endif
+
+namespace zvec::turbo::avx512 {
+
+// Compute squared Euclidean distance between a single quantized FP32
+// vector pair.
+void inner_product_fp32_distance(const void *a, const void *b, size_t dim,
+                                 float *distance) {
+#if defined(__AVX512F__)
+  const float *lhs = reinterpret_cast<const float *>(a);
+  const float *rhs = reinterpret_cast<const float *>(b);
+
+  const float *last = lhs + dim;
+  const float *last_aligned = lhs + ((dim >> 5) << 5);
+
+  __m512 zmm_sum_0 = _mm512_setzero_ps();
+  __m512 zmm_sum_1 = _mm512_setzero_ps();
+
+  if (((uintptr_t)lhs & 0x3f) == 0 && ((uintptr_t)rhs & 0x3f) == 0) {
+    for (; lhs != last_aligned; lhs += 32, rhs += 32) {
+      FMA_FP32_AVX512(_mm512_load_ps(lhs + 0), _mm512_load_ps(rhs + 0),
+                      zmm_sum_0)
+
+      FMA_FP32_AVX512(_mm512_load_ps(lhs + 16), _mm512_load_ps(rhs + 16),
+                      zmm_sum_1)
+    }
+
+    if (last >= last_aligned + 16) {
+      FMA_FP32_AVX512(_mm512_load_ps(lhs), _mm512_load_ps(rhs), zmm_sum_0)
+      lhs += 16;
+      rhs += 16;
+    }
+  } else {
+    for (; lhs != last_aligned; lhs += 32, rhs += 32) {
+      FMA_FP32_AVX512(_mm512_loadu_ps(lhs + 0), _mm512_loadu_ps(rhs + 0),
+                      zmm_sum_0)
+
+      FMA_FP32_AVX512(_mm512_loadu_ps(lhs + 16), _mm512_loadu_ps(rhs + 16),
+                      zmm_sum_1)
+    }
+
+    if (last >= last_aligned + 16) {
+      FMA_FP32_AVX512(_mm512_loadu_ps(lhs), _mm512_loadu_ps(rhs), zmm_sum_0)
+      lhs += 16;
+      rhs += 16;
+    }
+  }
+
+  zmm_sum_0 = _mm512_add_ps(zmm_sum_0, zmm_sum_1);
+  if (lhs != last) {
+    __mmask16 mask = (__mmask16)((1 << (last - lhs)) - 1);
+    __m512 zmm_undefined = _mm512_undefined_ps();
+    zmm_sum_0 = _mm512_mask3_fmadd_ps(
+        _mm512_mask_loadu_ps(zmm_undefined, mask, lhs),
+        _mm512_mask_loadu_ps(zmm_undefined, mask, rhs), zmm_sum_0, mask);
+  }
+
+  *distance = -1 * HorizontalAdd_FP32_V512(zmm_sum_0);
+
+#else
+  (void)a;
+  (void)b;
+  (void)dim;
+  (void)distance;
+#endif  //__AVX512F__
+}
+
+// Batch version of inner_product_fp32_distance.
+void inner_product_fp32_batch_distance(const void *const *vectors,
+                                       const void *query, size_t n, size_t dim,
+                                       float *distances) {
+#if defined(__AVX512F__)
+  for (size_t i = 0; i < n; ++i) {
+    inner_product_fp32_distance(vectors[i], query, dim, &distances[i]);
+  }
+#else
+  (void)vectors;
+  (void)query;
+  (void)n;
+  (void)dim;
+  (void)distances;
+#endif  //__AVX512F__
+}
+
+}  // namespace zvec::turbo::avx512
\ No newline at end of file
diff --git a/src/turbo/distance/avx512/float32/inner_product.h b/src/turbo/distance/avx512/float32/inner_product.h
new file mode 100644
index 000000000..d1f48eecf
--- /dev/null
+++ b/src/turbo/distance/avx512/float32/inner_product.h
@@ -0,0 +1,31 @@
+// Copyright 2025-present the zvec project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#pragma once
+
+#include <cstddef>
+
+namespace zvec::turbo::avx512 {
+
+// Compute inner product distance between a single quantized FP32
+// vector pair.
+void inner_product_fp32_distance(const void *a, const void *b, size_t dim,
+                                 float *distance);
+
+// Batch version of inner_product_fp32_distance.
+void inner_product_fp32_batch_distance(const void *const *vectors,
+                                       const void *query, size_t n, size_t dim,
+                                       float *distances);
+
+}  // namespace zvec::turbo::avx512
diff --git a/src/turbo/distance/avx512/float32/squared_euclidean.cc b/src/turbo/distance/avx512/float32/squared_euclidean.cc
new file mode 100644
index 000000000..cc00cacf9
--- /dev/null
+++ b/src/turbo/distance/avx512/float32/squared_euclidean.cc
@@ -0,0 +1,105 @@
+// Copyright 2025-present the zvec project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "avx512/float32/squared_euclidean.h"
+#include "avx512/float32/common.h"
+
+#if defined(__AVX512F__)
+#include <immintrin.h>
+#endif
+
+namespace zvec::turbo::avx512 {
+
+void squared_euclidean_fp32_distance(const void *a, const void *b, size_t dim,
+                                     float *distance) {
+#if defined(__AVX512F__)
+  const float *lhs = reinterpret_cast<const float *>(a);
+  const float *rhs = reinterpret_cast<const float *>(b);
+
+  const float *last = lhs + dim;
+  const float *last_aligned = lhs + ((dim >> 5) << 5);
+
+  __m512 zmm_sum_0 = _mm512_setzero_ps();
+  __m512 zmm_sum_1 = _mm512_setzero_ps();
+
+  if (((uintptr_t)lhs & 0x3f) == 0 && ((uintptr_t)rhs & 0x3f) == 0) {
+    for (; lhs != last_aligned; lhs += 32, rhs += 32) {
+      __m512 zmm_d_0 =
+          _mm512_sub_ps(_mm512_load_ps(lhs + 0), _mm512_load_ps(rhs + 0));
+      __m512 zmm_d_1 =
+          _mm512_sub_ps(_mm512_load_ps(lhs + 16), _mm512_load_ps(rhs + 16));
+      zmm_sum_0 = _mm512_fmadd_ps(zmm_d_0, zmm_d_0, zmm_sum_0);
+      zmm_sum_1 = _mm512_fmadd_ps(zmm_d_1, zmm_d_1, zmm_sum_1);
+    }
+
+    if (last >= last_aligned + 16) {
+      __m512 zmm_d = _mm512_sub_ps(_mm512_load_ps(lhs), _mm512_load_ps(rhs));
+      zmm_sum_0 = _mm512_fmadd_ps(zmm_d, zmm_d, zmm_sum_0);
+      lhs += 16;
+      rhs += 16;
+    }
+  } else {
+    for (; lhs != last_aligned; lhs += 32, rhs += 32) {
+      __m512 zmm_d_0 =
+          _mm512_sub_ps(_mm512_loadu_ps(lhs + 0), _mm512_loadu_ps(rhs + 0));
+      __m512 zmm_d_1 =
+          _mm512_sub_ps(_mm512_loadu_ps(lhs + 16), _mm512_loadu_ps(rhs + 16));
+      zmm_sum_0 = _mm512_fmadd_ps(zmm_d_0, zmm_d_0, zmm_sum_0);
+      zmm_sum_1 = _mm512_fmadd_ps(zmm_d_1, zmm_d_1, zmm_sum_1);
+    }
+
+    if (last >= last_aligned + 16) {
+      __m512 zmm_d = _mm512_sub_ps(_mm512_loadu_ps(lhs), _mm512_loadu_ps(rhs));
+      zmm_sum_0 = _mm512_fmadd_ps(zmm_d, zmm_d, zmm_sum_0);
+      lhs += 16;
+      rhs += 16;
+    }
+  }
+
+  zmm_sum_0 = _mm512_add_ps(zmm_sum_0, zmm_sum_1);
+  if (lhs != last) {
+    __mmask16 mask = (__mmask16)((1 << (last - lhs)) - 1);
+    __m512 zmm_undefined = _mm512_undefined_ps();
+    __m512 zmm_d = _mm512_mask_sub_ps(
+        zmm_undefined, mask, _mm512_mask_loadu_ps(zmm_undefined, mask, lhs),
+        _mm512_mask_loadu_ps(zmm_undefined, mask, rhs));
+    zmm_sum_0 = _mm512_mask3_fmadd_ps(zmm_d, zmm_d, zmm_sum_0, mask);
+  }
+
+  *distance = HorizontalAdd_FP32_V512(zmm_sum_0);
+#else
+  (void)a;
+  (void)b;
+  (void)dim;
+  (void)distance;
+#endif  // __AVX512F__
+}
+
+void squared_euclidean_fp32_batch_distance(const void *const *vectors,
+                                           const void *query, size_t n,
+                                           size_t dim, float *distances) {
+#if defined(__AVX512F__)
+  for (size_t i = 0; i < n; ++i) {
+    squared_euclidean_fp32_distance(vectors[i], query, dim, &distances[i]);
+  }
+#else
+  (void)vectors;
+  (void)query;
+  (void)n;
+  (void)dim;
+  (void)distances;
+#endif  //__AVX512F__
+}
+
+}  // namespace zvec::turbo::avx512
\ No newline at end of file
diff --git a/src/turbo/distance/avx512/float32/squared_euclidean.h b/src/turbo/distance/avx512/float32/squared_euclidean.h
new file mode 100644
index 000000000..8b43b540e
--- /dev/null
+++ b/src/turbo/distance/avx512/float32/squared_euclidean.h
@@ -0,0 +1,31 @@
+// Copyright 2025-present the zvec project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#pragma once
+
+#include <cstddef>
+
+namespace zvec::turbo::avx512 {
+
+// Compute squared euclidean distance between a single quantized FP32
+// vector pair.
+void squared_euclidean_fp32_distance(const void *a, const void *b, size_t dim,
+                                     float *distance);
+
+// Batch version of squared euclidean FP32.
+void squared_euclidean_fp32_batch_distance(const void *const *vectors,
+                                           const void *query, size_t n,
+                                           size_t dim, float *distances);
+
+}  // namespace zvec::turbo::avx512
diff --git a/src/turbo/distance/avx512/half_float/cosine.cc b/src/turbo/distance/avx512/half_float/cosine.cc
new file mode 100644
index 000000000..4f1492ca8
--- /dev/null
+++ b/src/turbo/distance/avx512/half_float/cosine.cc
@@ -0,0 +1,61 @@
+// Copyright 2025-present the zvec project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "avx512/half_float/cosine.h"
+#include "avx512/half_float/inner_product.h"
+#include "avx512/half_float/inner_product_common.h"
+
+#if defined(__AVX512F__)
+#include <immintrin.h>
+#endif
+
+namespace zvec::turbo::avx512 {
+
+void cosine_fp16_distance(const void *a, const void *b, size_t dim,
+                          float *distance) {
+#if defined(__AVX512F__)
+  float ip;
+  inner_product_fp16_distance(a, b, dim, &ip);
+
+  *distance = 1 - ip;
+#else
+  (void)a;
+  (void)b;
+  (void)dim;
+  (void)distance;
+#endif  // __AVX512F__
+}
+
+void cosine_fp16_batch_distance(const void *const *vectors, const void *query,
+                                size_t n, size_t dim, float *distances) {
+#if defined(__AVX512F__)
+  if (dim == 0) {
+    return;
+  }
+
+  inner_product_fp16_batch_distance(vectors, query, n, dim, distances);
+
+  for (size_t i = 0; i < n; ++i) {
+    distances[i] = 1 - distances[i];
+  }
+#else
+  (void)vectors;
+  (void)query;
+  (void)n;
+  (void)dim;
+  (void)distances;
+#endif  //__AVX512F__
+}
+
+}  // namespace zvec::turbo::avx512
\ No newline at end of file
diff --git a/src/turbo/distance/avx512/half_float/cosine.h b/src/turbo/distance/avx512/half_float/cosine.h
new file mode 100644
index 000000000..1e068dd6e
--- /dev/null
+++ b/src/turbo/distance/avx512/half_float/cosine.h
@@ -0,0 +1,30 @@
+// Copyright 2025-present the zvec project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#pragma once
+
+#include <cstddef>
+
+namespace zvec::turbo::avx512 {
+
+// Compute cosine distance (negative inner product after normalization) between
+// a single quantized FP32 vector pair.
+void cosine_fp16_distance(const void *a, const void *b, size_t dim,
+                          float *distance);
+
+// Batch version of cosine_fp32_distance.
+void cosine_fp16_batch_distance(const void *const *vectors, const void *query,
+                                size_t n, size_t dim, float *distances);
+
+}  // namespace zvec::turbo::avx512
\ No newline at end of file
diff --git a/src/turbo/distance/avx512/half_float/inner_product.cc b/src/turbo/distance/avx512/half_float/inner_product.cc
new file mode 100644
index 000000000..221d0a2ab
--- /dev/null
+++ b/src/turbo/distance/avx512/half_float/inner_product.cc
@@ -0,0 +1,59 @@
+// Copyright 2025-present the zvec project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include <cstddef>
+
+#if defined(__AVX512F__)
+#include <immintrin.h>
+#include <zvec/ailego/utility/float_helper.h>
+#include "avx512/half_float/inner_product.h"
+#include "avx512/half_float/inner_product_common.h"
+
+using namespace zvec::turbo::avx512::internal;
+#endif
+
+namespace zvec::turbo::avx512 {
+
+// Compute squared Euclidean distance between a single quantized FP16
+// vector pair.
+void inner_product_fp16_distance(const void *a, const void *b, size_t dim,
+                                 float *distance) {
+#if defined(__AVX512F__)
+  const zvec::ailego::Float16 *lhs =
+      reinterpret_cast<const zvec::ailego::Float16 *>(a);
+  const zvec::ailego::Float16 *rhs =
+      reinterpret_cast<const zvec::ailego::Float16 *>(b);
+
+  ACCUM_FP16_1X1_AVX512(lhs, rhs, dim, distance, 0ull, NEGATE_FP32_GENERAL)
+#endif
+}
+
+// Batch version of inner_product_fp16_distance.
+void inner_product_fp16_batch_distance(const void *const *vectors,
+                                       const void *query, size_t n, size_t dim,
+                                       float *distances) {
+#if defined(__AVX512F__)
+  for (size_t i = 0; i < n; ++i) {
+    inner_product_fp16_distance(vectors[i], query, dim, &distances[i]);
+  }
+#else
+  (void)vectors;
+  (void)query;
+  (void)n;
+  (void)dim;
+  (void)distances;
+#endif
+}
+
+}  // namespace zvec::turbo::avx512
\ No newline at end of file
diff --git a/src/turbo/distance/avx512/half_float/inner_product.h b/src/turbo/distance/avx512/half_float/inner_product.h
new file mode 100644
index 000000000..833d4c8c3
--- /dev/null
+++ b/src/turbo/distance/avx512/half_float/inner_product.h
@@ -0,0 +1,31 @@
+// Copyright 2025-present the zvec project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#pragma once
+
+#include <cstddef>
+
+namespace zvec::turbo::avx512 {
+
+// Compute inner product distance between a single quantized FP16
+// vector pair.
+void inner_product_fp16_distance(const void *a, const void *b, size_t dim,
+                                 float *distance);
+
+// Batch version of inner_product_fp32_distance.
+void inner_product_fp16_batch_distance(const void *const *vectors,
+                                       const void *query, size_t n, size_t dim,
+                                       float *distances);
+
+}  // namespace zvec::turbo::avx512
diff --git a/src/turbo/distance/avx512/half_float/inner_product_common.h b/src/turbo/distance/avx512/half_float/inner_product_common.h
new file mode 100644
index 000000000..dcd6f2a83
--- /dev/null
+++ b/src/turbo/distance/avx512/half_float/inner_product_common.h
@@ -0,0 +1,209 @@
+// Copyright 2025-present the zvec project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#pragma once
+
+#if defined(__AVX512F__)
+#include <immintrin.h>
+#include <array>
+#include <cstdint>
+#include <zvec/ailego/utility/float_helper.h>
+
+using namespace zvec::ailego;
+
+namespace zvec::turbo::avx512::internal {
+//! Reverse sign of value (GENERAL)
+#define NEGATE_FP32_GENERAL(v) -(v)
+
+static inline float HorizontalAdd_FP32_V256(__m256 v) {
+  __m256 x1 = _mm256_hadd_ps(v, v);
+  __m256 x2 = _mm256_hadd_ps(x1, x1);
+  __m128 x3 = _mm256_extractf128_ps(x2, 1);
+  __m128 x4 = _mm_add_ss(_mm256_castps256_ps128(x2), x3);
+  return _mm_cvtss_f32(x4);
+}
+
+//! Iterative process of computing distance (FP16, M=1, N=1)
+#define MATRIX_FP16_ITER_1X1_AVX512(m, q, _RES, _LOAD, _PROC)       \
+  {                                                                 \
+    __m512i zmm_mi = _LOAD((const __m512i *)m);                     \
+    __m512i zmm_qi = _LOAD((const __m512i *)q);                     \
+    __m512 zmm_m = _mm512_cvtph_ps(_mm512_castsi512_si256(zmm_mi)); \
+    __m512 zmm_q = _mm512_cvtph_ps(_mm512_castsi512_si256(zmm_qi)); \
+    _PROC(zmm_m, zmm_q, _RES##_0_0);                                \
+    zmm_m = _mm512_cvtph_ps(_mm512_extracti64x4_epi64(zmm_mi, 1));  \
+    zmm_q = _mm512_cvtph_ps(_mm512_extracti64x4_epi64(zmm_qi, 1));  \
+    _PROC(zmm_m, zmm_q, _RES##_0_0);                                \
+  }
+
+//! Mask process of computing distance (FP16)
+#define MATRIX_FP16_MASK_AVX(lhs, rhs, cnt, _MASK, _RES, _PROC)              \
+  switch (cnt) {                                                             \
+    case 7: {                                                                \
+      __m256 ymm_lhs = _mm256_cvtph_ps(_mm_set_epi16(                        \
+          (short)(_MASK), *((const short *)(lhs) + 6),                       \
+          *((const short *)(lhs) + 5), *((const short *)(lhs) + 4),          \
+          *((const short *)(lhs) + 3), *((const short *)(lhs) + 2),          \
+          *((const short *)(lhs) + 1), *((const short *)(lhs))));            \
+      __m256 ymm_rhs = _mm256_cvtph_ps(_mm_set_epi16(                        \
+          (short)(_MASK), *((const short *)(rhs) + 6),                       \
+          *((const short *)(rhs) + 5), *((const short *)(rhs) + 4),          \
+          *((const short *)(rhs) + 3), *((const short *)(rhs) + 2),          \
+          *((const short *)(rhs) + 1), *((const short *)(rhs))));            \
+      _PROC(ymm_lhs, ymm_rhs, _RES##_0_0)                                    \
+      break;                                                                 \
+    }                                                                        \
+    case 6: {                                                                \
+      __m256 ymm_lhs = _mm256_cvtph_ps(                                      \
+          _mm_set_epi32((int)(_MASK), *((const int *)(lhs) + 2),             \
+                        *((const int *)(lhs) + 1), *((const int *)(lhs))));  \
+      __m256 ymm_rhs = _mm256_cvtph_ps(                                      \
+          _mm_set_epi32((int)(_MASK), *((const int *)(rhs) + 2),             \
+                        *((const int *)(rhs) + 1), *((const int *)(rhs))));  \
+      _PROC(ymm_lhs, ymm_rhs, _RES##_0_0)                                    \
+      break;                                                                 \
+    }                                                                        \
+    case 5: {                                                                \
+      __m256 ymm_lhs = _mm256_cvtph_ps(_mm_set_epi16(                        \
+          (short)(_MASK), (short)(_MASK), (short)(_MASK),                    \
+          *((const short *)(lhs) + 4), *((const short *)(lhs) + 3),          \
+          *((const short *)(lhs) + 2), *((const short *)(lhs) + 1),          \
+          *((const short *)(lhs))));                                         \
+      __m256 ymm_rhs = _mm256_cvtph_ps(_mm_set_epi16(                        \
+          (short)(_MASK), (short)(_MASK), (short)(_MASK),                    \
+          *((const short *)(rhs) + 4), *((const short *)(rhs) + 3),          \
+          *((const short *)(rhs) + 2), *((const short *)(rhs) + 1),          \
+          *((const short *)(rhs))));                                         \
+      _PROC(ymm_lhs, ymm_rhs, _RES##_0_0)                                    \
+      break;                                                                 \
+    }                                                                        \
+    case 4: {                                                                \
+      __m256 ymm_lhs = _mm256_cvtph_ps(                                      \
+          _mm_set_epi64((__m64)(_MASK), *((const __m64 *)(lhs))));           \
+      __m256 ymm_rhs = _mm256_cvtph_ps(                                      \
+          _mm_set_epi64((__m64)(_MASK), *((const __m64 *)(rhs))));           \
+      _PROC(ymm_lhs, ymm_rhs, _RES##_0_0)                                    \
+      break;                                                                 \
+    }                                                                        \
+    case 3: {                                                                \
+      __m256 ymm_lhs = _mm256_cvtph_ps(_mm_set_epi16(                        \
+          (short)(_MASK), (short)(_MASK), (short)(_MASK), (short)(_MASK),    \
+          (short)(_MASK), *((const short *)(lhs) + 2),                       \
+          *((const short *)(lhs) + 1), *((const short *)(lhs))));            \
+      __m256 ymm_rhs = _mm256_cvtph_ps(_mm_set_epi16(                        \
+          (short)(_MASK), (short)(_MASK), (short)(_MASK), (short)(_MASK),    \
+          (short)(_MASK), *((const short *)(rhs) + 2),                       \
+          *((const short *)(rhs) + 1), *((const short *)(rhs))));            \
+      _PROC(ymm_lhs, ymm_rhs, _RES##_0_0)                                    \
+      break;                                                                 \
+    }                                                                        \
+    case 2: {                                                                \
+      __m256 ymm_lhs = _mm256_cvtph_ps(_mm_set_epi32(                        \
+          (int)(_MASK), (int)(_MASK), (int)(_MASK), *((const int *)(lhs)))); \
+      __m256 ymm_rhs = _mm256_cvtph_ps(_mm_set_epi32(                        \
+          (int)(_MASK), (int)(_MASK), (int)(_MASK), *((const int *)(rhs)))); \
+      _PROC(ymm_lhs, ymm_rhs, _RES##_0_0)                                    \
+      break;                                                                 \
+    }                                                                        \
+    case 1: {                                                                \
+      __m256 ymm_lhs = _mm256_cvtph_ps(                                      \
+          _mm_set_epi16(*((const short *)(lhs)), (short)(_MASK),             \
+                        (short)(_MASK), (short)(_MASK), (short)(_MASK),      \
+                        (short)(_MASK), (short)(_MASK), (short)(_MASK)));    \
+      __m256 ymm_rhs = _mm256_cvtph_ps(                                      \
+          _mm_set_epi16(*((const short *)(rhs)), (short)(_MASK),             \
+                        (short)(_MASK), (short)(_MASK), (short)(_MASK),      \
+                        (short)(_MASK), (short)(_MASK), (short)(_MASK)));    \
+      _PROC(ymm_lhs, ymm_rhs, _RES##_0_0)                                    \
+      break;                                                                 \
+    }                                                                        \
+  }
+
+//! Calculate Fused-Multiply-Add (AVX)
+#define FMA_FP32_AVX(ymm_m, ymm_q, ymm_sum) \
+  ymm_sum = _mm256_fmadd_ps(ymm_m, ymm_q, ymm_sum);
+
+#define ACCUM_FP32_STEP_AVX FMA_FP32_AVX
+
+//! Calculate Fused-Multiply-Add (AVX512)
+#define FMA_FP32_AVX512(zmm_m, zmm_q, zmm_sum) \
+  zmm_sum = _mm512_fmadd_ps(zmm_m, zmm_q, zmm_sum);
+
+#define ACCUM_FP32_STEP_AVX512 FMA_FP32_AVX512
+
+#define MATRIX_VAR_INIT_1X1(_VAR_TYPE, _VAR_NAME, _VAR_INIT) \
+  _VAR_TYPE _VAR_NAME##_0_0 = (_VAR_INIT);
+
+#define MATRIX_VAR_INIT(_M, _N, _VAR_TYPE, _VAR_NAME, _VAR_INIT) \
+  MATRIX_VAR_INIT_##_M##X##_N(_VAR_TYPE, _VAR_NAME, _VAR_INIT)
+
+//! Iterative process of computing distance (FP16, M=1, N=1)
+#define MATRIX_FP16_ITER_1X1_AVX(m, q, _RES, _LOAD, _PROC)          \
+  {                                                                 \
+    __m256i ymm_mi = _LOAD((const __m256i *)m);                     \
+    __m256i ymm_qi = _LOAD((const __m256i *)q);                     \
+    __m256 ymm_m = _mm256_cvtph_ps(_mm256_castsi256_si128(ymm_mi)); \
+    __m256 ymm_q = _mm256_cvtph_ps(_mm256_castsi256_si128(ymm_qi)); \
+    _PROC(ymm_m, ymm_q, _RES##_0_0);                                \
+    ymm_m = _mm256_cvtph_ps(_mm256_extractf128_si256(ymm_mi, 1));   \
+    ymm_q = _mm256_cvtph_ps(_mm256_extractf128_si256(ymm_qi, 1));   \
+    _PROC(ymm_m, ymm_q, _RES##_0_0);                                \
+  }
+
+//! Compute the distance between matrix and query (FP16, M=1, N=1)
+#define ACCUM_FP16_1X1_AVX512(m, q, dim, out, _MASK, _NORM)                   \
+  MATRIX_VAR_INIT(1, 1, __m512, zmm_sum, _mm512_setzero_ps())                 \
+  const Float16 *qe = q + dim;                                                \
+  const Float16 *qe_aligned = q + ((dim >> 5) << 5);                          \
+  if (((uintptr_t)m & 0x3f) == 0 && ((uintptr_t)q & 0x3f) == 0) {             \
+    for (; q != qe_aligned; m += 32, q += 32) {                               \
+      MATRIX_FP16_ITER_1X1_AVX512(m, q, zmm_sum, _mm512_load_si512,           \
+                                  ACCUM_FP32_STEP_AVX512)                     \
+    }                                                                         \
+    if (qe >= qe_aligned + 16) {                                              \
+      __m512 zmm_m = _mm512_cvtph_ps(_mm256_load_si256((const __m256i *)m));  \
+      __m512 zmm_q = _mm512_cvtph_ps(_mm256_load_si256((const __m256i *)q));  \
+      ACCUM_FP32_STEP_AVX512(zmm_m, zmm_q, zmm_sum_0_0)                       \
+      m += 16;                                                                \
+      q += 16;                                                                \
+    }                                                                         \
+  } else {                                                                    \
+    for (; q != qe_aligned; m += 32, q += 32) {                               \
+      MATRIX_FP16_ITER_1X1_AVX512(m, q, zmm_sum, _mm512_loadu_si512,          \
+                                  ACCUM_FP32_STEP_AVX512)                     \
+    }                                                                         \
+    if (qe >= qe_aligned + 16) {                                              \
+      __m512 zmm_m = _mm512_cvtph_ps(_mm256_loadu_si256((const __m256i *)m)); \
+      __m512 zmm_q = _mm512_cvtph_ps(_mm256_loadu_si256((const __m256i *)q)); \
+      ACCUM_FP32_STEP_AVX512(zmm_m, zmm_q, zmm_sum_0_0)                       \
+      m += 16;                                                                \
+      q += 16;                                                                \
+    }                                                                         \
+  }                                                                           \
+  __m256 ymm_sum_0_0 = _mm256_add_ps(_mm512_castps512_ps256(zmm_sum_0_0),     \
+                                     _mm256_castpd_ps(_mm512_extractf64x4_pd( \
+                                         _mm512_castps_pd(zmm_sum_0_0), 1))); \
+  if (qe >= q + 8) {                                                          \
+    __m256 ymm_m = _mm256_cvtph_ps(_mm_loadu_si128((const __m128i *)m));      \
+    __m256 ymm_q = _mm256_cvtph_ps(_mm_loadu_si128((const __m128i *)q));      \
+    ACCUM_FP32_STEP_AVX(ymm_m, ymm_q, ymm_sum_0_0)                            \
+    m += 8;                                                                   \
+    q += 8;                                                                   \
+  }                                                                           \
+  MATRIX_FP16_MASK_AVX(m, q, (qe - q), _MASK, ymm_sum, ACCUM_FP32_STEP_AVX)   \
+  *out = _NORM(HorizontalAdd_FP32_V256(ymm_sum_0_0));
+
+}  // namespace zvec::turbo::avx512::internal
+
+#endif  // defined(__AVX512F__)
diff --git a/src/turbo/distance/avx512/half_float/squared_euclidean.cc b/src/turbo/distance/avx512/half_float/squared_euclidean.cc
new file mode 100644
index 000000000..7a4b18e11
--- /dev/null
+++ b/src/turbo/distance/avx512/half_float/squared_euclidean.cc
@@ -0,0 +1,61 @@
+// Copyright 2025-present the zvec project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include <cstddef>
+
+#if defined(__AVX512F__)
+#include <immintrin.h>
+#include <zvec/ailego/utility/float_helper.h>
+#include "avx512/half_float/squared_euclidean.h"
+#include "avx512/half_float/squared_euclidean_common.h"
+
+using namespace zvec::turbo::avx512::internal;
+#endif
+
+namespace zvec::turbo::avx512 {
+
+void squared_euclidean_fp16_distance(const void *a, const void *b, size_t dim,
+                                     float *distance) {
+#if defined(__AVX512F__)
+  const zvec::ailego::Float16 *lhs =
+      reinterpret_cast<const zvec::ailego::Float16 *>(a);
+  const zvec::ailego::Float16 *rhs =
+      reinterpret_cast<const zvec::ailego::Float16 *>(b);
+
+  ACCUM_FP16_1X1_AVX512(lhs, rhs, dim, distance, 0ull, )
+#else
+  (void)a;
+  (void)b;
+  (void)dim;
+  (void)distance;
+#endif  // __AVX512F__
+}
+
+void squared_euclidean_fp16_batch_distance(const void *const *vectors,
+                                           const void *query, size_t n,
+                                           size_t dim, float *distances) {
+#if defined(__AVX512F__)
+  for (size_t i = 0; i < n; ++i) {
+    squared_euclidean_fp16_distance(vectors[i], query, dim, &distances[i]);
+  }
+#else
+  (void)vectors;
+  (void)query;
+  (void)n;
+  (void)dim;
+  (void)distances;
+#endif  //__AVX512F__
+}
+
+}  // namespace zvec::turbo::avx512
\ No newline at end of file
diff --git a/src/turbo/distance/avx512/half_float/squared_euclidean.h b/src/turbo/distance/avx512/half_float/squared_euclidean.h
new file mode 100644
index 000000000..399e238b0
--- /dev/null
+++ b/src/turbo/distance/avx512/half_float/squared_euclidean.h
@@ -0,0 +1,31 @@
+// Copyright 2025-present the zvec project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#pragma once
+
+#include <cstddef>
+
+namespace zvec::turbo::avx512 {
+
+// Compute squared euclidean distance between a single quantized FP32
+// vector pair.
+void squared_euclidean_fp16_distance(const void *a, const void *b, size_t dim,
+                                     float *distance);
+
+// Batch version of squared euclidean FP32.
+void squared_euclidean_fp16_batch_distance(const void *const *vectors,
+                                           const void *query, size_t n,
+                                           size_t dim, float *distances);
+
+}  // namespace zvec::turbo::avx512
diff --git a/src/turbo/distance/avx512/half_float/squared_euclidean_common.h b/src/turbo/distance/avx512/half_float/squared_euclidean_common.h
new file mode 100644
index 000000000..6ff8c4254
--- /dev/null
+++ b/src/turbo/distance/avx512/half_float/squared_euclidean_common.h
@@ -0,0 +1,200 @@
+// Copyright 2025-present the zvec project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#pragma once
+
+#if defined(__AVX512F__)
+#include <immintrin.h>
+#include <array>
+#include <cstdint>
+#include <zvec/ailego/utility/float_helper.h>
+
+using namespace zvec::ailego;
+
+namespace zvec::turbo::avx512::internal {
+
+static inline float HorizontalAdd_FP32_V256(__m256 v) {
+  __m256 x1 = _mm256_hadd_ps(v, v);
+  __m256 x2 = _mm256_hadd_ps(x1, x1);
+  __m128 x3 = _mm256_extractf128_ps(x2, 1);
+  __m128 x4 = _mm_add_ss(_mm256_castps256_ps128(x2), x3);
+  return _mm_cvtss_f32(x4);
+}
+
+//! Iterative process of computing distance (FP16, M=1, N=1)
+#define MATRIX_FP16_ITER_1X1_AVX512(m, q, _RES, _LOAD, _PROC)       \
+  {                                                                 \
+    __m512i zmm_mi = _LOAD((const __m512i *)m);                     \
+    __m512i zmm_qi = _LOAD((const __m512i *)q);                     \
+    __m512 zmm_m = _mm512_cvtph_ps(_mm512_castsi512_si256(zmm_mi)); \
+    __m512 zmm_q = _mm512_cvtph_ps(_mm512_castsi512_si256(zmm_qi)); \
+    _PROC(zmm_m, zmm_q, _RES##_0_0);                                \
+    zmm_m = _mm512_cvtph_ps(_mm512_extracti64x4_epi64(zmm_mi, 1));  \
+    zmm_q = _mm512_cvtph_ps(_mm512_extracti64x4_epi64(zmm_qi, 1));  \
+    _PROC(zmm_m, zmm_q, _RES##_0_0);                                \
+  }
+
+//! Mask process of computing distance (FP16)
+#define MATRIX_FP16_MASK_AVX(lhs, rhs, cnt, _MASK, _RES, _PROC)              \
+  switch (cnt) {                                                             \
+    case 7: {                                                                \
+      __m256 ymm_lhs = _mm256_cvtph_ps(_mm_set_epi16(                        \
+          (short)(_MASK), *((const short *)(lhs) + 6),                       \
+          *((const short *)(lhs) + 5), *((const short *)(lhs) + 4),          \
+          *((const short *)(lhs) + 3), *((const short *)(lhs) + 2),          \
+          *((const short *)(lhs) + 1), *((const short *)(lhs))));            \
+      __m256 ymm_rhs = _mm256_cvtph_ps(_mm_set_epi16(                        \
+          (short)(_MASK), *((const short *)(rhs) + 6),                       \
+          *((const short *)(rhs) + 5), *((const short *)(rhs) + 4),          \
+          *((const short *)(rhs) + 3), *((const short *)(rhs) + 2),          \
+          *((const short *)(rhs) + 1), *((const short *)(rhs))));            \
+      _PROC(ymm_lhs, ymm_rhs, _RES##_0_0)                                    \
+      break;                                                                 \
+    }                                                                        \
+    case 6: {                                                                \
+      __m256 ymm_lhs = _mm256_cvtph_ps(                                      \
+          _mm_set_epi32((int)(_MASK), *((const int *)(lhs) + 2),             \
+                        *((const int *)(lhs) + 1), *((const int *)(lhs))));  \
+      __m256 ymm_rhs = _mm256_cvtph_ps(                                      \
+          _mm_set_epi32((int)(_MASK), *((const int *)(rhs) + 2),             \
+                        *((const int *)(rhs) + 1), *((const int *)(rhs))));  \
+      _PROC(ymm_lhs, ymm_rhs, _RES##_0_0)                                    \
+      break;                                                                 \
+    }                                                                        \
+    case 5: {                                                                \
+      __m256 ymm_lhs = _mm256_cvtph_ps(_mm_set_epi16(                        \
+          (short)(_MASK), (short)(_MASK), (short)(_MASK),                    \
+          *((const short *)(lhs) + 4), *((const short *)(lhs) + 3),          \
+          *((const short *)(lhs) + 2), *((const short *)(lhs) + 1),          \
+          *((const short *)(lhs))));                                         \
+      __m256 ymm_rhs = _mm256_cvtph_ps(_mm_set_epi16(                        \
+          (short)(_MASK), (short)(_MASK), (short)(_MASK),                    \
+          *((const short *)(rhs) + 4), *((const short *)(rhs) + 3),          \
+          *((const short *)(rhs) + 2), *((const short *)(rhs) + 1),          \
+          *((const short *)(rhs))));                                         \
+      _PROC(ymm_lhs, ymm_rhs, _RES##_0_0)                                    \
+      break;                                                                 \
+    }                                                                        \
+    case 4: {                                                                \
+      __m256 ymm_lhs = _mm256_cvtph_ps(                                      \
+          _mm_set_epi64((__m64)(_MASK), *((const __m64 *)(lhs))));           \
+      __m256 ymm_rhs = _mm256_cvtph_ps(                                      \
+          _mm_set_epi64((__m64)(_MASK), *((const __m64 *)(rhs))));           \
+      _PROC(ymm_lhs, ymm_rhs, _RES##_0_0)                                    \
+      break;                                                                 \
+    }                                                                        \
+    case 3: {                                                                \
+      __m256 ymm_lhs = _mm256_cvtph_ps(_mm_set_epi16(                        \
+          (short)(_MASK), (short)(_MASK), (short)(_MASK), (short)(_MASK),    \
+          (short)(_MASK), *((const short *)(lhs) + 2),                       \
+          *((const short *)(lhs) + 1), *((const short *)(lhs))));            \
+      __m256 ymm_rhs = _mm256_cvtph_ps(_mm_set_epi16(                        \
+          (short)(_MASK), (short)(_MASK), (short)(_MASK), (short)(_MASK),    \
+          (short)(_MASK), *((const short *)(rhs) + 2),                       \
+          *((const short *)(rhs) + 1), *((const short *)(rhs))));            \
+      _PROC(ymm_lhs, ymm_rhs, _RES##_0_0)                                    \
+      break;                                                                 \
+    }                                                                        \
+    case 2: {                                                                \
+      __m256 ymm_lhs = _mm256_cvtph_ps(_mm_set_epi32(                        \
+          (int)(_MASK), (int)(_MASK), (int)(_MASK), *((const int *)(lhs)))); \
+      __m256 ymm_rhs = _mm256_cvtph_ps(_mm_set_epi32(                        \
+          (int)(_MASK), (int)(_MASK), (int)(_MASK), *((const int *)(rhs)))); \
+      _PROC(ymm_lhs, ymm_rhs, _RES##_0_0)                                    \
+      break;                                                                 \
+    }                                                                        \
+    case 1: {                                                                \
+      __m256 ymm_lhs = _mm256_cvtph_ps(                                      \
+          _mm_set_epi16(*((const short *)(lhs)), (short)(_MASK),             \
+                        (short)(_MASK), (short)(_MASK), (short)(_MASK),      \
+                        (short)(_MASK), (short)(_MASK), (short)(_MASK)));    \
+      __m256 ymm_rhs = _mm256_cvtph_ps(                                      \
+          _mm_set_epi16(*((const short *)(rhs)), (short)(_MASK),             \
+                        (short)(_MASK), (short)(_MASK), (short)(_MASK),      \
+                        (short)(_MASK), (short)(_MASK), (short)(_MASK)));    \
+      _PROC(ymm_lhs, ymm_rhs, _RES##_0_0)                                    \
+      break;                                                                 \
+    }                                                                        \
+  }
+
+//! Calculate sum of squared difference (AVX)
+#define SSD_FP32_AVX(ymm_m, ymm_q, ymm_sum)           \
+  {                                                   \
+    __m256 ymm_d = _mm256_sub_ps(ymm_m, ymm_q);       \
+    ymm_sum = _mm256_fmadd_ps(ymm_d, ymm_d, ymm_sum); \
+  }
+
+#define ACCUM_FP32_STEP_AVX SSD_FP32_AVX
+
+//! Calculate sum of squared difference (AVX512)
+#define SSD_FP32_AVX512(zmm_m, zmm_q, zmm_sum)        \
+  {                                                   \
+    __m512 zmm_d = _mm512_sub_ps(zmm_m, zmm_q);       \
+    zmm_sum = _mm512_fmadd_ps(zmm_d, zmm_d, zmm_sum); \
+  }
+
+#define ACCUM_FP32_STEP_AVX512 SSD_FP32_AVX512
+
+#define MATRIX_VAR_INIT_1X1(_VAR_TYPE, _VAR_NAME, _VAR_INIT) \
+  _VAR_TYPE _VAR_NAME##_0_0 = (_VAR_INIT);
+
+#define MATRIX_VAR_INIT(_M, _N, _VAR_TYPE, _VAR_NAME, _VAR_INIT) \
+  MATRIX_VAR_INIT_##_M##X##_N(_VAR_TYPE, _VAR_NAME, _VAR_INIT)
+
+//! Compute the distance between matrix and query (FP16, M=1, N=1)
+#define ACCUM_FP16_1X1_AVX512(m, q, dim, out, _MASK, _NORM)                   \
+  MATRIX_VAR_INIT(1, 1, __m512, zmm_sum, _mm512_setzero_ps())                 \
+  const Float16 *qe = q + dim;                                                \
+  const Float16 *qe_aligned = q + ((dim >> 5) << 5);                          \
+  if (((uintptr_t)m & 0x3f) == 0 && ((uintptr_t)q & 0x3f) == 0) {             \
+    for (; q != qe_aligned; m += 32, q += 32) {                               \
+      MATRIX_FP16_ITER_1X1_AVX512(m, q, zmm_sum, _mm512_load_si512,           \
+                                  ACCUM_FP32_STEP_AVX512)                     \
+    }                                                                         \
+    if (qe >= qe_aligned + 16) {                                              \
+      __m512 zmm_m = _mm512_cvtph_ps(_mm256_load_si256((const __m256i *)m));  \
+      __m512 zmm_q = _mm512_cvtph_ps(_mm256_load_si256((const __m256i *)q));  \
+      ACCUM_FP32_STEP_AVX512(zmm_m, zmm_q, zmm_sum_0_0)                       \
+      m += 16;                                                                \
+      q += 16;                                                                \
+    }                                                                         \
+  } else {                                                                    \
+    for (; q != qe_aligned; m += 32, q += 32) {                               \
+      MATRIX_FP16_ITER_1X1_AVX512(m, q, zmm_sum, _mm512_loadu_si512,          \
+                                  ACCUM_FP32_STEP_AVX512)                     \
+    }                                                                         \
+    if (qe >= qe_aligned + 16) {                                              \
+      __m512 zmm_m = _mm512_cvtph_ps(_mm256_loadu_si256((const __m256i *)m)); \
+      __m512 zmm_q = _mm512_cvtph_ps(_mm256_loadu_si256((const __m256i *)q)); \
+      ACCUM_FP32_STEP_AVX512(zmm_m, zmm_q, zmm_sum_0_0)                       \
+      m += 16;                                                                \
+      q += 16;                                                                \
+    }                                                                         \
+  }                                                                           \
+  __m256 ymm_sum_0_0 = _mm256_add_ps(_mm512_castps512_ps256(zmm_sum_0_0),     \
+                                     _mm256_castpd_ps(_mm512_extractf64x4_pd( \
+                                         _mm512_castps_pd(zmm_sum_0_0), 1))); \
+  if (qe >= q + 8) {                                                          \
+    __m256 ymm_m = _mm256_cvtph_ps(_mm_loadu_si128((const __m128i *)m));      \
+    __m256 ymm_q = _mm256_cvtph_ps(_mm_loadu_si128((const __m128i *)q));      \
+    ACCUM_FP32_STEP_AVX(ymm_m, ymm_q, ymm_sum_0_0)                            \
+    m += 8;                                                                   \
+    q += 8;                                                                   \
+  }                                                                           \
+  MATRIX_FP16_MASK_AVX(m, q, (qe - q), _MASK, ymm_sum, ACCUM_FP32_STEP_AVX)   \
+  *out = _NORM(HorizontalAdd_FP32_V256(ymm_sum_0_0));
+
+}  // namespace zvec::turbo::avx512::internal
+
+#endif  // defined(__AVX512F__)
diff --git a/src/turbo/distance/avx512_fp16/half_float/cosine.cc b/src/turbo/distance/avx512_fp16/half_float/cosine.cc
new file mode 100644
index 000000000..98dbe9f82
--- /dev/null
+++ b/src/turbo/distance/avx512_fp16/half_float/cosine.cc
@@ -0,0 +1,62 @@
+// Copyright 2025-present the zvec project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "avx512_fp16/half_float/cosine.h"
+#include "avx512_fp16/half_float/inner_product.h"
+#include "avx512_fp16/half_float/inner_product_common.h"
+
+#if defined(__AVX512FP16__)
+#include <immintrin.h>
+#endif
+
+namespace zvec::turbo::avx512_fp16 {
+
+void cosine_fp16_distance(const void *a, const void *b, size_t dim,
+                          float *distance) {
+#if defined(__AVX512FP16__)
+  float ip;
+  inner_product_fp16_distance(a, b, dim, &ip);
+
+  *distance = 1 - ip;
+#else
+  (void)a;
+  (void)b;
+  (void)dim;
+  (void)distance;
+#endif  // __AVX__
+}
+
+void cosine_fp16_batch_distance(const void *const *vectors, const void *query,
+                                size_t n, size_t dim, float *distances) {
+#if defined(__AVX512FP16__)
+  const size_t original_dim = dim;
+  if (original_dim <= 0) {
+    return;
+  }
+
+  inner_product_fp16_batch_distance(vectors, query, n, original_dim, distances);
+
+  for (size_t i = 0; i < n; ++i) {
+    distances[i] = 1 - distances[i];
+  }
+#else
+  (void)vectors;
+  (void)query;
+  (void)n;
+  (void)dim;
+  (void)distances;
+#endif  //__AVX__
+}
+
+}  // namespace zvec::turbo::avx512_fp16
\ No newline at end of file
diff --git a/src/turbo/distance/avx512_fp16/half_float/cosine.h b/src/turbo/distance/avx512_fp16/half_float/cosine.h
new file mode 100644
index 000000000..2b57bcf9e
--- /dev/null
+++ b/src/turbo/distance/avx512_fp16/half_float/cosine.h
@@ -0,0 +1,30 @@
+// Copyright 2025-present the zvec project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#pragma once
+
+#include <cstddef>
+
+namespace zvec::turbo::avx512_fp16 {
+
+// Compute cosine distance (negative inner product after normalization) between
+// a single quantized FP32 vector pair.
+void cosine_fp16_distance(const void *a, const void *b, size_t dim,
+                          float *distance);
+
+// Batch version of cosine_fp32_distance.
+void cosine_fp16_batch_distance(const void *const *vectors, const void *query,
+                                size_t n, size_t dim, float *distances);
+
+}  // namespace zvec::turbo::avx512_fp16
\ No newline at end of file
diff --git a/src/turbo/distance/avx512_fp16/half_float/inner_product.cc b/src/turbo/distance/avx512_fp16/half_float/inner_product.cc
new file mode 100644
index 000000000..c7262577d
--- /dev/null
+++ b/src/turbo/distance/avx512_fp16/half_float/inner_product.cc
@@ -0,0 +1,112 @@
+// Copyright 2025-present the zvec project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include <cstddef>
+
+#if defined(__AVX512FP16__)
+#include <immintrin.h>
+#include <zvec/ailego/utility/float_helper.h>
+#include "avx512_fp16/half_float/inner_product.h"
+#include "avx512_fp16/half_float/inner_product_common.h"
+
+using namespace zvec::ailego;
+
+using namespace zvec::turbo::avx512_fp16::internal;
+
+#endif
+
+namespace zvec::turbo::avx512_fp16 {
+
+// Compute squared Euclidean distance between a single quantized FP16
+// vector pair.
+void inner_product_fp16_distance(const void *a, const void *b, size_t dim,
+                                 float *distance) {
+#if defined(__AVX512FP16__)
+  const Float16 *lhs = reinterpret_cast<const Float16 *>(a);
+  const Float16 *rhs = reinterpret_cast<const Float16 *>(b);
+
+  const Float16 *last = lhs + dim;
+  const Float16 *last_aligned = lhs + ((dim >> 6) << 6);
+
+  __m512h zmm_sum_0 = _mm512_setzero_ph();
+  __m512h zmm_sum_1 = _mm512_setzero_ph();
+
+  if (((uintptr_t)lhs & 0x3f) == 0 && ((uintptr_t)rhs & 0x3f) == 0) {
+    for (; lhs != last_aligned; lhs += 64, rhs += 64) {
+      FMA_FP16_AVX512FP16(_mm512_load_ph(lhs + 0), _mm512_load_ph(rhs + 0),
+                          zmm_sum_0)
+
+      FMA_FP16_AVX512FP16(_mm512_load_ph(lhs + 32), _mm512_load_ph(rhs + 32),
+                          zmm_sum_1)
+    }
+
+    if (last >= last_aligned + 32) {
+      FMA_FP16_AVX512FP16(_mm512_load_ph(lhs), _mm512_load_ph(rhs), zmm_sum_0)
+      lhs += 32;
+      rhs += 32;
+    }
+  } else {
+    for (; lhs != last_aligned; lhs += 64, rhs += 64) {
+      FMA_FP16_AVX512FP16(_mm512_loadu_ph(lhs + 0), _mm512_loadu_ph(rhs + 0),
+                          zmm_sum_0)
+
+      FMA_FP16_AVX512FP16(_mm512_loadu_ph(lhs + 32), _mm512_loadu_ph(rhs + 32),
+                          zmm_sum_1)
+    }
+
+    if (last >= last_aligned + 32) {
+      FMA_FP16_AVX512FP16(_mm512_loadu_ph(lhs), _mm512_loadu_ph(rhs), zmm_sum_0)
+      lhs += 32;
+      rhs += 32;
+    }
+  }
+
+  zmm_sum_0 = _mm512_add_ph(zmm_sum_0, zmm_sum_1);
+
+  if (lhs != last) {
+    __mmask32 mask = (__mmask32)((1 << (last - lhs)) - 1);
+    __m512i zmm_undefined = _mm512_undefined_epi32();
+    zmm_sum_0 = _mm512_mask3_fmadd_ph(
+        _mm512_castsi512_ph(_mm512_mask_loadu_epi16(zmm_undefined, mask, lhs)),
+        _mm512_castsi512_ph(_mm512_mask_loadu_epi16(zmm_undefined, mask, rhs)),
+        zmm_sum_0, mask);
+  }
+
+  *distance = -1 * HorizontalAdd_FP16_V512(zmm_sum_0);
+#else
+  (void)a;
+  (void)b;
+  (void)dim;
+  (void)distance;
+#endif
+}
+
+// Batch version of inner_product_fp16_distance.
+void inner_product_fp16_batch_distance(const void *const *vectors,
+                                       const void *query, size_t n, size_t dim,
+                                       float *distances) {
+#if defined(__AVX512FP16__)
+  for (size_t i = 0; i < n; ++i) {
+    inner_product_fp16_distance(vectors[i], query, dim, &distances[i]);
+  }
+#else
+  (void)vectors;
+  (void)query;
+  (void)n;
+  (void)dim;
+  (void)distances;
+#endif  // __AVX512FP16__
+}
+
+}  // namespace zvec::turbo::avx512_fp16
\ No newline at end of file
diff --git a/src/turbo/distance/avx512_fp16/half_float/inner_product.h b/src/turbo/distance/avx512_fp16/half_float/inner_product.h
new file mode 100644
index 000000000..a80944713
--- /dev/null
+++ b/src/turbo/distance/avx512_fp16/half_float/inner_product.h
@@ -0,0 +1,31 @@
+// Copyright 2025-present the zvec project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#pragma once
+
+#include <cstddef>
+
+namespace zvec::turbo::avx512_fp16 {
+
+// Compute inner product distance between a single quantized FP16
+// vector pair.
+void inner_product_fp16_distance(const void *a, const void *b, size_t dim,
+                                 float *distance);
+
+// Batch version of inner_product_fp32_distance.
+void inner_product_fp16_batch_distance(const void *const *vectors,
+                                       const void *query, size_t n, size_t dim,
+                                       float *distances);
+
+}  // namespace zvec::turbo::avx512_fp16
diff --git a/src/turbo/distance/avx512_fp16/half_float/inner_product_common.h b/src/turbo/distance/avx512_fp16/half_float/inner_product_common.h
new file mode 100644
index 000000000..30921e038
--- /dev/null
+++ b/src/turbo/distance/avx512_fp16/half_float/inner_product_common.h
@@ -0,0 +1,53 @@
+// Copyright 2025-present the zvec project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#pragma once
+
+#if defined(__AVX512FP16__)
+#include <immintrin.h>
+#include <array>
+#include <cstdint>
+
+namespace zvec::turbo::avx512_fp16::internal {
+
+//! Calculate Fused-Multiply-Add (AVX512FP16)
+#define FMA_FP16_AVX512FP16(zmm_m, zmm_q, zmm_sum) \
+  zmm_sum = _mm512_fmadd_ph(zmm_m, zmm_q, zmm_sum);
+
+static inline float HorizontalAdd_FP32_V256(__m256 v) {
+  __m256 x1 = _mm256_hadd_ps(v, v);
+  __m256 x2 = _mm256_hadd_ps(x1, x1);
+  __m128 x3 = _mm256_extractf128_ps(x2, 1);
+  __m128 x4 = _mm_add_ss(_mm256_castps256_ps128(x2), x3);
+  return _mm_cvtss_f32(x4);
+}
+
+static inline float HorizontalAdd_FP32_V512(__m512 v) {
+  __m256 low = _mm512_castps512_ps256(v);
+  __m256 high =
+      _mm256_castpd_ps(_mm512_extractf64x4_pd(_mm512_castps_pd(v), 1));
+  return HorizontalAdd_FP32_V256(_mm256_add_ps(low, high));
+}
+
+static inline float HorizontalAdd_FP16_V512(__m512h v) {
+  __m512 low = _mm512_cvtxph_ps(_mm512_castph512_ph256(v));
+  __m512 high = _mm512_cvtxph_ps(
+      _mm256_castpd_ph(_mm512_extractf64x4_pd(_mm512_castph_pd(v), 1)));
+
+  return HorizontalAdd_FP32_V512(_mm512_add_ps(low, high));
+}
+
+}  // namespace zvec::turbo::avx512_fp16::internal
+
+#endif  // defined(__AVX512FP16__)
diff --git a/src/turbo/distance/avx512_fp16/half_float/squared_euclidean.cc b/src/turbo/distance/avx512_fp16/half_float/squared_euclidean.cc
new file mode 100644
index 000000000..5e33255b3
--- /dev/null
+++ b/src/turbo/distance/avx512_fp16/half_float/squared_euclidean.cc
@@ -0,0 +1,114 @@
+// Copyright 2025-present the zvec project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include <cstddef>
+
+#if defined(__AVX512F__)
+#include <immintrin.h>
+#include <zvec/ailego/utility/float_helper.h>
+#include "avx512_fp16/half_float/squared_euclidean.h"
+#include "avx512_fp16/half_float/squared_euclidean_common.h"
+
+using namespace zvec::ailego;
+
+using namespace zvec::turbo::avx512_fp16::internal;
+
+#endif
+
+namespace zvec::turbo::avx512_fp16 {
+
+void squared_euclidean_fp16_distance(const void *a, const void *b, size_t dim,
+                                     float *distance) {
+#if defined(__AVX512FP16__)
+  const Float16 *lhs = reinterpret_cast<const Float16 *>(a);
+  const Float16 *rhs = reinterpret_cast<const Float16 *>(b);
+
+  const Float16 *last = lhs + dim;
+  const Float16 *last_aligned = lhs + ((dim >> 6) << 6);
+
+  __m512h zmm_sum_0 = _mm512_setzero_ph();
+  __m512h zmm_sum_1 = _mm512_setzero_ph();
+
+  if (((uintptr_t)lhs & 0x3f) == 0 && ((uintptr_t)rhs & 0x3f) == 0) {
+    for (; lhs != last_aligned; lhs += 64, rhs += 64) {
+      __m512h zmm_d_0 =
+          _mm512_sub_ph(_mm512_load_ph(lhs + 0), _mm512_load_ph(rhs + 0));
+      __m512h zmm_d_1 =
+          _mm512_sub_ph(_mm512_load_ph(lhs + 32), _mm512_load_ph(rhs + 32));
+      zmm_sum_0 = _mm512_fmadd_ph(zmm_d_0, zmm_d_0, zmm_sum_0);
+      zmm_sum_1 = _mm512_fmadd_ph(zmm_d_1, zmm_d_1, zmm_sum_1);
+    }
+
+    if (last >= last_aligned + 32) {
+      __m512h zmm_d = _mm512_sub_ph(_mm512_load_ph(lhs), _mm512_load_ph(rhs));
+      zmm_sum_0 = _mm512_fmadd_ph(zmm_d, zmm_d, zmm_sum_0);
+      lhs += 32;
+      rhs += 32;
+    }
+  } else {
+    for (; lhs != last_aligned; lhs += 64, rhs += 64) {
+      __m512h zmm_d_0 =
+          _mm512_sub_ph(_mm512_loadu_ph(lhs + 0), _mm512_loadu_ph(rhs + 0));
+      __m512h zmm_d_1 =
+          _mm512_sub_ph(_mm512_loadu_ph(lhs + 32), _mm512_loadu_ph(rhs + 32));
+      zmm_sum_0 = _mm512_fmadd_ph(zmm_d_0, zmm_d_0, zmm_sum_0);
+      zmm_sum_1 = _mm512_fmadd_ph(zmm_d_1, zmm_d_1, zmm_sum_1);
+    }
+
+    if (last >= last_aligned + 32) {
+      __m512h zmm_d = _mm512_sub_ph(_mm512_loadu_ph(lhs), _mm512_loadu_ph(rhs));
+      zmm_sum_0 = _mm512_fmadd_ph(zmm_d, zmm_d, zmm_sum_0);
+      lhs += 32;
+      rhs += 32;
+    }
+  }
+
+  zmm_sum_0 = _mm512_add_ph(zmm_sum_0, zmm_sum_1);
+  if (lhs != last) {
+    __mmask32 mask = (__mmask32)((1 << (last - lhs)) - 1);
+    __m512i zmm_undefined = _mm512_undefined_epi32();
+    __m512h zmm_undefined_ph = _mm512_undefined_ph();
+    __m512h zmm_d = _mm512_mask_sub_ph(
+        zmm_undefined_ph, mask,
+        _mm512_castsi512_ph(_mm512_mask_loadu_epi16(zmm_undefined, mask, lhs)),
+        _mm512_castsi512_ph(_mm512_mask_loadu_epi16(zmm_undefined, mask, rhs)));
+    zmm_sum_0 = _mm512_mask3_fmadd_ph(zmm_d, zmm_d, zmm_sum_0, mask);
+  }
+
+  *distance = HorizontalAdd_FP16_V512(zmm_sum_0);
+#else
+  (void)a;
+  (void)b;
+  (void)dim;
+  (void)distance;
+#endif  // __AVX512FP16__
+}
+
+void squared_euclidean_fp32_batch_distance(const void *const *vectors,
+                                           const void *query, size_t n,
+                                           size_t dim, float *distances) {
+#if defined(__AVX512FP16__)
+  for (size_t i = 0; i < n; ++i) {
+    squared_euclidean_fp16_distance(vectors[i], query, dim, &distances[i]);
+  }
+#else
+  (void)vectors;
+  (void)query;
+  (void)n;
+  (void)dim;
+  (void)distances;
+#endif  //__AVX512FP16__
+}
+
+}  // namespace zvec::turbo::avx512_fp16
\ No newline at end of file
diff --git a/src/turbo/distance/avx512_fp16/half_float/squared_euclidean.h b/src/turbo/distance/avx512_fp16/half_float/squared_euclidean.h
new file mode 100644
index 000000000..669749f51
--- /dev/null
+++ b/src/turbo/distance/avx512_fp16/half_float/squared_euclidean.h
@@ -0,0 +1,31 @@
+// Copyright 2025-present the zvec project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#pragma once
+
+#include <cstddef>
+
+namespace zvec::turbo::avx512_fp16 {
+
+// Compute squared euclidean distance between a single quantized FP32
+// vector pair.
+void squared_euclidean_fp16_distance(const void *a, const void *b, size_t dim,
+                                     float *distance);
+
+// Batch version of squared euclidean FP32.
+void squared_euclidean_fp16_batch_distance(const void *const *vectors,
+                                           const void *query, size_t n,
+                                           size_t dim, float *distances);
+
+}  // namespace zvec::turbo::avx512_fp16
diff --git a/src/turbo/distance/avx512_fp16/half_float/squared_euclidean_common.h b/src/turbo/distance/avx512_fp16/half_float/squared_euclidean_common.h
new file mode 100644
index 000000000..b5f91988e
--- /dev/null
+++ b/src/turbo/distance/avx512_fp16/half_float/squared_euclidean_common.h
@@ -0,0 +1,49 @@
+// Copyright 2025-present the zvec project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#pragma once
+
+#if defined(__AVX512FP16__)
+#include <immintrin.h>
+#include <array>
+#include <cstdint>
+
+namespace zvec::turbo::avx512_fp16::internal {
+
+static inline float HorizontalAdd_FP32_V256(__m256 v) {
+  __m256 x1 = _mm256_hadd_ps(v, v);
+  __m256 x2 = _mm256_hadd_ps(x1, x1);
+  __m128 x3 = _mm256_extractf128_ps(x2, 1);
+  __m128 x4 = _mm_add_ss(_mm256_castps256_ps128(x2), x3);
+  return _mm_cvtss_f32(x4);
+}
+
+static inline float HorizontalAdd_FP32_V512(__m512 v) {
+  __m256 low = _mm512_castps512_ps256(v);
+  __m256 high =
+      _mm256_castpd_ps(_mm512_extractf64x4_pd(_mm512_castps_pd(v), 1));
+  return HorizontalAdd_FP32_V256(_mm256_add_ps(low, high));
+}
+
+static inline float HorizontalAdd_FP16_V512(__m512h v) {
+  __m512 low = _mm512_cvtxph_ps(_mm512_castph512_ph256(v));
+  __m512 high = _mm512_cvtxph_ps(
+      _mm256_castpd_ph(_mm512_extractf64x4_pd(_mm512_castph_pd(v), 1)));
+
+  return HorizontalAdd_FP32_V512(_mm512_add_ps(low, high));
+}
+
+}  // namespace zvec::turbo::avx512_fp16::internal
+
+#endif  // defined(__AVX512FP16__)
diff --git a/src/turbo/avx512_vnni/record_quantized_int8/common.h b/src/turbo/distance/avx512_vnni/record_quantized_int8/common.h
similarity index 100%
rename from src/turbo/avx512_vnni/record_quantized_int8/common.h
rename to src/turbo/distance/avx512_vnni/record_quantized_int8/common.h
diff --git a/src/turbo/avx512_vnni/record_quantized_int8/cosine.cc b/src/turbo/distance/avx512_vnni/record_quantized_int8/cosine.cc
similarity index 67%
rename from src/turbo/avx512_vnni/record_quantized_int8/cosine.cc
rename to src/turbo/distance/avx512_vnni/record_quantized_int8/cosine.cc
index 54caed6a4..bbfbf1f67 100644
--- a/src/turbo/avx512_vnni/record_quantized_int8/cosine.cc
+++ b/src/turbo/distance/avx512_vnni/record_quantized_int8/cosine.cc
@@ -21,6 +21,8 @@
 #if defined(__AVX512VNNI__) || (defined(_MSC_VER) && defined(__AVX512F__))
 #include <immintrin.h>
 #endif
+#include <cstring>
+#include <vector>
 
 // Tail layout for quantized INT8 cosine vectors:
 //
@@ -39,16 +41,16 @@ namespace zvec::turbo::avx512_vnni {
 void cosine_int8_distance(const void *a, const void *b, size_t dim,
                           float *distance) {
 #if defined(__AVX512VNNI__) || (defined(_MSC_VER) && defined(__AVX512F__))
-  // `dim` is the full encoded size; the original vector occupies dim-24 bytes.
-  const int original_dim = dim - 24;
+  // `dim` is the original_dim (the wrapper has already subtracted the 24-byte
+  // metadata tail). The single-distance contract here is symmetric: both `a`
+  // and `b` are raw int8 vectors (used both for query-vs-node and
+  // node-vs-node distances). Query preprocessing for the batch path is
+  // applied separately in `wrap_turbo_batch_distance`, not here.
+  const int original_dim = dim;
   if (original_dim <= 0) {
     return;
   }
 
-  // Compute raw integer inner product over the original_dim bytes.
-  // Note: for the single-vector path there is no query preprocessing, so both
-  // sides are treated as int8_t (same as the non-preprocessed path in
-  // MinusInnerProductDistanceBatchWithScoreUnquantized<int8_t>).
   internal::ip_int8_avx512_vnni(a, b, original_dim, distance);
 
   const float *a_tail = reinterpret_cast<const float *>(
@@ -64,9 +66,8 @@ void cosine_int8_distance(const void *a, const void *b, size_t dim,
   float qb = b_tail[1];
   float qs = b_tail[2];
 
-  // Dequantize and compute cosine distance:
-  //   cosine_dist = -(ma * qa * ip + mb * qa * qs + qb * ma * ms
-  //                   + original_dim * qb * mb)
+  // Dequantize and compute cosine distance numerator (-<float_a, float_b>).
+  // The metric layer's normalize() adds 1.0f to yield 1 - cos_sim.
   *distance = -(ma * qa * *distance + mb * qa * qs + qb * ma * ms +
                 static_cast<float>(original_dim) * qb * mb);
 #else
@@ -80,16 +81,31 @@ void cosine_int8_distance(const void *a, const void *b, size_t dim,
 void cosine_int8_batch_distance(const void *const *vectors, const void *query,
                                 size_t n, size_t dim, float *distances) {
 #if defined(__AVX512VNNI__) || (defined(_MSC_VER) && defined(__AVX512F__))
-  // `dim` is the full encoded size; the original vector occupies dim-24 bytes.
-  const int original_dim = dim - 24;
+  // `dim` is the original_dim (the wrapper has already subtracted the 24-byte
+  // metadata tail). The query is passed in as RAW int8; we shift the data
+  // bytes by +128 into a thread-local buffer so dpbusd (uint8 * int8) yields
+  // the correct integer inner product. The corresponding `128 * sum(int8_a)`
+  // bias is removed below using the precomputed `int8_sum` per stored vector.
+  const int original_dim = dim;
   if (original_dim <= 0) {
     return;
   }
 
-  // Compute raw inner products for all vectors. The query has been preprocessed
-  // (int8 + 128 -> uint8) so dpbusd can be used via ip_int8_batch_avx512_vnni.
-  internal::ip_int8_batch_avx512_vnni(vectors, query, n, original_dim,
-                                      distances);
+  // Shift the data portion of the query (+128) into a thread-local buffer so
+  // dpbusd (uint8 * int8) yields the correct integer inner product. The query
+  // metadata tail (3 floats: qa/qb/qs) is read directly from the caller's
+  // query buffer below to avoid touching memory we don't need to.
+  thread_local std::vector<uint8_t> query_buf;
+  const size_t data_bytes = static_cast<size_t>(original_dim);
+  if (query_buf.size() < data_bytes) {
+    query_buf.resize(data_bytes);
+  }
+  std::memcpy(query_buf.data(), query, data_bytes);
+  internal::shift_int8_to_uint8_avx512(query_buf.data(), original_dim);
+
+  // Compute raw inner products for all vectors using dpbusd (uint8 * int8).
+  internal::ip_int8_batch_avx512_vnni(vectors, query_buf.data(), n,
+                                      original_dim, distances);
 
   const float *q_tail = reinterpret_cast<const float *>(
       reinterpret_cast<const int8_t *>(query) + original_dim);
@@ -112,9 +128,8 @@ void cosine_int8_batch_distance(const void *const *vectors, const void *query,
     float &result = distances[i];
     result -= 128.0f * static_cast<float>(int8_sum);
 
-    // Dequantize and compute cosine distance:
-    //   cosine_dist = -(ma * qa * ip + mb * qa * qs + qb * ma * ms
-    //                   + original_dim * qb * mb)
+    // Dequantize and compute cosine distance numerator (-<float_a, float_b>).
+    // The metric layer's normalize() adds 1.0f to yield 1 - cos_sim.
     result = -(ma * qa * result + mb * qa * qs + qb * ma * ms +
                static_cast<float>(original_dim) * qb * mb);
   }
@@ -130,7 +145,7 @@ void cosine_int8_batch_distance(const void *const *vectors, const void *query,
 void cosine_int8_query_preprocess(void *query, size_t dim) {
 #if defined(__AVX512VNNI__) || (defined(_MSC_VER) && defined(__AVX512F__))
   // The original vector occupies dim-24 bytes; only those bytes are shifted.
-  const int original_dim = static_cast<int>(dim) - 24;
+  const int original_dim = static_cast<int>(dim);
   if (original_dim <= 0) {
     return;
   }
diff --git a/src/turbo/avx512_vnni/record_quantized_int8/cosine.h b/src/turbo/distance/avx512_vnni/record_quantized_int8/cosine.h
similarity index 100%
rename from src/turbo/avx512_vnni/record_quantized_int8/cosine.h
rename to src/turbo/distance/avx512_vnni/record_quantized_int8/cosine.h
diff --git a/src/turbo/distance/avx512_vnni/record_quantized_int8/inner_product.cc b/src/turbo/distance/avx512_vnni/record_quantized_int8/inner_product.cc
new file mode 100644
index 000000000..02b0ea353
--- /dev/null
+++ b/src/turbo/distance/avx512_vnni/record_quantized_int8/inner_product.cc
@@ -0,0 +1,65 @@
+// Copyright 2025-present the zvec project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "avx512_vnni/record_quantized_int8/inner_product.h"
+#include <cstdint>
+#include "avx512_vnni/record_quantized_int8/common.h"
+
+namespace zvec::turbo::avx512_vnni {
+
+// Compute squared Euclidean distance between a single quantized int8
+// vector pair.
+void inner_product_int8_distance(const void *a, const void *b, size_t dim,
+                                 float *distance) {
+  const size_t original_dim = dim;
+
+  if (original_dim <= 0) {
+    return;
+  }
+
+  internal::ip_int8_avx512_vnni(a, b, original_dim, distance);
+
+  const float *a_tail = reinterpret_cast<const float *>(
+      reinterpret_cast<const int8_t *>(a) + original_dim);
+  const float *b_tail = reinterpret_cast<const float *>(
+      reinterpret_cast<const int8_t *>(b) + original_dim);
+
+  float qa = a_tail[0];
+  float qb = a_tail[1];
+  float qs = a_tail[2];
+
+  float ma = b_tail[0];
+  float mb = b_tail[1];
+  float ms = b_tail[2];
+
+  *distance = -(ma * qa * *distance + mb * qa * qs + qb * ma * ms +
+                original_dim * qb * mb);
+}
+
+// Batch version of inner_product_int8_distance.
+void inner_product_int8_batch_distance(const void *const *vectors,
+                                       const void *query, size_t n, size_t dim,
+                                       float *distances) {
+#if defined(__AVX512VNNI__)
+  internal::ip_int8_batch_avx512_vnni(vectors, query, n, dim, distances);
+#else
+  (void)vectors;
+  (void)query;
+  (void)n;
+  (void)dim;
+  (void)distances;
+#endif  // __AVX512VNNI__
+}
+
+}  // namespace zvec::turbo::avx512_vnni
\ No newline at end of file
diff --git a/src/turbo/distance/avx512_vnni/record_quantized_int8/inner_product.h b/src/turbo/distance/avx512_vnni/record_quantized_int8/inner_product.h
new file mode 100644
index 000000000..25f0ce109
--- /dev/null
+++ b/src/turbo/distance/avx512_vnni/record_quantized_int8/inner_product.h
@@ -0,0 +1,31 @@
+// Copyright 2025-present the zvec project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#pragma once
+
+#include <cstddef>
+
+namespace zvec::turbo::avx512_vnni {
+
+// Compute inner product distance between a single quantized int8
+// vector pair.
+void inner_product_int8_distance(const void *a, const void *b, size_t dim,
+                                 float *distance);
+
+// Batch version of inner_product_int8_distance.
+void inner_product_int8_batch_distance(const void *const *vectors,
+                                       const void *query, size_t n, size_t dim,
+                                       float *distances);
+
+}  // namespace zvec::turbo::avx512_vnni
diff --git a/src/turbo/avx512_vnni/record_quantized_int8/squared_euclidean.cc b/src/turbo/distance/avx512_vnni/record_quantized_int8/squared_euclidean.cc
similarity index 78%
rename from src/turbo/avx512_vnni/record_quantized_int8/squared_euclidean.cc
rename to src/turbo/distance/avx512_vnni/record_quantized_int8/squared_euclidean.cc
index 16590af10..b66ec7433 100644
--- a/src/turbo/avx512_vnni/record_quantized_int8/squared_euclidean.cc
+++ b/src/turbo/distance/avx512_vnni/record_quantized_int8/squared_euclidean.cc
@@ -21,6 +21,8 @@
 #if defined(__AVX512VNNI__) || (defined(_MSC_VER) && defined(__AVX512F__))
 #include <immintrin.h>
 #endif
+#include <cstring>
+#include <vector>
 
 // Tail layout for quantized INT8 squared Euclidean vectors:
 //
@@ -39,7 +41,12 @@ namespace zvec::turbo::avx512_vnni {
 void squared_euclidean_int8_distance(const void *a, const void *b, size_t dim,
                                      float *distance) {
 #if defined(__AVX512VNNI__) || (defined(_MSC_VER) && defined(__AVX512F__))
-  const int original_dim = dim - 20;
+  // `dim` is the original_dim (the wrapper has already subtracted the 20-byte
+  // metadata tail). The single-distance contract here is symmetric: both `a`
+  // and `b` are raw int8 vectors (used for both query-vs-node and node-vs-node
+  // distances). Query preprocessing (+128 shift) for the batch path is done
+  // internally by `squared_euclidean_int8_batch_distance`, not here.
+  const int original_dim = dim;
   if (original_dim <= 0) {
     return;
   }
@@ -78,10 +85,28 @@ void squared_euclidean_int8_batch_distance(const void *const *vectors,
                                            const void *query, size_t n,
                                            size_t dim, float *distances) {
 #if defined(__AVX512VNNI__) || (defined(_MSC_VER) && defined(__AVX512F__))
-  const int original_dim = dim - 20;
+  // `dim` is the original_dim (the wrapper has already subtracted the 20-byte
+  // metadata tail). The query is passed in as RAW int8; we shift the data
+  // bytes by +128 into a thread-local buffer so dpbusd (uint8 * int8) yields
+  // the correct integer inner product. The corresponding `128 * sum(int8_a)`
+  // bias is removed below using the precomputed `int8_sum` per stored vector.
+  const int original_dim = dim;
   if (original_dim <= 0) {
     return;
   }
+
+  // Shift the data portion of the query (+128) into a thread-local buffer.
+  // The query metadata tail (4 floats: qa/qb/qs/qs2) is read directly from the
+  // caller's query buffer below.
+  thread_local std::vector<uint8_t> query_buf;
+  const size_t data_bytes = static_cast<size_t>(original_dim);
+  if (query_buf.size() < data_bytes) {
+    query_buf.resize(data_bytes);
+  }
+  std::memcpy(query_buf.data(), query, data_bytes);
+  internal::shift_int8_to_uint8_avx512(query_buf.data(), original_dim);
+  const void *shifted_query = query_buf.data();
+
   static constexpr size_t batch_size = 12;
   static constexpr size_t prefetch_step = 2;
   size_t i = 0;
@@ -108,7 +133,8 @@ void squared_euclidean_int8_batch_distance(const void *const *vectors,
       }
     }
     internal::ip_int8_batch_avx512_vnni_impl<batch_size>(
-        query, &vectors[i], prefetch_ptrs, original_dim, ip_dists.data());
+        shifted_query, &vectors[i], prefetch_ptrs, original_dim,
+        ip_dists.data());
     for (size_t j = 0; j < batch_size; ++j) {
       const float *m_tail = reinterpret_cast<const float *>(
           reinterpret_cast<const int8_t *>(data_ptrs_ptr[j]) + original_dim);
@@ -131,7 +157,7 @@ void squared_euclidean_int8_batch_distance(const void *const *vectors,
     std::array<const void *, 1> prefetch_ptrs{nullptr};
     float ip_dist;
     internal::ip_int8_batch_avx512_vnni_impl<1>(
-        query, &vectors[i], prefetch_ptrs, original_dim, &ip_dist);
+        shifted_query, &vectors[i], prefetch_ptrs, original_dim, &ip_dist);
     const float *m_tail = reinterpret_cast<const float *>(
         reinterpret_cast<const int8_t *>(data_ptrs_ptr[0]) + original_dim);
     float mA = m_tail[0];
diff --git a/src/turbo/avx512_vnni/record_quantized_int8/squared_euclidean.h b/src/turbo/distance/avx512_vnni/record_quantized_int8/squared_euclidean.h
similarity index 100%
rename from src/turbo/avx512_vnni/record_quantized_int8/squared_euclidean.h
rename to src/turbo/distance/avx512_vnni/record_quantized_int8/squared_euclidean.h
diff --git a/src/turbo/distance/scalar/float32/cosine.cc b/src/turbo/distance/scalar/float32/cosine.cc
new file mode 100644
index 000000000..17a36f181
--- /dev/null
+++ b/src/turbo/distance/scalar/float32/cosine.cc
@@ -0,0 +1,40 @@
+// Copyright 2025-present the zvec project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "scalar/float32/cosine.h"
+#include "scalar/float32/inner_product.h"
+
+namespace zvec::turbo::scalar {
+
+void cosine_fp32_distance(const void *a, const void *b, size_t dim,
+                          float *distance) {
+  // inner_product_fp32_distance returns -real_IP; cosine = 1 - real_IP = 1 +
+  // ip.
+  float ip;
+  inner_product_fp32_distance(a, b, dim, &ip);
+
+  *distance = 1 + ip;
+}
+
+void cosine_fp32_batch_distance(const void *const *vectors, const void *query,
+                                size_t n, size_t dim, float *distances) {
+  inner_product_fp32_batch_distance(vectors, query, n, dim, distances);
+  // inner_product batch returns -real_IP per element; cosine = 1 - real_IP = 1
+  // + d.
+  for (size_t i = 0; i < n; i++) {
+    distances[i] = 1 + distances[i];
+  }
+}
+
+}  // namespace zvec::turbo::scalar
\ No newline at end of file
diff --git a/src/turbo/distance/scalar/float32/cosine.h b/src/turbo/distance/scalar/float32/cosine.h
new file mode 100644
index 000000000..b5e4f4eee
--- /dev/null
+++ b/src/turbo/distance/scalar/float32/cosine.h
@@ -0,0 +1,30 @@
+// Copyright 2025-present the zvec project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#pragma once
+
+#include <cstddef>
+
+namespace zvec::turbo::scalar {
+
+// Compute cosine distance (negative inner product after normalization) between
+// a single quantized FP32 vector pair.
+void cosine_fp32_distance(const void *a, const void *b, size_t dim,
+                          float *distance);
+
+// Batch version of cosine_fp32_distance.
+void cosine_fp32_batch_distance(const void *const *vectors, const void *query,
+                                size_t n, size_t dim, float *distances);
+
+}  // namespace zvec::turbo::scalar
\ No newline at end of file
diff --git a/src/turbo/distance/scalar/float32/inner_product.cc b/src/turbo/distance/scalar/float32/inner_product.cc
new file mode 100644
index 000000000..23a282ef3
--- /dev/null
+++ b/src/turbo/distance/scalar/float32/inner_product.cc
@@ -0,0 +1,43 @@
+// Copyright 2025-present the zvec project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "scalar/float32/inner_product.h"
+
+namespace zvec::turbo::scalar {
+
+// Compute squared Euclidean distance between a single quantized FP32
+// vector pair.
+void inner_product_fp32_distance(const void *a, const void *b, size_t dim,
+                                 float *distance) {
+  const float *m = reinterpret_cast<const float *>(a);
+  const float *q = reinterpret_cast<const float *>(b);
+
+  float sum = 0.0;
+  for (size_t i = 0; i < dim; ++i) {
+    sum += static_cast<float>(m[i] * q[i]);
+  }
+
+  *distance = -sum;
+}
+
+// Batch version of inner_product_fp32_distance.
+void inner_product_fp32_batch_distance(const void *const *vectors,
+                                       const void *query, size_t n, size_t dim,
+                                       float *distances) {
+  for (size_t i = 0; i < n; ++i) {
+    inner_product_fp32_distance(vectors[i], query, dim, &distances[i]);
+  }
+}
+
+}  // namespace zvec::turbo::scalar
\ No newline at end of file
diff --git a/src/turbo/distance/scalar/float32/inner_product.h b/src/turbo/distance/scalar/float32/inner_product.h
new file mode 100644
index 000000000..d4e03418e
--- /dev/null
+++ b/src/turbo/distance/scalar/float32/inner_product.h
@@ -0,0 +1,31 @@
+// Copyright 2025-present the zvec project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#pragma once
+
+#include <cstddef>
+
+namespace zvec::turbo::scalar {
+
+// Compute inner product distance between a single quantized FP32
+// vector pair.
+void inner_product_fp32_distance(const void *a, const void *b, size_t dim,
+                                 float *distance);
+
+// Batch version of inner_product_fp32_distance.
+void inner_product_fp32_batch_distance(const void *const *vectors,
+                                       const void *query, size_t n, size_t dim,
+                                       float *distances);
+
+}  // namespace zvec::turbo::scalar
diff --git a/src/turbo/distance/scalar/float32/squared_euclidean.cc b/src/turbo/distance/scalar/float32/squared_euclidean.cc
new file mode 100644
index 000000000..a3ffd10bb
--- /dev/null
+++ b/src/turbo/distance/scalar/float32/squared_euclidean.cc
@@ -0,0 +1,41 @@
+// Copyright 2025-present the zvec project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "scalar/float32/squared_euclidean.h"
+#include <ailego/utility/math_helper.h>
+
+namespace zvec::turbo::scalar {
+
+void squared_euclidean_fp32_distance(const void *a, const void *b, size_t dim,
+                                     float *distance) {
+  const float *m = reinterpret_cast<const float *>(a);
+  const float *q = reinterpret_cast<const float *>(b);
+
+  float sum = 0.0;
+  for (size_t i = 0; i < dim; ++i) {
+    sum += zvec::ailego::MathHelper::SquaredDifference(m[i], q[i]);
+  }
+
+  *distance = sum;
+}
+
+void squared_euclidean_fp32_batch_distance(const void *const *vectors,
+                                           const void *query, size_t n,
+                                           size_t dim, float *distances) {
+  for (size_t i = 0; i < n; ++i) {
+    squared_euclidean_fp32_distance(vectors[i], query, dim, &distances[i]);
+  }
+}
+
+}  // namespace zvec::turbo::scalar
\ No newline at end of file
diff --git a/src/turbo/distance/scalar/float32/squared_euclidean.h b/src/turbo/distance/scalar/float32/squared_euclidean.h
new file mode 100644
index 000000000..bf319c1d2
--- /dev/null
+++ b/src/turbo/distance/scalar/float32/squared_euclidean.h
@@ -0,0 +1,31 @@
+// Copyright 2025-present the zvec project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#pragma once
+
+#include <cstddef>
+
+namespace zvec::turbo::scalar {
+
+// Compute squared euclidean distance between a single quantized FP32
+// vector pair.
+void squared_euclidean_fp32_distance(const void *a, const void *b, size_t dim,
+                                     float *distance);
+
+// Batch version of squared euclidean FP32.
+void squared_euclidean_fp32_batch_distance(const void *const *vectors,
+                                           const void *query, size_t n,
+                                           size_t dim, float *distances);
+
+}  // namespace zvec::turbo::scalar
diff --git a/src/turbo/distance/scalar/half_float/cosine.cc b/src/turbo/distance/scalar/half_float/cosine.cc
new file mode 100644
index 000000000..dbeecb5d2
--- /dev/null
+++ b/src/turbo/distance/scalar/half_float/cosine.cc
@@ -0,0 +1,35 @@
+// Copyright 2025-present the zvec project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "scalar/half_float/cosine.h"
+#include "scalar/half_float/inner_product.h"
+
+namespace zvec::turbo::scalar {
+
+void cosine_fp16_distance(const void *a, const void *b, size_t dim,
+                          float *distance) {
+  float ip;
+  inner_product_fp16_distance(a, b, dim, &ip);
+
+  *distance = 1 - ip;
+}
+
+void cosine_fp16_batch_distance(const void *const *vectors, const void *query,
+                                size_t n, size_t dim, float *distances) {
+  for (size_t i = 0; i < n; ++i) {
+    cosine_fp16_distance(vectors[i], query, dim, &distances[i]);
+  }
+}
+
+}  // namespace zvec::turbo::scalar
\ No newline at end of file
diff --git a/src/turbo/distance/scalar/half_float/cosine.h b/src/turbo/distance/scalar/half_float/cosine.h
new file mode 100644
index 000000000..cb82bc893
--- /dev/null
+++ b/src/turbo/distance/scalar/half_float/cosine.h
@@ -0,0 +1,30 @@
+// Copyright 2025-present the zvec project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#pragma once
+
+#include <cstddef>
+
+namespace zvec::turbo::scalar {
+
+// Compute cosine distance (negative inner product after normalization) between
+// a single quantized FP16 vector pair.
+void cosine_fp16_distance(const void *a, const void *b, size_t dim,
+                          float *distance);
+
+// Batch version of cosine_fp16_distance.
+void cosine_fp16_batch_distance(const void *const *vectors, const void *query,
+                                size_t n, size_t dim, float *distances);
+
+}  // namespace zvec::turbo::scalar
\ No newline at end of file
diff --git a/src/turbo/distance/scalar/half_float/inner_product.cc b/src/turbo/distance/scalar/half_float/inner_product.cc
new file mode 100644
index 000000000..d06c45b25
--- /dev/null
+++ b/src/turbo/distance/scalar/half_float/inner_product.cc
@@ -0,0 +1,46 @@
+// Copyright 2025-present the zvec project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "scalar/half_float/inner_product.h"
+#include <zvec/ailego/utility/float_helper.h>
+
+namespace zvec::turbo::scalar {
+
+// Compute squared Euclidean distance between a single quantized FP16
+// vector pair.
+void inner_product_fp16_distance(const void *a, const void *b, size_t dim,
+                                 float *distance) {
+  const zvec::ailego::Float16 *m =
+      reinterpret_cast<const zvec::ailego::Float16 *>(a);
+  const zvec::ailego::Float16 *q =
+      reinterpret_cast<const zvec::ailego::Float16 *>(b);
+
+  float sum = 0.0;
+  for (size_t i = 0; i < dim; ++i) {
+    sum += static_cast<float>(m[i] * q[i]);
+  }
+
+  *distance = -sum;
+}
+
+// Batch version of inner_product_fp16_distance.
+void inner_product_fp16_batch_distance(const void *const *vectors,
+                                       const void *query, size_t n, size_t dim,
+                                       float *distances) {
+  for (size_t i = 0; i < n; ++i) {
+    inner_product_fp16_distance(vectors[i], query, dim, &distances[i]);
+  }
+}
+
+}  // namespace zvec::turbo::scalar
\ No newline at end of file
diff --git a/src/turbo/distance/scalar/half_float/inner_product.h b/src/turbo/distance/scalar/half_float/inner_product.h
new file mode 100644
index 000000000..98fc4cba4
--- /dev/null
+++ b/src/turbo/distance/scalar/half_float/inner_product.h
@@ -0,0 +1,31 @@
+// Copyright 2025-present the zvec project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#pragma once
+
+#include <cstddef>
+
+namespace zvec::turbo::scalar {
+
+// Compute inner product distance between a single quantized FP16
+// vector pair.
+void inner_product_fp16_distance(const void *a, const void *b, size_t dim,
+                                 float *distance);
+
+// Batch version of inner_product_fp16_distance.
+void inner_product_fp16_batch_distance(const void *const *vectors,
+                                       const void *query, size_t n, size_t dim,
+                                       float *distances);
+
+}  // namespace zvec::turbo::scalar
diff --git a/src/turbo/distance/scalar/half_float/squared_euclidean.cc b/src/turbo/distance/scalar/half_float/squared_euclidean.cc
new file mode 100644
index 000000000..c3f6b3c2e
--- /dev/null
+++ b/src/turbo/distance/scalar/half_float/squared_euclidean.cc
@@ -0,0 +1,43 @@
+// Copyright 2025-present the zvec project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "scalar/half_float/squared_euclidean.h"
+#include <ailego/utility/math_helper.h>
+
+namespace zvec::turbo::scalar {
+
+void squared_euclidean_fp16_distance(const void *a, const void *b, size_t dim,
+                                     float *distance) {
+  const zvec::ailego::Float16 *m =
+      reinterpret_cast<const zvec::ailego::Float16 *>(a);
+  const zvec::ailego::Float16 *q =
+      reinterpret_cast<const zvec::ailego::Float16 *>(b);
+
+  float sum = 0.0;
+  for (size_t i = 0; i < dim; ++i) {
+    sum += zvec::ailego::MathHelper::SquaredDifference(m[i], q[i]);
+  }
+
+  *distance = sum;
+}
+
+void squared_euclidean_fp16_batch_distance(const void *const *vectors,
+                                           const void *query, size_t n,
+                                           size_t dim, float *distances) {
+  for (size_t i = 0; i < n; ++i) {
+    squared_euclidean_fp16_distance(vectors[i], query, dim, &distances[i]);
+  }
+}
+
+}  // namespace zvec::turbo::scalar
\ No newline at end of file
diff --git a/src/turbo/distance/scalar/half_float/squared_euclidean.h b/src/turbo/distance/scalar/half_float/squared_euclidean.h
new file mode 100644
index 000000000..8865cd1c2
--- /dev/null
+++ b/src/turbo/distance/scalar/half_float/squared_euclidean.h
@@ -0,0 +1,31 @@
+// Copyright 2025-present the zvec project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#pragma once
+
+#include <cstddef>
+
+namespace zvec::turbo::scalar {
+
+// Compute squared euclidean distance between a single quantized FP16
+// vector pair.
+void squared_euclidean_fp16_distance(const void *a, const void *b, size_t dim,
+                                     float *distance);
+
+// Batch version of squared euclidean FP32.
+void squared_euclidean_fp16_batch_distance(const void *const *vectors,
+                                           const void *query, size_t n,
+                                           size_t dim, float *distances);
+
+}  // namespace zvec::turbo::scalar
diff --git a/src/turbo/distance/scalar/record_quantized_int4/common.h b/src/turbo/distance/scalar/record_quantized_int4/common.h
new file mode 100644
index 000000000..f4b74d7d3
--- /dev/null
+++ b/src/turbo/distance/scalar/record_quantized_int4/common.h
@@ -0,0 +1,59 @@
+// Copyright 2025-present the zvec project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#pragma once
+
+#include <cstdint>
+#include <zvec/ailego/internal/platform.h>
+
+namespace zvec::turbo::scalar::internal {
+
+/*! Four-bits Integer Multiplication Table
+ */
+static const AILEGO_ALIGNED(64) int8_t Int4MulTable[256] = {
+    0, 0,  0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+    0, 1,  2,   3,   4,   5,   6,   7,   -8,  -7,  -6,  -5,  -4,  -3,  -2,  -1,
+    0, 2,  4,   6,   8,   10,  12,  14,  -16, -14, -12, -10, -8,  -6,  -4,  -2,
+    0, 3,  6,   9,   12,  15,  18,  21,  -24, -21, -18, -15, -12, -9,  -6,  -3,
+    0, 4,  8,   12,  16,  20,  24,  28,  -32, -28, -24, -20, -16, -12, -8,  -4,
+    0, 5,  10,  15,  20,  25,  30,  35,  -40, -35, -30, -25, -20, -15, -10, -5,
+    0, 6,  12,  18,  24,  30,  36,  42,  -48, -42, -36, -30, -24, -18, -12, -6,
+    0, 7,  14,  21,  28,  35,  42,  49,  -56, -49, -42, -35, -28, -21, -14, -7,
+    0, -8, -16, -24, -32, -40, -48, -56, 64,  56,  48,  40,  32,  24,  16,  8,
+    0, -7, -14, -21, -28, -35, -42, -49, 56,  49,  42,  35,  28,  21,  14,  7,
+    0, -6, -12, -18, -24, -30, -36, -42, 48,  42,  36,  30,  24,  18,  12,  6,
+    0, -5, -10, -15, -20, -25, -30, -35, 40,  35,  30,  25,  20,  15,  10,  5,
+    0, -4, -8,  -12, -16, -20, -24, -28, 32,  28,  24,  20,  16,  12,  8,   4,
+    0, -3, -6,  -9,  -12, -15, -18, -21, 24,  21,  18,  15,  12,  9,   6,   3,
+    0, -2, -4,  -6,  -8,  -10, -12, -14, 16,  14,  12,  10,  8,   6,   4,   2,
+    0, -1, -2,  -3,  -4,  -5,  -6,  -7,  8,   7,   6,   5,   4,   3,   2,   1,
+};
+
+static __attribute__((always_inline)) void inner_product_int4_scalar(
+    const void *a, const void *b, size_t dim, float *distance) {
+  const uint8_t *m = reinterpret_cast<const uint8_t *>(a);
+  const uint8_t *q = reinterpret_cast<const uint8_t *>(b);
+
+  float sum = 0.0;
+  for (size_t i = 0; i < dim; ++i) {
+    uint8_t m_val = m[i];
+    uint8_t q_val = q[i];
+    sum += Int4MulTable[((m_val << 4) & 0xf0) | ((q_val >> 0) & 0xf)] +
+           Int4MulTable[((m_val >> 0) & 0xf0) | ((q_val >> 4) & 0xf)];
+  }
+
+  *distance = sum;
+}
+
+}  // namespace zvec::turbo::scalar::internal
\ No newline at end of file
diff --git a/src/turbo/distance/scalar/record_quantized_int4/cosine.cc b/src/turbo/distance/scalar/record_quantized_int4/cosine.cc
new file mode 100644
index 000000000..c1f2fe502
--- /dev/null
+++ b/src/turbo/distance/scalar/record_quantized_int4/cosine.cc
@@ -0,0 +1,58 @@
+// Copyright 2025-present the zvec project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "scalar/record_quantized_int4/cosine.h"
+#include "scalar/record_quantized_int4/common.h"
+
+namespace zvec::turbo::scalar {
+
+void cosine_int4_distance(const void *a, const void *b, size_t dim,
+                          float *distance) {
+  const int d = dim;
+  const size_t original_dim = d >> 1;
+
+  if (original_dim <= 0) {
+    return;
+  }
+
+  // inner_product_int4_scalar returns +<nibble_a, nibble_b> already.
+  internal::inner_product_int4_scalar(a, b, original_dim, distance);
+
+  const float *a_tail = reinterpret_cast<const float *>(
+      reinterpret_cast<const uint8_t *>(a) + original_dim);
+  const float *b_tail = reinterpret_cast<const float *>(
+      reinterpret_cast<const uint8_t *>(b) + original_dim);
+
+  float qa = a_tail[0];
+  float qb = a_tail[1];
+  float qs = a_tail[2];
+
+  float ma = b_tail[0];
+  float mb = b_tail[1];
+  float ms = b_tail[2];
+
+  // Returns -<float_a, float_b>; the metric's normalize() adds 1.0f to yield
+  // the cosine distance (1 - cos_sim).
+  *distance = -(ma * qa * *distance + mb * qa * qs + qb * ma * ms +
+                static_cast<float>(d) * qb * mb);
+}
+
+void cosine_int4_batch_distance(const void *const *vectors, const void *query,
+                                size_t n, size_t dim, float *distances) {
+  for (size_t i = 0; i < n; ++i) {
+    cosine_int4_distance(vectors[i], query, dim, &distances[i]);
+  }
+}
+
+}  // namespace zvec::turbo::scalar
\ No newline at end of file
diff --git a/src/turbo/distance/scalar/record_quantized_int4/cosine.h b/src/turbo/distance/scalar/record_quantized_int4/cosine.h
new file mode 100644
index 000000000..25838aa02
--- /dev/null
+++ b/src/turbo/distance/scalar/record_quantized_int4/cosine.h
@@ -0,0 +1,30 @@
+// Copyright 2025-present the zvec project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#pragma once
+
+#include <cstddef>
+
+namespace zvec::turbo::scalar {
+
+// Compute cosine distance (negative inner product after normalization) between
+// a single quantized int4 vector pair.
+void cosine_int4_distance(const void *a, const void *b, size_t dim,
+                          float *distance);
+
+// Batch version of cosine_int4_distance.
+void cosine_int4_batch_distance(const void *const *vectors, const void *query,
+                                size_t n, size_t dim, float *distances);
+
+}  // namespace zvec::turbo::scalar
\ No newline at end of file
diff --git a/src/turbo/distance/scalar/record_quantized_int4/inner_product.cc b/src/turbo/distance/scalar/record_quantized_int4/inner_product.cc
new file mode 100644
index 000000000..3f574b155
--- /dev/null
+++ b/src/turbo/distance/scalar/record_quantized_int4/inner_product.cc
@@ -0,0 +1,59 @@
+// Copyright 2025-present the zvec project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "scalar/record_quantized_int4/inner_product.h"
+#include "scalar/record_quantized_int4/common.h"
+
+namespace zvec::turbo::scalar {
+
+// Compute squared Euclidean distance between a single quantized int4
+// vector pair.
+void inner_product_int4_distance(const void *a, const void *b, size_t dim,
+                                 float *distance) {
+  const int d = dim;
+  const size_t original_dim = d >> 1;
+
+  if (original_dim <= 0) {
+    return;
+  }
+
+  internal::inner_product_int4_scalar(a, b, original_dim, distance);
+
+  const float *a_tail = reinterpret_cast<const float *>(
+      reinterpret_cast<const uint8_t *>(a) + original_dim);
+  const float *b_tail = reinterpret_cast<const float *>(
+      reinterpret_cast<const uint8_t *>(b) + original_dim);
+
+  float qa = a_tail[0];
+  float qb = a_tail[1];
+  float qs = a_tail[2];
+
+  float ma = b_tail[0];
+  float mb = b_tail[1];
+  float ms = b_tail[2];
+
+  *distance =
+      -(ma * qa * *distance + mb * qa * qs + qb * ma * ms + d * qb * mb);
+}
+
+// Batch version of inner_product_int4_distance.
+void inner_product_int4_batch_distance(const void *const *vectors,
+                                       const void *query, size_t n, size_t dim,
+                                       float *distances) {
+  for (size_t i = 0; i < n; ++i) {
+    inner_product_int4_distance(vectors[i], query, dim, &distances[i]);
+  }
+}
+
+}  // namespace zvec::turbo::scalar
\ No newline at end of file
diff --git a/src/turbo/distance/scalar/record_quantized_int4/inner_product.h b/src/turbo/distance/scalar/record_quantized_int4/inner_product.h
new file mode 100644
index 000000000..b34d47aa4
--- /dev/null
+++ b/src/turbo/distance/scalar/record_quantized_int4/inner_product.h
@@ -0,0 +1,31 @@
+// Copyright 2025-present the zvec project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#pragma once
+
+#include <cstddef>
+
+namespace zvec::turbo::scalar {
+
+// Compute inner product distance between a single quantized int4
+// vector pair.
+void inner_product_int4_distance(const void *a, const void *b, size_t dim,
+                                 float *distance);
+
+// Batch version of inner_product_int4_distance.
+void inner_product_int4_batch_distance(const void *const *vectors,
+                                       const void *query, size_t n, size_t dim,
+                                       float *distances);
+
+}  // namespace zvec::turbo::scalar
diff --git a/src/turbo/distance/scalar/record_quantized_int4/squared_euclidean.cc b/src/turbo/distance/scalar/record_quantized_int4/squared_euclidean.cc
new file mode 100644
index 000000000..6cfb4a2b3
--- /dev/null
+++ b/src/turbo/distance/scalar/record_quantized_int4/squared_euclidean.cc
@@ -0,0 +1,61 @@
+// Copyright 2025-present the zvec project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "scalar/record_quantized_int4/squared_euclidean.h"
+#include "scalar/record_quantized_int4/common.h"
+
+namespace zvec::turbo::scalar {
+
+void squared_euclidean_int4_distance(const void *a, const void *b, size_t dim,
+                                     float *distance) {
+  const int d = dim;
+  const size_t original_dim = d >> 1;
+
+  if (original_dim <= 0) {
+    return;
+  }
+
+  internal::inner_product_int4_scalar(a, b, original_dim, distance);
+
+  const float *a_tail = reinterpret_cast<const float *>(
+      reinterpret_cast<const uint8_t *>(a) + original_dim);
+  const float *b_tail = reinterpret_cast<const float *>(
+      reinterpret_cast<const uint8_t *>(b) + original_dim);
+
+  float qa = a_tail[0];
+  float qb = a_tail[1];
+  float qs = a_tail[2];
+  float qs2 = a_tail[3];
+
+  const float sum = qa * qs;
+  const float sum2 = qa * qa * qs2;
+
+  float ma = b_tail[0];
+  float mb = b_tail[1];
+  float ms = b_tail[2];
+  float ms2 = b_tail[3];
+
+  *distance = ma * ma * ms2 + sum2 - 2 * ma * qa * *distance +
+              (mb - qb) * (mb - qb) * d + 2 * (mb - qb) * (ms * ma - sum);
+}
+
+void squared_euclidean_int4_batch_distance(const void *const *vectors,
+                                           const void *query, size_t n,
+                                           size_t dim, float *distances) {
+  for (size_t i = 0; i < n; ++i) {
+    squared_euclidean_int4_distance(vectors[i], query, dim, &distances[i]);
+  }
+}
+
+}  // namespace zvec::turbo::scalar
\ No newline at end of file
diff --git a/src/turbo/distance/scalar/record_quantized_int4/squared_euclidean.h b/src/turbo/distance/scalar/record_quantized_int4/squared_euclidean.h
new file mode 100644
index 000000000..ea37cfdec
--- /dev/null
+++ b/src/turbo/distance/scalar/record_quantized_int4/squared_euclidean.h
@@ -0,0 +1,31 @@
+// Copyright 2025-present the zvec project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#pragma once
+
+#include <cstddef>
+
+namespace zvec::turbo::scalar {
+
+// Compute squared euclidean distance between a single quantized INT8
+// vector pair.
+void squared_euclidean_int4_distance(const void *a, const void *b, size_t dim,
+                                     float *distance);
+
+// Batch version of squared euclidean  INT8.
+void squared_euclidean_int4_batch_distance(const void *const *vectors,
+                                           const void *query, size_t n,
+                                           size_t dim, float *distances);
+
+}  // namespace zvec::turbo::scalar
diff --git a/src/turbo/distance/scalar/record_quantized_int8/common.h b/src/turbo/distance/scalar/record_quantized_int8/common.h
new file mode 100644
index 000000000..d0b7186ae
--- /dev/null
+++ b/src/turbo/distance/scalar/record_quantized_int8/common.h
@@ -0,0 +1,34 @@
+// Copyright 2025-present the zvec project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#pragma once
+
+#include <cstdint>
+
+namespace zvec::turbo::scalar::internal {
+
+static __attribute__((always_inline)) void inner_product_int8_scalar(
+    const void *a, const void *b, size_t dim, float *distance) {
+  const int8_t *m = reinterpret_cast<const int8_t *>(a);
+  const int8_t *q = reinterpret_cast<const int8_t *>(b);
+
+  float sum = 0.0;
+  for (size_t i = 0; i < dim; ++i) {
+    sum += static_cast<float>(m[i] * q[i]);
+  }
+
+  *distance = -sum;
+}
+
+}  // namespace zvec::turbo::scalar::internal
diff --git a/src/turbo/distance/scalar/record_quantized_int8/cosine.cc b/src/turbo/distance/scalar/record_quantized_int8/cosine.cc
new file mode 100644
index 000000000..fdf5d0285
--- /dev/null
+++ b/src/turbo/distance/scalar/record_quantized_int8/cosine.cc
@@ -0,0 +1,60 @@
+// Copyright 2025-present the zvec project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "scalar/record_quantized_int8/cosine.h"
+#include <cstdint>
+#include "scalar/record_quantized_int8/common.h"
+
+namespace zvec::turbo::scalar {
+
+void cosine_int8_distance(const void *a, const void *b, size_t dim,
+                          float *distance) {
+  const int original_dim = dim;
+
+  if (original_dim <= 0) {
+    return;
+  }
+
+  // inner_product_int8_scalar returns -<int_a, int_b>; flip it back so the
+  // accumulated formula below produces the *positive* float dot product.
+  internal::inner_product_int8_scalar(a, b, original_dim, distance);
+  *distance = -*distance;
+
+  const float *a_tail = reinterpret_cast<const float *>(
+      reinterpret_cast<const int8_t *>(a) + original_dim);
+  const float *b_tail = reinterpret_cast<const float *>(
+      reinterpret_cast<const int8_t *>(b) + original_dim);
+
+  float qa = a_tail[0];
+  float qb = a_tail[1];
+  float qs = a_tail[2];
+
+  float ma = b_tail[0];
+  float mb = b_tail[1];
+  float ms = b_tail[2];
+
+  // Returns -<float_a, float_b>; the metric's normalize() adds 1.0f to yield
+  // the cosine distance (1 - cos_sim).
+  *distance = -(ma * qa * *distance + mb * qa * qs + qb * ma * ms +
+                static_cast<float>(original_dim) * qb * mb);
+}
+
+void cosine_int8_batch_distance(const void *const *vectors, const void *query,
+                                size_t n, size_t dim, float *distances) {
+  for (size_t i = 0; i < n; ++i) {
+    cosine_int8_distance(vectors[i], query, dim, &distances[i]);
+  }
+}
+
+}  // namespace zvec::turbo::scalar
\ No newline at end of file
diff --git a/src/turbo/distance/scalar/record_quantized_int8/cosine.h b/src/turbo/distance/scalar/record_quantized_int8/cosine.h
new file mode 100644
index 000000000..e06d8b234
--- /dev/null
+++ b/src/turbo/distance/scalar/record_quantized_int8/cosine.h
@@ -0,0 +1,30 @@
+// Copyright 2025-present the zvec project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#pragma once
+
+#include <cstddef>
+
+namespace zvec::turbo::scalar {
+
+// Compute cosine distance (negative inner product after normalization) between
+// a single quantized int8 vector pair.
+void cosine_int8_distance(const void *a, const void *b, size_t dim,
+                          float *distance);
+
+// Batch version of cosine_int8_distance.
+void cosine_int8_batch_distance(const void *const *vectors, const void *query,
+                                size_t n, size_t dim, float *distances);
+
+}  // namespace zvec::turbo::scalar
\ No newline at end of file
diff --git a/src/turbo/distance/scalar/record_quantized_int8/inner_product.cc b/src/turbo/distance/scalar/record_quantized_int8/inner_product.cc
new file mode 100644
index 000000000..a1331c410
--- /dev/null
+++ b/src/turbo/distance/scalar/record_quantized_int8/inner_product.cc
@@ -0,0 +1,61 @@
+// Copyright 2025-present the zvec project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "scalar/record_quantized_int8/inner_product.h"
+#include <cstdint>
+#include "scalar/record_quantized_int8/common.h"
+
+namespace zvec::turbo::scalar {
+
+// Compute squared Euclidean distance between a single quantized int8
+// vector pair.
+void inner_product_int8_distance(const void *a, const void *b, size_t dim,
+                                 float *distance) {
+  const size_t original_dim = dim;
+
+  if (original_dim <= 0) {
+    return;
+  }
+
+  internal::inner_product_int8_scalar(a, b, original_dim, distance);
+
+  *distance = -1 * *distance;
+
+  const float *a_tail = reinterpret_cast<const float *>(
+      reinterpret_cast<const int8_t *>(a) + original_dim);
+  const float *b_tail = reinterpret_cast<const float *>(
+      reinterpret_cast<const int8_t *>(b) + original_dim);
+
+  float qa = a_tail[0];
+  float qb = a_tail[1];
+  float qs = a_tail[2];
+
+  float ma = b_tail[0];
+  float mb = b_tail[1];
+  float ms = b_tail[2];
+
+  *distance = -(ma * qa * *distance + mb * qa * qs + qb * ma * ms +
+                original_dim * qb * mb);
+}
+
+// Batch version of inner_product_int8_distance.
+void inner_product_int8_batch_distance(const void *const *vectors,
+                                       const void *query, size_t n, size_t dim,
+                                       float *distances) {
+  for (size_t i = 0; i < n; ++i) {
+    inner_product_int8_distance(vectors[i], query, dim, &distances[i]);
+  }
+}
+
+}  // namespace zvec::turbo::scalar
\ No newline at end of file
diff --git a/src/turbo/distance/scalar/record_quantized_int8/inner_product.h b/src/turbo/distance/scalar/record_quantized_int8/inner_product.h
new file mode 100644
index 000000000..1ed51489a
--- /dev/null
+++ b/src/turbo/distance/scalar/record_quantized_int8/inner_product.h
@@ -0,0 +1,31 @@
+// Copyright 2025-present the zvec project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#pragma once
+
+#include <cstddef>
+
+namespace zvec::turbo::scalar {
+
+// Compute inner product distance between a single quantized int8
+// vector pair.
+void inner_product_int8_distance(const void *a, const void *b, size_t dim,
+                                 float *distance);
+
+// Batch version of inner_product_int8_distance.
+void inner_product_int8_batch_distance(const void *const *vectors,
+                                       const void *query, size_t n, size_t dim,
+                                       float *distances);
+
+}  // namespace zvec::turbo::scalar
diff --git a/src/turbo/distance/scalar/record_quantized_int8/squared_euclidean.cc b/src/turbo/distance/scalar/record_quantized_int8/squared_euclidean.cc
new file mode 100644
index 000000000..4fc9c6f6e
--- /dev/null
+++ b/src/turbo/distance/scalar/record_quantized_int8/squared_euclidean.cc
@@ -0,0 +1,61 @@
+// Copyright 2025-present the zvec project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "scalar/record_quantized_int8/squared_euclidean.h"
+#include "scalar/record_quantized_int8/common.h"
+
+namespace zvec::turbo::scalar {
+
+void squared_euclidean_int8_distance(const void *a, const void *b, size_t dim,
+                                     float *distance) {
+  const int original_dim = dim;
+  if (original_dim <= 0) {
+    return;
+  }
+
+  internal::inner_product_int8_scalar(a, b, original_dim, distance);
+  *distance = -*distance;
+
+  const float *a_tail = reinterpret_cast<const float *>(
+      reinterpret_cast<const int8_t *>(a) + original_dim);
+  const float *b_tail = reinterpret_cast<const float *>(
+      reinterpret_cast<const int8_t *>(b) + original_dim);
+
+  float ma = a_tail[0];
+  float mb = a_tail[1];
+  float ms = a_tail[2];
+  float ms2 = a_tail[3];
+
+  float qa = b_tail[0];
+  float qb = b_tail[1];
+  float qs = b_tail[2];
+  float qs2 = b_tail[3];
+
+  const float sum = qa * qs;
+  const float sum2 = qa * qa * qs2;
+
+  *distance = ma * ma * ms2 + sum2 - 2 * ma * qa * *distance +
+              (mb - qb) * (mb - qb) * original_dim +
+              2 * (mb - qb) * (ms * ma - sum);
+}
+
+void squared_euclidean_int8_batch_distance(const void *const *vectors,
+                                           const void *query, size_t n,
+                                           size_t dim, float *distances) {
+  for (size_t i = 0; i < n; ++i) {
+    squared_euclidean_int8_distance(vectors[i], query, dim, &distances[i]);
+  }
+}
+
+}  // namespace zvec::turbo::scalar
\ No newline at end of file
diff --git a/src/turbo/distance/scalar/record_quantized_int8/squared_euclidean.h b/src/turbo/distance/scalar/record_quantized_int8/squared_euclidean.h
new file mode 100644
index 000000000..07db60519
--- /dev/null
+++ b/src/turbo/distance/scalar/record_quantized_int8/squared_euclidean.h
@@ -0,0 +1,31 @@
+// Copyright 2025-present the zvec project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#pragma once
+
+#include <cstddef>
+
+namespace zvec::turbo::scalar {
+
+// Compute squared euclidean distance between a single quantized INT8
+// vector pair.
+void squared_euclidean_int8_distance(const void *a, const void *b, size_t dim,
+                                     float *distance);
+
+// Batch version of squared euclidean  INT8.
+void squared_euclidean_int8_batch_distance(const void *const *vectors,
+                                           const void *query, size_t n,
+                                           size_t dim, float *distances);
+
+}  // namespace zvec::turbo::scalar
diff --git a/src/turbo/distance/sse/record_quantized_int4/common.h b/src/turbo/distance/sse/record_quantized_int4/common.h
new file mode 100644
index 000000000..623d6365a
--- /dev/null
+++ b/src/turbo/distance/sse/record_quantized_int4/common.h
@@ -0,0 +1,174 @@
+// Copyright 2025-present the zvec project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#pragma once
+
+#if defined(__SSE4_1__)
+#include <immintrin.h>
+#include <array>
+#include <cstdint>
+#include <zvec/ailego/internal/platform.h>
+
+namespace zvec::turbo::sse::internal {
+
+//! Four-bits Convert Table
+static const AILEGO_ALIGNED(32) int8_t Int4ConvertTable[32] = {
+    0, 1, 2, 3, 4, 5, 6, 7, -8, -7, -6, -5, -4, -3, -2, -1,
+    0, 1, 2, 3, 4, 5, 6, 7, -8, -7, -6, -5, -4, -3, -2, -1};
+
+/*! Four-bits Integer Multiplication Table
+ */
+static const AILEGO_ALIGNED(64) int8_t Int4MulTable[256] = {
+    0, 0,  0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+    0, 1,  2,   3,   4,   5,   6,   7,   -8,  -7,  -6,  -5,  -4,  -3,  -2,  -1,
+    0, 2,  4,   6,   8,   10,  12,  14,  -16, -14, -12, -10, -8,  -6,  -4,  -2,
+    0, 3,  6,   9,   12,  15,  18,  21,  -24, -21, -18, -15, -12, -9,  -6,  -3,
+    0, 4,  8,   12,  16,  20,  24,  28,  -32, -28, -24, -20, -16, -12, -8,  -4,
+    0, 5,  10,  15,  20,  25,  30,  35,  -40, -35, -30, -25, -20, -15, -10, -5,
+    0, 6,  12,  18,  24,  30,  36,  42,  -48, -42, -36, -30, -24, -18, -12, -6,
+    0, 7,  14,  21,  28,  35,  42,  49,  -56, -49, -42, -35, -28, -21, -14, -7,
+    0, -8, -16, -24, -32, -40, -48, -56, 64,  56,  48,  40,  32,  24,  16,  8,
+    0, -7, -14, -21, -28, -35, -42, -49, 56,  49,  42,  35,  28,  21,  14,  7,
+    0, -6, -12, -18, -24, -30, -36, -42, 48,  42,  36,  30,  24,  18,  12,  6,
+    0, -5, -10, -15, -20, -25, -30, -35, 40,  35,  30,  25,  20,  15,  10,  5,
+    0, -4, -8,  -12, -16, -20, -24, -28, 32,  28,  24,  20,  16,  12,  8,   4,
+    0, -3, -6,  -9,  -12, -15, -18, -21, 24,  21,  18,  15,  12,  9,   6,   3,
+    0, -2, -4,  -6,  -8,  -10, -12, -14, 16,  14,  12,  10,  8,   6,   4,   2,
+    0, -1, -2,  -3,  -4,  -5,  -6,  -7,  8,   7,   6,   5,   4,   3,   2,   1,
+};
+
+//! Calculate Fused-Multiply-Add (GENERAL)
+#define FMA_INT4_GENERAL(m, q, sum)                               \
+  sum += Int4MulTable[(((m) << 4) & 0xf0) | (((q) >> 0) & 0xf)] + \
+         Int4MulTable[(((m) >> 0) & 0xf0) | (((q) >> 4) & 0xf)];
+
+#define MASK_INT4_SSE _mm_set1_epi32(0x0f0f0f0f)
+#define ONES_INT16_SSE _mm_set1_epi32(0x00010001)
+#define INT4_LOOKUP_SSE _mm_load_si128((const __m128i *)Int4ConvertTable)
+
+//! Compute the distance between matrix and query
+#define FMA_INT4_ITER_SSE(xmm_lhs, xmm_rhs, xmm_sum)                       \
+  {                                                                        \
+    __m128i xmm_lhs_0 = _mm_shuffle_epi8(                                  \
+        INT4_LOOKUP_SSE, _mm_and_si128((xmm_lhs), MASK_INT4_SSE));         \
+    __m128i xmm_rhs_0 = _mm_shuffle_epi8(                                  \
+        INT4_LOOKUP_SSE, _mm_and_si128((xmm_rhs), MASK_INT4_SSE));         \
+    __m128i xmm_lhs_1 = _mm_shuffle_epi8(                                  \
+        INT4_LOOKUP_SSE,                                                   \
+        _mm_and_si128(_mm_srli_epi32((xmm_lhs), 4), MASK_INT4_SSE));       \
+    __m128i xmm_rhs_1 = _mm_shuffle_epi8(                                  \
+        INT4_LOOKUP_SSE,                                                   \
+        _mm_and_si128(_mm_srli_epi32((xmm_rhs), 4), MASK_INT4_SSE));       \
+    xmm_lhs_0 = _mm_sign_epi8(xmm_lhs_0, xmm_rhs_0);                       \
+    xmm_lhs_1 = _mm_sign_epi8(xmm_lhs_1, xmm_rhs_1);                       \
+    xmm_rhs_0 = _mm_abs_epi8(xmm_rhs_0);                                   \
+    xmm_rhs_1 = _mm_abs_epi8(xmm_rhs_1);                                   \
+    xmm_lhs_0 = _mm_madd_epi16(_mm_maddubs_epi16(xmm_rhs_0, xmm_lhs_0),    \
+                               ONES_INT16_SSE);                            \
+    xmm_lhs_1 = _mm_madd_epi16(_mm_maddubs_epi16(xmm_rhs_1, xmm_lhs_1),    \
+                               ONES_INT16_SSE);                            \
+    xmm_sum = _mm_add_epi32(_mm_add_epi32(xmm_lhs_0, xmm_lhs_1), xmm_sum); \
+  }
+
+static inline int32_t HorizontalAdd_INT32_V128(__m128i v) {
+#ifdef __SSE3__
+  __m128i x1 = _mm_hadd_epi32(v, v);
+  __m128i x2 = _mm_hadd_epi32(x1, x1);
+  return _mm_cvtsi128_si32(x2);
+#else
+  __m128i x1 = _mm_shuffle_epi32(v, _MM_SHUFFLE(0, 0, 3, 2));
+  __m128i x2 = _mm_add_epi32(v, x1);
+  __m128i x3 = _mm_shuffle_epi32(x2, _MM_SHUFFLE(0, 0, 0, 1));
+  __m128i x4 = _mm_add_epi32(x2, x3);
+  return _mm_cvtsi128_si32(x4);
+#endif
+}
+
+static __attribute__((always_inline)) void inner_product_int4_sse(
+    const void *a, const void *b, size_t size, float *distance) {
+  const uint8_t *lhs = reinterpret_cast<const uint8_t *>(a);
+  const uint8_t *rhs = reinterpret_cast<const uint8_t *>(b);
+
+  const uint8_t *last = lhs + size;
+  const uint8_t *last_aligned = lhs + ((size >> 4) << 4);
+  __m128i xmm_sum = _mm_setzero_si128();
+
+  if (((uintptr_t)lhs & 0xf) == 0 && ((uintptr_t)rhs & 0xf) == 0) {
+    for (; lhs != last_aligned; lhs += 16, rhs += 16) {
+      __m128i xmm_lhs = _mm_load_si128((const __m128i *)(lhs));
+      __m128i xmm_rhs = _mm_load_si128((const __m128i *)(rhs));
+      FMA_INT4_ITER_SSE(xmm_lhs, xmm_rhs, xmm_sum)
+    }
+  } else {
+    for (; lhs != last_aligned; lhs += 16, rhs += 16) {
+      __m128i xmm_lhs = _mm_loadu_si128((const __m128i *)(lhs));
+      __m128i xmm_rhs = _mm_loadu_si128((const __m128i *)(rhs));
+      FMA_INT4_ITER_SSE(xmm_lhs, xmm_rhs, xmm_sum)
+    }
+  }
+  float result = static_cast<float>(HorizontalAdd_INT32_V128(xmm_sum));
+
+  switch (last - lhs) {
+    case 15:
+      FMA_INT4_GENERAL(lhs[14], rhs[14], result)
+      /* FALLTHRU */
+    case 14:
+      FMA_INT4_GENERAL(lhs[13], rhs[13], result)
+      /* FALLTHRU */
+    case 13:
+      FMA_INT4_GENERAL(lhs[12], rhs[12], result)
+      /* FALLTHRU */
+    case 12:
+      FMA_INT4_GENERAL(lhs[11], rhs[11], result)
+      /* FALLTHRU */
+    case 11:
+      FMA_INT4_GENERAL(lhs[10], rhs[10], result)
+      /* FALLTHRU */
+    case 10:
+      FMA_INT4_GENERAL(lhs[9], rhs[9], result)
+      /* FALLTHRU */
+    case 9:
+      FMA_INT4_GENERAL(lhs[8], rhs[8], result)
+      /* FALLTHRU */
+    case 8:
+      FMA_INT4_GENERAL(lhs[7], rhs[7], result)
+      /* FALLTHRU */
+    case 7:
+      FMA_INT4_GENERAL(lhs[6], rhs[6], result)
+      /* FALLTHRU */
+    case 6:
+      FMA_INT4_GENERAL(lhs[5], rhs[5], result)
+      /* FALLTHRU */
+    case 5:
+      FMA_INT4_GENERAL(lhs[4], rhs[4], result)
+      /* FALLTHRU */
+    case 4:
+      FMA_INT4_GENERAL(lhs[3], rhs[3], result)
+      /* FALLTHRU */
+    case 3:
+      FMA_INT4_GENERAL(lhs[2], rhs[2], result)
+      /* FALLTHRU */
+    case 2:
+      FMA_INT4_GENERAL(lhs[1], rhs[1], result)
+      /* FALLTHRU */
+    case 1:
+      FMA_INT4_GENERAL(lhs[0], rhs[0], result)
+  }
+
+  *distance = result;
+}
+
+}  // namespace zvec::turbo::sse::internal
+
+#endif  // defined(__SSE4_1__)
diff --git a/src/turbo/distance/sse/record_quantized_int4/cosine.cc b/src/turbo/distance/sse/record_quantized_int4/cosine.cc
new file mode 100644
index 000000000..5c5357678
--- /dev/null
+++ b/src/turbo/distance/sse/record_quantized_int4/cosine.cc
@@ -0,0 +1,70 @@
+// Copyright 2025-present the zvec project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "sse/record_quantized_int4/cosine.h"
+#include "sse/record_quantized_int4/common.h"
+#if defined(__SSE4_1__)
+#include <immintrin.h>
+#endif
+
+namespace zvec::turbo::sse {
+
+void cosine_int4_distance(const void *a, const void *b, size_t dim,
+                          float *distance) {
+#if defined(__SSE4_1__)
+  const int d = dim;
+  const size_t original_dim = d >> 1;
+  if (original_dim <= 0) {
+    return;
+  }
+
+  internal::inner_product_int4_sse(a, b, original_dim, distance);
+
+  const float *a_tail = reinterpret_cast<const float *>(
+      reinterpret_cast<const uint8_t *>(a) + original_dim);
+  const float *b_tail = reinterpret_cast<const float *>(
+      reinterpret_cast<const uint8_t *>(b) + original_dim);
+
+  float qa = a_tail[0];
+  float qb = a_tail[1];
+  float qs = a_tail[2];
+
+  float ma = b_tail[0];
+  float mb = b_tail[1];
+  float ms = b_tail[2];
+
+  *distance = -(ma * qa * *distance + mb * qa * qs + qb * ma * ms +
+                static_cast<float>(d) * qb * mb);
+#else
+  (void)a;
+  (void)b;
+  (void)dim;
+  (void)distance;
+#endif  // __SSE4_1__
+}
+
+void cosine_int4_batch_distance(const void *const *vectors, const void *query,
+                                size_t n, size_t dim, float *distances) {
+#if defined(__SSE4_1__)
+
+#else
+  (void)vectors;
+  (void)query;
+  (void)n;
+  (void)dim;
+  (void)distances;
+#endif  //__SSE4_1__
+}
+
+}  // namespace zvec::turbo::sse
\ No newline at end of file
diff --git a/src/turbo/distance/sse/record_quantized_int4/cosine.h b/src/turbo/distance/sse/record_quantized_int4/cosine.h
new file mode 100644
index 000000000..87306a06e
--- /dev/null
+++ b/src/turbo/distance/sse/record_quantized_int4/cosine.h
@@ -0,0 +1,30 @@
+// Copyright 2025-present the zvec project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#pragma once
+
+#include <cstddef>
+
+namespace zvec::turbo::sse {
+
+// Compute cosine distance (negative inner product after normalization) between
+// a single quantized INT4 vector pair.
+void cosine_int4_distance(const void *a, const void *b, size_t dim,
+                          float *distance);
+
+// Batch version of cosine_int4_distance.
+void cosine_int4_batch_distance(const void *const *vectors, const void *query,
+                                size_t n, size_t dim, float *distances);
+
+}  // namespace zvec::turbo::sse
\ No newline at end of file
diff --git a/src/turbo/distance/sse/record_quantized_int4/inner_product.cc b/src/turbo/distance/sse/record_quantized_int4/inner_product.cc
new file mode 100644
index 000000000..27d1fe3b3
--- /dev/null
+++ b/src/turbo/distance/sse/record_quantized_int4/inner_product.cc
@@ -0,0 +1,76 @@
+// Copyright 2025-present the zvec project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "sse/record_quantized_int4/inner_product.h"
+#include "sse/record_quantized_int4/common.h"
+
+#if defined(__SSE4_1__)
+#include <immintrin.h>
+#endif
+
+namespace zvec::turbo::sse {
+
+// Compute squared inner product distance between a single quantized INT4
+// vector pair.
+void inner_product_int4_distance(const void *a, const void *b, size_t dim,
+                                 float *distance) {
+#if defined(__SSE4_1__)
+  const int d = dim;
+  const size_t original_dim = d >> 1;
+
+  if (original_dim <= 0) {
+    return;
+  }
+
+  internal::inner_product_int4_sse(a, b, original_dim, distance);
+
+  const float *a_tail = reinterpret_cast<const float *>(
+      reinterpret_cast<const uint8_t *>(a) + original_dim);
+  const float *b_tail = reinterpret_cast<const float *>(
+      reinterpret_cast<const uint8_t *>(b) + original_dim);
+
+  float qa = a_tail[0];
+  float qb = a_tail[1];
+  float qs = a_tail[2];
+
+  float ma = b_tail[0];
+  float mb = b_tail[1];
+  float ms = b_tail[2];
+
+  *distance =
+      -(ma * qa * *distance + mb * qa * qs + qb * ma * ms + d * qb * mb);
+#else
+  (void)a;
+  (void)b;
+  (void)dim;
+  (void)distance;
+#endif  //__SSE4_1__
+}
+
+// Batch version of inner_product_int4_distance.
+void inner_product_int4_batch_distance(const void *const *vectors,
+                                       const void *query, size_t n, size_t dim,
+                                       float *distances) {
+#if defined(__SSE4_1__)
+
+#else
+  (void)vectors;
+  (void)query;
+  (void)n;
+  (void)dim;
+  (void)distances;
+#endif  //__SSE4_1__
+}
+
+}  // namespace zvec::turbo::sse
\ No newline at end of file
diff --git a/src/turbo/distance/sse/record_quantized_int4/inner_product.h b/src/turbo/distance/sse/record_quantized_int4/inner_product.h
new file mode 100644
index 000000000..4ee508ed2
--- /dev/null
+++ b/src/turbo/distance/sse/record_quantized_int4/inner_product.h
@@ -0,0 +1,31 @@
+// Copyright 2025-present the zvec project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#pragma once
+
+#include <cstddef>
+
+namespace zvec::turbo::sse {
+
+// Compute inner product distance between a single quantized INT4
+// vector pair.
+void inner_product_int4_distance(const void *a, const void *b, size_t dim,
+                                 float *distance);
+
+// Batch version of inner_product_int4_distance.
+void inner_product_int4_batch_distance(const void *const *vectors,
+                                       const void *query, size_t n, size_t dim,
+                                       float *distances);
+
+}  // namespace zvec::turbo::sse
diff --git a/src/turbo/distance/sse/record_quantized_int4/squared_euclidean.cc b/src/turbo/distance/sse/record_quantized_int4/squared_euclidean.cc
new file mode 100644
index 000000000..291bdf8e6
--- /dev/null
+++ b/src/turbo/distance/sse/record_quantized_int4/squared_euclidean.cc
@@ -0,0 +1,78 @@
+// Copyright 2025-present the zvec project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "sse/record_quantized_int4/squared_euclidean.h"
+#include "sse/record_quantized_int4/common.h"
+
+#if defined(__SSE4_1__)
+#include <immintrin.h>
+#endif
+
+namespace zvec::turbo::sse {
+
+void squared_euclidean_int4_distance(const void *a, const void *b, size_t dim,
+                                     float *distance) {
+#if defined(__SSE4_1__)
+  const int d = dim;
+  const size_t original_dim = d >> 1;
+
+  if (original_dim <= 0) {
+    return;
+  }
+
+  internal::inner_product_int4_sse(a, b, original_dim, distance);
+
+  const float *a_tail = reinterpret_cast<const float *>(
+      reinterpret_cast<const uint8_t *>(a) + original_dim);
+  const float *b_tail = reinterpret_cast<const float *>(
+      reinterpret_cast<const uint8_t *>(b) + original_dim);
+
+  float qa = a_tail[0];
+  float qb = a_tail[1];
+  float qs = a_tail[2];
+  float qs2 = a_tail[3];
+
+  const float sum = qa * qs;
+  const float sum2 = qa * qa * qs2;
+
+  float ma = b_tail[0];
+  float mb = b_tail[1];
+  float ms = b_tail[2];
+  float ms2 = b_tail[3];
+
+  *distance = ma * ma * ms2 + sum2 - 2 * ma * qa * *distance +
+              (mb - qb) * (mb - qb) * d + 2 * (mb - qb) * (ms * ma - sum);
+#else
+  (void)a;
+  (void)b;
+  (void)dim;
+  (void)distance;
+#endif  // __SSE4_1__
+}
+
+void squared_euclidean_int4_batch_distance(const void *const *vectors,
+                                           const void *query, size_t n,
+                                           size_t dim, float *distances) {
+#if defined(__SSE4_1__)
+
+#else
+  (void)vectors;
+  (void)query;
+  (void)n;
+  (void)dim;
+  (void)distances;
+#endif  //__SSE4_1__
+}
+
+}  // namespace zvec::turbo::sse
\ No newline at end of file
diff --git a/src/turbo/distance/sse/record_quantized_int4/squared_euclidean.h b/src/turbo/distance/sse/record_quantized_int4/squared_euclidean.h
new file mode 100644
index 000000000..3cff9f99b
--- /dev/null
+++ b/src/turbo/distance/sse/record_quantized_int4/squared_euclidean.h
@@ -0,0 +1,31 @@
+// Copyright 2025-present the zvec project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#pragma once
+
+#include <cstddef>
+
+namespace zvec::turbo::sse {
+
+// Compute squared euclidean distance between a single quantized INT4
+// vector pair.
+void squared_euclidean_int4_distance(const void *a, const void *b, size_t dim,
+                                     float *distance);
+
+// Batch version of squared euclidean  INT4.
+void squared_euclidean_int4_batch_distance(const void *const *vectors,
+                                           const void *query, size_t n,
+                                           size_t dim, float *distances);
+
+}  // namespace zvec::turbo::sse
diff --git a/src/turbo/distance/sse/record_quantized_int8/common.h b/src/turbo/distance/sse/record_quantized_int8/common.h
new file mode 100644
index 000000000..b48b2598e
--- /dev/null
+++ b/src/turbo/distance/sse/record_quantized_int8/common.h
@@ -0,0 +1,210 @@
+// Copyright 2025-present the zvec project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#pragma once
+
+#if defined(__SSE__)
+#include <immintrin.h>
+#include <array>
+#include <cstdint>
+#include <zvec/ailego/internal/platform.h>
+
+namespace zvec::turbo::sse::internal {
+
+#define ONES_INT16_SSE _mm_set1_epi32(0x00010001)
+
+static inline int32_t HorizontalAdd_INT32_V128(__m128i v) {
+#ifdef __SSE3__
+  __m128i x1 = _mm_hadd_epi32(v, v);
+  __m128i x2 = _mm_hadd_epi32(x1, x1);
+  return _mm_cvtsi128_si32(x2);
+#else
+  __m128i x1 = _mm_shuffle_epi32(v, _MM_SHUFFLE(0, 0, 3, 2));
+  __m128i x2 = _mm_add_epi32(v, x1);
+  __m128i x3 = _mm_shuffle_epi32(x2, _MM_SHUFFLE(0, 0, 0, 1));
+  __m128i x4 = _mm_add_epi32(x2, x3);
+  return _mm_cvtsi128_si32(x4);
+#endif
+}
+
+//! Calculate Fused-Multiply-Add (GENERAL)
+#define FMA_INT8_GENERAL(m, q, sum) sum += static_cast<float>(m * q);
+
+static __attribute__((always_inline)) void inner_product_int8_sse(
+    const void *a, const void *b, size_t size, float *distance) {
+  const int8_t *lhs = reinterpret_cast<const int8_t *>(a);
+  const int8_t *rhs = reinterpret_cast<const int8_t *>(b);
+
+  const int8_t *last = lhs + size;
+  const int8_t *last_aligned = lhs + ((size >> 5) << 5);
+
+  __m128i xmm_sum_0 = _mm_setzero_si128();
+  __m128i xmm_sum_1 = _mm_setzero_si128();
+
+  if (((uintptr_t)lhs & 0xf) == 0 && ((uintptr_t)rhs & 0xf) == 0) {
+    for (; lhs != last_aligned; lhs += 32, rhs += 32) {
+      __m128i xmm_lhs_0 = _mm_load_si128((const __m128i *)(lhs + 0));
+      __m128i xmm_lhs_1 = _mm_load_si128((const __m128i *)(lhs + 16));
+      __m128i xmm_rhs_0 = _mm_load_si128((const __m128i *)(rhs + 0));
+      __m128i xmm_rhs_1 = _mm_load_si128((const __m128i *)(rhs + 16));
+
+      xmm_lhs_0 = _mm_sign_epi8(xmm_lhs_0, xmm_rhs_0);
+      xmm_lhs_1 = _mm_sign_epi8(xmm_lhs_1, xmm_rhs_1);
+      xmm_rhs_0 = _mm_abs_epi8(xmm_rhs_0);
+      xmm_rhs_1 = _mm_abs_epi8(xmm_rhs_1);
+      xmm_sum_0 =
+          _mm_add_epi32(_mm_madd_epi16(_mm_maddubs_epi16(xmm_rhs_0, xmm_lhs_0),
+                                       ONES_INT16_SSE),
+                        xmm_sum_0);
+      xmm_sum_1 =
+          _mm_add_epi32(_mm_madd_epi16(_mm_maddubs_epi16(xmm_rhs_1, xmm_lhs_1),
+                                       ONES_INT16_SSE),
+                        xmm_sum_1);
+    }
+
+    if (last >= last_aligned + 16) {
+      __m128i xmm_lhs = _mm_load_si128((const __m128i *)lhs);
+      __m128i xmm_rhs = _mm_load_si128((const __m128i *)rhs);
+
+      xmm_lhs = _mm_sign_epi8(xmm_lhs, xmm_rhs);
+      xmm_rhs = _mm_abs_epi8(xmm_rhs);
+      xmm_sum_0 = _mm_add_epi32(
+          _mm_madd_epi16(_mm_maddubs_epi16(xmm_rhs, xmm_lhs), ONES_INT16_SSE),
+          xmm_sum_0);
+      lhs += 16;
+      rhs += 16;
+    }
+  } else {
+    for (; lhs != last_aligned; lhs += 32, rhs += 32) {
+      __m128i xmm_lhs_0 = _mm_loadu_si128((const __m128i *)(lhs + 0));
+      __m128i xmm_lhs_1 = _mm_loadu_si128((const __m128i *)(lhs + 16));
+      __m128i xmm_rhs_0 = _mm_loadu_si128((const __m128i *)(rhs + 0));
+      __m128i xmm_rhs_1 = _mm_loadu_si128((const __m128i *)(rhs + 16));
+
+      xmm_lhs_0 = _mm_sign_epi8(xmm_lhs_0, xmm_rhs_0);
+      xmm_lhs_1 = _mm_sign_epi8(xmm_lhs_1, xmm_rhs_1);
+      xmm_rhs_0 = _mm_abs_epi8(xmm_rhs_0);
+      xmm_rhs_1 = _mm_abs_epi8(xmm_rhs_1);
+      xmm_sum_0 =
+          _mm_add_epi32(_mm_madd_epi16(_mm_maddubs_epi16(xmm_rhs_0, xmm_lhs_0),
+                                       ONES_INT16_SSE),
+                        xmm_sum_0);
+      xmm_sum_1 =
+          _mm_add_epi32(_mm_madd_epi16(_mm_maddubs_epi16(xmm_rhs_1, xmm_lhs_1),
+                                       ONES_INT16_SSE),
+                        xmm_sum_1);
+    }
+
+    if (last >= last_aligned + 16) {
+      __m128i xmm_lhs = _mm_loadu_si128((const __m128i *)lhs);
+      __m128i xmm_rhs = _mm_loadu_si128((const __m128i *)rhs);
+
+      xmm_lhs = _mm_sign_epi8(xmm_lhs, xmm_rhs);
+      xmm_rhs = _mm_abs_epi8(xmm_rhs);
+      xmm_sum_0 = _mm_add_epi32(
+          _mm_madd_epi16(_mm_maddubs_epi16(xmm_rhs, xmm_lhs), ONES_INT16_SSE),
+          xmm_sum_0);
+      lhs += 16;
+      rhs += 16;
+    }
+  }
+  float result = static_cast<float>(
+      HorizontalAdd_INT32_V128(_mm_add_epi32(xmm_sum_0, xmm_sum_1)));
+
+  switch (last - lhs) {
+    case 15:
+      FMA_INT8_GENERAL(lhs[14], rhs[14], result)
+      /* FALLTHRU */
+    case 14:
+      FMA_INT8_GENERAL(lhs[13], rhs[13], result)
+      /* FALLTHRU */
+    case 13:
+      FMA_INT8_GENERAL(lhs[12], rhs[12], result)
+      /* FALLTHRU */
+    case 12:
+      FMA_INT8_GENERAL(lhs[11], rhs[11], result)
+      /* FALLTHRU */
+    case 11:
+      FMA_INT8_GENERAL(lhs[10], rhs[10], result)
+      /* FALLTHRU */
+    case 10:
+      FMA_INT8_GENERAL(lhs[9], rhs[9], result)
+      /* FALLTHRU */
+    case 9:
+      FMA_INT8_GENERAL(lhs[8], rhs[8], result)
+      /* FALLTHRU */
+    case 8:
+      FMA_INT8_GENERAL(lhs[7], rhs[7], result)
+      /* FALLTHRU */
+    case 7:
+      FMA_INT8_GENERAL(lhs[6], rhs[6], result)
+      /* FALLTHRU */
+    case 6:
+      FMA_INT8_GENERAL(lhs[5], rhs[5], result)
+      /* FALLTHRU */
+    case 5:
+      FMA_INT8_GENERAL(lhs[4], rhs[4], result)
+      /* FALLTHRU */
+    case 4:
+      FMA_INT8_GENERAL(lhs[3], rhs[3], result)
+      /* FALLTHRU */
+    case 3:
+      FMA_INT8_GENERAL(lhs[2], rhs[2], result)
+      /* FALLTHRU */
+    case 2:
+      FMA_INT8_GENERAL(lhs[1], rhs[1], result)
+      /* FALLTHRU */
+    case 1:
+      FMA_INT8_GENERAL(lhs[0], rhs[0], result)
+  }
+
+  *distance = result;
+}
+
+template <size_t batch_size>
+__attribute__((always_inline)) void inner_product_int8_batch_sse_impl(
+    const void *query, const void *const *vectors,
+    const std::array<const void *, batch_size> &prefetch_ptrs,
+    size_t dimensionality, float *distances) {
+  // TBD
+}
+
+static __attribute__((always_inline)) void inner_product_int8_batch_sse(
+    const void *const *vectors, const void *query, size_t n, size_t dim,
+    float *distances) {
+  static constexpr size_t batch_size = 2;
+  static constexpr size_t prefetch_step = 2;
+  size_t i = 0;
+  for (; i + batch_size <= n; i += batch_size) {
+    std::array<const void *, batch_size> prefetch_ptrs;
+    for (size_t j = 0; j < batch_size; ++j) {
+      if (i + j + batch_size * prefetch_step < n) {
+        prefetch_ptrs[j] = vectors[i + j + batch_size * prefetch_step];
+      } else {
+        prefetch_ptrs[j] = nullptr;
+      }
+    }
+    inner_product_int8_batch_sse_impl<batch_size>(
+        query, &vectors[i], prefetch_ptrs, dim, distances + i);
+  }
+  for (; i < n; i++) {
+    std::array<const void *, 1> prefetch_ptrs{nullptr};
+    inner_product_int8_batch_sse_impl<1>(query, &vectors[i], prefetch_ptrs, dim,
+                                         distances + i);
+  }
+}
+
+}  // namespace zvec::turbo::sse::internal
+
+#endif  // defined(__SSE__)
diff --git a/src/turbo/distance/sse/record_quantized_int8/cosine.cc b/src/turbo/distance/sse/record_quantized_int8/cosine.cc
new file mode 100644
index 000000000..ad41c87ae
--- /dev/null
+++ b/src/turbo/distance/sse/record_quantized_int8/cosine.cc
@@ -0,0 +1,70 @@
+// Copyright 2025-present the zvec project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "sse/record_quantized_int8/cosine.h"
+#include "sse/record_quantized_int8/common.h"
+
+#if defined(__SSE__)
+#include <immintrin.h>
+#endif
+
+namespace zvec::turbo::sse {
+
+void cosine_int8_distance(const void *a, const void *b, size_t dim,
+                          float *distance) {
+#if defined(__SSE__)
+  const int original_dim = dim;
+  if (original_dim <= 0) {
+    return;
+  }
+
+  internal::inner_product_int8_sse(a, b, original_dim, distance);
+
+  const float *a_tail = reinterpret_cast<const float *>(
+      reinterpret_cast<const int8_t *>(a) + original_dim);
+  const float *b_tail = reinterpret_cast<const float *>(
+      reinterpret_cast<const int8_t *>(b) + original_dim);
+
+  float qa = a_tail[0];
+  float qb = a_tail[1];
+  float qs = a_tail[2];
+
+  float ma = b_tail[0];
+  float mb = b_tail[1];
+  float ms = b_tail[2];
+
+  *distance = -(ma * qa * *distance + mb * qa * qs + qb * ma * ms +
+                static_cast<float>(original_dim) * qb * mb);
+#else
+  (void)a;
+  (void)b;
+  (void)dim;
+  (void)distance;
+#endif  // __SSE__
+}
+
+void cosine_int8_batch_distance(const void *const *vectors, const void *query,
+                                size_t n, size_t dim, float *distances) {
+#if defined(__SSE__)
+
+#else
+  (void)vectors;
+  (void)query;
+  (void)n;
+  (void)dim;
+  (void)distances;
+#endif  //__SSE__
+}
+
+}  // namespace zvec::turbo::sse
\ No newline at end of file
diff --git a/src/turbo/distance/sse/record_quantized_int8/cosine.h b/src/turbo/distance/sse/record_quantized_int8/cosine.h
new file mode 100644
index 000000000..e0ac7f556
--- /dev/null
+++ b/src/turbo/distance/sse/record_quantized_int8/cosine.h
@@ -0,0 +1,34 @@
+// Copyright 2025-present the zvec project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#pragma once
+
+#include <cstddef>
+
+namespace zvec::turbo::sse {
+
+// Compute cosine distance (negative inner product after normalization) between
+// a single quantized INT8 vector pair.
+// `dim` includes the original vector bytes plus a 24-byte metadata tail
+// (3 floats: scale_a, bias_a, sum_a).
+void cosine_int8_distance(const void *a, const void *b, size_t dim,
+                          float *distance);
+
+// Batch version of cosine_int8_distance.
+// The query must have been preprocessed by cosine_int8_query_preprocess
+// (int8 -> uint8 via +128 shift) before calling this function.
+void cosine_int8_batch_distance(const void *const *vectors, const void *query,
+                                size_t n, size_t dim, float *distances);
+
+}  // namespace zvec::turbo::sse
\ No newline at end of file
diff --git a/src/turbo/distance/sse/record_quantized_int8/inner_product.cc b/src/turbo/distance/sse/record_quantized_int8/inner_product.cc
new file mode 100644
index 000000000..35ed82db4
--- /dev/null
+++ b/src/turbo/distance/sse/record_quantized_int8/inner_product.cc
@@ -0,0 +1,75 @@
+// Copyright 2025-present the zvec project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "sse/record_quantized_int8/inner_product.h"
+#include "sse/record_quantized_int8/common.h"
+
+#if defined(__SSE__)
+#include <immintrin.h>
+#endif
+
+namespace zvec::turbo::sse {
+
+// Compute squared Euclidean distance between a single quantized INT4
+// vector pair.
+void inner_product_int8_distance(const void *a, const void *b, size_t dim,
+                                 float *distance) {
+#if defined(__SSE__)
+  const size_t original_dim = dim;
+
+  if (original_dim <= 0) {
+    return;
+  }
+
+  internal::inner_product_int8_sse(a, b, original_dim, distance);
+
+  const float *a_tail = reinterpret_cast<const float *>(
+      reinterpret_cast<const uint8_t *>(a) + original_dim);
+  const float *b_tail = reinterpret_cast<const float *>(
+      reinterpret_cast<const uint8_t *>(b) + original_dim);
+
+  float qa = a_tail[0];
+  float qb = a_tail[1];
+  float qs = a_tail[2];
+
+  float ma = b_tail[0];
+  float mb = b_tail[1];
+  float ms = b_tail[2];
+
+  *distance = -(ma * qa * *distance + mb * qa * qs + qb * ma * ms +
+                original_dim * qb * mb);
+#else
+  (void)a;
+  (void)b;
+  (void)dim;
+  (void)distance;
+#endif  //__SSE__
+}
+
+// Batch version of inner_product_int8_distance.
+void inner_product_int8_batch_distance(const void *const *vectors,
+                                       const void *query, size_t n, size_t dim,
+                                       float *distances) {
+#if defined(__SSE__)
+
+#else
+  (void)vectors;
+  (void)query;
+  (void)n;
+  (void)dim;
+  (void)distances;
+#endif  //__SSE__
+}
+
+}  // namespace zvec::turbo::sse
\ No newline at end of file
diff --git a/src/turbo/distance/sse/record_quantized_int8/inner_product.h b/src/turbo/distance/sse/record_quantized_int8/inner_product.h
new file mode 100644
index 000000000..9c6314b35
--- /dev/null
+++ b/src/turbo/distance/sse/record_quantized_int8/inner_product.h
@@ -0,0 +1,31 @@
+// Copyright 2025-present the zvec project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#pragma once
+
+#include <cstddef>
+
+namespace zvec::turbo::sse {
+
+// Compute inner product distance between a single quantized INT4
+// vector pair.
+void inner_product_int8_distance(const void *a, const void *b, size_t dim,
+                                 float *distance);
+
+// Batch version of inner_product_int4_distance.
+void inner_product_int8_batch_distance(const void *const *vectors,
+                                       const void *query, size_t n, size_t dim,
+                                       float *distances);
+
+}  // namespace zvec::turbo::sse
\ No newline at end of file
diff --git a/src/turbo/distance/sse/record_quantized_int8/squared_euclidean.cc b/src/turbo/distance/sse/record_quantized_int8/squared_euclidean.cc
new file mode 100644
index 000000000..052b3bb68
--- /dev/null
+++ b/src/turbo/distance/sse/record_quantized_int8/squared_euclidean.cc
@@ -0,0 +1,75 @@
+// Copyright 2025-present the zvec project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "sse/record_quantized_int8/squared_euclidean.h"
+#include "sse/record_quantized_int8/common.h"
+#if defined(__SSE__)
+#include <immintrin.h>
+#endif
+
+namespace zvec::turbo::sse {
+
+void squared_euclidean_int8_distance(const void *a, const void *b, size_t dim,
+                                     float *distance) {
+#if defined(__SSE__)
+  const int original_dim = dim;
+  if (original_dim <= 0) {
+    return;
+  }
+  internal::inner_product_int8_sse(a, b, original_dim, distance);
+
+  const float *a_tail = reinterpret_cast<const float *>(
+      reinterpret_cast<const int8_t *>(a) + original_dim);
+  const float *b_tail = reinterpret_cast<const float *>(
+      reinterpret_cast<const int8_t *>(b) + original_dim);
+
+  float ma = a_tail[0];
+  float mb = a_tail[1];
+  float ms = a_tail[2];
+  float ms2 = a_tail[3];
+
+  float qa = b_tail[0];
+  float qb = b_tail[1];
+  float qs = b_tail[2];
+  float qs2 = b_tail[3];
+
+  const float sum = qa * qs;
+  const float sum2 = qa * qa * qs2;
+
+  *distance = ma * ma * ms2 + sum2 - 2 * ma * qa * *distance +
+              (mb - qb) * (mb - qb) * original_dim +
+              2 * (mb - qb) * (ms * ma - sum);
+#else
+  (void)a;
+  (void)b;
+  (void)dim;
+  (void)distance;
+#endif
+}
+
+void squared_euclidean_int8_batch_distance(const void *const *vectors,
+                                           const void *query, size_t n,
+                                           size_t dim, float *distances) {
+#if defined(__SSE__)
+
+#else
+  (void)vectors;
+  (void)query;
+  (void)n;
+  (void)dim;
+  (void)distances;
+#endif
+}
+
+}  // namespace zvec::turbo::sse
diff --git a/src/turbo/distance/sse/record_quantized_int8/squared_euclidean.h b/src/turbo/distance/sse/record_quantized_int8/squared_euclidean.h
new file mode 100644
index 000000000..1e2cf45b4
--- /dev/null
+++ b/src/turbo/distance/sse/record_quantized_int8/squared_euclidean.h
@@ -0,0 +1,41 @@
+// Copyright 2025-present the zvec project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#pragma once
+
+#include <cstddef>
+
+namespace zvec::turbo::sse {
+
+// Compute squared Euclidean distance between a single quantized INT8
+// vector pair.
+// `dim` includes the original vector bytes plus a 20-byte metadata tail
+// (4 floats: scale_a, bias_a, sum_a, sum2_a).
+void squared_euclidean_int8_distance(const void *a, const void *b, size_t dim,
+                                     float *distance);
+
+// Batch version of squared_euclidean_int8_distance.
+// The query must have been preprocessed by
+// squared_euclidean_int8_query_preprocess (int8 -> uint8 via +128 shift)
+// before calling this function.
+void squared_euclidean_int8_batch_distance(const void *const *vectors,
+                                           const void *query, size_t n,
+                                           size_t dim, float *distances);
+
+// Preprocess the query vector in-place (shift int8 -> uint8 by adding 128)
+// for the batch path. Only the original_dim bytes are shifted; the metadata
+// tail is left intact. `dim` includes the 20-byte metadata tail.
+void squared_euclidean_int8_query_preprocess(void *query, size_t dim);
+
+}  // namespace zvec::turbo::sse
diff --git a/src/turbo/quantizer/distance.h b/src/turbo/quantizer/distance.h
new file mode 100644
index 000000000..bc8af6c1a
--- /dev/null
+++ b/src/turbo/quantizer/distance.h
@@ -0,0 +1,107 @@
+// Copyright 2025-present the zvec project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#pragma once
+
+#include <cstddef>
+#include <string>
+#include <utility>
+#include <zvec/turbo/turbo.h>
+
+namespace zvec {
+namespace turbo {
+
+//! A callable distance handle bound to a quantized query vector.
+//!
+//! DistanceImpl owns the quantized query bytes and a dispatched
+//! DistanceFunc. Invoking `operator()(candidate)` computes the distance
+//! between the stored query and the given candidate vector, which is
+//! expected to already be in the same quantized layout.
+class DistanceImpl {
+ public:
+  DistanceImpl() = default;
+
+  DistanceImpl(DistanceFunc func, std::string quantized_query, size_t dim)
+      : func_(std::move(func)),
+        query_storage_(std::move(quantized_query)),
+        dim_(dim) {}
+
+  DistanceImpl(DistanceFunc func, BatchDistanceFunc batch_func,
+               std::string quantized_query, size_t dim)
+      : func_(std::move(func)),
+        batch_func_(std::move(batch_func)),
+        query_storage_(std::move(quantized_query)),
+        dim_(dim) {}
+
+  //! Whether the handle is ready to compute distances.
+  bool valid() const {
+    return static_cast<bool>(func_);
+  }
+
+  //! Whether a batch distance function is available.
+  bool batch_valid() const {
+    return static_cast<bool>(batch_func_);
+  }
+
+  //! Compute the distance between the stored query and `candidate`.
+  float operator()(const void *candidate) const {
+    float d = 0.0f;
+    func_(candidate, query_storage_.data(), dim_, &d);
+    return d;
+  }
+
+  //! Compute distances for a batch of `num` candidates against the
+  //! stored query. Falls back to the scalar path when no batch function
+  //! is bound.
+  void batch(const void **candidates, size_t num, float *out) const {
+    if (batch_func_) {
+      batch_func_(candidates, query_storage_.data(), num, dim_, out);
+      return;
+    }
+    for (size_t i = 0; i < num; ++i) {
+      out[i] = 0.0f;
+      func_(candidates[i], query_storage_.data(), dim_, out + i);
+    }
+  }
+
+  //! Access the quantized query bytes (for pairwise helpers).
+  const std::string &query_storage() const {
+    return query_storage_;
+  }
+
+  size_t dim() const {
+    return dim_;
+  }
+
+  //! Raw scalar distance function (operates on already-quantized
+  //! candidates). Useful for pairwise node-vs-node distance where no
+  //! stored query is involved.
+  const DistanceFunc &func() const {
+    return func_;
+  }
+
+  //! Raw batch distance function.
+  const BatchDistanceFunc &batch_func() const {
+    return batch_func_;
+  }
+
+ private:
+  DistanceFunc func_{};
+  BatchDistanceFunc batch_func_{};
+  std::string query_storage_{};
+  size_t dim_{0};
+};
+
+}  // namespace turbo
+}  // namespace zvec
diff --git a/src/turbo/quantizer/fp16_quantizer/fp16_quantizer.cc b/src/turbo/quantizer/fp16_quantizer/fp16_quantizer.cc
new file mode 100644
index 000000000..9ceea28dc
--- /dev/null
+++ b/src/turbo/quantizer/fp16_quantizer/fp16_quantizer.cc
@@ -0,0 +1,99 @@
+// Copyright 2025-present the zvec project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "quantizer/fp16_quantizer/fp16_quantizer.h"
+#include <cmath>
+#include <cstring>
+#include <vector>
+#include <zvec/core/framework/index_error.h>
+#include <zvec/core/framework/index_factory.h>
+#include <zvec/core/framework/index_logger.h>
+#include "core/quantizer/record_quantizer.h"
+
+namespace zvec {
+namespace turbo {
+
+int Fp16Quantizer::init(const IndexMeta &meta,
+                        const ailego::Params & /*params*/) {
+  meta_ = meta;
+
+  meta_.set_meta(IndexMeta::DataType::DT_FP16, meta.dimension());
+
+  auto metric_name = meta.metric_name();
+  if (metric_name == "Cosine") {
+    extra_meta_size_ = EXTRA_META_SIZE_COSINE;
+    meta_.set_extra_meta_size(extra_meta_size_);
+  }
+
+  return 0;
+}
+
+int Fp16Quantizer::quantize(const void *query, const IndexQueryMeta &qmeta,
+                            std::string *out, IndexQueryMeta *ometa) const {
+  if (qmeta.unit_size() != sizeof(float)) {
+    return IndexError_Unsupported;
+  }
+  out->resize(qmeta.dimension() * sizeof(ailego::Float16));
+  ailego::FloatHelper::ToFP16(reinterpret_cast<const float *>(query),
+                              qmeta.dimension(),
+                              reinterpret_cast<uint16_t *>(&(*out)[0]));
+  *ometa = qmeta;
+  ometa->set_meta(IndexMeta::DataType::DT_FP16, qmeta.dimension(),
+                  static_cast<uint32_t>(type_), extra_meta_size_);
+
+  return 0;
+}
+
+int Fp16Quantizer::dequantize(const void *in, const IndexQueryMeta &qmeta,
+                              std::string *out) const {
+  if (qmeta.data_type() == IndexMeta::DataType::DT_FP16) {
+    size_t dimension = qmeta.dimension();
+
+    out->resize(dimension * sizeof(float));
+    float *out_buf = reinterpret_cast<float *>(out->data());
+
+    const uint16_t *in_buf = reinterpret_cast<const uint16_t *>(in);
+    for (size_t i = 0; i < dimension; ++i) {
+      out_buf[i] = ailego::FloatHelper::ToFP32(in_buf[i]);
+    }
+  }
+
+  return 0;
+}
+
+DistanceImpl Fp16Quantizer::distance(const void *query,
+                                     const IndexQueryMeta &qmeta) const {
+  std::string buf;
+  IndexQueryMeta ometa;
+  if (this->quantize(query, qmeta, &buf, &ometa) != 0) {
+    return DistanceImpl{};
+  }
+
+  auto metric = metric_from_name(meta_.metric_name());
+  auto func = get_distance_func(metric, DataType::kFp16, QuantizeType::kFp16,
+                                CpuArchType::kAuto);
+  if (!func) {
+    return DistanceImpl{};
+  }
+  auto batch_func = get_batch_distance_func(
+      metric, DataType::kFp16, QuantizeType::kFp16, CpuArchType::kAuto);
+
+  return DistanceImpl(std::move(func), std::move(batch_func), std::move(buf),
+                      ometa.dimension());
+}
+
+INDEX_FACTORY_REGISTER_QUANTIZER(Fp16Quantizer);
+
+}  // namespace turbo
+}  // namespace zvec
\ No newline at end of file
diff --git a/src/turbo/quantizer/fp16_quantizer/fp16_quantizer.h b/src/turbo/quantizer/fp16_quantizer/fp16_quantizer.h
new file mode 100644
index 000000000..70b91b8e2
--- /dev/null
+++ b/src/turbo/quantizer/fp16_quantizer/fp16_quantizer.h
@@ -0,0 +1,75 @@
+// Copyright 2025-present the zvec project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#pragma once
+
+#include <zvec/core/framework/index_holder.h>
+#include <zvec/core/framework/index_meta.h>
+#include <zvec/core/framework/index_reformer.h>
+#include <zvec/core/framework/index_stats.h>
+#include "quantizer/quantizer.h"
+
+namespace zvec {
+namespace turbo {
+
+using namespace zvec::core;
+
+class Fp16Quantizer : public Quantizer {
+ public:
+  Fp16Quantizer() {
+    type_ = QuantizeType::kRecordInt8;
+  }
+
+  virtual ~Fp16Quantizer() {}
+
+ public:
+  QuantizeType type() const override {
+    return type_;
+  }
+
+  int init(const core::IndexMeta &meta, const ailego::Params &params) override;
+
+  int train(core::IndexHolder::Pointer /*holder*/) override {
+    return 0;
+  }
+
+  const core::IndexMeta &meta(void) const override {
+    return meta_;
+  }
+
+  int quantize(const void *query, const core::IndexQueryMeta &qmeta,
+               std::string *out, core::IndexQueryMeta *ometa) const override;
+
+  int dequantize(const void *in, const core::IndexQueryMeta &qmeta,
+                 std::string *out) const override;
+
+  DistanceImpl distance(const void *query,
+                        const core::IndexQueryMeta &qmeta) const override;
+
+ private:
+  static constexpr uint32_t EXTRA_META_SIZE_COSINE = 4;
+
+  float bias_{0.0f};
+  float scale_{1.0f};
+  float scale_reciprocal_{1.0f};
+  bool inner_product_{false};
+
+  IndexMeta meta_{};
+  uint32_t original_dim_{0};
+  IndexMeta::DataType data_type_{};
+};
+
+
+}  // namespace turbo
+}  // namespace zvec
diff --git a/src/turbo/quantizer/fp32_quantizer/fp32_quantizer.cc b/src/turbo/quantizer/fp32_quantizer/fp32_quantizer.cc
new file mode 100644
index 000000000..e8e77bb50
--- /dev/null
+++ b/src/turbo/quantizer/fp32_quantizer/fp32_quantizer.cc
@@ -0,0 +1,109 @@
+// Copyright 2025-present the zvec project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "quantizer/fp32_quantizer/fp32_quantizer.h"
+#include <cmath>
+#include <cstring>
+#include <vector>
+#include <zvec/core/framework/index_error.h>
+#include <zvec/core/framework/index_factory.h>
+#include <zvec/core/framework/index_logger.h>
+#include "core/quantizer/record_quantizer.h"
+
+namespace zvec {
+namespace turbo {
+
+int Fp32Quantizer::init(const IndexMeta &meta,
+                        const ailego::Params & /*params*/) {
+  meta_ = meta;
+
+  meta_.set_meta(IndexMeta::DataType::DT_FP32, meta.dimension());
+
+  auto metric_name = meta.metric_name();
+  if (metric_name == "Cosine") {
+    extra_meta_size_ = EXTRA_META_SIZE_COSINE;
+    meta_.set_extra_meta_size(extra_meta_size_);
+  }
+
+  // `meta.dimension()` may be either the raw dim (when the caller passes a
+  // bare meta, e.g. unit tests) or the inflated storage dim (data + extras)
+  // when an upstream converter such as CosineConverter has already appended
+  // a norm float and set meta.extra_meta_size(). Distinguish via the input
+  // meta's extra_meta_size: if it is already set, the dim is inflated and
+  // we strip the extras to recover the raw dim; otherwise the dim is raw.
+  if (meta.extra_meta_size() > 0) {
+    original_dim_ = meta.dimension() - meta.extra_meta_size() / sizeof(float);
+  } else {
+    original_dim_ = meta.dimension();
+  }
+
+  return 0;
+}
+
+int Fp32Quantizer::quantize(const void *query, const IndexQueryMeta &qmeta,
+                            std::string *out, IndexQueryMeta *ometa) const {
+  if (qmeta.unit_size() != sizeof(float)) {
+    return IndexError_Unsupported;
+  }
+
+  // qmeta.dimension() may be the inflated (data + extras) dimension when the
+  // caller uses meta_.dimension() directly (e.g. HnswDistCalculator). Use the
+  // raw original dim we recorded at init() to avoid over-reading the query.
+  size_t raw_dim = (original_dim_ != 0 && qmeta.dimension() >= original_dim_)
+                       ? original_dim_
+                       : qmeta.dimension();
+  size_t byte_size = raw_dim * sizeof(float);
+  out->resize(byte_size);
+  std::memcpy(&(*out)[0], query, byte_size);
+
+  *ometa = qmeta;
+  ometa->set_meta(IndexMeta::DataType::DT_FP32, raw_dim,
+                  static_cast<uint32_t>(type_), extra_meta_size_);
+
+  return 0;
+}
+
+int Fp32Quantizer::dequantize(const void *in, const IndexQueryMeta &qmeta,
+                              std::string *out) const {
+  size_t byte_size = qmeta.dimension() * sizeof(float);
+  out->resize(byte_size);
+  std::memcpy(out->data(), in, byte_size);
+  return 0;
+}
+
+DistanceImpl Fp32Quantizer::distance(const void *query,
+                                     const IndexQueryMeta &qmeta) const {
+  std::string buf;
+  IndexQueryMeta ometa;
+  if (this->quantize(query, qmeta, &buf, &ometa) != 0) {
+    return DistanceImpl{};
+  }
+
+  auto metric = metric_from_name(meta_.metric_name());
+  auto func = get_distance_func(metric, DataType::kFp32, QuantizeType::kDefault,
+                                CpuArchType::kAuto);
+  if (!func) {
+    return DistanceImpl{};
+  }
+  auto batch_func = get_batch_distance_func(
+      metric, DataType::kFp32, QuantizeType::kDefault, CpuArchType::kAuto);
+
+  return DistanceImpl(std::move(func), std::move(batch_func), std::move(buf),
+                      ometa.dimension());
+}
+
+INDEX_FACTORY_REGISTER_QUANTIZER(Fp32Quantizer);
+
+}  // namespace turbo
+}  // namespace zvec
diff --git a/src/turbo/quantizer/fp32_quantizer/fp32_quantizer.h b/src/turbo/quantizer/fp32_quantizer/fp32_quantizer.h
new file mode 100644
index 000000000..47e802779
--- /dev/null
+++ b/src/turbo/quantizer/fp32_quantizer/fp32_quantizer.h
@@ -0,0 +1,70 @@
+// Copyright 2025-present the zvec project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#pragma once
+
+#include <zvec/core/framework/index_holder.h>
+#include <zvec/core/framework/index_meta.h>
+#include <zvec/core/framework/index_reformer.h>
+#include <zvec/core/framework/index_stats.h>
+#include "quantizer/quantizer.h"
+
+namespace zvec {
+namespace turbo {
+
+using namespace zvec::core;
+
+class Fp32Quantizer : public Quantizer {
+ public:
+  Fp32Quantizer() {
+    type_ = QuantizeType::kRecordInt8;
+  }
+
+  virtual ~Fp32Quantizer() {}
+
+ public:
+  QuantizeType type() const override {
+    return type_;
+  }
+
+  int init(const core::IndexMeta &meta, const ailego::Params &params) override;
+
+  int train(core::IndexHolder::Pointer /*holder*/) override {
+    return 0;
+  }
+
+  const core::IndexMeta &meta(void) const override {
+    return meta_;
+  }
+
+  int quantize(const void *query, const core::IndexQueryMeta &qmeta,
+               std::string *out, core::IndexQueryMeta *ometa) const override;
+
+  int dequantize(const void *in, const core::IndexQueryMeta &qmeta,
+                 std::string *out) const override;
+
+  DistanceImpl distance(const void *query,
+                        const core::IndexQueryMeta &qmeta) const override;
+
+ private:
+  static constexpr uint32_t EXTRA_META_SIZE_COSINE = 4;
+
+  IndexMeta meta_{};
+  uint32_t original_dim_{0};
+  IndexMeta::DataType data_type_{};
+};
+
+
+}  // namespace turbo
+}  // namespace zvec
diff --git a/src/turbo/quantizer/int4_quantizer/int4_quantizer.cc b/src/turbo/quantizer/int4_quantizer/int4_quantizer.cc
new file mode 100644
index 000000000..a21bbfc6e
--- /dev/null
+++ b/src/turbo/quantizer/int4_quantizer/int4_quantizer.cc
@@ -0,0 +1,257 @@
+// Copyright 2025-present the zvec project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "quantizer/int4_quantizer/int4_quantizer.h"
+#include <cmath>
+#include <cstring>
+#include <vector>
+#include <zvec/core/framework/index_error.h>
+#include <zvec/core/framework/index_factory.h>
+#include <zvec/core/framework/index_logger.h>
+#include "core/quantizer/record_quantizer.h"
+
+namespace zvec {
+namespace turbo {
+
+int Int4Quantizer::init(const core::IndexMeta &meta,
+                        const ailego::Params &params) {
+  data_type_ = IndexMeta::DataType::DT_INT4;
+  meta_ = meta;
+  meta_.set_meta(data_type_, meta.dimension());
+  original_dim_ = meta.dimension();
+
+  if (params.get(INT4_QUANTIZER_BIAS, &bias_) &&
+      params.get(INT4_QUANTIZER_SCALE, &scale_)) {
+    quantizer_.set_bias(bias_);
+    quantizer_.set_scale(scale_);
+  }
+
+  extra_meta_size_ = EXTRA_META_SIZE_INT4;
+
+  auto metric_name = meta.metric_name();
+  auto reciprocal = scale_ == 0.0 ? 1.0f : (1.0f / scale_);
+  if (metric_name == "SquaredEuclidean") {
+    scale_reciprocal_ = reciprocal * reciprocal;
+  } else if (metric_name == "Euclidean") {
+    scale_reciprocal_ = reciprocal;
+  } else if (metric_name == "InnerProduct") {
+    inner_product_ = true;
+    scale_reciprocal_ = reciprocal;
+  } else if (metric_name == "Cosine") {
+    inner_product_ = true;
+    cosine_ = true;
+    scale_reciprocal_ = reciprocal;  // missing query part
+
+    extra_meta_size_ += EXTRA_META_SIZE_COSINE;
+    meta_.set_extra_meta_size(extra_meta_size_);
+  } else {
+    LOG_WARN("Unsupported normalize the score for %s", metric_name.c_str());
+    scale_reciprocal_ = 1.0f;
+  }
+
+  meta_.set_extra_meta_size(extra_meta_size_);
+
+  LOG_DEBUG("Init integer reformer, bias %f, scale %f", bias_, scale_);
+  return 0;
+}
+
+int Int4Quantizer::train(core::IndexHolder::Pointer holder) {
+  if (holder->dimension() != meta_.dimension() ||
+      holder->data_type() != IndexMeta::DataType::DT_FP32) {
+    return IndexError_Mismatch;
+  }
+
+  ailego::ElapsedTime timer;
+
+  //! step1: compute max/min value
+  auto iter = holder->create_iterator();
+  if (!iter) {
+    LOG_ERROR("Failed to create iterator of holder");
+    return IndexError_Runtime;
+  }
+  std::vector<float> features;
+  float max = -std::numeric_limits<float>::max();
+  float min = std::numeric_limits<float>::max();
+  for (; iter->is_valid(); iter->next()) {
+    const float *vec = reinterpret_cast<const float *>(iter->data());
+    for (size_t i = 0; i < meta_.dimension(); ++i) {
+      max = std::max(max, vec[i]);
+      min = std::min(min, vec[i]);
+      features.emplace_back(vec[i]);
+    }
+  }
+  quantizer_.set_max(max);
+  quantizer_.set_min(min);
+
+  //! step2: feed quantizer with training data
+  for (size_t i = 0; i < features.size(); i += meta_.dimension()) {
+    quantizer_.feed(&features[i], meta_.dimension());
+  }
+
+  //! step3: feed quantizer with training data
+  if (!quantizer_.train()) {
+    LOG_ERROR("Quantizer train failed");
+    return IndexError_Runtime;
+  }
+
+  bias_ = quantizer_.bias();
+  scale_ = quantizer_.scale();
+
+  LOG_DEBUG(
+      "IntegerQuantizerConverter train done, costtime %zums, scale %f, bias "
+      "%f",
+      (size_t)timer.milli_seconds(), scale_, bias_);
+
+  return 0;
+}
+
+int Int4Quantizer::quantize(const void *record, const IndexQueryMeta &qmeta,
+                            std::string *out, IndexQueryMeta *ometa) const {
+  IndexMeta::DataType ft = qmeta.data_type();
+
+  if (ft != IndexMeta::DataType::DT_FP32 ||
+      qmeta.unit_size() !=
+          IndexMeta::UnitSizeof(IndexMeta::DataType::DT_FP32)) {
+    return IndexError_Unsupported;
+  }
+
+  *ometa = qmeta;
+  ometa->set_meta(data_type_, qmeta.dimension(), static_cast<uint32_t>(type_),
+                  extra_meta_size_);
+  size_t packed_size =
+      IndexMeta::ElementSizeof(ometa->data_type(), ometa->dimension());
+  size_t total_size = packed_size;
+  if (inner_product_) {
+    total_size += EXTRA_META_SIZE_INT4;
+    if (cosine_) {
+      total_size += EXTRA_META_SIZE_COSINE;
+    }
+  }
+  out->resize(total_size, 0);
+  const float *vec = reinterpret_cast<const float *>(record);
+  auto ovec = reinterpret_cast<uint8_t *>(&(*out)[0]);
+
+  if (!inner_product_) {
+    quantizer_.encode(vec, qmeta.dimension(), ovec);
+  } else {
+    size_t dim = qmeta.dimension();
+    const float *quantize_input = vec;
+
+    float abs_max = 0.0f;
+    for (size_t i = 0; i < dim; ++i) {
+      float a = std::abs(quantize_input[i]);
+      abs_max = std::max(a, abs_max);
+    }
+    if (abs_max == 0.0f) abs_max = 1.0f;
+    float scale = 7.0f / abs_max;
+    float sum = 0.0f;
+    float squared_sum = 0.0f;
+    int int_sum = 0;
+
+    // Pack int4 values (2 per byte): low nibble = even index, high nibble = odd
+    for (size_t i = 0; i < dim; i += 2) {
+      float lo_f = std::round(quantize_input[i] * scale);
+      float hi_f = std::round(quantize_input[i + 1] * scale);
+      int8_t lo = static_cast<int8_t>(lo_f);
+      int8_t hi = static_cast<int8_t>(hi_f);
+      ovec[i / 2] =
+          (static_cast<uint8_t>(hi) << 4) | (static_cast<uint8_t>(lo) & 0xF);
+      sum += lo_f + hi_f;
+      squared_sum += lo_f * lo_f + hi_f * hi_f;
+      int_sum += lo + hi;
+    }
+
+    // Write extras after packed int4 data
+    size_t packed_bytes = dim / 2;
+    float *extras = reinterpret_cast<float *>(ovec + packed_bytes);
+    extras[0] = abs_max / 7.0f;  // qa: dequant scale
+    extras[1] = 0.0f;            // qb: dequant bias
+    extras[2] = sum;             // qs: sum of quantized values
+    extras[3] = squared_sum;     // squared sum
+    reinterpret_cast<int *>(extras)[4] = int_sum;  // int_sum placeholder
+  }
+
+  return 0;
+}
+
+int Int4Quantizer::dequantize(const void *in, const IndexQueryMeta &qmeta,
+                              std::string *out) const {
+  if (!in || !out) {
+    return IndexError_InvalidArgument;
+  }
+
+  size_t dim = qmeta.dimension();
+  const uint8_t *ivec = reinterpret_cast<const uint8_t *>(in);
+  out->resize(dim * sizeof(float));
+  float *ovec = reinterpret_cast<float *>(&(*out)[0]);
+
+  if (!inner_product_) {
+    quantizer_.decode(ivec, dim, ovec);
+  } else {
+    for (size_t i = 0; i < dim; ++i) {
+      ovec[i] = static_cast<float>(ivec[i]);
+    }
+  }
+
+  return 0;
+}
+
+int Int4Quantizer::serialize(std::string *out) const {
+  if (!out) {
+    return IndexError_InvalidArgument;
+  }
+  out->resize(sizeof(float) * 2);
+  float *buf = reinterpret_cast<float *>(&(*out)[0]);
+  buf[0] = quantizer_.bias();
+  buf[1] = quantizer_.scale();
+  return 0;
+}
+
+int Int4Quantizer::deserialize(std::string &in) {
+  if (in.size() < sizeof(float) * 2) {
+    return IndexError_InvalidArgument;
+  }
+  const float *buf = reinterpret_cast<const float *>(in.data());
+  bias_ = buf[0];
+  scale_ = buf[1];
+  quantizer_.set_bias(bias_);
+  quantizer_.set_scale(scale_);
+  return 0;
+}
+
+DistanceImpl Int4Quantizer::distance(const void *query,
+                                     const IndexQueryMeta &qmeta) const {
+  std::string buf;
+  IndexQueryMeta ometa;
+  if (this->quantize(query, qmeta, &buf, &ometa) != 0) {
+    return DistanceImpl{};
+  }
+
+  auto metric = metric_from_name(meta_.metric_name());
+  auto func = get_distance_func(metric, DataType::kInt4, QuantizeType::kInt4,
+                                CpuArchType::kAuto);
+  if (!func) {
+    return DistanceImpl{};
+  }
+  auto batch_func = get_batch_distance_func(
+      metric, DataType::kInt4, QuantizeType::kInt4, CpuArchType::kAuto);
+
+  return DistanceImpl(std::move(func), std::move(batch_func), std::move(buf),
+                      ometa.dimension());
+}
+
+INDEX_FACTORY_REGISTER_QUANTIZER(Int4Quantizer);
+
+}  // namespace turbo
+}  // namespace zvec
\ No newline at end of file
diff --git a/src/turbo/quantizer/int4_quantizer/int4_quantizer.h b/src/turbo/quantizer/int4_quantizer/int4_quantizer.h
new file mode 100644
index 000000000..7295f0d33
--- /dev/null
+++ b/src/turbo/quantizer/int4_quantizer/int4_quantizer.h
@@ -0,0 +1,91 @@
+// Copyright 2025-present the zvec project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#pragma once
+
+#include <ailego/algorithm/integer_quantizer.h>
+#include <zvec/core/framework/index_converter.h>
+#include <zvec/core/framework/index_holder.h>
+#include <zvec/core/framework/index_meta.h>
+#include <zvec/core/framework/index_reformer.h>
+#include <zvec/core/framework/index_stats.h>
+#include "quantizer/quantizer.h"
+
+namespace zvec {
+namespace turbo {
+
+using namespace zvec::core;
+
+class Int4Quantizer : public Quantizer {
+ public:
+  Int4Quantizer() {
+    type_ = QuantizeType::kRecordInt4;
+  }
+
+  virtual ~Int4Quantizer() {}
+
+ public:
+  QuantizeType type() const override {
+    return type_;
+  }
+
+  int init(const IndexMeta &meta, const ailego::Params &params) override;
+
+  int train(IndexHolder::Pointer holder) override;
+
+  const IndexMeta &meta(void) const override {
+    return meta_;
+  }
+
+  int quantize(const void *query, const IndexQueryMeta &qmeta, std::string *out,
+               IndexQueryMeta *ometa) const override;
+
+  int dequantize(const void *in, const IndexQueryMeta &qmeta,
+                 std::string *out) const override;
+
+  int serialize(std::string *out) const override;
+
+  int deserialize(std::string &in) override;
+
+  DistanceImpl distance(const void *query,
+                        const IndexQueryMeta &qmeta) const override;
+
+  float bias() const {
+    return bias_;
+  }
+  float scale() const {
+    return scale_;
+  }
+
+ private:
+  static constexpr uint32_t EXTRA_META_SIZE_INT4 = 20;
+  static constexpr uint32_t EXTRA_META_SIZE_COSINE = 4;
+  const std::string INT4_QUANTIZER_BIAS = "int4_quantizer.bias";
+  const std::string INT4_QUANTIZER_SCALE = "int4_quantizer.scale";
+
+  float bias_{0.0f};
+  float scale_{1.0f};
+  float scale_reciprocal_{1.0f};
+  bool inner_product_{false};
+  bool cosine_{false};
+
+  mutable ailego::EntropyInt4Quantizer quantizer_;
+  IndexMeta meta_{};
+  uint32_t original_dim_{0};
+  IndexMeta::DataType data_type_{};
+};
+
+
+}  // namespace turbo
+}  // namespace zvec
diff --git a/src/turbo/quantizer/int8_quantizer/int8_quantizer.cc b/src/turbo/quantizer/int8_quantizer/int8_quantizer.cc
new file mode 100644
index 000000000..3b9e34ade
--- /dev/null
+++ b/src/turbo/quantizer/int8_quantizer/int8_quantizer.cc
@@ -0,0 +1,280 @@
+// Copyright 2025-present the zvec project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "quantizer/int8_quantizer/int8_quantizer.h"
+#include <cmath>
+#include <cstring>
+#include <vector>
+#include <zvec/core/framework/index_error.h>
+#include <zvec/core/framework/index_factory.h>
+#include <zvec/core/framework/index_logger.h>
+#include "core/quantizer/record_quantizer.h"
+
+namespace zvec {
+namespace turbo {
+
+int Int8Quantizer::init(const IndexMeta &meta, const ailego::Params &params) {
+  data_type_ = IndexMeta::DataType::DT_INT8;
+  meta_ = meta;
+  original_dim_ = meta.dimension();
+
+  if (params.get(INT8_QUANTIZER_BIAS, &bias_) &&
+      params.get(INT8_QUANTIZER_SCALE, &scale_)) {
+    quantizer_.set_bias(bias_);
+    quantizer_.set_scale(scale_);
+  }
+
+  auto metric_name = meta.metric_name();
+  auto reciprocal = scale_ == 0.0 ? 1.0f : (1.0f / scale_);
+
+  extra_meta_size_ = 0;
+  if (metric_name == "SquaredEuclidean") {
+    // Per-vector quantization (RecordQuantizer layout) so the test does not
+    // need to call train() first. Stored layout: [int8 data][20-byte tail =
+    // 4 floats (qa/qb/qs/qs2) + 1 int (int8_sum)] which matches what the
+    // turbo SE INT8 distance expects when the metric is wrapped in
+    // QuantizedInteger.
+    record_quantize_ = true;
+    scale_reciprocal_ = reciprocal * reciprocal;
+    extra_meta_size_ = EXTRA_META_SIZE_INT8;
+  } else if (metric_name == "Euclidean") {
+    scale_reciprocal_ = reciprocal;
+  } else if (metric_name == "InnerProduct") {
+    inner_product_ = true;
+    scale_reciprocal_ = reciprocal;
+    extra_meta_size_ = EXTRA_META_SIZE_INT8;
+  } else if (metric_name == "Cosine") {
+    inner_product_ = true;
+    cosine_ = true;
+    scale_reciprocal_ = reciprocal;
+    extra_meta_size_ = EXTRA_META_SIZE_INT8 + EXTRA_META_SIZE_COSINE;
+  } else {
+    LOG_WARN("Unsupported normalize the score for %s", metric_name.c_str());
+    scale_reciprocal_ = 1.0f;
+  }
+
+  // Inflate dimension by extra bytes (per-element unit=1 for INT8) so that
+  // meta_.element_size() reflects the actual per-vector storage size and
+  // HnswStreamer::check_params matches the ometa produced by quantize().
+  meta_.set_meta(data_type_, original_dim_ + extra_meta_size_);
+  meta_.set_extra_meta_size(extra_meta_size_);
+
+  if (record_quantize_) {
+    // Wrap the metric in QuantizedInteger so the streamer uses the turbo
+    // metadata-aware INT8 distance (matches RecordInt8Quantizer's approach).
+    ailego::Params metric_params;
+    metric_params.set("proxima.quantized_integer.metric.origin_metric_name",
+                      metric_name);
+    metric_params.set("proxima.quantized_integer.metric.origin_metric_params",
+                      meta.metric_params());
+    origin_metric_ = metric_from_name(metric_name);
+    meta_.set_metric("QuantizedInteger", 0, metric_params);
+  }
+
+  LOG_DEBUG("Init integer reformer, bias %f, scale %f", bias_, scale_);
+  return 0;
+}
+
+int Int8Quantizer::train(core::IndexHolder::Pointer holder) {
+  if (holder->dimension() != original_dim_ ||
+      holder->data_type() != IndexMeta::DataType::DT_FP32) {
+    return IndexError_Mismatch;
+  }
+
+  ailego::ElapsedTime timer;
+
+  //! step1: compute max/min value
+  auto iter = holder->create_iterator();
+  if (!iter) {
+    LOG_ERROR("Failed to create iterator of holder");
+    return IndexError_Runtime;
+  }
+  std::vector<float> features;
+  float max = -std::numeric_limits<float>::max();
+  float min = std::numeric_limits<float>::max();
+  for (; iter->is_valid(); iter->next()) {
+    const float *vec = reinterpret_cast<const float *>(iter->data());
+    for (size_t i = 0; i < original_dim_; ++i) {
+      max = std::max(max, vec[i]);
+      min = std::min(min, vec[i]);
+      features.emplace_back(vec[i]);
+    }
+  }
+  quantizer_.set_max(max);
+  quantizer_.set_min(min);
+
+  //! step2: feed quantizer with training data
+  for (size_t i = 0; i < features.size(); i += original_dim_) {
+    quantizer_.feed(&features[i], original_dim_);
+  }
+
+  //! step3: feed quantizer with training data
+  if (!quantizer_.train()) {
+    LOG_ERROR("Quantizer train failed");
+    return IndexError_Runtime;
+  }
+
+  bias_ = quantizer_.bias();
+  scale_ = quantizer_.scale();
+
+  LOG_DEBUG(
+      "IntegerQuantizerConverter train done, costtime %zums, scale %f, bias "
+      "%f",
+      (size_t)timer.milli_seconds(), scale_, bias_);
+
+  return 0;
+}
+
+int Int8Quantizer::quantize(const void *record, const IndexQueryMeta &qmeta,
+                            std::string *out, IndexQueryMeta *ometa) const {
+  IndexMeta::DataType ft = qmeta.data_type();
+
+  if (ft != IndexMeta::DataType::DT_FP32 ||
+      qmeta.unit_size() !=
+          IndexMeta::UnitSizeof(IndexMeta::DataType::DT_FP32)) {
+    return IndexError_Unsupported;
+  }
+
+  *ometa = qmeta;
+  // Inflate ometa dimension to match meta_ (data + extras). The HnswStreamer's
+  // check_params validates qmeta.dimension() == meta_.dimension(), so the
+  // output meta must use the same inflated dimension as quantizer->meta().
+  ometa->set_meta(data_type_, qmeta.dimension() + extra_meta_size_);
+  out->resize(ometa->element_size(), 0);
+  const float *vec = reinterpret_cast<const float *>(record);
+  auto ovec = reinterpret_cast<int8_t *>(&(*out)[0]);
+
+  if (record_quantize_) {
+    // Per-vector quantization with RecordQuantizer layout (matches turbo SE
+    // INT8 distance metadata format: [int8 data][qa][qb][qs][qs2][int8_sum]).
+    core::RecordQuantizer::quantize_record(vec, qmeta.dimension(),
+                                           core::IndexMeta::DataType::DT_INT8,
+                                           false, ovec);
+  } else if (!inner_product_) {
+    quantizer_.encode(vec, qmeta.dimension(), ovec);
+  } else {
+    size_t dim = qmeta.dimension();
+    const float *quantize_input = vec;
+
+    float abs_max = 0.0f;
+    for (size_t i = 0; i < dim; ++i) {
+      float a = std::abs(quantize_input[i]);
+      abs_max = std::max(a, abs_max);
+    }
+    if (abs_max == 0.0f) abs_max = 1.0f;
+    float scale = 127.0f / abs_max;
+    float sum = 0.0f;
+    float squared_sum = 0.0f;
+    int int8_sum = 0;
+    for (size_t i = 0; i < dim; ++i) {
+      int8_t v = static_cast<int8_t>(std::round(quantize_input[i] * scale));
+      ovec[i] = v;
+      sum += static_cast<float>(v);
+      squared_sum += static_cast<float>(v) * static_cast<float>(v);
+      int8_sum += v;
+    }
+
+    // Write extras after int8 data
+    float *extras = reinterpret_cast<float *>(ovec + dim);
+    extras[0] = abs_max / 127.0f;  // qa: dequant scale
+    extras[1] = 0.0f;              // qb: dequant bias
+    extras[2] = sum;               // qs: sum of quantized values
+    extras[3] = squared_sum;       // squared sum
+    reinterpret_cast<int32_t *>(extras + 4)[0] = int8_sum;
+  }
+
+  return 0;
+}
+
+int Int8Quantizer::dequantize(const void *in, const IndexQueryMeta & /*qmeta*/,
+                              std::string *out) const {
+  if (!in || !out) {
+    return IndexError_InvalidArgument;
+  }
+
+  // Always decode the original (pre-quantization) dimension; the IndexQueryMeta
+  // passed in may have its dimension inflated by extras.
+  size_t dim = original_dim_;
+  const int8_t *ivec = reinterpret_cast<const int8_t *>(in);
+  out->resize(dim * sizeof(float));
+  float *ovec = reinterpret_cast<float *>(&(*out)[0]);
+
+  if (record_quantize_) {
+    // Decode using the per-vector tail metadata produced by
+    // RecordQuantizer::quantize_record.
+    core::RecordQuantizer::unquantize_record(
+        in, dim, core::IndexMeta::DataType::DT_INT8, ovec);
+  } else if (!inner_product_) {
+    quantizer_.decode(ivec, dim, ovec);
+  } else {
+    for (size_t i = 0; i < dim; ++i) {
+      ovec[i] = static_cast<float>(ivec[i]);
+    }
+  }
+
+  return 0;
+}
+
+int Int8Quantizer::serialize(std::string *out) const {
+  if (!out) {
+    return IndexError_InvalidArgument;
+  }
+  out->resize(sizeof(float) * 2);
+  float *buf = reinterpret_cast<float *>(&(*out)[0]);
+  buf[0] = quantizer_.bias();
+  buf[1] = quantizer_.scale();
+  return 0;
+}
+
+int Int8Quantizer::deserialize(std::string &in) {
+  if (in.size() < sizeof(float) * 2) {
+    return IndexError_InvalidArgument;
+  }
+  const float *buf = reinterpret_cast<const float *>(in.data());
+  bias_ = buf[0];
+  scale_ = buf[1];
+  quantizer_.set_bias(bias_);
+  quantizer_.set_scale(scale_);
+  return 0;
+}
+
+DistanceImpl Int8Quantizer::distance(const void *query,
+                                     const IndexQueryMeta &qmeta) const {
+  std::string buf;
+  IndexQueryMeta ometa;
+  if (this->quantize(query, qmeta, &buf, &ometa) != 0) {
+    return DistanceImpl{};
+  }
+
+  // For record-quantize paths the wrapped meta_ metric is
+  // "QuantizedInteger"; we need the original metric for the turbo dispatch.
+  auto metric =
+      record_quantize_ ? origin_metric_ : metric_from_name(meta_.metric_name());
+  auto func = get_distance_func(metric, DataType::kInt8, QuantizeType::kInt8,
+                                CpuArchType::kAuto);
+  if (!func) {
+    return DistanceImpl{};
+  }
+  auto batch_func = get_batch_distance_func(
+      metric, DataType::kInt8, QuantizeType::kInt8, CpuArchType::kAuto);
+
+  // Pass the raw (non-inflated) dimension to the distance implementation.
+  return DistanceImpl(std::move(func), std::move(batch_func), std::move(buf),
+                      qmeta.dimension());
+}
+
+INDEX_FACTORY_REGISTER_QUANTIZER(Int8Quantizer);
+
+}  // namespace turbo
+}  // namespace zvec
\ No newline at end of file
diff --git a/src/turbo/quantizer/int8_quantizer/int8_quantizer.h b/src/turbo/quantizer/int8_quantizer/int8_quantizer.h
new file mode 100644
index 000000000..2e984a0e0
--- /dev/null
+++ b/src/turbo/quantizer/int8_quantizer/int8_quantizer.h
@@ -0,0 +1,92 @@
+// Copyright 2025-present the zvec project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#pragma once
+
+#include <ailego/algorithm/integer_quantizer.h>
+#include <zvec/core/framework/index_holder.h>
+#include <zvec/core/framework/index_meta.h>
+#include <zvec/core/framework/index_reformer.h>
+#include <zvec/core/framework/index_stats.h>
+#include "quantizer/quantizer.h"
+
+namespace zvec {
+namespace turbo {
+
+using namespace zvec::core;
+
+class Int8Quantizer : public Quantizer {
+ public:
+  Int8Quantizer() {
+    type_ = QuantizeType::kRecordInt8;
+  }
+
+  virtual ~Int8Quantizer() {}
+
+ public:
+  QuantizeType type() const override {
+    return type_;
+  }
+
+  int init(const core::IndexMeta &meta, const ailego::Params &params) override;
+
+  int train(core::IndexHolder::Pointer holder) override;
+
+  const core::IndexMeta &meta(void) const override {
+    return meta_;
+  }
+
+  int quantize(const void *query, const core::IndexQueryMeta &qmeta,
+               std::string *out, core::IndexQueryMeta *ometa) const override;
+
+  int dequantize(const void *in, const core::IndexQueryMeta &qmeta,
+                 std::string *out) const override;
+
+  int serialize(std::string *out) const override;
+
+  int deserialize(std::string &in) override;
+
+  DistanceImpl distance(const void *query,
+                        const core::IndexQueryMeta &qmeta) const override;
+
+  float bias() const {
+    return bias_;
+  }
+  float scale() const {
+    return scale_;
+  }
+
+ private:
+  static constexpr uint32_t EXTRA_META_SIZE_INT8 = 20;
+  static constexpr uint32_t EXTRA_META_SIZE_COSINE = 4;
+  const std::string INT8_QUANTIZER_BIAS = "int8_quantizer.bias";
+  const std::string INT8_QUANTIZER_SCALE = "int8_quantizer.scale";
+
+  mutable float bias_{0.0f};
+  mutable float scale_{1.0f};
+  float scale_reciprocal_{1.0f};
+  bool inner_product_{false};
+  bool cosine_{false};
+  bool record_quantize_{false};
+  MetricType origin_metric_{MetricType::kUnknown};
+
+  mutable ailego::EntropyInt8Quantizer quantizer_;
+  IndexMeta meta_{};
+  uint32_t original_dim_{0};
+  IndexMeta::DataType data_type_{};
+};
+
+
+}  // namespace turbo
+}  // namespace zvec
diff --git a/src/turbo/quantizer/quantizer.h b/src/turbo/quantizer/quantizer.h
new file mode 100644
index 000000000..40bdd484d
--- /dev/null
+++ b/src/turbo/quantizer/quantizer.h
@@ -0,0 +1,105 @@
+// Copyright 2025-present the zvec project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#pragma once
+
+#include <memory>
+#include <string>
+#include <zvec/ailego/container/params.h>
+#include <zvec/core/framework/index_error.h>
+#include <zvec/core/framework/index_holder.h>
+#include <zvec/core/framework/index_meta.h>
+#include <zvec/turbo/turbo.h>
+#include "distance.h"
+
+using namespace zvec::core;
+
+namespace zvec {
+namespace turbo {
+
+class Quantizer {
+ public:
+  typedef std::shared_ptr<Quantizer> Pointer;
+
+  Quantizer() {}
+  virtual ~Quantizer() {}
+
+  virtual QuantizeType type() const {
+    return type_;
+  }
+
+  //! Initialize quantizer with index metadata and parameters
+  virtual int init(const IndexMeta &meta, const ailego::Params &params) = 0;
+
+  //! Get the output metadata after initialization
+  virtual const IndexMeta &meta() const = 0;
+
+  //! Train the quantizer with data from an IndexHolder
+  virtual int train(IndexHolder::Pointer /*holder*/) {
+    return IndexError_NotImplemented;
+  }
+
+  //! Quantize a query vector for search
+  virtual int quantize(const void * /*query*/, const IndexQueryMeta & /*qmeta*/,
+                       std::string * /*out*/,
+                       IndexQueryMeta * /*ometa*/) const {
+    return IndexError_NotImplemented;
+  }
+
+  //! Dequantize a result vector back to original format
+  virtual int dequantize(const void * /*in*/, const IndexQueryMeta & /*qmeta*/,
+                         std::string * /*out*/) const {
+    return IndexError_NotImplemented;
+  }
+
+  //! Dequantize a result vector back to original format
+  virtual int serialize(std::string * /*out*/) const {
+    return IndexError_NotImplemented;
+  }
+
+  //! Deserialize
+  virtual int deserialize(std::string & /*in*/) {
+    return IndexError_NotImplemented;
+  }
+
+  virtual DistanceImpl distance(const void * /*query*/,
+                                const IndexQueryMeta & /*qmeta*/) const {
+    return DistanceImpl{};
+  }
+
+ protected:
+  //! Map a metric name (e.g. "SquaredEuclidean", "Cosine",
+  //! "InnerProduct", "MipsSquaredEuclidean") to its MetricType.
+  static MetricType metric_from_name(const std::string &name) {
+    if (name == "SquaredEuclidean") {
+      return MetricType::kSquaredEuclidean;
+    }
+    if (name == "Cosine") {
+      return MetricType::kCosine;
+    }
+    if (name == "InnerProduct") {
+      return MetricType::kInnerProduct;
+    }
+    if (name == "MipsSquaredEuclidean") {
+      return MetricType::kMipsSquaredEuclidean;
+    }
+    return MetricType::kUnknown;
+  }
+
+  QuantizeType type_{QuantizeType::kDefault};
+  uint32_t extra_meta_size_{0};
+};
+
+}  // namespace turbo
+}  // namespace zvec
diff --git a/src/turbo/quantizer/record_int4_quantizer/record_int4_quantizer.cc b/src/turbo/quantizer/record_int4_quantizer/record_int4_quantizer.cc
new file mode 100644
index 000000000..a988fa757
--- /dev/null
+++ b/src/turbo/quantizer/record_int4_quantizer/record_int4_quantizer.cc
@@ -0,0 +1,189 @@
+// Copyright 2025-present the zvec project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "quantizer/record_int4_quantizer/record_int4_quantizer.h"
+#include <cmath>
+#include <cstring>
+#include <vector>
+#include <zvec/core/framework/index_error.h>
+#include <zvec/core/framework/index_factory.h>
+#include <zvec/core/framework/index_logger.h>
+#include "core/quantizer/record_quantizer.h"
+
+namespace zvec {
+namespace turbo {
+
+int RecordInt4Quantizer::init(const core::IndexMeta &meta,
+                              const ailego::Params & /*params*/) {
+  if (meta.data_type() != core::IndexMeta::DataType::DT_FP32 ||
+      meta.unit_size() !=
+          core::IndexMeta::UnitSizeof(core::IndexMeta::DataType::DT_FP32)) {
+    LOG_ERROR("Unsupported type %d with unit size %u", meta.data_type(),
+              meta.unit_size());
+    return core::IndexError_Unsupported;
+  }
+
+  meta_ = meta;
+  original_dim_ = meta.dimension();
+  data_type_ = core::IndexMeta::DataType::DT_INT4;
+  meta_.set_meta(data_type_, meta_.dimension());
+
+  extra_meta_size_ = EXTRA_META_SIZE_INT4;
+  if (meta.metric_name() == "Cosine") {
+    cosine_ = true;
+    extra_meta_size_ += EXTRA_META_SIZE_COSINE;
+  } else {
+    if (meta.metric_name() == "SquaredEuclidean" ||
+        meta.metric_name() == "Euclidean") {
+      euclidean_ = true;
+    }
+  }
+
+  origin_metric_ = metric_from_name(meta.metric_name());
+
+  meta_.set_extra_meta_size(extra_meta_size_);
+
+  ailego::Params metric_params;
+  metric_params.set("proxima.quantized_integer.metric.origin_metric_name",
+                    meta.metric_name());
+  metric_params.set("proxima.quantized_integer.metric.origin_metric_params",
+                    meta.metric_params());
+  meta_.set_metric("QuantizedInteger", 0, metric_params);
+
+  return 0;
+}
+
+int RecordInt4Quantizer::quantize(const void *record,
+                                  const core::IndexQueryMeta & /*rmeta*/,
+                                  std::string *out,
+                                  core::IndexQueryMeta *ometa) const {
+  const float *src = reinterpret_cast<const float *>(record);
+  const float *quantize_input = src;
+  float norm = 1.0f;
+  std::vector<float> normalized;
+
+  if (cosine_) {
+    float sq = 0.0f;
+    for (uint32_t i = 0; i < original_dim_; ++i) {
+      sq += src[i] * src[i];
+    }
+    norm = std::sqrt(sq);
+
+    normalized.resize(original_dim_);
+    if (norm > 0.0f) {
+      for (uint32_t i = 0; i < original_dim_; ++i) {
+        normalized[i] = src[i] / norm;
+      }
+    } else {
+      std::memset(normalized.data(), 0, original_dim_ * sizeof(float));
+    }
+    quantize_input = normalized.data();
+  }
+
+  // INT4 packed size: original_dim_/2 bytes for data, plus extras
+  size_t packed_size = original_dim_ / 2;
+  size_t total_size = packed_size + EXTRA_META_SIZE_INT4;
+  if (cosine_) {
+    total_size += EXTRA_META_SIZE_COSINE;
+  }
+  out->resize(total_size, 0);
+
+  bool is_euclidean = !cosine_ && (meta_.metric_name() == "QuantizedInteger");
+  // Check original metric for euclidean
+  core::RecordQuantizer::quantize_record(quantize_input, original_dim_,
+                                         core::IndexMeta::DataType::DT_INT4,
+                                         euclidean_, &(*out)[0]);
+
+  if (cosine_) {
+    // Read back the quantized extras
+    const uint8_t *packed = reinterpret_cast<const uint8_t *>(out->data());
+    float *extras = reinterpret_cast<float *>(&(*out)[packed_size]);
+    float qa = extras[0];
+    float qb = extras[1];
+
+    // Compute dequantized norm of the quantized-then-normalized vector
+    float dequant_norm_sq = 0.0f;
+    for (uint32_t i = 0; i < original_dim_ / 2; ++i) {
+      int8_t lo = (static_cast<int8_t>(packed[i] << 4) >> 4);
+      int8_t hi = (static_cast<int8_t>(packed[i] & 0xf0) >> 4);
+      float val_lo = static_cast<float>(lo) * qa + qb;
+      float val_hi = static_cast<float>(hi) * qa + qb;
+      dequant_norm_sq += val_lo * val_lo + val_hi * val_hi;
+    }
+    float dequant_norm = std::sqrt(dequant_norm_sq);
+    if (dequant_norm > 0.0f) {
+      extras[0] = qa / dequant_norm;
+      extras[1] = qb / dequant_norm;
+      norm *= dequant_norm;
+    }
+
+    std::memcpy(&(*out)[packed_size + EXTRA_META_SIZE_INT4], &norm,
+                sizeof(float));
+  }
+
+  *ometa = core::IndexQueryMeta();
+  ometa->set_meta(core::IndexMeta::DataType::DT_INT4, meta_.dimension(),
+                  static_cast<uint32_t>(type_), extra_meta_size_);
+  return 0;
+}
+
+int RecordInt4Quantizer::dequantize(const void *in,
+                                    const core::IndexQueryMeta & /*qmeta*/,
+                                    std::string *out) const {
+  out->resize(original_dim_ * sizeof(float));
+  float *dst = reinterpret_cast<float *>(&(*out)[0]);
+
+  core::RecordQuantizer::unquantize_record(
+      in, original_dim_, core::IndexMeta::DataType::DT_INT4, dst);
+
+  if (cosine_) {
+    float norm = 0.0f;
+    size_t packed_size = original_dim_ / 2;
+    std::memcpy(
+        &norm,
+        static_cast<const char *>(in) + packed_size + EXTRA_META_SIZE_INT4,
+        sizeof(float));
+    for (uint32_t i = 0; i < original_dim_; ++i) {
+      dst[i] *= norm;
+    }
+  }
+
+  return 0;
+}
+
+DistanceImpl RecordInt4Quantizer::distance(
+    const void *query, const core::IndexQueryMeta &qmeta) const {
+  std::string buf;
+  core::IndexQueryMeta ometa;
+  if (this->quantize(query, qmeta, &buf, &ometa) != 0) {
+    return DistanceImpl{};
+  }
+
+  auto func = get_distance_func(origin_metric_, DataType::kInt4,
+                                QuantizeType::kRecordInt4, CpuArchType::kAuto);
+  if (!func) {
+    return DistanceImpl{};
+  }
+  auto batch_func =
+      get_batch_distance_func(origin_metric_, DataType::kInt4,
+                              QuantizeType::kRecordInt4, CpuArchType::kAuto);
+
+  return DistanceImpl(std::move(func), std::move(batch_func), std::move(buf),
+                      ometa.dimension());
+}
+
+INDEX_FACTORY_REGISTER_QUANTIZER(RecordInt4Quantizer);
+
+}  // namespace turbo
+}  // namespace zvec
diff --git a/src/turbo/quantizer/record_int4_quantizer/record_int4_quantizer.h b/src/turbo/quantizer/record_int4_quantizer/record_int4_quantizer.h
new file mode 100644
index 000000000..51f4db067
--- /dev/null
+++ b/src/turbo/quantizer/record_int4_quantizer/record_int4_quantizer.h
@@ -0,0 +1,72 @@
+// Copyright 2025-present the zvec project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#pragma once
+
+#include <zvec/core/framework/index_holder.h>
+#include <zvec/core/framework/index_meta.h>
+#include <zvec/core/framework/index_reformer.h>
+#include <zvec/core/framework/index_stats.h>
+#include "quantizer/quantizer.h"
+
+using namespace zvec::core;
+
+namespace zvec {
+namespace turbo {
+
+class RecordInt4Quantizer : public Quantizer {
+ public:
+  RecordInt4Quantizer() {
+    type_ = QuantizeType::kRecordInt4;
+  }
+
+  virtual ~RecordInt4Quantizer() {}
+
+ public:
+  QuantizeType type() const override {
+    return type_;
+  }
+
+  int init(const IndexMeta &meta, const ailego::Params &params) override;
+
+  const IndexMeta &meta(void) const override {
+    return meta_;
+  }
+
+  int quantize(const void *query, const IndexQueryMeta &qmeta, std::string *out,
+               IndexQueryMeta *ometa) const override;
+  int dequantize(const void *in, const IndexQueryMeta &qmeta,
+                 std::string *out) const override;
+
+  DistanceImpl distance(const void *query,
+                        const IndexQueryMeta &qmeta) const override;
+
+ private:
+  static constexpr uint32_t EXTRA_META_SIZE_INT4 = 20;
+  static constexpr uint32_t EXTRA_META_SIZE_COSINE = 4;
+
+  bool cosine_{false};
+  bool euclidean_{false};
+  uint32_t extra_meta_size_{0};
+
+  MetricType origin_metric_{MetricType::kUnknown};
+
+  uint32_t original_dim_{0};
+  IndexHolder::Pointer holder_{};
+  IndexMeta meta_{};
+  IndexMeta::DataType data_type_{};
+};
+
+}  // namespace turbo
+}  // namespace zvec
diff --git a/src/turbo/quantizer/record_int8_quantizer/record_int8_quantizer.cc b/src/turbo/quantizer/record_int8_quantizer/record_int8_quantizer.cc
new file mode 100644
index 000000000..7082e1b17
--- /dev/null
+++ b/src/turbo/quantizer/record_int8_quantizer/record_int8_quantizer.cc
@@ -0,0 +1,178 @@
+// Copyright 2025-present the zvec project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "quantizer/record_int8_quantizer/record_int8_quantizer.h"
+#include <cmath>
+#include <cstring>
+#include <vector>
+#include <zvec/core/framework/index_error.h>
+#include <zvec/core/framework/index_factory.h>
+#include <zvec/core/framework/index_logger.h>
+#include "core/quantizer/record_quantizer.h"
+
+namespace zvec {
+namespace turbo {
+
+int RecordInt8Quantizer::init(const core::IndexMeta &meta,
+                              const ailego::Params & /*params*/) {
+  if (meta.data_type() != core::IndexMeta::DataType::DT_FP32 ||
+      meta.unit_size() !=
+          core::IndexMeta::UnitSizeof(core::IndexMeta::DataType::DT_FP32)) {
+    LOG_ERROR("Unsupported type %d with unit size %u", meta.data_type(),
+              meta.unit_size());
+    return core::IndexError_Unsupported;
+  }
+
+  meta_ = meta;
+  original_dim_ = meta.dimension();
+  data_type_ = core::IndexMeta::DataType::DT_INT8;
+
+  extra_meta_size_ = EXTRA_META_SIZE_INT8;
+  if (meta.metric_name() == "Cosine") {
+    cosine_ = true;
+    extra_meta_size_ += EXTRA_META_SIZE_COSINE;
+  }
+
+  origin_metric_ = metric_from_name(meta.metric_name());
+
+  // Inflate dimension by extra bytes (INT8 unit=1) so meta_.element_size()
+  // reflects the real per-vector storage (data + extras).
+  meta_.set_meta(data_type_, original_dim_ + extra_meta_size_);
+  meta_.set_extra_meta_size(extra_meta_size_);
+
+  ailego::Params metric_params;
+  metric_params.set("proxima.quantized_integer.metric.origin_metric_name",
+                    meta.metric_name());
+  metric_params.set("proxima.quantized_integer.metric.origin_metric_params",
+                    meta.metric_params());
+  meta_.set_metric("QuantizedInteger", 0, metric_params);
+
+  return 0;
+}
+
+int RecordInt8Quantizer::quantize(const void *record,
+                                  const core::IndexQueryMeta & /*rmeta*/,
+                                  std::string *out,
+                                  core::IndexQueryMeta *ometa) const {
+  const float *src = reinterpret_cast<const float *>(record);
+  const float *quantize_input = src;
+  float norm = 1.0f;
+  std::vector<float> normalized;
+
+  if (cosine_) {
+    float sq = 0.0f;
+    for (uint32_t i = 0; i < original_dim_; ++i) {
+      sq += src[i] * src[i];
+    }
+    norm = std::sqrt(sq);
+
+    normalized.resize(original_dim_);
+    if (norm > 0.0f) {
+      for (uint32_t i = 0; i < original_dim_; ++i) {
+        normalized[i] = src[i] / norm;
+      }
+    } else {
+      std::memset(normalized.data(), 0, original_dim_ * sizeof(float));
+    }
+    quantize_input = normalized.data();
+  }
+
+  size_t packed_size = original_dim_;
+  size_t total_size = packed_size + EXTRA_META_SIZE_INT8;
+  if (cosine_) {
+    total_size += EXTRA_META_SIZE_COSINE;
+  }
+  out->resize(total_size, 0);
+  core::RecordQuantizer::quantize_record(quantize_input, original_dim_,
+                                         core::IndexMeta::DataType::DT_INT8,
+                                         false, &(*out)[0]);
+
+  if (cosine_) {
+    const int8_t *qvals = reinterpret_cast<const int8_t *>(out->data());
+    float *extras = reinterpret_cast<float *>(&(*out)[original_dim_]);
+    float qa = extras[0];
+    float qb = extras[1];
+    float dequant_norm_sq = 0.0f;
+    for (uint32_t i = 0; i < original_dim_; ++i) {
+      float val = static_cast<float>(qvals[i]) * qa + qb;
+      dequant_norm_sq += val * val;
+    }
+    float dequant_norm = std::sqrt(dequant_norm_sq);
+    if (dequant_norm > 0.0f) {
+      extras[0] = qa / dequant_norm;
+      extras[1] = qb / dequant_norm;
+      norm *= dequant_norm;
+    }
+
+    std::memcpy(&(*out)[original_dim_ + EXTRA_META_SIZE_INT8], &norm,
+                sizeof(float));
+  }
+
+  *ometa = core::IndexQueryMeta();
+  // Match meta_ dimension (data + extras) using 2-arg set_meta so that
+  // element_size() simply equals the inflated-dim byte count.
+  ometa->set_meta(core::IndexMeta::DataType::DT_INT8,
+                  original_dim_ + extra_meta_size_);
+  return 0;
+}
+
+int RecordInt8Quantizer::dequantize(const void *in,
+                                    const core::IndexQueryMeta & /*qmeta*/,
+                                    std::string *out) const {
+  out->resize(original_dim_ * sizeof(float));
+  float *dst = reinterpret_cast<float *>(&(*out)[0]);
+
+  core::RecordQuantizer::unquantize_record(
+      in, original_dim_, core::IndexMeta::DataType::DT_INT8, dst);
+
+  if (cosine_) {
+    float norm = 0.0f;
+    std::memcpy(
+        &norm,
+        static_cast<const char *>(in) + original_dim_ + EXTRA_META_SIZE_INT8,
+        sizeof(float));
+    for (uint32_t i = 0; i < original_dim_; ++i) {
+      dst[i] *= norm;
+    }
+  }
+
+  return 0;
+}
+
+DistanceImpl RecordInt8Quantizer::distance(
+    const void *query, const core::IndexQueryMeta &qmeta) const {
+  std::string buf;
+  core::IndexQueryMeta ometa;
+  if (this->quantize(query, qmeta, &buf, &ometa) != 0) {
+    return DistanceImpl{};
+  }
+
+  auto func = get_distance_func(origin_metric_, DataType::kInt8,
+                                QuantizeType::kRecordInt8, CpuArchType::kAuto);
+  if (!func) {
+    return DistanceImpl{};
+  }
+  auto batch_func =
+      get_batch_distance_func(origin_metric_, DataType::kInt8,
+                              QuantizeType::kRecordInt8, CpuArchType::kAuto);
+
+  // Pass the raw (non-inflated) dimension to the distance implementation.
+  return DistanceImpl(std::move(func), std::move(batch_func), std::move(buf),
+                      qmeta.dimension());
+}
+
+INDEX_FACTORY_REGISTER_QUANTIZER(RecordInt8Quantizer);
+
+}  // namespace turbo
+}  // namespace zvec
\ No newline at end of file
diff --git a/src/turbo/quantizer/record_int8_quantizer/record_int8_quantizer.h b/src/turbo/quantizer/record_int8_quantizer/record_int8_quantizer.h
new file mode 100644
index 000000000..53401b3cc
--- /dev/null
+++ b/src/turbo/quantizer/record_int8_quantizer/record_int8_quantizer.h
@@ -0,0 +1,72 @@
+// Copyright 2025-present the zvec project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#pragma once
+
+#include <zvec/core/framework/index_holder.h>
+#include <zvec/core/framework/index_meta.h>
+#include <zvec/core/framework/index_reformer.h>
+#include <zvec/core/framework/index_stats.h>
+#include "quantizer/quantizer.h"
+
+using namespace zvec::core;
+
+namespace zvec {
+namespace turbo {
+
+class RecordInt8Quantizer : public Quantizer {
+ public:
+  RecordInt8Quantizer() {
+    type_ = QuantizeType::kRecordInt8;
+  }
+
+  virtual ~RecordInt8Quantizer() {}
+
+ public:
+  QuantizeType type() const override {
+    return type_;
+  }
+
+  int init(const IndexMeta &meta, const ailego::Params &params) override;
+
+  const IndexMeta &meta(void) const override {
+    return meta_;
+  }
+
+  int quantize(const void *query, const IndexQueryMeta &qmeta, std::string *out,
+               IndexQueryMeta *ometa) const override;
+  int dequantize(const void *in, const IndexQueryMeta &qmeta,
+                 std::string *out) const override;
+
+  DistanceImpl distance(const void *query,
+                        const IndexQueryMeta &qmeta) const override;
+
+ private:
+  static constexpr uint32_t EXTRA_META_SIZE_INT8 = 20;
+  static constexpr uint32_t EXTRA_META_SIZE_COSINE = 4;
+
+  bool cosine_{false};
+  uint32_t extra_meta_size_{0};
+
+  MetricType origin_metric_{MetricType::kUnknown};
+
+  uint32_t original_dim_{0};
+  IndexHolder::Pointer holder_{};
+  IndexMeta meta_{};
+  IndexMeta::DataType data_type_{};
+};
+
+
+}  // namespace turbo
+}  // namespace zvec
diff --git a/src/turbo/turbo.cc b/src/turbo/turbo.cc
index a731cfed1..cd1480437 100644
--- a/src/turbo/turbo.cc
+++ b/src/turbo/turbo.cc
@@ -14,34 +14,344 @@
 
 #include <ailego/internal/cpu_features.h>
 #include <zvec/turbo/turbo.h>
+#include "armv8/float32/cosine.h"
+#include "armv8/float32/inner_product.h"
+#include "armv8/float32/squared_euclidean.h"
+#include "armv8/half_float/cosine.h"
+#include "armv8/half_float/inner_product.h"
+#include "armv8/half_float/squared_euclidean.h"
+#include "avx/float32/cosine.h"
+#include "avx/float32/inner_product.h"
+#include "avx/float32/squared_euclidean.h"
+#include "avx/half_float/cosine.h"
+#include "avx/half_float/inner_product.h"
+#include "avx/half_float/squared_euclidean.h"
+#include "avx2/record_quantized_int4/cosine.h"
+#include "avx2/record_quantized_int4/inner_product.h"
+#include "avx2/record_quantized_int4/squared_euclidean.h"
+#include "avx2/record_quantized_int8/cosine.h"
+#include "avx2/record_quantized_int8/inner_product.h"
+#include "avx2/record_quantized_int8/squared_euclidean.h"
+#include "avx512/float32/cosine.h"
+#include "avx512/float32/inner_product.h"
+#include "avx512/float32/squared_euclidean.h"
+#include "avx512/half_float/cosine.h"
+#include "avx512/half_float/inner_product.h"
+#include "avx512/half_float/squared_euclidean.h"
+#include "avx512_fp16/half_float/cosine.h"
+#include "avx512_fp16/half_float/inner_product.h"
+#include "avx512_fp16/half_float/squared_euclidean.h"
 #include "avx512_vnni/record_quantized_int8/cosine.h"
+#include "avx512_vnni/record_quantized_int8/inner_product.h"
 #include "avx512_vnni/record_quantized_int8/squared_euclidean.h"
+#include "scalar/float32/cosine.h"
+#include "scalar/float32/inner_product.h"
+#include "scalar/float32/squared_euclidean.h"
+#include "scalar/half_float/cosine.h"
+#include "scalar/half_float/inner_product.h"
+#include "scalar/half_float/squared_euclidean.h"
+#include "scalar/record_quantized_int4/cosine.h"
+#include "scalar/record_quantized_int4/inner_product.h"
+#include "scalar/record_quantized_int4/squared_euclidean.h"
+#include "scalar/record_quantized_int8/cosine.h"
+#include "scalar/record_quantized_int8/inner_product.h"
+#include "scalar/record_quantized_int8/squared_euclidean.h"
+#include "sse/record_quantized_int4/cosine.h"
+#include "sse/record_quantized_int4/inner_product.h"
+#include "sse/record_quantized_int4/squared_euclidean.h"
+#include "sse/record_quantized_int8/cosine.h"
+#include "sse/record_quantized_int8/inner_product.h"
+#include "sse/record_quantized_int8/squared_euclidean.h"
 
 namespace zvec::turbo {
 
 DistanceFunc get_distance_func(MetricType metric_type, DataType data_type,
-                               QuantizeType quantize_type) {
+                               QuantizeType quantize_type,
+                               CpuArchType cpu_arch_type) {
+#if defined(__ARM_NEON)
+  // INT8
   if (data_type == DataType::kInt8) {
     if (quantize_type == QuantizeType::kDefault) {
-      if (zvec::ailego::internal::CpuFeatures::static_flags_.AVX512_VNNI) {
+      if (metric_type == MetricType::kSquaredEuclidean) {
+        return scalar::squared_euclidean_int8_distance;
+      }
+
+      if (metric_type == MetricType::kCosine) {
+        return scalar::cosine_int8_distance;
+      }
+
+      if (metric_type == MetricType::kInnerProduct) {
+        return scalar::inner_product_int8_distance;
+      }
+    }
+  }
+
+  // INT$
+  if (data_type == DataType::kInt4) {
+    if (quantize_type == QuantizeType::kDefault) {
+      if (metric_type == MetricType::kSquaredEuclidean) {
+        return scalar::squared_euclidean_int4_distance;
+      }
+
+      if (metric_type == MetricType::kCosine) {
+        return scalar::cosine_int4_distance;
+      }
+
+      if (metric_type == MetricType::kInnerProduct) {
+        return scalar::inner_product_int4_distance;
+      }
+    }
+  }
+
+  // FP32
+  if (data_type == DataType::kFp32) {
+    if (quantize_type == QuantizeType::kDefault) {
+      if (metric_type == MetricType::kSquaredEuclidean) {
+        return armv8::squared_euclidean_fp32_distance;
+      }
+
+      if (metric_type == MetricType::kCosine) {
+        return armv8::cosine_fp32_distance;
+      }
+
+      if (metric_type == MetricType::kInnerProduct) {
+        return armv8::inner_product_fp32_distance;
+      }
+    }
+  }
+
+  // FP16
+  if (data_type == DataType::kFp16) {
+    if (quantize_type == QuantizeType::kDefault) {
+      if (metric_type == MetricType::kSquaredEuclidean) {
+        return armv8::squared_euclidean_fp16_distance;
+      }
+
+      if (metric_type == MetricType::kCosine) {
+        return armv8::cosine_fp16_distance;
+      }
+
+      if (metric_type == MetricType::kInnerProduct) {
+        return armv8::inner_product_fp16_distance;
+      }
+    }
+  }
+#else
+  // INT8
+  if (data_type == DataType::kInt8) {
+    if (quantize_type == QuantizeType::kDefault) {
+      if (zvec::ailego::internal::CpuFeatures::static_flags_.AVX512_VNNI &&
+          (cpu_arch_type == CpuArchType::kAuto ||
+           cpu_arch_type == CpuArchType::kAVX512VNNI)) {
         if (metric_type == MetricType::kSquaredEuclidean) {
           return avx512_vnni::squared_euclidean_int8_distance;
         }
         if (metric_type == MetricType::kCosine) {
           return avx512_vnni::cosine_int8_distance;
         }
+
+        if (metric_type == MetricType::kInnerProduct) {
+          return avx512_vnni::inner_product_int8_distance;
+        }
+      }
+
+      if (zvec::ailego::internal::CpuFeatures::static_flags_.AVX2 &&
+          (cpu_arch_type == CpuArchType::kAuto ||
+           cpu_arch_type == CpuArchType::kAVX2)) {
+        if (metric_type == MetricType::kSquaredEuclidean) {
+          return avx2::squared_euclidean_int8_distance;
+        }
+        if (metric_type == MetricType::kCosine) {
+          return avx2::cosine_int8_distance;
+        }
+
+        if (metric_type == MetricType::kInnerProduct) {
+          return avx2::inner_product_int8_distance;
+        }
+      }
+
+      if (zvec::ailego::internal::CpuFeatures::static_flags_.SSE &&
+          (cpu_arch_type == CpuArchType::kAuto ||
+           cpu_arch_type == CpuArchType::kSSE)) {
+        if (metric_type == MetricType::kSquaredEuclidean) {
+          return sse::squared_euclidean_int8_distance;
+        }
+        if (metric_type == MetricType::kCosine) {
+          return sse::cosine_int8_distance;
+        }
+
+        if (metric_type == MetricType::kInnerProduct) {
+          return sse::inner_product_int8_distance;
+        }
+      }
+
+      if (metric_type == MetricType::kSquaredEuclidean) {
+        return scalar::squared_euclidean_int8_distance;
+      }
+      if (metric_type == MetricType::kCosine) {
+        return scalar::cosine_int8_distance;
+      }
+
+      if (metric_type == MetricType::kInnerProduct) {
+        return scalar::inner_product_int8_distance;
+      }
+    }
+  }
+
+  // INT4
+  if (data_type == DataType::kInt4) {
+    if (quantize_type == QuantizeType::kDefault) {
+      if (zvec::ailego::internal::CpuFeatures::static_flags_.AVX2 &&
+          (cpu_arch_type == CpuArchType::kAuto ||
+           cpu_arch_type == CpuArchType::kAVX2)) {
+        if (metric_type == MetricType::kSquaredEuclidean) {
+          return avx2::squared_euclidean_int4_distance;
+        }
+        if (metric_type == MetricType::kCosine) {
+          return avx2::cosine_int4_distance;
+        }
+        if (metric_type == MetricType::kInnerProduct) {
+          return avx2::inner_product_int4_distance;
+        }
+      }
+
+      if (zvec::ailego::internal::CpuFeatures::static_flags_.SSE &&
+          (cpu_arch_type == CpuArchType::kAuto ||
+           cpu_arch_type == CpuArchType::kSSE)) {
+        if (metric_type == MetricType::kSquaredEuclidean) {
+          return sse::squared_euclidean_int4_distance;
+        }
+        if (metric_type == MetricType::kCosine) {
+          return sse::cosine_int4_distance;
+        }
+        if (metric_type == MetricType::kInnerProduct) {
+          return sse::inner_product_int4_distance;
+        }
+      }
+
+      if (metric_type == MetricType::kSquaredEuclidean) {
+        return scalar::squared_euclidean_int4_distance;
+      } else if (metric_type == MetricType::kCosine) {
+        return scalar::cosine_int4_distance;
+      } else if (metric_type == MetricType::kInnerProduct) {
+        return scalar::inner_product_int4_distance;
+      }
+    }
+  }
+
+  // FP32
+  if (data_type == DataType::kFp32) {
+    if (quantize_type == QuantizeType::kDefault) {
+      if (zvec::ailego::internal::CpuFeatures::static_flags_.AVX512F &&
+          (cpu_arch_type == CpuArchType::kAuto ||
+           cpu_arch_type == CpuArchType::kAVX512)) {
+        if (metric_type == MetricType::kSquaredEuclidean) {
+          return avx512::squared_euclidean_fp32_distance;
+        }
+        if (metric_type == MetricType::kCosine) {
+          return avx512::cosine_fp32_distance;
+        }
+        if (metric_type == MetricType::kInnerProduct) {
+          return avx512::inner_product_fp32_distance;
+        }
+      }
+
+      if (zvec::ailego::internal::CpuFeatures::static_flags_.AVX &&
+          (cpu_arch_type == CpuArchType::kAuto ||
+           cpu_arch_type == CpuArchType::kAVX)) {
+        if (metric_type == MetricType::kSquaredEuclidean) {
+          return avx::squared_euclidean_fp32_distance;
+        }
+        if (metric_type == MetricType::kCosine) {
+          return avx::cosine_fp32_distance;
+        }
+        if (metric_type == MetricType::kInnerProduct) {
+          return avx::inner_product_fp32_distance;
+        }
+      }
+
+      if (metric_type == MetricType::kSquaredEuclidean) {
+        return scalar::squared_euclidean_fp32_distance;
+      }
+      if (metric_type == MetricType::kCosine) {
+        return scalar::cosine_fp32_distance;
+      }
+      if (metric_type == MetricType::kInnerProduct) {
+        return scalar::inner_product_fp32_distance;
       }
     }
   }
+
+  // FP16
+  if (data_type == DataType::kFp16) {
+    if (quantize_type == QuantizeType::kDefault) {
+      if (zvec::ailego::internal::CpuFeatures::static_flags_.AVX512_FP16 &&
+          (cpu_arch_type == CpuArchType::kAuto ||
+           cpu_arch_type == CpuArchType::kAVX512FP16)) {
+        if (metric_type == MetricType::kInnerProduct) {
+          return avx512_fp16::inner_product_fp16_distance;
+        }
+        if (metric_type == MetricType::kCosine) {
+          return avx512_fp16::cosine_fp16_distance;
+        }
+        if (metric_type == MetricType::kSquaredEuclidean) {
+          return avx512_fp16::squared_euclidean_fp16_distance;
+        }
+      }
+
+      if (zvec::ailego::internal::CpuFeatures::static_flags_.AVX512F &&
+          (cpu_arch_type == CpuArchType::kAuto ||
+           cpu_arch_type == CpuArchType::kAVX512)) {
+        if (metric_type == MetricType::kSquaredEuclidean) {
+          return avx512::squared_euclidean_fp16_distance;
+        }
+        if (metric_type == MetricType::kCosine) {
+          return avx512::cosine_fp16_distance;
+        }
+        if (metric_type == MetricType::kInnerProduct) {
+          return avx512::inner_product_fp16_distance;
+        }
+      }
+
+      if (zvec::ailego::internal::CpuFeatures::static_flags_.AVX &&
+          (cpu_arch_type == CpuArchType::kAuto ||
+           cpu_arch_type == CpuArchType::kAVX)) {
+        if (metric_type == MetricType::kSquaredEuclidean) {
+          return avx::squared_euclidean_fp16_distance;
+        }
+        if (metric_type == MetricType::kCosine) {
+          return avx::cosine_fp16_distance;
+        }
+        if (metric_type == MetricType::kInnerProduct) {
+          return avx::inner_product_fp16_distance;
+        }
+      }
+
+      if (metric_type == MetricType::kSquaredEuclidean) {
+        return scalar::squared_euclidean_fp16_distance;
+      }
+      if (metric_type == MetricType::kCosine) {
+        return scalar::cosine_fp16_distance;
+      }
+      if (metric_type == MetricType::kInnerProduct) {
+        return scalar::inner_product_fp16_distance;
+      }
+    }
+  }
+#endif
+
   return nullptr;
 }
 
 BatchDistanceFunc get_batch_distance_func(MetricType metric_type,
                                           DataType data_type,
-                                          QuantizeType quantize_type) {
+                                          QuantizeType quantize_type,
+                                          CpuArchType cpu_arch_type) {
   if (data_type == DataType::kInt8) {
     if (quantize_type == QuantizeType::kDefault) {
-      if (zvec::ailego::internal::CpuFeatures::static_flags_.AVX512_VNNI) {
+      if (zvec::ailego::internal::CpuFeatures::static_flags_.AVX512_VNNI &&
+          (cpu_arch_type == CpuArchType::kAuto ||
+           cpu_arch_type == CpuArchType::kAVX512VNNI)) {
         if (metric_type == MetricType::kSquaredEuclidean) {
           return avx512_vnni::squared_euclidean_int8_batch_distance;
         }
@@ -51,15 +361,34 @@ BatchDistanceFunc get_batch_distance_func(MetricType metric_type,
       }
     }
   }
+
+  if (data_type == DataType::kInt4) {
+    if (quantize_type == QuantizeType::kDefault) {
+      if (zvec::ailego::internal::CpuFeatures::static_flags_.AVX2 &&
+          (cpu_arch_type == CpuArchType::kAuto ||
+           cpu_arch_type == CpuArchType::kAVX2)) {
+        // NOTE: avx2::{squared_euclidean,cosine,inner_product}_int4_batch
+        // call into inner_product_int4_batch_avx2_impl which currently has
+        // an empty body, so the resulting integer inner products would be
+        // uninitialized garbage. Return nullptr for all INT4 batch metrics
+        // here so callers fall back to the correct scalar/per-vector path.
+        (void)metric_type;
+      }
+    }
+  }
+
   return nullptr;
 }
 
 QueryPreprocessFunc get_query_preprocess_func(MetricType metric_type,
                                               DataType data_type,
-                                              QuantizeType quantize_type) {
+                                              QuantizeType quantize_type,
+                                              CpuArchType cpu_arch_type) {
   if (data_type == DataType::kInt8) {
     if (quantize_type == QuantizeType::kDefault) {
-      if (zvec::ailego::internal::CpuFeatures::static_flags_.AVX512_VNNI) {
+      if (zvec::ailego::internal::CpuFeatures::static_flags_.AVX512_VNNI &&
+          (cpu_arch_type == CpuArchType::kAuto ||
+           cpu_arch_type == CpuArchType::kAVX512VNNI)) {
         if (metric_type == MetricType::kSquaredEuclidean) {
           return avx512_vnni::squared_euclidean_int8_query_preprocess;
         }
diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt
index 7be2294dd..e3b54ee24 100644
--- a/tests/CMakeLists.txt
+++ b/tests/CMakeLists.txt
@@ -7,6 +7,7 @@ include_directories(${PROJECT_ROOT_DIR})
 cc_directories(ailego)
 cc_directories(db)
 cc_directories(core)
+cc_directories(turbo)
 if(BUILD_C_BINDINGS)
     cc_directories(c)
 endif()
diff --git a/tests/core/algorithm/hnsw/CMakeLists.txt b/tests/core/algorithm/hnsw/CMakeLists.txt
index 10c71d0cd..3bd58e6c5 100644
--- a/tests/core/algorithm/hnsw/CMakeLists.txt
+++ b/tests/core/algorithm/hnsw/CMakeLists.txt
@@ -7,7 +7,7 @@ foreach(CC_SRCS ${ALL_TEST_SRCS})
   cc_gtest(
       NAME ${CC_TARGET}
       STRICT
-      LIBS zvec_ailego core_framework core_utility core_metric core_quantizer core_knn_hnsw core_knn_flat
+      LIBS zvec_ailego core_framework core_utility core_metric core_quantizer core_knn_hnsw core_knn_flat zvec_turbo
       SRCS ${CC_SRCS}
       INCS . ${PROJECT_ROOT_DIR}/src/core ${PROJECT_ROOT_DIR}/src/core/algorithm/hnsw
     )
diff --git a/tests/core/algorithm/hnsw/hnsw_streamer_test.cc b/tests/core/algorithm/hnsw/hnsw_streamer_test.cc
index 2966b330b..69731173e 100644
--- a/tests/core/algorithm/hnsw/hnsw_streamer_test.cc
+++ b/tests/core/algorithm/hnsw/hnsw_streamer_test.cc
@@ -25,6 +25,7 @@
 #include <gtest/gtest.h>
 #include <zvec/ailego/container/vector.h>
 #include "tests/test_util.h"
+#include "turbo/quantizer/quantizer.h"
 
 #if defined(__GNUC__) || defined(__GNUG__)
 #pragma GCC diagnostic push
@@ -3447,93 +3448,6 @@ TEST_F(HnswStreamerTest, TestGroupInBruteforceSearch) {
   }
 }
 
-#if 0
-TEST_F(HnswStreamerTest, TestBinaryConverter) {
-  uint32_t dimension = 2560;
-
-  IndexStreamer::Pointer streamer =
-      IndexFactory::CreateStreamer("HnswStreamer");
-  ASSERT_TRUE(streamer != nullptr);
-
-  ailego::Params params;
-  // params.set(PARAM_HNSW_STREAMER_MAX_NEIGHBOR_COUNT, 10);
-  // params.set(PARAM_HNSW_STREAMER_SCALING_FACTOR, 16);
-  // params.set(PARAM_HNSW_STREAMER_EFCONSTRUCTION, 10);
-  // params.set(PARAM_HNSW_STREAMER_EF, 5);
-  params.set(PARAM_HNSW_STREAMER_BRUTE_FORCE_THRESHOLD, 1000U);
-
-  ailego::Params stg_params;
-
-  IndexMeta index_meta_raw(IndexMeta::DataType::DT_FP32, dimension);
-  index_meta_raw.set_metric("InnerProduct", 0, ailego::Params());
-
-  ailego::Params converter_params;
-  auto converter = IndexFactory::CreateConverter("BinaryConverter");
-  ASSERT_TRUE(converter != nullptr);
-
-  converter->init(index_meta_raw, converter_params);
-
-  IndexMeta index_meta = converter->meta();
-
-  auto reformer = IndexFactory::CreateReformer(index_meta.reformer_name());
-  ASSERT_TRUE(reformer != nullptr);
-
-  ASSERT_EQ(0, reformer->init(index_meta.reformer_params()));
-
-  auto storage = IndexFactory::CreateStorage("MMapFileStorage");
-  ASSERT_EQ(0, storage->init(stg_params));
-  ASSERT_EQ(0, storage->open(dir_ + "TestBinaryConverter.index", true));
-  ASSERT_EQ(0, streamer->init(index_meta, params));
-  ASSERT_EQ(0, streamer->open(storage));
-
-  size_t cnt = 5000U;
-  auto ctx = streamer->create_context();
-  ASSERT_TRUE(!!ctx);
-
-  IndexQueryMeta qmeta(IndexMeta::DataType::DT_FP32, dimension);
-
-  std::random_device rd;
-  std::mt19937 gen(rd());
-
-  std::uniform_real_distribution<float> dist(-2.0, 2.0);
-  std::vector<NumericalVector<float>> vecs;
-
-  for (size_t i = 0; i < cnt; i++) {
-    NumericalVector<float> vec(dimension);
-    for (size_t j = 0; j < dimension; ++j) {
-      vec[j] = dist(gen);
-    }
-
-    std::string new_vec;
-    IndexQueryMeta new_meta;
-
-    ASSERT_EQ(0, reformer->convert(vec.data(), qmeta, &new_vec, &new_meta));
-    ASSERT_EQ(0, streamer->add_impl(i, new_vec.data(), new_meta, ctx));
-
-    vecs.push_back(vec);
-  }
-
-  size_t query_cnt = 200U;
-  auto knnCtx = streamer->create_context();
-
-  float epison = 1e-6;
-  for (size_t i = 0; i < query_cnt; i++) {
-    auto &vec = vecs[i];
-    std::string new_query;
-    IndexQueryMeta new_meta;
-    ASSERT_EQ(0, reformer->transform(vec.data(), qmeta, &new_query, &new_meta));
-
-    size_t topk = 50;
-    knnCtx->set_topk(topk);
-    ASSERT_EQ(0, streamer->search_impl(new_query.data(), new_meta, knnCtx));
-    auto &results = knnCtx->result();
-    ASSERT_EQ(topk, results.size());
-    ASSERT_EQ(i, results[0].key());
-    ASSERT_NEAR(0, results[0].score(), epison);
-  }
-}
-#endif
-
 TEST_F(HnswStreamerTest, TestAddAndSearchWithID) {
   IndexStreamer::Pointer streamer =
       IndexFactory::CreateStreamer("HnswStreamer");
@@ -3647,130 +3561,394 @@ TEST_F(HnswStreamerTest, TestAddAndSearchWithID) {
   // EXPECT_GT(cost, 2.0f);
 }
 
-#if 0
-TEST_F(HnswStreamerTest, TestBasicRefiner) {
-  uint32_t dimension = 1120;
-
-  IndexStreamer::Pointer base_streamer =
+TEST_F(HnswStreamerTest, TestTurboCosineRecordInt8Quantizer) {
+  IndexStreamer::Pointer streamer =
       IndexFactory::CreateStreamer("HnswStreamer");
-  ASSERT_TRUE(base_streamer != nullptr);
+  ASSERT_TRUE(streamer != nullptr);
 
-  IndexStreamer::Pointer refine_streamer =
-      IndexFactory::CreateStreamer("FlatStreamer");
-  ASSERT_TRUE(refine_streamer != nullptr);
+  ailego::Params params;
+  params.set(PARAM_HNSW_STREAMER_MAX_NEIGHBOR_COUNT, 50);
+  params.set(PARAM_HNSW_STREAMER_SCALING_FACTOR, 16);
+  params.set(PARAM_HNSW_STREAMER_EFCONSTRUCTION, 200);
+  params.set(PARAM_HNSW_STREAMER_EF, 200);
+  params.set(PARAM_HNSW_STREAMER_BRUTE_FORCE_THRESHOLD, 1000U);
+  params.set(PARAM_HNSW_STREAMER_GET_VECTOR_ENABLE, true);
 
-  IndexRefiner::Pointer refiner = IndexFactory::CreateRefiner("BasicRefiner");
-  ASSERT_TRUE(refiner != nullptr);
+  ailego::Params stg_params;
 
-  ailego::Params params;
-  IndexMeta index_meta(IndexMeta::DataType::DT_FP32, dimension);
-  index_meta.set_metric("InnerProduct", 0, ailego::Params());
+  IndexMeta index_meta_raw(IndexMeta::DataType::DT_FP32, dim);
+  index_meta_raw.set_metric("Cosine", 0, ailego::Params());
 
   ailego::Params converter_params;
-  auto converter = IndexFactory::CreateConverter("BinaryConverter");
-  ASSERT_TRUE(converter != nullptr);
+  auto quantizer = IndexFactory::CreateQuantizer("RecordInt8Quantizer");
+  ASSERT_TRUE(quantizer != nullptr);
 
-  converter->init(index_meta, converter_params);
+  quantizer->init(index_meta_raw, converter_params);
 
-  IndexMeta index_meta_binary = converter->meta();
+  IndexMeta index_meta = quantizer->meta();
 
-  auto reformer =
-      IndexFactory::CreateReformer(index_meta_binary.reformer_name());
-  ASSERT_TRUE(reformer != nullptr);
+  auto storage = IndexFactory::CreateStorage("MMapFileStorage");
+  ASSERT_EQ(0, storage->init(stg_params));
+  ASSERT_EQ(0,
+            storage->open(dir_ + "TestTurboCosineInt8Quantizer.index", true));
+  ASSERT_EQ(0, streamer->init(index_meta, params));
+  ASSERT_EQ(0, streamer->open(storage));
+
+  NumericalVector<float> vec(dim);
+  size_t cnt = 2000U;
+  auto ctx = streamer->create_context();
+  ASSERT_TRUE(!!ctx);
+
+  IndexQueryMeta qmeta(IndexMeta::DataType::DT_FP32, dim);
+  IndexQueryMeta new_meta;
+
+  const float epsilon = 1e-2;
+  float fixed_value = float(cnt) / 2;
+  for (size_t i = 0; i < cnt; i++) {
+    float add_on = i * 10;
+    for (size_t j = 0; j < dim; ++j) {
+      if (j < dim / 4)
+        vec[j] = fixed_value;
+      else
+        vec[j] = fixed_value + add_on;
+    }
+
+    std::string new_vec;
+
+    ASSERT_EQ(0, quantizer->quantize(vec.data(), qmeta, &new_vec, &new_meta));
+    ASSERT_EQ(0, streamer->add_impl(i, new_vec.data(), new_meta, ctx));
+  }
 
-  ASSERT_EQ(0, reformer->init(index_meta_binary.reformer_params()));
+  for (size_t i = 0; i < cnt; i++) {
+    float add_on = i * 10;
 
-  // base streamer
-  ailego::Params base_stg_params;
-  auto base_storage = IndexFactory::CreateStorage("MMapFileStorage");
-  ASSERT_EQ(0, base_storage->init(base_stg_params));
-  ASSERT_EQ(0, base_storage->open(dir_ + "TestBasicRefinerBase.index", true));
-  ASSERT_EQ(0, base_streamer->init(index_meta_binary, params));
-  ASSERT_EQ(0, base_streamer->open(base_storage));
+    const void *vector = streamer->get_vector(i);
+    ASSERT_NE(vector, nullptr);
 
-  auto base_ctx = base_streamer->create_context();
-  ASSERT_TRUE(!!base_ctx);
+    std::string denormalized_vec;
+    denormalized_vec.resize(dim * sizeof(float));
+    quantizer->dequantize(vector, new_meta, &denormalized_vec);
 
-  // refine streamer
-  ailego::Params refine_stg_params;
-  auto refine_storage = IndexFactory::CreateStorage("MMapFileStorage");
-  ASSERT_EQ(0, refine_storage->init(refine_stg_params));
-  ASSERT_EQ(0,
-            refine_storage->open(dir_ + "TestBasicRefinerRefine.index", true));
-  ASSERT_EQ(0, refine_streamer->init(index_meta, params));
-  ASSERT_EQ(0, refine_streamer->open(refine_storage));
-  auto refine_ctx = refine_streamer->create_context();
-  ASSERT_TRUE(!!refine_ctx);
+    float vector_value = *((float *)(denormalized_vec.data()) + dim - 1);
+    EXPECT_NEAR(vector_value, fixed_value + add_on, epsilon);
+  }
 
-  ailego::Params refiner_params;
-  ASSERT_EQ(0, refiner->init(base_streamer, refine_streamer, refiner_params));
+  auto linearCtx = streamer->create_context();
+  linearCtx->set_fetch_vector(true);
+  auto knnCtx = streamer->create_context();
+  knnCtx->set_fetch_vector(true);
+
+  size_t query_cnt = 200U;
+  size_t topk = 200;
+  linearCtx->set_topk(topk);
+  knnCtx->set_topk(topk);
+  uint64_t knnTotalTime = 0;
+  uint64_t linearTotalTime = 0;
+  for (size_t i = 0; i < query_cnt; i++) {
+    float add_on = i * 10;
+    for (size_t j = 0; j < dim; ++j) {
+      if (j < dim / 4)
+        vec[j] = fixed_value;
+      else
+        vec[j] = fixed_value + add_on;
+    }
+
+    std::string new_query;
+    IndexQueryMeta new_meta;
+    ASSERT_EQ(0, quantizer->quantize(vec.data(), qmeta, &new_query, &new_meta));
+
+    auto t1 = ailego::Realtime::MicroSeconds();
+    ASSERT_EQ(0, streamer->search_impl(new_query.data(), new_meta, knnCtx));
+    auto t2 = ailego::Realtime::MicroSeconds();
+    ASSERT_EQ(0,
+              streamer->search_bf_impl(new_query.data(), new_meta, linearCtx));
+    auto t3 = ailego::Realtime::MicroSeconds();
+
+    knnTotalTime += t2 - t1;
+    linearTotalTime += t3 - t2;
+
+    auto &knnResult = knnCtx->result();
+    ASSERT_EQ(topk, knnResult.size());
+
+    auto &linearResult = linearCtx->result();
+    ASSERT_EQ(topk, linearResult.size());
+    ASSERT_EQ(i, linearResult[0].key());
+
+    ASSERT_NE(knnResult[0].vector(), nullptr);
+    ASSERT_NE(linearResult[0].vector(), nullptr);
+
+    std::string denormalized_vec;
+    denormalized_vec.resize(dim * sizeof(float));
+    quantizer->dequantize(linearResult[0].vector(), new_meta,
+                          &denormalized_vec);
+
+    float vector_value = *(((float *)(denormalized_vec.data()) + dim - 1));
+    EXPECT_NEAR(vector_value, fixed_value + add_on, epsilon);
+  }
+
+  std::cout << "knnTotalTime: " << knnTotalTime << std::endl;
+  std::cout << "linearTotalTime: " << linearTotalTime << std::endl;
+}
+
+TEST_F(HnswStreamerTest, TestTurboSquaredEuclideanRecordInt8Quantizer) {
+  IndexStreamer::Pointer streamer =
+      IndexFactory::CreateStreamer("HnswStreamer");
+  ASSERT_TRUE(streamer != nullptr);
+
+  ailego::Params params;
+  params.set(PARAM_HNSW_STREAMER_MAX_NEIGHBOR_COUNT, 50);
+  params.set(PARAM_HNSW_STREAMER_SCALING_FACTOR, 16);
+  params.set(PARAM_HNSW_STREAMER_EFCONSTRUCTION, 100);
+  params.set(PARAM_HNSW_STREAMER_EF, 100);
+  params.set(PARAM_HNSW_STREAMER_BRUTE_FORCE_THRESHOLD, 1000U);
+  params.set(PARAM_HNSW_STREAMER_GET_VECTOR_ENABLE, true);
+
+  ailego::Params stg_params;
+
+  IndexMeta index_meta_raw(IndexMeta::DataType::DT_FP32, dim);
+  index_meta_raw.set_metric("SquaredEuclidean", 0, ailego::Params());
+
+  ailego::Params converter_params;
+  auto quantizer = IndexFactory::CreateQuantizer("RecordInt8Quantizer");
+  ASSERT_TRUE(quantizer != nullptr);
+
+  quantizer->init(index_meta_raw, converter_params);
+
+  IndexMeta index_meta = quantizer->meta();
+
+  auto storage = IndexFactory::CreateStorage("MMapFileStorage");
+  ASSERT_EQ(0, storage->init(stg_params));
+  ASSERT_EQ(0,
+            storage->open(dir_ + "TestTurboCosineInt8Quantizer.index", true));
+  ASSERT_EQ(0, streamer->init(index_meta, params));
+  ASSERT_EQ(0, streamer->open(storage));
 
-  auto ctx = refiner->create_context();
+  NumericalVector<float> vec(dim);
+  size_t cnt = 2000U;
+  auto ctx = streamer->create_context();
   ASSERT_TRUE(!!ctx);
 
-  IndexQueryMeta qmeta(IndexMeta::DataType::DT_FP32, dimension);
+  IndexQueryMeta qmeta(IndexMeta::DataType::DT_FP32, dim);
+  IndexQueryMeta new_meta;
 
-  std::random_device rd;
-  std::mt19937 gen(rd());
+  const float epsilon = 1e-2;
+  float fixed_value = float(cnt) / 2;
+  for (size_t i = 0; i < cnt; i++) {
+    float add_on = i * 10;
+    for (size_t j = 0; j < dim; ++j) {
+      if (j < dim / 4)
+        vec[j] = fixed_value;
+      else
+        vec[j] = fixed_value + add_on;
+    }
 
-  std::uniform_real_distribution<float> dist(-2.0, 2.0);
-  std::vector<NumericalVector<float>> vecs;
+    std::string new_vec;
+
+    ASSERT_EQ(0, quantizer->quantize(vec.data(), qmeta, &new_vec, &new_meta));
+    ASSERT_EQ(0, streamer->add_impl(i, new_vec.data(), new_meta, ctx));
+  }
 
-  size_t cnt = 5000U;
   for (size_t i = 0; i < cnt; i++) {
-    NumericalVector<float> vec(dimension);
-    for (size_t j = 0; j < dimension; ++j) {
-      vec[j] = dist(gen);
+    float add_on = i * 10;
+
+    const void *vector = streamer->get_vector(i);
+    ASSERT_NE(vector, nullptr);
+
+    std::string denormalized_vec;
+    denormalized_vec.resize(dim * sizeof(float));
+    quantizer->dequantize(vector, new_meta, &denormalized_vec);
+
+    float vector_value = *((float *)(denormalized_vec.data()) + dim - 1);
+    EXPECT_NEAR(vector_value, fixed_value + add_on, epsilon);
+  }
+
+  auto linearCtx = streamer->create_context();
+  linearCtx->set_fetch_vector(true);
+  auto knnCtx = streamer->create_context();
+  knnCtx->set_fetch_vector(true);
+
+  size_t query_cnt = 200U;
+  size_t topk = 200;
+  linearCtx->set_topk(topk);
+  knnCtx->set_topk(topk);
+  uint64_t knnTotalTime = 0;
+  uint64_t linearTotalTime = 0;
+  for (size_t i = 0; i < query_cnt; i++) {
+    float add_on = i * 10;
+    for (size_t j = 0; j < dim; ++j) {
+      if (j < dim / 4)
+        vec[j] = fixed_value;
+      else
+        vec[j] = fixed_value + add_on;
     }
 
-    std::string binary_vec;
-    IndexQueryMeta binary_qmeta;
+    std::string new_query;
+    IndexQueryMeta new_meta;
+    ASSERT_EQ(0, quantizer->quantize(vec.data(), qmeta, &new_query, &new_meta));
 
+    auto t1 = ailego::Realtime::MicroSeconds();
+    ASSERT_EQ(0, streamer->search_impl(new_query.data(), new_meta, knnCtx));
+    auto t2 = ailego::Realtime::MicroSeconds();
     ASSERT_EQ(0,
-              reformer->convert(vec.data(), qmeta, &binary_vec, &binary_qmeta));
-    ASSERT_EQ(0, refiner->add_impl(i, binary_vec.data(), binary_qmeta,
-                                   vec.data(), qmeta, ctx));
+              streamer->search_bf_impl(new_query.data(), new_meta, linearCtx));
+    auto t3 = ailego::Realtime::MicroSeconds();
 
-    vecs.push_back(vec);
+    knnTotalTime += t2 - t1;
+    linearTotalTime += t3 - t2;
+
+    auto &knnResult = knnCtx->result();
+    ASSERT_EQ(topk, knnResult.size());
+
+    auto &linearResult = linearCtx->result();
+    ASSERT_EQ(topk, linearResult.size());
+    ASSERT_EQ(i, linearResult[0].key());
+
+    ASSERT_NE(knnResult[0].vector(), nullptr);
+    ASSERT_NE(linearResult[0].vector(), nullptr);
+
+    std::string denormalized_vec;
+    denormalized_vec.resize(dim * sizeof(float));
+    quantizer->dequantize(linearResult[0].vector(), new_meta,
+                          &denormalized_vec);
+
+    float vector_value = *(((float *)(denormalized_vec.data()) + dim - 1));
+    EXPECT_NEAR(vector_value, fixed_value + add_on, epsilon);
   }
 
-  size_t query_cnt = 200U;
-  // size_t query_cnt = 1U;
+  std::cout << "knnTotalTime: " << knnTotalTime << std::endl;
+  std::cout << "linearTotalTime: " << linearTotalTime << std::endl;
+}
 
-  auto searcherCtx = refiner->create_context();
 
-  for (size_t i = 0; i < query_cnt; i++) {
-    auto &vec = vecs[i];
+TEST_F(HnswStreamerTest, TestTurboSquaredEuclideanInt8Quantizer) {
+  IndexStreamer::Pointer streamer =
+      IndexFactory::CreateStreamer("HnswStreamer");
+  ASSERT_TRUE(streamer != nullptr);
+
+  ailego::Params params;
+  params.set(PARAM_HNSW_STREAMER_MAX_NEIGHBOR_COUNT, 50);
+  params.set(PARAM_HNSW_STREAMER_SCALING_FACTOR, 16);
+  params.set(PARAM_HNSW_STREAMER_EFCONSTRUCTION, 200);
+  params.set(PARAM_HNSW_STREAMER_EF, 200);
+  params.set(PARAM_HNSW_STREAMER_BRUTE_FORCE_THRESHOLD, 1000U);
+  params.set(PARAM_HNSW_STREAMER_GET_VECTOR_ENABLE, true);
 
-    // float abs_value{0};
-    // for (size_t j = 0; j < dimension; ++j) {
-    //   std::cout << "dim: " << j << ", value: " << vec[j] << std::endl;
+  ailego::Params stg_params;
 
-    //   abs_value += std::abs(vec[j]);
-    // }
-    // std::cout << "abs value: " << abs_value << std::endl;
+  IndexMeta index_meta_raw(IndexMeta::DataType::DT_FP32, dim);
+  index_meta_raw.set_metric("SquaredEuclidean", 0, ailego::Params());
+
+  ailego::Params converter_params;
+  auto quantizer = IndexFactory::CreateQuantizer("Int8Quantizer");
+  ASSERT_TRUE(quantizer != nullptr);
+
+  quantizer->init(index_meta_raw, converter_params);
+
+  IndexMeta index_meta = quantizer->meta();
+
+  auto storage = IndexFactory::CreateStorage("MMapFileStorage");
+  ASSERT_EQ(0, storage->init(stg_params));
+  ASSERT_EQ(0,
+            storage->open(dir_ + "TestTurboCosineInt8Quantizer.index", true));
+  ASSERT_EQ(0, streamer->init(index_meta, params));
+  ASSERT_EQ(0, streamer->open(storage));
+
+  NumericalVector<float> vec(dim);
+  size_t cnt = 2000U;
+  auto ctx = streamer->create_context();
+  ASSERT_TRUE(!!ctx);
+
+  IndexQueryMeta qmeta(IndexMeta::DataType::DT_FP32, dim);
+  IndexQueryMeta new_meta;
+
+  const float epsilon = 1e-2;
+  float fixed_value = float(cnt) / 2;
+  for (size_t i = 0; i < cnt; i++) {
+    float add_on = i * 10;
+    for (size_t j = 0; j < dim; ++j) {
+      if (j < dim / 4)
+        vec[j] = fixed_value;
+      else
+        vec[j] = fixed_value + add_on;
+    }
+
+    std::string new_vec;
+
+    ASSERT_EQ(0, quantizer->quantize(vec.data(), qmeta, &new_vec, &new_meta));
+    ASSERT_EQ(0, streamer->add_impl(i, new_vec.data(), new_meta, ctx));
+  }
+
+  for (size_t i = 0; i < cnt; i++) {
+    float add_on = i * 10;
+
+    const void *vector = streamer->get_vector(i);
+    ASSERT_NE(vector, nullptr);
+
+    std::string denormalized_vec;
+    denormalized_vec.resize(dim * sizeof(float));
+    quantizer->dequantize(vector, new_meta, &denormalized_vec);
+
+    float vector_value = *((float *)(denormalized_vec.data()) + dim - 1);
+    EXPECT_NEAR(vector_value, fixed_value + add_on, epsilon);
+  }
+
+  auto linearCtx = streamer->create_context();
+  linearCtx->set_fetch_vector(true);
+  auto knnCtx = streamer->create_context();
+  knnCtx->set_fetch_vector(true);
+
+  size_t query_cnt = 200U;
+  size_t topk = 200;
+  linearCtx->set_topk(topk);
+  knnCtx->set_topk(topk);
+  uint64_t knnTotalTime = 0;
+  uint64_t linearTotalTime = 0;
+  for (size_t i = 0; i < query_cnt; i++) {
+    float add_on = i * 10;
+    for (size_t j = 0; j < dim; ++j) {
+      if (j < dim / 4)
+        vec[j] = fixed_value;
+      else
+        vec[j] = fixed_value + add_on;
+    }
 
     std::string new_query;
-    IndexQueryMeta binary_qmeta;
-    ASSERT_EQ(
-        0, reformer->transform(vec.data(), qmeta, &new_query, &binary_qmeta));
-
-    size_t topk = 50;
-    searcherCtx->set_topk(topk);
-    ASSERT_EQ(0, refiner->search_impl(new_query.data(), binary_qmeta,
-                                      vec.data(), qmeta, searcherCtx));
-    auto &results = searcherCtx->result();
-    ASSERT_EQ(topk, results.size());
-    ASSERT_EQ(i, results[0].key());
-
-    // for (size_t i = 0; i < results.size(); ++i) {
-    //   std::cout << i << ", id: " << results[i].index()
-    //             << ", score: " << results[i].score() << std::endl;
-    // }
+    IndexQueryMeta new_meta;
+    ASSERT_EQ(0, quantizer->quantize(vec.data(), qmeta, &new_query, &new_meta));
+
+    auto t1 = ailego::Realtime::MicroSeconds();
+    ASSERT_EQ(0, streamer->search_impl(new_query.data(), new_meta, knnCtx));
+    auto t2 = ailego::Realtime::MicroSeconds();
+    ASSERT_EQ(0,
+              streamer->search_bf_impl(new_query.data(), new_meta, linearCtx));
+    auto t3 = ailego::Realtime::MicroSeconds();
+
+    knnTotalTime += t2 - t1;
+    linearTotalTime += t3 - t2;
+
+    auto &knnResult = knnCtx->result();
+    ASSERT_EQ(topk, knnResult.size());
+
+    auto &linearResult = linearCtx->result();
+    ASSERT_EQ(topk, linearResult.size());
+    ASSERT_EQ(i, linearResult[0].key());
+
+    ASSERT_NE(knnResult[0].vector(), nullptr);
+    ASSERT_NE(linearResult[0].vector(), nullptr);
+
+    std::string denormalized_vec;
+    denormalized_vec.resize(dim * sizeof(float));
+    quantizer->dequantize(linearResult[0].vector(), new_meta,
+                          &denormalized_vec);
+
+    float vector_value = *(((float *)(denormalized_vec.data()) + dim - 1));
+    EXPECT_NEAR(vector_value, fixed_value + add_on, epsilon);
   }
+
+  std::cout << "knnTotalTime: " << knnTotalTime << std::endl;
+  std::cout << "linearTotalTime: " << linearTotalTime << std::endl;
 }
 
-#endif
 
 TEST_F(HnswStreamerTest, TestContiguousMemorySearch) {
   // Build index with mmap mode
diff --git a/tests/core/interface/index_interface_test.cc b/tests/core/interface/index_interface_test.cc
index 0f590ea5d..8a055a0ab 100644
--- a/tests/core/interface/index_interface_test.cc
+++ b/tests/core/interface/index_interface_test.cc
@@ -43,7 +43,7 @@ TEST(IndexInterface, General) {
   auto func = [&](const BaseIndexParam::Pointer &param,
                   const BaseIndexQueryParam::Pointer &query_param) {
     zvec::test_util::RemoveTestFiles(index_name);
-    auto index = IndexFactory::CreateAndInitIndex(*param);
+    auto index = zvec::core_interface::IndexFactory::CreateAndInitIndex(*param);
     ASSERT_NE(nullptr, index);
 
 
@@ -196,7 +196,8 @@ TEST(IndexInterface, BufferGeneral) {
                   const BaseIndexQueryParam::Pointer &query_param) {
     std::string real_index_name = index_name;
     zvec::test_util::RemoveTestFiles(index_name + "*");
-    auto write_index = IndexFactory::CreateAndInitIndex(*param);
+    auto write_index =
+        zvec::core_interface::IndexFactory::CreateAndInitIndex(*param);
     ASSERT_NE(nullptr, write_index);
 
     write_index->Open(real_index_name,
@@ -210,7 +211,8 @@ TEST(IndexInterface, BufferGeneral) {
     ASSERT_TRUE(0 == write_index->Add(vector_data, 233));
     write_index->Close();
 
-    auto read_index = IndexFactory::CreateAndInitIndex(*param);
+    auto read_index =
+        zvec::core_interface::IndexFactory::CreateAndInitIndex(*param);
     ASSERT_NE(nullptr, read_index);
     read_index->Open(real_index_name,
                      {StorageOptions::StorageType::kBufferPool, false});
@@ -306,7 +308,7 @@ TEST(IndexInterface, SparseGeneral) {
   auto func = [&](const BaseIndexParam::Pointer &param,
                   const BaseIndexQueryParam::Pointer &query_param) {
     zvec::test_util::RemoveTestFiles(index_name);
-    auto index = IndexFactory::CreateAndInitIndex(*param);
+    auto index = zvec::core_interface::IndexFactory::CreateAndInitIndex(*param);
     ASSERT_NE(nullptr, index);
 
 
@@ -427,7 +429,7 @@ TEST(IndexInterface, Merge) {
       [&](const BaseIndexParam::Pointer &param,
           const std::string &index_name) -> Index::Pointer {
     del_index_file_func(index_name);
-    auto index = IndexFactory::CreateAndInitIndex(*param);
+    auto index = zvec::core_interface::IndexFactory::CreateAndInitIndex(*param);
     if (index == nullptr ||
         0 != index->Open(index_name,
                          {StorageOptions::StorageType::kMMAP, true})) {
@@ -592,7 +594,8 @@ TEST(IndexInterface, Serialize) {
     std::cout << "omit=false: " << param->SerializeToJson() << std::endl;
 
     auto deserialized_param =
-        IndexFactory::DeserializeIndexParamFromJson(param->SerializeToJson());
+        zvec::core_interface::IndexFactory::DeserializeIndexParamFromJson(
+            param->SerializeToJson());
     ASSERT_NE(nullptr, deserialized_param.get());
 
 
@@ -621,7 +624,8 @@ TEST(IndexInterface, Serialize) {
               << std::endl;
 
     auto deserialized_param =
-        IndexFactory::DeserializeIndexParamFromJson(param->SerializeToJson());
+        zvec::core_interface::IndexFactory::DeserializeIndexParamFromJson(
+            param->SerializeToJson());
     ASSERT_NE(nullptr, deserialized_param.get());
 
     std::cout << "serialize then de then se:"
@@ -639,22 +643,30 @@ TEST(IndexInterface, Serialize) {
     auto param =
         FlatQueryParamBuilder().with_topk(10).with_fetch_vector(true).build();
     std::cout << "flat query -- omit=true: "
-              << IndexFactory::QueryParamSerializeToJson(*param, true)
+              << zvec::core_interface::IndexFactory::QueryParamSerializeToJson(
+                     *param, true)
               << std::endl;
     std::cout << "flat query -- omit=false: "
-              << IndexFactory::QueryParamSerializeToJson(*param) << std::endl;
+              << zvec::core_interface::IndexFactory::QueryParamSerializeToJson(
+                     *param)
+              << std::endl;
 
     auto deserialized_param =
-        IndexFactory::QueryParamDeserializeFromJson<FlatQueryParam>(
-            IndexFactory::QueryParamSerializeToJson(*param));
+        zvec::core_interface::IndexFactory::QueryParamDeserializeFromJson<
+            FlatQueryParam>(
+            zvec::core_interface::IndexFactory::QueryParamSerializeToJson(
+                *param));
     ASSERT_NE(nullptr, deserialized_param.get());
 
     std::cout << "serialize then de then se:"
-              << IndexFactory::QueryParamSerializeToJson(*deserialized_param)
+              << zvec::core_interface::IndexFactory::QueryParamSerializeToJson(
+                     *deserialized_param)
               << std::endl;
 
-    ASSERT_TRUE(IndexFactory::QueryParamSerializeToJson(*deserialized_param) ==
-                IndexFactory::QueryParamSerializeToJson(*param));
+    ASSERT_TRUE(
+        zvec::core_interface::IndexFactory::QueryParamSerializeToJson(
+            *deserialized_param) ==
+        zvec::core_interface::IndexFactory::QueryParamSerializeToJson(*param));
   }
 
   {
@@ -665,23 +677,30 @@ TEST(IndexInterface, Serialize) {
                      .with_ef_search(20)
                      .build();
     std::cout << "hnsw query -- omit=true: "
-              << IndexFactory::QueryParamSerializeToJson(*param, true)
+              << zvec::core_interface::IndexFactory::QueryParamSerializeToJson(
+                     *param, true)
               << std::endl;
     std::cout << "hnsw query -- omit=false: "
-              << IndexFactory::QueryParamSerializeToJson(*param, false)
+              << zvec::core_interface::IndexFactory::QueryParamSerializeToJson(
+                     *param, false)
               << std::endl;
 
     auto deserialized_param =
-        IndexFactory::QueryParamDeserializeFromJson<HNSWQueryParam>(
-            IndexFactory::QueryParamSerializeToJson(*param));
+        zvec::core_interface::IndexFactory::QueryParamDeserializeFromJson<
+            HNSWQueryParam>(
+            zvec::core_interface::IndexFactory::QueryParamSerializeToJson(
+                *param));
     ASSERT_NE(nullptr, deserialized_param.get());
 
     std::cout << "serialize then de then se:"
-              << IndexFactory::QueryParamSerializeToJson(*deserialized_param)
+              << zvec::core_interface::IndexFactory::QueryParamSerializeToJson(
+                     *deserialized_param)
               << std::endl;
 
-    ASSERT_TRUE(IndexFactory::QueryParamSerializeToJson(*deserialized_param) ==
-                IndexFactory::QueryParamSerializeToJson(*param));
+    ASSERT_TRUE(
+        zvec::core_interface::IndexFactory::QueryParamSerializeToJson(
+            *deserialized_param) ==
+        zvec::core_interface::IndexFactory::QueryParamSerializeToJson(*param));
   }
 
   {
@@ -702,7 +721,8 @@ TEST(IndexInterface, Serialize) {
               << std::endl;
 
     auto deserialized_param =
-        IndexFactory::DeserializeIndexParamFromJson(param->SerializeToJson());
+        zvec::core_interface::IndexFactory::DeserializeIndexParamFromJson(
+            param->SerializeToJson());
     ASSERT_NE(nullptr, deserialized_param.get());
 
     std::cout << "serialize then de then se:"
@@ -728,7 +748,8 @@ TEST(IndexInterface, Serialize) {
     ASSERT_TRUE(json_str.find("use_contiguous_memory") != std::string::npos);
 
     auto deserialized_param =
-        IndexFactory::DeserializeIndexParamFromJson(json_str);
+        zvec::core_interface::IndexFactory::DeserializeIndexParamFromJson(
+            json_str);
     ASSERT_NE(nullptr, deserialized_param.get());
     auto hnsw_param =
         std::dynamic_pointer_cast<HNSWIndexParam>(deserialized_param);
@@ -755,7 +776,8 @@ TEST(IndexInterface, Serialize) {
     ASSERT_TRUE(json_str.find("use_contiguous_memory") != std::string::npos);
 
     auto deserialized_param =
-        IndexFactory::DeserializeIndexParamFromJson(json_str);
+        zvec::core_interface::IndexFactory::DeserializeIndexParamFromJson(
+            json_str);
     ASSERT_NE(nullptr, deserialized_param.get());
     auto vamana_param =
         std::dynamic_pointer_cast<VamanaIndexParam>(deserialized_param);
@@ -776,22 +798,30 @@ TEST(IndexInterface, Serialize) {
                      .with_ef_search(50)
                      .build();
     std::cout << "vamana query -- omit=true: "
-              << IndexFactory::QueryParamSerializeToJson(*param, true)
+              << zvec::core_interface::IndexFactory::QueryParamSerializeToJson(
+                     *param, true)
               << std::endl;
     std::cout << "vamana query -- omit=false: "
-              << IndexFactory::QueryParamSerializeToJson(*param) << std::endl;
+              << zvec::core_interface::IndexFactory::QueryParamSerializeToJson(
+                     *param)
+              << std::endl;
 
     auto deserialized_param =
-        IndexFactory::QueryParamDeserializeFromJson<VamanaQueryParam>(
-            IndexFactory::QueryParamSerializeToJson(*param));
+        zvec::core_interface::IndexFactory::QueryParamDeserializeFromJson<
+            VamanaQueryParam>(
+            zvec::core_interface::IndexFactory::QueryParamSerializeToJson(
+                *param));
     ASSERT_NE(nullptr, deserialized_param.get());
 
     std::cout << "serialize then de then se:"
-              << IndexFactory::QueryParamSerializeToJson(*deserialized_param)
+              << zvec::core_interface::IndexFactory::QueryParamSerializeToJson(
+                     *deserialized_param)
               << std::endl;
 
-    ASSERT_TRUE(IndexFactory::QueryParamSerializeToJson(*deserialized_param) ==
-                IndexFactory::QueryParamSerializeToJson(*param));
+    ASSERT_TRUE(
+        zvec::core_interface::IndexFactory::QueryParamSerializeToJson(
+            *deserialized_param) ==
+        zvec::core_interface::IndexFactory::QueryParamSerializeToJson(*param));
   }
 }
 
@@ -799,7 +829,7 @@ TEST(IndexInterface, Failure) {
   // Test unsupported index type
   {
     auto param = std::make_shared<BaseIndexParam>(IndexType::kIVF);
-    auto index = IndexFactory::CreateAndInitIndex(*param);
+    auto index = zvec::core_interface::IndexFactory::CreateAndInitIndex(*param);
     ASSERT_EQ(nullptr, index);
   }
 
@@ -810,7 +840,7 @@ TEST(IndexInterface, Failure) {
             .WithMetricType(MetricType::kNone)  // L2 not supported for sparse
             .WithDataType(DataType::DT_FP32)
             .Build();
-    auto index = IndexFactory::CreateAndInitIndex(*param);
+    auto index = zvec::core_interface::IndexFactory::CreateAndInitIndex(*param);
     ASSERT_EQ(nullptr, index);
   }
 
@@ -822,7 +852,7 @@ TEST(IndexInterface, Failure) {
             .WithDataType(DataType::DT_FP32)
             .WithIsSparse(true)
             .Build();
-    auto index = IndexFactory::CreateAndInitIndex(*param);
+    auto index = zvec::core_interface::IndexFactory::CreateAndInitIndex(*param);
     ASSERT_EQ(nullptr, index);
   }
 
@@ -849,7 +879,7 @@ TEST(IndexInterface, Failure) {
                      .WithQuantizerParam(
                          QuantizerParam(QuantizerType::kInt8))  // Unsupported
                      .Build();
-    auto index = IndexFactory::CreateAndInitIndex(*param);
+    auto index = zvec::core_interface::IndexFactory::CreateAndInitIndex(*param);
     ASSERT_EQ(nullptr, index);
   }
 
@@ -861,7 +891,7 @@ TEST(IndexInterface, Failure) {
                      .WithDimension(64)
                      .WithIsSparse(false)
                      .Build();
-    auto index = IndexFactory::CreateAndInitIndex(*param);
+    auto index = zvec::core_interface::IndexFactory::CreateAndInitIndex(*param);
     ASSERT_EQ(nullptr, index);
   }
 
@@ -873,7 +903,7 @@ TEST(IndexInterface, Failure) {
                      .WithDimension(64)
                      .WithIsSparse(false)
                      .Build();
-    auto index = IndexFactory::CreateAndInitIndex(*param);
+    auto index = zvec::core_interface::IndexFactory::CreateAndInitIndex(*param);
     ASSERT_NE(nullptr, index);
 
     StorageOptions invalid_storage;
@@ -890,7 +920,7 @@ TEST(IndexInterface, Failure) {
                      .WithDimension(64)
                      .WithIsSparse(false)
                      .Build();
-    auto index = IndexFactory::CreateAndInitIndex(*param);
+    auto index = zvec::core_interface::IndexFactory::CreateAndInitIndex(*param);
     ASSERT_NE(nullptr, index);
 
     index->Open("test.index", {StorageOptions::StorageType::kMMAP, true});
@@ -915,7 +945,7 @@ TEST(IndexInterface, Failure) {
                      .WithDataType(DataType::DT_FP32)
                      .WithIsSparse(true)
                      .Build();
-    auto index = IndexFactory::CreateAndInitIndex(*param);
+    auto index = zvec::core_interface::IndexFactory::CreateAndInitIndex(*param);
     ASSERT_NE(nullptr, index);
 
     index->Open("test.index", {StorageOptions::StorageType::kMMAP, true});
@@ -939,7 +969,7 @@ TEST(IndexInterface, Failure) {
                      .WithDimension(64)
                      .WithIsSparse(false)
                      .Build();
-    auto index = IndexFactory::CreateAndInitIndex(*param);
+    auto index = zvec::core_interface::IndexFactory::CreateAndInitIndex(*param);
     ASSERT_NE(nullptr, index);
 
     index->Open("test.index", {StorageOptions::StorageType::kMMAP, true});
@@ -960,7 +990,7 @@ TEST(IndexInterface, Failure) {
                      .WithDimension(64)
                      .WithIsSparse(false)
                      .Build();
-    auto index = IndexFactory::CreateAndInitIndex(*param);
+    auto index = zvec::core_interface::IndexFactory::CreateAndInitIndex(*param);
     ASSERT_NE(nullptr, index);
 
     index->Open("test.index", {StorageOptions::StorageType::kMMAP, true});
@@ -993,7 +1023,8 @@ TEST(IndexInterface, Failure) {
                       .WithDimension(64)
                       .WithIsSparse(false)
                       .Build();
-    auto index1 = IndexFactory::CreateAndInitIndex(*param1);
+    auto index1 =
+        zvec::core_interface::IndexFactory::CreateAndInitIndex(*param1);
     ASSERT_NE(nullptr, index1);
     index1->Open("test1.index", {StorageOptions::StorageType::kMMAP, true});
 
@@ -1003,7 +1034,8 @@ TEST(IndexInterface, Failure) {
                       .WithDimension(64)
                       .WithIsSparse(false)
                       .Build();
-    auto index2 = IndexFactory::CreateAndInitIndex(*param2);
+    auto index2 =
+        zvec::core_interface::IndexFactory::CreateAndInitIndex(*param2);
     ASSERT_NE(nullptr, index2);
     index2->Open("test2.index", {StorageOptions::StorageType::kMMAP, true});
 
@@ -1013,7 +1045,8 @@ TEST(IndexInterface, Failure) {
                       .WithDimension(64)
                       .WithIsSparse(false)
                       .Build();
-    auto index3 = IndexFactory::CreateAndInitIndex(*param3);
+    auto index3 =
+        zvec::core_interface::IndexFactory::CreateAndInitIndex(*param3);
     ASSERT_NE(nullptr, index3);
     index3->Open("test3.index", {StorageOptions::StorageType::kMMAP, true});
 
@@ -1042,7 +1075,7 @@ TEST(IndexInterface, Failure) {
                      .WithSearchListSize(100)
                      .WithAlpha(1.2f)
                      .Build();
-    auto index = IndexFactory::CreateAndInitIndex(*param);
+    auto index = zvec::core_interface::IndexFactory::CreateAndInitIndex(*param);
     ASSERT_NE(nullptr, index);
 
     index->Open("test.index", {StorageOptions::StorageType::kMMAP, true});
@@ -1076,7 +1109,7 @@ TEST(IndexInterface, Failure) {
                      .WithSearchListSize(100)
                      .WithAlpha(1.2f)
                      .Build();
-    auto index = IndexFactory::CreateAndInitIndex(*param);
+    auto index = zvec::core_interface::IndexFactory::CreateAndInitIndex(*param);
     ASSERT_NE(nullptr, index);
 
     index->Open("test.index", {StorageOptions::StorageType::kMMAP, true});
@@ -1111,7 +1144,7 @@ TEST(IndexInterface, Failure) {
                      .WithSearchListSize(100)
                      .WithAlpha(1.2f)
                      .Build();
-    auto index = IndexFactory::CreateAndInitIndex(*param);
+    auto index = zvec::core_interface::IndexFactory::CreateAndInitIndex(*param);
     ASSERT_NE(nullptr, index);
 
     index->Open("test.index", {StorageOptions::StorageType::kMMAP, true});
@@ -1140,7 +1173,9 @@ TEST(IndexInterface, SerializeFailure) {
   // Test invalid JSON deserialization
   {
     std::string invalid_json = "invalid json string";
-    auto param = IndexFactory::DeserializeIndexParamFromJson(invalid_json);
+    auto param =
+        zvec::core_interface::IndexFactory::DeserializeIndexParamFromJson(
+            invalid_json);
     ASSERT_EQ(nullptr, param);
   }
 
@@ -1153,7 +1188,9 @@ TEST(IndexInterface, SerializeFailure) {
       "is_sparse": false,
       "data_type": "DT_FP32"
     })";
-    auto param = IndexFactory::DeserializeIndexParamFromJson(invalid_enum_json);
+    auto param =
+        zvec::core_interface::IndexFactory::DeserializeIndexParamFromJson(
+            invalid_enum_json);
     ASSERT_EQ(nullptr, param);
   }
 
@@ -1166,7 +1203,9 @@ TEST(IndexInterface, SerializeFailure) {
       "is_sparse": false,
       "data_type": "DT_FP32"
     })";
-    auto param = IndexFactory::DeserializeIndexParamFromJson(invalid_type_json);
+    auto param =
+        zvec::core_interface::IndexFactory::DeserializeIndexParamFromJson(
+            invalid_type_json);
     ASSERT_EQ(nullptr, param);
   }
 
@@ -1179,7 +1218,9 @@ TEST(IndexInterface, SerializeFailure) {
       "is_sparse": "false",
       "data_type": "DT_FP32"
     })";
-    auto param = IndexFactory::DeserializeIndexParamFromJson(invalid_type_json);
+    auto param =
+        zvec::core_interface::IndexFactory::DeserializeIndexParamFromJson(
+            invalid_type_json);
     ASSERT_EQ(nullptr, param);
   }
 
@@ -1192,15 +1233,18 @@ TEST(IndexInterface, SerializeFailure) {
       "is_sparse": false,
       "data_type": "DT_FP32"
     })";
-    auto param = IndexFactory::DeserializeIndexParamFromJson(wrong_type_json);
+    auto param =
+        zvec::core_interface::IndexFactory::DeserializeIndexParamFromJson(
+            wrong_type_json);
     ASSERT_EQ(nullptr, param);
   }
 
   // Test QueryParam deserialization with invalid JSON
   {
     std::string invalid_json = "invalid json";
-    auto param = IndexFactory::QueryParamDeserializeFromJson<FlatQueryParam>(
-        invalid_json);
+    auto param =
+        zvec::core_interface::IndexFactory::QueryParamDeserializeFromJson<
+            FlatQueryParam>(invalid_json);
     ASSERT_EQ(nullptr, param);
   }
 
@@ -1213,8 +1257,9 @@ TEST(IndexInterface, SerializeFailure) {
       "radius": 0.0,
       "is_linear": false
     })";
-    auto param = IndexFactory::QueryParamDeserializeFromJson<FlatQueryParam>(
-        invalid_enum_json);
+    auto param =
+        zvec::core_interface::IndexFactory::QueryParamDeserializeFromJson<
+            FlatQueryParam>(invalid_enum_json);
     ASSERT_EQ(nullptr, param);
   }
 
@@ -1227,8 +1272,9 @@ TEST(IndexInterface, SerializeFailure) {
       "radius": 0.0,
       "is_linear": false
     })";
-    auto param = IndexFactory::QueryParamDeserializeFromJson<FlatQueryParam>(
-        invalid_type_json);
+    auto param =
+        zvec::core_interface::IndexFactory::QueryParamDeserializeFromJson<
+            FlatQueryParam>(invalid_type_json);
     ASSERT_EQ(nullptr, param);
   }
 
@@ -1242,8 +1288,9 @@ TEST(IndexInterface, SerializeFailure) {
       "is_linear": false,
       "ef_search": "not_a_number"
     })";
-    auto param = IndexFactory::QueryParamDeserializeFromJson<HNSWQueryParam>(
-        invalid_type_json);
+    auto param =
+        zvec::core_interface::IndexFactory::QueryParamDeserializeFromJson<
+            HNSWQueryParam>(invalid_type_json);
     ASSERT_EQ(nullptr, param);
   }
 }
@@ -1334,7 +1381,7 @@ TEST(IndexInterface, Score) {
                         const BaseIndexQueryParam::Pointer query_param,
                         MetricType metric_type) {
     zvec::test_util::RemoveTestFiles(index_file_path);
-    auto index = IndexFactory::CreateAndInitIndex(*param);
+    auto index = zvec::core_interface::IndexFactory::CreateAndInitIndex(*param);
     ASSERT_NE(nullptr, index);
 
     index->Open(index_file_path, {StorageOptions::StorageType::kMMAP, true});
@@ -1362,7 +1409,7 @@ TEST(IndexInterface, Score) {
                          const BaseIndexQueryParam::Pointer query_param,
                          MetricType metric_type) {
     zvec::test_util::RemoveTestFiles(index_file_path);
-    auto index = IndexFactory::CreateAndInitIndex(*param);
+    auto index = zvec::core_interface::IndexFactory::CreateAndInitIndex(*param);
     ASSERT_NE(nullptr, index);
 
     index->Open(index_file_path, {StorageOptions::StorageType::kMMAP, true});
@@ -1617,7 +1664,7 @@ TEST(IndexInterface, HNSWRabitqGeneral) {
   auto func = [&](const BaseIndexParam::Pointer &param,
                   const BaseIndexQueryParam::Pointer &query_param) {
     zvec::test_util::RemoveTestFiles(cleanup_pattern);
-    auto index = IndexFactory::CreateAndInitIndex(*param);
+    auto index = zvec::core_interface::IndexFactory::CreateAndInitIndex(*param);
     ASSERT_NE(nullptr, index);
 
     index->Open(index_name, {StorageOptions::StorageType::kMMAP, true});
@@ -1731,53 +1778,57 @@ TEST(IndexInterface, ContiguousMemoryEndToEnd) {
   // build_then_search builds an index from scratch (with use_contiguous_memory
   // possibly enabled), closes it, then reopens with the same params and runs a
   // search for each inserted vector, asserting top-1 is itself.
-  auto build_then_search = [&](const BaseIndexParam::Pointer &param,
-                               const BaseIndexQueryParam::Pointer &query_param) {
-    zvec::test_util::RemoveTestFiles(index_name);
-
-    // Phase 1: build & persist.
-    {
-      auto index = IndexFactory::CreateAndInitIndex(*param);
-      ASSERT_NE(nullptr, index);
-      ASSERT_EQ(0, index->Open(index_name,
-                               {StorageOptions::StorageType::kMMAP, true}));
-
-      std::vector<float> vec(kDimension);
-      for (uint32_t i = 0; i < kNumDocs; ++i) {
-        for (uint32_t d = 0; d < kDimension; ++d) {
-          vec[d] = static_cast<float>(i);
+  auto build_then_search =
+      [&](const BaseIndexParam::Pointer &param,
+          const BaseIndexQueryParam::Pointer &query_param) {
+        zvec::test_util::RemoveTestFiles(index_name);
+
+        // Phase 1: build & persist.
+        {
+          auto index =
+              zvec::core_interface::IndexFactory::CreateAndInitIndex(*param);
+          ASSERT_NE(nullptr, index);
+          ASSERT_EQ(0, index->Open(index_name,
+                                   {StorageOptions::StorageType::kMMAP, true}));
+
+          std::vector<float> vec(kDimension);
+          for (uint32_t i = 0; i < kNumDocs; ++i) {
+            for (uint32_t d = 0; d < kDimension; ++d) {
+              vec[d] = static_cast<float>(i);
+            }
+            VectorData data{DenseVector{vec.data()}};
+            ASSERT_EQ(0, index->Add(data, i));
+          }
+          ASSERT_EQ(0, index->Train());
+          ASSERT_EQ(0, index->Close());
         }
-        VectorData data{DenseVector{vec.data()}};
-        ASSERT_EQ(0, index->Add(data, i));
-      }
-      ASSERT_EQ(0, index->Train());
-      ASSERT_EQ(0, index->Close());
-    }
 
-    // Phase 2: reopen with same params (contiguous memory takes effect here)
-    // and search.
-    {
-      auto index = IndexFactory::CreateAndInitIndex(*param);
-      ASSERT_NE(nullptr, index);
-      ASSERT_EQ(0, index->Open(index_name,
-                               {StorageOptions::StorageType::kMMAP, false}));
-
-      std::vector<float> q(kDimension);
-      for (uint32_t i = 0; i < kNumDocs; i += 50) {
-        for (uint32_t d = 0; d < kDimension; ++d) {
-          q[d] = static_cast<float>(i);
+        // Phase 2: reopen with same params (contiguous memory takes effect
+        // here) and search.
+        {
+          auto index =
+              zvec::core_interface::IndexFactory::CreateAndInitIndex(*param);
+          ASSERT_NE(nullptr, index);
+          ASSERT_EQ(0,
+                    index->Open(index_name,
+                                {StorageOptions::StorageType::kMMAP, false}));
+
+          std::vector<float> q(kDimension);
+          for (uint32_t i = 0; i < kNumDocs; i += 50) {
+            for (uint32_t d = 0; d < kDimension; ++d) {
+              q[d] = static_cast<float>(i);
+            }
+            VectorData query{DenseVector{q.data()}};
+            SearchResult result;
+            ASSERT_EQ(0, index->Search(query, query_param, &result));
+            ASSERT_GT(result.doc_list_.size(), 0UL);
+            ASSERT_EQ(i, result.doc_list_[0].key());
+          }
+          ASSERT_EQ(0, index->Close());
         }
-        VectorData query{DenseVector{q.data()}};
-        SearchResult result;
-        ASSERT_EQ(0, index->Search(query, query_param, &result));
-        ASSERT_GT(result.doc_list_.size(), 0UL);
-        ASSERT_EQ(i, result.doc_list_[0].key());
-      }
-      ASSERT_EQ(0, index->Close());
-    }
 
-    zvec::test_util::RemoveTestFiles(index_name);
-  };
+        zvec::test_util::RemoveTestFiles(index_name);
+      };
 
   // HNSW + use_contiguous_memory=true
   build_then_search(HNSWIndexParamBuilder()
diff --git a/tests/core/metric/quantized_integer_metric_test.cc b/tests/core/metric/quantized_integer_metric_test.cc
index 835a07fb7..f56d6ef67 100644
--- a/tests/core/metric/quantized_integer_metric_test.cc
+++ b/tests/core/metric/quantized_integer_metric_test.cc
@@ -32,8 +32,7 @@ using namespace zvec::ailego;
 
 static IndexHolder::Pointer GetHolder(
     size_t dim, size_t count, std::uniform_real_distribution<float> &dist) {
-  std::random_device rd;
-  std::mt19937 gen(rd());
+  std::mt19937 gen(15583);
   auto holder = std::make_shared<MultiPassIndexHolder<IndexMeta::DT_FP32>>(dim);
   for (size_t i = 0; i < count; ++i) {
     ailego::NumericalVector<float> vec(dim);
@@ -71,8 +70,7 @@ TEST(QuantizedIntegerMetric, General) {
 
   Params params;
 
-  std::random_device rd;
-  std::mt19937 gen(rd());
+  std::mt19937 gen(15583);
   std::uniform_real_distribution<float> dist(-1.0, 1.0);
   const size_t DIMENSION = 21;
   ailego::NumericalVector<float> x(DIMENSION);
@@ -141,8 +139,7 @@ TEST(QuantizedIntegerMetric, General) {
 }
 
 TEST(QuantizedIntegerMetric, TestInt8SquaredEuclidean) {
-  std::random_device rd;
-  std::mt19937 gen(rd());
+  std::mt19937 gen(15583);
   std::uniform_real_distribution<float> dist(-1.0, 2.0);
 
   const size_t DIMENSION = std::uniform_int_distribution<int>(1, 128)(gen);
@@ -202,8 +199,7 @@ TEST(QuantizedIntegerMetric, TestInt8SquaredEuclidean) {
 }
 
 TEST(QuantizedIntegerMetric, TestInt8SquaredEuclideanReformer) {
-  std::random_device rd;
-  std::mt19937 gen(rd());
+  std::mt19937 gen(15583);
   std::uniform_real_distribution<float> dist(-1.0, 2.0);
   std::uniform_int_distribution<int> dist2(0, 1);
 
@@ -344,8 +340,7 @@ TEST(QuantizedIntegerMetric, TestInt8SquaredEuclideanMetric) {
 }
 
 TEST(QuantizedIntegerMetric, TestInt4SquaredEuclidean) {
-  std::random_device rd;
-  std::mt19937 gen(rd());
+  std::mt19937 gen(15583);
   std::uniform_real_distribution<float> dist(-1.0, 2.0);
 
   const size_t DIMENSION = std::uniform_int_distribution<int>(1, 128)(gen) * 2;
@@ -404,8 +399,7 @@ TEST(QuantizedIntegerMetric, TestInt4SquaredEuclidean) {
 }
 
 TEST(QuantizedIntegerMetric, TestInt4SquaredEuclideanReformer) {
-  std::random_device rd;
-  std::mt19937 gen(rd());
+  std::mt19937 gen(15583);
   std::uniform_real_distribution<float> dist(-1.0, 2.0);
   std::uniform_int_distribution<int> dist2(0, 1);
 
@@ -546,8 +540,7 @@ TEST(QuantizedIntegerMetric, TestInt4SquaredEuclideanMetric) {
 }
 
 TEST(QuantizedIntegerMetric, TestInt8InnerProduct) {
-  std::random_device rd;
-  std::mt19937 gen(rd());
+  std::mt19937 gen(15583);
   std::uniform_real_distribution<float> dist(-1.0, 2.0);
 
   const size_t DIMENSION = std::uniform_int_distribution<int>(1, 128)(gen);
@@ -631,8 +624,7 @@ TEST(QuantizedIntegerMetric, TestInt8InnerProductMetric) {
 }
 
 TEST(QuantizedIntegerMetric, TestInt4InnerProduct) {
-  std::random_device rd;
-  std::mt19937 gen(rd());
+  std::mt19937 gen(15583);
   std::uniform_real_distribution<float> dist(-1.0, 2.0);
 
   const size_t DIMENSION = std::uniform_int_distribution<int>(1, 128)(gen) * 2;
@@ -716,8 +708,7 @@ TEST(QuantizedIntegerMetric, TestInt4InnerProductMetric) {
 }
 
 TEST(QuantizedIntegerMetric, TestInt8MipsSquaredEuclidean) {
-  std::random_device rd;
-  std::mt19937 gen(rd());
+  std::mt19937 gen(15583);
   std::uniform_real_distribution<float> dist(-1.0, 2.0);
 
   const size_t DIMENSION = std::uniform_int_distribution<int>(1, 128)(gen);
@@ -805,8 +796,7 @@ TEST(QuantizedIntegerMetric, TestInt8MipsSquaredEuclideanMetric) {
 }
 
 TEST(QuantizedIntegerMetric, TestInt4MipsSquaredEuclidean) {
-  std::random_device rd;
-  std::mt19937 gen(rd());
+  std::mt19937 gen(15583);
   std::uniform_real_distribution<float> dist(-1.0, 2.0);
 
   const size_t DIMENSION = std::uniform_int_distribution<int>(1, 128)(gen) * 2;
@@ -890,8 +880,7 @@ TEST(QuantizedIntegerMetric, TestInt4MipsSquaredEuclideanMetric) {
 }
 
 TEST(QuantizedIntegerMetric, TestInt8NormalizedCosine) {
-  std::random_device rd;
-  std::mt19937 gen(rd());
+  std::mt19937 gen(15583);
   std::uniform_real_distribution<float> dist(-1.0, 2.0);
 
   const size_t DIMENSION = std::uniform_int_distribution<int>(1, 128)(gen);
@@ -990,8 +979,7 @@ TEST(QuantizedIntegerMetric, TestInt8NormalizedCosineMetric) {
 }
 
 TEST(QuantizedIntegerMetric, TestInt8Cosine) {
-  std::random_device rd;
-  std::mt19937 gen(rd());
+  std::mt19937 gen(15583);
   std::uniform_real_distribution<float> dist(-1.0, 2.0);
 
   const size_t DIMENSION = std::uniform_int_distribution<int>(1, 128)(gen);
@@ -1071,8 +1059,7 @@ TEST(QuantizedIntegerMetric, TestInt8Cosine) {
 }
 
 TEST(QuantizedIntegerMetric, TestInt4NormalizedCosine) {
-  std::random_device rd;
-  std::mt19937 gen(rd());
+  std::mt19937 gen(15583);
   std::uniform_real_distribution<float> dist(-1.0, 2.0);
 
   const size_t DIMENSION = std::uniform_int_distribution<int>(1, 128)(gen) * 2;
diff --git a/tests/db/collection_test.cc b/tests/db/collection_test.cc
index d50701dc3..aa798eb5a 100644
--- a/tests/db/collection_test.cc
+++ b/tests/db/collection_test.cc
@@ -780,7 +780,7 @@ TEST_F(CollectionTest, Feature_Insert_Duplicate) {
       TestHelper::CreateCollectionWithDoc(col_path, *schema, options, 0, 100);
 
   // update all docs then
-  Result<WriteResults> s;
+  zvec::Result<WriteResults> s;
   for (int i = 0; i < 100; i++) {
     Doc new_doc = TestHelper::CreateDoc(i, *schema);
     std::vector<Doc> docs = {new_doc};
@@ -1137,7 +1137,7 @@ TEST_F(CollectionTest, Feature_Update_General) {
     };
 
     // update all docs then
-    Result<WriteResults> s;
+    zvec::Result<WriteResults> s;
     for (int i = 0; i < doc_count; i++) {
       Doc new_doc =
           TestHelper::CreateDoc(i + 1, *schema, TestHelper::MakePK(i));
@@ -1244,7 +1244,7 @@ TEST_F(CollectionTest, Feature_Update_Incremental) {
     };
 
     // update all docs then
-    Result<WriteResults> s;
+    zvec::Result<WriteResults> s;
     for (int i = 0; i < doc_count; i++) {
       Doc new_doc =
           TestHelper::CreateDoc(i + 1, *schema, TestHelper::MakePK(i));
@@ -1414,7 +1414,7 @@ TEST_F(CollectionTest, Feature_Update_Empty) {
       TestHelper::CreateCollectionWithDoc(col_path, *schema, options, 0, 0);
 
   // update all docs then
-  Result<WriteResults> s;
+  zvec::Result<WriteResults> s;
   for (int i = 0; i < 100; i++) {
     Doc new_doc = TestHelper::CreateDoc(i + 1, *schema, TestHelper::MakePK(i));
     std::vector<Doc> docs = {new_doc};
@@ -1470,7 +1470,7 @@ TEST_F(CollectionTest, Feature_Delete_General) {
       }
     };
 
-    Result<WriteResults> s;
+    zvec::Result<WriteResults> s;
     for (int i = 0; i < doc_count; i++) {
       s = collection->Delete({TestHelper::MakePK(i)});
       if (!s.has_value()) {
@@ -1544,7 +1544,7 @@ TEST_F(CollectionTest, Feature_Delete_Repeated) {
 
     for (int i = 0; i < 10; i++) {
       // delete first
-      Result<WriteResults> s;
+      zvec::Result<WriteResults> s;
       for (int i = 0; i < doc_count; i++) {
         s = collection->Delete({TestHelper::MakePK(i)});
         if (!s.has_value()) {
diff --git a/tests/db/index/column/vector_column_indexer_test.cc b/tests/db/index/column/vector_column_indexer_test.cc
index b798e8de6..b57acf234 100644
--- a/tests/db/index/column/vector_column_indexer_test.cc
+++ b/tests/db/index/column/vector_column_indexer_test.cc
@@ -1574,6 +1574,7 @@ TEST(VectorColumnIndexerTest, CosineGeneral) {
   zvec::test_util::RemoveTestFiles(index_file_path);
 
   auto func = [&](const IndexParams::Ptr index_params, DataType data_type) {
+    fprintf(stderr, "\n[DBG] === New CosineGeneral case ===\n");
     zvec::test_util::RemoveTestFiles(index_file_path);
     auto indexer = std::make_shared<VectorColumnIndexer>(
         index_file_path,
@@ -1632,6 +1633,8 @@ TEST(VectorColumnIndexerTest, CosineGeneral) {
         ASSERT_TRUE(iter->valid());
         LOG_INFO("topk1 pk:%zu", (size_t)iter->doc_id());
         LOG_INFO("topk1 score:%.10f", iter->score());
+        fprintf(stderr, "[DBG] query_pk=%d topk1_pk=%zu topk1_score=%.6f\n", i,
+                (size_t)iter->doc_id(), iter->score());
 
         if (!(iter->score() > -0.01 && iter->score() < 2.01)) {
           ASSERT_TRUE(iter->score() < 2.01);
diff --git a/tests/turbo/CMakeLists.txt b/tests/turbo/CMakeLists.txt
new file mode 100644
index 000000000..518909e5d
--- /dev/null
+++ b/tests/turbo/CMakeLists.txt
@@ -0,0 +1,5 @@
+include(${PROJECT_ROOT_DIR}/cmake/bazel.cmake)
+include(${PROJECT_ROOT_DIR}/cmake/option.cmake)
+
+cc_directories(distance)
+cc_directories(quantizer)
diff --git a/tests/turbo/distance/CMakeLists.txt b/tests/turbo/distance/CMakeLists.txt
new file mode 100644
index 000000000..8d1bc6295
--- /dev/null
+++ b/tests/turbo/distance/CMakeLists.txt
@@ -0,0 +1,14 @@
+include(${PROJECT_ROOT_DIR}/cmake/bazel.cmake)
+
+file(GLOB_RECURSE ALL_TEST_SRCS *_test.cc)
+
+foreach(CC_SRCS ${ALL_TEST_SRCS})
+  get_filename_component(CC_TARGET ${CC_SRCS} NAME_WE)
+  cc_gtest(
+      NAME ${CC_TARGET}
+      STRICT
+      LIBS zvec_ailego core_framework core_metric core_quantizer zvec_turbo
+      SRCS ${CC_SRCS}
+      INCS . ${PROJECT_ROOT_DIR}/src/core/
+    )
+endforeach()
\ No newline at end of file
diff --git a/tests/turbo/distance/turbo_cosine_test.cc b/tests/turbo/distance/turbo_cosine_test.cc
new file mode 100644
index 000000000..27cd5325f
--- /dev/null
+++ b/tests/turbo/distance/turbo_cosine_test.cc
@@ -0,0 +1,366 @@
+// Copyright 2025-present the zvec project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include <iostream>
+#include <gtest/gtest.h>
+#include <zvec/ailego/container/params.h>
+#include <zvec/turbo/turbo.h>
+#include "zvec/core/framework/index_factory.h"
+
+using namespace zvec;
+using namespace zvec::core;
+using namespace zvec::ailego;
+using namespace zvec::turbo;
+
+// Target Test Type: avx, avx512, scalar
+TEST(CosineMetric, TestFp32Cosine) {
+  std::mt19937 gen(15583);
+  std::uniform_real_distribution<float> dist(-1.0, 2.0);
+
+  const size_t DIMENSION = std::uniform_int_distribution<int>(1, 128)(gen);
+  const size_t COUNT = 1024;
+
+  auto quantizer = IndexFactory::CreateQuantizer("Fp32Quantizer");
+  IndexMeta meta(IndexMeta::DT_FP32, DIMENSION);
+  meta.set_metric("Cosine", 0, Params());
+  ASSERT_TRUE(!!quantizer);
+  ASSERT_EQ(0u, quantizer->init(meta, Params()));
+  auto &convert_meta = quantizer->meta();
+
+  auto func_avx512 = get_distance_func(MetricType::kCosine, DataType::kFp32,
+                                       turbo::QuantizeType::kDefault,
+                                       turbo::CpuArchType::kAVX512);
+
+  auto func_avx = get_distance_func(MetricType::kCosine, DataType::kFp32,
+                                    turbo::QuantizeType::kDefault,
+                                    turbo::CpuArchType::kAVX);
+
+  auto func_scalar = get_distance_func(MetricType::kCosine, DataType::kFp32,
+                                       turbo::QuantizeType::kDefault,
+                                       turbo::CpuArchType::kScalar);
+
+  ailego::NumericalVector<float> query_vec(DIMENSION);
+  for (size_t j = 0; j < DIMENSION; ++j) {
+    query_vec[j] = dist(gen);
+  }
+
+  IndexQueryMeta qmeta;
+  qmeta.set_meta(IndexMeta::DT_FP32, DIMENSION);
+  IndexQueryMeta qmeta_quantizer;
+
+  std::string query_out;
+  ASSERT_EQ(0, quantizer->quantize(query_vec.data(), qmeta, &query_out,
+                                   &qmeta_quantizer));
+  ASSERT_EQ(qmeta_quantizer.dimension(), convert_meta.dimension());
+
+  for (size_t i = 0; i < COUNT; ++i) {
+    ailego::NumericalVector<float> doc_vec(DIMENSION);
+    for (size_t j = 0; j < DIMENSION; ++j) {
+      doc_vec[j] = dist(gen);
+    }
+
+    std::string doc_out;
+    ASSERT_EQ(0, quantizer->quantize(doc_vec.data(), qmeta, &doc_out,
+                                     &qmeta_quantizer));
+    ASSERT_EQ(qmeta_quantizer.dimension(), convert_meta.dimension());
+
+    float score_scalar{0.0f};
+    float score_avx{0.0f};
+    float score_avx512{0.0f};
+
+    func_scalar(doc_vec.data(), query_vec.data(), DIMENSION, &score_scalar);
+
+    func_avx512(doc_vec.data(), query_vec.data(), DIMENSION, &score_avx512);
+
+    func_avx(doc_vec.data(), query_vec.data(), DIMENSION, &score_avx);
+
+    float epsilon = 0.001;
+    ASSERT_NEAR(score_scalar, score_avx512, epsilon);
+    ASSERT_NEAR(score_scalar, score_avx, epsilon);
+  }
+}
+
+// Target Test Type: avx, avx512, avx512fp16, scalar
+TEST(CosineMetric, TestFp16Cosine) {
+  std::mt19937 gen(15583);
+  std::uniform_real_distribution<float> dist(-1.0, 2.0);
+
+  const size_t DIMENSION = std::uniform_int_distribution<int>(1, 128)(gen);
+  const size_t COUNT = 1024;
+
+  auto quantizer = IndexFactory::CreateQuantizer("Fp16Quantizer");
+  IndexMeta meta(IndexMeta::DT_FP32, DIMENSION);
+  meta.set_metric("Cosine", 0, Params());
+  ASSERT_TRUE(!!quantizer);
+  ASSERT_EQ(0u, quantizer->init(meta, Params()));
+  auto &convert_meta = quantizer->meta();
+
+  auto func_avx512fp16 = get_distance_func(
+      MetricType::kCosine, turbo::DataType::kFp16,
+      turbo::QuantizeType::kDefault, turbo::CpuArchType::kAVX512FP16);
+
+  auto func_avx512 = get_distance_func(MetricType::kCosine, DataType::kFp16,
+                                       turbo::QuantizeType::kDefault,
+                                       turbo::CpuArchType::kAVX512);
+
+  auto func_avx = get_distance_func(MetricType::kCosine, DataType::kFp16,
+                                    turbo::QuantizeType::kDefault,
+                                    turbo::CpuArchType::kAVX);
+
+  auto func_scalar = get_distance_func(MetricType::kCosine, DataType::kFp16,
+                                       turbo::QuantizeType::kDefault,
+                                       turbo::CpuArchType::kScalar);
+
+  ailego::NumericalVector<float> query_vec(DIMENSION);
+  for (size_t j = 0; j < DIMENSION; ++j) {
+    query_vec[j] = dist(gen);
+  }
+
+  IndexQueryMeta qmeta;
+  qmeta.set_meta(IndexMeta::DT_FP32, DIMENSION);
+  IndexQueryMeta qmeta_quantizer;
+
+  std::string query_out;
+  ASSERT_EQ(0, quantizer->quantize(query_vec.data(), qmeta, &query_out,
+                                   &qmeta_quantizer));
+  ASSERT_EQ(qmeta_quantizer.dimension(), convert_meta.dimension());
+
+  for (size_t i = 0; i < COUNT; ++i) {
+    ailego::NumericalVector<float> doc_vec(DIMENSION);
+    for (size_t j = 0; j < DIMENSION; ++j) {
+      doc_vec[j] = dist(gen);
+    }
+
+    std::string doc_out;
+    ASSERT_EQ(0, quantizer->quantize(doc_vec.data(), qmeta, &doc_out,
+                                     &qmeta_quantizer));
+    ASSERT_EQ(qmeta_quantizer.dimension(), convert_meta.dimension());
+
+    float score_avx512fp16{0.0f};
+    float score_avx512{0.0f};
+    float score_avx{0.0f};
+    float score_scalar{0.0f};
+
+    func_avx512fp16(doc_out.data(), query_out.data(),
+                    qmeta_quantizer.dimension(), &score_avx512fp16);
+
+    func_avx512(doc_out.data(), query_out.data(), qmeta_quantizer.dimension(),
+                &score_avx512);
+
+    func_avx(doc_out.data(), query_out.data(), qmeta_quantizer.dimension(),
+             &score_avx);
+
+    func_scalar(doc_out.data(), query_out.data(), qmeta_quantizer.dimension(),
+                &score_scalar);
+
+    float epsilon = 0.2;
+    ASSERT_NEAR(score_scalar, score_avx512fp16, epsilon);
+    ASSERT_NEAR(score_scalar, score_avx512, epsilon);
+    ASSERT_NEAR(score_scalar, score_avx, epsilon);
+  }
+}
+
+#if 0
+// Target Test Type: avx, avx512, scalar
+TEST(CosineMetric, TestFp32CosineBatch) {
+  std::mt19937 gen(15583);
+  std::uniform_real_distribution<float> dist(-1.0, 2.0);
+
+  const size_t DIMENSION = std::uniform_int_distribution<int>(1, 128)(gen);
+  const size_t COUNT = 1024;
+  const size_t BATCH_SIZE = 16;
+
+  auto quantizer = IndexFactory::CreateQuantizer("Fp32Quantizer");
+  IndexMeta meta(IndexMeta::DT_FP32, DIMENSION);
+  meta.set_metric("Cosine", 0, Params());
+  ASSERT_TRUE(!!quantizer);
+  ASSERT_EQ(0u, quantizer->init(meta, Params()));
+  auto &convert_meta = quantizer->meta();
+
+  auto batch_func_avx512 = get_batch_distance_func(
+      MetricType::kCosine, DataType::kFp32, turbo::QuantizeType::kDefault,
+      turbo::CpuArchType::kAVX512);
+
+  auto batch_func_avx = turbo::get_batch_distance_func(
+      MetricType::kCosine, DataType::kFp32, turbo::QuantizeType::kDefault,
+      turbo::CpuArchType::kAVX);
+
+  auto batch_func_scalar = turbo::get_batch_distance_func(
+      MetricType::kCosine, DataType::kFp32, turbo::QuantizeType::kDefault,
+      turbo::CpuArchType::kScalar);
+
+  ailego::NumericalVector<float> query_vec(DIMENSION);
+  for (size_t j = 0; j < DIMENSION; ++j) {
+    query_vec[j] = dist(gen);
+  }
+
+  IndexQueryMeta qmeta;
+  qmeta.set_meta(IndexMeta::DT_FP32, DIMENSION);
+  IndexQueryMeta qmeta_quantizer;
+
+  std::string query_out;
+  ASSERT_EQ(0, quantizer->quantize(query_vec.data(), qmeta, &query_out,
+                                   &qmeta_quantizer));
+  ASSERT_EQ(qmeta_quantizer.dimension(), convert_meta.dimension());
+
+  std::vector<ailego::NumericalVector<float>> doc_vecs;
+  std::vector<std::string> doc_outs;
+  for (size_t i = 0; i < COUNT; ++i) {
+    ailego::NumericalVector<float> doc_vec(DIMENSION);
+    for (size_t j = 0; j < DIMENSION; ++j) {
+      doc_vec[j] = dist(gen);
+    }
+
+    doc_vecs.push_back(doc_vec);
+
+    std::string doc_out;
+    ASSERT_EQ(0, quantizer->quantize(doc_vec.data(), qmeta, &doc_out,
+                                     &qmeta_quantizer));
+    ASSERT_EQ(qmeta_quantizer.dimension(), convert_meta.dimension());
+
+    doc_outs.push_back(doc_out);
+
+    if (doc_vecs.size() == BATCH_SIZE) {
+      std::vector<const void *> doc_ptrs(BATCH_SIZE);
+      for (size_t k = 0; k < BATCH_SIZE; ++k) {
+        doc_ptrs[k] = doc_vecs[k].data();
+      }
+
+      std::vector<float> score_scalar(BATCH_SIZE, 0.0f);
+      std::vector<float> score_avx(BATCH_SIZE, 0.0f);
+      std::vector<float> score_avx512(BATCH_SIZE, 0.0f);
+
+      batch_func_scalar(doc_ptrs.data(), query_vec.data(), DIMENSION,
+                        BATCH_SIZE, &score_scalar[0]);
+
+      batch_func_avx512(doc_ptrs.data(), query_vec.data(), DIMENSION,
+                        BATCH_SIZE, &score_avx512[0]);
+
+      batch_func_avx(doc_ptrs.data(), query_vec.data(), DIMENSION, BATCH_SIZE,
+                     &score_avx[0]);
+
+      for (size_t j = 0; j < BATCH_SIZE; ++j) {
+        float epsilon = 0.001;
+        ASSERT_NEAR(score_scalar[j], score_avx512[j], epsilon);
+        ASSERT_NEAR(score_scalar[j], score_avx[j], epsilon);
+      }
+
+      doc_vecs.clear();
+      doc_outs.clear();
+    }
+  }
+}
+
+// Target Test Type: avx, avx512, avx512fp16, scalar
+TEST(CosineMetric, TestFp16CosineBatch) {
+  std::mt19937 gen(15583);
+  std::uniform_real_distribution<float> dist(-1.0, 2.0);
+
+  const size_t DIMENSION = std::uniform_int_distribution<int>(1, 128)(gen);
+  const size_t COUNT = 1024;
+  const size_t BATCH_SIZE = 16;
+
+  auto quantizer = IndexFactory::CreateQuantizer("Fp16Quantizer");
+  IndexMeta meta(IndexMeta::DT_FP32, DIMENSION);
+  meta.set_metric("Cosine", 0, Params());
+  ASSERT_TRUE(!!quantizer);
+  ASSERT_EQ(0u, quantizer->init(meta, Params()));
+  auto &convert_meta = quantizer->meta();
+
+  auto batch_func_avx512fp16 = get_batch_distance_func(
+      MetricType::kCosine, DataType::kFp16, QuantizeType::kDefault,
+      turbo::CpuArchType::kAVX512FP16);
+
+  auto batch_func_avx512 = get_batch_distance_func(
+      MetricType::kCosine, DataType::kFp16, turbo::QuantizeType::kDefault,
+      turbo::CpuArchType::kAVX512);
+
+  auto batch_func_avx = get_batch_distance_func(
+      MetricType::kCosine, DataType::kFp16, turbo::QuantizeType::kDefault,
+      turbo::CpuArchType::kAVX);
+
+  auto batch_func_scalar =
+      get_batch_distance_func(MetricType::kCosine, DataType::kFp16,
+                              QuantizeType::kDefault, CpuArchType::kScalar);
+
+  ailego::NumericalVector<float> query_vec(DIMENSION);
+  for (size_t j = 0; j < DIMENSION; ++j) {
+    query_vec[j] = dist(gen);
+  }
+
+  IndexQueryMeta qmeta;
+  qmeta.set_meta(IndexMeta::DT_FP32, DIMENSION);
+  IndexQueryMeta qmeta_quantizer;
+
+  std::string query_out;
+  ASSERT_EQ(0, quantizer->quantize(query_vec.data(), qmeta, &query_out,
+                                   &qmeta_quantizer));
+  ASSERT_EQ(qmeta_quantizer.dimension(), convert_meta.dimension());
+
+  std::vector<ailego::NumericalVector<float>> doc_vecs;
+  std::vector<std::string> doc_outs;
+  for (size_t i = 0; i < COUNT; ++i) {
+    ailego::NumericalVector<float> doc_vec(DIMENSION);
+    for (size_t j = 0; j < DIMENSION; ++j) {
+      doc_vec[j] = dist(gen);
+    }
+
+    doc_vecs.push_back(doc_vec);
+
+    std::string doc_out;
+    ASSERT_EQ(0, quantizer->quantize(doc_vec.data(), qmeta, &doc_out,
+                                     &qmeta_quantizer));
+    ASSERT_EQ(qmeta_quantizer.dimension(), convert_meta.dimension());
+    doc_outs.push_back(doc_out);
+
+    if (doc_vecs.size() == BATCH_SIZE) {
+      std::vector<const void *> doc_ptrs(BATCH_SIZE);
+      for (size_t k = 0; k < BATCH_SIZE; ++k) {
+        doc_ptrs[k] = doc_outs[k].data();
+      }
+
+      std::vector<float> score_avx512fp16(BATCH_SIZE, 0.0f);
+      std::vector<float> score_avx512(BATCH_SIZE, 0.0f);
+      std::vector<float> score_avx(BATCH_SIZE, 0.0f);
+      std::vector<float> score_scalar(BATCH_SIZE, 0.0f);
+
+      batch_func_avx512fp16(doc_ptrs.data(), query_out.data(),
+                            qmeta_quantizer.dimension(), BATCH_SIZE,
+                            &score_avx512fp16[0]);
+
+      batch_func_avx512(doc_ptrs.data(), query_out.data(),
+                        qmeta_quantizer.dimension(), BATCH_SIZE,
+                        &score_avx512[0]);
+
+      batch_func_avx(doc_ptrs.data(), query_out.data(),
+                     qmeta_quantizer.dimension(), BATCH_SIZE, &score_avx[0]);
+
+      batch_func_scalar(doc_ptrs.data(), query_out.data(),
+                        qmeta_quantizer.dimension(), BATCH_SIZE,
+                        &score_scalar[0]);
+
+      for (size_t j = 0; j < BATCH_SIZE; ++j) {
+        float epsilon = 0.2;
+        ASSERT_NEAR(score_scalar[j], score_avx512fp16[j], epsilon);
+        ASSERT_NEAR(score_scalar[j], score_avx512[j], epsilon);
+        ASSERT_NEAR(score_scalar[j], score_avx[j], epsilon);
+      }
+
+      doc_vecs.clear();
+      doc_outs.clear();
+    }
+  }
+}
+
+#endif
\ No newline at end of file
diff --git a/tests/turbo/distance/turbo_euclidean_test.cc b/tests/turbo/distance/turbo_euclidean_test.cc
new file mode 100644
index 000000000..d1d2d8534
--- /dev/null
+++ b/tests/turbo/distance/turbo_euclidean_test.cc
@@ -0,0 +1,318 @@
+// Copyright 2025-present the zvec project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+#include <iostream>
+#include <gtest/gtest.h>
+#include <zvec/ailego/container/params.h>
+#include <zvec/turbo/turbo.h>
+#include "zvec/core/framework/index_factory.h"
+
+using namespace zvec;
+using namespace zvec::core;
+using namespace zvec::ailego;
+using namespace zvec::turbo;
+
+// Target Test Type: avx, avx512, scalar
+TEST(SquaredEuclideanMetric, TestFp32SquaredEuclidean) {
+  std::mt19937 gen(15583);
+  std::uniform_real_distribution<float> dist(-1.0, 2.0);
+
+  const size_t DIMENSION = std::uniform_int_distribution<int>(1, 128)(gen);
+  const size_t COUNT = 1024;
+
+  auto func_avx512 =
+      get_distance_func(MetricType::kSquaredEuclidean, DataType::kFp32,
+                        QuantizeType::kDefault, CpuArchType::kAVX512);
+
+  auto func_avx =
+      get_distance_func(MetricType::kSquaredEuclidean, DataType::kFp32,
+                        QuantizeType::kDefault, CpuArchType::kAVX);
+
+  auto func_scalar =
+      get_distance_func(MetricType::kSquaredEuclidean, DataType::kFp32,
+                        QuantizeType::kDefault, CpuArchType::kScalar);
+
+  ailego::NumericalVector<float> query_vec(DIMENSION);
+  for (size_t j = 0; j < DIMENSION; ++j) {
+    query_vec[j] = dist(gen);
+  }
+
+  for (size_t i = 0; i < COUNT; ++i) {
+    ailego::NumericalVector<float> doc_vec(DIMENSION);
+    for (size_t j = 0; j < DIMENSION; ++j) {
+      doc_vec[j] = dist(gen);
+    }
+
+    float score_scalar{0.0f};
+    float score_avx{0.0f};
+    float score_avx512{0.0f};
+
+    func_scalar(doc_vec.data(), query_vec.data(), DIMENSION, &score_scalar);
+
+    func_avx512(doc_vec.data(), query_vec.data(), DIMENSION, &score_avx512);
+
+    func_avx(doc_vec.data(), query_vec.data(), DIMENSION, &score_avx);
+
+    float epsilon = 0.001;
+    ASSERT_NEAR(score_scalar, score_avx512, epsilon);
+    ASSERT_NEAR(score_scalar, score_avx, epsilon);
+  }
+}
+
+// Target Test Type: avx, avx512, avx512fp16, scalar
+TEST(SquaredEuclideanMetric, TestFp16SquaredEuclidean) {
+  std::mt19937 gen(15583);
+  std::uniform_real_distribution<float> dist(-1.0, 2.0);
+
+  const size_t DIMENSION = std::uniform_int_distribution<int>(1, 128)(gen);
+  const size_t COUNT = 1024;
+
+  auto quantizer = IndexFactory::CreateQuantizer("Fp16Quantizer");
+  IndexMeta meta(IndexMeta::DT_FP32, DIMENSION);
+  meta.set_metric("SquaredEuclidean", 0, Params());
+  ASSERT_TRUE(!!quantizer);
+  ASSERT_EQ(0u, quantizer->init(meta, Params()));
+  auto &convert_meta = quantizer->meta();
+
+  auto func_avx512fp16 =
+      get_distance_func(MetricType::kSquaredEuclidean, DataType::kFp16,
+                        QuantizeType::kDefault, CpuArchType::kAVX512FP16);
+
+  auto func_avx512 =
+      get_distance_func(MetricType::kSquaredEuclidean, DataType::kFp16,
+                        QuantizeType::kDefault, CpuArchType::kAVX512);
+
+  auto func_avx =
+      get_distance_func(MetricType::kSquaredEuclidean, DataType::kFp16,
+                        QuantizeType::kDefault, CpuArchType::kAVX);
+
+  auto func_scalar =
+      get_distance_func(MetricType::kSquaredEuclidean, DataType::kFp16,
+                        QuantizeType::kDefault, CpuArchType::kScalar);
+
+  ailego::NumericalVector<float> query_vec(DIMENSION);
+  for (size_t j = 0; j < DIMENSION; ++j) {
+    query_vec[j] = dist(gen);
+  }
+
+  IndexQueryMeta qmeta;
+  qmeta.set_meta(IndexMeta::DT_FP32, DIMENSION);
+  IndexQueryMeta qmeta_quantizer;
+
+  std::string query_out;
+  ASSERT_EQ(0, quantizer->quantize(query_vec.data(), qmeta, &query_out,
+                                   &qmeta_quantizer));
+  ASSERT_EQ(qmeta_quantizer.dimension(), convert_meta.dimension());
+
+  for (size_t i = 0; i < COUNT; ++i) {
+    ailego::NumericalVector<float> doc_vec(DIMENSION);
+    for (size_t j = 0; j < DIMENSION; ++j) {
+      doc_vec[j] = dist(gen);
+    }
+
+    std::string doc_out;
+    ASSERT_EQ(0, quantizer->quantize(doc_vec.data(), qmeta, &doc_out,
+                                     &qmeta_quantizer));
+    ASSERT_EQ(qmeta_quantizer.dimension(), convert_meta.dimension());
+
+    float score_avx512fp16{0.0f};
+    float score_avx512{0.0f};
+    float score_avx{0.0f};
+    float score_scalar{0.0f};
+
+    func_avx512fp16(doc_out.data(), query_out.data(),
+                    qmeta_quantizer.dimension(), &score_avx512fp16);
+
+    func_avx512(doc_out.data(), query_out.data(), qmeta_quantizer.dimension(),
+                &score_avx512);
+
+    func_avx(doc_out.data(), query_out.data(), qmeta_quantizer.dimension(),
+             &score_avx);
+
+    func_scalar(doc_out.data(), query_out.data(), qmeta_quantizer.dimension(),
+                &score_scalar);
+
+    float epsilon = 0.2;
+    ASSERT_NEAR(score_scalar, score_avx512fp16, epsilon);
+    ASSERT_NEAR(score_scalar, score_avx512, epsilon);
+    ASSERT_NEAR(score_scalar, score_avx, epsilon);
+  }
+}
+
+#if 0
+// Target Test Type: avx, avx512, scalar
+TEST(SquaredEuclideanMetric, TestFp32SquaredEuclideanBatch) {
+  std::mt19937 gen(15583);
+  std::uniform_real_distribution<float> dist(-1.0, 2.0);
+
+  const size_t DIMENSION = std::uniform_int_distribution<int>(1, 128)(gen);
+  const size_t COUNT = 1024;
+  const size_t BATCH_SIZE = 16;
+
+  auto batch_func_avx512 =
+      get_batch_distance_func(MetricType::kSquaredEuclidean, DataType::kFp32,
+                              QuantizeType::kDefault, CpuArchType::kAVX512);
+
+  auto batch_func_avx =
+      get_batch_distance_func(MetricType::kSquaredEuclidean, DataType::kFp32,
+                              QuantizeType::kDefault, CpuArchType::kAVX);
+
+  auto batch_func_scalar =
+      get_batch_distance_func(MetricType::kSquaredEuclidean, DataType::kFp32,
+                              QuantizeType::kDefault, CpuArchType::kScalar);
+
+  ailego::NumericalVector<float> query_vec(DIMENSION);
+  for (size_t j = 0; j < DIMENSION; ++j) {
+    query_vec[j] = dist(gen);
+  }
+
+  std::vector<ailego::NumericalVector<float>> doc_vecs;
+  for (size_t i = 0; i < COUNT; ++i) {
+    ailego::NumericalVector<float> doc_vec(DIMENSION);
+    for (size_t j = 0; j < DIMENSION; ++j) {
+      doc_vec[j] = dist(gen);
+    }
+    doc_vecs.push_back(doc_vec);
+
+    if (doc_vecs.size() == BATCH_SIZE) {
+      std::vector<const void *> doc_ptrs(BATCH_SIZE);
+      for (size_t k = 0; k < BATCH_SIZE; ++k) {
+        doc_ptrs[k] = doc_vecs[k].data();
+      }
+
+      std::vector<float> score_scalar(BATCH_SIZE, 0.0f);
+      std::vector<float> score_avx(BATCH_SIZE, 0.0f);
+      std::vector<float> score_avx512(BATCH_SIZE, 0.0f);
+
+      batch_func_scalar(doc_ptrs.data(), query_vec.data(), DIMENSION,
+                        BATCH_SIZE, &score_scalar[0]);
+
+      batch_func_avx512(doc_ptrs.data(), query_vec.data(), DIMENSION,
+                        BATCH_SIZE, &score_avx512[0]);
+
+      batch_func_avx(doc_ptrs.data(), query_vec.data(), DIMENSION, BATCH_SIZE,
+                     &score_avx[0]);
+
+      for (size_t j = 0; j < BATCH_SIZE; ++j) {
+        float epsilon = 0.001;
+        ASSERT_NEAR(score_scalar[j], score_avx512[j], epsilon);
+        ASSERT_NEAR(score_scalar[j], score_avx[j], epsilon);
+      }
+
+      doc_vecs.clear();
+    }
+  }
+}
+
+// Target Test Type: avx, avx512, avx512fp16, scalar
+TEST(SquaredEuclideanMetric, TestFp16SquaredEuclideanBatch) {
+  std::mt19937 gen(15583);
+  std::uniform_real_distribution<float> dist(-1.0, 2.0);
+
+  const size_t DIMENSION = std::uniform_int_distribution<int>(1, 128)(gen);
+  const size_t COUNT = 1024;
+  const size_t BATCH_SIZE = 16;
+
+  auto quantizer = IndexFactory::CreateQuantizer("Fp16Quantizer");
+  IndexMeta meta(IndexMeta::DT_FP32, DIMENSION);
+  meta.set_metric("SquaredEuclidean", 0, Params());
+  ASSERT_TRUE(!!quantizer);
+  ASSERT_EQ(0u, quantizer->init(meta, Params()));
+  auto &convert_meta = quantizer->meta();
+
+  auto batch_func_avx512fp16 =
+      get_batch_distance_func(MetricType::kSquaredEuclidean, DataType::kFp16,
+                              QuantizeType::kDefault, CpuArchType::kAVX512FP16);
+
+  auto batch_func_avx512 =
+      get_batch_distance_func(MetricType::kSquaredEuclidean, DataType::kFp16,
+                              QuantizeType::kDefault, CpuArchType::kAVX512);
+
+  auto batch_func_avx =
+      get_batch_distance_func(MetricType::kSquaredEuclidean, DataType::kFp16,
+                              QuantizeType::kDefault, CpuArchType::kAVX);
+
+  auto batch_func_scalar =
+      get_batch_distance_func(MetricType::kSquaredEuclidean, DataType::kFp16,
+                              QuantizeType::kDefault, CpuArchType::kScalar);
+
+  ailego::NumericalVector<float> query_vec(DIMENSION);
+  for (size_t j = 0; j < DIMENSION; ++j) {
+    query_vec[j] = dist(gen);
+  }
+
+  IndexQueryMeta qmeta;
+  qmeta.set_meta(IndexMeta::DT_FP32, DIMENSION);
+  IndexQueryMeta qmeta_quantizer;
+
+  std::string query_out;
+  ASSERT_EQ(0, quantizer->quantize(query_vec.data(), qmeta, &query_out,
+                                   &qmeta_quantizer));
+  ASSERT_EQ(qmeta_quantizer.dimension(), convert_meta.dimension());
+
+  std::vector<ailego::NumericalVector<float>> doc_vecs;
+  std::vector<std::string> doc_outs;
+  for (size_t i = 0; i < COUNT; ++i) {
+    ailego::NumericalVector<float> doc_vec(DIMENSION);
+    for (size_t j = 0; j < DIMENSION; ++j) {
+      doc_vec[j] = dist(gen);
+    }
+    doc_vecs.push_back(doc_vec);
+
+    std::string doc_out;
+    ASSERT_EQ(0, quantizer->quantize(doc_vec.data(), qmeta, &doc_out,
+                                     &qmeta_quantizer));
+    ASSERT_EQ(qmeta_quantizer.dimension(), convert_meta.dimension());
+
+    doc_outs.push_back(doc_out);
+
+    if (doc_vecs.size() == BATCH_SIZE) {
+      std::vector<const void *> doc_ptrs(BATCH_SIZE);
+      for (size_t k = 0; k < BATCH_SIZE; ++k) {
+        doc_ptrs[k] = doc_outs[k].data();
+      }
+
+      std::vector<float> score_avx512fp16(BATCH_SIZE, 0.0f);
+      std::vector<float> score_avx512(BATCH_SIZE, 0.0f);
+      std::vector<float> score_avx(BATCH_SIZE, 0.0f);
+      std::vector<float> score_scalar(BATCH_SIZE, 0.0f);
+
+      batch_func_avx512fp16(doc_ptrs.data(), query_out.data(),
+                            qmeta_quantizer.dimension(), BATCH_SIZE,
+                            &score_avx512fp16[0]);
+
+      batch_func_avx512(doc_ptrs.data(), query_out.data(),
+                        qmeta_quantizer.dimension(), BATCH_SIZE,
+                        &score_avx512[0]);
+
+      batch_func_avx(doc_ptrs.data(), query_out.data(),
+                     qmeta_quantizer.dimension(), BATCH_SIZE, &score_avx[0]);
+
+      batch_func_scalar(doc_ptrs.data(), query_out.data(),
+                        qmeta_quantizer.dimension(), BATCH_SIZE,
+                        &score_scalar[0]);
+
+      for (size_t j = 0; j < BATCH_SIZE; ++j) {
+        float epsilon = 0.2;
+        ASSERT_NEAR(score_scalar[j], score_avx512fp16[j], epsilon);
+        ASSERT_NEAR(score_scalar[j], score_avx512[j], epsilon);
+        ASSERT_NEAR(score_scalar[j], score_avx[j], epsilon);
+      }
+
+      doc_vecs.clear();
+      doc_outs.clear();
+    }
+  }
+}
+
+#endif
\ No newline at end of file
diff --git a/tests/turbo/distance/turbo_inner_product_test.cc b/tests/turbo/distance/turbo_inner_product_test.cc
new file mode 100644
index 000000000..316d470f5
--- /dev/null
+++ b/tests/turbo/distance/turbo_inner_product_test.cc
@@ -0,0 +1,317 @@
+// Copyright 2025-present the zvec project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+#include <iostream>
+#include <gtest/gtest.h>
+#include <zvec/ailego/container/params.h>
+#include <zvec/turbo/turbo.h>
+#include "zvec/core/framework/index_factory.h"
+
+using namespace zvec;
+using namespace zvec::core;
+using namespace zvec::ailego;
+using namespace zvec::turbo;
+
+// Target Test Type: avx, avx512, scalar
+TEST(InnerProductMetric, TestFp32InnerProduct) {
+  std::mt19937 gen(15583);
+  std::uniform_real_distribution<float> dist(-1.0, 2.0);
+
+  const size_t DIMENSION = std::uniform_int_distribution<int>(1, 128)(gen);
+  const size_t COUNT = 1024;
+
+  auto func_avx512 =
+      get_distance_func(MetricType::kInnerProduct, DataType::kFp32,
+                        QuantizeType::kDefault, CpuArchType::kAVX512);
+
+  auto func_avx = get_distance_func(MetricType::kInnerProduct, DataType::kFp32,
+                                    QuantizeType::kDefault, CpuArchType::kAVX);
+
+  auto func_scalar =
+      get_distance_func(MetricType::kInnerProduct, DataType::kFp32,
+                        QuantizeType::kDefault, CpuArchType::kScalar);
+
+  ailego::NumericalVector<float> query_vec(DIMENSION);
+  for (size_t j = 0; j < DIMENSION; ++j) {
+    query_vec[j] = dist(gen);
+  }
+
+  for (size_t i = 0; i < COUNT; ++i) {
+    ailego::NumericalVector<float> doc_vec(DIMENSION);
+    for (size_t j = 0; j < DIMENSION; ++j) {
+      doc_vec[j] = dist(gen);
+    }
+
+    float score_scalar{0.0f};
+    float score_avx{0.0f};
+    float score_avx512{0.0f};
+
+    func_scalar(doc_vec.data(), query_vec.data(), DIMENSION, &score_scalar);
+
+    func_avx512(doc_vec.data(), query_vec.data(), DIMENSION, &score_avx512);
+
+    func_avx(doc_vec.data(), query_vec.data(), DIMENSION, &score_avx);
+
+    float epsilon = 0.001;
+    ASSERT_NEAR(score_scalar, score_avx512, epsilon);
+    ASSERT_NEAR(score_scalar, score_avx, epsilon);
+  }
+}
+
+// Target Test Type: avx, avx512, avx512fp16, scalar
+TEST(InnerProductMetric, TestFp16InnerProduct) {
+  std::mt19937 gen(15583);
+  std::uniform_real_distribution<float> dist(-1.0, 2.0);
+
+  const size_t DIMENSION = std::uniform_int_distribution<int>(1, 128)(gen);
+  const size_t COUNT = 1024;
+
+  auto quantizer = IndexFactory::CreateQuantizer("Fp16Quantizer");
+  IndexMeta meta(IndexMeta::DT_FP32, DIMENSION);
+  meta.set_metric("InnerProduct", 0, Params());
+  ASSERT_TRUE(!!quantizer);
+  ASSERT_EQ(0u, quantizer->init(meta, Params()));
+  auto &convert_meta = quantizer->meta();
+
+  auto func_avx512fp16 =
+      get_distance_func(MetricType::kInnerProduct, DataType::kFp16,
+                        QuantizeType::kDefault, CpuArchType::kAVX512FP16);
+
+  auto func_avx512 =
+      get_distance_func(MetricType::kInnerProduct, DataType::kFp16,
+                        QuantizeType::kDefault, CpuArchType::kAVX512);
+
+  auto func_avx = get_distance_func(MetricType::kInnerProduct, DataType::kFp16,
+                                    QuantizeType::kDefault, CpuArchType::kAVX);
+
+  auto func_scalar =
+      get_distance_func(MetricType::kInnerProduct, DataType::kFp16,
+                        QuantizeType::kDefault, CpuArchType::kScalar);
+
+  ailego::NumericalVector<float> query_vec(DIMENSION);
+  for (size_t j = 0; j < DIMENSION; ++j) {
+    query_vec[j] = dist(gen);
+  }
+
+  IndexQueryMeta qmeta;
+  qmeta.set_meta(IndexMeta::DT_FP32, DIMENSION);
+  IndexQueryMeta qmeta_quantizer;
+
+  std::string query_out;
+  ASSERT_EQ(0, quantizer->quantize(query_vec.data(), qmeta, &query_out,
+                                   &qmeta_quantizer));
+  ASSERT_EQ(qmeta_quantizer.dimension(), convert_meta.dimension());
+
+  for (size_t i = 0; i < COUNT; ++i) {
+    ailego::NumericalVector<float> doc_vec(DIMENSION);
+    for (size_t j = 0; j < DIMENSION; ++j) {
+      doc_vec[j] = dist(gen);
+    }
+
+    std::string doc_out;
+    ASSERT_EQ(0, quantizer->quantize(doc_vec.data(), qmeta, &doc_out,
+                                     &qmeta_quantizer));
+    ASSERT_EQ(qmeta_quantizer.dimension(), convert_meta.dimension());
+
+    float score_avx512fp16{0.0f};
+    float score_avx512{0.0f};
+    float score_avx{0.0f};
+    float score_scalar{0.0f};
+
+    func_avx512fp16(doc_out.data(), query_out.data(),
+                    qmeta_quantizer.dimension(), &score_avx512fp16);
+
+    func_avx512(doc_out.data(), query_out.data(), qmeta_quantizer.dimension(),
+                &score_avx512);
+
+    func_avx(doc_out.data(), query_out.data(), qmeta_quantizer.dimension(),
+             &score_avx);
+
+    func_scalar(doc_out.data(), query_out.data(), qmeta_quantizer.dimension(),
+                &score_scalar);
+
+    float epsilon = 0.2;
+    ASSERT_NEAR(score_scalar, score_avx512fp16, epsilon);
+    ASSERT_NEAR(score_scalar, score_avx512, epsilon);
+    ASSERT_NEAR(score_scalar, score_avx, epsilon);
+  }
+}
+
+#if 0
+// Target Test Type: avx, avx512, scalar
+TEST(InnerProductMetric, TestFp32InnerProductBatch) {
+  std::mt19937 gen(15583);
+  std::uniform_real_distribution<float> dist(-1.0, 2.0);
+
+  const size_t DIMENSION = std::uniform_int_distribution<int>(1, 128)(gen);
+  const size_t COUNT = 1024;
+  const size_t BATCH_SIZE = 16;
+
+  auto batch_func_avx512 =
+      get_batch_distance_func(MetricType::kInnerProduct, DataType::kFp32,
+                              QuantizeType::kDefault, CpuArchType::kAVX512);
+
+  auto batch_func_avx =
+      get_batch_distance_func(MetricType::kInnerProduct, DataType::kFp32,
+                              QuantizeType::kDefault, CpuArchType::kAVX);
+
+  auto batch_func_scalar =
+      get_batch_distance_func(MetricType::kInnerProduct, DataType::kFp32,
+                              QuantizeType::kDefault, CpuArchType::kScalar);
+
+  ailego::NumericalVector<float> query_vec(DIMENSION);
+  for (size_t j = 0; j < DIMENSION; ++j) {
+    query_vec[j] = dist(gen);
+  }
+
+  std::vector<ailego::NumericalVector<float>> doc_vecs;
+
+  for (size_t i = 0; i < COUNT; ++i) {
+    ailego::NumericalVector<float> doc_vec(DIMENSION);
+    for (size_t j = 0; j < DIMENSION; ++j) {
+      doc_vec[j] = dist(gen);
+    }
+
+    doc_vecs.push_back(doc_vec);
+
+    if (doc_vecs.size() == BATCH_SIZE) {
+      std::vector<const void *> doc_ptrs(BATCH_SIZE);
+      for (size_t k = 0; k < BATCH_SIZE; ++k) {
+        doc_ptrs[k] = doc_vecs[k].data();
+      }
+
+      std::vector<float> score_scalar(BATCH_SIZE, 0.0f);
+      std::vector<float> score_avx(BATCH_SIZE, 0.0f);
+      std::vector<float> score_avx512(BATCH_SIZE, 0.0f);
+
+      batch_func_scalar(doc_ptrs.data(), query_vec.data(), DIMENSION,
+                        BATCH_SIZE, &score_scalar[0]);
+      batch_func_avx512(doc_ptrs.data(), query_vec.data(), DIMENSION,
+                        BATCH_SIZE, &score_avx512[0]);
+      batch_func_avx(doc_ptrs.data(), query_vec.data(), DIMENSION, BATCH_SIZE,
+                     &score_avx[0]);
+
+      for (size_t j = 0; j < BATCH_SIZE; ++j) {
+        float epsilon = 0.001;
+        ASSERT_NEAR(score_scalar[j], score_avx512[j], epsilon);
+        ASSERT_NEAR(score_scalar[j], score_avx[j], epsilon);
+      }
+
+      doc_vecs.clear();
+    }
+  }
+}
+
+// Target Test Type: avx, avx512, avx512fp16, scalar
+TEST(InnerProductMetric, TestFp16InnerProductBatch) {
+  std::mt19937 gen(15583);
+  std::uniform_real_distribution<float> dist(-1.0, 2.0);
+
+  const size_t DIMENSION = std::uniform_int_distribution<int>(1, 128)(gen);
+  const size_t COUNT = 1024;
+  const size_t BATCH_SIZE = 16;
+
+  auto quantizer = IndexFactory::CreateQuantizer("Fp16Quantizer");
+  IndexMeta meta(IndexMeta::DT_FP32, DIMENSION);
+  meta.set_metric("InnerProduct", 0, Params());
+  ASSERT_TRUE(!!quantizer);
+  ASSERT_EQ(0u, quantizer->init(meta, Params()));
+  auto &convert_meta = quantizer->meta();
+
+  auto batch_func_avx512fp16 =
+      get_batch_distance_func(MetricType::kInnerProduct, DataType::kFp16,
+                              QuantizeType::kDefault, CpuArchType::kAVX512FP16);
+
+  auto batch_func_avx512 =
+      get_batch_distance_func(MetricType::kInnerProduct, DataType::kFp16,
+                              QuantizeType::kDefault, CpuArchType::kAVX512);
+
+  auto batch_func_avx =
+      get_batch_distance_func(MetricType::kInnerProduct, DataType::kFp16,
+                              QuantizeType::kDefault, CpuArchType::kAVX);
+
+  auto batch_func_scalar =
+      get_batch_distance_func(MetricType::kInnerProduct, DataType::kFp16,
+                              QuantizeType::kDefault, CpuArchType::kScalar);
+
+  ailego::NumericalVector<float> query_vec(DIMENSION);
+  for (size_t j = 0; j < DIMENSION; ++j) {
+    query_vec[j] = dist(gen);
+  }
+
+  IndexQueryMeta qmeta;
+  qmeta.set_meta(IndexMeta::DT_FP32, DIMENSION);
+  IndexQueryMeta qmeta_quantizer;
+
+  std::string query_out;
+  ASSERT_EQ(0, quantizer->quantize(query_vec.data(), qmeta, &query_out,
+                                   &qmeta_quantizer));
+  ASSERT_EQ(qmeta_quantizer.dimension(), convert_meta.dimension());
+
+  std::vector<ailego::NumericalVector<float>> doc_vecs;
+  std::vector<std::string> doc_outs;
+
+  for (size_t i = 0; i < COUNT; ++i) {
+    ailego::NumericalVector<float> doc_vec(DIMENSION);
+    for (size_t j = 0; j < DIMENSION; ++j) {
+      doc_vec[j] = dist(gen);
+    }
+
+    doc_vecs.push_back(doc_vec);
+
+    std::string doc_out;
+    ASSERT_EQ(0, quantizer->quantize(doc_vec.data(), qmeta, &doc_out,
+                                     &qmeta_quantizer));
+    ASSERT_EQ(qmeta_quantizer.dimension(), convert_meta.dimension());
+    doc_outs.push_back(doc_out);
+
+    if (doc_vecs.size() == BATCH_SIZE) {
+      std::vector<const void *> doc_ptrs(BATCH_SIZE);
+      for (size_t k = 0; k < BATCH_SIZE; ++k) {
+        doc_ptrs[k] = doc_outs[k].data();
+      }
+
+      std::vector<float> score_avx512fp16(BATCH_SIZE, 0.0f);
+      std::vector<float> score_avx512(BATCH_SIZE, 0.0f);
+      std::vector<float> score_avx(BATCH_SIZE, 0.0f);
+      std::vector<float> score_scalar(BATCH_SIZE, 0.0f);
+
+      batch_func_avx512fp16(doc_ptrs.data(), query_out.data(),
+                            qmeta_quantizer.dimension(), BATCH_SIZE,
+                            &score_avx512fp16[0]);
+
+      batch_func_avx512(doc_ptrs.data(), query_out.data(),
+                        qmeta_quantizer.dimension(), BATCH_SIZE,
+                        &score_avx512[0]);
+
+      batch_func_avx(doc_ptrs.data(), query_out.data(),
+                     qmeta_quantizer.dimension(), BATCH_SIZE, &score_avx[0]);
+
+      batch_func_scalar(doc_ptrs.data(), query_out.data(),
+                        qmeta_quantizer.dimension(), BATCH_SIZE,
+                        &score_scalar[0]);
+
+      for (size_t j = 0; j < BATCH_SIZE; ++j) {
+        float epsilon = 0.2;
+        ASSERT_NEAR(score_scalar[j], score_avx512fp16[j], epsilon);
+        ASSERT_NEAR(score_scalar[j], score_avx512[j], epsilon);
+        ASSERT_NEAR(score_scalar[j], score_avx[j], epsilon);
+      }
+
+      doc_vecs.clear();
+      doc_outs.clear();
+    }
+  }
+}
+
+#endif
diff --git a/tests/turbo/distance/turbo_quantized_integer_test.cc b/tests/turbo/distance/turbo_quantized_integer_test.cc
new file mode 100644
index 000000000..9bea276c9
--- /dev/null
+++ b/tests/turbo/distance/turbo_quantized_integer_test.cc
@@ -0,0 +1,1261 @@
+// Copyright 2025-present the zvec project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+#include <fstream>
+#include <iostream>
+#include <unordered_set>
+#include <vector>
+#include <ailego/math/distance.h>
+#include <ailego/math/norm_matrix.h>
+#include <ailego/math/normalizer.h>
+#include <gtest/gtest.h>
+#include <zvec/ailego/container/params.h>
+#include <zvec/core/framework/index_factory.h>
+#include <zvec/turbo/turbo.h>
+
+using namespace zvec;
+using namespace zvec::core;
+using namespace zvec::ailego;
+using namespace zvec::turbo;
+
+// Target Test Type: avx2, sse, scalar
+TEST(QuantizedIntegerMetric, TestInt8InnerProduct) {
+  std::mt19937 gen(15583);
+  std::uniform_real_distribution<float> dist(-1.0, 2.0);
+
+  const size_t DIMENSION = std::uniform_int_distribution<int>(1, 128)(gen);
+  const size_t COUNT = 1024;
+
+  auto quantizer = IndexFactory::CreateQuantizer("RecordInt8Quantizer");
+  IndexMeta meta(IndexMeta::DT_FP32, DIMENSION);
+  meta.set_metric("InnerProduct", 0, Params());
+  ASSERT_TRUE(!!quantizer);
+  ASSERT_EQ(0u, quantizer->init(meta, Params()));
+  auto &convert_meta = quantizer->meta();
+  ;
+
+  auto func_float32 = get_distance_func(
+      turbo::MetricType::kInnerProduct, turbo::DataType::kFp32,
+      turbo::QuantizeType::kDefault, turbo::CpuArchType::kAuto);
+
+  auto func_avx512vnni = get_distance_func(
+      turbo::MetricType::kInnerProduct, turbo::DataType::kInt8,
+      turbo::QuantizeType::kDefault, turbo::CpuArchType::kAVX512VNNI);
+
+  auto func_avx2 = get_distance_func(
+      turbo::MetricType::kInnerProduct, turbo::DataType::kInt8,
+      turbo::QuantizeType::kDefault, turbo::CpuArchType::kAVX2);
+
+  auto func_sse = get_distance_func(
+      turbo::MetricType::kInnerProduct, turbo::DataType::kInt8,
+      turbo::QuantizeType::kDefault, turbo::CpuArchType::kSSE);
+
+  auto func_scalar = get_distance_func(
+      turbo::MetricType::kInnerProduct, turbo::DataType::kInt8,
+      turbo::QuantizeType::kDefault, turbo::CpuArchType::kScalar);
+
+  ailego::NumericalVector<float> query_vec(DIMENSION);
+  for (size_t j = 0; j < DIMENSION; ++j) {
+    query_vec[j] = dist(gen);
+  }
+
+  IndexQueryMeta qmeta;
+  qmeta.set_meta(IndexMeta::DT_FP32, DIMENSION);
+  IndexQueryMeta qmeta_quantizer;
+
+  std::string query_out;
+  ASSERT_EQ(0, quantizer->quantize(query_vec.data(), qmeta, &query_out,
+                                   &qmeta_quantizer));
+  ASSERT_EQ(qmeta_quantizer.dimension(), convert_meta.dimension());
+
+  for (size_t i = 0; i < COUNT; ++i) {
+    ailego::NumericalVector<float> doc_vec(DIMENSION);
+    for (size_t j = 0; j < DIMENSION; ++j) {
+      doc_vec[j] = dist(gen);
+    }
+
+    std::string doc_out;
+    ASSERT_EQ(0, quantizer->quantize(doc_vec.data(), qmeta, &doc_out,
+                                     &qmeta_quantizer));
+    ASSERT_EQ(qmeta_quantizer.dimension(), convert_meta.dimension());
+
+    float score_float32{0.0f};
+    float score_scalar{0.0f};
+    float score_avx512vnni{0.0f};
+    float score_avx2{0.0f};
+    float score_sse{0.0f};
+
+    func_float32(query_vec.data(), doc_vec.data(), DIMENSION, &score_float32);
+
+    func_scalar(doc_out.data(), query_out.data(), DIMENSION, &score_scalar);
+
+    func_avx512vnni(doc_out.data(), query_out.data(), DIMENSION,
+                    &score_avx512vnni);
+
+    func_avx2(doc_out.data(), query_out.data(), DIMENSION, &score_avx2);
+
+    func_sse(doc_out.data(), query_out.data(), DIMENSION, &score_sse);
+
+    ASSERT_NEAR(score_float32, score_avx512vnni, 0.2 * DIMENSION);
+    ASSERT_NEAR(score_float32, score_avx2, 0.2 * DIMENSION);
+    ASSERT_NEAR(score_float32, score_sse, 0.2 * DIMENSION);
+    ASSERT_NEAR(score_float32, score_scalar, 0.2 * DIMENSION);
+    ASSERT_NEAR(score_scalar, score_avx2, 0.001);
+    ASSERT_NEAR(score_scalar, score_sse, 0.001);
+  }
+}
+
+// Target Test Type: avx2, sse, scalar
+TEST(QuantizedIntegerMetric, TestInt4InnerProduct) {
+  std::mt19937 gen(15583);
+  std::uniform_real_distribution<float> dist(-1.0, 2.0);
+
+  const size_t DIMENSION = std::uniform_int_distribution<int>(1, 128)(gen) * 2;
+  const size_t COUNT = 1024;
+
+  auto quantizer = IndexFactory::CreateQuantizer("RecordInt4Quantizer");
+  IndexMeta meta(IndexMeta::DT_FP32, DIMENSION);
+  meta.set_metric("InnerProduct", 0, Params());
+  ASSERT_TRUE(!!quantizer);
+  ASSERT_EQ(0u, quantizer->init(meta, Params()));
+  auto &convert_meta = quantizer->meta();
+
+  auto func_float32 = get_distance_func(
+      turbo::MetricType::kInnerProduct, turbo::DataType::kFp32,
+      turbo::QuantizeType::kDefault, turbo::CpuArchType::kAuto);
+
+  auto func_avx2 = get_distance_func(
+      turbo::MetricType::kInnerProduct, turbo::DataType::kInt4,
+      turbo::QuantizeType::kDefault, turbo::CpuArchType::kAVX2);
+
+  auto func_sse = get_distance_func(
+      turbo::MetricType::kInnerProduct, turbo::DataType::kInt4,
+      turbo::QuantizeType::kDefault, turbo::CpuArchType::kSSE);
+
+  auto func_scalar = get_distance_func(
+      turbo::MetricType::kInnerProduct, turbo::DataType::kInt4,
+      turbo::QuantizeType::kDefault, turbo::CpuArchType::kScalar);
+
+  ailego::NumericalVector<float> query_vec(DIMENSION);
+  for (size_t j = 0; j < DIMENSION; ++j) {
+    query_vec[j] = dist(gen);
+  }
+
+  IndexQueryMeta qmeta;
+  qmeta.set_meta(IndexMeta::DT_FP32, DIMENSION);
+  IndexQueryMeta qmeta_quantizer;
+
+  std::string query_out;
+  ASSERT_EQ(0, quantizer->quantize(query_vec.data(), qmeta, &query_out,
+                                   &qmeta_quantizer));
+  ASSERT_EQ(qmeta_quantizer.dimension(), convert_meta.dimension());
+
+  for (size_t i = 0; i < COUNT; ++i) {
+    ailego::NumericalVector<float> doc_vec(DIMENSION);
+    for (size_t j = 0; j < DIMENSION; ++j) {
+      doc_vec[j] = dist(gen);
+    }
+
+    std::string doc_out;
+    ASSERT_EQ(0, quantizer->quantize(doc_vec.data(), qmeta, &doc_out,
+                                     &qmeta_quantizer));
+    ASSERT_EQ(qmeta_quantizer.dimension(), convert_meta.dimension());
+
+    float score_float32{0.0f};
+    float score_scalar{0.0f};
+    float score_avx2{0.0f};
+    float score_sse{0.0f};
+
+    func_float32(query_vec.data(), doc_vec.data(), DIMENSION, &score_float32);
+
+    func_scalar(doc_out.data(), query_out.data(), DIMENSION, &score_scalar);
+
+    func_avx2(doc_out.data(), query_out.data(), DIMENSION, &score_avx2);
+
+    func_sse(doc_out.data(), query_out.data(), DIMENSION, &score_sse);
+
+    ASSERT_NEAR(score_float32, score_avx2, 0.2 * DIMENSION);
+    ASSERT_NEAR(score_float32, score_sse, 0.2 * DIMENSION);
+    ASSERT_NEAR(score_float32, score_scalar, 0.2 * DIMENSION);
+    ASSERT_NEAR(score_scalar, score_avx2, 0.001);
+    ASSERT_NEAR(score_scalar, score_sse, 0.001);
+  }
+}
+
+// Target Test Type: avx2, sse, scalar
+TEST(QuantizedIntegerMetric, TestInt8SquaredEuclidean) {
+  std::mt19937 gen(15583);
+  std::uniform_real_distribution<float> dist(-1.0, 2.0);
+
+  const size_t DIMENSION = std::uniform_int_distribution<int>(1, 128)(gen);
+  const size_t COUNT = 1024;
+
+  auto quantizer = IndexFactory::CreateQuantizer("RecordInt8Quantizer");
+  IndexMeta meta(IndexMeta::DT_FP32, DIMENSION);
+  meta.set_metric("SquaredEuclidean", 0, Params());
+  ASSERT_TRUE(!!quantizer);
+  ASSERT_EQ(0u, quantizer->init(meta, Params()));
+  auto &convert_meta = quantizer->meta();
+
+  auto func_float32 = get_distance_func(
+      turbo::MetricType::kSquaredEuclidean, turbo::DataType::kFp32,
+      turbo::QuantizeType::kDefault, turbo::CpuArchType::kAuto);
+
+  auto func_avx2 = get_distance_func(
+      turbo::MetricType::kSquaredEuclidean, turbo::DataType::kInt8,
+      turbo::QuantizeType::kDefault, turbo::CpuArchType::kAVX2);
+
+  auto func_sse = get_distance_func(
+      turbo::MetricType::kSquaredEuclidean, turbo::DataType::kInt8,
+      turbo::QuantizeType::kDefault, turbo::CpuArchType::kSSE);
+
+  auto func_scalar = get_distance_func(
+      turbo::MetricType::kSquaredEuclidean, turbo::DataType::kInt8,
+      turbo::QuantizeType::kDefault, turbo::CpuArchType::kScalar);
+
+  ailego::NumericalVector<float> query_vec(DIMENSION);
+  for (size_t j = 0; j < DIMENSION; ++j) {
+    query_vec[j] = dist(gen);
+  }
+
+  IndexQueryMeta qmeta;
+  qmeta.set_meta(IndexMeta::DT_FP32, DIMENSION);
+  IndexQueryMeta qmeta_quantizer;
+
+  std::string query_out;
+  ASSERT_EQ(0, quantizer->quantize(query_vec.data(), qmeta, &query_out,
+                                   &qmeta_quantizer));
+  ASSERT_EQ(qmeta_quantizer.dimension(), convert_meta.dimension());
+
+  for (size_t i = 0; i < COUNT; ++i) {
+    ailego::NumericalVector<float> doc_vec(DIMENSION);
+    for (size_t j = 0; j < DIMENSION; ++j) {
+      doc_vec[j] = dist(gen);
+    }
+
+    std::string doc_out;
+    ASSERT_EQ(0, quantizer->quantize(doc_vec.data(), qmeta, &doc_out,
+                                     &qmeta_quantizer));
+    ASSERT_EQ(qmeta_quantizer.dimension(), convert_meta.dimension());
+
+    float score_float32{0.0f};
+    float score_scalar{0.0f};
+    float score_avx2{0.0f};
+    float score_sse{0.0f};
+
+    func_float32(query_vec.data(), doc_vec.data(), DIMENSION, &score_float32);
+
+    func_scalar(doc_out.data(), query_out.data(), DIMENSION, &score_scalar);
+
+    func_avx2(doc_out.data(), query_out.data(), DIMENSION, &score_avx2);
+
+    func_sse(doc_out.data(), query_out.data(), DIMENSION, &score_sse);
+
+    ASSERT_NEAR(score_float32, score_avx2, 0.2 * DIMENSION);
+    ASSERT_NEAR(score_float32, score_sse, 0.2 * DIMENSION);
+    ASSERT_NEAR(score_float32, score_scalar, 0.2 * DIMENSION);
+    ASSERT_NEAR(score_scalar, score_avx2, 0.001);
+    ASSERT_NEAR(score_scalar, score_sse, 0.001);
+  }
+}
+
+// Target Test Type: avx2, sse, scalar
+TEST(QuantizedIntegerMetric, TestInt4SquaredEuclidean) {
+  std::mt19937 gen(15583);
+  std::uniform_real_distribution<float> dist(-1.0, 2.0);
+
+  const size_t DIMENSION = std::uniform_int_distribution<int>(1, 128)(gen) * 2;
+  const size_t COUNT = 1024;
+
+  auto quantizer = IndexFactory::CreateQuantizer("RecordInt4Quantizer");
+  IndexMeta meta(IndexMeta::DT_FP32, DIMENSION);
+  meta.set_metric("SquaredEuclidean", 0, Params());
+  ASSERT_TRUE(!!quantizer);
+  ASSERT_EQ(0u, quantizer->init(meta, Params()));
+  auto &convert_meta = quantizer->meta();
+
+  auto func_float32 = get_distance_func(
+      turbo::MetricType::kSquaredEuclidean, turbo::DataType::kFp32,
+      turbo::QuantizeType::kDefault, turbo::CpuArchType::kAuto);
+
+  auto func_avx2 = get_distance_func(
+      turbo::MetricType::kSquaredEuclidean, turbo::DataType::kInt4,
+      turbo::QuantizeType::kDefault, turbo::CpuArchType::kAVX2);
+
+  auto func_sse = get_distance_func(
+      turbo::MetricType::kSquaredEuclidean, turbo::DataType::kInt4,
+      turbo::QuantizeType::kDefault, turbo::CpuArchType::kSSE);
+
+  auto func_scalar = get_distance_func(
+      turbo::MetricType::kSquaredEuclidean, turbo::DataType::kInt4,
+      turbo::QuantizeType::kDefault, turbo::CpuArchType::kScalar);
+
+  ailego::NumericalVector<float> query_vec(DIMENSION);
+  for (size_t j = 0; j < DIMENSION; ++j) {
+    query_vec[j] = dist(gen);
+  }
+
+  IndexQueryMeta qmeta;
+  qmeta.set_meta(IndexMeta::DT_FP32, DIMENSION);
+  IndexQueryMeta qmeta_quantizer;
+
+  std::string query_out;
+  ASSERT_EQ(0, quantizer->quantize(query_vec.data(), qmeta, &query_out,
+                                   &qmeta_quantizer));
+  ASSERT_EQ(qmeta_quantizer.dimension(), convert_meta.dimension());
+
+  for (size_t i = 0; i < COUNT; ++i) {
+    ailego::NumericalVector<float> doc_vec(DIMENSION);
+    for (size_t j = 0; j < DIMENSION; ++j) {
+      doc_vec[j] = dist(gen);
+    }
+
+    std::string doc_out;
+    ASSERT_EQ(0, quantizer->quantize(doc_vec.data(), qmeta, &doc_out,
+                                     &qmeta_quantizer));
+    ASSERT_EQ(qmeta_quantizer.dimension(), convert_meta.dimension());
+
+    float score_float32{0.0f};
+    float score_scalar{0.0f};
+    float score_avx2{0.0f};
+    float score_sse{0.0f};
+
+    func_float32(query_vec.data(), doc_vec.data(), DIMENSION, &score_float32);
+
+    func_scalar(doc_out.data(), query_out.data(), DIMENSION, &score_scalar);
+
+    func_avx2(doc_out.data(), query_out.data(), DIMENSION, &score_avx2);
+
+    func_sse(doc_out.data(), query_out.data(), DIMENSION, &score_sse);
+
+    ASSERT_NEAR(score_float32, score_avx2, 0.2 * DIMENSION);
+    ASSERT_NEAR(score_float32, score_sse, 0.2 * DIMENSION);
+    ASSERT_NEAR(score_float32, score_scalar, 0.2 * DIMENSION);
+    ASSERT_NEAR(score_scalar, score_avx2, 0.001);
+    ASSERT_NEAR(score_scalar, score_sse, 0.001);
+  }
+}
+
+// Target Test Type: avx2, sse, scalar
+TEST(QuantizedIntegerMetric, TestInt8Cosine) {
+  std::mt19937 gen(15583);
+  std::uniform_real_distribution<float> dist(-1.0, 2.0);
+
+  const size_t DIMENSION = std::uniform_int_distribution<int>(1, 128)(gen);
+  const size_t COUNT = 1024;
+
+  IndexMeta meta(IndexMeta::DT_FP32, DIMENSION);
+  meta.set_metric("Cosine", 0, Params());
+
+  // fp32 converter
+  auto fp32_quantizer = IndexFactory::CreateQuantizer("Fp32Quantizer");
+  ASSERT_TRUE(!!fp32_quantizer);
+  ASSERT_EQ(0u, fp32_quantizer->init(meta, Params()));
+
+  auto &fp32_convert_meta = fp32_quantizer->meta();
+
+  // int8 converter
+  auto quantizer = IndexFactory::CreateQuantizer("Int8Quantizer");
+  ASSERT_TRUE(!!quantizer);
+  ASSERT_EQ(0u, quantizer->init(meta, Params()));
+
+  auto &convert_meta = quantizer->meta();
+
+  auto func_float32 = get_distance_func(
+      turbo::MetricType::kCosine, turbo::DataType::kFp32,
+      turbo::QuantizeType::kDefault, turbo::CpuArchType::kAuto);
+
+  auto func_avx512vnni = get_distance_func(
+      turbo::MetricType::kCosine, turbo::DataType::kInt8,
+      turbo::QuantizeType::kDefault, turbo::CpuArchType::kAVX512VNNI);
+
+  auto func_avx2 = get_distance_func(
+      turbo::MetricType::kCosine, turbo::DataType::kInt8,
+      turbo::QuantizeType::kDefault, turbo::CpuArchType::kAVX2);
+
+  auto func_sse = get_distance_func(
+      turbo::MetricType::kCosine, turbo::DataType::kInt8,
+      turbo::QuantizeType::kDefault, turbo::CpuArchType::kSSE);
+
+  auto func_scalar = get_distance_func(
+      turbo::MetricType::kCosine, turbo::DataType::kInt8,
+      turbo::QuantizeType::kDefault, turbo::CpuArchType::kScalar);
+
+  ailego::NumericalVector<float> query_vec(DIMENSION);
+  for (size_t j = 0; j < DIMENSION; ++j) {
+    query_vec[j] = dist(gen);
+  }
+
+  IndexQueryMeta qmeta;
+  qmeta.set_meta(IndexMeta::DT_FP32, DIMENSION);
+  IndexQueryMeta fp32_qmeta_quantizer;
+
+  std::string fp32_query_out;
+  ASSERT_EQ(0,
+            fp32_quantizer->quantize(query_vec.data(), qmeta, &fp32_query_out,
+                                     &fp32_qmeta_quantizer));
+  ASSERT_EQ(fp32_qmeta_quantizer.dimension(), fp32_convert_meta.dimension());
+
+  IndexQueryMeta qmeta_quantizer;
+
+  std::string query_out;
+  ASSERT_EQ(0, quantizer->quantize(query_vec.data(), qmeta, &query_out,
+                                   &qmeta_quantizer));
+  ASSERT_EQ(qmeta_quantizer.dimension(), convert_meta.dimension());
+
+  for (size_t i = 0; i < COUNT; ++i) {
+    ailego::NumericalVector<float> doc_vec(DIMENSION);
+    for (size_t j = 0; j < DIMENSION; ++j) {
+      doc_vec[j] = dist(gen);
+    }
+
+    float score_float32{0.0f};
+    float score_scalar{0.0f};
+    float score_avx512vnni{0.0f};
+    float score_avx2{0.0f};
+    float score_sse{0.0f};
+
+    std::string fp32_doc_out;
+    ASSERT_EQ(0, fp32_quantizer->quantize(doc_vec.data(), qmeta, &fp32_doc_out,
+                                          &fp32_qmeta_quantizer));
+    ASSERT_EQ(fp32_qmeta_quantizer.dimension(), fp32_convert_meta.dimension());
+
+    func_float32(fp32_query_out.data(), fp32_doc_out.data(),
+                 fp32_qmeta_quantizer.dimension(), &score_float32);
+
+    std::string doc_out;
+    ASSERT_EQ(0, quantizer->quantize(doc_vec.data(), qmeta, &doc_out,
+                                     &qmeta_quantizer));
+    ASSERT_EQ(qmeta_quantizer.dimension(), convert_meta.dimension());
+
+    func_scalar(doc_out.data(), query_out.data(), DIMENSION, &score_scalar);
+
+    func_avx512vnni(doc_out.data(), query_out.data(), DIMENSION,
+                    &score_avx512vnni);
+
+    func_avx2(doc_out.data(), query_out.data(), DIMENSION, &score_avx2);
+
+    func_sse(doc_out.data(), query_out.data(), DIMENSION, &score_sse);
+
+    ASSERT_NEAR(score_float32, score_avx512vnni, 0.2 * DIMENSION);
+    ASSERT_NEAR(score_float32, score_avx2, 0.2 * DIMENSION);
+    ASSERT_NEAR(score_float32, score_sse, 0.2 * DIMENSION);
+    ASSERT_NEAR(score_float32, score_scalar, 0.2 * DIMENSION);
+    ASSERT_NEAR(score_scalar, score_avx2, 0.001);
+    ASSERT_NEAR(score_scalar, score_sse, 0.001);
+  }
+}
+
+// Target Test Type: avx2, sse, scalar
+TEST(QuantizedIntegerMetric, TestInt4Cosine) {
+  std::mt19937 gen(15583);
+  std::uniform_real_distribution<float> dist(-1.0, 2.0);
+
+  const size_t DIMENSION = std::uniform_int_distribution<int>(1, 128)(gen) * 2;
+  const size_t COUNT = 1024;
+
+  IndexMeta meta(IndexMeta::DT_FP32, DIMENSION);
+  meta.set_metric("Cosine", 0, Params());
+
+  // fp32 converter
+  auto fp32_quantizer = IndexFactory::CreateQuantizer("Fp32Quantizer");
+  ASSERT_TRUE(!!fp32_quantizer);
+  ASSERT_EQ(0u, fp32_quantizer->init(meta, Params()));
+
+  auto &fp32_convert_meta = fp32_quantizer->meta();
+
+  // int4 converter
+  auto quantizer = IndexFactory::CreateQuantizer("Int4Quantizer");
+  ASSERT_TRUE(!!quantizer);
+  ASSERT_EQ(0u, quantizer->init(meta, Params()));
+  auto &convert_meta = quantizer->meta();
+
+  auto func_float32 = get_distance_func(
+      turbo::MetricType::kCosine, turbo::DataType::kFp32,
+      turbo::QuantizeType::kDefault, turbo::CpuArchType::kAuto);
+
+  auto func_avx2 = get_distance_func(
+      turbo::MetricType::kCosine, turbo::DataType::kInt4,
+      turbo::QuantizeType::kDefault, turbo::CpuArchType::kAVX2);
+
+  auto func_sse = get_distance_func(
+      turbo::MetricType::kCosine, turbo::DataType::kInt4,
+      turbo::QuantizeType::kDefault, turbo::CpuArchType::kSSE);
+
+  auto func_scalar = get_distance_func(
+      turbo::MetricType::kCosine, turbo::DataType::kInt4,
+      turbo::QuantizeType::kDefault, turbo::CpuArchType::kScalar);
+
+  ailego::NumericalVector<float> query_vec(DIMENSION);
+  for (size_t j = 0; j < DIMENSION; ++j) {
+    query_vec[j] = dist(gen);
+  }
+
+  IndexQueryMeta qmeta;
+  qmeta.set_meta(IndexMeta::DT_FP32, DIMENSION);
+  IndexQueryMeta fp32_qmeta_quantizer;
+
+  std::string fp32_query_out;
+  ASSERT_EQ(0,
+            fp32_quantizer->quantize(query_vec.data(), qmeta, &fp32_query_out,
+                                     &fp32_qmeta_quantizer));
+  ASSERT_EQ(fp32_qmeta_quantizer.dimension(), fp32_convert_meta.dimension());
+
+  IndexQueryMeta qmeta_quantizer;
+
+  std::string query_out;
+  ASSERT_EQ(0, quantizer->quantize(query_vec.data(), qmeta, &query_out,
+                                   &qmeta_quantizer));
+  ASSERT_EQ(qmeta_quantizer.dimension(), convert_meta.dimension());
+
+  for (size_t i = 0; i < COUNT; ++i) {
+    ailego::NumericalVector<float> doc_vec(DIMENSION);
+    for (size_t j = 0; j < DIMENSION; ++j) {
+      doc_vec[j] = dist(gen);
+    }
+
+    float score_float32{0.0f};
+    float score_scalar{0.0f};
+    float score_avx2{0.0f};
+    float score_sse{0.0f};
+
+    std::string fp32_doc_out;
+    ASSERT_EQ(0, fp32_quantizer->quantize(doc_vec.data(), qmeta, &fp32_doc_out,
+                                          &fp32_qmeta_quantizer));
+    ASSERT_EQ(fp32_qmeta_quantizer.dimension(), fp32_convert_meta.dimension());
+
+    func_float32(fp32_query_out.data(), fp32_doc_out.data(),
+                 fp32_qmeta_quantizer.dimension(), &score_float32);
+
+    std::string doc_out;
+    ASSERT_EQ(0, quantizer->quantize(doc_vec.data(), qmeta, &doc_out,
+                                     &qmeta_quantizer));
+    ASSERT_EQ(qmeta_quantizer.dimension(), convert_meta.dimension());
+
+    func_scalar(doc_out.data(), query_out.data(), DIMENSION, &score_scalar);
+
+    func_avx2(doc_out.data(), query_out.data(), DIMENSION, &score_avx2);
+
+    func_sse(doc_out.data(), query_out.data(), DIMENSION, &score_sse);
+
+    if (i < 3) {
+      std::cerr << "[INT4 Cosine i=" << i << "] f32=" << score_float32
+                << " scalar=" << score_scalar << " avx2=" << score_avx2
+                << " sse=" << score_sse << std::endl;
+    }
+
+    ASSERT_NEAR(score_float32, score_avx2, 0.2 * DIMENSION);
+    ASSERT_NEAR(score_float32, score_sse, 0.2 * DIMENSION);
+    ASSERT_NEAR(score_float32, score_scalar, 0.2 * DIMENSION);
+    ASSERT_NEAR(score_scalar, score_avx2, 0.001);
+    ASSERT_NEAR(score_scalar, score_sse, 0.001);
+  }
+}
+
+#if 0
+// Target Test Type: avx2, sse, scalar
+TEST(QuantizedIntegerMetric, TestInt8InnerProductBatch) {
+  std::mt19937 gen(15583);
+  std::uniform_real_distribution<float> dist(-1.0, 2.0);
+
+  const size_t DIMENSION = std::uniform_int_distribution<int>(1, 128)(gen);
+  const size_t COUNT = 1024;
+  const size_t BATCH_SIZE = 16;
+
+  auto quantizer = IndexFactory::CreateQuantizer("RecordInt8Quantizer");
+  IndexMeta meta(IndexMeta::DT_FP32, DIMENSION);
+  meta.set_metric("InnerProduct", 0, Params());
+  ASSERT_TRUE(!!quantizer);
+  ASSERT_EQ(0u, quantizer->init(meta, Params()));
+  auto &convert_meta = quantizer->meta();
+
+  auto batch_func_float32 = get_batch_distance_func(
+      turbo::MetricType::kInnerProduct, turbo::DataType::kFp32,
+      turbo::QuantizeType::kDefault, turbo::CpuArchType::kAuto);
+
+  auto batch_func_avx512vnni = get_batch_distance_func(
+      turbo::MetricType::kInnerProduct, turbo::DataType::kInt8,
+      turbo::QuantizeType::kDefault, turbo::CpuArchType::kAVX512VNNI);
+
+  auto batch_func_avx2 = get_batch_distance_func(
+      turbo::MetricType::kInnerProduct, turbo::DataType::kInt8,
+      turbo::QuantizeType::kDefault, turbo::CpuArchType::kAVX2);
+
+  auto batch_func_sse = get_batch_distance_func(
+      turbo::MetricType::kInnerProduct, turbo::DataType::kInt8,
+      turbo::QuantizeType::kDefault, turbo::CpuArchType::kSSE);
+
+  auto batch_func_scalar = get_batch_distance_func(
+      turbo::MetricType::kInnerProduct, turbo::DataType::kInt8,
+      turbo::QuantizeType::kDefault, turbo::CpuArchType::kScalar);
+
+  ailego::NumericalVector<float> query_vec(DIMENSION);
+  for (size_t j = 0; j < DIMENSION; ++j) {
+    query_vec[j] = dist(gen);
+  }
+
+  IndexQueryMeta qmeta;
+  qmeta.set_meta(IndexMeta::DT_FP32, DIMENSION);
+  IndexQueryMeta qmeta_quantizer;
+
+  std::string query_out;
+  ASSERT_EQ(0, quantizer->quantize(query_vec.data(), qmeta, &query_out,
+                                   &qmeta_quantizer));
+  ASSERT_EQ(qmeta_quantizer.dimension(), convert_meta.dimension());
+
+  std::vector<ailego::NumericalVector<float>> doc_vecs;
+  std::vector<std::string> doc_outs;
+
+  for (size_t i = 0; i < COUNT; ++i) {
+    ailego::NumericalVector<float> doc_vec(DIMENSION);
+    for (size_t j = 0; j < DIMENSION; ++j) {
+      doc_vec[j] = dist(gen);
+    }
+
+    doc_vecs.push_back(doc_vec);
+
+    std::string doc_out;
+    ASSERT_EQ(0, quantizer->quantize(doc_vec.data(), qmeta, &doc_out,
+                                     &qmeta_quantizer));
+    ASSERT_EQ(qmeta_quantizer.dimension(), convert_meta.dimension());
+
+    doc_outs.push_back(doc_out);
+
+    if (doc_vecs.size() == BATCH_SIZE) {
+      std::vector<float> scores_float32(BATCH_SIZE, 0.0f);
+      std::vector<float> scores_scalar(BATCH_SIZE, 0.0f);
+      std::vector<float> scores_avx512vnni(BATCH_SIZE, 0.0f);
+      std::vector<float> scores_avx2(BATCH_SIZE, 0.0f);
+      std::vector<float> scores_sse(BATCH_SIZE, 0.0f);
+
+      // Build pointer arrays for batch functions
+      std::vector<const void *> float_ptrs(BATCH_SIZE);
+      std::vector<const void *> doc_ptrs(BATCH_SIZE);
+      for (size_t k = 0; k < BATCH_SIZE; ++k) {
+        float_ptrs[k] = doc_vecs[k].data();
+        doc_ptrs[k] = doc_outs[k].data();
+      }
+
+      batch_func_float32(float_ptrs.data(), query_vec.data(), BATCH_SIZE,
+                         DIMENSION, &scores_float32[0]);
+
+      batch_func_scalar(doc_ptrs.data(), query_out.data(), BATCH_SIZE,
+                        qmeta_quantizer.dimension(), &scores_scalar[0]);
+
+      batch_func_avx512vnni(doc_ptrs.data(), query_out.data(), BATCH_SIZE,
+                            qmeta_quantizer.dimension(), &scores_avx512vnni[0]);
+
+      batch_func_avx2(doc_ptrs.data(), query_out.data(), BATCH_SIZE,
+                      qmeta_quantizer.dimension(), &scores_avx2[0]);
+
+      batch_func_sse(doc_ptrs.data(), query_out.data(), BATCH_SIZE,
+                     qmeta_quantizer.dimension(), &scores_sse[0]);
+
+      for (size_t j = 0; j < BATCH_SIZE; ++j) {
+        ASSERT_NEAR(scores_float32[j], scores_avx512vnni[j], 0.2 * DIMENSION);
+        ASSERT_NEAR(scores_float32[j], scores_avx2[j], 0.2 * DIMENSION);
+        ASSERT_NEAR(scores_float32[j], scores_sse[j], 0.2 * DIMENSION);
+        ASSERT_NEAR(scores_float32[j], scores_scalar[j], 0.2 * DIMENSION);
+        ASSERT_NEAR(scores_scalar[j], scores_avx2[j], 0.001);
+        ASSERT_NEAR(scores_scalar[j], scores_sse[j], 0.001);
+      }
+
+      doc_outs.clear();
+      doc_vecs.clear();
+    }
+  }
+}
+
+// Target Test Type: avx2, sse, scalar
+TEST(QuantizedIntegerMetric, TestInt4InnerProductBatch) {
+  std::mt19937 gen(15583);
+  std::uniform_real_distribution<float> dist(-1.0, 2.0);
+
+  const size_t DIMENSION = std::uniform_int_distribution<int>(1, 128)(gen) * 2;
+  const size_t COUNT = 1024;
+  const size_t BATCH_SIZE = 16;
+
+  auto quantizer = IndexFactory::CreateQuantizer("RecordInt4Quantizer");
+  IndexMeta meta(IndexMeta::DT_FP32, DIMENSION);
+  meta.set_metric("InnerProduct", 0, Params());
+  ASSERT_TRUE(!!quantizer);
+  ASSERT_EQ(0u, quantizer->init(meta, Params()));
+  auto &convert_meta = quantizer->meta();
+
+  auto batch_func_float32 = get_batch_distance_func(
+      turbo::MetricType::kInnerProduct, turbo::DataType::kFp32,
+      turbo::QuantizeType::kDefault, turbo::CpuArchType::kAuto);
+
+  auto batch_func_avx2 = get_batch_distance_func(
+      turbo::MetricType::kInnerProduct, turbo::DataType::kInt4,
+      turbo::QuantizeType::kDefault, turbo::CpuArchType::kAVX2);
+
+  auto batch_func_sse = get_batch_distance_func(
+      turbo::MetricType::kInnerProduct, turbo::DataType::kInt4,
+      turbo::QuantizeType::kDefault, turbo::CpuArchType::kSSE);
+
+  auto batch_func_scalar = get_batch_distance_func(
+      turbo::MetricType::kInnerProduct, turbo::DataType::kInt4,
+      turbo::QuantizeType::kDefault, turbo::CpuArchType::kScalar);
+
+  ailego::NumericalVector<float> query_vec(DIMENSION);
+  for (size_t j = 0; j < DIMENSION; ++j) {
+    query_vec[j] = dist(gen);
+  }
+
+  IndexQueryMeta qmeta;
+  qmeta.set_meta(IndexMeta::DT_FP32, DIMENSION);
+  IndexQueryMeta qmeta_quantizer;
+
+  std::string query_out;
+  ASSERT_EQ(0, quantizer->quantize(query_vec.data(), qmeta, &query_out,
+                                   &qmeta_quantizer));
+  ASSERT_EQ(qmeta_quantizer.dimension(), convert_meta.dimension());
+
+  std::vector<ailego::NumericalVector<float>> doc_vecs;
+  std::vector<std::string> doc_outs;
+
+  for (size_t i = 0; i < COUNT; ++i) {
+    ailego::NumericalVector<float> doc_vec(DIMENSION);
+    for (size_t j = 0; j < DIMENSION; ++j) {
+      doc_vec[j] = dist(gen);
+    }
+
+    doc_vecs.push_back(doc_vec);
+
+    std::string doc_out;
+    ASSERT_EQ(0, quantizer->quantize(doc_vec.data(), qmeta, &doc_out,
+                                     &qmeta_quantizer));
+    ASSERT_EQ(qmeta_quantizer.dimension(), convert_meta.dimension());
+
+    doc_outs.push_back(doc_out);
+
+    if (doc_outs.size() == BATCH_SIZE) {
+      std::vector<float> scores_float32(BATCH_SIZE, 0.0f);
+      std::vector<float> scores_scalar(BATCH_SIZE, 0.0f);
+      std::vector<float> scores_avx2(BATCH_SIZE, 0.0f);
+      std::vector<float> scores_sse(BATCH_SIZE, 0.0f);
+
+      // Build pointer arrays for batch functions
+      std::vector<const void *> float_ptrs(BATCH_SIZE);
+      std::vector<const void *> doc_ptrs(BATCH_SIZE);
+      for (size_t k = 0; k < BATCH_SIZE; ++k) {
+        float_ptrs[k] = doc_vecs[k].data();
+        doc_ptrs[k] = doc_outs[k].data();
+      }
+
+      batch_func_float32(float_ptrs.data(), query_vec.data(), BATCH_SIZE,
+                         DIMENSION, &scores_float32[0]);
+
+      batch_func_scalar(doc_ptrs.data(), query_out.data(), BATCH_SIZE,
+                        qmeta_quantizer.dimension(), &scores_scalar[0]);
+
+      batch_func_avx2(doc_ptrs.data(), query_out.data(), BATCH_SIZE,
+                      qmeta_quantizer.dimension(), &scores_avx2[0]);
+
+      batch_func_sse(doc_ptrs.data(), query_out.data(), BATCH_SIZE,
+                     qmeta_quantizer.dimension(), &scores_sse[0]);
+
+      for (size_t j = 0; j < BATCH_SIZE; ++j) {
+        ASSERT_NEAR(scores_float32[j], scores_avx2[j], 0.2 * DIMENSION);
+        ASSERT_NEAR(scores_float32[j], scores_sse[j], 0.2 * DIMENSION);
+        ASSERT_NEAR(scores_float32[j], scores_scalar[j], 0.2 * DIMENSION);
+        ASSERT_NEAR(scores_scalar[j], scores_avx2[j], 0.001);
+        ASSERT_NEAR(scores_scalar[j], scores_sse[j], 0.001);
+      }
+
+      doc_outs.clear();
+      doc_vecs.clear();
+    }
+  }
+}
+
+// Target Test Type: avx2, sse, scalar
+TEST(QuantizedIntegerMetric, TestInt8SquaredEuclideanBatch) {
+  std::mt19937 gen(15583);
+  std::uniform_real_distribution<float> dist(-1.0, 2.0);
+
+  const size_t DIMENSION = std::uniform_int_distribution<int>(1, 128)(gen);
+  const size_t COUNT = 1024;
+  const size_t BATCH_SIZE = 16;
+
+  auto quantizer = IndexFactory::CreateQuantizer("RecordInt8Quantizer");
+  IndexMeta meta(IndexMeta::DT_FP32, DIMENSION);
+  meta.set_metric("SquaredEuclidean", 0, Params());
+  ASSERT_TRUE(!!quantizer);
+  ASSERT_EQ(0u, quantizer->init(meta, Params()));
+  auto &convert_meta = quantizer->meta();
+
+  auto batch_func_float32 = get_batch_distance_func(
+      turbo::MetricType::kSquaredEuclidean, turbo::DataType::kFp32,
+      turbo::QuantizeType::kDefault, turbo::CpuArchType::kAuto);
+
+  auto batch_func_avx2 = get_batch_distance_func(
+      turbo::MetricType::kSquaredEuclidean, turbo::DataType::kInt8,
+      turbo::QuantizeType::kDefault, turbo::CpuArchType::kAVX2);
+
+  auto batch_func_sse = get_batch_distance_func(
+      turbo::MetricType::kSquaredEuclidean, turbo::DataType::kInt8,
+      turbo::QuantizeType::kDefault, turbo::CpuArchType::kSSE);
+
+  auto batch_func_scalar = get_batch_distance_func(
+      turbo::MetricType::kSquaredEuclidean, turbo::DataType::kInt8,
+      turbo::QuantizeType::kDefault, turbo::CpuArchType::kScalar);
+
+  ailego::NumericalVector<float> query_vec(DIMENSION);
+  for (size_t j = 0; j < DIMENSION; ++j) {
+    query_vec[j] = dist(gen);
+  }
+
+  IndexQueryMeta qmeta;
+  qmeta.set_meta(IndexMeta::DT_FP32, DIMENSION);
+  IndexQueryMeta qmeta_quantizer;
+
+  std::string query_out;
+  ASSERT_EQ(0, quantizer->quantize(query_vec.data(), qmeta, &query_out,
+                                   &qmeta_quantizer));
+  ASSERT_EQ(qmeta_quantizer.dimension(), convert_meta.dimension());
+
+  std::vector<ailego::NumericalVector<float>> doc_vecs;
+  std::vector<std::string> doc_outs;
+
+  for (size_t i = 0; i < COUNT; ++i) {
+    ailego::NumericalVector<float> doc_vec(DIMENSION);
+    for (size_t j = 0; j < DIMENSION; ++j) {
+      doc_vec[j] = dist(gen);
+    }
+
+    doc_vecs.push_back(doc_vec);
+
+    std::string doc_out;
+    ASSERT_EQ(0, quantizer->quantize(doc_vec.data(), qmeta, &doc_out,
+                                     &qmeta_quantizer));
+    ASSERT_EQ(qmeta_quantizer.dimension(), convert_meta.dimension());
+
+    doc_outs.push_back(doc_out);
+
+    if (doc_outs.size() == BATCH_SIZE) {
+      std::vector<float> scores_float32(BATCH_SIZE, 0.0f);
+      std::vector<float> scores_scalar(BATCH_SIZE, 0.0f);
+      std::vector<float> scores_avx2(BATCH_SIZE, 0.0f);
+      std::vector<float> scores_sse(BATCH_SIZE, 0.0f);
+
+      // Build pointer arrays for batch functions
+      std::vector<const void *> float_ptrs(BATCH_SIZE);
+      std::vector<const void *> doc_ptrs(BATCH_SIZE);
+      for (size_t k = 0; k < BATCH_SIZE; ++k) {
+        float_ptrs[k] = doc_vecs[k].data();
+        doc_ptrs[k] = doc_outs[k].data();
+      }
+
+      batch_func_float32(float_ptrs.data(), query_vec.data(), BATCH_SIZE,
+                         DIMENSION, &scores_float32[0]);
+
+      batch_func_scalar(doc_ptrs.data(), query_out.data(), BATCH_SIZE,
+                        qmeta_quantizer.dimension(), &scores_scalar[0]);
+
+      batch_func_avx2(doc_ptrs.data(), query_out.data(), BATCH_SIZE,
+                      qmeta_quantizer.dimension(), &scores_avx2[0]);
+
+      batch_func_sse(doc_ptrs.data(), query_out.data(), BATCH_SIZE,
+                     qmeta_quantizer.dimension(), &scores_sse[0]);
+
+      for (size_t j = 0; j < BATCH_SIZE; ++j) {
+        ASSERT_NEAR(scores_float32[j], scores_avx2[j], 0.2 * DIMENSION);
+        ASSERT_NEAR(scores_float32[j], scores_sse[j], 0.2 * DIMENSION);
+        ASSERT_NEAR(scores_float32[j], scores_scalar[j], 0.2 * DIMENSION);
+        ASSERT_NEAR(scores_scalar[j], scores_avx2[j], 0.001);
+        ASSERT_NEAR(scores_scalar[j], scores_sse[j], 0.001);
+      }
+
+      doc_outs.clear();
+      doc_vecs.clear();
+    }
+  }
+}
+
+// Target Test Type: avx2, sse, scalar
+TEST(QuantizedIntegerMetric, TestInt4SquaredEuclideanBatch) {
+  std::mt19937 gen(15583);
+  std::uniform_real_distribution<float> dist(-1.0, 2.0);
+
+  const size_t DIMENSION = std::uniform_int_distribution<int>(1, 128)(gen) * 2;
+  const size_t COUNT = 1024;
+  const size_t BATCH_SIZE = 16;
+
+  auto quantizer = IndexFactory::CreateQuantizer("RecordInt4Quantizer");
+  IndexMeta meta(IndexMeta::DT_FP32, DIMENSION);
+  meta.set_metric("SquaredEuclidean", 0, Params());
+  ASSERT_TRUE(!!quantizer);
+  ASSERT_EQ(0u, quantizer->init(meta, Params()));
+  auto &convert_meta = quantizer->meta();
+
+  auto batch_func_float32 = get_batch_distance_func(
+      turbo::MetricType::kSquaredEuclidean, turbo::DataType::kFp32,
+      turbo::QuantizeType::kDefault, turbo::CpuArchType::kAuto);
+
+  auto batch_func_avx2 = get_batch_distance_func(
+      turbo::MetricType::kSquaredEuclidean, turbo::DataType::kInt4,
+      turbo::QuantizeType::kDefault, turbo::CpuArchType::kAVX2);
+
+  auto batch_func_sse = get_batch_distance_func(
+      turbo::MetricType::kSquaredEuclidean, turbo::DataType::kInt4,
+      turbo::QuantizeType::kDefault, turbo::CpuArchType::kSSE);
+
+  auto batch_func_scalar = get_batch_distance_func(
+      turbo::MetricType::kSquaredEuclidean, turbo::DataType::kInt4,
+      turbo::QuantizeType::kDefault, turbo::CpuArchType::kScalar);
+
+  ailego::NumericalVector<float> query_vec(DIMENSION);
+  for (size_t j = 0; j < DIMENSION; ++j) {
+    query_vec[j] = dist(gen);
+  }
+
+  IndexQueryMeta qmeta;
+  qmeta.set_meta(IndexMeta::DT_FP32, DIMENSION);
+  IndexQueryMeta qmeta_quantizer;
+
+  std::string query_out;
+  ASSERT_EQ(0, quantizer->quantize(query_vec.data(), qmeta, &query_out,
+                                   &qmeta_quantizer));
+  ASSERT_EQ(qmeta_quantizer.dimension(), convert_meta.dimension());
+
+  std::vector<ailego::NumericalVector<float>> doc_vecs;
+  std::vector<std::string> doc_outs;
+
+  for (size_t i = 0; i < COUNT; ++i) {
+    ailego::NumericalVector<float> doc_vec(DIMENSION);
+    for (size_t j = 0; j < DIMENSION; ++j) {
+      doc_vec[j] = dist(gen);
+    }
+
+    doc_vecs.push_back(doc_vec);
+
+    std::string doc_out;
+    ASSERT_EQ(0, quantizer->quantize(doc_vec.data(), qmeta, &doc_out,
+                                     &qmeta_quantizer));
+    ASSERT_EQ(qmeta_quantizer.dimension(), convert_meta.dimension());
+
+    doc_outs.push_back(doc_out);
+
+    if (doc_outs.size() == BATCH_SIZE) {
+      std::vector<float> scores_float32(BATCH_SIZE, 0.0f);
+      std::vector<float> scores_scalar(BATCH_SIZE, 0.0f);
+      std::vector<float> scores_avx2(BATCH_SIZE, 0.0f);
+      std::vector<float> scores_sse(BATCH_SIZE, 0.0f);
+
+      // Build pointer arrays for batch functions
+      std::vector<const void *> float_ptrs(BATCH_SIZE);
+      std::vector<const void *> doc_ptrs(BATCH_SIZE);
+      for (size_t k = 0; k < BATCH_SIZE; ++k) {
+        float_ptrs[k] = doc_vecs[k].data();
+        doc_ptrs[k] = doc_outs[k].data();
+      }
+
+      batch_func_float32(float_ptrs.data(), query_vec.data(), BATCH_SIZE,
+                         DIMENSION, &scores_float32[0]);
+
+      batch_func_scalar(doc_ptrs.data(), query_out.data(), BATCH_SIZE,
+                        qmeta_quantizer.dimension(), &scores_scalar[0]);
+
+      batch_func_avx2(doc_ptrs.data(), query_out.data(), BATCH_SIZE,
+                      qmeta_quantizer.dimension(), &scores_avx2[0]);
+
+      batch_func_sse(doc_ptrs.data(), query_out.data(), BATCH_SIZE,
+                     qmeta_quantizer.dimension(), &scores_sse[0]);
+
+      for (size_t j = 0; j < BATCH_SIZE; ++j) {
+        ASSERT_NEAR(scores_float32[j], scores_avx2[j], 0.2 * DIMENSION);
+        ASSERT_NEAR(scores_float32[j], scores_sse[j], 0.2 * DIMENSION);
+        ASSERT_NEAR(scores_float32[j], scores_scalar[j], 0.2 * DIMENSION);
+        ASSERT_NEAR(scores_float32[j], scores_avx2[j], 0.001);
+        ASSERT_NEAR(scores_float32[j], scores_sse[j], 0.001);
+      }
+
+      doc_outs.clear();
+      doc_vecs.clear();
+    }
+  }
+}
+
+// Target Test Type: avx2, sse, scalar
+TEST(QuantizedIntegerMetric, TestInt8CosineBatch) {
+  std::mt19937 gen(15583);
+  std::uniform_real_distribution<float> dist(-1.0, 2.0);
+
+  const size_t DIMENSION = std::uniform_int_distribution<int>(1, 128)(gen);
+  const size_t COUNT = 1024;
+  const size_t BATCH_SIZE = 16;
+
+  IndexMeta meta(IndexMeta::DT_FP32, DIMENSION);
+  meta.set_metric("Cosine", 0, Params());
+
+  // fp32 converter
+  auto fp32_converter = IndexFactory::CreateQuantizer("Fp32Quantizer  ");
+  ASSERT_TRUE(!!fp32_converter);
+  ASSERT_EQ(0u, fp32_converter->init(meta, Params()));
+
+  auto &fp32_convert_meta = fp32_converter->meta();
+
+  // int8 converter
+  auto quantizer = IndexFactory::CreateQuantizer("CosineInt8Quantizer");
+  ASSERT_TRUE(!!quantizer);
+  ASSERT_EQ(0u, quantizer->init(meta, Params()));
+
+  auto &convert_meta = quantizer->meta();
+
+  auto batch_func_float32 = get_batch_distance_func(
+      turbo::MetricType::kCosine, turbo::DataType::kFp32,
+      turbo::QuantizeType::kDefault, turbo::CpuArchType::kAuto);
+
+  auto batch_func_avx512vnni = get_batch_distance_func(
+      turbo::MetricType::kCosine, turbo::DataType::kInt8,
+      turbo::QuantizeType::kDefault, turbo::CpuArchType::kAVX512VNNI);
+
+  auto batch_func_avx2 = get_batch_distance_func(
+      turbo::MetricType::kCosine, turbo::DataType::kInt8,
+      turbo::QuantizeType::kDefault, turbo::CpuArchType::kAVX2);
+
+  auto batch_func_sse = get_batch_distance_func(
+      turbo::MetricType::kCosine, turbo::DataType::kInt8,
+      turbo::QuantizeType::kDefault, turbo::CpuArchType::kSSE);
+
+  auto batch_func_scalar = get_batch_distance_func(
+      turbo::MetricType::kCosine, turbo::DataType::kInt8,
+      turbo::QuantizeType::kDefault, turbo::CpuArchType::kScalar);
+
+  ailego::NumericalVector<float> query_vec(DIMENSION);
+  for (size_t j = 0; j < DIMENSION; ++j) {
+    query_vec[j] = dist(gen);
+  }
+
+  IndexQueryMeta qmeta;
+  qmeta.set_meta(IndexMeta::DT_FP32, DIMENSION);
+  IndexQueryMeta fp32_qmeta_quantizer;
+
+  std::string fp32_query_out;
+  ASSERT_EQ(0,
+            fp32_converter->quantize(query_vec.data(), qmeta, &fp32_query_out,
+                                     &fp32_qmeta_quantizer));
+  ASSERT_EQ(fp32_qmeta_quantizer.dimension(), fp32_convert_meta.dimension());
+
+  IndexQueryMeta qmeta_quantizer;
+  std::string query_out;
+  ASSERT_EQ(0, quantizer->quantize(query_vec.data(), qmeta, &query_out,
+                                   &qmeta_quantizer));
+  ASSERT_EQ(qmeta_quantizer.dimension(), convert_meta.dimension());
+
+  std::vector<ailego::NumericalVector<float>> doc_vecs;
+  std::vector<std::string> doc_outs;
+  std::vector<std::string> fp32_doc_outs;
+
+  for (size_t i = 0; i < COUNT; ++i) {
+    ailego::NumericalVector<float> doc_vec(DIMENSION);
+    for (size_t j = 0; j < DIMENSION; ++j) {
+      doc_vec[j] = dist(gen);
+    }
+
+    doc_vecs.push_back(doc_vec);
+
+    std::string fp32_doc_out;
+    ASSERT_EQ(0, fp32_converter->quantize(doc_vec.data(), qmeta, &fp32_doc_out,
+                                          &fp32_qmeta_quantizer));
+    ASSERT_EQ(fp32_qmeta_quantizer.dimension(), fp32_convert_meta.dimension());
+
+    fp32_doc_outs.push_back(fp32_doc_out);
+
+    std::string doc_out;
+    ASSERT_EQ(0, quantizer->quantize(doc_vec.data(), qmeta, &doc_out,
+                                     &qmeta_quantizer));
+    ASSERT_EQ(qmeta_quantizer.dimension(), convert_meta.dimension());
+
+    doc_outs.push_back(doc_out);
+
+    if (doc_outs.size() == BATCH_SIZE) {
+      std::vector<float> score_float32(BATCH_SIZE, 0.0f);
+      std::vector<float> score_scalar(BATCH_SIZE, 0.0f);
+      std::vector<float> score_avx512vnni(BATCH_SIZE, 0.0f);
+      std::vector<float> score_avx2(BATCH_SIZE, 0.0f);
+      std::vector<float> score_sse(BATCH_SIZE, 0.0f);
+
+      // Build pointer arrays for batch functions
+      std::vector<const void *> fp32_doc_ptrs(BATCH_SIZE);
+      std::vector<const void *> doc_ptrs(BATCH_SIZE);
+      for (size_t k = 0; k < BATCH_SIZE; ++k) {
+        fp32_doc_ptrs[k] = fp32_doc_outs[k].data();
+        doc_ptrs[k] = doc_outs[k].data();
+      }
+
+      batch_func_float32(fp32_doc_ptrs.data(), fp32_query_out.data(),
+                         BATCH_SIZE, fp32_qmeta_quantizer.dimension(),
+                         &score_float32[0]);
+
+      batch_func_scalar(doc_ptrs.data(), query_out.data(), BATCH_SIZE,
+                        qmeta_quantizer.dimension(), &score_scalar[0]);
+
+      batch_func_avx512vnni(doc_ptrs.data(), query_out.data(), BATCH_SIZE,
+                            qmeta_quantizer.dimension(), &score_avx512vnni[0]);
+
+      batch_func_avx2(doc_ptrs.data(), query_out.data(), BATCH_SIZE,
+                      qmeta_quantizer.dimension(), &score_avx2[0]);
+
+      batch_func_sse(doc_ptrs.data(), query_out.data(), BATCH_SIZE,
+                     qmeta_quantizer.dimension(), &score_sse[0]);
+
+      for (size_t j = 0; j < BATCH_SIZE; ++j) {
+        ASSERT_NEAR(score_float32[j], score_avx512vnni[j], 0.2 * DIMENSION);
+        ASSERT_NEAR(score_float32[j], score_avx2[j], 0.2 * DIMENSION);
+        ASSERT_NEAR(score_float32[j], score_sse[j], 0.2 * DIMENSION);
+        ASSERT_NEAR(score_float32[j], score_scalar[j], 0.2 * DIMENSION);
+        ASSERT_NEAR(score_scalar[j], score_avx2[j], 0.001);
+        ASSERT_NEAR(score_scalar[j], score_sse[j], 0.001);
+      }
+
+      doc_outs.clear();
+      doc_vecs.clear();
+      fp32_doc_outs.clear();
+    }
+  }
+}
+
+// Target Test Type: avx2, sse, scalar
+TEST(QuantizedIntegerMetric, TestInt4CosineBatch) {
+  std::mt19937 gen(15583);
+  std::uniform_real_distribution<float> dist(-1.0, 2.0);
+
+  const size_t DIMENSION = std::uniform_int_distribution<int>(1, 128)(gen) * 2;
+  const size_t COUNT = 1024;
+  const size_t BATCH_SIZE = 16;
+
+  IndexMeta meta(IndexMeta::DT_FP32, DIMENSION);
+  meta.set_metric("Cosine", 0, Params());
+
+  // fp32 converter
+  auto fp32_quantizer = IndexFactory::CreateQuantizer("Fp32Quantizer");
+  ASSERT_TRUE(!!fp32_quantizer);
+  ASSERT_EQ(0u, fp32_quantizer->init(meta, Params()));
+
+  auto &fp32_convert_meta = fp32_quantizer->meta();
+
+  // int4 converter
+  auto quantizer = IndexFactory::CreateQuantizer("CosineInt4Quantizer");
+  ASSERT_TRUE(!!quantizer);
+  ASSERT_EQ(0u, quantizer->init(meta, Params()));
+  auto &convert_meta = quantizer->meta();
+
+  auto batch_func_float32 = get_batch_distance_func(
+      turbo::MetricType::kCosine, turbo::DataType::kFp32,
+      turbo::QuantizeType::kDefault, turbo::CpuArchType::kAuto);
+
+  auto batch_func_avx2 = get_batch_distance_func(
+      turbo::MetricType::kCosine, turbo::DataType::kInt4,
+      turbo::QuantizeType::kDefault, turbo::CpuArchType::kAVX2);
+
+  auto batch_func_sse = get_batch_distance_func(
+      turbo::MetricType::kCosine, turbo::DataType::kInt4,
+      turbo::QuantizeType::kDefault, turbo::CpuArchType::kSSE);
+
+  auto batch_func_scalar = get_batch_distance_func(
+      turbo::MetricType::kCosine, turbo::DataType::kInt4,
+      turbo::QuantizeType::kDefault, turbo::CpuArchType::kScalar);
+
+  ailego::NumericalVector<float> query_vec(DIMENSION);
+  for (size_t j = 0; j < DIMENSION; ++j) {
+    query_vec[j] = dist(gen);
+  }
+
+  IndexQueryMeta qmeta;
+  qmeta.set_meta(IndexMeta::DT_FP32, DIMENSION);
+  IndexQueryMeta fp32_qmeta_quantizer;
+
+  std::string fp32_query_out;
+  ASSERT_EQ(0,
+            fp32_quantizer->quantize(query_vec.data(), qmeta, &fp32_query_out,
+                                     &fp32_qmeta_quantizer));
+  ASSERT_EQ(fp32_qmeta_quantizer.dimension(), fp32_convert_meta.dimension());
+
+  IndexQueryMeta qmeta_quantizer;
+  std::string query_out;
+  ASSERT_EQ(0, quantizer->quantize(query_vec.data(), qmeta, &query_out,
+                                   &qmeta_quantizer));
+  ASSERT_EQ(qmeta_quantizer.dimension(), convert_meta.dimension());
+
+  std::vector<ailego::NumericalVector<float>> doc_vecs;
+  std::vector<std::string> doc_outs;
+  std::vector<std::string> fp32_doc_outs;
+
+  for (size_t i = 0; i < COUNT; ++i) {
+    ailego::NumericalVector<float> doc_vec(DIMENSION);
+    for (size_t j = 0; j < DIMENSION; ++j) {
+      doc_vec[j] = dist(gen);
+    }
+
+    doc_vecs.push_back(doc_vec);
+
+    std::string fp32_doc_out;
+    ASSERT_EQ(0, fp32_quantizer->quantize(doc_vec.data(), qmeta, &fp32_doc_out,
+                                          &fp32_qmeta_quantizer));
+    ASSERT_EQ(fp32_qmeta_quantizer.dimension(), fp32_convert_meta.dimension());
+
+    fp32_doc_outs.push_back(fp32_doc_out);
+
+    std::string doc_out;
+    ASSERT_EQ(0, quantizer->quantize(doc_vec.data(), qmeta, &doc_out,
+                                     &qmeta_quantizer));
+    ASSERT_EQ(qmeta_quantizer.dimension(), convert_meta.dimension());
+
+    doc_outs.push_back(doc_out);
+
+    if (doc_outs.size() == BATCH_SIZE) {
+      std::vector<float> score_float32(BATCH_SIZE, 0.0f);
+      std::vector<float> score_scalar(BATCH_SIZE, 0.0f);
+      std::vector<float> score_avx2(BATCH_SIZE, 0.0f);
+      std::vector<float> score_sse(BATCH_SIZE, 0.0f);
+
+      // Build pointer arrays for batch functions
+      std::vector<const void *> fp32_doc_ptrs(BATCH_SIZE);
+      std::vector<const void *> doc_ptrs(BATCH_SIZE);
+      for (size_t k = 0; k < BATCH_SIZE; ++k) {
+        fp32_doc_ptrs[k] = fp32_doc_outs[k].data();
+        doc_ptrs[k] = doc_outs[k].data();
+      }
+
+      batch_func_float32(fp32_doc_ptrs.data(), fp32_query_out.data(),
+                         BATCH_SIZE, fp32_qmeta_quantizer.dimension(),
+                         &score_float32[0]);
+
+      batch_func_scalar(doc_ptrs.data(), query_out.data(), BATCH_SIZE,
+                        qmeta_quantizer.dimension(), &score_scalar[0]);
+
+      batch_func_avx2(doc_ptrs.data(), query_out.data(), BATCH_SIZE,
+                      qmeta_quantizer.dimension(), &score_avx2[0]);
+
+      batch_func_sse(doc_ptrs.data(), query_out.data(), BATCH_SIZE,
+                     qmeta_quantizer.dimension(), &score_sse[0]);
+
+      for (size_t j = 0; j < BATCH_SIZE; ++j) {
+        ASSERT_NEAR(score_float32[j], score_avx2[j], 0.2 * DIMENSION);
+        ASSERT_NEAR(score_float32[j], score_sse[j], 0.2 * DIMENSION);
+        ASSERT_NEAR(score_float32[j], score_scalar[j], 0.2 * DIMENSION);
+        ASSERT_NEAR(score_scalar[j], score_avx2[j], 0.001);
+        ASSERT_NEAR(score_scalar[j], score_sse[j], 0.001);
+      }
+
+      doc_outs.clear();
+      doc_vecs.clear();
+      fp32_doc_outs.clear();
+    }
+  }
+}
+
+#endif
\ No newline at end of file
diff --git a/tests/turbo/quantizer/CMakeLists.txt b/tests/turbo/quantizer/CMakeLists.txt
new file mode 100644
index 000000000..8a3527d41
--- /dev/null
+++ b/tests/turbo/quantizer/CMakeLists.txt
@@ -0,0 +1,14 @@
+include(${PROJECT_ROOT_DIR}/cmake/bazel.cmake)
+
+file(GLOB_RECURSE ALL_TEST_SRCS *_test.cc)
+
+foreach(CC_SRCS ${ALL_TEST_SRCS})
+  get_filename_component(CC_TARGET ${CC_SRCS} NAME_WE)
+  cc_gtest(
+      NAME ${CC_TARGET}
+      STRICT
+      LIBS zvec_ailego core_framework core_metric core_quantizer zvec_turbo
+      SRCS ${CC_SRCS}
+      INCS . ${PROJECT_ROOT_DIR}/src/core/ ${PROJECT_ROOT_DIR}/src/turbo/
+    )
+endforeach()
\ No newline at end of file
diff --git a/tests/turbo/quantizer/turbo_fp16_quantizer_test.cc b/tests/turbo/quantizer/turbo_fp16_quantizer_test.cc
new file mode 100644
index 000000000..1753dbd1c
--- /dev/null
+++ b/tests/turbo/quantizer/turbo_fp16_quantizer_test.cc
@@ -0,0 +1,82 @@
+// Copyright 2025-present the zvec project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include <iostream>
+#include <gtest/gtest.h>
+#include <zvec/ailego/container/params.h>
+#include <zvec/turbo/turbo.h>
+#include "zvec/core/framework/index_factory.h"
+
+using namespace zvec;
+using namespace zvec::core;
+using namespace zvec::ailego;
+
+TEST(Fp16Quantizer, TestCosine) {
+  std::mt19937 gen(15583);
+  std::uniform_real_distribution<float> dist(0.0, 1.0);
+
+  const size_t COUNT = 10000;
+  const size_t DIMENSION = 12;
+
+  IndexMeta meta;
+  meta.set_meta(IndexMeta::DataType::DT_FP32, DIMENSION);
+
+  auto quantizer = IndexFactory::CreateQuantizer("Fp16Quantizer");
+  ASSERT_TRUE(quantizer);
+  zvec::ailego::Params params;
+  ASSERT_EQ(0u, quantizer->init(meta, params));
+
+  auto holder =
+      std::make_shared<MultiPassIndexHolder<IndexMeta::DataType::DT_FP32>>(
+          DIMENSION);
+  for (size_t i = 0; i < COUNT; ++i) {
+    zvec::ailego::NumericalVector<float> vec(DIMENSION);
+    for (size_t j = 0; j < DIMENSION; ++j) {
+      vec[j] = dist(gen);
+    }
+    holder->emplace(i + 1, vec);
+  }
+  EXPECT_EQ(COUNT, holder->count());
+  EXPECT_EQ(IndexMeta::DataType::DT_FP32, holder->data_type());
+
+  ASSERT_EQ(0u, quantizer->train(holder));
+
+  auto iter = holder->create_iterator();
+  std::string quant_buffer;
+  std::string dequant_buffer;
+
+  for (; iter->is_valid(); iter->next()) {
+    EXPECT_TRUE(iter->data());
+
+    IndexQueryMeta qmeta;
+    quant_buffer.clear();
+    EXPECT_EQ(0, quantizer->quantize(
+                     iter->data(),
+                     IndexQueryMeta(holder->data_type(), holder->dimension()),
+                     &quant_buffer, &qmeta));
+    EXPECT_EQ(IndexMeta::DataType::DT_FP16, qmeta.data_type());
+    EXPECT_EQ(holder->dimension(), qmeta.dimension());
+
+    dequant_buffer.clear();
+    EXPECT_EQ(
+        0, quantizer->dequantize(quant_buffer.data(), qmeta, &dequant_buffer));
+
+    const float *original_data = reinterpret_cast<const float *>(iter->data());
+    const float *dequantize_data =
+        reinterpret_cast<const float *>(dequant_buffer.data());
+    for (size_t i = 0; i < holder->dimension(); ++i) {
+      EXPECT_NEAR(original_data[i], dequantize_data[i], 1e-3);
+    }
+  }
+}
\ No newline at end of file
diff --git a/tests/turbo/quantizer/turbo_fp32_quantizer_test.cc b/tests/turbo/quantizer/turbo_fp32_quantizer_test.cc
new file mode 100644
index 000000000..40165a5d3
--- /dev/null
+++ b/tests/turbo/quantizer/turbo_fp32_quantizer_test.cc
@@ -0,0 +1,83 @@
+// Copyright 2025-present the zvec project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include <iostream>
+#include <gtest/gtest.h>
+#include <zvec/ailego/container/params.h>
+#include <zvec/turbo/turbo.h>
+#include "zvec/core/framework/index_factory.h"
+
+using namespace zvec;
+using namespace zvec::core;
+using namespace zvec::ailego;
+
+TEST(Fp32Quantizer, General) {
+  std::mt19937 gen(15583);
+  std::uniform_real_distribution<float> dist(0.0, 1.0);
+
+  const size_t COUNT = 10000;
+  const size_t DIMENSION = 12;
+
+  IndexMeta meta;
+  meta.set_meta(IndexMeta::DataType::DT_FP32, DIMENSION);
+  meta.set_metric("Cosine", 0, Params());
+
+  auto quantizer = IndexFactory::CreateQuantizer("Fp32Quantizer");
+  ASSERT_TRUE(quantizer);
+  zvec::ailego::Params params;
+  ASSERT_EQ(0u, quantizer->init(meta, params));
+
+  auto holder =
+      std::make_shared<MultiPassIndexHolder<IndexMeta::DataType::DT_FP32>>(
+          DIMENSION);
+  for (size_t i = 0; i < COUNT; ++i) {
+    zvec::ailego::NumericalVector<float> vec(DIMENSION);
+    for (size_t j = 0; j < DIMENSION; ++j) {
+      vec[j] = dist(gen);
+    }
+    holder->emplace(i + 1, vec);
+  }
+  EXPECT_EQ(COUNT, holder->count());
+  EXPECT_EQ(IndexMeta::DataType::DT_FP32, holder->data_type());
+
+  ASSERT_EQ(0u, quantizer->train(holder));
+
+  auto iter = holder->create_iterator();
+  std::string quant_buffer;
+  std::string dequant_buffer;
+
+  for (; iter->is_valid(); iter->next()) {
+    EXPECT_TRUE(iter->data());
+
+    IndexQueryMeta qmeta;
+    quant_buffer.clear();
+    EXPECT_EQ(0, quantizer->quantize(
+                     iter->data(),
+                     IndexQueryMeta(holder->data_type(), holder->dimension()),
+                     &quant_buffer, &qmeta));
+    EXPECT_EQ(IndexMeta::DataType::DT_FP32, qmeta.data_type());
+    EXPECT_EQ(holder->dimension(), qmeta.dimension());
+
+    dequant_buffer.clear();
+    EXPECT_EQ(
+        0, quantizer->dequantize(quant_buffer.data(), qmeta, &dequant_buffer));
+
+    const float *original_data = reinterpret_cast<const float *>(iter->data());
+    const float *dequantize_data =
+        reinterpret_cast<const float *>(dequant_buffer.data());
+    for (size_t i = 0; i < holder->dimension(); ++i) {
+      EXPECT_NEAR(original_data[i], dequantize_data[i], 1e-3);
+    }
+  }
+}
\ No newline at end of file
diff --git a/tests/turbo/quantizer/turbo_int4_quantizer_test.cc b/tests/turbo/quantizer/turbo_int4_quantizer_test.cc
new file mode 100644
index 000000000..bca0ed3c7
--- /dev/null
+++ b/tests/turbo/quantizer/turbo_int4_quantizer_test.cc
@@ -0,0 +1,185 @@
+// Copyright 2025-present the zvec project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include <iostream>
+#include <gtest/gtest.h>
+#include <zvec/ailego/container/params.h>
+#include <zvec/turbo/turbo.h>
+#include "quantizer/int4_quantizer/int4_quantizer.h"
+#include "zvec/core/framework/index_factory.h"
+
+using namespace zvec;
+using namespace zvec::core;
+using namespace zvec::ailego;
+
+TEST(Int4Quantizer, General) {
+  std::mt19937 gen(15583);
+  std::uniform_real_distribution<float> dist(0.0, 1.0);
+
+  const size_t COUNT = 10000;
+  const size_t DIMENSION = 12;
+
+  IndexMeta meta;
+  meta.set_meta(IndexMeta::DataType::DT_FP32, DIMENSION);
+
+  auto quantizer = IndexFactory::CreateQuantizer("Int4Quantizer");
+  ASSERT_TRUE(quantizer);
+  zvec::ailego::Params params;
+  params.set("proxima.int4_quantizer.converter.histogram_bins_count", 10000);
+  ASSERT_EQ(0u, quantizer->init(meta, params));
+
+  auto holder =
+      std::make_shared<MultiPassIndexHolder<IndexMeta::DataType::DT_FP32>>(
+          DIMENSION);
+  for (size_t i = 0; i < COUNT; ++i) {
+    zvec::ailego::NumericalVector<float> vec(DIMENSION);
+    for (size_t j = 0; j < DIMENSION; ++j) {
+      vec[j] = dist(gen);
+    }
+    holder->emplace(i + 1, vec);
+  }
+  EXPECT_EQ(COUNT, holder->count());
+  EXPECT_EQ(IndexMeta::DataType::DT_FP32, holder->data_type());
+
+  ASSERT_EQ(0u, quantizer->train(holder));
+
+  auto iter = holder->create_iterator();
+  std::string quant_buffer;
+  std::string dequant_buffer;
+
+  for (; iter->is_valid(); iter->next()) {
+    EXPECT_TRUE(iter->data());
+
+    IndexQueryMeta qmeta;
+    EXPECT_EQ(0, quantizer->quantize(
+                     iter->data(),
+                     IndexQueryMeta(holder->data_type(), holder->dimension()),
+                     &quant_buffer, &qmeta));
+    EXPECT_EQ(IndexMeta::DataType::DT_INT4, qmeta.data_type());
+    EXPECT_EQ(holder->dimension(), qmeta.dimension());
+
+    EXPECT_EQ(
+        0, quantizer->dequantize(quant_buffer.data(), qmeta, &dequant_buffer));
+
+    const float *original_data = reinterpret_cast<const float *>(iter->data());
+    const float *dequantize_data =
+        reinterpret_cast<const float *>(dequant_buffer.data());
+    for (size_t i = 0; i < holder->dimension(); ++i) {
+      EXPECT_NEAR(original_data[i], dequantize_data[i], 0.15);
+    }
+  }
+}
+
+TEST(Int4Quantizer, TestSerialize) {
+  std::mt19937 gen(15583);
+  std::uniform_real_distribution<float> dist(0.0, 1.0);
+
+  const size_t COUNT = 10000;
+  const size_t DIMENSION = 12;
+
+  IndexMeta meta;
+  meta.set_meta(IndexMeta::DataType::DT_FP32, DIMENSION);
+
+  auto quantizer = IndexFactory::CreateQuantizer("Int4Quantizer");
+  ASSERT_TRUE(quantizer);
+  zvec::ailego::Params params;
+  ASSERT_EQ(0u, quantizer->init(meta, params));
+
+  auto holder =
+      std::make_shared<MultiPassIndexHolder<IndexMeta::DataType::DT_FP32>>(
+          DIMENSION);
+  for (size_t i = 0; i < COUNT; ++i) {
+    zvec::ailego::NumericalVector<float> vec(DIMENSION);
+    for (size_t j = 0; j < DIMENSION; ++j) {
+      vec[j] = dist(gen);
+    }
+    holder->emplace(i + 1, vec);
+  }
+  EXPECT_EQ(COUNT, holder->count());
+  EXPECT_EQ(IndexMeta::DataType::DT_FP32, holder->data_type());
+
+  ASSERT_EQ(0u, quantizer->train(holder));
+
+  std::string param_buffer;
+  ASSERT_EQ(0u, quantizer->serialize(&param_buffer));
+
+  // new quantizer
+  auto quantizer_new = IndexFactory::CreateQuantizer("Int4Quantizer");
+  ASSERT_TRUE(quantizer_new);
+  zvec::ailego::Params params_new;
+  ASSERT_EQ(0u, quantizer_new->init(meta, params_new));
+  ASSERT_EQ(0u, quantizer_new->deserialize(param_buffer));
+
+  zvec::turbo::Int4Quantizer *int4_quantizer =
+      reinterpret_cast<zvec::turbo::Int4Quantizer *>(quantizer.get());
+
+  zvec::turbo::Int4Quantizer *int4_quantizer_new =
+      reinterpret_cast<zvec::turbo::Int4Quantizer *>(quantizer_new.get());
+
+  ASSERT_EQ(int4_quantizer->bias(), int4_quantizer_new->bias());
+  ASSERT_EQ(int4_quantizer->scale(), int4_quantizer_new->scale());
+
+  auto iter = holder->create_iterator();
+  std::string quant_buffer;
+  std::string dequant_buffer;
+
+  for (; iter->is_valid(); iter->next()) {
+    EXPECT_TRUE(iter->data());
+
+    IndexQueryMeta qmeta;
+    quant_buffer.clear();
+    EXPECT_EQ(0, quantizer->quantize(
+                     iter->data(),
+                     IndexQueryMeta(holder->data_type(), holder->dimension()),
+                     &quant_buffer, &qmeta));
+    EXPECT_EQ(IndexMeta::DataType::DT_INT4, qmeta.data_type());
+    EXPECT_EQ(holder->dimension(), qmeta.dimension());
+
+    dequant_buffer.clear();
+    EXPECT_EQ(
+        0, quantizer->dequantize(quant_buffer.data(), qmeta, &dequant_buffer));
+
+    const float *original_data = reinterpret_cast<const float *>(iter->data());
+    const float *dequantize_data =
+        reinterpret_cast<const float *>(dequant_buffer.data());
+    for (size_t i = 0; i < holder->dimension(); ++i) {
+      EXPECT_NEAR(original_data[i], dequantize_data[i], 0.15);
+    }
+  }
+
+  auto iter2 = holder->create_iterator();
+  for (; iter2->is_valid(); iter2->next()) {
+    EXPECT_TRUE(iter2->data());
+
+    IndexQueryMeta qmeta;
+    quant_buffer.clear();
+    EXPECT_EQ(0, quantizer_new->quantize(
+                     iter2->data(),
+                     IndexQueryMeta(holder->data_type(), holder->dimension()),
+                     &quant_buffer, &qmeta));
+    EXPECT_EQ(IndexMeta::DataType::DT_INT4, qmeta.data_type());
+    EXPECT_EQ(holder->dimension(), qmeta.dimension());
+
+    dequant_buffer.clear();
+    EXPECT_EQ(0, quantizer_new->dequantize(quant_buffer.data(), qmeta,
+                                           &dequant_buffer));
+
+    const float *original_data = reinterpret_cast<const float *>(iter2->data());
+    const float *dequantize_data =
+        reinterpret_cast<const float *>(dequant_buffer.data());
+    for (size_t i = 0; i < holder->dimension(); ++i) {
+      EXPECT_NEAR(original_data[i], dequantize_data[i], 0.15);
+    }
+  }
+}
diff --git a/tests/turbo/quantizer/turbo_int8_quantizer_test.cc b/tests/turbo/quantizer/turbo_int8_quantizer_test.cc
new file mode 100644
index 000000000..5c8cf81f0
--- /dev/null
+++ b/tests/turbo/quantizer/turbo_int8_quantizer_test.cc
@@ -0,0 +1,188 @@
+// Copyright 2025-present the zvec project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include <iostream>
+#include <gtest/gtest.h>
+#include <zvec/ailego/container/params.h>
+#include <zvec/turbo/turbo.h>
+#include "quantizer/int8_quantizer/int8_quantizer.h"
+#include "zvec/core/framework/index_factory.h"
+
+using namespace zvec;
+using namespace zvec::core;
+using namespace zvec::ailego;
+
+TEST(Int8Quantizer, Int8General) {
+  std::mt19937 gen(15583);
+  std::uniform_real_distribution<float> dist(0.0, 1.0);
+
+  const size_t COUNT = 10000;
+  const size_t DIMENSION = 12;
+
+  IndexMeta meta;
+  meta.set_meta(IndexMeta::DataType::DT_FP32, DIMENSION);
+
+  auto quantizer = IndexFactory::CreateQuantizer("Int8Quantizer");
+  ASSERT_TRUE(quantizer);
+  zvec::ailego::Params params;
+  params.set("int8_quantizer.bias", 0.0f);
+  params.set("int8_quantizer.scale", 127.0f);
+  ASSERT_EQ(0u, quantizer->init(meta, params));
+
+  auto holder =
+      std::make_shared<MultiPassIndexHolder<IndexMeta::DataType::DT_FP32>>(
+          DIMENSION);
+  for (size_t i = 0; i < COUNT; ++i) {
+    zvec::ailego::NumericalVector<float> vec(DIMENSION);
+    for (size_t j = 0; j < DIMENSION; ++j) {
+      vec[j] = dist(gen);
+    }
+    holder->emplace(i + 1, vec);
+  }
+  EXPECT_EQ(COUNT, holder->count());
+  EXPECT_EQ(IndexMeta::DataType::DT_FP32, holder->data_type());
+
+  ASSERT_EQ(0u, quantizer->train(holder));
+
+  auto iter = holder->create_iterator();
+  std::string quant_buffer;
+  std::string dequant_buffer;
+
+  for (; iter->is_valid(); iter->next()) {
+    EXPECT_TRUE(iter->data());
+
+    IndexQueryMeta qmeta;
+    quant_buffer.clear();
+    EXPECT_EQ(0, quantizer->quantize(
+                     iter->data(),
+                     IndexQueryMeta(holder->data_type(), holder->dimension()),
+                     &quant_buffer, &qmeta));
+    EXPECT_EQ(IndexMeta::DataType::DT_INT8, qmeta.data_type());
+    EXPECT_EQ(quantizer->meta().dimension(), qmeta.dimension());
+
+    dequant_buffer.clear();
+    EXPECT_EQ(
+        0, quantizer->dequantize(quant_buffer.data(), qmeta, &dequant_buffer));
+
+    const float *original_data = reinterpret_cast<const float *>(iter->data());
+    const float *dequantize_data =
+        reinterpret_cast<const float *>(dequant_buffer.data());
+    for (size_t i = 0; i < holder->dimension(); ++i) {
+      EXPECT_NEAR(original_data[i], dequantize_data[i], 1e-2);
+    }
+  }
+}
+
+
+TEST(Int8Quantizer, TestSerialize) {
+  std::mt19937 gen(15583);
+  std::uniform_real_distribution<float> dist(0.0, 1.0);
+
+  const size_t COUNT = 10000;
+  const size_t DIMENSION = 12;
+
+  IndexMeta meta;
+  meta.set_meta(IndexMeta::DataType::DT_FP32, DIMENSION);
+
+  auto quantizer = IndexFactory::CreateQuantizer("Int8Quantizer");
+  ASSERT_TRUE(quantizer);
+  zvec::ailego::Params params;
+  ASSERT_EQ(0u, quantizer->init(meta, params));
+
+  auto holder =
+      std::make_shared<MultiPassIndexHolder<IndexMeta::DataType::DT_FP32>>(
+          DIMENSION);
+  for (size_t i = 0; i < COUNT; ++i) {
+    zvec::ailego::NumericalVector<float> vec(DIMENSION);
+    for (size_t j = 0; j < DIMENSION; ++j) {
+      vec[j] = dist(gen);
+    }
+    holder->emplace(i + 1, vec);
+  }
+  EXPECT_EQ(COUNT, holder->count());
+  EXPECT_EQ(IndexMeta::DataType::DT_FP32, holder->data_type());
+
+  ASSERT_EQ(0u, quantizer->train(holder));
+
+  std::string param_buffer;
+  ASSERT_EQ(0u, quantizer->serialize(&param_buffer));
+
+  // new quantizer
+  auto quantizer_new = IndexFactory::CreateQuantizer("Int8Quantizer");
+  ASSERT_TRUE(quantizer_new);
+  zvec::ailego::Params params_new;
+  ASSERT_EQ(0u, quantizer_new->init(meta, params_new));
+  ASSERT_EQ(0u, quantizer_new->deserialize(param_buffer));
+
+  auto *int8_quantizer =
+      reinterpret_cast<zvec::turbo::Int8Quantizer *>(quantizer.get());
+  auto *int8_quantizer_new =
+      reinterpret_cast<zvec::turbo::Int8Quantizer *>(quantizer_new.get());
+
+  ASSERT_EQ(int8_quantizer->bias(), int8_quantizer_new->bias());
+  ASSERT_EQ(int8_quantizer->scale(), int8_quantizer_new->scale());
+
+  auto iter = holder->create_iterator();
+  std::string quant_buffer;
+  std::string dequant_buffer;
+
+  for (; iter->is_valid(); iter->next()) {
+    EXPECT_TRUE(iter->data());
+
+    IndexQueryMeta qmeta;
+    quant_buffer.clear();
+    EXPECT_EQ(0, quantizer->quantize(
+                     iter->data(),
+                     IndexQueryMeta(holder->data_type(), holder->dimension()),
+                     &quant_buffer, &qmeta));
+    EXPECT_EQ(IndexMeta::DataType::DT_INT8, qmeta.data_type());
+    EXPECT_EQ(quantizer->meta().dimension(), qmeta.dimension());
+
+    dequant_buffer.clear();
+    EXPECT_EQ(
+        0, quantizer->dequantize(quant_buffer.data(), qmeta, &dequant_buffer));
+
+    const float *original_data = reinterpret_cast<const float *>(iter->data());
+    const float *dequantize_data =
+        reinterpret_cast<const float *>(dequant_buffer.data());
+    for (size_t i = 0; i < holder->dimension(); ++i) {
+      EXPECT_NEAR(original_data[i], dequantize_data[i], 0.15);
+    }
+  }
+
+  auto iter2 = holder->create_iterator();
+  for (; iter2->is_valid(); iter2->next()) {
+    EXPECT_TRUE(iter2->data());
+
+    IndexQueryMeta qmeta;
+    quant_buffer.clear();
+    EXPECT_EQ(0, quantizer_new->quantize(
+                     iter2->data(),
+                     IndexQueryMeta(holder->data_type(), holder->dimension()),
+                     &quant_buffer, &qmeta));
+    EXPECT_EQ(IndexMeta::DataType::DT_INT8, qmeta.data_type());
+    EXPECT_EQ(quantizer_new->meta().dimension(), qmeta.dimension());
+
+    dequant_buffer.clear();
+    EXPECT_EQ(0, quantizer_new->dequantize(quant_buffer.data(), qmeta,
+                                           &dequant_buffer));
+
+    const float *original_data = reinterpret_cast<const float *>(iter2->data());
+    const float *dequantize_data =
+        reinterpret_cast<const float *>(dequant_buffer.data());
+    for (size_t i = 0; i < holder->dimension(); ++i) {
+      EXPECT_NEAR(original_data[i], dequantize_data[i], 0.15);
+    }
+  }
+}