diff --git a/src/circuit_builder.rs b/src/circuit_builder.rs
index c0db18f4..c76abcd4 100644
--- a/src/circuit_builder.rs
+++ b/src/circuit_builder.rs
@@ -1,11 +1,11 @@
 use std::collections::HashSet;
 
-use crate::circuit_data::CircuitConfig;
+use crate::circuit_data::{CircuitConfig, CircuitData, ProverCircuitData, VerifierCircuitData};
 use crate::field::field::Field;
+use crate::gates::constant::ConstantGate2;
 use crate::gates::gate::{GateInstance, GateRef};
 use crate::generator::{CopyGenerator, WitnessGenerator};
 use crate::target::Target;
-use crate::gates::constant::ConstantGate2;
 use crate::wire::Wire;
 
 pub struct CircuitBuilder2<F: Field> {
@@ -91,4 +91,19 @@ impl<F: Field> CircuitBuilder2<F> {
         let gate = self.add_gate(ConstantGate2::get(), vec![c]);
         Target::Wire(Wire { gate, input: ConstantGate2::WIRE_OUTPUT })
     }
+
+    /// Builds a "full circuit", with both prover and verifier data.
+    pub fn build(&self) -> CircuitData<F> {
+        todo!()
+    }
+
+    /// Builds a "prover circuit", with data needed to generate proofs but not verify them.
+    pub fn build_prover(&self) -> ProverCircuitData<F> {
+        todo!()
+    }
+
+    /// Builds a "verifier circuit", with data needed to verify proofs but not generate them.
+    pub fn build_verifier(&self) -> VerifierCircuitData<F> {
+        todo!()
+    }
 }
diff --git a/src/circuit_data.rs b/src/circuit_data.rs
index d9e4051e..54036e7f 100644
--- a/src/circuit_data.rs
+++ b/src/circuit_data.rs
@@ -1,8 +1,10 @@
 use crate::field::fft::FftPrecomputation;
 use crate::field::field::Field;
+use crate::generator::WitnessGenerator;
 use crate::proof::{Hash, Proof2};
