From adc532b732ab0ce8ee54d921d4cfd88bb231b5dc Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Tue, 20 Jan 2026 23:27:52 +0000
Subject: [PATCH 01/26] Initial plan


From cd02489dedbe03beb6c4d5c36b0193dcb11737e1 Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Tue, 20 Jan 2026 23:30:41 +0000
Subject: [PATCH 02/26] Enable Miri tests in CI with continue-on-error and time
 reporting

Co-authored-by: arrayka <1551741+arrayka@users.noreply.github.com>
---
 .github/workflows/ci.yml | 54 ++++++++++++++++++++++++----------------
 1 file changed, 32 insertions(+), 22 deletions(-)

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index ccf812649..4b9a48bcd 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -204,28 +204,38 @@ jobs:
   #       env:
   #         CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }}
 
-  # miri:
-  #   needs: basics
-  #   name: miri-test
-  #   runs-on: ubuntu-latest
-  #   steps:
-  #     - uses: actions/checkout@v4
-  #       with:
-  #         lfs: true
+  miri:
+    needs: basics
+    name: miri-test
+    runs-on: ubuntu-latest
+    continue-on-error: true
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          lfs: true
 
-  #     - name: Install Rust nightly with miri
-  #       uses: dtolnay/rust-toolchain@stable
-  #       with:
-  #         toolchain: nightly
-  #         components: miri
+      - name: Install Rust nightly with miri
+        uses: dtolnay/rust-toolchain@stable
+        with:
+          toolchain: nightly
+          components: miri
 
-  #     - name: Install cargo-nextest
-  #       uses: taiki-e/install-action@v2
-  #       with:
-  #         tool: cargo-nextest
+      - name: Install cargo-nextest
+        uses: taiki-e/install-action@v2
+        with:
+          tool: cargo-nextest
 
-  #     - uses: Swatinem/rust-cache@v2
-  #     - name: miri
-  #       run: cargo +nightly miri nextest run --package diskann-quantization
-  #       env:
-  #         MIRIFLAGS: -Zmiri-disable-isolation -Zmiri-strict-provenance
+      - uses: Swatinem/rust-cache@v2
+
+      - name: miri
+        run: |
+          set -euxo pipefail
+          echo "::group::Miri Test Execution"
+          START_TIME=$(date +%s)
+          cargo +nightly miri nextest run --package diskann-quantization || true
+          END_TIME=$(date +%s)
+          DURATION=$((END_TIME - START_TIME))
+          echo "::endgroup::"
+          echo "::notice::Miri tests completed in ${DURATION} seconds"
+        env:
+          MIRIFLAGS: -Zmiri-disable-isolation -Zmiri-strict-provenance

From 3b7eeb7fd53e07016c83bc81da9068cd070b0046 Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Tue, 20 Jan 2026 23:31:32 +0000
Subject: [PATCH 03/26] Fix bash flags to allow proper error handling in Miri
 tests

Co-authored-by: arrayka <1551741+arrayka@users.noreply.github.com>
---
 .github/workflows/ci.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 4b9a48bcd..db03a7e26 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -229,7 +229,7 @@ jobs:
 
       - name: miri
         run: |
-          set -euxo pipefail
+          set -eux
           echo "::group::Miri Test Execution"
           START_TIME=$(date +%s)
           cargo +nightly miri nextest run --package diskann-quantization || true

From b2b0400c90820f7c216321e6aa26c41ee8dc7d8e Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Tue, 20 Jan 2026 23:32:29 +0000
Subject: [PATCH 04/26] Use set -ux for consistent error handling with || true

Co-authored-by: arrayka <1551741+arrayka@users.noreply.github.com>
---
 .github/workflows/ci.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index db03a7e26..f8434768c 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -229,7 +229,7 @@ jobs:
 
       - name: miri
         run: |
-          set -eux
+          set -ux
           echo "::group::Miri Test Execution"
           START_TIME=$(date +%s)
           cargo +nightly miri nextest run --package diskann-quantization || true

From e17c07f904b3eb81488f03d6292d44e1825ad28a Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Tue, 20 Jan 2026 23:55:13 +0000
Subject: [PATCH 05/26] Simplify Miri command to use original syntax without
 time measurement

Co-authored-by: arrayka <1551741+arrayka@users.noreply.github.com>
---
 .github/workflows/ci.yml | 10 +---------
 1 file changed, 1 insertion(+), 9 deletions(-)

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index f8434768c..04108b22f 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -228,14 +228,6 @@ jobs:
       - uses: Swatinem/rust-cache@v2
 
       - name: miri
-        run: |
-          set -ux
-          echo "::group::Miri Test Execution"
-          START_TIME=$(date +%s)
-          cargo +nightly miri nextest run --package diskann-quantization || true
-          END_TIME=$(date +%s)
-          DURATION=$((END_TIME - START_TIME))
-          echo "::endgroup::"
-          echo "::notice::Miri tests completed in ${DURATION} seconds"
+        run: cargo +nightly miri nextest run --package diskann-quantization
         env:
           MIRIFLAGS: -Zmiri-disable-isolation -Zmiri-strict-provenance

From f5f255be01d6100c7bb7aa3cbf10049f71fa0dee Mon Sep 17 00:00:00 2001
From: "Alex Razumov (from Dev Box)" <alrazu@microsoft.com>
Date: Thu, 22 Jan 2026 16:52:20 -0800
Subject: [PATCH 06/26] Fix unused imports

---
 diskann-quantization/src/algorithms/kmeans/plusplus.rs   | 2 ++
 diskann-quantization/src/product/tables/test.rs          | 8 ++++++--
 .../src/product/tables/transposed/table.rs               | 9 +++++----
 diskann-quantization/src/test_util.rs                    | 8 +++++++-
 4 files changed, 20 insertions(+), 7 deletions(-)

