diff --git a/src/algebraic_props/sponge.rs b/src/algebraic_props/sponge.rs
index e1af413..3d15ea5 100644
--- a/src/algebraic_props/sponge.rs
+++ b/src/algebraic_props/sponge.rs
@@ -60,7 +60,7 @@ impl<
 
     pub fn absorb(&mut self, values: &[F]) {
         let mut rest = values;
-        // quickly fill the unfilled, then do full absorbtion rounds, then save the rest
+        // quickly fill the unfilled, then do full absorption rounds, then save the rest
         if rest.len() > AW - self.filled {
             self.filled = 0;
             let (to_use, other) = rest.split_at(AW - self.filled);
diff --git a/src/cs/gates/constants_allocator_as_explicit_constraint.rs b/src/cs/gates/constants_allocator_as_explicit_constraint.rs
index 104f6e6..29c53da 100644
--- a/src/cs/gates/constants_allocator_as_explicit_constraint.rs
+++ b/src/cs/gates/constants_allocator_as_explicit_constraint.rs
@@ -6,7 +6,7 @@ use super::*;
 // Even though it can be achieved by manual crafting of quotient terms,
 // we would like to make our lives easier. This gate ALWAYS adds 0, 1 and -1 as
 // constants, and can add an arbitrary set. Largely powers of two would be a good case,
-// even though they can be produced by just having FMA gate (that also shares coeffients) like 2 * 1 * 1 -> 2,
+// even though they can be produced by just having FMA gate (that also shares coefficients) like 2 * 1 * 1 -> 2,
 // 2 * 2 * 1 -> 4, etc
 
 #[derive(Derivative)]
diff --git a/src/cs/gates/uintx_add.rs b/src/cs/gates/uintx_add.rs
index 92591dc..2eebef6 100644
--- a/src/cs/gates/uintx_add.rs
+++ b/src/cs/gates/uintx_add.rs
@@ -6,7 +6,7 @@ use crate::{
 use super::*;
 
 // a + b + carry_in = c + 2^N * carry_out,
-// `carry_out` is boolean constrainted
+// `carry_out` is boolean constrained
 // but `c` is NOT. We will use reduction gate to perform decomposition of `c`, and separate range checks
 
 const UNIQUE_IDENTIFIER: &str = "a + b + carry_in = c + 2^N * carry_out";
diff --git a/src/cs/implementations/fri/mod.rs b/src/cs/implementations/fri/mod.rs
index 534f4a9..4d971bc 100644
--- a/src/cs/implementations/fri/mod.rs
+++ b/src/cs/implementations/fri/mod.rs
@@ -12,7 +12,7 @@ use std::mem::MaybeUninit;
 // Unfortunately we can not do it (unless we prove the opposite later on) due to e.g. https://www.youtube.com/watch?v=0DHoxCAsick - parallel repetition
 
 // So when we get presumably RS codes from quotening operation (f(x) - f(z))/(x - z) and linear combination of such terms,
-// we immediatelly pull challenges for such linear combination from quadratic extension, so our initial oracle for FRI containes Fp2 elements in the leafs.
+// we immediately pull challenges for such linear combination from quadratic extension, so our initial oracle for FRI containes Fp2 elements in the leafs.
 // Then on every step of interpolation we will take another challenge from Fp2 and continue
 
 // Another things is FRI soundness bound. FRI (not DEEP-FRI) is sound up to Johnson bound IF code size is much smaller
diff --git a/src/cs/implementations/lookup_argument.rs b/src/cs/implementations/lookup_argument.rs
index 90fdaa3..c7e36a5 100644
--- a/src/cs/implementations/lookup_argument.rs
+++ b/src/cs/implementations/lookup_argument.rs
@@ -218,7 +218,7 @@ pub(crate) fn compute_lookup_poly_pairs_over_general_purpose_columns<
         let aggregated_lookup_columns_inversed =
             P::vec_from_base_vec(aggregated_lookup_columns_inversed);
 
-        // we follow the same aproach as above - first prepare chunks, and then work over them
+        // we follow the same approach as above - first prepare chunks, and then work over them
 
         assert_eq!(
             variables_columns
diff --git a/src/cs/implementations/witness.rs b/src/cs/implementations/witness.rs
index be1f5e8..2c939ef 100644
--- a/src/cs/implementations/witness.rs
+++ b/src/cs/implementations/witness.rs
@@ -210,7 +210,7 @@ impl<
                             if var.is_placeholder() == false {
                                 *dst = witness_ref[var.0 as usize];
                             } else {
-                                // we can use 0 as a substitue for all undefined variables,
+                                // we can use 0 as a substitute for all undefined variables,
                                 // or add ZK into them
                             }
                         }