diff --git a/.circleci/config.yml b/.circleci/config.yml
index 65f39859594..82730b366e8 100644
--- a/.circleci/config.yml
+++ b/.circleci/config.yml
@@ -104,6 +104,17 @@ jobs:
           name: "Build"
           command: cond_spot_run_build barretenberg-x86_64-linux-clang 64
 
+  barretenberg-x86_64-linux-clang-fuzzing:
+    docker:
+      - image: aztecprotocol/alpine-build-image
+    resource_class: small
+    steps:
+      - *checkout
+      - *setup_env
+      - run:
+          name: "Build"
+          command: cond_spot_run_build barretenberg-x86_64-linux-clang-fuzzing 64
+
   barretenberg-x86_64-linux-clang-assert:
     docker:
       - image: aztecprotocol/alpine-build-image
@@ -1006,6 +1017,7 @@ workflows:
       - barretenberg-x86_64-linux-gcc: *defaults
       - barretenberg-x86_64-linux-clang: *defaults
       - barretenberg-x86_64-linux-clang-assert: *defaults
+      - barretenberg-x86_64-linux-clang-fuzzing: *defaults
       - barretenberg-wasm-linux-clang: *defaults
       - barretenberg-proof-system-tests: *bb_test
       - barretenberg-honk-tests: *bb_test
diff --git a/build_manifest.json b/build_manifest.json
index 96a2a1a352d..7e5016900dc 100644
--- a/build_manifest.json
+++ b/build_manifest.json
@@ -11,6 +11,12 @@
     "rebuildPatterns": ["^circuits/cpp/barretenberg/cpp/"],
     "dependencies": []
   },
+  "barretenberg-x86_64-linux-clang-fuzzing": {
+    "buildDir": "circuits/cpp/barretenberg/cpp",
+    "dockerfile": "dockerfiles/Dockerfile.x86_64-linux-clang-fuzzing",
+    "rebuildPatterns": ["^circuits/cpp/barretenberg/cpp/"],
+    "dependencies": []
+  },
   "barretenberg-x86_64-linux-gcc": {
     "buildDir": "circuits/cpp/barretenberg/cpp",
     "dockerfile": "dockerfiles/Dockerfile.x86_64-linux-gcc",
diff --git a/circuits/cpp/barretenberg/.circleci/config.yml b/circuits/cpp/barretenberg/.circleci/config.yml
index 0dc48e614c0..0436b49b804 100644
--- a/circuits/cpp/barretenberg/.circleci/config.yml
+++ b/circuits/cpp/barretenberg/.circleci/config.yml
@@ -145,6 +145,17 @@ jobs:
   #           name: "Build"
   #           command: cond_spot_run_build barretenberg-x86_64-linux-clang-assert 64
 
+  x86_64-linux-clang-fuzzing:
+    docker:
+      - image: aztecprotocol/alpine-build-image
+    resource_class: small
+    steps:
+      - *checkout
+      - *setup_env
+      - run:
+          name: "Build"
+          command: cond_spot_run_build barretenberg-x86_64-linux-clang-fuzzing 64
+
   #   stdlib-tests:
   #     docker:
   #       - image: aztecprotocol/alpine-build-image
@@ -391,6 +402,7 @@ workflows:
       # - x86_64-linux-gcc: *defaults
       - x86_64-linux-clang: *defaults
       # - x86_64-linux-clang-assert: *defaults
+      - x86_64-linux-clang-fuzzing: *defaults
       # - wasm-linux-clang: *defaults
       # - proof-system-tests: *bb_test
       # - honk-tests: *bb_test
diff --git a/circuits/cpp/barretenberg/build_manifest.json b/circuits/cpp/barretenberg/build_manifest.json
index f755fc51d6e..564626daca9 100644
--- a/circuits/cpp/barretenberg/build_manifest.json
+++ b/circuits/cpp/barretenberg/build_manifest.json
@@ -11,6 +11,12 @@
     "rebuildPatterns": ["^cpp/"],
     "dependencies": []
   },
