diff --git a/folding/src/lib.rs b/folding/src/lib.rs
index 1cd94a940e..8e34be8aae 100644
--- a/folding/src/lib.rs
+++ b/folding/src/lib.rs
@@ -218,7 +218,7 @@ impl<'a, CF: FoldingConfig> FoldingScheme<'a, CF> {
         let error_evals = error.map(|e| Evaluations::from_vec_and_domain(e, self.domain));
 
         // Committing to the cross terms
-        // Default blinder for commiting to the cross terms
+        // Default blinder for committing to the cross terms
         let blinders = PolyComm::new(vec![ScalarField::<CF>::one()]);
         let error_commitments = error_evals
             .iter()
diff --git a/folding/tests/test_folding_with_quadriticization.rs b/folding/tests/test_folding_with_quadriticization.rs
index 2d23f76510..12a4a43df1 100644
--- a/folding/tests/test_folding_with_quadriticization.rs
+++ b/folding/tests/test_folding_with_quadriticization.rs
@@ -181,7 +181,7 @@ impl FoldingEnv<Fp, TestInstance, TestWitness, TestColumn, TestChallenge, Dynami
     }
 
     // this is exclusively for dynamic selectors aiming to make use of optimization
-    // as clasic static selectors will be handle as normal structure columns in col()
+    // as classic static selectors will be handle as normal structure columns in col()
     // the implementation of this if the same as col(), it is just separated as they
     // have different types to resolve
     fn selector(&self, s: &DynamicSelector, side: Side) -> &[Fp] {
diff --git a/folding/tests/test_quadraticization.rs b/folding/tests/test_quadraticization.rs
index 84f0df360e..b0a9cfea20 100644
--- a/folding/tests/test_quadraticization.rs
+++ b/folding/tests/test_quadraticization.rs
@@ -1,4 +1,4 @@
-//! quadraticization test, check that diferent cases result in the expected number of columns
+//! quadraticization test, check that different cases result in the expected number of columns
 //! being added
 use ark_poly::Radix2EvaluationDomain;
 use folding::{
diff --git a/ivc/tests/simple.rs b/ivc/tests/simple.rs
index c651e33652..47d4b63bc7 100644
--- a/ivc/tests/simple.rs
+++ b/ivc/tests/simple.rs
@@ -271,7 +271,7 @@ pub fn heavy_test_simple_add() {
             .map(|x| FoldingCompatibleExpr::from(x.clone()))
             .collect();
 
-        // IVC column expression should be shifted to the right to accomodate
+        // IVC column expression should be shifted to the right to accommodate
         // app witness.
         let ivc_mapper = &(|Variable { col, row }| {
             let rel_offset: usize = AdditionColumn::COUNT;
diff --git a/kimchi/src/snarky/constraint_system.rs b/kimchi/src/snarky/constraint_system.rs
index ed53a40e32..68cb88e732 100644
--- a/kimchi/src/snarky/constraint_system.rs
+++ b/kimchi/src/snarky/constraint_system.rs
@@ -625,7 +625,7 @@ impl<Field: PrimeField> SnarkyConstraintSystem<Field> {
         let public_input_size = self.public_input_size.unwrap();
         let pub_selectors: Vec<_> = vec![
             Field::one(),
-            // TODO: unecessary
+            // TODO: unnecessary
             Field::zero(),
             Field::zero(),
             Field::zero(),
diff --git a/kimchi/src/snarky/errors.rs b/kimchi/src/snarky/errors.rs
index c267bf5126..34ce17ff5a 100644
--- a/kimchi/src/snarky/errors.rs
+++ b/kimchi/src/snarky/errors.rs
@@ -12,7 +12,7 @@ pub type SnarkyRuntimeResult<T> = std::result::Result<T, Box<SnarkyRuntimeError>
 pub type SnarkyCompileResult<T> = std::result::Result<T, SnarkyCompilationError>;
 
 #[derive(Debug, Error)]
-#[error("an error ocurred in snarky")]
+#[error("an error occurred in snarky")]
 pub struct RealSnarkyError {
     /// The actual error.
     pub source: SnarkyError,
diff --git a/msm/src/fec/interpreter.rs b/msm/src/fec/interpreter.rs
index ce3f78b39c..7bc16698a1 100644
--- a/msm/src/fec/interpreter.rs
+++ b/msm/src/fec/interpreter.rs
@@ -289,7 +289,7 @@ pub fn constrain_ec_addition<
         .enumerate()
     {
         if i % 6 == 5 {
-            // This should be a diferent range check depending on which big-limb we're processing?
+            // This should be a different range check depending on which big-limb we're processing?
             // So instead of one type of lookup we will have 5 different ones?
             env.lookup(LookupTable::RangeCheck9Abs, vec![x.clone()]);
         } else {
diff --git a/msm/src/logup.rs b/msm/src/logup.rs
index 19ba65a191..f38c2ff171 100644
--- a/msm/src/logup.rs
+++ b/msm/src/logup.rs
@@ -553,7 +553,7 @@ pub mod prover {
         /// Create an environment for the prover to create a proof for the Logup protocol.
         /// The protocol does suppose that the individual lookup terms are
         /// committed as part of the columns.
-        /// Therefore, the protocol only focus on commiting to the "grand
+        /// Therefore, the protocol only focus on committing to the "grand
         /// product sum" and the "row-accumulated" values.
         pub fn create<
             OpeningProof: OpenProof<G>,
diff --git a/msm/src/test/test_circuit/interpreter.rs b/msm/src/test/test_circuit/interpreter.rs
index afb72942fd..7331a19ff5 100644
--- a/msm/src/test/test_circuit/interpreter.rs
+++ b/msm/src/test/test_circuit/interpreter.rs
@@ -162,7 +162,7 @@ pub fn constrain_test_fixed_sel_degree_7_with_constants<
     env: &mut Env,
 ) {
     let a0 = Env::read_column(env, TestColumn::A(0));
-    let fourty_two = Env::constant(F::from(42u32));
+    let forty_two = Env::constant(F::from(42u32));
     let three = Env::constant(F::from(3u32));
     let b0 = Env::read_column(env, TestColumn::B(0));
     let fixed_e = Env::read_column(env, TestColumn::FixedSel1);
@@ -170,7 +170,7 @@ pub fn constrain_test_fixed_sel_degree_7_with_constants<
     let a0_4 = a0_2.clone() * a0_2.clone();
     let a0_6 = a0_4.clone() * a0_2.clone();
     let a0_7 = a0_6.clone() * a0.clone();
-    let equation = three * a0_7.clone() + fourty_two * b0.clone() - fixed_e;
+    let equation = three * a0_7.clone() + forty_two * b0.clone() - fixed_e;
     env.assert_zero(equation.clone());
 }
 
diff --git a/poly-commitment/src/ipa.rs b/poly-commitment/src/ipa.rs
index 17c561bb3d..47dd316e5b 100644
--- a/poly-commitment/src/ipa.rs
+++ b/poly-commitment/src/ipa.rs
@@ -410,7 +410,7 @@ where
 
         let coeffs: Vec<_> = plnm.iter().map(|c| c.into_bigint()).collect();
 
-        // chunk while commiting
+        // chunk while committing
         let mut chunks = vec![];
         if is_zero {
             chunks.push(G::zero());
diff --git a/poly-commitment/src/utils.rs b/poly-commitment/src/utils.rs
index fc43883aff..f91ff421d6 100644
--- a/poly-commitment/src/utils.rs
+++ b/poly-commitment/src/utils.rs
@@ -63,7 +63,7 @@ impl<'a, F: Field> ScaledChunkedPolynomial<F, &'a [F]> {
 
 /// Combine the polynomials using a scalar (`polyscale`), creating a single
 /// unified polynomial to open. This function also accepts polynomials in
-/// evaluations form. In this case it applies an IFFT, and, if necessarry,
+/// evaluations form. In this case it applies an IFFT, and, if necessary,
 /// applies chunking to it (ie. split it in multiple polynomials of
 /// degree less than the SRS size).
 ///