diff --git a/halo2_frontend/src/circuit.rs b/halo2_frontend/src/circuit.rs
index cff44823b..399ee98cb 100644
--- a/halo2_frontend/src/circuit.rs
+++ b/halo2_frontend/src/circuit.rs
@@ -29,8 +29,8 @@ pub use floor_planner::single_pass::SimpleFloorPlanner;
 
 pub mod layouter;
 
+use crate::plonk::FieldFront;
 pub use table_layouter::{SimpleTableLayouter, TableLayouter};
-use crate::plonk::FieldFr;
 
 /// Compile a circuit.  Runs configure and synthesize on the circuit in order to materialize the
 /// circuit into its columns and the column configuration; as well as doing the fixed column and
@@ -38,7 +38,7 @@ use crate::plonk::FieldFr;
 /// generation, and proof generation.
 /// If `compress_selectors` is true, multiple selector columns may be multiplexed.
 #[allow(clippy::type_complexity)]
-pub fn compile_circuit<FF: FieldFr<Field=F>, F: Field, ConcreteCircuit: Circuit<FF>>(
+pub fn compile_circuit<FF: FieldFront<Field = F>, F: Field, ConcreteCircuit: Circuit<FF>>(
     k: u32,
     circuit: &ConcreteCircuit,
     compress_selectors: bool,
@@ -99,7 +99,10 @@ pub fn compile_circuit<FF: FieldFr<Field=F>, F: Field, ConcreteCircuit: Circuit<
         permutation: halo2_middleware::permutation::AssemblyMid {
             copies: assembly.permutation.copies,
         },
-        fixed: fixed.into_iter().map(|f| f.into_iter().map(|f| f.into_field()).collect()).collect(),
+        fixed: fixed
+            .into_iter()
+            .map(|f| f.into_iter().map(|f| f.into_field()).collect())
+            .collect(),
     };
 
     Ok((
@@ -112,7 +115,7 @@ pub fn compile_circuit<FF: FieldFr<Field=F>, F: Field, ConcreteCircuit: Circuit<
     ))
 }
 
-struct WitnessCollection<'a, F: FieldFr> {
+struct WitnessCollection<'a, F: FieldFront> {
     k: u32,
     current_phase: sealed::Phase,
     advice_column_phase: &'a Vec<sealed::Phase>,
@@ -122,7 +125,7 @@ struct WitnessCollection<'a, F: FieldFr> {
     usable_rows: RangeTo<usize>,
 }
 