+  "barretenberg-x86_64-linux-clang-fuzzing": {
+    "buildDir": "cpp",
+    "dockerfile": "dockerfiles/Dockerfile.x86_64-linux-clang-fuzzing",
+    "rebuildPatterns": ["^cpp/"],
+    "dependencies": []
+  },
   "barretenberg-x86_64-linux-gcc": {
     "buildDir": "cpp",
     "dockerfile": "dockerfiles/Dockerfile.x86_64-linux-gcc",
diff --git a/circuits/cpp/barretenberg/cpp/dockerfiles/Dockerfile.x86_64-linux-clang-fuzzing b/circuits/cpp/barretenberg/cpp/dockerfiles/Dockerfile.x86_64-linux-clang-fuzzing
new file mode 100644
index 00000000000..f9dd7717b23
--- /dev/null
+++ b/circuits/cpp/barretenberg/cpp/dockerfiles/Dockerfile.x86_64-linux-clang-fuzzing
@@ -0,0 +1,23 @@
+FROM alpine:3.18 AS builder
+RUN apk update && \
+    apk upgrade && \
+    apk add --no-cache \
+        build-base \
+        clang16 \
+        compiler-rt \
+        openmp-dev \
+        cmake \
+        ninja \
+        git \
+        curl \
+        perl
+
+WORKDIR /usr/src/barretenberg/cpp
+
+COPY . .
+# Build the entire project, as we want to check everything builds under clang
+RUN cmake --preset fuzzing && cmake --build --preset fuzzing
+
+FROM alpine:3.18
+RUN apk update && apk add openmp
+COPY --from=builder /usr/src/barretenberg/cpp/srs_db /usr/src/barretenberg/cpp/srs_db
diff --git a/circuits/cpp/barretenberg/cpp/src/barretenberg/bb/CMakeLists.txt b/circuits/cpp/barretenberg/cpp/src/barretenberg/bb/CMakeLists.txt
index 42ccf9bf15d..910b29b7a14 100644
--- a/circuits/cpp/barretenberg/cpp/src/barretenberg/bb/CMakeLists.txt
+++ b/circuits/cpp/barretenberg/cpp/src/barretenberg/bb/CMakeLists.txt
@@ -1,11 +1,13 @@
-add_executable(
-    bb
-    main.cpp
-)
+if (NOT(FUZZING))
+    add_executable(
+        bb
+        main.cpp
+    )
 
-target_link_libraries(
-    bb
-    PRIVATE
-    barretenberg
-    env
-)
\ No newline at end of file
+    target_link_libraries(
+        bb
+        PRIVATE
+        barretenberg
+        env
+    )
+endif()
\ No newline at end of file
diff --git a/circuits/cpp/barretenberg/cpp/src/barretenberg/common/fuzzer.hpp b/circuits/cpp/barretenberg/cpp/src/barretenberg/common/fuzzer.hpp
index 079ae269f7f..9910a83d609 100644
--- a/circuits/cpp/barretenberg/cpp/src/barretenberg/common/fuzzer.hpp
+++ b/circuits/cpp/barretenberg/cpp/src/barretenberg/common/fuzzer.hpp
@@ -1,6 +1,6 @@
 #pragma once
-#include "barretenberg/plonk/composer/standard_composer.hpp"
-#include "barretenberg/plonk/composer/turbo_composer.hpp"
+#include "barretenberg/proof_system/circuit_builder/standard_circuit_builder.hpp"
+#include "barretenberg/proof_system/circuit_builder/turbo_circuit_builder.hpp"
 #include <concepts>
 
 #define PARENS ()
@@ -84,83 +84,80 @@ class FastRandom {
  *
  * @tparam T
  */
-template <typename T> concept SimpleRng = requires(T a)
-{
-    {
-        a.next()
-    }
-    ->std::convertible_to<uint32_t>;
-};
+template <typename T>
+concept SimpleRng = requires(T a) {
+                        {
+                            a.next()
+                            } -> std::convertible_to<uint32_t>;
+                    };
 /**
  * @brief Concept for forcing ArgumentSizes to be size_t
  *
  * @tparam T
  */
-template <typename T> concept InstructionArgumentSizes = requires
-{
-    {
-        std::make_tuple(T::CONSTANT,
-                        T::WITNESS,
-                        T::CONSTANT_WITNESS,
-                        T::ADD,
-                        T::SUBTRACT,
-                        T::MULTIPLY,
-                        T::DIVIDE,
-                        T::ADD_TWO,
-                        T::MADD,
-                        T::MULT_MADD,
-                        T::MSUB_DIV,
-                        T::SQR,
-                        T::SQR_ADD,
-                        T::SUBTRACT_WITH_CONSTRAINT,
-                        T::DIVIDE_WITH_CONSTRAINTS,
-                        T::SLICE,
-                        T::ASSERT_ZERO,
-                        T::ASSERT_NOT_ZERO)
-    }
-    ->std::same_as<std::tuple<size_t>>;
-};
+template <typename T>
+concept InstructionArgumentSizes = requires {
+                                       {
+                                           std::make_tuple(T::CONSTANT,
+                                                           T::WITNESS,
+                                                           T::CONSTANT_WITNESS,
+                                                           T::ADD,
+                                                           T::SUBTRACT,
+                                                           T::MULTIPLY,
+                                                           T::DIVIDE,
+                                                           T::ADD_TWO,
+                                                           T::MADD,
+                                                           T::MULT_MADD,
+                                                           T::MSUB_DIV,
+                                                           T::SQR,
+                                                           T::SQR_ADD,
+                                                           T::SUBTRACT_WITH_CONSTRAINT,
+                                                           T::DIVIDE_WITH_CONSTRAINTS,
+                                                           T::SLICE,
+                                                           T::ASSERT_ZERO,
+                                                           T::ASSERT_NOT_ZERO)
+                                           } -> std::same_as<std::tuple<size_t>>;
+                                   };
 
 /**
  * @brief Concept for Havoc Configurations
  *
  * @tparam T
  */
-template <typename T> concept HavocConfigConstraint = requires
-{
-    {
-        std::make_tuple(T::GEN_MUTATION_COUNT_LOG, T::GEN_STRUCTURAL_MUTATION_PROBABILITY)
-    }
-    ->std::same_as<std::tuple<size_t>>;
-    T::GEN_MUTATION_COUNT_LOG <= 7;
-};
+template <typename T>
+concept HavocConfigConstraint =
+    requires {
+        {
+            std::make_tuple(T::GEN_MUTATION_COUNT_LOG, T::GEN_STRUCTURAL_MUTATION_PROBABILITY)
+            } -> std::same_as<std::tuple<size_t>>;
+        T::GEN_MUTATION_COUNT_LOG <= 7;
+    };
 /**
  * @brief Concept specifying the class used by the fuzzer
  *
  * @tparam T
  */
-template <typename T> concept ArithmeticFuzzHelperConstraint = requires
-{
-    typename T::ArgSizes;
-    typename T::Instruction;
-    typename T::ExecutionState;
-    typename T::ExecutionHandler;
-    InstructionArgumentSizes<typename T::ArgSizes>;
-    // HavocConfigConstraint<typename T::HavocConfig>;
-};
+template <typename T>
+concept ArithmeticFuzzHelperConstraint = requires {
+                                             typename T::ArgSizes;
+                                             typename T::Instruction;
+                                             typename T::ExecutionState;
+                                             typename T::ExecutionHandler;
+                                             InstructionArgumentSizes<typename T::ArgSizes>;
+                                             // HavocConfigConstraint<typename T::HavocConfig>;
+                                         };
 
 /**
  * @brief Fuzzer uses only composers with check_circuit function
  *
  * @tparam T
  */
-template <typename T> concept CheckableComposer = requires(T a)
-{
-    {
-        a.check_circuit()
-    }
-    ->std::same_as<bool>;
-};
+template <typename T>
+concept CheckableComposer = requires(T a) {
+                                {
+                                    a.check_circuit()
+                                    } -> std::same_as<bool>;
+                            };
 
 /**
  * @brief The fuzzer can use a postprocessing function that is specific to the type being fuzzed
@@ -170,13 +167,11 @@ template <typename T> concept CheckableComposer = requires(T a)
  * @tparam Context The class containing the full context
  */
 template <typename T, typename Composer, typename Context>
-concept PostProcessingEnabled = requires(Composer composer, Context context)
-{
-    {
-        T::postProcess(&composer, context)
-    }
-    ->std::same_as<bool>;
-};
+concept PostProcessingEnabled = requires(Composer composer, Context context) {
+                                    {
+                                        T::postProcess(&composer, context)
+                                        } -> std::same_as<bool>;
+                                };
 
 /**
  * @brief This concept is used when we want to limit the number of executions of certain instructions (for example,
@@ -184,17 +179,19 @@ concept PostProcessingEnabled = requires(Composer composer, Context context)
  *
  * @tparam T
  */
-template <typename T> concept InstructionWeightsEnabled = requires
-{
-    typename T::InstructionWeights;
-    T::InstructionWeights::_LIMIT;
-};
+template <typename T>
+concept InstructionWeightsEnabled = requires {
+                                        typename T::InstructionWeights;
+                                        T::InstructionWeights::_LIMIT;
+                                    };
 /**
  * @brief A templated class containing most of the fuzzing logic for a generic Arithmetic class
  *
  * @tparam T
  */
-template <typename T> requires ArithmeticFuzzHelperConstraint<T> class ArithmeticFuzzHelper {
+template <typename T>
+    requires ArithmeticFuzzHelperConstraint<T>
+class ArithmeticFuzzHelper {
   private:
     /**
      * @brief Mutator swapping two instructions together
@@ -497,8 +494,8 @@ template <typename T> requires ArithmeticFuzzHelperConstraint<T> class Arithmeti
      * @param instructions
      */
     template <typename Composer>
-    inline static void executeInstructions(
-        std::vector<typename T::Instruction>& instructions) requires CheckableComposer<Composer>
+    inline static void executeInstructions(std::vector<typename T::Instruction>& instructions)
+        requires CheckableComposer<Composer>
     {
         typename T::ExecutionState state;
         Composer composer = Composer();
@@ -590,9 +587,9 @@ template <template <typename> class Fuzzer, uint64_t Composers>
 constexpr void RunWithComposers(const uint8_t* Data, const size_t Size, FastRandom& VarianceRNG)
 {
     if (Composers & 1) {
-        RunWithComposer<Fuzzer, plonk::StandardPlonkComposer>(Data, Size, VarianceRNG);
+        RunWithComposer<Fuzzer, proof_system::StandardCircuitBuilder>(Data, Size, VarianceRNG);
     }
     if (Composers & 2) {
-        RunWithComposer<Fuzzer, plonk::TurboPlonkComposer>(Data, Size, VarianceRNG);
+        RunWithComposer<Fuzzer, proof_system::TurboCircuitBuilder>(Data, Size, VarianceRNG);
     }
 }
diff --git a/circuits/cpp/barretenberg/cpp/src/barretenberg/grumpkin_srs_gen/CMakeLists.txt b/circuits/cpp/barretenberg/cpp/src/barretenberg/grumpkin_srs_gen/CMakeLists.txt
index ab74222c700..bc7540c7258 100644
--- a/circuits/cpp/barretenberg/cpp/src/barretenberg/grumpkin_srs_gen/CMakeLists.txt
+++ b/circuits/cpp/barretenberg/cpp/src/barretenberg/grumpkin_srs_gen/CMakeLists.txt
@@ -1,12 +1,14 @@
-add_executable(
-    grumpkin_srs_gen
-    grumpkin_srs_gen.cpp
-)
+if (NOT(FUZZING))
+    add_executable(
+        grumpkin_srs_gen
+        grumpkin_srs_gen.cpp
+    )
 
-target_link_libraries(
-    grumpkin_srs_gen
-    PRIVATE
-    srs
-    ecc
-    crypto_sha256
-)
\ No newline at end of file
+    target_link_libraries(
+        grumpkin_srs_gen
+        PRIVATE
+        srs
+        ecc
+        crypto_sha256
+    )
+endif()
\ No newline at end of file
diff --git a/circuits/cpp/barretenberg/cpp/src/barretenberg/solidity_helpers/CMakeLists.txt b/circuits/cpp/barretenberg/cpp/src/barretenberg/solidity_helpers/CMakeLists.txt
index bf448229a81..d0281e4e1a2 100644
--- a/circuits/cpp/barretenberg/cpp/src/barretenberg/solidity_helpers/CMakeLists.txt
+++ b/circuits/cpp/barretenberg/cpp/src/barretenberg/solidity_helpers/CMakeLists.txt
@@ -1,15 +1,17 @@
 barretenberg_module(stdlib_solidity_helpers plonk proof_system transcript crypto_pedersen_commitment polynomials crypto_sha256 ecc crypto_blake3s stdlib_primitives stdlib_pedersen_commitment stdlib_blake3s stdlib_blake2s srs)
 
-add_executable(solidity_key_gen key_gen.cpp)
+if (NOT(FUZZING))
+  add_executable(solidity_key_gen key_gen.cpp)
 
-add_executable(solidity_proof_gen proof_gen.cpp)
+  add_executable(solidity_proof_gen proof_gen.cpp)
 
-target_link_libraries(
-  solidity_key_gen
-  stdlib_solidity_helpers
-)
+  target_link_libraries(
+    solidity_key_gen
+    stdlib_solidity_helpers
+  )
 
-target_link_libraries(
-  solidity_proof_gen
-  stdlib_solidity_helpers
-)
+  target_link_libraries(
+    solidity_proof_gen
+    stdlib_solidity_helpers
+  )
+endif()
\ No newline at end of file
diff --git a/circuits/cpp/barretenberg/cpp/src/barretenberg/stdlib/primitives/bigfield/bigfield.fuzzer.hpp b/circuits/cpp/barretenberg/cpp/src/barretenberg/stdlib/primitives/bigfield/bigfield.fuzzer.hpp
index 1480c61407a..81f204b33e1 100644
--- a/circuits/cpp/barretenberg/cpp/src/barretenberg/stdlib/primitives/bigfield/bigfield.fuzzer.hpp
+++ b/circuits/cpp/barretenberg/cpp/src/barretenberg/stdlib/primitives/bigfield/bigfield.fuzzer.hpp
@@ -2,6 +2,7 @@
 #include "barretenberg/numeric/random/engine.hpp"
 #include "barretenberg/numeric/uint256/uint256.hpp"
 #include "barretenberg/stdlib/primitives/bigfield/bigfield.hpp"
+#include "barretenberg/stdlib/primitives/circuit_builders/circuit_builders_fwd.hpp"
 #pragma clang diagnostic push
 // TODO(luke/kesha): Add a comment explaining why we need this ignore and what the solution is.
 #pragma clang diagnostic ignored "-Wc99-designator"
@@ -156,15 +157,11 @@ template <typename Composer> class BigFieldBase {
             RANDOMSEED,
             _LAST
         };
-        Instruction& operator=(const Instruction& other) = default;
 
         struct Element {
-            Element() = default;
-            Element(const Element& other) = default;
-            Element(const Element&& other) { value = std::move(other.value); };
-            Element(fq in)
-                : value(in){};
-            Element& operator=(const Element& other) = default;
+            Element(uint64_t v)
+                : value(v)
+            {}
             fq value;
         };
         struct TwoArgs {
@@ -213,8 +210,9 @@ template <typename Composer> class BigFieldBase {
             uint8_t out3;
         };
         union ArgumentContents {
-            ArgumentContents() { element = Element(fq(0)); }
-            ArgumentContents& operator=(const ArgumentContents& other) = default;
+            ArgumentContents()
+                : randomseed(0)
+            {}
             uint32_t randomseed;
             Element element;
             TwoArgs twoArgs;
@@ -229,6 +227,7 @@ template <typename Composer> class BigFieldBase {
         OPCODE id;
         // Instruction arguments
         ArgumentContents arguments;
+
         /**
          * @brief Generate a random instruction
          *
@@ -236,7 +235,9 @@ template <typename Composer> class BigFieldBase {
          * @param rng PRNG used
          * @return A random instruction
          */
-        template <typename T> inline static Instruction generateRandom(T& rng) requires SimpleRng<T>
+        template <typename T>
+        inline static Instruction generateRandom(T& rng)
+            requires SimpleRng<T>
         {
             // Choose which instruction we are going to generate
             OPCODE instruction_opcode = static_cast<OPCODE>(rng.next() % (OPCODE::_LAST));
@@ -362,7 +363,8 @@ template <typename Composer> class BigFieldBase {
          * @return Mutated element
          */
         template <typename T>
-        inline static fq mutateFieldElement(fq e, T& rng, HavocSettings& havoc_config) requires SimpleRng<T>
+        inline static fq mutateFieldElement(fq e, T& rng, HavocSettings& havoc_config)
+            requires SimpleRng<T>
         {
             // With a certain probability, we apply changes to the Montgomery form, rather than the plain form. This
             // has merit, since the computation is performed in montgomery form and comparisons are often performed
@@ -458,9 +460,8 @@ template <typename Composer> class BigFieldBase {
          * @return Mutated instruction
          */
         template <typename T>
-        inline static Instruction mutateInstruction(Instruction instruction,
-                                                    T& rng,
-                                                    HavocSettings& havoc_config) requires SimpleRng<T>
+        inline static Instruction mutateInstruction(Instruction instruction, T& rng, HavocSettings& havoc_config)
+            requires SimpleRng<T>
         {
 #define PUT_RANDOM_BYTE_IF_LUCKY(variable)                                                                             \
     if (rng.next() & 1) {                                                                                              \
@@ -1929,7 +1930,7 @@ extern "C" int LLVMFuzzerInitialize(int* argc, char*** argv)
  */
 extern "C" size_t LLVMFuzzerCustomMutator(uint8_t* Data, size_t Size, size_t MaxSize, unsigned int Seed)
 {
-    using FuzzerClass = BigFieldBase<plonk::StandardPlonkComposer>;
+    using FuzzerClass = BigFieldBase<proof_system::StandardCircuitBuilder>;
     auto fast_random = FastRandom(Seed);
     auto size_occupied = ArithmeticFuzzHelper<FuzzerClass>::MutateInstructionBuffer(Data, Size, MaxSize, fast_random);
     if ((fast_random.next() % 200) < fuzzer_havoc_settings.GEN_LLVM_POST_MUTATION_PROB) {
@@ -1950,7 +1951,7 @@ extern "C" size_t LLVMFuzzerCustomCrossOver(const uint8_t* Data1,
                                             size_t MaxOutSize,
                                             unsigned int Seed)
 {
-    using FuzzerClass = BigFieldBase<plonk::StandardPlonkComposer>;
+    using FuzzerClass = BigFieldBase<proof_system::StandardCircuitBuilder>;
     auto fast_random = FastRandom(Seed);
     auto vecA = ArithmeticFuzzHelper<FuzzerClass>::parseDataIntoInstructions(Data1, Size1);
     auto vecB = ArithmeticFuzzHelper<FuzzerClass>::parseDataIntoInstructions(Data2, Size2);
diff --git a/circuits/cpp/barretenberg/cpp/src/barretenberg/stdlib/primitives/bit_array/bit_array.fuzzer.hpp b/circuits/cpp/barretenberg/cpp/src/barretenberg/stdlib/primitives/bit_array/bit_array.fuzzer.hpp
index 106b0b6a5b4..397ba57c853 100644
--- a/circuits/cpp/barretenberg/cpp/src/barretenberg/stdlib/primitives/bit_array/bit_array.fuzzer.hpp
+++ b/circuits/cpp/barretenberg/cpp/src/barretenberg/stdlib/primitives/bit_array/bit_array.fuzzer.hpp
@@ -33,7 +33,7 @@ template <typename Composer> class BitArrayFuzzBase {
     typedef proof_system::plonk::stdlib::bit_array<Composer> bit_array_t;
     typedef proof_system::plonk::stdlib::byte_array<Composer> byte_array_t;
     template <size_t NumBytes, size_t NumWords>
-    static std::vector<uint8_t> to_vector(std::array<plonk::stdlib::uint32<Composer>, NumWords>& a32)
+    static std::vector<uint8_t> to_vector(std::array<proof_system::plonk::stdlib::uint32<Composer>, NumWords>& a32)
     {
         /* Convert array of uint32_t to vector of uint8_t */
         std::vector<uint8_t> v(NumBytes);
@@ -60,7 +60,7 @@ template <typename Composer> class BitArrayFuzzBase {
              */
             return static_cast<byte_array_t>(bit_array).get_value();
         } else if (bit_array.size() - offset == NumBits) {
-            std::array<plonk::stdlib::uint32<Composer>, NumWords> a32;
+            std::array<proof_system::plonk::stdlib::uint32<Composer>, NumWords> a32;
             bit_array.template populate_uint32_array<NumWords>(offset, a32);
             return to_vector<NumBytes, NumWords>(a32);
         } else {
@@ -92,7 +92,7 @@ template <typename Composer> class BitArrayFuzzBase {
              */
             return static_cast<byte_array_t>(bit_array).get_value();
         } else if (bit_array.size() == NumBits) {
-            std::array<plonk::stdlib::uint32<Composer>, NumWords> a32;
+            std::array<proof_system::plonk::stdlib::uint32<Composer>, NumWords> a32;
 
             /* Switch between two different methods to retrieve the uint32 array */
             if (cast_or_populate) {
@@ -170,7 +170,9 @@ template <typename Composer> class BitArrayFuzzBase {
          * @param rng PRNG used
          * @return A random instruction
          */
-        template <typename T> inline static Instruction generateRandom(T& rng) requires SimpleRng<T>
+        template <typename T>
+        inline static Instruction generateRandom(T& rng)
+            requires SimpleRng<T>
         {
             // Choose which instruction we are going to generate
             OPCODE instruction_opcode = static_cast<OPCODE>(rng.next() % (OPCODE::_LAST));
@@ -229,9 +231,8 @@ template <typename Composer> class BitArrayFuzzBase {
          * @return Mutated instruction
          */
         template <typename T>
-        inline static Instruction mutateInstruction(Instruction instruction,
-                                                    T& rng,
-                                                    HavocSettings& havoc_config) requires SimpleRng<T>
+        inline static Instruction mutateInstruction(Instruction instruction, T& rng, HavocSettings& havoc_config)
+            requires SimpleRng<T>
         {
             (void)rng;
             (void)havoc_config;
@@ -444,7 +445,8 @@ template <typename Composer> class BitArrayFuzzBase {
                 if (bit_array.size() == MAX_ARRAY_SIZE / 32) {
                     std::array<uint32_t, MAX_ARRAY_SIZE> a32;
                     const auto a32_ =
-                        static_cast<std::array<plonk::stdlib::uint32<Composer>, MAX_ARRAY_SIZE>>(bit_array);
+                        static_cast<std::array<proof_system::plonk::stdlib::uint32<Composer>, MAX_ARRAY_SIZE>>(
+                            bit_array);
                     for (size_t i = 0; i < a32_.size(); i++) {
                         a32[i] = static_cast<uint32_t>(a32_[i].get_value());
                     }
@@ -881,7 +883,7 @@ extern "C" int LLVMFuzzerInitialize(int* argc, char*** argv)
  */
 extern "C" size_t LLVMFuzzerCustomMutator(uint8_t* Data, size_t Size, size_t MaxSize, unsigned int Seed)
 {
-    using FuzzerClass = BitArrayFuzzBase<plonk::StandardPlonkComposer>;
+    using FuzzerClass = BitArrayFuzzBase<proof_system::StandardCircuitBuilder>;
     auto fast_random = FastRandom(Seed);
     auto size_occupied = ArithmeticFuzzHelper<FuzzerClass>::MutateInstructionBuffer(Data, Size, MaxSize, fast_random);
     if ((fast_random.next() % 200) < fuzzer_havoc_settings.GEN_LLVM_POST_MUTATION_PROB) {
@@ -902,7 +904,7 @@ extern "C" size_t LLVMFuzzerCustomCrossOver(const uint8_t* Data1,
                                             size_t MaxOutSize,
                                             unsigned int Seed)
 {
-    using FuzzerClass = BitArrayFuzzBase<plonk::StandardPlonkComposer>;
+    using FuzzerClass = BitArrayFuzzBase<proof_system::StandardCircuitBuilder>;
     auto fast_random = FastRandom(Seed);
     auto vecA = ArithmeticFuzzHelper<FuzzerClass>::parseDataIntoInstructions(Data1, Size1);
     auto vecB = ArithmeticFuzzHelper<FuzzerClass>::parseDataIntoInstructions(Data2, Size2);
diff --git a/circuits/cpp/barretenberg/cpp/src/barretenberg/stdlib/primitives/bool/bool.fuzzer.hpp b/circuits/cpp/barretenberg/cpp/src/barretenberg/stdlib/primitives/bool/bool.fuzzer.hpp
index 06dc11eee66..f516c802961 100644
--- a/circuits/cpp/barretenberg/cpp/src/barretenberg/stdlib/primitives/bool/bool.fuzzer.hpp
+++ b/circuits/cpp/barretenberg/cpp/src/barretenberg/stdlib/primitives/bool/bool.fuzzer.hpp
@@ -72,7 +72,9 @@ template <typename Composer> class BoolFuzzBase {
          * @param rng PRNG used
          * @return A random instruction
          */
-        template <typename T> inline static Instruction generateRandom(T& rng) requires SimpleRng<T>
+        template <typename T>
+        inline static Instruction generateRandom(T& rng)
+            requires SimpleRng<T>
         {
             // Choose which instruction we are going to generate
             OPCODE instruction_opcode = static_cast<OPCODE>(rng.next() % (OPCODE::_LAST));
@@ -129,9 +131,8 @@ template <typename Composer> class BoolFuzzBase {
          * @return Mutated instruction
          */
         template <typename T>
-        inline static Instruction mutateInstruction(Instruction instruction,
-                                                    T& rng,
-                                                    HavocSettings& havoc_config) requires SimpleRng<T>
+        inline static Instruction mutateInstruction(Instruction instruction, T& rng, HavocSettings& havoc_config)
+            requires SimpleRng<T>
         {
             (void)rng;
             (void)havoc_config;
@@ -800,7 +801,7 @@ extern "C" int LLVMFuzzerInitialize(int* argc, char*** argv)
  */
 extern "C" size_t LLVMFuzzerCustomMutator(uint8_t* Data, size_t Size, size_t MaxSize, unsigned int Seed)
 {
-    using FuzzerClass = BoolFuzzBase<plonk::StandardPlonkComposer>;
+    using FuzzerClass = BoolFuzzBase<proof_system::StandardCircuitBuilder>;
     auto fast_random = FastRandom(Seed);
     auto size_occupied = ArithmeticFuzzHelper<FuzzerClass>::MutateInstructionBuffer(Data, Size, MaxSize, fast_random);
     if ((fast_random.next() % 200) < fuzzer_havoc_settings.GEN_LLVM_POST_MUTATION_PROB) {
@@ -821,7 +822,7 @@ extern "C" size_t LLVMFuzzerCustomCrossOver(const uint8_t* Data1,
                                             size_t MaxOutSize,
                                             unsigned int Seed)
 {
-    using FuzzerClass = BoolFuzzBase<plonk::StandardPlonkComposer>;
+    using FuzzerClass = BoolFuzzBase<proof_system::StandardCircuitBuilder>;
     auto fast_random = FastRandom(Seed);
     auto vecA = ArithmeticFuzzHelper<FuzzerClass>::parseDataIntoInstructions(Data1, Size1);
     auto vecB = ArithmeticFuzzHelper<FuzzerClass>::parseDataIntoInstructions(Data2, Size2);
diff --git a/circuits/cpp/barretenberg/cpp/src/barretenberg/stdlib/primitives/byte_array/byte_array.fuzzer.hpp b/circuits/cpp/barretenberg/cpp/src/barretenberg/stdlib/primitives/byte_array/byte_array.fuzzer.hpp
index 6ec22b68cde..1680e94b7f5 100644
--- a/circuits/cpp/barretenberg/cpp/src/barretenberg/stdlib/primitives/byte_array/byte_array.fuzzer.hpp
+++ b/circuits/cpp/barretenberg/cpp/src/barretenberg/stdlib/primitives/byte_array/byte_array.fuzzer.hpp
@@ -106,7 +106,9 @@ template <typename Composer> class ByteArrayFuzzBase {
          * @param rng PRNG used
          * @return A random instruction
          */
-        template <typename T> inline static Instruction generateRandom(T& rng) requires SimpleRng<T>
+        template <typename T>
+        inline static Instruction generateRandom(T& rng)
+            requires SimpleRng<T>
         {
             // Choose which instruction we are going to generate
             OPCODE instruction_opcode = static_cast<OPCODE>(rng.next() % (OPCODE::_LAST));
@@ -176,9 +178,8 @@ template <typename Composer> class ByteArrayFuzzBase {
          * @return Mutated instruction
          */
         template <typename T>
-        inline static Instruction mutateInstruction(Instruction instruction,
-                                                    T& rng,
-                                                    HavocSettings& havoc_config) requires SimpleRng<T>
+        inline static Instruction mutateInstruction(Instruction instruction, T& rng, HavocSettings& havoc_config)
+            requires SimpleRng<T>
         {
             (void)rng;
             (void)havoc_config;
@@ -929,7 +930,7 @@ extern "C" int LLVMFuzzerInitialize(int* argc, char*** argv)
  */
 extern "C" size_t LLVMFuzzerCustomMutator(uint8_t* Data, size_t Size, size_t MaxSize, unsigned int Seed)
 {
-    using FuzzerClass = ByteArrayFuzzBase<plonk::StandardPlonkComposer>;
+    using FuzzerClass = ByteArrayFuzzBase<proof_system::StandardCircuitBuilder>;
     auto fast_random = FastRandom(Seed);
     auto size_occupied = ArithmeticFuzzHelper<FuzzerClass>::MutateInstructionBuffer(Data, Size, MaxSize, fast_random);
     if ((fast_random.next() % 200) < fuzzer_havoc_settings.GEN_LLVM_POST_MUTATION_PROB) {
@@ -950,7 +951,7 @@ extern "C" size_t LLVMFuzzerCustomCrossOver(const uint8_t* Data1,
                                             size_t MaxOutSize,
                                             unsigned int Seed)
 {
-    using FuzzerClass = ByteArrayFuzzBase<plonk::StandardPlonkComposer>;
+    using FuzzerClass = ByteArrayFuzzBase<proof_system::StandardCircuitBuilder>;
     auto fast_random = FastRandom(Seed);
     auto vecA = ArithmeticFuzzHelper<FuzzerClass>::parseDataIntoInstructions(Data1, Size1);
     auto vecB = ArithmeticFuzzHelper<FuzzerClass>::parseDataIntoInstructions(Data2, Size2);
diff --git a/circuits/cpp/barretenberg/cpp/src/barretenberg/stdlib/primitives/field/field.fuzzer.hpp b/circuits/cpp/barretenberg/cpp/src/barretenberg/stdlib/primitives/field/field.fuzzer.hpp
index 53483c9f2f5..c898d9d3763 100644
--- a/circuits/cpp/barretenberg/cpp/src/barretenberg/stdlib/primitives/field/field.fuzzer.hpp
+++ b/circuits/cpp/barretenberg/cpp/src/barretenberg/stdlib/primitives/field/field.fuzzer.hpp
@@ -4,6 +4,7 @@
 #include "barretenberg/numeric/uint256/uint256.hpp"
 #include "barretenberg/stdlib/primitives/bool/bool.hpp"
 #include "barretenberg/stdlib/primitives/field/field.hpp"
+#include "cstring"
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Wc99-designator"
 
@@ -98,7 +99,7 @@ FastRandom VarianceRNG(0);
 
 #define OPERATION_TYPE_SIZE 1
 
-#define ELEMENT_SIZE (sizeof(fr) + 1)
+#define ELEMENT_SIZE (sizeof(barretenberg::fr) + 1)
 #define TWO_IN_ONE_OUT 3
 #define THREE_IN_ONE_OUT 4
 #define SLICE_ARGS_SIZE 6
@@ -158,17 +159,8 @@ template <typename Composer> class FieldBase {
             INVERT,
             _LAST
         };
-        Instruction& operator=(const Instruction& other) = default;
-
-        struct Element {
-            Element() = default;
-            Element(const Element& other) = default;
-            Element(const Element&& other) { value = std::move(other.value); };
-            Element(fr in)
-                : value(in){};
-            Element& operator=(const Element& other) = default;
-            fr value;
-        };
+
+        typedef barretenberg::fr Element;
         struct SingleArg {
             uint8_t in;
         };
@@ -212,8 +204,6 @@ template <typename Composer> class FieldBase {
             uint8_t out3;
         };
         union ArgumentContents {
-            ArgumentContents() { element = Element(fr(0)); }
-            ArgumentContents& operator=(const ArgumentContents& other) = default;
             uint32_t randomseed;
             Element element;
             SingleArg singleArg;
@@ -229,6 +219,7 @@ template <typename Composer> class FieldBase {
         OPCODE id;
         // Instruction arguments
         ArgumentContents arguments;
+
         /**
          * @brief Generate a random instruction
          *
@@ -236,13 +227,14 @@ template <typename Composer> class FieldBase {
          * @param rng PRNG used
          * @return A random instruction
          */
-        template <typename T> inline static Instruction generateRandom(T& rng) requires SimpleRng<T>
+        template <typename T>
+        inline static Instruction generateRandom(T& rng)
+            requires SimpleRng<T>
         {
             // Choose which instruction we are going to generate
             OPCODE instruction_opcode = static_cast<OPCODE>(rng.next() % (OPCODE::_LAST));
             uint8_t in1, in2, in3, lsb, msb, out, out1, out2, out3, mask_size;
             uint256_t mask, temp;
-            Instruction instr;
 
             // Depending on instruction
             switch (instruction_opcode) {
@@ -335,7 +327,8 @@ template <typename Composer> class FieldBase {
          * @return Mutated element
          */
         template <typename T>
-        inline static fr mutateFieldElement(fr e, T& rng, HavocSettings& havoc_config) requires SimpleRng<T>
+        inline static barretenberg::fr mutateFieldElement(barretenberg::fr e, T& rng, HavocSettings& havoc_config)
+            requires SimpleRng<T>
         {
             // With a certain probability, we apply changes to the Montgomery form, rather than the plain form. This
             // has merit, since the computation is performed in montgomery form and comparisons are often performed
@@ -354,9 +347,9 @@ template <typename Composer> class FieldBase {
             // Inverse conversion at the end
 #define INV_MONT_CONVERSION                                                                                            \
     if (convert_to_montgomery) {                                                                                       \
-        e = fr(value_data).from_montgomery_form();                                                                     \
+        e = barretenberg::fr(value_data).from_montgomery_form();                                                       \
     } else {                                                                                                           \
-        e = fr(value_data);                                                                                            \
+        e = barretenberg::fr(value_data);                                                                              \
     }
 
             // Pick the last value from the mutation distrivution vector
@@ -374,9 +367,9 @@ template <typename Composer> class FieldBase {
                     e = e.to_montgomery_form();
                 }
                 if (rng.next() & 1) {
-                    value_data = e + fr(rng.next() & 0xff);
+                    value_data = e + barretenberg::fr(rng.next() & 0xff);
                 } else {
-                    value_data = e - fr(rng.next() & 0xff);
+                    value_data = e - barretenberg::fr(rng.next() & 0xff);
                 }
                 if (convert_to_montgomery) {
                     e = e.from_montgomery_form();
@@ -386,31 +379,31 @@ template <typename Composer> class FieldBase {
                 MONT_CONVERSION
                 switch (rng.next() % 9) {
                 case 0:
-                    e = fr::zero();
+                    e = barretenberg::fr::zero();
                     break;
                 case 1:
-                    e = fr::one();
+                    e = barretenberg::fr::one();
                     break;
                 case 2:
-                    e = -fr::one();
+                    e = -barretenberg::fr::one();
                     break;
                 case 3:
-                    e = fr::one().sqrt().second;
+                    e = barretenberg::fr::one().sqrt().second;
                     break;
                 case 4:
-                    e = fr::one().sqrt().second.invert();
+                    e = barretenberg::fr::one().sqrt().second.invert();
                     break;
                 case 5:
-                    e = fr::get_root_of_unity(8);
+                    e = barretenberg::fr::get_root_of_unity(8);
                     break;
                 case 6:
-                    e = fr(2);
+                    e = barretenberg::fr(2);
                     break;
                 case 7:
-                    e = fr((fr::modulus - 1) / 2);
+                    e = barretenberg::fr((barretenberg::fr::modulus - 1) / 2);
                     break;
                 case 8:
-                    e = fr((fr::modulus));
+                    e = barretenberg::fr((barretenberg::fr::modulus));
                     break;
                 default:
                     abort();
@@ -431,9 +424,8 @@ template <typename Composer> class FieldBase {
          * @return Mutated instruction
          */
         template <typename T>
-        inline static Instruction mutateInstruction(Instruction instruction,
-                                                    T& rng,
-                                                    HavocSettings& havoc_config) requires SimpleRng<T>
+        inline static Instruction mutateInstruction(Instruction instruction, T& rng, HavocSettings& havoc_config)
+            requires SimpleRng<T>
         {
 #define PUT_RANDOM_BYTE_IF_LUCKY(variable)                                                                             \
     if (rng.next() & 1) {                                                                                              \
@@ -447,8 +439,8 @@ template <typename Composer> class FieldBase {
                 // If it represents pushing a value on the stack with a 50% probability randomly sample a bit_range
                 // Maybe mutate the value
                 if (rng.next() & 1) {
-                    instruction.arguments.element.value =
-                        mutateFieldElement(instruction.arguments.element.value, rng, havoc_config);
+                    instruction.arguments.element =
+                        mutateFieldElement(instruction.arguments.element, rng, havoc_config);
                 }
                 break;
             case OPCODE::ASSERT_ZERO:
@@ -510,9 +502,9 @@ template <typename Composer> class FieldBase {
     // instruction is enabled (if it is -1,it's disabled )
     class ArgSizes {
       public:
-        static constexpr size_t CONSTANT = sizeof(fr);
-        static constexpr size_t WITNESS = sizeof(fr);
-        static constexpr size_t CONSTANT_WITNESS = sizeof(fr);
+        static constexpr size_t CONSTANT = sizeof(barretenberg::fr);
+        static constexpr size_t WITNESS = sizeof(barretenberg::fr);
+        static constexpr size_t CONSTANT_WITNESS = sizeof(barretenberg::fr);
         static constexpr size_t SQR = 2;
         static constexpr size_t ASSERT_EQUAL = 2;
         static constexpr size_t ASSERT_NOT_EQUAL = 2;
@@ -594,8 +586,8 @@ template <typename Composer> class FieldBase {
                           opcode == Instruction::OPCODE::CONSTANT_WITNESS) {
                 Instruction instr;
                 instr.id = static_cast<typename Instruction::OPCODE>(opcode);
-                // instr.arguments.element.value = fr::serialize_from_buffer(Data+1);
-                instr.arguments.element.value = fr::serialize_from_buffer(Data);
+                // instr.arguments.element = fr::serialize_from_buffer(Data+1);
+                instr.arguments.element = barretenberg::fr::serialize_from_buffer(Data);
                 return instr;
             };
             if constexpr (opcode == Instruction::OPCODE::ASSERT_ZERO ||
@@ -655,9 +647,7 @@ template <typename Composer> class FieldBase {
                           instruction_opcode == Instruction::OPCODE::WITNESS ||
                           instruction_opcode == Instruction::OPCODE::CONSTANT_WITNESS) {
                 *Data = instruction.id;
-                memcpy(Data + 1,
-                       &instruction.arguments.element.value.data[0],
-                       sizeof(instruction.arguments.element.value.data));
+                memcpy(Data + 1, &instruction.arguments.element.data[0], sizeof(instruction.arguments.element.data));
             }
 
             if constexpr (instruction_opcode == Instruction::OPCODE::ASSERT_ZERO ||
@@ -777,18 +767,18 @@ template <typename Composer> class FieldBase {
         }
 
       public:
-        fr base;
+        barretenberg::fr base;
         field_t field;
         ExecutionHandler() = default;
-        ExecutionHandler(fr a, field_t b)
+        ExecutionHandler(barretenberg::fr a, field_t b)
             : base(a)
             , field(b)
         {}
-        ExecutionHandler(fr a, field_t& b)
+        ExecutionHandler(barretenberg::fr a, field_t& b)
             : base(a)
             , field(b)
         {}
-        ExecutionHandler(fr& a, field_t& b)
+        ExecutionHandler(barretenberg::fr& a, field_t& b)
             : base(a)
             , field(b)
         {}
@@ -1019,7 +1009,7 @@ template <typename Composer> class FieldBase {
 #ifdef SHOW_INFORMATION
                 std::cout << "Construct via fr" << std::endl;
 #endif
-                return construct_via_cast<fr>(fr::modulus - 1);
+                return construct_via_cast<barretenberg::fr>(barretenberg::fr::modulus - 1);
             case 6:
 #if 1
                 /* Disabled because casting to bool_t can fail.
@@ -1027,10 +1017,10 @@ template <typename Composer> class FieldBase {
                  *
                  * TEST(stdlib_field, test_construct_via_bool_t)
                  * {
-                 *     plonk::StandardPlonkComposer composer = proof_system::plonk::StandardPlonkComposer();
-                 *     field_t a(witness_t(&composer, fr(uint256_t{0xf396b678452ebf15, 0x82ae10893982638b,
-                 * 0xdf185a29c65fbf80, 0x1d18b2de99e48308}))); field_t b = a - a; field_t c(static_cast<bool_t>(b));
-                 *     std::cout << c.get_value() << std::endl;
+                 *     proof_system::StandardCircuitBuilder composer =
+                 * proof_system::proof_system::StandardCircuitBuilder(); field_t a(witness_t(&composer,
+                 * fr(uint256_t{0xf396b678452ebf15, 0x82ae10893982638b, 0xdf185a29c65fbf80, 0x1d18b2de99e48308})));
+                 * field_t b = a - a; field_t c(static_cast<bool_t>(b)); std::cout << c.get_value() << std::endl;
                  * }
                  *
                  * According to Rumata this is because the input value needs to be normalized
@@ -1071,14 +1061,15 @@ template <typename Composer> class FieldBase {
                 // const auto bits = this->f().decompose_into_bits(num_bits);
                 const auto bits = this->f().decompose_into_bits();
 
-                std::vector<fr> frs(bits.size());
+                std::vector<barretenberg::fr> frs(bits.size());
                 for (size_t i = 0; i < bits.size(); i++) {
-                    frs[i] = bits[i].get_value() ? fr(uint256_t(1) << i) : 0;
+                    frs[i] = bits[i].get_value() ? barretenberg::fr(uint256_t(1) << i) : 0;
                 }
 
                 switch (VarianceRNG.next() % 2) {
                 case 0: {
-                    const fr field_from_bits = std::accumulate(frs.begin(), frs.end(), fr(0));
+                    const barretenberg::fr field_from_bits =
+                        std::accumulate(frs.begin(), frs.end(), barretenberg::fr(0));
                     return ExecutionHandler(this->base, field_t(composer, field_from_bits));
                 }
                 case 1: {
@@ -1104,7 +1095,7 @@ template <typename Composer> class FieldBase {
             if (this->base == 0) {
                 return ExecutionHandler(this->base, this->f());
             } else {
-                return ExecutionHandler(fr(1) / this->base, this->f().invert());
+                return ExecutionHandler(barretenberg::fr(1) / this->base, this->f().invert());
             }
         }
 
@@ -1121,10 +1112,10 @@ template <typename Composer> class FieldBase {
                                               Instruction& instruction)
         {
             (void)composer;
-            stack.push_back(ExecutionHandler(instruction.arguments.element.value,
-                                             field_t(composer, instruction.arguments.element.value)));
+            stack.push_back(
+                ExecutionHandler(instruction.arguments.element, field_t(composer, instruction.arguments.element)));
 #ifdef SHOW_INFORMATION
-            std::cout << "Pushed constant value " << instruction.arguments.element.value << " to position "
+            std::cout << "Pushed constant value " << instruction.arguments.element << " to position "
                       << stack.size() - 1 << std::endl;
 #endif
             return 0;
@@ -1144,12 +1135,12 @@ template <typename Composer> class FieldBase {
         {
 
             // THis is strange
-            stack.push_back(ExecutionHandler(instruction.arguments.element.value,
-                                             witness_t(composer, instruction.arguments.element.value)));
+            stack.push_back(
+                ExecutionHandler(instruction.arguments.element, witness_t(composer, instruction.arguments.element)));
 
 #ifdef SHOW_INFORMATION
-            std::cout << "Pushed witness value " << instruction.arguments.element.value << " to position "
-                      << stack.size() - 1 << std::endl;
+            std::cout << "Pushed witness value " << instruction.arguments.element << " to position " << stack.size() - 1
+                      << std::endl;
 #endif
             return 0;
         }
@@ -1167,11 +1158,11 @@ template <typename Composer> class FieldBase {
                                                       std::vector<ExecutionHandler>& stack,
                                                       Instruction& instruction)
         {
-            auto v = field_t(witness_t(composer, instruction.arguments.element.value));
-            v.convert_constant_to_witness(composer);
-            stack.push_back(ExecutionHandler(instruction.arguments.element.value, std::move(v)));
+            auto v = field_t(witness_t(composer, instruction.arguments.element));
+            v.convert_constant_to_fixed_witness(composer);
+            stack.push_back(ExecutionHandler(instruction.arguments.element, std::move(v)));
 #ifdef SHOW_INFORMATION
-            std::cout << "Pushed constant witness value " << instruction.arguments.element.value << " to position "
+            std::cout << "Pushed constant witness value " << instruction.arguments.element << " to position "
                       << stack.size() - 1 << std::endl;
 #endif
             return 0;
@@ -1458,7 +1449,7 @@ template <typename Composer> class FieldBase {
             PRINT_TWO_ARG_INSTRUCTION(first_index, second_index, stack, "Dividing", "/")
 
             ExecutionHandler result;
-            if (fr((uint256_t(stack[second_index].f().get_value()) % fr::modulus)) == 0) {
+            if (barretenberg::fr((uint256_t(stack[second_index].f().get_value()) % barretenberg::fr::modulus)) == 0) {
                 return 0; // This is not handled by field
             }
             // TODO: FIX THIS. I can't think of an elegant fix for this field issue right now
@@ -1841,7 +1832,7 @@ template <typename Composer> class FieldBase {
         (void)composer;
         for (size_t i = 0; i < stack.size(); i++) {
             auto element = stack[i];
-            if (fr((uint256_t(element.field.get_value()) % fr::modulus)) != element.base) {
+            if (barretenberg::fr((uint256_t(element.field.get_value()) % barretenberg::fr::modulus)) != element.base) {
                 std::cerr << "Failed at " << i << " with actual value " << element.base << " and value in field "
                           << element.field.get_value() << std::endl;
                 return false;
@@ -1979,7 +1970,7 @@ extern "C" int LLVMFuzzerInitialize(int* argc, char*** argv)
  */
 extern "C" size_t LLVMFuzzerCustomMutator(uint8_t* Data, size_t Size, size_t MaxSize, unsigned int Seed)
 {
-    using FuzzerClass = FieldBase<plonk::StandardPlonkComposer>;
+    using FuzzerClass = FieldBase<proof_system::StandardCircuitBuilder>;
     auto fast_random = FastRandom(Seed);
     auto size_occupied = ArithmeticFuzzHelper<FuzzerClass>::MutateInstructionBuffer(Data, Size, MaxSize, fast_random);
     if ((fast_random.next() % 200) < fuzzer_havoc_settings.GEN_LLVM_POST_MUTATION_PROB) {
@@ -2000,7 +1991,7 @@ extern "C" size_t LLVMFuzzerCustomCrossOver(const uint8_t* Data1,
                                             size_t MaxOutSize,
                                             unsigned int Seed)
 {
-    using FuzzerClass = FieldBase<plonk::StandardPlonkComposer>;
+    using FuzzerClass = FieldBase<proof_system::StandardCircuitBuilder>;
     auto fast_random = FastRandom(Seed);
     auto vecA = ArithmeticFuzzHelper<FuzzerClass>::parseDataIntoInstructions(Data1, Size1);
     auto vecB = ArithmeticFuzzHelper<FuzzerClass>::parseDataIntoInstructions(Data2, Size2);
diff --git a/circuits/cpp/barretenberg/cpp/src/barretenberg/stdlib/primitives/safe_uint/safe_uint.fuzzer.hpp b/circuits/cpp/barretenberg/cpp/src/barretenberg/stdlib/primitives/safe_uint/safe_uint.fuzzer.hpp
index d41b51107e8..c1fc716935e 100644
--- a/circuits/cpp/barretenberg/cpp/src/barretenberg/stdlib/primitives/safe_uint/safe_uint.fuzzer.hpp
+++ b/circuits/cpp/barretenberg/cpp/src/barretenberg/stdlib/primitives/safe_uint/safe_uint.fuzzer.hpp
@@ -9,6 +9,7 @@
 // the input should fail
 bool circuit_should_fail = false;
 
+using fr = barretenberg::fr;
 #define HAVOC_TESTING
 
 #include "barretenberg/common/fuzzer.hpp"
@@ -188,7 +189,9 @@ template <typename Composer> class SafeUintFuzzBase {
          * @param rng PRNG used
          * @return A random instruction
          */
-        template <typename T> inline static Instruction generateRandom(T& rng) requires SimpleRng<T>
+        template <typename T>
+        inline static Instruction generateRandom(T& rng)
+            requires SimpleRng<T>
         {
             // Choose which instruction we are going to generate
             OPCODE instruction_opcode = static_cast<OPCODE>(rng.next() % (OPCODE::_LAST));
@@ -283,7 +286,8 @@ template <typename Composer> class SafeUintFuzzBase {
          * @return Mutated element
          */
         template <typename T>
-        inline static fr mutateFieldElement(fr e, T& rng, HavocSettings& havoc_config) requires SimpleRng<T>
+        inline static fr mutateFieldElement(fr e, T& rng, HavocSettings& havoc_config)
+            requires SimpleRng<T>
         {
             // With a certain probability, we apply changes to the Montgomery form, rather than the plain form. This has
             // merit, since the computation is performed in montgomery form and comparisons are often performed in it,
@@ -376,9 +380,8 @@ template <typename Composer> class SafeUintFuzzBase {
          * @return Mutated instruction
          */
         template <typename T>
-        inline static Instruction mutateInstruction(Instruction instruction,
-                                                    T& rng,
-                                                    HavocSettings& havoc_config) requires SimpleRng<T>
+        inline static Instruction mutateInstruction(Instruction instruction, T& rng, HavocSettings& havoc_config)
+            requires SimpleRng<T>
         {
 #define PUT_RANDOM_BYTE_IF_LUCKY(variable)                                                                             \
     if (rng.next() & 1) {                                                                                              \
@@ -1417,7 +1420,7 @@ extern "C" int LLVMFuzzerInitialize(int* argc, char*** argv)
  */
 extern "C" size_t LLVMFuzzerCustomMutator(uint8_t* Data, size_t Size, size_t MaxSize, unsigned int Seed)
 {
-    using FuzzerClass = SafeUintFuzzBase<plonk::StandardPlonkComposer>;
+    using FuzzerClass = SafeUintFuzzBase<proof_system::StandardCircuitBuilder>;
     auto fast_random = FastRandom(Seed);
     auto size_occupied = ArithmeticFuzzHelper<FuzzerClass>::MutateInstructionBuffer(Data, Size, MaxSize, fast_random);
     if ((fast_random.next() % 200) < fuzzer_havoc_settings.GEN_LLVM_POST_MUTATION_PROB) {
@@ -1438,7 +1441,7 @@ extern "C" size_t LLVMFuzzerCustomCrossOver(const uint8_t* Data1,
                                             size_t MaxOutSize,
                                             unsigned int Seed)
 {
-    using FuzzerClass = SafeUintFuzzBase<plonk::StandardPlonkComposer>;
+    using FuzzerClass = SafeUintFuzzBase<proof_system::StandardCircuitBuilder>;
     auto fast_random = FastRandom(Seed);
     auto vecA = ArithmeticFuzzHelper<FuzzerClass>::parseDataIntoInstructions(Data1, Size1);
     auto vecB = ArithmeticFuzzHelper<FuzzerClass>::parseDataIntoInstructions(Data2, Size2);
diff --git a/circuits/cpp/barretenberg/cpp/src/barretenberg/stdlib/primitives/uint/uint.fuzzer.hpp b/circuits/cpp/barretenberg/cpp/src/barretenberg/stdlib/primitives/uint/uint.fuzzer.hpp
index 921f5cbc0e6..20ab5fa3618 100644
--- a/circuits/cpp/barretenberg/cpp/src/barretenberg/stdlib/primitives/uint/uint.fuzzer.hpp
+++ b/circuits/cpp/barretenberg/cpp/src/barretenberg/stdlib/primitives/uint/uint.fuzzer.hpp
@@ -1,6 +1,7 @@
 #include "barretenberg/numeric/random/engine.hpp"
 #include "barretenberg/stdlib/primitives/bool/bool.hpp"
 #include "barretenberg/stdlib/primitives/byte_array/byte_array.hpp"
+#include "barretenberg/stdlib/primitives/circuit_builders/circuit_builders_fwd.hpp"
 #include "barretenberg/stdlib/primitives/field/field.hpp"
 #include "barretenberg/stdlib/primitives/uint/uint.hpp"
 #pragma clang diagnostic push
@@ -104,7 +105,9 @@ template <typename Composer> class UintFuzzBase {
          * @param rng PRNG used
          * @return A random instruction
          */
-        template <typename T> inline static Instruction generateRandom(T& rng) requires SimpleRng<T>
+        template <typename T>
+        inline static Instruction generateRandom(T& rng)
+            requires SimpleRng<T>
         {
             // Choose which instruction we are going to generate
             OPCODE instruction_opcode = static_cast<OPCODE>(rng.next() % (OPCODE::_LAST));
@@ -164,9 +167,8 @@ template <typename Composer> class UintFuzzBase {
          * @return Mutated instruction
          */
         template <typename T>
-        inline static Instruction mutateInstruction(Instruction instruction,
-                                                    T& rng,
-                                                    HavocSettings& havoc_config) requires SimpleRng<T>
+        inline static Instruction mutateInstruction(Instruction instruction, T& rng, HavocSettings& havoc_config)
+            requires SimpleRng<T>
         {
             (void)rng;
             (void)havoc_config;
@@ -1545,7 +1547,7 @@ extern "C" int LLVMFuzzerInitialize(int* argc, char*** argv)
  */
 extern "C" size_t LLVMFuzzerCustomMutator(uint8_t* Data, size_t Size, size_t MaxSize, unsigned int Seed)
 {
-    using FuzzerClass = UintFuzzBase<plonk::StandardPlonkComposer>;
+    using FuzzerClass = UintFuzzBase<proof_system::StandardCircuitBuilder>;
     auto fast_random = FastRandom(Seed);
     auto size_occupied = ArithmeticFuzzHelper<FuzzerClass>::MutateInstructionBuffer(Data, Size, MaxSize, fast_random);
     if ((fast_random.next() % 200) < fuzzer_havoc_settings.GEN_LLVM_POST_MUTATION_PROB) {
@@ -1566,7 +1568,7 @@ extern "C" size_t LLVMFuzzerCustomCrossOver(const uint8_t* Data1,
                                             size_t MaxOutSize,
                                             unsigned int Seed)
 {
-    using FuzzerClass = UintFuzzBase<plonk::StandardPlonkComposer>;
+    using FuzzerClass = UintFuzzBase<proof_system::StandardCircuitBuilder>;
     auto fast_random = FastRandom(Seed);
     auto vecA = ArithmeticFuzzHelper<FuzzerClass>::parseDataIntoInstructions(Data1, Size1);
     auto vecB = ArithmeticFuzzHelper<FuzzerClass>::parseDataIntoInstructions(Data2, Size2);