diff --git a/Cargo.lock b/Cargo.lock
index fa7680d11..6e0fc4d6b 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -308,17 +308,6 @@ dependencies = [
  "version_check",
 ]
 
-[[package]]
-name = "getrandom"
-version = "0.2.14"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "94b22e06ecb0110981051723910cbf0b5f5e09a2062dd7663334ee79a9d1286c"
-dependencies = [
- "cfg-if",
- "libc",
- "wasi",
-]
-
 [[package]]
 name = "half"
 version = "2.4.1"
@@ -489,12 +478,6 @@ dependencies = [
  "plotters-backend",
 ]
 
-[[package]]
-name = "ppv-lite86"
-version = "0.2.17"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5b40af805b3121feab8a3c29f04d8ad262fa8e0561883e7653e024ae4479e6de"
-
 [[package]]
 name = "proc-macro2"
 version = "1.0.81"
@@ -519,18 +502,6 @@ version = "0.8.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "34af8d1a0e25924bc5b7c43c079c942339d8f0a8b57c39049bef581b46327404"
 dependencies = [
- "libc",
- "rand_chacha",
- "rand_core",
-]
-
-[[package]]
-name = "rand_chacha"
-version = "0.3.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e6c10a63a0fa32252be49d21e7709d4d4baf8d231c2dbce1eaa8141b9b127d88"
-dependencies = [
- "ppv-lite86",
  "rand_core",
 ]
 
@@ -539,9 +510,6 @@ name = "rand_core"
 version = "0.6.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ec0be4795e2f6a28069bec0b5ff3e2ac9bafc99e6a9a7dc3547996c5c816922c"
-dependencies = [
- "getrandom",
-]
 
 [[package]]
 name = "rayon"
@@ -872,12 +840,6 @@ dependencies = [
  "winapi-util",
 ]
 
-[[package]]
-name = "wasi"
-version = "0.11.0+wasi-snapshot-preview1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9c8d87e72b64a3b4db28d11ce29237c246188f4f51057d65a7eab63b7987e423"
-
 [[package]]
 name = "wasm-bindgen"
 version = "0.2.92"
diff --git a/crates/prover/Cargo.toml b/crates/prover/Cargo.toml
index eb3dbc52c..3a9be22b6 100644
--- a/crates/prover/Cargo.toml
+++ b/crates/prover/Cargo.toml
@@ -14,11 +14,11 @@ itertools.workspace = true
 num-traits.workspace = true
 thiserror.workspace = true
 bytemuck = { workspace = true, features = ["derive"] }
+rand = { version = "0.8.5", default-features = false, features = ["small_rng"] }
 tracing.workspace = true
 
 [dev-dependencies]
 criterion = { version = "0.5.1", features = ["html_reports"] }
-rand = { version = "0.8.5", features = ["small_rng"] }
 test-log = { version = "0.2.15", features = ["trace"] }
 tracing-subscriber = "0.3.18"
 
diff --git a/crates/prover/benches/eval_at_point.rs b/crates/prover/benches/eval_at_point.rs
index dfc98dd8d..059817925 100644
--- a/crates/prover/benches/eval_at_point.rs
+++ b/crates/prover/benches/eval_at_point.rs
@@ -2,7 +2,7 @@ use criterion::{black_box, Criterion};
 
 #[cfg(target_arch = "x86_64")]
 pub fn cpu_eval_at_secure_point(c: &mut criterion::Criterion) {
-    use rand::rngs::StdRng;
+    use rand::rngs::SmallRng;
     use rand::{Rng, SeedableRng};
     use stwo_prover::core::backend::CPUBackend;
     use stwo_prover::core::circle::CirclePoint;
@@ -11,7 +11,7 @@ pub fn cpu_eval_at_secure_point(c: &mut criterion::Criterion) {
     use stwo_prover::core::poly::circle::{CanonicCoset, CircleEvaluation, PolyOps};
     use stwo_prover::core::poly::NaturalOrder;
     let log_size = 20;
-    let rng = &mut StdRng::seed_from_u64(0);
+    let mut rng = SmallRng::seed_from_u64(0);
 
     let domain = CanonicCoset::new(log_size as u32).circle_domain();
     let evaluation = CircleEvaluation::<CPUBackend, _, NaturalOrder>::new(
@@ -21,18 +21,8 @@ pub fn cpu_eval_at_secure_point(c: &mut criterion::Criterion) {
             .collect(),
     );
     let poly = evaluation.bit_reverse().interpolate();
-    let x = QM31::from_u32_unchecked(
-        rng.gen::<u32>(),
-        rng.gen::<u32>(),
-        rng.gen::<u32>(),
-        rng.gen::<u32>(),
-    );
-    let y = QM31::from_u32_unchecked(
-        rng.gen::<u32>(),
-        rng.gen::<u32>(),
-        rng.gen::<u32>(),
-        rng.gen::<u32>(),
-    );
+    let x: QM31 = rng.gen();
+    let y: QM31 = rng.gen();
 
     let point = CirclePoint { x, y };
     c.bench_function("cpu eval_at_secure_field_point 2^20", |b| {
@@ -44,7 +34,7 @@ pub fn cpu_eval_at_secure_point(c: &mut criterion::Criterion) {
 
 #[cfg(target_arch = "x86_64")]
 pub fn avx512_eval_at_secure_point(c: &mut criterion::Criterion) {
-    use rand::rngs::StdRng;
+    use rand::rngs::SmallRng;
     use rand::{Rng, SeedableRng};
     use stwo_prover::core::backend::avx512::AVX512Backend;
     use stwo_prover::core::circle::CirclePoint;
@@ -53,7 +43,7 @@ pub fn avx512_eval_at_secure_point(c: &mut criterion::Criterion) {
     use stwo_prover::core::poly::circle::{CanonicCoset, CircleEvaluation, PolyOps};
     use stwo_prover::core::poly::NaturalOrder;
     let log_size = 20;
-    let rng = &mut StdRng::seed_from_u64(0);
+    let mut rng = SmallRng::seed_from_u64(0);
 
     let domain = CanonicCoset::new(log_size as u32).circle_domain();
     let evaluation = CircleEvaluation::<AVX512Backend, BaseField, NaturalOrder>::new(
@@ -63,18 +53,8 @@ pub fn avx512_eval_at_secure_point(c: &mut criterion::Criterion) {
             .collect(),
     );
     let poly = evaluation.bit_reverse().interpolate();
-    let x = QM31::from_u32_unchecked(
-        rng.gen::<u32>(),
-        rng.gen::<u32>(),
-        rng.gen::<u32>(),
-        rng.gen::<u32>(),
-    );
-    let y = QM31::from_u32_unchecked(
-        rng.gen::<u32>(),
-        rng.gen::<u32>(),
-        rng.gen::<u32>(),
-        rng.gen::<u32>(),
-    );
+    let x: QM31 = rng.gen();
+    let y: QM31 = rng.gen();
 
     let point = CirclePoint { x, y };
     c.bench_function("avx eval_at_secure_field_point 2^20", |b| {
diff --git a/crates/prover/benches/field.rs b/crates/prover/benches/field.rs
index fd7eed062..7b63aa116 100644
--- a/crates/prover/benches/field.rs
+++ b/crates/prover/benches/field.rs
@@ -1,38 +1,17 @@
 use criterion::Criterion;
-use rand::rngs::ThreadRng;
-use rand::Rng;
+use rand::rngs::SmallRng;
+use rand::{Rng, SeedableRng};
 use stwo_prover::core::fields::cm31::CM31;
-use stwo_prover::core::fields::m31::{M31, P};
+use stwo_prover::core::fields::m31::M31;
 use stwo_prover::core::fields::qm31::SecureField;
+
 pub const N_ELEMENTS: usize = 1 << 16;
 pub const N_STATE_ELEMENTS: usize = 8;
 
-pub fn get_random_m31_element(rng: &mut ThreadRng) -> M31 {
-    M31::from_u32_unchecked(rng.gen::<u32>() % P)
-}
-
-pub fn get_random_cm31_element(rng: &mut ThreadRng) -> CM31 {
-    CM31::from_m31(get_random_m31_element(rng), get_random_m31_element(rng))
-}
-
-pub fn get_random_qm31_element(rng: &mut ThreadRng) -> SecureField {
-    SecureField::from_m31(
-        get_random_m31_element(rng),
-        get_random_m31_element(rng),
-        get_random_m31_element(rng),
-        get_random_m31_element(rng),
-    )
-}
-
 pub fn m31_operations_bench(c: &mut criterion::Criterion) {
-    let mut rng = rand::thread_rng();
-    let mut elements: Vec<M31> = Vec::new();
-    let mut state: [M31; N_STATE_ELEMENTS] =
-        [(); N_STATE_ELEMENTS].map(|_| get_random_m31_element(&mut rng));
-
-    for _ in 0..(N_ELEMENTS) {
-        elements.push(get_random_m31_element(&mut rng));
-    }
+    let mut rng = SmallRng::seed_from_u64(0);
+    let elements: Vec<M31> = (0..N_ELEMENTS).map(|_| rng.gen()).collect();
+    let mut state: [M31; N_STATE_ELEMENTS] = rng.gen();
 
     c.bench_function("M31 mul", |b| {
         b.iter(|| {
@@ -60,14 +39,9 @@ pub fn m31_operations_bench(c: &mut criterion::Criterion) {
 }
 
 pub fn cm31_operations_bench(c: &mut criterion::Criterion) {
-    let mut rng = rand::thread_rng();
-    let mut elements: Vec<CM31> = Vec::new();
-    let mut state: [CM31; N_STATE_ELEMENTS] =
-        [(); N_STATE_ELEMENTS].map(|_| get_random_cm31_element(&mut rng));
-
-    for _ in 0..(N_ELEMENTS) {
-        elements.push(get_random_cm31_element(&mut rng));
-    }
+    let mut rng = SmallRng::seed_from_u64(0);
+    let elements: Vec<CM31> = (0..N_ELEMENTS).map(|_| rng.gen()).collect();
+    let mut state: [CM31; N_STATE_ELEMENTS] = rng.gen();
 
     c.bench_function("CM31 mul", |b| {
         b.iter(|| {
@@ -95,14 +69,9 @@ pub fn cm31_operations_bench(c: &mut criterion::Criterion) {
 }
 
 pub fn qm31_operations_bench(c: &mut criterion::Criterion) {
-    let mut rng = rand::thread_rng();
-    let mut elements: Vec<SecureField> = Vec::new();
-    let mut state: [SecureField; N_STATE_ELEMENTS] =
-        [(); N_STATE_ELEMENTS].map(|_| get_random_qm31_element(&mut rng));
-
-    for _ in 0..(N_ELEMENTS) {
-        elements.push(get_random_qm31_element(&mut rng));
-    }
+    let mut rng = SmallRng::seed_from_u64(0);
+    let elements: Vec<SecureField> = (0..N_ELEMENTS).map(|_| rng.gen()).collect();
+    let mut state: [SecureField; N_STATE_ELEMENTS] = rng.gen();
 
     c.bench_function("SecureField mul", |b| {
         b.iter(|| {
@@ -138,15 +107,13 @@ pub fn avx512_m31_operations_bench(c: &mut criterion::Criterion) {
         return;
     }
 
-    let mut rng = rand::thread_rng();
+    let mut rng = SmallRng::seed_from_u64(0);
     let mut elements: Vec<PackedBaseField> = Vec::new();
     let mut states: Vec<PackedBaseField> =
         vec![PackedBaseField::from_array([1.into(); K_BLOCK_SIZE]); N_STATE_ELEMENTS];
 
     for _ in 0..(N_ELEMENTS / K_BLOCK_SIZE) {
-        elements.push(PackedBaseField::from_array(
-            [get_random_m31_element(&mut rng); K_BLOCK_SIZE],
-        ));
+        elements.push(PackedBaseField::from_array(rng.gen()));
     }
 
     c.bench_function("mul_avx512", |b| {
diff --git a/crates/prover/benches/matrix.rs b/crates/prover/benches/matrix.rs
index 61b3f3c7f..8e44a9887 100644
--- a/crates/prover/benches/matrix.rs
+++ b/crates/prover/benches/matrix.rs
@@ -1,5 +1,6 @@
 use criterion::{black_box, criterion_group, criterion_main, Criterion};
-use rand::Rng;
+use rand::rngs::SmallRng;
+use rand::{Rng, SeedableRng};
 use stwo_prover::core::fields::m31::{M31, P};
 use stwo_prover::core::fields::qm31::QM31;
 use stwo_prover::math::matrix::{RowMajorMatrix, SquareMatrix};
@@ -9,30 +10,22 @@ const QM31_MATRIX_SIZE: usize = 6;
 
 // TODO(ShaharS): Share code with other benchmarks.
 fn row_major_matrix_multiplication_bench(c: &mut Criterion) {
-    let mut rng = rand::thread_rng();
+    let mut rng = SmallRng::seed_from_u64(0);
 
     let matrix_m31 = RowMajorMatrix::<M31, MATRIX_SIZE>::new(
         (0..MATRIX_SIZE.pow(2))
-            .map(|_| M31::from_u32_unchecked(rng.gen::<u32>() % P))
+            .map(|_| rng.gen())
             .collect::<Vec<M31>>(),
     );
 
     let matrix_qm31 = RowMajorMatrix::<QM31, QM31_MATRIX_SIZE>::new(
         (0..QM31_MATRIX_SIZE.pow(2))
-            .map(|_| {
-                QM31::from_u32_unchecked(
-                    rng.gen::<u32>() % P,
-                    rng.gen::<u32>() % P,
-                    rng.gen::<u32>() % P,
-                    rng.gen::<u32>() % P,
-                )
-            })
+            .map(|_| rng.gen())
             .collect::<Vec<QM31>>(),
     );
 
     // Create vector M31.
-    let vec: [M31; MATRIX_SIZE] =
-        [(); MATRIX_SIZE].map(|_| M31::from_u32_unchecked(rng.gen::<u32>() % P));
+    let vec: [M31; MATRIX_SIZE] = rng.gen();
 
     // Create vector QM31.
     let vec_qm31: [QM31; QM31_MATRIX_SIZE] = [(); QM31_MATRIX_SIZE].map(|_| {
diff --git a/crates/prover/src/core/air/accumulation.rs b/crates/prover/src/core/air/accumulation.rs
index dca4bc8b9..4ceeb245e 100644
--- a/crates/prover/src/core/air/accumulation.rs
+++ b/crates/prover/src/core/air/accumulation.rs
@@ -159,7 +159,7 @@ mod tests {
     use std::array;
 
     use num_traits::Zero;
-    use rand::rngs::StdRng;
+    use rand::rngs::SmallRng;
     use rand::{Rng, SeedableRng};
 
     use super::*;
@@ -171,7 +171,7 @@ mod tests {
     #[test]
     fn test_point_evaluation_accumulator() {
         // Generate a vector of random sizes with a constant seed.
-        let rng = &mut StdRng::seed_from_u64(0);
+        let mut rng = SmallRng::seed_from_u64(0);
         const MAX_LOG_SIZE: u32 = 10;
         const MASK: u32 = P;
         let log_sizes = (0..100)
@@ -204,7 +204,7 @@ mod tests {
     #[test]
     fn test_domain_evaluation_accumulator() {
         // Generate a vector of random sizes with a constant seed.
-        let rng = &mut StdRng::seed_from_u64(0);
+        let mut rng = SmallRng::seed_from_u64(0);
         const LOG_SIZE_MIN: u32 = 4;
         const LOG_SIZE_BOUND: u32 = 10;
         const MASK: u32 = P;
diff --git a/crates/prover/src/core/backend/avx512/circle.rs b/crates/prover/src/core/backend/avx512/circle.rs
index 922fc46d1..170325a2f 100644
--- a/crates/prover/src/core/backend/avx512/circle.rs
+++ b/crates/prover/src/core/backend/avx512/circle.rs
@@ -332,7 +332,7 @@ fn slow_eval_at_point(
 #[cfg(all(target_arch = "x86_64", target_feature = "avx512f"))]
 #[cfg(test)]
 mod tests {
-    use rand::rngs::StdRng;
+    use rand::rngs::SmallRng;
     use rand::{Rng, SeedableRng};
 
     use crate::core::backend::avx512::circle::slow_eval_at_point;
@@ -341,9 +341,9 @@ mod tests {
     use crate::core::backend::Column;
     use crate::core::circle::CirclePoint;
     use crate::core::fields::m31::BaseField;
+    use crate::core::fields::qm31::SecureField;
     use crate::core::poly::circle::{CanonicCoset, CircleEvaluation, CirclePoly, PolyOps};
     use crate::core::poly::{BitReversedOrder, NaturalOrder};
-    use crate::qm31;
 
     #[test]
     fn test_interpolate_and_eval() {
@@ -426,7 +426,7 @@ mod tests {
     #[test]
     fn test_eval_securefield() {
         use crate::core::backend::avx512::fft::MIN_FFT_LOG_SIZE;
-        let rng = &mut StdRng::seed_from_u64(0);
+        let mut rng = SmallRng::seed_from_u64(0);
 
         for log_size in MIN_FFT_LOG_SIZE..(CACHED_FFT_LOG_SIZE + 2) {
             let domain = CanonicCoset::new(log_size as u32).circle_domain();
@@ -438,18 +438,8 @@ mod tests {
             );
             let poly = evaluation.bit_reverse().interpolate();
 
-            let x = qm31!(
-                rng.gen::<u32>(),
-                rng.gen::<u32>(),
-                rng.gen::<u32>(),
-                rng.gen::<u32>()
-            );
-            let y = qm31!(
-                rng.gen::<u32>(),
-                rng.gen::<u32>(),
-                rng.gen::<u32>(),
-                rng.gen::<u32>()
-            );
+            let x: SecureField = rng.gen();
+            let y: SecureField = rng.gen();
 
             let p = CirclePoint { x, y };
 
diff --git a/crates/prover/src/core/backend/avx512/cm31.rs b/crates/prover/src/core/backend/avx512/cm31.rs
index b2a060a65..1122bdb85 100644
--- a/crates/prover/src/core/backend/avx512/cm31.rs
+++ b/crates/prover/src/core/backend/avx512/cm31.rs
@@ -105,22 +105,21 @@ impl Mul<PackedBaseField> for PackedCM31 {
 #[cfg(all(target_arch = "x86_64", target_feature = "avx512f"))]
 #[cfg(test)]
 mod tests {
-    use rand::rngs::StdRng;
+    use rand::rngs::SmallRng;
     use rand::{Rng, SeedableRng};
 
     use super::*;
-    use crate::core::fields::m31::{M31, P};
 
     #[test]
     fn test_cm31avx512_basic_ops() {
-        let rng = &mut StdRng::seed_from_u64(0);
+        let mut rng = SmallRng::seed_from_u64(0);
         let x = PackedCM31([
-            PackedBaseField::from_array(std::array::from_fn(|_| M31::from(rng.gen::<u32>() % P))),
-            PackedBaseField::from_array(std::array::from_fn(|_| M31::from(rng.gen::<u32>() % P))),
+            PackedBaseField::from_array(rng.gen()),
+            PackedBaseField::from_array(rng.gen()),
         ]);
         let y = PackedCM31([
-            PackedBaseField::from_array(std::array::from_fn(|_| M31::from(rng.gen::<u32>() % P))),
-            PackedBaseField::from_array(std::array::from_fn(|_| M31::from(rng.gen::<u32>() % P))),
+            PackedBaseField::from_array(rng.gen()),
+            PackedBaseField::from_array(rng.gen()),
         ]);
         let sum = x + y;
         let diff = x - y;
diff --git a/crates/prover/src/core/backend/avx512/mod.rs b/crates/prover/src/core/backend/avx512/mod.rs
index a3747381c..f8b3b5e6c 100644
--- a/crates/prover/src/core/backend/avx512/mod.rs
+++ b/crates/prover/src/core/backend/avx512/mod.rs
@@ -274,12 +274,11 @@ impl FromIterator<SecureField> for SecureColumn<AVX512Backend> {
 #[cfg(all(target_arch = "x86_64", target_feature = "avx512f"))]
 #[cfg(test)]
 mod tests {
-    use rand::rngs::StdRng;
+    use rand::rngs::SmallRng;
     use rand::{Rng, SeedableRng};
 
     use super::*;
     use crate::core::backend::{Col, Column};
-    use crate::core::fields::m31::P;
 
     type B = AVX512Backend;
 
@@ -322,12 +321,10 @@ mod tests {
 
     #[test]
     fn test_packed_basefield_batch_inverse() {
-        let mut rng = StdRng::seed_from_u64(0);
-        let column = BaseFieldVec::from_iter(
-            (0..64).map(|_| BaseField::from_u32_unchecked(rng.gen::<u32>() % P)),
-        );
+        let mut rng = SmallRng::seed_from_u64(0);
+        let column = (0..64).map(|_| rng.gen()).collect::<BaseFieldVec>();
         let expected = column.data.iter().map(|e| e.inverse()).collect::<Vec<_>>();
-        let mut dst = BaseFieldVec::from_iter((0..64).map(|_| BaseField::zero()));
+        let mut dst = (0..64).map(|_| BaseField::zero()).collect::<BaseFieldVec>();
 
         <AVX512Backend as FieldOps<BaseField>>::batch_inverse(&column, &mut dst);
 
diff --git a/crates/prover/src/core/backend/avx512/qm31.rs b/crates/prover/src/core/backend/avx512/qm31.rs
index f63d8df61..ace542599 100644
--- a/crates/prover/src/core/backend/avx512/qm31.rs
+++ b/crates/prover/src/core/backend/avx512/qm31.rs
@@ -164,53 +164,16 @@ unsafe impl Zeroable for PackedSecureField {
 #[cfg(all(target_arch = "x86_64", target_feature = "avx512f"))]
 #[cfg(test)]
 mod tests {
-    use rand::rngs::StdRng;
+    use rand::rngs::SmallRng;
     use rand::{Rng, SeedableRng};
 
     use super::*;
-    use crate::core::backend::avx512::m31::PackedBaseField;
-    use crate::core::fields::cm31::CM31;
-    use crate::core::fields::m31::{M31, P};
 
     #[test]
     fn test_qm31avx512_basic_ops() {
-        let rng = &mut StdRng::seed_from_u64(0);
-        let x = PackedSecureField([
-            PackedCM31([
-                PackedBaseField::from_array(std::array::from_fn(|_| {
-                    M31::from(rng.gen::<u32>() % P)
-                })),
-                PackedBaseField::from_array(std::array::from_fn(|_| {
-                    M31::from(rng.gen::<u32>() % P)
-                })),
-            ]),
-            PackedCM31([
-                PackedBaseField::from_array(std::array::from_fn(|_| {
-                    M31::from(rng.gen::<u32>() % P)
-                })),
-                PackedBaseField::from_array(std::array::from_fn(|_| {
-                    M31::from(rng.gen::<u32>() % P)
-                })),
-            ]),
-        ]);
-        let y = PackedSecureField([
-            PackedCM31([
-                PackedBaseField::from_array(std::array::from_fn(|_| {
-                    M31::from(rng.gen::<u32>() % P)
-                })),
-                PackedBaseField::from_array(std::array::from_fn(|_| {
-                    M31::from(rng.gen::<u32>() % P)
-                })),
-            ]),
-            PackedCM31([
-                PackedBaseField::from_array(std::array::from_fn(|_| {
-                    M31::from(rng.gen::<u32>() % P)
-                })),
-                PackedBaseField::from_array(std::array::from_fn(|_| {
-                    M31::from(rng.gen::<u32>() % P)
-                })),
-            ]),
-        ]);
+        let mut rng = SmallRng::seed_from_u64(0);
+        let x = PackedSecureField::from_array(rng.gen());
+        let y = PackedSecureField::from_array(rng.gen());
         let sum = x + y;
         let diff = x - y;
         let prod = x * y;
@@ -223,19 +186,8 @@ mod tests {
 
     #[test]
     fn test_from_array() {
-        let rng = &mut StdRng::seed_from_u64(0);
-        let x_arr = std::array::from_fn(|_| {
-            QM31(
-                CM31(
-                    M31::from(rng.gen::<u32>() % P),
-                    M31::from(rng.gen::<u32>() % P),
-                ),
-                CM31(
-                    M31::from(rng.gen::<u32>() % P),
-                    M31::from(rng.gen::<u32>() % P),
-                ),
-            )
-        });
+        let mut rng = SmallRng::seed_from_u64(0);
+        let x_arr = std::array::from_fn(|_| rng.gen());
 
         let packed = PackedSecureField::from_array(x_arr);
         let to_arr = packed.to_array();
diff --git a/crates/prover/src/core/backend/cpu/mod.rs b/crates/prover/src/core/backend/cpu/mod.rs
index d102a4d63..d81de6e21 100644
--- a/crates/prover/src/core/backend/cpu/mod.rs
+++ b/crates/prover/src/core/backend/cpu/mod.rs
@@ -60,23 +60,13 @@ mod tests {
     use rand::rngs::SmallRng;
 
     use crate::core::backend::{CPUBackend, Column, FieldOps};
-    use crate::core::fields::m31::P;
     use crate::core::fields::qm31::QM31;
     use crate::core::fields::FieldExpOps;
 
     #[test]
     fn batch_inverse_test() {
         let mut rng = SmallRng::seed_from_u64(0);
-        let column: Vec<QM31> = (0..16)
-            .map(|_| {
-                QM31::from_u32_unchecked(
-                    rng.gen::<u32>() % P,
-                    rng.gen::<u32>() % P,
-                    rng.gen::<u32>() % P,
-                    rng.gen::<u32>() % P,
-                )
-            })
-            .collect();
+        let column = rng.gen::<[QM31; 16]>().to_vec();
         let expected = column.iter().map(|e| e.inverse()).collect_vec();
         let mut dst = Column::zeros(column.len());
 
@@ -89,16 +79,7 @@ mod tests {
     #[test]
     fn batch_inverse_reused_vec_test() {
         let mut rng = SmallRng::seed_from_u64(0);
-        let column: Vec<QM31> = (0..16)
-            .map(|_| {
-                QM31::from_u32_unchecked(
-                    rng.gen::<u32>() % P,
-                    rng.gen::<u32>() % P,
-                    rng.gen::<u32>() % P,
-                    rng.gen::<u32>() % P,
-                )
-            })
-            .collect();
+        let column = rng.gen::<[QM31; 16]>().to_vec();
         let expected = column.iter().map(|e| e.inverse()).collect_vec();
         let mut dst = Column::zeros(column.len());
 
diff --git a/crates/prover/src/core/fields/cm31.rs b/crates/prover/src/core/fields/cm31.rs
index b1f8e11fc..9154972f7 100644
--- a/crates/prover/src/core/fields/cm31.rs
+++ b/crates/prover/src/core/fields/cm31.rs
@@ -70,7 +70,8 @@ macro_rules! cm31 {
 
 #[cfg(test)]
 mod tests {
-    use rand::Rng;
+    use rand::rngs::SmallRng;
+    use rand::{Rng, SeedableRng};
 
     use super::CM31;
     use crate::core::fields::m31::P;
@@ -105,10 +106,8 @@ mod tests {
 
     #[test]
     fn test_into_slice() {
-        let mut rng = rand::thread_rng();
-        let x = (0..100)
-            .map(|_| cm31!(rng.gen::<u32>(), rng.gen::<u32>()))
-            .collect::<Vec<CM31>>();
+        let mut rng = SmallRng::seed_from_u64(0);
+        let x = (0..100).map(|_| rng.gen()).collect::<Vec<CM31>>();
 
         let slice = CM31::into_slice(&x);
 
diff --git a/crates/prover/src/core/fields/m31.rs b/crates/prover/src/core/fields/m31.rs
index 23bf06546..53028cb90 100644
--- a/crates/prover/src/core/fields/m31.rs
+++ b/crates/prover/src/core/fields/m31.rs
@@ -4,6 +4,7 @@ use std::ops::{
 };
 
 use bytemuck::{Pod, Zeroable};
+use rand::distributions::{Distribution, Standard};
 
 use super::{ComplexConjugate, FieldExpOps};
 use crate::impl_field;
@@ -125,6 +126,13 @@ impl From<i32> for M31 {
     }
 }
 
+impl Distribution<M31> for Standard {
+    // Not intended for cryptographic use. Should only be used in tests and benchmarks.
+    fn sample<R: rand::Rng + ?Sized>(&self, rng: &mut R) -> M31 {
+        M31(rng.gen_range(0..P))
+    }
+}
+
 #[cfg(test)]
 #[macro_export]
 macro_rules! m31 {
@@ -158,7 +166,8 @@ fn sqn<const N: usize, T: FieldExpOps>(mut v: T) -> T {
 
 #[cfg(test)]
 mod tests {
-    use rand::Rng;
+    use rand::rngs::SmallRng;
+    use rand::{Rng, SeedableRng};
 
     use super::{M31, P};
     use crate::core::fields::m31::{pow2147483645, BaseField};
@@ -182,7 +191,7 @@ mod tests {
 
     #[test]
     fn test_basic_ops() {
-        let mut rng = rand::thread_rng();
+        let mut rng = SmallRng::seed_from_u64(0);
         for _ in 0..10000 {
             let x: u32 = rng.gen::<u32>() % P;
             let y: u32 = rng.gen::<u32>() % P;
@@ -194,10 +203,8 @@ mod tests {
 
     #[test]
     fn test_into_slice() {
-        let mut rng = rand::thread_rng();
-        let x = (0..100)
-            .map(|_| m31!(rng.gen::<u32>()))
-            .collect::<Vec<M31>>();
+        let mut rng = SmallRng::seed_from_u64(0);
+        let x = (0..100).map(|_| rng.gen()).collect::<Vec<M31>>();
 
         let slice = M31::into_slice(&x);
 
diff --git a/crates/prover/src/core/fields/mod.rs b/crates/prover/src/core/fields/mod.rs
index 35ab99ee1..fbeefbb94 100644
--- a/crates/prover/src/core/fields/mod.rs
+++ b/crates/prover/src/core/fields/mod.rs
@@ -274,7 +274,8 @@ macro_rules! impl_field {
 /// Used to extend a field (with characteristic M31) by 2.
 #[macro_export]
 macro_rules! impl_extension_field {
-    ($field_name: ty, $extended_field_name: ty) => {
+    ($field_name: ident, $extended_field_name: ty) => {
+        use rand::distributions::{Distribution, Standard};
         use $crate::core::fields::ExtensionOf;
 
         impl ExtensionOf<M31> for $field_name {
@@ -445,38 +446,42 @@ macro_rules! impl_extension_field {
                 );
             }
         }
+
+        impl Distribution<$field_name> for Standard {
+            // Not intended for cryptographic use. Should only be used in tests and benchmarks.
+            fn sample<R: rand::Rng + ?Sized>(&self, rng: &mut R) -> $field_name {
+                $field_name(rng.gen(), rng.gen())
+            }
+        }
     };
 }
 
 #[cfg(test)]
 mod tests {
     use num_traits::Zero;
-    use rand::rngs::StdRng;
+    use rand::rngs::SmallRng;
     use rand::{Rng, SeedableRng};
 
-    use crate::core::fields::m31::{M31, P};
+    use crate::core::fields::m31::M31;
     use crate::core::fields::FieldExpOps;
 
     #[test]
     fn test_slice_batch_inverse() {
-        let mut rng = StdRng::seed_from_u64(0);
-        let elements: Vec<M31> = (0..16)
-            .map(|_| M31::from_u32_unchecked(rng.gen::<u32>() % P))
-            .collect();
+        let mut rng = SmallRng::seed_from_u64(0);
+        let elements: [M31; 16] = rng.gen();
         let expected = elements.iter().map(|e| e.inverse()).collect::<Vec<_>>();
         let mut dst = [M31::zero(); 16];
 
         M31::batch_inverse(&elements, &mut dst);
+
         assert_eq!(expected, dst);
     }
 
     #[test]
     #[should_panic]
     fn test_slice_batch_inverse_wrong_dst_size() {
-        let mut rng = StdRng::seed_from_u64(0);
-        let elements: Vec<M31> = (0..16)
-            .map(|_| M31::from_u32_unchecked(rng.gen::<u32>() % P))
-            .collect();
+        let mut rng = SmallRng::seed_from_u64(0);
+        let elements: [M31; 16] = rng.gen();
         let mut dst = [M31::zero(); 15];
 
         M31::batch_inverse(&elements, &mut dst);
diff --git a/crates/prover/src/core/fields/qm31.rs b/crates/prover/src/core/fields/qm31.rs
index 9b739b15f..54cee0d4f 100644
--- a/crates/prover/src/core/fields/qm31.rs
+++ b/crates/prover/src/core/fields/qm31.rs
@@ -90,7 +90,8 @@ macro_rules! qm31 {
 #[cfg(test)]
 mod tests {
     use num_traits::One;
-    use rand::Rng;
+    use rand::rngs::SmallRng;
+    use rand::{Rng, SeedableRng};
 
     use super::QM31;
     use crate::core::fields::m31::P;
@@ -125,17 +126,8 @@ mod tests {
 
     #[test]
     fn test_into_slice() {
-        let mut rng = rand::thread_rng();
-        let x = (0..100)
-            .map(|_| {
-                qm31!(
-                    rng.gen::<u32>(),
-                    rng.gen::<u32>(),
-                    rng.gen::<u32>(),
-                    rng.gen::<u32>()
-                )
-            })
-            .collect::<Vec<QM31>>();
+        let mut rng = SmallRng::seed_from_u64(0);
+        let x = (0..100).map(|_| rng.gen()).collect::<Vec<QM31>>();
 
         let slice = QM31::into_slice(&x);
 
diff --git a/crates/prover/src/core/vcs/blake2_merkle.rs b/crates/prover/src/core/vcs/blake2_merkle.rs
index bbc787b19..6efc9ebfd 100644
--- a/crates/prover/src/core/vcs/blake2_merkle.rs
+++ b/crates/prover/src/core/vcs/blake2_merkle.rs
@@ -43,7 +43,7 @@ mod tests {
 
     use itertools::Itertools;
     use num_traits::Zero;
-    use rand::rngs::StdRng;
+    use rand::rngs::SmallRng;
     use rand::{Rng, SeedableRng};
 
     use crate::core::backend::CPUBackend;
@@ -63,7 +63,7 @@ mod tests {
         const N_QUERIES: usize = 7;
         let log_size_range = 6..9;
 
-        let rng = &mut StdRng::seed_from_u64(0);
+        let mut rng = SmallRng::seed_from_u64(0);
         let log_sizes = (0..N_COLS)
             .map(|_| rng.gen_range(log_size_range.clone()))
             .collect_vec();
diff --git a/crates/prover/src/examples/fibonacci/mod.rs b/crates/prover/src/examples/fibonacci/mod.rs
index 679efdb2b..b18e7548e 100644
--- a/crates/prover/src/examples/fibonacci/mod.rs
+++ b/crates/prover/src/examples/fibonacci/mod.rs
@@ -114,7 +114,7 @@ mod tests {
 
     use itertools::Itertools;
     use num_traits::One;
-    use rand::rngs::StdRng;
+    use rand::rngs::SmallRng;
     use rand::{Rng, SeedableRng};
 
     use super::{Fibonacci, MultiFibonacci};
@@ -130,7 +130,7 @@ mod tests {
     use crate::{m31, qm31};
 
     pub fn generate_test_queries(n_queries: usize, trace_length: usize) -> Vec<usize> {
-        let rng = &mut StdRng::seed_from_u64(0);
+        let mut rng = SmallRng::seed_from_u64(0);
         let mut queries: Vec<usize> = (0..n_queries)
             .map(|_| rng.gen_range(0..trace_length))
             .collect();