diff --git a/diskann-quantization/src/algorithms/kmeans/plusplus.rs b/diskann-quantization/src/algorithms/kmeans/plusplus.rs
index e34945ad4..117acab5b 100644
--- a/diskann-quantization/src/algorithms/kmeans/plusplus.rs
+++ b/diskann-quantization/src/algorithms/kmeans/plusplus.rs
@@ -695,6 +695,7 @@ mod tests {
 
     // Kmeans++ sanity checks - if there are only `N` distinct and we want `N` centers,
     // then all `N` should be selected without repeats.
+    #[cfg(not(miri))]
     fn sanity_check_impl<R: Rng>(ncenters: usize, dim: usize, rng: &mut R) {
         let repeats_per_center = 3;
         let context = lazy_format!(
@@ -756,6 +757,7 @@ mod tests {
 
     // This test is like the sanity check - but instead of exact repeats, we use slightly
     // perturbed values to test that the proportionality is of distances is respected.
+    #[cfg(not(miri))]
     fn fuzzy_sanity_check_impl<R: Rng>(ncenters: usize, dim: usize, rng: &mut R) {
         let repeats_per_center = 3;
 
diff --git a/diskann-quantization/src/product/tables/test.rs b/diskann-quantization/src/product/tables/test.rs
index 2c823c1eb..70732f65d 100644
--- a/diskann-quantization/src/product/tables/test.rs
+++ b/diskann-quantization/src/product/tables/test.rs
@@ -4,10 +4,13 @@
  */
 
 // A collection of test helpers to ensure uniformity across tables.
-use diskann_utils::views::{Matrix, MatrixView, MutMatrixView};
+use diskann_utils::views::Matrix;
+#[cfg(not(miri))]
+use diskann_utils::views::{MatrixView, MutMatrixView};
+#[cfg(not(miri))]
+use rand::seq::IndexedRandom;
 use rand::{
     distr::{Distribution, Uniform},
-    seq::IndexedRandom,
     Rng, SeedableRng,
 };
 
@@ -290,6 +293,7 @@ pub(super) fn check_pqtable_single_compression_errors<T>(
 ////////////////////////////////////////////////////////////////////
 
 // A cantralized test for error handling in `CompressInto<[f32], [u8]>`
+#[cfg(not(miri))]
 pub(super) fn check_pqtable_batch_compression_errors<T>(
     build: &dyn Fn(Matrix<f32>, ChunkOffsets) -> T,
     context: &dyn std::fmt::Display,
diff --git a/diskann-quantization/src/product/tables/transposed/table.rs b/diskann-quantization/src/product/tables/transposed/table.rs
index 2db1ac8a7..c18828705 100644
--- a/diskann-quantization/src/product/tables/transposed/table.rs
+++ b/diskann-quantization/src/product/tables/transposed/table.rs
@@ -511,13 +511,14 @@ mod test_compression {
     };
 
     use super::*;
+    #[cfg(not(miri))]
+    use crate::product::tables::test::{
+        check_pqtable_batch_compression_errors, check_pqtable_single_compression_errors,
+    };
     use crate::{
         distances::{InnerProduct, SquaredL2},
         error::format,
-        product::tables::test::{
-            check_pqtable_batch_compression_errors, check_pqtable_single_compression_errors,
-            create_dataset, create_pivot_tables,
-        },
+        product::tables::test::{create_dataset, create_pivot_tables},
     };
     use diskann_utils::lazy_format;
 
diff --git a/diskann-quantization/src/test_util.rs b/diskann-quantization/src/test_util.rs
index a258dd12a..7bb0d7496 100644
--- a/diskann-quantization/src/test_util.rs
+++ b/diskann-quantization/src/test_util.rs
@@ -3,6 +3,7 @@
  * Licensed under the MIT license.
  */
 
+#[cfg(not(miri))]
 use std::sync::{
     atomic::{AtomicUsize, Ordering},
     Arc,
@@ -15,7 +16,9 @@ use rand::{
     seq::SliceRandom,
 };
 
-use crate::alloc::{AllocatorCore, AllocatorError, GlobalAllocator};
+#[cfg(not(miri))]
+use crate::alloc::GlobalAllocator;
+use crate::alloc::{AllocatorCore, AllocatorError};
 
 /// An allocator that always fails.
 #[derive(Debug, Clone, Copy)]
@@ -36,11 +39,13 @@ unsafe impl AllocatorCore for AlwaysFails {
 /// An allocator that can only perform a limited number of allocations.
 ///
 /// Used to test interfaces for allocation reliability.
+#[cfg(not(miri))]
 #[derive(Debug, Clone)]
 pub(crate) struct LimitedAllocator {
     remaining: Arc<AtomicUsize>,
 }
 
+#[cfg(not(miri))]
 impl LimitedAllocator {
     pub(crate) fn new(allocations: usize) -> Self {
         Self {
@@ -50,6 +55,7 @@ impl LimitedAllocator {
 }
 
 /// SAFETY: This either forwards to the global allocator, or failed.
+#[cfg(not(miri))]
 unsafe impl AllocatorCore for LimitedAllocator {
     fn allocate(
         &self,

From 1f8c1dedef1ddc94771844df6ae94812870dc0e9 Mon Sep 17 00:00:00 2001
From: "Alex Razumov (from Dev Box)" <alrazu@microsoft.com>
Date: Thu, 22 Jan 2026 17:07:44 -0800
Subject: [PATCH 07/26] Adjust the safety comment

---
 diskann-quantization/src/test_util.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/diskann-quantization/src/test_util.rs b/diskann-quantization/src/test_util.rs
index 7bb0d7496..780471776 100644
--- a/diskann-quantization/src/test_util.rs
+++ b/diskann-quantization/src/test_util.rs
@@ -54,8 +54,8 @@ impl LimitedAllocator {
     }
 }
 
-/// SAFETY: This either forwards to the global allocator, or failed.
 #[cfg(not(miri))]
+/// SAFETY: This either forwards to the global allocator, or failed.
 unsafe impl AllocatorCore for LimitedAllocator {
     fn allocate(
         &self,

From 337a120b73b8947836a2713c9477ae9991a1ff35 Mon Sep 17 00:00:00 2001
From: "Alex Razumov (from Dev Box)" <alrazu@microsoft.com>
Date: Thu, 22 Jan 2026 18:11:04 -0800
Subject: [PATCH 08/26] Speed up miri tests

---
 diskann-quantization/src/algorithms/heap.rs   | 14 +++++++++-----
 .../algorithms/transforms/double_hadamard.rs  | 19 +++++++++++++++++--
 .../algorithms/transforms/padding_hadamard.rs | 18 ++++++++++++++++--
 .../src/algorithms/transforms/test_utils.rs   |  3 +++
 diskann-quantization/src/bits/distances.rs    |  8 +++++++-
 5 files changed, 52 insertions(+), 10 deletions(-)

diff --git a/diskann-quantization/src/algorithms/heap.rs b/diskann-quantization/src/algorithms/heap.rs
index b3d1093fe..3943cdd30 100644
--- a/diskann-quantization/src/algorithms/heap.rs
+++ b/diskann-quantization/src/algorithms/heap.rs
@@ -390,11 +390,15 @@ mod tests {
         // Heap of size 2.
         fuzz_test_impl(2, 101, &mut rng);
 
-        // Heap size not power of two.
-        fuzz_test_impl(1000, 1000, &mut rng);
-
-        // Heap size power of two.
-        fuzz_test_impl(128, 1000, &mut rng);
+        // Miri is extremely slow, so we skip the larger tests there.
+        #[cfg(not(miri))]
+        {
+            // Heap size not power of two.
+            fuzz_test_impl(1000, 1000, &mut rng);
+
+            // Heap size power of two.
+            fuzz_test_impl(128, 1000, &mut rng);
+        }
     }
 
     #[test]
diff --git a/diskann-quantization/src/algorithms/transforms/double_hadamard.rs b/diskann-quantization/src/algorithms/transforms/double_hadamard.rs
index 33ea3fbb8..d23e652c6 100644
--- a/diskann-quantization/src/algorithms/transforms/double_hadamard.rs
+++ b/diskann-quantization/src/algorithms/transforms/double_hadamard.rs
@@ -417,6 +417,7 @@ mod tests {
         //
         // Subsampling results in poor preservation of inner products, so we skip it
         // altogether.
+        #[cfg(not(miri))]
         let subsampled_errors = test_utils::ErrorSetup {
             norm: test_utils::Check::absrel(0.0, 2e-2),
             l2: test_utils::Check::absrel(0.0, 2e-2),
@@ -424,6 +425,9 @@ mod tests {
         };
 
         let target_dim = |v| TargetDim::Override(NonZeroUsize::new(v).unwrap());
+
+        // Miri is extremely slow, so we skip the larger tests there.
+        #[cfg(not(miri))]
         let dim_combos = [
             // Natural
             (15, 15, true, TargetDim::Same, &natural_errors),
@@ -441,9 +445,20 @@ mod tests {
             (1024, 1023, false, target_dim(1023), &subsampled_errors),
             (1000, 999, false, target_dim(999), &subsampled_errors),
         ];
+        #[cfg(miri)]
+        let dim_combos = [
+            (15, 15, true, target_dim(15), &natural_errors),
+        ];
 
-        let trials_per_combo = 20;
-        let trials_per_dim = 100;
+        cfg_if::cfg_if! {
+            if #[cfg(miri)] {
+                let trials_per_combo = 1;
+                let trials_per_dim = 1;
+            } else {
+                let trials_per_combo = 20;
+                let trials_per_dim = 100;
+            }
+        }
 
         let mut rng = StdRng::seed_from_u64(0x6d1699abe066147);
         for (input, output, preserves_norms, target, errors) in dim_combos {
diff --git a/diskann-quantization/src/algorithms/transforms/padding_hadamard.rs b/diskann-quantization/src/algorithms/transforms/padding_hadamard.rs
index ed6d3b27f..e6d3eb6fe 100644
--- a/diskann-quantization/src/algorithms/transforms/padding_hadamard.rs
+++ b/diskann-quantization/src/algorithms/transforms/padding_hadamard.rs
@@ -463,6 +463,7 @@ mod tests {
         //
         // Subsampling results in poor preservation of inner products, so we skip it
         // altogether.
+        #[cfg(not(miri))]
         let subsampled_errors = test_utils::ErrorSetup {
             norm: test_utils::Check::absrel(0.0, 1e-1),
             l2: test_utils::Check::absrel(0.0, 1e-1),
@@ -471,6 +472,8 @@ mod tests {
 
         let target_dim = |v| TargetDim::Override(NonZeroUsize::new(v).unwrap());
 
+        // Miri is extremely slow, so we skip the larger tests there.
+        #[cfg(not(miri))]
         let dim_combos = [
             // Natural
             (15, 16, true, target_dim(16), &natural_errors),
@@ -486,9 +489,20 @@ mod tests {
             (1000, 1000, false, TargetDim::Same, &subsampled_errors),
             (500, 1000, false, target_dim(1000), &subsampled_errors),
         ];
+        #[cfg(miri)]
+        let dim_combos = [
+            (15, 16, true, target_dim(16), &natural_errors),
+        ];
 
-        let trials_per_combo = 20;
-        let trials_per_dim = 100;
+        cfg_if::cfg_if! {
+            if #[cfg(miri)] {
+                let trials_per_combo = 1;
+                let trials_per_dim = 1;
+            } else {
+                let trials_per_combo = 20;
+                let trials_per_dim = 100;
+            }
+        }
 
         let mut rng = StdRng::seed_from_u64(0x6d1699abe0626147);
         for (input, output, preserves_norms, target, errors) in dim_combos {
diff --git a/diskann-quantization/src/algorithms/transforms/test_utils.rs b/diskann-quantization/src/algorithms/transforms/test_utils.rs
index c853cc904..648a07647 100644
--- a/diskann-quantization/src/algorithms/transforms/test_utils.rs
+++ b/diskann-quantization/src/algorithms/transforms/test_utils.rs
@@ -173,6 +173,7 @@ fn within_ulp(mut got: f32, expected: f32, ulp: usize) -> bool {
 pub(super) enum Check {
     Ulp(usize),
     AbsRel { abs: f32, rel: f32 },
+    #[cfg(not(miri))]
     Skip,
 }
 
@@ -185,6 +186,7 @@ impl Check {
         Self::AbsRel { abs, rel }
     }
 
+    #[cfg(not(miri))]
     pub(super) fn skip() -> Self {
         Self::Skip
     }
@@ -219,6 +221,7 @@ impl Check {
                     })
                 }
             }
+            #[cfg(not(miri))]
             Self::Skip => Ok(()),
         }
     }
diff --git a/diskann-quantization/src/bits/distances.rs b/diskann-quantization/src/bits/distances.rs
index 00ece2883..e888dccf0 100644
--- a/diskann-quantization/src/bits/distances.rs
+++ b/diskann-quantization/src/bits/distances.rs
@@ -2003,6 +2003,12 @@ mod tests {
         let dist = Uniform::new_inclusive(min, max).unwrap();
 
         for dim in 0..dim_max {
+            // Only run the maximum dimension when running under miri.
+            #[cfg(miri)]
+            if dim != dim_max - 1 {
+                continue;
+            }
+
             let mut x_reference: Vec<u8> = vec![0; dim];
             let mut y_reference: Vec<u8> = vec![0; dim];
 
@@ -2092,7 +2098,7 @@ mod tests {
 
     cfg_if::cfg_if! {
         if #[cfg(miri)] {
-            const MAX_DIM: usize = 128;
+            const MAX_DIM: usize = 8;
             const TRIALS_PER_DIM: usize = 1;
         } else {
             const MAX_DIM: usize = 256;

From a54c9c1d99bda82624b9c10692fe4dccddeb35c0 Mon Sep 17 00:00:00 2001
From: "Alex Razumov (from Dev Box)" <alrazu@microsoft.com>
Date: Thu, 22 Jan 2026 18:22:27 -0800
Subject: [PATCH 09/26] Speed up miri tests

---
 .../src/algorithms/kmeans/common.rs              | 16 ++++++++++++++++
 .../src/algorithms/kmeans/lloyds.rs              | 10 ++++++++++
 .../src/algorithms/transforms/double_hadamard.rs |  4 +---
 .../algorithms/transforms/padding_hadamard.rs    |  4 +---
 .../src/algorithms/transforms/test_utils.rs      |  5 ++++-
 diskann-quantization/src/bits/slice.rs           | 10 ++++++++++
 6 files changed, 42 insertions(+), 7 deletions(-)

diff --git a/diskann-quantization/src/algorithms/kmeans/common.rs b/diskann-quantization/src/algorithms/kmeans/common.rs
index 3c095de0d..4808b6fa5 100644
--- a/diskann-quantization/src/algorithms/kmeans/common.rs
+++ b/diskann-quantization/src/algorithms/kmeans/common.rs
@@ -565,19 +565,35 @@ mod tests {
 
     #[test]
     fn test_block_transpose_16() {
+        #[cfg(not(miri))]
         for nrows in 0..128 {
             for ncols in 0..5 {
                 test_block_transpose::<16>(nrows, ncols);
             }
         }
+
+        #[cfg(miri)]
+        for nrows in 127..128 {
+            for ncols in 4..5 {
+                test_block_transpose::<16>(nrows, ncols);
+            }
+        }
     }
 
     #[test]
     fn test_block_transpose_8() {
+        #[cfg(not(miri))]
         for nrows in 0..128 {
             for ncols in 0..5 {
                 test_block_transpose::<8>(nrows, ncols);
             }
         }
+
+        #[cfg(miri)]
+        for nrows in 127..128 {
+            for ncols in 4..5 {
+                test_block_transpose::<8>(nrows, ncols);
+            }
+        }
     }
 }
diff --git a/diskann-quantization/src/algorithms/kmeans/lloyds.rs b/diskann-quantization/src/algorithms/kmeans/lloyds.rs
index 5c99d3d4e..46e7c591d 100644
--- a/diskann-quantization/src/algorithms/kmeans/lloyds.rs
+++ b/diskann-quantization/src/algorithms/kmeans/lloyds.rs
@@ -567,6 +567,7 @@ mod tests {
     #[test]
     fn test_distances_in_place() {
         let mut rng = StdRng::seed_from_u64(0xece88a9c6cd86a8a);
+        #[cfg(not(miri))]
         for ndata in 1..=31 {
             for ncenters in 1..=5 {
                 for dim in 1..=4 {
@@ -574,6 +575,15 @@ mod tests {
                 }
             }
         }
+
+        #[cfg(miri)]
+        for ndata in 31..=31 {
+            for ncenters in 5..=5 {
+                for dim in 4..=4 {
+                    test_distances_in_place_impl(ndata, ncenters, dim, TRIALS, &mut rng);
+                }
+            }
+        }
     }
 
     // We do not perform any value-dependent control-flow for memory accesses.
diff --git a/diskann-quantization/src/algorithms/transforms/double_hadamard.rs b/diskann-quantization/src/algorithms/transforms/double_hadamard.rs
index d23e652c6..20fdf42db 100644
--- a/diskann-quantization/src/algorithms/transforms/double_hadamard.rs
+++ b/diskann-quantization/src/algorithms/transforms/double_hadamard.rs
@@ -446,9 +446,7 @@ mod tests {
             (1000, 999, false, target_dim(999), &subsampled_errors),
         ];
         #[cfg(miri)]
-        let dim_combos = [
-            (15, 15, true, target_dim(15), &natural_errors),
-        ];
+        let dim_combos = [(15, 15, true, target_dim(15), &natural_errors)];
 
         cfg_if::cfg_if! {
             if #[cfg(miri)] {
diff --git a/diskann-quantization/src/algorithms/transforms/padding_hadamard.rs b/diskann-quantization/src/algorithms/transforms/padding_hadamard.rs
index e6d3eb6fe..656a1b582 100644
--- a/diskann-quantization/src/algorithms/transforms/padding_hadamard.rs
+++ b/diskann-quantization/src/algorithms/transforms/padding_hadamard.rs
@@ -490,9 +490,7 @@ mod tests {
             (500, 1000, false, target_dim(1000), &subsampled_errors),
         ];
         #[cfg(miri)]
-        let dim_combos = [
-            (15, 16, true, target_dim(16), &natural_errors),
-        ];
+        let dim_combos = [(15, 16, true, target_dim(16), &natural_errors)];
 
         cfg_if::cfg_if! {
             if #[cfg(miri)] {
diff --git a/diskann-quantization/src/algorithms/transforms/test_utils.rs b/diskann-quantization/src/algorithms/transforms/test_utils.rs
index 648a07647..c38ba5ea0 100644
--- a/diskann-quantization/src/algorithms/transforms/test_utils.rs
+++ b/diskann-quantization/src/algorithms/transforms/test_utils.rs
@@ -172,7 +172,10 @@ fn within_ulp(mut got: f32, expected: f32, ulp: usize) -> bool {
 #[derive(Debug, Clone, Copy)]
 pub(super) enum Check {
     Ulp(usize),
-    AbsRel { abs: f32, rel: f32 },
+    AbsRel {
+        abs: f32,
+        rel: f32,
+    },
     #[cfg(not(miri))]
     Skip,
 }
diff --git a/diskann-quantization/src/bits/slice.rs b/diskann-quantization/src/bits/slice.rs
index fb77cefff..a08708f4c 100644
--- a/diskann-quantization/src/bits/slice.rs
+++ b/diskann-quantization/src/bits/slice.rs
@@ -1512,6 +1512,11 @@ mod tests {
     fn test_binary_dense() {
         let mut rng = StdRng::seed_from_u64(0xb3c95e8e19d3842e);
         for len in 0..MAX_DIM {
+            #[cfg(miri)]
+            if len != MAX_DIM - 1 {
+                continue;
+            }
+
             test_send_and_sync::<1, Binary, Dense>();
             test_empty::<1, Binary, Dense>();
             test_construction_errors::<1, Binary, Dense>();
@@ -1558,6 +1563,11 @@ mod tests {
     fn test_4bit_bit_transpose() {
         let mut rng = StdRng::seed_from_u64(0xb3c95e8e19d3842e);
         for len in 0..MAX_DIM {
+            #[cfg(miri)]
+            if len != MAX_DIM - 1 {
+                continue;
+            }
+
             test_send_and_sync::<4, Unsigned, BitTranspose>();
             test_empty::<4, Unsigned, BitTranspose>();
             test_construction_errors::<4, Unsigned, BitTranspose>();

From 7a971922cdb297d2b700dfdf9a3628a928ba620b Mon Sep 17 00:00:00 2001
From: "Alex Razumov (from Dev Box)" <alrazu@microsoft.com>
Date: Thu, 22 Jan 2026 21:37:05 -0800
Subject: [PATCH 10/26] Optimizing more tests for miri

---
 .../src/algorithms/kmeans/lloyds.rs           | 20 +++++++++++++++++++
 .../src/algorithms/kmeans/plusplus.rs         |  5 +++++
 diskann-quantization/src/minmax/quantizer.rs  |  5 +++++
 diskann-quantization/src/minmax/vectors.rs    |  8 +++++++-
 .../src/product/tables/transposed/pivots.rs   | 12 ++++++++++-
 5 files changed, 48 insertions(+), 2 deletions(-)

diff --git a/diskann-quantization/src/algorithms/kmeans/lloyds.rs b/diskann-quantization/src/algorithms/kmeans/lloyds.rs
index 46e7c591d..56c641b0e 100644
--- a/diskann-quantization/src/algorithms/kmeans/lloyds.rs
+++ b/diskann-quantization/src/algorithms/kmeans/lloyds.rs
@@ -615,6 +615,7 @@ mod tests {
         //
         // Similarly, we need to ensure we have both an even and odd number of centers,
         // so bound this up to 5.
+        #[cfg(not(miri))]
         for ndata in 1..=35 {
             for ncenters in 1..=5 {
                 for dim in 1..=4 {
@@ -622,6 +623,15 @@ mod tests {
                 }
             }
         }
+
+        #[cfg(miri)]
+        for ndata in 34..=35 {
+            for ncenters in 4..=5 {
+                for dim in 3..=4 {
+                    test_miri_distances_in_place_impl(ndata, ncenters, dim);
+                }
+            }
+        }
     }
 
     // End-to-end test.
@@ -729,6 +739,7 @@ mod tests {
     #[test]
     fn end_to_end_test() {
         let mut rng = StdRng::seed_from_u64(0xff22c38d0f0531bf);
+        #[cfg(not(miri))]
         let setup = EndToEndSetup {
             ncenters: 11,
             ndim: 4,
@@ -736,6 +747,15 @@ mod tests {
             step_between_clusters: 20,
             ntrials: 10,
         };
+
+        #[cfg(miri)]
+        let setup = EndToEndSetup {
+            ncenters: 3,
+            ndim: 4,
+            data_per_center: 2,
+            step_between_clusters: 20,
+            ntrials: 2,
+        };
         end_to_end_test_impl(&setup, &mut rng);
     }
 
diff --git a/diskann-quantization/src/algorithms/kmeans/plusplus.rs b/diskann-quantization/src/algorithms/kmeans/plusplus.rs
index 117acab5b..efc2ab544 100644
--- a/diskann-quantization/src/algorithms/kmeans/plusplus.rs
+++ b/diskann-quantization/src/algorithms/kmeans/plusplus.rs
@@ -683,6 +683,11 @@ mod tests {
     fn test_update_distances() {
         let mut rng = StdRng::seed_from_u64(0x56c94b53c73e4fd9);
         for num_points in 0..48 {
+            #[cfg(miri)]
+            if num_points % 7 != 0 {
+                continue;
+            }
+
             for dim in 1..4 {
                 test_update_distances_impl(num_points, dim, &mut rng);
             }
diff --git a/diskann-quantization/src/minmax/quantizer.rs b/diskann-quantization/src/minmax/quantizer.rs
index 13d624b0a..5e085d74e 100644
--- a/diskann-quantization/src/minmax/quantizer.rs
+++ b/diskann-quantization/src/minmax/quantizer.rs
@@ -475,6 +475,11 @@ mod minmax_quantizer_tests {
                 let scales = [1.0, 1.1, 0.9];
                 for (s, e) in scales.iter().zip($err) {
                     for d in 10..$dim {
+                        #[cfg(miri)]
+                        if d != $dim - 1 {
+                            continue;
+                        }
+
                         for _ in 0..TRIALS {
                             test_quantizer_encoding_random::<$nbits>(d, &mut rng, e, *s);
                         }
diff --git a/diskann-quantization/src/minmax/vectors.rs b/diskann-quantization/src/minmax/vectors.rs
index b8aac8a1c..52b15d17a 100644
--- a/diskann-quantization/src/minmax/vectors.rs
+++ b/diskann-quantization/src/minmax/vectors.rs
@@ -752,7 +752,13 @@ mod minmax_vector_tests {
             #[test]
             fn $name() {
                 let mut rng = StdRng::seed_from_u64($seed);
-                for dim in 1..(bit_scale::<$nbits>() as usize) {
+                const MAX_DIM: usize = (bit_scale::<$nbits>() as usize);
+                for dim in 1..=MAX_DIM {
+                    #[cfg(miri)]
+                    if dim != MAX_DIM {
+                        continue;
+                    }
+
                     for _ in 0..TRIALS {
                         test_minmax_compensated_vectors::<$nbits, _>(dim, &mut rng);
                     }
diff --git a/diskann-quantization/src/product/tables/transposed/pivots.rs b/diskann-quantization/src/product/tables/transposed/pivots.rs
index a6d96c256..f4dcd9f36 100644
--- a/diskann-quantization/src/product/tables/transposed/pivots.rs
+++ b/diskann-quantization/src/product/tables/transposed/pivots.rs
@@ -1418,7 +1418,7 @@ mod tests {
     fn run_test_happy_path() {
         // Step dimensions by 1 to test all possible residual combinations.
         let dims: Vec<usize> = if cfg!(miri) {
-            (1..=8).collect()
+            (7..=8).collect()
         } else {
             (1..=16).collect()
         };
@@ -1583,12 +1583,22 @@ mod tests {
     #[test]
     fn test_process_into() {
         let mut rng = StdRng::seed_from_u64(0x21dfb5f35dfe5639);
+
+        #[cfg(not(miri))]
         for total in 1..64 {
             for dim in 1..5 {
                 println!("on ({}, {})", total, dim);
                 test_process_into_impl(dim, total, &mut rng);
             }
         }
+
+        #[cfg(miri)]
+        for total in 63..64 {
+            for dim in 4..5 {
+                println!("on ({}, {})", total, dim);
+                test_process_into_impl(dim, total, &mut rng);
+            }
+        }
     }
 
     #[test]

From 9e7d4aed649c3e1b21c6689f8259991503ff4c3b Mon Sep 17 00:00:00 2001
From: "Alex Razumov (from Dev Box)" <alrazu@microsoft.com>
Date: Thu, 22 Jan 2026 23:33:34 -0800
Subject: [PATCH 11/26] Fixing unsigned_minmax_compensated_test_u1 test

---
 diskann-quantization/src/minmax/vectors.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/diskann-quantization/src/minmax/vectors.rs b/diskann-quantization/src/minmax/vectors.rs
index 52b15d17a..45948e708 100644
--- a/diskann-quantization/src/minmax/vectors.rs
+++ b/diskann-quantization/src/minmax/vectors.rs
@@ -766,7 +766,7 @@ mod minmax_vector_tests {
             }
         };
     }
-    test_minmax_compensated!(unsigned_minmax_compensated_test_u1, 1, 0xa32d5658097a1c35);
+    test_minmax_compensated!(unsigned_minmax_compensated_test_u1, 1, 0xa33d5658097a1c35);
     test_minmax_compensated!(unsigned_minmax_compensated_test_u2, 2, 0xaedf3d2a223b7b77);
     test_minmax_compensated!(unsigned_minmax_compensated_test_u4, 4, 0xf60c0c8d1aadc126);
     test_minmax_compensated!(unsigned_minmax_compensated_test_u8, 8, 0x09fa14c42a9d7d98);

From f288d34b03692484ac8b0d1b15631beaf436b29f Mon Sep 17 00:00:00 2001
From: "Alex Razumov (from Dev Box)" <alrazu@microsoft.com>
Date: Thu, 22 Jan 2026 23:48:32 -0800
Subject: [PATCH 12/26] More test optimizations

---
 .../src/product/tables/transposed/table.rs            | 11 ++++++++++-
 1 file changed, 10 insertions(+), 1 deletion(-)

diff --git a/diskann-quantization/src/product/tables/transposed/table.rs b/diskann-quantization/src/product/tables/transposed/table.rs
index c18828705..d20105e11 100644
--- a/diskann-quantization/src/product/tables/transposed/table.rs
+++ b/diskann-quantization/src/product/tables/transposed/table.rs
@@ -619,7 +619,7 @@ mod test_compression {
         let mut rng = StdRng::seed_from_u64(0x88e3d3366501ad6c);
 
         let num_data = if cfg!(miri) {
-            vec![0, 8, 9, 10, 11]
+            vec![7, 8]
         } else {
             vec![0, 1, 2, 3, 4, 16, 17, 18, 19]
         };
@@ -916,11 +916,20 @@ mod test_compression {
     #[test]
     fn test_process_into() {
         let mut rng = StdRng::seed_from_u64(0x0e3cf3ba4b27e7f8);
+
+        #[cfg(not(miri))]
         for num_chunks in 1..5 {
             for num_centers in 1..48 {
                 test_process_into_impl(num_chunks, num_centers, 2, &mut rng);
             }
         }
+
+        #[cfg(miri)]
+        for num_chunks in 4..5 {
+            for num_centers in 47..48 {
+                test_process_into_impl(num_chunks, num_centers, 2, &mut rng);
+            }
+        }
     }
 
     #[test]

From 7bc3e20e604cf6c045e298b64be9f8a8d1399ed9 Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Sat, 24 Jan 2026 02:26:26 +0000
Subject: [PATCH 13/26] Disable test_double_hadamard and test_padding_hadamard
 for miri, revert miri-specific changes

Co-authored-by: arrayka <1551741+arrayka@users.noreply.github.com>
---
 .../algorithms/transforms/double_hadamard.rs   | 18 +++---------------
 .../algorithms/transforms/padding_hadamard.rs  | 17 +++--------------
 2 files changed, 6 insertions(+), 29 deletions(-)

diff --git a/diskann-quantization/src/algorithms/transforms/double_hadamard.rs b/diskann-quantization/src/algorithms/transforms/double_hadamard.rs
index 20fdf42db..da9d7c4af 100644
--- a/diskann-quantization/src/algorithms/transforms/double_hadamard.rs
+++ b/diskann-quantization/src/algorithms/transforms/double_hadamard.rs
@@ -400,6 +400,7 @@ mod tests {
     test_utils::delegate_transformer!(DoubleHadamard<GlobalAllocator>);
 
     #[test]
+    #[cfg_attr(miri, ignore)]
     fn test_double_hadamard() {
         // Inner product computations are more susceptible to floating point error.
         // Instead of using ULP here, we fall back to using absolute and relative error.
@@ -417,7 +418,6 @@ mod tests {
         //
         // Subsampling results in poor preservation of inner products, so we skip it
         // altogether.
-        #[cfg(not(miri))]
         let subsampled_errors = test_utils::ErrorSetup {
             norm: test_utils::Check::absrel(0.0, 2e-2),
             l2: test_utils::Check::absrel(0.0, 2e-2),
@@ -425,9 +425,6 @@ mod tests {
         };
 
         let target_dim = |v| TargetDim::Override(NonZeroUsize::new(v).unwrap());
-
-        // Miri is extremely slow, so we skip the larger tests there.
-        #[cfg(not(miri))]
         let dim_combos = [
             // Natural
             (15, 15, true, TargetDim::Same, &natural_errors),
@@ -445,18 +442,9 @@ mod tests {
             (1024, 1023, false, target_dim(1023), &subsampled_errors),
             (1000, 999, false, target_dim(999), &subsampled_errors),
         ];
-        #[cfg(miri)]
-        let dim_combos = [(15, 15, true, target_dim(15), &natural_errors)];
 
-        cfg_if::cfg_if! {
-            if #[cfg(miri)] {
-                let trials_per_combo = 1;
-                let trials_per_dim = 1;
-            } else {
-                let trials_per_combo = 20;
-                let trials_per_dim = 100;
-            }
-        }
+        let trials_per_combo = 20;
+        let trials_per_dim = 100;
 
         let mut rng = StdRng::seed_from_u64(0x6d1699abe066147);
         for (input, output, preserves_norms, target, errors) in dim_combos {
diff --git a/diskann-quantization/src/algorithms/transforms/padding_hadamard.rs b/diskann-quantization/src/algorithms/transforms/padding_hadamard.rs
index 656a1b582..fd70a3c2f 100644
--- a/diskann-quantization/src/algorithms/transforms/padding_hadamard.rs
+++ b/diskann-quantization/src/algorithms/transforms/padding_hadamard.rs
@@ -446,6 +446,7 @@ mod tests {
     // This tests the natural hadamard transform where the output dimension is upgraded
     // to the next power of 2.
     #[test]
+    #[cfg_attr(miri, ignore)]
     fn test_padding_hadamard() {
         // Inner product computations are more susceptible to floating point error.
         // Instead of using ULP here, we fall back to using absolute and relative error.
@@ -463,7 +464,6 @@ mod tests {
         //
         // Subsampling results in poor preservation of inner products, so we skip it
         // altogether.
-        #[cfg(not(miri))]
         let subsampled_errors = test_utils::ErrorSetup {
             norm: test_utils::Check::absrel(0.0, 1e-1),
             l2: test_utils::Check::absrel(0.0, 1e-1),
@@ -472,8 +472,6 @@ mod tests {
 
         let target_dim = |v| TargetDim::Override(NonZeroUsize::new(v).unwrap());
 
-        // Miri is extremely slow, so we skip the larger tests there.
-        #[cfg(not(miri))]
         let dim_combos = [
             // Natural
             (15, 16, true, target_dim(16), &natural_errors),
@@ -489,18 +487,9 @@ mod tests {
             (1000, 1000, false, TargetDim::Same, &subsampled_errors),
             (500, 1000, false, target_dim(1000), &subsampled_errors),
         ];
-        #[cfg(miri)]
-        let dim_combos = [(15, 16, true, target_dim(16), &natural_errors)];
 
-        cfg_if::cfg_if! {
-            if #[cfg(miri)] {
-                let trials_per_combo = 1;
-                let trials_per_dim = 1;
-            } else {
-                let trials_per_combo = 20;
-                let trials_per_dim = 100;
-            }
-        }
+        let trials_per_combo = 20;
+        let trials_per_dim = 100;
 
         let mut rng = StdRng::seed_from_u64(0x6d1699abe0626147);
         for (input, output, preserves_norms, target, errors) in dim_combos {

From 0833183608eec6859d9b964742816dbf0d048808 Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Sat, 24 Jan 2026 02:37:59 +0000
Subject: [PATCH 14/26] Disable test_distances_in_place and
 minmax_quantizer_tests for miri, apply cfg!(miri) pattern to end_to_end_test

Co-authored-by: arrayka <1551741+arrayka@users.noreply.github.com>
---
 .../src/algorithms/kmeans/lloyds.rs           | 53 ++++++-------------
 diskann-quantization/src/minmax/quantizer.rs  |  6 +--
 2 files changed, 18 insertions(+), 41 deletions(-)

diff --git a/diskann-quantization/src/algorithms/kmeans/lloyds.rs b/diskann-quantization/src/algorithms/kmeans/lloyds.rs
index 56c641b0e..796b69836 100644
--- a/diskann-quantization/src/algorithms/kmeans/lloyds.rs
+++ b/diskann-quantization/src/algorithms/kmeans/lloyds.rs
@@ -565,9 +565,9 @@ mod tests {
     }
 
     #[test]
+    #[cfg_attr(miri, ignore)]
     fn test_distances_in_place() {
         let mut rng = StdRng::seed_from_u64(0xece88a9c6cd86a8a);
-        #[cfg(not(miri))]
         for ndata in 1..=31 {
             for ncenters in 1..=5 {
                 for dim in 1..=4 {
@@ -575,15 +575,6 @@ mod tests {
                 }
             }
         }
-
-        #[cfg(miri)]
-        for ndata in 31..=31 {
-            for ncenters in 5..=5 {
-                for dim in 4..=4 {
-                    test_distances_in_place_impl(ndata, ncenters, dim, TRIALS, &mut rng);
-                }
-            }
-        }
     }
 
     // We do not perform any value-dependent control-flow for memory accesses.
@@ -615,7 +606,6 @@ mod tests {
         //
         // Similarly, we need to ensure we have both an even and odd number of centers,
         // so bound this up to 5.
-        #[cfg(not(miri))]
         for ndata in 1..=35 {
             for ncenters in 1..=5 {
                 for dim in 1..=4 {
@@ -623,15 +613,6 @@ mod tests {
                 }
             }
         }
-
-        #[cfg(miri)]
-        for ndata in 34..=35 {
-            for ncenters in 4..=5 {
-                for dim in 3..=4 {
-                    test_miri_distances_in_place_impl(ndata, ncenters, dim);
-                }
-            }
-        }
     }
 
     // End-to-end test.
@@ -739,22 +720,22 @@ mod tests {
     #[test]
     fn end_to_end_test() {
         let mut rng = StdRng::seed_from_u64(0xff22c38d0f0531bf);
-        #[cfg(not(miri))]
-        let setup = EndToEndSetup {
-            ncenters: 11,
-            ndim: 4,
-            data_per_center: 8,
-            step_between_clusters: 20,
-            ntrials: 10,
-        };
-
-        #[cfg(miri)]
-        let setup = EndToEndSetup {
-            ncenters: 3,
-            ndim: 4,
-            data_per_center: 2,
-            step_between_clusters: 20,
-            ntrials: 2,
+        let setup = if cfg!(miri) {
+            EndToEndSetup {
+                ncenters: 3,
+                ndim: 4,
+                data_per_center: 2,
+                step_between_clusters: 20,
+                ntrials: 2,
+            }
+        } else {
+            EndToEndSetup {
+                ncenters: 11,
+                ndim: 4,
+                data_per_center: 8,
+                step_between_clusters: 20,
+                ntrials: 10,
+            }
         };
         end_to_end_test_impl(&setup, &mut rng);
     }
diff --git a/diskann-quantization/src/minmax/quantizer.rs b/diskann-quantization/src/minmax/quantizer.rs
index 5e085d74e..0eef68164 100644
--- a/diskann-quantization/src/minmax/quantizer.rs
+++ b/diskann-quantization/src/minmax/quantizer.rs
@@ -337,6 +337,7 @@ impl_functor!(MinMaxCosineNormalized);
 // Tests //
 ///////////
 #[cfg(test)]
+#[cfg_attr(miri, ignore)]
 mod minmax_quantizer_tests {
     use std::num::NonZeroUsize;
 
@@ -475,11 +476,6 @@ mod minmax_quantizer_tests {
                 let scales = [1.0, 1.1, 0.9];
                 for (s, e) in scales.iter().zip($err) {
                     for d in 10..$dim {
-                        #[cfg(miri)]
-                        if d != $dim - 1 {
-                            continue;
-                        }
-
                         for _ in 0..TRIALS {
                             test_quantizer_encoding_random::<$nbits>(d, &mut rng, e, *s);
                         }

From bf86fef0684d431307664a2513c1f8bb007566d0 Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Sat, 24 Jan 2026 02:41:49 +0000
Subject: [PATCH 15/26] Revert miri-specific loop skip in minmax vectors,
 disable minmax_vector_tests module for miri

Co-authored-by: arrayka <1551741+arrayka@users.noreply.github.com>
---
 diskann-quantization/src/minmax/vectors.rs | 6 +-----
 1 file changed, 1 insertion(+), 5 deletions(-)

diff --git a/diskann-quantization/src/minmax/vectors.rs b/diskann-quantization/src/minmax/vectors.rs
index 45948e708..4b3b7764f 100644
--- a/diskann-quantization/src/minmax/vectors.rs
+++ b/diskann-quantization/src/minmax/vectors.rs
@@ -489,6 +489,7 @@ where
 ///////////
 
 #[cfg(test)]
+#[cfg_attr(miri, ignore)]
 mod minmax_vector_tests {
     use diskann_utils::Reborrow;
     use rand::{
@@ -754,11 +755,6 @@ mod minmax_vector_tests {
                 let mut rng = StdRng::seed_from_u64($seed);
                 const MAX_DIM: usize = (bit_scale::<$nbits>() as usize);
                 for dim in 1..=MAX_DIM {
-                    #[cfg(miri)]
-                    if dim != MAX_DIM {
-                        continue;
-                    }
-
                     for _ in 0..TRIALS {
                         test_minmax_compensated_vectors::<$nbits, _>(dim, &mut rng);
                     }

From 5a9dc325cb68fa9f2400112404449283a6d088f6 Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Mon, 26 Jan 2026 04:58:19 +0000
Subject: [PATCH 16/26] Use #[cfg(not(miri))] instead of #[cfg_attr(miri,
 ignore)] for test_distances_in_place

Co-authored-by: arrayka <1551741+arrayka@users.noreply.github.com>
---
 diskann-quantization/src/algorithms/kmeans/lloyds.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/diskann-quantization/src/algorithms/kmeans/lloyds.rs b/diskann-quantization/src/algorithms/kmeans/lloyds.rs
index 796b69836..4b8b4a029 100644
--- a/diskann-quantization/src/algorithms/kmeans/lloyds.rs
+++ b/diskann-quantization/src/algorithms/kmeans/lloyds.rs
@@ -565,7 +565,7 @@ mod tests {
     }
 
     #[test]
-    #[cfg_attr(miri, ignore)]
+    #[cfg(not(miri))]
     fn test_distances_in_place() {
         let mut rng = StdRng::seed_from_u64(0xece88a9c6cd86a8a);
         for ndata in 1..=31 {

From a9cdeb74a1455956d9e663bb480fa225560cee33 Mon Sep 17 00:00:00 2001
From: "Alex Razumov (from Dev Box)" <alrazu@microsoft.com>
Date: Sun, 25 Jan 2026 21:58:29 -0800
Subject: [PATCH 17/26] Minor clean-up

---
 .../src/algorithms/transforms/double_hadamard.rs                | 2 +-
 .../src/algorithms/transforms/padding_hadamard.rs               | 2 +-
 diskann-quantization/src/minmax/quantizer.rs                    | 2 +-
 diskann-quantization/src/minmax/vectors.rs                      | 2 +-
 4 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/diskann-quantization/src/algorithms/transforms/double_hadamard.rs b/diskann-quantization/src/algorithms/transforms/double_hadamard.rs
index da9d7c4af..d5b4f26b0 100644
--- a/diskann-quantization/src/algorithms/transforms/double_hadamard.rs
+++ b/diskann-quantization/src/algorithms/transforms/double_hadamard.rs
@@ -400,7 +400,7 @@ mod tests {
     test_utils::delegate_transformer!(DoubleHadamard<GlobalAllocator>);
 
     #[test]
-    #[cfg_attr(miri, ignore)]
+    #[cfg(not(miri))]
     fn test_double_hadamard() {
         // Inner product computations are more susceptible to floating point error.
         // Instead of using ULP here, we fall back to using absolute and relative error.
diff --git a/diskann-quantization/src/algorithms/transforms/padding_hadamard.rs b/diskann-quantization/src/algorithms/transforms/padding_hadamard.rs
index fd70a3c2f..aa2c76b45 100644
--- a/diskann-quantization/src/algorithms/transforms/padding_hadamard.rs
+++ b/diskann-quantization/src/algorithms/transforms/padding_hadamard.rs
@@ -446,7 +446,7 @@ mod tests {
     // This tests the natural hadamard transform where the output dimension is upgraded
     // to the next power of 2.
     #[test]
-    #[cfg_attr(miri, ignore)]
+    #[cfg(not(miri))]
     fn test_padding_hadamard() {
         // Inner product computations are more susceptible to floating point error.
         // Instead of using ULP here, we fall back to using absolute and relative error.
diff --git a/diskann-quantization/src/minmax/quantizer.rs b/diskann-quantization/src/minmax/quantizer.rs
index 0eef68164..e9f10f651 100644
--- a/diskann-quantization/src/minmax/quantizer.rs
+++ b/diskann-quantization/src/minmax/quantizer.rs
@@ -337,7 +337,7 @@ impl_functor!(MinMaxCosineNormalized);
 // Tests //
 ///////////
 #[cfg(test)]
-#[cfg_attr(miri, ignore)]
+#[cfg(not(miri))]
 mod minmax_quantizer_tests {
     use std::num::NonZeroUsize;
 
diff --git a/diskann-quantization/src/minmax/vectors.rs b/diskann-quantization/src/minmax/vectors.rs
index 4b3b7764f..51510cf82 100644
--- a/diskann-quantization/src/minmax/vectors.rs
+++ b/diskann-quantization/src/minmax/vectors.rs
@@ -489,7 +489,7 @@ where
 ///////////
 
 #[cfg(test)]
-#[cfg_attr(miri, ignore)]
+#[cfg(not(miri))]
 mod minmax_vector_tests {
     use diskann_utils::Reborrow;
     use rand::{

From 399c945bd720cc853e6acfceac7b80871a4ba0f1 Mon Sep 17 00:00:00 2001
From: "Alex Razumov (from Dev Box)" <alrazu@microsoft.com>
Date: Sun, 25 Jan 2026 22:29:44 -0800
Subject: [PATCH 18/26] Fixing unused code

---
 .../src/algorithms/kmeans/lloyds.rs           | 25 ++++++++-----------
 .../algorithms/transforms/double_hadamard.rs  |  2 +-
 .../src/algorithms/transforms/mod.rs          |  2 ++
 .../algorithms/transforms/padding_hadamard.rs | 10 +++++---
 4 files changed, 20 insertions(+), 19 deletions(-)

diff --git a/diskann-quantization/src/algorithms/kmeans/lloyds.rs b/diskann-quantization/src/algorithms/kmeans/lloyds.rs
index 4b8b4a029..f6b575fba 100644
--- a/diskann-quantization/src/algorithms/kmeans/lloyds.rs
+++ b/diskann-quantization/src/algorithms/kmeans/lloyds.rs
@@ -457,14 +457,15 @@ pub fn lloyds(
 
 #[cfg(test)]
 mod tests {
-    use diskann_utils::{lazy_format, views::Matrix};
+    #[cfg(not(miri))]
+    use diskann_utils::lazy_format;
+    use diskann_utils::views::Matrix;
     use diskann_vector::{distance::SquaredL2, PureDistanceFunction};
-    use rand::{
-        distr::{Distribution, Uniform},
-        rngs::StdRng,
-        seq::{IndexedRandom, SliceRandom},
-        Rng, SeedableRng,
-    };
+    #[cfg(not(miri))]
+    use rand::distr::{Distribution, Uniform};
+    #[cfg(not(miri))]
+    use rand::seq::IndexedRandom;
+    use rand::{rngs::StdRng, seq::SliceRandom, Rng, SeedableRng};
 
     use super::*;
 
@@ -477,6 +478,7 @@ mod tests {
     // relatively quickly.
     //
     // Outside of rare validations, Miri tests go through a different path for speed purposes.
+    #[cfg(not(miri))]
     fn test_distances_in_place_impl<R: Rng>(
         ndata: usize,
         ncenters: usize,
@@ -556,13 +558,8 @@ mod tests {
         }
     }
 
-    cfg_if::cfg_if! {
-        if #[cfg(miri)] {
-            const TRIALS: usize = 1;
-        } else {
-            const TRIALS: usize = 100;
-        }
-    }
+    #[cfg(not(miri))]
+    const TRIALS: usize = 100;
 
     #[test]
     #[cfg(not(miri))]
diff --git a/diskann-quantization/src/algorithms/transforms/double_hadamard.rs b/diskann-quantization/src/algorithms/transforms/double_hadamard.rs
index d5b4f26b0..c5740a988 100644
--- a/diskann-quantization/src/algorithms/transforms/double_hadamard.rs
+++ b/diskann-quantization/src/algorithms/transforms/double_hadamard.rs
@@ -387,6 +387,7 @@ where
 ///////////
 
 #[cfg(test)]
+#[cfg(not(miri))]
 mod tests {
     use diskann_utils::lazy_format;
     use rand::{rngs::StdRng, SeedableRng};
@@ -400,7 +401,6 @@ mod tests {
     test_utils::delegate_transformer!(DoubleHadamard<GlobalAllocator>);
 
     #[test]
-    #[cfg(not(miri))]
     fn test_double_hadamard() {
         // Inner product computations are more susceptible to floating point error.
         // Instead of using ULP here, we fall back to using absolute and relative error.
diff --git a/diskann-quantization/src/algorithms/transforms/mod.rs b/diskann-quantization/src/algorithms/transforms/mod.rs
index 867e1ebd2..4205a605e 100644
--- a/diskann-quantization/src/algorithms/transforms/mod.rs
+++ b/diskann-quantization/src/algorithms/transforms/mod.rs
@@ -28,6 +28,7 @@ crate::utils::features! {
 mod utils;
 
 #[cfg(test)]
+#[cfg(not(miri))]
 mod test_utils;
 
 // reexports
@@ -355,4 +356,5 @@ pub enum TargetDim {
 }
 
 #[cfg(test)]
+#[cfg(not(miri))]
 test_utils::delegate_transformer!(Transform<crate::alloc::GlobalAllocator>);
diff --git a/diskann-quantization/src/algorithms/transforms/padding_hadamard.rs b/diskann-quantization/src/algorithms/transforms/padding_hadamard.rs
index aa2c76b45..535f5c624 100644
--- a/diskann-quantization/src/algorithms/transforms/padding_hadamard.rs
+++ b/diskann-quantization/src/algorithms/transforms/padding_hadamard.rs
@@ -366,14 +366,15 @@ where
 
 #[cfg(test)]
 mod tests {
+    #[cfg(not(miri))]
     use diskann_utils::lazy_format;
     use rand::{rngs::StdRng, SeedableRng};
 
     use super::*;
-    use crate::{
-        algorithms::transforms::{test_utils, Transform, TransformKind},
-        alloc::GlobalAllocator,
-    };
+
+    #[cfg(not(miri))]
+    use crate::algorithms::transforms::{test_utils, Transform, TransformKind};
+    use crate::alloc::GlobalAllocator;
 
     // Since we use a slightly non-obvious strategy for applying the +/-1 permutation, we
     // test its behavior explicitly.
@@ -441,6 +442,7 @@ mod tests {
         assert_eq!(output[15], 0.0f32);
     }
 
+    #[cfg(not(miri))]
     test_utils::delegate_transformer!(PaddingHadamard<GlobalAllocator>);
 
     // This tests the natural hadamard transform where the output dimension is upgraded

From f20fa83f451f7d131eee7180908d61ad847b97ce Mon Sep 17 00:00:00 2001
From: "Alex Razumov (from Dev Box)" <alrazu@microsoft.com>
Date: Mon, 26 Jan 2026 11:39:57 -0800
Subject: [PATCH 19/26] Addressed comments

---
 .../src/algorithms/kmeans/common.rs           | 26 ++++++-------------
 diskann-quantization/src/bits/distances.rs    |  6 -----
 diskann-quantization/src/bits/slice.rs        | 10 -------
 .../src/product/tables/transposed/pivots.rs   | 14 +++-------
 .../src/product/tables/transposed/table.rs    | 18 ++++++-------
 5 files changed, 21 insertions(+), 53 deletions(-)

diff --git a/diskann-quantization/src/algorithms/kmeans/common.rs b/diskann-quantization/src/algorithms/kmeans/common.rs
index 4808b6fa5..13a6a8f04 100644
--- a/diskann-quantization/src/algorithms/kmeans/common.rs
+++ b/diskann-quantization/src/algorithms/kmeans/common.rs
@@ -565,16 +565,11 @@ mod tests {
 
     #[test]
     fn test_block_transpose_16() {
-        #[cfg(not(miri))]
-        for nrows in 0..128 {
-            for ncols in 0..5 {
-                test_block_transpose::<16>(nrows, ncols);
-            }
-        }
+        let row_range = if cfg!(miri) { 127..128 } else { 0..128 };
+        let column_range = if cfg!(miri) { 4..5 } else { 0..5 };
 
-        #[cfg(miri)]
-        for nrows in 127..128 {
-            for ncols in 4..5 {
+        for nrows in row_range {
+            for ncols in column_range.clone() {
                 test_block_transpose::<16>(nrows, ncols);
             }
         }
@@ -582,16 +577,11 @@ mod tests {
 
     #[test]
     fn test_block_transpose_8() {
-        #[cfg(not(miri))]
-        for nrows in 0..128 {
-            for ncols in 0..5 {
-                test_block_transpose::<8>(nrows, ncols);
-            }
-        }
+        let row_range = if cfg!(miri) { 127..128 } else { 0..128 };
+        let column_range = if cfg!(miri) { 4..5 } else { 0..5 };
 
-        #[cfg(miri)]
-        for nrows in 127..128 {
-            for ncols in 4..5 {
+        for nrows in row_range {
+            for ncols in column_range.clone() {
                 test_block_transpose::<8>(nrows, ncols);
             }
         }
diff --git a/diskann-quantization/src/bits/distances.rs b/diskann-quantization/src/bits/distances.rs
index e888dccf0..9d1266e25 100644
--- a/diskann-quantization/src/bits/distances.rs
+++ b/diskann-quantization/src/bits/distances.rs
@@ -2003,12 +2003,6 @@ mod tests {
         let dist = Uniform::new_inclusive(min, max).unwrap();
 
         for dim in 0..dim_max {
-            // Only run the maximum dimension when running under miri.
-            #[cfg(miri)]
-            if dim != dim_max - 1 {
-                continue;
-            }
-
             let mut x_reference: Vec<u8> = vec![0; dim];
             let mut y_reference: Vec<u8> = vec![0; dim];
 
diff --git a/diskann-quantization/src/bits/slice.rs b/diskann-quantization/src/bits/slice.rs
index a08708f4c..fb77cefff 100644
--- a/diskann-quantization/src/bits/slice.rs
+++ b/diskann-quantization/src/bits/slice.rs
@@ -1512,11 +1512,6 @@ mod tests {
     fn test_binary_dense() {
         let mut rng = StdRng::seed_from_u64(0xb3c95e8e19d3842e);
         for len in 0..MAX_DIM {
-            #[cfg(miri)]
-            if len != MAX_DIM - 1 {
-                continue;
-            }
-
             test_send_and_sync::<1, Binary, Dense>();
             test_empty::<1, Binary, Dense>();
             test_construction_errors::<1, Binary, Dense>();
@@ -1563,11 +1558,6 @@ mod tests {
     fn test_4bit_bit_transpose() {
         let mut rng = StdRng::seed_from_u64(0xb3c95e8e19d3842e);
         for len in 0..MAX_DIM {
-            #[cfg(miri)]
-            if len != MAX_DIM - 1 {
-                continue;
-            }
-
             test_send_and_sync::<4, Unsigned, BitTranspose>();
             test_empty::<4, Unsigned, BitTranspose>();
             test_construction_errors::<4, Unsigned, BitTranspose>();
diff --git a/diskann-quantization/src/product/tables/transposed/pivots.rs b/diskann-quantization/src/product/tables/transposed/pivots.rs
index f4dcd9f36..c9d0c62bb 100644
--- a/diskann-quantization/src/product/tables/transposed/pivots.rs
+++ b/diskann-quantization/src/product/tables/transposed/pivots.rs
@@ -1584,17 +1584,11 @@ mod tests {
     fn test_process_into() {
         let mut rng = StdRng::seed_from_u64(0x21dfb5f35dfe5639);
 
-        #[cfg(not(miri))]
-        for total in 1..64 {
-            for dim in 1..5 {
-                println!("on ({}, {})", total, dim);
-                test_process_into_impl(dim, total, &mut rng);
-            }
-        }
+        let total_range = if cfg!(miri) { 1..48 } else { 1..64 };
+        let dim_range = if cfg!(miri) { 4..5 } else { 1..5 };
 
-        #[cfg(miri)]
-        for total in 63..64 {
-            for dim in 4..5 {
+        for total in total_range {
+            for dim in dim_range.clone() {
                 println!("on ({}, {})", total, dim);
                 test_process_into_impl(dim, total, &mut rng);
             }
diff --git a/diskann-quantization/src/product/tables/transposed/table.rs b/diskann-quantization/src/product/tables/transposed/table.rs
index d20105e11..33eeeeaa7 100644
--- a/diskann-quantization/src/product/tables/transposed/table.rs
+++ b/diskann-quantization/src/product/tables/transposed/table.rs
@@ -917,16 +917,16 @@ mod test_compression {
     fn test_process_into() {
         let mut rng = StdRng::seed_from_u64(0x0e3cf3ba4b27e7f8);
 
-        #[cfg(not(miri))]
-        for num_chunks in 1..5 {
-            for num_centers in 1..48 {
-                test_process_into_impl(num_chunks, num_centers, 2, &mut rng);
-            }
-        }
+        let num_chunks_range = if cfg!(miri) { 4..5 } else { 1..5 };
+
+        let num_centers: Vec<usize> = if cfg!(miri) {
+            vec![1, 7, 16, 33, 47]
+        } else {
+            (1..48).collect()
+        };
 
-        #[cfg(miri)]
-        for num_chunks in 4..5 {
-            for num_centers in 47..48 {
+        for num_chunks in num_chunks_range {
+            for num_centers in num_centers.clone() {
                 test_process_into_impl(num_chunks, num_centers, 2, &mut rng);
             }
         }

From 90d61f97aa6c6e86139cb1599dc64bd255720f36 Mon Sep 17 00:00:00 2001
From: "Alex Razumov (from Dev Box)" <alrazu@microsoft.com>
Date: Mon, 26 Jan 2026 14:31:01 -0800
Subject: [PATCH 20/26] Experiment with gh pools

---
 .github/workflows/ci.yml | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 04108b22f..1fd2d78c4 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -96,8 +96,8 @@ jobs:
     strategy:
       matrix:
         os:
-          - windows-latest
-          - ubuntu-latest
+          - [ self-hosted, 1ES.Pool=1es-vscode-oss-windows-2022-x64 ]
+          - [ self-hosted, 1ES.Pool=1es-vscode-oss-ubuntu-22.04-x64 ]
 
     steps:
       - uses: actions/checkout@v4
@@ -129,8 +129,8 @@ jobs:
     strategy:
       matrix:
         os:
-          - windows-latest
-          - ubuntu-latest
+          - [ self-hosted, 1ES.Pool=1es-vscode-oss-windows-2022-x64 ]
+          - [ self-hosted, 1ES.Pool=1es-vscode-oss-ubuntu-22.04-x64 ]
 
     steps:
       - uses: actions/checkout@v4
@@ -207,7 +207,7 @@ jobs:
   miri:
     needs: basics
     name: miri-test
-    runs-on: ubuntu-latest
+    runs-on: [ self-hosted, 1ES.Pool=1es-vscode-oss-ubuntu-22.04-x64 ]
     continue-on-error: true
     steps:
       - uses: actions/checkout@v4

From 993716e35831744774471250fa1000dd3f31aff0 Mon Sep 17 00:00:00 2001
From: "Alex Razumov (from Dev Box)" <alrazu@microsoft.com>
Date: Mon, 26 Jan 2026 14:50:09 -0800
Subject: [PATCH 21/26] Revert "Experiment with gh pools"

This reverts commit 90d61f97aa6c6e86139cb1599dc64bd255720f36.
---
 .github/workflows/ci.yml | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 1fd2d78c4..04108b22f 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -96,8 +96,8 @@ jobs:
     strategy:
       matrix:
         os:
-          - [ self-hosted, 1ES.Pool=1es-vscode-oss-windows-2022-x64 ]
-          - [ self-hosted, 1ES.Pool=1es-vscode-oss-ubuntu-22.04-x64 ]
+          - windows-latest
+          - ubuntu-latest
 
     steps:
       - uses: actions/checkout@v4
@@ -129,8 +129,8 @@ jobs:
     strategy:
       matrix:
         os:
-          - [ self-hosted, 1ES.Pool=1es-vscode-oss-windows-2022-x64 ]
-          - [ self-hosted, 1ES.Pool=1es-vscode-oss-ubuntu-22.04-x64 ]
+          - windows-latest
+          - ubuntu-latest
 
     steps:
       - uses: actions/checkout@v4
@@ -207,7 +207,7 @@ jobs:
   miri:
     needs: basics
     name: miri-test
-    runs-on: [ self-hosted, 1ES.Pool=1es-vscode-oss-ubuntu-22.04-x64 ]
+    runs-on: ubuntu-latest
     continue-on-error: true
     steps:
       - uses: actions/checkout@v4

From b0582172b932e5e1af83b966354ef30861cb0e97 Mon Sep 17 00:00:00 2001
From: "Alex Razumov (from Dev Box)" <alrazu@microsoft.com>
Date: Mon, 26 Jan 2026 17:49:24 -0800
Subject: [PATCH 22/26] Run Miri after PR merge only

---
 .github/workflows/ci.yml | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 04108b22f..34a81822f 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -207,6 +207,8 @@ jobs:
   miri:
     needs: basics
     name: miri-test
+    # This step is slow, so it only runs after a PR merge to avoid slowing down pre-merge checks.
+    if: ${{ github.event_name == 'push' }}
     runs-on: ubuntu-latest
     continue-on-error: true
     steps:

From 4fb02970b2b4f097cec0fe217545f247f29d99b1 Mon Sep 17 00:00:00 2001
From: "Alex Razumov (from Dev Box)" <alrazu@microsoft.com>
Date: Tue, 27 Jan 2026 13:36:25 -0800
Subject: [PATCH 23/26] Merge branch 'main' into
 copilot/enable-miri-tests-ci-yml


From 60889c36e583eac0bff334350190ce326676ba94 Mon Sep 17 00:00:00 2001
From: "Alex Razumov (from Dev Box)" <alrazu@microsoft.com>
Date: Fri, 30 Jan 2026 18:44:05 -0800
Subject: [PATCH 24/26] Addressed feedback

---
 diskann-quantization/src/algorithms/heap.rs                 | 3 +++
 diskann-quantization/src/bits/distances.rs                  | 2 +-
 diskann-quantization/src/product/tables/transposed/table.rs | 2 +-
 3 files changed, 5 insertions(+), 2 deletions(-)

diff --git a/diskann-quantization/src/algorithms/heap.rs b/diskann-quantization/src/algorithms/heap.rs
index 3943cdd30..d78aac2aa 100644
--- a/diskann-quantization/src/algorithms/heap.rs
+++ b/diskann-quantization/src/algorithms/heap.rs
@@ -389,6 +389,9 @@ mod tests {
 
         // Heap of size 2.
         fuzz_test_impl(2, 101, &mut rng);
+        
+        // Heap of size 10.
+        fuzz_test_impl(10, 101, &mut rng);
 
         // Miri is extremely slow, so we skip the larger tests there.
         #[cfg(not(miri))]
diff --git a/diskann-quantization/src/bits/distances.rs b/diskann-quantization/src/bits/distances.rs
index 9d1266e25..529643e12 100644
--- a/diskann-quantization/src/bits/distances.rs
+++ b/diskann-quantization/src/bits/distances.rs
@@ -2092,7 +2092,7 @@ mod tests {
 
     cfg_if::cfg_if! {
         if #[cfg(miri)] {
-            const MAX_DIM: usize = 8;
+            const MAX_DIM: usize = 132;
             const TRIALS_PER_DIM: usize = 1;
         } else {
             const MAX_DIM: usize = 256;
diff --git a/diskann-quantization/src/product/tables/transposed/table.rs b/diskann-quantization/src/product/tables/transposed/table.rs
index 33eeeeaa7..36d42dabd 100644
--- a/diskann-quantization/src/product/tables/transposed/table.rs
+++ b/diskann-quantization/src/product/tables/transposed/table.rs
@@ -619,7 +619,7 @@ mod test_compression {
         let mut rng = StdRng::seed_from_u64(0x88e3d3366501ad6c);
 
         let num_data = if cfg!(miri) {
-            vec![7, 8]
+            vec![0, 7, 8, 10]
         } else {
             vec![0, 1, 2, 3, 4, 16, 17, 18, 19]
         };

From 2351954ca626676ce6cf770ef4245a319fb3ed18 Mon Sep 17 00:00:00 2001
From: "Alex Razumov (from Dev Box)" <alrazu@microsoft.com>
Date: Fri, 30 Jan 2026 22:13:19 -0800
Subject: [PATCH 25/26] Fix formatting

---
 diskann-quantization/src/algorithms/heap.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/diskann-quantization/src/algorithms/heap.rs b/diskann-quantization/src/algorithms/heap.rs
index d78aac2aa..943f17d15 100644
--- a/diskann-quantization/src/algorithms/heap.rs
+++ b/diskann-quantization/src/algorithms/heap.rs
@@ -389,7 +389,7 @@ mod tests {
 
         // Heap of size 2.
         fuzz_test_impl(2, 101, &mut rng);
-        
+
         // Heap of size 10.
         fuzz_test_impl(10, 101, &mut rng);
 

From f92478c97b0d7b89886c528708b5923a75f1c1ff Mon Sep 17 00:00:00 2001
From: "Alex Razumov (from Dev Box)" <alrazu@microsoft.com>
Date: Fri, 30 Jan 2026 22:27:31 -0800
Subject: [PATCH 26/26] Temporarly enable miri in prs

---
 .github/workflows/ci.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 5262800f1..b5fe117a5 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -204,7 +204,7 @@ jobs:
     needs: basics
     name: miri-test
     # This step is slow, so it only runs after a PR merge to avoid slowing down pre-merge checks.
-    if: ${{ github.event_name == 'push' }}
+    # if: ${{ github.event_name == 'push' }}
     runs-on: ubuntu-latest
     continue-on-error: true
     steps: