diff --git a/Cargo.toml b/Cargo.toml
index ea108b53..76232408 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -63,11 +63,11 @@ default-features = false
 features = ["prepush-hook", "run-cargo-fmt", "run-cargo-test", "run-cargo-clippy"]
 
 [[bench]]
-name = "trivial"
+name = "sangria_trivial"
 harness = false
 
 [[bench]]
-name = "poseidon"
+name = "sangria_poseidon"
 harness = false
 
 [features]
diff --git a/benches/cyclefold_poseidon/main.rs b/benches/cyclefold_poseidon/main.rs
new file mode 100644
index 00000000..e2b493df
--- /dev/null
+++ b/benches/cyclefold_poseidon/main.rs
@@ -0,0 +1,151 @@
+use std::{array, io, marker::PhantomData, path::Path};
+
+use bn256::G1 as C1;
+use criterion::{criterion_group, Criterion};
+use metadata::LevelFilter;
+use sirius::{
+    commitment::CommitmentKey,
+    ff::{Field, FromUniformBytes, PrimeFieldBits},
+    group::Group,
+    halo2_proofs::{
+        circuit::{AssignedCell, Layouter},
+        plonk::ConstraintSystem,
+    },
+    halo2curves::{bn256, grumpkin, CurveAffine},
+    ivc::{
+        cyclefold::{PublicParams, IVC},
+        StepCircuit, SynthesisError,
+    },
+    main_gate::{MainGate, MainGateConfig, RegionCtx, WrapValue},
+    poseidon::{poseidon_circuit::PoseidonChip, Spec},
+};
+use tracing::*;
+use tracing_subscriber::{fmt::format::FmtSpan, EnvFilter};
+
+const ARITY: usize = 1;
+
+const CIRCUIT_TABLE_SIZE1: usize = 17;
+const COMMITMENT_KEY_SIZE: usize = 21;
+
+// Spec for user defined poseidon circuit
+const T1: usize = 3;
+const RATE1: usize = 2;
+const R_F1: usize = 4;
+const R_P1: usize = 3;
+
+#[derive(Clone, Debug)]
+struct TestPoseidonCircuitConfig {
+    pconfig: MainGateConfig<T1>,
+}
+
+#[derive(Default, Debug, Clone)]
+struct TestPoseidonCircuit<F: PrimeFieldBits> {
+    _p: PhantomData<F>,
+}
+
+impl<F: PrimeFieldBits + FromUniformBytes<64>> StepCircuit<ARITY, F> for TestPoseidonCircuit<F> {
+    type Config = TestPoseidonCircuitConfig;
+
+    fn configure(meta: &mut ConstraintSystem<F>) -> Self::Config {
+        let pconfig = MainGate::configure(meta);
+        Self::Config { pconfig }
+    }
+
+    fn synthesize_step(
+        &self,
+        config: Self::Config,
+        layouter: &mut impl Layouter<F>,
+        z_in: &[AssignedCell<F, F>; ARITY],
+    ) -> Result<[AssignedCell<F, F>; ARITY], SynthesisError> {
+        let spec = Spec::<F, T1, RATE1>::new(R_F1, R_P1);
+        let mut pchip = PoseidonChip::new(config.pconfig, spec);
+        let input = z_in.iter().map(|x| x.into()).collect::<Vec<WrapValue<F>>>();
+        pchip.update(&input);
+        let output = layouter
+            .assign_region(
+                || "poseidon hash",
+                |region| {
+                    let ctx = &mut RegionCtx::new(region, 0);
+                    pchip.squeeze(ctx)
+                },
+            )
+            .map_err(SynthesisError::Halo2)?;
+        Ok([output])
+    }
+}
+
+type C1Scalar = <C1 as Group>::Scalar;
+
+const FOLDER: &str = ".cache/examples";
+
+#[instrument]
+fn get_or_create_commitment_key<C: CurveAffine>(
+    k: usize,
+    label: &'static str,
+) -> io::Result<CommitmentKey<C>> {
+    unsafe { CommitmentKey::load_or_setup_cache(Path::new(FOLDER), label, k) }
+}
+
+pub fn criterion_benchmark(c: &mut Criterion) {
+    let _span = info_span!("poseidon_bench").entered();
+    let prepare_span = info_span!("prepare").entered();
+
+    // C1
+    let sc1 = TestPoseidonCircuit::default();
+
+    let primary_commitment_key =
+        get_or_create_commitment_key::<bn256::G1Affine>(COMMITMENT_KEY_SIZE, "bn256")
+            .expect("Failed to get secondary key");
+    let secondary_commitment_key =
+        get_or_create_commitment_key::<grumpkin::G1Affine>(COMMITMENT_KEY_SIZE, "grumpkin")
+            .expect("Failed to get primary key");
+
+    let mut pp = PublicParams::new(
+        &sc1,
+        primary_commitment_key,
+        secondary_commitment_key,
+        CIRCUIT_TABLE_SIZE1 as u32,
+    )
+    .unwrap();
+
+    prepare_span.exit();
+
+    let mut group = c.benchmark_group("ivc_of_poseidon");
+    group.significance_level(0.1).sample_size(10);
+
+    group.bench_function("fold_1_step", |b| {
+        let mut rnd = rand::thread_rng();
+        let primary_z_0 = array::from_fn(|_| C1Scalar::random(&mut rnd));
+
+        b.iter(|| {
+            IVC::new(&mut pp, &sc1, primary_z_0)
+                .expect("while step=0")
+                .next(&pp, &sc1)
+                .expect("while step=1")
+                .verify(&pp)
+                .expect("while verify");
+        })
+    });
+
+    group.finish();
+}
+
+criterion_group!(benches, criterion_benchmark);
+
+fn main() {
+    tracing_subscriber::fmt()
+        .with_span_events(FmtSpan::ENTER | FmtSpan::CLOSE)
+        .with_env_filter(
+            EnvFilter::builder()
+                .with_default_directive(LevelFilter::INFO.into())
+                .from_env_lossy(),
+        )
+        .json()
+        .init();
+
+    benches();
+
+    criterion::Criterion::default()
+        .configure_from_args()
+        .final_summary();
+}
diff --git a/benches/poseidon/main.rs b/benches/sangria_poseidon/main.rs
similarity index 97%
rename from benches/poseidon/main.rs
rename to benches/sangria_poseidon/main.rs
index 750e202f..6c945e76 100644
--- a/benches/poseidon/main.rs
+++ b/benches/sangria_poseidon/main.rs
@@ -13,7 +13,10 @@ use sirius::{
         plonk::ConstraintSystem,
     },
     halo2curves::{bn256, grumpkin, CurveAffine, CurveExt},
-    ivc::{step_circuit, CircuitPublicParamsInput, PublicParams, StepCircuit, SynthesisError, IVC},
+    ivc::{
+        sangria::{CircuitPublicParamsInput, PublicParams, IVC},
+        step_circuit, StepCircuit, SynthesisError,
+    },
     main_gate::{MainGate, MainGateConfig, RegionCtx, WrapValue},
     poseidon::{self, poseidon_circuit::PoseidonChip, ROPair, Spec},
 };
diff --git a/benches/trivial/main.rs b/benches/sangria_trivial/main.rs
similarity index 96%
rename from benches/trivial/main.rs
rename to benches/sangria_trivial/main.rs
index e563811a..fe7d53cf 100644
--- a/benches/trivial/main.rs
+++ b/benches/sangria_trivial/main.rs
@@ -11,7 +11,10 @@ use sirius::{
     ff::Field,
     group::{prime::PrimeCurve, Group},
     halo2curves::{bn256, grumpkin, CurveAffine, CurveExt},
-    ivc::{step_circuit, CircuitPublicParamsInput, PublicParams, IVC},
+    ivc::{
+        sangria::{CircuitPublicParamsInput, PublicParams},
+        step_circuit, SangriaIVC,
+    },
     poseidon::{self, ROPair},
 };
 use tracing::*;
@@ -109,7 +112,7 @@ pub fn criterion_benchmark(c: &mut Criterion) {
         let secondary_z_0 = array::from_fn(|_| C2Scalar::random(&mut rnd));
 
         b.iter(|| {
-            IVC::fold(
+            SangriaIVC::fold(
                 &pp,
                 &sc1,
                 black_box(primary_z_0),
@@ -127,7 +130,7 @@ pub fn criterion_benchmark(c: &mut Criterion) {
         let secondary_z_0 = array::from_fn(|_| C2Scalar::random(&mut rnd));
 
         b.iter(|| {
-            IVC::fold(
+            SangriaIVC::fold(
                 &pp,
                 &sc1,
                 black_box(primary_z_0),
diff --git a/examples/cli.rs b/examples/cli.rs
index 02b4ba86..a082c92d 100644
--- a/examples/cli.rs
+++ b/examples/cli.rs
@@ -15,7 +15,11 @@ use halo2_proofs::halo2curves;
 use poseidon::poseidon_step_circuit::TestPoseidonCircuit;
 use sirius::{
     ff::{FromUniformBytes, PrimeField, PrimeFieldBits},
-    ivc::{step_circuit::trivial, CircuitPublicParamsInput, PublicParams, StepCircuit, IVC},
+    ivc::{
+        sangria::{CircuitPublicParamsInput, PublicParams, IVC},
+        step_circuit::trivial,
+        StepCircuit,
+    },
     poseidon::ROPair,
 };
 use tracing::*;
diff --git a/examples/cyclefold_trivial/main.rs b/examples/cyclefold_trivial/main.rs
new file mode 100644
index 00000000..f96b231f
--- /dev/null
+++ b/examples/cyclefold_trivial/main.rs
@@ -0,0 +1,63 @@
+use std::{array, path::Path};
+
+use sirius::{commitment::CommitmentKey, ff::Field, ivc::step_circuit::trivial};
+
+/// Arity : Input/output size per fold-step for primary step-circuit
+/// For tivial case it can be any number
+const A1: usize = 5;
+
+/// Key size for Primary Circuit
+const PRIMARY_COMMITMENT_KEY_SIZE: usize = 23;
+
+/// Table size for Primary Circuit
+///
+/// Requires at least 17, for service purposes, but if the primary requires more, increase the
+/// constant
+const PRIMARY_CIRCUIT_TABLE_SIZE: usize = 20;
+
+/// Key size for Primary Circuit
+const SECONDARY_COMMITMENT_KEY_SIZE: usize = 23;
+
+use sirius::cyclefold_prelude::{
+    bn256::{C1Affine, C1Scalar, C2Affine},
+    PublicParams, IVC,
+};
+
+const FOLDER: &str = ".cache/examples";
+
+fn main() {
+    let sc = trivial::Circuit::<A1, C1Scalar>::default();
+
+    let primary_commitment_key = unsafe {
+        CommitmentKey::<C1Affine>::load_or_setup_cache(
+            Path::new(FOLDER),
+            "bn256",
+            PRIMARY_COMMITMENT_KEY_SIZE,
+        )
+        .unwrap()
+    };
+
+    let secondary_commitment_key = unsafe {
+        CommitmentKey::<C2Affine>::load_or_setup_cache(
+            Path::new(FOLDER),
+            "grumpkin",
+            SECONDARY_COMMITMENT_KEY_SIZE,
+        )
+        .unwrap()
+    };
+
+    let mut pp = PublicParams::new(
+        &sc,
+        primary_commitment_key,
+        secondary_commitment_key,
+        PRIMARY_CIRCUIT_TABLE_SIZE as u32,
+    )
+    .unwrap();
+
+    IVC::new(&mut pp, &sc, array::from_fn(|_| C1Scalar::ZERO))
+        .expect("while step=0")
+        .next(&pp, &sc)
+        .expect("while step=1")
+        .verify(&pp)
+        .expect("while verify");
+}
diff --git a/examples/instances.rs b/examples/instances.rs
index 51c23f5f..cd347f31 100644
--- a/examples/instances.rs
+++ b/examples/instances.rs
@@ -10,9 +10,9 @@ use sirius::{
         step_circuit::{trivial, AssignedCell, ConstraintSystem, Layouter},
         SynthesisError,
     },
-    prelude::{
+    sangria_prelude::{
         bn256::{new_default_pp, C1Affine, C1Scalar, C2Affine, C2Scalar},
-        CommitmentKey, PrimeField, StepCircuit, IVC,
+        CommitmentKey, PrimeField, SangriaIVC, StepCircuit,
     },
 };
 use tracing::debug;
@@ -155,7 +155,7 @@ fn main() {
         &sc2,
     );
 
-    IVC::fold_with_debug_mode(
+    SangriaIVC::fold_with_debug_mode(
         &pp,
         &sc1,
         array::from_fn(|i| C1Scalar::from(i as u64)),
diff --git a/examples/merkle/main.rs b/examples/merkle/main.rs
index 6885704c..7e8ace99 100644
--- a/examples/merkle/main.rs
+++ b/examples/merkle/main.rs
@@ -27,7 +27,10 @@ mod sirius_mod {
         commitment::CommitmentKey,
         ff::Field,
         group::{prime::PrimeCurve, Group},
-        ivc::{step_circuit::trivial, CircuitPublicParamsInput, PublicParams, IVC},
+        ivc::{
+            sangria::{CircuitPublicParamsInput, PublicParams, IVC},
+            step_circuit::trivial,
+        },
     };
     use tracing::info_span;
 
diff --git a/examples/my_circuit.rs b/examples/my_circuit.rs
index d0541d51..5b2553d3 100644
--- a/examples/my_circuit.rs
+++ b/examples/my_circuit.rs
@@ -5,9 +5,9 @@ use sirius::{
         step_circuit::{trivial, AssignedCell, ConstraintSystem, Layouter},
         SynthesisError,
     },
-    prelude::{
+    sangria_prelude::{
         bn256::{new_default_pp, C1Affine, C1Scalar, C2Affine, C2Scalar},
-        CommitmentKey, PrimeField, StepCircuit, IVC,
+        CommitmentKey, PrimeField, SangriaIVC, StepCircuit,
     },
 };
 
@@ -87,7 +87,7 @@ fn main() {
         &sc2,
     );
 
-    IVC::fold_with_debug_mode(
+    SangriaIVC::fold_with_debug_mode(
         &pp,
         &sc1,
         array::from_fn(|i| C1Scalar::from(i as u64)),
diff --git a/examples/poseidon.rs b/examples/poseidon.rs
index 9c487a1e..a008e896 100644
--- a/examples/poseidon.rs
+++ b/examples/poseidon.rs
@@ -127,7 +127,10 @@ use sirius::{
     commitment::CommitmentKey,
     group::{prime::PrimeCurve, Group},
     halo2curves::{bn256, grumpkin, CurveAffine},
-    ivc::{step_circuit, CircuitPublicParamsInput, PublicParams, IVC},
+    ivc::{
+        sangria::{CircuitPublicParamsInput, PublicParams, IVC},
+        step_circuit,
+    },
     poseidon::{self, ROPair},
 };
 use tracing::*;
diff --git a/examples/trivial/main.rs b/examples/sangria_trivial/main.rs
similarity index 90%
rename from examples/trivial/main.rs
rename to examples/sangria_trivial/main.rs
index 0c880456..5501df44 100644
--- a/examples/trivial/main.rs
+++ b/examples/sangria_trivial/main.rs
@@ -2,7 +2,7 @@ use std::{array, num::NonZeroUsize};
 
 use sirius::{
     commitment::CommitmentKey,
-    ivc::{step_circuit::trivial, IVC},
+    ivc::{step_circuit::trivial, SangriaIVC},
 };
 
 /// Arity : Input/output size per fold-step for primary step-circuit
@@ -31,7 +31,7 @@ const PRIMARY_CIRCUIT_TABLE_SIZE: usize = 17;
 /// Key size for Primary Circuit
 const SECONDARY_COMMITMENT_KEY_SIZE: usize = 21;
 
-use sirius::prelude::bn256::{new_default_pp, C1Affine, C1Scalar, C2Affine, C2Scalar};
+use sirius::sangria_prelude::bn256::{new_default_pp, C1Affine, C1Scalar, C2Affine, C2Scalar};
 
 fn main() {
     let sc1 = trivial::Circuit::<A1, C1Scalar>::default();
@@ -52,7 +52,7 @@ fn main() {
         &sc2,
     );
 
-    IVC::fold_with_debug_mode(
+    SangriaIVC::fold_with_debug_mode(
         &pp,
         &sc1,
         array::from_fn(|i| C1Scalar::from(i as u64)),
diff --git a/examples/sha256/main.rs b/examples/sha256/main.rs
index 15bc7c88..2e4d8c1f 100644
--- a/examples/sha256/main.rs
+++ b/examples/sha256/main.rs
@@ -13,7 +13,10 @@ use sirius::{
     ff::PrimeField,
     group::{prime::PrimeCurve, Group},
     halo2curves::{bn256, grumpkin, CurveAffine, CurveExt},
-    ivc::{step_circuit, CircuitPublicParamsInput, PublicParams, StepCircuit, SynthesisError, IVC},
+    ivc::{
+        sangria::{CircuitPublicParamsInput, PublicParams, IVC},
+        step_circuit, StepCircuit, SynthesisError,
+    },
     poseidon::{self, ROPair},
 };
 use tracing::*;
diff --git a/rust-toolchain.toml b/rust-toolchain.toml
index 2ceee0d0..b0e5f137 100644
--- a/rust-toolchain.toml
+++ b/rust-toolchain.toml
@@ -1 +1 @@
-toolchain.channel = "1.83.0"
+toolchain.channel = "1.84.0"
diff --git a/src/ivc/cyclefold/incrementally_verifiable_computation/mod.rs b/src/ivc/cyclefold/incrementally_verifiable_computation/mod.rs
index 0ff17f2e..72d9f251 100644
--- a/src/ivc/cyclefold/incrementally_verifiable_computation/mod.rs
+++ b/src/ivc/cyclefold/incrementally_verifiable_computation/mod.rs
@@ -29,7 +29,7 @@ use crate::{
     plonk::{eval, PlonkTrace},
     polynomial::lagrange,
     poseidon::random_oracle::ROTrait,
-    prelude::CommitmentKey,
+    sangria_prelude::CommitmentKey,
     table::CircuitRunner,
     util,
 };
@@ -534,7 +534,7 @@ mod tests {
         commitment::CommitmentKey,
         halo2_proofs::arithmetic::Field,
         ivc::step_circuit::trivial,
-        prelude::bn256::{C1Affine, C1Scalar, C2Affine},
+        sangria_prelude::bn256::{C1Affine, C1Scalar, C2Affine},
     };
 
     /// Arity : Input/output size per fold-step for primary step-circuit
diff --git a/src/ivc/cyclefold/incrementally_verifiable_computation/public_params.rs b/src/ivc/cyclefold/incrementally_verifiable_computation/public_params.rs
index bb27d9ac..b7ef8848 100644
--- a/src/ivc/cyclefold/incrementally_verifiable_computation/public_params.rs
+++ b/src/ivc/cyclefold/incrementally_verifiable_computation/public_params.rs
@@ -29,7 +29,7 @@ use crate::{
     plonk::{PlonkStructure, PlonkTrace},
     polynomial::Expression,
     poseidon::{PoseidonHash, ROTrait, Spec},
-    prelude::CommitmentKey,
+    sangria_prelude::CommitmentKey,
     table::CircuitRunner,
     util,
 };
diff --git a/src/ivc/cyclefold/mod.rs b/src/ivc/cyclefold/mod.rs
index 6aacca8f..a80e9db9 100644
--- a/src/ivc/cyclefold/mod.rs
+++ b/src/ivc/cyclefold/mod.rs
@@ -11,7 +11,9 @@ mod support_circuit;
 mod sfc;
 
 #[allow(clippy::upper_case_acronyms)]
-mod incrementally_verifiable_computation;
+pub mod incrementally_verifiable_computation;
+
+pub use incrementally_verifiable_computation::{PublicParams, IVC};
 
 pub const T: usize = 5;
 pub const T_MAIN_GATE: usize = 5;
diff --git a/src/ivc/cyclefold/sfc/input/assigned.rs b/src/ivc/cyclefold/sfc/input/assigned.rs
index 3b48765f..7c58cce2 100644
--- a/src/ivc/cyclefold/sfc/input/assigned.rs
+++ b/src/ivc/cyclefold/sfc/input/assigned.rs
@@ -905,7 +905,7 @@ impl<const A: usize, F: PrimeField> Input<A, F> {
                 Halo2PlonkError::Synthesis
             })?;
 
-        for (acc_W, incoming_W, trace, new_acc_W, index) in itertools::multizip((
+        for (acc_W, incoming_W, support_trace, new_acc_W, index) in itertools::multizip((
             self.self_trace.input_accumulator.ins.W_commitments.iter(),
             self.self_trace.incoming.W_commitments.iter(),
             self.support_trace.incoming.iter(),
@@ -914,7 +914,7 @@ impl<const A: usize, F: PrimeField> Input<A, F> {
         )) {
             info!("start {index} commitment check");
 
-            let [expected_x, expected_y, x0, y0, l0, x1, y1, l1]: [_; support_circuit::INSTANCES_LEN] = trace.instance
+            let [expected_x, expected_y, x0, y0, l0, x1, y1, l1]: [_; support_circuit::INSTANCES_LEN] = support_trace.instance
                 .instances
                 .first()
                 .expect("`SupportCircuit` always has instances.len() == 1 and it should always be used for sfc")
diff --git a/src/ivc/cyclefold/sfc/sangria_adapter.rs b/src/ivc/cyclefold/sfc/sangria_adapter.rs
index 05bf53c1..d0e22f44 100644
--- a/src/ivc/cyclefold/sfc/sangria_adapter.rs
+++ b/src/ivc/cyclefold/sfc/sangria_adapter.rs
@@ -18,7 +18,9 @@ use crate::{
     },
     ivc::{
         cyclefold::{ro_chip, DEFAULT_LIMBS_COUNT, DEFAULT_LIMB_WIDTH},
-        fold_relaxed_plonk_instance_chip::{self, BigUintView, FoldRelaxedPlonkInstanceChip},
+        sangria::fold_relaxed_plonk_instance_chip::{
+            self, BigUintView, FoldRelaxedPlonkInstanceChip,
+        },
     },
     main_gate::{AssignedValue, MainGate, MainGateConfig, RegionCtx},
     nifs::sangria,
diff --git a/src/ivc/cyclefold/support_circuit/mod.rs b/src/ivc/cyclefold/support_circuit/mod.rs
index 885c4f77..f3dadcae 100644
--- a/src/ivc/cyclefold/support_circuit/mod.rs
+++ b/src/ivc/cyclefold/support_circuit/mod.rs
@@ -172,7 +172,7 @@ mod tests {
     use super::*;
     use crate::{
         halo2_proofs::{dev::MockProver, halo2curves::group::prime::PrimeCurveAffine},
-        prelude::{bn256::C1Affine as Curve, Field},
+        sangria_prelude::{bn256::C1Affine as Curve, Field},
     };
 
     type Base = <Curve as CurveAffine>::Base;
diff --git a/src/ivc/mod.rs b/src/ivc/mod.rs
index cda44ec7..aef35056 100644
--- a/src/ivc/mod.rs
+++ b/src/ivc/mod.rs
@@ -1,15 +1,15 @@
 pub mod step_circuit;
 
 pub mod sangria;
-pub use sangria::{
-    fold_relaxed_plonk_instance_chip, incrementally_verifiable_computation,
-    public_params::{CircuitPublicParamsInput, PublicParams},
-    step_folding_circuit,
-};
+pub use sangria::step_folding_circuit;
 
 pub mod protogalaxy;
 
 pub mod cyclefold;
 
+pub use cyclefold::incrementally_verifiable_computation::IVC as CyclefoldIVC;
 pub use halo2_proofs::circuit::SimpleFloorPlanner;
-pub use incrementally_verifiable_computation::*;
+
+pub use sangria::incrementally_verifiable_computation::{
+    Instances, StepCircuit, SynthesisError, IVC as SangriaIVC,
+};
diff --git a/src/ivc/sangria/consistency_markers_computation.rs b/src/ivc/sangria/consistency_markers_computation.rs
index 3de457aa..e89c48ed 100644
--- a/src/ivc/sangria/consistency_markers_computation.rs
+++ b/src/ivc/sangria/consistency_markers_computation.rs
@@ -210,7 +210,7 @@ mod tests {
     use super::*;
     use crate::{
         commitment::CommitmentKey,
-        ivc::fold_relaxed_plonk_instance_chip::FoldRelaxedPlonkInstanceChip,
+        ivc::sangria::fold_relaxed_plonk_instance_chip::FoldRelaxedPlonkInstanceChip,
         main_gate::AdviceCyclicAssignor,
         poseidon::{poseidon_circuit::PoseidonChip, PoseidonHash, Spec},
         table::WitnessCollector,
diff --git a/src/ivc/sangria/mod.rs b/src/ivc/sangria/mod.rs
index 8be65dc1..0cddee4d 100644
--- a/src/ivc/sangria/mod.rs
+++ b/src/ivc/sangria/mod.rs
@@ -4,3 +4,6 @@ pub mod incrementally_verifiable_computation;
 pub mod instances_accumulator_computation;
 pub mod public_params;
 pub mod step_folding_circuit;
+
+pub use incrementally_verifiable_computation::IVC;
+pub use public_params::{CircuitPublicParamsInput, PublicParams};
diff --git a/src/ivc/sangria/step_folding_circuit.rs b/src/ivc/sangria/step_folding_circuit.rs
index 2bda683a..16edaa72 100644
--- a/src/ivc/sangria/step_folding_circuit.rs
+++ b/src/ivc/sangria/step_folding_circuit.rs
@@ -13,10 +13,12 @@ use crate::{
     },
     halo2curves::CurveAffine,
     ivc::{
-        fold_relaxed_plonk_instance_chip::{
-            AssignedRelaxedPlonkInstance, FoldRelaxedPlonkInstanceChip, FoldResult,
+        sangria::{
+            consistency_markers_computation::AssignedConsistencyMarkersComputation,
+            fold_relaxed_plonk_instance_chip::{
+                AssignedRelaxedPlonkInstance, FoldRelaxedPlonkInstanceChip, FoldResult,
+            },
         },
-        sangria::consistency_markers_computation::AssignedConsistencyMarkersComputation,
         StepCircuit,
     },
     main_gate::{AdviceCyclicAssignor, MainGate, MainGateConfig, RegionCtx},
diff --git a/src/ivc/step_circuit.rs b/src/ivc/step_circuit.rs
index d6160099..dedfff9b 100644
--- a/src/ivc/step_circuit.rs
+++ b/src/ivc/step_circuit.rs
@@ -1,6 +1,6 @@
 use tracing::*;
 
-use super::fold_relaxed_plonk_instance_chip;
+use super::sangria::fold_relaxed_plonk_instance_chip;
 pub use crate::halo2_proofs::{
     circuit::{AssignedCell, Layouter},
     plonk::ConstraintSystem,
diff --git a/src/lib.rs b/src/lib.rs
index 51fce4ba..f43186e3 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -25,14 +25,37 @@ pub use halo2_proofs::{
     halo2curves::{ff, group},
 };
 
-pub mod prelude {
+pub mod cyclefold_prelude {
+    /// All imports and alias related to what will use bn256 & grumpkin as the first and second
+    /// curve respectively
+    pub mod bn256 {
+        pub use bn256::G1;
+        pub use grumpkin::G1 as G2;
+
+        use crate::halo2curves::{
+            bn256,
+            group::{prime::PrimeCurve, Group},
+            grumpkin,
+        };
+
+        pub type C1Affine = <G1 as PrimeCurve>::Affine;
+        pub type C2Affine = <G2 as PrimeCurve>::Affine;
+
+        pub type C1Scalar = <G1 as Group>::Scalar;
+        pub type C2Scalar = <G2 as Group>::Scalar;
+    }
+
+    pub use crate::ivc::cyclefold::{PublicParams, IVC};
+}
+
+pub mod sangria_prelude {
     use std::num::NonZeroUsize;
 
     use crate::ff::{FromUniformBytes, PrimeFieldBits};
     pub use crate::{
         commitment::CommitmentKey,
         ff::{Field, PrimeField},
-        ivc::{StepCircuit, IVC},
+        ivc::{SangriaIVC, StepCircuit},
     };
 
     /// Within the IVC framework, on-circuit & off-circuit random oracle will be used
@@ -104,7 +127,7 @@ pub mod prelude {
         pub type C2Scalar = <G2 as Group>::Scalar;
 
         pub type PublicParams<'l, const A1: usize, C1, const A2: usize, C2> =
-            crate::ivc::PublicParams<
+            crate::ivc::sangria::PublicParams<
                 'l,
                 A1,
                 A2,
@@ -139,13 +162,13 @@ pub mod prelude {
             C2: StepCircuit<A2, C2Scalar>,
         {
             PublicParams::new(
-                crate::ivc::CircuitPublicParamsInput::new(
+                crate::ivc::sangria::CircuitPublicParamsInput::new(
                     primary_k_table_size,
                     primary_commitment_key,
                     super::default_random_oracle_constant(),
                     sc1,
                 ),
-                crate::ivc::CircuitPublicParamsInput::new(
+                crate::ivc::sangria::CircuitPublicParamsInput::new(
                     secondary_k_table_size,
                     secondary_commitment_key,
                     super::default_random_oracle_constant(),
@@ -181,7 +204,7 @@ pub mod prelude {
         pub type C2Scalar = <G2 as Group>::Scalar;
 
         pub type PublicParams<'l, const A1: usize, C1, const A2: usize, C2> =
-            crate::ivc::PublicParams<
+            crate::ivc::sangria::PublicParams<
                 'l,
                 A1,
                 A2,
@@ -216,13 +239,13 @@ pub mod prelude {
             C2: StepCircuit<A2, C2Scalar>,
         {
             PublicParams::new(
-                crate::ivc::CircuitPublicParamsInput::new(
+                crate::ivc::sangria::CircuitPublicParamsInput::new(
                     primary_k_table_size,
                     primary_commitment_key,
                     super::default_random_oracle_constant(),
                     sc1,
                 ),
-                crate::ivc::CircuitPublicParamsInput::new(
+                crate::ivc::sangria::CircuitPublicParamsInput::new(
                     secondary_k_table_size,
                     secondary_commitment_key,
                     super::default_random_oracle_constant(),
diff --git a/src/nifs/sangria/accumulator.rs b/src/nifs/sangria/accumulator.rs
index 402b6a60..2cbf98b4 100644
--- a/src/nifs/sangria/accumulator.rs
+++ b/src/nifs/sangria/accumulator.rs
@@ -17,9 +17,7 @@ use crate::{
     ff::{Field, PrimeField},
     ivc::sangria::instances_accumulator_computation,
     main_gate::{AssignedValue, WrapValue},
-    plonk::{
-        self, GetChallenges, GetWitness, PlonkInstance, PlonkStructure, PlonkTrace, PlonkWitness,
-    },
+    plonk::{self, GetChallenges, GetWitness, PlonkInstance, PlonkTrace, PlonkWitness},
     poseidon::{AbsorbInRO, ROTrait},
     util::ScalarToBase,
 };
@@ -294,31 +292,6 @@ impl<C: CurveAffine, const MARKERS_LEN: usize> RelaxedPlonkTrace<C, MARKERS_LEN>
 
 pub type RelaxedPlonkTraceArgs = plonk::PlonkTraceArgs;
 
-impl<C: CurveAffine> RelaxedPlonkTrace<C>
-where
-    C::Base: PrimeFieldBits + FromUniformBytes<64>,
-{
-    pub fn new(args: RelaxedPlonkTraceArgs) -> Self {
-        Self {
-            U: RelaxedPlonkInstance::new(
-                args.num_challenges,
-                args.num_witness,
-                args.num_io.len() - 1, // instances
-            ),
-            W: RelaxedPlonkWitness::new(args.k_table_size, &args.round_sizes),
-        }
-    }
-}
-
-impl<C: CurveAffine> From<&PlonkStructure<C::ScalarExt>> for RelaxedPlonkTrace<C>
-where
-    C::Base: PrimeFieldBits + FromUniformBytes<64>,
-{
-    fn from(value: &PlonkStructure<C::ScalarExt>) -> Self {
-        Self::new(RelaxedPlonkTraceArgs::from(value))
-    }
-}
-
 impl<F: PrimeField> GetWitness<F> for RelaxedPlonkWitness<F> {
     fn get_witness(&self) -> &[Vec<F>] {
         &self.W
diff --git a/src/plonk/eval.rs b/src/plonk/eval.rs
index c6f37d28..11e9840d 100644
--- a/src/plonk/eval.rs
+++ b/src/plonk/eval.rs
@@ -103,7 +103,7 @@ pub struct PlonkEvalDomain<'a, F: PrimeField> {
     pub(crate) W2s: &'a [Vec<F>],
 }
 
-impl<'a, F: PrimeField> GetDataForEval<F> for LookupEvalDomain<'a, F> {
+impl<F: PrimeField> GetDataForEval<F> for LookupEvalDomain<'_, F> {
     fn num_lookup(&self) -> usize {
         self.num_lookup
     }
@@ -133,7 +133,7 @@ impl<'a, F: PrimeField> GetDataForEval<F> for LookupEvalDomain<'a, F> {
     }
 }
 
-impl<'a, F: PrimeField> GetDataForEval<F> for PlonkEvalDomain<'a, F> {
+impl<F: PrimeField> GetDataForEval<F> for PlonkEvalDomain<'_, F> {
     fn num_lookup(&self) -> usize {
         self.num_lookup
     }