-use crate::prover::prove2;
-use crate::verifier::verify2;
+use crate::prover::prove;
+use crate::verifier::verify;
+use crate::witness::PartialWitness;
 
 #[derive(Copy, Clone)]
 pub struct CircuitConfig {
@@ -25,12 +27,12 @@ pub struct CircuitData<F: Field> {
 }
 
 impl<F: Field> CircuitData<F> {
-    pub fn prove2(&self) -> Proof2<F> {
-        prove2(&self.prover_only, &self.common)
+    pub fn prove(&self, inputs: PartialWitness<F>) -> Proof2<F> {
+        prove(&self.prover_only, &self.common, inputs)
     }
 
-    pub fn verify2(&self) {
-        verify2(&self.verifier_only, &self.common)
+    pub fn verify(&self) {
+        verify(&self.verifier_only, &self.common)
     }
 }
 
@@ -41,8 +43,8 @@ pub struct ProverCircuitData<F: Field> {
 }
 
 impl<F: Field> ProverCircuitData<F> {
-    pub fn prove2(&self) -> Proof2<F> {
-        prove2(&self.prover_only, &self.common)
+    pub fn prove(&self, inputs: PartialWitness<F>) -> Proof2<F> {
+        prove(&self.prover_only, &self.common, inputs)
     }
 }
 
@@ -54,14 +56,13 @@ pub struct VerifierCircuitData<F: Field> {
 
 impl<F: Field> VerifierCircuitData<F> {
     pub fn verify2(&self) {
-        verify2(&self.verifier_only, &self.common)
+        verify(&self.verifier_only, &self.common)
     }
 }
 
 /// Circuit data required by the prover, but not the verifier.
 pub(crate) struct ProverOnlyCircuitData<F: Field> {
-    /// A precomputation used for FFTs of degree 8n, where n is the number of gates.
-    pub fft_precomputation_8n: FftPrecomputation<F>,
+    pub generators: Vec<Box<dyn WitnessGenerator<F>>>,
 }
 
 /// Circuit data required by the verifier, but not the prover.
@@ -78,7 +79,4 @@ pub(crate) struct CommonCircuitData<F: Field> {
 
     /// A commitment to each permutation polynomial.
     pub sigmas_root: Hash<F>,
-
-    /// A precomputation used for FFTs of degree n, where n is the number of gates.
-    pub fft_precomputation_n: FftPrecomputation<F>,
 }
diff --git a/src/gadgets/split_join.rs b/src/gadgets/split_join.rs
index 751f82f4..481d0c61 100644
--- a/src/gadgets/split_join.rs
+++ b/src/gadgets/split_join.rs
@@ -53,7 +53,7 @@ impl<F: Field> SimpleGenerator<F> for SplitGenerator {
         vec![self.integer]
     }
 
-    fn run_once(&mut self, witness: &PartialWitness<F>) -> PartialWitness<F> {
+    fn run_once(&self, witness: &PartialWitness<F>) -> PartialWitness<F> {
         let mut integer_value = witness.get_target(self.integer).to_canonical_u64();
 
         let mut result = PartialWitness::new();
diff --git a/src/gates/deterministic_gate.rs b/src/gates/deterministic_gate.rs
index d66c5e03..34dee585 100644
--- a/src/gates/deterministic_gate.rs
+++ b/src/gates/deterministic_gate.rs
@@ -114,7 +114,7 @@ impl<F: Field> SimpleGenerator<F> for OutputGenerator<F> {
             .collect()
     }
 
-    fn run_once(&mut self, witness: &PartialWitness<F>) -> PartialWitness<F> {
+    fn run_once(&self, witness: &PartialWitness<F>) -> PartialWitness<F> {
         let mut local_wire_values = Vec::new();
         let mut next_wire_values = Vec::new();
 
diff --git a/src/gates/fri_consistency_gate.rs b/src/gates/fri_consistency_gate.rs
index ee8e1099..b1fc842d 100644
--- a/src/gates/fri_consistency_gate.rs
+++ b/src/gates/fri_consistency_gate.rs
@@ -308,7 +308,7 @@ impl<F: Field> SimpleGenerator<F> for InterpolantGenerator<F> {
         deps
     }
 
-    fn run_once(&mut self, witness: &PartialWitness<F>) -> PartialWitness<F> {
+    fn run_once(&self, witness: &PartialWitness<F>) -> PartialWitness<F> {
         let mut result = PartialWitness::new();
 
         for commit_idx in 0..self.gate.num_commits {
diff --git a/src/gates/gmimc.rs b/src/gates/gmimc.rs
index 2aa90284..ba1a225a 100644
--- a/src/gates/gmimc.rs
+++ b/src/gates/gmimc.rs
@@ -176,7 +176,7 @@ mod tests {
         }
 
         let generators = gate.0.generators(config, 0, vec![], vec![]);
-        generate_partial_witness(&mut witness, generators);
+        generate_partial_witness(&mut witness, &generators);
 
         let expected_outputs: [F; W] = gmimc_permute_naive(
             permutation_inputs.try_into().unwrap(),
diff --git a/src/generator.rs b/src/generator.rs
index ebeced47..f317cf9c 100644
--- a/src/generator.rs
+++ b/src/generator.rs
@@ -4,9 +4,11 @@ use crate::field::field::Field;
 use crate::target::Target;
 use crate::witness::PartialWitness;
 
+/// Given a `PartialWitness` that has only inputs set, populates the rest of the witness using the
+/// given set of generators.
 pub(crate) fn generate_partial_witness<F: Field>(
     witness: &mut PartialWitness<F>,
-    mut generators: Vec<Box<dyn WitnessGenerator<F>>>,
+    mut generators: &[Box<dyn WitnessGenerator<F>>],
 ) {
     // Index generator indices by their watched targets.
     let mut generator_indices_by_watches: HashMap<Target, Vec<usize>> = HashMap::new();
@@ -67,14 +69,14 @@ pub trait WitnessGenerator<F: Field>: 'static {
     /// flag indicating whether the generator is finished. If the flag is true, the generator will
     /// never be run again, otherwise it will be queued for another run next time a target in its
     /// watch list is populated.
-    fn run(&mut self, witness: &PartialWitness<F>) -> (PartialWitness<F>, bool);
+    fn run(&self, witness: &PartialWitness<F>) -> (PartialWitness<F>, bool);
 }
 
 /// A generator which runs once after a list of dependencies is present in the witness.
 pub trait SimpleGenerator<F: Field>: 'static {
     fn dependencies(&self) -> Vec<Target>;
 
-    fn run_once(&mut self, witness: &PartialWitness<F>) -> PartialWitness<F>;
+    fn run_once(&self, witness: &PartialWitness<F>) -> PartialWitness<F>;
 }
 
 impl<F: Field, SG: SimpleGenerator<F>> WitnessGenerator<F> for SG {
@@ -82,7 +84,7 @@ impl<F: Field, SG: SimpleGenerator<F>> WitnessGenerator<F> for SG {
         self.dependencies()
     }
 
-    fn run(&mut self, witness: &PartialWitness<F>) -> (PartialWitness<F>, bool) {
+    fn run(&self, witness: &PartialWitness<F>) -> (PartialWitness<F>, bool) {
         if witness.contains_all(&self.dependencies()) {
             (self.run_once(witness), true)
         } else {
@@ -102,7 +104,7 @@ impl<F: Field> SimpleGenerator<F> for CopyGenerator {
         vec![self.src]
     }
 
-    fn run_once(&mut self, witness: &PartialWitness<F>) -> PartialWitness<F> {
+    fn run_once(&self, witness: &PartialWitness<F>) -> PartialWitness<F> {
         let value = witness.get_target(self.src);
         PartialWitness::singleton(self.dst, value)
     }
diff --git a/src/prover.rs b/src/prover.rs
index 8ed7417e..4550e7a3 100644
--- a/src/prover.rs
+++ b/src/prover.rs
@@ -1,10 +1,21 @@
 use crate::circuit_data::{CommonCircuitData, ProverOnlyCircuitData};
 use crate::field::field::Field;
+use crate::generator::generate_partial_witness;
 use crate::proof::Proof2;
+use crate::witness::PartialWitness;
 
-pub(crate) fn prove2<F: Field>(
+pub(crate) fn prove<F: Field>(
     prover_data: &ProverOnlyCircuitData<F>,
     common_data: &CommonCircuitData<F>,
+    inputs: PartialWitness<F>,
 ) -> Proof2<F> {
-    todo!()
+    let mut witness = inputs;
+    generate_partial_witness(&mut witness, &prover_data.generators);
+
+    Proof2 {
+        wires_root: todo!(),
+        plonk_z_root: todo!(),
+        plonk_t_root: todo!(),
+        openings: todo!(),
+    }
 }
diff --git a/src/verifier.rs b/src/verifier.rs
index d9d67607..64ae2aed 100644
--- a/src/verifier.rs
+++ b/src/verifier.rs
@@ -1,7 +1,7 @@
 use crate::circuit_data::{CommonCircuitData, VerifierOnlyCircuitData};
 use crate::field::field::Field;
 
-pub(crate) fn verify2<F: Field>(
+pub(crate) fn verify<F: Field>(
     verifier_data: &VerifierOnlyCircuitData,
     common_data: &CommonCircuitData<F>,
 ) {