-impl<'a, F: FieldFr> Assignment<F> for WitnessCollection<'a, F> {
+impl<'a, F: FieldFront> Assignment<F> for WitnessCollection<'a, F> {
     fn enter_region<NR, N>(&mut self, _: N)
     where
         NR: Into<String>,
@@ -253,7 +256,7 @@ impl<'a, F: FieldFr> Assignment<F> for WitnessCollection<'a, F> {
 
 /// Witness calculator.  Frontend function
 #[derive(Debug)]
-pub struct WitnessCalculator<'a, F: FieldFr, ConcreteCircuit: Circuit<F>> {
+pub struct WitnessCalculator<'a, F: FieldFront, ConcreteCircuit: Circuit<F>> {
     k: u32,
     n: usize,
     unusable_rows_start: usize,
@@ -264,7 +267,7 @@ pub struct WitnessCalculator<'a, F: FieldFr, ConcreteCircuit: Circuit<F>> {
     next_phase: u8,
 }
 
-impl<'a, F: FieldFr, ConcreteCircuit: Circuit<F>> WitnessCalculator<'a, F, ConcreteCircuit> {
+impl<'a, F: FieldFront, ConcreteCircuit: Circuit<F>> WitnessCalculator<'a, F, ConcreteCircuit> {
     /// Create a new WitnessCalculator
     pub fn new(
         k: u32,
@@ -361,7 +364,7 @@ impl<'a, F: FieldFr, ConcreteCircuit: Circuit<F>> WitnessCalculator<'a, F, Concr
 
 // Turn vectors of `Assigned<F>` into vectors of `F` by evaluation the divisions in `Assigned<F>`
 // using batched inversions.
-fn batch_invert_assigned<F: FieldFr>(assigned: Vec<Vec<Assigned<F>>>) -> Vec<Vec<F>> {
+fn batch_invert_assigned<F: FieldFront>(assigned: Vec<Vec<Assigned<F>>>) -> Vec<Vec<F>> {
     let mut assigned_denominators: Vec<_> = assigned
         .iter()
         .map(|f| {
@@ -393,7 +396,7 @@ fn batch_invert_assigned<F: FieldFr>(assigned: Vec<Vec<Assigned<F>>>) -> Vec<Vec
 // Turn a slice of `Assigned<F>` into a vector of F by multiplying each numerator with the elements
 // from `inv_denoms`, assuming that `inv_denoms` are the inverted denominators of the
 // `Assigned<F>`.
-fn poly_invert<F: FieldFr>(
+fn poly_invert<F: FieldFront>(
     poly: &[Assigned<F>],
     inv_denoms: impl ExactSizeIterator<Item = F>,
 ) -> Vec<F> {
@@ -412,7 +415,7 @@ fn poly_invert<F: FieldFr>(
 /// The chip also loads any fixed configuration needed at synthesis time
 /// using its own implementation of `load`, and stores it in [`Chip::Loaded`].
 /// This can be accessed via [`Chip::loaded`].
-pub trait Chip<F: FieldFr>: Sized {
+pub trait Chip<F: FieldFront>: Sized {
     /// A type that holds the configuration for this chip, and any other state it may need
     /// during circuit synthesis, that can be derived during [`Circuit::configure`].
     ///
@@ -484,13 +487,13 @@ pub struct Cell {
 
 /// An assigned cell.
 #[derive(Clone, Debug)]
-pub struct AssignedCell<V, F: FieldFr> {
+pub struct AssignedCell<V, F: FieldFront> {
     value: Value<V>,
     cell: Cell,
     _marker: PhantomData<F>,
 }
 
-impl<V, F: FieldFr> AssignedCell<V, F> {
+impl<V, F: FieldFront> AssignedCell<V, F> {
     /// Returns the value of the [`AssignedCell`].
     pub fn value(&self) -> Value<&V> {
         self.value.as_ref()
@@ -502,7 +505,7 @@ impl<V, F: FieldFr> AssignedCell<V, F> {
     }
 }
 
-impl<V, F: FieldFr> AssignedCell<V, F>
+impl<V, F: FieldFront> AssignedCell<V, F>
 where
     for<'v> Assigned<F>: From<&'v V>,
 {
@@ -512,7 +515,7 @@ where
     }
 }
 
-impl<F: FieldFr> AssignedCell<Assigned<F>, F> {
+impl<F: FieldFront> AssignedCell<Assigned<F>, F> {
     /// Evaluates this assigned cell's value directly, performing an unbatched inversion
     /// if necessary.
     ///
@@ -526,7 +529,7 @@ impl<F: FieldFr> AssignedCell<Assigned<F>, F> {
     }
 }
 
-impl<V: Clone, F: FieldFr> AssignedCell<V, F>
+impl<V: Clone, F: FieldFront> AssignedCell<V, F>
 where
     for<'v> Assigned<F>: From<&'v V>,
 {
@@ -565,17 +568,17 @@ where
 /// "logical" columns that are guaranteed to correspond to the chip (and have come from
 /// `Chip::Config`).
 #[derive(Debug)]
-pub struct Region<'r, F: FieldFr> {
+pub struct Region<'r, F: FieldFront> {
     region: &'r mut dyn layouter::RegionLayouter<F>,
 }
 
-impl<'r, F: FieldFr> From<&'r mut dyn layouter::RegionLayouter<F>> for Region<'r, F> {
+impl<'r, F: FieldFront> From<&'r mut dyn layouter::RegionLayouter<F>> for Region<'r, F> {
     fn from(region: &'r mut dyn layouter::RegionLayouter<F>) -> Self {
         Region { region }
     }
 }
 
-impl<'r, F: FieldFr> Region<'r, F> {
+impl<'r, F: FieldFront> Region<'r, F> {
     /// Enables a selector at the given offset.
     pub fn enable_selector<A, AR>(
         &mut self,
@@ -768,17 +771,17 @@ impl<'r, F: FieldFr> Region<'r, F> {
 
 /// A lookup table in the circuit.
 #[derive(Debug)]
-pub struct Table<'r, F: FieldFr> {
+pub struct Table<'r, F: FieldFront> {
     table: &'r mut dyn TableLayouter<F>,
 }
 
-impl<'r, F: FieldFr> From<&'r mut dyn TableLayouter<F>> for Table<'r, F> {
+impl<'r, F: FieldFront> From<&'r mut dyn TableLayouter<F>> for Table<'r, F> {
     fn from(table: &'r mut dyn TableLayouter<F>) -> Self {
         Table { table }
     }
 }
 
-impl<'r, F: FieldFr> Table<'r, F> {
+impl<'r, F: FieldFront> Table<'r, F> {
     /// Assigns a fixed value to a table cell.
     ///
     /// Returns an error if the table cell has already been assigned to.
@@ -809,7 +812,7 @@ impl<'r, F: FieldFr> Table<'r, F> {
 ///
 /// This abstracts over the circuit assignments, handling row indices etc.
 ///
-pub trait Layouter<F: FieldFr> {
+pub trait Layouter<F: FieldFront> {
     /// Represents the type of the "root" of this layouter, so that nested namespaces
     /// can minimize indirection.
     type Root: Layouter<F>;
@@ -893,9 +896,9 @@ pub trait Layouter<F: FieldFr> {
 /// This is a "namespaced" layouter which borrows a `Layouter` (pushing a namespace
 /// context) and, when dropped, pops out of the namespace context.
 #[derive(Debug)]
-pub struct NamespacedLayouter<'a, F: FieldFr, L: Layouter<F> + 'a>(&'a mut L, PhantomData<F>);
+pub struct NamespacedLayouter<'a, F: FieldFront, L: Layouter<F> + 'a>(&'a mut L, PhantomData<F>);
 
-impl<'a, F: FieldFr, L: Layouter<F> + 'a> Layouter<F> for NamespacedLayouter<'a, F, L> {
+impl<'a, F: FieldFront, L: Layouter<F> + 'a> Layouter<F> for NamespacedLayouter<'a, F, L> {
     type Root = L::Root;
 
     fn assign_region<A, AR, N, NR>(&mut self, name: N, assignment: A) -> Result<AR, Error>
@@ -946,7 +949,7 @@ impl<'a, F: FieldFr, L: Layouter<F> + 'a> Layouter<F> for NamespacedLayouter<'a,
     }
 }
 
-impl<'a, F: FieldFr, L: Layouter<F> + 'a> Drop for NamespacedLayouter<'a, F, L> {
+impl<'a, F: FieldFront, L: Layouter<F> + 'a> Drop for NamespacedLayouter<'a, F, L> {
     fn drop(&mut self) {
         let gadget_name = {
             #[cfg(feature = "gadget-traces")]
diff --git a/halo2_frontend/src/circuit/floor_planner/single_pass.rs b/halo2_frontend/src/circuit/floor_planner/single_pass.rs
index 659b42a0d..9d317f539 100644
--- a/halo2_frontend/src/circuit/floor_planner/single_pass.rs
+++ b/halo2_frontend/src/circuit/floor_planner/single_pass.rs
@@ -5,7 +5,7 @@ use std::marker::PhantomData;
 
 use halo2_middleware::circuit::Any;
 
-use crate::plonk::{Assigned, FieldFr};
+use crate::plonk::{Assigned, FieldFront};
 use crate::{
     circuit::{
         layouter::{RegionColumn, RegionLayouter, RegionShape, SyncDeps, TableLayouter},
@@ -27,7 +27,7 @@ use crate::{
 pub struct SimpleFloorPlanner;
 
 impl FloorPlanner for SimpleFloorPlanner {
-    fn synthesize<F: FieldFr, CS: Assignment<F> + SyncDeps, C: Circuit<F>>(
+    fn synthesize<F: FieldFront, CS: Assignment<F> + SyncDeps, C: Circuit<F>>(
         cs: &mut CS,
         circuit: &C,
         config: C::Config,
@@ -39,7 +39,7 @@ impl FloorPlanner for SimpleFloorPlanner {
 }
 
 /// A [`Layouter`] for a single-chip circuit.
-pub struct SingleChipLayouter<'a, F: FieldFr, CS: Assignment<F> + 'a> {
+pub struct SingleChipLayouter<'a, F: FieldFront, CS: Assignment<F> + 'a> {
     cs: &'a mut CS,
     constants: Vec<Column<Fixed>>,
     /// Stores the starting row for each region.
@@ -51,7 +51,7 @@ pub struct SingleChipLayouter<'a, F: FieldFr, CS: Assignment<F> + 'a> {
     _marker: PhantomData<F>,
 }
 
-impl<'a, F: FieldFr, CS: Assignment<F> + 'a> fmt::Debug for SingleChipLayouter<'a, F, CS> {
+impl<'a, F: FieldFront, CS: Assignment<F> + 'a> fmt::Debug for SingleChipLayouter<'a, F, CS> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         f.debug_struct("SingleChipLayouter")
             .field("regions", &self.regions)
@@ -60,7 +60,7 @@ impl<'a, F: FieldFr, CS: Assignment<F> + 'a> fmt::Debug for SingleChipLayouter<'
     }
 }
 
-impl<'a, F: FieldFr, CS: Assignment<F>> SingleChipLayouter<'a, F, CS> {
+impl<'a, F: FieldFront, CS: Assignment<F>> SingleChipLayouter<'a, F, CS> {
     /// Creates a new single-chip layouter.
     pub fn new(cs: &'a mut CS, constants: Vec<Column<Fixed>>) -> Result<Self, Error> {
         let ret = SingleChipLayouter {
@@ -75,7 +75,7 @@ impl<'a, F: FieldFr, CS: Assignment<F>> SingleChipLayouter<'a, F, CS> {
     }
 }
 
-impl<'a, F: FieldFr, CS: Assignment<F> + 'a + SyncDeps> Layouter<F>
+impl<'a, F: FieldFront, CS: Assignment<F> + 'a + SyncDeps> Layouter<F>
     for SingleChipLayouter<'a, F, CS>
 {
     type Root = Self;
@@ -222,14 +222,14 @@ impl<'a, F: FieldFr, CS: Assignment<F> + 'a + SyncDeps> Layouter<F>
     }
 }
 
-struct SingleChipLayouterRegion<'r, 'a, F: FieldFr, CS: Assignment<F> + 'a> {
+struct SingleChipLayouterRegion<'r, 'a, F: FieldFront, CS: Assignment<F> + 'a> {
     layouter: &'r mut SingleChipLayouter<'a, F, CS>,
     region_index: RegionIndex,
     /// Stores the constants to be assigned, and the cells to which they are copied.
     constants: Vec<(Assigned<F>, Cell)>,
 }
 
-impl<'r, 'a, F: FieldFr, CS: Assignment<F> + 'a> fmt::Debug
+impl<'r, 'a, F: FieldFront, CS: Assignment<F> + 'a> fmt::Debug
     for SingleChipLayouterRegion<'r, 'a, F, CS>
 {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
@@ -240,7 +240,7 @@ impl<'r, 'a, F: FieldFr, CS: Assignment<F> + 'a> fmt::Debug
     }
 }
 
-impl<'r, 'a, F: FieldFr, CS: Assignment<F> + 'a> SingleChipLayouterRegion<'r, 'a, F, CS> {
+impl<'r, 'a, F: FieldFront, CS: Assignment<F> + 'a> SingleChipLayouterRegion<'r, 'a, F, CS> {
     fn new(layouter: &'r mut SingleChipLayouter<'a, F, CS>, region_index: RegionIndex) -> Self {
         SingleChipLayouterRegion {
             layouter,
@@ -250,7 +250,7 @@ impl<'r, 'a, F: FieldFr, CS: Assignment<F> + 'a> SingleChipLayouterRegion<'r, 'a
     }
 }
 
-impl<'r, 'a, F: FieldFr, CS: Assignment<F> + 'a + SyncDeps> RegionLayouter<F>
+impl<'r, 'a, F: FieldFront, CS: Assignment<F> + 'a + SyncDeps> RegionLayouter<F>
     for SingleChipLayouterRegion<'r, 'a, F, CS>
 {
     fn enable_selector<'v>(
diff --git a/halo2_frontend/src/circuit/floor_planner/v1.rs b/halo2_frontend/src/circuit/floor_planner/v1.rs
index 94a0b78d2..9445aa214 100644
--- a/halo2_frontend/src/circuit/floor_planner/v1.rs
+++ b/halo2_frontend/src/circuit/floor_planner/v1.rs
@@ -2,7 +2,7 @@ use std::fmt;
 
 use halo2_middleware::circuit::Any;
 
-use crate::plonk::{Assigned, FieldFr};
+use crate::plonk::{Assigned, FieldFront};
 use crate::{
     circuit::{
         layouter::{RegionColumn, RegionLayouter, RegionShape, SyncDeps, TableLayouter},
@@ -28,7 +28,7 @@ pub mod strategy;
 #[derive(Debug)]
 pub struct V1;
 
-struct V1Plan<'a, F: FieldFr, CS: Assignment<F> + 'a> {
+struct V1Plan<'a, F: FieldFront, CS: Assignment<F> + 'a> {
     cs: &'a mut CS,
     /// Stores the starting row for each region.
     regions: Vec<RegionStart>,
@@ -38,13 +38,13 @@ struct V1Plan<'a, F: FieldFr, CS: Assignment<F> + 'a> {
     table_columns: Vec<TableColumn>,
 }
 
-impl<'a, F: FieldFr, CS: Assignment<F> + 'a> fmt::Debug for V1Plan<'a, F, CS> {
+impl<'a, F: FieldFront, CS: Assignment<F> + 'a> fmt::Debug for V1Plan<'a, F, CS> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         f.debug_struct("floor_planner::V1Plan").finish()
     }
 }
 
-impl<'a, F: FieldFr, CS: Assignment<F> + SyncDeps> V1Plan<'a, F, CS> {
+impl<'a, F: FieldFront, CS: Assignment<F> + SyncDeps> V1Plan<'a, F, CS> {
     /// Creates a new v1 layouter.
     pub fn new(cs: &'a mut CS) -> Result<Self, Error> {
         let ret = V1Plan {
@@ -58,7 +58,7 @@ impl<'a, F: FieldFr, CS: Assignment<F> + SyncDeps> V1Plan<'a, F, CS> {
 }
 
 impl FloorPlanner for V1 {
-    fn synthesize<F: FieldFr, CS: Assignment<F> + SyncDeps, C: Circuit<F>>(
+    fn synthesize<F: FieldFront, CS: Assignment<F> + SyncDeps, C: Circuit<F>>(
         cs: &mut CS,
         circuit: &C,
         config: C::Config,
@@ -142,16 +142,16 @@ impl FloorPlanner for V1 {
 }
 
 #[derive(Debug)]
-enum Pass<'p, 'a, F: FieldFr, CS: Assignment<F> + 'a> {
+enum Pass<'p, 'a, F: FieldFront, CS: Assignment<F> + 'a> {
     Measurement(&'p mut MeasurementPass),
     Assignment(&'p mut AssignmentPass<'p, 'a, F, CS>),
 }
 
 /// A single pass of the [`V1`] layouter.
 #[derive(Debug)]
-pub struct V1Pass<'p, 'a, F: FieldFr, CS: Assignment<F> + 'a>(Pass<'p, 'a, F, CS>);
+pub struct V1Pass<'p, 'a, F: FieldFront, CS: Assignment<F> + 'a>(Pass<'p, 'a, F, CS>);
 
-impl<'p, 'a, F: FieldFr, CS: Assignment<F> + 'a> V1Pass<'p, 'a, F, CS> {
+impl<'p, 'a, F: FieldFront, CS: Assignment<F> + 'a> V1Pass<'p, 'a, F, CS> {
     fn measure(pass: &'p mut MeasurementPass) -> Self {
         V1Pass(Pass::Measurement(pass))
     }
@@ -161,7 +161,7 @@ impl<'p, 'a, F: FieldFr, CS: Assignment<F> + 'a> V1Pass<'p, 'a, F, CS> {
     }
 }
 
-impl<'p, 'a, F: FieldFr, CS: Assignment<F> + SyncDeps> Layouter<F> for V1Pass<'p, 'a, F, CS> {
+impl<'p, 'a, F: FieldFront, CS: Assignment<F> + SyncDeps> Layouter<F> for V1Pass<'p, 'a, F, CS> {
     type Root = Self;
 
     fn assign_region<A, AR, N, NR>(&mut self, name: N, assignment: A) -> Result<AR, Error>
@@ -239,7 +239,7 @@ impl MeasurementPass {
         MeasurementPass { regions: vec![] }
     }
 
-    fn assign_region<F: FieldFr, A, AR>(&mut self, mut assignment: A) -> Result<AR, Error>
+    fn assign_region<F: FieldFront, A, AR>(&mut self, mut assignment: A) -> Result<AR, Error>
     where
         A: FnMut(Region<'_, F>) -> Result<AR, Error>,
     {
@@ -259,13 +259,13 @@ impl MeasurementPass {
 
 /// Assigns the circuit.
 #[derive(Debug)]
-pub struct AssignmentPass<'p, 'a, F: FieldFr, CS: Assignment<F> + 'a> {
+pub struct AssignmentPass<'p, 'a, F: FieldFront, CS: Assignment<F> + 'a> {
     plan: &'p mut V1Plan<'a, F, CS>,
     /// Counter tracking which region we need to assign next.
     region_index: usize,
 }
 
-impl<'p, 'a, F: FieldFr, CS: Assignment<F> + SyncDeps> AssignmentPass<'p, 'a, F, CS> {
+impl<'p, 'a, F: FieldFront, CS: Assignment<F> + SyncDeps> AssignmentPass<'p, 'a, F, CS> {
     fn new(plan: &'p mut V1Plan<'a, F, CS>) -> Self {
         AssignmentPass {
             plan,
@@ -348,12 +348,12 @@ impl<'p, 'a, F: FieldFr, CS: Assignment<F> + SyncDeps> AssignmentPass<'p, 'a, F,
     }
 }
 
-struct V1Region<'r, 'a, F: FieldFr, CS: Assignment<F> + 'a> {
+struct V1Region<'r, 'a, F: FieldFront, CS: Assignment<F> + 'a> {
     plan: &'r mut V1Plan<'a, F, CS>,
     region_index: RegionIndex,
 }
 
-impl<'r, 'a, F: FieldFr, CS: Assignment<F> + 'a> fmt::Debug for V1Region<'r, 'a, F, CS> {
+impl<'r, 'a, F: FieldFront, CS: Assignment<F> + 'a> fmt::Debug for V1Region<'r, 'a, F, CS> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         f.debug_struct("V1Region")
             .field("plan", &self.plan)
@@ -362,13 +362,15 @@ impl<'r, 'a, F: FieldFr, CS: Assignment<F> + 'a> fmt::Debug for V1Region<'r, 'a,
     }
 }
 
-impl<'r, 'a, F: FieldFr, CS: Assignment<F> + 'a> V1Region<'r, 'a, F, CS> {
+impl<'r, 'a, F: FieldFront, CS: Assignment<F> + 'a> V1Region<'r, 'a, F, CS> {
     fn new(plan: &'r mut V1Plan<'a, F, CS>, region_index: RegionIndex) -> Self {
         V1Region { plan, region_index }
     }
 }
 
-impl<'r, 'a, F: FieldFr, CS: Assignment<F> + SyncDeps> RegionLayouter<F> for V1Region<'r, 'a, F, CS> {
+impl<'r, 'a, F: FieldFront, CS: Assignment<F> + SyncDeps> RegionLayouter<F>
+    for V1Region<'r, 'a, F, CS>
+{
     fn enable_selector<'v>(
         &'v mut self,
         annotation: &'v (dyn Fn() -> String + 'v),
diff --git a/halo2_frontend/src/circuit/layouter.rs b/halo2_frontend/src/circuit/layouter.rs
index 796ff6b13..ce8c3d74f 100644
--- a/halo2_frontend/src/circuit/layouter.rs
+++ b/halo2_frontend/src/circuit/layouter.rs
@@ -4,8 +4,8 @@ use std::cmp;
 use std::collections::HashSet;
 use std::fmt;
 
+use crate::plonk::FieldFront;
 use halo2_middleware::circuit::Any;
-use crate::plonk::FieldFr;
 
 pub use super::table_layouter::TableLayouter;
 use super::{Cell, RegionIndex, Value};
@@ -31,7 +31,7 @@ impl<T> SyncDeps for T {}
 /// This trait is used for implementing region assignments:
 ///
 /// ```ignore
-/// impl<'a, F: FieldFr, C: Chip<F>, CS: Assignment<F> + 'a> Layouter<C> for MyLayouter<'a, C, CS> {
+/// impl<'a, F: FieldFront, C: Chip<F>, CS: Assignment<F> + 'a> Layouter<C> for MyLayouter<'a, C, CS> {
 ///     fn assign_region(
 ///         &mut self,
 ///         assignment: impl FnOnce(Region<'_, F, C>) -> Result<(), Error>,
@@ -56,7 +56,7 @@ impl<T> SyncDeps for T {}
 /// `Chip::Config`).
 ///
 /// [`Layouter`]: super::Layouter
-pub trait RegionLayouter<F: FieldFr>: fmt::Debug + SyncDeps {
+pub trait RegionLayouter<F: FieldFront>: fmt::Debug + SyncDeps {
     /// Enables a selector at the given offset.
     fn enable_selector<'v>(
         &'v mut self,
@@ -210,7 +210,7 @@ impl RegionShape {
     }
 }
 
-impl<F: FieldFr> RegionLayouter<F> for RegionShape {
+impl<F: FieldFront> RegionLayouter<F> for RegionShape {
     fn enable_selector<'v>(
         &'v mut self,
         _: &'v (dyn Fn() -> String + 'v),
diff --git a/halo2_frontend/src/circuit/table_layouter.rs b/halo2_frontend/src/circuit/table_layouter.rs
index cab58b56a..1c871b42a 100644
--- a/halo2_frontend/src/circuit/table_layouter.rs
+++ b/halo2_frontend/src/circuit/table_layouter.rs
@@ -6,15 +6,15 @@ use std::{
 };
 
 use super::Value;
+use crate::plonk::FieldFront;
 use crate::plonk::{Assigned, Assignment, Error, TableColumn, TableError};
-use crate::plonk::FieldFr;
 
 /// Helper trait for implementing a custom [`Layouter`].
 ///
 /// This trait is used for implementing table assignments.
 ///
 /// [`Layouter`]: super::Layouter
-pub trait TableLayouter<F: FieldFr>: std::fmt::Debug {
+pub trait TableLayouter<F: FieldFront>: std::fmt::Debug {
     /// Assigns a fixed value to a table cell.
     ///
     /// Returns an error if the table cell has already been assigned to.
@@ -37,14 +37,16 @@ pub trait TableLayouter<F: FieldFr>: std::fmt::Debug {
 type DefaultTableValue<F> = Option<Value<Assigned<F>>>;
 
 /// A table layouter that can be used to assign values to a table.
-pub struct SimpleTableLayouter<'r, 'a, F: FieldFr, CS: Assignment<F> + 'a> {
+pub struct SimpleTableLayouter<'r, 'a, F: FieldFront, CS: Assignment<F> + 'a> {
     cs: &'a mut CS,
     used_columns: &'r [TableColumn],
     /// maps from a fixed column to a pair (default value, vector saying which rows are assigned)
     pub default_and_assigned: HashMap<TableColumn, (DefaultTableValue<F>, Vec<bool>)>,
 }
 
-impl<'r, 'a, F: FieldFr, CS: Assignment<F> + 'a> fmt::Debug for SimpleTableLayouter<'r, 'a, F, CS> {
+impl<'r, 'a, F: FieldFront, CS: Assignment<F> + 'a> fmt::Debug
+    for SimpleTableLayouter<'r, 'a, F, CS>
+{
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         f.debug_struct("SimpleTableLayouter")
             .field("used_columns", &self.used_columns)
@@ -53,7 +55,7 @@ impl<'r, 'a, F: FieldFr, CS: Assignment<F> + 'a> fmt::Debug for SimpleTableLayou
     }
 }
 
-impl<'r, 'a, F: FieldFr, CS: Assignment<F> + 'a> SimpleTableLayouter<'r, 'a, F, CS> {
+impl<'r, 'a, F: FieldFront, CS: Assignment<F> + 'a> SimpleTableLayouter<'r, 'a, F, CS> {
     /// Returns a new SimpleTableLayouter
     pub fn new(cs: &'a mut CS, used_columns: &'r [TableColumn]) -> Self {
         SimpleTableLayouter {
@@ -64,7 +66,7 @@ impl<'r, 'a, F: FieldFr, CS: Assignment<F> + 'a> SimpleTableLayouter<'r, 'a, F,
     }
 }
 
-impl<'r, 'a, F: FieldFr, CS: Assignment<F> + 'a> TableLayouter<F>
+impl<'r, 'a, F: FieldFront, CS: Assignment<F> + 'a> TableLayouter<F>
     for SimpleTableLayouter<'r, 'a, F, CS>
 {
     fn assign_cell<'v>(
diff --git a/halo2_frontend/src/circuit/value.rs b/halo2_frontend/src/circuit/value.rs
index 3e8415ab1..e0adc97e5 100644
--- a/halo2_frontend/src/circuit/value.rs
+++ b/halo2_frontend/src/circuit/value.rs
@@ -1,7 +1,7 @@
 use std::borrow::Borrow;
 use std::ops::{Add, Mul, Neg, Sub};
 
-use crate::plonk::FieldFr;
+use crate::plonk::FieldFront;
 
 use crate::plonk::{Assigned, Error};
 
@@ -523,7 +523,7 @@ where
 // Assigned<Field>
 //
 
-impl<F: FieldFr> From<Value<F>> for Value<Assigned<F>> {
+impl<F: FieldFront> From<Value<F>> for Value<Assigned<F>> {
     #[must_use]
     fn from(value: Value<F>) -> Self {
         Self {
@@ -532,7 +532,7 @@ impl<F: FieldFr> From<Value<F>> for Value<Assigned<F>> {
     }
 }
 
-impl<F: FieldFr> Add<Value<F>> for Value<Assigned<F>> {
+impl<F: FieldFront> Add<Value<F>> for Value<Assigned<F>> {
     type Output = Value<Assigned<F>>;
 
     #[must_use]
@@ -543,7 +543,7 @@ impl<F: FieldFr> Add<Value<F>> for Value<Assigned<F>> {
     }
 }
 
-impl<F: FieldFr> Add<F> for Value<Assigned<F>> {
+impl<F: FieldFront> Add<F> for Value<Assigned<F>> {
     type Output = Value<Assigned<F>>;
 
     #[must_use]
@@ -552,7 +552,7 @@ impl<F: FieldFr> Add<F> for Value<Assigned<F>> {
     }
 }
 
-impl<F: FieldFr> Add<Value<F>> for Value<&Assigned<F>> {
+impl<F: FieldFront> Add<Value<F>> for Value<&Assigned<F>> {
     type Output = Value<Assigned<F>>;
 
     #[must_use]
@@ -563,7 +563,7 @@ impl<F: FieldFr> Add<Value<F>> for Value<&Assigned<F>> {
     }
 }
 
-impl<F: FieldFr> Add<F> for Value<&Assigned<F>> {
+impl<F: FieldFront> Add<F> for Value<&Assigned<F>> {
     type Output = Value<Assigned<F>>;
 
     #[must_use]
@@ -572,7 +572,7 @@ impl<F: FieldFr> Add<F> for Value<&Assigned<F>> {
     }
 }
 
-impl<F: FieldFr> Sub<Value<F>> for Value<Assigned<F>> {
+impl<F: FieldFront> Sub<Value<F>> for Value<Assigned<F>> {
     type Output = Value<Assigned<F>>;
 
     #[must_use]
@@ -583,7 +583,7 @@ impl<F: FieldFr> Sub<Value<F>> for Value<Assigned<F>> {
     }
 }
 
-impl<F: FieldFr> Sub<F> for Value<Assigned<F>> {
+impl<F: FieldFront> Sub<F> for Value<Assigned<F>> {
     type Output = Value<Assigned<F>>;
 
     #[must_use]
@@ -592,7 +592,7 @@ impl<F: FieldFr> Sub<F> for Value<Assigned<F>> {
     }
 }
 
-impl<F: FieldFr> Sub<Value<F>> for Value<&Assigned<F>> {
+impl<F: FieldFront> Sub<Value<F>> for Value<&Assigned<F>> {
     type Output = Value<Assigned<F>>;
 
     #[must_use]
@@ -603,7 +603,7 @@ impl<F: FieldFr> Sub<Value<F>> for Value<&Assigned<F>> {
     }
 }
 
-impl<F: FieldFr> Sub<F> for Value<&Assigned<F>> {
+impl<F: FieldFront> Sub<F> for Value<&Assigned<F>> {
     type Output = Value<Assigned<F>>;
 
     #[must_use]
@@ -612,7 +612,7 @@ impl<F: FieldFr> Sub<F> for Value<&Assigned<F>> {
     }
 }
 
-impl<F: FieldFr> Mul<Value<F>> for Value<Assigned<F>> {
+impl<F: FieldFront> Mul<Value<F>> for Value<Assigned<F>> {
     type Output = Value<Assigned<F>>;
 
     #[must_use]
@@ -623,7 +623,7 @@ impl<F: FieldFr> Mul<Value<F>> for Value<Assigned<F>> {
     }
 }
 
-impl<F: FieldFr> Mul<F> for Value<Assigned<F>> {
+impl<F: FieldFront> Mul<F> for Value<Assigned<F>> {
     type Output = Value<Assigned<F>>;
 
     #[must_use]
@@ -632,7 +632,7 @@ impl<F: FieldFr> Mul<F> for Value<Assigned<F>> {
     }
 }
 
-impl<F: FieldFr> Mul<Value<F>> for Value<&Assigned<F>> {
+impl<F: FieldFront> Mul<Value<F>> for Value<&Assigned<F>> {
     type Output = Value<Assigned<F>>;
 
     #[must_use]
@@ -643,7 +643,7 @@ impl<F: FieldFr> Mul<Value<F>> for Value<&Assigned<F>> {
     }
 }
 
-impl<F: FieldFr> Mul<F> for Value<&Assigned<F>> {
+impl<F: FieldFront> Mul<F> for Value<&Assigned<F>> {
     type Output = Value<Assigned<F>>;
 
     #[must_use]
@@ -655,7 +655,7 @@ impl<F: FieldFr> Mul<F> for Value<&Assigned<F>> {
 impl<V> Value<V> {
     /// Returns the field element corresponding to this value.
     #[must_use]
-    pub fn to_field<F: FieldFr>(&self) -> Value<Assigned<F>>
+    pub fn to_field<F: FieldFront>(&self) -> Value<Assigned<F>>
     where
         for<'v> Assigned<F>: From<&'v V>,
     {
@@ -666,7 +666,7 @@ impl<V> Value<V> {
 
     /// Returns the field element corresponding to this value.
     #[must_use]
-    pub fn into_field<F: FieldFr>(self) -> Value<Assigned<F>>
+    pub fn into_field<F: FieldFront>(self) -> Value<Assigned<F>>
     where
         V: Into<Assigned<F>>,
     {
@@ -679,7 +679,7 @@ impl<V> Value<V> {
     ///
     /// # Examples
     ///
-    /// If you have a `Value<F: FieldFr>`, convert it to `Value<Assigned<F>>` first:
+    /// If you have a `Value<F: FieldFront>`, convert it to `Value<Assigned<F>>` first:
     /// ```
     /// # use halo2curves::pasta::pallas::Base as F;
     /// use halo2_frontend::circuit::Value;
@@ -690,7 +690,7 @@ impl<V> Value<V> {
     /// let _ = v.double();
     /// ```
     #[must_use]
-    pub fn double<F: FieldFr>(&self) -> Value<Assigned<F>>
+    pub fn double<F: FieldFront>(&self) -> Value<Assigned<F>>
     where
         V: Borrow<Assigned<F>>,
     {
@@ -701,7 +701,7 @@ impl<V> Value<V> {
 
     /// Squares this field element.
     #[must_use]
-    pub fn square<F: FieldFr>(&self) -> Value<Assigned<F>>
+    pub fn square<F: FieldFront>(&self) -> Value<Assigned<F>>
     where
         V: Borrow<Assigned<F>>,
     {
@@ -712,7 +712,7 @@ impl<V> Value<V> {
 
     /// Cubes this field element.
     #[must_use]
-    pub fn cube<F: FieldFr>(&self) -> Value<Assigned<F>>
+    pub fn cube<F: FieldFront>(&self) -> Value<Assigned<F>>
     where
         V: Borrow<Assigned<F>>,
     {
@@ -723,7 +723,7 @@ impl<V> Value<V> {
 
     /// Inverts this assigned value (taking the inverse of zero to be zero).
     #[must_use]
-    pub fn invert<F: FieldFr>(&self) -> Value<Assigned<F>>
+    pub fn invert<F: FieldFront>(&self) -> Value<Assigned<F>>
     where
         V: Borrow<Assigned<F>>,
     {
@@ -733,7 +733,7 @@ impl<V> Value<V> {
     }
 }
 
-impl<F: FieldFr> Value<Assigned<F>> {
+impl<F: FieldFront> Value<Assigned<F>> {
     /// Evaluates this value directly, performing an unbatched inversion if necessary.
     ///
     /// If the denominator is zero, the returned value is zero.
diff --git a/halo2_frontend/src/dev.rs b/halo2_frontend/src/dev.rs
index 7e60c8062..2397147f4 100644
--- a/halo2_frontend/src/dev.rs
+++ b/halo2_frontend/src/dev.rs
@@ -41,7 +41,7 @@ pub use gates::CircuitGates;
 mod tfp;
 pub use tfp::TracingFloorPlanner;
 
-use crate::plonk::FieldFr;
+use crate::plonk::FieldFront;
 
 #[cfg(feature = "dev-graph")]
 mod graph;
@@ -89,7 +89,7 @@ impl Region {
 
 /// The value of a particular cell within the circuit.
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
-pub enum CellValue<F: FieldFr> {
+pub enum CellValue<F: FieldFront> {
     /// An unassigned cell.
     Unassigned,
     /// A cell that has been assigned a value.
@@ -100,12 +100,12 @@ pub enum CellValue<F: FieldFr> {
 
 /// A value within an expression.
 #[derive(Clone, Copy, Debug, PartialEq, Eq, Ord, PartialOrd)]
-enum Value<F: FieldFr> {
+enum Value<F: FieldFront> {
     Real(F),
     Poison,
 }
 
-impl<F: FieldFr> From<CellValue<F>> for Value<F> {
+impl<F: FieldFront> From<CellValue<F>> for Value<F> {
     fn from(value: CellValue<F>) -> Self {
         match value {
             // Cells that haven't been explicitly assigned to, default to zero.
@@ -116,7 +116,7 @@ impl<F: FieldFr> From<CellValue<F>> for Value<F> {
     }
 }
 
-impl<F: FieldFr> Neg for Value<F> {
+impl<F: FieldFront> Neg for Value<F> {
     type Output = Self;
 
     fn neg(self) -> Self::Output {
@@ -127,7 +127,7 @@ impl<F: FieldFr> Neg for Value<F> {
     }
 }
 
-impl<F: FieldFr> Add for Value<F> {
+impl<F: FieldFront> Add for Value<F> {
     type Output = Self;
 
     fn add(self, rhs: Self) -> Self::Output {
@@ -138,7 +138,7 @@ impl<F: FieldFr> Add for Value<F> {
     }
 }
 
-impl<F: FieldFr> Mul for Value<F> {
+impl<F: FieldFront> Mul for Value<F> {
     type Output = Self;
 
     fn mul(self, rhs: Self) -> Self::Output {
@@ -156,7 +156,7 @@ impl<F: FieldFr> Mul for Value<F> {
     }
 }
 
-impl<F: FieldFr> Mul<F> for Value<F> {
+impl<F: FieldFront> Mul<F> for Value<F> {
     type Output = Self;
 
     fn mul(self, rhs: F) -> Self::Output {
@@ -289,7 +289,7 @@ impl<F: FieldFr> Mul<F> for Value<F> {
 /// );
 /// ```
 #[derive(Debug)]
-pub struct MockProver<F: FieldFr> {
+pub struct MockProver<F: FieldFront> {
     k: u32,
     n: u32,
     cs: ConstraintSystem<F>,
@@ -321,14 +321,14 @@ pub struct MockProver<F: FieldFr> {
 
 /// Instance Value
 #[derive(Debug, Clone, PartialEq, Eq)]
-pub enum InstanceValue<F: FieldFr> {
+pub enum InstanceValue<F: FieldFront> {
     /// Assigned instance value
     Assigned(F),
     /// Padding
     Padding,
 }
 
-impl<F: FieldFr> InstanceValue<F> {
+impl<F: FieldFront> InstanceValue<F> {
     /// Field value on the instance cell
     pub fn value(&self) -> F {
         match self {
@@ -338,13 +338,13 @@ impl<F: FieldFr> InstanceValue<F> {
     }
 }
 
-impl<F: FieldFr> MockProver<F> {
+impl<F: FieldFront> MockProver<F> {
     fn in_phase<P: Phase>(&self, phase: P) -> bool {
         self.current_phase == phase.to_sealed()
     }
 }
 
-impl<F: FieldFr> Assignment<F> for MockProver<F> {
+impl<F: FieldFront> Assignment<F> for MockProver<F> {
     fn enter_region<NR, N>(&mut self, name: N)
     where
         NR: Into<String>,
@@ -608,7 +608,7 @@ impl<F: FieldFr> Assignment<F> for MockProver<F> {
     }
 }
 
-impl<F: FieldFr + FromUniformBytes<64> + Ord> MockProver<F> {
+impl<F: FieldFront + FromUniformBytes<64> + Ord> MockProver<F> {
     /// Runs a synthetic keygen-and-prove operation on the given circuit, collecting data
     /// about the constraints and their assignments.
     pub fn run<ConcreteCircuit: Circuit<F>>(
diff --git a/halo2_frontend/src/dev/cost.rs b/halo2_frontend/src/dev/cost.rs
index df0ca90c5..9e03afc80 100644
--- a/halo2_frontend/src/dev/cost.rs
+++ b/halo2_frontend/src/dev/cost.rs
@@ -8,10 +8,10 @@ use std::{
     ops::{Add, Mul},
 };
 
+use crate::plonk::FieldFront;
 use group::prime::PrimeGroup;
 use halo2_middleware::circuit::Any;
-use crate::plonk::FieldFr;
-use halo2_middleware::ff::{Field, PrimeField};
+use halo2_middleware::ff::PrimeField;
 use halo2_middleware::poly::Rotation;
 
 use crate::{
@@ -25,7 +25,8 @@ use crate::{
 /// Measures a circuit to determine its costs, and explain what contributes to them.
 #[allow(dead_code)]
 #[derive(Debug)]
-pub struct CircuitCost<G: PrimeGroup, F: FieldFr<Field=G::Scalar>, ConcreteCircuit: Circuit<F>> {
+pub struct CircuitCost<G: PrimeGroup, F: FieldFront<Field = G::Scalar>, ConcreteCircuit: Circuit<F>>
+{
     /// Power-of-2 bound on the number of rows in the circuit.
     k: u32,
     /// Maximum degree of the circuit.
@@ -148,7 +149,7 @@ impl Layout {
     }
 }
 
-impl<F: FieldFr> Assignment<F> for Layout {
+impl<F: FieldFront> Assignment<F> for Layout {
     fn enter_region<NR, N>(&mut self, name_fn: N)
     where
         NR: Into<String>,
@@ -267,7 +268,9 @@ impl<F: FieldFr> Assignment<F> for Layout {
     }
 }
 
-impl<G: PrimeGroup, FE: FieldFr<Field=G::Scalar>, ConcreteCircuit: Circuit<FE>> CircuitCost<G, FE, ConcreteCircuit> {
+impl<G: PrimeGroup, FE: FieldFront<Field = G::Scalar>, ConcreteCircuit: Circuit<FE>>
+    CircuitCost<G, FE, ConcreteCircuit>
+{
     /// Measures a circuit with parameter constant `k`.
     ///
     /// Panics if `k` is not large enough for the circuit.
diff --git a/halo2_frontend/src/dev/cost_model.rs b/halo2_frontend/src/dev/cost_model.rs
index 793c02f71..ec415712c 100644
--- a/halo2_frontend/src/dev/cost_model.rs
+++ b/halo2_frontend/src/dev/cost_model.rs
@@ -4,8 +4,8 @@
 use std::collections::HashSet;
 use std::{iter, num::ParseIntError, str::FromStr};
 
-use crate::plonk::{Circuit, FieldFr};
-use halo2_middleware::ff::{Field, FromUniformBytes};
+use crate::plonk::{Circuit, FieldFront};
+use halo2_middleware::ff::FromUniformBytes;
 use serde::Deserialize;
 use serde_derive::Serialize;
 
@@ -242,7 +242,7 @@ impl CostOptions {
 
 /// Given a Plonk circuit, this function returns a [ModelCircuit]
 pub fn from_circuit_to_model_circuit<
-    F: Ord + FieldFr + FromUniformBytes<64>,
+    F: Ord + FieldFront + FromUniformBytes<64>,
     C: Circuit<F>,
     const COMM: usize,
     const SCALAR: usize,
@@ -257,7 +257,10 @@ pub fn from_circuit_to_model_circuit<
 }
 
 /// Given a Plonk circuit, this function returns [CostOptions]
-pub fn from_circuit_to_cost_model_options<F: Ord + FieldFr + FromUniformBytes<64>, C: Circuit<F>>(
+pub fn from_circuit_to_cost_model_options<
+    F: Ord + FieldFront + FromUniformBytes<64>,
+    C: Circuit<F>,
+>(
     k: u32,
     circuit: &C,
     instances: Vec<Vec<F>>,
diff --git a/halo2_frontend/src/dev/failure.rs b/halo2_frontend/src/dev/failure.rs
index df04821b9..c1108e721 100644
--- a/halo2_frontend/src/dev/failure.rs
+++ b/halo2_frontend/src/dev/failure.rs
@@ -1,7 +1,7 @@
 use std::collections::{BTreeMap, HashSet};
 use std::fmt::{self, Debug};
 
-use crate::plonk::FieldFr;
+use crate::plonk::FieldFront;
 
 use super::metadata::{DebugColumn, DebugVirtualCell};
 use super::MockProver;
@@ -63,7 +63,7 @@ impl FailureLocation {
         }
     }
 
-    pub(super) fn find_expressions<'a, F: FieldFr>(
+    pub(super) fn find_expressions<'a, F: FieldFront>(
         cs: &ConstraintSystem<F>,
         regions: &[Region],
         failure_row: usize,
@@ -370,7 +370,7 @@ impl Debug for VerifyFailure {
 ///
 ///   Gate 'Equality check' (applied at offset 1) queries these cells.
 /// ```
-fn render_cell_not_assigned<F: FieldFr>(
+fn render_cell_not_assigned<F: FieldFront>(
     gates: &[Gate<F>],
     gate: &metadata::Gate,
     region: &metadata::Region,
@@ -439,7 +439,7 @@ fn render_cell_not_assigned<F: FieldFr>(
 ///     x0 = 0x5
 ///     x1 = 0x5
 /// ```
-fn render_constraint_not_satisfied<F: FieldFr>(
+fn render_constraint_not_satisfied<F: FieldFront>(
     gates: &[Gate<F>],
     constraint: &metadata::Constraint,
     location: &FailureLocation,
@@ -504,7 +504,7 @@ fn render_constraint_not_satisfied<F: FieldFr>(
 ///     |   x0 = 0x5
 ///     |   x1 = 1
 /// ```
-fn render_lookup<F: FieldFr>(
+fn render_lookup<F: FieldFront>(
     prover: &MockProver<F>,
     name: &str,
     lookup_index: usize,
@@ -570,7 +570,7 @@ fn render_lookup<F: FieldFr>(
         )
     });
 
-    fn cell_value<'a, F: FieldFr, Q: Into<AnyQuery> + Copy>(
+    fn cell_value<'a, F: FieldFront, Q: Into<AnyQuery> + Copy>(
         load: impl Fn(Q) -> Value<F> + 'a,
     ) -> impl Fn(Q) -> BTreeMap<metadata::VirtualCell, String> + 'a {
         move |query| {
@@ -672,7 +672,7 @@ fn render_lookup<F: FieldFr>(
     }
 }
 
-fn render_shuffle<F: FieldFr>(
+fn render_shuffle<F: FieldFront>(
     prover: &MockProver<F>,
     name: &str,
     shuffle_index: usize,
@@ -736,7 +736,7 @@ fn render_shuffle<F: FieldFr>(
         )
     });
 
-    fn cell_value<'a, F: FieldFr, Q: Into<AnyQuery> + Copy>(
+    fn cell_value<'a, F: FieldFront, Q: Into<AnyQuery> + Copy>(
         load: impl Fn(Q) -> Value<F> + 'a,
     ) -> impl Fn(Q) -> BTreeMap<metadata::VirtualCell, String> + 'a {
         move |query| {
@@ -839,7 +839,7 @@ fn render_shuffle<F: FieldFr>(
 
 impl VerifyFailure {
     /// Emits this failure in pretty-printed format to stderr.
-    pub fn emit<F: FieldFr>(&self, prover: &MockProver<F>) {
+    pub fn emit<F: FieldFront>(&self, prover: &MockProver<F>) {
         match self {
             Self::CellNotAssigned {
                 gate,
diff --git a/halo2_frontend/src/dev/failure/emitter.rs b/halo2_frontend/src/dev/failure/emitter.rs
index 71fd5e075..1a3291077 100644
--- a/halo2_frontend/src/dev/failure/emitter.rs
+++ b/halo2_frontend/src/dev/failure/emitter.rs
@@ -1,6 +1,6 @@
+use crate::plonk::FieldFront;
 use std::collections::BTreeMap;
 use std::iter;
-use crate::plonk::FieldFr;
 
 use super::FailureLocation;
 use crate::dev::{metadata, util};
@@ -136,7 +136,7 @@ pub(super) fn render_cell_layout(
     }
 }
 
-pub(super) fn expression_to_string<F: FieldFr>(
+pub(super) fn expression_to_string<F: FieldFront>(
     expr: &Expression<F>,
     layout: &BTreeMap<i32, BTreeMap<metadata::Column, String>>,
 ) -> String {
diff --git a/halo2_frontend/src/dev/gates.rs b/halo2_frontend/src/dev/gates.rs
index 524e42c3d..54fb8c471 100644
--- a/halo2_frontend/src/dev/gates.rs
+++ b/halo2_frontend/src/dev/gates.rs
@@ -3,8 +3,8 @@ use std::{
     fmt::{self, Write},
 };
 
-use crate::{dev::util, plonk::FieldFr};
 use crate::plonk::{sealed::SealedPhase, Circuit, ConstraintSystem, FirstPhase};
+use crate::{dev::util, plonk::FieldFront};
 
 #[derive(Debug)]
 struct Constraint {
@@ -39,7 +39,7 @@ struct Gate {
 /// #[derive(Clone, Default)]
 /// struct MyCircuit {}
 ///
-/// impl<F: FieldFr> Circuit<F> for MyCircuit {
+/// impl<F: FieldFront> Circuit<F> for MyCircuit {
 ///     type Config = MyConfig;
 ///     type FloorPlanner = SimpleFloorPlanner;
 ///     #[cfg(feature = "circuit-params")]
@@ -101,7 +101,7 @@ pub struct CircuitGates {
 
 impl CircuitGates {
     /// Collects the gates from within the circuit.
-    pub fn collect<F: FieldFr, C: Circuit<F>>(
+    pub fn collect<F: FieldFront, C: Circuit<F>>(
         #[cfg(feature = "circuit-params")] params: C::Params,
     ) -> Self {
         // Collect the graph details.
diff --git a/halo2_frontend/src/dev/graph.rs b/halo2_frontend/src/dev/graph.rs
index 045df059c..44837c26a 100644
--- a/halo2_frontend/src/dev/graph.rs
+++ b/halo2_frontend/src/dev/graph.rs
@@ -1,9 +1,8 @@
 use crate::plonk::{
-    Advice, Assigned, Assignment, Challenge, Circuit, Column, ConstraintSystem, Error, Fixed,
-    FloorPlanner, Instance, Selector, FieldFr
+    Advice, Assigned, Assignment, Challenge, Circuit, Column, ConstraintSystem, Error, FieldFront,
+    Fixed, FloorPlanner, Instance, Selector,
 };
 use halo2_middleware::circuit::Any;
-use halo2_middleware::ff::Field;
 use tabbycat::{AttrList, Edge, GraphBuilder, GraphType, Identity, StmtList};
 
 use crate::circuit::Value;
@@ -16,7 +15,7 @@ pub mod layout;
 /// inside the gadgets and chips that it uses.
 ///
 /// [`Layouter::namespace`]: crate::circuit::Layouter#method.namespace
-pub fn circuit_dot_graph<F: FieldFr, ConcreteCircuit: Circuit<F>>(
+pub fn circuit_dot_graph<F: FieldFront, ConcreteCircuit: Circuit<F>>(
     circuit: &ConcreteCircuit,
 ) -> String {
     // Collect the graph details.
@@ -79,7 +78,7 @@ struct Graph {
     current_namespace: Vec<usize>,
 }
 
-impl<F: FieldFr> Assignment<F> for Graph {
+impl<F: FieldFront> Assignment<F> for Graph {
     fn enter_region<NR, N>(&mut self, _: N)
     where
         NR: Into<String>,
diff --git a/halo2_frontend/src/dev/graph/layout.rs b/halo2_frontend/src/dev/graph/layout.rs
index 2cb18b66f..7e72117f1 100644
--- a/halo2_frontend/src/dev/graph/layout.rs
+++ b/halo2_frontend/src/dev/graph/layout.rs
@@ -1,4 +1,3 @@
-use halo2_middleware::ff::Field;
 use plotters::{
     coord::Shift,
     prelude::{DrawingArea, DrawingAreaErrorKind, DrawingBackend},
@@ -6,7 +5,7 @@ use plotters::{
 use std::collections::HashSet;
 use std::ops::Range;
 
-use crate::plonk::{Circuit, Column, ConstraintSystem, FloorPlanner, FieldFr};
+use crate::plonk::{Circuit, Column, ConstraintSystem, FieldFront, FloorPlanner};
 use crate::{circuit::layouter::RegionColumn, dev::cost::Layout};
 use halo2_middleware::circuit::Any;
 
@@ -80,7 +79,7 @@ impl CircuitLayout {
     }
 
     /// Renders the given circuit on the given drawing area.
-    pub fn render<F: FieldFr, ConcreteCircuit: Circuit<F>, DB: DrawingBackend>(
+    pub fn render<F: FieldFront, ConcreteCircuit: Circuit<F>, DB: DrawingBackend>(
         self,
         k: u32,
         circuit: &ConcreteCircuit,
diff --git a/halo2_frontend/src/dev/tfp.rs b/halo2_frontend/src/dev/tfp.rs
index 38c096d62..eecb9cb9f 100644
--- a/halo2_frontend/src/dev/tfp.rs
+++ b/halo2_frontend/src/dev/tfp.rs
@@ -3,15 +3,18 @@ use std::{fmt, marker::PhantomData};
 use halo2_middleware::circuit::Any;
 use tracing::{debug, debug_span, span::EnteredSpan};
 
-use crate::{circuit::{
-    layouter::{RegionLayouter, SyncDeps},
-    AssignedCell, Cell, Layouter, Region, Table, Value,
-}, plonk::FieldFr};
 use crate::plonk::{
     circuit::expression::{Challenge, Column},
     Advice, Assigned, Assignment, Circuit, ConstraintSystem, Error, Fixed, FloorPlanner, Instance,
     Selector,
 };
+use crate::{
+    circuit::{
+        layouter::{RegionLayouter, SyncDeps},
+        AssignedCell, Cell, Layouter, Region, Table, Value,
+    },
+    plonk::FieldFront,
+};
 
 /// A helper type that augments a [`FloorPlanner`] with [`tracing`] spans and events.
 ///
@@ -35,12 +38,12 @@ use crate::plonk::{
 ///     plonk::{Circuit, ConstraintSystem, Error},
 /// };
 ///
-/// # struct MyCircuit<F: FieldFr> {
+/// # struct MyCircuit<F: FieldFront> {
 /// #     some_witness: Value<F>,
 /// # };
 /// # #[derive(Clone)]
 /// # struct MyConfig;
-/// impl<F: FieldFr> Circuit<F> for MyCircuit<F> {
+/// impl<F: FieldFront> Circuit<F> for MyCircuit<F> {
 ///     // Wrap `TracingFloorPlanner` around your existing floor planner of choice.
 ///     //type FloorPlanner = floor_planner::V1;
 ///     type FloorPlanner = TracingFloorPlanner<floor_planner::V1>;
@@ -85,7 +88,7 @@ pub struct TracingFloorPlanner<P: FloorPlanner> {
 }
 
 impl<P: FloorPlanner> FloorPlanner for TracingFloorPlanner<P> {
-    fn synthesize<F: FieldFr, CS: Assignment<F> + SyncDeps, C: Circuit<F>>(
+    fn synthesize<F: FieldFront, CS: Assignment<F> + SyncDeps, C: Circuit<F>>(
         cs: &mut CS,
         circuit: &C,
         config: C::Config,
@@ -101,12 +104,12 @@ impl<P: FloorPlanner> FloorPlanner for TracingFloorPlanner<P> {
 }
 
 /// A helper type that augments a [`Circuit`] with [`tracing`] spans and events.
-enum TracingCircuit<'c, F: FieldFr, C: Circuit<F>> {
+enum TracingCircuit<'c, F: FieldFront, C: Circuit<F>> {
     Borrowed(&'c C, PhantomData<F>),
     Owned(C, PhantomData<F>),
 }
 
-impl<'c, F: FieldFr, C: Circuit<F>> TracingCircuit<'c, F, C> {
+impl<'c, F: FieldFront, C: Circuit<F>> TracingCircuit<'c, F, C> {
     fn borrowed(circuit: &'c C) -> Self {
         Self::Borrowed(circuit, PhantomData)
     }
@@ -123,7 +126,7 @@ impl<'c, F: FieldFr, C: Circuit<F>> TracingCircuit<'c, F, C> {
     }
 }
 
-impl<'c, F: FieldFr, C: Circuit<F>> Circuit<F> for TracingCircuit<'c, F, C> {
+impl<'c, F: FieldFront, C: Circuit<F>> Circuit<F> for TracingCircuit<'c, F, C> {
     type Config = C::Config;
     type FloorPlanner = C::FloorPlanner;
     #[cfg(feature = "circuit-params")]
@@ -146,13 +149,13 @@ impl<'c, F: FieldFr, C: Circuit<F>> Circuit<F> for TracingCircuit<'c, F, C> {
 }
 
 /// A helper type that augments a [`Layouter`] with [`tracing`] spans and events.
-struct TracingLayouter<F: FieldFr, L: Layouter<F>> {
+struct TracingLayouter<F: FieldFront, L: Layouter<F>> {
     layouter: L,
     namespace_spans: Vec<EnteredSpan>,
     _phantom: PhantomData<F>,
 }
 
-impl<F: FieldFr, L: Layouter<F>> TracingLayouter<F, L> {
+impl<F: FieldFront, L: Layouter<F>> TracingLayouter<F, L> {
     fn new(layouter: L) -> Self {
         Self {
             layouter,
@@ -162,7 +165,7 @@ impl<F: FieldFr, L: Layouter<F>> TracingLayouter<F, L> {
     }
 }
 
-impl<F: FieldFr, L: Layouter<F>> Layouter<F> for TracingLayouter<F, L> {
+impl<F: FieldFront, L: Layouter<F>> Layouter<F> for TracingLayouter<F, L> {
     type Root = Self;
 
     fn assign_region<A, AR, N, NR>(&mut self, name: N, mut assignment: A) -> Result<AR, Error>
@@ -222,23 +225,23 @@ impl<F: FieldFr, L: Layouter<F>> Layouter<F> for TracingLayouter<F, L> {
     }
 }
 
-fn debug_value<F: FieldFr, V: fmt::Debug>(value: &AssignedCell<V, F>) {
+fn debug_value<F: FieldFront, V: fmt::Debug>(value: &AssignedCell<V, F>) {
     value.value().assert_if_known(|v| {
         debug!(target: "assigned", value = ?v);
         true
     });
 }
 
-fn debug_value_and_return_cell<F: FieldFr, V: fmt::Debug>(value: AssignedCell<V, F>) -> Cell {
+fn debug_value_and_return_cell<F: FieldFront, V: fmt::Debug>(value: AssignedCell<V, F>) -> Cell {
     debug_value(&value);
     value.cell()
 }
 
 /// A helper type that augments a [`Region`] with [`tracing`] spans and events.
 #[derive(Debug)]
-struct TracingRegion<'r, F: FieldFr>(Region<'r, F>);
+struct TracingRegion<'r, F: FieldFront>(Region<'r, F>);
 
-impl<'r, F: FieldFr> RegionLayouter<F> for TracingRegion<'r, F> {
+impl<'r, F: FieldFront> RegionLayouter<F> for TracingRegion<'r, F> {
     fn enable_selector<'v>(
         &'v mut self,
         annotation: &'v (dyn Fn() -> String + 'v),
@@ -354,13 +357,13 @@ impl<'r, F: FieldFr> RegionLayouter<F> for TracingRegion<'r, F> {
 }
 
 /// A helper type that augments an [`Assignment`] with [`tracing`] spans and events.
-struct TracingAssignment<'cs, F: FieldFr, CS: Assignment<F>> {
+struct TracingAssignment<'cs, F: FieldFront, CS: Assignment<F>> {
     cs: &'cs mut CS,
     in_region: bool,
     _phantom: PhantomData<F>,
 }
 
-impl<'cs, F: FieldFr, CS: Assignment<F>> TracingAssignment<'cs, F, CS> {
+impl<'cs, F: FieldFront, CS: Assignment<F>> TracingAssignment<'cs, F, CS> {
     fn new(cs: &'cs mut CS) -> Self {
         Self {
             cs,
@@ -370,7 +373,7 @@ impl<'cs, F: FieldFr, CS: Assignment<F>> TracingAssignment<'cs, F, CS> {
     }
 }
 
-impl<'cs, F: FieldFr, CS: Assignment<F>> Assignment<F> for TracingAssignment<'cs, F, CS> {
+impl<'cs, F: FieldFront, CS: Assignment<F>> Assignment<F> for TracingAssignment<'cs, F, CS> {
     fn enter_region<NR, N>(&mut self, name_fn: N)
     where
         NR: Into<String>,
diff --git a/halo2_frontend/src/dev/util.rs b/halo2_frontend/src/dev/util.rs
index 0a1dfe4ba..e1e036c6c 100644
--- a/halo2_frontend/src/dev/util.rs
+++ b/halo2_frontend/src/dev/util.rs
@@ -1,12 +1,12 @@
 use std::collections::BTreeMap;
 
 use super::{metadata, CellValue, InstanceValue, Value};
+use crate::plonk::FieldFront;
 use crate::plonk::{
     AdviceQuery, Column, ColumnType, Expression, FixedQuery, Gate, InstanceQuery, VirtualCell,
 };
 use halo2_middleware::circuit::Any;
 use halo2_middleware::poly::Rotation;
-use crate::plonk::FieldFr;
 
 pub(crate) struct AnyQuery {
     /// Query index
@@ -52,7 +52,7 @@ impl From<InstanceQuery> for AnyQuery {
     }
 }
 
-pub(super) fn format_value<F: FieldFr>(v: F) -> String {
+pub(super) fn format_value<F: FieldFront>(v: F) -> String {
     if v.is_zero_vartime() {
         "0".into()
     } else if v == F::ONE {
@@ -69,7 +69,7 @@ pub(super) fn format_value<F: FieldFr>(v: F) -> String {
     }
 }
 
-pub(super) fn load<'a, F: FieldFr, T: ColumnType, Q: Into<AnyQuery> + Copy>(
+pub(super) fn load<'a, F: FieldFront, T: ColumnType, Q: Into<AnyQuery> + Copy>(
     n: i32,
     row: i32,
     queries: &'a [(Column<T>, Rotation)],
@@ -82,7 +82,7 @@ pub(super) fn load<'a, F: FieldFr, T: ColumnType, Q: Into<AnyQuery> + Copy>(
     }
 }
 
-pub(super) fn load_instance<'a, F: FieldFr, T: ColumnType, Q: Into<AnyQuery> + Copy>(
+pub(super) fn load_instance<'a, F: FieldFront, T: ColumnType, Q: Into<AnyQuery> + Copy>(
     n: i32,
     row: i32,
     queries: &'a [(Column<T>, Rotation)],
@@ -96,7 +96,7 @@ pub(super) fn load_instance<'a, F: FieldFr, T: ColumnType, Q: Into<AnyQuery> + C
     }
 }
 
-fn cell_value<'a, F: FieldFr, Q: Into<AnyQuery> + Copy>(
+fn cell_value<'a, F: FieldFront, Q: Into<AnyQuery> + Copy>(
     virtual_cells: &'a [VirtualCell],
     load: impl Fn(Q) -> Value<F> + 'a,
 ) -> impl Fn(Q) -> BTreeMap<metadata::VirtualCell, String> + 'a {
@@ -129,7 +129,7 @@ fn cell_value<'a, F: FieldFr, Q: Into<AnyQuery> + Copy>(
     }
 }
 
-pub(super) fn cell_values<'a, F: FieldFr>(
+pub(super) fn cell_values<'a, F: FieldFront>(
     gate: &Gate<F>,
     poly: &Expression<F>,
     load_fixed: impl Fn(FixedQuery) -> Value<F> + 'a,
diff --git a/halo2_frontend/src/lib.rs b/halo2_frontend/src/lib.rs
index 60f14c042..fb4513738 100644
--- a/halo2_frontend/src/lib.rs
+++ b/halo2_frontend/src/lib.rs
@@ -2,4 +2,4 @@
 
 pub mod circuit;
 pub mod dev;
-pub mod plonk;
\ No newline at end of file
+pub mod plonk;
diff --git a/halo2_frontend/src/plonk/assigned.rs b/halo2_frontend/src/plonk/assigned.rs
index 755b5ddde..b072e6bcb 100644
--- a/halo2_frontend/src/plonk/assigned.rs
+++ b/halo2_frontend/src/plonk/assigned.rs
@@ -1,5 +1,5 @@
+use crate::plonk::FieldFront;
 use std::ops::{Add, AddAssign, Mul, MulAssign, Neg, Sub, SubAssign};
-use crate::plonk::FieldFr;
 
 /// A value assigned to a cell within a circuit.
 ///
@@ -16,31 +16,31 @@ pub enum Assigned<F> {
     Rational(F, F),
 }
 
-impl<F: FieldFr> From<&Assigned<F>> for Assigned<F> {
+impl<F: FieldFront> From<&Assigned<F>> for Assigned<F> {
     fn from(val: &Assigned<F>) -> Self {
         *val
     }
 }
 
-impl<F: FieldFr> From<&F> for Assigned<F> {
+impl<F: FieldFront> From<&F> for Assigned<F> {
     fn from(numerator: &F) -> Self {
         Assigned::Trivial(*numerator)
     }
 }
 
-impl<F: FieldFr> From<F> for Assigned<F> {
+impl<F: FieldFront> From<F> for Assigned<F> {
     fn from(numerator: F) -> Self {
         Assigned::Trivial(numerator)
     }
 }
 
-impl<F: FieldFr> From<(F, F)> for Assigned<F> {
+impl<F: FieldFront> From<(F, F)> for Assigned<F> {
     fn from((numerator, denominator): (F, F)) -> Self {
         Assigned::Rational(numerator, denominator)
     }
 }
 
-impl<F: FieldFr> PartialEq for Assigned<F> {
+impl<F: FieldFront> PartialEq for Assigned<F> {
     fn eq(&self, other: &Self) -> bool {
         match (self, other) {
             // At least one side is directly zero.
@@ -68,9 +68,9 @@ impl<F: FieldFr> PartialEq for Assigned<F> {
     }
 }
 
-impl<F: FieldFr> Eq for Assigned<F> {}
+impl<F: FieldFront> Eq for Assigned<F> {}
 
-impl<F: FieldFr> Neg for Assigned<F> {
+impl<F: FieldFront> Neg for Assigned<F> {
     type Output = Assigned<F>;
     fn neg(self) -> Self::Output {
         match self {
@@ -81,14 +81,14 @@ impl<F: FieldFr> Neg for Assigned<F> {
     }
 }
 
-impl<F: FieldFr> Neg for &Assigned<F> {
+impl<F: FieldFront> Neg for &Assigned<F> {
     type Output = Assigned<F>;
     fn neg(self) -> Self::Output {
         -*self
     }
 }
 
-impl<F: FieldFr> Add for Assigned<F> {
+impl<F: FieldFront> Add for Assigned<F> {
     type Output = Assigned<F>;
     fn add(self, rhs: Assigned<F>) -> Assigned<F> {
         match (self, rhs) {
@@ -120,108 +120,108 @@ impl<F: FieldFr> Add for Assigned<F> {
     }
 }
 
-impl<F: FieldFr> Add<F> for Assigned<F> {
+impl<F: FieldFront> Add<F> for Assigned<F> {
     type Output = Assigned<F>;
     fn add(self, rhs: F) -> Assigned<F> {
         self + Self::Trivial(rhs)
     }
 }
 
-impl<F: FieldFr> Add<F> for &Assigned<F> {
+impl<F: FieldFront> Add<F> for &Assigned<F> {
     type Output = Assigned<F>;
     fn add(self, rhs: F) -> Assigned<F> {
         *self + rhs
     }
 }
 
-impl<F: FieldFr> Add<&Assigned<F>> for Assigned<F> {
+impl<F: FieldFront> Add<&Assigned<F>> for Assigned<F> {
     type Output = Assigned<F>;
     fn add(self, rhs: &Self) -> Assigned<F> {
         self + *rhs
     }
 }
 
-impl<F: FieldFr> Add<Assigned<F>> for &Assigned<F> {
+impl<F: FieldFront> Add<Assigned<F>> for &Assigned<F> {
     type Output = Assigned<F>;
     fn add(self, rhs: Assigned<F>) -> Assigned<F> {
         *self + rhs
     }
 }
 
-impl<F: FieldFr> Add<&Assigned<F>> for &Assigned<F> {
+impl<F: FieldFront> Add<&Assigned<F>> for &Assigned<F> {
     type Output = Assigned<F>;
     fn add(self, rhs: &Assigned<F>) -> Assigned<F> {
         *self + *rhs
     }
 }
 
-impl<F: FieldFr> AddAssign for Assigned<F> {
+impl<F: FieldFront> AddAssign for Assigned<F> {
     fn add_assign(&mut self, rhs: Self) {
         *self = *self + rhs;
     }
 }
 
-impl<F: FieldFr> AddAssign<&Assigned<F>> for Assigned<F> {
+impl<F: FieldFront> AddAssign<&Assigned<F>> for Assigned<F> {
     fn add_assign(&mut self, rhs: &Self) {
         *self = *self + rhs;
     }
 }
 
-impl<F: FieldFr> Sub for Assigned<F> {
+impl<F: FieldFront> Sub for Assigned<F> {
     type Output = Assigned<F>;
     fn sub(self, rhs: Assigned<F>) -> Assigned<F> {
         self + (-rhs)
     }
 }
 
-impl<F: FieldFr> Sub<F> for Assigned<F> {
+impl<F: FieldFront> Sub<F> for Assigned<F> {
     type Output = Assigned<F>;
     fn sub(self, rhs: F) -> Assigned<F> {
         self + (-rhs)
     }
 }
 
-impl<F: FieldFr> Sub<F> for &Assigned<F> {
+impl<F: FieldFront> Sub<F> for &Assigned<F> {
     type Output = Assigned<F>;
     fn sub(self, rhs: F) -> Assigned<F> {
         *self - rhs
     }
 }
 
-impl<F: FieldFr> Sub<&Assigned<F>> for Assigned<F> {
+impl<F: FieldFront> Sub<&Assigned<F>> for Assigned<F> {
     type Output = Assigned<F>;
     fn sub(self, rhs: &Self) -> Assigned<F> {
         self - *rhs
     }
 }
 
-impl<F: FieldFr> Sub<Assigned<F>> for &Assigned<F> {
+impl<F: FieldFront> Sub<Assigned<F>> for &Assigned<F> {
     type Output = Assigned<F>;
     fn sub(self, rhs: Assigned<F>) -> Assigned<F> {
         *self - rhs
     }
 }
 
-impl<F: FieldFr> Sub<&Assigned<F>> for &Assigned<F> {
+impl<F: FieldFront> Sub<&Assigned<F>> for &Assigned<F> {
     type Output = Assigned<F>;
     fn sub(self, rhs: &Assigned<F>) -> Assigned<F> {
         *self - *rhs
     }
 }
 
-impl<F: FieldFr> SubAssign for Assigned<F> {
+impl<F: FieldFront> SubAssign for Assigned<F> {
     fn sub_assign(&mut self, rhs: Self) {
         *self = *self - rhs;
     }
 }
 
-impl<F: FieldFr> SubAssign<&Assigned<F>> for Assigned<F> {
+impl<F: FieldFront> SubAssign<&Assigned<F>> for Assigned<F> {
     fn sub_assign(&mut self, rhs: &Self) {
         *self = *self - rhs;
     }
 }
 
-impl<F: FieldFr> Mul for Assigned<F> {
+impl<F: FieldFront> Mul for Assigned<F> {
     type Output = Assigned<F>;
     fn mul(self, rhs: Assigned<F>) -> Assigned<F> {
         match (self, rhs) {
@@ -242,40 +242,40 @@ impl<F: FieldFr> Mul for Assigned<F> {
     }
 }
 
-impl<F: FieldFr> Mul<F> for Assigned<F> {
+impl<F: FieldFront> Mul<F> for Assigned<F> {
     type Output = Assigned<F>;
     fn mul(self, rhs: F) -> Assigned<F> {
         self * Self::Trivial(rhs)
     }
 }
 
-impl<F: FieldFr> Mul<F> for &Assigned<F> {
+impl<F: FieldFront> Mul<F> for &Assigned<F> {
     type Output = Assigned<F>;
     fn mul(self, rhs: F) -> Assigned<F> {
         *self * rhs
     }
 }
 
-impl<F: FieldFr> Mul<&Assigned<F>> for Assigned<F> {
+impl<F: FieldFront> Mul<&Assigned<F>> for Assigned<F> {
     type Output = Assigned<F>;
     fn mul(self, rhs: &Assigned<F>) -> Assigned<F> {
         self * *rhs
     }
 }
 
-impl<F: FieldFr> MulAssign for Assigned<F> {
+impl<F: FieldFront> MulAssign for Assigned<F> {
     fn mul_assign(&mut self, rhs: Self) {
         *self = *self * rhs;
     }
 }
 
-impl<F: FieldFr> MulAssign<&Assigned<F>> for Assigned<F> {
+impl<F: FieldFront> MulAssign<&Assigned<F>> for Assigned<F> {
     fn mul_assign(&mut self, rhs: &Self) {
         *self = *self * rhs;
     }
 }
 
-impl<F: FieldFr> Assigned<F> {
+impl<F: FieldFront> Assigned<F> {
     /// Returns the numerator.
     pub fn numerator(&self) -> F {
         match self {
@@ -371,9 +371,9 @@ mod proptests {
         ops::{Add, Mul, Neg, Sub},
     };
 
+    use crate::plonk::FieldFront;
     use halo2curves::pasta::Fp;
     use proptest::{collection::vec, prelude::*, sample::select};
-    use crate::plonk::FieldFr;
 
     use super::Assigned;
 
@@ -384,7 +384,7 @@ mod proptests {
         fn inv0(&self) -> Self;
     }
 
-    impl<F: FieldFr> UnaryOperand for F {
+    impl<F: FieldFront> UnaryOperand for F {
         fn double(&self) -> Self {
             self.double()
         }
@@ -402,7 +402,7 @@ mod proptests {
         }
     }
 
-    impl<F: FieldFr> UnaryOperand for Assigned<F> {
+    impl<F: FieldFront> UnaryOperand for Assigned<F> {
         fn double(&self) -> Self {
             self.double()
         }
@@ -450,8 +450,8 @@ mod proptests {
     }
 
     trait BinaryOperand: Sized + Add<Output = Self> + Sub<Output = Self> + Mul<Output = Self> {}
-    impl<F: FieldFr> BinaryOperand for F {}
-    impl<F: FieldFr> BinaryOperand for Assigned<F> {}
+    impl<F: FieldFront> BinaryOperand for F {}
+    impl<F: FieldFront> BinaryOperand for Assigned<F> {}
 
     #[derive(Clone, Debug)]
     enum BinaryOperator {
diff --git a/halo2_frontend/src/plonk/circuit.rs b/halo2_frontend/src/plonk/circuit.rs
index d784d5727..552e415fd 100644
--- a/halo2_frontend/src/plonk/circuit.rs
+++ b/halo2_frontend/src/plonk/circuit.rs
@@ -15,7 +15,7 @@ pub trait ColumnType:
     'static + Sized + Copy + std::fmt::Debug + PartialEq + Eq + Into<Any>
 {
     /// Return expression from cell
-    fn query_cell<F: FieldFr>(&self, index: usize, at: Rotation) -> Expression<F>;
+    fn query_cell<F: FieldFront>(&self, index: usize, at: Rotation) -> Expression<F>;
 }
 
 /// An advice column
@@ -31,7 +31,7 @@ pub struct Fixed;
 pub struct Instance;
 
 impl ColumnType for Advice {
-    fn query_cell<F: FieldFr>(&self, index: usize, at: Rotation) -> Expression<F> {
+    fn query_cell<F: FieldFront>(&self, index: usize, at: Rotation) -> Expression<F> {
         Expression::Advice(AdviceQuery {
             index: None,
             column_index: index,
@@ -40,7 +40,7 @@ impl ColumnType for Advice {
     }
 }
 impl ColumnType for Fixed {
-    fn query_cell<F: FieldFr>(&self, index: usize, at: Rotation) -> Expression<F> {
+    fn query_cell<F: FieldFront>(&self, index: usize, at: Rotation) -> Expression<F> {
         Expression::Fixed(FixedQuery {
             index: None,
             column_index: index,
@@ -49,7 +49,7 @@ impl ColumnType for Fixed {
     }
 }
 impl ColumnType for Instance {
-    fn query_cell<F: FieldFr>(&self, index: usize, at: Rotation) -> Expression<F> {
+    fn query_cell<F: FieldFront>(&self, index: usize, at: Rotation) -> Expression<F> {
         Expression::Instance(InstanceQuery {
             index: None,
             column_index: index,
@@ -58,7 +58,7 @@ impl ColumnType for Instance {
     }
 }
 impl ColumnType for Any {
-    fn query_cell<F: FieldFr>(&self, index: usize, at: Rotation) -> Expression<F> {
+    fn query_cell<F: FieldFront>(&self, index: usize, at: Rotation) -> Expression<F> {
         match self {
             Any::Advice => Expression::Advice(AdviceQuery {
                 index: None,
@@ -99,7 +99,7 @@ impl From<Instance> for Any {
 
 /// This trait allows a [`Circuit`] to direct some backend to assign a witness
 /// for a constraint system.
-pub trait Assignment<F: FieldFr> {
+pub trait Assignment<F: FieldFront> {
     /// Creates a new region and enters into it.
     ///
     /// Panics if we are currently in a region (if `exit_region` was not called).
@@ -228,7 +228,7 @@ pub trait FloorPlanner {
     /// - Perform any necessary setup or measurement tasks, which may involve one or more
     ///   calls to `Circuit::default().synthesize(config, &mut layouter)`.
     /// - Call `circuit.synthesize(config, &mut layouter)` exactly once.
-    fn synthesize<F: FieldFr, CS: Assignment<F> + SyncDeps, C: Circuit<F>>(
+    fn synthesize<F: FieldFront, CS: Assignment<F> + SyncDeps, C: Circuit<F>>(
         cs: &mut CS,
         circuit: &C,
         config: C::Config,
@@ -239,7 +239,7 @@ pub trait FloorPlanner {
 /// This is a trait that circuits provide implementations for so that the
 /// backend prover can ask the circuit to synthesize using some given
 /// [`ConstraintSystem`] implementation.
-pub trait Circuit<F: FieldFr> {
+pub trait Circuit<F: FieldFront> {
     /// This is a configuration object that stores things like columns.
     type Config: Clone;
     /// The floor planner used for this circuit. This is an associated type of the
diff --git a/halo2_frontend/src/plonk/circuit/compress_selectors.rs b/halo2_frontend/src/plonk/circuit/compress_selectors.rs
index 507cd77bf..70c252067 100644
--- a/halo2_frontend/src/plonk/circuit/compress_selectors.rs
+++ b/halo2_frontend/src/plonk/circuit/compress_selectors.rs
@@ -1,4 +1,4 @@
-use super::{Expression, FieldFr};
+use super::{Expression, FieldFront};
 
 /// This describes a selector and where it is activated.
 #[derive(Debug, Clone)]
@@ -19,7 +19,7 @@ pub(crate) struct SelectorDescription {
 /// This describes the assigned combination of a particular selector as well as
 /// the expression it should be substituted with.
 #[derive(Debug, Clone)]
-pub(crate) struct SelectorAssignment<F: FieldFr> {
+pub(crate) struct SelectorAssignment<F: FieldFront> {
     /// The selector that this structure references, by index.
     pub selector: usize,
 
@@ -47,7 +47,7 @@ pub(crate) struct SelectorAssignment<F: FieldFr> {
 /// substitutions to the constraint system.
 ///
 /// This function is completely deterministic.
-pub(crate) fn process<F: FieldFr, E>(
+pub(crate) fn process<F: FieldFront, E>(
     mut selectors: Vec<SelectorDescription>,
     max_degree: usize,
     mut allocate_fixed_column: E,
@@ -229,11 +229,11 @@ where
 mod tests {
     use super::*;
     use crate::plonk::FixedQuery;
+    use halo2_middleware::ff::Field;
     use halo2_middleware::poly::Rotation;
     use halo2curves::pasta::Fp;
     use proptest::collection::{vec, SizeRange};
     use proptest::prelude::*;
-    use halo2_middleware::ff::Field;
 
     prop_compose! {
         fn arb_selector(assignment_size: usize, max_degree: usize)
diff --git a/halo2_frontend/src/plonk/circuit/constraint_system.rs b/halo2_frontend/src/plonk/circuit/constraint_system.rs
index b75a8903d..f7edbb6b3 100644
--- a/halo2_frontend/src/plonk/circuit/constraint_system.rs
+++ b/halo2_frontend/src/plonk/circuit/constraint_system.rs
@@ -1,5 +1,6 @@
 use super::compress_selectors;
 use super::expression::sealed;
+use crate::plonk::FieldFront;
 use crate::plonk::{
     lookup, permutation, shuffle, Advice, AdviceQuery, Challenge, Column, Expression, FirstPhase,
     Fixed, FixedQuery, Instance, InstanceQuery, Phase, Selector, TableColumn,
@@ -11,7 +12,6 @@ use halo2_middleware::poly::Rotation;
 use std::collections::HashMap;
 use std::convert::TryFrom;
 use std::fmt::Debug;
-use crate::plonk::FieldFr;
 
 /// Represents an index into a vector where each entry corresponds to a distinct
 /// point that polynomials are queried at.
@@ -40,12 +40,12 @@ impl<Col: Into<Column<Any>>> From<(Col, Rotation)> for VirtualCell {
 ///
 /// These are returned by the closures passed to `ConstraintSystem::create_gate`.
 #[derive(Debug)]
-pub struct Constraint<F: FieldFr> {
+pub struct Constraint<F: FieldFront> {
     name: String,
     poly: Expression<F>,
 }
 
-impl<F: FieldFr> From<Expression<F>> for Constraint<F> {
+impl<F: FieldFront> From<Expression<F>> for Constraint<F> {
     fn from(poly: Expression<F>) -> Self {
         Constraint {
             name: "".to_string(),
@@ -54,7 +54,7 @@ impl<F: FieldFr> From<Expression<F>> for Constraint<F> {
     }
 }
 
-impl<F: FieldFr, S: AsRef<str>> From<(S, Expression<F>)> for Constraint<F> {
+impl<F: FieldFront, S: AsRef<str>> From<(S, Expression<F>)> for Constraint<F> {
     fn from((name, poly): (S, Expression<F>)) -> Self {
         Constraint {
             name: name.as_ref().to_string(),
@@ -63,7 +63,7 @@ impl<F: FieldFr, S: AsRef<str>> From<(S, Expression<F>)> for Constraint<F> {
     }
 }
 
-impl<F: FieldFr> From<Expression<F>> for Vec<Constraint<F>> {
+impl<F: FieldFront> From<Expression<F>> for Vec<Constraint<F>> {
     fn from(poly: Expression<F>) -> Self {
         vec![Constraint {
             name: "".to_string(),
@@ -108,12 +108,12 @@ impl<F: FieldFr> From<Expression<F>> for Vec<Constraint<F>> {
 /// support Rust 1.51 or 1.52. If your minimum supported Rust version is 1.53 or greater,
 /// you can pass an array directly.
 #[derive(Debug)]
-pub struct Constraints<F: FieldFr, C: Into<Constraint<F>>, Iter: IntoIterator<Item = C>> {
+pub struct Constraints<F: FieldFront, C: Into<Constraint<F>>, Iter: IntoIterator<Item = C>> {
     selector: Expression<F>,
     constraints: Iter,
 }
 
-impl<F: FieldFr, C: Into<Constraint<F>>, Iter: IntoIterator<Item = C>> Constraints<F, C, Iter> {
+impl<F: FieldFront, C: Into<Constraint<F>>, Iter: IntoIterator<Item = C>> Constraints<F, C, Iter> {
     /// Constructs a set of constraints that are controlled by the given selector.
     ///
     /// Each constraint `c` in `iterator` will be converted into the constraint
@@ -126,7 +126,7 @@ impl<F: FieldFr, C: Into<Constraint<F>>, Iter: IntoIterator<Item = C>> Constrain
     }
 }
 
-fn apply_selector_to_constraint<F: FieldFr, C: Into<Constraint<F>>>(
+fn apply_selector_to_constraint<F: FieldFront, C: Into<Constraint<F>>>(
     (selector, c): (Expression<F>, C),
 ) -> Constraint<F> {
     let constraint: Constraint<F> = c.into();
@@ -142,7 +142,7 @@ type ConstraintsIterator<F, C, I> = std::iter::Map<
     ApplySelectorToConstraint<F, C>,
 >;
 
-impl<F: FieldFr, C: Into<Constraint<F>>, Iter: IntoIterator<Item = C>> IntoIterator
+impl<F: FieldFront, C: Into<Constraint<F>>, Iter: IntoIterator<Item = C>> IntoIterator
     for Constraints<F, C, Iter>
 {
     type Item = Constraint<F>;
@@ -157,7 +157,7 @@ impl<F: FieldFr, C: Into<Constraint<F>>, Iter: IntoIterator<Item = C>> IntoItera
 
 /// Gate
 #[derive(Clone, Debug)]
-pub struct Gate<F: FieldFr> {
+pub struct Gate<F: FieldFront> {
     pub(crate) name: String,
     pub(crate) constraint_names: Vec<String>,
     pub(crate) polys: Vec<Expression<F>>,
@@ -167,7 +167,7 @@ pub struct Gate<F: FieldFr> {
     pub(crate) queried_cells: Vec<VirtualCell>,
 }
 
-impl<F: FieldFr> Gate<F> {
+impl<F: FieldFront> Gate<F> {
     /// Returns the gate name.
     pub fn name(&self) -> &str {
         self.name.as_str()
@@ -192,7 +192,7 @@ impl<F: FieldFr> Gate<F> {
     }
 }
 
-impl<F: FieldFr<Field=IF>, IF: Field> From<ConstraintSystem<F>> for ConstraintSystemMid<IF> {
+impl<F: FieldFront<Field = IF>, IF: Field> From<ConstraintSystem<F>> for ConstraintSystemMid<IF> {
     fn from(cs: ConstraintSystem<F>) -> Self {
         ConstraintSystemMid {
             num_fixed_columns: cs.num_fixed_columns,
@@ -259,7 +259,7 @@ impl<F: FieldFr<Field=IF>, IF: Field> From<ConstraintSystem<F>> for ConstraintSy
 /// This is a description of the circuit environment, such as the gate, column and
 /// permutation arrangements.
 #[derive(Debug, Clone)]
-pub struct ConstraintSystem<F: FieldFr> {
+pub struct ConstraintSystem<F: FieldFront> {
     pub(crate) num_fixed_columns: usize,
     pub(crate) num_advice_columns: usize,
     pub(crate) num_instance_columns: usize,
@@ -309,7 +309,7 @@ pub struct ConstraintSystem<F: FieldFr> {
     pub(crate) minimum_degree: Option<usize>,
 }
 
-impl<F: FieldFr> Default for ConstraintSystem<F> {
+impl<F: FieldFront> Default for ConstraintSystem<F> {
     fn default() -> ConstraintSystem<F> {
         ConstraintSystem {
             num_fixed_columns: 0,
@@ -336,7 +336,7 @@ impl<F: FieldFr> Default for ConstraintSystem<F> {
     }
 }
 
-impl<F: FieldFr> ConstraintSystem<F> {
+impl<F: FieldFront> ConstraintSystem<F> {
     /// Enables this fixed column to be used for global constant assignments.
     ///
     /// # Side-effects
@@ -694,7 +694,7 @@ impl<F: FieldFr> ConstraintSystem<F> {
     }
 
     fn replace_selectors_with_fixed(&mut self, selector_replacements: &[Expression<F>]) {
-        fn replace_selectors<F: FieldFr>(
+        fn replace_selectors<F: FieldFront>(
             expr: &mut Expression<F>,
             selector_replacements: &[Expression<F>],
             must_be_nonsimple: bool,
@@ -1110,13 +1110,13 @@ impl<F: FieldFr> ConstraintSystem<F> {
 /// Exposes the "virtual cells" that can be queried while creating a custom gate or lookup
 /// table.
 #[derive(Debug)]
-pub struct VirtualCells<'a, F: FieldFr> {
+pub struct VirtualCells<'a, F: FieldFront> {
     pub(super) meta: &'a mut ConstraintSystem<F>,
     pub(super) queried_selectors: Vec<Selector>,
     pub(super) queried_cells: Vec<VirtualCell>,
 }
 
-impl<'a, F: FieldFr> VirtualCells<'a, F> {
+impl<'a, F: FieldFront> VirtualCells<'a, F> {
     fn new(meta: &'a mut ConstraintSystem<F>) -> Self {
         VirtualCells {
             meta,
diff --git a/halo2_frontend/src/plonk/circuit/expression.rs b/halo2_frontend/src/plonk/circuit/expression.rs
index 9ce4298e4..4279b7a18 100644
--- a/halo2_frontend/src/plonk/circuit/expression.rs
+++ b/halo2_frontend/src/plonk/circuit/expression.rs
@@ -46,27 +46,27 @@ impl<C: ColumnType> Column<C> {
     }
 
     /// Return expression from column at a relative position
-    pub fn query_cell<F: FieldFr>(&self, at: Rotation) -> Expression<F> {
+    pub fn query_cell<F: FieldFront>(&self, at: Rotation) -> Expression<F> {
         self.column_type.query_cell(self.index, at)
     }
 
     /// Return expression from column at the current row
-    pub fn cur<F: FieldFr>(&self) -> Expression<F> {
+    pub fn cur<F: FieldFront>(&self) -> Expression<F> {
         self.query_cell(Rotation::cur())
     }
 
     /// Return expression from column at the next row
-    pub fn next<F: FieldFr>(&self) -> Expression<F> {
+    pub fn next<F: FieldFront>(&self) -> Expression<F> {
         self.query_cell(Rotation::next())
     }
 
     /// Return expression from column at the previous row
-    pub fn prev<F: FieldFr>(&self) -> Expression<F> {
+    pub fn prev<F: FieldFront>(&self) -> Expression<F> {
         self.query_cell(Rotation::prev())
     }
 
     /// Return expression from column at the specified rotation
-    pub fn rot<F: FieldFr>(&self, rotation: i32) -> Expression<F> {
+    pub fn rot<F: FieldFront>(&self, rotation: i32) -> Expression<F> {
         self.query_cell(Rotation(rotation))
     }
 }
@@ -262,7 +262,7 @@ impl SealedPhase for ThirdPhase {
 ///     s: Selector,
 /// }
 ///
-/// fn circuit_logic<F: FieldFr, C: Chip<F>>(chip: C, mut layouter: impl Layouter<F>) -> Result<(), Error> {
+/// fn circuit_logic<F: FieldFront, C: Chip<F>>(chip: C, mut layouter: impl Layouter<F>) -> Result<(), Error> {
 ///     let config = chip.config();
 ///     # let config: Config = todo!();
 ///     layouter.assign_region(|| "bar", |mut region| {
@@ -278,7 +278,11 @@ pub struct Selector(pub usize, pub(crate) bool);
 
 impl Selector {
     /// Enable this selector at the given offset within the given region.
-    pub fn enable<F: FieldFr>(&self, region: &mut Region<F>, offset: usize) -> Result<(), Error> {
+    pub fn enable<F: FieldFront>(
+        &self,
+        region: &mut Region<F>,
+        offset: usize,
+    ) -> Result<(), Error> {
         region.enable_selector(|| "", self, offset)
     }
 
@@ -294,7 +298,7 @@ impl Selector {
     }
 
     /// Return expression from selector
-    pub fn expr<F: FieldFr>(&self) -> Expression<F> {
+    pub fn expr<F: FieldFront>(&self) -> Expression<F> {
         Expression::Selector(*self)
     }
 }
@@ -416,7 +420,7 @@ impl Challenge {
     }
 
     /// Return Expression
-    pub fn expr<F: FieldFr>(&self) -> Expression<F> {
+    pub fn expr<F: FieldFront>(&self) -> Expression<F> {
         Expression::Challenge(*self)
     }
 }
@@ -441,7 +445,7 @@ impl From<ChallengeMid> for Challenge {
 
 /// Low-degree expression representing an identity that must hold over the committed columns.
 #[derive(Copy, Clone, PartialEq, Eq)]
-pub enum Expression<F: FieldFr> {
+pub enum Expression<F: FieldFront> {
     /// This is a constant polynomial
     Constant(F),
     /// This is a virtual selector
@@ -467,7 +471,7 @@ pub enum Expression<F: FieldFr> {
 }
 
 // Arena context
-pub trait FieldFr: Field {
+pub trait FieldFront: Field {
     type Field: Field;
     fn alloc(expr: Expression<Self>) -> ExprRef<Self>;
     fn get(ref_: &ExprRef<Self>) -> Expression<Self>;
@@ -477,19 +481,19 @@ pub trait FieldFr: Field {
 
 #[derive(Clone, Copy, Eq, PartialEq)]
 pub struct ExprRef<F>(usize, std::marker::PhantomData<F>);
-impl<F: FieldFr> Into<ExprRef<F>> for Expression<F> {
+impl<F: FieldFront> Into<ExprRef<F>> for Expression<F> {
     fn into(self) -> ExprRef<F> {
         F::alloc(self)
     }
 }
 
 #[allow(unused)]
-struct ArenaPool<F: FieldFr> {
+struct ArenaPool<F: FieldFront> {
     expressions: Vec<Expression<F>>,
 }
 
 #[allow(unused)]
-impl<F: FieldFr> ArenaPool<F> {
+impl<F: FieldFront> ArenaPool<F> {
     fn new() -> Self {
         Self {
             expressions: Vec::new(),
@@ -505,7 +509,7 @@ impl<F: FieldFr> ArenaPool<F> {
     }
 }
 
-impl<F: FieldFr<Field = IF>, IF: Field> From<Expression<F>> for ExpressionMid<IF> {
+impl<F: FieldFront<Field = IF>, IF: Field> From<Expression<F>> for ExpressionMid<IF> {
     fn from(val: Expression<F>) -> Self {
         match val {
             Expression::Constant(c) => ExpressionMid::Constant(c.into_field()),
@@ -554,7 +558,7 @@ impl<F: FieldFr<Field = IF>, IF: Field> From<Expression<F>> for ExpressionMid<IF
     }
 }
 
-impl<F: FieldFr> Expression<F> {
+impl<F: FieldFront> Expression<F> {
     /// Make side effects
     pub fn query_cells(&mut self, cells: &mut VirtualCells<'_, F>) {
         match self {
@@ -1021,7 +1025,7 @@ impl<F: FieldFr> Expression<F> {
     }
 }
 
-impl<F: FieldFr> std::fmt::Debug for Expression<F> {
+impl<F: FieldFront> std::fmt::Debug for Expression<F> {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match self {
             Expression::Constant(scalar) => f.debug_tuple("Constant").field(scalar).finish(),
@@ -1084,7 +1088,7 @@ impl<F: FieldFr> std::fmt::Debug for Expression<F> {
     }
 }
 
-impl<F: FieldFr> Neg for Expression<F> {
+impl<F: FieldFront> Neg for Expression<F> {
     type Output = Expression<F>;
     fn neg(self) -> Self::Output {
         let ref_ = match self {
@@ -1096,7 +1100,7 @@ impl<F: FieldFr> Neg for Expression<F> {
     }
 }
 
-impl<F: FieldFr> Add for Expression<F> {
+impl<F: FieldFront> Add for Expression<F> {
     type Output = Expression<F>;
     fn add(self, rhs: Expression<F>) -> Expression<F> {
         if self.contains_simple_selector() || rhs.contains_simple_selector() {
@@ -1115,7 +1119,7 @@ impl<F: FieldFr> Add for Expression<F> {
     }
 }
 
-impl<F: FieldFr> Sub for Expression<F> {
+impl<F: FieldFront> Sub for Expression<F> {
     type Output = Expression<F>;
     fn sub(self, rhs: Expression<F>) -> Expression<F> {
         if self.contains_simple_selector() || rhs.contains_simple_selector() {
@@ -1135,7 +1139,7 @@ impl<F: FieldFr> Sub for Expression<F> {
     }
 }
 
-impl<F: FieldFr> Mul for Expression<F> {
+impl<F: FieldFront> Mul for Expression<F> {
     type Output = Expression<F>;
     fn mul(self, rhs: Expression<F>) -> Expression<F> {
         if self.contains_simple_selector() && rhs.contains_simple_selector() {
@@ -1153,7 +1157,7 @@ impl<F: FieldFr> Mul for Expression<F> {
     }
 }
 
-impl<F: FieldFr> Mul<F> for Expression<F> {
+impl<F: FieldFront> Mul<F> for Expression<F> {
     type Output = Expression<F>;
     fn mul(self, rhs: F) -> Expression<F> {
         let self_ = match self {
@@ -1164,14 +1168,14 @@ impl<F: FieldFr> Mul<F> for Expression<F> {
     }
 }
 
-impl<F: FieldFr> Sum<Self> for Expression<F> {
+impl<F: FieldFront> Sum<Self> for Expression<F> {
     fn sum<I: Iterator<Item = Self>>(iter: I) -> Self {
         iter.reduce(|acc, x| acc + x)
             .unwrap_or(Expression::Constant(F::ZERO))
     }
 }
 
-impl<F: FieldFr> Product<Self> for Expression<F> {
+impl<F: FieldFront> Product<Self> for Expression<F> {
     fn product<I: Iterator<Item = Self>>(iter: I) -> Self {
         iter.reduce(|acc, x| acc * x)
             .unwrap_or(Expression::Constant(F::ONE))
@@ -1179,9 +1183,9 @@ impl<F: FieldFr> Product<Self> for Expression<F> {
 }
 
 #[allow(non_camel_case_types)]
-pub struct ExprArena<F: FieldFr>(Vec<Expression<F>>);
+pub struct ExprArena<F: FieldFront>(Vec<Expression<F>>);
 
-impl<F: FieldFr> ExprArena<F> {
+impl<F: FieldFront> ExprArena<F> {
     pub fn new() -> Self {
         Self(Vec::new())
     }
@@ -1199,11 +1203,12 @@ impl<F: FieldFr> ExprArena<F> {
 macro_rules! expression_arena {
     ($arena:ident, $field:ty) => {
         fn $arena() -> &'static std::sync::RwLock<ExprArena<$field>> {
-            static LINES: std::sync::OnceLock<std::sync::RwLock<ExprArena<$field>>> = std::sync::OnceLock::new();
+            static LINES: std::sync::OnceLock<std::sync::RwLock<ExprArena<$field>>> =
+                std::sync::OnceLock::new();
             LINES.get_or_init(|| std::sync::RwLock::new(ExprArena::new()))
         }
 
-        impl crate::plonk::FieldFr for $field {
+        impl crate::plonk::FieldFront for $field {
             type Field = $field;
             fn into_field(self) -> Self::Field {
                 self
@@ -1221,7 +1226,7 @@ macro_rules! expression_arena {
 
         impl Into<crate::plonk::ExprRef<$field>> for $field {
             fn into(self) -> crate::plonk::ExprRef<$field> {
-                crate::plonk::FieldFr::alloc(crate::plonk::Expression::Constant(self))
+                crate::plonk::FieldFront::alloc(crate::plonk::Expression::Constant(self))
             }
         }
     };
@@ -1234,7 +1239,6 @@ expression_arena!(arena_pasta_fp, halo2curves::pasta::Fp);
 
 #[cfg(test)]
 mod tests {
-    use super::Expression;
     use super::*;
     use halo2curves::bn256::Fr;
 
diff --git a/halo2_frontend/src/plonk/keygen.rs b/halo2_frontend/src/plonk/keygen.rs
index 88650e825..5bdd11707 100644
--- a/halo2_frontend/src/plonk/keygen.rs
+++ b/halo2_frontend/src/plonk/keygen.rs
@@ -1,7 +1,7 @@
 use std::ops::Range;
 
+use crate::plonk::FieldFront;
 use halo2_middleware::circuit::Any;
-use crate::plonk::FieldFr;
 
 use crate::circuit::Value;
 use crate::plonk::{
@@ -10,7 +10,7 @@ use crate::plonk::{
 
 /// Assembly to be used in circuit synthesis.
 #[derive(Debug)]
-pub(crate) struct Assembly<F: FieldFr> {
+pub(crate) struct Assembly<F: FieldFront> {
     pub(crate) k: u32,
     pub(crate) fixed: Vec<Vec<Assigned<F>>>,
     pub(crate) permutation: permutation::Assembly,
@@ -20,7 +20,7 @@ pub(crate) struct Assembly<F: FieldFr> {
     pub(crate) _marker: std::marker::PhantomData<F>,
 }
 
-impl<F: FieldFr> Assignment<F> for Assembly<F> {
+impl<F: FieldFront> Assignment<F> for Assembly<F> {
     fn enter_region<NR, N>(&mut self, _: N)
     where
         NR: Into<String>,
diff --git a/halo2_frontend/src/plonk/lookup.rs b/halo2_frontend/src/plonk/lookup.rs
index 5e9f9e2b8..d45225ff3 100644
--- a/halo2_frontend/src/plonk/lookup.rs
+++ b/halo2_frontend/src/plonk/lookup.rs
@@ -1,16 +1,16 @@
 use crate::plonk::Expression;
+use crate::plonk::FieldFront;
 use std::fmt::{self, Debug};
-use crate::plonk::FieldFr;
 
 /// Expressions involved in a lookup argument, with a name as metadata.
 #[derive(Clone)]
-pub struct Argument<F: FieldFr> {
+pub struct Argument<F: FieldFront> {
     pub(crate) name: String,
     pub(crate) input_expressions: Vec<Expression<F>>,
     pub(crate) table_expressions: Vec<Expression<F>>,
 }
 
-impl<F: FieldFr> Debug for Argument<F> {
+impl<F: FieldFront> Debug for Argument<F> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         f.debug_struct("Argument")
             .field("input_expressions", &self.input_expressions)
@@ -19,7 +19,7 @@ impl<F: FieldFr> Debug for Argument<F> {
     }
 }
 
-impl<F: FieldFr> Argument<F> {
+impl<F: FieldFront> Argument<F> {
     /// Constructs a new lookup argument.
     ///
     /// `table_map` is a sequence of `(input, table)` tuples.
diff --git a/halo2_frontend/src/plonk/shuffle.rs b/halo2_frontend/src/plonk/shuffle.rs
index 6f90f04eb..2d485182c 100644
--- a/halo2_frontend/src/plonk/shuffle.rs
+++ b/halo2_frontend/src/plonk/shuffle.rs
@@ -1,16 +1,16 @@
 use crate::plonk::Expression;
+use crate::plonk::FieldFront;
 use std::fmt::{self, Debug};
-use crate::plonk::FieldFr;
 
 /// Expressions involved in a shuffle argument, with a name as metadata.
 #[derive(Clone)]
-pub struct Argument<F: FieldFr> {
+pub struct Argument<F: FieldFront> {
     pub(crate) name: String,
     pub(crate) input_expressions: Vec<Expression<F>>,
     pub(crate) shuffle_expressions: Vec<Expression<F>>,
 }
 
-impl<F: FieldFr> Debug for Argument<F> {
+impl<F: FieldFront> Debug for Argument<F> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         f.debug_struct("Argument")
             .field("input_expressions", &self.input_expressions)
@@ -19,7 +19,7 @@ impl<F: FieldFr> Debug for Argument<F> {
     }
 }
 
-impl<F: FieldFr> Argument<F> {
+impl<F: FieldFront> Argument<F> {
     /// Constructs a new shuffle argument.
     ///
     /// `shuffle` is a sequence of `(input, shuffle)` tuples.
diff --git a/halo2_proofs/CHANGELOG.md b/halo2_proofs/CHANGELOG.md
index e087727a3..b5aaf86a1 100644
--- a/halo2_proofs/CHANGELOG.md
+++ b/halo2_proofs/CHANGELOG.md
@@ -11,7 +11,7 @@ and this project adheres to Rust's notion of
 ### Added
 - `halo2_proofs::circuit::Value`, a more usable and type-safe replacement for
   `Option<V>` in circuit synthesis.
-- `impl Mul<F: FieldFr> for &Assigned<F>`
+- `impl Mul<F: FieldFront> for &Assigned<F>`
 
 ### Changed
 All APIs that represented witnessed values as `Option<V>` now represent them as
diff --git a/halo2_proofs/benches/dev_lookup.rs b/halo2_proofs/benches/dev_lookup.rs
index e3ca036a4..ad03956d9 100644
--- a/halo2_proofs/benches/dev_lookup.rs
+++ b/halo2_proofs/benches/dev_lookup.rs
@@ -2,7 +2,7 @@
 extern crate criterion;
 
 use ff::{Field, PrimeField};
-use halo2_frontend::plonk::FieldFr;
+use halo2_frontend::plonk::FieldFront;
 use halo2_proofs::circuit::{Layouter, SimpleFloorPlanner, Value};
 use halo2_proofs::dev::MockProver;
 use halo2_proofs::plonk::*;
@@ -15,7 +15,7 @@ use criterion::{BenchmarkId, Criterion};
 
 fn criterion_benchmark(c: &mut Criterion) {
     #[derive(Clone, Default)]
-    struct MyCircuit<F: FieldFr> {
+    struct MyCircuit<F: FieldFront> {
         _marker: PhantomData<F>,
     }
 
@@ -26,7 +26,7 @@ fn criterion_benchmark(c: &mut Criterion) {
         advice: Column<Advice>,
     }
 
-    impl<F: FieldFr + From<u64>> Circuit<F> for MyCircuit<F> {
+    impl<F: FieldFront + From<u64>> Circuit<F> for MyCircuit<F> {
         type Config = MyConfig;
         type FloorPlanner = SimpleFloorPlanner;
         #[cfg(feature = "circuit-params")]
diff --git a/halo2_proofs/benches/plonk.rs b/halo2_proofs/benches/plonk.rs
index 9802969a7..100c76b5f 100644
--- a/halo2_proofs/benches/plonk.rs
+++ b/halo2_proofs/benches/plonk.rs
@@ -2,7 +2,7 @@
 extern crate criterion;
 
 use group::ff::Field;
-use halo2_frontend::plonk::FieldFr;
+use halo2_frontend::plonk::FieldFront;
 use halo2_proofs::circuit::{Cell, Layouter, SimpleFloorPlanner, Value};
 use halo2_proofs::plonk::*;
 use halo2_proofs::poly::{commitment::ParamsProver, Rotation};
@@ -44,7 +44,7 @@ fn criterion_benchmark(c: &mut Criterion) {
         sm: Column<Fixed>,
     }
 
-    trait StandardCs<FF: FieldFr> {
+    trait StandardCs<FF: FieldFront> {
         fn raw_multiply<F>(
             &self,
             layouter: &mut impl Layouter<FF>,
@@ -68,17 +68,17 @@ fn criterion_benchmark(c: &mut Criterion) {
     }
 
     #[derive(Clone)]
-    struct MyCircuit<F: FieldFr> {
+    struct MyCircuit<F: FieldFront> {
         a: Value<F>,
         k: u32,
     }
 
-    struct StandardPlonk<F: FieldFr> {
+    struct StandardPlonk<F: FieldFront> {
         config: PlonkConfig,
         _marker: PhantomData<F>,
     }
 
-    impl<FF: FieldFr> StandardPlonk<FF> {
+    impl<FF: FieldFront> StandardPlonk<FF> {
         fn new(config: PlonkConfig) -> Self {
             StandardPlonk {
                 config,
@@ -87,7 +87,7 @@ fn criterion_benchmark(c: &mut Criterion) {
         }
     }
 
-    impl<FF: FieldFr> StandardCs<FF> for StandardPlonk<FF> {
+    impl<FF: FieldFront> StandardCs<FF> for StandardPlonk<FF> {
         fn raw_multiply<F>(
             &self,
             layouter: &mut impl Layouter<FF>,
@@ -187,7 +187,7 @@ fn criterion_benchmark(c: &mut Criterion) {
         }
     }
 
-    impl<F: FieldFr> Circuit<F> for MyCircuit<F> {
+    impl<F: FieldFront> Circuit<F> for MyCircuit<F> {
         type Config = PlonkConfig;
         type FloorPlanner = SimpleFloorPlanner;
         #[cfg(feature = "circuit-params")]
@@ -288,7 +288,15 @@ fn criterion_benchmark(c: &mut Criterion) {
         };
 
         let mut transcript = Blake2bWrite::<_, _, Challenge255<EqAffine>>::init(vec![]);
-        create_proof::<IPACommitmentScheme<EqAffine>, ProverIPA<EqAffine>, _, _, _, _, halo2curves::pasta::Fp>(
+        create_proof::<
+            IPACommitmentScheme<EqAffine>,
+            ProverIPA<EqAffine>,
+            _,
+            _,
+            _,
+            _,
+            halo2curves::pasta::Fp,
+        >(
             params,
             pk,
             &[circuit],
diff --git a/halo2_proofs/examples/circuit-layout.rs b/halo2_proofs/examples/circuit-layout.rs
index 6547498df..c0e206fee 100644
--- a/halo2_proofs/examples/circuit-layout.rs
+++ b/halo2_proofs/examples/circuit-layout.rs
@@ -47,12 +47,12 @@ trait StandardCs<FF: Field> {
     ) -> Result<(), ErrorFront>;
 }
 
-struct MyCircuit<F: FieldFr> {
+struct MyCircuit<F: FieldFront> {
     a: Value<F>,
     lookup_table: Vec<F>,
 }
 
-struct StandardPlonk<F: FieldFr> {
+struct StandardPlonk<F: FieldFront> {
     config: PlonkConfig,
     _marker: PhantomData<F>,
 }
@@ -175,7 +175,7 @@ impl<FF: Field> StandardCs<FF> for StandardPlonk<FF> {
     }
 }
 
-impl<F: FieldFr> Circuit<F> for MyCircuit<F> {
+impl<F: FieldFront> Circuit<F> for MyCircuit<F> {
     type Config = PlonkConfig;
     type FloorPlanner = SimpleFloorPlanner;
     #[cfg(feature = "circuit-params")]
diff --git a/halo2_proofs/examples/simple-example.rs b/halo2_proofs/examples/simple-example.rs
index f526e2232..2578c36d2 100644
--- a/halo2_proofs/examples/simple-example.rs
+++ b/halo2_proofs/examples/simple-example.rs
@@ -1,6 +1,6 @@
 use std::marker::PhantomData;
 
-use halo2_frontend::plonk::FieldFr;
+use halo2_frontend::plonk::FieldFront;
 use halo2_proofs::{
     arithmetic::Field,
     circuit::{AssignedCell, Chip, Layouter, Region, SimpleFloorPlanner, Value},
@@ -9,7 +9,7 @@ use halo2_proofs::{
 };
 
 // ANCHOR: instructions
-trait NumericInstructions<F: FieldFr>: Chip<F> {
+trait NumericInstructions<F: FieldFront>: Chip<F> {
     /// Variable representing a number.
     type Num;
 
@@ -48,7 +48,7 @@ trait NumericInstructions<F: FieldFr>: Chip<F> {
 // ANCHOR: chip
 /// The chip that will implement our instructions! Chips store their own
 /// config, as well as type markers if necessary.
-struct FieldChip<F: FieldFr> {
+struct FieldChip<F: FieldFront> {
     config: FieldConfig,
     _marker: PhantomData<F>,
 }
@@ -74,7 +74,7 @@ struct FieldConfig {
     s_mul: Selector,
 }
 
-impl<F: FieldFr> FieldChip<F> {
+impl<F: FieldFront> FieldChip<F> {
     fn construct(config: <Self as Chip<F>>::Config) -> Self {
         Self {
             config,
@@ -135,7 +135,7 @@ impl<F: FieldFr> FieldChip<F> {
 // ANCHOR_END: chip-config
 
 // ANCHOR: chip-impl
-impl<F: FieldFr> Chip<F> for FieldChip<F> {
+impl<F: FieldFront> Chip<F> for FieldChip<F> {
     type Config = FieldConfig;
     type Loaded = ();
 
@@ -152,9 +152,9 @@ impl<F: FieldFr> Chip<F> for FieldChip<F> {
 // ANCHOR: instructions-impl
 /// A variable representing a number.
 #[derive(Clone)]
-struct Number<F: FieldFr>(AssignedCell<F, F>);
+struct Number<F: FieldFront>(AssignedCell<F, F>);
 
-impl<F: FieldFr> NumericInstructions<F> for FieldChip<F> {
+impl<F: FieldFront> NumericInstructions<F> for FieldChip<F> {
     type Num = Number<F>;
 
     fn load_private(
@@ -247,13 +247,13 @@ impl<F: FieldFr> NumericInstructions<F> for FieldChip<F> {
 /// they won't have any value during key generation. During proving, if any of these
 /// were `None` we would get an error.
 #[derive(Default)]
-struct MyCircuit<F: FieldFr> {
+struct MyCircuit<F: FieldFront> {
     constant: F,
     a: Value<F>,
     b: Value<F>,
 }
 
-impl<F: FieldFr> Circuit<F> for MyCircuit<F> {
+impl<F: FieldFront> Circuit<F> for MyCircuit<F> {
     // Since we are using a single chip for everything, we can just reuse its config.
     type Config = FieldConfig;
     type FloorPlanner = SimpleFloorPlanner;
diff --git a/halo2_proofs/examples/two-chip.rs b/halo2_proofs/examples/two-chip.rs
index a6badb16e..98f583886 100644
--- a/halo2_proofs/examples/two-chip.rs
+++ b/halo2_proofs/examples/two-chip.rs
@@ -1,6 +1,6 @@
 use std::marker::PhantomData;
 
-use halo2_frontend::plonk::FieldFr;
+use halo2_frontend::plonk::FieldFront;
 use halo2_proofs::{
     arithmetic::Field,
     circuit::{AssignedCell, Chip, Layouter, Region, SimpleFloorPlanner, Value},
@@ -11,9 +11,9 @@ use halo2_proofs::{
 // ANCHOR: field-instructions
 /// A variable representing a number.
 #[derive(Clone)]
-struct Number<F: FieldFr>(AssignedCell<F, F>);
+struct Number<F: FieldFront>(AssignedCell<F, F>);
 
-trait FieldInstructions<F: FieldFr>: AddInstructions<F> + MulInstructions<F> {
+trait FieldInstructions<F: FieldFront>: AddInstructions<F> + MulInstructions<F> {
     /// Variable representing a number.
     type Num;
 
@@ -44,7 +44,7 @@ trait FieldInstructions<F: FieldFr>: AddInstructions<F> + MulInstructions<F> {
 // ANCHOR_END: field-instructions
 
 // ANCHOR: add-instructions
-trait AddInstructions<F: FieldFr>: Chip<F> {
+trait AddInstructions<F: FieldFront>: Chip<F> {
     /// Variable representing a number.
     type Num;
 
@@ -59,7 +59,7 @@ trait AddInstructions<F: FieldFr>: Chip<F> {
 // ANCHOR_END: add-instructions
 
 // ANCHOR: mul-instructions
-trait MulInstructions<F: FieldFr>: Chip<F> {
+trait MulInstructions<F: FieldFront>: Chip<F> {
     /// Variable representing a number.
     type Num;
 
@@ -109,28 +109,28 @@ struct MulConfig {
 
 // ANCHOR: field-chip
 /// The top-level chip that will implement the `FieldInstructions`.
-struct FieldChip<F: FieldFr> {
+struct FieldChip<F: FieldFront> {
     config: FieldConfig,
     _marker: PhantomData<F>,
 }
 // ANCHOR_END: field-chip
 
 // ANCHOR: add-chip
-struct AddChip<F: FieldFr> {
+struct AddChip<F: FieldFront> {
     config: AddConfig,
     _marker: PhantomData<F>,
 }
 // ANCHOR END: add-chip
 
 // ANCHOR: mul-chip
-struct MulChip<F: FieldFr> {
+struct MulChip<F: FieldFront> {
     config: MulConfig,
     _marker: PhantomData<F>,
 }
 // ANCHOR_END: mul-chip
 
 // ANCHOR: add-chip-trait-impl
-impl<F: FieldFr> Chip<F> for AddChip<F> {
+impl<F: FieldFront> Chip<F> for AddChip<F> {
     type Config = AddConfig;
     type Loaded = ();
 
@@ -145,7 +145,7 @@ impl<F: FieldFr> Chip<F> for AddChip<F> {
 // ANCHOR END: add-chip-trait-impl
 
 // ANCHOR: add-chip-impl
-impl<F: FieldFr> AddChip<F> {
+impl<F: FieldFront> AddChip<F> {
     fn construct(config: <Self as Chip<F>>::Config, _loaded: <Self as Chip<F>>::Loaded) -> Self {
         Self {
             config,
@@ -175,7 +175,7 @@ impl<F: FieldFr> AddChip<F> {
 // ANCHOR END: add-chip-impl
 
 // ANCHOR: add-instructions-impl
-impl<F: FieldFr> AddInstructions<F> for FieldChip<F> {
+impl<F: FieldFront> AddInstructions<F> for FieldChip<F> {
     type Num = Number<F>;
     fn add(
         &self,
@@ -190,7 +190,7 @@ impl<F: FieldFr> AddInstructions<F> for FieldChip<F> {
     }
 }
 
-impl<F: FieldFr> AddInstructions<F> for AddChip<F> {
+impl<F: FieldFront> AddInstructions<F> for AddChip<F> {
     type Num = Number<F>;
 
     fn add(
@@ -232,7 +232,7 @@ impl<F: FieldFr> AddInstructions<F> for AddChip<F> {
 // ANCHOR END: add-instructions-impl
 
 // ANCHOR: mul-chip-trait-impl
-impl<F: FieldFr> Chip<F> for MulChip<F> {
+impl<F: FieldFront> Chip<F> for MulChip<F> {
     type Config = MulConfig;
     type Loaded = ();
 
@@ -247,7 +247,7 @@ impl<F: FieldFr> Chip<F> for MulChip<F> {
 // ANCHOR END: mul-chip-trait-impl
 
 // ANCHOR: mul-chip-impl
-impl<F: FieldFr> MulChip<F> {
+impl<F: FieldFront> MulChip<F> {
     fn construct(config: <Self as Chip<F>>::Config, _loaded: <Self as Chip<F>>::Loaded) -> Self {
         Self {
             config,
@@ -297,7 +297,7 @@ impl<F: FieldFr> MulChip<F> {
 // ANCHOR_END: mul-chip-impl
 
 // ANCHOR: mul-instructions-impl
-impl<F: FieldFr> MulInstructions<F> for FieldChip<F> {
+impl<F: FieldFront> MulInstructions<F> for FieldChip<F> {
     type Num = Number<F>;
     fn mul(
         &self,
@@ -311,7 +311,7 @@ impl<F: FieldFr> MulInstructions<F> for FieldChip<F> {
     }
 }
 
-impl<F: FieldFr> MulInstructions<F> for MulChip<F> {
+impl<F: FieldFront> MulInstructions<F> for MulChip<F> {
     type Num = Number<F>;
 
     fn mul(
@@ -353,7 +353,7 @@ impl<F: FieldFr> MulInstructions<F> for MulChip<F> {
 // ANCHOR END: mul-instructions-impl
 
 // ANCHOR: field-chip-trait-impl
-impl<F: FieldFr> Chip<F> for FieldChip<F> {
+impl<F: FieldFront> Chip<F> for FieldChip<F> {
     type Config = FieldConfig;
     type Loaded = ();
 
@@ -368,7 +368,7 @@ impl<F: FieldFr> Chip<F> for FieldChip<F> {
 // ANCHOR_END: field-chip-trait-impl
 
 // ANCHOR: field-chip-impl
-impl<F: FieldFr> FieldChip<F> {
+impl<F: FieldFront> FieldChip<F> {
     fn construct(config: <Self as Chip<F>>::Config, _loaded: <Self as Chip<F>>::Loaded) -> Self {
         Self {
             config,
@@ -397,7 +397,7 @@ impl<F: FieldFr> FieldChip<F> {
 // ANCHOR_END: field-chip-impl
 
 // ANCHOR: field-instructions-impl
-impl<F: FieldFr> FieldInstructions<F> for FieldChip<F> {
+impl<F: FieldFront> FieldInstructions<F> for FieldChip<F> {
     type Num = Number<F>;
 
     fn load_private(
@@ -449,13 +449,13 @@ impl<F: FieldFr> FieldInstructions<F> for FieldChip<F> {
 /// they won't have any value during key generation. During proving, if any of these
 /// were `Value::unknown()` we would get an error.
 #[derive(Default)]
-struct MyCircuit<F: FieldFr> {
+struct MyCircuit<F: FieldFront> {
     a: Value<F>,
     b: Value<F>,
     c: Value<F>,
 }
 
-impl<F: FieldFr> Circuit<F> for MyCircuit<F> {
+impl<F: FieldFront> Circuit<F> for MyCircuit<F> {
     // Since we are using a single chip for everything, we can just reuse its config.
     type Config = FieldConfig;
     type FloorPlanner = SimpleFloorPlanner;
diff --git a/halo2_proofs/examples/vector-mul.rs b/halo2_proofs/examples/vector-mul.rs
index ea80bd0d9..28ec830a6 100644
--- a/halo2_proofs/examples/vector-mul.rs
+++ b/halo2_proofs/examples/vector-mul.rs
@@ -1,6 +1,6 @@
 use std::marker::PhantomData;
 
-use halo2_frontend::plonk::FieldFr;
+use halo2_frontend::plonk::FieldFront;
 use halo2_proofs::{
     arithmetic::Field,
     circuit::{AssignedCell, Chip, Layouter, Region, SimpleFloorPlanner, Value},
@@ -9,7 +9,7 @@ use halo2_proofs::{
 };
 
 // ANCHOR: instructions
-trait NumericInstructions<F: FieldFr>: Chip<F> {
+trait NumericInstructions<F: FieldFront>: Chip<F> {
     /// Variable representing a number.
     type Num;
 
@@ -41,7 +41,7 @@ trait NumericInstructions<F: FieldFr>: Chip<F> {
 // ANCHOR: chip
 /// The chip that will implement our instructions! Chips store their own
 /// config, as well as type markers if necessary.
-struct FieldChip<F: FieldFr> {
+struct FieldChip<F: FieldFront> {
     config: FieldConfig,
     _marker: PhantomData<F>,
 }
@@ -67,7 +67,7 @@ struct FieldConfig {
     s_mul: Selector,
 }
 
-impl<F: FieldFr> FieldChip<F> {
+impl<F: FieldFront> FieldChip<F> {
     fn construct(config: <Self as Chip<F>>::Config) -> Self {
         Self {
             config,
@@ -125,7 +125,7 @@ impl<F: FieldFr> FieldChip<F> {
 // ANCHOR_END: chip-config
 
 // ANCHOR: chip-impl
-impl<F: FieldFr> Chip<F> for FieldChip<F> {
+impl<F: FieldFront> Chip<F> for FieldChip<F> {
     type Config = FieldConfig;
     type Loaded = ();
 
@@ -142,9 +142,9 @@ impl<F: FieldFr> Chip<F> for FieldChip<F> {
 // ANCHOR: instructions-impl
 /// A variable representing a number.
 #[derive(Clone, Debug)]
-struct Number<F: FieldFr>(AssignedCell<F, F>);
+struct Number<F: FieldFront>(AssignedCell<F, F>);
 
-impl<F: FieldFr> NumericInstructions<F> for FieldChip<F> {
+impl<F: FieldFront> NumericInstructions<F> for FieldChip<F> {
     type Num = Number<F>;
 
     fn load_private(
@@ -224,12 +224,12 @@ impl<F: FieldFr> NumericInstructions<F> for FieldChip<F> {
 /// they won't have any value during key generation. During proving, if any of these
 /// were `None` we would get an error.
 #[derive(Default)]
-struct MyCircuit<F: FieldFr> {
+struct MyCircuit<F: FieldFront> {
     a: Vec<Value<F>>,
     b: Vec<Value<F>>,
 }
 
-impl<F: FieldFr> Circuit<F> for MyCircuit<F> {
+impl<F: FieldFront> Circuit<F> for MyCircuit<F> {
     // Since we are using a single chip for everything, we can just reuse its config.
     type Config = FieldConfig;
     type FloorPlanner = SimpleFloorPlanner;
diff --git a/halo2_proofs/src/plonk.rs b/halo2_proofs/src/plonk.rs
index 0c13e1085..b3d3232f9 100644
--- a/halo2_proofs/src/plonk.rs
+++ b/halo2_proofs/src/plonk.rs
@@ -12,7 +12,7 @@ mod verifier {
     pub use halo2_backend::plonk::verifier::verify_proof;
 }
 
-use halo2_frontend::{circuit::compile_circuit, plonk::FieldFr};
+use halo2_frontend::{circuit::compile_circuit, plonk::FieldFront};
 pub use keygen::{keygen_pk, keygen_pk_custom, keygen_vk, keygen_vk_custom};
 
 pub use prover::{create_proof, create_proof_with_engine};
@@ -50,7 +50,7 @@ pub fn vk_read<C: SerdeCurveAffine, R: io::Read, F, ConcreteCircuit: Circuit<F>>
 ) -> io::Result<VerifyingKey<C>>
 where
     C::Scalar: SerdePrimeField + FromUniformBytes<64>,
-    F: FieldFr<Field = C::Scalar>,
+    F: FieldFront<Field = C::Scalar>,
 {
     let (_, _, cs) = compile_circuit(k, circuit, compress_selectors)
         .map_err(|e| io::Error::new(io::ErrorKind::Other, e.to_string()))?;
@@ -79,9 +79,8 @@ pub fn pk_read<C: SerdeCurveAffine, R: io::Read, F, ConcreteCircuit: Circuit<F>>
 ) -> io::Result<ProvingKey<C>>
 where
     C::Scalar: SerdePrimeField + FromUniformBytes<64>,
-    F: FieldFr<Field = C::Scalar>,
-
-    {
+    F: FieldFront<Field = C::Scalar>,
+{
     let (_, _, cs) = compile_circuit(k, circuit, compress_selectors)
         .map_err(|e| io::Error::new(io::ErrorKind::Other, e.to_string()))?;
     let cs_mid: ConstraintSystemMid<_> = cs.into();
diff --git a/halo2_proofs/src/plonk/keygen.rs b/halo2_proofs/src/plonk/keygen.rs
index 079c8fd5a..91a348d6c 100644
--- a/halo2_proofs/src/plonk/keygen.rs
+++ b/halo2_proofs/src/plonk/keygen.rs
@@ -4,8 +4,8 @@ use halo2_backend::plonk::{
     ProvingKey, VerifyingKey,
 };
 use halo2_backend::{arithmetic::CurveAffine, poly::commitment::Params};
-use halo2_frontend::{circuit::compile_circuit, plonk::FieldFr};
 use halo2_frontend::plonk::Circuit;
+use halo2_frontend::{circuit::compile_circuit, plonk::FieldFront};
 use halo2_middleware::ff::FromUniformBytes;
 
 /// Generate a `VerifyingKey` from an instance of `Circuit`.
@@ -21,7 +21,7 @@ pub fn keygen_vk<C, P, ConcreteCircuit, F>(
 where
     C: CurveAffine,
     P: Params<C>,
-    F: FieldFr<Field = C::Scalar>,
+    F: FieldFront<Field = C::Scalar>,
     ConcreteCircuit: Circuit<F>,
     C::Scalar: FromUniformBytes<64>,
 {
@@ -44,7 +44,7 @@ pub fn keygen_vk_custom<C, P, ConcreteCircuit, F>(
 where
     C: CurveAffine,
     P: Params<C>,
-    F: FieldFr<Field = C::Scalar>,
+    F: FieldFront<Field = C::Scalar>,
     ConcreteCircuit: Circuit<F>,
     C::Scalar: FromUniformBytes<64>,
 {
@@ -66,7 +66,7 @@ pub fn keygen_pk<C, P, ConcreteCircuit, F>(
 where
     C: CurveAffine,
     P: Params<C>,
-    F: FieldFr<Field = C::Scalar>,    
+    F: FieldFront<Field = C::Scalar>,
     ConcreteCircuit: Circuit<F>,
 {
     keygen_pk_custom(params, vk, circuit, true)
@@ -89,7 +89,7 @@ pub fn keygen_pk_custom<C, P, ConcreteCircuit, F>(
 where
     C: CurveAffine,
     P: Params<C>,
-    F: FieldFr<Field = C::Scalar>,
+    F: FieldFront<Field = C::Scalar>,
     ConcreteCircuit: Circuit<F>,
 {
     let (compiled_circuit, _, _) = compile_circuit(params.k(), circuit, compress_selectors)?;
diff --git a/halo2_proofs/src/plonk/prover.rs b/halo2_proofs/src/plonk/prover.rs
index 7641ba9ef..e4fefb1a7 100644
--- a/halo2_proofs/src/plonk/prover.rs
+++ b/halo2_proofs/src/plonk/prover.rs
@@ -3,7 +3,7 @@ use crate::poly::commitment::{self, CommitmentScheme, Params};
 use crate::transcript::{EncodedChallenge, TranscriptWrite};
 use halo2_backend::plonk::{prover::Prover, ProvingKey};
 use halo2_frontend::circuit::WitnessCalculator;
-use halo2_frontend::plonk::{Circuit, ConstraintSystem, FieldFr};
+use halo2_frontend::plonk::{Circuit, ConstraintSystem, FieldFront};
 use halo2_middleware::ff::{FromUniformBytes, WithSmallOrderMulGroup};
 use halo2_middleware::zal::{
     impls::{PlonkEngine, PlonkEngineConfig},
@@ -25,7 +25,7 @@ pub fn create_proof_with_engine<
     T: TranscriptWrite<Scheme::Curve, E>,
     ConcreteCircuit: Circuit<F>,
     M: MsmAccel<Scheme::Curve>,
-    F: FieldFr<Field = Scheme::Scalar>,
+    F: FieldFront<Field = Scheme::Scalar>,
 >(
     engine: PlonkEngine<Scheme::Curve, M>,
     params: &'params Scheme::ParamsProver,
@@ -81,12 +81,20 @@ where
             .iter()
             .map(|v| {
                 v.into_iter()
-                    .map(|v| v.as_ref().map(|v| v.into_iter().map(|f| f.into_field()).collect()))
+                    .map(|v| {
+                        v.as_ref()
+                            .map(|v| v.into_iter().map(|f| f.into_field()).collect())
+                    })
                     .collect()
             })
             .collect();
 
-        challenges = prover.commit_phase(*phase, witnesses).unwrap().into_iter().map(|(k, v)| (k, F::into_field_fr(v))).collect();
+        challenges = prover
+            .commit_phase(*phase, witnesses)
+            .unwrap()
+            .into_iter()
+            .map(|(k, v)| (k, F::into_field_fr(v)))
+            .collect();
     }
     Ok(prover.create_proof()?)
 }
@@ -103,7 +111,7 @@ pub fn create_proof<
     R: RngCore,
     T: TranscriptWrite<Scheme::Curve, E>,
     ConcreteCircuit: Circuit<F>,
-    F: FieldFr<Field = Scheme::Scalar>,
+    F: FieldFront<Field = Scheme::Scalar>,
 >(
     params: &'params Scheme::ParamsProver,
     pk: &ProvingKey<Scheme::Curve>,
@@ -124,9 +132,9 @@ where
 
 #[cfg(test)]
 mod test {
-    use crate::plonk::Error;
-    use halo2_frontend::plonk::{Circuit, FieldFr};
     use super::*;
+    use crate::plonk::Error;
+    use halo2_frontend::plonk::{Circuit, FieldFront};
 
     #[test]
     fn test_create_proof() {
@@ -139,14 +147,13 @@ mod test {
             },
             transcript::{Blake2bWrite, Challenge255, TranscriptWriterBuffer},
         };
-        use halo2_middleware::ff::Field;
         use halo2curves::bn256::Bn256;
         use rand_core::OsRng;
 
         #[derive(Clone, Copy)]
         struct MyCircuit;
 
-        impl<F: FieldFr> Circuit<F> for MyCircuit {
+        impl<F: FieldFront> Circuit<F> for MyCircuit {
             type Config = ();
             type FloorPlanner = SimpleFloorPlanner;
             #[cfg(feature = "circuit-params")]
@@ -168,12 +175,22 @@ mod test {
         }
 
         let params: ParamsKZG<Bn256> = ParamsKZG::setup(3, OsRng);
-        let vk = keygen_vk::<_, _, _,halo2curves::bn256::Fr>(&params, &MyCircuit).expect("keygen_vk should not fail");
-        let pk = keygen_pk::<_,_,_,halo2curves::bn256::Fr>(&params, vk, &MyCircuit).expect("keygen_pk should not fail");
+        let vk = keygen_vk::<_, _, _, halo2curves::bn256::Fr>(&params, &MyCircuit)
+            .expect("keygen_vk should not fail");
+        let pk = keygen_pk::<_, _, _, halo2curves::bn256::Fr>(&params, vk, &MyCircuit)
+            .expect("keygen_pk should not fail");
         let mut transcript = Blake2bWrite::<_, _, Challenge255<_>>::init(vec![]);
 
         // Create proof with wrong number of instances
-        let proof = create_proof::<KZGCommitmentScheme<_>, ProverSHPLONK<_>,_, _, _, _, halo2curves::bn256::Fr>(
+        let proof = create_proof::<
+            KZGCommitmentScheme<_>,
+            ProverSHPLONK<_>,
+            _,
+            _,
+            _,
+            _,
+            halo2curves::bn256::Fr,
+        >(
             &params,
             &pk,
             &[MyCircuit, MyCircuit],
@@ -210,15 +227,14 @@ mod test {
             },
             transcript::{Blake2bWrite, Challenge255, TranscriptWriterBuffer},
         };
-        use halo2_frontend::plonk::FieldFr;
-        use halo2_middleware::ff::Field;
+        use halo2_frontend::plonk::FieldFront;
         use halo2curves::bn256::Bn256;
         use rand_core::OsRng;
 
         #[derive(Clone, Copy)]
         struct MyCircuit;
 
-        impl<F: FieldFr> Circuit<F> for MyCircuit {
+        impl<F: FieldFront> Circuit<F> for MyCircuit {
             type Config = ();
             type FloorPlanner = SimpleFloorPlanner;
             #[cfg(feature = "circuit-params")]
@@ -241,14 +257,32 @@ mod test {
 
         let params: ParamsKZG<Bn256> = ParamsKZG::setup(3, OsRng);
         let compress_selectors = true;
-        let vk = keygen_vk_custom::<_,_,_,halo2curves::bn256::Fr>(&params, &MyCircuit, compress_selectors)
-            .expect("keygen_vk_custom should not fail");
-        let pk = keygen_pk_custom::<_,_,_,halo2curves::bn256::Fr>(&params, vk, &MyCircuit, compress_selectors)
-            .expect("keygen_pk_custom should not fail");
+        let vk = keygen_vk_custom::<_, _, _, halo2curves::bn256::Fr>(
+            &params,
+            &MyCircuit,
+            compress_selectors,
+        )
+        .expect("keygen_vk_custom should not fail");
+        let pk = keygen_pk_custom::<_, _, _, halo2curves::bn256::Fr>(
+            &params,
+            vk,
+            &MyCircuit,
+            compress_selectors,
+        )
+        .expect("keygen_pk_custom should not fail");
         let mut transcript = Blake2bWrite::<_, _, Challenge255<_>>::init(vec![]);
         let engine = PlonkEngineConfig::build_default();
 
-        create_proof_with_engine::<KZGCommitmentScheme<_>, ProverSHPLONK<_>,_,_,  _, _, _, halo2curves::bn256::Fr>(
+        create_proof_with_engine::<
+            KZGCommitmentScheme<_>,
+            ProverSHPLONK<_>,
+            _,
+            _,
+            _,
+            _,
+            _,
+            halo2curves::bn256::Fr,
+        >(
             engine,
             &params,
             &pk,
@@ -259,4 +293,4 @@ mod test {
         )
         .expect("proof generation should not fail");
     }
-}
\ No newline at end of file
+}
diff --git a/halo2_proofs/tests/compress_selectors.rs b/halo2_proofs/tests/compress_selectors.rs
index 32abfe419..b14ae5324 100644
--- a/halo2_proofs/tests/compress_selectors.rs
+++ b/halo2_proofs/tests/compress_selectors.rs
@@ -5,7 +5,7 @@ use std::marker::PhantomData;
 use ff::PrimeField;
 use halo2_debug::display::expr_disp_names;
 use halo2_frontend::circuit::compile_circuit;
-use halo2_frontend::plonk::{Error, FieldFr};
+use halo2_frontend::plonk::{Error, FieldFront};
 use halo2_proofs::circuit::{Cell, Layouter, SimpleFloorPlanner, Value};
 use halo2_proofs::poly::Rotation;
 
@@ -24,8 +24,6 @@ use halo2_proofs::poly::kzg::strategy::SingleStrategy;
 use halo2curves::bn256::{Bn256, Fr, G1Affine};
 use rand_core::block::BlockRng;
 use rand_core::block::BlockRngCore;
-use halo2_frontend::expression_arena;
-use halo2_frontend::plonk;
 
 // One number generator, that can be used as a deterministic Rng, outputing fixed values.
 pub struct OneNg {}
@@ -56,12 +54,12 @@ struct MyCircuitConfig {
 }
 
 #[derive(Debug)]
-struct MyCircuitChip<F: FieldFr> {
+struct MyCircuitChip<F: FieldFront> {
     config: MyCircuitConfig,
     marker: PhantomData<F>,
 }
 
-trait MyCircuitComposer<F: FieldFr> {
+trait MyCircuitComposer<F: FieldFront> {
     fn raw_multiply<FM>(
         &self,
         layouter: &mut impl Layouter<F>,
@@ -93,7 +91,7 @@ trait MyCircuitComposer<F: FieldFr> {
         FM: FnMut() -> Value<(Assigned<F>, Assigned<F>)>;
 }
 
-impl<F: FieldFr> MyCircuitChip<F> {
+impl<F: FieldFront> MyCircuitChip<F> {
     fn construct(config: MyCircuitConfig) -> Self {
         Self {
             config,
@@ -164,7 +162,7 @@ impl<F: FieldFr> MyCircuitChip<F> {
     }
 }
 
-impl<F: FieldFr> MyCircuitComposer<F> for MyCircuitChip<F> {
+impl<F: FieldFront> MyCircuitComposer<F> for MyCircuitChip<F> {
     fn raw_multiply<FM>(
         &self,
         layouter: &mut impl Layouter<F>,
@@ -293,13 +291,13 @@ impl<F: FieldFr> MyCircuitComposer<F> for MyCircuitChip<F> {
 }
 
 #[derive(Debug, Clone, Default)]
-struct MyCircuit<F: FieldFr> {
+struct MyCircuit<F: FieldFront> {
     x: Value<F>,
     y: Value<F>,
     constant: F,
 }
 
-impl<F: FieldFr> Circuit<F> for MyCircuit<F> {
+impl<F: FieldFront> Circuit<F> for MyCircuit<F> {
     type Config = MyCircuitConfig;
     type FloorPlanner = SimpleFloorPlanner;
     #[cfg(feature = "circuit-params")]
@@ -376,7 +374,16 @@ fn test_mycircuit(
     let instances = vec![vec![vec![Fr::one(), Fr::from_u128(3)]]];
 
     let mut transcript = Blake2bWrite::<_, G1Affine, Challenge255<_>>::init(vec![]);
-    create_proof_with_engine::<KZGCommitmentScheme<Bn256>, ProverSHPLONK<'_, Bn256>, _, _, _, _, _, halo2curves::bn256::Fr>(
+    create_proof_with_engine::<
+        KZGCommitmentScheme<Bn256>,
+        ProverSHPLONK<'_, Bn256>,
+        _,
+        _,
+        _,
+        _,
+        _,
+        halo2curves::bn256::Fr,
+    >(
         engine,
         &params,
         &pk,
diff --git a/halo2_proofs/tests/plonk_api.rsx b/halo2_proofs/tests/plonk_api.rsx
index c5606c945..5ca0fe358 100644
--- a/halo2_proofs/tests/plonk_api.rsx
+++ b/halo2_proofs/tests/plonk_api.rsx
@@ -87,12 +87,12 @@ fn plonk_api() {
     }
 
     #[derive(Clone)]
-    struct MyCircuit<F: FieldFr> {
+    struct MyCircuit<F: FieldFront> {
         a: Value<F>,
         lookup_table: Vec<F>,
     }
 
-    struct StandardPlonk<F: FieldFr> {
+    struct StandardPlonk<F: FieldFront> {
         config: PlonkConfig,
         _marker: PhantomData<F>,
     }
@@ -280,7 +280,7 @@ fn plonk_api() {
         }
     }
 
-    impl<F: FieldFr> Circuit<F> for MyCircuit<F> {
+    impl<F: FieldFront> Circuit<F> for MyCircuit<F> {
         type Config = PlonkConfig;
         type FloorPlanner = SimpleFloorPlanner;
         #[cfg(feature = "circuit-params")]
diff --git a/halo2_proofs/tests/shuffle.rsx b/halo2_proofs/tests/shuffle.rsx
index 23867d0db..7c35061d3 100644
--- a/halo2_proofs/tests/shuffle.rsx
+++ b/halo2_proofs/tests/shuffle.rsx
@@ -1,5 +1,5 @@
 use ff::{BatchInvert, FromUniformBytes};
-use halo2_frontend::plonk::FieldFr;
+use halo2_frontend::plonk::FieldFront;
 use halo2_proofs::{
     arithmetic::{CurveAffine, Field},
     circuit::{floor_planner::V1, Layouter, Value},
@@ -22,11 +22,11 @@ use halo2_proofs::{
 use rand_core::{OsRng, RngCore};
 use std::iter;
 
-fn rand_2d_array<F: FieldFr, R: RngCore, const W: usize, const H: usize>(rng: &mut R) -> [[F; H]; W] {
+fn rand_2d_array<F: FieldFront, R: RngCore, const W: usize, const H: usize>(rng: &mut R) -> [[F; H]; W] {
     [(); W].map(|_| [(); H].map(|_| F::random(&mut *rng)))
 }
 
-fn shuffled<F: FieldFr, R: RngCore, const W: usize, const H: usize>(
+fn shuffled<F: FieldFront, R: RngCore, const W: usize, const H: usize>(
     original: [[F; H]; W],
     rng: &mut R,
 ) -> [[F; H]; W] {
@@ -55,7 +55,7 @@ struct MyConfig<const W: usize> {
 }
 
 impl<const W: usize> MyConfig<W> {
-    fn configure<F: FieldFr>(meta: &mut ConstraintSystem<F>) -> Self {
+    fn configure<F: FieldFront>(meta: &mut ConstraintSystem<F>) -> Self {
         let [q_shuffle, q_first, q_last] = [(); 3].map(|_| meta.selector());
         // First phase
         let original = [(); W].map(|_| meta.advice_column_in(FirstPhase));
@@ -111,12 +111,12 @@ impl<const W: usize> MyConfig<W> {
 }
 
 #[derive(Clone, Default)]
-struct MyCircuit<F: FieldFr, const W: usize, const H: usize> {
+struct MyCircuit<F: FieldFront, const W: usize, const H: usize> {
     original: Value<[[F; H]; W]>,
     shuffled: Value<[[F; H]; W]>,
 }
 
-impl<F: FieldFr, const W: usize, const H: usize> MyCircuit<F, W, H> {
+impl<F: FieldFront, const W: usize, const H: usize> MyCircuit<F, W, H> {
     fn rand<R: RngCore>(rng: &mut R) -> Self {
         let original = rand_2d_array::<F, _, W, H>(rng);
         let shuffled = shuffled(original, rng);
@@ -128,7 +128,7 @@ impl<F: FieldFr, const W: usize, const H: usize> MyCircuit<F, W, H> {
     }
 }
 
-impl<F: FieldFr, const W: usize, const H: usize> Circuit<F> for MyCircuit<F, W, H> {
+impl<F: FieldFront, const W: usize, const H: usize> Circuit<F> for MyCircuit<F, W, H> {
     type Config = MyConfig<W>;
     type FloorPlanner = V1;
     #[cfg(feature = "circuit-params")]
diff --git a/halo2_proofs/tests/shuffle_api.rsx b/halo2_proofs/tests/shuffle_api.rsx
index c02468483..e3368fa5b 100644
--- a/halo2_proofs/tests/shuffle_api.rsx
+++ b/halo2_proofs/tests/shuffle_api.rsx
@@ -25,7 +25,7 @@ use halo2_proofs::{
 use halo2curves::{pasta::EqAffine, CurveAffine};
 use rand_core::OsRng;
 
-struct ShuffleChip<F: FieldFr> {
+struct ShuffleChip<F: FieldFront> {
     config: ShuffleConfig,
     _marker: PhantomData<F>,
 }
@@ -40,7 +40,7 @@ struct ShuffleConfig {
     s_shuffle: Selector,
 }
 
-impl<F: FieldFr> ShuffleChip<F> {
+impl<F: FieldFront> ShuffleChip<F> {
     fn construct(config: ShuffleConfig) -> Self {
         Self {
             config,
@@ -81,14 +81,14 @@ impl<F: FieldFr> ShuffleChip<F> {
 }
 
 #[derive(Default)]
-struct MyCircuit<F: FieldFr> {
+struct MyCircuit<F: FieldFront> {
     input_0: Vec<Value<F>>,
     input_1: Vec<F>,
     shuffle_0: Vec<Value<F>>,
     shuffle_1: Vec<Value<F>>,
 }
 
-impl<F: FieldFr> Circuit<F> for MyCircuit<F> {
+impl<F: FieldFront> Circuit<F> for MyCircuit<F> {
     // Since we are using a single chip for everything, we can just reuse its config.
     type Config = ShuffleConfig;
     type FloorPlanner = SimpleFloorPlanner;
diff --git a/halo2_proofs/tests/vector-ops-unblinded.rsx b/halo2_proofs/tests/vector-ops-unblinded.rsx
index 9f1187de4..b33689b07 100644
--- a/halo2_proofs/tests/vector-ops-unblinded.rsx
+++ b/halo2_proofs/tests/vector-ops-unblinded.rsx
@@ -4,7 +4,7 @@
 use std::marker::PhantomData;
 
 use ff::FromUniformBytes;
-use halo2_frontend::plonk::FieldFr;
+use halo2_frontend::plonk::FieldFront;
 use halo2_proofs::{
     arithmetic::{CurveAffine, Field},
     circuit::{AssignedCell, Chip, Layouter, Region, SimpleFloorPlanner, Value},
@@ -25,7 +25,7 @@ use halo2_proofs::{
 use rand_core::OsRng;
 
 // ANCHOR: instructions
-trait NumericInstructions<F: FieldFr>: Chip<F> {
+trait NumericInstructions<F: FieldFront>: Chip<F> {
     /// Variable representing a number.
     type Num;
 
@@ -65,7 +65,7 @@ trait NumericInstructions<F: FieldFr>: Chip<F> {
 // ANCHOR: chip
 /// The chip that will implement our instructions! Chips store their own
 /// config, as well as type markers if necessary.
-struct MultChip<F: FieldFr> {
+struct MultChip<F: FieldFront> {
     config: FieldConfig,
     _marker: PhantomData<F>,
 }
@@ -73,7 +73,7 @@ struct MultChip<F: FieldFr> {
 // ANCHOR: chip
 /// The chip that will implement our instructions! Chips store their own
 /// config, as well as type markers if necessary.
-struct AddChip<F: FieldFr> {
+struct AddChip<F: FieldFront> {
     config: FieldConfig,
     _marker: PhantomData<F>,
 }
@@ -89,7 +89,7 @@ struct FieldConfig {
     s: Selector,
 }
 
-impl<F: FieldFr> MultChip<F> {
+impl<F: FieldFront> MultChip<F> {
     fn construct(config: <Self as Chip<F>>::Config) -> Self {
         Self {
             config,
@@ -126,7 +126,7 @@ impl<F: FieldFr> MultChip<F> {
     }
 }
 
-impl<F: FieldFr> AddChip<F> {
+impl<F: FieldFront> AddChip<F> {
     fn construct(config: <Self as Chip<F>>::Config) -> Self {
         Self {
             config,
@@ -165,7 +165,7 @@ impl<F: FieldFr> AddChip<F> {
 // ANCHOR_END: chip-config
 
 // ANCHOR: chip-impl
-impl<F: FieldFr> Chip<F> for MultChip<F> {
+impl<F: FieldFront> Chip<F> for MultChip<F> {
     type Config = FieldConfig;
     type Loaded = ();
 
@@ -180,7 +180,7 @@ impl<F: FieldFr> Chip<F> for MultChip<F> {
 // ANCHOR_END: chip-impl
 
 // ANCHOR: chip-impl
-impl<F: FieldFr> Chip<F> for AddChip<F> {
+impl<F: FieldFront> Chip<F> for AddChip<F> {
     type Config = FieldConfig;
     type Loaded = ();
 
@@ -196,9 +196,9 @@ impl<F: FieldFr> Chip<F> for AddChip<F> {
 // ANCHOR: instructions-impl
 /// A variable representing a number.
 #[derive(Clone, Debug)]
-struct Number<F: FieldFr>(AssignedCell<F, F>);
+struct Number<F: FieldFront>(AssignedCell<F, F>);
 
-impl<F: FieldFr> NumericInstructions<F> for MultChip<F> {
+impl<F: FieldFront> NumericInstructions<F> for MultChip<F> {
     type Num = Number<F>;
 
     fn load_unblinded(
@@ -280,7 +280,7 @@ impl<F: FieldFr> NumericInstructions<F> for MultChip<F> {
 }
 // ANCHOR_END: instructions-impl
 
-impl<F: FieldFr> NumericInstructions<F> for AddChip<F> {
+impl<F: FieldFront> NumericInstructions<F> for AddChip<F> {
     type Num = Number<F>;
 
     fn load_unblinded(
@@ -362,12 +362,12 @@ impl<F: FieldFr> NumericInstructions<F> for AddChip<F> {
 }
 
 #[derive(Default)]
-struct MulCircuit<F: FieldFr> {
+struct MulCircuit<F: FieldFront> {
     a: Vec<Value<F>>,
     b: Vec<Value<F>>,
 }
 
-impl<F: FieldFr> Circuit<F> for MulCircuit<F> {
+impl<F: FieldFront> Circuit<F> for MulCircuit<F> {
     // Since we are using a single chip for everything, we can just reuse its config.
     type Config = FieldConfig;
     type FloorPlanner = SimpleFloorPlanner;
@@ -415,12 +415,12 @@ impl<F: FieldFr> Circuit<F> for MulCircuit<F> {
 // ANCHOR_END: circuit
 
 #[derive(Default)]
-struct AddCircuit<F: FieldFr> {
+struct AddCircuit<F: FieldFront> {
     a: Vec<Value<F>>,
     b: Vec<Value<F>>,
 }
 
-impl<F: FieldFr> Circuit<F> for AddCircuit<F> {
+impl<F: FieldFront> Circuit<F> for AddCircuit<F> {
     // Since we are using a single chip for everything, we can just reuse its config.
     type Config = FieldConfig;
     type FloorPlanner = SimpleFloorPlanner;
@@ -467,7 +467,7 @@ impl<F: FieldFr> Circuit<F> for AddCircuit<F> {
 }
 // ANCHOR_END: circuit
 
-fn test_prover<C: CurveAffine, FE: FieldFr<Field=C::Scalar>>(
+fn test_prover<C: CurveAffine, FE: FieldFront<Field=C::Scalar>>(
     k: u32,
     circuit: impl Circuit<FE>,
     expected: bool,