diff --git a/kimchi/src/bench.rs b/kimchi/src/bench.rs
index 97cb026a2e..57cd64ff80 100644
--- a/kimchi/src/bench.rs
+++ b/kimchi/src/bench.rs
@@ -77,7 +77,12 @@ impl BenchmarkCtx {
     }
 
     /// Produces a proof
-    pub fn create_proof(&self) -> (ProverProof<Vesta, OpeningProof<Vesta>>, Vec<Fp>) {
+    pub fn create_proof(
+        &self,
+    ) -> (
+        ProverProof<Vesta, OpeningProof<Vesta>, KIMCHI_COLS>,
+        Vec<Fp>,
+    ) {
         // create witness
         let witness: [Vec<Fp>; KIMCHI_COLS] = array::from_fn(|_| vec![1u32.into(); self.num_gates]);
 
@@ -97,7 +102,13 @@ impl BenchmarkCtx {
     }
 
     #[allow(clippy::type_complexity)]
-    pub fn batch_verification(&self, batch: &[(ProverProof<Vesta, OpeningProof<Vesta>>, Vec<Fp>)]) {
+    pub fn batch_verification(
+        &self,
+        batch: &[(
+            ProverProof<Vesta, OpeningProof<Vesta>, KIMCHI_COLS>,
+            Vec<Fp>,
+        )],
+    ) {
         // verify the proof
         let batch: Vec<_> = batch
             .iter()
diff --git a/kimchi/src/circuits/argument.rs b/kimchi/src/circuits/argument.rs
index d4bde64d82..2f862bf1d7 100644
--- a/kimchi/src/circuits/argument.rs
+++ b/kimchi/src/circuits/argument.rs
@@ -13,7 +13,6 @@ use serde::{Deserialize, Serialize};
 use super::{
     expr::{constraints::ExprOps, Cache, ConstantExpr, Constants},
     gate::{CurrOrNext, GateType},
-    wires::KIMCHI_COLS,
 };
 use CurrOrNext::{Curr, Next};
 
@@ -37,8 +36,8 @@ pub enum ArgumentType {
 /// created with ArgumentData and F = Field or F = PrimeField, then the constraints
 /// are built as expressions of real field elements and can be evaluated directly on
 /// the witness without using the prover.
-pub struct ArgumentEnv<F: 'static, T, const COLUMNS: usize = KIMCHI_COLS> {
-    data: Option<ArgumentData<F, COLUMNS>>,
+pub struct ArgumentEnv<F: 'static, T> {
+    data: Option<ArgumentData<F>>,
     phantom_data: PhantomData<T>,
 }
 
@@ -52,14 +51,10 @@ impl<F, T> Default for ArgumentEnv<F, T> {
     }
 }
 
-impl<F: Field, T: ExprOps<F>, const COLUMNS: usize> ArgumentEnv<F, T, COLUMNS> {
+impl<F: Field, T: ExprOps<F>> ArgumentEnv<F, T> {
     /// Initialize the environment for creating constraints of real field elements that can be
     /// evaluated directly over the witness without the prover/verifier
-    pub fn create(
-        witness: ArgumentWitness<F, COLUMNS>,
-        coeffs: Vec<F>,
-        constants: Constants<F>,
-    ) -> Self {
+    pub fn create(witness: ArgumentWitness<F>, coeffs: Vec<F>, constants: Constants<F>) -> Self {
         ArgumentEnv {
             data: Some(ArgumentData {
                 witness,
@@ -134,9 +129,9 @@ impl<F: Field, T: ExprOps<F>, const COLUMNS: usize> ArgumentEnv<F, T, COLUMNS> {
 }
 
 /// Argument environment data for constraints of field elements
-pub struct ArgumentData<F: 'static, const COLUMNS: usize = KIMCHI_COLS> {
+pub struct ArgumentData<F: 'static> {
     /// Witness rows
-    pub witness: ArgumentWitness<F, COLUMNS>,
+    pub witness: ArgumentWitness<F>,
     /// Gate coefficients
     pub coeffs: Vec<F>,
     /// Constants
@@ -144,14 +139,14 @@ pub struct ArgumentData<F: 'static, const COLUMNS: usize = KIMCHI_COLS> {
 }
 
 /// Witness data for a argument
-pub struct ArgumentWitness<T, const COLUMNS: usize = KIMCHI_COLS> {
+pub struct ArgumentWitness<T> {
     /// Witness for current row
-    pub curr: [T; COLUMNS],
+    pub curr: Vec<T>,
     /// Witness for next row
-    pub next: [T; COLUMNS],
+    pub next: Vec<T>,
 }
 
-impl<T, const COLUMNS: usize> std::ops::Index<(CurrOrNext, usize)> for ArgumentWitness<T, COLUMNS> {
+impl<T> std::ops::Index<(CurrOrNext, usize)> for ArgumentWitness<T> {
     type Output = T;
 
     fn index(&self, idx: (CurrOrNext, usize)) -> &T {
@@ -173,10 +168,7 @@ pub trait Argument<F: PrimeField> {
     const CONSTRAINTS: u32;
 
     /// Constraints for this argument
-    fn constraint_checks<T: ExprOps<F>, const COLUMNS: usize>(
-        env: &ArgumentEnv<F, T, COLUMNS>,
-        cache: &mut Cache,
-    ) -> Vec<T>;
+    fn constraint_checks<T: ExprOps<F>>(env: &ArgumentEnv<F, T>, cache: &mut Cache) -> Vec<T>;
 
     /// Returns the set of constraints required to prove this argument.
     fn constraints(cache: &mut Cache) -> Vec<E<F>> {
diff --git a/kimchi/src/circuits/expr.rs b/kimchi/src/circuits/expr.rs
index 90150e237f..7bf57b785d 100644
--- a/kimchi/src/circuits/expr.rs
+++ b/kimchi/src/circuits/expr.rs
@@ -2662,20 +2662,13 @@ pub mod constraints {
         fn literal(x: F) -> Self;
 
         // Witness variable
-        fn witness<const COLUMNS: usize>(
-            row: CurrOrNext,
-            col: usize,
-            env: Option<&ArgumentData<F, COLUMNS>>,
-        ) -> Self;
+        fn witness(row: CurrOrNext, col: usize, env: Option<&ArgumentData<F>>) -> Self;
 
         /// Coefficient
-        fn coeff<const COLUMNS: usize>(col: usize, env: Option<&ArgumentData<F, COLUMNS>>) -> Self;
+        fn coeff(col: usize, env: Option<&ArgumentData<F>>) -> Self;
 
         /// Create a constant
-        fn constant<const COLUMNS: usize>(
-            expr: ConstantExpr<F>,
-            env: Option<&ArgumentData<F, COLUMNS>>,
-        ) -> Self;
+        fn constant(expr: ConstantExpr<F>, env: Option<&ArgumentData<F>>) -> Self;
 
         /// Cache item
         fn cache(&self, cache: &mut Cache) -> Self;
@@ -2735,22 +2728,15 @@ pub mod constraints {
             Expr::Constant(ConstantExpr::Literal(x))
         }
 
-        fn witness<const COLUMNS: usize>(
-            row: CurrOrNext,
-            col: usize,
-            _: Option<&ArgumentData<F, COLUMNS>>,
-        ) -> Self {
+        fn witness(row: CurrOrNext, col: usize, _: Option<&ArgumentData<F>>) -> Self {
             witness(col, row)
         }
 
-        fn coeff<const COLUMNS: usize>(col: usize, _: Option<&ArgumentData<F, COLUMNS>>) -> Self {
+        fn coeff(col: usize, _: Option<&ArgumentData<F>>) -> Self {
             coeff(col)
         }
 
-        fn constant<const COLUMNS: usize>(
-            expr: ConstantExpr<F>,
-            _: Option<&ArgumentData<F, COLUMNS>>,
-        ) -> Self {
+        fn constant(expr: ConstantExpr<F>, _: Option<&ArgumentData<F>>) -> Self {
             Expr::Constant(expr)
         }
 
@@ -2800,28 +2786,21 @@ pub mod constraints {
             x
         }
 
-        fn witness<const COLUMNS: usize>(
-            row: CurrOrNext,
-            col: usize,
-            env: Option<&ArgumentData<F, COLUMNS>>,
-        ) -> Self {
+        fn witness(row: CurrOrNext, col: usize, env: Option<&ArgumentData<F>>) -> Self {
             match env {
                 Some(data) => data.witness[(row, col)],
                 None => panic!("Missing witness"),
             }
         }
 
-        fn coeff<const COLUMNS: usize>(col: usize, env: Option<&ArgumentData<F, COLUMNS>>) -> Self {
+        fn coeff(col: usize, env: Option<&ArgumentData<F>>) -> Self {
             match env {
                 Some(data) => data.coeffs[col],
                 None => panic!("Missing coefficients"),
             }
         }
 
-        fn constant<const COLUMNS: usize>(
-            expr: ConstantExpr<F>,
-            env: Option<&ArgumentData<F, COLUMNS>>,
-        ) -> Self {
+        fn constant(expr: ConstantExpr<F>, env: Option<&ArgumentData<F>>) -> Self {
             match env {
                 Some(data) => expr.value(&data.constants),
                 None => panic!("Missing constants"),
diff --git a/kimchi/src/circuits/gate.rs b/kimchi/src/circuits/gate.rs
index cdbd44a6a5..3163eeee5b 100644
--- a/kimchi/src/circuits/gate.rs
+++ b/kimchi/src/circuits/gate.rs
@@ -264,8 +264,7 @@ impl<F: PrimeField + SquareRootField> CircuitGate<F> {
             zk_rows: cs.zk_rows,
         };
         // Create the argument environment for the constraints over field elements
-        let env =
-            ArgumentEnv::<F, F, COLUMNS>::create(argument_witness, self.coeffs.clone(), constants);
+        let env = ArgumentEnv::<F, F>::create(argument_witness, self.coeffs.clone(), constants);
 
         // Check the wiring (i.e. copy constraints) for this gate
         // Note: Gates can operated on row Curr or Curr and Next.
@@ -300,9 +299,7 @@ impl<F: PrimeField + SquareRootField> CircuitGate<F> {
                 // TODO: implement the verification for the generic gate
                 vec![]
             }
-            GateType::Poseidon => {
-                poseidon::Poseidon::constraint_checks::<F, COLUMNS>(&env, &mut cache)
-            }
+            GateType::Poseidon => poseidon::Poseidon::constraint_checks(&env, &mut cache),
             GateType::CompleteAdd => complete_add::CompleteAdd::constraint_checks(&env, &mut cache),
             GateType::VarBaseMul => varbasemul::VarbaseMul::constraint_checks(&env, &mut cache),
             GateType::EndoMul => endosclmul::EndosclMul::constraint_checks(&env, &mut cache),
@@ -361,7 +358,7 @@ impl<F: PrimeField + SquareRootField> CircuitGate<F> {
         &self,
         row: usize,
         witness: &[Vec<F>; COLUMNS],
-    ) -> CircuitGateResult<ArgumentWitness<F, COLUMNS>> {
+    ) -> CircuitGateResult<ArgumentWitness<F>> {
         // Get the part of the witness relevant to this gate
         let witness_curr: [F; COLUMNS] = (0..witness.len())
             .map(|col| witness[col][row])
@@ -378,9 +375,9 @@ impl<F: PrimeField + SquareRootField> CircuitGate<F> {
             [F::zero(); COLUMNS]
         };
 
-        Ok(ArgumentWitness::<F, COLUMNS> {
-            curr: witness_curr,
-            next: witness_next,
+        Ok(ArgumentWitness::<F> {
+            curr: witness_curr.to_vec(),
+            next: witness_next.to_vec(),
         })
     }
 }
diff --git a/kimchi/src/circuits/lookup/lookups.rs b/kimchi/src/circuits/lookup/lookups.rs
index d8694c19d4..5a41485449 100644
--- a/kimchi/src/circuits/lookup/lookups.rs
+++ b/kimchi/src/circuits/lookup/lookups.rs
@@ -780,16 +780,12 @@ pub mod wasm {
             lookup: bool,
             range_check: bool,
             foreign_field_mul: bool,
-            keccak_round: bool,
-            keccak_sponge: bool,
         ) -> LookupPatterns {
             LookupPatterns {
                 xor,
                 lookup,
                 range_check,
                 foreign_field_mul,
-                keccak_round,
-                keccak_sponge,
             }
         }
     }
diff --git a/kimchi/src/circuits/lookup/tables/bits16.rs b/kimchi/src/circuits/lookup/tables/bits16.rs
index 91db8ae786..50ae56b613 100644
--- a/kimchi/src/circuits/lookup/tables/bits16.rs
+++ b/kimchi/src/circuits/lookup/tables/bits16.rs
@@ -6,6 +6,10 @@ use super::BITS16_TABLE_ID;
 //~ The lookup table for 16-bits
 
 /// Returns the lookup table for all 16-bit values
+///
+/// # Panics
+///
+/// Will panic if `data` is invalid.
 pub fn bits16_table<F: Field>() -> LookupTable<F> {
     let mut data = vec![vec![]; 1];
 
diff --git a/kimchi/src/circuits/lookup/tables/reset.rs b/kimchi/src/circuits/lookup/tables/reset.rs
index 9e359f3ad9..2be1e04bd3 100644
--- a/kimchi/src/circuits/lookup/tables/reset.rs
+++ b/kimchi/src/circuits/lookup/tables/reset.rs
@@ -8,6 +8,10 @@ use super::RESET_TABLE_ID;
 //~ The first column contains the 16-bit values, and the second column contains their expansion to 64-bit values.
 
 /// Returns the sparse lookup table
+///
+/// # Panics
+///
+/// Will panic if `data` is invalid.
 pub fn reset_table<F: Field>() -> LookupTable<F> {
     let mut data = vec![vec![]; 2];
 
diff --git a/kimchi/src/circuits/lookup/tables/sparse.rs b/kimchi/src/circuits/lookup/tables/sparse.rs
index e33130197f..e1a3fcc79d 100644
--- a/kimchi/src/circuits/lookup/tables/sparse.rs
+++ b/kimchi/src/circuits/lookup/tables/sparse.rs
@@ -5,6 +5,10 @@ use ark_ff::Field;
 //~ This is a 1-column table containing the sparse representation of all 16-bit preimages.
 
 /// Returns the sparse lookup table
+///
+/// # Panics
+///
+/// Will panic if `data` is invalid.
 pub fn sparse_table<F: Field>() -> LookupTable<F> {
     let mut data = vec![vec![]; 1];
 
diff --git a/kimchi/src/circuits/lookup/tables/xor.rs b/kimchi/src/circuits/lookup/tables/xor.rs
index 3ecc9d3b4f..d846942a31 100644
--- a/kimchi/src/circuits/lookup/tables/xor.rs
+++ b/kimchi/src/circuits/lookup/tables/xor.rs
@@ -14,6 +14,10 @@ use ark_ff::Field;
 //~ will translate into a scalar multiplication by 0, which is free.
 
 /// Returns the XOR lookup table
+///
+/// # Panics
+///
+/// Will panic if `data` is invalid.
 pub fn xor_table<F: Field>() -> LookupTable<F> {
     let mut data = vec![vec![]; 3];
 
diff --git a/kimchi/src/circuits/polynomials/complete_add.rs b/kimchi/src/circuits/polynomials/complete_add.rs
index 3b39b9d711..578af66046 100644
--- a/kimchi/src/circuits/polynomials/complete_add.rs
+++ b/kimchi/src/circuits/polynomials/complete_add.rs
@@ -97,10 +97,7 @@ where
     const ARGUMENT_TYPE: ArgumentType = ArgumentType::Gate(GateType::CompleteAdd);
     const CONSTRAINTS: u32 = 7;
 
-    fn constraint_checks<T: ExprOps<F>, const COLUMNS: usize>(
-        env: &ArgumentEnv<F, T, COLUMNS>,
-        cache: &mut Cache,
-    ) -> Vec<T> {
+    fn constraint_checks<T: ExprOps<F>>(env: &ArgumentEnv<F, T>, cache: &mut Cache) -> Vec<T> {
         // This function makes 2 + 1 + 1 + 1 + 2 = 7 constraints
         let x1 = env.witness_curr(0);
         let y1 = env.witness_curr(1);
diff --git a/kimchi/src/circuits/polynomials/endomul_scalar.rs b/kimchi/src/circuits/polynomials/endomul_scalar.rs
index 5e46d74432..731d7841e1 100644
--- a/kimchi/src/circuits/polynomials/endomul_scalar.rs
+++ b/kimchi/src/circuits/polynomials/endomul_scalar.rs
@@ -167,10 +167,7 @@ where
     const ARGUMENT_TYPE: ArgumentType = ArgumentType::Gate(GateType::EndoMulScalar);
     const CONSTRAINTS: u32 = 11;
 
-    fn constraint_checks<T: ExprOps<F>, const COLUMNS: usize>(
-        env: &ArgumentEnv<F, T, COLUMNS>,
-        cache: &mut Cache,
-    ) -> Vec<T> {
+    fn constraint_checks<T: ExprOps<F>>(env: &ArgumentEnv<F, T>, cache: &mut Cache) -> Vec<T> {
         let n0 = env.witness_curr(0);
         let n8 = env.witness_curr(1);
         let a0 = env.witness_curr(2);
diff --git a/kimchi/src/circuits/polynomials/endosclmul.rs b/kimchi/src/circuits/polynomials/endosclmul.rs
index 63156559c8..8bbcb2e0b4 100644
--- a/kimchi/src/circuits/polynomials/endosclmul.rs
+++ b/kimchi/src/circuits/polynomials/endosclmul.rs
@@ -186,10 +186,7 @@ where
     const ARGUMENT_TYPE: ArgumentType = ArgumentType::Gate(GateType::EndoMul);
     const CONSTRAINTS: u32 = 11;
 
-    fn constraint_checks<T: ExprOps<F>, const COLUMNS: usize>(
-        env: &ArgumentEnv<F, T, COLUMNS>,
-        cache: &mut Cache,
-    ) -> Vec<T> {
+    fn constraint_checks<T: ExprOps<F>>(env: &ArgumentEnv<F, T>, cache: &mut Cache) -> Vec<T> {
         let b1 = env.witness_curr(11);
         let b2 = env.witness_curr(12);
         let b3 = env.witness_curr(13);
diff --git a/kimchi/src/circuits/polynomials/foreign_field_add/circuitgates.rs b/kimchi/src/circuits/polynomials/foreign_field_add/circuitgates.rs
index 289d31a6bf..cc25e60565 100644
--- a/kimchi/src/circuits/polynomials/foreign_field_add/circuitgates.rs
+++ b/kimchi/src/circuits/polynomials/foreign_field_add/circuitgates.rs
@@ -142,10 +142,7 @@ where
     const ARGUMENT_TYPE: ArgumentType = ArgumentType::Gate(GateType::ForeignFieldAdd);
     const CONSTRAINTS: u32 = 4;
 
-    fn constraint_checks<T: ExprOps<F>, const COLUMNS: usize>(
-        env: &ArgumentEnv<F, T, COLUMNS>,
-        _cache: &mut Cache,
-    ) -> Vec<T> {
+    fn constraint_checks<T: ExprOps<F>>(env: &ArgumentEnv<F, T>, _cache: &mut Cache) -> Vec<T> {
         let foreign_modulus: [T; LIMB_COUNT] = array::from_fn(|i| env.coeff(i));
 
         // stored as coefficient for better correspondance with the relation being proved
diff --git a/kimchi/src/circuits/polynomials/foreign_field_mul/circuitgates.rs b/kimchi/src/circuits/polynomials/foreign_field_mul/circuitgates.rs
index b4e390ccd8..4baa6a9eb9 100644
--- a/kimchi/src/circuits/polynomials/foreign_field_mul/circuitgates.rs
+++ b/kimchi/src/circuits/polynomials/foreign_field_mul/circuitgates.rs
@@ -193,10 +193,7 @@ where
     const CONSTRAINTS: u32 = 11;
     // DEGREE is 4
 
-    fn constraint_checks<T: ExprOps<F>, const COLUMNS: usize>(
-        env: &ArgumentEnv<F, T, COLUMNS>,
-        _cache: &mut Cache,
-    ) -> Vec<T> {
+    fn constraint_checks<T: ExprOps<F>>(env: &ArgumentEnv<F, T>, _cache: &mut Cache) -> Vec<T> {
         let mut constraints = vec![];
 
         //
diff --git a/kimchi/src/circuits/polynomials/generic.rs b/kimchi/src/circuits/polynomials/generic.rs
index 29bd71b825..77a985ad45 100644
--- a/kimchi/src/circuits/polynomials/generic.rs
+++ b/kimchi/src/circuits/polynomials/generic.rs
@@ -74,10 +74,7 @@ where
     const ARGUMENT_TYPE: ArgumentType = ArgumentType::Gate(GateType::Generic);
     const CONSTRAINTS: u32 = 2;
 
-    fn constraint_checks<T: ExprOps<F>, const COLUMNS: usize>(
-        env: &ArgumentEnv<F, T, COLUMNS>,
-        _cache: &mut Cache,
-    ) -> Vec<T> {
+    fn constraint_checks<T: ExprOps<F>>(env: &ArgumentEnv<F, T>, _cache: &mut Cache) -> Vec<T> {
         // First generic gate
         let left_coeff1 = env.coeff(0);
         let right_coeff1 = env.coeff(1);
diff --git a/kimchi/src/circuits/polynomials/poseidon.rs b/kimchi/src/circuits/polynomials/poseidon.rs
index b690ce45fd..a636570d5b 100644
--- a/kimchi/src/circuits/polynomials/poseidon.rs
+++ b/kimchi/src/circuits/polynomials/poseidon.rs
@@ -337,10 +337,7 @@ where
     const ARGUMENT_TYPE: ArgumentType = ArgumentType::Gate(GateType::Poseidon);
     const CONSTRAINTS: u32 = 15;
 
-    fn constraint_checks<T: ExprOps<F>, const COLUMNS: usize>(
-        env: &ArgumentEnv<F, T, COLUMNS>,
-        cache: &mut Cache,
-    ) -> Vec<T> {
+    fn constraint_checks<T: ExprOps<F>>(env: &ArgumentEnv<F, T>, cache: &mut Cache) -> Vec<T> {
         let mut res = vec![];
 
         let mut idx = 0;
diff --git a/kimchi/src/circuits/polynomials/range_check/circuitgates.rs b/kimchi/src/circuits/polynomials/range_check/circuitgates.rs
index 6e4b3def8e..f543aae001 100644
--- a/kimchi/src/circuits/polynomials/range_check/circuitgates.rs
+++ b/kimchi/src/circuits/polynomials/range_check/circuitgates.rs
@@ -178,10 +178,7 @@ where
     //   * Operates on Curr row
     //   * Range constrain all limbs except vp0 and vp1 (barring plookup constraints, which are done elsewhere)
     //   * Constrain that combining all limbs equals the limb stored in column 0
-    fn constraint_checks<T: ExprOps<F>, const COLUMNS: usize>(
-        env: &ArgumentEnv<F, T, COLUMNS>,
-        _cache: &mut Cache,
-    ) -> Vec<T> {
+    fn constraint_checks<T: ExprOps<F>>(env: &ArgumentEnv<F, T>, _cache: &mut Cache) -> Vec<T> {
         // 1) Apply range constraints on the limbs
         //    * Columns 1-2 are 12-bit copy constraints
         //        * They are copied 3 rows ahead (to the final row) and are constrained by lookups
@@ -282,10 +279,7 @@ where
     //   * Operates on Curr and Next row
     //   * Range constrain all limbs (barring plookup constraints, which are done elsewhere)
     //   * Constrain that combining all limbs equals the value v2 stored in row Curr, column 0
-    fn constraint_checks<T: ExprOps<F>, const COLUMNS: usize>(
-        env: &ArgumentEnv<F, T, COLUMNS>,
-        _cache: &mut Cache,
-    ) -> Vec<T> {
+    fn constraint_checks<T: ExprOps<F>>(env: &ArgumentEnv<F, T>, _cache: &mut Cache) -> Vec<T> {
         // 1) Apply range constraints on limbs for Curr row
         //    * Column 2 is a 2-bit crumb
         let mut constraints = vec![crumb(&env.witness_curr(2))];
diff --git a/kimchi/src/circuits/polynomials/rot.rs b/kimchi/src/circuits/polynomials/rot.rs
index e1ef1e4acb..71bcdef994 100644
--- a/kimchi/src/circuits/polynomials/rot.rs
+++ b/kimchi/src/circuits/polynomials/rot.rs
@@ -213,10 +213,7 @@ where
     // (stored in coefficient as a power-of-two form)
     //   * Operates on Curr row
     //   * Shifts the words by `rot` bits and then adds the excess to obtain the rotated word.
-    fn constraint_checks<T: ExprOps<F>, const COLUMNS: usize>(
-        env: &ArgumentEnv<F, T, COLUMNS>,
-        _cache: &mut Cache,
-    ) -> Vec<T> {
+    fn constraint_checks<T: ExprOps<F>>(env: &ArgumentEnv<F, T>, _cache: &mut Cache) -> Vec<T> {
         // Check that the last 8 columns are 2-bit crumbs
         // C1..C8: x * (x - 1) * (x - 2) * (x - 3) = 0
         let mut constraints = (7..KIMCHI_COLS)
diff --git a/kimchi/src/circuits/polynomials/turshi.rs b/kimchi/src/circuits/polynomials/turshi.rs
index 6a8a76fd85..7a40b318ff 100644
--- a/kimchi/src/circuits/polynomials/turshi.rs
+++ b/kimchi/src/circuits/polynomials/turshi.rs
@@ -772,10 +772,7 @@ where
 
     /// Generates the constraints for the Cairo initial claim and first memory checks
     ///     Accesses Curr and Next rows
-    fn constraint_checks<T: ExprOps<F>, const COLUMNS: usize>(
-        env: &ArgumentEnv<F, T, COLUMNS>,
-        _cache: &mut Cache,
-    ) -> Vec<T> {
+    fn constraint_checks<T: ExprOps<F>>(env: &ArgumentEnv<F, T>, _cache: &mut Cache) -> Vec<T> {
         let pc_ini = env.witness_curr(0); // copy from public input
         let ap_ini = env.witness_curr(1); // copy from public input
         let pc_fin = env.witness_curr(2); // copy from public input
@@ -812,10 +809,7 @@ where
 
     /// Generates the constraints for the Cairo instruction
     ///     Accesses Curr and Next rows
-    fn constraint_checks<T: ExprOps<F>, const COLUMNS: usize>(
-        env: &ArgumentEnv<F, T, COLUMNS>,
-        cache: &mut Cache,
-    ) -> Vec<T> {
+    fn constraint_checks<T: ExprOps<F>>(env: &ArgumentEnv<F, T>, cache: &mut Cache) -> Vec<T> {
         // load all variables of the witness corresponding to Cairoinstruction gates
         let pc = env.witness_curr(0);
         let ap = env.witness_curr(1);
@@ -961,10 +955,7 @@ where
 
     /// Generates the constraints for the Cairo flags
     ///     Accesses Curr and Next rows
-    fn constraint_checks<T: ExprOps<F>, const COLUMNS: usize>(
-        env: &ArgumentEnv<F, T, COLUMNS>,
-        _cache: &mut Cache,
-    ) -> Vec<T> {
+    fn constraint_checks<T: ExprOps<F>>(env: &ArgumentEnv<F, T>, _cache: &mut Cache) -> Vec<T> {
         // Load current row
         let f_pc_abs = env.witness_curr(7);
         let f_pc_rel = env.witness_curr(8);
@@ -1031,10 +1022,7 @@ where
 
     /// Generates the constraints for the Cairo transition
     ///     Accesses Curr and Next rows (Next only first 3 entries)
-    fn constraint_checks<T: ExprOps<F>, const COLUMNS: usize>(
-        env: &ArgumentEnv<F, T, COLUMNS>,
-        _cache: &mut Cache,
-    ) -> Vec<T> {
+    fn constraint_checks<T: ExprOps<F>>(env: &ArgumentEnv<F, T>, _cache: &mut Cache) -> Vec<T> {
         // load computed updated registers
         let pcup = env.witness_curr(7);
         let apup = env.witness_curr(8);
diff --git a/kimchi/src/circuits/polynomials/varbasemul.rs b/kimchi/src/circuits/polynomials/varbasemul.rs
index 9f9e524c0b..a21f7305ab 100644
--- a/kimchi/src/circuits/polynomials/varbasemul.rs
+++ b/kimchi/src/circuits/polynomials/varbasemul.rs
@@ -176,10 +176,7 @@ impl<T> Point<T> {
 }
 
 impl Point<Variable> {
-    pub fn new_from_env<F: PrimeField, T: ExprOps<F>, const COLUMNS: usize>(
-        &self,
-        env: &ArgumentEnv<F, T, COLUMNS>,
-    ) -> Point<T> {
+    pub fn new_from_env<F: PrimeField, T: ExprOps<F>>(&self, env: &ArgumentEnv<F, T>) -> Point<T> {
         Point::create(self.x.new_from_env(env), self.y.new_from_env(env))
     }
 }
@@ -290,7 +287,7 @@ trait FromWitness<F, T>
 where
     F: PrimeField,
 {
-    fn new_from_env<const COLUMNS: usize>(&self, env: &ArgumentEnv<F, T, COLUMNS>) -> T;
+    fn new_from_env(&self, env: &ArgumentEnv<F, T>) -> T;
 }
 
 impl<F, T> FromWitness<F, T> for Variable
@@ -298,7 +295,7 @@ where
     F: PrimeField,
     T: ExprOps<F>,
 {
-    fn new_from_env<const COLUMNS: usize>(&self, env: &ArgumentEnv<F, T, COLUMNS>) -> T {
+    fn new_from_env(&self, env: &ArgumentEnv<F, T>) -> T {
         let column_to_index = |_| match self.col {
             Column::Witness(i) => i,
             _ => panic!("Can't get index from witness columns"),
@@ -334,10 +331,7 @@ impl Layout<Variable> {
         }
     }
 
-    fn new_from_env<F: PrimeField, T: ExprOps<F>, const COLUMNS: usize>(
-        &self,
-        env: &ArgumentEnv<F, T, COLUMNS>,
-    ) -> Layout<T> {
+    fn new_from_env<F: PrimeField, T: ExprOps<F>>(&self, env: &ArgumentEnv<F, T>) -> Layout<T> {
         Layout {
             accs: self.accs.map(|point| point.new_from_env(env)),
             bits: self.bits.map(|var| var.new_from_env(env)),
@@ -420,10 +414,7 @@ where
     const ARGUMENT_TYPE: ArgumentType = ArgumentType::Gate(GateType::VarBaseMul);
     const CONSTRAINTS: u32 = 21;
 
-    fn constraint_checks<T: ExprOps<F>, const COLUMNS: usize>(
-        env: &ArgumentEnv<F, T, COLUMNS>,
-        cache: &mut Cache,
-    ) -> Vec<T> {
+    fn constraint_checks<T: ExprOps<F>>(env: &ArgumentEnv<F, T>, cache: &mut Cache) -> Vec<T> {
         let Layout {
             base,
             accs,
@@ -431,7 +422,7 @@ where
             ss,
             n_prev,
             n_next,
-        } = Layout::create().new_from_env::<F, T, COLUMNS>(env);
+        } = Layout::create().new_from_env::<F, T>(env);
 
         // n'
         // = 2^5 * n + 2^4 b0 + 2^3 b1 + 2^2 b2 + 2^1 b3 + b4
diff --git a/kimchi/src/circuits/polynomials/xor.rs b/kimchi/src/circuits/polynomials/xor.rs
index 630df1d2c9..431734926a 100644
--- a/kimchi/src/circuits/polynomials/xor.rs
+++ b/kimchi/src/circuits/polynomials/xor.rs
@@ -149,10 +149,7 @@ where
     //   * Operates on Curr and Next rows
     //   * Constrain the decomposition of `in1`, `in2` and `out` of multiples of 16 bits
     //   * The actual XOR is performed thanks to the plookups of 4-bit XORs.
-    fn constraint_checks<T: ExprOps<F>, const COLUMNS: usize>(
-        env: &ArgumentEnv<F, T, COLUMNS>,
-        _cache: &mut Cache,
-    ) -> Vec<T> {
+    fn constraint_checks<T: ExprOps<F>>(env: &ArgumentEnv<F, T>, _cache: &mut Cache) -> Vec<T> {
         let two = T::from(2u64);
         // in1 = in1_0 + in1_1 * 2^4 + in1_2 * 2^8 + in1_3 * 2^12 + next_in1 * 2^16
         // in2 = in2_0 + in2_1 * 2^4 + in2_2 * 2^8 + in2_3 * 2^12 + next_in2 * 2^16