diff --git a/barretenberg/cpp/src/barretenberg/common/fuzzer.hpp b/barretenberg/cpp/src/barretenberg/common/fuzzer.hpp
index 2aa56914080..891c247d232 100644
--- a/barretenberg/cpp/src/barretenberg/common/fuzzer.hpp
+++ b/barretenberg/cpp/src/barretenberg/common/fuzzer.hpp
@@ -680,7 +680,7 @@ class ArithmeticFuzzHelper {
 };
 
 template <template <typename> class Fuzzer, typename Composer>
-constexpr void RunWithComposer(const uint8_t* Data, const size_t Size, FastRandom& VarianceRNG)
+constexpr void RunWithBuilder(const uint8_t* Data, const size_t Size, FastRandom& VarianceRNG)
 {
     VarianceRNG.reseed(0);
     auto instructions = ArithmeticFuzzHelper<Fuzzer<Composer>>::parseDataIntoInstructions(Data, Size);
@@ -688,13 +688,13 @@ constexpr void RunWithComposer(const uint8_t* Data, const size_t Size, FastRando
 }
 
 template <template <typename> class Fuzzer, uint64_t Composers>
-constexpr void RunWithComposers(const uint8_t* Data, const size_t Size, FastRandom& VarianceRNG)
+constexpr void RunWithBuilders(const uint8_t* Data, const size_t Size, FastRandom& VarianceRNG)
 {
     if (Composers & 1) {
-        RunWithComposer<Fuzzer, proof_system::StandardCircuitBuilder>(Data, Size, VarianceRNG);
+        RunWithBuilder<Fuzzer, proof_system::StandardCircuitBuilder>(Data, Size, VarianceRNG);
     }
     if (Composers & 2) {
-        RunWithComposer<Fuzzer, proof_system::TurboCircuitBuilder>(Data, Size, VarianceRNG);
+        RunWithBuilder<Fuzzer, proof_system::TurboCircuitBuilder>(Data, Size, VarianceRNG);
     }
 }
 
diff --git a/barretenberg/cpp/src/barretenberg/stdlib/commitment/pedersen/pedersen.hpp b/barretenberg/cpp/src/barretenberg/stdlib/commitment/pedersen/pedersen.hpp
index fd3eca12d74..160a5289213 100644
--- a/barretenberg/cpp/src/barretenberg/stdlib/commitment/pedersen/pedersen.hpp
+++ b/barretenberg/cpp/src/barretenberg/stdlib/commitment/pedersen/pedersen.hpp
@@ -10,12 +10,12 @@ namespace stdlib {
 
 constexpr uint64_t WNAF_MASK = crypto::generators::WNAF_MASK;
 
-template <typename ComposerContext> class pedersen_commitment {
+template <typename CircuitBuilder> class pedersen_commitment {
   private:
-    typedef stdlib::field_t<ComposerContext> field_t;
-    typedef stdlib::point<ComposerContext> point;
-    typedef stdlib::byte_array<ComposerContext> byte_array;
-    typedef stdlib::bool_t<ComposerContext> bool_t;
+    typedef stdlib::field_t<CircuitBuilder> field_t;
+    typedef stdlib::point<CircuitBuilder> point;
+    typedef stdlib::byte_array<CircuitBuilder> byte_array;
+    typedef stdlib::bool_t<CircuitBuilder> bool_t;
 
   public:
     static point commit(const std::vector<field_t>& inputs, const size_t hash_index = 0);
diff --git a/barretenberg/cpp/src/barretenberg/stdlib/commitment/pedersen/pedersen.test.cpp b/barretenberg/cpp/src/barretenberg/stdlib/commitment/pedersen/pedersen.test.cpp
index f5d2348da56..b14a4beabf0 100644
--- a/barretenberg/cpp/src/barretenberg/stdlib/commitment/pedersen/pedersen.test.cpp
+++ b/barretenberg/cpp/src/barretenberg/stdlib/commitment/pedersen/pedersen.test.cpp
@@ -14,14 +14,14 @@ namespace {
 auto& engine = numeric::random::get_debug_engine();
 }
 
-template <typename Composer> class stdlib_pedersen : public testing::Test {
-    typedef stdlib::bn254<Composer> curve;
+template <typename Builder> class stdlib_pedersen : public testing::Test {
+    typedef stdlib::bn254<Builder> curve;
 
     typedef typename curve::byte_array_ct byte_array_ct;
     typedef typename curve::ScalarField fr_ct;
     typedef typename curve::witness_ct witness_ct;
     typedef typename curve::public_witness_ct public_witness_ct;
-    typedef typename stdlib::pedersen_commitment<Composer> pedersen_commitment;
+    typedef typename stdlib::pedersen_commitment<Builder> pedersen_commitment;
 
   public:
     static grumpkin::g1::element pedersen_recover(const fr& left_in, const fr& right_in)
@@ -135,7 +135,7 @@ template <typename Composer> class stdlib_pedersen : public testing::Test {
     static void test_pedersen()
     {
 
-        Composer composer;
+        Builder builder;
 
         fr left_in = fr::random_element();
         fr right_in = fr::random_element();
@@ -148,17 +148,17 @@ template <typename Composer> class stdlib_pedersen : public testing::Test {
             right_in += fr::one();
         }
 
-        fr_ct left = public_witness_ct(&composer, left_in);
-        fr_ct right = witness_ct(&composer, right_in);
+        fr_ct left = public_witness_ct(&builder, left_in);
+        fr_ct right = witness_ct(&builder, right_in);
 
-        composer.fix_witness(left.witness_index, left.get_value());
-        composer.fix_witness(right.witness_index, right.get_value());
+        builder.fix_witness(left.witness_index, left.get_value());
+        builder.fix_witness(right.witness_index, right.get_value());
 
         fr_ct out = pedersen_commitment::compress(left, right);
 
-        info("composer gates = ", composer.get_num_gates());
+        info("num gates = ", builder.get_num_gates());
 
-        bool result = composer.check_circuit();
+        bool result = builder.check_circuit();
         EXPECT_EQ(result, true);
 
         auto hash_output = pedersen_recover(left_in, right_in);
@@ -176,7 +176,7 @@ template <typename Composer> class stdlib_pedersen : public testing::Test {
 
     static void test_pedersen_edge_cases()
     {
-        Composer composer;
+        Builder builder;
 
         fr zero_fr = fr::zero();
         fr one_fr = fr::one();
@@ -184,11 +184,11 @@ template <typename Composer> class stdlib_pedersen : public testing::Test {
         fr r_minus_two_fr = fr::modulus - 2;
         fr r_fr = fr::modulus;
 
-        fr_ct zero = witness_ct(&composer, zero_fr);
-        fr_ct one = witness_ct(&composer, one_fr);
-        fr_ct r_minus_one = witness_ct(&composer, r_minus_one_fr);
-        fr_ct r_minus_two = witness_ct(&composer, r_minus_two_fr);
-        fr_ct r = witness_ct(&composer, r_fr);
+        fr_ct zero = witness_ct(&builder, zero_fr);
+        fr_ct one = witness_ct(&builder, one_fr);
+        fr_ct r_minus_one = witness_ct(&builder, r_minus_one_fr);
+        fr_ct r_minus_two = witness_ct(&builder, r_minus_two_fr);
+        fr_ct r = witness_ct(&builder, r_fr);
 
         fr_ct out_1_with_zero = pedersen_commitment::compress(zero, one);
         fr_ct out_1_with_r = pedersen_commitment::compress(r, one);
@@ -196,9 +196,9 @@ template <typename Composer> class stdlib_pedersen : public testing::Test {
         fr_ct out_with_zero = pedersen_commitment::compress(out_1_with_zero, out_2);
         fr_ct out_with_r = pedersen_commitment::compress(out_1_with_r, out_2);
 
-        info("composer gates = ", composer.get_num_gates());
+        info("num gates = ", builder.get_num_gates());
 
-        bool result = composer.check_circuit();
+        bool result = builder.check_circuit();
         EXPECT_EQ(result, true);
 
         auto hash_output_1_with_zero = pedersen_recover(zero_fr, one_fr);
@@ -242,7 +242,7 @@ template <typename Composer> class stdlib_pedersen : public testing::Test {
 
     static void test_pedersen_large()
     {
-        Composer composer;
+        Builder builder;
 
         fr left_in = fr::random_element();
         fr right_in = fr::random_element();
@@ -253,18 +253,18 @@ template <typename Composer> class stdlib_pedersen : public testing::Test {
         if ((right_in.from_montgomery_form().data[0] & 1) == 0) {
             right_in += fr::one();
         }
-        fr_ct left = witness_ct(&composer, left_in);
-        fr_ct right = witness_ct(&composer, right_in);
+        fr_ct left = witness_ct(&builder, left_in);
+        fr_ct right = witness_ct(&builder, right_in);
 
         for (size_t i = 0; i < 256; ++i) {
             left = pedersen_commitment::compress(left, right);
         }
 
-        composer.set_public_input(left.witness_index);
+        builder.set_public_input(left.witness_index);
 
-        info("composer gates = ", composer.get_num_gates());
+        info("num gates = ", builder.get_num_gates());
 
-        bool result = composer.check_circuit();
+        bool result = builder.check_circuit();
         EXPECT_EQ(result, true);
     }
 
@@ -272,7 +272,7 @@ template <typename Composer> class stdlib_pedersen : public testing::Test {
     {
         const size_t num_input_bytes = 351;
 
-        Composer composer;
+        Builder builder;
 
         std::vector<uint8_t> input;
         input.reserve(num_input_bytes);
@@ -282,20 +282,20 @@ template <typename Composer> class stdlib_pedersen : public testing::Test {
 
         fr expected = crypto::pedersen_commitment::compress_native(input);
 
-        byte_array_ct circuit_input(&composer, input);
+        byte_array_ct circuit_input(&builder, input);
         auto result = pedersen_commitment::compress(circuit_input);
 
         EXPECT_EQ(result.get_value(), expected);
 
-        info("composer gates = ", composer.get_num_gates());
+        info("num gates = ", builder.get_num_gates());
 
-        bool proof_result = composer.check_circuit();
+        bool proof_result = builder.check_circuit();
         EXPECT_EQ(proof_result, true);
     }
 
     static void test_multi_compress()
     {
-        Composer composer;
+        Builder builder;
 
         for (size_t i = 0; i < 7; ++i) {
             std::vector<barretenberg::fr> inputs;
@@ -329,7 +329,7 @@ template <typename Composer> class stdlib_pedersen : public testing::Test {
             }
             std::vector<fr_ct> witnesses;
             for (auto input : inputs) {
-                witnesses.push_back(witness_ct(&composer, input));
+                witnesses.push_back(witness_ct(&builder, input));
             }
 
             barretenberg::fr expected = crypto::pedersen_commitment::compress_native(inputs);
@@ -338,23 +338,23 @@ template <typename Composer> class stdlib_pedersen : public testing::Test {
             EXPECT_EQ(result.get_value(), expected);
         }
 
-        info("composer gates = ", composer.get_num_gates());
+        info("num gates = ", builder.get_num_gates());
 
-        bool proof_result = composer.check_circuit();
+        bool proof_result = builder.check_circuit();
         EXPECT_EQ(proof_result, true);
     }
 
     static void test_compress_eight()
     {
-        Composer composer;
+        Builder builder;
 
         std::vector<grumpkin::fq> inputs;
         inputs.reserve(8);
-        std::vector<stdlib::field_t<Composer>> witness_inputs;
+        std::vector<stdlib::field_t<Builder>> witness_inputs;
 
         for (size_t i = 0; i < 8; ++i) {
             inputs.emplace_back(barretenberg::fr::random_element());
-            witness_inputs.emplace_back(witness_ct(&composer, inputs[i]));
+            witness_inputs.emplace_back(witness_ct(&builder, inputs[i]));
         }
 
         constexpr size_t hash_idx = 10;
@@ -366,17 +366,17 @@ template <typename Composer> class stdlib_pedersen : public testing::Test {
 
     static void test_compress_constants()
     {
-        Composer composer;
+        Builder builder;
 
         std::vector<barretenberg::fr> inputs;
-        std::vector<stdlib::field_t<Composer>> witness_inputs;
+        std::vector<stdlib::field_t<Builder>> witness_inputs;
 
         for (size_t i = 0; i < 8; ++i) {
             inputs.push_back(barretenberg::fr::random_element());
             if (i % 2 == 1) {
-                witness_inputs.push_back(witness_ct(&composer, inputs[i]));
+                witness_inputs.push_back(witness_ct(&builder, inputs[i]));
             } else {
-                witness_inputs.push_back(fr_ct(&composer, inputs[i]));
+                witness_inputs.push_back(fr_ct(&builder, inputs[i]));
             }
         }
 
diff --git a/barretenberg/cpp/src/barretenberg/stdlib/commitment/pedersen/pedersen_plookup.hpp b/barretenberg/cpp/src/barretenberg/stdlib/commitment/pedersen/pedersen_plookup.hpp
index aa74a158774..04e1c9546d5 100644
--- a/barretenberg/cpp/src/barretenberg/stdlib/commitment/pedersen/pedersen_plookup.hpp
+++ b/barretenberg/cpp/src/barretenberg/stdlib/commitment/pedersen/pedersen_plookup.hpp
@@ -7,12 +7,12 @@
 namespace proof_system::plonk {
 namespace stdlib {
 
-template <typename ComposerContext> class pedersen_plookup_commitment {
+template <typename CircuitBuilder> class pedersen_plookup_commitment {
   private:
-    typedef stdlib::field_t<ComposerContext> field_t;
-    typedef stdlib::point<ComposerContext> point;
-    typedef stdlib::packed_byte_array<ComposerContext> packed_byte_array;
-    typedef stdlib::bool_t<ComposerContext> bool_t;
+    typedef stdlib::field_t<CircuitBuilder> field_t;
+    typedef stdlib::point<CircuitBuilder> point;
+    typedef stdlib::packed_byte_array<CircuitBuilder> packed_byte_array;
+    typedef stdlib::bool_t<CircuitBuilder> bool_t;
 
   public:
     static point commit(const std::vector<field_t>& inputs, const size_t hash_index = 0);
diff --git a/barretenberg/cpp/src/barretenberg/stdlib/commitment/pedersen/pedersen_plookup.test.cpp b/barretenberg/cpp/src/barretenberg/stdlib/commitment/pedersen/pedersen_plookup.test.cpp
index 835db53bd9b..6e4de9495c4 100644
--- a/barretenberg/cpp/src/barretenberg/stdlib/commitment/pedersen/pedersen_plookup.test.cpp
+++ b/barretenberg/cpp/src/barretenberg/stdlib/commitment/pedersen/pedersen_plookup.test.cpp
@@ -19,13 +19,13 @@ typedef stdlib::field_t<proof_system::UltraCircuitBuilder> field_ct;
 typedef stdlib::witness_t<proof_system::UltraCircuitBuilder> witness_ct;
 TEST(stdlib_pedersen, test_pedersen_plookup)
 {
-    proof_system::UltraCircuitBuilder composer = proof_system::UltraCircuitBuilder();
+    proof_system::UltraCircuitBuilder builder = proof_system::UltraCircuitBuilder();
 
     fr left_in = fr::random_element();
     fr right_in = fr::random_element();
 
-    field_ct left = witness_ct(&composer, left_in);
-    field_ct right = witness_ct(&composer, right_in);
+    field_ct left = witness_ct(&builder, left_in);
+    field_ct right = witness_ct(&builder, right_in);
 
     field_ct result = stdlib::pedersen_plookup_commitment<proof_system::UltraCircuitBuilder>::compress(left, right);
 
@@ -33,15 +33,15 @@ TEST(stdlib_pedersen, test_pedersen_plookup)
 
     EXPECT_EQ(result.get_value(), expected);
 
-    info("composer gates = ", composer.get_num_gates());
+    info("num gates = ", builder.get_num_gates());
 
-    bool proof_result = composer.check_circuit();
+    bool proof_result = builder.check_circuit();
     EXPECT_EQ(proof_result, true);
 }
 
 TEST(stdlib_pedersen, test_compress_many_plookup)
 {
-    proof_system::UltraCircuitBuilder composer = proof_system::UltraCircuitBuilder();
+    proof_system::UltraCircuitBuilder builder = proof_system::UltraCircuitBuilder();
 
     std::vector<fr> input_values{
         fr::random_element(), fr::random_element(), fr::random_element(),
@@ -49,7 +49,7 @@ TEST(stdlib_pedersen, test_compress_many_plookup)
     };
     std::vector<field_ct> inputs;
     for (const auto& input : input_values) {
-        inputs.emplace_back(witness_ct(&composer, input));
+        inputs.emplace_back(witness_ct(&builder, input));
     }
 
     const size_t hash_idx = 20;
@@ -61,15 +61,15 @@ TEST(stdlib_pedersen, test_compress_many_plookup)
 
     EXPECT_EQ(result.get_value(), expected);
 
-    info("composer gates = ", composer.get_num_gates());
+    info("num gates = ", builder.get_num_gates());
 
-    bool proof_result = composer.check_circuit();
+    bool proof_result = builder.check_circuit();
     EXPECT_EQ(proof_result, true);
 }
 
 TEST(stdlib_pedersen, test_merkle_damgard_compress_plookup)
 {
-    proof_system::UltraCircuitBuilder composer = proof_system::UltraCircuitBuilder();
+    proof_system::UltraCircuitBuilder builder = proof_system::UltraCircuitBuilder();
 
     std::vector<fr> input_values{
         fr::random_element(), fr::random_element(), fr::random_element(),
@@ -77,9 +77,9 @@ TEST(stdlib_pedersen, test_merkle_damgard_compress_plookup)
     };
     std::vector<field_ct> inputs;
     for (const auto& input : input_values) {
-        inputs.emplace_back(witness_ct(&composer, input));
+        inputs.emplace_back(witness_ct(&builder, input));
     }
-    field_ct iv = witness_ct(&composer, fr(10));
+    field_ct iv = witness_ct(&builder, fr(10));
 
     field_ct result =
         stdlib::pedersen_plookup_commitment<proof_system::UltraCircuitBuilder>::merkle_damgard_compress(inputs, iv).x;
@@ -88,15 +88,15 @@ TEST(stdlib_pedersen, test_merkle_damgard_compress_plookup)
 
     EXPECT_EQ(result.get_value(), expected.normalize().x);
 
-    info("composer gates = ", composer.get_num_gates());
+    info("num gates = ", builder.get_num_gates());
 
-    bool proof_result = composer.check_circuit();
+    bool proof_result = builder.check_circuit();
     EXPECT_EQ(proof_result, true);
 }
 
 TEST(stdlib_pedersen, test_merkle_damgard_compress_multiple_iv_plookup)
 {
-    proof_system::UltraCircuitBuilder composer = proof_system::UltraCircuitBuilder();
+    proof_system::UltraCircuitBuilder builder = proof_system::UltraCircuitBuilder();
 
     const size_t m = 10;
     std::vector<fr> input_values;
@@ -109,8 +109,8 @@ TEST(stdlib_pedersen, test_merkle_damgard_compress_multiple_iv_plookup)
     std::vector<field_ct> inputs;
     std::vector<field_ct> ivs;
     for (size_t i = 0; i < m; i++) {
-        inputs.emplace_back(witness_ct(&composer, input_values[i]));
-        ivs.emplace_back(witness_ct(&composer, fr(iv_values[i])));
+        inputs.emplace_back(witness_ct(&builder, input_values[i]));
+        ivs.emplace_back(witness_ct(&builder, fr(iv_values[i])));
     }
 
     field_ct result =
@@ -120,15 +120,15 @@ TEST(stdlib_pedersen, test_merkle_damgard_compress_multiple_iv_plookup)
 
     EXPECT_EQ(result.get_value(), expected.normalize().x);
 
-    info("composer gates = ", composer.get_num_gates());
+    info("num gates = ", builder.get_num_gates());
 
-    bool proof_result = composer.check_circuit();
+    bool proof_result = builder.check_circuit();
     EXPECT_EQ(proof_result, true);
 }
 
 TEST(stdlib_pedersen, test_merkle_damgard_tree_compress_plookup)
 {
-    proof_system::UltraCircuitBuilder composer = proof_system::UltraCircuitBuilder();
+    proof_system::UltraCircuitBuilder builder = proof_system::UltraCircuitBuilder();
 
     const size_t m = 16;
     std::vector<fr> input_values;
@@ -141,8 +141,8 @@ TEST(stdlib_pedersen, test_merkle_damgard_tree_compress_plookup)
     std::vector<field_ct> inputs;
     std::vector<field_ct> ivs;
     for (size_t i = 0; i < m; i++) {
-        inputs.emplace_back(witness_ct(&composer, input_values[i]));
-        ivs.emplace_back(witness_ct(&composer, fr(iv_values[i])));
+        inputs.emplace_back(witness_ct(&builder, input_values[i]));
+        ivs.emplace_back(witness_ct(&builder, fr(iv_values[i])));
     }
 
     field_ct result =
@@ -154,9 +154,9 @@ TEST(stdlib_pedersen, test_merkle_damgard_tree_compress_plookup)
 
     EXPECT_EQ(result.get_value(), expected.normalize().x);
 
-    info("composer gates = ", composer.get_num_gates());
+    info("num gates = ", builder.get_num_gates());
 
-    bool proof_result = composer.check_circuit();
+    bool proof_result = builder.check_circuit();
     EXPECT_EQ(proof_result, true);
 }
 
diff --git a/barretenberg/cpp/src/barretenberg/stdlib/encryption/aes128/aes128.cpp b/barretenberg/cpp/src/barretenberg/stdlib/encryption/aes128/aes128.cpp
index c9193f6c5f9..b1d8c135373 100644
--- a/barretenberg/cpp/src/barretenberg/stdlib/encryption/aes128/aes128.cpp
+++ b/barretenberg/cpp/src/barretenberg/stdlib/encryption/aes128/aes128.cpp
@@ -13,29 +13,29 @@ using namespace barretenberg;
 namespace proof_system::plonk {
 namespace stdlib {
 namespace aes128 {
-template <typename Composer> using byte_pair = std::pair<field_t<Composer>, field_t<Composer>>;
+template <typename Builder> using byte_pair = std::pair<field_t<Builder>, field_t<Builder>>;
 using namespace plookup;
 
 constexpr uint32_t AES128_BASE = 9;
 
-template <typename Composer> field_t<Composer> normalize_sparse_form(Composer*, field_t<Composer>& byte)
+template <typename Builder> field_t<Builder> normalize_sparse_form(Builder*, field_t<Builder>& byte)
 {
-    auto result = plookup_read<Composer>::read_from_1_to_2_table(AES_NORMALIZE, byte);
+    auto result = plookup_read<Builder>::read_from_1_to_2_table(AES_NORMALIZE, byte);
     return result;
 }
 
-template <typename Composer> byte_pair<Composer> apply_aes_sbox_map(Composer*, field_t<Composer>& input)
+template <typename Builder> byte_pair<Builder> apply_aes_sbox_map(Builder*, field_t<Builder>& input)
 {
-    return plookup_read<Composer>::read_pair_from_table(AES_SBOX, input);
+    return plookup_read<Builder>::read_pair_from_table(AES_SBOX, input);
 }
 
-template <typename Composer>
-std::array<field_t<Composer>, 16> convert_into_sparse_bytes(Composer*, const field_t<Composer>& block_data)
+template <typename Builder>
+std::array<field_t<Builder>, 16> convert_into_sparse_bytes(Builder*, const field_t<Builder>& block_data)
 {
     // `block_data` must be a 128 bit variable
-    std::array<field_t<Composer>, 16> sparse_bytes;
+    std::array<field_t<Builder>, 16> sparse_bytes;
 
-    auto lookup = plookup_read<Composer>::get_lookup_accumulators(AES_INPUT, block_data);
+    auto lookup = plookup_read<Builder>::get_lookup_accumulators(AES_INPUT, block_data);
 
     for (size_t i = 0; i < 16; ++i) {
         sparse_bytes[15 - i] = lookup[ColumnIdx::C2][i];
@@ -44,9 +44,9 @@ std::array<field_t<Composer>, 16> convert_into_sparse_bytes(Composer*, const fie
     return sparse_bytes;
 }
 
-template <typename Composer> field_t<Composer> convert_from_sparse_bytes(Composer* ctx, field_t<Composer>* sparse_bytes)
+template <typename Builder> field_t<Builder> convert_from_sparse_bytes(Builder* ctx, field_t<Builder>* sparse_bytes)
 {
-    std::array<field_t<Composer>, 16> bytes;
+    std::array<field_t<Builder>, 16> bytes;
 
     uint256_t accumulator = 0;
     for (size_t i = 0; i < 16; ++i) {
@@ -56,9 +56,9 @@ template <typename Composer> field_t<Composer> convert_from_sparse_bytes(Compose
         accumulator += (byte);
     }
 
-    field_t<Composer> result = witness_t(ctx, fr(accumulator));
+    field_t<Builder> result = witness_t(ctx, fr(accumulator));
 
-    const auto lookup = plookup_read<Composer>::get_lookup_accumulators(AES_INPUT, result);
+    const auto lookup = plookup_read<Builder>::get_lookup_accumulators(AES_INPUT, result);
 
     for (size_t i = 0; i < 16; ++i) {
         sparse_bytes[15 - i].assert_equal(lookup[ColumnIdx::C2][i]);
@@ -67,10 +67,10 @@ template <typename Composer> field_t<Composer> convert_from_sparse_bytes(Compose
     return result;
 }
 
-template <typename Composer> std::array<field_t<Composer>, 176> expand_key(Composer* ctx, const field_t<Composer>& key)
+template <typename Builder> std::array<field_t<Builder>, 176> expand_key(Builder* ctx, const field_t<Builder>& key)
 {
     constexpr uint8_t round_constants[11] = { 0x8d, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x1b, 0x36 };
-    std::array<field_t<Composer>, 11> sparse_round_constants{
+    std::array<field_t<Builder>, 11> sparse_round_constants{
         field_t(ctx, fr(numeric::map_into_sparse_form<AES128_BASE>(round_constants[0]))),
         field_t(ctx, fr(numeric::map_into_sparse_form<AES128_BASE>(round_constants[1]))),
         field_t(ctx, fr(numeric::map_into_sparse_form<AES128_BASE>(round_constants[2]))),
@@ -84,10 +84,10 @@ template <typename Composer> std::array<field_t<Composer>, 176> expand_key(Compo
         field_t(ctx, fr(numeric::map_into_sparse_form<AES128_BASE>(round_constants[10]))),
     };
 
-    std::array<field_t<Composer>, 176> round_key{};
+    std::array<field_t<Builder>, 176> round_key{};
     const auto sparse_key = convert_into_sparse_bytes(ctx, key);
 
-    field_t<Composer> temp[4]{};
+    field_t<Builder> temp[4]{};
     uint64_t temp_add_counts[4]{};
     uint64_t add_counts[176]{};
     for (size_t i = 0; i < 176; ++i) {
@@ -161,9 +161,9 @@ template <typename Composer> std::array<field_t<Composer>, 176> expand_key(Compo
     return round_key;
 }
 
-template <typename Composer> void shift_rows(byte_pair<Composer>* state)
+template <typename Builder> void shift_rows(byte_pair<Builder>* state)
 {
-    byte_pair<Composer> temp = state[1];
+    byte_pair<Builder> temp = state[1];
     state[1] = state[5];
     state[5] = state[9];
     state[9] = state[13];
@@ -183,8 +183,8 @@ template <typename Composer> void shift_rows(byte_pair<Composer>* state)
     state[7] = temp;
 }
 
-template <typename Composer>
-void mix_column_and_add_round_key(byte_pair<Composer>* column_pairs, field_t<Composer>* round_key, uint64_t round)
+template <typename Builder>
+void mix_column_and_add_round_key(byte_pair<Builder>* column_pairs, field_t<Builder>* round_key, uint64_t round)
 {
 
     auto t0 = column_pairs[0].first.add_two(column_pairs[3].first, column_pairs[1].second);
@@ -201,8 +201,8 @@ void mix_column_and_add_round_key(byte_pair<Composer>* column_pairs, field_t<Com
     column_pairs[3].first = r3 + round_key[(round * 16U) + 3];
 }
 
-template <typename Composer>
-void mix_columns_and_add_round_key(byte_pair<Composer>* state_pairs, field_t<Composer>* round_key, uint64_t round)
+template <typename Builder>
+void mix_columns_and_add_round_key(byte_pair<Builder>* state_pairs, field_t<Builder>* round_key, uint64_t round)
 {
     mix_column_and_add_round_key(state_pairs, round_key, round);
     mix_column_and_add_round_key(state_pairs + 4, round_key + 4, round);
@@ -210,15 +210,15 @@ void mix_columns_and_add_round_key(byte_pair<Composer>* state_pairs, field_t<Com
     mix_column_and_add_round_key(state_pairs + 12, round_key + 12, round);
 }
 
-template <typename Composer> void sub_bytes(Composer* ctx, byte_pair<Composer>* state_pairs)
+template <typename Builder> void sub_bytes(Builder* ctx, byte_pair<Builder>* state_pairs)
 {
     for (size_t i = 0; i < 16; ++i) {
         state_pairs[i] = apply_aes_sbox_map(ctx, state_pairs[i].first);
     }
 }
 
-template <typename Composer>
-void add_round_key(byte_pair<Composer>* sparse_state, field_t<Composer>* sparse_round_key, uint64_t round)
+template <typename Builder>
+void add_round_key(byte_pair<Builder>* sparse_state, field_t<Builder>* sparse_round_key, uint64_t round)
 {
     for (size_t i = 0; i < 16; i += 4) {
         for (size_t j = 0; j < 4; ++j) {
@@ -227,15 +227,15 @@ void add_round_key(byte_pair<Composer>* sparse_state, field_t<Composer>* sparse_
     }
 }
 
-template <typename Composer> void xor_with_iv(byte_pair<Composer>* state, field_t<Composer>* iv)
+template <typename Builder> void xor_with_iv(byte_pair<Builder>* state, field_t<Builder>* iv)
 {
     for (size_t i = 0; i < 16; ++i) {
         state[i].first += iv[i];
     }
 }
 
-template <typename Composer>
-void aes128_cipher(Composer* ctx, byte_pair<Composer>* state, field_t<Composer>* sparse_round_key)
+template <typename Builder>
+void aes128_cipher(Builder* ctx, byte_pair<Builder>* state, field_t<Builder>* sparse_round_key)
 {
     add_round_key(state, sparse_round_key, 0);
     for (size_t i = 0; i < 16; ++i) {
@@ -256,18 +256,18 @@ void aes128_cipher(Composer* ctx, byte_pair<Composer>* state, field_t<Composer>*
     add_round_key(state, sparse_round_key, 10);
 }
 
-template <typename Composer>
-std::vector<field_t<Composer>> encrypt_buffer_cbc(const std::vector<field_t<Composer>>& input,
-                                                  const field_t<Composer>& iv,
-                                                  const field_t<Composer>& key)
+template <typename Builder>
+std::vector<field_t<Builder>> encrypt_buffer_cbc(const std::vector<field_t<Builder>>& input,
+                                                 const field_t<Builder>& iv,
+                                                 const field_t<Builder>& key)
 {
-    Composer* ctx = key.get_context();
+    Builder* ctx = key.get_context();
 
     auto round_key = expand_key(ctx, key);
 
     const size_t num_blocks = input.size();
 
-    std::vector<byte_pair<Composer>> sparse_state;
+    std::vector<byte_pair<Builder>> sparse_state;
     for (size_t i = 0; i < num_blocks; ++i) {
         auto bytes = convert_into_sparse_bytes(ctx, input[i]);
         for (const auto& byte : bytes) {
@@ -278,7 +278,7 @@ std::vector<field_t<Composer>> encrypt_buffer_cbc(const std::vector<field_t<Comp
     auto sparse_iv = convert_into_sparse_bytes(ctx, iv);
 
     for (size_t i = 0; i < num_blocks; ++i) {
-        byte_pair<Composer>* round_state = &sparse_state[i * 16];
+        byte_pair<Builder>* round_state = &sparse_state[i * 16];
         xor_with_iv(round_state, &sparse_iv[0]);
         aes128_cipher(ctx, round_state, &round_key[0]);
 
@@ -287,12 +287,12 @@ std::vector<field_t<Composer>> encrypt_buffer_cbc(const std::vector<field_t<Comp
         }
     }
 
-    std::vector<field_t<Composer>> sparse_output;
+    std::vector<field_t<Builder>> sparse_output;
     for (auto& element : sparse_state) {
         sparse_output.push_back(normalize_sparse_form(ctx, element.first));
     }
 
-    std::vector<field_t<Composer>> output;
+    std::vector<field_t<Builder>> output;
     for (size_t i = 0; i < num_blocks; ++i) {
         output.push_back(convert_from_sparse_bytes(ctx, &sparse_output[i * 16]));
     }
diff --git a/barretenberg/cpp/src/barretenberg/stdlib/encryption/aes128/aes128.hpp b/barretenberg/cpp/src/barretenberg/stdlib/encryption/aes128/aes128.hpp
index 28b4f4057db..7e8d4332b4a 100644
--- a/barretenberg/cpp/src/barretenberg/stdlib/encryption/aes128/aes128.hpp
+++ b/barretenberg/cpp/src/barretenberg/stdlib/encryption/aes128/aes128.hpp
@@ -12,10 +12,10 @@ namespace stdlib {
 
 namespace aes128 {
 
-template <typename Composer>
-std::vector<stdlib::field_t<Composer>> encrypt_buffer_cbc(const std::vector<stdlib::field_t<Composer>>& input,
-                                                          const stdlib::field_t<Composer>& iv,
-                                                          const stdlib::field_t<Composer>& key);
+template <typename Builder>
+std::vector<stdlib::field_t<Builder>> encrypt_buffer_cbc(const std::vector<stdlib::field_t<Builder>>& input,
+                                                         const stdlib::field_t<Builder>& iv,
+                                                         const stdlib::field_t<Builder>& key);
 
 } // namespace aes128
 } // namespace stdlib
diff --git a/barretenberg/cpp/src/barretenberg/stdlib/encryption/aes128/aes128.test.cpp b/barretenberg/cpp/src/barretenberg/stdlib/encryption/aes128/aes128.test.cpp
index 1d7c131c286..9ce03d388a6 100644
--- a/barretenberg/cpp/src/barretenberg/stdlib/encryption/aes128/aes128.test.cpp
+++ b/barretenberg/cpp/src/barretenberg/stdlib/encryption/aes128/aes128.test.cpp
@@ -32,17 +32,17 @@ TEST(stdlib_aes128, encrypt_64_bytes)
         return converted;
     };
 
-    auto composer = proof_system::UltraCircuitBuilder();
+    auto builder = proof_system::UltraCircuitBuilder();
 
     std::vector<field_pt> in_field{
-        witness_pt(&composer, fr(convert_bytes(in))),
-        witness_pt(&composer, fr(convert_bytes(in + 16))),
-        witness_pt(&composer, fr(convert_bytes(in + 32))),
-        witness_pt(&composer, fr(convert_bytes(in + 48))),
+        witness_pt(&builder, fr(convert_bytes(in))),
+        witness_pt(&builder, fr(convert_bytes(in + 16))),
+        witness_pt(&builder, fr(convert_bytes(in + 32))),
+        witness_pt(&builder, fr(convert_bytes(in + 48))),
     };
 
-    field_pt key_field(witness_pt(&composer, fr(convert_bytes(key))));
-    field_pt iv_field(witness_pt(&composer, fr(convert_bytes(iv))));
+    field_pt key_field(witness_pt(&builder, fr(convert_bytes(key))));
+    field_pt iv_field(witness_pt(&builder, fr(convert_bytes(iv))));
 
     std::vector<fr> expected{
         convert_bytes(out), convert_bytes(out + 16), convert_bytes(out + 32), convert_bytes(out + 48)
@@ -54,8 +54,8 @@ TEST(stdlib_aes128, encrypt_64_bytes)
         EXPECT_EQ(result[i].get_value(), expected[i]);
     }
 
-    std::cout << "composer gates = " << composer.get_num_gates() << std::endl;
+    std::cout << "num gates = " << builder.get_num_gates() << std::endl;
 
-    bool proof_result = composer.check_circuit();
+    bool proof_result = builder.check_circuit();
     EXPECT_EQ(proof_result, true);
 }
diff --git a/barretenberg/cpp/src/barretenberg/stdlib/encryption/ecdsa/ecdsa.hpp b/barretenberg/cpp/src/barretenberg/stdlib/encryption/ecdsa/ecdsa.hpp
index 8dffc2afb01..c01b7d9d08a 100644
--- a/barretenberg/cpp/src/barretenberg/stdlib/encryption/ecdsa/ecdsa.hpp
+++ b/barretenberg/cpp/src/barretenberg/stdlib/encryption/ecdsa/ecdsa.hpp
@@ -8,35 +8,34 @@ namespace proof_system::plonk {
 namespace stdlib {
 namespace ecdsa {
 
-template <typename Composer> struct signature {
-    stdlib::byte_array<Composer> r;
-    stdlib::byte_array<Composer> s;
-    stdlib::uint8<Composer> v;
+template <typename Builder> struct signature {
+    stdlib::byte_array<Builder> r;
+    stdlib::byte_array<Builder> s;
+    stdlib::uint8<Builder> v;
 };
 
-template <typename Composer, typename Curve, typename Fq, typename Fr, typename G1>
-bool_t<Composer> verify_signature(const stdlib::byte_array<Composer>& message,
-                                  const G1& public_key,
-                                  const signature<Composer>& sig);
+template <typename Builder, typename Curve, typename Fq, typename Fr, typename G1>
+bool_t<Builder> verify_signature(const stdlib::byte_array<Builder>& message,
+                                 const G1& public_key,
+                                 const signature<Builder>& sig);
 
-template <typename Composer, typename Curve, typename Fq, typename Fr, typename G1>
-bool_t<Composer> verify_signature_noassert(const stdlib::byte_array<Composer>& message,
-                                           const G1& public_key,
-                                           const signature<Composer>& sig);
-template <typename Composer, typename Curve, typename Fq, typename Fr, typename G1>
-bool_t<Composer> verify_signature_prehashed_message_noassert(const stdlib::byte_array<Composer>& hashed_message,
-                                                             const G1& public_key,
-                                                             const signature<Composer>& sig);
+template <typename Builder, typename Curve, typename Fq, typename Fr, typename G1>
+bool_t<Builder> verify_signature_noassert(const stdlib::byte_array<Builder>& message,
+                                          const G1& public_key,
+                                          const signature<Builder>& sig);
+template <typename Builder, typename Curve, typename Fq, typename Fr, typename G1>
+bool_t<Builder> verify_signature_prehashed_message_noassert(const stdlib::byte_array<Builder>& hashed_message,
+                                                            const G1& public_key,
+                                                            const signature<Builder>& sig);
 
-template <typename Composer>
-static signature<Composer> from_witness(Composer* ctx, const crypto::ecdsa::signature& input)
+template <typename Builder> static signature<Builder> from_witness(Builder* ctx, const crypto::ecdsa::signature& input)
 {
     std::vector<uint8_t> r_vec(std::begin(input.r), std::end(input.r));
     std::vector<uint8_t> s_vec(std::begin(input.s), std::end(input.s));
-    stdlib::byte_array<Composer> r(ctx, r_vec);
-    stdlib::byte_array<Composer> s(ctx, s_vec);
-    stdlib::uint8<Composer> v(ctx, input.v);
-    signature<Composer> out;
+    stdlib::byte_array<Builder> r(ctx, r_vec);
+    stdlib::byte_array<Builder> s(ctx, s_vec);
+    stdlib::uint8<Builder> v(ctx, input.v);
+    signature<Builder> out;
     out.r = r;
     out.s = s;
     out.v = v;
diff --git a/barretenberg/cpp/src/barretenberg/stdlib/encryption/ecdsa/ecdsa.test.cpp b/barretenberg/cpp/src/barretenberg/stdlib/encryption/ecdsa/ecdsa.test.cpp
index 9105464fd52..a84fe113e1f 100644
--- a/barretenberg/cpp/src/barretenberg/stdlib/encryption/ecdsa/ecdsa.test.cpp
+++ b/barretenberg/cpp/src/barretenberg/stdlib/encryption/ecdsa/ecdsa.test.cpp
@@ -10,13 +10,13 @@ using namespace barretenberg;
 using namespace proof_system::plonk;
 
 namespace test_stdlib_ecdsa {
-using Composer = proof_system::UltraCircuitBuilder;
-using curve = stdlib::secp256k1<Composer>;
-using curveR1 = stdlib::secp256r1<Composer>;
+using Builder = proof_system::UltraCircuitBuilder;
+using curve = stdlib::secp256k1<Builder>;
+using curveR1 = stdlib::secp256r1<Builder>;
 
 TEST(stdlib_ecdsa, verify_signature)
 {
-    Composer composer = Composer();
+    Builder builder = Builder();
 
     // whaaablaghaaglerijgeriij
     std::string message_string = "Instructions unclear, ask again later.";
@@ -32,34 +32,33 @@ TEST(stdlib_ecdsa, verify_signature)
         message_string, account.public_key, signature);
     EXPECT_EQ(first_result, true);
 
-    curve::g1_bigfr_ct public_key = curve::g1_bigfr_ct::from_witness(&composer, account.public_key);
+    curve::g1_bigfr_ct public_key = curve::g1_bigfr_ct::from_witness(&builder, account.public_key);
 
     std::vector<uint8_t> rr(signature.r.begin(), signature.r.end());
     std::vector<uint8_t> ss(signature.s.begin(), signature.s.end());
     uint8_t vv = signature.v;
 
-    stdlib::ecdsa::signature<Composer> sig{ curve::byte_array_ct(&composer, rr),
-                                            curve::byte_array_ct(&composer, ss),
-                                            stdlib::uint8<Composer>(&composer, vv) };
+    stdlib::ecdsa::signature<Builder> sig{ curve::byte_array_ct(&builder, rr),
+                                           curve::byte_array_ct(&builder, ss),
+                                           stdlib::uint8<Builder>(&builder, vv) };
 
-    curve::byte_array_ct message(&composer, message_string);
+    curve::byte_array_ct message(&builder, message_string);
 
     curve::bool_ct signature_result =
-        stdlib::ecdsa::verify_signature<Composer, curve, curve::fq_ct, curve::bigfr_ct, curve::g1_bigfr_ct>(
+        stdlib::ecdsa::verify_signature<Builder, curve, curve::fq_ct, curve::bigfr_ct, curve::g1_bigfr_ct>(
             message, public_key, sig);
 
     EXPECT_EQ(signature_result.get_value(), true);
 
-    std::cerr << "composer gates = " << composer.get_num_gates() << std::endl;
-    benchmark_info(
-        Composer::NAME_STRING, "ECDSA", "Signature Verification Test", "Gate Count", composer.get_num_gates());
-    bool proof_result = composer.check_circuit();
+    std::cerr << "num gates = " << builder.get_num_gates() << std::endl;
+    benchmark_info(Builder::NAME_STRING, "ECDSA", "Signature Verification Test", "Gate Count", builder.get_num_gates());
+    bool proof_result = builder.check_circuit();
     EXPECT_EQ(proof_result, true);
 }
 
 TEST(stdlib_ecdsa, verify_r1_signature)
 {
-    Composer composer = Composer();
+    Builder builder = Builder();
 
     std::string message_string = "Instructions unclear, ask again later.";
 
@@ -75,34 +74,33 @@ TEST(stdlib_ecdsa, verify_r1_signature)
         message_string, account.public_key, signature);
     EXPECT_EQ(first_result, true);
 
-    curveR1::g1_bigfr_ct public_key = curveR1::g1_bigfr_ct::from_witness(&composer, account.public_key);
+    curveR1::g1_bigfr_ct public_key = curveR1::g1_bigfr_ct::from_witness(&builder, account.public_key);
 
     std::vector<uint8_t> rr(signature.r.begin(), signature.r.end());
     std::vector<uint8_t> ss(signature.s.begin(), signature.s.end());
     uint8_t vv = signature.v;
 
-    stdlib::ecdsa::signature<Composer> sig{ curveR1::byte_array_ct(&composer, rr),
-                                            curveR1::byte_array_ct(&composer, ss),
-                                            stdlib::uint8<Composer>(&composer, vv) };
+    stdlib::ecdsa::signature<Builder> sig{ curveR1::byte_array_ct(&builder, rr),
+                                           curveR1::byte_array_ct(&builder, ss),
+                                           stdlib::uint8<Builder>(&builder, vv) };
 
-    curveR1::byte_array_ct message(&composer, message_string);
+    curveR1::byte_array_ct message(&builder, message_string);
 
     curveR1::bool_ct signature_result =
-        stdlib::ecdsa::verify_signature<Composer, curveR1, curveR1::fq_ct, curveR1::bigfr_ct, curveR1::g1_bigfr_ct>(
+        stdlib::ecdsa::verify_signature<Builder, curveR1, curveR1::fq_ct, curveR1::bigfr_ct, curveR1::g1_bigfr_ct>(
             message, public_key, sig);
 
     EXPECT_EQ(signature_result.get_value(), true);
 
-    std::cerr << "composer gates = " << composer.get_num_gates() << std::endl;
-    benchmark_info(
-        Composer::NAME_STRING, "ECDSA", "Signature Verification Test", "Gate Count", composer.get_num_gates());
-    bool proof_result = composer.check_circuit();
+    std::cerr << "num gates = " << builder.get_num_gates() << std::endl;
+    benchmark_info(Builder::NAME_STRING, "ECDSA", "Signature Verification Test", "Gate Count", builder.get_num_gates());
+    bool proof_result = builder.check_circuit();
     EXPECT_EQ(proof_result, true);
 }
 
 TEST(stdlib_ecdsa, verify_signature_noassert_succeed)
 {
-    Composer composer = Composer();
+    Builder builder = Builder();
 
     // whaaablaghaaglerijgeriij
     std::string message_string = "Instructions unclear, ask again later.";
@@ -118,36 +116,35 @@ TEST(stdlib_ecdsa, verify_signature_noassert_succeed)
         message_string, account.public_key, signature);
     EXPECT_EQ(first_result, true);
 
-    curve::g1_bigfr_ct public_key = curve::g1_bigfr_ct::from_witness(&composer, account.public_key);
+    curve::g1_bigfr_ct public_key = curve::g1_bigfr_ct::from_witness(&builder, account.public_key);
 
     std::vector<uint8_t> rr(signature.r.begin(), signature.r.end());
     std::vector<uint8_t> ss(signature.s.begin(), signature.s.end());
     uint8_t vv = signature.v;
 
-    stdlib::ecdsa::signature<Composer> sig{
-        curve::byte_array_ct(&composer, rr),
-        curve::byte_array_ct(&composer, ss),
-        stdlib::uint8<Composer>(&composer, vv),
+    stdlib::ecdsa::signature<Builder> sig{
+        curve::byte_array_ct(&builder, rr),
+        curve::byte_array_ct(&builder, ss),
+        stdlib::uint8<Builder>(&builder, vv),
     };
 
-    curve::byte_array_ct message(&composer, message_string);
+    curve::byte_array_ct message(&builder, message_string);
 
     curve::bool_ct signature_result =
-        stdlib::ecdsa::verify_signature_noassert<Composer, curve, curve::fq_ct, curve::bigfr_ct, curve::g1_bigfr_ct>(
+        stdlib::ecdsa::verify_signature_noassert<Builder, curve, curve::fq_ct, curve::bigfr_ct, curve::g1_bigfr_ct>(
             message, public_key, sig);
 
     EXPECT_EQ(signature_result.get_value(), true);
 
-    std::cerr << "composer gates = " << composer.get_num_gates() << std::endl;
-    benchmark_info(
-        Composer::NAME_STRING, "ECDSA", "Signature Verification Test", "Gate Count", composer.get_num_gates());
-    bool proof_result = composer.check_circuit();
+    std::cerr << "num gates = " << builder.get_num_gates() << std::endl;
+    benchmark_info(Builder::NAME_STRING, "ECDSA", "Signature Verification Test", "Gate Count", builder.get_num_gates());
+    bool proof_result = builder.check_circuit();
     EXPECT_EQ(proof_result, true);
 }
 
 TEST(stdlib_ecdsa, verify_signature_noassert_fail)
 {
-    Composer composer = Composer();
+    Builder builder = Builder();
 
     // whaaablaghaaglerijgeriij
     std::string message_string = "Instructions unclear, ask again later.";
@@ -166,27 +163,24 @@ TEST(stdlib_ecdsa, verify_signature_noassert_fail)
         message_string, account.public_key, signature);
     EXPECT_EQ(first_result, false);
 
-    curve::g1_bigfr_ct public_key = curve::g1_bigfr_ct::from_witness(&composer, account.public_key);
+    curve::g1_bigfr_ct public_key = curve::g1_bigfr_ct::from_witness(&builder, account.public_key);
 
     std::vector<uint8_t> rr(signature.r.begin(), signature.r.end());
     std::vector<uint8_t> ss(signature.s.begin(), signature.s.end());
 
-    stdlib::ecdsa::signature<Composer> sig{ curve::byte_array_ct(&composer, rr),
-                                            curve::byte_array_ct(&composer, ss),
-                                            27 };
+    stdlib::ecdsa::signature<Builder> sig{ curve::byte_array_ct(&builder, rr), curve::byte_array_ct(&builder, ss), 27 };
 
-    curve::byte_array_ct message(&composer, message_string);
+    curve::byte_array_ct message(&builder, message_string);
 
     curve::bool_ct signature_result =
-        stdlib::ecdsa::verify_signature_noassert<Composer, curve, curve::fq_ct, curve::bigfr_ct, curve::g1_bigfr_ct>(
+        stdlib::ecdsa::verify_signature_noassert<Builder, curve, curve::fq_ct, curve::bigfr_ct, curve::g1_bigfr_ct>(
             message, public_key, sig);
 
     EXPECT_EQ(signature_result.get_value(), false);
 
-    std::cerr << "composer gates = " << composer.get_num_gates() << std::endl;
-    benchmark_info(
-        Composer::NAME_STRING, "ECDSA", "Signature Verification Test", "Gate Count", composer.get_num_gates());
-    bool proof_result = composer.check_circuit();
+    std::cerr << "num gates = " << builder.get_num_gates() << std::endl;
+    benchmark_info(Builder::NAME_STRING, "ECDSA", "Signature Verification Test", "Gate Count", builder.get_num_gates());
+    bool proof_result = builder.check_circuit();
     EXPECT_EQ(proof_result, true);
 }
 } // namespace test_stdlib_ecdsa
diff --git a/barretenberg/cpp/src/barretenberg/stdlib/encryption/ecdsa/ecdsa_impl.hpp b/barretenberg/cpp/src/barretenberg/stdlib/encryption/ecdsa/ecdsa_impl.hpp
index 7e709ff12dd..e1975a51423 100644
--- a/barretenberg/cpp/src/barretenberg/stdlib/encryption/ecdsa/ecdsa_impl.hpp
+++ b/barretenberg/cpp/src/barretenberg/stdlib/encryption/ecdsa/ecdsa_impl.hpp
@@ -10,7 +10,7 @@ namespace ecdsa {
 /**
  * @brief Verify ECDSA signature. Produces unsatisfiable constraints if signature fails
  *
- * @tparam Composer
+ * @tparam Builder
  * @tparam Curve
  * @tparam Fq
  * @tparam Fr
@@ -18,14 +18,14 @@ namespace ecdsa {
  * @param message
  * @param public_key
  * @param sig
- * @return bool_t<Composer>
+ * @return bool_t<Builder>
  */
-template <typename Composer, typename Curve, typename Fq, typename Fr, typename G1>
-bool_t<Composer> verify_signature(const stdlib::byte_array<Composer>& message,
-                                  const G1& public_key,
-                                  const signature<Composer>& sig)
+template <typename Builder, typename Curve, typename Fq, typename Fr, typename G1>
+bool_t<Builder> verify_signature(const stdlib::byte_array<Builder>& message,
+                                 const G1& public_key,
+                                 const signature<Builder>& sig)
 {
-    Composer* ctx = message.get_context() ? message.get_context() : public_key.x.context;
+    Builder* ctx = message.get_context() ? message.get_context() : public_key.x.context;
 
     /**
      * Check if recovery id v is either 27 ot 28.
@@ -55,11 +55,11 @@ bool_t<Composer> verify_signature(const stdlib::byte_array<Composer>& message,
      *
      */
     // Note: This check is also present in the _noassert variation of this method.
-    field_t<Composer>(sig.v).assert_is_in_set({ field_t<Composer>(27), field_t<Composer>(28) },
-                                              "signature is non-standard");
+    field_t<Builder>(sig.v).assert_is_in_set({ field_t<Builder>(27), field_t<Builder>(28) },
+                                             "signature is non-standard");
 
-    stdlib::byte_array<Composer> hashed_message =
-        static_cast<stdlib::byte_array<Composer>>(stdlib::sha256<Composer>(message));
+    stdlib::byte_array<Builder> hashed_message =
+        static_cast<stdlib::byte_array<Builder>>(stdlib::sha256<Builder>(message));
 
     Fr z(hashed_message);
     z.assert_is_in_field();
@@ -87,7 +87,7 @@ bool_t<Composer> verify_signature(const stdlib::byte_array<Composer>& message,
     // TODO(Cody): Having Plookup should not determine which curve is used.
     // Use special plookup secp256k1 ECDSA mul if available (this relies on k1 endomorphism, and cannot be used for
     // other curves)
-    if constexpr (HasPlookup<Composer> && Curve::type == proof_system::CurveType::SECP256K1) {
+    if constexpr (HasPlookup<Builder> && Curve::type == proof_system::CurveType::SECP256K1) {
         result = G1::secp256k1_ecdsa_mul(public_key, u1, u2);
     } else {
         result = G1::batch_mul({ G1::one(ctx), public_key }, { u1, u2 });
@@ -114,13 +114,13 @@ bool_t<Composer> verify_signature(const stdlib::byte_array<Composer>& message,
     result_mod_r.binary_basis_limbs[2].element.assert_equal(r.binary_basis_limbs[2].element);
     result_mod_r.binary_basis_limbs[3].element.assert_equal(r.binary_basis_limbs[3].element);
     result_mod_r.prime_basis_limb.assert_equal(r.prime_basis_limb);
-    return bool_t<Composer>(ctx, true);
+    return bool_t<Builder>(ctx, true);
 }
 
 /**
  * @brief Verify ECDSA signature. Returns 0 if signature fails (i.e. does not produce unsatisfiable constraints)
  *
- * @tparam Composer
+ * @tparam Builder
  * @tparam Curve
  * @tparam Fq
  * @tparam Fr
@@ -128,14 +128,14 @@ bool_t<Composer> verify_signature(const stdlib::byte_array<Composer>& message,
  * @param hashed_message
  * @param public_key
  * @param sig
- * @return bool_t<Composer>
+ * @return bool_t<Builder>
  */
-template <typename Composer, typename Curve, typename Fq, typename Fr, typename G1>
-bool_t<Composer> verify_signature_prehashed_message_noassert(const stdlib::byte_array<Composer>& hashed_message,
-                                                             const G1& public_key,
-                                                             const signature<Composer>& sig)
+template <typename Builder, typename Curve, typename Fq, typename Fr, typename G1>
+bool_t<Builder> verify_signature_prehashed_message_noassert(const stdlib::byte_array<Builder>& hashed_message,
+                                                            const G1& public_key,
+                                                            const signature<Builder>& sig)
 {
-    Composer* ctx = hashed_message.get_context() ? hashed_message.get_context() : public_key.x.context;
+    Builder* ctx = hashed_message.get_context() ? hashed_message.get_context() : public_key.x.context;
 
     Fr z(hashed_message);
     z.assert_is_in_field();
@@ -162,7 +162,7 @@ bool_t<Composer> verify_signature_prehashed_message_noassert(const stdlib::byte_
     G1 result;
     // Use special plookup secp256k1 ECDSA mul if available (this relies on k1 endomorphism, and cannot be used for
     // other curves)
-    if constexpr (HasPlookup<Composer> && Curve::type == proof_system::CurveType::SECP256K1) {
+    if constexpr (HasPlookup<Builder> && Curve::type == proof_system::CurveType::SECP256K1) {
         result = G1::secp256k1_ecdsa_mul(public_key, u1, u2);
     } else {
         result = G1::batch_mul({ G1::one(ctx), public_key }, { u1, u2 });
@@ -184,15 +184,15 @@ bool_t<Composer> verify_signature_prehashed_message_noassert(const stdlib::byte_
 
     result_mod_r.assert_is_in_field();
 
-    bool_t<Composer> output(ctx, true);
+    bool_t<Builder> output(ctx, true);
     output &= result_mod_r.binary_basis_limbs[0].element == (r.binary_basis_limbs[0].element);
     output &= result_mod_r.binary_basis_limbs[1].element == (r.binary_basis_limbs[1].element);
     output &= result_mod_r.binary_basis_limbs[2].element == (r.binary_basis_limbs[2].element);
     output &= result_mod_r.binary_basis_limbs[3].element == (r.binary_basis_limbs[3].element);
     output &= result_mod_r.prime_basis_limb == (r.prime_basis_limb);
 
-    field_t<Composer>(sig.v).assert_is_in_set({ field_t<Composer>(27), field_t<Composer>(28) },
-                                              "signature is non-standard");
+    field_t<Builder>(sig.v).assert_is_in_set({ field_t<Builder>(27), field_t<Builder>(28) },
+                                             "signature is non-standard");
 
     return output;
 }
@@ -200,7 +200,7 @@ bool_t<Composer> verify_signature_prehashed_message_noassert(const stdlib::byte_
 /**
  * @brief Verify ECDSA signature. Returns 0 if signature fails (i.e. does not produce unsatisfiable constraints)
  *
- * @tparam Composer
+ * @tparam Builder
  * @tparam Curve
  * @tparam Fq
  * @tparam Fr
@@ -208,17 +208,17 @@ bool_t<Composer> verify_signature_prehashed_message_noassert(const stdlib::byte_
  * @param message
  * @param public_key
  * @param sig
- * @return bool_t<Composer>
+ * @return bool_t<Builder>
  */
-template <typename Composer, typename Curve, typename Fq, typename Fr, typename G1>
-bool_t<Composer> verify_signature_noassert(const stdlib::byte_array<Composer>& message,
-                                           const G1& public_key,
-                                           const signature<Composer>& sig)
+template <typename Builder, typename Curve, typename Fq, typename Fr, typename G1>
+bool_t<Builder> verify_signature_noassert(const stdlib::byte_array<Builder>& message,
+                                          const G1& public_key,
+                                          const signature<Builder>& sig)
 {
-    stdlib::byte_array<Composer> hashed_message =
-        static_cast<stdlib::byte_array<Composer>>(stdlib::sha256<Composer>(message));
+    stdlib::byte_array<Builder> hashed_message =
+        static_cast<stdlib::byte_array<Builder>>(stdlib::sha256<Builder>(message));
 
-    return verify_signature_prehashed_message_noassert<Composer, Curve, Fq, Fr, G1>(hashed_message, public_key, sig);
+    return verify_signature_prehashed_message_noassert<Builder, Curve, Fq, Fr, G1>(hashed_message, public_key, sig);
 }
 
 } // namespace ecdsa
diff --git a/barretenberg/cpp/src/barretenberg/stdlib/encryption/schnorr/schnorr.test.cpp b/barretenberg/cpp/src/barretenberg/stdlib/encryption/schnorr/schnorr.test.cpp
index 9e7110e844c..a5eca30695e 100644
--- a/barretenberg/cpp/src/barretenberg/stdlib/encryption/schnorr/schnorr.test.cpp
+++ b/barretenberg/cpp/src/barretenberg/stdlib/encryption/schnorr/schnorr.test.cpp
@@ -12,28 +12,28 @@ using namespace barretenberg;
 using namespace proof_system::plonk::stdlib;
 using namespace proof_system::plonk::stdlib::schnorr;
 
-using Composer = proof_system::UltraCircuitBuilder;
-using bool_ct = bool_t<Composer>;
-using byte_array_ct = byte_array<Composer>;
-using field_ct = field_t<Composer>;
-using point_ct = point<Composer>;
-using witness_ct = witness_t<Composer>;
+using Builder = proof_system::UltraCircuitBuilder;
+using bool_ct = bool_t<Builder>;
+using byte_array_ct = byte_array<Builder>;
+using field_ct = field_t<Builder>;
+using point_ct = point<Builder>;
+using witness_ct = witness_t<Builder>;
 
 auto run_scalar_mul_test = [](grumpkin::fr scalar_mont, bool expect_verify) {
-    Composer composer = Composer();
+    Builder builder = Builder();
 
     grumpkin::fr scalar = scalar_mont.from_montgomery_form();
 
     uint256_t scalar_low{ scalar.data[0], scalar.data[1], 0ULL, 0ULL };
     uint256_t scalar_high{ scalar.data[2], scalar.data[3], 0ULL, 0ULL };
 
-    field_ct input_lo = witness_ct(&composer, scalar_low);
-    field_ct input_hi = witness_ct(&composer, scalar_high);
+    field_ct input_lo = witness_ct(&builder, scalar_low);
+    field_ct input_hi = witness_ct(&builder, scalar_high);
 
     grumpkin::g1::element expected = grumpkin::g1::one * scalar_mont;
     expected = expected.normalize();
-    point_ct point_input{ witness_ct(&composer, grumpkin::g1::affine_one.x),
-                          witness_ct(&composer, grumpkin::g1::affine_one.y) };
+    point_ct point_input{ witness_ct(&builder, grumpkin::g1::affine_one.x),
+                          witness_ct(&builder, grumpkin::g1::affine_one.y) };
 
     point_ct output = variable_base_mul(point_input, input_lo, input_hi);
 
@@ -42,13 +42,13 @@ auto run_scalar_mul_test = [](grumpkin::fr scalar_mont, bool expect_verify) {
         EXPECT_EQ(output.y.get_value(), expected.y);
     };
 
-    info("composer gates = ", composer.get_num_gates());
+    info("num gates = ", builder.get_num_gates());
 
-    bool result = composer.check_circuit();
+    bool result = builder.check_circuit();
     EXPECT_EQ(result, expect_verify);
 };
 
-typedef wnaf_record<Composer> wnaf_record_ct;
+typedef wnaf_record<Builder> wnaf_record_ct;
 
 /**
  * @brief Helper function to compare wnaf_records, useful since == on bool_ct's returns a bool_ct.
@@ -68,7 +68,7 @@ bool compare_records(wnaf_record_ct a, wnaf_record_ct b)
 
 TEST(stdlib_schnorr, convert_field_into_wnaf_special)
 {
-    Composer composer = Composer();
+    Builder builder = Builder();
 
     // the wnaf_record ((b_1, ... b_128), skew) corresponding to the 129-bit  non-negative value
     // is, 2^128 + 2^127 w_1 + ... + 2 w_127 + w_128 - skew, where w_i = 1 if b_i is true, else -1..
@@ -131,17 +131,17 @@ TEST(stdlib_schnorr, convert_field_into_wnaf_special)
     // integers less than 2^128 are converted correctly
     for (size_t i = 0; i != num_special_values; ++i) {
         field_ct elt = special_field_elts[i];
-        wnaf_record_ct record = convert_field_into_wnaf(&composer, elt);
+        wnaf_record_ct record = convert_field_into_wnaf(&builder, elt);
         wnaf_record_ct expected_record = expected_wnaf_records[i];
         bool records_equal = compare_records(record, expected_record);
         ASSERT_TRUE(records_equal);
-        ASSERT_FALSE(composer.failed());
+        ASSERT_FALSE(builder.failed());
     }
 }
 
 TEST(stdlib_schnorr, convert_field_into_wnaf)
 {
-    Composer composer = Composer();
+    Builder builder = Builder();
 
     grumpkin::fq scalar_mont = grumpkin::fq::random_element();
     grumpkin::fq scalar = scalar_mont.from_montgomery_form();
@@ -153,12 +153,12 @@ TEST(stdlib_schnorr, convert_field_into_wnaf)
 
     scalar = scalar.to_montgomery_form();
 
-    field_ct input(&composer, scalar);
-    convert_field_into_wnaf(&composer, input);
+    field_ct input(&builder, scalar);
+    convert_field_into_wnaf(&builder, input);
 
-    info("composer gates = ", composer.get_num_gates());
+    info("num gates = ", builder.get_num_gates());
 
-    bool result = composer.check_circuit();
+    bool result = builder.check_circuit();
     EXPECT_EQ(result, true);
 }
 
@@ -187,7 +187,7 @@ TEST(stdlib_schnorr, verify_signature)
 
     std::vector<size_t> test_lengths({ 0, 1, 32, 33 });
     for (size_t i : test_lengths) {
-        Composer composer = Composer();
+        Builder builder = Builder();
         auto message_string = longer_string.substr(0, i);
 
         crypto::schnorr::key_pair<grumpkin::fr, grumpkin::g1> account;
@@ -202,13 +202,13 @@ TEST(stdlib_schnorr, verify_signature)
             message_string, account.public_key, signature);
         EXPECT_EQ(first_result, true);
 
-        point_ct pub_key{ witness_ct(&composer, account.public_key.x), witness_ct(&composer, account.public_key.y) };
-        signature_bits sig = convert_signature(&composer, signature);
-        byte_array_ct message(&composer, message_string);
+        point_ct pub_key{ witness_ct(&builder, account.public_key.x), witness_ct(&builder, account.public_key.y) };
+        signature_bits sig = convert_signature(&builder, signature);
+        byte_array_ct message(&builder, message_string);
         verify_signature(message, pub_key, sig);
 
-        info("composer gates = ", composer.get_num_gates());
-        bool result = composer.check_circuit();
+        info("num gates = ", builder.get_num_gates());
+        bool result = builder.check_circuit();
         EXPECT_EQ(result, true);
     }
 }
@@ -219,7 +219,7 @@ TEST(stdlib_schnorr, verify_signature)
  */
 TEST(stdlib_schnorr, verify_signature_failure)
 {
-    Composer composer = Composer();
+    Builder builder = Builder();
     std::string message_string = "This is a test string of length 34";
 
     // create key pair 1
@@ -243,14 +243,14 @@ TEST(stdlib_schnorr, verify_signature_failure)
     EXPECT_EQ(native_result, false);
 
     // check stdlib verification with account 2 public key fails
-    point_ct pub_key2_ct{ witness_ct(&composer, account2.public_key.x), witness_ct(&composer, account2.public_key.y) };
-    signature_bits sig = convert_signature(&composer, signature);
-    byte_array_ct message(&composer, message_string);
+    point_ct pub_key2_ct{ witness_ct(&builder, account2.public_key.x), witness_ct(&builder, account2.public_key.y) };
+    signature_bits sig = convert_signature(&builder, signature);
+    byte_array_ct message(&builder, message_string);
     verify_signature(message, pub_key2_ct, sig);
 
-    info("composer gates = ", composer.get_num_gates());
+    info("num gates = ", builder.get_num_gates());
 
-    bool verification_result = composer.check_circuit();
+    bool verification_result = builder.check_circuit();
     EXPECT_EQ(verification_result, false);
 }
 
@@ -262,7 +262,7 @@ TEST(stdlib_schnorr, signature_verification_result)
 {
     std::string longer_string = "This is a test string of length 34";
 
-    Composer composer = Composer();
+    Builder builder = Builder();
 
     crypto::schnorr::key_pair<grumpkin::fr, grumpkin::g1> account;
     account.private_key = grumpkin::fr::random_element();
@@ -276,15 +276,15 @@ TEST(stdlib_schnorr, signature_verification_result)
         longer_string, account.public_key, signature);
     EXPECT_EQ(first_result, true);
 
-    point_ct pub_key{ witness_ct(&composer, account.public_key.x), witness_ct(&composer, account.public_key.y) };
-    signature_bits sig = convert_signature(&composer, signature);
-    byte_array_ct message(&composer, longer_string);
+    point_ct pub_key{ witness_ct(&builder, account.public_key.x), witness_ct(&builder, account.public_key.y) };
+    signature_bits sig = convert_signature(&builder, signature);
+    byte_array_ct message(&builder, longer_string);
     bool_ct signature_result = signature_verification_result(message, pub_key, sig);
     EXPECT_EQ(signature_result.witness_bool, true);
 
-    info("composer gates = ", composer.get_num_gates());
+    info("num gates = ", builder.get_num_gates());
 
-    bool result = composer.check_circuit();
+    bool result = builder.check_circuit();
     EXPECT_EQ(result, true);
 }
 
@@ -294,7 +294,7 @@ TEST(stdlib_schnorr, signature_verification_result)
  */
 TEST(stdlib_schnorr, signature_verification_result_failure)
 {
-    Composer composer = Composer();
+    Builder builder = Builder();
     std::string message_string = "This is a test string of length 34";
 
     // create key pair 1
@@ -318,15 +318,15 @@ TEST(stdlib_schnorr, signature_verification_result_failure)
     EXPECT_EQ(native_result, false);
 
     // check stdlib verification with account 2 public key fails
-    point_ct pub_key2_ct{ witness_ct(&composer, account2.public_key.x), witness_ct(&composer, account2.public_key.y) };
-    signature_bits sig = convert_signature(&composer, signature);
-    byte_array_ct message(&composer, message_string);
+    point_ct pub_key2_ct{ witness_ct(&builder, account2.public_key.x), witness_ct(&builder, account2.public_key.y) };
+    signature_bits sig = convert_signature(&builder, signature);
+    byte_array_ct message(&builder, message_string);
     bool_ct signature_result = signature_verification_result(message, pub_key2_ct, sig);
     EXPECT_EQ(signature_result.witness_bool, false);
 
-    info("composer gates = ", composer.get_num_gates());
+    info("num gates = ", builder.get_num_gates());
 
-    bool verification_result = composer.check_circuit();
+    bool verification_result = builder.check_circuit();
     EXPECT_EQ(verification_result, true);
 }
 
diff --git a/barretenberg/cpp/src/barretenberg/stdlib/hash/benchmarks/external/external.bench.cpp b/barretenberg/cpp/src/barretenberg/stdlib/hash/benchmarks/external/external.bench.cpp
index 97bda1baf6a..b68a87cbd02 100644
--- a/barretenberg/cpp/src/barretenberg/stdlib/hash/benchmarks/external/external.bench.cpp
+++ b/barretenberg/cpp/src/barretenberg/stdlib/hash/benchmarks/external/external.bench.cpp
@@ -25,7 +25,7 @@ constexpr size_t NUM_PROOFS = 3;
  * @brief Main function generating a circuit with num_iterations sequential sha256 hashes, where the output of a
  * previous iteration is fed into the next one
  *
- * @param composer
+ * @param builder
  * @param num_iterations
  */
 void generate_test_sha256_plonk_circuit(Builder& builder, size_t num_iterations)
@@ -107,7 +107,7 @@ BENCHMARK(verify_sha256_proof_bench)->DenseRange(0, 2)->Setup(generate_sha256_ve
 /**
  * @brief Main function for generating Blake 3 circuits
  *
- * @param composer
+ * @param builder
  * @param num_iterations
  */
 void generate_test_blake3s_plonk_circuit(Builder& builder, size_t num_iterations)
diff --git a/barretenberg/cpp/src/barretenberg/stdlib/hash/benchmarks/sha256/sha256.bench.cpp b/barretenberg/cpp/src/barretenberg/stdlib/hash/benchmarks/sha256/sha256.bench.cpp
index 9f5deca6460..3a6953d4bbc 100644
--- a/barretenberg/cpp/src/barretenberg/stdlib/hash/benchmarks/sha256/sha256.bench.cpp
+++ b/barretenberg/cpp/src/barretenberg/stdlib/hash/benchmarks/sha256/sha256.bench.cpp
@@ -53,7 +53,6 @@ void preprocess_witnesses_bench(State& state) noexcept
         composers[idx] = (void*)new Composer();
         provers[idx] = ((Composer*)composers[idx])->create_prover(*(Builder*)builders[idx]);
         std::cout << "prover subgroup size = " << provers[idx].key->small_domain.size << std::endl;
-        // printf("num bytes = %" PRIx64 ", num gates = %zu\n", state.range(0), composers[idx].get_num_gates());
     }
 }
 BENCHMARK(preprocess_witnesses_bench)->DenseRange(START_BYTES, MAX_BYTES, BYTES_PER_CHUNK);
diff --git a/barretenberg/cpp/src/barretenberg/stdlib/hash/blake2s/blake2s.cpp b/barretenberg/cpp/src/barretenberg/stdlib/hash/blake2s/blake2s.cpp
index 340f99508d7..a19afebd703 100644
--- a/barretenberg/cpp/src/barretenberg/stdlib/hash/blake2s/blake2s.cpp
+++ b/barretenberg/cpp/src/barretenberg/stdlib/hash/blake2s/blake2s.cpp
@@ -22,13 +22,13 @@ enum blake2s_constant {
     BLAKE2S_PERSONALBYTES = 8
 };
 
-template <typename Composer> struct blake2s_state {
-    uint32<Composer> h[8];
-    uint32<Composer> t[2];
-    uint32<Composer> f[2];
+template <typename Builder> struct blake2s_state {
+    uint32<Builder> h[8];
+    uint32<Builder> t[2];
+    uint32<Builder> f[2];
 };
 
-template <typename Composer> void blake2s_increment_counter(blake2s_state<Composer>& S, const uint32_t inc)
+template <typename Builder> void blake2s_increment_counter(blake2s_state<Builder>& S, const uint32_t inc)
 {
     S.t[0] = S.t[0] + inc;
     const bool to_inc = S.t[0].get_value() < inc;
@@ -39,13 +39,13 @@ template <typename Composer> void blake2s_increment_counter(blake2s_state<Compos
     ASSERT(S.t[1].is_constant());
 }
 
-template <typename Composer> void blake2s_compress(blake2s_state<Composer>& S, byte_array<Composer> const& in)
+template <typename Builder> void blake2s_compress(blake2s_state<Builder>& S, byte_array<Builder> const& in)
 {
-    uint32<Composer> m[16];
-    uint32<Composer> v[16];
+    uint32<Builder> m[16];
+    uint32<Builder> v[16];
 
     for (size_t i = 0; i < 16; ++i) {
-        m[i] = uint32<Composer>(in.slice(i * 4, 4).reverse());
+        m[i] = uint32<Builder>(in.slice(i * 4, 4).reverse());
     }
 
     for (size_t i = 0; i < 8; ++i) {
@@ -61,16 +61,16 @@ template <typename Composer> void blake2s_compress(blake2s_state<Composer>& S, b
     v[14] = S.f[0] ^ blake2s_IV[6];
     v[15] = S.f[1] ^ blake2s_IV[7];
 
-    blake_util::round_fn<Composer>(v, m, 0);
-    blake_util::round_fn<Composer>(v, m, 1);
-    blake_util::round_fn<Composer>(v, m, 2);
-    blake_util::round_fn<Composer>(v, m, 3);
-    blake_util::round_fn<Composer>(v, m, 4);
-    blake_util::round_fn<Composer>(v, m, 5);
-    blake_util::round_fn<Composer>(v, m, 6);
-    blake_util::round_fn<Composer>(v, m, 7);
-    blake_util::round_fn<Composer>(v, m, 8);
-    blake_util::round_fn<Composer>(v, m, 9);
+    blake_util::round_fn<Builder>(v, m, 0);
+    blake_util::round_fn<Builder>(v, m, 1);
+    blake_util::round_fn<Builder>(v, m, 2);
+    blake_util::round_fn<Builder>(v, m, 3);
+    blake_util::round_fn<Builder>(v, m, 4);
+    blake_util::round_fn<Builder>(v, m, 5);
+    blake_util::round_fn<Builder>(v, m, 6);
+    blake_util::round_fn<Builder>(v, m, 7);
+    blake_util::round_fn<Builder>(v, m, 8);
+    blake_util::round_fn<Builder>(v, m, 9);
 
     // ROUND(0);
     // ROUND(1);
@@ -91,7 +91,7 @@ template <typename Composer> void blake2s_compress(blake2s_state<Composer>& S, b
 #undef G
 #undef ROUND
 
-template <typename Composer> void blake2s(blake2s_state<Composer>& S, byte_array<Composer> const& in)
+template <typename Builder> void blake2s(blake2s_state<Builder>& S, byte_array<Builder> const& in)
 {
     size_t offset = 0;
     size_t size = in.size();
@@ -106,21 +106,21 @@ template <typename Composer> void blake2s(blake2s_state<Composer>& S, byte_array
     // Set last block.
     S.f[0] = (uint32_t)-1;
 
-    byte_array<Composer> final(in.get_context());
-    final.write(in.slice(offset)).write(byte_array<Composer>(in.get_context(), BLAKE2S_BLOCKBYTES - size));
+    byte_array<Builder> final(in.get_context());
+    final.write(in.slice(offset)).write(byte_array<Builder>(in.get_context(), BLAKE2S_BLOCKBYTES - size));
     blake2s_increment_counter(S, (uint32_t)size);
     blake2s_compress(S, final);
 }
 
 } // namespace
 
-template <typename Composer> byte_array<Composer> blake2s(const byte_array<Composer>& input)
+template <typename Builder> byte_array<Builder> blake2s(const byte_array<Builder>& input)
 {
-    if constexpr (HasPlookup<Composer>) {
-        return blake2s_plookup::blake2s<Composer>(input);
+    if constexpr (HasPlookup<Builder>) {
+        return blake2s_plookup::blake2s<Builder>(input);
     }
 
-    blake2s_state<Composer> S;
+    blake2s_state<Builder> S;
 
     for (size_t i = 0; i < 8; i++) {
         S.h[i] = initial_H[i];
@@ -128,9 +128,9 @@ template <typename Composer> byte_array<Composer> blake2s(const byte_array<Compo
 
     blake2s(S, input);
 
-    byte_array<Composer> result(input.get_context());
+    byte_array<Builder> result(input.get_context());
     for (auto h : S.h) {
-        byte_array<Composer> v = static_cast<byte_array<Composer>>(h);
+        byte_array<Builder> v = static_cast<byte_array<Builder>>(h);
         result.write(v.reverse());
     }
     return result;
diff --git a/barretenberg/cpp/src/barretenberg/stdlib/hash/blake2s/blake2s.hpp b/barretenberg/cpp/src/barretenberg/stdlib/hash/blake2s/blake2s.hpp
index 905ef630804..68d8ca8687f 100644
--- a/barretenberg/cpp/src/barretenberg/stdlib/hash/blake2s/blake2s.hpp
+++ b/barretenberg/cpp/src/barretenberg/stdlib/hash/blake2s/blake2s.hpp
@@ -5,7 +5,7 @@
 namespace proof_system::plonk {
 namespace stdlib {
 
-template <typename Composer> byte_array<Composer> blake2s(const byte_array<Composer>& input);
+template <typename Builder> byte_array<Builder> blake2s(const byte_array<Builder>& input);
 
 #define BLAKE2S(circuit_type) byte_array<circuit_type> blake2s(const byte_array<circuit_type>& input)
 
diff --git a/barretenberg/cpp/src/barretenberg/stdlib/hash/blake2s/blake2s.test.cpp b/barretenberg/cpp/src/barretenberg/stdlib/hash/blake2s/blake2s.test.cpp
index 17f53081609..1b01854ceaa 100644
--- a/barretenberg/cpp/src/barretenberg/stdlib/hash/blake2s/blake2s.test.cpp
+++ b/barretenberg/cpp/src/barretenberg/stdlib/hash/blake2s/blake2s.test.cpp
@@ -17,20 +17,20 @@ using public_witness_t = public_witness_t<Builder>;
 
 // TEST(stdlib_blake2s, test_single_block)
 // {
-//     auto composer = Builder();
+//     auto builder = Builder();
 //     std::string input = "abcdefghijklmnopqrstuvwxyz0123456789abcdefghijklmnopqrstuvwxyz01";
 //     std::vector<uint8_t> input_v(input.begin(), input.end());
 
-//     byte_array_ct input_arr(&composer, input_v);
+//     byte_array_ct input_arr(&builder, input_v);
 //     byte_array_ct output = blake2s(input_arr);
 
 //     std::vector<uint8_t> expected = blake2::blake2s(input_v);
 
 //     EXPECT_EQ(output.get_value(), expected);
 
-//     info("composer gates = %zu\n", composer.get_num_gates());
+//     info("num gates = %zu\n", builder.get_num_gates());
 
-//     bool proof_result = composer.check_circuit();
+//     bool proof_result = builder.check_circuit();
 //     EXPECT_EQ(proof_result, true);
 // }
 
@@ -55,20 +55,20 @@ TEST(stdlib_blake2s, test_single_block_plookup)
 
 // TEST(stdlib_blake2s, test_double_block)
 // {
-//     auto composer = Builder();
+//     auto builder = Builder();
 //     std::string input = "abcdefghijklmnopqrstuvwxyz0123456789abcdefghijklmnopqrstuvwxyz0123456789";
 //     std::vector<uint8_t> input_v(input.begin(), input.end());
 
-//     byte_array_ct input_arr(&composer, input_v);
+//     byte_array_ct input_arr(&builder, input_v);
 //     byte_array_ct output = blake2s(input_arr);
 
 //     std::vector<uint8_t> expected = blake2::blake2s(input_v);
 
 //     EXPECT_EQ(output.get_value(), expected);
 
-//     info("composer gates = %zu\n", composer.get_num_gates());
+//     info("num gates = %zu\n", builder.get_num_gates());
 
-//     bool proof_result = composer.check_circuit();
+//     bool proof_result = builder.check_circuit();
 //     EXPECT_EQ(proof_result, true);
 // }
 
diff --git a/barretenberg/cpp/src/barretenberg/stdlib/hash/blake2s/blake2s_plookup.cpp b/barretenberg/cpp/src/barretenberg/stdlib/hash/blake2s/blake2s_plookup.cpp
index 1a9ee17fc90..14945bc5f08 100644
--- a/barretenberg/cpp/src/barretenberg/stdlib/hash/blake2s/blake2s_plookup.cpp
+++ b/barretenberg/cpp/src/barretenberg/stdlib/hash/blake2s/blake2s_plookup.cpp
@@ -56,15 +56,15 @@ enum blake2s_constant {
  * Further, the internal state 4x4 matrix used by the compression function is denoted by v.
  * The input data is stored in the 16-word message m.
  */
-template <typename Composer> struct blake2s_state {
-    field_t<Composer> h[8];
-    field_t<Composer> t[2];
-    field_t<Composer> f[2];
+template <typename Builder> struct blake2s_state {
+    field_t<Builder> h[8];
+    field_t<Builder> t[2];
+    field_t<Builder> f[2];
 };
 
-template <typename Composer> void blake2s_increment_counter(blake2s_state<Composer>& S, const uint32_t inc)
+template <typename Builder> void blake2s_increment_counter(blake2s_state<Builder>& S, const uint32_t inc)
 {
-    typedef field_t<Composer> field_pt;
+    typedef field_t<Builder> field_pt;
     field_pt inc_scalar = field_pt(uint256_t(inc));
     S.t[0] = S.t[0] + inc_scalar;
     // TODO: Secure!? Think so as inc is known at "compile" time as it's derived from the msg length.
@@ -72,9 +72,9 @@ template <typename Composer> void blake2s_increment_counter(blake2s_state<Compos
     S.t[1] = S.t[1] + (to_inc ? field_pt(1) : field_pt(0));
 }
 
-template <typename Composer> void blake2s_compress(blake2s_state<Composer>& S, byte_array<Composer> const& in)
+template <typename Builder> void blake2s_compress(blake2s_state<Builder>& S, byte_array<Builder> const& in)
 {
-    typedef field_t<Composer> field_pt;
+    typedef field_t<Builder> field_pt;
     field_pt m[16];
     field_pt v[16];
 
@@ -93,74 +93,74 @@ template <typename Composer> void blake2s_compress(blake2s_state<Composer>& S, b
 
     // Use the lookup tables to perform XORs
     const auto lookup_1 =
-        plookup_read<Composer>::get_lookup_accumulators(BLAKE_XOR, S.t[0], field_pt(uint256_t(blake2s_IV[4])), true);
+        plookup_read<Builder>::get_lookup_accumulators(BLAKE_XOR, S.t[0], field_pt(uint256_t(blake2s_IV[4])), true);
     v[12] = lookup_1[ColumnIdx::C3][0];
     const auto lookup_2 =
-        plookup_read<Composer>::get_lookup_accumulators(BLAKE_XOR, S.t[1], field_pt(uint256_t(blake2s_IV[5])), true);
+        plookup_read<Builder>::get_lookup_accumulators(BLAKE_XOR, S.t[1], field_pt(uint256_t(blake2s_IV[5])), true);
     v[13] = lookup_2[ColumnIdx::C3][0];
     const auto lookup_3 =
-        plookup_read<Composer>::get_lookup_accumulators(BLAKE_XOR, S.f[0], field_pt(uint256_t(blake2s_IV[6])), true);
+        plookup_read<Builder>::get_lookup_accumulators(BLAKE_XOR, S.f[0], field_pt(uint256_t(blake2s_IV[6])), true);
     v[14] = lookup_3[ColumnIdx::C3][0];
     const auto lookup_4 =
-        plookup_read<Composer>::get_lookup_accumulators(BLAKE_XOR, S.f[1], field_pt(uint256_t(blake2s_IV[7])), true);
+        plookup_read<Builder>::get_lookup_accumulators(BLAKE_XOR, S.f[1], field_pt(uint256_t(blake2s_IV[7])), true);
     v[15] = lookup_4[ColumnIdx::C3][0];
 
-    blake_util::round_fn_lookup<Composer>(v, m, 0);
-    blake_util::round_fn_lookup<Composer>(v, m, 1);
-    blake_util::round_fn_lookup<Composer>(v, m, 2);
-    blake_util::round_fn_lookup<Composer>(v, m, 3);
-    blake_util::round_fn_lookup<Composer>(v, m, 4);
-    blake_util::round_fn_lookup<Composer>(v, m, 5);
-    blake_util::round_fn_lookup<Composer>(v, m, 6);
-    blake_util::round_fn_lookup<Composer>(v, m, 7);
-    blake_util::round_fn_lookup<Composer>(v, m, 8);
-    blake_util::round_fn_lookup<Composer>(v, m, 9);
+    blake_util::round_fn_lookup<Builder>(v, m, 0);
+    blake_util::round_fn_lookup<Builder>(v, m, 1);
+    blake_util::round_fn_lookup<Builder>(v, m, 2);
+    blake_util::round_fn_lookup<Builder>(v, m, 3);
+    blake_util::round_fn_lookup<Builder>(v, m, 4);
+    blake_util::round_fn_lookup<Builder>(v, m, 5);
+    blake_util::round_fn_lookup<Builder>(v, m, 6);
+    blake_util::round_fn_lookup<Builder>(v, m, 7);
+    blake_util::round_fn_lookup<Builder>(v, m, 8);
+    blake_util::round_fn_lookup<Builder>(v, m, 9);
 
     // At this point in the algorithm, the elements (v0, v1, v2, v3) and (v8, v9, v10, v11) in the state matrix 'v' can
     // be 'overflowed' i.e. contain values > 2^{32}. However we do NOT need to normalize them to be < 2^{32}, the
     // following `read_sequence_from_table` calls correctly constrain the output to be 32-bits
     for (size_t i = 0; i < 8; ++i) {
-        const auto lookup_a = plookup_read<Composer>::get_lookup_accumulators(BLAKE_XOR, S.h[i], v[i], true);
+        const auto lookup_a = plookup_read<Builder>::get_lookup_accumulators(BLAKE_XOR, S.h[i], v[i], true);
         const auto lookup_b =
-            plookup_read<Composer>::get_lookup_accumulators(BLAKE_XOR, lookup_a[ColumnIdx::C3][0], v[i + 8], true);
+            plookup_read<Builder>::get_lookup_accumulators(BLAKE_XOR, lookup_a[ColumnIdx::C3][0], v[i + 8], true);
         S.h[i] = lookup_b[ColumnIdx::C3][0];
     }
 }
 
-template <typename Composer> void blake2s(blake2s_state<Composer>& S, byte_array<Composer> const& in)
+template <typename Builder> void blake2s(blake2s_state<Builder>& S, byte_array<Builder> const& in)
 {
     size_t offset = 0;
     size_t size = in.size();
 
     while (size > BLAKE2S_BLOCKBYTES) {
         blake2s_increment_counter(S, BLAKE2S_BLOCKBYTES);
-        blake2s_compress<Composer>(S, in.slice(offset, BLAKE2S_BLOCKBYTES));
+        blake2s_compress<Builder>(S, in.slice(offset, BLAKE2S_BLOCKBYTES));
         offset += BLAKE2S_BLOCKBYTES;
         size -= BLAKE2S_BLOCKBYTES;
     }
 
     // Set last block.
-    S.f[0] = field_t<Composer>(uint256_t((uint32_t)-1));
+    S.f[0] = field_t<Builder>(uint256_t((uint32_t)-1));
 
-    byte_array<Composer> final(in.get_context());
-    final.write(in.slice(offset)).write(byte_array<Composer>(in.get_context(), BLAKE2S_BLOCKBYTES - size));
+    byte_array<Builder> final(in.get_context());
+    final.write(in.slice(offset)).write(byte_array<Builder>(in.get_context(), BLAKE2S_BLOCKBYTES - size));
     blake2s_increment_counter(S, (uint32_t)size);
-    blake2s_compress<Composer>(S, final);
+    blake2s_compress<Builder>(S, final);
 }
 
-template <typename Composer> byte_array<Composer> blake2s(const byte_array<Composer>& input)
+template <typename Builder> byte_array<Builder> blake2s(const byte_array<Builder>& input)
 {
-    blake2s_state<Composer> S;
+    blake2s_state<Builder> S;
 
     for (size_t i = 0; i < 8; i++) {
-        S.h[i] = field_t<Composer>(uint256_t(initial_H[i]));
+        S.h[i] = field_t<Builder>(uint256_t(initial_H[i]));
     }
 
     blake2s(S, input);
 
-    byte_array<Composer> result(input.get_context());
+    byte_array<Builder> result(input.get_context());
     for (auto h : S.h) {
-        byte_array<Composer> v(h, 4);
+        byte_array<Builder> v(h, 4);
         result.write(v.reverse());
     }
     return result;
diff --git a/barretenberg/cpp/src/barretenberg/stdlib/hash/blake2s/blake2s_plookup.hpp b/barretenberg/cpp/src/barretenberg/stdlib/hash/blake2s/blake2s_plookup.hpp
index 272986210c0..995ef030549 100644
--- a/barretenberg/cpp/src/barretenberg/stdlib/hash/blake2s/blake2s_plookup.hpp
+++ b/barretenberg/cpp/src/barretenberg/stdlib/hash/blake2s/blake2s_plookup.hpp
@@ -14,7 +14,7 @@ namespace stdlib {
 
 namespace blake2s_plookup {
 
-template <typename Composer> byte_array<Composer> blake2s(const byte_array<Composer>& input);
+template <typename Builder> byte_array<Builder> blake2s(const byte_array<Builder>& input);
 
 #define BLAKE2S_ULTRA(ULTRA_TYPE) byte_array<ULTRA_TYPE> blake2s(const byte_array<ULTRA_TYPE>& input)
 
diff --git a/barretenberg/cpp/src/barretenberg/stdlib/hash/blake2s/blake_util.hpp b/barretenberg/cpp/src/barretenberg/stdlib/hash/blake2s/blake_util.hpp
index ae95162cca9..be960fe45fd 100644
--- a/barretenberg/cpp/src/barretenberg/stdlib/hash/blake2s/blake_util.hpp
+++ b/barretenberg/cpp/src/barretenberg/stdlib/hash/blake2s/blake_util.hpp
@@ -35,12 +35,12 @@ constexpr uint8_t MSG_SCHEDULE_BLAKE2[10][16] = {
  * Additionally, it checks if the overflow of the addition is a maximum of 3 bits.
  * This is to ascertain that the additions of two 32-bit scalars in blake2s and blake3s do not exceed 35 bits.
  */
-template <typename Composer> field_t<Composer> add_normalize(const field_t<Composer>& a, const field_t<Composer>& b)
+template <typename Builder> field_t<Builder> add_normalize(const field_t<Builder>& a, const field_t<Builder>& b)
 {
-    typedef field_t<Composer> field_pt;
-    typedef witness_t<Composer> witness_pt;
+    typedef field_t<Builder> field_pt;
+    typedef witness_t<Builder> witness_pt;
 
-    Composer* ctx = a.get_context() ? a.get_context() : b.get_context();
+    Builder* ctx = a.get_context() ? a.get_context() : b.get_context();
 
     uint256_t sum = a.get_value() + b.get_value();
 
@@ -72,14 +72,14 @@ template <typename Composer> field_t<Composer> add_normalize(const field_t<Compo
  *         - addition messages x and y
  *
  **/
-template <typename Composer>
-void g(uint32<Composer> state[BLAKE3_STATE_SIZE],
+template <typename Builder>
+void g(uint32<Builder> state[BLAKE3_STATE_SIZE],
        size_t a,
        size_t b,
        size_t c,
        size_t d,
-       uint32<Composer> x,
-       uint32<Composer> y)
+       uint32<Builder> x,
+       uint32<Builder> y)
 {
     state[a] = state[a] + state[b] + x;
     state[d] = (state[d] ^ state[a]).ror(16);
@@ -138,25 +138,24 @@ void g(uint32<Composer> state[BLAKE3_STATE_SIZE],
  *
  *
  **/
-template <typename Composer>
-void g_lookup(field_t<Composer> state[BLAKE3_STATE_SIZE],
+template <typename Builder>
+void g_lookup(field_t<Builder> state[BLAKE3_STATE_SIZE],
               size_t a,
               size_t b,
               size_t c,
               size_t d,
-              field_t<Composer> x,
-              field_t<Composer> y,
+              field_t<Builder> x,
+              field_t<Builder> y,
               const bool last_update = false)
 {
-    typedef field_t<Composer> field_pt;
+    typedef field_t<Builder> field_pt;
 
     // For simplicity, state[a] is written as `a' in comments.
     // a = a + b + x
     state[a] = state[a].add_two(state[b], x);
 
     // d = (d ^ a).ror(16)
-    const auto lookup_1 =
-        plookup_read<Composer>::get_lookup_accumulators(BLAKE_XOR_ROTATE_16, state[d], state[a], true);
+    const auto lookup_1 = plookup_read<Builder>::get_lookup_accumulators(BLAKE_XOR_ROTATE_16, state[d], state[a], true);
     field_pt scaling_factor_1 = (1 << (32 - 16));
     state[d] = lookup_1[ColumnIdx::C3][0] * scaling_factor_1;
 
@@ -164,7 +163,7 @@ void g_lookup(field_t<Composer> state[BLAKE3_STATE_SIZE],
     state[c] = state[c] + state[d];
 
     // b = (b ^ c).ror(12)
-    const auto lookup_2 = plookup_read<Composer>::get_lookup_accumulators(BLAKE_XOR, state[b], state[c], true);
+    const auto lookup_2 = plookup_read<Builder>::get_lookup_accumulators(BLAKE_XOR, state[b], state[c], true);
     field_pt lookup_output = lookup_2[ColumnIdx::C3][2];
     field_pt t2_term = field_pt(1 << 12) * lookup_2[ColumnIdx::C3][2];
     lookup_output += (lookup_2[ColumnIdx::C3][0] - t2_term) * field_pt(1 << 20);
@@ -178,7 +177,7 @@ void g_lookup(field_t<Composer> state[BLAKE3_STATE_SIZE],
     }
 
     // d = (d ^ a).ror(8)
-    const auto lookup_3 = plookup_read<Composer>::get_lookup_accumulators(BLAKE_XOR_ROTATE_8, state[d], state[a], true);
+    const auto lookup_3 = plookup_read<Builder>::get_lookup_accumulators(BLAKE_XOR_ROTATE_8, state[d], state[a], true);
     field_pt scaling_factor_3 = (1 << (32 - 8));
     state[d] = lookup_3[ColumnIdx::C3][0] * scaling_factor_3;
 
@@ -190,7 +189,7 @@ void g_lookup(field_t<Composer> state[BLAKE3_STATE_SIZE],
     }
 
     // b = (b ^ c).ror(7)
-    const auto lookup_4 = plookup_read<Composer>::get_lookup_accumulators(BLAKE_XOR_ROTATE_7, state[b], state[c], true);
+    const auto lookup_4 = plookup_read<Builder>::get_lookup_accumulators(BLAKE_XOR_ROTATE_7, state[b], state[c], true);
     field_pt scaling_factor_4 = (1 << (32 - 7));
     state[b] = lookup_4[ColumnIdx::C3][0] * scaling_factor_4;
 }
@@ -202,9 +201,9 @@ void g_lookup(field_t<Composer> state[BLAKE3_STATE_SIZE],
  *         - round numbe
  *         - which_blake to choose Blake2 or Blake3 (false -> Blake2)
  */
-template <typename Composer>
-void round_fn(uint32<Composer> state[BLAKE3_STATE_SIZE],
-              uint32<Composer> msg[BLAKE3_STATE_SIZE],
+template <typename Builder>
+void round_fn(uint32<Builder> state[BLAKE3_STATE_SIZE],
+              uint32<Builder> msg[BLAKE3_STATE_SIZE],
               size_t round,
               const bool which_blake = false)
 {
@@ -212,16 +211,16 @@ void round_fn(uint32<Composer> state[BLAKE3_STATE_SIZE],
     const uint8_t* schedule = which_blake ? MSG_SCHEDULE_BLAKE3[round] : MSG_SCHEDULE_BLAKE2[round];
 
     // Mix the columns.
-    g<Composer>(state, 0, 4, 8, 12, msg[schedule[0]], msg[schedule[1]]);
-    g<Composer>(state, 1, 5, 9, 13, msg[schedule[2]], msg[schedule[3]]);
-    g<Composer>(state, 2, 6, 10, 14, msg[schedule[4]], msg[schedule[5]]);
-    g<Composer>(state, 3, 7, 11, 15, msg[schedule[6]], msg[schedule[7]]);
+    g<Builder>(state, 0, 4, 8, 12, msg[schedule[0]], msg[schedule[1]]);
+    g<Builder>(state, 1, 5, 9, 13, msg[schedule[2]], msg[schedule[3]]);
+    g<Builder>(state, 2, 6, 10, 14, msg[schedule[4]], msg[schedule[5]]);
+    g<Builder>(state, 3, 7, 11, 15, msg[schedule[6]], msg[schedule[7]]);
 
     // Mix the rows.
-    g<Composer>(state, 0, 5, 10, 15, msg[schedule[8]], msg[schedule[9]]);
-    g<Composer>(state, 1, 6, 11, 12, msg[schedule[10]], msg[schedule[11]]);
-    g<Composer>(state, 2, 7, 8, 13, msg[schedule[12]], msg[schedule[13]]);
-    g<Composer>(state, 3, 4, 9, 14, msg[schedule[14]], msg[schedule[15]]);
+    g<Builder>(state, 0, 5, 10, 15, msg[schedule[8]], msg[schedule[9]]);
+    g<Builder>(state, 1, 6, 11, 12, msg[schedule[10]], msg[schedule[11]]);
+    g<Builder>(state, 2, 7, 8, 13, msg[schedule[12]], msg[schedule[13]]);
+    g<Builder>(state, 3, 4, 9, 14, msg[schedule[14]], msg[schedule[15]]);
 }
 
 /*
@@ -231,9 +230,9 @@ void round_fn(uint32<Composer> state[BLAKE3_STATE_SIZE],
  *         - round numbe
  *         - which_blake to choose Blake2 or Blake3 (false -> Blake2)
  */
-template <typename Composer>
-void round_fn_lookup(field_t<Composer> state[BLAKE3_STATE_SIZE],
-                     field_t<Composer> msg[BLAKE3_STATE_SIZE],
+template <typename Builder>
+void round_fn_lookup(field_t<Builder> state[BLAKE3_STATE_SIZE],
+                     field_t<Builder> msg[BLAKE3_STATE_SIZE],
                      size_t round,
                      const bool which_blake = false)
 {
@@ -241,16 +240,16 @@ void round_fn_lookup(field_t<Composer> state[BLAKE3_STATE_SIZE],
     const uint8_t* schedule = which_blake ? MSG_SCHEDULE_BLAKE3[round] : MSG_SCHEDULE_BLAKE2[round];
 
     // Mix the columns.
-    g_lookup<Composer>(state, 0, 4, 8, 12, msg[schedule[0]], msg[schedule[1]]);
-    g_lookup<Composer>(state, 1, 5, 9, 13, msg[schedule[2]], msg[schedule[3]]);
-    g_lookup<Composer>(state, 2, 6, 10, 14, msg[schedule[4]], msg[schedule[5]]);
-    g_lookup<Composer>(state, 3, 7, 11, 15, msg[schedule[6]], msg[schedule[7]]);
+    g_lookup<Builder>(state, 0, 4, 8, 12, msg[schedule[0]], msg[schedule[1]]);
+    g_lookup<Builder>(state, 1, 5, 9, 13, msg[schedule[2]], msg[schedule[3]]);
+    g_lookup<Builder>(state, 2, 6, 10, 14, msg[schedule[4]], msg[schedule[5]]);
+    g_lookup<Builder>(state, 3, 7, 11, 15, msg[schedule[6]], msg[schedule[7]]);
 
     // Mix the rows.
-    g_lookup<Composer>(state, 0, 5, 10, 15, msg[schedule[8]], msg[schedule[9]], true);
-    g_lookup<Composer>(state, 1, 6, 11, 12, msg[schedule[10]], msg[schedule[11]], true);
-    g_lookup<Composer>(state, 2, 7, 8, 13, msg[schedule[12]], msg[schedule[13]], true);
-    g_lookup<Composer>(state, 3, 4, 9, 14, msg[schedule[14]], msg[schedule[15]], true);
+    g_lookup<Builder>(state, 0, 5, 10, 15, msg[schedule[8]], msg[schedule[9]], true);
+    g_lookup<Builder>(state, 1, 6, 11, 12, msg[schedule[10]], msg[schedule[11]], true);
+    g_lookup<Builder>(state, 2, 7, 8, 13, msg[schedule[12]], msg[schedule[13]], true);
+    g_lookup<Builder>(state, 3, 4, 9, 14, msg[schedule[14]], msg[schedule[15]], true);
 }
 
 } // namespace blake_util
diff --git a/barretenberg/cpp/src/barretenberg/stdlib/hash/blake3s/blake3s.cpp b/barretenberg/cpp/src/barretenberg/stdlib/hash/blake3s/blake3s.cpp
index 298368268f7..abedf6fa36f 100644
--- a/barretenberg/cpp/src/barretenberg/stdlib/hash/blake3s/blake3s.cpp
+++ b/barretenberg/cpp/src/barretenberg/stdlib/hash/blake3s/blake3s.cpp
@@ -37,14 +37,14 @@ enum blake3s_constant {
 static const uint32_t IV[8] = { 0x6A09E667UL, 0xBB67AE85UL, 0x3C6EF372UL, 0xA54FF53AUL,
                                 0x510E527FUL, 0x9B05688CUL, 0x1F83D9ABUL, 0x5BE0CD19UL };
 
-template <typename Composer> struct blake3_hasher {
-    uint32<Composer> key[8];
-    uint32<Composer> cv[8];
-    byte_array<Composer> buf;
+template <typename Builder> struct blake3_hasher {
+    uint32<Builder> key[8];
+    uint32<Builder> cv[8];
+    byte_array<Builder> buf;
     uint8_t buf_len;
     uint8_t blocks_compressed;
     uint8_t flags;
-    Composer* context;
+    Builder* context;
 };
 
 /*
@@ -52,16 +52,16 @@ template <typename Composer> struct blake3_hasher {
  * constant parameters and fewer rounds.
  *
  */
-template <typename Composer>
-void compress_pre(uint32<Composer> state[BLAKE3_STATE_SIZE],
-                  const uint32<Composer> cv[8],
-                  const byte_array<Composer>& block,
+template <typename Builder>
+void compress_pre(uint32<Builder> state[BLAKE3_STATE_SIZE],
+                  const uint32<Builder> cv[8],
+                  const byte_array<Builder>& block,
                   uint8_t block_len,
                   uint8_t flags)
 {
-    uint32<Composer> block_words[BLAKE3_STATE_SIZE];
+    uint32<Builder> block_words[BLAKE3_STATE_SIZE];
     for (size_t i = 0; i < BLAKE3_STATE_SIZE; ++i) {
-        block_words[i] = uint32<Composer>(block.slice(i * 4, 4).reverse());
+        block_words[i] = uint32<Builder>(block.slice(i * 4, 4).reverse());
     }
 
     state[0] = cv[0];
@@ -76,28 +76,25 @@ void compress_pre(uint32<Composer> state[BLAKE3_STATE_SIZE],
     state[9] = IV[1];
     state[10] = IV[2];
     state[11] = IV[3];
-    state[12] = uint32<Composer>(block.get_context(), 0);
-    state[13] = uint32<Composer>(block.get_context(), 0);
-    state[14] = uint32<Composer>(block.get_context(), block_len);
-    state[15] = uint32<Composer>(block.get_context(), flags);
+    state[12] = uint32<Builder>(block.get_context(), 0);
+    state[13] = uint32<Builder>(block.get_context(), 0);
+    state[14] = uint32<Builder>(block.get_context(), block_len);
+    state[15] = uint32<Builder>(block.get_context(), flags);
 
-    blake_util::round_fn<Composer>(state, &block_words[0], 0, true);
-    blake_util::round_fn<Composer>(state, &block_words[0], 1, true);
-    blake_util::round_fn<Composer>(state, &block_words[0], 2, true);
-    blake_util::round_fn<Composer>(state, &block_words[0], 3, true);
-    blake_util::round_fn<Composer>(state, &block_words[0], 4, true);
-    blake_util::round_fn<Composer>(state, &block_words[0], 5, true);
-    blake_util::round_fn<Composer>(state, &block_words[0], 6, true);
+    blake_util::round_fn<Builder>(state, &block_words[0], 0, true);
+    blake_util::round_fn<Builder>(state, &block_words[0], 1, true);
+    blake_util::round_fn<Builder>(state, &block_words[0], 2, true);
+    blake_util::round_fn<Builder>(state, &block_words[0], 3, true);
+    blake_util::round_fn<Builder>(state, &block_words[0], 4, true);
+    blake_util::round_fn<Builder>(state, &block_words[0], 5, true);
+    blake_util::round_fn<Builder>(state, &block_words[0], 6, true);
 }
 
-template <typename Composer>
-void blake3_compress_in_place(uint32<Composer> cv[8],
-                              const byte_array<Composer>& block,
-                              uint8_t block_len,
-                              uint8_t flags)
+template <typename Builder>
+void blake3_compress_in_place(uint32<Builder> cv[8], const byte_array<Builder>& block, uint8_t block_len, uint8_t flags)
 {
-    uint32<Composer> state[BLAKE3_STATE_SIZE];
-    compress_pre<Composer>(state, cv, block, block_len, flags);
+    uint32<Builder> state[BLAKE3_STATE_SIZE];
+    compress_pre<Builder>(state, cv, block, block_len, flags);
     cv[0] = state[0] ^ state[8];
     cv[1] = state[1] ^ state[9];
     cv[2] = state[2] ^ state[10];
@@ -108,40 +105,40 @@ void blake3_compress_in_place(uint32<Composer> cv[8],
     cv[7] = state[7] ^ state[15];
 }
 
-template <typename Composer>
-void blake3_compress_xof(const uint32<Composer> cv[8],
-                         const byte_array<Composer>& block,
+template <typename Builder>
+void blake3_compress_xof(const uint32<Builder> cv[8],
+                         const byte_array<Builder>& block,
                          uint8_t block_len,
                          uint8_t flags,
-                         byte_array<Composer>& out)
+                         byte_array<Builder>& out)
 {
-    uint32<Composer> state[BLAKE3_STATE_SIZE];
-    compress_pre<Composer>(state, cv, block, block_len, flags);
+    uint32<Builder> state[BLAKE3_STATE_SIZE];
+    compress_pre<Builder>(state, cv, block, block_len, flags);
 
-    out.write_at(static_cast<byte_array<Composer>>(state[0] ^ state[8]).reverse(), 0 * 4);
-    out.write_at(static_cast<byte_array<Composer>>(state[1] ^ state[9]).reverse(), 1 * 4);
-    out.write_at(static_cast<byte_array<Composer>>(state[2] ^ state[10]).reverse(), 2 * 4);
-    out.write_at(static_cast<byte_array<Composer>>(state[3] ^ state[11]).reverse(), 3 * 4);
-    out.write_at(static_cast<byte_array<Composer>>(state[4] ^ state[12]).reverse(), 4 * 4);
-    out.write_at(static_cast<byte_array<Composer>>(state[5] ^ state[13]).reverse(), 5 * 4);
-    out.write_at(static_cast<byte_array<Composer>>(state[6] ^ state[14]).reverse(), 6 * 4);
-    out.write_at(static_cast<byte_array<Composer>>(state[7] ^ state[15]).reverse(), 7 * 4);
+    out.write_at(static_cast<byte_array<Builder>>(state[0] ^ state[8]).reverse(), 0 * 4);
+    out.write_at(static_cast<byte_array<Builder>>(state[1] ^ state[9]).reverse(), 1 * 4);
+    out.write_at(static_cast<byte_array<Builder>>(state[2] ^ state[10]).reverse(), 2 * 4);
+    out.write_at(static_cast<byte_array<Builder>>(state[3] ^ state[11]).reverse(), 3 * 4);
+    out.write_at(static_cast<byte_array<Builder>>(state[4] ^ state[12]).reverse(), 4 * 4);
+    out.write_at(static_cast<byte_array<Builder>>(state[5] ^ state[13]).reverse(), 5 * 4);
+    out.write_at(static_cast<byte_array<Builder>>(state[6] ^ state[14]).reverse(), 6 * 4);
+    out.write_at(static_cast<byte_array<Builder>>(state[7] ^ state[15]).reverse(), 7 * 4);
 
-    out.write_at(static_cast<byte_array<Composer>>(state[8] ^ cv[0]).reverse(), 8 * 4);
-    out.write_at(static_cast<byte_array<Composer>>(state[9] ^ cv[1]).reverse(), 9 * 4);
-    out.write_at(static_cast<byte_array<Composer>>(state[10] ^ cv[2]).reverse(), 10 * 4);
-    out.write_at(static_cast<byte_array<Composer>>(state[11] ^ cv[3]).reverse(), 11 * 4);
-    out.write_at(static_cast<byte_array<Composer>>(state[12] ^ cv[4]).reverse(), 12 * 4);
-    out.write_at(static_cast<byte_array<Composer>>(state[13] ^ cv[5]).reverse(), 13 * 4);
-    out.write_at(static_cast<byte_array<Composer>>(state[14] ^ cv[6]).reverse(), 14 * 4);
-    out.write_at(static_cast<byte_array<Composer>>(state[15] ^ cv[7]).reverse(), 15 * 4);
+    out.write_at(static_cast<byte_array<Builder>>(state[8] ^ cv[0]).reverse(), 8 * 4);
+    out.write_at(static_cast<byte_array<Builder>>(state[9] ^ cv[1]).reverse(), 9 * 4);
+    out.write_at(static_cast<byte_array<Builder>>(state[10] ^ cv[2]).reverse(), 10 * 4);
+    out.write_at(static_cast<byte_array<Builder>>(state[11] ^ cv[3]).reverse(), 11 * 4);
+    out.write_at(static_cast<byte_array<Builder>>(state[12] ^ cv[4]).reverse(), 12 * 4);
+    out.write_at(static_cast<byte_array<Builder>>(state[13] ^ cv[5]).reverse(), 13 * 4);
+    out.write_at(static_cast<byte_array<Builder>>(state[14] ^ cv[6]).reverse(), 14 * 4);
+    out.write_at(static_cast<byte_array<Builder>>(state[15] ^ cv[7]).reverse(), 15 * 4);
 }
 
 /*
  * Blake3s helper functions.
  *
  */
-template <typename Composer> uint8_t maybe_start_flag(const blake3_hasher<Composer>* self)
+template <typename Builder> uint8_t maybe_start_flag(const blake3_hasher<Builder>* self)
 {
     if (self->blocks_compressed == 0) {
         return CHUNK_START;
@@ -150,24 +147,24 @@ template <typename Composer> uint8_t maybe_start_flag(const blake3_hasher<Compos
     }
 }
 
-template <typename Composer> struct output_t {
-    uint32<Composer> input_cv[8];
-    byte_array<Composer> block;
+template <typename Builder> struct output_t {
+    uint32<Builder> input_cv[8];
+    byte_array<Builder> block;
     uint8_t block_len;
     uint8_t flags;
 };
 
-template <typename Composer>
-output_t<Composer> make_output(const uint32<Composer> input_cv[8],
-                               const byte_array<Composer>& block,
-                               uint8_t block_len,
-                               uint8_t flags)
+template <typename Builder>
+output_t<Builder> make_output(const uint32<Builder> input_cv[8],
+                              const byte_array<Builder>& block,
+                              uint8_t block_len,
+                              uint8_t flags)
 {
-    output_t<Composer> ret;
+    output_t<Builder> ret;
     for (size_t i = 0; i < (BLAKE3_OUT_LEN >> 2); ++i) {
         ret.input_cv[i] = input_cv[i];
     }
-    ret.block = byte_array<Composer>(block.get_context(), BLAKE3_BLOCK_LEN);
+    ret.block = byte_array<Builder>(block.get_context(), BLAKE3_BLOCK_LEN);
     for (size_t i = 0; i < BLAKE3_BLOCK_LEN; i++) {
         ret.block.set_byte(i, block[i]);
     }
@@ -180,23 +177,23 @@ output_t<Composer> make_output(const uint32<Composer> input_cv[8],
  * Blake3s wrapper functions.
  *
  */
-template <typename Composer> void blake3_hasher_init(blake3_hasher<Composer>* self)
+template <typename Builder> void blake3_hasher_init(blake3_hasher<Builder>* self)
 {
     for (size_t i = 0; i < (BLAKE3_KEY_LEN >> 2); ++i) {
         self->key[i] = IV[i];
         self->cv[i] = IV[i];
     }
-    self->buf = byte_array<Composer>(self->context, BLAKE3_BLOCK_LEN);
+    self->buf = byte_array<Builder>(self->context, BLAKE3_BLOCK_LEN);
     for (size_t i = 0; i < BLAKE3_BLOCK_LEN; i++) {
-        self->buf.set_byte(i, field_t<Composer>(self->context, 0));
+        self->buf.set_byte(i, field_t<Builder>(self->context, 0));
     }
     self->buf_len = 0;
     self->blocks_compressed = 0;
     self->flags = 0;
 }
 
-template <typename Composer>
-void blake3_hasher_update(blake3_hasher<Composer>* self, const byte_array<Composer>& input, size_t input_len)
+template <typename Builder>
+void blake3_hasher_update(blake3_hasher<Builder>* self, const byte_array<Builder>& input, size_t input_len)
 {
     if (input_len == 0) {
         return;
@@ -204,10 +201,10 @@ void blake3_hasher_update(blake3_hasher<Composer>* self, const byte_array<Compos
 
     size_t start_counter = 0;
     while (input_len > BLAKE3_BLOCK_LEN) {
-        blake3_compress_in_place<Composer>(self->cv,
-                                           input.slice(start_counter, BLAKE3_BLOCK_LEN),
-                                           BLAKE3_BLOCK_LEN,
-                                           self->flags | maybe_start_flag(self));
+        blake3_compress_in_place<Builder>(self->cv,
+                                          input.slice(start_counter, BLAKE3_BLOCK_LEN),
+                                          BLAKE3_BLOCK_LEN,
+                                          self->flags | maybe_start_flag(self));
         self->blocks_compressed = static_cast<uint8_t>(self->blocks_compressed + 1);
         start_counter += BLAKE3_BLOCK_LEN;
         input_len -= BLAKE3_BLOCK_LEN;
@@ -225,12 +222,12 @@ void blake3_hasher_update(blake3_hasher<Composer>* self, const byte_array<Compos
     input_len -= take;
 }
 
-template <typename Composer> void blake3_hasher_finalize(const blake3_hasher<Composer>* self, byte_array<Composer>& out)
+template <typename Builder> void blake3_hasher_finalize(const blake3_hasher<Builder>* self, byte_array<Builder>& out)
 {
     uint8_t block_flags = self->flags | maybe_start_flag(self) | CHUNK_END;
-    output_t<Composer> output = make_output<Composer>(self->cv, self->buf, self->buf_len, block_flags);
+    output_t<Builder> output = make_output<Builder>(self->cv, self->buf, self->buf_len, block_flags);
 
-    byte_array<Composer> wide_buf(out.get_context(), BLAKE3_BLOCK_LEN);
+    byte_array<Builder> wide_buf(out.get_context(), BLAKE3_BLOCK_LEN);
     blake3_compress_xof(output.input_cv, output.block, output.block_len, output.flags | ROOT, wide_buf);
     for (size_t i = 0; i < BLAKE3_OUT_LEN; i++) {
         out.set_byte(i, wide_buf[i]);
@@ -242,18 +239,18 @@ template <typename Composer> void blake3_hasher_finalize(const blake3_hasher<Com
 
 using namespace blake3_internal;
 
-template <typename Composer> byte_array<Composer> blake3s(const byte_array<Composer>& input)
+template <typename Builder> byte_array<Builder> blake3s(const byte_array<Builder>& input)
 {
-    if constexpr (HasPlookup<Composer>) {
-        return blake3s_plookup::blake3s<Composer>(input);
+    if constexpr (HasPlookup<Builder>) {
+        return blake3s_plookup::blake3s<Builder>(input);
     }
 
-    blake3_hasher<Composer> hasher = {};
+    blake3_hasher<Builder> hasher = {};
     hasher.context = input.get_context();
-    blake3_hasher_init<Composer>(&hasher);
-    blake3_hasher_update<Composer>(&hasher, input, input.size());
-    byte_array<Composer> result(input.get_context(), BLAKE3_OUT_LEN);
-    blake3_hasher_finalize<Composer>(&hasher, result);
+    blake3_hasher_init<Builder>(&hasher);
+    blake3_hasher_update<Builder>(&hasher, input, input.size());
+    byte_array<Builder> result(input.get_context(), BLAKE3_OUT_LEN);
+    blake3_hasher_finalize<Builder>(&hasher, result);
     return result;
 }
 
diff --git a/barretenberg/cpp/src/barretenberg/stdlib/hash/blake3s/blake3s.hpp b/barretenberg/cpp/src/barretenberg/stdlib/hash/blake3s/blake3s.hpp
index fa032e57a2c..141860ea9e5 100644
--- a/barretenberg/cpp/src/barretenberg/stdlib/hash/blake3s/blake3s.hpp
+++ b/barretenberg/cpp/src/barretenberg/stdlib/hash/blake3s/blake3s.hpp
@@ -5,7 +5,7 @@
 namespace proof_system::plonk {
 namespace stdlib {
 
-template <typename Composer> byte_array<Composer> blake3s(const byte_array<Composer>& input);
+template <typename Builder> byte_array<Builder> blake3s(const byte_array<Builder>& input);
 #define BLAKE3S(circuit_type) byte_array<circuit_type> blake3s(const byte_array<circuit_type>& input);
 
 EXTERN_STDLIB_METHOD(BLAKE3S)
diff --git a/barretenberg/cpp/src/barretenberg/stdlib/hash/blake3s/blake3s.test.cpp b/barretenberg/cpp/src/barretenberg/stdlib/hash/blake3s/blake3s.test.cpp
index 9a48d1df17e..06ec006981c 100644
--- a/barretenberg/cpp/src/barretenberg/stdlib/hash/blake3s/blake3s.test.cpp
+++ b/barretenberg/cpp/src/barretenberg/stdlib/hash/blake3s/blake3s.test.cpp
@@ -7,84 +7,84 @@
 using namespace barretenberg;
 using namespace proof_system::plonk;
 
-typedef proof_system::TurboCircuitBuilder Composer;
-typedef stdlib::byte_array<Composer> byte_array;
+typedef proof_system::TurboCircuitBuilder Builder;
+typedef stdlib::byte_array<Builder> byte_array;
 typedef stdlib::byte_array<proof_system::UltraCircuitBuilder> byte_array_plookup;
-typedef stdlib::public_witness_t<Composer> public_witness_t;
+typedef stdlib::public_witness_t<Builder> public_witness_t;
 typedef stdlib::public_witness_t<proof_system::UltraCircuitBuilder> public_witness_t_plookup;
 
 TEST(stdlib_blake3s, test_single_block)
 {
-    Composer composer = Composer();
+    Builder builder = Builder();
     std::string input = "abcdefghijklmnopqrstuvwxyz0123456789abcdefghijklmnopqrstuvwxyz01";
     std::vector<uint8_t> input_v(input.begin(), input.end());
 
-    byte_array input_arr(&composer, input_v);
+    byte_array input_arr(&builder, input_v);
     byte_array output = stdlib::blake3s(input_arr);
 
     std::vector<uint8_t> expected = blake3::blake3s(input_v);
 
     EXPECT_EQ(output.get_value(), expected);
 
-    info("composer gates = ", composer.get_num_gates());
+    info("builder gates = ", builder.get_num_gates());
 
-    bool proof_result = composer.check_circuit();
+    bool proof_result = builder.check_circuit();
     EXPECT_EQ(proof_result, true);
 }
 
 TEST(stdlib_blake3s, test_single_block_plookup)
 {
-    proof_system::UltraCircuitBuilder composer = proof_system::UltraCircuitBuilder();
+    proof_system::UltraCircuitBuilder builder = proof_system::UltraCircuitBuilder();
     std::string input = "abcdefghijklmnopqrstuvwxyz0123456789abcdefghijklmnopqrstuvwxyz01";
     std::vector<uint8_t> input_v(input.begin(), input.end());
 
-    byte_array_plookup input_arr(&composer, input_v);
+    byte_array_plookup input_arr(&builder, input_v);
     byte_array_plookup output = stdlib::blake3s<proof_system::UltraCircuitBuilder>(input_arr);
 
     std::vector<uint8_t> expected = blake3::blake3s(input_v);
 
     EXPECT_EQ(output.get_value(), expected);
 
-    info("composer gates = ", composer.get_num_gates());
+    info("builder gates = ", builder.get_num_gates());
 
-    bool proof_result = composer.check_circuit();
+    bool proof_result = builder.check_circuit();
     EXPECT_EQ(proof_result, true);
 }
 
 TEST(stdlib_blake3s, test_double_block)
 {
-    Composer composer = Composer();
+    Builder builder = Builder();
     std::string input = "abcdefghijklmnopqrstuvwxyz0123456789abcdefghijklmnopqrstuvwxyz0123456789";
     std::vector<uint8_t> input_v(input.begin(), input.end());
 
-    byte_array input_arr(&composer, input_v);
+    byte_array input_arr(&builder, input_v);
     byte_array output = stdlib::blake3s(input_arr);
 
     std::vector<uint8_t> expected = blake3::blake3s(input_v);
 
     EXPECT_EQ(output.get_value(), expected);
 
-    info("composer gates = ", composer.get_num_gates());
+    info("builder gates = ", builder.get_num_gates());
 
-    bool proof_result = composer.check_circuit();
+    bool proof_result = builder.check_circuit();
     EXPECT_EQ(proof_result, true);
 }
 
 TEST(stdlib_blake3s, test_double_block_plookup)
 {
-    proof_system::UltraCircuitBuilder composer = proof_system::UltraCircuitBuilder();
+    proof_system::UltraCircuitBuilder builder = proof_system::UltraCircuitBuilder();
     std::string input = "abcdefghijklmnopqrstuvwxyz0123456789abcdefghijklmnopqrstuvwxyz0123456789";
     std::vector<uint8_t> input_v(input.begin(), input.end());
 
-    byte_array_plookup input_arr(&composer, input_v);
+    byte_array_plookup input_arr(&builder, input_v);
     byte_array_plookup output = stdlib::blake3s(input_arr);
 
     std::vector<uint8_t> expected = blake3::blake3s(input_v);
 
     EXPECT_EQ(output.get_value(), expected);
 
-    info("composer gates = ", composer.get_num_gates());
+    info("builder gates = ", builder.get_num_gates());
 
-    bool proof_result = composer.check_circuit();
+    bool proof_result = builder.check_circuit();
     EXPECT_EQ(proof_result, true);
 }
diff --git a/barretenberg/cpp/src/barretenberg/stdlib/hash/blake3s/blake3s_plookup.cpp b/barretenberg/cpp/src/barretenberg/stdlib/hash/blake3s/blake3s_plookup.cpp
index 04540fdb28e..66d681ba4bb 100644
--- a/barretenberg/cpp/src/barretenberg/stdlib/hash/blake3s/blake3s_plookup.cpp
+++ b/barretenberg/cpp/src/barretenberg/stdlib/hash/blake3s/blake3s_plookup.cpp
@@ -43,14 +43,14 @@ enum blake3s_constant {
 constexpr uint32_t IV[8] = { 0x6A09E667UL, 0xBB67AE85UL, 0x3C6EF372UL, 0xA54FF53AUL,
                              0x510E527FUL, 0x9B05688CUL, 0x1F83D9ABUL, 0x5BE0CD19UL };
 
-template <typename Composer> struct blake3_hasher {
-    field_t<Composer> key[8];
-    field_t<Composer> cv[8];
-    byte_array<Composer> buf;
+template <typename Builder> struct blake3_hasher {
+    field_t<Builder> key[8];
+    field_t<Builder> cv[8];
+    byte_array<Builder> buf;
     uint8_t buf_len;
     uint8_t blocks_compressed;
     uint8_t flags;
-    Composer* context;
+    Builder* context;
 };
 
 /*
@@ -58,14 +58,14 @@ template <typename Composer> struct blake3_hasher {
  * constant parameters and fewer rounds.
  *
  */
-template <typename Composer>
-void compress_pre(field_t<Composer> state[BLAKE3_STATE_SIZE],
-                  const field_t<Composer> cv[8],
-                  const byte_array<Composer>& block,
+template <typename Builder>
+void compress_pre(field_t<Builder> state[BLAKE3_STATE_SIZE],
+                  const field_t<Builder> cv[8],
+                  const byte_array<Builder>& block,
                   uint8_t block_len,
                   uint8_t flags)
 {
-    typedef field_t<Composer> field_pt;
+    typedef field_t<Builder> field_pt;
     field_pt block_words[BLAKE3_STATE_SIZE];
     for (size_t i = 0; i < BLAKE3_STATE_SIZE; ++i) {
         block_words[i] = field_pt(block.slice(i * 4, 4).reverse());
@@ -88,24 +88,24 @@ void compress_pre(field_t<Composer> state[BLAKE3_STATE_SIZE],
     state[14] = field_pt(block.get_context(), uint256_t(block_len));
     state[15] = field_pt(block.get_context(), uint256_t(flags));
 
-    blake_util::round_fn_lookup<Composer>(state, &block_words[0], 0, true);
-    blake_util::round_fn_lookup<Composer>(state, &block_words[0], 1, true);
-    blake_util::round_fn_lookup<Composer>(state, &block_words[0], 2, true);
-    blake_util::round_fn_lookup<Composer>(state, &block_words[0], 3, true);
-    blake_util::round_fn_lookup<Composer>(state, &block_words[0], 4, true);
-    blake_util::round_fn_lookup<Composer>(state, &block_words[0], 5, true);
-    blake_util::round_fn_lookup<Composer>(state, &block_words[0], 6, true);
+    blake_util::round_fn_lookup<Builder>(state, &block_words[0], 0, true);
+    blake_util::round_fn_lookup<Builder>(state, &block_words[0], 1, true);
+    blake_util::round_fn_lookup<Builder>(state, &block_words[0], 2, true);
+    blake_util::round_fn_lookup<Builder>(state, &block_words[0], 3, true);
+    blake_util::round_fn_lookup<Builder>(state, &block_words[0], 4, true);
+    blake_util::round_fn_lookup<Builder>(state, &block_words[0], 5, true);
+    blake_util::round_fn_lookup<Builder>(state, &block_words[0], 6, true);
 }
 
-template <typename Composer>
-void blake3_compress_in_place(field_t<Composer> cv[8],
-                              const byte_array<Composer>& block,
+template <typename Builder>
+void blake3_compress_in_place(field_t<Builder> cv[8],
+                              const byte_array<Builder>& block,
                               uint8_t block_len,
                               uint8_t flags)
 {
-    typedef field_t<Composer> field_pt;
+    typedef field_t<Builder> field_pt;
     field_pt state[BLAKE3_STATE_SIZE];
-    compress_pre<Composer>(state, cv, block, block_len, flags);
+    compress_pre<Builder>(state, cv, block, block_len, flags);
 
     /**
      * At this point in the algorithm, a malicious prover could tweak the add_normalise function in `blake_util.hpp` to
@@ -115,34 +115,34 @@ void blake3_compress_in_place(field_t<Composer> cv[8],
      * contrained to 32 bits.
      */
     for (size_t i = 0; i < (BLAKE3_STATE_SIZE >> 1); i++) {
-        const auto lookup = plookup_read<Composer>::get_lookup_accumulators(BLAKE_XOR, state[i], state[i + 8], true);
+        const auto lookup = plookup_read<Builder>::get_lookup_accumulators(BLAKE_XOR, state[i], state[i + 8], true);
         cv[i] = lookup[ColumnIdx::C3][0];
     }
 }
 
-template <typename Composer>
-void blake3_compress_xof(const field_t<Composer> cv[8],
-                         const byte_array<Composer>& block,
+template <typename Builder>
+void blake3_compress_xof(const field_t<Builder> cv[8],
+                         const byte_array<Builder>& block,
                          uint8_t block_len,
                          uint8_t flags,
-                         byte_array<Composer>& out)
+                         byte_array<Builder>& out)
 {
-    typedef field_t<Composer> field_pt;
+    typedef field_t<Builder> field_pt;
     field_pt state[BLAKE3_STATE_SIZE];
 
-    compress_pre<Composer>(state, cv, block, block_len, flags);
+    compress_pre<Builder>(state, cv, block, block_len, flags);
 
     /**
      * The same note as in the above `blake3_compress_in_place()` function. Here too, reading from the lookup table
      * ensures that correct 32-bit inputs are used.
      */
     for (size_t i = 0; i < (BLAKE3_STATE_SIZE >> 1); i++) {
-        const auto lookup_1 = plookup_read<Composer>::get_lookup_accumulators(BLAKE_XOR, state[i], state[i + 8], true);
-        byte_array<Composer> out_bytes_1(lookup_1[ColumnIdx::C3][0], 4);
+        const auto lookup_1 = plookup_read<Builder>::get_lookup_accumulators(BLAKE_XOR, state[i], state[i + 8], true);
+        byte_array<Builder> out_bytes_1(lookup_1[ColumnIdx::C3][0], 4);
         out.write_at(out_bytes_1.reverse(), i * 4);
 
-        const auto lookup_2 = plookup_read<Composer>::get_lookup_accumulators(BLAKE_XOR, state[i + 8], cv[i], true);
-        byte_array<Composer> out_bytes_2(lookup_2[ColumnIdx::C3][0], 4);
+        const auto lookup_2 = plookup_read<Builder>::get_lookup_accumulators(BLAKE_XOR, state[i + 8], cv[i], true);
+        byte_array<Builder> out_bytes_2(lookup_2[ColumnIdx::C3][0], 4);
         out.write_at(out_bytes_2.reverse(), (i + 8) * 4);
     }
 }
@@ -151,7 +151,7 @@ void blake3_compress_xof(const field_t<Composer> cv[8],
  * Blake3s helper functions.
  *
  */
-template <typename Composer> uint8_t maybe_start_flag(const blake3_hasher<Composer>* self)
+template <typename Builder> uint8_t maybe_start_flag(const blake3_hasher<Builder>* self)
 {
     if (self->blocks_compressed == 0) {
         return CHUNK_START;
@@ -160,24 +160,24 @@ template <typename Composer> uint8_t maybe_start_flag(const blake3_hasher<Compos
     }
 }
 
-template <typename Composer> struct output_t {
-    field_t<Composer> input_cv[8];
-    byte_array<Composer> block;
+template <typename Builder> struct output_t {
+    field_t<Builder> input_cv[8];
+    byte_array<Builder> block;
     uint8_t block_len;
     uint8_t flags;
 };
 
-template <typename Composer>
-output_t<Composer> make_output(const field_t<Composer> input_cv[8],
-                               const byte_array<Composer>& block,
-                               uint8_t block_len,
-                               uint8_t flags)
+template <typename Builder>
+output_t<Builder> make_output(const field_t<Builder> input_cv[8],
+                              const byte_array<Builder>& block,
+                              uint8_t block_len,
+                              uint8_t flags)
 {
-    output_t<Composer> ret;
+    output_t<Builder> ret;
     for (size_t i = 0; i < (BLAKE3_OUT_LEN >> 2); ++i) {
         ret.input_cv[i] = input_cv[i];
     }
-    ret.block = byte_array<Composer>(block.get_context(), BLAKE3_BLOCK_LEN);
+    ret.block = byte_array<Builder>(block.get_context(), BLAKE3_BLOCK_LEN);
     for (size_t i = 0; i < BLAKE3_BLOCK_LEN; i++) {
         ret.block.set_byte(i, block[i]);
     }
@@ -190,14 +190,14 @@ output_t<Composer> make_output(const field_t<Composer> input_cv[8],
  * Blake3s wrapper functions.
  *
  */
-template <typename Composer> void blake3_hasher_init(blake3_hasher<Composer>* self)
+template <typename Builder> void blake3_hasher_init(blake3_hasher<Builder>* self)
 {
-    typedef field_t<Composer> field_pt;
+    typedef field_t<Builder> field_pt;
     for (size_t i = 0; i < (BLAKE3_KEY_LEN >> 2); ++i) {
         self->key[i] = field_pt(uint256_t(IV[i]));
         self->cv[i] = field_pt(uint256_t(IV[i]));
     }
-    self->buf = byte_array<Composer>(self->context, BLAKE3_BLOCK_LEN);
+    self->buf = byte_array<Builder>(self->context, BLAKE3_BLOCK_LEN);
     for (size_t i = 0; i < BLAKE3_BLOCK_LEN; i++) {
         self->buf.set_byte(i, field_pt(self->context, 0));
     }
@@ -206,8 +206,8 @@ template <typename Composer> void blake3_hasher_init(blake3_hasher<Composer>* se
     self->flags = 0;
 }
 
-template <typename Composer>
-void blake3_hasher_update(blake3_hasher<Composer>* self, const byte_array<Composer>& input, size_t input_len)
+template <typename Builder>
+void blake3_hasher_update(blake3_hasher<Builder>* self, const byte_array<Builder>& input, size_t input_len)
 {
     if (input_len == 0) {
         return;
@@ -215,10 +215,10 @@ void blake3_hasher_update(blake3_hasher<Composer>* self, const byte_array<Compos
 
     size_t start_counter = 0;
     while (input_len > BLAKE3_BLOCK_LEN) {
-        blake3_compress_in_place<Composer>(self->cv,
-                                           input.slice(start_counter, BLAKE3_BLOCK_LEN),
-                                           BLAKE3_BLOCK_LEN,
-                                           self->flags | maybe_start_flag(self));
+        blake3_compress_in_place<Builder>(self->cv,
+                                          input.slice(start_counter, BLAKE3_BLOCK_LEN),
+                                          BLAKE3_BLOCK_LEN,
+                                          self->flags | maybe_start_flag(self));
         self->blocks_compressed = static_cast<uint8_t>(self->blocks_compressed + 1);
         start_counter += BLAKE3_BLOCK_LEN;
         input_len -= BLAKE3_BLOCK_LEN;
@@ -236,12 +236,12 @@ void blake3_hasher_update(blake3_hasher<Composer>* self, const byte_array<Compos
     input_len -= take;
 }
 
-template <typename Composer> void blake3_hasher_finalize(const blake3_hasher<Composer>* self, byte_array<Composer>& out)
+template <typename Builder> void blake3_hasher_finalize(const blake3_hasher<Builder>* self, byte_array<Builder>& out)
 {
     uint8_t block_flags = self->flags | maybe_start_flag(self) | CHUNK_END;
-    output_t<Composer> output = make_output<Composer>(self->cv, self->buf, self->buf_len, block_flags);
+    output_t<Builder> output = make_output<Builder>(self->cv, self->buf, self->buf_len, block_flags);
 
-    byte_array<Composer> wide_buf(out.get_context(), BLAKE3_BLOCK_LEN);
+    byte_array<Builder> wide_buf(out.get_context(), BLAKE3_BLOCK_LEN);
     blake3_compress_xof(output.input_cv, output.block, output.block_len, output.flags | ROOT, wide_buf);
     for (size_t i = 0; i < BLAKE3_OUT_LEN; i++) {
         out.set_byte(i, wide_buf[i]);
@@ -249,14 +249,14 @@ template <typename Composer> void blake3_hasher_finalize(const blake3_hasher<Com
     return;
 }
 
-template <typename Composer> byte_array<Composer> blake3s(const byte_array<Composer>& input)
+template <typename Builder> byte_array<Builder> blake3s(const byte_array<Builder>& input)
 {
-    blake3_hasher<Composer> hasher = {};
+    blake3_hasher<Builder> hasher = {};
     hasher.context = input.get_context();
-    blake3_hasher_init<Composer>(&hasher);
-    blake3_hasher_update<Composer>(&hasher, input, input.size());
-    byte_array<Composer> result(input.get_context(), BLAKE3_OUT_LEN);
-    blake3_hasher_finalize<Composer>(&hasher, result);
+    blake3_hasher_init<Builder>(&hasher);
+    blake3_hasher_update<Builder>(&hasher, input, input.size());
+    byte_array<Builder> result(input.get_context(), BLAKE3_OUT_LEN);
+    blake3_hasher_finalize<Builder>(&hasher, result);
     return result;
 }
 
diff --git a/barretenberg/cpp/src/barretenberg/stdlib/hash/blake3s/blake3s_plookup.hpp b/barretenberg/cpp/src/barretenberg/stdlib/hash/blake3s/blake3s_plookup.hpp
index 1fec0298b21..6cecfa26ba3 100644
--- a/barretenberg/cpp/src/barretenberg/stdlib/hash/blake3s/blake3s_plookup.hpp
+++ b/barretenberg/cpp/src/barretenberg/stdlib/hash/blake3s/blake3s_plookup.hpp
@@ -14,7 +14,7 @@ namespace stdlib {
 
 namespace blake3s_plookup {
 
-template <typename Composer> byte_array<Composer> blake3s(const byte_array<Composer>& input);
+template <typename Builder> byte_array<Builder> blake3s(const byte_array<Builder>& input);
 
 #define BLAKE3S_PLOOKUP(circuit_type) byte_array<circuit_type> blake3s(const byte_array<circuit_type>& input)
 
diff --git a/barretenberg/cpp/src/barretenberg/stdlib/hash/keccak/keccak.cpp b/barretenberg/cpp/src/barretenberg/stdlib/hash/keccak/keccak.cpp
index 8ef249a47dd..2ff044e13fe 100644
--- a/barretenberg/cpp/src/barretenberg/stdlib/hash/keccak/keccak.cpp
+++ b/barretenberg/cpp/src/barretenberg/stdlib/hash/keccak/keccak.cpp
@@ -21,11 +21,11 @@ using namespace plookup;
  * @tparam lane_index What keccak lane are we working on?
  * @param limb Input limb we want to normalize and rotate
  * @param msb (return parameter) The most significant bit of the normalized and rotated limb
- * @return field_t<Composer> The normalized and rotated output
+ * @return field_t<Builder> The normalized and rotated output
  */
-template <typename Composer>
+template <typename Builder>
 template <size_t lane_index>
-field_t<Composer> keccak<Composer>::normalize_and_rotate(const field_ct& limb, field_ct& msb)
+field_t<Builder> keccak<Builder>::normalize_and_rotate(const field_ct& limb, field_ct& msb)
 {
     // left_bits = the number of bits that wrap around 11^64 (left_bits)
     constexpr size_t left_bits = ROTATIONS[lane_index];
@@ -121,7 +121,7 @@ field_t<Composer> keccak<Composer>::normalize_and_rotate(const field_ct& limb, f
             const uint64_t normalized_msb = (static_cast<uint64_t>(normalized_slice) / msb_divisor);
             lookup[ColumnIdx::C3].push_back(normalized_msb);
 
-            // We need to provide a key/value object for this lookup in order for the Composer
+            // We need to provide a key/value object for this lookup in order for the Builder
             // to compute the plookup sorted list commitment
             const auto [input_quotient, input_slice] = input.divmod(divisor);
             lookup.key_entries.push_back(
@@ -140,7 +140,7 @@ field_t<Composer> keccak<Composer>::normalize_and_rotate(const field_ct& limb, f
     compute_lookup_witnesses_for_limb.template operator()<right_bits, num_right_tables>(right_normalized);
     compute_lookup_witnesses_for_limb.template operator()<left_bits, num_left_tables>(left_normalized);
 
-    // Call composer method to create plookup constraints.
+    // Call builder method to create plookup constraints.
     // The MultiTable table index can be derived from `lane_idx`
     // Each lane_idx has a different rotation amount, which changes sizes of left/right slices
     // and therefore the selector constants required (i.e. the Q1, Q2, Q3 values in the earlier example)
@@ -154,15 +154,15 @@ field_t<Composer> keccak<Composer>::normalize_and_rotate(const field_ct& limb, f
                                        accumulator_witnesses[ColumnIdx::C3][num_left_tables + num_right_tables - 1]);
 
     // Extract the witness that maps to the normalized right slice
-    const field_t<Composer> right_output =
-        field_t<Composer>::from_witness_index(limb.get_context(), accumulator_witnesses[ColumnIdx::C2][0]);
+    const field_t<Builder> right_output =
+        field_t<Builder>::from_witness_index(limb.get_context(), accumulator_witnesses[ColumnIdx::C2][0]);
 
     if (num_left_tables == 0) {
         // if the left slice size is 0 bits (i.e. no rotation), return `right_output`
         return right_output;
     } else {
         // Extract the normalized left slice
-        const field_t<Composer> left_output = field_t<Composer>::from_witness_index(
+        const field_t<Builder> left_output = field_t<Builder>::from_witness_index(
             limb.get_context(), accumulator_witnesses[ColumnIdx::C2][num_right_tables]);
 
         // Stitch the right/left slices together to create our rotated output
@@ -184,10 +184,10 @@ field_t<Composer> keccak<Composer>::normalize_and_rotate(const field_ct& limb, f
  * The equivalent of XOR(A, ROTL(B, 1)) is A.twist + 2B.twist (in base-11 form)
  * The output is present in bit slices 1-64
  *
- * @tparam Composer
+ * @tparam Builder
  * @param internal
  */
-template <typename Composer> void keccak<Composer>::compute_twisted_state(keccak_state& internal)
+template <typename Builder> void keccak<Builder>::compute_twisted_state(keccak_state& internal)
 {
     for (size_t i = 0; i < NUM_KECCAK_LANES; ++i) {
         internal.twisted_state[i] = ((internal.state[i] * 11) + internal.state_msb[i]).normalize();
@@ -197,7 +197,7 @@ template <typename Composer> void keccak<Composer>::compute_twisted_state(keccak
 /**
  * @brief THETA round
  *
- * @tparam Composer
+ * @tparam Builder
  *
  * THETA consists of XOR operations as well as left rotations by 1 bit.
  *
@@ -241,7 +241,7 @@ template <typename Composer> void keccak<Composer>::compute_twisted_state(keccak
  *
  * Total cost of theta = 20.5 gates per 5 lanes + 25 = 127.5 per round
  */
-template <typename Composer> void keccak<Composer>::theta(keccak_state& internal)
+template <typename Builder> void keccak<Builder>::theta(keccak_state& internal)
 {
     std::array<field_ct, 5> C;
     std::array<field_ct, 5> D;
@@ -320,11 +320,11 @@ template <typename Composer> void keccak<Composer>::theta(keccak_state& internal
             // | hi | mid | lo | X  |
             // | P0 | P1  | P2 | Y  |
             // To save a gate, we would need to place the wires for the first KECCAK_THETA_OUTPUT plookup gate
-            // at P0, P1, P2. This is fiddly composer logic that is circuit-width-dependent
+            // at P0, P1, P2. This is fiddly builder logic that is circuit-width-dependent
             // (this would save 120 gates per hash block... not worth making the code less readable for that)
-            D[i] = plookup_read<Composer>::read_from_1_to_2_table(KECCAK_THETA_OUTPUT, mid);
+            D[i] = plookup_read<Builder>::read_from_1_to_2_table(KECCAK_THETA_OUTPUT, mid);
         } else {
-            const auto accumulators = plookup_read<Composer>::get_lookup_accumulators(KECCAK_THETA_OUTPUT, D[i]);
+            const auto accumulators = plookup_read<Builder>::get_lookup_accumulators(KECCAK_THETA_OUTPUT, D[i]);
             D[i] = accumulators[ColumnIdx::C2][0];
 
             // Ensure input to lookup is < 11^64,
@@ -335,8 +335,8 @@ template <typename Composer> void keccak<Composer>::theta(keccak_state& internal
             // prevents an extra range table from being created
             constexpr uint256_t maximum = BASE.pow(64 % plookup::keccak_tables::Theta::TABLE_BITS);
             const field_ct target = -most_significant_slice + maximum;
-            ASSERT(((uint256_t(1) << Composer::DEFAULT_PLOOKUP_RANGE_BITNUM) - 1) > maximum);
-            target.create_range_constraint(Composer::DEFAULT_PLOOKUP_RANGE_BITNUM,
+            ASSERT(((uint256_t(1) << Builder::DEFAULT_PLOOKUP_RANGE_BITNUM) - 1) > maximum);
+            target.create_range_constraint(Builder::DEFAULT_PLOOKUP_RANGE_BITNUM,
                                            "input to KECCAK_THETA_OUTPUT too large!");
         }
     }
@@ -352,7 +352,7 @@ template <typename Composer> void keccak<Composer>::theta(keccak_state& internal
 /**
  * @brief RHO round
  *
- * @tparam Composer
+ * @tparam Builder
  *
  * The limbs of internal.state are represented via base-11 integers
  *  limb = \sum_{i=0}^63 b_i * 11^i
@@ -375,7 +375,7 @@ template <typename Composer> void keccak<Composer>::theta(keccak_state& internal
  * N.B. Can reduce lookup costs by using larger lookup tables.
  * Current algo is optimized for lookup tables where sum of all table sizes is < 2^64
  */
-template <typename Composer> void keccak<Composer>::rho(keccak_state& internal)
+template <typename Builder> void keccak<Builder>::rho(keccak_state& internal)
 {
     constexpr_for<0, NUM_KECCAK_LANES, 1>(
         [&]<size_t i>() { internal.state[i] = normalize_and_rotate<i>(internal.state[i], internal.state_msb[i]); });
@@ -387,10 +387,10 @@ template <typename Composer> void keccak<Composer>::rho(keccak_state& internal)
  * PI permutes the keccak lanes. Adds 0 constraints as this is simply a
  * re-ordering of witnesses
  *
- * @tparam Composer
+ * @tparam Builder
  * @param internal
  */
-template <typename Composer> void keccak<Composer>::pi(keccak_state& internal)
+template <typename Builder> void keccak<Builder>::pi(keccak_state& internal)
 {
     std::array<field_ct, NUM_KECCAK_LANES> B;
 
@@ -424,9 +424,9 @@ template <typename Composer> void keccak<Composer>::pi(keccak_state& internal)
  *
  * N.B. the KECCAK_CHI_OUTPUT table also has a column for the most significant bit of each lookup.
  *      We use this to create a 'twisted representation of each hash lane (see THETA comments for more details)
- * @tparam Composer
+ * @tparam Builder
  */
-template <typename Composer> void keccak<Composer>::chi(keccak_state& internal)
+template <typename Builder> void keccak<Builder>::chi(keccak_state& internal)
 {
     // (cost = 12 * 25 = 300?)
     auto& state = internal.state;
@@ -443,7 +443,7 @@ template <typename Composer> void keccak<Composer>::chi(keccak_state& internal)
         }
         for (size_t x = 0; x < 5; ++x) {
             // Normalize lane outputs and assign to internal.state
-            auto accumulators = plookup_read<Composer>::get_lookup_accumulators(KECCAK_CHI_OUTPUT, lane_outputs[x]);
+            auto accumulators = plookup_read<Builder>::get_lookup_accumulators(KECCAK_CHI_OUTPUT, lane_outputs[x]);
             internal.state[y * 5 + x] = accumulators[ColumnIdx::C2][0];
             internal.state_msb[y * 5 + x] = accumulators[ColumnIdx::C3][accumulators[ColumnIdx::C3].size() - 1];
         }
@@ -455,11 +455,11 @@ template <typename Composer> void keccak<Composer>::chi(keccak_state& internal)
  *
  * XOR first hash limb with a precomputed constant.
  * We re-use the RHO_OUTPUT table to normalize after this operation
- * @tparam Composer
+ * @tparam Builder
  * @param internal
  * @param round
  */
-template <typename Composer> void keccak<Composer>::iota(keccak_state& internal, size_t round)
+template <typename Builder> void keccak<Builder>::iota(keccak_state& internal, size_t round)
 {
     const field_ct xor_result = internal.state[0] + SPARSE_RC[round];
 
@@ -472,7 +472,7 @@ template <typename Composer> void keccak<Composer>::iota(keccak_state& internal,
     }
 }
 
-template <typename Composer> void keccak<Composer>::keccakf1600(keccak_state& internal)
+template <typename Builder> void keccak<Builder>::keccakf1600(keccak_state& internal)
 {
     for (size_t i = 0; i < NUM_KECCAK_ROUNDS; ++i) {
         theta(internal);
@@ -483,11 +483,11 @@ template <typename Composer> void keccak<Composer>::keccakf1600(keccak_state& in
     }
 }
 
-template <typename Composer>
-void keccak<Composer>::sponge_absorb(keccak_state& internal,
-                                     const std::vector<field_ct>& input_buffer,
-                                     const std::vector<field_ct>& msb_buffer,
-                                     const field_ct& num_blocks_with_data)
+template <typename Builder>
+void keccak<Builder>::sponge_absorb(keccak_state& internal,
+                                    const std::vector<field_ct>& input_buffer,
+                                    const std::vector<field_ct>& msb_buffer,
+                                    const field_ct& num_blocks_with_data)
 {
     const size_t l = input_buffer.size();
 
@@ -532,13 +532,13 @@ void keccak<Composer>::sponge_absorb(keccak_state& internal,
     }
 }
 
-template <typename Composer> byte_array<Composer> keccak<Composer>::sponge_squeeze(keccak_state& internal)
+template <typename Builder> byte_array<Builder> keccak<Builder>::sponge_squeeze(keccak_state& internal)
 {
     byte_array_ct result(internal.context);
 
     // Each hash limb represents a little-endian integer. Need to reverse bytes before we write into the output array
     for (size_t i = 0; i < 4; ++i) {
-        field_ct output_limb = plookup_read<Composer>::read_from_1_to_2_table(KECCAK_FORMAT_OUTPUT, internal.state[i]);
+        field_ct output_limb = plookup_read<Builder>::read_from_1_to_2_table(KECCAK_FORMAT_OUTPUT, internal.state[i]);
         byte_array_ct limb_bytes(output_limb, 8);
         byte_array_ct little_endian_limb_bytes(internal.context, 8);
         little_endian_limb_bytes.set_byte(0, limb_bytes[7]);
@@ -561,13 +561,13 @@ template <typename Composer> byte_array<Composer> keccak<Composer>::sponge_squee
  *        (0x1 inserted after the final byte of input data)
  *        (0x80 inserted at the end of the final block)
  *
- * @tparam Composer
+ * @tparam Builder
  * @param input
  * @param num_bytes
- * @return std::vector<field_t<Composer>>
+ * @return std::vector<field_t<Builder>>
  */
-template <typename Composer>
-std::vector<field_t<Composer>> keccak<Composer>::format_input_lanes(byte_array_ct& _input, const uint32_ct& num_bytes)
+template <typename Builder>
+std::vector<field_t<Builder>> keccak<Builder>::format_input_lanes(byte_array_ct& _input, const uint32_ct& num_bytes)
 {
     byte_array_ct input(_input);
 
@@ -677,7 +677,7 @@ std::vector<field_t<Composer>> keccak<Composer>::format_input_lanes(byte_array_c
 
     // validate the number of lanes is less than the default plookup size (we use the default size to do a cheap `<`
     // check later on. Should be fine as this translates to ~2MB of input data)
-    ASSERT(uint256_t(sliced_buffer.size()) < (uint256_t(1ULL) << Composer::DEFAULT_PLOOKUP_RANGE_BITNUM));
+    ASSERT(uint256_t(sliced_buffer.size()) < (uint256_t(1ULL) << Builder::DEFAULT_PLOOKUP_RANGE_BITNUM));
 
     // If the terminating input byte index matches the terminating block byte index, we set the byte to 0x80.
     // If we trigger this case, set `terminating_index_limb_addition` to 0 so that we do not write `0x01 + 0x80`
@@ -689,7 +689,7 @@ std::vector<field_t<Composer>> keccak<Composer>::format_input_lanes(byte_array_c
     for (size_t i = 0; i < sliced_buffer.size(); ++i) {
         // If i > terminating_index, limb must be 0
         bool_ct limb_must_be_zeroes =
-            terminating_index.template ranged_less_than<Composer::DEFAULT_PLOOKUP_RANGE_BITNUM>(field_ct(i));
+            terminating_index.template ranged_less_than<Builder::DEFAULT_PLOOKUP_RANGE_BITNUM>(field_ct(i));
         // Is i == terminating_limb_index?
         bool_ct is_terminating_limb = terminating_index == field_ct(i);
 
@@ -721,8 +721,8 @@ std::vector<field_t<Composer>> keccak<Composer>::format_input_lanes(byte_array_c
     return lanes;
 }
 
-template <typename Composer>
-stdlib::byte_array<Composer> keccak<Composer>::hash(byte_array_ct& input, const uint32_ct& num_bytes)
+template <typename Builder>
+stdlib::byte_array<Builder> keccak<Builder>::hash(byte_array_ct& input, const uint32_ct& num_bytes)
 {
     auto ctx = input.get_context();
 
@@ -749,7 +749,7 @@ stdlib::byte_array<Composer> keccak<Composer>::hash(byte_array_ct& input, const
     internal.context = ctx;
     for (size_t i = 0; i < formatted_slices.size(); ++i) {
         const auto accumulators =
-            plookup_read<Composer>::get_lookup_accumulators(KECCAK_FORMAT_INPUT, formatted_slices[i]);
+            plookup_read<Builder>::get_lookup_accumulators(KECCAK_FORMAT_INPUT, formatted_slices[i]);
         converted_buffer[i] = accumulators[ColumnIdx::C2][0];
         msb_buffer[i] = accumulators[ColumnIdx::C3][accumulators[ColumnIdx::C3].size() - 1];
     }
diff --git a/barretenberg/cpp/src/barretenberg/stdlib/hash/keccak/keccak.hpp b/barretenberg/cpp/src/barretenberg/stdlib/hash/keccak/keccak.hpp
index a04b275d019..1790040731e 100644
--- a/barretenberg/cpp/src/barretenberg/stdlib/hash/keccak/keccak.hpp
+++ b/barretenberg/cpp/src/barretenberg/stdlib/hash/keccak/keccak.hpp
@@ -4,13 +4,9 @@
 #include "barretenberg/stdlib/primitives/uint/uint.hpp"
 #include <array>
 
-namespace proof_system::plonk {
-class UltraPlonkComposer;
-} // namespace proof_system::plonk
-
 namespace proof_system::plonk {
 namespace stdlib {
-template <typename Composer> class bit_array;
+template <typename Builder> class bit_array;
 
 /**
  * @brief KECCAAAAAAAAAAK
@@ -22,15 +18,15 @@ template <typename Composer> class bit_array;
  * Current cost 17,329 constraints for a 1-block hash
  * using small(ish) lookup tables (total size < 2^64)
  *
- * @tparam Composer
+ * @tparam Builder
  */
-template <typename Composer> class keccak {
+template <typename Builder> class keccak {
   public:
-    using witness_ct = stdlib::witness_t<Composer>;
-    using field_ct = stdlib::field_t<Composer>;
-    using bool_ct = stdlib::bool_t<Composer>;
-    using byte_array_ct = stdlib::byte_array<Composer>;
-    using uint32_ct = stdlib::uint32<Composer>;
+    using witness_ct = stdlib::witness_t<Builder>;
+    using field_ct = stdlib::field_t<Builder>;
+    using bool_ct = stdlib::bool_t<Builder>;
+    using byte_array_ct = stdlib::byte_array<Builder>;
+    using uint32_ct = stdlib::uint32<Builder>;
 
     // base of extended representation we use for efficient logic operations
     static constexpr uint256_t BASE = 11;
@@ -162,10 +158,10 @@ template <typename Composer> class keccak {
         std::array<field_ct, NUM_KECCAK_LANES> state;
         std::array<field_ct, NUM_KECCAK_LANES> state_msb;
         std::array<field_ct, NUM_KECCAK_LANES> twisted_state;
-        Composer* context;
+        Builder* context;
     };
 
-    template <size_t lane_index> static field_t<Composer> normalize_and_rotate(const field_ct& limb, field_ct& msb);
+    template <size_t lane_index> static field_t<Builder> normalize_and_rotate(const field_ct& limb, field_ct& msb);
     static void compute_twisted_state(keccak_state& internal);
     static void theta(keccak_state& state);
     static void rho(keccak_state& state);
diff --git a/barretenberg/cpp/src/barretenberg/stdlib/hash/keccak/keccak.test.cpp b/barretenberg/cpp/src/barretenberg/stdlib/hash/keccak/keccak.test.cpp
index 30c4bbd00ba..dd5ab49884e 100644
--- a/barretenberg/cpp/src/barretenberg/stdlib/hash/keccak/keccak.test.cpp
+++ b/barretenberg/cpp/src/barretenberg/stdlib/hash/keccak/keccak.test.cpp
@@ -7,12 +7,12 @@
 using namespace barretenberg;
 using namespace proof_system::plonk;
 
-typedef proof_system::UltraCircuitBuilder Composer;
-typedef stdlib::byte_array<Composer> byte_array;
-typedef stdlib::public_witness_t<Composer> public_witness_t;
-typedef stdlib::field_t<Composer> field_ct;
-typedef stdlib::witness_t<Composer> witness_ct;
-typedef stdlib::uint32<Composer> uint32_ct;
+typedef proof_system::UltraCircuitBuilder Builder;
+typedef stdlib::byte_array<Builder> byte_array;
+typedef stdlib::public_witness_t<Builder> public_witness_t;
+typedef stdlib::field_t<Builder> field_ct;
+typedef stdlib::witness_t<Builder> witness_ct;
+typedef stdlib::uint32<Builder> uint32_ct;
 
 namespace {
 auto& engine = numeric::random::get_debug_engine();
@@ -20,35 +20,35 @@ auto& engine = numeric::random::get_debug_engine();
 
 TEST(stdlib_keccak, keccak_format_input_table)
 {
-    Composer composer = Composer();
+    Builder builder = Builder();
 
     for (size_t i = 0; i < 25; ++i) {
         uint64_t limb_native = engine.get_random_uint64();
-        field_ct limb(witness_ct(&composer, limb_native));
-        stdlib::plookup_read<Composer>::read_from_1_to_2_table(plookup::KECCAK_FORMAT_INPUT, limb);
+        field_ct limb(witness_ct(&builder, limb_native));
+        stdlib::plookup_read<Builder>::read_from_1_to_2_table(plookup::KECCAK_FORMAT_INPUT, limb);
     }
 
-    bool proof_result = composer.check_circuit();
+    bool proof_result = builder.check_circuit();
     EXPECT_EQ(proof_result, true);
 }
 
 TEST(stdlib_keccak, keccak_format_output_table)
 {
-    Composer composer = Composer();
+    Builder builder = Builder();
 
     for (size_t i = 0; i < 25; ++i) {
         uint64_t limb_native = engine.get_random_uint64();
-        uint256_t extended_native = stdlib::keccak<Composer>::convert_to_sparse(limb_native);
-        field_ct limb(witness_ct(&composer, extended_native));
-        stdlib::plookup_read<Composer>::read_from_1_to_2_table(plookup::KECCAK_FORMAT_OUTPUT, limb);
+        uint256_t extended_native = stdlib::keccak<Builder>::convert_to_sparse(limb_native);
+        field_ct limb(witness_ct(&builder, extended_native));
+        stdlib::plookup_read<Builder>::read_from_1_to_2_table(plookup::KECCAK_FORMAT_OUTPUT, limb);
     }
-    bool proof_result = composer.check_circuit();
+    bool proof_result = builder.check_circuit();
     EXPECT_EQ(proof_result, true);
 }
 
 TEST(stdlib_keccak, keccak_theta_output_table)
 {
-    Composer composer = Composer();
+    Builder builder = Builder();
 
     for (size_t i = 0; i < 25; ++i) {
         uint256_t extended_native = 0;
@@ -57,16 +57,16 @@ TEST(stdlib_keccak, keccak_theta_output_table)
             uint64_t base_value = (engine.get_random_uint64() % 11);
             extended_native += base_value;
         }
-        field_ct limb(witness_ct(&composer, extended_native));
-        stdlib::plookup_read<Composer>::read_from_1_to_2_table(plookup::KECCAK_THETA_OUTPUT, limb);
+        field_ct limb(witness_ct(&builder, extended_native));
+        stdlib::plookup_read<Builder>::read_from_1_to_2_table(plookup::KECCAK_THETA_OUTPUT, limb);
     }
-    bool proof_result = composer.check_circuit();
+    bool proof_result = builder.check_circuit();
     EXPECT_EQ(proof_result, true);
 }
 
 TEST(stdlib_keccak, keccak_rho_output_table)
 {
-    Composer composer = Composer();
+    Builder builder = Builder();
 
     barretenberg::constexpr_for<0, 25, 1>([&]<size_t i> {
         uint256_t extended_native = 0;
@@ -78,24 +78,24 @@ TEST(stdlib_keccak, keccak_rho_output_table)
             extended_native += base_value;
             binary_native += (base_value & 1);
         }
-        const size_t left_bits = stdlib::keccak<Composer>::ROTATIONS[i];
+        const size_t left_bits = stdlib::keccak<Builder>::ROTATIONS[i];
         const size_t right_bits = 64 - left_bits;
         const uint256_t left = binary_native >> right_bits;
         const uint256_t right = binary_native - (left << right_bits);
         const uint256_t binary_rotated = left + (right << left_bits);
 
-        const uint256_t expected_limb = stdlib::keccak<Composer>::convert_to_sparse(binary_rotated);
+        const uint256_t expected_limb = stdlib::keccak<Builder>::convert_to_sparse(binary_rotated);
         // msb only is correct iff rotation == 0 (no need to get msb for rotated lookups)
         const uint256_t expected_msb = (binary_native >> 63);
-        field_ct limb(witness_ct(&composer, extended_native));
+        field_ct limb(witness_ct(&builder, extended_native));
         field_ct result_msb;
-        field_ct result_limb = stdlib::keccak<Composer>::normalize_and_rotate<i>(limb, result_msb);
+        field_ct result_limb = stdlib::keccak<Builder>::normalize_and_rotate<i>(limb, result_msb);
         EXPECT_EQ(static_cast<uint256_t>(result_limb.get_value()), expected_limb);
         EXPECT_EQ(static_cast<uint256_t>(result_msb.get_value()), expected_msb);
     });
 
-    info("composer gates = ", composer.get_num_gates());
-    bool proof_result = composer.check_circuit();
+    info("num gates = ", builder.get_num_gates());
+    bool proof_result = builder.check_circuit();
     EXPECT_EQ(proof_result, true);
 }
 
@@ -105,7 +105,7 @@ TEST(stdlib_keccak, keccak_chi_output_table)
         0, // 1 + 2a - b + c => a xor (~b & c)
         0, 1, 1, 0,
     };
-    Composer composer = Composer();
+    Builder builder = Builder();
 
     for (size_t i = 0; i < 25; ++i) {
         uint256_t normalized_native = 0;
@@ -120,9 +120,9 @@ TEST(stdlib_keccak, keccak_chi_output_table)
             normalized_native += chi_normalization_table[base_value];
             binary_native += chi_normalization_table[base_value];
         }
-        field_ct limb(witness_ct(&composer, extended_native));
+        field_ct limb(witness_ct(&builder, extended_native));
         const auto accumulators =
-            stdlib::plookup_read<Composer>::get_lookup_accumulators(plookup::KECCAK_CHI_OUTPUT, limb);
+            stdlib::plookup_read<Builder>::get_lookup_accumulators(plookup::KECCAK_CHI_OUTPUT, limb);
 
         field_ct normalized = accumulators[plookup::ColumnIdx::C2][0];
         field_ct msb = accumulators[plookup::ColumnIdx::C3][accumulators[plookup::ColumnIdx::C3].size() - 1];
@@ -130,14 +130,14 @@ TEST(stdlib_keccak, keccak_chi_output_table)
         EXPECT_EQ(static_cast<uint256_t>(normalized.get_value()), normalized_native);
         EXPECT_EQ(static_cast<uint256_t>(msb.get_value()), binary_native >> 63);
     }
-    info("composer gates = n", composer.get_num_gates());
-    bool proof_result = composer.check_circuit();
+    info("num gates = n", builder.get_num_gates());
+    bool proof_result = builder.check_circuit();
     EXPECT_EQ(proof_result, true);
 }
 
 TEST(stdlib_keccak, test_format_input_lanes)
 {
-    Composer composer = Composer();
+    Builder builder = Builder();
 
     for (size_t i = 543; i < 544; ++i) {
         std::cout << "i = " << i << std::endl;
@@ -153,13 +153,13 @@ TEST(stdlib_keccak, test_format_input_lanes)
         for (size_t k = 0; k < excess_zeroes; ++k) {
             input_padded_v.push_back(0);
         }
-        byte_array input_arr(&composer, input_v);
-        byte_array input_padded_arr(&composer, input_padded_v);
+        byte_array input_arr(&builder, input_v);
+        byte_array input_padded_arr(&builder, input_padded_v);
 
         auto num_bytes_native = static_cast<uint32_t>(i);
-        uint32_ct num_bytes(witness_ct(&composer, num_bytes_native));
-        std::vector<field_ct> result = stdlib::keccak<Composer>::format_input_lanes(input_padded_arr, num_bytes);
-        std::vector<field_ct> expected = stdlib::keccak<Composer>::format_input_lanes(input_arr, num_bytes_native);
+        uint32_ct num_bytes(witness_ct(&builder, num_bytes_native));
+        std::vector<field_ct> result = stdlib::keccak<Builder>::format_input_lanes(input_padded_arr, num_bytes);
+        std::vector<field_ct> expected = stdlib::keccak<Builder>::format_input_lanes(input_arr, num_bytes_native);
 
         EXPECT_GT(result.size(), expected.size() - 1);
 
@@ -171,54 +171,54 @@ TEST(stdlib_keccak, test_format_input_lanes)
         }
     }
 
-    bool proof_result = composer.check_circuit();
+    bool proof_result = builder.check_circuit();
     EXPECT_EQ(proof_result, true);
 }
 
 TEST(stdlib_keccak, test_single_block)
 {
-    Composer composer = Composer();
+    Builder builder = Builder();
     std::string input = "abcdefghijklmnopqrstuvwxyz0123456789abcdefghijklmnopqrstuvwxyz01";
     std::vector<uint8_t> input_v(input.begin(), input.end());
 
-    byte_array input_arr(&composer, input_v);
-    byte_array output = stdlib::keccak<Composer>::hash(input_arr);
+    byte_array input_arr(&builder, input_v);
+    byte_array output = stdlib::keccak<Builder>::hash(input_arr);
 
-    std::vector<uint8_t> expected = stdlib::keccak<Composer>::hash_native(input_v);
+    std::vector<uint8_t> expected = stdlib::keccak<Builder>::hash_native(input_v);
 
     EXPECT_EQ(output.get_value(), expected);
 
-    composer.print_num_gates();
+    builder.print_num_gates();
 
-    bool proof_result = composer.check_circuit();
+    bool proof_result = builder.check_circuit();
     EXPECT_EQ(proof_result, true);
 }
 
 TEST(stdlib_keccak, test_double_block)
 {
-    Composer composer = Composer();
+    Builder builder = Builder();
     std::string input = "";
     for (size_t i = 0; i < 200; ++i) {
         input += "a";
     }
     std::vector<uint8_t> input_v(input.begin(), input.end());
 
-    byte_array input_arr(&composer, input_v);
-    byte_array output = stdlib::keccak<Composer>::hash(input_arr);
+    byte_array input_arr(&builder, input_v);
+    byte_array output = stdlib::keccak<Builder>::hash(input_arr);
 
-    std::vector<uint8_t> expected = stdlib::keccak<Composer>::hash_native(input_v);
+    std::vector<uint8_t> expected = stdlib::keccak<Builder>::hash_native(input_v);
 
     EXPECT_EQ(output.get_value(), expected);
 
-    composer.print_num_gates();
+    builder.print_num_gates();
 
-    bool proof_result = composer.check_circuit();
+    bool proof_result = builder.check_circuit();
     EXPECT_EQ(proof_result, true);
 }
 
 TEST(stdlib_keccak, test_double_block_variable_length)
 {
-    Composer composer = Composer();
+    Builder builder = Builder();
     std::string input = "";
     for (size_t i = 0; i < 200; ++i) {
         input += "a";
@@ -230,23 +230,23 @@ TEST(stdlib_keccak, test_double_block_variable_length)
     for (size_t i = 0; i < 51; ++i) {
         input_v_padded.push_back(0);
     }
-    byte_array input_arr(&composer, input_v_padded);
+    byte_array input_arr(&builder, input_v_padded);
 
-    uint32_ct length(witness_ct(&composer, 200));
-    byte_array output = stdlib::keccak<Composer>::hash(input_arr, length);
+    uint32_ct length(witness_ct(&builder, 200));
+    byte_array output = stdlib::keccak<Builder>::hash(input_arr, length);
 
-    std::vector<uint8_t> expected = stdlib::keccak<Composer>::hash_native(input_v);
+    std::vector<uint8_t> expected = stdlib::keccak<Builder>::hash_native(input_v);
 
     EXPECT_EQ(output.get_value(), expected);
 
-    bool proof_result = composer.check_circuit();
+    bool proof_result = builder.check_circuit();
     EXPECT_EQ(proof_result, true);
 }
 
 TEST(stdlib_keccak, test_variable_length_nonzero_input_greater_than_byte_array_size)
 
 {
-    Composer composer = Composer();
+    Builder builder = Builder();
     std::string input = "";
     size_t target_length = 2;
     size_t byte_array_length = 200;
@@ -254,18 +254,18 @@ TEST(stdlib_keccak, test_variable_length_nonzero_input_greater_than_byte_array_s
         input += "a";
     }
     std::vector<uint8_t> input_expected(input.begin(), input.end());
-    std::vector<uint8_t> expected = stdlib::keccak<Composer>::hash_native(input_expected);
+    std::vector<uint8_t> expected = stdlib::keccak<Builder>::hash_native(input_expected);
     for (size_t i = target_length; i < byte_array_length; ++i) {
         input += "a";
     }
     std::vector<uint8_t> input_v(input.begin(), input.end());
 
-    byte_array input_arr(&composer, input_v);
+    byte_array input_arr(&builder, input_v);
 
-    uint32_ct length(witness_ct(&composer, 2));
-    byte_array output = stdlib::keccak<Composer>::hash(input_arr, length);
+    uint32_ct length(witness_ct(&builder, 2));
+    byte_array output = stdlib::keccak<Builder>::hash(input_arr, length);
 
     EXPECT_EQ(output.get_value(), expected);
-    bool proof_result = composer.check_circuit();
+    bool proof_result = builder.check_circuit();
     EXPECT_EQ(proof_result, true);
 }
diff --git a/barretenberg/cpp/src/barretenberg/stdlib/hash/pedersen/pedersen.cpp b/barretenberg/cpp/src/barretenberg/stdlib/hash/pedersen/pedersen.cpp
index 28f2b8c5a0b..a85e7d9177e 100644
--- a/barretenberg/cpp/src/barretenberg/stdlib/hash/pedersen/pedersen.cpp
+++ b/barretenberg/cpp/src/barretenberg/stdlib/hash/pedersen/pedersen.cpp
@@ -207,7 +207,7 @@ point<C> pedersen_hash<C>::hash_single_internal(const field_t& in,
         } else {
             if constexpr (HasPlookup<C> && (C::merkle_hash_type == merkle::HashType::FIXED_BASE_PEDERSEN ||
                                             C::commitment_type == pedersen::CommitmentType::FIXED_BASE_PEDERSEN)) {
-                /* In TurboPlonkComposer, the selector q_5 is used to show that w_1 and w_2 are properly initialized to
+                /* In TurboBuilder, the selector q_5 is used to show that w_1 and w_2 are properly initialized to
                  * the coordinates of P_s = (-s + 4^n)[g]. In UltraPlonK, we have removed q_5 for overall efficiency (it
                  * would only be used here in this gate), but this presents us a cost in the present circuit: we must
                  * use an additional gate to perform part of the initialization. Since q_5 is only involved in the
diff --git a/barretenberg/cpp/src/barretenberg/stdlib/hash/pedersen/pedersen.hpp b/barretenberg/cpp/src/barretenberg/stdlib/hash/pedersen/pedersen.hpp
index 951b90752e0..b03b4edce41 100644
--- a/barretenberg/cpp/src/barretenberg/stdlib/hash/pedersen/pedersen.hpp
+++ b/barretenberg/cpp/src/barretenberg/stdlib/hash/pedersen/pedersen.hpp
@@ -8,12 +8,12 @@ namespace proof_system::plonk {
 namespace stdlib {
 
 using namespace barretenberg;
-template <typename ComposerContext> class pedersen_hash {
+template <typename Builder> class pedersen_hash {
 
   private:
-    typedef stdlib::field_t<ComposerContext> field_t;
-    typedef stdlib::point<ComposerContext> point;
-    typedef stdlib::bool_t<ComposerContext> bool_t;
+    typedef stdlib::field_t<Builder> field_t;
+    typedef stdlib::point<Builder> point;
+    typedef stdlib::bool_t<Builder> bool_t;
 
   private:
     static point add_points(const point& first, const point& second);
@@ -23,7 +23,7 @@ template <typename ComposerContext> class pedersen_hash {
                                       const bool validate_input_is_in_field = true);
 
   public:
-    static void validate_wnaf_is_in_field(ComposerContext* ctx, const std::vector<uint32_t>& accumulator);
+    static void validate_wnaf_is_in_field(Builder* ctx, const std::vector<uint32_t>& accumulator);
 
     static point accumulate(const std::vector<point>& to_accumulate);
 
diff --git a/barretenberg/cpp/src/barretenberg/stdlib/hash/pedersen/pedersen_gates.hpp b/barretenberg/cpp/src/barretenberg/stdlib/hash/pedersen/pedersen_gates.hpp
index 1a5cb6ac44e..e105d7e321c 100644
--- a/barretenberg/cpp/src/barretenberg/stdlib/hash/pedersen/pedersen_gates.hpp
+++ b/barretenberg/cpp/src/barretenberg/stdlib/hash/pedersen/pedersen_gates.hpp
@@ -18,29 +18,29 @@ namespace stdlib {
  * N.B. wherever possible, UltraPlonk should use pedersen_plookup as it is MUCH more efficient!
  * pedersen_plookup produces different hash outputs to the TurboPlonk pedersen hash, use this if interoperability
  * between proof systems is required
- * @tparam Composer
+ * @tparam Builder
  */
-template <typename Composer> class pedersen_gates {
+template <typename Builder> class pedersen_gates {
   public:
-    using FF = typename Composer::FF;
+    using FF = typename Builder::FF;
     using fixed_group_add_quad = proof_system::fixed_group_add_quad_<FF>;
     using fixed_group_init_quad = proof_system::fixed_group_init_quad_<FF>;
     using add_quad = proof_system::add_quad_<FF>;
 
-    Composer* context;
+    Builder* context;
     fixed_group_add_quad previous_add_quad;
 
-    pedersen_gates(Composer* input_context = nullptr)
+    pedersen_gates(Builder* input_context = nullptr)
         : context(input_context)
     {}
 
     void create_fixed_group_add_gate(const fixed_group_add_quad& in)
     {
-        if constexpr (std::same_as<Composer, TurboCircuitBuilder>) {
+        if constexpr (std::same_as<Builder, TurboCircuitBuilder>) {
             context->create_fixed_group_add_gate(in);
         } else {
 
-            // TODO: not supported by honk composer?
+            // TODO: not supported by honk builder?
             // context->assert_valid_variables({ in.a, in.b, in.c, in.d });
 
             auto row_1 = previous_add_quad;
@@ -229,7 +229,7 @@ template <typename Composer> class pedersen_gates {
 
     void create_fixed_group_add_gate_with_init(const fixed_group_add_quad& in, const fixed_group_init_quad& init)
     {
-        if constexpr (std::same_as<Composer, TurboCircuitBuilder>) {
+        if constexpr (std::same_as<Builder, TurboCircuitBuilder>) {
             context->create_fixed_group_add_gate_with_init(in, init);
         } else {
             uint32_t x_0_idx = in.a;
@@ -247,7 +247,7 @@ template <typename Composer> class pedersen_gates {
             fr q_c = init.q_y_2;
 
             // We will think of s = 1-a_0 as an auxiliary "switch" which is equal to either -x_alpha or 0
-            // during the initialization step, but we will not add this variable to the composer for reasons of
+            // during the initialization step, but we will not add this variable to the builder for reasons of
             // efficiency.
 
             // (ɑ^4 identity) impose 1-a_0 = 0 or -x_alpha
@@ -295,7 +295,7 @@ template <typename Composer> class pedersen_gates {
 
     void create_fixed_group_add_gate_final(const add_quad& in)
     {
-        if constexpr (std::same_as<Composer, TurboCircuitBuilder>) {
+        if constexpr (std::same_as<Builder, TurboCircuitBuilder>) {
             context->create_fixed_group_add_gate_final(in);
         } else {
 
diff --git a/barretenberg/cpp/src/barretenberg/stdlib/hash/pedersen/pedersen_plookup.hpp b/barretenberg/cpp/src/barretenberg/stdlib/hash/pedersen/pedersen_plookup.hpp
index 1333be44106..4ec5d4a7de8 100644
--- a/barretenberg/cpp/src/barretenberg/stdlib/hash/pedersen/pedersen_plookup.hpp
+++ b/barretenberg/cpp/src/barretenberg/stdlib/hash/pedersen/pedersen_plookup.hpp
@@ -7,12 +7,12 @@
 namespace proof_system::plonk {
 namespace stdlib {
 
-template <typename ComposerContext> class pedersen_plookup_hash {
+template <typename Builder> class pedersen_plookup_hash {
   private:
-    typedef stdlib::field_t<ComposerContext> field_t;
-    typedef stdlib::point<ComposerContext> point;
-    typedef stdlib::packed_byte_array<ComposerContext> packed_byte_array;
-    typedef stdlib::bool_t<ComposerContext> bool_t;
+    typedef stdlib::field_t<Builder> field_t;
+    typedef stdlib::point<Builder> point;
+    typedef stdlib::packed_byte_array<Builder> packed_byte_array;
+    typedef stdlib::bool_t<Builder> bool_t;
 
     enum AddType {
         LAMBDA,
diff --git a/barretenberg/cpp/src/barretenberg/stdlib/hash/sha256/sha256.cpp b/barretenberg/cpp/src/barretenberg/stdlib/hash/sha256/sha256.cpp
index 306b3a12ba3..e7098f2be39 100644
--- a/barretenberg/cpp/src/barretenberg/stdlib/hash/sha256/sha256.cpp
+++ b/barretenberg/cpp/src/barretenberg/stdlib/hash/sha256/sha256.cpp
@@ -28,7 +28,7 @@ constexpr size_t get_num_blocks(const size_t num_bits)
 }
 } // namespace internal
 
-template <typename Composer> void prepare_constants(std::array<uint32<Composer>, 8>& input)
+template <typename Builder> void prepare_constants(std::array<uint32<Builder>, 8>& input)
 {
     input[0] = internal::init_constants[0];
     input[1] = internal::init_constants[1];
@@ -40,11 +40,11 @@ template <typename Composer> void prepare_constants(std::array<uint32<Composer>,
     input[7] = internal::init_constants[7];
 }
 
-template <typename Composer>
-std::array<uint32<Composer>, 8> sha256_block(const std::array<uint32<Composer>, 8>& h_init,
-                                             const std::array<uint32<Composer>, 16>& input)
+template <typename Builder>
+std::array<uint32<Builder>, 8> sha256_block(const std::array<uint32<Builder>, 8>& h_init,
+                                            const std::array<uint32<Builder>, 16>& input)
 {
-    typedef uint32<Composer> uint32;
+    typedef uint32<Builder> uint32;
     std::array<uint32, 64> w;
 
     /**
@@ -112,38 +112,38 @@ std::array<uint32<Composer>, 8> sha256_block(const std::array<uint32<Composer>,
     return output;
 }
 
-template <typename Composer> byte_array<Composer> sha256_block(const byte_array<Composer>& input)
+template <typename Builder> byte_array<Builder> sha256_block(const byte_array<Builder>& input)
 {
-    typedef uint32<Composer> uint32;
+    typedef uint32<Builder> uint32;
 
     ASSERT(input.size() == 64);
 
     std::array<uint32, 8> hash;
-    prepare_constants<Composer>(hash);
+    prepare_constants<Builder>(hash);
 
     std::array<uint32, 16> hash_input;
     for (size_t i = 0; i < 16; ++i) {
         hash_input[i] = uint32(input.slice(i * 4, 4));
     }
-    hash = sha256_block<Composer>(hash, hash_input);
+    hash = sha256_block<Builder>(hash, hash_input);
 
-    byte_array<Composer> result(input.get_context());
+    byte_array<Builder> result(input.get_context());
     for (size_t i = 0; i < 8; ++i) {
-        result.write(static_cast<byte_array<Composer>>(hash[i]));
+        result.write(static_cast<byte_array<Builder>>(hash[i]));
     }
 
     return result;
 }
 
-template <typename Composer> packed_byte_array<Composer> sha256(const packed_byte_array<Composer>& input)
+template <typename Builder> packed_byte_array<Builder> sha256(const packed_byte_array<Builder>& input)
 {
-    if constexpr (HasPlookup<Composer>) {
+    if constexpr (HasPlookup<Builder>) {
         return sha256_plookup::sha256(input);
     }
-    typedef field_t<Composer> field_pt;
-    typedef uint32<Composer> uint32;
+    typedef field_t<Builder> field_pt;
+    typedef uint32<Builder> uint32;
 
-    Composer* ctx = input.get_context();
+    Builder* ctx = input.get_context();
 
     auto message_schedule(input);
 
@@ -166,17 +166,17 @@ template <typename Composer> packed_byte_array<Composer> sha256(const packed_byt
     constexpr size_t slices_per_block = 16;
 
     std::array<uint32, 8> rolling_hash;
-    prepare_constants<Composer>(rolling_hash);
+    prepare_constants<Builder>(rolling_hash);
     for (size_t i = 0; i < num_blocks; ++i) {
         std::array<uint32, 16> hash_input;
         for (size_t j = 0; j < 16; ++j) {
             hash_input[j] = uint32(slices[i * slices_per_block + j]);
         }
-        rolling_hash = sha256_block<Composer>(rolling_hash, hash_input);
+        rolling_hash = sha256_block<Builder>(rolling_hash, hash_input);
     }
 
     std::vector<field_pt> output(rolling_hash.begin(), rolling_hash.end());
-    return packed_byte_array<Composer>(output, 4);
+    return packed_byte_array<Builder>(output, 4);
 }
 
 INSTANTIATE_STDLIB_METHOD(SHA256_BLOCK)
diff --git a/barretenberg/cpp/src/barretenberg/stdlib/hash/sha256/sha256.hpp b/barretenberg/cpp/src/barretenberg/stdlib/hash/sha256/sha256.hpp
index d3cc1767dc8..e078c118500 100644
--- a/barretenberg/cpp/src/barretenberg/stdlib/hash/sha256/sha256.hpp
+++ b/barretenberg/cpp/src/barretenberg/stdlib/hash/sha256/sha256.hpp
@@ -9,18 +9,18 @@
 
 namespace proof_system::plonk {
 namespace stdlib {
-template <typename Composer> class bit_array;
+template <typename Builder> class bit_array;
 
-template <typename Composer>
-std::array<uint32<Composer>, 8> sha256_block(const std::array<uint32<Composer>, 8>& h_init,
-                                             const std::array<uint32<Composer>, 16>& input);
+template <typename Builder>
+std::array<uint32<Builder>, 8> sha256_block(const std::array<uint32<Builder>, 8>& h_init,
+                                            const std::array<uint32<Builder>, 16>& input);
 
-template <typename Composer> byte_array<Composer> sha256_block(const byte_array<Composer>& input);
-template <typename Composer> packed_byte_array<Composer> sha256(const packed_byte_array<Composer>& input);
+template <typename Builder> byte_array<Builder> sha256_block(const byte_array<Builder>& input);
+template <typename Builder> packed_byte_array<Builder> sha256(const packed_byte_array<Builder>& input);
 
-template <typename Composer> field_t<Composer> sha256_to_field(const packed_byte_array<Composer>& input)
+template <typename Builder> field_t<Builder> sha256_to_field(const packed_byte_array<Builder>& input)
 {
-    std::vector<field_t<Composer>> slices = stdlib::sha256<Composer>(input).to_unverified_byte_slices(16);
+    std::vector<field_t<Builder>> slices = stdlib::sha256<Builder>(input).to_unverified_byte_slices(16);
     return slices[1] + (slices[0] * (uint256_t(1) << 128));
 }
 
diff --git a/barretenberg/cpp/src/barretenberg/stdlib/hash/sha256/sha256.test.cpp b/barretenberg/cpp/src/barretenberg/stdlib/hash/sha256/sha256.test.cpp
index 85a5c1c874b..02409a10d2a 100644
--- a/barretenberg/cpp/src/barretenberg/stdlib/hash/sha256/sha256.test.cpp
+++ b/barretenberg/cpp/src/barretenberg/stdlib/hash/sha256/sha256.test.cpp
@@ -18,11 +18,11 @@ namespace proof_system::test_stdlib_sha256 {
 using namespace barretenberg;
 using namespace proof_system::plonk::stdlib;
 
-using Composer = proof_system::UltraCircuitBuilder;
+using Builder = proof_system::UltraCircuitBuilder;
 
-using byte_array_ct = byte_array<Composer>;
-using packed_byte_array_ct = packed_byte_array<Composer>;
-using field_ct = field_t<Composer>;
+using byte_array_ct = byte_array<Builder>;
+using packed_byte_array_ct = packed_byte_array<Builder>;
+using field_ct = field_t<Builder>;
 
 constexpr uint64_t ror(uint64_t val, uint64_t shift)
 {
@@ -117,14 +117,14 @@ std::array<uint64_t, 8> inner_block(std::array<uint64_t, 64>& w)
 // TEST(stdlib_sha256_plookup, test_round)
 // {
 
-//     auto composer = UltraPlonkComposer();
+//     auto builder = UltraPlonkBuilder();
 
 //     std::array<uint64_t, 64> w_inputs;
 //     std::array<proof_system::plonk::stdlib::field_t<proof_system::UltraCircuitBuilder>, 64> w_elements;
 
 //     for (size_t i = 0; i < 64; ++i) {
 //         w_inputs[i] = engine.get_random_uint32();
-//         w_elements[i] = proof_system::plonk::stdlib::witness_t<proof_system::UltraCircuitBuilder>(&composer,
+//         w_elements[i] = proof_system::plonk::stdlib::witness_t<proof_system::UltraCircuitBuilder>(&builder,
 //         barretenberg::fr(w_inputs[i]));
 //     }
 
@@ -136,13 +136,13 @@ std::array<uint64_t, 8> inner_block(std::array<uint64_t, 64>& w)
 //         EXPECT_EQ(uint256_t(result[i].get_value()).data[0] & 0xffffffffUL,
 //                   uint256_t(expected[i]).data[0] & 0xffffffffUL);
 //     }
-//     info("composer gates = %zu\n", composer.get_num_gates());
+//     info("num gates = %zu\n", builder.get_num_gates());
 
 //     auto prover = composer.create_prover();
 
 //     auto verifier = composer.create_verifier();
 //     proof_system::plonk::proof proof = prover.construct_proof();
-//     bool proof_result = composer.check_circuit();
+//     bool proof_result = builder.check_circuit();
 //     EXPECT_EQ(proof_result, true);
 // }
 
@@ -153,8 +153,8 @@ TEST(stdlib_sha256, test_plookup_55_bytes)
 
     // 55 bytes is the largest number of bytes that can be hashed in a single block,
     // accounting for the single padding bit, and the 64 size bits required by the SHA-256 standard.
-    auto composer = proof_system::UltraCircuitBuilder();
-    packed_byte_array_pt input(&composer, "An 8 character password? Snow White and the 7 Dwarves..");
+    auto builder = proof_system::UltraCircuitBuilder();
+    packed_byte_array_pt input(&builder, "An 8 character password? Snow White and the 7 Dwarves..");
 
     packed_byte_array_pt output_bits = proof_system::plonk::stdlib::sha256(input);
 
@@ -168,9 +168,9 @@ TEST(stdlib_sha256, test_plookup_55_bytes)
     EXPECT_EQ(uint256_t(output[5].get_value()), 0xbde22ab0U);
     EXPECT_EQ(uint256_t(output[6].get_value()), 0x54a8fac7U);
     EXPECT_EQ(uint256_t(output[7].get_value()), 0x93791fc7U);
-    info("composer gates = ", composer.get_num_gates());
+    info("num gates = ", builder.get_num_gates());
 
-    bool proof_result = composer.check_circuit();
+    bool proof_result = builder.check_circuit();
     EXPECT_EQ(proof_result, true);
 }
 
@@ -178,8 +178,8 @@ TEST(stdlib_sha256, test_55_bytes)
 {
     // 55 bytes is the largest number of bytes that can be hashed in a single block,
     // accounting for the single padding bit, and the 64 size bits required by the SHA-256 standard.
-    auto composer = Composer();
-    packed_byte_array_ct input(&composer, "An 8 character password? Snow White and the 7 Dwarves..");
+    auto builder = Builder();
+    packed_byte_array_ct input(&builder, "An 8 character password? Snow White and the 7 Dwarves..");
 
     packed_byte_array_ct output_bits = proof_system::plonk::stdlib::sha256(input);
 
@@ -193,9 +193,9 @@ TEST(stdlib_sha256, test_55_bytes)
     EXPECT_EQ(output[5].get_value(), fr(0xbde22ab0ULL));
     EXPECT_EQ(output[6].get_value(), fr(0x54a8fac7ULL));
     EXPECT_EQ(output[7].get_value(), fr(0x93791fc7ULL));
-    info("composer gates = ", composer.get_num_gates());
+    info("num gates = ", builder.get_num_gates());
 
-    bool proof_result = composer.check_circuit();
+    bool proof_result = builder.check_circuit();
     EXPECT_EQ(proof_result, true);
 }
 
@@ -204,9 +204,9 @@ TEST(stdlib_sha256, test_NIST_vector_one_packed_byte_array)
     typedef proof_system::plonk::stdlib::field_t<proof_system::UltraCircuitBuilder> field_pt;
     typedef proof_system::plonk::stdlib::packed_byte_array<proof_system::UltraCircuitBuilder> packed_byte_array_pt;
 
-    auto composer = proof_system::UltraCircuitBuilder();
+    auto builder = proof_system::UltraCircuitBuilder();
 
-    packed_byte_array_pt input(&composer, "abc");
+    packed_byte_array_pt input(&builder, "abc");
     packed_byte_array_pt output_bytes = proof_system::plonk::stdlib::sha256(input);
     std::vector<field_pt> output = output_bytes.to_unverified_byte_slices(4);
     EXPECT_EQ(uint256_t(output[0].get_value()).data[0], (uint64_t)0xBA7816BFU);
@@ -217,9 +217,9 @@ TEST(stdlib_sha256, test_NIST_vector_one_packed_byte_array)
     EXPECT_EQ(uint256_t(output[5].get_value()).data[0], (uint64_t)0x96177A9CU);
     EXPECT_EQ(uint256_t(output[6].get_value()).data[0], (uint64_t)0xB410FF61U);
     EXPECT_EQ(uint256_t(output[7].get_value()).data[0], (uint64_t)0xF20015ADU);
-    info("composer gates = ", composer.get_num_gates());
+    info("num gates = ", builder.get_num_gates());
 
-    bool proof_result = composer.check_circuit();
+    bool proof_result = builder.check_circuit();
     EXPECT_EQ(proof_result, true);
 }
 
@@ -228,9 +228,9 @@ TEST(stdlib_sha256, test_NIST_vector_one)
     typedef proof_system::plonk::stdlib::field_t<proof_system::UltraCircuitBuilder> field_pt;
     typedef proof_system::plonk::stdlib::packed_byte_array<proof_system::UltraCircuitBuilder> packed_byte_array_pt;
 
-    auto composer = proof_system::UltraCircuitBuilder();
+    auto builder = proof_system::UltraCircuitBuilder();
 
-    packed_byte_array_pt input(&composer, "abc");
+    packed_byte_array_pt input(&builder, "abc");
 
     packed_byte_array_pt output_bits = proof_system::plonk::stdlib::sha256(input);
 
@@ -244,19 +244,19 @@ TEST(stdlib_sha256, test_NIST_vector_one)
     EXPECT_EQ(output[5].get_value(), fr(0x96177A9CULL));
     EXPECT_EQ(output[6].get_value(), fr(0xB410FF61ULL));
     EXPECT_EQ(output[7].get_value(), fr(0xF20015ADULL));
-    info("composer gates = ", composer.get_num_gates());
+    info("num gates = ", builder.get_num_gates());
 
-    bool proof_result = composer.check_circuit();
+    bool proof_result = builder.check_circuit();
     EXPECT_EQ(proof_result, true);
 }
 
 TEST(stdlib_sha256, test_NIST_vector_two)
 {
-    auto composer = Composer();
+    auto builder = Builder();
 
-    byte_array_ct input(&composer, "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq");
+    byte_array_ct input(&builder, "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq");
 
-    byte_array_ct output_bits = proof_system::plonk::stdlib::sha256<Composer>(input);
+    byte_array_ct output_bits = proof_system::plonk::stdlib::sha256<Builder>(input);
 
     std::vector<field_ct> output = packed_byte_array_ct(output_bits).to_unverified_byte_slices(4);
 
@@ -268,20 +268,20 @@ TEST(stdlib_sha256, test_NIST_vector_two)
     EXPECT_EQ(output[5].get_value(), 0x64FF2167ULL);
     EXPECT_EQ(output[6].get_value(), 0xF6ECEDD4ULL);
     EXPECT_EQ(output[7].get_value(), 0x19DB06C1ULL);
-    info("composer gates = ", composer.get_num_gates());
+    info("num gates = ", builder.get_num_gates());
 
-    bool proof_result = composer.check_circuit();
+    bool proof_result = builder.check_circuit();
     EXPECT_EQ(proof_result, true);
 }
 
 TEST(stdlib_sha256, test_NIST_vector_three)
 {
-    auto composer = Composer();
+    auto builder = Builder();
 
     // one byte, 0xbd
-    byte_array_ct input(&composer, std::vector<uint8_t>{ 0xbd });
+    byte_array_ct input(&builder, std::vector<uint8_t>{ 0xbd });
 
-    byte_array_ct output_bits = proof_system::plonk::stdlib::sha256<Composer>(input);
+    byte_array_ct output_bits = proof_system::plonk::stdlib::sha256<Builder>(input);
 
     std::vector<field_ct> output = packed_byte_array_ct(output_bits).to_unverified_byte_slices(4);
 
@@ -293,20 +293,20 @@ TEST(stdlib_sha256, test_NIST_vector_three)
     EXPECT_EQ(output[5].get_value(), 0x7dc4b5aaULL);
     EXPECT_EQ(output[6].get_value(), 0xe11204c0ULL);
     EXPECT_EQ(output[7].get_value(), 0x8ffe732bULL);
-    info("composer gates = ", composer.get_num_gates());
+    info("num gates = ", builder.get_num_gates());
 
-    bool proof_result = composer.check_circuit();
+    bool proof_result = builder.check_circuit();
     EXPECT_EQ(proof_result, true);
 }
 
 TEST(stdlib_sha256, test_NIST_vector_four)
 {
-    auto composer = Composer();
+    auto builder = Builder();
 
     // 4 bytes, 0xc98c8e55
-    byte_array_ct input(&composer, std::vector<uint8_t>{ 0xc9, 0x8c, 0x8e, 0x55 });
+    byte_array_ct input(&builder, std::vector<uint8_t>{ 0xc9, 0x8c, 0x8e, 0x55 });
 
-    byte_array_ct output_bits = proof_system::plonk::stdlib::sha256<Composer>(input);
+    byte_array_ct output_bits = proof_system::plonk::stdlib::sha256<Builder>(input);
 
     std::vector<field_ct> output = packed_byte_array_ct(output_bits).to_unverified_byte_slices(4);
 
@@ -319,9 +319,9 @@ TEST(stdlib_sha256, test_NIST_vector_four)
     EXPECT_EQ(output[6].get_value(), 0xbd56c61cULL);
     EXPECT_EQ(output[7].get_value(), 0xcccd9504ULL);
 
-    info("composer gates = ", composer.get_num_gates());
+    info("num gates = ", builder.get_num_gates());
 
-    bool proof_result = composer.check_circuit();
+    bool proof_result = builder.check_circuit();
     EXPECT_EQ(proof_result, true);
 }
 
@@ -330,10 +330,10 @@ HEAVY_TEST(stdlib_sha256, test_NIST_vector_five)
     typedef proof_system::plonk::stdlib::field_t<proof_system::UltraCircuitBuilder> field_pt;
     typedef proof_system::plonk::stdlib::packed_byte_array<proof_system::UltraCircuitBuilder> packed_byte_array_pt;
 
-    auto composer = proof_system::UltraCircuitBuilder();
+    auto builder = proof_system::UltraCircuitBuilder();
 
     packed_byte_array_pt input(
-        &composer,
+        &builder,
         "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
         "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
         "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
@@ -358,23 +358,23 @@ HEAVY_TEST(stdlib_sha256, test_NIST_vector_five)
     EXPECT_EQ(output[6].get_value(), 0xa519105aULL);
     EXPECT_EQ(output[7].get_value(), 0x1eadd6e4ULL);
 
-    info("composer gates = ", composer.get_num_gates());
+    info("num gates = ", builder.get_num_gates());
 
-    bool proof_result = composer.check_circuit();
+    bool proof_result = builder.check_circuit();
     EXPECT_EQ(proof_result, true);
 }
 
 TEST(stdlib_sha256, test_input_len_multiple)
 {
-    auto composer = Composer();
+    auto builder = Builder();
 
     std::vector<uint32_t> input_sizes = { 1, 7, 15, 16, 30, 32, 55, 64, 90, 128, 512, 700 };
 
     for (auto& inp : input_sizes) {
         auto input_buf = std::vector<uint8_t>(inp, 1);
 
-        byte_array_ct input(&composer, input_buf);
-        byte_array_ct output_bits = proof_system::plonk::stdlib::sha256<Composer>(input);
+        byte_array_ct input(&builder, input_buf);
+        byte_array_ct output_bits = proof_system::plonk::stdlib::sha256<Builder>(input);
 
         auto circuit_output = output_bits.get_value();
 
@@ -386,7 +386,7 @@ TEST(stdlib_sha256, test_input_len_multiple)
 
 TEST(stdlib_sha256, test_input_str_len_multiple)
 {
-    auto composer = Composer();
+    auto builder = Builder();
 
     std::vector<std::string> input_strings = {
         "y",                                                                                          // 1
@@ -417,8 +417,8 @@ TEST(stdlib_sha256, test_input_str_len_multiple)
     for (auto& input_str : input_strings) {
         auto input_buf = std::vector<uint8_t>(input_str.begin(), input_str.end());
 
-        byte_array_ct input(&composer, input_buf);
-        byte_array_ct output_bits = proof_system::plonk::stdlib::sha256<Composer>(input);
+        byte_array_ct input(&builder, input_buf);
+        byte_array_ct output_bits = proof_system::plonk::stdlib::sha256<Builder>(input);
 
         auto circuit_output = output_bits.get_value();
 
diff --git a/barretenberg/cpp/src/barretenberg/stdlib/hash/sha256/sha256_plookup.cpp b/barretenberg/cpp/src/barretenberg/stdlib/hash/sha256/sha256_plookup.cpp
index acdd8c62624..90eb394ea44 100644
--- a/barretenberg/cpp/src/barretenberg/stdlib/hash/sha256/sha256_plookup.cpp
+++ b/barretenberg/cpp/src/barretenberg/stdlib/hash/sha256/sha256_plookup.cpp
@@ -25,7 +25,7 @@ constexpr size_t get_num_blocks(const size_t num_bits)
 }
 } // namespace internal
 
-template <typename Composer> void prepare_constants(std::array<field_t<Composer>, 8>& input)
+template <typename Builder> void prepare_constants(std::array<field_t<Builder>, 8>& input)
 {
     constexpr uint64_t init_constants[8]{ 0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a,
                                           0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19 };
@@ -40,13 +40,13 @@ template <typename Composer> void prepare_constants(std::array<field_t<Composer>
     input[7] = init_constants[7];
 }
 
-template <typename Composer> sparse_witness_limbs<Composer> convert_witness(const field_t<Composer>& w)
+template <typename Builder> sparse_witness_limbs<Builder> convert_witness(const field_t<Builder>& w)
 {
-    typedef field_t<Composer> field_pt;
+    typedef field_t<Builder> field_pt;
 
     sparse_witness_limbs result(w);
 
-    const auto lookup = plookup_read<Composer>::get_lookup_accumulators(MultiTableId::SHA256_WITNESS_INPUT, w);
+    const auto lookup = plookup_read<Builder>::get_lookup_accumulators(MultiTableId::SHA256_WITNESS_INPUT, w);
 
     result.sparse_limbs = std::array<field_pt, 4>{
         lookup[ColumnIdx::C2][0],
@@ -65,16 +65,16 @@ template <typename Composer> sparse_witness_limbs<Composer> convert_witness(cons
     return result;
 }
 
-template <typename Composer>
-std::array<field_t<Composer>, 64> extend_witness(const std::array<field_t<Composer>, 16>& w_in)
+template <typename Builder>
+std::array<field_t<Builder>, 64> extend_witness(const std::array<field_t<Builder>, 16>& w_in)
 {
-    typedef field_t<Composer> field_pt;
+    typedef field_t<Builder> field_pt;
 
-    Composer* ctx = w_in[0].get_context();
+    Builder* ctx = w_in[0].get_context();
 
-    std::array<sparse_witness_limbs<Composer>, 64> w_sparse;
+    std::array<sparse_witness_limbs<Builder>, 64> w_sparse;
     for (size_t i = 0; i < 16; ++i) {
-        w_sparse[i] = sparse_witness_limbs<Composer>(w_in[i]);
+        w_sparse[i] = sparse_witness_limbs<Builder>(w_in[i]);
         if (!ctx && w_in[i].get_context()) {
             ctx = w_in[i].get_context();
         }
@@ -129,7 +129,7 @@ std::array<field_t<Composer>, 64> extend_witness(const std::array<field_t<Compos
                                            .add_two(w_right.rotated_limbs[3], left_xor_sparse)
                                            .normalize();
 
-        field_pt xor_result = plookup_read<Composer>::read_from_1_to_2_table(SHA256_WITNESS_OUTPUT, xor_result_sparse);
+        field_pt xor_result = plookup_read<Builder>::read_from_1_to_2_table(SHA256_WITNESS_OUTPUT, xor_result_sparse);
 
         // TODO NORMALIZE WITH RANGE CHECK
 
@@ -139,7 +139,7 @@ std::array<field_t<Composer>, 64> extend_witness(const std::array<field_t<Compos
             w_out = field_pt(ctx, fr(w_out_raw.get_value().from_montgomery_form().data[0] & (uint64_t)0xffffffffULL));
 
         } else {
-            w_out = witness_t<Composer>(
+            w_out = witness_t<Builder>(
                 ctx, fr(w_out_raw.get_value().from_montgomery_form().data[0] & (uint64_t)0xffffffffULL));
         }
         w_sparse[i] = sparse_witness_limbs(w_out);
@@ -153,30 +153,30 @@ std::array<field_t<Composer>, 64> extend_witness(const std::array<field_t<Compos
     return w_extended;
 }
 
-template <typename Composer> sparse_value<Composer> map_into_choose_sparse_form(const field_t<Composer>& e)
+template <typename Builder> sparse_value<Builder> map_into_choose_sparse_form(const field_t<Builder>& e)
 {
-    sparse_value<Composer> result;
+    sparse_value<Builder> result;
     result.normal = e;
-    result.sparse = plookup_read<Composer>::read_from_1_to_2_table(SHA256_CH_INPUT, e);
+    result.sparse = plookup_read<Builder>::read_from_1_to_2_table(SHA256_CH_INPUT, e);
 
     return result;
 }
 
-template <typename Composer> sparse_value<Composer> map_into_maj_sparse_form(const field_t<Composer>& e)
+template <typename Builder> sparse_value<Builder> map_into_maj_sparse_form(const field_t<Builder>& e)
 {
-    sparse_value<Composer> result;
+    sparse_value<Builder> result;
     result.normal = e;
-    result.sparse = plookup_read<Composer>::read_from_1_to_2_table(SHA256_MAJ_INPUT, e);
+    result.sparse = plookup_read<Builder>::read_from_1_to_2_table(SHA256_MAJ_INPUT, e);
 
     return result;
 }
 
-template <typename Composer>
-field_t<Composer> choose(sparse_value<Composer>& e, const sparse_value<Composer>& f, const sparse_value<Composer>& g)
+template <typename Builder>
+field_t<Builder> choose(sparse_value<Builder>& e, const sparse_value<Builder>& f, const sparse_value<Builder>& g)
 {
-    typedef field_t<Composer> field_pt;
+    typedef field_t<Builder> field_pt;
 
-    const auto lookup = plookup_read<Composer>::get_lookup_accumulators(SHA256_CH_INPUT, e.normal);
+    const auto lookup = plookup_read<Builder>::get_lookup_accumulators(SHA256_CH_INPUT, e.normal);
     const auto rotation_coefficients = sha256_tables::get_choose_rotation_multipliers();
 
     field_pt rotation_result = lookup[ColumnIdx::C3][0];
@@ -192,17 +192,17 @@ field_t<Composer> choose(sparse_value<Composer>& e, const sparse_value<Composer>
 
     field_pt choose_result_sparse = xor_result.add_two(f.sparse + f.sparse, g.sparse + g.sparse + g.sparse).normalize();
 
-    field_pt choose_result = plookup_read<Composer>::read_from_1_to_2_table(SHA256_CH_OUTPUT, choose_result_sparse);
+    field_pt choose_result = plookup_read<Builder>::read_from_1_to_2_table(SHA256_CH_OUTPUT, choose_result_sparse);
 
     return choose_result;
 }
 
-template <typename Composer>
-field_t<Composer> majority(sparse_value<Composer>& a, const sparse_value<Composer>& b, const sparse_value<Composer>& c)
+template <typename Builder>
+field_t<Builder> majority(sparse_value<Builder>& a, const sparse_value<Builder>& b, const sparse_value<Builder>& c)
 {
-    typedef field_t<Composer> field_pt;
+    typedef field_t<Builder> field_pt;
 
-    const auto lookup = plookup_read<Composer>::get_lookup_accumulators(SHA256_MAJ_INPUT, a.normal);
+    const auto lookup = plookup_read<Builder>::get_lookup_accumulators(SHA256_MAJ_INPUT, a.normal);
     const auto rotation_coefficients = sha256_tables::get_majority_rotation_multipliers();
 
     field_pt rotation_result =
@@ -217,18 +217,17 @@ field_t<Composer> majority(sparse_value<Composer>& a, const sparse_value<Compose
 
     field_pt majority_result_sparse = xor_result.add_two(b.sparse, c.sparse).normalize();
 
-    field_pt majority_result =
-        plookup_read<Composer>::read_from_1_to_2_table(SHA256_MAJ_OUTPUT, majority_result_sparse);
+    field_pt majority_result = plookup_read<Builder>::read_from_1_to_2_table(SHA256_MAJ_OUTPUT, majority_result_sparse);
 
     return majority_result;
 }
 
-template <typename Composer> field_t<Composer> add_normalize(const field_t<Composer>& a, const field_t<Composer>& b)
+template <typename Builder> field_t<Builder> add_normalize(const field_t<Builder>& a, const field_t<Builder>& b)
 {
-    typedef field_t<Composer> field_pt;
-    typedef witness_t<Composer> witness_pt;
+    typedef field_t<Builder> field_pt;
+    typedef witness_t<Builder> witness_pt;
 
-    Composer* ctx = a.get_context() ? a.get_context() : b.get_context();
+    Builder* ctx = a.get_context() ? a.get_context() : b.get_context();
 
     uint256_t sum = a.get_value() + b.get_value();
 
@@ -246,11 +245,11 @@ template <typename Composer> field_t<Composer> add_normalize(const field_t<Compo
     return result;
 }
 
-template <typename Composer>
-std::array<field_t<Composer>, 8> sha256_block(const std::array<field_t<Composer>, 8>& h_init,
-                                              const std::array<field_t<Composer>, 16>& input)
+template <typename Builder>
+std::array<field_t<Builder>, 8> sha256_block(const std::array<field_t<Builder>, 8>& h_init,
+                                             const std::array<field_t<Builder>, 16>& input)
 {
-    typedef field_t<Composer> field_pt;
+    typedef field_t<Builder> field_pt;
 
     constexpr uint64_t round_constants[64]{
         0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
@@ -324,11 +323,11 @@ std::array<field_t<Composer>, 8> sha256_block(const std::array<field_t<Composer>
     return output;
 }
 
-template <typename Composer> packed_byte_array<Composer> sha256(const packed_byte_array<Composer>& input)
+template <typename Builder> packed_byte_array<Builder> sha256(const packed_byte_array<Builder>& input)
 {
-    typedef field_t<Composer> field_pt;
+    typedef field_t<Builder> field_pt;
 
-    Composer* ctx = input.get_context();
+    Builder* ctx = input.get_context();
 
     auto message_schedule(input);
 
@@ -361,7 +360,7 @@ template <typename Composer> packed_byte_array<Composer> sha256(const packed_byt
     }
 
     std::vector<field_pt> output(rolling_hash.begin(), rolling_hash.end());
-    return packed_byte_array<Composer>(output, 4);
+    return packed_byte_array<Builder>(output, 4);
 }
 #define SHA256_PLOOKUP(circuit_type)                                                                                   \
     packed_byte_array<circuit_type> sha256(const packed_byte_array<circuit_type>& input)
diff --git a/barretenberg/cpp/src/barretenberg/stdlib/hash/sha256/sha256_plookup.hpp b/barretenberg/cpp/src/barretenberg/stdlib/hash/sha256/sha256_plookup.hpp
index 48bf3ae4a99..7011f2db217 100644
--- a/barretenberg/cpp/src/barretenberg/stdlib/hash/sha256/sha256_plookup.hpp
+++ b/barretenberg/cpp/src/barretenberg/stdlib/hash/sha256/sha256_plookup.hpp
@@ -13,24 +13,24 @@ namespace proof_system::plonk {
 namespace stdlib {
 namespace sha256_plookup {
 
-template <typename Composer> struct sparse_ch_value {
-    field_t<Composer> normal;
-    field_t<Composer> sparse;
-    field_t<Composer> rot6;
-    field_t<Composer> rot11;
-    field_t<Composer> rot25;
+template <typename Builder> struct sparse_ch_value {
+    field_t<Builder> normal;
+    field_t<Builder> sparse;
+    field_t<Builder> rot6;
+    field_t<Builder> rot11;
+    field_t<Builder> rot25;
 };
 
-template <typename Composer> struct sparse_maj_value {
-    field_t<Composer> normal;
-    field_t<Composer> sparse;
-    field_t<Composer> rot2;
-    field_t<Composer> rot13;
-    field_t<Composer> rot22;
+template <typename Builder> struct sparse_maj_value {
+    field_t<Builder> normal;
+    field_t<Builder> sparse;
+    field_t<Builder> rot2;
+    field_t<Builder> rot13;
+    field_t<Builder> rot22;
 };
 
-template <typename Composer> struct sparse_witness_limbs {
-    sparse_witness_limbs(const field_t<Composer>& in = 0)
+template <typename Builder> struct sparse_witness_limbs {
+    sparse_witness_limbs(const field_t<Builder>& in = 0)
     {
         normal = in;
         has_sparse_limbs = false;
@@ -41,21 +41,21 @@ template <typename Composer> struct sparse_witness_limbs {
     sparse_witness_limbs& operator=(const sparse_witness_limbs& other) = default;
     sparse_witness_limbs& operator=(sparse_witness_limbs&& other) = default;
 
-    field_t<Composer> normal;
+    field_t<Builder> normal;
 
-    std::array<field_t<Composer>, 4> sparse_limbs;
+    std::array<field_t<Builder>, 4> sparse_limbs;
 
-    std::array<field_t<Composer>, 4> rotated_limbs;
+    std::array<field_t<Builder>, 4> rotated_limbs;
 
     bool has_sparse_limbs = false;
 };
 
-template <typename Composer> struct sparse_value {
-    sparse_value(const field_t<Composer>& in = 0)
+template <typename Builder> struct sparse_value {
+    sparse_value(const field_t<Builder>& in = 0)
     {
         normal = in;
         if (normal.witness_index == IS_CONSTANT) {
-            sparse = field_t<Composer>(
+            sparse = field_t<Builder>(
                 in.get_context(),
                 barretenberg::fr(numeric::map_into_sparse_form<16>(uint256_t(in.get_value()).data[0])));
         }
@@ -67,25 +67,25 @@ template <typename Composer> struct sparse_value {
     sparse_value& operator=(const sparse_value& other) = default;
     sparse_value& operator=(sparse_value&& other) = default;
 
-    field_t<Composer> normal;
-    field_t<Composer> sparse;
+    field_t<Builder> normal;
+    field_t<Builder> sparse;
 };
 
-template <typename Composer> sparse_witness_limbs<Composer> convert_witness(const field_t<Composer>& w);
+template <typename Builder> sparse_witness_limbs<Builder> convert_witness(const field_t<Builder>& w);
 
-template <typename Composer>
-std::array<field_t<Composer>, 64> extend_witness(const std::array<field_t<Composer>, 16>& w_in);
+template <typename Builder>
+std::array<field_t<Builder>, 64> extend_witness(const std::array<field_t<Builder>, 16>& w_in);
 
-template <typename Composer>
-field_t<Composer> choose(sparse_value<Composer>& e, const sparse_value<Composer>& f, const sparse_value<Composer>& g);
-template <typename Composer>
-field_t<Composer> majority(sparse_value<Composer>& a, const sparse_value<Composer>& b, const sparse_value<Composer>& c);
+template <typename Builder>
+field_t<Builder> choose(sparse_value<Builder>& e, const sparse_value<Builder>& f, const sparse_value<Builder>& g);
+template <typename Builder>
+field_t<Builder> majority(sparse_value<Builder>& a, const sparse_value<Builder>& b, const sparse_value<Builder>& c);
 
-template <typename Composer>
-std::array<field_t<Composer>, 8> sha256_block(const std::array<field_t<Composer>, 8>& h_init,
-                                              const std::array<field_t<Composer>, 16>& input);
+template <typename Builder>
+std::array<field_t<Builder>, 8> sha256_block(const std::array<field_t<Builder>, 8>& h_init,
+                                             const std::array<field_t<Builder>, 16>& input);
 
-template <typename Composer> packed_byte_array<Composer> sha256(const packed_byte_array<Composer>& input);
+template <typename Builder> packed_byte_array<Builder> sha256(const packed_byte_array<Builder>& input);
 } // namespace sha256_plookup
 } // namespace stdlib
 } // namespace proof_system::plonk
diff --git a/barretenberg/cpp/src/barretenberg/stdlib/merkle_tree/hash.test.cpp b/barretenberg/cpp/src/barretenberg/stdlib/merkle_tree/hash.test.cpp
index b5eaf44f562..d1f28860fc2 100644
--- a/barretenberg/cpp/src/barretenberg/stdlib/merkle_tree/hash.test.cpp
+++ b/barretenberg/cpp/src/barretenberg/stdlib/merkle_tree/hash.test.cpp
@@ -10,17 +10,17 @@ namespace proof_system::stdlib_merkle_tree_hash_test {
 using namespace barretenberg;
 using namespace proof_system::plonk::stdlib;
 
-using Composer = proof_system::UltraCircuitBuilder;
+using Builder = proof_system::UltraCircuitBuilder;
 
-using field_ct = field_t<Composer>;
-using witness_ct = witness_t<Composer>;
+using field_ct = field_t<Builder>;
+using witness_ct = witness_t<Builder>;
 
 TEST(stdlib_merkle_tree_hash, compress_native_vs_circuit)
 {
     fr x = uint256_t(0x5ec473eb273a8011, 0x50160109385471ca, 0x2f3095267e02607d, 0x02586f4a39e69b86);
-    Composer composer = Composer();
-    witness_ct y = witness_ct(&composer, x);
-    field_ct z = pedersen_hash<Composer>::hash_multiple({ y, y });
+    Builder builder = Builder();
+    witness_ct y = witness_ct(&builder, x);
+    field_ct z = pedersen_hash<Builder>::hash_multiple({ y, y });
     auto zz = merkle_tree::hash_pair_native(x, x);
 
     EXPECT_EQ(z.get_value(), zz);
@@ -28,17 +28,17 @@ TEST(stdlib_merkle_tree_hash, compress_native_vs_circuit)
 
 TEST(stdlib_merkle_tree_hash, compute_tree_root_native_vs_circuit)
 {
-    Composer composer = Composer();
+    Builder builder = Builder();
     std::vector<fr> inputs;
     std::vector<field_ct> inputs_ct;
     for (size_t i = 0; i < 16; i++) {
         auto input = fr::random_element();
-        auto input_ct = witness_ct(&composer, input);
+        auto input_ct = witness_ct(&builder, input);
         inputs.push_back(input);
         inputs_ct.push_back(input_ct);
     }
 
-    field_ct z = merkle_tree::compute_tree_root<Composer>(inputs_ct);
+    field_ct z = merkle_tree::compute_tree_root<Builder>(inputs_ct);
     auto zz = merkle_tree::compute_tree_root_native(inputs);
 
     EXPECT_EQ(z.get_value(), zz);
diff --git a/barretenberg/cpp/src/barretenberg/stdlib/merkle_tree/membership.hpp b/barretenberg/cpp/src/barretenberg/stdlib/merkle_tree/membership.hpp
index d9682794cb9..1aa4e797ed2 100644
--- a/barretenberg/cpp/src/barretenberg/stdlib/merkle_tree/membership.hpp
+++ b/barretenberg/cpp/src/barretenberg/stdlib/merkle_tree/membership.hpp
@@ -8,7 +8,7 @@ namespace proof_system::plonk {
 namespace stdlib {
 namespace merkle_tree {
 
-template <typename ComposerContext> using bit_vector = std::vector<bool_t<ComposerContext>>;
+template <typename Builder> using bit_vector = std::vector<bool_t<Builder>>;
 /**
  * Computes the new merkle root if the subtree is correctly inserted at a specified index in a Merkle tree.
  *
@@ -18,30 +18,30 @@ template <typename ComposerContext> using bit_vector = std::vector<bool_t<Compos
  * @param index: The index of any leaf in the subtree,
  * @param at_height: The height of the subtree,
  * @param is_updating_tree: set to true if we're updating the tree.
- * @tparam Composer: type of composer.
+ * @tparam Builder: type of builder.
  *
  * @see Check full documentation: https://hackmd.io/2zyJc6QhRuugyH8D78Tbqg?view
  */
-template <typename Composer>
-field_t<Composer> compute_subtree_root(hash_path<Composer> const& hashes,
-                                       field_t<Composer> const& value,
-                                       bit_vector<Composer> const& index,
-                                       size_t at_height,
-                                       bool const is_updating_tree = false)
+template <typename Builder>
+field_t<Builder> compute_subtree_root(hash_path<Builder> const& hashes,
+                                      field_t<Builder> const& value,
+                                      bit_vector<Builder> const& index,
+                                      size_t at_height,
+                                      bool const is_updating_tree = false)
 {
     auto current = value;
     for (size_t i = at_height; i < hashes.size(); ++i) {
         // get the parity bit at this level of the tree (get_bit returns bool so we know this is 0 or 1)
-        bool_t<Composer> path_bit = index[i];
+        bool_t<Builder> path_bit = index[i];
 
         // reconstruct the two inputs we need to hash
         // if `path_bit = false`, we know `current` is the left leaf and `hashes[i].second` is the right leaf
         // if `path_bit = true`, we know `current` is the right leaf and `hashes[i].first` is the left leaf
         // We don't need to explicitly check that hashes[i].first = current iff !path bit , or that hashes[i].second =
         // current iff path_bit If either of these does not hold, then the final computed merkle root will not match
-        field_t<Composer> left = field_t<Composer>::conditional_assign(path_bit, hashes[i].first, current);
-        field_t<Composer> right = field_t<Composer>::conditional_assign(path_bit, current, hashes[i].second);
-        current = pedersen_hash<Composer>::hash_multiple({ left, right }, 0, is_updating_tree);
+        field_t<Builder> left = field_t<Builder>::conditional_assign(path_bit, hashes[i].first, current);
+        field_t<Builder> right = field_t<Builder>::conditional_assign(path_bit, current, hashes[i].second);
+        current = pedersen_hash<Builder>::hash_multiple({ left, right }, 0, is_updating_tree);
     }
 
     return current;
@@ -57,17 +57,17 @@ field_t<Composer> compute_subtree_root(hash_path<Composer> const& hashes,
  * @param index: The index of any leaf in the subtree,
  * @param at_height: The height of the subtree,
  * @param is_updating_tree: set to true if we're updating the tree.
- * @tparam Composer: type of composer.
+ * @tparam Builder: type of builder.
  *
  * @see Check full documentation: https://hackmd.io/2zyJc6QhRuugyH8D78Tbqg?view
  */
-template <typename Composer>
-bool_t<Composer> check_subtree_membership(field_t<Composer> const& root,
-                                          hash_path<Composer> const& hashes,
-                                          field_t<Composer> const& value,
-                                          bit_vector<Composer> const& index,
-                                          size_t at_height,
-                                          bool const is_updating_tree = false)
+template <typename Builder>
+bool_t<Builder> check_subtree_membership(field_t<Builder> const& root,
+                                         hash_path<Builder> const& hashes,
+                                         field_t<Builder> const& value,
+                                         bit_vector<Builder> const& index,
+                                         size_t at_height,
+                                         bool const is_updating_tree = false)
 {
     return (compute_subtree_root(hashes, value, index, at_height, is_updating_tree) == root);
 }
@@ -83,13 +83,13 @@ bool_t<Composer> check_subtree_membership(field_t<Composer> const& root,
  * @param at_height: The height of the subtree,
  * @param is_updating_tree: set to true if we're updating the tree,
  * @param msg: error message.
- * @tparam Composer: type of composer.
+ * @tparam Builder: type of builder.
  */
-template <typename Composer>
-void assert_check_subtree_membership(field_t<Composer> const& root,
-                                     hash_path<Composer> const& hashes,
-                                     field_t<Composer> const& value,
-                                     bit_vector<Composer> const& index,
+template <typename Builder>
+void assert_check_subtree_membership(field_t<Builder> const& root,
+                                     hash_path<Builder> const& hashes,
+                                     field_t<Builder> const& value,
+                                     bit_vector<Builder> const& index,
                                      size_t at_height,
                                      bool const is_updating_tree = false,
                                      std::string const& msg = "assert_check_subtree_membership")
@@ -107,14 +107,14 @@ void assert_check_subtree_membership(field_t<Composer> const& root,
  * @param value: The value of the leaf,
  * @param index: The index of the leaf in the tree,
  * @param is_updating_tree: set to true if we're updating the tree.
- * @tparam Composer: type of composer.
+ * @tparam Builder: type of builder.
  */
-template <typename Composer>
-bool_t<Composer> check_membership(field_t<Composer> const& root,
-                                  hash_path<Composer> const& hashes,
-                                  field_t<Composer> const& value,
-                                  bit_vector<Composer> const& index,
-                                  bool const is_updating_tree = false)
+template <typename Builder>
+bool_t<Builder> check_membership(field_t<Builder> const& root,
+                                 hash_path<Builder> const& hashes,
+                                 field_t<Builder> const& value,
+                                 bit_vector<Builder> const& index,
+                                 bool const is_updating_tree = false)
 {
     return check_subtree_membership(root, hashes, value, index, 0, is_updating_tree);
 }
@@ -129,13 +129,13 @@ bool_t<Composer> check_membership(field_t<Composer> const& root,
  * @param index: The index of the leaf in the tree,
  * @param is_updating_tree: set to true if we're updating the tree,
  * @param msg: error message.
- * @tparam Composer: type of composer.
+ * @tparam Builder: type of builder.
  */
-template <typename Composer>
-void assert_check_membership(field_t<Composer> const& root,
-                             hash_path<Composer> const& hashes,
-                             field_t<Composer> const& value,
-                             bit_vector<Composer> const& index,
+template <typename Builder>
+void assert_check_membership(field_t<Builder> const& root,
+                             hash_path<Builder> const& hashes,
+                             field_t<Builder> const& value,
+                             bit_vector<Builder> const& index,
                              bool const is_updating_tree = false,
                              std::string const& msg = "assert_check_membership")
 {
@@ -154,15 +154,15 @@ void assert_check_membership(field_t<Composer> const& root,
  * @param old_value: The value of the leaf before it was updated with new_value,
  * @param index: The index of the leaf in the tree,
  * @param msg: error message.
- * @tparam Composer: type of composer.
+ * @tparam Builder: type of builder.
  */
-template <typename Composer>
-void update_membership(field_t<Composer> const& new_root,
-                       field_t<Composer> const& new_value,
-                       field_t<Composer> const& old_root,
-                       hash_path<Composer> const& old_hashes,
-                       field_t<Composer> const& old_value,
-                       bit_vector<Composer> const& index,
+template <typename Builder>
+void update_membership(field_t<Builder> const& new_root,
+                       field_t<Builder> const& new_value,
+                       field_t<Builder> const& old_root,
+                       hash_path<Builder> const& old_hashes,
+                       field_t<Builder> const& old_value,
+                       bit_vector<Builder> const& index,
                        std::string const& msg = "update_membership")
 {
     // Check that the old_value, is in the tree given by old_root, at index.
@@ -181,15 +181,15 @@ void update_membership(field_t<Composer> const& new_root,
  * @param old_values: The values of the existing leaves that were updated,
  * @param old_paths: The hash path from the given index right before a given existing leaf is updated,
  * @param old_indicies: Indices of the existing leaves that need to be updated,
- * @tparam Composer: type of composer.
+ * @tparam Builder: type of builder.
  */
-template <typename Composer>
-field_t<Composer> update_memberships(field_t<Composer> old_root,
-                                     std::vector<field_t<Composer>> const& new_roots,
-                                     std::vector<field_t<Composer>> const& new_values,
-                                     std::vector<field_t<Composer>> const& old_values,
-                                     std::vector<hash_path<Composer>> const& old_paths,
-                                     std::vector<bit_vector<Composer>> const& old_indicies)
+template <typename Builder>
+field_t<Builder> update_memberships(field_t<Builder> old_root,
+                                    std::vector<field_t<Builder>> const& new_roots,
+                                    std::vector<field_t<Builder>> const& new_values,
+                                    std::vector<field_t<Builder>> const& old_values,
+                                    std::vector<hash_path<Builder>> const& old_paths,
+                                    std::vector<bit_vector<Builder>> const& old_indicies)
 {
     for (size_t i = 0; i < old_indicies.size(); i++) {
         update_membership(
@@ -213,15 +213,15 @@ field_t<Composer> update_memberships(field_t<Composer> old_root,
  * @param index: The index of any leaf in the subtree,
  * @param at_height: The height of the subtree,
  * @param msg: error message.
- * @tparam Composer: type of composer.
+ * @tparam Builder: type of builder.
  */
-template <typename Composer>
-void update_subtree_membership(field_t<Composer> const& new_root,
-                               field_t<Composer> const& new_subtree_root,
-                               field_t<Composer> const& old_root,
-                               hash_path<Composer> const& old_hashes,
-                               field_t<Composer> const& old_subtree_root,
-                               bit_vector<Composer> const& index,
+template <typename Builder>
+void update_subtree_membership(field_t<Builder> const& new_root,
+                               field_t<Builder> const& new_subtree_root,
+                               field_t<Builder> const& old_root,
+                               hash_path<Builder> const& old_hashes,
+                               field_t<Builder> const& old_subtree_root,
+                               bit_vector<Builder> const& index,
                                size_t at_height,
                                std::string const& msg = "update_subtree_membership")
 {
@@ -240,18 +240,18 @@ void update_subtree_membership(field_t<Composer> const& new_root,
  * Computes the root of a tree with leaves given as the vector `input`.
  *
  * @param input: vector of leaf values.
- * @tparam Composer: type of composer.
+ * @tparam Builder: type of builder.
  */
-template <typename Composer> field_t<Composer> compute_tree_root(std::vector<field_t<Composer>> const& input)
+template <typename Builder> field_t<Builder> compute_tree_root(std::vector<field_t<Builder>> const& input)
 {
     // Check if the input vector size is a power of 2.
     ASSERT(input.size() > 0);
     ASSERT(!(input.size() & (input.size() - 1)) == true);
     auto layer = input;
     while (layer.size() > 1) {
-        std::vector<field_t<Composer>> next_layer(layer.size() / 2);
+        std::vector<field_t<Builder>> next_layer(layer.size() / 2);
         for (size_t i = 0; i < next_layer.size(); ++i) {
-            next_layer[i] = pedersen_hash<Composer>::hash_multiple({ layer[i * 2], layer[i * 2 + 1] });
+            next_layer[i] = pedersen_hash<Builder>::hash_multiple({ layer[i * 2], layer[i * 2 + 1] });
         }
         layer = std::move(next_layer);
     }
@@ -263,10 +263,10 @@ template <typename Composer> field_t<Composer> compute_tree_root(std::vector<fie
  * Checks if a given root matches the root computed from a set of leaves.
  *
  * @param values: vector of leaf values.
- * @tparam Composer: type of composer.
+ * @tparam Builder: type of builder.
  */
-template <typename Composer>
-bool_t<Composer> check_tree(field_t<Composer> const& root, std::vector<field_t<Composer>> const& values)
+template <typename Builder>
+bool_t<Builder> check_tree(field_t<Builder> const& root, std::vector<field_t<Builder>> const& values)
 {
     return compute_tree_root(values) == root;
 }
@@ -275,10 +275,10 @@ bool_t<Composer> check_tree(field_t<Composer> const& root, std::vector<field_t<C
  * Asserts if a given root matches the root computed from a set of leaves.
  *
  * @param values: vector of leaf values.
- * @tparam Composer: type of composer.
+ * @tparam Builder: type of builder.
  */
-template <typename Composer>
-void assert_check_tree(field_t<Composer> const& root, std::vector<field_t<Composer>> const& values)
+template <typename Builder>
+void assert_check_tree(field_t<Builder> const& root, std::vector<field_t<Builder>> const& values)
 {
     auto valid = check_tree(root, values);
     valid.assert_equal(true, "assert_check_tree");
@@ -293,18 +293,18 @@ void assert_check_tree(field_t<Composer> const& root, std::vector<field_t<Compos
  * @param new_values: The vector of values to be inserted from start_index,
  * @param start_index: The index of any leaf from which new values are inserted,
  * @param msg: error message.
- * @tparam Composer: type of composer.
+ * @tparam Builder: type of builder.
  */
-template <typename Composer>
-void batch_update_membership(field_t<Composer> const& new_root,
-                             field_t<Composer> const& old_root,
-                             hash_path<Composer> const& old_path,
-                             std::vector<field_t<Composer>> const& new_values,
-                             field_t<Composer> const& start_index,
+template <typename Builder>
+void batch_update_membership(field_t<Builder> const& new_root,
+                             field_t<Builder> const& old_root,
+                             hash_path<Builder> const& old_path,
+                             std::vector<field_t<Builder>> const& new_values,
+                             field_t<Builder> const& start_index,
                              std::string const& msg = "batch_update_membership")
 {
     size_t height = numeric::get_msb(new_values.size());
-    auto zero_subtree_root = field_t<Composer>(zero_hash_at_height(height));
+    auto zero_subtree_root = field_t<Builder>(zero_hash_at_height(height));
 
     auto rollup_root = compute_tree_root(new_values);
 
diff --git a/barretenberg/cpp/src/barretenberg/stdlib/merkle_tree/membership.test.cpp b/barretenberg/cpp/src/barretenberg/stdlib/merkle_tree/membership.test.cpp
index bd0ddb27038..577d0590563 100644
--- a/barretenberg/cpp/src/barretenberg/stdlib/merkle_tree/membership.test.cpp
+++ b/barretenberg/cpp/src/barretenberg/stdlib/merkle_tree/membership.test.cpp
@@ -17,34 +17,34 @@ using namespace barretenberg;
 using namespace proof_system::plonk::stdlib::merkle_tree;
 using namespace proof_system::plonk::stdlib;
 
-using Composer = proof_system::UltraCircuitBuilder;
+using Builder = proof_system::UltraCircuitBuilder;
 
-using bool_ct = bool_t<Composer>;
-using field_ct = field_t<Composer>;
-using witness_ct = witness_t<Composer>;
+using bool_ct = bool_t<Builder>;
+using field_ct = field_t<Builder>;
+using witness_ct = witness_t<Builder>;
 
 TEST(stdlib_merkle_tree, test_check_membership)
 {
     MemoryStore store;
     auto db = MerkleTree(store, 3);
-    auto composer = Composer();
+    auto builder = Builder();
 
     // Check membership at index 0.
-    auto zero = field_ct(witness_ct(&composer, fr::zero())).decompose_into_bits();
-    field_ct root = witness_ct(&composer, db.root());
+    auto zero = field_ct(witness_ct(&builder, fr::zero())).decompose_into_bits();
+    field_ct root = witness_ct(&builder, db.root());
     bool_ct is_member =
-        check_membership(root, create_witness_hash_path(composer, db.get_hash_path(0)), field_ct(0), zero);
+        check_membership(root, create_witness_hash_path(builder, db.get_hash_path(0)), field_ct(0), zero);
 
     // Check membership at index 7 after inserting 1.
     db.update_element(7, 1);
-    auto seven = field_ct(witness_ct(&composer, fr(7))).decompose_into_bits();
-    root = witness_ct(&composer, db.root());
+    auto seven = field_ct(witness_ct(&builder, fr(7))).decompose_into_bits();
+    root = witness_ct(&builder, db.root());
     bool_ct is_member_ =
-        check_membership(root, create_witness_hash_path(composer, db.get_hash_path(1)), field_ct(1), seven);
+        check_membership(root, create_witness_hash_path(builder, db.get_hash_path(1)), field_ct(1), seven);
 
-    printf("composer gates = %zu\n", composer.get_num_gates());
+    printf("num gates = %zu\n", builder.get_num_gates());
 
-    bool result = composer.check_circuit();
+    bool result = builder.check_circuit();
     EXPECT_EQ(is_member.get_value(), true);
     EXPECT_EQ(is_member_.get_value(), true);
     EXPECT_EQ(result, true);
@@ -54,25 +54,25 @@ TEST(stdlib_merkle_tree, test_batch_update_membership)
 {
     MemoryStore store;
     MerkleTree db(store, 4);
-    auto composer = Composer();
+    auto builder = Builder();
     // Fill in an arbitrary value at i = 2.
     db.update_element(2, fr::random_element());
     // Define old state.
-    field_ct old_root = witness_ct(&composer, db.root());
-    auto old_hash_path_1 = create_witness_hash_path(composer, db.get_hash_path(5));
-    auto old_hash_path_2 = create_witness_hash_path(composer, db.get_hash_path(7));
+    field_ct old_root = witness_ct(&builder, db.root());
+    auto old_hash_path_1 = create_witness_hash_path(builder, db.get_hash_path(5));
+    auto old_hash_path_2 = create_witness_hash_path(builder, db.get_hash_path(7));
     auto values = std::vector<field_ct>(4);
     for (size_t i = 4; i < 8; i++) {
-        values[i - 4] = field_ct(&composer, i * 2);
+        values[i - 4] = field_ct(&builder, i * 2);
         db.update_element(i, fr(i * 2));
     }
     // Define new state. Batch update must verify with any old hash path in the subtree.
-    field_ct new_root = witness_ct(&composer, db.root());
-    field_ct start_idx = field_ct(witness_ct(&composer, fr(4)));
+    field_ct new_root = witness_ct(&builder, db.root());
+    field_ct start_idx = field_ct(witness_ct(&builder, fr(4)));
     batch_update_membership(new_root, old_root, old_hash_path_1, values, start_idx);
     batch_update_membership(new_root, old_root, old_hash_path_2, values, start_idx);
-    printf("composer gates = %zu\n", composer.get_num_gates());
-    bool result = composer.check_circuit();
+    printf("num gates = %zu\n", builder.get_num_gates());
+    bool result = builder.check_circuit();
     EXPECT_EQ(result, true);
 }
 
@@ -80,16 +80,16 @@ TEST(stdlib_merkle_tree, test_assert_check_membership)
 {
     MemoryStore store;
     auto db = MerkleTree(store, 3);
-    auto composer = Composer();
+    auto builder = Builder();
 
-    auto zero = field_ct(witness_ct(&composer, fr::zero())).decompose_into_bits();
-    field_ct root = witness_ct(&composer, db.root());
+    auto zero = field_ct(witness_ct(&builder, fr::zero())).decompose_into_bits();
+    field_ct root = witness_ct(&builder, db.root());
 
-    assert_check_membership(root, create_witness_hash_path(composer, db.get_hash_path(0)), field_ct(0), zero);
+    assert_check_membership(root, create_witness_hash_path(builder, db.get_hash_path(0)), field_ct(0), zero);
 
-    printf("composer gates = %zu\n", composer.get_num_gates());
+    printf("num gates = %zu\n", builder.get_num_gates());
 
-    bool result = composer.check_circuit();
+    bool result = builder.check_circuit();
     EXPECT_EQ(result, true);
 }
 
@@ -98,16 +98,16 @@ TEST(stdlib_merkle_tree, test_assert_check_membership_fail)
     MemoryStore store;
     auto db = MerkleTree(store, 3);
 
-    auto composer = Composer();
+    auto builder = Builder();
 
-    auto zero = field_ct(witness_ct(&composer, fr::zero())).decompose_into_bits();
-    field_ct root = witness_ct(&composer, db.root());
+    auto zero = field_ct(witness_ct(&builder, fr::zero())).decompose_into_bits();
+    field_ct root = witness_ct(&builder, db.root());
 
-    assert_check_membership(root, create_witness_hash_path(composer, db.get_hash_path(0)), field_ct(1), zero);
+    assert_check_membership(root, create_witness_hash_path(builder, db.get_hash_path(0)), field_ct(1), zero);
 
-    printf("composer gates = %zu\n", composer.get_num_gates());
+    printf("num gates = %zu\n", builder.get_num_gates());
 
-    bool result = composer.check_circuit();
+    bool result = builder.check_circuit();
     EXPECT_EQ(result, false);
 }
 // To test whether both old hash path and new hash path works for the same Merkle tree
@@ -117,48 +117,48 @@ TEST(stdlib_merkle_tree, test_update_members)
         MemoryStore store;
         auto db = MerkleTree(store, 3);
 
-        auto composer = Composer();
+        auto builder = Builder();
 
-        auto zero = field_ct(witness_ct(&composer, fr::zero())).decompose_into_bits();
+        auto zero = field_ct(witness_ct(&builder, fr::zero())).decompose_into_bits();
 
         auto old_value = field_ct(0);
-        hash_path<Composer> old_path = create_witness_hash_path(composer, db.get_hash_path(0));
-        field_ct old_root = witness_ct(&composer, db.root());
+        hash_path<Builder> old_path = create_witness_hash_path(builder, db.get_hash_path(0));
+        field_ct old_root = witness_ct(&builder, db.root());
 
         auto new_value = field_ct(1);
         auto new_path_fr = get_new_hash_path(db.get_hash_path(0), 0, new_value.get_value());
-        hash_path<Composer> new_path = create_witness_hash_path(composer, new_path_fr);
-        field_ct new_root = witness_ct(&composer, get_hash_path_root(new_path_fr));
+        hash_path<Builder> new_path = create_witness_hash_path(builder, new_path_fr);
+        field_ct new_root = witness_ct(&builder, get_hash_path_root(new_path_fr));
 
         update_membership(new_root, new_value, old_root, old_path, old_value, zero);
 
-        printf("composer gates = %zu\n", composer.get_num_gates());
+        printf("num gates = %zu\n", builder.get_num_gates());
 
-        bool result = composer.check_circuit();
+        bool result = builder.check_circuit();
         EXPECT_EQ(result, true);
     }
     {
         MemoryStore store;
         auto db = MerkleTree(store, 3);
 
-        auto composer = Composer();
+        auto builder = Builder();
 
-        auto zero = field_ct(witness_ct(&composer, fr::zero())).decompose_into_bits();
+        auto zero = field_ct(witness_ct(&builder, fr::zero())).decompose_into_bits();
 
         auto old_value = field_ct(0);
-        hash_path<Composer> old_path = create_witness_hash_path(composer, db.get_hash_path(0));
-        field_ct old_root = witness_ct(&composer, db.root());
+        hash_path<Builder> old_path = create_witness_hash_path(builder, db.get_hash_path(0));
+        field_ct old_root = witness_ct(&builder, db.root());
 
         auto new_value = field_ct(1);
         auto new_path_fr = get_new_hash_path(db.get_hash_path(0), 0, new_value.get_value());
-        hash_path<Composer> new_path = create_witness_hash_path(composer, new_path_fr);
-        field_ct new_root = witness_ct(&composer, get_hash_path_root(new_path_fr));
+        hash_path<Builder> new_path = create_witness_hash_path(builder, new_path_fr);
+        field_ct new_root = witness_ct(&builder, get_hash_path_root(new_path_fr));
 
         update_membership(new_root, new_value, old_root, new_path, old_value, zero);
 
-        printf("composer gates = %zu\n", composer.get_num_gates());
+        printf("num gates = %zu\n", builder.get_num_gates());
 
-        bool result = composer.check_circuit();
+        bool result = builder.check_circuit();
         EXPECT_EQ(result, true);
     }
 }
@@ -171,17 +171,17 @@ TEST(stdlib_merkle_tree, test_tree)
     MerkleTree db(store, depth);
     MemoryTree mem_tree(depth);
 
-    auto composer = Composer();
+    auto builder = Builder();
 
-    auto zero_field = field_ct(witness_ct(&composer, fr::zero()));
+    auto zero_field = field_ct(witness_ct(&builder, fr::zero()));
     auto values = std::vector<field_ct>(num, zero_field);
-    auto root = field_ct(&composer, mem_tree.root());
+    auto root = field_ct(&builder, mem_tree.root());
 
     assert_check_tree(root, values);
 
-    printf("composer gates = %zu\n", composer.get_num_gates());
+    printf("num gates = %zu\n", builder.get_num_gates());
 
-    bool result = composer.check_circuit();
+    bool result = builder.check_circuit();
     EXPECT_EQ(result, true);
 }
 
@@ -191,7 +191,7 @@ TEST(stdlib_merkle_tree, test_update_memberships)
     MemoryStore store;
     MerkleTree tree(store, depth);
 
-    auto composer = Composer();
+    auto builder = Builder();
 
     constexpr size_t filled = (1UL << depth) / 2;
     std::vector<fr> filled_values;
@@ -222,29 +222,29 @@ TEST(stdlib_merkle_tree, test_update_memberships)
     }
 
     // old state circuit types
-    field_ct old_root_ct = witness_ct(&composer, old_root);
-    std::vector<bit_vector<Composer>> old_indices_ct;
+    field_ct old_root_ct = witness_ct(&builder, old_root);
+    std::vector<bit_vector<Builder>> old_indices_ct;
     std::vector<field_ct> old_values_ct;
-    std::vector<hash_path<Composer>> old_hash_paths_ct;
+    std::vector<hash_path<Builder>> old_hash_paths_ct;
 
     // new state circuit types
     std::vector<field_ct> new_values_ct;
     std::vector<field_ct> new_roots_ct;
 
     for (size_t i = 0; i < old_indices.size(); i++) {
-        auto idx_vec = field_ct(witness_ct(&composer, uint256_t(old_indices[i]))).decompose_into_bits(depth);
+        auto idx_vec = field_ct(witness_ct(&builder, uint256_t(old_indices[i]))).decompose_into_bits(depth);
         old_indices_ct.push_back(idx_vec);
-        old_values_ct.push_back(witness_ct(&composer, old_values[i]));
-        old_hash_paths_ct.push_back(create_witness_hash_path(composer, old_hash_paths[i]));
+        old_values_ct.push_back(witness_ct(&builder, old_values[i]));
+        old_hash_paths_ct.push_back(create_witness_hash_path(builder, old_hash_paths[i]));
 
-        new_values_ct.push_back(witness_ct(&composer, new_values[i]));
-        new_roots_ct.push_back(witness_ct(&composer, new_roots[i]));
+        new_values_ct.push_back(witness_ct(&builder, new_values[i]));
+        new_roots_ct.push_back(witness_ct(&builder, new_roots[i]));
     }
 
     update_memberships(old_root_ct, new_roots_ct, new_values_ct, old_values_ct, old_hash_paths_ct, old_indices_ct);
 
-    printf("composer gates = %zu\n", composer.get_num_gates());
-    bool result = composer.check_circuit();
+    printf("num gates = %zu\n", builder.get_num_gates());
+    bool result = builder.check_circuit();
     EXPECT_EQ(result, true);
 }
 } // namespace proof_system::stdlib_merkle_test
\ No newline at end of file
diff --git a/barretenberg/cpp/src/barretenberg/stdlib/merkle_tree/merkle_tree.test.cpp b/barretenberg/cpp/src/barretenberg/stdlib/merkle_tree/merkle_tree.test.cpp
index 121da58d438..0715c5be073 100644
--- a/barretenberg/cpp/src/barretenberg/stdlib/merkle_tree/merkle_tree.test.cpp
+++ b/barretenberg/cpp/src/barretenberg/stdlib/merkle_tree/merkle_tree.test.cpp
@@ -10,10 +10,10 @@ namespace proof_system::test_stdlib_merkle_tree {
 using namespace proof_system::plonk::stdlib;
 using namespace proof_system::plonk::stdlib::merkle_tree;
 
-using Composer = proof_system::UltraCircuitBuilder;
+using Builder = proof_system::UltraCircuitBuilder;
 
-using field_ct = field_t<Composer>;
-using witness_ct = witness_t<Composer>;
+using field_ct = field_t<Builder>;
+using witness_ct = witness_t<Builder>;
 namespace {
 auto& engine = numeric::random::get_debug_engine();
 auto& random_engine = numeric::random::get_engine();
diff --git a/barretenberg/cpp/src/barretenberg/stdlib/primitives/address/address.hpp b/barretenberg/cpp/src/barretenberg/stdlib/primitives/address/address.hpp
index 28dfdb915a1..55af6848571 100644
--- a/barretenberg/cpp/src/barretenberg/stdlib/primitives/address/address.hpp
+++ b/barretenberg/cpp/src/barretenberg/stdlib/primitives/address/address.hpp
@@ -70,18 +70,18 @@ template <typename B> void write(B& buf, address const& addr)
 }
 
 // Circuit type
-template <typename Composer> class address_t {
+template <typename Builder> class address_t {
   public:
-    field_t<Composer> address_;
-    Composer* context_;
+    field_t<Builder> address_;
+    Builder* context_;
 
     address_t() = default;
 
-    address_t(address_t<Composer> const& other)
+    address_t(address_t<Builder> const& other)
         : address_(other.address_)
         , context_(other.context_){};
 
-    address_t(field_t<Composer> const& address)
+    address_t(field_t<Builder> const& address)
         : address_(address)
         , context_(address.context){};
 
@@ -93,24 +93,24 @@ template <typename Composer> class address_t {
         : address_(address)
         , context_(nullptr){};
 
-    address_t(witness_t<Composer> const& witness)
+    address_t(witness_t<Builder> const& witness)
     {
         address_ = field_t(witness);
         context_ = witness.context;
     }
 
-    address_t<Composer>& operator=(const address_t<Composer>& other)
+    address_t<Builder>& operator=(const address_t<Builder>& other)
     {
         address_ = other.address_;
         context_ = other.context_;
         return *this;
     }
 
-    bool_t<Composer> operator==(const address_t& other) const { return this->to_field() == other.to_field(); }
+    bool_t<Builder> operator==(const address_t& other) const { return this->to_field() == other.to_field(); }
 
-    bool_t<Composer> operator!=(const address_t& other) const { return this->to_field() != other.to_field(); }
+    bool_t<Builder> operator!=(const address_t& other) const { return this->to_field() != other.to_field(); }
 
-    field_t<Composer> to_field() const { return address_; }
+    field_t<Builder> to_field() const { return address_; }
 
     fr get_value() const { return address_.get_value(); };
 
@@ -122,26 +122,26 @@ template <typename Composer> class address_t {
     void assert_is_in_set(const std::vector<address_t>& set,
                           std::string const& msg = "address_t::assert_is_in_set") const
     {
-        std::vector<field_t<Composer>> field_set;
+        std::vector<field_t<Builder>> field_set;
         for (const auto& e : set) {
             field_set.push_back(e.address_);
         }
         address_.assert_is_in_set(field_set, msg);
     }
 
-    static address_t conditional_assign(const bool_t<Composer>& predicate, const address_t& lhs, const address_t& rhs)
+    static address_t conditional_assign(const bool_t<Builder>& predicate, const address_t& lhs, const address_t& rhs)
     {
-        return field_t<Composer>::conditional_assign(predicate, lhs.address_, rhs.address_);
+        return field_t<Builder>::conditional_assign(predicate, lhs.address_, rhs.address_);
     };
 
-    static address_t<Composer> derive_from_private_key(field_t<Composer> const& private_key)
+    static address_t<Builder> derive_from_private_key(field_t<Builder> const& private_key)
     {
         // TODO: Dummy logic, for now. Proper derivation undecided.
-        point<Composer> public_key = group<Composer>::template fixed_base_scalar_mul_g1<254>(private_key);
-        return address_t<Composer>(public_key.x);
+        point<Builder> public_key = group<Builder>::template fixed_base_scalar_mul_g1<254>(private_key);
+        return address_t<Builder>(public_key.x);
     }
 
-    friend std::ostream& operator<<(std::ostream& os, address_t<Composer> const& v) { return os << v.address_; }
+    friend std::ostream& operator<<(std::ostream& os, address_t<Builder> const& v) { return os << v.address_; }
 };
 
 } // namespace stdlib
diff --git a/barretenberg/cpp/src/barretenberg/stdlib/primitives/bigfield/bigfield.fuzzer.hpp b/barretenberg/cpp/src/barretenberg/stdlib/primitives/bigfield/bigfield.fuzzer.hpp
index 7fbdedb9c81..18e2cbe129e 100644
--- a/barretenberg/cpp/src/barretenberg/stdlib/primitives/bigfield/bigfield.fuzzer.hpp
+++ b/barretenberg/cpp/src/barretenberg/stdlib/primitives/bigfield/bigfield.fuzzer.hpp
@@ -119,13 +119,13 @@ FastRandom VarianceRNG(0);
  * @brief The class parametrizing Bigfield fuzzing instructions, execution, etc
  *
  */
-template <typename Composer> class BigFieldBase {
+template <typename Builder> class BigFieldBase {
   private:
-    typedef proof_system::plonk::stdlib::bool_t<Composer> bool_t;
-    typedef proof_system::plonk::stdlib::field_t<Composer> field_t;
-    typedef proof_system::plonk::stdlib::witness_t<Composer> witness_t;
-    typedef proof_system::plonk::stdlib::public_witness_t<Composer> public_witness_t;
-    typedef proof_system::plonk::stdlib::bigfield<Composer, barretenberg::Bn254FqParams> bigfield_t;
+    typedef proof_system::plonk::stdlib::bool_t<Builder> bool_t;
+    typedef proof_system::plonk::stdlib::field_t<Builder> field_t;
+    typedef proof_system::plonk::stdlib::witness_t<Builder> witness_t;
+    typedef proof_system::plonk::stdlib::public_witness_t<Builder> public_witness_t;
+    typedef proof_system::plonk::stdlib::bigfield<Builder, barretenberg::Bn254FqParams> bigfield_t;
 
   public:
     /**
@@ -799,7 +799,7 @@ template <typename Composer> class BigFieldBase {
      */
     class ExecutionHandler {
       private:
-        static bool_t construct_predicate(Composer* composer, const bool predicate)
+        static bool_t construct_predicate(Builder* builder, const bool predicate)
         {
             /* The context field of a predicate can be nullptr;
              * in that case, the function that handles the predicate
@@ -807,7 +807,7 @@ template <typename Composer> class BigFieldBase {
              */
             const bool predicate_has_ctx = static_cast<bool>(VarianceRNG.next() % 2);
 
-            return bool_t(predicate_has_ctx ? composer : nullptr, predicate);
+            return bool_t(predicate_has_ctx ? builder : nullptr, predicate);
         }
         bigfield_t bf() const
         {
@@ -1027,20 +1027,19 @@ template <typename Composer> class BigFieldBase {
             }
         }
 
-        ExecutionHandler conditional_negate(Composer* composer, const bool predicate)
+        ExecutionHandler conditional_negate(Builder* builder, const bool predicate)
         {
             return ExecutionHandler(predicate ? -(this->base) : this->base,
-                                    this->bf().conditional_negate(construct_predicate(composer, predicate)));
+                                    this->bf().conditional_negate(construct_predicate(builder, predicate)));
         }
 
-        ExecutionHandler conditional_select(Composer* composer, ExecutionHandler& other, const bool predicate)
+        ExecutionHandler conditional_select(Builder* builder, ExecutionHandler& other, const bool predicate)
         {
-            return ExecutionHandler(
-                predicate ? other.base : this->base,
-                this->bf().conditional_select(other.bf(), construct_predicate(composer, predicate)));
+            return ExecutionHandler(predicate ? other.base : this->base,
+                                    this->bf().conditional_select(other.bf(), construct_predicate(builder, predicate)));
         }
         /* Explicit re-instantiation using the various bigfield_t constructors */
-        ExecutionHandler set(Composer* composer)
+        ExecutionHandler set(Builder* builder)
         {
             /* Invariant check */
             if (this->bigfield.get_value() > this->bigfield.get_maximum_value()) {
@@ -1054,7 +1053,7 @@ template <typename Composer> class BigFieldBase {
                 return ExecutionHandler(this->base, bigfield_t(this->bigfield));
             case 1:
                 /* Construct via uint256_t */
-                return ExecutionHandler(this->base, bigfield_t(composer, bf_u256()));
+                return ExecutionHandler(this->base, bigfield_t(builder, bf_u256()));
             case 2:
                 /* Construct via byte_array */
                 /*
@@ -1066,8 +1065,8 @@ template <typename Composer> class BigFieldBase {
                 const uint256_t u256 = bf_u256();
                 const uint256_t u256_lo = u256.slice(0, bigfield_t::NUM_LIMB_BITS * 2);
                 const uint256_t u256_hi = u256.slice(bigfield_t::NUM_LIMB_BITS * 2, bigfield_t::NUM_LIMB_BITS * 4);
-                const field_t field_lo(composer, u256_lo);
-                const field_t field_hi(composer, u256_hi);
+                const field_t field_lo(builder, u256_lo);
+                const field_t field_hi(builder, u256_hi);
 
                 /* Construct via two field_t's */
                 return ExecutionHandler(this->base, bigfield_t(field_lo, field_hi));
@@ -1075,7 +1074,7 @@ template <typename Composer> class BigFieldBase {
             case 4: {
                 /* Invoke assignment operator */
 
-                bigfield_t bf_new(composer);
+                bigfield_t bf_new(builder);
                 bf_new = bf();
 
                 return ExecutionHandler(this->base, bigfield_t(bf_new));
@@ -1094,18 +1093,18 @@ template <typename Composer> class BigFieldBase {
         /**
          * @brief Execute the constant instruction (push constant safeuint to the stack)
          *
-         * @param composer
+         * @param builder
          * @param stack
          * @param instruction
          * @return 0 if everything is ok, 1 if we should stop execution, since an expected error was encountered
          */
-        static inline size_t execute_CONSTANT(Composer* composer,
+        static inline size_t execute_CONSTANT(Builder* builder,
                                               std::vector<ExecutionHandler>& stack,
                                               Instruction& instruction)
         {
-            (void)composer;
+            (void)builder;
             stack.push_back(ExecutionHandler(instruction.arguments.element.value,
-                                             bigfield_t(composer, instruction.arguments.element.value)));
+                                             bigfield_t(builder, instruction.arguments.element.value)));
 #ifdef SHOW_INFORMATION
             std::cout << "Pushed constant value " << instruction.arguments.element.value << " to position "
                       << stack.size() - 1 << std::endl;
@@ -1116,12 +1115,12 @@ template <typename Composer> class BigFieldBase {
         /**
          * @brief Execute the witness instruction (push witness safeuit to the stack)
          *
-         * @param composer
+         * @param builder
          * @param stack
          * @param instruction
          * @return if everything is ok, 1 if we should stop execution, since an expected error was encountered
          */
-        static inline size_t execute_WITNESS(Composer* composer,
+        static inline size_t execute_WITNESS(Builder* builder,
                                              std::vector<ExecutionHandler>& stack,
                                              Instruction& instruction)
         {
@@ -1129,9 +1128,9 @@ template <typename Composer> class BigFieldBase {
             // THis is strange
             stack.push_back(
                 ExecutionHandler(instruction.arguments.element.value,
-                                 bigfield_t::from_witness(composer, fq(instruction.arguments.element.value))));
+                                 bigfield_t::from_witness(builder, fq(instruction.arguments.element.value))));
             // stack.push_back(
-            //    bigfield_t::create_from_u512_as_witness(composer,
+            //    bigfield_t::create_from_u512_as_witness(builder,
             //    uint256_t(instruction.arguments.element.value)));
 
 #ifdef SHOW_INFORMATION
@@ -1145,18 +1144,18 @@ template <typename Composer> class BigFieldBase {
          * @brief Execute the constant_witness instruction (push a safeuint witness equal to the constant to the
          * stack)
          *
-         * @param composer
+         * @param builder
          * @param stack
          * @param instruction
          * @return 0 if everything is ok, 1 if we should stop execution, since an expected error was encountered
          */
-        static inline size_t execute_CONSTANT_WITNESS(Composer* composer,
+        static inline size_t execute_CONSTANT_WITNESS(Builder* builder,
                                                       std::vector<ExecutionHandler>& stack,
                                                       Instruction& instruction)
         {
             stack.push_back(ExecutionHandler(
                 instruction.arguments.element.value,
-                bigfield_t::create_from_u512_as_witness(composer, uint256_t(instruction.arguments.element.value))));
+                bigfield_t::create_from_u512_as_witness(builder, uint256_t(instruction.arguments.element.value))));
 #ifdef SHOW_INFORMATION
             std::cout << "Pushed constant witness value " << instruction.arguments.element.value << " to position "
                       << stack.size() - 1 << std::endl;
@@ -1166,17 +1165,17 @@ template <typename Composer> class BigFieldBase {
         /**
          * @brief Execute the multiply instruction
          *
-         * @param composer
+         * @param builder
          * @param stack
          * @param instruction
          * @return if everything is ok, 1 if we should stop execution, since an expected error was encountered
          */
-        static inline size_t execute_MULTIPLY(Composer* composer,
+        static inline size_t execute_MULTIPLY(Builder* builder,
                                               std::vector<ExecutionHandler>& stack,
                                               Instruction& instruction)
         {
 
-            (void)composer;
+            (void)builder;
             if (stack.size() == 0) {
                 return 1;
             }
@@ -1202,16 +1201,16 @@ template <typename Composer> class BigFieldBase {
         /**
          * @brief Execute the addition operator instruction
          *
-         * @param composer
+         * @param builder
          * @param stack
          * @param instruction
          * @return if everything is ok, 1 if we should stop execution, since an expected error was encountered
          */
-        static inline size_t execute_ADD(Composer* composer,
+        static inline size_t execute_ADD(Builder* builder,
                                          std::vector<ExecutionHandler>& stack,
                                          Instruction& instruction)
         {
-            (void)composer;
+            (void)builder;
             if (stack.size() == 0) {
                 return 1;
             }
@@ -1238,16 +1237,16 @@ template <typename Composer> class BigFieldBase {
         /**
          * @brief Execute the SQR  instruction
          *
-         * @param composer
+         * @param builder
          * @param stack
          * @param instruction
          * @return if everything is ok, 1 if we should stop execution, since an expected error was encountered
          */
-        static inline size_t execute_SQR(Composer* composer,
+        static inline size_t execute_SQR(Builder* builder,
                                          std::vector<ExecutionHandler>& stack,
                                          Instruction& instruction)
         {
-            (void)composer;
+            (void)builder;
             if (stack.size() == 0) {
                 return 1;
             }
@@ -1273,16 +1272,16 @@ template <typename Composer> class BigFieldBase {
         /**
          * @brief Execute the ASSERT_EQUAL  instruction
          *
-         * @param composer
+         * @param builder
          * @param stack
          * @param instruction
          * @return if everything is ok, 1 if we should stop execution, since an expected error was encountered
          */
-        static inline size_t execute_ASSERT_EQUAL(Composer* composer,
+        static inline size_t execute_ASSERT_EQUAL(Builder* builder,
                                                   std::vector<ExecutionHandler>& stack,
                                                   Instruction& instruction)
         {
-            (void)composer;
+            (void)builder;
             if (stack.size() == 0) {
                 return 1;
             }
@@ -1301,16 +1300,16 @@ template <typename Composer> class BigFieldBase {
         /**
          * @brief Execute the ASSERT_NOT_EQUAL  instruction
          *
-         * @param composer
+         * @param builder
          * @param stack
          * @param instruction
          * @return if everything is ok, 1 if we should stop execution, since an expected error was encountered
          */
-        static inline size_t execute_ASSERT_NOT_EQUAL(Composer* composer,
+        static inline size_t execute_ASSERT_NOT_EQUAL(Builder* builder,
                                                       std::vector<ExecutionHandler>& stack,
                                                       Instruction& instruction)
         {
-            (void)composer;
+            (void)builder;
             if (stack.size() == 0) {
                 return 1;
             }
@@ -1333,16 +1332,16 @@ template <typename Composer> class BigFieldBase {
         /**
          * @brief Execute the subtraction operator instruction
          *
-         * @param composer
+         * @param builder
          * @param stack
          * @param instruction
          * @return if everything is ok, 1 if we should stop execution, since an expected error was encountered
          */
-        static inline size_t execute_SUBTRACT(Composer* composer,
+        static inline size_t execute_SUBTRACT(Builder* builder,
                                               std::vector<ExecutionHandler>& stack,
                                               Instruction& instruction)
         {
-            (void)composer;
+            (void)builder;
             if (stack.size() == 0) {
                 return 1;
             }
@@ -1368,16 +1367,16 @@ template <typename Composer> class BigFieldBase {
         /**
          * @brief Execute the division operator instruction
          *
-         * @param composer
+         * @param builder
          * @param stack
          * @param instruction
          * @return if everything is ok, 1 if we should stop execution, since an expected error was encountered
          */
-        static inline size_t execute_DIVIDE(Composer* composer,
+        static inline size_t execute_DIVIDE(Builder* builder,
                                             std::vector<ExecutionHandler>& stack,
                                             Instruction& instruction)
         {
-            (void)composer;
+            (void)builder;
             if (stack.size() == 0) {
                 return 1;
             }
@@ -1410,17 +1409,17 @@ template <typename Composer> class BigFieldBase {
         /**
          * @brief Execute the MADD instruction
          *
-         * @param composer
+         * @param builder
          * @param stack
          * @param instruction
          * @return if everything is ok, 1 if we should stop execution, since an expected error was encountered
         size_t
          */
-        static inline size_t execute_MADD(Composer* composer,
+        static inline size_t execute_MADD(Builder* builder,
                                           std::vector<ExecutionHandler>& stack,
                                           Instruction& instruction)
         {
-            (void)composer;
+            (void)builder;
             if (stack.size() == 0) {
                 return 1;
             }
@@ -1446,17 +1445,17 @@ template <typename Composer> class BigFieldBase {
         /**
          * @brief Execute the MULT_MADD instruction
          *
-         * @param composer
+         * @param builder
          * @param stack
          * @param instruction
          * @return if everything is ok, 1 if we should stop execution, since an expected error was encountered
         size_t
          */
-        static inline size_t execute_MULT_MADD(Composer* composer,
+        static inline size_t execute_MULT_MADD(Builder* builder,
                                                std::vector<ExecutionHandler>& stack,
                                                Instruction& instruction)
         {
-            (void)composer;
+            (void)builder;
             if (stack.size() == 0) {
                 return 1;
             }
@@ -1519,17 +1518,17 @@ template <typename Composer> class BigFieldBase {
         /**
          * @brief Execute the MSUB_DIV instruction
          *
-         * @param composer
+         * @param builder
          * @param stack
          * @param instruction
          * @return if everything is ok, 1 if we should stop execution, since an expected error was encountered
         size_t
          */
-        static inline size_t execute_MSUB_DIV(Composer* composer,
+        static inline size_t execute_MSUB_DIV(Builder* builder,
                                               std::vector<ExecutionHandler>& stack,
                                               Instruction& instruction)
         {
-            (void)composer;
+            (void)builder;
             if (stack.size() == 0) {
                 return 1;
             }
@@ -1602,17 +1601,17 @@ template <typename Composer> class BigFieldBase {
         /**
          * @brief Execute the SQR_ADD instruction
          *
-         * @param composer
+         * @param builder
          * @param stack
          * @param instruction
          * @return if everything is ok, 1 if we should stop execution, since an expected error was encountered
         size_t
          */
-        static inline size_t execute_SQR_ADD(Composer* composer,
+        static inline size_t execute_SQR_ADD(Builder* builder,
                                              std::vector<ExecutionHandler>& stack,
                                              Instruction& instruction)
         {
-            (void)composer;
+            (void)builder;
             if (stack.size() == 0) {
                 return 1;
             }
@@ -1663,16 +1662,16 @@ template <typename Composer> class BigFieldBase {
         /**
          * @brief Execute the COND_NEGATE instruction
          *
-         * @param composer
+         * @param builder
          * @param stack
          * @param instruction
          * @return if everything is ok, 1 if we should stop execution, since an expected error was encountered
          */
-        static inline size_t execute_COND_NEGATE(Composer* composer,
+        static inline size_t execute_COND_NEGATE(Builder* builder,
                                                  std::vector<ExecutionHandler>& stack,
                                                  Instruction& instruction)
         {
-            (void)composer;
+            (void)builder;
             if (stack.size() == 0) {
                 return 1;
             }
@@ -1680,7 +1679,7 @@ template <typename Composer> class BigFieldBase {
             size_t output_index = instruction.arguments.threeArgs.out % stack.size();
             bool predicate = instruction.arguments.threeArgs.in2 % 2;
             ExecutionHandler result;
-            result = stack[first_index].conditional_negate(composer, predicate);
+            result = stack[first_index].conditional_negate(builder, predicate);
             // If the output index is larger than the number of elements in stack, append
             if (output_index >= stack.size()) {
                 PRINT_RESULT("", "pushed to ", stack.size(), result)
@@ -1696,16 +1695,16 @@ template <typename Composer> class BigFieldBase {
         /**
          * @brief Execute the COND_SELECT instruction
          *
-         * @param composer
+         * @param builder
          * @param stack
          * @param instruction
          * @return if everything is ok, 1 if we should stop execution, since an expected error was encountered
          */
-        static inline size_t execute_COND_SELECT(Composer* composer,
+        static inline size_t execute_COND_SELECT(Builder* builder,
                                                  std::vector<ExecutionHandler>& stack,
                                                  Instruction& instruction)
         {
-            (void)composer;
+            (void)builder;
             if (stack.size() == 0) {
                 return 1;
             }
@@ -1715,7 +1714,7 @@ template <typename Composer> class BigFieldBase {
             bool predicate = instruction.arguments.fourArgs.in3 % 2;
 
             ExecutionHandler result;
-            result = stack[first_index].conditional_select(composer, stack[second_index], predicate);
+            result = stack[first_index].conditional_select(builder, stack[second_index], predicate);
             // If the output index is larger than the number of elements in stack, append
             if (output_index >= stack.size()) {
                 PRINT_RESULT("", "pushed to ", stack.size(), result)
@@ -1730,23 +1729,23 @@ template <typename Composer> class BigFieldBase {
         /**
          * @brief Execute the SET instruction
          *
-         * @param composer
+         * @param builder
          * @param stack
          * @param instruction
          * @return if everything is ok, 1 if we should stop execution, since an expected error was encountered
          */
-        static inline size_t execute_SET(Composer* composer,
+        static inline size_t execute_SET(Builder* builder,
                                          std::vector<ExecutionHandler>& stack,
                                          Instruction& instruction)
         {
-            (void)composer;
+            (void)builder;
             if (stack.size() == 0) {
                 return 1;
             }
             size_t first_index = instruction.arguments.twoArgs.in % stack.size();
             size_t output_index = instruction.arguments.twoArgs.out;
             ExecutionHandler result;
-            result = stack[first_index].set(composer);
+            result = stack[first_index].set(builder);
             // If the output index is larger than the number of elements in stack, append
             if (output_index >= stack.size()) {
                 stack.push_back(result);
@@ -1758,16 +1757,16 @@ template <typename Composer> class BigFieldBase {
         /**
          * @brief Execute the RANDOMSEED instruction
          *
-         * @param composer
+         * @param builder
          * @param stack
          * @param instruction
          * @return if everything is ok, 1 if we should stop execution, since an expected error was encountered
          */
-        static inline size_t execute_RANDOMSEED(Composer* composer,
+        static inline size_t execute_RANDOMSEED(Builder* builder,
                                                 std::vector<ExecutionHandler>& stack,
                                                 Instruction& instruction)
         {
-            (void)composer;
+            (void)builder;
             (void)stack;
 
             VarianceRNG.reseed(instruction.arguments.randomseed);
@@ -1782,15 +1781,15 @@ template <typename Composer> class BigFieldBase {
     /**
      * @brief Check that the resulting values are equal to expected
      *
-     * @tparam Composer
-     * @param composer
+     * @tparam Builder
+     * @param builder
      * @param stack
      * @return true
      * @return false
      */
-    inline static bool postProcess(Composer* composer, std::vector<BigFieldBase::ExecutionHandler>& stack)
+    inline static bool postProcess(Builder* builder, std::vector<BigFieldBase::ExecutionHandler>& stack)
     {
-        (void)composer;
+        (void)builder;
         for (size_t i = 0; i < stack.size(); i++) {
             auto element = stack[i];
             if (fq((element.bigfield.get_value() % uint512_t(fq::modulus)).lo) != element.base) {
@@ -1968,7 +1967,7 @@ extern "C" size_t LLVMFuzzerCustomCrossOver(const uint8_t* Data1,
  */
 extern "C" size_t LLVMFuzzerTestOneInput(const uint8_t* Data, size_t Size)
 {
-    RunWithComposers<BigFieldBase, FuzzerCircuitTypes>(Data, Size, VarianceRNG);
+    RunWithBuilders<BigFieldBase, FuzzerCircuitTypes>(Data, Size, VarianceRNG);
     return 0;
 }
 
diff --git a/barretenberg/cpp/src/barretenberg/stdlib/primitives/bigfield/bigfield.hpp b/barretenberg/cpp/src/barretenberg/stdlib/primitives/bigfield/bigfield.hpp
index 2ccbcac523e..3de1bd7342b 100644
--- a/barretenberg/cpp/src/barretenberg/stdlib/primitives/bigfield/bigfield.hpp
+++ b/barretenberg/cpp/src/barretenberg/stdlib/primitives/bigfield/bigfield.hpp
@@ -14,7 +14,7 @@
 namespace proof_system::plonk {
 namespace stdlib {
 
-template <typename Composer, typename T> class bigfield {
+template <typename Builder, typename T> class bigfield {
 
   public:
     typedef T TParams;
@@ -27,7 +27,7 @@ template <typename Composer, typename T> class bigfield {
 
     struct Limb {
         Limb() {}
-        Limb(const field_t<Composer>& input, const uint256_t max = uint256_t(0))
+        Limb(const field_t<Builder>& input, const uint256_t max = uint256_t(0))
             : element(input)
         {
             if (input.witness_index == IS_CONSTANT) {
@@ -48,22 +48,22 @@ template <typename Composer, typename T> class bigfield {
         Limb& operator=(const Limb& other) = default;
         Limb& operator=(Limb&& other) = default;
 
-        field_t<Composer> element;
+        field_t<Builder> element;
         uint256_t maximum_value;
     };
 
-    bigfield(const field_t<Composer>& low_bits,
-             const field_t<Composer>& high_bits,
+    bigfield(const field_t<Builder>& low_bits,
+             const field_t<Builder>& high_bits,
              const bool can_overflow = false,
              const size_t maximum_bitlength = 0);
-    bigfield(Composer* parent_context = nullptr);
-    bigfield(Composer* parent_context, const uint256_t& value);
+    bigfield(Builder* parent_context = nullptr);
+    bigfield(Builder* parent_context, const uint256_t& value);
 
     // we assume the limbs have already been normalized!
-    bigfield(const field_t<Composer>& a,
-             const field_t<Composer>& b,
-             const field_t<Composer>& c,
-             const field_t<Composer>& d,
+    bigfield(const field_t<Builder>& a,
+             const field_t<Builder>& b,
+             const field_t<Builder>& c,
+             const field_t<Builder>& d,
              const bool can_overflow = false)
     {
         context = a.context;
@@ -79,11 +79,11 @@ template <typename Composer, typename T> class bigfield {
     };
 
     // we assume the limbs have already been normalized!
-    bigfield(const field_t<Composer>& a,
-             const field_t<Composer>& b,
-             const field_t<Composer>& c,
-             const field_t<Composer>& d,
-             const field_t<Composer>& prime_limb,
+    bigfield(const field_t<Builder>& a,
+             const field_t<Builder>& b,
+             const field_t<Builder>& c,
+             const field_t<Builder>& d,
+             const field_t<Builder>& prime_limb,
              const bool can_overflow = false)
     {
         context = a.context;
@@ -95,21 +95,21 @@ template <typename Composer, typename T> class bigfield {
         prime_basis_limb = prime_limb;
     };
 
-    bigfield(const byte_array<Composer>& bytes);
+    bigfield(const byte_array<Builder>& bytes);
     bigfield(const bigfield& other);
     bigfield(bigfield&& other);
 
-    static bigfield create_from_u512_as_witness(Composer* ctx,
+    static bigfield create_from_u512_as_witness(Builder* ctx,
                                                 const uint512_t& value,
                                                 const bool can_overflow = false,
                                                 const size_t maximum_bitlength = 0);
 
-    static bigfield from_witness(Composer* ctx, const barretenberg::field<T>& input)
+    static bigfield from_witness(Builder* ctx, const barretenberg::field<T>& input)
     {
         uint256_t input_u256(input);
-        field_t<Composer> low(witness_t<Composer>(ctx, barretenberg::fr(input_u256.slice(0, NUM_LIMB_BITS * 2))));
-        field_t<Composer> hi(
-            witness_t<Composer>(ctx, barretenberg::fr(input_u256.slice(NUM_LIMB_BITS * 2, NUM_LIMB_BITS * 4))));
+        field_t<Builder> low(witness_t<Builder>(ctx, barretenberg::fr(input_u256.slice(0, NUM_LIMB_BITS * 2))));
+        field_t<Builder> hi(
+            witness_t<Builder>(ctx, barretenberg::fr(input_u256.slice(NUM_LIMB_BITS * 2, NUM_LIMB_BITS * 4))));
         return bigfield(low, hi);
     }
 
@@ -154,11 +154,11 @@ template <typename Composer, typename T> class bigfield {
         barretenberg::fr(negative_prime_modulus.slice(NUM_LIMB_BITS * 3, NUM_LIMB_BITS * 4).lo),
     };
 
-    byte_array<Composer> to_byte_array() const
+    byte_array<Builder> to_byte_array() const
     {
-        byte_array<Composer> result(get_context());
-        field_t<Composer> lo = binary_basis_limbs[0].element + (binary_basis_limbs[1].element * shift_1);
-        field_t<Composer> hi = binary_basis_limbs[2].element + (binary_basis_limbs[3].element * shift_1);
+        byte_array<Builder> result(get_context());
+        field_t<Builder> lo = binary_basis_limbs[0].element + (binary_basis_limbs[1].element * shift_1);
+        field_t<Builder> hi = binary_basis_limbs[2].element + (binary_basis_limbs[3].element * shift_1);
         // n.b. this only works if NUM_LIMB_BITS * 2 is divisible by 8
         //
         // We are packing two bigfield limbs each into the field elements `lo` and `hi`.
@@ -167,15 +167,15 @@ template <typename Composer, typename T> class bigfield {
         // Therefore, it is necessary for (NUM_LIMB_BITS * 2) to be divisible by 8 for correctly
         // converting `lo` and `hi` to `byte_array`s.
         ASSERT((NUM_LIMB_BITS * 2 / 8) * 8 == NUM_LIMB_BITS * 2);
-        result.write(byte_array<Composer>(hi, 32 - (NUM_LIMB_BITS / 4)));
-        result.write(byte_array<Composer>(lo, (NUM_LIMB_BITS / 4)));
+        result.write(byte_array<Builder>(hi, 32 - (NUM_LIMB_BITS / 4)));
+        result.write(byte_array<Builder>(lo, (NUM_LIMB_BITS / 4)));
         return result;
     }
 
     uint512_t get_value() const;
     uint512_t get_maximum_value() const;
 
-    bigfield add_to_lower_limb(const field_t<Composer>& other, uint256_t other_maximum_value) const;
+    bigfield add_to_lower_limb(const field_t<Builder>& other, uint256_t other_maximum_value) const;
     bigfield operator+(const bigfield& other) const;
     bigfield operator-(const bigfield& other) const;
     bigfield operator*(const bigfield& other) const;
@@ -244,8 +244,8 @@ template <typename Composer, typename T> class bigfield {
     static bigfield div_without_denominator_check(const std::vector<bigfield>& numerators, const bigfield& denominator);
     static bigfield div_check_denominator_nonzero(const std::vector<bigfield>& numerators, const bigfield& denominator);
 
-    bigfield conditional_negate(const bool_t<Composer>& predicate) const;
-    bigfield conditional_select(const bigfield& other, const bool_t<Composer>& predicate) const;
+    bigfield conditional_negate(const bool_t<Builder>& predicate) const;
+    bigfield conditional_select(const bigfield& other, const bool_t<Builder>& predicate) const;
 
     void assert_is_in_field() const;
     void assert_less_than(const uint256_t upper_limit) const;
@@ -292,16 +292,16 @@ template <typename Composer, typename T> class bigfield {
         result.binary_basis_limbs[2] =
             Limb(barretenberg::fr(multiple_of_modulus.slice(2 * NUM_LIMB_BITS, 3 * NUM_LIMB_BITS).lo));
         result.binary_basis_limbs[3] = Limb(barretenberg::fr(multiple_of_modulus.slice(3 * NUM_LIMB_BITS, msb + 1).lo));
-        result.prime_basis_limb = field_t<Composer>((multiple_of_modulus % uint512_t(field_t<Composer>::modulus)).lo);
+        result.prime_basis_limb = field_t<Builder>((multiple_of_modulus % uint512_t(field_t<Builder>::modulus)).lo);
         return result;
     }
 
     /**
      * Create a witness form a constant. This way the value of the witness is fixed and public.
      **/
-    void convert_constant_to_fixed_witness(Composer* composer)
+    void convert_constant_to_fixed_witness(Builder* builder)
     {
-        context = composer;
+        context = builder;
         for (auto& limb : binary_basis_limbs) {
             limb.element.convert_constant_to_fixed_witness(context);
         }
@@ -319,7 +319,7 @@ template <typename Composer, typename T> class bigfield {
         prime_basis_limb.fix_witness();
     }
 
-    Composer* get_context() const { return context; }
+    Builder* get_context() const { return context; }
 
     static constexpr uint512_t get_maximum_unreduced_value(const size_t num_products = 1)
     {
@@ -436,9 +436,9 @@ template <typename Composer, typename T> class bigfield {
     static constexpr uint256_t get_maximum_unreduced_limb_value() { return uint256_t(1) << MAX_UNREDUCED_LIMB_SIZE; }
 
     static_assert(MAX_UNREDUCED_LIMB_SIZE < (NUM_LIMB_BITS * 2));
-    Composer* context;
+    Builder* context;
     mutable Limb binary_basis_limbs[4];
-    mutable field_t<Composer> prime_basis_limb;
+    mutable field_t<Builder> prime_basis_limb;
 
   private:
     static std::pair<uint512_t, uint512_t> compute_quotient_remainder_values(const bigfield& a,
diff --git a/barretenberg/cpp/src/barretenberg/stdlib/primitives/bigfield/bigfield.test.cpp b/barretenberg/cpp/src/barretenberg/stdlib/primitives/bigfield/bigfield.test.cpp
index c6915434eaf..4db4fe6068c 100644
--- a/barretenberg/cpp/src/barretenberg/stdlib/primitives/bigfield/bigfield.test.cpp
+++ b/barretenberg/cpp/src/barretenberg/stdlib/primitives/bigfield/bigfield.test.cpp
@@ -34,9 +34,9 @@ namespace {
 auto& engine = numeric::random::get_debug_engine();
 }
 
-template <typename Composer> class stdlib_bigfield : public testing::Test {
+template <typename Builder> class stdlib_bigfield : public testing::Test {
 
-    typedef stdlib::bn254<Composer> bn254;
+    typedef stdlib::bn254<Builder> bn254;
 
     typedef typename bn254::ScalarField fr_ct;
     typedef typename bn254::BaseField fq_ct;
@@ -48,35 +48,35 @@ template <typename Composer> class stdlib_bigfield : public testing::Test {
     // operator
     static void test_division_formula_bug()
     {
-        auto composer = Composer();
+        auto builder = Builder();
         uint256_t value(2);
-        fq_ct tval = fq_ct::create_from_u512_as_witness(&composer, value);
+        fq_ct tval = fq_ct::create_from_u512_as_witness(&builder, value);
         fq_ct tval1 = tval - tval;
         fq_ct tval2 = tval1 / tval;
         (void)tval2;
-        bool result = composer.check_circuit();
+        bool result = builder.check_circuit();
         EXPECT_EQ(result, true);
     }
 
     static void test_bad_mul()
     {
-        auto composer = Composer();
+        auto builder = Builder();
         uint256_t value(2);
-        fq_ct tval = fq_ct::create_from_u512_as_witness(&composer, value);
+        fq_ct tval = fq_ct::create_from_u512_as_witness(&builder, value);
         fq_ct tval1 = tval - tval;
         fq_ct tval2 = tval1 / tval;
         (void)tval2;
-        bool result = composer.check_circuit();
+        bool result = builder.check_circuit();
         EXPECT_EQ(result, true);
     }
 
-    static std::pair<fq, fq_ct> get_random_element(Composer* ctx)
+    static std::pair<fq, fq_ct> get_random_element(Builder* ctx)
     {
         fq elt = fq::random_element();
         return std::make_pair(elt, fq_ct::from_witness(ctx, elt));
     }
 
-    static std::pair<std::vector<fq>, std::vector<fq_ct>> get_random_elements(Composer* ctx, size_t num)
+    static std::pair<std::vector<fq>, std::vector<fq_ct>> get_random_elements(Builder* ctx, size_t num)
     {
         std::vector<fq> elts(num);
         std::vector<fq_ct> big_elts(num);
@@ -91,23 +91,23 @@ template <typename Composer> class stdlib_bigfield : public testing::Test {
   public:
     static void test_mul()
     {
-        auto composer = Composer();
+        auto builder = Builder();
         size_t num_repetitions = 4;
         for (size_t i = 0; i < num_repetitions; ++i) {
             fq inputs[3]{ fq::random_element(), fq::random_element(), fq::random_element() };
-            fq_ct a(witness_ct(&composer, fr(uint256_t(inputs[0]).slice(0, fq_ct::NUM_LIMB_BITS * 2))),
-                    witness_ct(&composer,
+            fq_ct a(witness_ct(&builder, fr(uint256_t(inputs[0]).slice(0, fq_ct::NUM_LIMB_BITS * 2))),
+                    witness_ct(&builder,
                                fr(uint256_t(inputs[0]).slice(fq_ct::NUM_LIMB_BITS * 2, fq_ct::NUM_LIMB_BITS * 4))));
-            fq_ct b(witness_ct(&composer, fr(uint256_t(inputs[1]).slice(0, fq_ct::NUM_LIMB_BITS * 2))),
-                    witness_ct(&composer,
+            fq_ct b(witness_ct(&builder, fr(uint256_t(inputs[1]).slice(0, fq_ct::NUM_LIMB_BITS * 2))),
+                    witness_ct(&builder,
                                fr(uint256_t(inputs[1]).slice(fq_ct::NUM_LIMB_BITS * 2, fq_ct::NUM_LIMB_BITS * 4))));
-            uint64_t before = composer.get_num_gates();
+            uint64_t before = builder.get_num_gates();
             fq_ct c = a * b;
-            uint64_t after = composer.get_num_gates();
+            uint64_t after = builder.get_num_gates();
             // Don't profile 1st repetition. It sets up a lookup table, cost is not representative of a typical mul
             if (i == num_repetitions - 2) {
                 std::cerr << "num gates per mul = " << after - before << std::endl;
-                benchmark_info(Composer::NAME_STRING, "Bigfield", "MUL", "Gate Count", after - before);
+                benchmark_info(Builder::NAME_STRING, "Bigfield", "MUL", "Gate Count", after - before);
             }
             // uint256_t modulus{ Bn254FqParams::modulus_0,
             //                    Bn254FqParams::modulus_1,
@@ -127,25 +127,25 @@ template <typename Composer> class stdlib_bigfield : public testing::Test {
             EXPECT_EQ(result.hi.data[2], 0ULL);
             EXPECT_EQ(result.hi.data[3], 0ULL);
         }
-        bool result = composer.check_circuit();
+        bool result = builder.check_circuit();
         EXPECT_EQ(result, true);
     }
 
     static void test_sqr()
     {
-        auto composer = Composer();
+        auto builder = Builder();
         size_t num_repetitions = 10;
         for (size_t i = 0; i < num_repetitions; ++i) {
             fq inputs[3]{ fq::random_element(), fq::random_element(), fq::random_element() };
-            fq_ct a(witness_ct(&composer, fr(uint256_t(inputs[0]).slice(0, fq_ct::NUM_LIMB_BITS * 2))),
-                    witness_ct(&composer,
+            fq_ct a(witness_ct(&builder, fr(uint256_t(inputs[0]).slice(0, fq_ct::NUM_LIMB_BITS * 2))),
+                    witness_ct(&builder,
                                fr(uint256_t(inputs[0]).slice(fq_ct::NUM_LIMB_BITS * 2, fq_ct::NUM_LIMB_BITS * 4))));
-            uint64_t before = composer.get_num_gates();
+            uint64_t before = builder.get_num_gates();
             fq_ct c = a.sqr();
-            uint64_t after = composer.get_num_gates();
+            uint64_t after = builder.get_num_gates();
             if (i == num_repetitions - 1) {
                 std::cerr << "num gates per mul = " << after - before << std::endl;
-                benchmark_info(Composer::NAME_STRING, "Bigfield", "SQR", "Gate Count", after - before);
+                benchmark_info(Builder::NAME_STRING, "Bigfield", "SQR", "Gate Count", after - before);
             }
             // uint256_t modulus{ Bn254FqParams::modulus_0,
             //                    Bn254FqParams::modulus_1,
@@ -165,33 +165,33 @@ template <typename Composer> class stdlib_bigfield : public testing::Test {
             EXPECT_EQ(result.hi.data[2], 0ULL);
             EXPECT_EQ(result.hi.data[3], 0ULL);
         }
-        bool result = composer.check_circuit();
+        bool result = builder.check_circuit();
         EXPECT_EQ(result, true);
     }
 
     static void test_madd()
     {
-        auto composer = Composer();
+        auto builder = Builder();
         size_t num_repetitions = 1;
         for (size_t i = 0; i < num_repetitions; ++i) {
             fq inputs[3]{ fq::random_element(), fq::random_element(), fq::random_element() };
-            fq_ct a(witness_ct(&composer, fr(uint256_t(inputs[0]).slice(0, fq_ct::NUM_LIMB_BITS * 2))),
-                    witness_ct(&composer,
+            fq_ct a(witness_ct(&builder, fr(uint256_t(inputs[0]).slice(0, fq_ct::NUM_LIMB_BITS * 2))),
+                    witness_ct(&builder,
                                fr(uint256_t(inputs[0]).slice(fq_ct::NUM_LIMB_BITS * 2, fq_ct::NUM_LIMB_BITS * 4))));
-            fq_ct b(witness_ct(&composer, fr(uint256_t(inputs[1]).slice(0, fq_ct::NUM_LIMB_BITS * 2))),
-                    witness_ct(&composer,
+            fq_ct b(witness_ct(&builder, fr(uint256_t(inputs[1]).slice(0, fq_ct::NUM_LIMB_BITS * 2))),
+                    witness_ct(&builder,
                                fr(uint256_t(inputs[1]).slice(fq_ct::NUM_LIMB_BITS * 2, fq_ct::NUM_LIMB_BITS * 4))));
 
-            fq_ct c(witness_ct(&composer, fr(uint256_t(inputs[2]).slice(0, fq_ct::NUM_LIMB_BITS * 2))),
-                    witness_ct(&composer,
+            fq_ct c(witness_ct(&builder, fr(uint256_t(inputs[2]).slice(0, fq_ct::NUM_LIMB_BITS * 2))),
+                    witness_ct(&builder,
                                fr(uint256_t(inputs[2]).slice(fq_ct::NUM_LIMB_BITS * 2, fq_ct::NUM_LIMB_BITS * 4))));
 
-            uint64_t before = composer.get_num_gates();
+            uint64_t before = builder.get_num_gates();
             fq_ct d = a.madd(b, { c });
-            uint64_t after = composer.get_num_gates();
+            uint64_t after = builder.get_num_gates();
             if (i == num_repetitions - 1) {
                 std::cerr << "num gates per mul = " << after - before << std::endl;
-                benchmark_info(Composer::NAME_STRING, "Bigfield", "MADD", "Gate Count", after - before);
+                benchmark_info(Builder::NAME_STRING, "Bigfield", "MADD", "Gate Count", after - before);
             }
             // uint256_t modulus{ Bn254FqParams::modulus_0,
             //                    Bn254FqParams::modulus_1,
@@ -211,13 +211,13 @@ template <typename Composer> class stdlib_bigfield : public testing::Test {
             EXPECT_EQ(result.hi.data[2], 0ULL);
             EXPECT_EQ(result.hi.data[3], 0ULL);
         }
-        bool result = composer.check_circuit();
+        bool result = builder.check_circuit();
         EXPECT_EQ(result, true);
     }
 
     static void test_mult_madd()
     {
-        auto composer = Composer();
+        auto builder = Builder();
         size_t num_repetitions = 1;
         const size_t number_of_madds = 32;
         for (size_t i = 0; i < num_repetitions; ++i) {
@@ -238,28 +238,28 @@ template <typename Composer> class stdlib_bigfield : public testing::Test {
                 mul_right_values[j] = fq::random_element();
                 expected += mul_left_values[j] * mul_right_values[j];
                 mul_left.emplace_back(
-                    fq_ct::create_from_u512_as_witness(&composer, uint512_t(uint256_t(mul_left_values[j]))));
+                    fq_ct::create_from_u512_as_witness(&builder, uint512_t(uint256_t(mul_left_values[j]))));
                 mul_right.emplace_back(
-                    fq_ct::create_from_u512_as_witness(&composer, uint512_t(uint256_t(mul_right_values[j]))));
+                    fq_ct::create_from_u512_as_witness(&builder, uint512_t(uint256_t(mul_right_values[j]))));
                 to_add_values[j] = fq::random_element();
                 expected += to_add_values[j];
                 to_add.emplace_back(
-                    fq_ct::create_from_u512_as_witness(&composer, uint512_t(uint256_t(to_add_values[j]))));
+                    fq_ct::create_from_u512_as_witness(&builder, uint512_t(uint256_t(to_add_values[j]))));
             }
-            uint64_t before = composer.get_num_gates();
+            uint64_t before = builder.get_num_gates();
             fq_ct f = fq_ct::mult_madd(mul_left, mul_right, to_add);
-            uint64_t after = composer.get_num_gates();
+            uint64_t after = builder.get_num_gates();
             if (i == num_repetitions - 1) {
                 std::cerr << "num gates with mult_madd = " << after - before << std::endl;
-                benchmark_info(Composer::NAME_STRING, "Bigfield", "MULT_MADD", "Gate Count", after - before);
+                benchmark_info(Builder::NAME_STRING, "Bigfield", "MULT_MADD", "Gate Count", after - before);
             }
             /**
-            before = composer.get_num_gates();
+            before = builder.get_num_gates();
             fq_ct f1(0);
             for (size_t j = 0; j < number_of_madds; j++) {
                 f1 += mul_left[j] * mul_right[j] + to_add[j];
             }
-            after = composer.get_num_gates();
+            after = builder.get_num_gates();
             if (i == num_repetitions - 1) {
                 std::cerr << "num gates with regular multiply_add = " << after - before << std::endl;
             }
@@ -277,40 +277,40 @@ template <typename Composer> class stdlib_bigfield : public testing::Test {
             EXPECT_EQ(result.hi.data[2], 0ULL);
             EXPECT_EQ(result.hi.data[3], 0ULL);
         }
-        if (composer.failed()) {
-            info("Composer failed with error: ", composer.err());
+        if (builder.failed()) {
+            info("Builder failed with error: ", builder.err());
         };
-        bool result = composer.check_circuit();
+        bool result = builder.check_circuit();
         EXPECT_EQ(result, true);
     }
 
     static void test_dual_madd()
     {
-        auto composer = Composer();
+        auto builder = Builder();
         size_t num_repetitions = 1;
         for (size_t i = 0; i < num_repetitions; ++i) {
             fq inputs[5]{ -1, -2, -3, -4, -5 };
-            fq_ct a(witness_ct(&composer, fr(uint256_t(inputs[0]).slice(0, fq_ct::NUM_LIMB_BITS * 2))),
-                    witness_ct(&composer,
+            fq_ct a(witness_ct(&builder, fr(uint256_t(inputs[0]).slice(0, fq_ct::NUM_LIMB_BITS * 2))),
+                    witness_ct(&builder,
                                fr(uint256_t(inputs[0]).slice(fq_ct::NUM_LIMB_BITS * 2, fq_ct::NUM_LIMB_BITS * 4))));
-            fq_ct b(witness_ct(&composer, fr(uint256_t(inputs[1]).slice(0, fq_ct::NUM_LIMB_BITS * 2))),
-                    witness_ct(&composer,
+            fq_ct b(witness_ct(&builder, fr(uint256_t(inputs[1]).slice(0, fq_ct::NUM_LIMB_BITS * 2))),
+                    witness_ct(&builder,
                                fr(uint256_t(inputs[1]).slice(fq_ct::NUM_LIMB_BITS * 2, fq_ct::NUM_LIMB_BITS * 4))));
 
-            fq_ct c(witness_ct(&composer, fr(uint256_t(inputs[2]).slice(0, fq_ct::NUM_LIMB_BITS * 2))),
-                    witness_ct(&composer,
+            fq_ct c(witness_ct(&builder, fr(uint256_t(inputs[2]).slice(0, fq_ct::NUM_LIMB_BITS * 2))),
+                    witness_ct(&builder,
                                fr(uint256_t(inputs[2]).slice(fq_ct::NUM_LIMB_BITS * 2, fq_ct::NUM_LIMB_BITS * 4))));
 
-            fq_ct d(witness_ct(&composer, fr(uint256_t(inputs[3]).slice(0, fq_ct::NUM_LIMB_BITS * 2))),
-                    witness_ct(&composer,
+            fq_ct d(witness_ct(&builder, fr(uint256_t(inputs[3]).slice(0, fq_ct::NUM_LIMB_BITS * 2))),
+                    witness_ct(&builder,
                                fr(uint256_t(inputs[3]).slice(fq_ct::NUM_LIMB_BITS * 2, fq_ct::NUM_LIMB_BITS * 4))));
-            fq_ct e(witness_ct(&composer, fr(uint256_t(inputs[4]).slice(0, fq_ct::NUM_LIMB_BITS * 2))),
-                    witness_ct(&composer,
+            fq_ct e(witness_ct(&builder, fr(uint256_t(inputs[4]).slice(0, fq_ct::NUM_LIMB_BITS * 2))),
+                    witness_ct(&builder,
                                fr(uint256_t(inputs[4]).slice(fq_ct::NUM_LIMB_BITS * 2, fq_ct::NUM_LIMB_BITS * 4))));
 
-            uint64_t before = composer.get_num_gates();
+            uint64_t before = builder.get_num_gates();
             fq_ct f = fq_ct::dual_madd(a, b, c, d, { e });
-            uint64_t after = composer.get_num_gates();
+            uint64_t after = builder.get_num_gates();
             if (i == num_repetitions - 1) {
                 std::cerr << "num gates per mul = " << after - before << std::endl;
             }
@@ -332,33 +332,33 @@ template <typename Composer> class stdlib_bigfield : public testing::Test {
             EXPECT_EQ(result.hi.data[2], 0ULL);
             EXPECT_EQ(result.hi.data[3], 0ULL);
         }
-        if (composer.failed()) {
-            info("Composer failed with error: ", composer.err());
+        if (builder.failed()) {
+            info("Builder failed with error: ", builder.err());
         };
-        bool result = composer.check_circuit();
+        bool result = builder.check_circuit();
         EXPECT_EQ(result, true);
     }
 
     static void test_div()
     {
-        auto composer = Composer();
+        auto builder = Builder();
         size_t num_repetitions = 10;
         for (size_t i = 0; i < num_repetitions; ++i) {
             fq inputs[3]{ fq::random_element(), fq::random_element(), fq::random_element() };
             inputs[0] = inputs[0].reduce_once().reduce_once();
             inputs[1] = inputs[1].reduce_once().reduce_once();
-            fq_ct a(witness_ct(&composer, fr(uint256_t(inputs[0]).slice(0, fq_ct::NUM_LIMB_BITS * 2))),
-                    witness_ct(&composer,
+            fq_ct a(witness_ct(&builder, fr(uint256_t(inputs[0]).slice(0, fq_ct::NUM_LIMB_BITS * 2))),
+                    witness_ct(&builder,
                                fr(uint256_t(inputs[0]).slice(fq_ct::NUM_LIMB_BITS * 2, fq_ct::NUM_LIMB_BITS * 4))));
-            fq_ct b(witness_ct(&composer, fr(uint256_t(inputs[1]).slice(0, fq_ct::NUM_LIMB_BITS * 2))),
-                    witness_ct(&composer,
+            fq_ct b(witness_ct(&builder, fr(uint256_t(inputs[1]).slice(0, fq_ct::NUM_LIMB_BITS * 2))),
+                    witness_ct(&builder,
                                fr(uint256_t(inputs[1]).slice(fq_ct::NUM_LIMB_BITS * 2, fq_ct::NUM_LIMB_BITS * 4))));
-            uint64_t before = composer.get_num_gates();
+            uint64_t before = builder.get_num_gates();
             fq_ct c = a / b;
-            uint64_t after = composer.get_num_gates();
+            uint64_t after = builder.get_num_gates();
             if (i == num_repetitions - 1) {
                 std::cout << "num gates per div = " << after - before << std::endl;
-                benchmark_info(Composer::NAME_STRING, "Bigfield", "DIV", "Gate Count", after - before);
+                benchmark_info(Builder::NAME_STRING, "Bigfield", "DIV", "Gate Count", after - before);
             }
             // uint256_t modulus{ Bn254FqParams::modulus_0,
             //                    Bn254FqParams::modulus_1,
@@ -379,27 +379,27 @@ template <typename Composer> class stdlib_bigfield : public testing::Test {
             EXPECT_EQ(result.hi.data[2], 0ULL);
             EXPECT_EQ(result.hi.data[3], 0ULL);
         }
-        bool result = composer.check_circuit();
+        bool result = builder.check_circuit();
         EXPECT_EQ(result, true);
     }
 
     static void test_add_and_div()
     {
-        auto composer = Composer();
+        auto builder = Builder();
         size_t num_repetitions = 1;
         for (size_t i = 0; i < num_repetitions; ++i) {
             fq inputs[4]{ fq::random_element(), fq::random_element(), fq::random_element() };
-            fq_ct a(witness_ct(&composer, fr(uint256_t(inputs[0]).slice(0, fq_ct::NUM_LIMB_BITS * 2))),
-                    witness_ct(&composer,
+            fq_ct a(witness_ct(&builder, fr(uint256_t(inputs[0]).slice(0, fq_ct::NUM_LIMB_BITS * 2))),
+                    witness_ct(&builder,
                                fr(uint256_t(inputs[0]).slice(fq_ct::NUM_LIMB_BITS * 2, fq_ct::NUM_LIMB_BITS * 4))));
-            fq_ct b(witness_ct(&composer, fr(uint256_t(inputs[1]).slice(0, fq_ct::NUM_LIMB_BITS * 2))),
-                    witness_ct(&composer,
+            fq_ct b(witness_ct(&builder, fr(uint256_t(inputs[1]).slice(0, fq_ct::NUM_LIMB_BITS * 2))),
+                    witness_ct(&builder,
                                fr(uint256_t(inputs[1]).slice(fq_ct::NUM_LIMB_BITS * 2, fq_ct::NUM_LIMB_BITS * 4))));
-            fq_ct c(witness_ct(&composer, fr(uint256_t(inputs[2]).slice(0, fq_ct::NUM_LIMB_BITS * 2))),
-                    witness_ct(&composer,
+            fq_ct c(witness_ct(&builder, fr(uint256_t(inputs[2]).slice(0, fq_ct::NUM_LIMB_BITS * 2))),
+                    witness_ct(&builder,
                                fr(uint256_t(inputs[2]).slice(fq_ct::NUM_LIMB_BITS * 2, fq_ct::NUM_LIMB_BITS * 4))));
-            fq_ct d(witness_ct(&composer, fr(uint256_t(inputs[3]).slice(0, fq_ct::NUM_LIMB_BITS * 2))),
-                    witness_ct(&composer,
+            fq_ct d(witness_ct(&builder, fr(uint256_t(inputs[3]).slice(0, fq_ct::NUM_LIMB_BITS * 2))),
+                    witness_ct(&builder,
                                fr(uint256_t(inputs[3]).slice(fq_ct::NUM_LIMB_BITS * 2, fq_ct::NUM_LIMB_BITS * 4))));
             fq_ct e = (a + b) / (c + d);
             // uint256_t modulus{ Bn254FqParams::modulus_0,
@@ -421,28 +421,28 @@ template <typename Composer> class stdlib_bigfield : public testing::Test {
             EXPECT_EQ(result.hi.data[2], 0ULL);
             EXPECT_EQ(result.hi.data[3], 0ULL);
         }
-        bool result = composer.check_circuit();
+        bool result = builder.check_circuit();
         EXPECT_EQ(result, true);
     }
 
     static void test_add_and_mul()
     {
-        auto composer = Composer();
+        auto builder = Builder();
         size_t num_repetitions = 10;
         for (size_t i = 0; i < num_repetitions; ++i) {
             fq inputs[4]{ fq::random_element(), fq::random_element(), fq::random_element(), fq::random_element() };
 
-            fq_ct a(witness_ct(&composer, fr(uint256_t(inputs[0]).slice(0, fq_ct::NUM_LIMB_BITS * 2))),
-                    witness_ct(&composer,
+            fq_ct a(witness_ct(&builder, fr(uint256_t(inputs[0]).slice(0, fq_ct::NUM_LIMB_BITS * 2))),
+                    witness_ct(&builder,
                                fr(uint256_t(inputs[0]).slice(fq_ct::NUM_LIMB_BITS * 2, fq_ct::NUM_LIMB_BITS * 4))));
-            fq_ct b(witness_ct(&composer, fr(uint256_t(inputs[1]).slice(0, fq_ct::NUM_LIMB_BITS * 2))),
-                    witness_ct(&composer,
+            fq_ct b(witness_ct(&builder, fr(uint256_t(inputs[1]).slice(0, fq_ct::NUM_LIMB_BITS * 2))),
+                    witness_ct(&builder,
                                fr(uint256_t(inputs[1]).slice(fq_ct::NUM_LIMB_BITS * 2, fq_ct::NUM_LIMB_BITS * 4))));
-            fq_ct c(witness_ct(&composer, fr(uint256_t(inputs[2]).slice(0, fq_ct::NUM_LIMB_BITS * 2))),
-                    witness_ct(&composer,
+            fq_ct c(witness_ct(&builder, fr(uint256_t(inputs[2]).slice(0, fq_ct::NUM_LIMB_BITS * 2))),
+                    witness_ct(&builder,
                                fr(uint256_t(inputs[2]).slice(fq_ct::NUM_LIMB_BITS * 2, fq_ct::NUM_LIMB_BITS * 4))));
-            fq_ct d(witness_ct(&composer, fr(uint256_t(inputs[3]).slice(0, fq_ct::NUM_LIMB_BITS * 2))),
-                    witness_ct(&composer,
+            fq_ct d(witness_ct(&builder, fr(uint256_t(inputs[3]).slice(0, fq_ct::NUM_LIMB_BITS * 2))),
+                    witness_ct(&builder,
                                fr(uint256_t(inputs[3]).slice(fq_ct::NUM_LIMB_BITS * 2, fq_ct::NUM_LIMB_BITS * 4))));
             fq_ct e = (a + b) * (c + d);
             fq expected = (inputs[0] + inputs[1]) * (inputs[2] + inputs[3]);
@@ -458,26 +458,26 @@ template <typename Composer> class stdlib_bigfield : public testing::Test {
             EXPECT_EQ(result.hi.data[2], 0ULL);
             EXPECT_EQ(result.hi.data[3], 0ULL);
         }
-        bool result = composer.check_circuit();
+        bool result = builder.check_circuit();
         EXPECT_EQ(result, true);
     }
 
     static void test_add_and_mul_with_constants()
     {
-        auto composer = Composer();
+        auto builder = Builder();
         size_t num_repetitions = 10;
         for (size_t i = 0; i < num_repetitions; ++i) {
             fq inputs[2]{ fq::random_element(), fq::random_element() };
             uint256_t constants[2]{ engine.get_random_uint256() % fq_ct::modulus,
                                     engine.get_random_uint256() % fq_ct::modulus };
-            fq_ct a(witness_ct(&composer, fr(uint256_t(inputs[0]).slice(0, fq_ct::NUM_LIMB_BITS * 2))),
-                    witness_ct(&composer,
+            fq_ct a(witness_ct(&builder, fr(uint256_t(inputs[0]).slice(0, fq_ct::NUM_LIMB_BITS * 2))),
+                    witness_ct(&builder,
                                fr(uint256_t(inputs[0]).slice(fq_ct::NUM_LIMB_BITS * 2, fq_ct::NUM_LIMB_BITS * 4))));
-            fq_ct b(&composer, constants[0]);
-            fq_ct c(witness_ct(&composer, fr(uint256_t(inputs[1]).slice(0, fq_ct::NUM_LIMB_BITS * 2))),
-                    witness_ct(&composer,
+            fq_ct b(&builder, constants[0]);
+            fq_ct c(witness_ct(&builder, fr(uint256_t(inputs[1]).slice(0, fq_ct::NUM_LIMB_BITS * 2))),
+                    witness_ct(&builder,
                                fr(uint256_t(inputs[1]).slice(fq_ct::NUM_LIMB_BITS * 2, fq_ct::NUM_LIMB_BITS * 4))));
-            fq_ct d(&composer, constants[1]);
+            fq_ct d(&builder, constants[1]);
             fq_ct e = (a + b) * (c + d);
             fq expected = (inputs[0] + constants[0]) * (inputs[1] + constants[1]);
             expected = expected.from_montgomery_form();
@@ -492,28 +492,28 @@ template <typename Composer> class stdlib_bigfield : public testing::Test {
             EXPECT_EQ(result.hi.data[2], 0ULL);
             EXPECT_EQ(result.hi.data[3], 0ULL);
         }
-        bool result = composer.check_circuit();
+        bool result = builder.check_circuit();
         EXPECT_EQ(result, true);
     }
 
     static void test_sub_and_mul()
     {
-        auto composer = Composer();
+        auto builder = Builder();
         size_t num_repetitions = 10;
         for (size_t i = 0; i < num_repetitions; ++i) {
             fq inputs[4]{ fq::random_element(), fq::random_element(), fq::random_element(), fq::random_element() };
 
-            fq_ct a(witness_ct(&composer, fr(uint256_t(inputs[0]).slice(0, fq_ct::NUM_LIMB_BITS * 2))),
-                    witness_ct(&composer,
+            fq_ct a(witness_ct(&builder, fr(uint256_t(inputs[0]).slice(0, fq_ct::NUM_LIMB_BITS * 2))),
+                    witness_ct(&builder,
                                fr(uint256_t(inputs[0]).slice(fq_ct::NUM_LIMB_BITS * 2, fq_ct::NUM_LIMB_BITS * 4))));
-            fq_ct b(witness_ct(&composer, fr(uint256_t(inputs[1]).slice(0, fq_ct::NUM_LIMB_BITS * 2))),
-                    witness_ct(&composer,
+            fq_ct b(witness_ct(&builder, fr(uint256_t(inputs[1]).slice(0, fq_ct::NUM_LIMB_BITS * 2))),
+                    witness_ct(&builder,
                                fr(uint256_t(inputs[1]).slice(fq_ct::NUM_LIMB_BITS * 2, fq_ct::NUM_LIMB_BITS * 4))));
-            fq_ct c(witness_ct(&composer, fr(uint256_t(inputs[2]).slice(0, fq_ct::NUM_LIMB_BITS * 2))),
-                    witness_ct(&composer,
+            fq_ct c(witness_ct(&builder, fr(uint256_t(inputs[2]).slice(0, fq_ct::NUM_LIMB_BITS * 2))),
+                    witness_ct(&builder,
                                fr(uint256_t(inputs[2]).slice(fq_ct::NUM_LIMB_BITS * 2, fq_ct::NUM_LIMB_BITS * 4))));
-            fq_ct d(witness_ct(&composer, fr(uint256_t(inputs[3]).slice(0, fq_ct::NUM_LIMB_BITS * 2))),
-                    witness_ct(&composer,
+            fq_ct d(witness_ct(&builder, fr(uint256_t(inputs[3]).slice(0, fq_ct::NUM_LIMB_BITS * 2))),
+                    witness_ct(&builder,
                                fr(uint256_t(inputs[3]).slice(fq_ct::NUM_LIMB_BITS * 2, fq_ct::NUM_LIMB_BITS * 4))));
             fq_ct e = (a - b) * (c - d);
             fq expected = (inputs[0] - inputs[1]) * (inputs[2] - inputs[3]);
@@ -529,7 +529,7 @@ template <typename Composer> class stdlib_bigfield : public testing::Test {
             EXPECT_EQ(result.hi.data[2], 0ULL);
             EXPECT_EQ(result.hi.data[3], 0ULL);
         }
-        bool result = composer.check_circuit();
+        bool result = builder.check_circuit();
         EXPECT_EQ(result, true);
     }
 
@@ -537,14 +537,14 @@ template <typename Composer> class stdlib_bigfield : public testing::Test {
     {
         size_t num_repetitions = 8;
         for (size_t i = 0; i < num_repetitions; ++i) {
-            auto composer = Composer();
-            auto [mul_l, mul_l_ct] = get_random_element(&composer);
-            auto [mul_r1, mul_r1_ct] = get_random_element(&composer);
-            auto [mul_r2, mul_r2_ct] = get_random_element(&composer);
-            auto [divisor1, divisor1_ct] = get_random_element(&composer);
-            auto [divisor2, divisor2_ct] = get_random_element(&composer);
-            auto [to_sub1, to_sub1_ct] = get_random_element(&composer);
-            auto [to_sub2, to_sub2_ct] = get_random_element(&composer);
+            auto builder = Builder();
+            auto [mul_l, mul_l_ct] = get_random_element(&builder);
+            auto [mul_r1, mul_r1_ct] = get_random_element(&builder);
+            auto [mul_r2, mul_r2_ct] = get_random_element(&builder);
+            auto [divisor1, divisor1_ct] = get_random_element(&builder);
+            auto [divisor2, divisor2_ct] = get_random_element(&builder);
+            auto [to_sub1, to_sub1_ct] = get_random_element(&builder);
+            auto [to_sub2, to_sub2_ct] = get_random_element(&builder);
 
             fq_ct result_ct = fq_ct::msub_div(
                 { mul_l_ct }, { mul_r1_ct - mul_r2_ct }, divisor1_ct - divisor2_ct, { to_sub1_ct, to_sub2_ct });
@@ -552,30 +552,30 @@ template <typename Composer> class stdlib_bigfield : public testing::Test {
             EXPECT_EQ(result_ct.get_value().lo, uint256_t(expected));
             EXPECT_EQ(result_ct.get_value().hi, uint256_t(0));
 
-            bool result = composer.check_circuit();
+            bool result = builder.check_circuit();
             EXPECT_EQ(result, true);
         }
     }
 
     static void test_conditional_negate()
     {
-        auto composer = Composer();
+        auto builder = Builder();
         size_t num_repetitions = 1;
         for (size_t i = 0; i < num_repetitions; ++i) {
 
             fq inputs[4]{ fq::random_element(), fq::random_element(), fq::random_element(), fq::random_element() };
 
-            fq_ct a(witness_ct(&composer, fr(uint256_t(inputs[0]).slice(0, fq_ct::NUM_LIMB_BITS * 2))),
-                    witness_ct(&composer,
+            fq_ct a(witness_ct(&builder, fr(uint256_t(inputs[0]).slice(0, fq_ct::NUM_LIMB_BITS * 2))),
+                    witness_ct(&builder,
                                fr(uint256_t(inputs[0]).slice(fq_ct::NUM_LIMB_BITS * 2, fq_ct::NUM_LIMB_BITS * 4))));
-            // fq_ct b(witness_ct(&composer,
+            // fq_ct b(witness_ct(&builder,
             // fr(uint256_t(inputs[1]).slice(0, fq_ct::NUM_LIMB_BITS * 2))),
-            //            witness_ct(&composer,
+            //            witness_ct(&builder,
             //            fr(uint256_t(inputs[1]).slice(fq_ct::NUM_LIMB_BITS * 2,
             //            fq_ct::NUM_LIMB_BITS * 4))));
 
-            typename bn254::bool_ct predicate_a(witness_ct(&composer, true));
-            // bool_ct predicate_b(witness_ct(&composer, false));
+            typename bn254::bool_ct predicate_a(witness_ct(&builder, true));
+            // bool_ct predicate_b(witness_ct(&builder, false));
 
             fq_ct c = a.conditional_negate(predicate_a);
             fq_ct d = a.conditional_negate(!predicate_a);
@@ -595,36 +595,36 @@ template <typename Composer> class stdlib_bigfield : public testing::Test {
             EXPECT_EQ(result_d, expected_d);
             EXPECT_EQ(result_e, fq(0));
         }
-        bool result = composer.check_circuit();
+        bool result = builder.check_circuit();
         EXPECT_EQ(result, true);
     }
 
     static void test_group_operations()
     {
-        auto composer = Composer();
+        auto builder = Builder();
         size_t num_repetitions = 1;
         for (size_t i = 0; i < num_repetitions; ++i) {
             g1::affine_element P1(g1::element::random_element());
             g1::affine_element P2(g1::element::random_element());
 
             fq_ct x1(
-                witness_ct(&composer, fr(uint256_t(P1.x).slice(0, fq_ct::NUM_LIMB_BITS * 2))),
-                witness_ct(&composer, fr(uint256_t(P1.x).slice(fq_ct::NUM_LIMB_BITS * 2, fq_ct::NUM_LIMB_BITS * 4))));
+                witness_ct(&builder, fr(uint256_t(P1.x).slice(0, fq_ct::NUM_LIMB_BITS * 2))),
+                witness_ct(&builder, fr(uint256_t(P1.x).slice(fq_ct::NUM_LIMB_BITS * 2, fq_ct::NUM_LIMB_BITS * 4))));
             fq_ct y1(
-                witness_ct(&composer, fr(uint256_t(P1.y).slice(0, fq_ct::NUM_LIMB_BITS * 2))),
-                witness_ct(&composer, fr(uint256_t(P1.y).slice(fq_ct::NUM_LIMB_BITS * 2, fq_ct::NUM_LIMB_BITS * 4))));
+                witness_ct(&builder, fr(uint256_t(P1.y).slice(0, fq_ct::NUM_LIMB_BITS * 2))),
+                witness_ct(&builder, fr(uint256_t(P1.y).slice(fq_ct::NUM_LIMB_BITS * 2, fq_ct::NUM_LIMB_BITS * 4))));
             fq_ct x2(
-                witness_ct(&composer, fr(uint256_t(P2.x).slice(0, fq_ct::NUM_LIMB_BITS * 2))),
-                witness_ct(&composer, fr(uint256_t(P2.x).slice(fq_ct::NUM_LIMB_BITS * 2, fq_ct::NUM_LIMB_BITS * 4))));
+                witness_ct(&builder, fr(uint256_t(P2.x).slice(0, fq_ct::NUM_LIMB_BITS * 2))),
+                witness_ct(&builder, fr(uint256_t(P2.x).slice(fq_ct::NUM_LIMB_BITS * 2, fq_ct::NUM_LIMB_BITS * 4))));
             fq_ct y2(
-                witness_ct(&composer, fr(uint256_t(P2.y).slice(0, fq_ct::NUM_LIMB_BITS * 2))),
-                witness_ct(&composer, fr(uint256_t(P2.y).slice(fq_ct::NUM_LIMB_BITS * 2, fq_ct::NUM_LIMB_BITS * 4))));
-            uint64_t before = composer.get_num_gates();
+                witness_ct(&builder, fr(uint256_t(P2.y).slice(0, fq_ct::NUM_LIMB_BITS * 2))),
+                witness_ct(&builder, fr(uint256_t(P2.y).slice(fq_ct::NUM_LIMB_BITS * 2, fq_ct::NUM_LIMB_BITS * 4))));
+            uint64_t before = builder.get_num_gates();
 
             fq_ct lambda = (y2 - y1) / (x2 - x1);
             fq_ct x3 = lambda.sqr() - (x2 + x1);
             fq_ct y3 = (x1 - x3) * lambda - y1;
-            uint64_t after = composer.get_num_gates();
+            uint64_t after = builder.get_num_gates();
             std::cerr << "added gates = " << after - before << std::endl;
             g1::affine_element P3(g1::element(P1) + g1::element(P2));
             fq expected_x = P3.x;
@@ -642,23 +642,23 @@ template <typename Composer> class stdlib_bigfield : public testing::Test {
             EXPECT_EQ(result_y.lo.data[2], expected_y.data[2]);
             EXPECT_EQ(result_y.lo.data[3], expected_y.data[3]);
         }
-        bool result = composer.check_circuit();
+        bool result = builder.check_circuit();
         EXPECT_EQ(result, true);
     }
 
     static void test_reduce()
     {
-        auto composer = Composer();
+        auto builder = Builder();
         size_t num_repetitions = 10;
         for (size_t i = 0; i < num_repetitions; ++i) {
 
             fq inputs[4]{ fq::random_element(), fq::random_element(), fq::random_element(), fq::random_element() };
 
-            fq_ct a(witness_ct(&composer, fr(uint256_t(inputs[0]).slice(0, fq_ct::NUM_LIMB_BITS * 2))),
-                    witness_ct(&composer,
+            fq_ct a(witness_ct(&builder, fr(uint256_t(inputs[0]).slice(0, fq_ct::NUM_LIMB_BITS * 2))),
+                    witness_ct(&builder,
                                fr(uint256_t(inputs[0]).slice(fq_ct::NUM_LIMB_BITS * 2, fq_ct::NUM_LIMB_BITS * 4))));
-            fq_ct b(witness_ct(&composer, fr(uint256_t(inputs[1]).slice(0, fq_ct::NUM_LIMB_BITS * 2))),
-                    witness_ct(&composer,
+            fq_ct b(witness_ct(&builder, fr(uint256_t(inputs[1]).slice(0, fq_ct::NUM_LIMB_BITS * 2))),
+                    witness_ct(&builder,
                                fr(uint256_t(inputs[1]).slice(fq_ct::NUM_LIMB_BITS * 2, fq_ct::NUM_LIMB_BITS * 4))));
 
             fq_ct c = a;
@@ -673,23 +673,23 @@ template <typename Composer> class stdlib_bigfield : public testing::Test {
             EXPECT_EQ(result, expected);
             EXPECT_EQ(c.get_value().get_msb() < 254, true);
         }
-        bool result = composer.check_circuit();
+        bool result = builder.check_circuit();
         EXPECT_EQ(result, true);
     }
 
     static void test_assert_is_in_field_success()
     {
-        auto composer = Composer();
+        auto builder = Builder();
         size_t num_repetitions = 10;
         for (size_t i = 0; i < num_repetitions; ++i) {
 
             fq inputs[4]{ fq::random_element(), fq::random_element(), fq::random_element(), fq::random_element() };
 
-            fq_ct a(witness_ct(&composer, fr(uint256_t(inputs[0]).slice(0, fq_ct::NUM_LIMB_BITS * 2))),
-                    witness_ct(&composer,
+            fq_ct a(witness_ct(&builder, fr(uint256_t(inputs[0]).slice(0, fq_ct::NUM_LIMB_BITS * 2))),
+                    witness_ct(&builder,
                                fr(uint256_t(inputs[0]).slice(fq_ct::NUM_LIMB_BITS * 2, fq_ct::NUM_LIMB_BITS * 4))));
-            fq_ct b(witness_ct(&composer, fr(uint256_t(inputs[1]).slice(0, fq_ct::NUM_LIMB_BITS * 2))),
-                    witness_ct(&composer,
+            fq_ct b(witness_ct(&builder, fr(uint256_t(inputs[1]).slice(0, fq_ct::NUM_LIMB_BITS * 2))),
+                    witness_ct(&builder,
                                fr(uint256_t(inputs[1]).slice(fq_ct::NUM_LIMB_BITS * 2, fq_ct::NUM_LIMB_BITS * 4))));
 
             fq_ct c = a;
@@ -704,13 +704,13 @@ template <typename Composer> class stdlib_bigfield : public testing::Test {
             EXPECT_EQ(result, uint256_t(expected));
             EXPECT_EQ(c.get_value().get_msb() < 254, true);
         }
-        bool result = composer.check_circuit();
+        bool result = builder.check_circuit();
         EXPECT_EQ(result, true);
     }
 
     static void test_assert_less_than_success()
     {
-        auto composer = Composer();
+        auto builder = Builder();
         size_t num_repetitions = 10;
         constexpr size_t num_bits = 200;
         constexpr uint256_t bit_mask = (uint256_t(1) << num_bits) - 1;
@@ -721,11 +721,11 @@ template <typename Composer> class stdlib_bigfield : public testing::Test {
                           uint256_t(fq::random_element()) && bit_mask,
                           uint256_t(fq::random_element()) && bit_mask };
 
-            fq_ct a(witness_ct(&composer, fr(uint256_t(inputs[0]).slice(0, fq_ct::NUM_LIMB_BITS * 2))),
-                    witness_ct(&composer,
+            fq_ct a(witness_ct(&builder, fr(uint256_t(inputs[0]).slice(0, fq_ct::NUM_LIMB_BITS * 2))),
+                    witness_ct(&builder,
                                fr(uint256_t(inputs[0]).slice(fq_ct::NUM_LIMB_BITS * 2, fq_ct::NUM_LIMB_BITS * 4))));
-            fq_ct b(witness_ct(&composer, fr(uint256_t(inputs[1]).slice(0, fq_ct::NUM_LIMB_BITS * 2))),
-                    witness_ct(&composer,
+            fq_ct b(witness_ct(&builder, fr(uint256_t(inputs[1]).slice(0, fq_ct::NUM_LIMB_BITS * 2))),
+                    witness_ct(&builder,
                                fr(uint256_t(inputs[1]).slice(fq_ct::NUM_LIMB_BITS * 2, fq_ct::NUM_LIMB_BITS * 4))));
 
             fq_ct c = a;
@@ -740,24 +740,24 @@ template <typename Composer> class stdlib_bigfield : public testing::Test {
             EXPECT_EQ(result, uint256_t(expected));
             EXPECT_EQ(c.get_value().get_msb() < num_bits, true);
         }
-        bool result = composer.check_circuit();
+        bool result = builder.check_circuit();
         EXPECT_EQ(result, true);
         // Checking edge conditions
         fq random_input = fq::random_element();
-        fq_ct a(witness_ct(&composer, fr(uint256_t(random_input).slice(0, fq_ct::NUM_LIMB_BITS * 2))),
-                witness_ct(&composer,
+        fq_ct a(witness_ct(&builder, fr(uint256_t(random_input).slice(0, fq_ct::NUM_LIMB_BITS * 2))),
+                witness_ct(&builder,
                            fr(uint256_t(random_input).slice(fq_ct::NUM_LIMB_BITS * 2, fq_ct::NUM_LIMB_BITS * 4))));
 
         a.assert_less_than(random_input + 1);
-        EXPECT_EQ(composer.check_circuit(), true);
+        EXPECT_EQ(builder.check_circuit(), true);
 
         a.assert_less_than(random_input);
-        EXPECT_EQ(composer.check_circuit(), false);
+        EXPECT_EQ(builder.check_circuit(), false);
     }
 
     static void test_byte_array_constructors()
     {
-        auto composer = Composer();
+        auto builder = Builder();
         size_t num_repetitions = 10;
         for (size_t i = 0; i < num_repetitions; ++i) {
 
@@ -767,8 +767,8 @@ template <typename Composer> class stdlib_bigfield : public testing::Test {
             std::vector<uint8_t> input_b(sizeof(fq));
             fq::serialize_to_buffer(inputs[1], &input_b[0]);
 
-            stdlib::byte_array<Composer> input_arr_a(&composer, input_a);
-            stdlib::byte_array<Composer> input_arr_b(&composer, input_b);
+            stdlib::byte_array<Builder> input_arr_a(&builder, input_a);
+            stdlib::byte_array<Builder> input_arr_b(&builder, input_b);
 
             fq_ct a(input_arr_a);
             fq_ct b(input_arr_b);
@@ -779,19 +779,19 @@ template <typename Composer> class stdlib_bigfield : public testing::Test {
             uint256_t result = (c.get_value().lo);
             EXPECT_EQ(result, uint256_t(expected));
         }
-        bool result = composer.check_circuit();
+        bool result = builder.check_circuit();
         EXPECT_EQ(result, true);
     }
 
     // This check tests if elements are reduced to fit quotient into range proof
     static void test_quotient_completeness()
     {
-        auto composer = Composer();
+        auto builder = Builder();
         const uint256_t input =
             uint256_t(0xfffffffffffffffe, 0xffffffffffffffff, 0xffffffffffffffff, 0x3fffffffffffffff);
 
-        fq_ct a(witness_ct(&composer, fr(uint256_t(input).slice(0, fq_ct::NUM_LIMB_BITS * 2))),
-                witness_ct(&composer, fr(uint256_t(input).slice(fq_ct::NUM_LIMB_BITS * 2, fq_ct::NUM_LIMB_BITS * 4))),
+        fq_ct a(witness_ct(&builder, fr(uint256_t(input).slice(0, fq_ct::NUM_LIMB_BITS * 2))),
+                witness_ct(&builder, fr(uint256_t(input).slice(fq_ct::NUM_LIMB_BITS * 2, fq_ct::NUM_LIMB_BITS * 4))),
                 false);
         auto a1 = a;
         auto a2 = a;
@@ -821,26 +821,26 @@ template <typename Composer> class stdlib_bigfield : public testing::Test {
         auto f = fq_ct::mult_madd({ a4 }, { a4 }, {}, false);
         (void)f;
 
-        bool result = composer.check_circuit();
+        bool result = builder.check_circuit();
         EXPECT_EQ(result, true);
     }
 
     static void test_conditional_select_regression()
     {
-        auto composer = Composer();
+        auto builder = Builder();
         barretenberg::fq a(0);
         barretenberg::fq b(1);
-        fq_ct a_ct(&composer, a);
-        fq_ct b_ct(&composer, b);
-        fq_ct selected = a_ct.conditional_select(b_ct, typename bn254::bool_ct(&composer, true));
+        fq_ct a_ct(&builder, a);
+        fq_ct b_ct(&builder, b);
+        fq_ct selected = a_ct.conditional_select(b_ct, typename bn254::bool_ct(&builder, true));
         EXPECT_EQ(barretenberg::fq((selected.get_value() % uint512_t(barretenberg::fq::modulus)).lo), b);
     }
 
     static void test_division_context()
     {
-        auto composer = Composer();
+        auto builder = Builder();
         barretenberg::fq a(1);
-        fq_ct a_ct(&composer, a);
+        fq_ct a_ct(&builder, a);
         fq_ct ret = fq_ct::div_check_denominator_nonzero({}, a_ct);
         EXPECT_NE(ret.get_context(), nullptr);
     }
@@ -938,18 +938,18 @@ TYPED_TEST(stdlib_bigfield, division_context)
 // // This test was disabled before the refactor to use TYPED_TEST's/
 // TEST(stdlib_bigfield, DISABLED_test_div_against_constants)
 // {
-//     auto composer = Composer();
+//     auto builder = Builder();
 //     size_t num_repetitions = 1;
 //     for (size_t i = 0; i < num_repetitions; ++i) {
 //         fq inputs[3]{ fq::random_element(), fq::random_element(), fq::random_element() };
-//         fq_ct a(witness_ct(&composer, barretenberg::fr(uint256_t(inputs[0]).slice(0,
+//         fq_ct a(witness_ct(&builder, barretenberg::fr(uint256_t(inputs[0]).slice(0,
 //         fq_ct::NUM_LIMB_BITS * 2))),
 //                 witness_ct(
-//                     &composer,
+//                     &builder,
 //                     barretenberg::fr(uint256_t(inputs[0]).slice(fq_ct::NUM_LIMB_BITS * 2,
 //                     fq_ct::NUM_LIMB_BITS * 4))));
-//         fq_ct b1(&composer, uint256_t(inputs[1]));
-//         fq_ct b2(&composer, uint256_t(inputs[2]));
+//         fq_ct b1(&builder, uint256_t(inputs[1]));
+//         fq_ct b2(&builder, uint256_t(inputs[2]));
 //         fq_ct c = a / (b1 - b2);
 //         // uint256_t modulus{ barretenberg::Bn254FqParams::modulus_0,
 //         //                    barretenberg::Bn254FqParams::modulus_1,
@@ -981,26 +981,26 @@ TYPED_TEST(stdlib_bigfield, division_context)
 // // PLOOKUP TESTS
 // TEST(stdlib_bigfield_plookup, test_mul)
 // {
-//     plonk::UltraPlonkComposer composer = proof_system::plonk::UltraPlonkComposer();
+//     plonk::UltraPlonkBuilder builder = proof_system::plonk::UltraPlonkBuilder();
 //     size_t num_repetitions = 1;
 //     for (size_t i = 0; i < num_repetitions; ++i) {
 //         fq inputs[3]{ fq::random_element(), fq::random_element(), fq::random_element() };
 //         fq_ct a(
-//             witness_ct(&composer, barretenberg::fr(uint256_t(inputs[0]).slice(0,
-//             fq_ct::NUM_LIMB_BITS * 2))), witness_ct(&composer,
+//             witness_ct(&builder, barretenberg::fr(uint256_t(inputs[0]).slice(0,
+//             fq_ct::NUM_LIMB_BITS * 2))), witness_ct(&builder,
 //                        barretenberg::fr(
 //                            uint256_t(inputs[0]).slice(fq_ct::NUM_LIMB_BITS * 2, fq_ct::NUM_LIMB_BITS *
 //                            4))));
 //         fq_ct b(
-//             witness_ct(&composer, barretenberg::fr(uint256_t(inputs[1]).slice(0,
-//             fq_ct::NUM_LIMB_BITS * 2))), witness_ct(&composer,
+//             witness_ct(&builder, barretenberg::fr(uint256_t(inputs[1]).slice(0,
+//             fq_ct::NUM_LIMB_BITS * 2))), witness_ct(&builder,
 //                        barretenberg::fr(
 //                            uint256_t(inputs[1]).slice(fq_ct::NUM_LIMB_BITS * 2, fq_ct::NUM_LIMB_BITS *
 //                            4))));
 //         std::cerr << "starting mul" << std::endl;
-//         uint64_t before = composer.get_num_gates();
+//         uint64_t before = builder.get_num_gates();
 //         fq_ct c = a * b;
-//         uint64_t after = composer.get_num_gates();
+//         uint64_t after = builder.get_num_gates();
 //         if (i == num_repetitions - 1) {
 //             std::cerr << "num gates per mul = " << after - before << std::endl;
 //         }
@@ -1018,7 +1018,7 @@ TYPED_TEST(stdlib_bigfield, division_context)
 //         EXPECT_EQ(result.hi.data[2], 0ULL);
 //         EXPECT_EQ(result.hi.data[3], 0ULL);
 //     }
-//     composer.process_range_lists();
+//     builder.process_range_lists();
 //     plonk::PlookupProver prover = composer.create_prover();
 //     plonk::PlookupVerifier verifier = composer.create_verifier();
 //     plonk::proof proof = prover.construct_proof();
@@ -1028,19 +1028,19 @@ TYPED_TEST(stdlib_bigfield, division_context)
 
 // TEST(stdlib_bigfield_plookup, test_sqr)
 // {
-//     plonk::UltraPlonkComposer composer = proof_system::plonk::UltraPlonkComposer();
+//     plonk::UltraPlonkBuilder builder = proof_system::plonk::UltraPlonkBuilder();
 //     size_t num_repetitions = 10;
 //     for (size_t i = 0; i < num_repetitions; ++i) {
 //         fq inputs[3]{ fq::random_element(), fq::random_element(), fq::random_element() };
 //         fq_ct a(
-//             witness_ct(&composer, barretenberg::fr(uint256_t(inputs[0]).slice(0,
-//             fq_ct::NUM_LIMB_BITS * 2))), witness_ct(&composer,
+//             witness_ct(&builder, barretenberg::fr(uint256_t(inputs[0]).slice(0,
+//             fq_ct::NUM_LIMB_BITS * 2))), witness_ct(&builder,
 //                        barretenberg::fr(
 //                            uint256_t(inputs[0]).slice(fq_ct::NUM_LIMB_BITS * 2, fq_ct::NUM_LIMB_BITS *
 //                            4))));
-//         uint64_t before = composer.get_num_gates();
+//         uint64_t before = builder.get_num_gates();
 //         fq_ct c = a.sqr();
-//         uint64_t after = composer.get_num_gates();
+//         uint64_t after = builder.get_num_gates();
 //         if (i == num_repetitions - 1) {
 //             std::cerr << "num gates per sqr = " << after - before << std::endl;
 //         }
diff --git a/barretenberg/cpp/src/barretenberg/stdlib/primitives/bigfield/bigfield_impl.hpp b/barretenberg/cpp/src/barretenberg/stdlib/primitives/bigfield/bigfield_impl.hpp
index bc1c8ee42a4..72330802d0a 100644
--- a/barretenberg/cpp/src/barretenberg/stdlib/primitives/bigfield/bigfield_impl.hpp
+++ b/barretenberg/cpp/src/barretenberg/stdlib/primitives/bigfield/bigfield_impl.hpp
@@ -14,8 +14,8 @@ using namespace barretenberg;
 namespace proof_system::plonk {
 namespace stdlib {
 
-template <typename C, typename T>
-bigfield<C, T>::bigfield(C* parent_context)
+template <typename Builder, typename T>
+bigfield<Builder, T>::bigfield(Builder* parent_context)
     : context(parent_context)
     , binary_basis_limbs{ Limb(barretenberg::fr(0)),
                           Limb(barretenberg::fr(0)),
@@ -24,8 +24,8 @@ bigfield<C, T>::bigfield(C* parent_context)
     , prime_basis_limb(context, 0)
 {}
 
-template <typename C, typename T>
-bigfield<C, T>::bigfield(C* parent_context, const uint256_t& value)
+template <typename Builder, typename T>
+bigfield<Builder, T>::bigfield(Builder* parent_context, const uint256_t& value)
     : context(parent_context)
     , binary_basis_limbs{ Limb(barretenberg::fr(value.slice(0, NUM_LIMB_BITS))),
                           Limb(barretenberg::fr(value.slice(NUM_LIMB_BITS, NUM_LIMB_BITS * 2))),
@@ -36,11 +36,11 @@ bigfield<C, T>::bigfield(C* parent_context, const uint256_t& value)
     ASSERT(value < modulus);
 }
 
-template <typename C, typename T>
-bigfield<C, T>::bigfield(const field_t<C>& low_bits_in,
-                         const field_t<C>& high_bits_in,
-                         const bool can_overflow,
-                         const size_t maximum_bitlength)
+template <typename Builder, typename T>
+bigfield<Builder, T>::bigfield(const field_t<Builder>& low_bits_in,
+                               const field_t<Builder>& high_bits_in,
+                               const bool can_overflow,
+                               const size_t maximum_bitlength)
 {
     ASSERT((can_overflow == true && maximum_bitlength == 0) ||
            (can_overflow == false && (maximum_bitlength == 0 || maximum_bitlength > (3 * NUM_LIMB_BITS))));
@@ -50,19 +50,19 @@ bigfield<C, T>::bigfield(const field_t<C>& low_bits_in,
     ASSERT(uint256_t(high_bits_in.get_value()) < (uint256_t(1) << (NUM_LIMB_BITS * 2)));
 
     context = low_bits_in.context == nullptr ? high_bits_in.context : low_bits_in.context;
-    field_t<C> limb_0(context);
-    field_t<C> limb_1(context);
-    field_t<C> limb_2(context);
-    field_t<C> limb_3(context);
+    field_t<Builder> limb_0(context);
+    field_t<Builder> limb_1(context);
+    field_t<Builder> limb_2(context);
+    field_t<Builder> limb_3(context);
     if (low_bits_in.witness_index != IS_CONSTANT) {
         std::vector<uint32_t> low_accumulator;
-        if constexpr (HasPlookup<C>) {
+        if constexpr (HasPlookup<Builder>) {
             // MERGE NOTE: this was the if constexpr block introduced in ecebe7643
             const auto limb_witnesses =
                 context->decompose_non_native_field_double_width_limb(low_bits_in.normalize().witness_index);
             limb_0.witness_index = limb_witnesses[0];
             limb_1.witness_index = limb_witnesses[1];
-            field_t<C>::evaluate_linear_identity(low_bits_in, -limb_0, -limb_1 * shift_1, field_t<C>(0));
+            field_t<Builder>::evaluate_linear_identity(low_bits_in, -limb_0, -limb_1 * shift_1, field_t<Builder>(0));
 
             // // Enforce that low_bits_in indeed only contains 2*NUM_LIMB_BITS bits
             // low_accumulator = context->decompose_into_default_range(low_bits_in.witness_index,
@@ -107,12 +107,12 @@ bigfield<C, T>::bigfield(const field_t<C>& low_bits_in,
     if (high_bits_in.witness_index != IS_CONSTANT) {
 
         std::vector<uint32_t> high_accumulator;
-        if constexpr (HasPlookup<C>) {
+        if constexpr (HasPlookup<Builder>) {
             const auto limb_witnesses = context->decompose_non_native_field_double_width_limb(
                 high_bits_in.normalize().witness_index, (size_t)num_high_limb_bits);
             limb_2.witness_index = limb_witnesses[0];
             limb_3.witness_index = limb_witnesses[1];
-            field_t<C>::evaluate_linear_identity(high_bits_in, -limb_2, -limb_3 * shift_1, field_t<C>(0));
+            field_t<Builder>::evaluate_linear_identity(high_bits_in, -limb_2, -limb_3 * shift_1, field_t<Builder>(0));
 
         } else {
             high_accumulator = context->decompose_into_base4_accumulators(high_bits_in.witness_index,
@@ -140,8 +140,8 @@ bigfield<C, T>::bigfield(const field_t<C>& low_bits_in,
     prime_basis_limb = low_bits_in + (high_bits_in * shift_2);
 }
 
-template <typename C, typename T>
-bigfield<C, T>::bigfield(const bigfield& other)
+template <typename Builder, typename T>
+bigfield<Builder, T>::bigfield(const bigfield& other)
     : context(other.context)
     , binary_basis_limbs{ other.binary_basis_limbs[0],
                           other.binary_basis_limbs[1],
@@ -150,8 +150,8 @@ bigfield<C, T>::bigfield(const bigfield& other)
     , prime_basis_limb(other.prime_basis_limb)
 {}
 
-template <typename C, typename T>
-bigfield<C, T>::bigfield(bigfield&& other)
+template <typename Builder, typename T>
+bigfield<Builder, T>::bigfield(bigfield&& other)
     : context(other.context)
     , binary_basis_limbs{ other.binary_basis_limbs[0],
                           other.binary_basis_limbs[1],
@@ -169,15 +169,15 @@ bigfield<C, T>::bigfield(bigfield&& other)
  * @param can_overflow Can the input value have more than log2(modulus) bits?
  * @param maximum_bitlength Provide the explicit maximum bitlength if known. Otherwise bigfield max value will be either
  * log2(modulus) bits iff can_overflow = false, or (4 * NUM_LIMB_BITS) iff can_overflow = true
- * @return bigfield<C, T>
+ * @return bigfield<Builder, T>
  *
  * @details This method is 1 gate more efficient than constructing from 2 field_ct elements.
  */
-template <typename C, typename T>
-bigfield<C, T> bigfield<C, T>::create_from_u512_as_witness(C* ctx,
-                                                           const uint512_t& value,
-                                                           const bool can_overflow,
-                                                           const size_t maximum_bitlength)
+template <typename Builder, typename T>
+bigfield<Builder, T> bigfield<Builder, T>::create_from_u512_as_witness(Builder* ctx,
+                                                                       const uint512_t& value,
+                                                                       const bool can_overflow,
+                                                                       const size_t maximum_bitlength)
 {
     ASSERT((can_overflow == true && maximum_bitlength == 0) ||
            (can_overflow == false && (maximum_bitlength == 0 || maximum_bitlength > (3 * NUM_LIMB_BITS))));
@@ -187,12 +187,12 @@ bigfield<C, T> bigfield<C, T>::create_from_u512_as_witness(C* ctx,
     limbs[2] = value.slice(NUM_LIMB_BITS * 2, NUM_LIMB_BITS * 3).lo;
     limbs[3] = value.slice(NUM_LIMB_BITS * 3, NUM_LIMB_BITS * 4).lo;
 
-    if constexpr (HasPlookup<C>) {
-        field_t<C> limb_0(ctx);
-        field_t<C> limb_1(ctx);
-        field_t<C> limb_2(ctx);
-        field_t<C> limb_3(ctx);
-        field_t<C> prime_limb(ctx);
+    if constexpr (HasPlookup<Builder>) {
+        field_t<Builder> limb_0(ctx);
+        field_t<Builder> limb_1(ctx);
+        field_t<Builder> limb_2(ctx);
+        field_t<Builder> limb_3(ctx);
+        field_t<Builder> prime_limb(ctx);
         limb_0.witness_index = ctx->add_variable(barretenberg::fr(limbs[0]));
         limb_1.witness_index = ctx->add_variable(barretenberg::fr(limbs[1]));
         limb_2.witness_index = ctx->add_variable(barretenberg::fr(limbs[2]));
@@ -242,43 +242,44 @@ bigfield<C, T> bigfield<C, T>::create_from_u512_as_witness(C* ctx,
     }
 }
 
-template <typename C, typename T> bigfield<C, T>::bigfield(const byte_array<C>& bytes)
+template <typename Builder, typename T> bigfield<Builder, T>::bigfield(const byte_array<Builder>& bytes)
 {
     ASSERT(bytes.size() == 32); // we treat input as a 256-bit big integer
-    const auto split_byte_into_nibbles = [](C* ctx, const field_t<C>& split_byte) {
+    const auto split_byte_into_nibbles = [](Builder* ctx, const field_t<Builder>& split_byte) {
         const uint64_t byte_val = uint256_t(split_byte.get_value()).data[0];
         const uint64_t lo_nibble_val = byte_val & 15ULL;
         const uint64_t hi_nibble_val = byte_val >> 4;
 
-        const field_t<C> lo_nibble(witness_t<C>(ctx, lo_nibble_val));
-        const field_t<C> hi_nibble(witness_t<C>(ctx, hi_nibble_val));
+        const field_t<Builder> lo_nibble(witness_t<Builder>(ctx, lo_nibble_val));
+        const field_t<Builder> hi_nibble(witness_t<Builder>(ctx, hi_nibble_val));
         lo_nibble.create_range_constraint(4, "bigfield: lo_nibble too large");
         hi_nibble.create_range_constraint(4, "bigfield: hi_nibble too large");
 
-        const field_t<C> sum = lo_nibble + (hi_nibble * 16);
+        const field_t<Builder> sum = lo_nibble + (hi_nibble * 16);
         sum.assert_equal(split_byte);
-        return std::make_pair<field_t<C>, field_t<C>>((field_t<C>)lo_nibble, (field_t<C>)hi_nibble);
+        return std::make_pair<field_t<Builder>, field_t<Builder>>((field_t<Builder>)lo_nibble,
+                                                                  (field_t<Builder>)hi_nibble);
     };
 
-    const auto reconstruct_two_limbs = [&split_byte_into_nibbles](C* ctx,
-                                                                  const field_t<C>& hi_bytes,
-                                                                  const field_t<C>& lo_bytes,
-                                                                  const field_t<C>& split_byte) {
+    const auto reconstruct_two_limbs = [&split_byte_into_nibbles](Builder* ctx,
+                                                                  const field_t<Builder>& hi_bytes,
+                                                                  const field_t<Builder>& lo_bytes,
+                                                                  const field_t<Builder>& split_byte) {
         const auto [lo_nibble, hi_nibble] = split_byte_into_nibbles(ctx, split_byte);
 
-        field_t<C> hi_limb = hi_nibble + hi_bytes * 16;
-        field_t<C> lo_limb = lo_bytes + lo_nibble * field_t<C>(ctx, uint256_t(1) << 64);
-        return std::make_pair<field_t<C>, field_t<C>>((field_t<C>)lo_limb, (field_t<C>)hi_limb);
+        field_t<Builder> hi_limb = hi_nibble + hi_bytes * 16;
+        field_t<Builder> lo_limb = lo_bytes + lo_nibble * field_t<Builder>(ctx, uint256_t(1) << 64);
+        return std::make_pair<field_t<Builder>, field_t<Builder>>((field_t<Builder>)lo_limb, (field_t<Builder>)hi_limb);
     };
-    C* ctx = bytes.get_context();
+    Builder* ctx = bytes.get_context();
 
-    const field_t<C> hi_8_bytes(bytes.slice(0, 6));
-    const field_t<C> mid_split_byte(bytes.slice(6, 1));
-    const field_t<C> mid_8_bytes(bytes.slice(7, 8));
+    const field_t<Builder> hi_8_bytes(bytes.slice(0, 6));
+    const field_t<Builder> mid_split_byte(bytes.slice(6, 1));
+    const field_t<Builder> mid_8_bytes(bytes.slice(7, 8));
 
-    const field_t<C> lo_8_bytes(bytes.slice(15, 8));
-    const field_t<C> lo_split_byte(bytes.slice(23, 1));
-    const field_t<C> lolo_8_bytes(bytes.slice(24, 8));
+    const field_t<Builder> lo_8_bytes(bytes.slice(15, 8));
+    const field_t<Builder> lo_split_byte(bytes.slice(23, 1));
+    const field_t<Builder> lolo_8_bytes(bytes.slice(24, 8));
 
     const auto [limb0, limb1] = reconstruct_two_limbs(ctx, lo_8_bytes, lolo_8_bytes, lo_split_byte);
     const auto [limb2, limb3] = reconstruct_two_limbs(ctx, hi_8_bytes, mid_8_bytes, mid_split_byte);
@@ -290,7 +291,7 @@ template <typename C, typename T> bigfield<C, T>::bigfield(const byte_array<C>&
     *this = res;
 }
 
-template <typename C, typename T> bigfield<C, T>& bigfield<C, T>::operator=(const bigfield& other)
+template <typename Builder, typename T> bigfield<Builder, T>& bigfield<Builder, T>::operator=(const bigfield& other)
 {
     context = other.context;
     binary_basis_limbs[0] = other.binary_basis_limbs[0];
@@ -301,7 +302,7 @@ template <typename C, typename T> bigfield<C, T>& bigfield<C, T>::operator=(cons
     return *this;
 }
 
-template <typename C, typename T> bigfield<C, T>& bigfield<C, T>::operator=(bigfield&& other)
+template <typename Builder, typename T> bigfield<Builder, T>& bigfield<Builder, T>::operator=(bigfield&& other)
 {
     context = other.context;
     binary_basis_limbs[0] = other.binary_basis_limbs[0];
@@ -312,7 +313,7 @@ template <typename C, typename T> bigfield<C, T>& bigfield<C, T>::operator=(bigf
     return *this;
 }
 
-template <typename C, typename T> uint512_t bigfield<C, T>::get_value() const
+template <typename Builder, typename T> uint512_t bigfield<Builder, T>::get_value() const
 {
     uint512_t t0 = uint256_t(binary_basis_limbs[0].element.get_value());
     uint512_t t1 = uint256_t(binary_basis_limbs[1].element.get_value());
@@ -321,7 +322,7 @@ template <typename C, typename T> uint512_t bigfield<C, T>::get_value() const
     return t0 + (t1 << (NUM_LIMB_BITS)) + (t2 << (2 * NUM_LIMB_BITS)) + (t3 << (3 * NUM_LIMB_BITS));
 }
 
-template <typename C, typename T> uint512_t bigfield<C, T>::get_maximum_value() const
+template <typename Builder, typename T> uint512_t bigfield<Builder, T>::get_maximum_value() const
 {
     uint512_t t0 = uint512_t(binary_basis_limbs[0].maximum_value);
     uint512_t t1 = uint512_t(binary_basis_limbs[1].maximum_value) << NUM_LIMB_BITS;
@@ -339,19 +340,20 @@ template <typename C, typename T> uint512_t bigfield<C, T>::get_maximum_value()
  * value. That will create 2 additional constraints instead of 5/3 needed to add 2 bigfield elements and several needed
  * to construct a bigfield element.
  *
- * @tparam C Composer
+ * @tparam Builder Builder
  * @tparam T Field Parameters
  * @param other Field element that will be added to the lower
  * @param other_maximum_value The maximum value of other
- * @return bigfield<C, T> Result
+ * @return bigfield<Builder, T> Result
  */
-template <typename C, typename T>
-bigfield<C, T> bigfield<C, T>::add_to_lower_limb(const field_t<C>& other, uint256_t other_maximum_value) const
+template <typename Builder, typename T>
+bigfield<Builder, T> bigfield<Builder, T>::add_to_lower_limb(const field_t<Builder>& other,
+                                                             uint256_t other_maximum_value) const
 {
     reduction_check();
     ASSERT((other_maximum_value + binary_basis_limbs[0].maximum_value) <= get_maximum_unreduced_limb_value());
     // needed cause a constant doesn't have a valid context
-    C* ctx = context ? context : other.context;
+    Builder* ctx = context ? context : other.context;
 
     if (is_constant() && other.is_constant()) {
         return bigfield(ctx, uint256_t((get_value() + uint256_t(other.get_value())) % modulus_u512));
@@ -364,12 +366,13 @@ bigfield<C, T> bigfield<C, T>::add_to_lower_limb(const field_t<C>& other, uint25
     return result;
 }
 
-template <typename C, typename T> bigfield<C, T> bigfield<C, T>::operator+(const bigfield& other) const
+template <typename Builder, typename T>
+bigfield<Builder, T> bigfield<Builder, T>::operator+(const bigfield& other) const
 {
     reduction_check();
     other.reduction_check();
     // needed cause a constant doesn't have a valid context
-    C* ctx = context ? context : other.context;
+    Builder* ctx = context ? context : other.context;
 
     if (is_constant() && other.is_constant()) {
         return bigfield(ctx, uint256_t((get_value() + other.get_value()) % modulus_u512));
@@ -384,7 +387,7 @@ template <typename C, typename T> bigfield<C, T> bigfield<C, T>::operator+(const
     result.binary_basis_limbs[3].maximum_value =
         binary_basis_limbs[3].maximum_value + other.binary_basis_limbs[3].maximum_value;
 
-    if constexpr (HasPlookup<C>) {
+    if constexpr (HasPlookup<Builder>) {
         if (prime_basis_limb.multiplicative_constant == 1 && other.prime_basis_limb.multiplicative_constant == 1 &&
             !is_constant() && !other.is_constant()) {
             bool limbconst = binary_basis_limbs[0].element.is_constant();
@@ -430,11 +433,11 @@ template <typename C, typename T> bigfield<C, T> bigfield<C, T>::operator+(const
 
                 const auto output_witnesses = ctx->evaluate_non_native_field_addition(
                     { x0, y0, c0 }, { x1, y1, c1 }, { x2, y2, c2 }, { x3, y3, c3 }, { xp, yp, cp });
-                result.binary_basis_limbs[0].element = field_t<C>::from_witness_index(ctx, output_witnesses[0]);
-                result.binary_basis_limbs[1].element = field_t<C>::from_witness_index(ctx, output_witnesses[1]);
-                result.binary_basis_limbs[2].element = field_t<C>::from_witness_index(ctx, output_witnesses[2]);
-                result.binary_basis_limbs[3].element = field_t<C>::from_witness_index(ctx, output_witnesses[3]);
-                result.prime_basis_limb = field_t<C>::from_witness_index(ctx, output_witnesses[4]);
+                result.binary_basis_limbs[0].element = field_t<Builder>::from_witness_index(ctx, output_witnesses[0]);
+                result.binary_basis_limbs[1].element = field_t<Builder>::from_witness_index(ctx, output_witnesses[1]);
+                result.binary_basis_limbs[2].element = field_t<Builder>::from_witness_index(ctx, output_witnesses[2]);
+                result.binary_basis_limbs[3].element = field_t<Builder>::from_witness_index(ctx, output_witnesses[3]);
+                result.prime_basis_limb = field_t<Builder>::from_witness_index(ctx, output_witnesses[4]);
                 return result;
             }
         }
@@ -471,9 +474,10 @@ template <typename C, typename T> bigfield<C, T> bigfield<C, T>::operator+(const
  *
  * *this.limb[i] + X.limb[i] - other.limb[i]
  **/
-template <typename C, typename T> bigfield<C, T> bigfield<C, T>::operator-(const bigfield& other) const
+template <typename Builder, typename T>
+bigfield<Builder, T> bigfield<Builder, T>::operator-(const bigfield& other) const
 {
-    C* ctx = context ? context : other.context;
+    Builder* ctx = context ? context : other.context;
     reduction_check();
     other.reduction_check();
 
@@ -592,7 +596,7 @@ template <typename C, typename T> bigfield<C, T> bigfield<C, T>::operator-(const
     result.binary_basis_limbs[2].element = binary_basis_limbs[2].element + barretenberg::fr(to_add_2);
     result.binary_basis_limbs[3].element = binary_basis_limbs[3].element + barretenberg::fr(to_add_3);
 
-    if constexpr (HasPlookup<C>) {
+    if constexpr (HasPlookup<Builder>) {
         if (prime_basis_limb.multiplicative_constant == 1 && other.prime_basis_limb.multiplicative_constant == 1 &&
             !is_constant() && !other.is_constant()) {
             bool limbconst = result.binary_basis_limbs[0].element.is_constant();
@@ -641,11 +645,11 @@ template <typename C, typename T> bigfield<C, T> bigfield<C, T>::operator-(const
                 const auto output_witnesses = ctx->evaluate_non_native_field_subtraction(
                     { x0, y0, c0 }, { x1, y1, c1 }, { x2, y2, c2 }, { x3, y3, c3 }, { xp, yp, cp });
 
-                result.binary_basis_limbs[0].element = field_t<C>::from_witness_index(ctx, output_witnesses[0]);
-                result.binary_basis_limbs[1].element = field_t<C>::from_witness_index(ctx, output_witnesses[1]);
-                result.binary_basis_limbs[2].element = field_t<C>::from_witness_index(ctx, output_witnesses[2]);
-                result.binary_basis_limbs[3].element = field_t<C>::from_witness_index(ctx, output_witnesses[3]);
-                result.prime_basis_limb = field_t<C>::from_witness_index(ctx, output_witnesses[4]);
+                result.binary_basis_limbs[0].element = field_t<Builder>::from_witness_index(ctx, output_witnesses[0]);
+                result.binary_basis_limbs[1].element = field_t<Builder>::from_witness_index(ctx, output_witnesses[1]);
+                result.binary_basis_limbs[2].element = field_t<Builder>::from_witness_index(ctx, output_witnesses[2]);
+                result.binary_basis_limbs[3].element = field_t<Builder>::from_witness_index(ctx, output_witnesses[3]);
+                result.prime_basis_limb = field_t<Builder>::from_witness_index(ctx, output_witnesses[4]);
                 return result;
             }
         }
@@ -674,12 +678,13 @@ template <typename C, typename T> bigfield<C, T> bigfield<C, T>::operator-(const
  * a * b - q * p - c = 0 mod modulus_u512 (binary basis modulus, currently 2**272)
  * a * b - q * p - c = 0 mod circuit modulus
  **/
-template <typename C, typename T> bigfield<C, T> bigfield<C, T>::operator*(const bigfield& other) const
+template <typename Builder, typename T>
+bigfield<Builder, T> bigfield<Builder, T>::operator*(const bigfield& other) const
 {
     // First we do basic reduction checks of individual elements
     reduction_check();
     other.reduction_check();
-    C* ctx = context ? context : other.context;
+    Builder* ctx = context ? context : other.context;
     // Now we can actually compute the quotient and remainder values
     const auto [quotient_value, remainder_value] = compute_quotient_remainder_values(*this, other, {});
     bigfield remainder;
@@ -719,7 +724,8 @@ template <typename C, typename T> bigfield<C, T> bigfield<C, T>::operator*(const
  *
  * To evaluate (a / b = c mod p), we instead evaluate (c * b = a mod p).
  **/
-template <typename C, typename T> bigfield<C, T> bigfield<C, T>::operator/(const bigfield& other) const
+template <typename Builder, typename T>
+bigfield<Builder, T> bigfield<Builder, T>::operator/(const bigfield& other) const
 {
 
     return internal_div({ *this }, other, false);
@@ -727,12 +733,13 @@ template <typename C, typename T> bigfield<C, T> bigfield<C, T>::operator/(const
 /**
  * @brief Create constraints for summing these terms
  *
- * @tparam C
+ * @tparam Builder
  * @tparam T
  * @param terms
  * @return The sum of terms
  */
-template <typename C, typename T> bigfield<C, T> bigfield<C, T>::sum(const std::vector<bigfield>& terms)
+template <typename Builder, typename T>
+bigfield<Builder, T> bigfield<Builder, T>::sum(const std::vector<bigfield>& terms)
 {
     ASSERT(terms.size() > 0);
 
@@ -758,17 +765,17 @@ template <typename C, typename T> bigfield<C, T> bigfield<C, T>::sum(const std::
  *
  * @return The result of division
  * */
-template <typename C, typename T>
-bigfield<C, T> bigfield<C, T>::internal_div(const std::vector<bigfield>& numerators,
-                                            const bigfield& denominator,
-                                            bool check_for_zero)
+template <typename Builder, typename T>
+bigfield<Builder, T> bigfield<Builder, T>::internal_div(const std::vector<bigfield>& numerators,
+                                                        const bigfield& denominator,
+                                                        bool check_for_zero)
 {
     if (numerators.size() == 0) {
-        return bigfield<C, T>(denominator.get_context(), uint256_t(0));
+        return bigfield<Builder, T>(denominator.get_context(), uint256_t(0));
     }
 
     denominator.reduction_check();
-    C* ctx = denominator.context;
+    Builder* ctx = denominator.context;
     uint512_t numerator_values(0);
     bool numerator_constant = true;
     for (const auto& numerator_element : numerators) {
@@ -832,9 +839,9 @@ bigfield<C, T> bigfield<C, T>::internal_div(const std::vector<bigfield>& numerat
  * Similar to operator/ but numerator can be linear sum of multiple elements
  *
  **/
-template <typename C, typename T>
-bigfield<C, T> bigfield<C, T>::div_without_denominator_check(const std::vector<bigfield>& numerators,
-                                                             const bigfield& denominator)
+template <typename Builder, typename T>
+bigfield<Builder, T> bigfield<Builder, T>::div_without_denominator_check(const std::vector<bigfield>& numerators,
+                                                                         const bigfield& denominator)
 {
     return internal_div(numerators, denominator, false);
 }
@@ -846,9 +853,9 @@ bigfield<C, T> bigfield<C, T>::div_without_denominator_check(const std::vector<b
  *
  * TODO: After we create a mechanism for easy updating of witnesses, create a test with proof check
  **/
-template <typename C, typename T>
-bigfield<C, T> bigfield<C, T>::div_check_denominator_nonzero(const std::vector<bigfield>& numerators,
-                                                             const bigfield& denominator)
+template <typename Builder, typename T>
+bigfield<Builder, T> bigfield<Builder, T>::div_check_denominator_nonzero(const std::vector<bigfield>& numerators,
+                                                                         const bigfield& denominator)
 {
     return internal_div(numerators, denominator, true);
 }
@@ -857,10 +864,10 @@ bigfield<C, T> bigfield<C, T>::div_check_denominator_nonzero(const std::vector<b
  *
  * Slightly cheaper than operator* for StandardPlonk and TurboPlonk
  **/
-template <typename C, typename T> bigfield<C, T> bigfield<C, T>::sqr() const
+template <typename Builder, typename T> bigfield<Builder, T> bigfield<Builder, T>::sqr() const
 {
     reduction_check();
-    C* ctx = context;
+    Builder* ctx = context;
 
     const auto [quotient_value, remainder_value] = compute_quotient_remainder_values(*this, *this, {});
 
@@ -894,11 +901,12 @@ template <typename C, typename T> bigfield<C, T> bigfield<C, T>::sqr() const
  * Chaining the additions here is cheaper than calling operator+ because we can combine some gates in
  *`evaluate_multiply_add`
  **/
-template <typename C, typename T> bigfield<C, T> bigfield<C, T>::sqradd(const std::vector<bigfield>& to_add) const
+template <typename Builder, typename T>
+bigfield<Builder, T> bigfield<Builder, T>::sqradd(const std::vector<bigfield>& to_add) const
 {
     reduction_check();
 
-    C* ctx = context;
+    Builder* ctx = context;
 
     uint512_t add_values(0);
     bool add_constant = true;
@@ -961,10 +969,10 @@ template <typename C, typename T> bigfield<C, T> bigfield<C, T>::sqradd(const st
  *
  * @return New bigfield elment c
  **/
-template <typename C, typename T>
-bigfield<C, T> bigfield<C, T>::madd(const bigfield& to_mul, const std::vector<bigfield>& to_add) const
+template <typename Builder, typename T>
+bigfield<Builder, T> bigfield<Builder, T>::madd(const bigfield& to_mul, const std::vector<bigfield>& to_add) const
 {
-    C* ctx = context ? context : to_mul.context;
+    Builder* ctx = context ? context : to_mul.context;
     reduction_check();
     to_mul.reduction_check();
 
@@ -1018,16 +1026,16 @@ bigfield<C, T> bigfield<C, T>::madd(const bigfield& to_mul, const std::vector<bi
  * modulus overflow and to fit the quotient inside the range proof
  *
  *
- * @tparam C composer
+ * @tparam Builder builder
  * @tparam T basefield
  * @param mul_left
  * @param mul_right
  * @param to_add
  */
-template <typename C, typename T>
-void bigfield<C, T>::perform_reductions_for_mult_madd(std::vector<bigfield>& mul_left,
-                                                      std::vector<bigfield>& mul_right,
-                                                      const std::vector<bigfield>& to_add)
+template <typename Builder, typename T>
+void bigfield<Builder, T>::perform_reductions_for_mult_madd(std::vector<bigfield>& mul_left,
+                                                            std::vector<bigfield>& mul_right,
+                                                            const std::vector<bigfield>& to_add)
 {
     const size_t number_of_products = mul_left.size();
     // Get the maximum values of elements
@@ -1156,11 +1164,11 @@ void bigfield<C, T>::perform_reductions_for_mult_madd(std::vector<bigfield>& mul
  *
  * @return A reduced value that is the sum of all products and to_add values
  * */
-template <typename C, typename T>
-bigfield<C, T> bigfield<C, T>::mult_madd(const std::vector<bigfield>& mul_left,
-                                         const std::vector<bigfield>& mul_right,
-                                         const std::vector<bigfield>& to_add,
-                                         bool fix_remainder_to_zero)
+template <typename Builder, typename T>
+bigfield<Builder, T> bigfield<Builder, T>::mult_madd(const std::vector<bigfield>& mul_left,
+                                                     const std::vector<bigfield>& mul_right,
+                                                     const std::vector<bigfield>& to_add,
+                                                     bool fix_remainder_to_zero)
 {
     ASSERT(mul_left.size() == mul_right.size());
 
@@ -1206,7 +1214,7 @@ bigfield<C, T> bigfield<C, T>::mult_madd(const std::vector<bigfield>& mul_left,
         }
     }
 
-    C* ctx = nullptr;
+    Builder* ctx = nullptr;
     // Search through all multiplicands on the left
     for (auto& el : mutable_mul_left) {
         if (el.context) {
@@ -1326,12 +1334,12 @@ bigfield<C, T> bigfield<C, T>::mult_madd(const std::vector<bigfield>& mul_left,
  *
  * This is cheaper than two multiplication operations, as the above only requires one quotient/remainder
  **/
-template <typename C, typename T>
-bigfield<C, T> bigfield<C, T>::dual_madd(const bigfield& left_a,
-                                         const bigfield& right_a,
-                                         const bigfield& left_b,
-                                         const bigfield& right_b,
-                                         const std::vector<bigfield>& to_add)
+template <typename Builder, typename T>
+bigfield<Builder, T> bigfield<Builder, T>::dual_madd(const bigfield& left_a,
+                                                     const bigfield& right_a,
+                                                     const bigfield& left_b,
+                                                     const bigfield& right_b,
+                                                     const std::vector<bigfield>& to_add)
 {
     left_a.reduction_check();
     right_a.reduction_check();
@@ -1362,14 +1370,14 @@ bigfield<C, T> bigfield<C, T>::dual_madd(const bigfield& left_a,
  *
  * We proxy this to mult_madd, so it only requires one quotient and remainder + overflow limbs
  **/
-template <typename C, typename T>
-bigfield<C, T> bigfield<C, T>::msub_div(const std::vector<bigfield>& mul_left,
-                                        const std::vector<bigfield>& mul_right,
-                                        const bigfield& divisor,
-                                        const std::vector<bigfield>& to_sub,
-                                        bool enable_divisor_nz_check)
+template <typename Builder, typename T>
+bigfield<Builder, T> bigfield<Builder, T>::msub_div(const std::vector<bigfield>& mul_left,
+                                                    const std::vector<bigfield>& mul_right,
+                                                    const bigfield& divisor,
+                                                    const std::vector<bigfield>& to_sub,
+                                                    bool enable_divisor_nz_check)
 {
-    C* ctx = divisor.context;
+    Builder* ctx = divisor.context;
 
     const size_t num_multiplications = mul_left.size();
     native product_native = 0;
@@ -1428,9 +1436,10 @@ bigfield<C, T> bigfield<C, T>::msub_div(const std::vector<bigfield>& mul_left,
     return result;
 }
 
-template <typename C, typename T> bigfield<C, T> bigfield<C, T>::conditional_negate(const bool_t<C>& predicate) const
+template <typename Builder, typename T>
+bigfield<Builder, T> bigfield<Builder, T>::conditional_negate(const bool_t<Builder>& predicate) const
 {
-    C* ctx = context ? context : predicate.context;
+    Builder* ctx = context ? context : predicate.context;
 
     if (is_constant() && predicate.is_constant()) {
         if (predicate.get_value()) {
@@ -1481,14 +1490,14 @@ template <typename C, typename T> bigfield<C, T> bigfield<C, T>::conditional_neg
     // = predicate * (limb_i - 2 * value) + value
     barretenberg::fr two(2);
 
-    field_t limb_0 = static_cast<field_t<C>>(predicate).madd(-(binary_basis_limbs[0].element * two) + to_add_0,
-                                                             binary_basis_limbs[0].element);
-    field_t limb_1 = static_cast<field_t<C>>(predicate).madd(-(binary_basis_limbs[1].element * two) + to_add_1,
-                                                             binary_basis_limbs[1].element);
-    field_t limb_2 = static_cast<field_t<C>>(predicate).madd(-(binary_basis_limbs[2].element * two) + to_add_2,
-                                                             binary_basis_limbs[2].element);
-    field_t limb_3 = static_cast<field_t<C>>(predicate).madd(-(binary_basis_limbs[3].element * two) + to_add_3,
-                                                             binary_basis_limbs[3].element);
+    field_t limb_0 = static_cast<field_t<Builder>>(predicate).madd(-(binary_basis_limbs[0].element * two) + to_add_0,
+                                                                   binary_basis_limbs[0].element);
+    field_t limb_1 = static_cast<field_t<Builder>>(predicate).madd(-(binary_basis_limbs[1].element * two) + to_add_1,
+                                                                   binary_basis_limbs[1].element);
+    field_t limb_2 = static_cast<field_t<Builder>>(predicate).madd(-(binary_basis_limbs[2].element * two) + to_add_2,
+                                                                   binary_basis_limbs[2].element);
+    field_t limb_3 = static_cast<field_t<Builder>>(predicate).madd(-(binary_basis_limbs[3].element * two) + to_add_3,
+                                                                   binary_basis_limbs[3].element);
 
     uint256_t max_limb_0 = binary_basis_limbs[0].maximum_value + to_add_0_u256 + t0;
     uint256_t max_limb_1 = binary_basis_limbs[1].maximum_value + to_add_1_u256 + t1;
@@ -1504,7 +1513,7 @@ template <typename C, typename T> bigfield<C, T> bigfield<C, T>::conditional_neg
     uint512_t constant_to_add_mod_p = constant_to_add % prime_basis.modulus;
     field_t prime_basis_to_add(ctx, barretenberg::fr(constant_to_add_mod_p.lo));
     result.prime_basis_limb =
-        static_cast<field_t<C>>(predicate).madd(-(prime_basis_limb * two) + prime_basis_to_add, prime_basis_limb);
+        static_cast<field_t<Builder>>(predicate).madd(-(prime_basis_limb * two) + prime_basis_to_add, prime_basis_limb);
 
     return result;
 }
@@ -1512,14 +1521,15 @@ template <typename C, typename T> bigfield<C, T> bigfield<C, T>::conditional_neg
 /**
  * @brief Create an element which is equal to either this or other based on the predicate
  *
- * @tparam C
+ * @tparam Builder
  * @tparam T
  * @param other The other bigfield element
  * @param predicate Predicate controlling the result (0 for this, 1 for the other)
  * @return Resulting element
  */
-template <typename C, typename T>
-bigfield<C, T> bigfield<C, T>::conditional_select(const bigfield& other, const bool_t<C>& predicate) const
+template <typename Builder, typename T>
+bigfield<Builder, T> bigfield<Builder, T>::conditional_select(const bigfield& other,
+                                                              const bool_t<Builder>& predicate) const
 {
     if (is_constant() && other.is_constant() && predicate.is_constant()) {
         if (predicate.get_value()) {
@@ -1527,19 +1537,19 @@ bigfield<C, T> bigfield<C, T>::conditional_select(const bigfield& other, const b
         }
         return *this;
     }
-    C* ctx = context ? context : (other.context ? other.context : predicate.context);
+    Builder* ctx = context ? context : (other.context ? other.context : predicate.context);
 
     // TODO: use field_t::conditional_assign method
-    field_t binary_limb_0 = static_cast<field_t<C>>(predicate).madd(
+    field_t binary_limb_0 = static_cast<field_t<Builder>>(predicate).madd(
         other.binary_basis_limbs[0].element - binary_basis_limbs[0].element, binary_basis_limbs[0].element);
-    field_t binary_limb_1 = static_cast<field_t<C>>(predicate).madd(
+    field_t binary_limb_1 = static_cast<field_t<Builder>>(predicate).madd(
         other.binary_basis_limbs[1].element - binary_basis_limbs[1].element, binary_basis_limbs[1].element);
-    field_t binary_limb_2 = static_cast<field_t<C>>(predicate).madd(
+    field_t binary_limb_2 = static_cast<field_t<Builder>>(predicate).madd(
         other.binary_basis_limbs[2].element - binary_basis_limbs[2].element, binary_basis_limbs[2].element);
-    field_t binary_limb_3 = static_cast<field_t<C>>(predicate).madd(
+    field_t binary_limb_3 = static_cast<field_t<Builder>>(predicate).madd(
         other.binary_basis_limbs[3].element - binary_basis_limbs[3].element, binary_basis_limbs[3].element);
     field_t prime_limb =
-        static_cast<field_t<C>>(predicate).madd(other.prime_basis_limb - prime_basis_limb, prime_basis_limb);
+        static_cast<field_t<Builder>>(predicate).madd(other.prime_basis_limb - prime_basis_limb, prime_basis_limb);
 
     bigfield result(ctx);
     // the maximum of the maximal values of elements is large enough
@@ -1569,7 +1579,7 @@ bigfield<C, T> bigfield<C, T>::conditional_select(const bigfield& other, const b
  * @param num_products The number of products a*b in the parent function that calls the reduction check. Needed to
  *limit overflow
  **/
-template <typename C, typename T> void bigfield<C, T>::reduction_check(const size_t num_products) const
+template <typename Builder, typename T> void bigfield<Builder, T>::reduction_check(const size_t num_products) const
 {
 
     if (is_constant()) { // this seems not a reduction check, but actually computing the reduction
@@ -1601,7 +1611,7 @@ template <typename C, typename T> void bigfield<C, T>::reduction_check(const siz
 // Including the effect of carries the operation inside each limb is in the range [-2^b-1,2^{b+1}]
 // Assuming this values are all distinct mod r, which happens e.g. if r/2>2^{b+1}, then if all limb values are
 // non-negative at the end of subtraction, we know the subtraction result is positive as integers and a<p
-template <typename C, typename T> void bigfield<C, T>::assert_is_in_field() const
+template <typename Builder, typename T> void bigfield<Builder, T>::assert_is_in_field() const
 {
     // Warning: this assumes we have run circuit construction at least once in debug mode where large non reduced
     // constants are allowed via ASSERT
@@ -1625,29 +1635,29 @@ template <typename C, typename T> void bigfield<C, T>::assert_is_in_field() cons
     bool borrow_2_value =
         (value.slice(NUM_LIMB_BITS * 2, NUM_LIMB_BITS * 3) + uint256_t(borrow_1_value)) > (modulus_minus_one_2);
 
-    field_t<C> modulus_0(context, modulus_minus_one_0);
-    field_t<C> modulus_1(context, modulus_minus_one_1);
-    field_t<C> modulus_2(context, modulus_minus_one_2);
-    field_t<C> modulus_3(context, modulus_minus_one_3);
-    bool_t<C> borrow_0(witness_t<C>(context, borrow_0_value));
-    bool_t<C> borrow_1(witness_t<C>(context, borrow_1_value));
-    bool_t<C> borrow_2(witness_t<C>(context, borrow_2_value));
+    field_t<Builder> modulus_0(context, modulus_minus_one_0);
+    field_t<Builder> modulus_1(context, modulus_minus_one_1);
+    field_t<Builder> modulus_2(context, modulus_minus_one_2);
+    field_t<Builder> modulus_3(context, modulus_minus_one_3);
+    bool_t<Builder> borrow_0(witness_t<Builder>(context, borrow_0_value));
+    bool_t<Builder> borrow_1(witness_t<Builder>(context, borrow_1_value));
+    bool_t<Builder> borrow_2(witness_t<Builder>(context, borrow_2_value));
     // The way we use borrows here ensures that we are checking that modulus - binary_basis > 0.
     // We check that the result in each limb is > 0.
     // If the modulus part in this limb is smaller, we simply borrow the value from the higher limb.
     // The prover can rearrange the borrows the way they like. The important thing is that the borrows are
     // constrained.
-    field_t<C> r0 = modulus_0 - binary_basis_limbs[0].element + static_cast<field_t<C>>(borrow_0) * shift_1;
-    field_t<C> r1 = modulus_1 - binary_basis_limbs[1].element + static_cast<field_t<C>>(borrow_1) * shift_1 -
-                    static_cast<field_t<C>>(borrow_0);
-    field_t<C> r2 = modulus_2 - binary_basis_limbs[2].element + static_cast<field_t<C>>(borrow_2) * shift_1 -
-                    static_cast<field_t<C>>(borrow_1);
-    field_t<C> r3 = modulus_3 - binary_basis_limbs[3].element - static_cast<field_t<C>>(borrow_2);
+    field_t<Builder> r0 = modulus_0 - binary_basis_limbs[0].element + static_cast<field_t<Builder>>(borrow_0) * shift_1;
+    field_t<Builder> r1 = modulus_1 - binary_basis_limbs[1].element +
+                          static_cast<field_t<Builder>>(borrow_1) * shift_1 - static_cast<field_t<Builder>>(borrow_0);
+    field_t<Builder> r2 = modulus_2 - binary_basis_limbs[2].element +
+                          static_cast<field_t<Builder>>(borrow_2) * shift_1 - static_cast<field_t<Builder>>(borrow_1);
+    field_t<Builder> r3 = modulus_3 - binary_basis_limbs[3].element - static_cast<field_t<Builder>>(borrow_2);
     r0 = r0.normalize();
     r1 = r1.normalize();
     r2 = r2.normalize();
     r3 = r3.normalize();
-    if constexpr (HasPlookup<C>) {
+    if constexpr (HasPlookup<Builder>) {
         context->decompose_into_default_range(r0.witness_index, static_cast<size_t>(NUM_LIMB_BITS));
         context->decompose_into_default_range(r1.witness_index, static_cast<size_t>(NUM_LIMB_BITS));
         context->decompose_into_default_range(r2.witness_index, static_cast<size_t>(NUM_LIMB_BITS));
@@ -1664,7 +1674,7 @@ template <typename C, typename T> void bigfield<C, T>::assert_is_in_field() cons
     }
 }
 
-template <typename C, typename T> void bigfield<C, T>::assert_less_than(const uint256_t upper_limit) const
+template <typename Builder, typename T> void bigfield<Builder, T>::assert_less_than(const uint256_t upper_limit) const
 {
     // TODO(kesha): Merge this with assert_is_in_field
     // Warning: this assumes we have run circuit construction at least once in debug mode where large non reduced
@@ -1690,29 +1700,30 @@ template <typename C, typename T> void bigfield<C, T>::assert_less_than(const ui
     bool borrow_2_value =
         (value.slice(NUM_LIMB_BITS * 2, NUM_LIMB_BITS * 3) + uint256_t(borrow_1_value)) > (upper_limit_value_2);
 
-    field_t<C> upper_limit_0(context, upper_limit_value_0);
-    field_t<C> upper_limit_1(context, upper_limit_value_1);
-    field_t<C> upper_limit_2(context, upper_limit_value_2);
-    field_t<C> upper_limit_3(context, upper_limit_value_3);
-    bool_t<C> borrow_0(witness_t<C>(context, borrow_0_value));
-    bool_t<C> borrow_1(witness_t<C>(context, borrow_1_value));
-    bool_t<C> borrow_2(witness_t<C>(context, borrow_2_value));
+    field_t<Builder> upper_limit_0(context, upper_limit_value_0);
+    field_t<Builder> upper_limit_1(context, upper_limit_value_1);
+    field_t<Builder> upper_limit_2(context, upper_limit_value_2);
+    field_t<Builder> upper_limit_3(context, upper_limit_value_3);
+    bool_t<Builder> borrow_0(witness_t<Builder>(context, borrow_0_value));
+    bool_t<Builder> borrow_1(witness_t<Builder>(context, borrow_1_value));
+    bool_t<Builder> borrow_2(witness_t<Builder>(context, borrow_2_value));
     // The way we use borrows here ensures that we are checking that upper_limit - binary_basis > 0.
     // We check that the result in each limb is > 0.
     // If the modulus part in this limb is smaller, we simply borrow the value from the higher limb.
     // The prover can rearrange the borrows the way they like. The important thing is that the borrows are
     // constrained.
-    field_t<C> r0 = upper_limit_0 - binary_basis_limbs[0].element + static_cast<field_t<C>>(borrow_0) * shift_1;
-    field_t<C> r1 = upper_limit_1 - binary_basis_limbs[1].element + static_cast<field_t<C>>(borrow_1) * shift_1 -
-                    static_cast<field_t<C>>(borrow_0);
-    field_t<C> r2 = upper_limit_2 - binary_basis_limbs[2].element + static_cast<field_t<C>>(borrow_2) * shift_1 -
-                    static_cast<field_t<C>>(borrow_1);
-    field_t<C> r3 = upper_limit_3 - binary_basis_limbs[3].element - static_cast<field_t<C>>(borrow_2);
+    field_t<Builder> r0 =
+        upper_limit_0 - binary_basis_limbs[0].element + static_cast<field_t<Builder>>(borrow_0) * shift_1;
+    field_t<Builder> r1 = upper_limit_1 - binary_basis_limbs[1].element +
+                          static_cast<field_t<Builder>>(borrow_1) * shift_1 - static_cast<field_t<Builder>>(borrow_0);
+    field_t<Builder> r2 = upper_limit_2 - binary_basis_limbs[2].element +
+                          static_cast<field_t<Builder>>(borrow_2) * shift_1 - static_cast<field_t<Builder>>(borrow_1);
+    field_t<Builder> r3 = upper_limit_3 - binary_basis_limbs[3].element - static_cast<field_t<Builder>>(borrow_2);
     r0 = r0.normalize();
     r1 = r1.normalize();
     r2 = r2.normalize();
     r3 = r3.normalize();
-    if constexpr (C::CIRCUIT_TYPE == CircuitType::ULTRA) {
+    if constexpr (Builder::CIRCUIT_TYPE == CircuitType::ULTRA) {
         context->decompose_into_default_range(r0.witness_index, static_cast<size_t>(NUM_LIMB_BITS));
         context->decompose_into_default_range(r1.witness_index, static_cast<size_t>(NUM_LIMB_BITS));
         context->decompose_into_default_range(r2.witness_index, static_cast<size_t>(NUM_LIMB_BITS));
@@ -1731,9 +1742,9 @@ template <typename C, typename T> void bigfield<C, T>::assert_less_than(const ui
 
 // check elements are equal mod p by proving their integer difference is a multiple of p.
 // This relies on the minus operator for a-b increasing a by a multiple of p large enough so diff is non-negative
-template <typename C, typename T> void bigfield<C, T>::assert_equal(const bigfield& other) const
+template <typename Builder, typename T> void bigfield<Builder, T>::assert_equal(const bigfield& other) const
 {
-    C* ctx = this->context ? this->context : other.context;
+    Builder* ctx = this->context ? this->context : other.context;
 
     if (is_constant() && other.is_constant()) {
         std::cerr << "bigfield: calling assert equal on 2 CONSTANT bigfield elements...is this intended?" << std::endl;
@@ -1741,11 +1752,11 @@ template <typename C, typename T> void bigfield<C, T>::assert_equal(const bigfie
     } else if (other.is_constant()) {
         // evaluate a strict equality - make sure *this is reduced first, or an honest prover
         // might not be able to satisfy these constraints.
-        field_t<C> t0 = (binary_basis_limbs[0].element - other.binary_basis_limbs[0].element);
-        field_t<C> t1 = (binary_basis_limbs[1].element - other.binary_basis_limbs[1].element);
-        field_t<C> t2 = (binary_basis_limbs[2].element - other.binary_basis_limbs[2].element);
-        field_t<C> t3 = (binary_basis_limbs[3].element - other.binary_basis_limbs[3].element);
-        field_t<C> t4 = (prime_basis_limb - other.prime_basis_limb);
+        field_t<Builder> t0 = (binary_basis_limbs[0].element - other.binary_basis_limbs[0].element);
+        field_t<Builder> t1 = (binary_basis_limbs[1].element - other.binary_basis_limbs[1].element);
+        field_t<Builder> t2 = (binary_basis_limbs[2].element - other.binary_basis_limbs[2].element);
+        field_t<Builder> t3 = (binary_basis_limbs[3].element - other.binary_basis_limbs[3].element);
+        field_t<Builder> t4 = (prime_basis_limb - other.prime_basis_limb);
         t0.assert_is_zero();
         t1.assert_is_zero();
         t2.assert_is_zero();
@@ -1783,7 +1794,7 @@ template <typename C, typename T> void bigfield<C, T>::assert_equal(const bigfie
 // Suppose a-b = 0 mod p. Then a-b = k*p for k in a range [-R,L] such that L*p>= a, R*p>=b. And also a-b = k*p mod r
 // for such k. Thus we can verify a-b is non-zero mod p by taking the product of such values (a-b-kp) and showing
 // it's non-zero mod r
-template <typename C, typename T> void bigfield<C, T>::assert_is_not_equal(const bigfield& other) const
+template <typename Builder, typename T> void bigfield<Builder, T>::assert_is_not_equal(const bigfield& other) const
 {
     // Why would we use this for 2 constants? Turns out, in biggroup
     const auto get_overload_count = [target_modulus = modulus_u512](const uint512_t& maximum_value) {
@@ -1803,10 +1814,10 @@ template <typename C, typename T> void bigfield<C, T>::assert_is_not_equal(const
 
     // if numeric val of a = a' + p.q
     // we want to check (a' + p.q == b mod n)
-    const field_t<C> base_diff = prime_basis_limb - other.prime_basis_limb;
+    const field_t<Builder> base_diff = prime_basis_limb - other.prime_basis_limb;
     auto diff = base_diff;
-    field_t<C> prime_basis(get_context(), modulus);
-    field_t<C> prime_basis_accumulator = prime_basis;
+    field_t<Builder> prime_basis(get_context(), modulus);
+    field_t<Builder> prime_basis_accumulator = prime_basis;
     // Each loop iteration adds 1 gate
     // (prime_basis and prime_basis accumulator are constant so only the * operator adds a gate)
     for (size_t i = 0; i < lhs_overload_count; ++i) {
@@ -1825,7 +1836,7 @@ template <typename C, typename T> void bigfield<C, T>::assert_is_not_equal(const
 // This is much cheaper than actually reducing mod p and suffices for addition chains (where we just need not to
 // overflow 2^t) We also reduce any "spillage" inside the first 3 limbs, so that their range is NUM_LIMB_BITS and
 // not larger
-template <typename C, typename T> void bigfield<C, T>::self_reduce() const
+template <typename Builder, typename T> void bigfield<Builder, T>::self_reduce() const
 {
     // Warning: this assumes we have run circuit construction at least once in debug mode where large non reduced
     // constants are disallowed via ASSERT
@@ -1844,8 +1855,8 @@ template <typename C, typename T> void bigfield<C, T>::self_reduce() const
     }
     // TODO: implicit assumption here - NUM_LIMB_BITS large enough for all the quotient
     uint32_t quotient_limb_index = context->add_variable(barretenberg::fr(quotient_value.lo));
-    field_t<C> quotient_limb = field_t<C>::from_witness_index(context, quotient_limb_index);
-    if constexpr (HasPlookup<C>) {
+    field_t<Builder> quotient_limb = field_t<Builder>::from_witness_index(context, quotient_limb_index);
+    if constexpr (HasPlookup<Builder>) {
         context->decompose_into_default_range(quotient_limb.witness_index, static_cast<size_t>(maximum_quotient_bits));
     } else {
         context->decompose_into_base4_accumulators(quotient_limb.witness_index,
@@ -1856,9 +1867,9 @@ template <typename C, typename T> void bigfield<C, T>::self_reduce() const
     ASSERT((uint1024_t(1) << maximum_quotient_bits) * uint1024_t(modulus_u512) + DEFAULT_MAXIMUM_REMAINDER <
            get_maximum_crt_product());
     quotient.binary_basis_limbs[0] = Limb(quotient_limb, uint256_t(1) << maximum_quotient_bits);
-    quotient.binary_basis_limbs[1] = Limb(field_t<C>::from_witness_index(context, context->zero_idx), 0);
-    quotient.binary_basis_limbs[2] = Limb(field_t<C>::from_witness_index(context, context->zero_idx), 0);
-    quotient.binary_basis_limbs[3] = Limb(field_t<C>::from_witness_index(context, context->zero_idx), 0);
+    quotient.binary_basis_limbs[1] = Limb(field_t<Builder>::from_witness_index(context, context->zero_idx), 0);
+    quotient.binary_basis_limbs[2] = Limb(field_t<Builder>::from_witness_index(context, context->zero_idx), 0);
+    quotient.binary_basis_limbs[3] = Limb(field_t<Builder>::from_witness_index(context, context->zero_idx), 0);
     quotient.prime_basis_limb = quotient_limb;
     // this constructor with can_overflow=false will enforce remainder of size<2^s
     bigfield remainder = bigfield(
@@ -1886,12 +1897,12 @@ template <typename C, typename T> void bigfield<C, T>::self_reduce() const
  *
  * THIS FUNCTION IS UNSAFE TO USE IN CIRCUITS AS IT DOES NOT PROTECT AGAINST CRT OVERFLOWS.
  * */
-template <typename C, typename T>
-void bigfield<C, T>::unsafe_evaluate_multiply_add(const bigfield& input_left,
-                                                  const bigfield& input_to_mul,
-                                                  const std::vector<bigfield>& to_add,
-                                                  const bigfield& input_quotient,
-                                                  const std::vector<bigfield>& input_remainders)
+template <typename Builder, typename T>
+void bigfield<Builder, T>::unsafe_evaluate_multiply_add(const bigfield& input_left,
+                                                        const bigfield& input_to_mul,
+                                                        const std::vector<bigfield>& to_add,
+                                                        const bigfield& input_quotient,
+                                                        const std::vector<bigfield>& input_remainders)
 {
 
     std::vector<bigfield> remainders(input_remainders);
@@ -1899,7 +1910,7 @@ void bigfield<C, T>::unsafe_evaluate_multiply_add(const bigfield& input_left,
     bigfield to_mul = input_to_mul;
     bigfield quotient = input_quotient;
 
-    C* ctx = left.context ? left.context : to_mul.context;
+    Builder* ctx = left.context ? left.context : to_mul.context;
 
     uint512_t max_b0 = (left.binary_basis_limbs[1].maximum_value * to_mul.binary_basis_limbs[0].maximum_value);
     max_b0 += (neg_modulus_limbs_u256[1] * quotient.binary_basis_limbs[0].maximum_value);
@@ -1947,20 +1958,20 @@ void bigfield<C, T>::unsafe_evaluate_multiply_add(const bigfield& input_left,
         ++max_hi_bits;
     }
 
-    if constexpr (HasPlookup<C>) {
+    if constexpr (HasPlookup<Builder>) {
         // The plookup custom bigfield gate requires inputs are witnesses.
         // If we're using constant values, instantiate them as circuit variables
         const auto convert_constant_to_fixed_witness = [ctx](const bigfield& input) {
             bigfield output(input);
-            output.prime_basis_limb =
-                field_t<C>::from_witness_index(ctx, ctx->put_constant_variable(input.prime_basis_limb.get_value()));
-            output.binary_basis_limbs[0].element = field_t<C>::from_witness_index(
+            output.prime_basis_limb = field_t<Builder>::from_witness_index(
+                ctx, ctx->put_constant_variable(input.prime_basis_limb.get_value()));
+            output.binary_basis_limbs[0].element = field_t<Builder>::from_witness_index(
                 ctx, ctx->put_constant_variable(input.binary_basis_limbs[0].element.get_value()));
-            output.binary_basis_limbs[1].element = field_t<C>::from_witness_index(
+            output.binary_basis_limbs[1].element = field_t<Builder>::from_witness_index(
                 ctx, ctx->put_constant_variable(input.binary_basis_limbs[1].element.get_value()));
-            output.binary_basis_limbs[2].element = field_t<C>::from_witness_index(
+            output.binary_basis_limbs[2].element = field_t<Builder>::from_witness_index(
                 ctx, ctx->put_constant_variable(input.binary_basis_limbs[2].element.get_value()));
-            output.binary_basis_limbs[3].element = field_t<C>::from_witness_index(
+            output.binary_basis_limbs[3].element = field_t<Builder>::from_witness_index(
                 ctx, ctx->put_constant_variable(input.binary_basis_limbs[3].element.get_value()));
             output.context = ctx;
             return output;
@@ -1978,9 +1989,9 @@ void bigfield<C, T>::unsafe_evaluate_multiply_add(const bigfield& input_left,
             remainders[0] = convert_constant_to_fixed_witness(remainders[0]);
         }
 
-        std::vector<field_t<C>> limb_0_accumulator{ remainders[0].binary_basis_limbs[0].element };
-        std::vector<field_t<C>> limb_2_accumulator{ remainders[0].binary_basis_limbs[2].element };
-        std::vector<field_t<C>> prime_limb_accumulator{ remainders[0].prime_basis_limb };
+        std::vector<field_t<Builder>> limb_0_accumulator{ remainders[0].binary_basis_limbs[0].element };
+        std::vector<field_t<Builder>> limb_2_accumulator{ remainders[0].binary_basis_limbs[2].element };
+        std::vector<field_t<Builder>> prime_limb_accumulator{ remainders[0].prime_basis_limb };
         for (size_t i = 1; i < remainders.size(); ++i) {
             limb_0_accumulator.emplace_back(remainders[i].binary_basis_limbs[0].element);
             limb_0_accumulator.emplace_back(remainders[i].binary_basis_limbs[1].element * shift_1);
@@ -2006,15 +2017,15 @@ void bigfield<C, T>::unsafe_evaluate_multiply_add(const bigfield& input_left,
             limb_2_accumulator.emplace_back(remainders[0].binary_basis_limbs[3].element * shift_1);
         }
 
-        field_t<C> remainder_limbs[4]{
-            field_t<C>::accumulate(limb_0_accumulator),
-            needs_normalize ? field_t<C>::from_witness_index(ctx, ctx->zero_idx)
+        field_t<Builder> remainder_limbs[4]{
+            field_t<Builder>::accumulate(limb_0_accumulator),
+            needs_normalize ? field_t<Builder>::from_witness_index(ctx, ctx->zero_idx)
                             : remainders[0].binary_basis_limbs[1].element,
-            field_t<C>::accumulate(limb_2_accumulator),
-            needs_normalize ? field_t<C>::from_witness_index(ctx, ctx->zero_idx)
+            field_t<Builder>::accumulate(limb_2_accumulator),
+            needs_normalize ? field_t<Builder>::from_witness_index(ctx, ctx->zero_idx)
                             : remainders[0].binary_basis_limbs[3].element,
         };
-        field_t<C> remainder_prime_limb = field_t<C>::accumulate(prime_limb_accumulator);
+        field_t<Builder> remainder_prime_limb = field_t<Builder>::accumulate(prime_limb_accumulator);
 
         proof_system::UltraCircuitBuilder::non_native_field_witnesses witnesses{
             {
@@ -2052,13 +2063,13 @@ void bigfield<C, T>::unsafe_evaluate_multiply_add(const bigfield& input_left,
         const auto [lo_idx, hi_idx] = ctx->evaluate_non_native_field_multiplication(witnesses, false);
 
         barretenberg::fr neg_prime = -barretenberg::fr(uint256_t(target_basis.modulus));
-        field_t<C>::evaluate_polynomial_identity(left.prime_basis_limb,
-                                                 to_mul.prime_basis_limb,
-                                                 quotient.prime_basis_limb * neg_prime,
-                                                 -remainder_prime_limb);
+        field_t<Builder>::evaluate_polynomial_identity(left.prime_basis_limb,
+                                                       to_mul.prime_basis_limb,
+                                                       quotient.prime_basis_limb * neg_prime,
+                                                       -remainder_prime_limb);
 
-        field_t lo = field_t<C>::from_witness_index(ctx, lo_idx);
-        field_t hi = field_t<C>::from_witness_index(ctx, hi_idx);
+        field_t lo = field_t<Builder>::from_witness_index(ctx, lo_idx);
+        field_t hi = field_t<Builder>::from_witness_index(ctx, hi_idx);
         const uint64_t carry_lo_msb = max_lo_bits - (2 * NUM_LIMB_BITS);
         const uint64_t carry_hi_msb = max_hi_bits - (2 * NUM_LIMB_BITS);
 
@@ -2134,7 +2145,7 @@ void bigfield<C, T>::unsafe_evaluate_multiply_add(const bigfield& input_left,
         }
         barretenberg::fr neg_prime = -barretenberg::fr(uint256_t(target_basis.modulus));
 
-        field_t<C> linear_terms(ctx, barretenberg::fr(0));
+        field_t<Builder> linear_terms(ctx, barretenberg::fr(0));
         if (to_add.size() >= 2) {
             for (size_t i = 0; i < to_add.size(); i += 2) {
                 linear_terms = linear_terms.add_two(to_add[i].prime_basis_limb, to_add[i + 1].prime_basis_limb);
@@ -2153,22 +2164,22 @@ void bigfield<C, T>::unsafe_evaluate_multiply_add(const bigfield& input_left,
             linear_terms += -remainders[remainders.size() - 1].prime_basis_limb;
         }
         // This is where we show our identity is zero mod r (to use CRT we show it's zero mod r and mod 2^t)
-        field_t<C>::evaluate_polynomial_identity(
+        field_t<Builder>::evaluate_polynomial_identity(
             left.prime_basis_limb, to_mul.prime_basis_limb, quotient.prime_basis_limb * neg_prime, linear_terms);
 
         const uint64_t carry_lo_msb = max_lo_bits - (2 * NUM_LIMB_BITS);
         const uint64_t carry_hi_msb = max_hi_bits - (2 * NUM_LIMB_BITS);
 
         const barretenberg::fr carry_lo_shift(uint256_t(uint256_t(1) << carry_lo_msb));
-        if ((carry_hi_msb + carry_lo_msb) < field_t<C>::modulus.get_msb()) {
+        if ((carry_hi_msb + carry_lo_msb) < field_t<Builder>::modulus.get_msb()) {
             field_t carry_combined = carry_lo + (carry_hi * carry_lo_shift);
             carry_combined = carry_combined.normalize();
             const auto accumulators = ctx->decompose_into_base4_accumulators(
                 carry_combined.witness_index,
                 static_cast<size_t>(carry_lo_msb + carry_hi_msb),
                 "bigfield: carry_combined too large in unsafe_evaluate_multiply_add.");
-            field_t<C> accumulator_midpoint =
-                field_t<C>::from_witness_index(ctx, accumulators[static_cast<size_t>((carry_hi_msb / 2) - 1)]);
+            field_t<Builder> accumulator_midpoint =
+                field_t<Builder>::from_witness_index(ctx, accumulators[static_cast<size_t>((carry_hi_msb / 2) - 1)]);
             carry_hi.assert_equal(accumulator_midpoint, "bigfield multiply range check failed");
         } else {
             carry_lo = carry_lo.normalize();
@@ -2204,12 +2215,12 @@ void bigfield<C, T>::unsafe_evaluate_multiply_add(const bigfield& input_left,
  *
  * THIS METHOD IS UNSAFE TO USE IN CIRCUITS DIRECTLY AS IT LACKS OVERFLOW CHECKS.
  **/
-template <typename C, typename T>
-void bigfield<C, T>::unsafe_evaluate_multiple_multiply_add(const std::vector<bigfield>& input_left,
-                                                           const std::vector<bigfield>& input_right,
-                                                           const std::vector<bigfield>& to_add,
-                                                           const bigfield& input_quotient,
-                                                           const std::vector<bigfield>& input_remainders)
+template <typename Builder, typename T>
+void bigfield<Builder, T>::unsafe_evaluate_multiple_multiply_add(const std::vector<bigfield>& input_left,
+                                                                 const std::vector<bigfield>& input_right,
+                                                                 const std::vector<bigfield>& to_add,
+                                                                 const bigfield& input_quotient,
+                                                                 const std::vector<bigfield>& input_remainders)
 {
 
     std::vector<bigfield> remainders(input_remainders);
@@ -2218,7 +2229,7 @@ void bigfield<C, T>::unsafe_evaluate_multiple_multiply_add(const std::vector<big
     bigfield quotient = input_quotient;
     const size_t num_multiplications = input_left.size();
 
-    C* ctx = input_left[0].context ? input_left[0].context : input_right[0].context;
+    Builder* ctx = input_left[0].context ? input_left[0].context : input_right[0].context;
 
     const auto get_product_maximum = [](const bigfield& left, const bigfield& right) {
         uint512_t max_b0_inner = (left.binary_basis_limbs[1].maximum_value * right.binary_basis_limbs[0].maximum_value);
@@ -2307,21 +2318,21 @@ void bigfield<C, T>::unsafe_evaluate_multiple_multiply_add(const std::vector<big
         ++max_hi_bits;
     }
 
-    if constexpr (HasPlookup<C>) {
+    if constexpr (HasPlookup<Builder>) {
         // The plookup custom bigfield gate requires inputs are witnesses.
         // If we're using constant values, instantiate them as circuit variables
 
         const auto convert_constant_to_fixed_witness = [ctx](const bigfield& input) {
             bigfield output(input);
-            output.prime_basis_limb =
-                field_t<C>::from_witness_index(ctx, ctx->put_constant_variable(input.prime_basis_limb.get_value()));
-            output.binary_basis_limbs[0].element = field_t<C>::from_witness_index(
+            output.prime_basis_limb = field_t<Builder>::from_witness_index(
+                ctx, ctx->put_constant_variable(input.prime_basis_limb.get_value()));
+            output.binary_basis_limbs[0].element = field_t<Builder>::from_witness_index(
                 ctx, ctx->put_constant_variable(input.binary_basis_limbs[0].element.get_value()));
-            output.binary_basis_limbs[1].element = field_t<C>::from_witness_index(
+            output.binary_basis_limbs[1].element = field_t<Builder>::from_witness_index(
                 ctx, ctx->put_constant_variable(input.binary_basis_limbs[1].element.get_value()));
-            output.binary_basis_limbs[2].element = field_t<C>::from_witness_index(
+            output.binary_basis_limbs[2].element = field_t<Builder>::from_witness_index(
                 ctx, ctx->put_constant_variable(input.binary_basis_limbs[2].element.get_value()));
-            output.binary_basis_limbs[3].element = field_t<C>::from_witness_index(
+            output.binary_basis_limbs[3].element = field_t<Builder>::from_witness_index(
                 ctx, ctx->put_constant_variable(input.binary_basis_limbs[3].element.get_value()));
             output.context = ctx;
             return output;
@@ -2337,9 +2348,9 @@ void bigfield<C, T>::unsafe_evaluate_multiple_multiply_add(const std::vector<big
         // `lo`, and `lo_1/2^{136} + hi_1` into `hi`. we can then subtract off `lo_1/2^{136}` from `hi`, by setting
         // `r = [0, 0, lo_1, 0]` This saves us 2 addition gates as we don't have to add together the outputs of two
         // calls to `evaluate_non_native_field_multiplication`
-        std::vector<field_t<C>> limb_0_accumulator;
-        std::vector<field_t<C>> limb_2_accumulator;
-        std::vector<field_t<C>> prime_limb_accumulator;
+        std::vector<field_t<Builder>> limb_0_accumulator;
+        std::vector<field_t<Builder>> limb_2_accumulator;
+        std::vector<field_t<Builder>> prime_limb_accumulator;
 
         for (size_t i = 0; i < num_multiplications; ++i) {
             if (i == 0 && left[0].is_constant()) {
@@ -2391,8 +2402,8 @@ void bigfield<C, T>::unsafe_evaluate_multiple_multiply_add(const std::vector<big
 
                 const auto [lo_2_idx, hi_2_idx] = ctx->queue_partial_non_native_field_multiplication(mul_witnesses);
 
-                field_t<C> lo_2 = field_t<C>::from_witness_index(ctx, lo_2_idx);
-                field_t<C> hi_2 = field_t<C>::from_witness_index(ctx, hi_2_idx);
+                field_t<Builder> lo_2 = field_t<Builder>::from_witness_index(ctx, lo_2_idx);
+                field_t<Builder> hi_2 = field_t<Builder>::from_witness_index(ctx, hi_2_idx);
 
                 limb_0_accumulator.emplace_back(-lo_2);
                 limb_2_accumulator.emplace_back(-hi_2);
@@ -2424,33 +2435,33 @@ void bigfield<C, T>::unsafe_evaluate_multiple_multiply_add(const std::vector<big
             prime_limb_accumulator.emplace_back(-add.prime_basis_limb);
         }
 
-        field_t<C> accumulated_lo = field_t<C>::accumulate(limb_0_accumulator);
-        field_t<C> accumulated_hi = field_t<C>::accumulate(limb_2_accumulator);
+        field_t<Builder> accumulated_lo = field_t<Builder>::accumulate(limb_0_accumulator);
+        field_t<Builder> accumulated_hi = field_t<Builder>::accumulate(limb_2_accumulator);
         if (accumulated_lo.is_constant()) {
             accumulated_lo =
-                field_t<C>::from_witness_index(ctx, ctx->put_constant_variable(accumulated_lo.get_value()));
+                field_t<Builder>::from_witness_index(ctx, ctx->put_constant_variable(accumulated_lo.get_value()));
         }
         if (accumulated_hi.is_constant()) {
             accumulated_hi =
-                field_t<C>::from_witness_index(ctx, ctx->put_constant_variable(accumulated_hi.get_value()));
+                field_t<Builder>::from_witness_index(ctx, ctx->put_constant_variable(accumulated_hi.get_value()));
         }
-        field_t<C> remainder1 = no_remainders ? field_t<C>::from_witness_index(ctx, ctx->zero_idx)
-                                              : remainders[0].binary_basis_limbs[1].element;
+        field_t<Builder> remainder1 = no_remainders ? field_t<Builder>::from_witness_index(ctx, ctx->zero_idx)
+                                                    : remainders[0].binary_basis_limbs[1].element;
         if (remainder1.is_constant()) {
-            remainder1 = field_t<C>::from_witness_index(ctx, ctx->put_constant_variable(remainder1.get_value()));
+            remainder1 = field_t<Builder>::from_witness_index(ctx, ctx->put_constant_variable(remainder1.get_value()));
         }
-        field_t<C> remainder3 = no_remainders ? field_t<C>::from_witness_index(ctx, ctx->zero_idx)
-                                              : remainders[0].binary_basis_limbs[3].element;
+        field_t<Builder> remainder3 = no_remainders ? field_t<Builder>::from_witness_index(ctx, ctx->zero_idx)
+                                                    : remainders[0].binary_basis_limbs[3].element;
         if (remainder3.is_constant()) {
-            remainder3 = field_t<C>::from_witness_index(ctx, ctx->put_constant_variable(remainder3.get_value()));
+            remainder3 = field_t<Builder>::from_witness_index(ctx, ctx->put_constant_variable(remainder3.get_value()));
         }
-        field_t<C> remainder_limbs[4]{
+        field_t<Builder> remainder_limbs[4]{
             accumulated_lo,
             remainder1,
             accumulated_hi,
             remainder3,
         };
-        field_t<C> remainder_prime_limb = field_t<C>::accumulate(prime_limb_accumulator);
+        field_t<Builder> remainder_prime_limb = field_t<Builder>::accumulate(prime_limb_accumulator);
 
         proof_system::UltraCircuitBuilder::non_native_field_witnesses witnesses{
             {
@@ -2489,13 +2500,13 @@ void bigfield<C, T>::unsafe_evaluate_multiple_multiply_add(const std::vector<big
 
         barretenberg::fr neg_prime = -barretenberg::fr(uint256_t(target_basis.modulus));
 
-        field_t<C>::evaluate_polynomial_identity(left[0].prime_basis_limb,
-                                                 right[0].prime_basis_limb,
-                                                 quotient.prime_basis_limb * neg_prime,
-                                                 -remainder_prime_limb);
+        field_t<Builder>::evaluate_polynomial_identity(left[0].prime_basis_limb,
+                                                       right[0].prime_basis_limb,
+                                                       quotient.prime_basis_limb * neg_prime,
+                                                       -remainder_prime_limb);
 
-        field_t lo = field_t<C>::from_witness_index(ctx, lo_1_idx);
-        field_t hi = field_t<C>::from_witness_index(ctx, hi_1_idx);
+        field_t lo = field_t<Builder>::from_witness_index(ctx, lo_1_idx);
+        field_t hi = field_t<Builder>::from_witness_index(ctx, hi_1_idx);
 
         const uint64_t carry_lo_msb = max_lo_bits - (2 * NUM_LIMB_BITS);
         const uint64_t carry_hi_msb = max_hi_bits - (2 * NUM_LIMB_BITS);
@@ -2510,7 +2521,7 @@ void bigfield<C, T>::unsafe_evaluate_multiple_multiply_add(const std::vector<big
             ctx->decompose_into_default_range(lo.normalize().witness_index, carry_lo_msb);
         }
         /*  NOTE TO AUDITOR: An extraneous block
-               if constexpr (HasPlookup<C>) {
+               if constexpr (HasPlookup<Builder>) {
                    carry_lo = carry_lo.normalize();
                    carry_hi = carry_hi.normalize();
                    ctx->decompose_into_default_range(carry_lo.witness_index, static_cast<size_t>(carry_lo_msb));
@@ -2552,9 +2563,9 @@ void bigfield<C, T>::unsafe_evaluate_multiple_multiply_add(const std::vector<big
          *TurboPlonk gate.
          **/
 
-        std::vector<field_t<C>> limb_0_accumulator;
-        std::vector<field_t<C>> limb_2_accumulator;
-        std::vector<field_t<C>> prime_limb_accumulator;
+        std::vector<field_t<Builder>> limb_0_accumulator;
+        std::vector<field_t<Builder>> limb_2_accumulator;
+        std::vector<field_t<Builder>> prime_limb_accumulator;
 
         // Add remaining products into the limb accumulators.
         // We negate the product values because the accumulator values itself will be negated
@@ -2606,33 +2617,33 @@ void bigfield<C, T>::unsafe_evaluate_multiple_multiply_add(const std::vector<big
             prime_limb_accumulator.emplace_back(-add.prime_basis_limb);
         }
 
-        field_t<C> accumulated_lo = field_t<C>::accumulate(limb_0_accumulator);
-        field_t<C> accumulated_hi = field_t<C>::accumulate(limb_2_accumulator);
+        field_t<Builder> accumulated_lo = field_t<Builder>::accumulate(limb_0_accumulator);
+        field_t<Builder> accumulated_hi = field_t<Builder>::accumulate(limb_2_accumulator);
         if (accumulated_lo.is_constant()) {
             accumulated_lo =
-                field_t<C>::from_witness_index(ctx, ctx->put_constant_variable(accumulated_lo.get_value()));
+                field_t<Builder>::from_witness_index(ctx, ctx->put_constant_variable(accumulated_lo.get_value()));
         }
         if (accumulated_hi.is_constant()) {
             accumulated_hi =
-                field_t<C>::from_witness_index(ctx, ctx->put_constant_variable(accumulated_hi.get_value()));
+                field_t<Builder>::from_witness_index(ctx, ctx->put_constant_variable(accumulated_hi.get_value()));
         }
-        field_t<C> remainder1 = no_remainders ? field_t<C>::from_witness_index(ctx, ctx->zero_idx)
-                                              : remainders[0].binary_basis_limbs[1].element;
+        field_t<Builder> remainder1 = no_remainders ? field_t<Builder>::from_witness_index(ctx, ctx->zero_idx)
+                                                    : remainders[0].binary_basis_limbs[1].element;
         if (remainder1.is_constant()) {
-            remainder1 = field_t<C>::from_witness_index(ctx, ctx->put_constant_variable(remainder1.get_value()));
+            remainder1 = field_t<Builder>::from_witness_index(ctx, ctx->put_constant_variable(remainder1.get_value()));
         }
-        field_t<C> remainder3 = no_remainders ? field_t<C>::from_witness_index(ctx, ctx->zero_idx)
-                                              : remainders[0].binary_basis_limbs[3].element;
+        field_t<Builder> remainder3 = no_remainders ? field_t<Builder>::from_witness_index(ctx, ctx->zero_idx)
+                                                    : remainders[0].binary_basis_limbs[3].element;
         if (remainder3.is_constant()) {
-            remainder3 = field_t<C>::from_witness_index(ctx, ctx->put_constant_variable(remainder3.get_value()));
+            remainder3 = field_t<Builder>::from_witness_index(ctx, ctx->put_constant_variable(remainder3.get_value()));
         }
-        field_t<C> remainder_limbs[4]{
+        field_t<Builder> remainder_limbs[4]{
             accumulated_lo,
             remainder1,
             accumulated_hi,
             remainder3,
         };
-        field_t<C> remainder_prime_limb = field_t<C>::accumulate(prime_limb_accumulator);
+        field_t<Builder> remainder_prime_limb = field_t<Builder>::accumulate(prime_limb_accumulator);
 
         // We wish to show that left*right - quotient*remainder = 0 mod 2^t, we do this by collecting the limb
         // products into two separate variables - carry_lo and carry_hi, which are still small enough not to wrap
@@ -2660,12 +2671,12 @@ void bigfield<C, T>::unsafe_evaluate_multiple_multiply_add(const std::vector<big
 
         barretenberg::fr neg_prime = -barretenberg::fr(uint256_t(target_basis.modulus));
 
-        field_t<C> linear_terms(ctx, barretenberg::fr(0));
+        field_t<Builder> linear_terms(ctx, barretenberg::fr(0));
 
         linear_terms += -remainder_prime_limb;
 
         // This is where we show our identity is zero mod r (to use CRT we show it's zero mod r and mod 2^t)
-        field_t<C>::evaluate_polynomial_identity(
+        field_t<Builder>::evaluate_polynomial_identity(
             left[0].prime_basis_limb, right[0].prime_basis_limb, quotient.prime_basis_limb * neg_prime, linear_terms);
 
         const uint64_t carry_lo_msb = max_lo_bits - (2 * NUM_LIMB_BITS);
@@ -2673,22 +2684,22 @@ void bigfield<C, T>::unsafe_evaluate_multiple_multiply_add(const std::vector<big
 
         const barretenberg::fr carry_lo_shift(uint256_t(uint256_t(1) << carry_lo_msb));
 
-        if constexpr (HasPlookup<C>) {
+        if constexpr (HasPlookup<Builder>) {
             carry_lo = carry_lo.normalize();
             carry_hi = carry_hi.normalize();
             ctx->decompose_into_default_range(carry_lo.witness_index, static_cast<size_t>(carry_lo_msb));
             ctx->decompose_into_default_range(carry_hi.witness_index, static_cast<size_t>(carry_hi_msb));
 
         } else {
-            if ((carry_hi_msb + carry_lo_msb) < field_t<C>::modulus.get_msb()) {
+            if ((carry_hi_msb + carry_lo_msb) < field_t<Builder>::modulus.get_msb()) {
                 field_t carry_combined = carry_lo + (carry_hi * carry_lo_shift);
                 carry_combined = carry_combined.normalize();
                 const auto accumulators = ctx->decompose_into_base4_accumulators(
                     carry_combined.witness_index,
                     static_cast<size_t>(carry_lo_msb + carry_hi_msb),
                     "bigfield: carry_combined too large in unsafe_evaluate_multiple_multiply_add.");
-                field_t<C> accumulator_midpoint =
-                    field_t<C>::from_witness_index(ctx, accumulators[static_cast<size_t>((carry_hi_msb / 2) - 1)]);
+                field_t<Builder> accumulator_midpoint = field_t<Builder>::from_witness_index(
+                    ctx, accumulators[static_cast<size_t>((carry_hi_msb / 2) - 1)]);
                 carry_hi.assert_equal(accumulator_midpoint, "bigfield multiply range check failed");
             } else {
                 carry_lo = carry_lo.normalize();
@@ -2706,17 +2717,17 @@ void bigfield<C, T>::unsafe_evaluate_multiple_multiply_add(const std::vector<big
     }
 }
 
-template <typename C, typename T>
-void bigfield<C, T>::unsafe_evaluate_square_add(const bigfield& left,
-                                                const std::vector<bigfield>& to_add,
-                                                const bigfield& quotient,
-                                                const bigfield& remainder)
+template <typename Builder, typename T>
+void bigfield<Builder, T>::unsafe_evaluate_square_add(const bigfield& left,
+                                                      const std::vector<bigfield>& to_add,
+                                                      const bigfield& quotient,
+                                                      const bigfield& remainder)
 {
-    if (HasPlookup<C>) {
+    if (HasPlookup<Builder>) {
         unsafe_evaluate_multiply_add(left, left, to_add, quotient, { remainder });
         return;
     }
-    C* ctx = left.context == nullptr ? quotient.context : left.context;
+    Builder* ctx = left.context == nullptr ? quotient.context : left.context;
 
     uint512_t max_b0 = (left.binary_basis_limbs[1].maximum_value * left.binary_basis_limbs[0].maximum_value);
     max_b0 += (neg_modulus_limbs_u256[1] << NUM_LIMB_BITS);
@@ -2817,7 +2828,7 @@ void bigfield<C, T>::unsafe_evaluate_square_add(const bigfield& left,
     }
 
     barretenberg::fr neg_prime = -barretenberg::fr(uint256_t(target_basis.modulus));
-    field_t<C> linear_terms = -remainder.prime_basis_limb;
+    field_t<Builder> linear_terms = -remainder.prime_basis_limb;
     if (to_add.size() >= 2) {
         for (size_t i = 0; i < to_add.size() / 2; i += 1) {
             linear_terms = linear_terms.add_two(to_add[2 * i].prime_basis_limb, to_add[2 * i + 1].prime_basis_limb);
@@ -2826,29 +2837,29 @@ void bigfield<C, T>::unsafe_evaluate_square_add(const bigfield& left,
     if ((to_add.size() & 1UL) == 1UL) {
         linear_terms += to_add[to_add.size() - 1].prime_basis_limb;
     }
-    field_t<C>::evaluate_polynomial_identity(
+    field_t<Builder>::evaluate_polynomial_identity(
         left.prime_basis_limb, left.prime_basis_limb, quotient.prime_basis_limb * neg_prime, linear_terms);
 
     const uint64_t carry_lo_msb = max_lo_bits - (2 * NUM_LIMB_BITS);
     const uint64_t carry_hi_msb = max_hi_bits - (2 * NUM_LIMB_BITS);
 
     const barretenberg::fr carry_lo_shift(uint256_t(uint256_t(1) << carry_lo_msb));
-    if constexpr (HasPlookup<C>) {
+    if constexpr (HasPlookup<Builder>) {
         carry_lo = carry_lo.normalize();
         carry_hi = carry_hi.normalize();
         ctx->decompose_into_default_range(carry_lo.witness_index, static_cast<size_t>(carry_lo_msb));
         ctx->decompose_into_default_range(carry_hi.witness_index, static_cast<size_t>(carry_hi_msb));
 
     } else {
-        if ((carry_hi_msb + carry_lo_msb) < field_t<C>::modulus.get_msb()) {
+        if ((carry_hi_msb + carry_lo_msb) < field_t<Builder>::modulus.get_msb()) {
             field_t carry_combined = carry_lo + (carry_hi * carry_lo_shift);
             carry_combined = carry_combined.normalize();
             const auto accumulators = ctx->decompose_into_base4_accumulators(
                 carry_combined.witness_index,
                 static_cast<size_t>(carry_lo_msb + carry_hi_msb),
                 "bigfield: carry_combined too large in unsafe_evaluate_square_add.");
-            field_t<C> accumulator_midpoint =
-                field_t<C>::from_witness_index(ctx, accumulators[static_cast<size_t>((carry_hi_msb / 2) - 1)]);
+            field_t<Builder> accumulator_midpoint =
+                field_t<Builder>::from_witness_index(ctx, accumulators[static_cast<size_t>((carry_hi_msb / 2) - 1)]);
             carry_hi.assert_equal(accumulator_midpoint, "bigfield multiply range check failed");
         } else {
             carry_lo = carry_lo.normalize();
@@ -2863,10 +2874,9 @@ void bigfield<C, T>::unsafe_evaluate_square_add(const bigfield& left,
     }
 }
 
-template <typename C, typename T>
-std::pair<uint512_t, uint512_t> bigfield<C, T>::compute_quotient_remainder_values(const bigfield& a,
-                                                                                  const bigfield& b,
-                                                                                  const std::vector<bigfield>& to_add)
+template <typename Builder, typename T>
+std::pair<uint512_t, uint512_t> bigfield<Builder, T>::compute_quotient_remainder_values(
+    const bigfield& a, const bigfield& b, const std::vector<bigfield>& to_add)
 {
     uint512_t add_values(0);
     for (const auto& add_element : to_add) {
@@ -2884,10 +2894,10 @@ std::pair<uint512_t, uint512_t> bigfield<C, T>::compute_quotient_remainder_value
     return { quotient_1024.lo, remainder_1024.lo };
 }
 
-template <typename C, typename T>
-uint512_t bigfield<C, T>::compute_maximum_quotient_value(const std::vector<uint512_t>& as,
-                                                         const std::vector<uint512_t>& bs,
-                                                         const std::vector<uint512_t>& to_add)
+template <typename Builder, typename T>
+uint512_t bigfield<Builder, T>::compute_maximum_quotient_value(const std::vector<uint512_t>& as,
+                                                               const std::vector<uint512_t>& bs,
+                                                               const std::vector<uint512_t>& to_add)
 {
     ASSERT(as.size() == bs.size());
     uint512_t add_values(0);
@@ -2905,11 +2915,11 @@ uint512_t bigfield<C, T>::compute_maximum_quotient_value(const std::vector<uint5
 
     return quotient_1024.lo;
 }
-template <typename C, typename T>
-std::pair<bool, size_t> bigfield<C, T>::get_quotient_reduction_info(const std::vector<uint512_t>& as_max,
-                                                                    const std::vector<uint512_t>& bs_max,
-                                                                    const std::vector<bigfield>& to_add,
-                                                                    const std::vector<uint1024_t>& remainders_max)
+template <typename Builder, typename T>
+std::pair<bool, size_t> bigfield<Builder, T>::get_quotient_reduction_info(const std::vector<uint512_t>& as_max,
+                                                                          const std::vector<uint512_t>& bs_max,
+                                                                          const std::vector<bigfield>& to_add,
+                                                                          const std::vector<uint1024_t>& remainders_max)
 {
     ASSERT(as_max.size() == bs_max.size());
     // Check if the product sum can overflow CRT modulus
diff --git a/barretenberg/cpp/src/barretenberg/stdlib/primitives/biggroup/biggroup.hpp b/barretenberg/cpp/src/barretenberg/stdlib/primitives/biggroup/biggroup.hpp
index ce2f64f9fee..65823a98302 100644
--- a/barretenberg/cpp/src/barretenberg/stdlib/primitives/biggroup/biggroup.hpp
+++ b/barretenberg/cpp/src/barretenberg/stdlib/primitives/biggroup/biggroup.hpp
@@ -16,13 +16,13 @@ namespace proof_system::plonk {
 namespace stdlib {
 
 // ( ͡° ͜ʖ ͡°)
-template <class Composer, class Fq, class Fr, class NativeGroup> class element {
+template <class Builder, class Fq, class Fr, class NativeGroup> class element {
   public:
     struct secp256k1_wnaf {
-        std::vector<field_t<Composer>> wnaf;
-        field_t<Composer> positive_skew;
-        field_t<Composer> negative_skew;
-        field_t<Composer> least_significant_wnaf_fragment;
+        std::vector<field_t<Builder>> wnaf;
+        field_t<Builder> positive_skew;
+        field_t<Builder> negative_skew;
+        field_t<Builder> least_significant_wnaf_fragment;
         bool has_wnaf_fragment = false;
     };
     struct secp256k1_wnaf_pair {
@@ -37,7 +37,7 @@ template <class Composer, class Fq, class Fr, class NativeGroup> class element {
     element(const element& other);
     element(element&& other);
 
-    static element from_witness(Composer* ctx, const typename NativeGroup::affine_element& input)
+    static element from_witness(Builder* ctx, const typename NativeGroup::affine_element& input)
     {
         Fq x = Fq::from_witness(ctx, input.x);
         Fq y = Fq::from_witness(ctx, input.y);
@@ -59,7 +59,7 @@ template <class Composer, class Fq, class Fr, class NativeGroup> class element {
         }
     }
 
-    static element one(Composer* ctx)
+    static element one(Builder* ctx)
     {
         uint256_t x = uint256_t(NativeGroup::one.x);
         uint256_t y = uint256_t(NativeGroup::one.y);
@@ -71,9 +71,9 @@ template <class Composer, class Fq, class Fr, class NativeGroup> class element {
     element& operator=(const element& other);
     element& operator=(element&& other);
 
-    byte_array<Composer> to_byte_array() const
+    byte_array<Builder> to_byte_array() const
     {
-        byte_array<Composer> result(get_context());
+        byte_array<Builder> result(get_context());
         result.write(y.to_byte_array());
         result.write(x.to_byte_array());
         return result;
@@ -101,7 +101,7 @@ template <class Composer, class Fq, class Fr, class NativeGroup> class element {
 
     element operator*(const Fr& other) const;
 
-    element conditional_negate(const bool_t<Composer>& predicate) const
+    element conditional_negate(const bool_t<Builder>& predicate) const
     {
         element result(*this);
         result.y = result.y.conditional_negate(predicate);
@@ -213,15 +213,15 @@ template <class Composer, class Fq, class Fr, class NativeGroup> class element {
     template <typename X = NativeGroup, typename = typename std::enable_if_t<std::is_same<X, secp256k1::g1>::value>>
     static element secp256k1_ecdsa_mul(const element& pubkey, const Fr& u1, const Fr& u2);
 
-    static std::vector<bool_t<Composer>> compute_naf(const Fr& scalar, const size_t max_num_bits = 0);
+    static std::vector<bool_t<Builder>> compute_naf(const Fr& scalar, const size_t max_num_bits = 0);
 
     template <size_t max_num_bits = 0, size_t WNAF_SIZE = 4>
-    static std::vector<field_t<Composer>> compute_wnaf(const Fr& scalar);
+    static std::vector<field_t<Builder>> compute_wnaf(const Fr& scalar);
 
     template <size_t wnaf_size, size_t staggered_lo_offset = 0, size_t staggered_hi_offset = 0>
     static secp256k1_wnaf_pair compute_secp256k1_endo_wnaf(const Fr& scalar);
 
-    Composer* get_context() const
+    Builder* get_context() const
     {
         if (x.context != nullptr) {
             return x.context;
@@ -232,7 +232,7 @@ template <class Composer, class Fq, class Fr, class NativeGroup> class element {
         return nullptr;
     }
 
-    Composer* get_context(const element& other) const
+    Builder* get_context(const element& other) const
     {
         if (x.context != nullptr) {
             return x.context;
@@ -253,32 +253,32 @@ template <class Composer, class Fq, class Fr, class NativeGroup> class element {
     Fq y;
 
   private:
-    template <size_t num_elements, typename = typename std::enable_if<HasPlookup<Composer>>>
-    static std::array<twin_rom_table<Composer>, 5> create_group_element_rom_tables(
+    template <size_t num_elements, typename = typename std::enable_if<HasPlookup<Builder>>>
+    static std::array<twin_rom_table<Builder>, 5> create_group_element_rom_tables(
         const std::array<element, num_elements>& elements, std::array<uint256_t, 8>& limb_max);
 
-    template <size_t num_elements, typename = typename std::enable_if<HasPlookup<Composer>>>
-    static element read_group_element_rom_tables(const std::array<twin_rom_table<Composer>, 5>& tables,
-                                                 const field_t<Composer>& index,
+    template <size_t num_elements, typename = typename std::enable_if<HasPlookup<Builder>>>
+    static element read_group_element_rom_tables(const std::array<twin_rom_table<Builder>, 5>& tables,
+                                                 const field_t<Builder>& index,
                                                  const std::array<uint256_t, 8>& limb_max);
 
     static std::pair<element, element> compute_offset_generators(const size_t num_rounds);
 
-    template <typename = typename std::enable_if<HasPlookup<Composer>>> struct four_bit_table_plookup {
+    template <typename = typename std::enable_if<HasPlookup<Builder>>> struct four_bit_table_plookup {
         four_bit_table_plookup(){};
         four_bit_table_plookup(const element& input);
 
         four_bit_table_plookup(const four_bit_table_plookup& other) = default;
         four_bit_table_plookup& operator=(const four_bit_table_plookup& other) = default;
 
-        element operator[](const field_t<Composer>& index) const;
+        element operator[](const field_t<Builder>& index) const;
         element operator[](const size_t idx) const { return element_table[idx]; }
         std::array<element, 16> element_table;
-        std::array<twin_rom_table<Composer>, 5> coordinates;
+        std::array<twin_rom_table<Builder>, 5> coordinates;
         std::array<uint256_t, 8> limb_max; // tracks the maximum limb size represented in each element_table entry
     };
 
-    template <typename = typename std::enable_if<HasPlookup<Composer>>> struct eight_bit_fixed_base_table {
+    template <typename = typename std::enable_if<HasPlookup<Builder>>> struct eight_bit_fixed_base_table {
         enum CurveType { BN254, SECP256K1, SECP256R1 };
         eight_bit_fixed_base_table(const CurveType input_curve_type, bool use_endo)
             : curve_type(input_curve_type)
@@ -287,7 +287,7 @@ template <class Composer, class Fq, class Fr, class NativeGroup> class element {
         eight_bit_fixed_base_table(const eight_bit_fixed_base_table& other) = default;
         eight_bit_fixed_base_table& operator=(const eight_bit_fixed_base_table& other) = default;
 
-        element operator[](const field_t<Composer>& index) const;
+        element operator[](const field_t<Builder>& index) const;
 
         element operator[](const size_t idx) const;
 
@@ -295,7 +295,7 @@ template <class Composer, class Fq, class Fr, class NativeGroup> class element {
         bool use_endomorphism;
     };
 
-    template <typename = typename std::enable_if<HasPlookup<Composer>>>
+    template <typename = typename std::enable_if<HasPlookup<Builder>>>
     static std::pair<four_bit_table_plookup<>, four_bit_table_plookup<>> create_endo_pair_four_bit_table_plookup(
         const element& input)
     {
@@ -351,19 +351,19 @@ template <class Composer, class Fq, class Fr, class NativeGroup> class element {
         lookup_table_base(const lookup_table_base& other) = default;
         lookup_table_base& operator=(const lookup_table_base& other) = default;
 
-        element get(const std::array<bool_t<Composer>, length>& bits) const;
+        element get(const std::array<bool_t<Builder>, length>& bits) const;
 
         element operator[](const size_t idx) const { return element_table[idx]; }
 
-        std::array<field_t<Composer>, table_size> x_b0_table;
-        std::array<field_t<Composer>, table_size> x_b1_table;
-        std::array<field_t<Composer>, table_size> x_b2_table;
-        std::array<field_t<Composer>, table_size> x_b3_table;
+        std::array<field_t<Builder>, table_size> x_b0_table;
+        std::array<field_t<Builder>, table_size> x_b1_table;
+        std::array<field_t<Builder>, table_size> x_b2_table;
+        std::array<field_t<Builder>, table_size> x_b3_table;
 
-        std::array<field_t<Composer>, table_size> y_b0_table;
-        std::array<field_t<Composer>, table_size> y_b1_table;
-        std::array<field_t<Composer>, table_size> y_b2_table;
-        std::array<field_t<Composer>, table_size> y_b3_table;
+        std::array<field_t<Builder>, table_size> y_b0_table;
+        std::array<field_t<Builder>, table_size> y_b1_table;
+        std::array<field_t<Builder>, table_size> y_b2_table;
+        std::array<field_t<Builder>, table_size> y_b3_table;
         element twin0;
         element twin1;
         std::array<element, table_size> element_table;
@@ -374,30 +374,30 @@ template <class Composer, class Fq, class Fr, class NativeGroup> class element {
      *
      * Uses ROM tables to efficiently access lookup table
      **/
-    template <size_t length, typename = typename std::enable_if<HasPlookup<Composer>>> struct lookup_table_plookup {
+    template <size_t length, typename = typename std::enable_if<HasPlookup<Builder>>> struct lookup_table_plookup {
         static constexpr size_t table_size = (1ULL << (length));
         lookup_table_plookup() {}
         lookup_table_plookup(const std::array<element, length>& inputs);
         lookup_table_plookup(const lookup_table_plookup& other) = default;
         lookup_table_plookup& operator=(const lookup_table_plookup& other) = default;
 
-        element get(const std::array<bool_t<Composer>, length>& bits) const;
+        element get(const std::array<bool_t<Builder>, length>& bits) const;
 
         element operator[](const size_t idx) const { return element_table[idx]; }
 
         std::array<element, table_size> element_table;
-        std::array<twin_rom_table<Composer>, 5> coordinates;
+        std::array<twin_rom_table<Builder>, 5> coordinates;
         std::array<uint256_t, 8> limb_max;
     };
 
     using twin_lookup_table =
-        typename std::conditional<HasPlookup<Composer>, lookup_table_plookup<2, void>, lookup_table_base<2>>::type;
+        typename std::conditional<HasPlookup<Builder>, lookup_table_plookup<2, void>, lookup_table_base<2>>::type;
 
     using triple_lookup_table =
-        typename std::conditional<HasPlookup<Composer>, lookup_table_plookup<3, void>, lookup_table_base<3>>::type;
+        typename std::conditional<HasPlookup<Builder>, lookup_table_plookup<3, void>, lookup_table_base<3>>::type;
 
     using quad_lookup_table =
-        typename std::conditional<HasPlookup<Composer>, lookup_table_plookup<4, void>, lookup_table_base<4>>::type;
+        typename std::conditional<HasPlookup<Builder>, lookup_table_plookup<4, void>, lookup_table_base<4>>::type;
 
     /**
      * Creates a pair of 4-bit lookup tables, the former corresponding to 4 input points,
@@ -410,7 +410,7 @@ template <class Composer, class Fq, class Fr, class NativeGroup> class element {
         quad_lookup_table endo_table;
         uint256_t beta_val = barretenberg::field<typename Fq::TParams>::cube_root_of_unity();
         Fq beta(barretenberg::fr(beta_val.slice(0, 136)), barretenberg::fr(beta_val.slice(136, 256)), false);
-        if constexpr (HasPlookup<Composer>) {
+        if constexpr (HasPlookup<Builder>) {
             for (size_t i = 0; i < 8; ++i) {
                 endo_table.element_table[i + 8].x = base_table[7 - i].x * beta;
                 endo_table.element_table[i + 8].y = base_table[7 - i].y;
@@ -435,7 +435,7 @@ template <class Composer, class Fq, class Fr, class NativeGroup> class element {
      * Creates a pair of 5-bit lookup tables, the former corresponding to 5 input points,
      * the latter corresponding to the endomorphism equivalent of the 5 input points (e.g. x -> \beta * x, y -> -y)
      **/
-    template <typename X = typename std::enable_if<HasPlookup<Composer>>>
+    template <typename X = typename std::enable_if<HasPlookup<Builder>>>
     static std::pair<lookup_table_plookup<5, X>, lookup_table_plookup<5, X>> create_endo_pair_five_lookup_table(
         const std::array<element, 5>& inputs)
     {
@@ -443,7 +443,7 @@ template <class Composer, class Fq, class Fr, class NativeGroup> class element {
         lookup_table_plookup<5> endo_table;
         uint256_t beta_val = barretenberg::field<typename Fq::TParams>::cube_root_of_unity();
         Fq beta(barretenberg::fr(beta_val.slice(0, 136)), barretenberg::fr(beta_val.slice(136, 256)), false);
-        if constexpr (HasPlookup<Composer>) {
+        if constexpr (HasPlookup<Builder>) {
             for (size_t i = 0; i < 16; ++i) {
                 endo_table.element_table[i + 16].x = base_table[15 - i].x * beta;
                 endo_table.element_table[i + 16].y = base_table[15 - i].y;
@@ -462,7 +462,7 @@ template <class Composer, class Fq, class Fr, class NativeGroup> class element {
      *
      * UltraPlonk version
      **/
-    template <typename X = typename std::enable_if<HasPlookup<Composer>>> struct batch_lookup_table_plookup {
+    template <typename X = typename std::enable_if<HasPlookup<Builder>>> struct batch_lookup_table_plookup {
         batch_lookup_table_plookup(const std::vector<element>& points)
         {
             num_points = points.size();
@@ -592,7 +592,7 @@ template <class Composer, class Fq, class Fr, class NativeGroup> class element {
             return chain_add_accumulator(add_accumulator[0]);
         }
 
-        element::chain_add_accumulator get_chain_add_accumulator(std::vector<bool_t<Composer>>& naf_entries) const
+        element::chain_add_accumulator get_chain_add_accumulator(std::vector<bool_t<Builder>>& naf_entries) const
         {
             std::vector<element> round_accumulator;
             for (size_t j = 0; j < num_sixes; ++j) {
@@ -644,7 +644,7 @@ template <class Composer, class Fq, class Fr, class NativeGroup> class element {
             return (accumulator);
         }
 
-        element get(std::vector<bool_t<Composer>>& naf_entries) const
+        element get(std::vector<bool_t<Builder>>& naf_entries) const
         {
             std::vector<element> round_accumulator;
             for (size_t j = 0; j < num_sixes; ++j) {
@@ -797,21 +797,21 @@ template <class Composer, class Fq, class Fr, class NativeGroup> class element {
             return chain_add_accumulator(add_accumulator[0]);
         }
 
-        element::chain_add_accumulator get_chain_add_accumulator(std::vector<bool_t<Composer>>& naf_entries) const
+        element::chain_add_accumulator get_chain_add_accumulator(std::vector<bool_t<Builder>>& naf_entries) const
         {
             std::vector<element> round_accumulator;
             for (size_t j = 0; j < num_quads; ++j) {
-                round_accumulator.push_back(quad_tables[j].get(std::array<bool_t<Composer>, 4>{
+                round_accumulator.push_back(quad_tables[j].get(std::array<bool_t<Builder>, 4>{
                     naf_entries[4 * j], naf_entries[4 * j + 1], naf_entries[4 * j + 2], naf_entries[4 * j + 3] }));
             }
 
             if (has_triple) {
-                round_accumulator.push_back(triple_tables[0].get(std::array<bool_t<Composer>, 3>{
+                round_accumulator.push_back(triple_tables[0].get(std::array<bool_t<Builder>, 3>{
                     naf_entries[num_quads * 4], naf_entries[num_quads * 4 + 1], naf_entries[num_quads * 4 + 2] }));
             }
             if (has_twin) {
                 round_accumulator.push_back(twin_tables[0].get(
-                    std::array<bool_t<Composer>, 2>{ naf_entries[num_quads * 4], naf_entries[num_quads * 4 + 1] }));
+                    std::array<bool_t<Builder>, 2>{ naf_entries[num_quads * 4], naf_entries[num_quads * 4 + 1] }));
             }
             if (has_singleton) {
                 round_accumulator.push_back(singletons[0].conditional_negate(naf_entries[num_points - 1]));
@@ -834,7 +834,7 @@ template <class Composer, class Fq, class Fr, class NativeGroup> class element {
             return (accumulator);
         }
 
-        element get(std::vector<bool_t<Composer>>& naf_entries) const
+        element get(std::vector<bool_t<Builder>>& naf_entries) const
         {
             std::vector<element> round_accumulator;
             for (size_t j = 0; j < num_quads; ++j) {
@@ -843,7 +843,7 @@ template <class Composer, class Fq, class Fr, class NativeGroup> class element {
             }
 
             if (has_triple) {
-                round_accumulator.push_back(triple_tables[0].get(std::array<bool_t<Composer>, 3>{
+                round_accumulator.push_back(triple_tables[0].get(std::array<bool_t<Builder>, 3>{
                     naf_entries[num_quads * 4], naf_entries[num_quads * 4 + 1], naf_entries[num_quads * 4 + 2] }));
             }
             if (has_twin) {
@@ -882,7 +882,7 @@ template <class Composer, class Fq, class Fr, class NativeGroup> class element {
     };
 
     using batch_lookup_table =
-        typename std::conditional<HasPlookup<Composer>, batch_lookup_table_plookup<>, batch_lookup_table_base>::type;
+        typename std::conditional<HasPlookup<Builder>, batch_lookup_table_plookup<>, batch_lookup_table_base>::type;
 };
 
 template <typename C, typename Fq, typename Fr, typename G>
diff --git a/barretenberg/cpp/src/barretenberg/stdlib/primitives/biggroup/biggroup.test.cpp b/barretenberg/cpp/src/barretenberg/stdlib/primitives/biggroup/biggroup.test.cpp
index 5ca3bbad35e..0eb8bcbf09b 100644
--- a/barretenberg/cpp/src/barretenberg/stdlib/primitives/biggroup/biggroup.test.cpp
+++ b/barretenberg/cpp/src/barretenberg/stdlib/primitives/biggroup/biggroup.test.cpp
@@ -45,31 +45,31 @@ template <typename TestType> class stdlib_biggroup : public testing::Test {
     using affine_element = typename g1::affine_element;
     using element = typename g1::element;
 
-    using Composer = typename Curve::Composer;
+    using Builder = typename Curve::Builder;
 
-    static constexpr auto EXPECT_CIRCUIT_CORRECTNESS = [](Composer& composer, bool expected_result = true) {
-        info("composer gates = ", composer.get_num_gates());
-        EXPECT_EQ(composer.check_circuit(), expected_result);
+    static constexpr auto EXPECT_CIRCUIT_CORRECTNESS = [](Builder& builder, bool expected_result = true) {
+        info("num gates = ", builder.get_num_gates());
+        EXPECT_EQ(builder.check_circuit(), expected_result);
     };
 
   public:
     static void test_add()
     {
-        Composer composer;
+        Builder builder;
         size_t num_repetitions = 10;
         for (size_t i = 0; i < num_repetitions; ++i) {
             affine_element input_a(element::random_element());
             affine_element input_b(element::random_element());
 
-            element_ct a = element_ct::from_witness(&composer, input_a);
-            element_ct b = element_ct::from_witness(&composer, input_b);
+            element_ct a = element_ct::from_witness(&builder, input_a);
+            element_ct b = element_ct::from_witness(&builder, input_b);
 
-            uint64_t before = composer.get_num_gates();
+            uint64_t before = builder.get_num_gates();
             element_ct c = a + b;
-            uint64_t after = composer.get_num_gates();
+            uint64_t after = builder.get_num_gates();
             if (i == num_repetitions - 1) {
                 std::cout << "num gates per add = " << after - before << std::endl;
-                benchmark_info(Composer::NAME_STRING, "Biggroup", "ADD", "Gate Count", after - before);
+                benchmark_info(Builder::NAME_STRING, "Biggroup", "ADD", "Gate Count", after - before);
             }
 
             affine_element c_expected(element(input_a) + element(input_b));
@@ -84,19 +84,19 @@ template <typename TestType> class stdlib_biggroup : public testing::Test {
             EXPECT_EQ(c_y_result, c_expected.y);
         }
 
-        EXPECT_CIRCUIT_CORRECTNESS(composer);
+        EXPECT_CIRCUIT_CORRECTNESS(builder);
     }
 
     static void test_sub()
     {
-        Composer composer;
+        Builder builder;
         size_t num_repetitions = 10;
         for (size_t i = 0; i < num_repetitions; ++i) {
             affine_element input_a(element::random_element());
             affine_element input_b(element::random_element());
 
-            element_ct a = element_ct::from_witness(&composer, input_a);
-            element_ct b = element_ct::from_witness(&composer, input_b);
+            element_ct a = element_ct::from_witness(&builder, input_a);
+            element_ct b = element_ct::from_witness(&builder, input_b);
 
             element_ct c = a - b;
 
@@ -112,17 +112,17 @@ template <typename TestType> class stdlib_biggroup : public testing::Test {
             EXPECT_EQ(c_y_result, c_expected.y);
         }
 
-        EXPECT_CIRCUIT_CORRECTNESS(composer);
+        EXPECT_CIRCUIT_CORRECTNESS(builder);
     }
 
     static void test_dbl()
     {
-        Composer composer;
+        Builder builder;
         size_t num_repetitions = 10;
         for (size_t i = 0; i < num_repetitions; ++i) {
             affine_element input_a(element::random_element());
 
-            element_ct a = element_ct::from_witness(&composer, input_a);
+            element_ct a = element_ct::from_witness(&builder, input_a);
 
             element_ct c = a.dbl();
 
@@ -138,19 +138,19 @@ template <typename TestType> class stdlib_biggroup : public testing::Test {
             EXPECT_EQ(c_y_result, c_expected.y);
         }
 
-        EXPECT_CIRCUIT_CORRECTNESS(composer);
+        EXPECT_CIRCUIT_CORRECTNESS(builder);
     }
 
     static void test_montgomery_ladder()
     {
-        Composer composer;
+        Builder builder;
         size_t num_repetitions = 1;
         for (size_t i = 0; i < num_repetitions; ++i) {
             affine_element input_a(element::random_element());
             affine_element input_b(element::random_element());
 
-            element_ct a = element_ct::from_witness(&composer, input_a);
-            element_ct b = element_ct::from_witness(&composer, input_b);
+            element_ct a = element_ct::from_witness(&builder, input_a);
+            element_ct b = element_ct::from_witness(&builder, input_b);
 
             element_ct c = a.montgomery_ladder(b);
 
@@ -166,12 +166,12 @@ template <typename TestType> class stdlib_biggroup : public testing::Test {
             EXPECT_EQ(c_y_result, c_expected.y);
         }
 
-        EXPECT_CIRCUIT_CORRECTNESS(composer);
+        EXPECT_CIRCUIT_CORRECTNESS(builder);
     }
 
     static void test_mul()
     {
-        Composer composer;
+        Builder builder;
         size_t num_repetitions = 1;
         for (size_t i = 0; i < num_repetitions; ++i) {
             affine_element input(element::random_element());
@@ -179,12 +179,12 @@ template <typename TestType> class stdlib_biggroup : public testing::Test {
             if (uint256_t(scalar).get_bit(0)) {
                 scalar -= fr(1); // make sure to add skew
             }
-            element_ct P = element_ct::from_witness(&composer, input);
-            scalar_ct x = scalar_ct::from_witness(&composer, scalar);
+            element_ct P = element_ct::from_witness(&builder, input);
+            scalar_ct x = scalar_ct::from_witness(&builder, scalar);
 
-            std::cerr << "gates before mul " << composer.get_num_gates() << std::endl;
+            std::cerr << "gates before mul " << builder.get_num_gates() << std::endl;
             element_ct c = P * x;
-            std::cerr << "composer aftr mul " << composer.get_num_gates() << std::endl;
+            std::cerr << "builder aftr mul " << builder.get_num_gates() << std::endl;
             affine_element c_expected(element(input) * scalar);
 
             fq c_x_result(c.x.get_value().lo);
@@ -194,12 +194,12 @@ template <typename TestType> class stdlib_biggroup : public testing::Test {
             EXPECT_EQ(c_y_result, c_expected.y);
         }
 
-        EXPECT_CIRCUIT_CORRECTNESS(composer);
+        EXPECT_CIRCUIT_CORRECTNESS(builder);
     }
 
     static void test_twin_mul()
     {
-        Composer composer;
+        Builder builder;
         size_t num_repetitions = 1;
         for (size_t i = 0; i < num_repetitions; ++i) {
             affine_element input_a(element::random_element());
@@ -212,10 +212,10 @@ template <typename TestType> class stdlib_biggroup : public testing::Test {
             if ((uint256_t(scalar_b).get_bit(0) & 1) == 0) {
                 scalar_b += fr(1); // skew bit is 0
             }
-            element_ct P_a = element_ct::from_witness(&composer, input_a);
-            scalar_ct x_a = scalar_ct::from_witness(&composer, scalar_a);
-            element_ct P_b = element_ct::from_witness(&composer, input_b);
-            scalar_ct x_b = scalar_ct::from_witness(&composer, scalar_b);
+            element_ct P_a = element_ct::from_witness(&builder, input_a);
+            scalar_ct x_a = scalar_ct::from_witness(&builder, scalar_a);
+            element_ct P_b = element_ct::from_witness(&builder, input_b);
+            scalar_ct x_b = scalar_ct::from_witness(&builder, scalar_b);
 
             element_ct c = element_ct::batch_mul({ P_a, P_b }, { x_a, x_b });
             element input_c = (element(input_a) * scalar_a);
@@ -227,12 +227,12 @@ template <typename TestType> class stdlib_biggroup : public testing::Test {
             EXPECT_EQ(c_x_result, expected.x);
             EXPECT_EQ(c_y_result, expected.y);
         }
-        EXPECT_CIRCUIT_CORRECTNESS(composer);
+        EXPECT_CIRCUIT_CORRECTNESS(builder);
     }
 
     static void test_triple_mul()
     {
-        Composer composer;
+        Builder builder;
         size_t num_repetitions = 1;
         for (size_t i = 0; i < num_repetitions; ++i) {
             affine_element input_a(element::random_element());
@@ -247,12 +247,12 @@ template <typename TestType> class stdlib_biggroup : public testing::Test {
             if ((uint256_t(scalar_b).get_bit(0) & 1) == 0) {
                 scalar_b += fr(1); // skew bit is 0
             }
-            element_ct P_a = element_ct::from_witness(&composer, input_a);
-            scalar_ct x_a = scalar_ct::from_witness(&composer, scalar_a);
-            element_ct P_b = element_ct::from_witness(&composer, input_b);
-            scalar_ct x_b = scalar_ct::from_witness(&composer, scalar_b);
-            element_ct P_c = element_ct::from_witness(&composer, input_c);
-            scalar_ct x_c = scalar_ct::from_witness(&composer, scalar_c);
+            element_ct P_a = element_ct::from_witness(&builder, input_a);
+            scalar_ct x_a = scalar_ct::from_witness(&builder, scalar_a);
+            element_ct P_b = element_ct::from_witness(&builder, input_b);
+            scalar_ct x_b = scalar_ct::from_witness(&builder, scalar_b);
+            element_ct P_c = element_ct::from_witness(&builder, input_c);
+            scalar_ct x_c = scalar_ct::from_witness(&builder, scalar_c);
 
             element_ct c = element_ct::batch_mul({ P_a, P_b, P_c }, { x_a, x_b, x_c });
             element input_e = (element(input_a) * scalar_a);
@@ -267,12 +267,12 @@ template <typename TestType> class stdlib_biggroup : public testing::Test {
             EXPECT_EQ(c_y_result, expected.y);
         }
 
-        EXPECT_CIRCUIT_CORRECTNESS(composer);
+        EXPECT_CIRCUIT_CORRECTNESS(builder);
     }
 
     static void test_quad_mul()
     {
-        Composer composer;
+        Builder builder;
         size_t num_repetitions = 1;
         for (size_t i = 0; i < num_repetitions; ++i) {
             affine_element input_a(element::random_element());
@@ -289,14 +289,14 @@ template <typename TestType> class stdlib_biggroup : public testing::Test {
             if ((uint256_t(scalar_b).get_bit(0) & 1) == 0) {
                 scalar_b += fr(1); // skew bit is 0
             }
-            element_ct P_a = element_ct::from_witness(&composer, input_a);
-            scalar_ct x_a = scalar_ct::from_witness(&composer, scalar_a);
-            element_ct P_b = element_ct::from_witness(&composer, input_b);
-            scalar_ct x_b = scalar_ct::from_witness(&composer, scalar_b);
-            element_ct P_c = element_ct::from_witness(&composer, input_c);
-            scalar_ct x_c = scalar_ct::from_witness(&composer, scalar_c);
-            element_ct P_d = element_ct::from_witness(&composer, input_d);
-            scalar_ct x_d = scalar_ct::from_witness(&composer, scalar_d);
+            element_ct P_a = element_ct::from_witness(&builder, input_a);
+            scalar_ct x_a = scalar_ct::from_witness(&builder, scalar_a);
+            element_ct P_b = element_ct::from_witness(&builder, input_b);
+            scalar_ct x_b = scalar_ct::from_witness(&builder, scalar_b);
+            element_ct P_c = element_ct::from_witness(&builder, input_c);
+            scalar_ct x_c = scalar_ct::from_witness(&builder, scalar_c);
+            element_ct P_d = element_ct::from_witness(&builder, input_d);
+            scalar_ct x_d = scalar_ct::from_witness(&builder, scalar_d);
 
             element_ct c = element_ct::batch_mul({ P_a, P_b, P_c, P_d }, { x_a, x_b, x_c, x_d });
             element input_e = (element(input_a) * scalar_a);
@@ -312,20 +312,20 @@ template <typename TestType> class stdlib_biggroup : public testing::Test {
             EXPECT_EQ(c_y_result, expected.y);
         }
 
-        EXPECT_CIRCUIT_CORRECTNESS(composer);
+        EXPECT_CIRCUIT_CORRECTNESS(builder);
     }
 
     static void test_one()
     {
-        Composer composer;
+        Builder builder;
         size_t num_repetitions = 1;
         for (size_t i = 0; i < num_repetitions; ++i) {
             fr scalar_a(fr::random_element());
             if ((uint256_t(scalar_a).get_bit(0) & 1) == 1) {
                 scalar_a -= fr(1); // skew bit is 1
             }
-            element_ct P_a = element_ct::one(&composer);
-            scalar_ct x_a = scalar_ct::from_witness(&composer, scalar_a);
+            element_ct P_a = element_ct::one(&builder);
+            scalar_ct x_a = scalar_ct::from_witness(&builder, scalar_a);
             element_ct c = P_a * x_a;
             affine_element expected(g1::one * scalar_a);
             fq c_x_result(c.x.get_value().lo);
@@ -335,13 +335,13 @@ template <typename TestType> class stdlib_biggroup : public testing::Test {
             EXPECT_EQ(c_y_result, expected.y);
         }
 
-        EXPECT_CIRCUIT_CORRECTNESS(composer);
+        EXPECT_CIRCUIT_CORRECTNESS(builder);
     }
 
     static void test_batch_mul()
     {
         const size_t num_points = 5;
-        Composer composer;
+        Builder builder;
         std::vector<affine_element> points;
         std::vector<fr> scalars;
         for (size_t i = 0; i < num_points; ++i) {
@@ -352,8 +352,8 @@ template <typename TestType> class stdlib_biggroup : public testing::Test {
         std::vector<element_ct> circuit_points;
         std::vector<scalar_ct> circuit_scalars;
         for (size_t i = 0; i < num_points; ++i) {
-            circuit_points.push_back(element_ct::from_witness(&composer, points[i]));
-            circuit_scalars.push_back(scalar_ct::from_witness(&composer, scalars[i]));
+            circuit_points.push_back(element_ct::from_witness(&builder, points[i]));
+            circuit_scalars.push_back(scalar_ct::from_witness(&builder, scalars[i]));
         }
 
         element_ct result_point = element_ct::batch_mul(circuit_points, circuit_scalars);
@@ -371,21 +371,21 @@ template <typename TestType> class stdlib_biggroup : public testing::Test {
         EXPECT_EQ(result_x, expected_point.x);
         EXPECT_EQ(result_y, expected_point.y);
 
-        EXPECT_CIRCUIT_CORRECTNESS(composer);
+        EXPECT_CIRCUIT_CORRECTNESS(builder);
     }
 
     static void test_chain_add()
     {
-        Composer composer = Composer();
+        Builder builder = Builder();
         size_t num_repetitions = 10;
         for (size_t i = 0; i < num_repetitions; ++i) {
             affine_element input_a(element::random_element());
             affine_element input_b(element::random_element());
             affine_element input_c(element::random_element());
 
-            element_ct a = element_ct::from_witness(&composer, input_a);
-            element_ct b = element_ct::from_witness(&composer, input_b);
-            element_ct c = element_ct::from_witness(&composer, input_c);
+            element_ct a = element_ct::from_witness(&builder, input_a);
+            element_ct b = element_ct::from_witness(&builder, input_b);
+            element_ct c = element_ct::from_witness(&builder, input_c);
 
             auto acc = element_ct::chain_add_start(a, b);
             auto acc_out = element_ct::chain_add(c, acc);
@@ -406,23 +406,23 @@ template <typename TestType> class stdlib_biggroup : public testing::Test {
             EXPECT_EQ(lambda_result, lambda);
         }
 
-        EXPECT_CIRCUIT_CORRECTNESS(composer);
+        EXPECT_CIRCUIT_CORRECTNESS(builder);
     }
 
     static void test_multiple_montgomery_ladder()
     {
-        Composer composer = Composer();
+        Builder builder = Builder();
         size_t num_repetitions = 10;
         for (size_t i = 0; i < num_repetitions; ++i) {
             affine_element acc_small(element::random_element());
-            element_ct acc_big = element_ct::from_witness(&composer, acc_small);
+            element_ct acc_big = element_ct::from_witness(&builder, acc_small);
 
             std::vector<typename element_ct::chain_add_accumulator> to_add;
             for (size_t j = 0; j < i; ++j) {
                 affine_element add_1_small_0(element::random_element());
-                element_ct add_1_big_0 = element_ct::from_witness(&composer, add_1_small_0);
+                element_ct add_1_big_0 = element_ct::from_witness(&builder, add_1_small_0);
                 affine_element add_2_small_0(element::random_element());
-                element_ct add_2_big_0 = element_ct::from_witness(&composer, add_2_small_0);
+                element_ct add_2_big_0 = element_ct::from_witness(&builder, add_2_small_0);
                 typename element_ct::chain_add_accumulator add_1 =
                     element_ct::chain_add_start(add_1_big_0, add_2_big_0);
                 to_add.emplace_back(add_1);
@@ -430,16 +430,16 @@ template <typename TestType> class stdlib_biggroup : public testing::Test {
             acc_big.multiple_montgomery_ladder(to_add);
         }
 
-        EXPECT_CIRCUIT_CORRECTNESS(composer);
+        EXPECT_CIRCUIT_CORRECTNESS(builder);
     }
 
     static void test_compute_naf()
     {
-        Composer composer = Composer();
+        Builder builder = Builder();
         size_t num_repetitions(32);
         for (size_t i = 0; i < num_repetitions; i++) {
             fr scalar_val = fr::random_element();
-            scalar_ct scalar = scalar_ct::from_witness(&composer, scalar_val);
+            scalar_ct scalar = scalar_ct::from_witness(&builder, scalar_val);
             auto naf = element_ct::compute_naf(scalar);
             // scalar = -naf[254] + \sum_{i=0}^{253}(1-2*naf[i]) 2^{253-i}
             fr reconstructed_val(0);
@@ -449,23 +449,23 @@ template <typename TestType> class stdlib_biggroup : public testing::Test {
             reconstructed_val -= fr(naf[254].witness_bool);
             EXPECT_EQ(scalar_val, reconstructed_val);
         }
-        EXPECT_CIRCUIT_CORRECTNESS(composer);
+        EXPECT_CIRCUIT_CORRECTNESS(builder);
     }
 
     static void test_compute_wnaf()
     {
-        Composer composer = Composer();
+        Builder builder = Builder();
 
         fr scalar_val = fr::random_element();
-        scalar_ct scalar = scalar_ct::from_witness(&composer, scalar_val);
+        scalar_ct scalar = scalar_ct::from_witness(&builder, scalar_val);
         element_ct::compute_wnaf(scalar);
 
-        EXPECT_CIRCUIT_CORRECTNESS(composer);
+        EXPECT_CIRCUIT_CORRECTNESS(builder);
     }
 
     static void test_wnaf_batch_mul()
     {
-        Composer composer;
+        Builder builder;
         size_t num_repetitions = 1;
         for (size_t i = 0; i < num_repetitions; ++i) {
             affine_element input(element::random_element());
@@ -473,12 +473,12 @@ template <typename TestType> class stdlib_biggroup : public testing::Test {
             if ((uint256_t(scalar).get_bit(0) & 1) == 1) {
                 scalar -= fr(1); // make sure to add skew
             }
-            element_ct P = element_ct::from_witness(&composer, input);
-            scalar_ct x = scalar_ct::from_witness(&composer, scalar);
+            element_ct P = element_ct::from_witness(&builder, input);
+            scalar_ct x = scalar_ct::from_witness(&builder, scalar);
 
-            std::cerr << "gates before mul " << composer.get_num_gates() << std::endl;
+            std::cerr << "gates before mul " << builder.get_num_gates() << std::endl;
             element_ct c = element_ct::wnaf_batch_mul({ P }, { x });
-            std::cerr << "composer aftr mul " << composer.get_num_gates() << std::endl;
+            std::cerr << "builder aftr mul " << builder.get_num_gates() << std::endl;
             affine_element c_expected(element(input) * scalar);
 
             fq c_x_result(c.x.get_value().lo);
@@ -488,13 +488,13 @@ template <typename TestType> class stdlib_biggroup : public testing::Test {
             EXPECT_EQ(c_y_result, c_expected.y);
         }
 
-        EXPECT_CIRCUIT_CORRECTNESS(composer);
+        EXPECT_CIRCUIT_CORRECTNESS(builder);
     }
 
     static void test_batch_mul_short_scalars()
     {
         const size_t num_points = 11;
-        Composer composer;
+        Builder builder;
         std::vector<affine_element> points;
         std::vector<fr> scalars;
         for (size_t i = 0; i < num_points; ++i) {
@@ -507,8 +507,8 @@ template <typename TestType> class stdlib_biggroup : public testing::Test {
         std::vector<element_ct> circuit_points;
         std::vector<scalar_ct> circuit_scalars;
         for (size_t i = 0; i < num_points; ++i) {
-            circuit_points.push_back(element_ct::from_witness(&composer, points[i]));
-            circuit_scalars.push_back(scalar_ct::from_witness(&composer, scalars[i]));
+            circuit_points.push_back(element_ct::from_witness(&builder, points[i]));
+            circuit_scalars.push_back(scalar_ct::from_witness(&builder, scalars[i]));
         }
 
         element_ct result_point = element_ct::batch_mul(circuit_points, circuit_scalars, 128);
@@ -526,12 +526,12 @@ template <typename TestType> class stdlib_biggroup : public testing::Test {
         EXPECT_EQ(result_x, expected_point.x);
         EXPECT_EQ(result_y, expected_point.y);
 
-        EXPECT_CIRCUIT_CORRECTNESS(composer);
+        EXPECT_CIRCUIT_CORRECTNESS(builder);
     }
 
     static void test_wnaf_batch_mul_128_bit()
     {
-        Composer composer = Composer();
+        Builder builder = Builder();
         size_t num_repetitions = 1;
         for (size_t i = 0; i < num_repetitions; ++i) {
             affine_element input(element::random_element());
@@ -542,13 +542,13 @@ template <typename TestType> class stdlib_biggroup : public testing::Test {
             if ((uint256_t(scalar).get_bit(0) & 1) == 1) {
                 scalar -= fr(1); // make sure to add skew
             }
-            element_ct P = element_ct::from_witness(&composer, input);
-            scalar_ct x = scalar_ct::from_witness(&composer, scalar);
+            element_ct P = element_ct::from_witness(&builder, input);
+            scalar_ct x = scalar_ct::from_witness(&builder, scalar);
 
-            std::cerr << "gates before mul " << composer.get_num_gates() << std::endl;
+            std::cerr << "gates before mul " << builder.get_num_gates() << std::endl;
             // Note: need >136 bits to complete this when working over bigfield
             element_ct c = element_ct::template wnaf_batch_mul<128>({ P }, { x });
-            std::cerr << "composer aftr mul " << composer.get_num_gates() << std::endl;
+            std::cerr << "builder aftr mul " << builder.get_num_gates() << std::endl;
             affine_element c_expected(element(input) * scalar);
 
             fq c_x_result(c.x.get_value().lo);
@@ -558,12 +558,12 @@ template <typename TestType> class stdlib_biggroup : public testing::Test {
             EXPECT_EQ(c_y_result, c_expected.y);
         }
 
-        EXPECT_CIRCUIT_CORRECTNESS(composer);
+        EXPECT_CIRCUIT_CORRECTNESS(builder);
     }
 
     static void test_wnaf_batch_4()
     {
-        Composer composer = Composer();
+        Builder builder = Builder();
         size_t num_repetitions = 1;
         for (size_t i = 0; i < num_repetitions; ++i) {
             const auto get_128_bit_scalar = []() {
@@ -578,23 +578,23 @@ template <typename TestType> class stdlib_biggroup : public testing::Test {
             affine_element input3(element::random_element());
             affine_element input4(element::random_element());
 
-            element_ct P1 = element_ct::from_witness(&composer, input1);
-            element_ct P2 = element_ct::from_witness(&composer, input2);
-            element_ct P3 = element_ct::from_witness(&composer, input3);
-            element_ct P4 = element_ct::from_witness(&composer, input4);
+            element_ct P1 = element_ct::from_witness(&builder, input1);
+            element_ct P2 = element_ct::from_witness(&builder, input2);
+            element_ct P3 = element_ct::from_witness(&builder, input3);
+            element_ct P4 = element_ct::from_witness(&builder, input4);
 
             fr scalar1 = get_128_bit_scalar();
             fr scalar2 = get_128_bit_scalar();
             fr scalar3 = get_128_bit_scalar();
             fr scalar4 = get_128_bit_scalar();
-            scalar_ct x1 = scalar_ct::from_witness(&composer, scalar1);
-            scalar_ct x2 = scalar_ct::from_witness(&composer, scalar2);
-            scalar_ct x3 = scalar_ct::from_witness(&composer, scalar3);
-            scalar_ct x4 = scalar_ct::from_witness(&composer, scalar4);
+            scalar_ct x1 = scalar_ct::from_witness(&builder, scalar1);
+            scalar_ct x2 = scalar_ct::from_witness(&builder, scalar2);
+            scalar_ct x3 = scalar_ct::from_witness(&builder, scalar3);
+            scalar_ct x4 = scalar_ct::from_witness(&builder, scalar4);
 
-            std::cerr << "gates before mul " << composer.get_num_gates() << std::endl;
+            std::cerr << "gates before mul " << builder.get_num_gates() << std::endl;
             element_ct c = element_ct::batch_mul({ P1, P2, P3, P4 }, { x1, x2, x3, x4 }, 128);
-            std::cerr << "composer aftr mul " << composer.get_num_gates() << std::endl;
+            std::cerr << "builder aftr mul " << builder.get_num_gates() << std::endl;
 
             element out = input1 * scalar1;
             out += (input2 * scalar2);
@@ -609,14 +609,14 @@ template <typename TestType> class stdlib_biggroup : public testing::Test {
             EXPECT_EQ(c_y_result, c_expected.y);
         }
 
-        EXPECT_CIRCUIT_CORRECTNESS(composer);
+        EXPECT_CIRCUIT_CORRECTNESS(builder);
     }
 
     static void test_bn254_endo_batch_mul()
     {
         const size_t num_big_points = 2;
         const size_t num_small_points = 1;
-        Composer composer;
+        Builder builder;
         std::vector<affine_element> big_points;
         std::vector<fr> big_scalars;
         std::vector<affine_element> small_points;
@@ -639,12 +639,12 @@ template <typename TestType> class stdlib_biggroup : public testing::Test {
         std::vector<element_ct> small_circuit_points;
         std::vector<scalar_ct> small_circuit_scalars;
         for (size_t i = 0; i < num_big_points; ++i) {
-            big_circuit_points.push_back(element_ct::from_witness(&composer, big_points[i]));
-            big_circuit_scalars.push_back(scalar_ct::from_witness(&composer, big_scalars[i]));
+            big_circuit_points.push_back(element_ct::from_witness(&builder, big_points[i]));
+            big_circuit_scalars.push_back(scalar_ct::from_witness(&builder, big_scalars[i]));
         }
         for (size_t i = 0; i < num_small_points; ++i) {
-            small_circuit_points.push_back(element_ct::from_witness(&composer, small_points[i]));
-            small_circuit_scalars.push_back(scalar_ct::from_witness(&composer, small_scalars[i]));
+            small_circuit_points.push_back(element_ct::from_witness(&builder, small_points[i]));
+            small_circuit_scalars.push_back(scalar_ct::from_witness(&builder, small_scalars[i]));
         }
 
         element_ct result_point = element_ct::bn254_endo_batch_mul(
@@ -666,12 +666,12 @@ template <typename TestType> class stdlib_biggroup : public testing::Test {
         EXPECT_EQ(result_x, expected_point.x);
         EXPECT_EQ(result_y, expected_point.y);
 
-        EXPECT_CIRCUIT_CORRECTNESS(composer);
+        EXPECT_CIRCUIT_CORRECTNESS(builder);
     }
 
     static void test_mixed_mul_bn254_endo()
     {
-        Composer composer;
+        Builder builder;
         size_t num_repetitions = 1;
 
         const auto get_small_scalar = []() {
@@ -699,27 +699,27 @@ template <typename TestType> class stdlib_biggroup : public testing::Test {
             for (size_t i = 0; i < 25; ++i) {
                 small_points_w[i] = affine_element(element::random_element());
                 small_scalars_w[i] = get_small_scalar();
-                small_points[i] = element_ct::from_witness(&composer, small_points_w[i]);
-                small_scalars[i] = scalar_ct::from_witness(&composer, small_scalars_w[i]);
+                small_points[i] = element_ct::from_witness(&builder, small_points_w[i]);
+                small_scalars[i] = scalar_ct::from_witness(&builder, small_scalars_w[i]);
             }
             for (size_t i = 0; i < 5; ++i) {
                 big_points_w[i] = affine_element(element::random_element());
                 big_scalars_w[i] = fr::random_element();
-                big_points[i] = element_ct::from_witness(&composer, big_points_w[i]);
-                big_scalars[i] = scalar_ct::from_witness(&composer, big_scalars_w[i]);
+                big_points[i] = element_ct::from_witness(&builder, big_points_w[i]);
+                big_scalars[i] = scalar_ct::from_witness(&builder, big_scalars_w[i]);
             }
             for (size_t i = 0; i < 11; ++i) {
                 double_points_w[i] = affine_element(element::random_element());
                 double_scalars_w[i] = get_small_scalar();
-                double_points[i] = element_ct::from_witness(&composer, double_points_w[i]);
-                double_scalars[i] = scalar_ct::from_witness(&composer, double_scalars_w[i]);
+                double_points[i] = element_ct::from_witness(&builder, double_points_w[i]);
+                double_scalars[i] = scalar_ct::from_witness(&builder, double_scalars_w[i]);
             }
 
             fr omega = get_small_scalar();
 
             const auto double_opening_result = element_ct::batch_mul(double_points, double_scalars, 128);
             small_points.push_back(double_opening_result);
-            small_scalars.push_back(scalar_ct::from_witness(&composer, omega));
+            small_scalars.push_back(scalar_ct::from_witness(&builder, omega));
 
             auto opening_result =
                 element_ct::bn254_endo_batch_mul(big_points, big_scalars, small_points, small_scalars, 128);
@@ -748,50 +748,50 @@ template <typename TestType> class stdlib_biggroup : public testing::Test {
             EXPECT_EQ(result_y, expected.y);
         }
 
-        EXPECT_CIRCUIT_CORRECTNESS(composer);
+        EXPECT_CIRCUIT_CORRECTNESS(builder);
     };
 
     static void test_wnaf_secp256k1()
     {
-        Composer composer = Composer();
+        Builder builder = Builder();
         size_t num_repetitions = 1;
         for (size_t i = 0; i < num_repetitions; ++i) {
             fr scalar_a(fr::random_element());
             if ((uint256_t(scalar_a).get_bit(0) & 1) == 1) {
                 scalar_a -= fr(1); // skew bit is 1
             }
-            scalar_ct x_a = scalar_ct::from_witness(&composer, scalar_a);
+            scalar_ct x_a = scalar_ct::from_witness(&builder, scalar_a);
             element_ct::template compute_secp256k1_endo_wnaf<4, 0, 3>(x_a);
             element_ct::template compute_secp256k1_endo_wnaf<4, 1, 2>(x_a);
             element_ct::template compute_secp256k1_endo_wnaf<4, 2, 1>(x_a);
             element_ct::template compute_secp256k1_endo_wnaf<4, 3, 0>(x_a);
         }
 
-        EXPECT_CIRCUIT_CORRECTNESS(composer);
+        EXPECT_CIRCUIT_CORRECTNESS(builder);
     }
 
     static void test_wnaf_8bit_secp256k1()
     {
-        Composer composer = Composer();
+        Builder builder = Builder();
         size_t num_repetitions = 1;
         for (size_t i = 0; i < num_repetitions; ++i) {
             fr scalar_a(fr::random_element());
             if ((uint256_t(scalar_a).get_bit(0) & 1) == 1) {
                 scalar_a -= fr(1); // skew bit is 1
             }
-            scalar_ct x_a = scalar_ct::from_witness(&composer, scalar_a);
+            scalar_ct x_a = scalar_ct::from_witness(&builder, scalar_a);
             element_ct::template compute_secp256k1_endo_wnaf<8, 0, 3>(x_a);
             element_ct::template compute_secp256k1_endo_wnaf<8, 1, 2>(x_a);
             element_ct::template compute_secp256k1_endo_wnaf<8, 2, 1>(x_a);
             element_ct::template compute_secp256k1_endo_wnaf<8, 3, 0>(x_a);
         }
 
-        EXPECT_CIRCUIT_CORRECTNESS(composer);
+        EXPECT_CIRCUIT_CORRECTNESS(builder);
     }
 
     static void test_ecdsa_mul_secp256k1()
     {
-        Composer composer = Composer();
+        Builder builder = Builder();
         size_t num_repetitions = 1;
         for (size_t i = 0; i < num_repetitions; ++i) {
             fr scalar_a(fr::random_element());
@@ -800,9 +800,9 @@ template <typename TestType> class stdlib_biggroup : public testing::Test {
             if ((uint256_t(scalar_a).get_bit(0) & 1) == 1) {
                 scalar_a -= fr(1); // skew bit is 1
             }
-            element_ct P_a = element_ct::from_witness(&composer, g1::one * scalar_c);
-            scalar_ct u1 = scalar_ct::from_witness(&composer, scalar_a);
-            scalar_ct u2 = scalar_ct::from_witness(&composer, scalar_b);
+            element_ct P_a = element_ct::from_witness(&builder, g1::one * scalar_c);
+            scalar_ct u1 = scalar_ct::from_witness(&builder, scalar_a);
+            scalar_ct u2 = scalar_ct::from_witness(&builder, scalar_b);
 
             fr alo;
             fr ahi;
@@ -819,7 +819,7 @@ template <typename TestType> class stdlib_biggroup : public testing::Test {
             EXPECT_EQ(output.y.get_value().lo, uint256_t(expected.y));
         }
 
-        EXPECT_CIRCUIT_CORRECTNESS(composer);
+        EXPECT_CIRCUIT_CORRECTNESS(builder);
     }
 };
 
@@ -896,7 +896,7 @@ HEAVY_TYPED_TEST(stdlib_biggroup, compute_naf)
 /* These tests only work for Ultra Circuit Constructor */
 HEAVY_TYPED_TEST(stdlib_biggroup, wnaf_batch_mul)
 {
-    if constexpr (HasPlookup<typename TypeParam::Curve::Composer>) {
+    if constexpr (HasPlookup<typename TypeParam::Curve::Builder>) {
         TestFixture::test_compute_wnaf();
     } else {
         GTEST_SKIP();
@@ -907,7 +907,7 @@ HEAVY_TYPED_TEST(stdlib_biggroup, wnaf_batch_mul)
    case where Fr is a bigfield. */
 HEAVY_TYPED_TEST(stdlib_biggroup, compute_wnaf)
 {
-    if constexpr (!HasPlookup<typename TypeParam::Curve::Composer> && TypeParam::use_bigfield) {
+    if constexpr (!HasPlookup<typename TypeParam::Curve::Builder> && TypeParam::use_bigfield) {
         GTEST_SKIP();
     } else {
         TestFixture::test_compute_wnaf();
diff --git a/barretenberg/cpp/src/barretenberg/stdlib/primitives/biggroup/biggroup_impl.hpp b/barretenberg/cpp/src/barretenberg/stdlib/primitives/biggroup/biggroup_impl.hpp
index c62ffea796c..1ca76538963 100644
--- a/barretenberg/cpp/src/barretenberg/stdlib/primitives/biggroup/biggroup_impl.hpp
+++ b/barretenberg/cpp/src/barretenberg/stdlib/primitives/biggroup/biggroup_impl.hpp
@@ -522,8 +522,8 @@ element<C, Fq, Fr, G> element<C, Fq, Fr, G>::multiple_montgomery_ladder(
             y_4.mul_right.emplace_back(previous_y.is_negative ? previous_x - x_4 : x_4 - previous_x);
             // append terms in previous_y to y_4. We want to make sure the terms above are added into the start of y_4.
             // This is to ensure they are cached correctly when
-            // `composer::evaluate_partial_non_native_field_multiplication` is called.
-            // (the 1st mul_left, mul_right elements will trigger composer::evaluate_non_native_field_multiplication
+            // `builder::evaluate_partial_non_native_field_multiplication` is called.
+            // (the 1st mul_left, mul_right elements will trigger builder::evaluate_non_native_field_multiplication
             //  when Fq::mult_madd is called - this term cannot be cached so we want to make sure it is unique)
             std::copy(previous_y.mul_left.begin(), previous_y.mul_left.end(), std::back_inserter(y_4.mul_left));
             std::copy(previous_y.mul_right.begin(), previous_y.mul_right.end(), std::back_inserter(y_4.mul_right));
diff --git a/barretenberg/cpp/src/barretenberg/stdlib/primitives/biggroup/biggroup_nafs.hpp b/barretenberg/cpp/src/barretenberg/stdlib/primitives/biggroup/biggroup_nafs.hpp
index 26ebc3ade81..55bc21b6cbb 100644
--- a/barretenberg/cpp/src/barretenberg/stdlib/primitives/biggroup/biggroup_nafs.hpp
+++ b/barretenberg/cpp/src/barretenberg/stdlib/primitives/biggroup/biggroup_nafs.hpp
@@ -500,7 +500,7 @@ std::vector<bool_t<C>> element<C, Fq, Fr, G>::compute_naf(const Fr& scalar, cons
     for (size_t i = 0; i < num_rounds - 1; ++i) {
         bool next_entry = scalar_multiplier.get_bit(i + 1);
         // if the next entry is false, we need to flip the sign of the current entry. i.e. make negative
-        // This is a VERY hacky workaround to ensure that UltraPlonkComposer will apply a basic
+        // This is a VERY hacky workaround to ensure that UltraPlonkBuilder will apply a basic
         // range constraint per bool, and not a full 1-bit range gate
         if (next_entry == false) {
             bool_t<C> bit(ctx, true);
diff --git a/barretenberg/cpp/src/barretenberg/stdlib/primitives/bit_array/bit_array.cpp b/barretenberg/cpp/src/barretenberg/stdlib/primitives/bit_array/bit_array.cpp
index a6e3ee7e2d2..1f777d61fd8 100644
--- a/barretenberg/cpp/src/barretenberg/stdlib/primitives/bit_array/bit_array.cpp
+++ b/barretenberg/cpp/src/barretenberg/stdlib/primitives/bit_array/bit_array.cpp
@@ -6,15 +6,15 @@
 namespace proof_system::plonk {
 namespace stdlib {
 
-template <typename ComposerContext>
-bit_array<ComposerContext>::bit_array(ComposerContext* parent_context, const size_t n)
+template <typename Builder>
+bit_array<Builder>::bit_array(Builder* parent_context, const size_t n)
     : context(parent_context)
     , length(n)
-    , values(std::vector<bool_t<ComposerContext>>(n))
+    , values(std::vector<bool_t<Builder>>(n))
 {}
 
-template <typename ComposerContext>
-bit_array<ComposerContext>::bit_array(ComposerContext* parent_context, const std::string& input)
+template <typename Builder>
+bit_array<Builder>::bit_array(Builder* parent_context, const std::string& input)
     : context(parent_context)
 {
     length = input.length() * 8;
@@ -27,18 +27,18 @@ bit_array<ComposerContext>::bit_array(ComposerContext* parent_context, const std
         size_t position = length - (8 * (i + 1));
         for (size_t j = 0; j < 8; ++j) {
             // printf("bit [%lu][%lu] = %u\n", i, j, char_bits[j] == true ? 1 : 0);
-            witness_t<ComposerContext> value(context, char_bits[j]);
+            witness_t<Builder> value(context, char_bits[j]);
             values[position + j] = value;
         }
     }
 }
 
-template <typename ComposerContext>
-bit_array<ComposerContext>::bit_array(ComposerContext* parent_context, const std::vector<uint8_t>& input)
+template <typename Builder>
+bit_array<Builder>::bit_array(Builder* parent_context, const std::vector<uint8_t>& input)
     : bit_array(parent_context, std::string(input.begin(), input.end()))
 {}
 
-template <typename ComposerContext> bit_array<ComposerContext>::bit_array(uint32<ComposerContext> const& input)
+template <typename Builder> bit_array<Builder>::bit_array(uint32<Builder> const& input)
 {
     context = input.get_context();
     size_t num_bits = input.get_width();
@@ -51,8 +51,7 @@ template <typename ComposerContext> bit_array<ComposerContext>::bit_array(uint32
     length = num_bits;
 }
 
-template <typename ComposerContext>
-bit_array<ComposerContext>::bit_array(const std::vector<uint32<ComposerContext>>& input)
+template <typename Builder> bit_array<Builder>::bit_array(const std::vector<uint32<Builder>>& input)
 {
     auto it = std::find_if(input.begin(), input.end(), [](const auto x) { return x.get_context() != nullptr; });
     if (it != std::end(input)) {
@@ -74,31 +73,30 @@ bit_array<ComposerContext>::bit_array(const std::vector<uint32<ComposerContext>>
     length = num_bits;
 }
 
-template <typename ComposerContext> bit_array<ComposerContext>::bit_array(const bit_array& other)
+template <typename Builder> bit_array<Builder>::bit_array(const bit_array& other)
 {
     context = other.context;
     std::copy(other.values.begin(), other.values.end(), std::back_inserter(values));
     length = values.size();
 }
 
-template <typename ComposerContext> bit_array<ComposerContext>::bit_array(bit_array&& other)
+template <typename Builder> bit_array<Builder>::bit_array(bit_array&& other)
 {
     context = other.context;
     length = other.length;
     values = std::move(other.values); // yoink
 }
 
-template <typename ComposerContext>
-bit_array<ComposerContext>& bit_array<ComposerContext>::operator=(const bit_array& other)
+template <typename Builder> bit_array<Builder>& bit_array<Builder>::operator=(const bit_array& other)
 {
     length = other.length;
     context = other.context;
-    values = std::vector<bool_t<ComposerContext>>();
+    values = std::vector<bool_t<Builder>>();
     std::copy(other.values.begin(), other.values.end(), std::back_inserter(values));
     return *this;
 }
 
-template <typename ComposerContext> bit_array<ComposerContext>& bit_array<ComposerContext>::operator=(bit_array&& other)
+template <typename Builder> bit_array<Builder>& bit_array<Builder>::operator=(bit_array&& other)
 {
     length = other.length;
     context = other.context;
@@ -106,24 +104,23 @@ template <typename ComposerContext> bit_array<ComposerContext>& bit_array<Compos
     return *this;
 }
 
-template <typename ComposerContext> bool_t<ComposerContext>& bit_array<ComposerContext>::operator[](const size_t idx)
+template <typename Builder> bool_t<Builder>& bit_array<Builder>::operator[](const size_t idx)
 {
     return values[idx];
 }
 
-template <typename ComposerContext>
-bool_t<ComposerContext> bit_array<ComposerContext>::operator[](const size_t idx) const
+template <typename Builder> bool_t<Builder> bit_array<Builder>::operator[](const size_t idx) const
 {
     return values[idx];
 }
 
-template <typename ComposerContext> std::vector<uint32<ComposerContext>> bit_array<ComposerContext>::to_uint32_vector()
+template <typename Builder> std::vector<uint32<Builder>> bit_array<Builder>::to_uint32_vector()
 {
     size_t num_uint32s = (length / 32) + (length % 32 != 0);
-    std::vector<uint32<ComposerContext>> output;
+    std::vector<uint32<Builder>> output;
 
     for (size_t i = 0; i < num_uint32s; ++i) {
-        std::array<bool_t<ComposerContext>, 32> bools;
+        std::array<bool_t<Builder>, 32> bools;
         size_t end;
         size_t start;
         start = ((num_uint32s - i) * 32) - 32;
@@ -133,15 +130,15 @@ template <typename ComposerContext> std::vector<uint32<ComposerContext>> bit_arr
         }
         if (start + 32 > length) {
             for (size_t j = end; j < start + 32; ++j) {
-                bools[j - start] = bool_t<ComposerContext>(context, false);
+                bools[j - start] = bool_t<Builder>(context, false);
             }
         }
-        output.push_back(uint32<ComposerContext>(context, bools));
+        output.push_back(uint32<Builder>(context, bools));
     }
     return output;
 }
 
-template <typename ComposerContext> std::string bit_array<ComposerContext>::get_witness_as_string() const
+template <typename Builder> std::string bit_array<Builder>::get_witness_as_string() const
 {
     size_t num_chars = length / 8;
     ASSERT(num_chars * 8 == length);
diff --git a/barretenberg/cpp/src/barretenberg/stdlib/primitives/bit_array/bit_array.fuzzer.hpp b/barretenberg/cpp/src/barretenberg/stdlib/primitives/bit_array/bit_array.fuzzer.hpp
index 397ba57c853..d4ad0fb0feb 100644
--- a/barretenberg/cpp/src/barretenberg/stdlib/primitives/bit_array/bit_array.fuzzer.hpp
+++ b/barretenberg/cpp/src/barretenberg/stdlib/primitives/bit_array/bit_array.fuzzer.hpp
@@ -28,12 +28,12 @@ FastRandom VarianceRNG(0);
  * @brief The class parametrizing ByteArray fuzzing instructions, execution, etc
  *
  */
-template <typename Composer> class BitArrayFuzzBase {
+template <typename Builder> class BitArrayFuzzBase {
   private:
-    typedef proof_system::plonk::stdlib::bit_array<Composer> bit_array_t;
-    typedef proof_system::plonk::stdlib::byte_array<Composer> byte_array_t;
+    typedef proof_system::plonk::stdlib::bit_array<Builder> bit_array_t;
+    typedef proof_system::plonk::stdlib::byte_array<Builder> byte_array_t;
     template <size_t NumBytes, size_t NumWords>
-    static std::vector<uint8_t> to_vector(std::array<proof_system::plonk::stdlib::uint32<Composer>, NumWords>& a32)
+    static std::vector<uint8_t> to_vector(std::array<proof_system::plonk::stdlib::uint32<Builder>, 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<proof_system::plonk::stdlib::uint32<Composer>, NumWords> a32;
+            std::array<proof_system::plonk::stdlib::uint32<Builder>, 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<proof_system::plonk::stdlib::uint32<Composer>, NumWords> a32;
+            std::array<proof_system::plonk::stdlib::uint32<Builder>, NumWords> a32;
 
             /* Switch between two different methods to retrieve the uint32 array */
             if (cast_or_populate) {
@@ -445,7 +445,7 @@ 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<proof_system::plonk::stdlib::uint32<Composer>, MAX_ARRAY_SIZE>>(
+                        static_cast<std::array<proof_system::plonk::stdlib::uint32<Builder>, MAX_ARRAY_SIZE>>(
                             bit_array);
                     for (size_t i = 0; i < a32_.size(); i++) {
                         a32[i] = static_cast<uint32_t>(a32_[i].get_value());
@@ -482,7 +482,7 @@ template <typename Composer> class BitArrayFuzzBase {
             , bit_array(s)
         {}
 
-        ExecutionHandler get_bit(Composer* composer, const size_t bit) const
+        ExecutionHandler get_bit(Builder* builder, const size_t bit) const
         {
             if (bit >= this->reference_value.size() * 8) {
                 return ExecutionHandler(this->reference_value, this->bit_array);
@@ -490,7 +490,7 @@ template <typename Composer> class BitArrayFuzzBase {
                 const bool is_set_ref = get_bit(this->reference_value, bit);
                 const bool is_set_ba = this->bit_array[bit].get_value();
 
-                return ExecutionHandler(bool_to_vector(is_set_ref), bit_array_t(composer, bool_to_vector(is_set_ba)));
+                return ExecutionHandler(bool_to_vector(is_set_ref), bit_array_t(builder, bool_to_vector(is_set_ba)));
             }
         }
         /* Modifies the buffer at hand, so does not produce a return value */
@@ -502,7 +502,7 @@ template <typename Composer> class BitArrayFuzzBase {
             }
         }
         /* output = input[offset:] (where offset denotes bits) */
-        ExecutionHandler slice(Composer* composer, const size_t offset)
+        ExecutionHandler slice(Builder* builder, const size_t offset)
         {
             static_assert(MAX_ARRAY_SIZE % 4 == 0);
             const auto v_ba = vector_via_populate_uint32_array<MAX_ARRAY_SIZE / 4>(this->bit_array, offset);
@@ -522,11 +522,11 @@ template <typename Composer> class BitArrayFuzzBase {
                 }
             }
 
-            return ExecutionHandler(v_ref, bit_array_t(composer, v_ba));
+            return ExecutionHandler(v_ref, bit_array_t(builder, v_ba));
         }
 
         /* Explicit re-instantiation using the various bit_array constructors */
-        ExecutionHandler set(Composer* composer)
+        ExecutionHandler set(Builder* builder)
         {
             const uint8_t which = VarianceRNG.next() % 6;
 
@@ -538,11 +538,11 @@ template <typename Composer> class BitArrayFuzzBase {
                 return ExecutionHandler(ref, bit_array_t(this->bit_array));
             case 1:
                 /* Construct via std::string */
-                return ExecutionHandler(ref, bit_array_t(composer, this->bit_array.get_witness_as_string()));
+                return ExecutionHandler(ref, bit_array_t(builder, this->bit_array.get_witness_as_string()));
             case 2:
                 /* Construct via std::vector<uint8_t> */
                 return ExecutionHandler(ref,
-                                        bit_array_t(composer, static_cast<byte_array_t>(this->bit_array).get_value()));
+                                        bit_array_t(builder, static_cast<byte_array_t>(this->bit_array).get_value()));
             case 3:
                 /* Construct via byte_array */
                 return ExecutionHandler(ref, bit_array_t(static_cast<byte_array_t>(this->bit_array)));
@@ -553,10 +553,10 @@ template <typename Composer> class BitArrayFuzzBase {
                     const auto v = this->bit_array.to_uint32_vector();
 
                     if (v.size() == 1 && static_cast<bool>(VarianceRNG.next() % 2)) {
-                        /* Construct via uint32<ComposerContext> */
+                        /* Construct via uint32<Builder> */
                         return ExecutionHandler(ref, bit_array_t(v[0]));
                     } else {
-                        /* Construct via std::vector<uint32<ComposerContext>> */
+                        /* Construct via std::vector<uint32<Builder>> */
                         return ExecutionHandler(ref, bit_array_t(v));
                     }
                 }
@@ -571,7 +571,7 @@ template <typename Composer> class BitArrayFuzzBase {
                 for (size_t i = 0; i < gibberish_size; i++) {
                     gibberish[i] = static_cast<uint8_t>(VarianceRNG.next() % 0xFF);
                 }
-                auto ba = bit_array_t(composer, gibberish);
+                auto ba = bit_array_t(builder, gibberish);
 
                 /* Construct via assignment */
                 ba = this->bit_array;
@@ -586,32 +586,32 @@ template <typename Composer> class BitArrayFuzzBase {
         /**
          * @brief Execute the constant instruction (push constant safeuint to the stack)
          *
-         * @param composer
+         * @param builder
          * @param stack
          * @param instruction
          * @return 0 if everything is ok, 1 if we should stop execution, since an expected error was encountered
          */
-        static inline size_t execute_CONSTANT(Composer* composer,
+        static inline size_t execute_CONSTANT(Builder* builder,
                                               std::vector<ExecutionHandler>& stack,
                                               Instruction& instruction)
         {
-            (void)composer;
-            stack.push_back(bit_array_t(composer, instruction.arguments.element.as_string()));
+            (void)builder;
+            stack.push_back(bit_array_t(builder, instruction.arguments.element.as_string()));
             return 0;
         }
         /**
          * @brief Execute the GET_BIT instruction
          *
-         * @param composer
+         * @param builder
          * @param stack
          * @param instruction
          * @return if everything is ok, 1 if we should stop execution, since an expected error was encountered
          */
-        static inline size_t execute_GET_BIT(Composer* composer,
+        static inline size_t execute_GET_BIT(Builder* builder,
                                              std::vector<ExecutionHandler>& stack,
                                              Instruction& instruction)
         {
-            (void)composer;
+            (void)builder;
             if (stack.size() == 0) {
                 return 1;
             }
@@ -619,7 +619,7 @@ template <typename Composer> class BitArrayFuzzBase {
             size_t output_index = instruction.arguments.getBitArgs.out;
             const uint32_t bit = instruction.arguments.getBitArgs.bit;
             ExecutionHandler result;
-            result = stack[first_index].get_bit(composer, bit);
+            result = stack[first_index].get_bit(builder, bit);
             // If the output index is larger than the number of elements in stack, append
             if (output_index >= stack.size()) {
                 stack.push_back(result);
@@ -631,16 +631,16 @@ template <typename Composer> class BitArrayFuzzBase {
         /**
          * @brief Execute the SET_BIT instruction
          *
-         * @param composer
+         * @param builder
          * @param stack
          * @param instruction
          * @return if everything is ok, 1 if we should stop execution, since an expected error was encountered
          */
-        static inline size_t execute_SET_BIT(Composer* composer,
+        static inline size_t execute_SET_BIT(Builder* builder,
                                              std::vector<ExecutionHandler>& stack,
                                              Instruction& instruction)
         {
-            (void)composer;
+            (void)builder;
             if (stack.size() == 0) {
                 return 1;
             }
@@ -653,16 +653,16 @@ template <typename Composer> class BitArrayFuzzBase {
         /**
          * @brief Execute the SLICE instruction
          *
-         * @param composer
+         * @param builder
          * @param stack
          * @param instruction
          * @return if everything is ok, 1 if we should stop execution, since an expected error was encountered
          */
-        static inline size_t execute_SLICE(Composer* composer,
+        static inline size_t execute_SLICE(Builder* builder,
                                            std::vector<ExecutionHandler>& stack,
                                            Instruction& instruction)
         {
-            (void)composer;
+            (void)builder;
             if (stack.size() == 0) {
                 return 1;
             }
@@ -670,7 +670,7 @@ template <typename Composer> class BitArrayFuzzBase {
             size_t output_index = instruction.arguments.sliceArgs.out;
             const uint16_t offset = instruction.arguments.sliceArgs.offset;
             ExecutionHandler result;
-            result = stack[first_index].slice(composer, offset);
+            result = stack[first_index].slice(builder, offset);
             // If the output index is larger than the number of elements in stack, append
             if (output_index >= stack.size()) {
                 stack.push_back(result);
@@ -682,23 +682,23 @@ template <typename Composer> class BitArrayFuzzBase {
         /**
          * @brief Execute the SET instruction
          *
-         * @param composer
+         * @param builder
          * @param stack
          * @param instruction
          * @return if everything is ok, 1 if we should stop execution, since an expected error was encountered
          */
-        static inline size_t execute_SET(Composer* composer,
+        static inline size_t execute_SET(Builder* builder,
                                          std::vector<ExecutionHandler>& stack,
                                          Instruction& instruction)
         {
-            (void)composer;
+            (void)builder;
             if (stack.size() == 0) {
                 return 1;
             }
             size_t first_index = instruction.arguments.twoArgs.in % stack.size();
             size_t output_index = instruction.arguments.twoArgs.out;
             ExecutionHandler result;
-            result = stack[first_index].set(composer);
+            result = stack[first_index].set(builder);
             // If the output index is larger than the number of elements in stack, append
             if (output_index >= stack.size()) {
                 stack.push_back(result);
@@ -710,16 +710,16 @@ template <typename Composer> class BitArrayFuzzBase {
         /**
          * @brief Execute the RANDOMSEED instruction
          *
-         * @param composer
+         * @param builder
          * @param stack
          * @param instruction
          * @return if everything is ok, 1 if we should stop execution, since an expected error was encountered
          */
-        static inline size_t execute_RANDOMSEED(Composer* composer,
+        static inline size_t execute_RANDOMSEED(Builder* builder,
                                                 std::vector<ExecutionHandler>& stack,
                                                 Instruction& instruction)
         {
-            (void)composer;
+            (void)builder;
             (void)stack;
 
             VarianceRNG.reseed(instruction.arguments.randomseed);
@@ -731,15 +731,15 @@ template <typename Composer> class BitArrayFuzzBase {
     /**
      * @brief Check that the resulting values are equal to expected
      *
-     * @tparam Composer
-     * @param composer
+     * @tparam Builder
+     * @param builder
      * @param stack
      * @return true
      * @return false
      */
-    inline static bool postProcess(Composer* composer, std::vector<BitArrayFuzzBase::ExecutionHandler>& stack)
+    inline static bool postProcess(Builder* builder, std::vector<BitArrayFuzzBase::ExecutionHandler>& stack)
     {
-        (void)composer;
+        (void)builder;
         for (size_t i = 0; i < stack.size(); i++) {
             auto element = stack[i];
             const auto other = from_to<std::string, std::vector<uint8_t>>(element.bit_array.get_witness_as_string());
@@ -920,7 +920,7 @@ extern "C" size_t LLVMFuzzerCustomCrossOver(const uint8_t* Data1,
  */
 extern "C" size_t LLVMFuzzerTestOneInput(const uint8_t* Data, size_t Size)
 {
-    RunWithComposers<BitArrayFuzzBase, FuzzerCircuitTypes>(Data, Size, VarianceRNG);
+    RunWithBuilders<BitArrayFuzzBase, FuzzerCircuitTypes>(Data, Size, VarianceRNG);
     return 0;
 }
 
diff --git a/barretenberg/cpp/src/barretenberg/stdlib/primitives/bit_array/bit_array.hpp b/barretenberg/cpp/src/barretenberg/stdlib/primitives/bit_array/bit_array.hpp
index 40dbf049064..4e07b0ad10b 100644
--- a/barretenberg/cpp/src/barretenberg/stdlib/primitives/bit_array/bit_array.hpp
+++ b/barretenberg/cpp/src/barretenberg/stdlib/primitives/bit_array/bit_array.hpp
@@ -6,14 +6,14 @@
 namespace proof_system::plonk {
 namespace stdlib {
 
-template <typename ComposerContext> class bit_array {
+template <typename Builder> class bit_array {
   public:
-    bit_array(ComposerContext* parent_context, const size_t n);
-    bit_array(ComposerContext* parent_context, const std::string& input);
-    bit_array(ComposerContext* parent_context, const std::vector<uint8_t>& input);
-    bit_array(const std::vector<uint32<ComposerContext>>& input);
-    bit_array(uint32<ComposerContext> const& input);
-    bit_array(byte_array<ComposerContext> const& input)
+    bit_array(Builder* parent_context, const size_t n);
+    bit_array(Builder* parent_context, const std::string& input);
+    bit_array(Builder* parent_context, const std::vector<uint8_t>& input);
+    bit_array(const std::vector<uint32<Builder>>& input);
+    bit_array(uint32<Builder> const& input);
+    bit_array(byte_array<Builder> const& input)
         : context(input.get_context())
         , length(input.size() * 8)
     {
@@ -22,10 +22,10 @@ template <typename ComposerContext> class bit_array {
         values.resize(num_bits);
         for (size_t i = 0; i < bytes.size(); ++i) {
             const auto byte = bytes[i];
-            field_t<ComposerContext> accumulator(0);
+            field_t<Builder> accumulator(0);
             for (size_t j = 0; j < 8; ++j) {
                 const auto bit_witness = uint256_t((uint256_t(byte.get_value()) >> (7 - j)) & uint256_t(1));
-                bool_t<ComposerContext> bit = witness_t<ComposerContext>(context, bit_witness);
+                bool_t<Builder> bit = witness_t<Builder>(context, bit_witness);
                 values[i * 8 + j] = bit;
                 accumulator *= 2;
                 accumulator += bit;
@@ -35,7 +35,7 @@ template <typename ComposerContext> class bit_array {
         std::reverse(values.begin(), values.end());
     }
 
-    template <size_t N> bit_array(const std::array<uint32<ComposerContext>, N>& input)
+    template <size_t N> bit_array(const std::array<uint32<Builder>, N>& input)
     {
         context = nullptr;
         for (const auto& x : input) {
@@ -62,41 +62,41 @@ template <typename ComposerContext> class bit_array {
     bit_array& operator=(const bit_array& other);
     bit_array& operator=(bit_array&& other);
 
-    bool_t<ComposerContext>& operator[](const size_t idx);
-    bool_t<ComposerContext> operator[](const size_t idx) const;
+    bool_t<Builder>& operator[](const size_t idx);
+    bool_t<Builder> operator[](const size_t idx) const;
 
-    explicit operator byte_array<ComposerContext>() const
+    explicit operator byte_array<Builder>() const
     {
 
-        std::vector<bool_t<ComposerContext>> rbits(values.rbegin(), values.rend());
+        std::vector<bool_t<Builder>> rbits(values.rbegin(), values.rend());
 
         const size_t num_bits = rbits.size();
         const size_t num_bytes = (num_bits / 8) + (num_bits % 8 != 0);
 
-        std::vector<field_t<ComposerContext>> values(num_bytes);
+        std::vector<field_t<Builder>> values(num_bytes);
 
         for (size_t i = 0; i < num_bytes; ++i) {
             size_t end = 8;
             if (i == num_bytes - 1 && (num_bits % 8 != 0)) {
                 end = num_bits % 8;
             }
-            field_t<ComposerContext> accumulator(0);
+            field_t<Builder> accumulator(0);
             for (size_t j = 0; j < end; ++j) {
                 const auto bit = rbits[i * 8 + j];
                 const uint256_t scaling_factor = uint256_t(1) << (end - j - 1);
-                accumulator += field_t<ComposerContext>(bit) * barretenberg::fr(scaling_factor);
+                accumulator += field_t<Builder>(bit) * barretenberg::fr(scaling_factor);
             }
             values[i] = accumulator;
         }
         return byte_array(context, values);
     };
 
-    template <size_t N> operator std::array<uint32<ComposerContext>, N>()
+    template <size_t N> operator std::array<uint32<Builder>, N>()
     {
         // ASSERT(N * 32 == length);
-        std::array<uint32<ComposerContext>, N> output;
+        std::array<uint32<Builder>, N> output;
         for (size_t i = 0; i < N; ++i) {
-            std::array<bool_t<ComposerContext>, 32> bools;
+            std::array<bool_t<Builder>, 32> bools;
             size_t end;
             size_t start;
             start = ((N - i) * 32) - 32;
@@ -106,18 +106,17 @@ template <typename ComposerContext> class bit_array {
             }
             if (start + 32 > length) {
                 for (size_t j = end; j < start + 32; ++j) {
-                    bools[j - start] = bool_t<ComposerContext>(context, false);
+                    bools[j - start] = bool_t<Builder>(context, false);
                 }
             }
-            output[i] = uint32<ComposerContext>(context, bools);
+            output[i] = uint32<Builder>(context, bools);
         }
         return output;
     }
 
-    std::vector<uint32<ComposerContext>> to_uint32_vector();
+    std::vector<uint32<Builder>> to_uint32_vector();
 
-    template <size_t N>
-    void populate_uint32_array(const size_t starting_index, std::array<uint32<ComposerContext>, N>& output)
+    template <size_t N> void populate_uint32_array(const size_t starting_index, std::array<uint32<Builder>, N>& output)
     {
         // ASSERT(N * 32 == (length - starting_index));
 
@@ -126,7 +125,7 @@ template <typename ComposerContext> class bit_array {
 
         size_t count = 0;
         for (size_t i = (0); i < num_selected_uint32s; ++i) {
-            std::array<bool_t<ComposerContext>, 32> bools;
+            std::array<bool_t<Builder>, 32> bools;
             size_t end;
             size_t start;
             start = ((num_uint32s - i) * 32) - 32;
@@ -136,11 +135,11 @@ template <typename ComposerContext> class bit_array {
             }
             if (start + 32 > length) {
                 for (size_t j = end; j < start + 32; ++j) {
-                    bools[j - start] = bool_t<ComposerContext>(context, false);
+                    bools[j - start] = bool_t<Builder>(context, false);
                 }
             }
 
-            output[count] = uint32<ComposerContext>(context, bools);
+            output[count] = uint32<Builder>(context, bools);
             ++count;
         }
     }
@@ -149,7 +148,7 @@ template <typename ComposerContext> class bit_array {
 
     size_t size() const { return length; }
 
-    ComposerContext* get_context() const { return context; }
+    Builder* get_context() const { return context; }
 
     void print() const
     {
@@ -168,16 +167,16 @@ template <typename ComposerContext> class bit_array {
         printf(" ]\n");
     }
 
-    std::vector<bool_t<ComposerContext>> get_bits() const
+    std::vector<bool_t<Builder>> get_bits() const
     {
-        const std::vector<bool_t<ComposerContext>> result(values.begin(), values.end());
+        const std::vector<bool_t<Builder>> result(values.begin(), values.end());
         return result;
     }
 
   private:
-    ComposerContext* context;
+    Builder* context;
     size_t length;
-    std::vector<bool_t<ComposerContext>> values;
+    std::vector<bool_t<Builder>> values;
 };
 
 EXTERN_STDLIB_TYPE(bit_array);
diff --git a/barretenberg/cpp/src/barretenberg/stdlib/primitives/bit_array/bit_array.test.cpp b/barretenberg/cpp/src/barretenberg/stdlib/primitives/bit_array/bit_array.test.cpp
index 230b618e504..1d4bfa2f0a8 100644
--- a/barretenberg/cpp/src/barretenberg/stdlib/primitives/bit_array/bit_array.test.cpp
+++ b/barretenberg/cpp/src/barretenberg/stdlib/primitives/bit_array/bit_array.test.cpp
@@ -9,13 +9,13 @@
 #pragma GCC diagnostic ignored "-Wunused-local-typedefs"
 
 #define STDLIB_TYPE_ALIASES                                                                                            \
-    using Composer = TypeParam;                                                                                        \
-    using witness_ct = stdlib::witness_t<Composer>;                                                                    \
-    using byte_array_ct = stdlib::byte_array<Composer>;                                                                \
-    using field_ct = stdlib::field_t<Composer>;                                                                        \
-    using uint32_ct = stdlib::uint32<Composer>;                                                                        \
-    using bit_array_ct = stdlib::bit_array<Composer>;                                                                  \
-    using bool_ct = stdlib::bool_t<Composer>;
+    using Builder = TypeParam;                                                                                         \
+    using witness_ct = stdlib::witness_t<Builder>;                                                                     \
+    using byte_array_ct = stdlib::byte_array<Builder>;                                                                 \
+    using field_ct = stdlib::field_t<Builder>;                                                                         \
+    using uint32_ct = stdlib::uint32<Builder>;                                                                         \
+    using bit_array_ct = stdlib::bit_array<Builder>;                                                                   \
+    using bool_ct = stdlib::bool_t<Builder>;
 
 namespace test_stdlib_bit_array {
 
@@ -26,7 +26,7 @@ namespace {
 auto& engine = numeric::random::get_debug_engine();
 }
 
-template <class Composer> class BitArrayTest : public ::testing::Test {};
+template <class Builder> class BitArrayTest : public ::testing::Test {};
 
 using CircuitTypes = ::testing::
     Types<proof_system::StandardCircuitBuilder, proof_system::TurboCircuitBuilder, proof_system::UltraCircuitBuilder>;
@@ -35,13 +35,13 @@ TYPED_TEST_SUITE(BitArrayTest, CircuitTypes);
 TYPED_TEST(BitArrayTest, test_uint32_input_output_consistency)
 {
     STDLIB_TYPE_ALIASES
-    auto composer = Composer();
+    auto builder = Builder();
 
     uint32_t a_expected = engine.get_random_uint32();
     uint32_t b_expected = engine.get_random_uint32();
 
-    uint32_ct a = witness_ct(&composer, a_expected);
-    uint32_ct b = witness_ct(&composer, b_expected);
+    uint32_ct a = witness_ct(&builder, a_expected);
+    uint32_ct b = witness_ct(&builder, b_expected);
 
     std::vector<uint32_ct> inputs = { a, b };
     bit_array_ct test_bit_array = bit_array_ct(inputs);
@@ -51,9 +51,9 @@ TYPED_TEST(BitArrayTest, test_uint32_input_output_consistency)
     EXPECT_EQ(result.size(), 2UL);
 
     auto a_result =
-        static_cast<uint32_t>(composer.get_variable(result[0].get_witness_index()).from_montgomery_form().data[0]);
+        static_cast<uint32_t>(builder.get_variable(result[0].get_witness_index()).from_montgomery_form().data[0]);
     auto b_result =
-        static_cast<uint32_t>(composer.get_variable(result[1].get_witness_index()).from_montgomery_form().data[0]);
+        static_cast<uint32_t>(builder.get_variable(result[1].get_witness_index()).from_montgomery_form().data[0]);
 
     EXPECT_EQ(a_result, a_expected);
     EXPECT_EQ(b_result, b_expected);
@@ -62,22 +62,22 @@ TYPED_TEST(BitArrayTest, test_uint32_input_output_consistency)
 TYPED_TEST(BitArrayTest, test_binary_input_output_consistency)
 {
     STDLIB_TYPE_ALIASES
-    auto composer = Composer();
+    auto builder = Builder();
 
-    bit_array_ct test_bit_array = bit_array_ct(&composer, 5);
+    bit_array_ct test_bit_array = bit_array_ct(&builder, 5);
 
-    test_bit_array[0] = bool_ct(witness_ct(&composer, true));
-    test_bit_array[1] = bool_ct(witness_ct(&composer, false));
-    test_bit_array[2] = bool_ct(witness_ct(&composer, true));
-    test_bit_array[3] = bool_ct(witness_ct(&composer, true));
-    test_bit_array[4] = bool_ct(witness_ct(&composer, false));
+    test_bit_array[0] = bool_ct(witness_ct(&builder, true));
+    test_bit_array[1] = bool_ct(witness_ct(&builder, false));
+    test_bit_array[2] = bool_ct(witness_ct(&builder, true));
+    test_bit_array[3] = bool_ct(witness_ct(&builder, true));
+    test_bit_array[4] = bool_ct(witness_ct(&builder, false));
 
     std::vector<uint32_ct> uint32_vec = test_bit_array.to_uint32_vector();
 
     EXPECT_EQ(uint32_vec.size(), 1UL);
 
     auto result =
-        static_cast<uint32_t>(composer.get_variable(uint32_vec[0].get_witness_index()).from_montgomery_form().data[0]);
+        static_cast<uint32_t>(builder.get_variable(uint32_vec[0].get_witness_index()).from_montgomery_form().data[0]);
 
     auto expected = 0b01101;
     EXPECT_EQ(result, expected);
@@ -86,10 +86,10 @@ TYPED_TEST(BitArrayTest, test_binary_input_output_consistency)
 TYPED_TEST(BitArrayTest, test_string_input_output_consistency)
 {
     STDLIB_TYPE_ALIASES
-    auto composer = Composer();
+    auto builder = Builder();
 
     std::string expected = "string literals inside a SNARK circuit? What nonsense!";
-    bit_array_ct test_bit_array = bit_array_ct(&composer, expected);
+    bit_array_ct test_bit_array = bit_array_ct(&builder, expected);
 
     std::string result = test_bit_array.get_witness_as_string();
 
@@ -99,10 +99,10 @@ TYPED_TEST(BitArrayTest, test_string_input_output_consistency)
 TYPED_TEST(BitArrayTest, test_byte_array_conversion)
 {
     STDLIB_TYPE_ALIASES
-    auto composer = Composer();
+    auto builder = Builder();
 
     std::string expected = "string literals inside a SNARK circuit? What nonsense!";
-    bit_array_ct test_bit_array = bit_array_ct(&composer, expected);
+    bit_array_ct test_bit_array = bit_array_ct(&builder, expected);
 
     byte_array_ct test_bytes(test_bit_array);
     bit_array_ct test_output(test_bytes);
@@ -114,13 +114,13 @@ TYPED_TEST(BitArrayTest, test_byte_array_conversion)
 TYPED_TEST(BitArrayTest, test_uint32_vector_constructor)
 {
     STDLIB_TYPE_ALIASES
-    auto composer = Composer();
+    auto builder = Builder();
 
     uint32_t a_expected = engine.get_random_uint32();
     uint32_t b_expected = engine.get_random_uint32();
 
-    uint32_ct a = witness_ct(&composer, a_expected);
-    uint32_ct b = witness_ct(&composer, b_expected);
+    uint32_ct a = witness_ct(&builder, a_expected);
+    uint32_ct b = witness_ct(&builder, b_expected);
 
     std::vector<uint32_ct> inputs = { a, b };
     bit_array_ct test_bit_array = bit_array_ct(inputs);
diff --git a/barretenberg/cpp/src/barretenberg/stdlib/primitives/bool/bool.cpp b/barretenberg/cpp/src/barretenberg/stdlib/primitives/bool/bool.cpp
index 0ee6c3ef8ad..75d41f19d7b 100644
--- a/barretenberg/cpp/src/barretenberg/stdlib/primitives/bool/bool.cpp
+++ b/barretenberg/cpp/src/barretenberg/stdlib/primitives/bool/bool.cpp
@@ -7,16 +7,16 @@ using namespace proof_system;
 namespace proof_system::plonk {
 namespace stdlib {
 
-template <typename ComposerContext>
-bool_t<ComposerContext>::bool_t(const bool value)
+template <typename Builder>
+bool_t<Builder>::bool_t(const bool value)
     : context(nullptr)
     , witness_bool(value)
     , witness_inverted(false)
     , witness_index(IS_CONSTANT)
 {}
 
-template <typename ComposerContext>
-bool_t<ComposerContext>::bool_t(ComposerContext* parent_context)
+template <typename Builder>
+bool_t<Builder>::bool_t(Builder* parent_context)
     : context(parent_context)
 {
     witness_bool = false;
@@ -24,8 +24,8 @@ bool_t<ComposerContext>::bool_t(ComposerContext* parent_context)
     witness_index = IS_CONSTANT;
 }
 
-template <typename ComposerContext>
-bool_t<ComposerContext>::bool_t(const witness_t<ComposerContext>& value)
+template <typename Builder>
+bool_t<Builder>::bool_t(const witness_t<Builder>& value)
     : context(value.context)
 {
     ASSERT((value.witness == barretenberg::fr::zero()) || (value.witness == barretenberg::fr::one()));
@@ -35,8 +35,8 @@ bool_t<ComposerContext>::bool_t(const witness_t<ComposerContext>& value)
     witness_inverted = false;
 }
 
-template <typename ComposerContext>
-bool_t<ComposerContext>::bool_t(ComposerContext* parent_context, const bool value)
+template <typename Builder>
+bool_t<Builder>::bool_t(Builder* parent_context, const bool value)
     : context(parent_context)
 {
     context = parent_context;
@@ -45,8 +45,8 @@ bool_t<ComposerContext>::bool_t(ComposerContext* parent_context, const bool valu
     witness_inverted = false;
 }
 
-template <typename ComposerContext>
-bool_t<ComposerContext>::bool_t(const bool_t<ComposerContext>& other)
+template <typename Builder>
+bool_t<Builder>::bool_t(const bool_t<Builder>& other)
     : context(other.context)
 {
     witness_index = other.witness_index;
@@ -54,8 +54,8 @@ bool_t<ComposerContext>::bool_t(const bool_t<ComposerContext>& other)
     witness_inverted = other.witness_inverted;
 }
 
-template <typename ComposerContext>
-bool_t<ComposerContext>::bool_t(bool_t<ComposerContext>&& other)
+template <typename Builder>
+bool_t<Builder>::bool_t(bool_t<Builder>&& other)
     : context(other.context)
 {
     witness_index = other.witness_index;
@@ -63,7 +63,7 @@ bool_t<ComposerContext>::bool_t(bool_t<ComposerContext>&& other)
     witness_inverted = other.witness_inverted;
 }
 
-template <typename ComposerContext> bool_t<ComposerContext>& bool_t<ComposerContext>::operator=(const bool other)
+template <typename Builder> bool_t<Builder>& bool_t<Builder>::operator=(const bool other)
 {
     context = nullptr;
     witness_index = IS_CONSTANT;
@@ -72,7 +72,7 @@ template <typename ComposerContext> bool_t<ComposerContext>& bool_t<ComposerCont
     return *this;
 }
 
-template <typename ComposerContext> bool_t<ComposerContext>& bool_t<ComposerContext>::operator=(const bool_t& other)
+template <typename Builder> bool_t<Builder>& bool_t<Builder>::operator=(const bool_t& other)
 {
     context = other.context;
     witness_index = other.witness_index;
@@ -81,7 +81,7 @@ template <typename ComposerContext> bool_t<ComposerContext>& bool_t<ComposerCont
     return *this;
 }
 
-template <typename ComposerContext> bool_t<ComposerContext>& bool_t<ComposerContext>::operator=(bool_t&& other)
+template <typename Builder> bool_t<Builder>& bool_t<Builder>::operator=(bool_t&& other)
 {
     context = other.context;
     witness_index = other.witness_index;
@@ -90,8 +90,7 @@ template <typename ComposerContext> bool_t<ComposerContext>& bool_t<ComposerCont
     return *this;
 }
 
-template <typename ComposerContext>
-bool_t<ComposerContext>& bool_t<ComposerContext>::operator=(const witness_t<ComposerContext>& other)
+template <typename Builder> bool_t<Builder>& bool_t<Builder>::operator=(const witness_t<Builder>& other)
 {
     ASSERT((other.witness == barretenberg::fr::one()) || (other.witness == barretenberg::fr::zero()));
     context = other.context;
@@ -102,10 +101,9 @@ bool_t<ComposerContext>& bool_t<ComposerContext>::operator=(const witness_t<Comp
     return *this;
 }
 
-template <typename ComposerContext>
-bool_t<ComposerContext> bool_t<ComposerContext>::operator&(const bool_t& other) const
+template <typename Builder> bool_t<Builder> bool_t<Builder>::operator&(const bool_t& other) const
 {
-    bool_t<ComposerContext> result(context == nullptr ? other.context : context);
+    bool_t<Builder> result(context == nullptr ? other.context : context);
     bool left = witness_inverted ^ witness_bool;
     bool right = other.witness_inverted ^ other.witness_bool;
 
@@ -162,7 +160,7 @@ bool_t<ComposerContext> bool_t<ComposerContext>::operator&(const bool_t& other)
         });
     } else if (witness_index != IS_CONSTANT && other.witness_index == IS_CONSTANT) {
         if (other.witness_bool ^ other.witness_inverted) {
-            result = bool_t<ComposerContext>(*this);
+            result = bool_t<Builder>(*this);
         } else {
             result.witness_bool = false;
             result.witness_inverted = false;
@@ -170,7 +168,7 @@ bool_t<ComposerContext> bool_t<ComposerContext>::operator&(const bool_t& other)
         }
     } else if (witness_index == IS_CONSTANT && other.witness_index != IS_CONSTANT) {
         if (witness_bool ^ witness_inverted) {
-            result = bool_t<ComposerContext>(other);
+            result = bool_t<Builder>(other);
         } else {
             result.witness_bool = false;
             result.witness_inverted = false;
@@ -184,10 +182,9 @@ bool_t<ComposerContext> bool_t<ComposerContext>::operator&(const bool_t& other)
     return result;
 }
 
-template <typename ComposerContext>
-bool_t<ComposerContext> bool_t<ComposerContext>::operator|(const bool_t& other) const
+template <typename Builder> bool_t<Builder> bool_t<Builder>::operator|(const bool_t& other) const
 {
-    bool_t<ComposerContext> result(context == nullptr ? other.context : context);
+    bool_t<Builder> result(context == nullptr ? other.context : context);
 
     ASSERT(result.context || (witness_index == IS_CONSTANT && other.witness_index == IS_CONSTANT));
 
@@ -248,7 +245,7 @@ bool_t<ComposerContext> bool_t<ComposerContext>::operator|(const bool_t& other)
             result.witness_bool = true;
             result.witness_inverted = false;
         } else {
-            result = bool_t<ComposerContext>(*this);
+            result = bool_t<Builder>(*this);
         }
     } else if (witness_index == IS_CONSTANT && other.witness_index != IS_CONSTANT) {
         if (witness_bool ^ witness_inverted) {
@@ -256,7 +253,7 @@ bool_t<ComposerContext> bool_t<ComposerContext>::operator|(const bool_t& other)
             result.witness_bool = true;
             result.witness_inverted = false;
         } else {
-            result = bool_t<ComposerContext>(other);
+            result = bool_t<Builder>(other);
         }
     } else {
         result.witness_inverted = false;
@@ -265,10 +262,9 @@ bool_t<ComposerContext> bool_t<ComposerContext>::operator|(const bool_t& other)
     return result;
 }
 
-template <typename ComposerContext>
-bool_t<ComposerContext> bool_t<ComposerContext>::operator^(const bool_t& other) const
+template <typename Builder> bool_t<Builder> bool_t<Builder>::operator^(const bool_t& other) const
 {
-    bool_t<ComposerContext> result(context == nullptr ? other.context : context);
+    bool_t<Builder> result(context == nullptr ? other.context : context);
 
     ASSERT(result.context || (witness_index == IS_CONSTANT && other.witness_index == IS_CONSTANT));
 
@@ -308,15 +304,15 @@ bool_t<ComposerContext> bool_t<ComposerContext>::operator^(const bool_t& other)
     } else if (witness_index != IS_CONSTANT && other.witness_index == IS_CONSTANT) {
         // witness ^ 1 = !witness
         if (other.witness_bool ^ other.witness_inverted) {
-            result = !bool_t<ComposerContext>(*this);
+            result = !bool_t<Builder>(*this);
         } else {
-            result = bool_t<ComposerContext>(*this);
+            result = bool_t<Builder>(*this);
         }
     } else if (witness_index == IS_CONSTANT && other.witness_index != IS_CONSTANT) {
         if (witness_bool ^ witness_inverted) {
-            result = !bool_t<ComposerContext>(other);
+            result = !bool_t<Builder>(other);
         } else {
-            result = bool_t<ComposerContext>(other);
+            result = bool_t<Builder>(other);
         }
     } else {
         result.witness_inverted = false;
@@ -325,19 +321,18 @@ bool_t<ComposerContext> bool_t<ComposerContext>::operator^(const bool_t& other)
     return result;
 }
 
-template <typename ComposerContext> bool_t<ComposerContext> bool_t<ComposerContext>::operator!() const
+template <typename Builder> bool_t<Builder> bool_t<Builder>::operator!() const
 {
-    bool_t<ComposerContext> result(*this);
+    bool_t<Builder> result(*this);
     result.witness_inverted = !result.witness_inverted;
     return result;
 }
 
-template <typename ComposerContext>
-bool_t<ComposerContext> bool_t<ComposerContext>::operator==(const bool_t& other) const
+template <typename Builder> bool_t<Builder> bool_t<Builder>::operator==(const bool_t& other) const
 {
     ASSERT(context || other.context || (witness_index == IS_CONSTANT && other.witness_index == IS_CONSTANT));
     if ((other.witness_index == IS_CONSTANT) && (witness_index == IS_CONSTANT)) {
-        bool_t<ComposerContext> result(context == nullptr ? other.context : context);
+        bool_t<Builder> result(context == nullptr ? other.context : context);
         result.witness_bool = (witness_bool ^ witness_inverted) == (other.witness_bool ^ other.witness_inverted);
         result.witness_index = IS_CONSTANT;
         return result;
@@ -354,7 +349,7 @@ bool_t<ComposerContext> bool_t<ComposerContext>::operator==(const bool_t& other)
             return !(other);
         }
     } else {
-        bool_t<ComposerContext> result(context == nullptr ? other.context : context);
+        bool_t<Builder> result(context == nullptr ? other.context : context);
         result.witness_bool = (witness_bool ^ witness_inverted) == (other.witness_bool ^ other.witness_inverted);
         barretenberg::fr value = result.witness_bool ? barretenberg::fr::one() : barretenberg::fr::zero();
         result.witness_index = context->add_variable(value);
@@ -387,29 +382,25 @@ bool_t<ComposerContext> bool_t<ComposerContext>::operator==(const bool_t& other)
     }
 }
 
-template <typename ComposerContext>
-bool_t<ComposerContext> bool_t<ComposerContext>::operator!=(const bool_t<ComposerContext>& other) const
+template <typename Builder> bool_t<Builder> bool_t<Builder>::operator!=(const bool_t<Builder>& other) const
 {
     return operator^(other);
 }
 
-template <typename ComposerContext>
-bool_t<ComposerContext> bool_t<ComposerContext>::operator&&(const bool_t<ComposerContext>& other) const
+template <typename Builder> bool_t<Builder> bool_t<Builder>::operator&&(const bool_t<Builder>& other) const
 {
     return operator&(other);
 }
 
-template <typename ComposerContext>
-bool_t<ComposerContext> bool_t<ComposerContext>::operator||(const bool_t<ComposerContext>& other) const
+template <typename Builder> bool_t<Builder> bool_t<Builder>::operator||(const bool_t<Builder>& other) const
 {
     return operator|(other);
 }
 
-template <typename ComposerContext>
-void bool_t<ComposerContext>::assert_equal(const bool_t& rhs, std::string const& msg) const
+template <typename Builder> void bool_t<Builder>::assert_equal(const bool_t& rhs, std::string const& msg) const
 {
     const bool_t lhs = *this;
-    ComposerContext* ctx = lhs.get_context() ? lhs.get_context() : rhs.get_context();
+    Builder* ctx = lhs.get_context() ? lhs.get_context() : rhs.get_context();
 
     if (lhs.is_constant() && rhs.is_constant()) {
         ASSERT(lhs.get_value() == rhs.get_value());
@@ -434,16 +425,15 @@ void bool_t<ComposerContext>::assert_equal(const bool_t& rhs, std::string const&
 }
 
 // if predicate == true then return lhs, else return rhs
-template <typename ComposerContext>
-bool_t<ComposerContext> bool_t<ComposerContext>::conditional_assign(const bool_t<ComposerContext>& predicate,
-                                                                    const bool_t& lhs,
-                                                                    const bool_t& rhs)
+template <typename Builder>
+bool_t<Builder> bool_t<Builder>::conditional_assign(const bool_t<Builder>& predicate,
+                                                    const bool_t& lhs,
+                                                    const bool_t& rhs)
 {
     return (predicate && lhs) || (!predicate && rhs);
 }
 
-template <typename ComposerContext>
-bool_t<ComposerContext> bool_t<ComposerContext>::implies(const bool_t<ComposerContext>& other) const
+template <typename Builder> bool_t<Builder> bool_t<Builder>::implies(const bool_t<Builder>& other) const
 {
     return (!(*this) || other); // P => Q is equiv. to !P || Q (not(P) or Q).
 }
@@ -454,8 +444,7 @@ bool_t<ComposerContext> bool_t<ComposerContext>::implies(const bool_t<ComposerCo
  * <=>  !P || (Q && R)           [by distributivity of propositional logic]
  * <=>  P => (Q && R)            [a.k.a. distribution of implication over conjunction]
  */
-template <typename ComposerContext>
-void bool_t<ComposerContext>::must_imply(const bool_t& other, std::string const& msg) const
+template <typename Builder> void bool_t<Builder>::must_imply(const bool_t& other, std::string const& msg) const
 {
     (this->implies(other)).assert_equal(true, msg);
 }
@@ -471,25 +460,25 @@ void bool_t<ComposerContext>::must_imply(const bool_t& other, std::string const&
  * <=>  !P || (Q && R)           [by distributivity of propositional logic]
  * <=>  P => (Q && R)            [a.k.a. distribution of implication over conjunction]
  */
-template <typename ComposerContext>
-void bool_t<ComposerContext>::must_imply(const std::vector<std::pair<bool_t, std::string>>& conds) const
+template <typename Builder>
+void bool_t<Builder>::must_imply(const std::vector<std::pair<bool_t, std::string>>& conds) const
 {
-    // Extract the composer
+    // Extract the builder
     const bool_t this_bool = *this;
-    ComposerContext* ctx = this_bool.get_context();
-    bool composer_found = (ctx != nullptr);
+    Builder* ctx = this_bool.get_context();
+    bool builder_found = (ctx != nullptr);
     for (size_t i = 0; i < conds.size(); i++) {
-        if (!composer_found) {
+        if (!builder_found) {
             ctx = conds[i].first.get_context();
-            composer_found = (ctx != nullptr);
+            builder_found = (ctx != nullptr);
         }
     }
 
-    // If no composer is found, all of the bool_t's must be constants.
+    // If no builder is found, all of the bool_t's must be constants.
     // In that case, we enforce a static assertion to check must_imply condition holds.
     // If all of your inputs do this function are constants and they don't obey a condition,
     // this function will panic at those static assertions.
-    if (!composer_found) {
+    if (!builder_found) {
         bool is_const = this_bool.is_constant();
         bool result = !this_bool.get_value();
         bool acc = true;
@@ -526,13 +515,12 @@ void bool_t<ComposerContext>::must_imply(const std::vector<std::pair<bool_t, std
 
 // A "double-implication" (<=>),
 // a.k.a "iff", a.k.a. "biconditional"
-template <typename ComposerContext>
-bool_t<ComposerContext> bool_t<ComposerContext>::implies_both_ways(const bool_t<ComposerContext>& other) const
+template <typename Builder> bool_t<Builder> bool_t<Builder>::implies_both_ways(const bool_t<Builder>& other) const
 {
     return (!(*this) ^ other); // P <=> Q is equiv. to !(P ^ Q) (not(P xor Q)).
 }
 
-template <typename ComposerContext> bool_t<ComposerContext> bool_t<ComposerContext>::normalize() const
+template <typename Builder> bool_t<Builder> bool_t<Builder>::normalize() const
 {
     if (is_constant() || !witness_inverted) {
         return *this;
diff --git a/barretenberg/cpp/src/barretenberg/stdlib/primitives/bool/bool.fuzzer.hpp b/barretenberg/cpp/src/barretenberg/stdlib/primitives/bool/bool.fuzzer.hpp
index f516c802961..886fc1e9a46 100644
--- a/barretenberg/cpp/src/barretenberg/stdlib/primitives/bool/bool.fuzzer.hpp
+++ b/barretenberg/cpp/src/barretenberg/stdlib/primitives/bool/bool.fuzzer.hpp
@@ -25,10 +25,10 @@ FastRandom VarianceRNG(0);
  * @brief The class parametrizing ByteArray fuzzing instructions, execution, etc
  *
  */
-template <typename Composer> class BoolFuzzBase {
+template <typename Builder> class BoolFuzzBase {
   private:
-    typedef proof_system::plonk::stdlib::bool_t<Composer> bool_t;
-    typedef proof_system::plonk::stdlib::witness_t<Composer> witness_t;
+    typedef proof_system::plonk::stdlib::bool_t<Builder> bool_t;
+    typedef proof_system::plonk::stdlib::witness_t<Builder> witness_t;
 
   public:
     /**
@@ -388,9 +388,9 @@ template <typename Composer> class BoolFuzzBase {
         }
 
         /* Explicit re-instantiation using the various bit_array constructors */
-        ExecutionHandler set(Composer* composer)
+        ExecutionHandler set(Builder* builder)
         {
-            (void)composer;
+            (void)builder;
             switch (VarianceRNG.next() % 2) {
             case 0:
                 return ExecutionHandler(this->reference_value, bool_t(this->reference_value));
@@ -404,49 +404,49 @@ template <typename Composer> class BoolFuzzBase {
         /**
          * @brief Execute the constant instruction (push constant bool_t to the stack)
          *
-         * @param composer
+         * @param builder
          * @param stack
          * @param instruction
          * @return 0 if everything is ok, 1 if we should stop execution, since an expected error was encountered
          */
-        static inline size_t execute_CONSTANT(Composer* composer,
+        static inline size_t execute_CONSTANT(Builder* builder,
                                               std::vector<ExecutionHandler>& stack,
                                               Instruction& instruction)
         {
-            (void)composer;
-            stack.push_back(bool_t(composer, instruction.arguments.element));
+            (void)builder;
+            stack.push_back(bool_t(builder, instruction.arguments.element));
             return 0;
         }
         /**
          * @brief Execute the witness instruction (push witness bool_t to the stack)
          *
-         * @param composer
+         * @param builder
          * @param stack
          * @param instruction
          * @return if everything is ok, 1 if we should stop execution, since an expected error was encountered
          */
-        static inline size_t execute_WITNESS(Composer* composer,
+        static inline size_t execute_WITNESS(Builder* builder,
                                              std::vector<ExecutionHandler>& stack,
                                              Instruction& instruction)
         {
 
             stack.push_back(
-                ExecutionHandler(instruction.arguments.element, witness_t(composer, instruction.arguments.element)));
+                ExecutionHandler(instruction.arguments.element, witness_t(builder, instruction.arguments.element)));
             return 0;
         }
         /**
          * @brief Execute the and operator instruction
          *
-         * @param composer
+         * @param builder
          * @param stack
          * @param instruction
          * @return if everything is ok, 1 if we should stop execution, since an expected error was encountered
          */
-        static inline size_t execute_AND(Composer* composer,
+        static inline size_t execute_AND(Builder* builder,
                                          std::vector<ExecutionHandler>& stack,
                                          Instruction& instruction)
         {
-            (void)composer;
+            (void)builder;
             if (stack.size() == 0) {
                 return 1;
             }
@@ -467,16 +467,16 @@ template <typename Composer> class BoolFuzzBase {
         /**
          * @brief Execute the or operator instruction
          *
-         * @param composer
+         * @param builder
          * @param stack
          * @param instruction
          * @return if everything is ok, 1 if we should stop execution, since an expected error was encountered
          */
-        static inline size_t execute_OR(Composer* composer,
+        static inline size_t execute_OR(Builder* builder,
                                         std::vector<ExecutionHandler>& stack,
                                         Instruction& instruction)
         {
-            (void)composer;
+            (void)builder;
             if (stack.size() == 0) {
                 return 1;
             }
@@ -497,16 +497,16 @@ template <typename Composer> class BoolFuzzBase {
         /**
          * @brief Execute the xor operator instruction
          *
-         * @param composer
+         * @param builder
          * @param stack
          * @param instruction
          * @return if everything is ok, 1 if we should stop execution, since an expected error was encountered
          */
-        static inline size_t execute_XOR(Composer* composer,
+        static inline size_t execute_XOR(Builder* builder,
                                          std::vector<ExecutionHandler>& stack,
                                          Instruction& instruction)
         {
-            (void)composer;
+            (void)builder;
             if (stack.size() == 0) {
                 return 1;
             }
@@ -527,16 +527,16 @@ template <typename Composer> class BoolFuzzBase {
         /**
          * @brief Execute the NOT instruction
          *
-         * @param composer
+         * @param builder
          * @param stack
          * @param instruction
          * @return if everything is ok, 1 if we should stop execution, since an expected error was encountered
          */
-        static inline size_t execute_NOT(Composer* composer,
+        static inline size_t execute_NOT(Builder* builder,
                                          std::vector<ExecutionHandler>& stack,
                                          Instruction& instruction)
         {
-            (void)composer;
+            (void)builder;
             if (stack.size() == 0) {
                 return 1;
             }
@@ -556,16 +556,16 @@ template <typename Composer> class BoolFuzzBase {
         /**
          * @brief Execute the SELECT_IF_EQ instruction
          *
-         * @param composer
+         * @param builder
          * @param stack
          * @param instruction
          * @return if everything is ok, 1 if we should stop execution, since an expected error was encountered
          */
-        static inline size_t execute_SELECT_IF_EQ(Composer* composer,
+        static inline size_t execute_SELECT_IF_EQ(Builder* builder,
                                                   std::vector<ExecutionHandler>& stack,
                                                   Instruction& instruction)
         {
-            (void)composer;
+            (void)builder;
             if (stack.size() == 0) {
                 return 1;
             }
@@ -587,16 +587,16 @@ template <typename Composer> class BoolFuzzBase {
         /**
          * @brief Execute the ASSERT_EQUAL  instruction
          *
-         * @param composer
+         * @param builder
          * @param stack
          * @param instruction
          * @return if everything is ok, 1 if we should stop execution, since an expected error was encountered
          */
-        static inline size_t execute_ASSERT_EQUAL(Composer* composer,
+        static inline size_t execute_ASSERT_EQUAL(Builder* builder,
                                                   std::vector<ExecutionHandler>& stack,
                                                   Instruction& instruction)
         {
-            (void)composer;
+            (void)builder;
             if (stack.size() == 0) {
                 return 1;
             }
@@ -609,23 +609,23 @@ template <typename Composer> class BoolFuzzBase {
         /**
          * @brief Execute the SET instruction
          *
-         * @param composer
+         * @param builder
          * @param stack
          * @param instruction
          * @return if everything is ok, 1 if we should stop execution, since an expected error was encountered
          */
-        static inline size_t execute_SET(Composer* composer,
+        static inline size_t execute_SET(Builder* builder,
                                          std::vector<ExecutionHandler>& stack,
                                          Instruction& instruction)
         {
-            (void)composer;
+            (void)builder;
             if (stack.size() == 0) {
                 return 1;
             }
             size_t first_index = instruction.arguments.twoArgs.in % stack.size();
             size_t output_index = instruction.arguments.twoArgs.out;
             ExecutionHandler result;
-            result = stack[first_index].set(composer);
+            result = stack[first_index].set(builder);
             // If the output index is larger than the number of elements in stack, append
             if (output_index >= stack.size()) {
                 stack.push_back(result);
@@ -637,16 +637,16 @@ template <typename Composer> class BoolFuzzBase {
         /**
          * @brief Execute the RANDOMSEED instruction
          *
-         * @param composer
+         * @param builder
          * @param stack
          * @param instruction
          * @return if everything is ok, 1 if we should stop execution, since an expected error was encountered
          */
-        static inline size_t execute_RANDOMSEED(Composer* composer,
+        static inline size_t execute_RANDOMSEED(Builder* builder,
                                                 std::vector<ExecutionHandler>& stack,
                                                 Instruction& instruction)
         {
-            (void)composer;
+            (void)builder;
             (void)stack;
 
             VarianceRNG.reseed(instruction.arguments.randomseed);
@@ -658,15 +658,15 @@ template <typename Composer> class BoolFuzzBase {
     /**
      * @brief Check that the resulting values are equal to expected
      *
-     * @tparam Composer
-     * @param composer
+     * @tparam Builder
+     * @param builder
      * @param stack
      * @return true
      * @return false
      */
-    inline static bool postProcess(Composer* composer, std::vector<BoolFuzzBase::ExecutionHandler>& stack)
+    inline static bool postProcess(Builder* builder, std::vector<BoolFuzzBase::ExecutionHandler>& stack)
     {
-        (void)composer;
+        (void)builder;
         for (size_t i = 0; i < stack.size(); i++) {
             auto element = stack[i];
             if (element.b.get_value() != element.reference_value) {
@@ -838,7 +838,7 @@ extern "C" size_t LLVMFuzzerCustomCrossOver(const uint8_t* Data1,
  */
 extern "C" size_t LLVMFuzzerTestOneInput(const uint8_t* Data, size_t Size)
 {
-    RunWithComposers<BoolFuzzBase, FuzzerCircuitTypes>(Data, Size, VarianceRNG);
+    RunWithBuilders<BoolFuzzBase, FuzzerCircuitTypes>(Data, Size, VarianceRNG);
     return 0;
 }
 
diff --git a/barretenberg/cpp/src/barretenberg/stdlib/primitives/bool/bool.hpp b/barretenberg/cpp/src/barretenberg/stdlib/primitives/bool/bool.hpp
index 4550342c21b..6e567925e33 100644
--- a/barretenberg/cpp/src/barretenberg/stdlib/primitives/bool/bool.hpp
+++ b/barretenberg/cpp/src/barretenberg/stdlib/primitives/bool/bool.hpp
@@ -4,17 +4,17 @@
 
 namespace proof_system::plonk::stdlib {
 
-template <typename ComposerContext> class bool_t {
+template <typename Builder> class bool_t {
   public:
     bool_t(const bool value = false);
-    bool_t(ComposerContext* parent_context);
-    bool_t(ComposerContext* parent_context, const bool value);
-    bool_t(const witness_t<ComposerContext>& value);
+    bool_t(Builder* parent_context);
+    bool_t(Builder* parent_context, const bool value);
+    bool_t(const witness_t<Builder>& value);
     bool_t(const bool_t& other);
     bool_t(bool_t&& other);
 
     bool_t& operator=(const bool other);
-    bool_t& operator=(const witness_t<ComposerContext>& other);
+    bool_t& operator=(const witness_t<Builder>& other);
     bool_t& operator=(const bool_t& other);
     bool_t& operator=(bool_t&& other);
 
@@ -50,7 +50,7 @@ template <typename ComposerContext> class bool_t {
     // assertions
     void assert_equal(const bool_t& rhs, std::string const& msg = "bool_t::assert_equal") const;
 
-    static bool_t conditional_assign(const bool_t<ComposerContext>& predicate, const bool_t& lhs, const bool_t& rhs);
+    static bool_t conditional_assign(const bool_t<Builder>& predicate, const bool_t& lhs, const bool_t& rhs);
 
     void must_imply(const bool_t& other, std::string const& msg = "bool_t::must_imply") const;
 
@@ -62,9 +62,9 @@ template <typename ComposerContext> class bool_t {
 
     bool_t normalize() const;
 
-    ComposerContext* get_context() const { return context; }
+    Builder* get_context() const { return context; }
 
-    mutable ComposerContext* context = nullptr;
+    mutable Builder* context = nullptr;
     mutable bool witness_bool = false;
     mutable bool witness_inverted = false;
     mutable uint32_t witness_index = IS_CONSTANT;
diff --git a/barretenberg/cpp/src/barretenberg/stdlib/primitives/bool/bool.test.cpp b/barretenberg/cpp/src/barretenberg/stdlib/primitives/bool/bool.test.cpp
index 424be906180..ffc856ca210 100644
--- a/barretenberg/cpp/src/barretenberg/stdlib/primitives/bool/bool.test.cpp
+++ b/barretenberg/cpp/src/barretenberg/stdlib/primitives/bool/bool.test.cpp
@@ -4,9 +4,9 @@
 #include <gtest/gtest.h>
 
 #define STDLIB_TYPE_ALIASES                                                                                            \
-    using Composer = TypeParam;                                                                                        \
-    using witness_ct = stdlib::witness_t<Composer>;                                                                    \
-    using bool_ct = stdlib::bool_t<Composer>;
+    using Builder = TypeParam;                                                                                         \
+    using witness_ct = stdlib::witness_t<Builder>;                                                                     \
+    using bool_ct = stdlib::bool_t<Builder>;
 
 namespace test_stdlib_bool {
 using namespace barretenberg;
@@ -16,7 +16,7 @@ namespace {
 auto& engine = numeric::random::get_debug_engine();
 }
 
-template <class Composer> class BoolTest : public ::testing::Test {};
+template <class Builder> class BoolTest : public ::testing::Test {};
 
 using CircuitTypes = ::testing::
     Types<proof_system::StandardCircuitBuilder, proof_system::TurboCircuitBuilder, proof_system::UltraCircuitBuilder>;
@@ -26,12 +26,12 @@ TYPED_TEST(BoolTest, TestBasicOperations)
 {
 
     STDLIB_TYPE_ALIASES
-    auto composer = Composer();
+    auto builder = Builder();
 
-    auto gates_before = composer.get_num_gates();
+    auto gates_before = builder.get_num_gates();
 
-    bool_ct a = witness_ct(&composer, barretenberg::fr::one());
-    bool_ct b = witness_ct(&composer, barretenberg::fr::zero());
+    bool_ct a = witness_ct(&builder, barretenberg::fr::one());
+    bool_ct b = witness_ct(&builder, barretenberg::fr::zero());
     a = a ^ b; // a = 1
     EXPECT_EQ(a.get_value(), 1);
     b = !b; // b = 1 (witness 0)
@@ -47,17 +47,17 @@ TYPED_TEST(BoolTest, TestBasicOperations)
     d = (!f) & a; // d = 1
     EXPECT_EQ(d.get_value(), 1);
 
-    bool result = composer.check_circuit();
+    bool result = builder.check_circuit();
     EXPECT_EQ(result, true);
 
-    auto gates_after = composer.get_num_gates();
+    auto gates_after = builder.get_num_gates();
     EXPECT_EQ(gates_after - gates_before, 6UL);
 }
 
 TYPED_TEST(BoolTest, Xor)
 {
     STDLIB_TYPE_ALIASES
-    auto composer = Composer();
+    auto builder = Builder();
 
     for (size_t j = 0; j < 4; ++j) {
         bool lhs_constant = (bool)(j % 2);
@@ -66,169 +66,169 @@ TYPED_TEST(BoolTest, Xor)
         for (size_t i = 0; i < 4; ++i) {
             bool a_val = (bool)(i % 2);
             bool b_val = (bool)(i > 1 ? true : false);
-            bool_ct a = lhs_constant ? bool_ct(a_val) : (witness_ct(&composer, a_val));
-            bool_ct b = rhs_constant ? bool_ct(b_val) : (witness_ct(&composer, b_val));
+            bool_ct a = lhs_constant ? bool_ct(a_val) : (witness_ct(&builder, a_val));
+            bool_ct b = rhs_constant ? bool_ct(b_val) : (witness_ct(&builder, b_val));
             bool_ct c = a ^ b;
             EXPECT_EQ(c.get_value(), a.get_value() ^ b.get_value());
         }
     }
-    bool result = composer.check_circuit();
+    bool result = builder.check_circuit();
     EXPECT_EQ(result, true);
 }
 
 TYPED_TEST(BoolTest, XorConstants)
 {
     STDLIB_TYPE_ALIASES
-    auto composer = Composer();
+    auto builder = Builder();
 
     for (size_t i = 0; i < 32; ++i) {
-        bool_ct a = witness_ct(&composer, (bool)(i % 2));
-        bool_ct b = witness_ct(&composer, (bool)(i % 3 == 1));
+        bool_ct a = witness_ct(&builder, (bool)(i % 2));
+        bool_ct b = witness_ct(&builder, (bool)(i % 3 == 1));
         a ^ b;
     }
     for (size_t i = 0; i < 32; ++i) {
         if (i % 2 == 0) {
-            bool_ct a = witness_ct(&composer, (bool)(i % 2));
-            bool_ct b(&composer, (bool)(i % 3 == 1));
+            bool_ct a = witness_ct(&builder, (bool)(i % 2));
+            bool_ct b(&builder, (bool)(i % 3 == 1));
             a ^ b;
         } else {
-            bool_ct a(&composer, (bool)(i % 2));
-            bool_ct b = witness_ct(&composer, (bool)(i % 3 == 1));
+            bool_ct a(&builder, (bool)(i % 2));
+            bool_ct b = witness_ct(&builder, (bool)(i % 3 == 1));
             a ^ b;
         }
     }
 
-    bool result = composer.check_circuit();
+    bool result = builder.check_circuit();
     EXPECT_EQ(result, true);
 }
 
 TYPED_TEST(BoolTest, XorTwinConstants)
 {
     STDLIB_TYPE_ALIASES
-    auto composer = Composer();
+    auto builder = Builder();
 
     bool_ct c;
     for (size_t i = 0; i < 32; ++i) {
-        bool_ct a(&composer, (i % 1) == 0);
-        bool_ct b(&composer, (i % 1) == 1);
+        bool_ct a(&builder, (i % 1) == 0);
+        bool_ct b(&builder, (i % 1) == 1);
         c = c ^ a ^ b;
     }
-    c = c ^ bool_ct(witness_ct(&composer, true));
+    c = c ^ bool_ct(witness_ct(&builder, true));
     for (size_t i = 0; i < 32; ++i) {
         if (i % 2 == 0) {
-            bool_ct a = witness_ct(&composer, (bool)(i % 2));
-            bool_ct b(&composer, (bool)(i % 3 == 1));
+            bool_ct a = witness_ct(&builder, (bool)(i % 2));
+            bool_ct b(&builder, (bool)(i % 3 == 1));
             c = c ^ a ^ b;
         } else {
-            bool_ct a(&composer, (bool)(i % 2));
-            bool_ct b = witness_ct(&composer, (bool)(i % 3 == 1));
+            bool_ct a(&builder, (bool)(i % 2));
+            bool_ct b = witness_ct(&builder, (bool)(i % 3 == 1));
             c = c ^ a ^ b;
         }
     }
 
-    bool result = composer.check_circuit();
+    bool result = builder.check_circuit();
     EXPECT_EQ(result, true);
 }
 
 TYPED_TEST(BoolTest, LogicalAnd)
 {
     STDLIB_TYPE_ALIASES
-    auto composer = Composer();
+    auto builder = Builder();
 
-    bool_ct a = witness_ct(&composer, 1);
-    bool_ct b = witness_ct(&composer, 1);
+    bool_ct a = witness_ct(&builder, 1);
+    bool_ct b = witness_ct(&builder, 1);
     (!a) && (!b);
 
-    bool result = composer.check_circuit();
+    bool result = builder.check_circuit();
     EXPECT_EQ(result, true);
 }
 
 TYPED_TEST(BoolTest, And)
 {
     STDLIB_TYPE_ALIASES
-    auto composer = Composer();
+    auto builder = Builder();
 
     for (size_t i = 0; i < 32; ++i) {
-        bool_ct a = witness_ct(&composer, (bool)(i % 1));
-        bool_ct b = witness_ct(&composer, (bool)(i % 2 == 1));
+        bool_ct a = witness_ct(&builder, (bool)(i % 1));
+        bool_ct b = witness_ct(&builder, (bool)(i % 2 == 1));
         a& b;
     }
 
-    bool result = composer.check_circuit();
+    bool result = builder.check_circuit();
     EXPECT_EQ(result, true);
 }
 
 TYPED_TEST(BoolTest, AndConstants)
 {
     STDLIB_TYPE_ALIASES
-    auto composer = Composer();
+    auto builder = Builder();
 
     for (size_t i = 0; i < 32; ++i) {
-        bool_ct a = witness_ct(&composer, (bool)(i % 2));
-        bool_ct b = witness_ct(&composer, (bool)(i % 3 == 1));
+        bool_ct a = witness_ct(&builder, (bool)(i % 2));
+        bool_ct b = witness_ct(&builder, (bool)(i % 3 == 1));
         a& b;
     }
     for (size_t i = 0; i < 32; ++i) {
         if (i % 2 == 0) {
-            bool_ct a = witness_ct(&composer, (bool)(i % 2));
-            bool_ct b(&composer, (bool)(i % 3 == 1));
+            bool_ct a = witness_ct(&builder, (bool)(i % 2));
+            bool_ct b(&builder, (bool)(i % 3 == 1));
             a& b;
         } else {
-            bool_ct a(&composer, (bool)(i % 2));
-            bool_ct b = witness_ct(&composer, (bool)(i % 3 == 1));
+            bool_ct a(&builder, (bool)(i % 2));
+            bool_ct b = witness_ct(&builder, (bool)(i % 3 == 1));
             a& b;
         }
     }
 
-    bool result = composer.check_circuit();
+    bool result = builder.check_circuit();
     EXPECT_EQ(result, true);
 }
 
 TYPED_TEST(BoolTest, or)
 {
     STDLIB_TYPE_ALIASES
-    auto composer = Composer();
+    auto builder = Builder();
 
     for (size_t i = 0; i < 32; ++i) {
-        bool_ct a = witness_ct(&composer, (bool)(i % 2));
-        bool_ct b = witness_ct(&composer, (bool)(i % 3 == 1));
+        bool_ct a = witness_ct(&builder, (bool)(i % 2));
+        bool_ct b = witness_ct(&builder, (bool)(i % 3 == 1));
         a | b;
     }
 
-    bool result = composer.check_circuit();
+    bool result = builder.check_circuit();
     EXPECT_EQ(result, true);
 }
 
 TYPED_TEST(BoolTest, OrConstants)
 {
     STDLIB_TYPE_ALIASES
-    auto composer = Composer();
+    auto builder = Builder();
 
     for (size_t i = 0; i < 32; ++i) {
-        bool_ct a = witness_ct(&composer, (bool)(i % 2));
-        bool_ct b = witness_ct(&composer, (bool)(i % 3 == 1));
+        bool_ct a = witness_ct(&builder, (bool)(i % 2));
+        bool_ct b = witness_ct(&builder, (bool)(i % 3 == 1));
         a | b;
     }
     for (size_t i = 0; i < 32; ++i) {
         if (i % 2 == 0) {
-            bool_ct a = witness_ct(&composer, (bool)(i % 2));
-            bool_ct b(&composer, (bool)(i % 3 == 1));
+            bool_ct a = witness_ct(&builder, (bool)(i % 2));
+            bool_ct b(&builder, (bool)(i % 3 == 1));
             a | b;
         } else {
-            bool_ct a(&composer, (bool)(i % 2));
-            bool_ct b = witness_ct(&composer, (bool)(i % 3 == 1));
+            bool_ct a(&builder, (bool)(i % 2));
+            bool_ct b = witness_ct(&builder, (bool)(i % 3 == 1));
             a | b;
         }
     }
 
-    bool result = composer.check_circuit();
+    bool result = builder.check_circuit();
     EXPECT_EQ(result, true);
 }
 
 TYPED_TEST(BoolTest, Eq)
 {
     STDLIB_TYPE_ALIASES
-    auto composer = Composer();
+    auto builder = Builder();
 
     bool a_alt[32];
     bool b_alt[32];
@@ -253,13 +253,13 @@ TYPED_TEST(BoolTest, Eq)
     bool_ct d[32];
     for (size_t i = 0; i < 32; ++i) {
         if (i % 2 == 0) {
-            a[i] = witness_ct(&composer, (bool)(i % 2));
-            b[i] = witness_ct(&composer, (bool)(0));
+            a[i] = witness_ct(&builder, (bool)(i % 2));
+            b[i] = witness_ct(&builder, (bool)(0));
             c[i] = a[i] ^ b[i];
             d[i] = a[i] == c[i];
         } else {
-            a[i] = witness_ct(&composer, (bool)(1));
-            b[i] = witness_ct(&composer, (bool)(0));
+            a[i] = witness_ct(&builder, (bool)(1));
+            b[i] = witness_ct(&builder, (bool)(0));
             c[i] = a[i] & b[i];
             d[i] = a[i] == c[i];
         }
@@ -271,14 +271,14 @@ TYPED_TEST(BoolTest, Eq)
         EXPECT_EQ(d[i].get_value(), d_alt[i]);
     }
 
-    bool result = composer.check_circuit();
+    bool result = builder.check_circuit();
     EXPECT_EQ(result, true);
 }
 
 TYPED_TEST(BoolTest, Implies)
 {
     STDLIB_TYPE_ALIASES
-    auto composer = Composer();
+    auto builder = Builder();
 
     for (size_t j = 0; j < 4; ++j) {
         bool lhs_constant = (bool)(j % 2);
@@ -287,21 +287,21 @@ TYPED_TEST(BoolTest, Implies)
         for (size_t i = 0; i < 4; ++i) {
             bool a_val = (bool)(i % 2);
             bool b_val = (bool)(i > 1 ? true : false);
-            bool_ct a = lhs_constant ? bool_ct(a_val) : (witness_ct(&composer, a_val));
-            bool_ct b = rhs_constant ? bool_ct(b_val) : (witness_ct(&composer, b_val));
+            bool_ct a = lhs_constant ? bool_ct(a_val) : (witness_ct(&builder, a_val));
+            bool_ct b = rhs_constant ? bool_ct(b_val) : (witness_ct(&builder, b_val));
             bool_ct c = a.implies(b);
             EXPECT_EQ(c.get_value(), !a.get_value() || b.get_value());
         }
     }
 
-    bool result = composer.check_circuit();
+    bool result = builder.check_circuit();
     EXPECT_EQ(result, true);
 }
 
 TYPED_TEST(BoolTest, ImpliesBothWays)
 {
     STDLIB_TYPE_ALIASES
-    auto composer = Composer();
+    auto builder = Builder();
 
     for (size_t j = 0; j < 4; ++j) {
         bool lhs_constant = (bool)(j % 2);
@@ -310,21 +310,21 @@ TYPED_TEST(BoolTest, ImpliesBothWays)
         for (size_t i = 0; i < 4; ++i) {
             bool a_val = (bool)(i % 2);
             bool b_val = (bool)(i > 1 ? true : false);
-            bool_ct a = lhs_constant ? bool_ct(a_val) : (witness_ct(&composer, a_val));
-            bool_ct b = rhs_constant ? bool_ct(b_val) : (witness_ct(&composer, b_val));
+            bool_ct a = lhs_constant ? bool_ct(a_val) : (witness_ct(&builder, a_val));
+            bool_ct b = rhs_constant ? bool_ct(b_val) : (witness_ct(&builder, b_val));
             bool_ct c = a.implies_both_ways(b);
             EXPECT_EQ(c.get_value(), !(a.get_value() ^ b.get_value()));
         }
     }
 
-    bool result = composer.check_circuit();
+    bool result = builder.check_circuit();
     EXPECT_EQ(result, true);
 }
 
 TYPED_TEST(BoolTest, MustImply)
 {
     STDLIB_TYPE_ALIASES
-    auto composer = Composer();
+    auto builder = Builder();
 
     for (size_t j = 0; j < 4; ++j) {
         bool lhs_constant = (bool)(j % 2);
@@ -337,20 +337,20 @@ TYPED_TEST(BoolTest, MustImply)
             bool six = (bool)(i % 6);
             bool a_val = (two && three);
             bool b_val = six;
-            bool_ct a = lhs_constant ? bool_ct(a_val) : (witness_ct(&composer, a_val));
-            bool_ct b = rhs_constant ? bool_ct(b_val) : (witness_ct(&composer, b_val));
+            bool_ct a = lhs_constant ? bool_ct(a_val) : (witness_ct(&builder, a_val));
+            bool_ct b = rhs_constant ? bool_ct(b_val) : (witness_ct(&builder, b_val));
             a.must_imply(b);
         }
     }
 
-    bool result = composer.check_circuit();
+    bool result = builder.check_circuit();
     EXPECT_EQ(result, true);
 }
 
 TYPED_TEST(BoolTest, MustImplyFails)
 {
     STDLIB_TYPE_ALIASES
-    auto composer = Composer();
+    auto builder = Builder();
 
     for (size_t j = 0; j < 3; ++j) { // ignore the case when both lhs and rhs are constants
         bool lhs_constant = (bool)(j % 2);
@@ -361,19 +361,19 @@ TYPED_TEST(BoolTest, MustImplyFails)
         const size_t i = 8;
         bool a_val = (bool)(i % 2 == 0);
         bool b_val = (bool)(i % 6 == 0);
-        bool_ct a = lhs_constant ? bool_ct(a_val) : (witness_ct(&composer, a_val));
-        bool_ct b = rhs_constant ? bool_ct(b_val) : (witness_ct(&composer, b_val));
+        bool_ct a = lhs_constant ? bool_ct(a_val) : (witness_ct(&builder, a_val));
+        bool_ct b = rhs_constant ? bool_ct(b_val) : (witness_ct(&builder, b_val));
         a.must_imply(b, "div by 2 does not imply div by 8");
 
-        EXPECT_EQ(composer.failed(), true);
-        EXPECT_EQ(composer.err(), "div by 2 does not imply div by 8");
+        EXPECT_EQ(builder.failed(), true);
+        EXPECT_EQ(builder.err(), "div by 2 does not imply div by 8");
     }
 }
 
 TYPED_TEST(BoolTest, MustImplyMultiple)
 {
     STDLIB_TYPE_ALIASES
-    auto composer = Composer();
+    auto builder = Builder();
 
     /**
      * Define g(x) = 2x + 12
@@ -394,8 +394,8 @@ TYPED_TEST(BoolTest, MustImplyMultiple)
             bool four = (bool)(x % 4 == 0);
             bool six = (bool)(x % 6 == 0);
 
-            bool_ct a = lhs_constant ? bool_ct(four) : (witness_ct(&composer, four));
-            bool_ct b = rhs_constant ? bool_ct(six) : (witness_ct(&composer, six));
+            bool_ct a = lhs_constant ? bool_ct(four) : (witness_ct(&builder, four));
+            bool_ct b = rhs_constant ? bool_ct(six) : (witness_ct(&builder, six));
 
             auto g_x = g(x);
             conditions.push_back(std::make_pair(g_x > 0, "g(x) > 0"));
@@ -405,10 +405,10 @@ TYPED_TEST(BoolTest, MustImplyMultiple)
 
             (a && b).must_imply(conditions);
 
-            if (composer.failed()) {
-                EXPECT_EQ(composer.err(), "multi implication fail: g(x) is a multiple of 6");
+            if (builder.failed()) {
+                EXPECT_EQ(builder.err(), "multi implication fail: g(x) is a multiple of 6");
             } else {
-                bool result = composer.check_circuit();
+                bool result = builder.check_circuit();
                 EXPECT_EQ(result, true);
             }
         }
@@ -418,7 +418,7 @@ TYPED_TEST(BoolTest, MustImplyMultiple)
 TYPED_TEST(BoolTest, MustImplyMultipleFails)
 {
     STDLIB_TYPE_ALIASES
-    auto composer = Composer();
+    auto builder = Builder();
 
     /**
      * Given x = 15:
@@ -432,24 +432,24 @@ TYPED_TEST(BoolTest, MustImplyMultipleFails)
 
         size_t x = 15;
         bool main = (bool)(x > 10);
-        bool_ct main_ct = is_constant ? bool_ct(main) : (witness_ct(&composer, main));
+        bool_ct main_ct = is_constant ? bool_ct(main) : (witness_ct(&builder, main));
 
         std::vector<std::pair<bool_ct, std::string>> conditions;
-        conditions.push_back(std::make_pair(witness_ct(&composer, x > 8), "x > 8"));
-        conditions.push_back(std::make_pair(witness_ct(&composer, x > 5), "x > 5"));
-        conditions.push_back(std::make_pair(witness_ct(&composer, x > 18), "x > 18"));
+        conditions.push_back(std::make_pair(witness_ct(&builder, x > 8), "x > 8"));
+        conditions.push_back(std::make_pair(witness_ct(&builder, x > 5), "x > 5"));
+        conditions.push_back(std::make_pair(witness_ct(&builder, x > 18), "x > 18"));
 
         main_ct.must_imply(conditions);
 
-        EXPECT_EQ(composer.failed(), true);
-        EXPECT_EQ(composer.err(), "multi implication fail: x > 18");
+        EXPECT_EQ(builder.failed(), true);
+        EXPECT_EQ(builder.err(), "multi implication fail: x > 18");
     }
 }
 
 TYPED_TEST(BoolTest, ConditionalAssign)
 {
     STDLIB_TYPE_ALIASES
-    auto composer = Composer();
+    auto builder = Builder();
 
     for (size_t j = 0; j < 4; ++j) {
         bool lhs_constant = (bool)(j % 2);
@@ -461,40 +461,40 @@ TYPED_TEST(BoolTest, ConditionalAssign)
         bool condition = (val % 2 == 0);
         bool right = x < val;
         bool left = x > val;
-        bool_ct l_ct = lhs_constant ? bool_ct(left) : (witness_ct(&composer, left));
-        bool_ct r_ct = rhs_constant ? bool_ct(right) : (witness_ct(&composer, right));
-        bool_ct cond = (witness_ct(&composer, condition));
+        bool_ct l_ct = lhs_constant ? bool_ct(left) : (witness_ct(&builder, left));
+        bool_ct r_ct = rhs_constant ? bool_ct(right) : (witness_ct(&builder, right));
+        bool_ct cond = (witness_ct(&builder, condition));
 
         auto result = bool_ct::conditional_assign(cond, l_ct, r_ct);
 
         EXPECT_EQ(result.get_value(), condition ? left : right);
     }
-    info("composer gates = ", composer.get_num_gates());
-    bool result = composer.check_circuit();
+    info("num gates = ", builder.get_num_gates());
+    bool result = builder.check_circuit();
     EXPECT_EQ(result, true);
 }
 
 TYPED_TEST(BoolTest, TestSimpleProof)
 {
     STDLIB_TYPE_ALIASES
-    auto composer = Composer();
+    auto builder = Builder();
 
-    bool_ct a(&composer);
-    bool_ct b(&composer);
-    a = witness_ct(&composer, barretenberg::fr::one());
-    b = witness_ct(&composer, barretenberg::fr::zero());
-    // bool_ct c(&composer);
+    bool_ct a(&builder);
+    bool_ct b(&builder);
+    a = witness_ct(&builder, barretenberg::fr::one());
+    b = witness_ct(&builder, barretenberg::fr::zero());
+    // bool_ct c(&builder);
     a = a ^ b;            // a = 1
     b = !b;               // b = 1 (witness 0)
     bool_ct c = (a == b); // c = 1
-    bool_ct d(&composer); // d = ?
+    bool_ct d(&builder);  // d = ?
     d = false;            // d = 0
     bool_ct e = a | d;    // e = 1 = a
     bool_ct f = e ^ b;    // f = 0
     d = (!f) & a;         // d = 1
     for (size_t i = 0; i < 64; ++i) {
-        a = witness_ct(&composer, (bool)(i % 2));
-        b = witness_ct(&composer, (bool)(i % 3 == 1));
+        a = witness_ct(&builder, (bool)(i % 2));
+        b = witness_ct(&builder, (bool)(i % 3 == 1));
         c = a ^ b;
         a = b ^ c;
         c = a;
@@ -502,17 +502,17 @@ TYPED_TEST(BoolTest, TestSimpleProof)
         f = b;
     }
 
-    bool result = composer.check_circuit();
+    bool result = builder.check_circuit();
     EXPECT_EQ(result, true);
 }
 
 TYPED_TEST(BoolTest, Normalize)
 {
     STDLIB_TYPE_ALIASES
-    auto composer = Composer();
+    auto builder = Builder();
 
-    auto generate_constraints = [&composer](bool value, bool is_constant, bool is_inverted) {
-        bool_ct a = is_constant ? bool_ct(&composer, value) : witness_ct(&composer, value);
+    auto generate_constraints = [&builder](bool value, bool is_constant, bool is_inverted) {
+        bool_ct a = is_constant ? bool_ct(&builder, value) : witness_ct(&builder, value);
         bool_ct b = is_inverted ? !a : a;
         bool_ct c = b.normalize();
         EXPECT_EQ(c.get_value(), value ^ is_inverted);
@@ -527,7 +527,7 @@ TYPED_TEST(BoolTest, Normalize)
     generate_constraints(true, true, false);
     generate_constraints(true, true, true);
 
-    bool result = composer.check_circuit();
+    bool result = builder.check_circuit();
     EXPECT_EQ(result, true);
 }
 } // namespace test_stdlib_bool
\ No newline at end of file
diff --git a/barretenberg/cpp/src/barretenberg/stdlib/primitives/byte_array/byte_array.cpp b/barretenberg/cpp/src/barretenberg/stdlib/primitives/byte_array/byte_array.cpp
index 083ca758a57..0f4933640bd 100644
--- a/barretenberg/cpp/src/barretenberg/stdlib/primitives/byte_array/byte_array.cpp
+++ b/barretenberg/cpp/src/barretenberg/stdlib/primitives/byte_array/byte_array.cpp
@@ -11,19 +11,19 @@ namespace stdlib {
 
 // ULTRA: Further merging with
 
-template <typename Composer>
-byte_array<Composer>::byte_array(Composer* parent_context)
+template <typename Builder>
+byte_array<Builder>::byte_array(Builder* parent_context)
     : context(parent_context)
 {}
 
-template <typename Composer>
-byte_array<Composer>::byte_array(Composer* parent_context, const size_t n)
+template <typename Builder>
+byte_array<Builder>::byte_array(Builder* parent_context, const size_t n)
     : context(parent_context)
-    , values(std::vector<field_t<Composer>>(n))
+    , values(std::vector<field_t<Builder>>(n))
 {}
 
-template <typename Composer>
-byte_array<Composer>::byte_array(Composer* parent_context, const std::string& input)
+template <typename Builder>
+byte_array<Builder>::byte_array(Builder* parent_context, const std::string& input)
     : byte_array(parent_context, std::vector<uint8_t>(input.begin(), input.end()))
 {}
 
@@ -33,14 +33,14 @@ byte_array<Composer>::byte_array(Composer* parent_context, const std::string& in
  * @warning This constructor will instantiate each byte as a circuit witness, NOT a circuit constant.
  * Do not use this method if the input needs to be hardcoded for a specific circuit
  **/
-template <typename Composer>
-byte_array<Composer>::byte_array(Composer* parent_context, std::vector<uint8_t> const& input)
+template <typename Builder>
+byte_array<Builder>::byte_array(Builder* parent_context, std::vector<uint8_t> const& input)
     : context(parent_context)
     , values(input.size())
 {
     for (size_t i = 0; i < input.size(); ++i) {
         uint8_t c = input[i];
-        field_t<Composer> value(witness_t(context, (uint64_t)c));
+        field_t<Builder> value(witness_t(context, (uint64_t)c));
         value.create_range_constraint(8, "byte_array: vector entry larger than 1 byte.");
         values[i] = value;
     }
@@ -91,7 +91,7 @@ byte_array<Composer>::byte_array(Composer* parent_context, std::vector<uint8_t>
  *      y_hi := s_hi - v_hi - y_overlap,
  * range constrianing y_hi to 128 bits imposes validator < r.
  */
-template <typename Composer> byte_array<Composer>::byte_array(const field_t<Composer>& input, const size_t num_bytes)
+template <typename Builder> byte_array<Builder>::byte_array(const field_t<Builder>& input, const size_t num_bytes)
 {
     ASSERT(num_bytes <= 32);
     uint256_t value = input.get_value();
@@ -103,19 +103,19 @@ template <typename Composer> byte_array<Composer>::byte_array(const field_t<Comp
         }
     } else {
         constexpr barretenberg::fr byte_shift(256);
-        field_t<Composer> validator(context, 0);
+        field_t<Builder> validator(context, 0);
 
-        field_t<Composer> shifted_high_limb(context, 0); // will be set to 2^128v_hi if `i` reaches 15.
+        field_t<Builder> shifted_high_limb(context, 0); // will be set to 2^128v_hi if `i` reaches 15.
         for (size_t i = 0; i < num_bytes; ++i) {
             barretenberg::fr byte_val = value.slice((num_bytes - i - 1) * 8, (num_bytes - i) * 8);
-            field_t<Composer> byte = witness_t(context, byte_val);
+            field_t<Builder> byte = witness_t(context, byte_val);
             byte.create_range_constraint(8, "byte_array: byte extraction failed.");
             barretenberg::fr scaling_factor_value = byte_shift.pow(static_cast<uint64_t>(num_bytes - 1 - i));
-            field_t<Composer> scaling_factor(context, scaling_factor_value);
+            field_t<Builder> scaling_factor(context, scaling_factor_value);
             validator = validator + (scaling_factor * byte);
             values[i] = byte;
             if (i == 15) {
-                shifted_high_limb = field_t<Composer>(validator);
+                shifted_high_limb = field_t<Builder>(validator);
             }
         }
         validator.assert_equal(input);
@@ -126,17 +126,17 @@ template <typename Composer> byte_array<Composer>::byte_array(const field_t<Comp
             const fr s_lo = modulus_minus_one.slice(0, 128);
             const fr s_hi = modulus_minus_one.slice(128, 256);
             const fr shift = fr(uint256_t(1) << 128);
-            field_t<Composer> y_lo = (-validator) + (s_lo + shift);
+            field_t<Builder> y_lo = (-validator) + (s_lo + shift);
 
-            field_t<Composer> y_overlap;
-            if constexpr (HasPlookup<Composer>) {
+            field_t<Builder> y_overlap;
+            if constexpr (HasPlookup<Builder>) {
                 // carve out the 2 high bits from (y_lo + shifted_high_limb) and instantiate as y_overlap
                 const uint256_t y_lo_value = y_lo.get_value() + shifted_high_limb.get_value();
                 const uint256_t y_overlap_value = y_lo_value >> 128;
-                y_overlap = witness_t<Composer>(context, y_overlap_value);
+                y_overlap = witness_t<Builder>(context, y_overlap_value);
                 y_overlap.create_range_constraint(2, "byte_array: y_overlap is not a quad");
-                field_t<Composer> y_remainder =
-                    y_lo.add_two(shifted_high_limb, -(y_overlap * field_t<Composer>(uint256_t(1ULL) << 128)));
+                field_t<Builder> y_remainder =
+                    y_lo.add_two(shifted_high_limb, -(y_overlap * field_t<Builder>(uint256_t(1ULL) << 128)));
                 y_remainder.create_range_constraint(128, "byte_array: y_remainder doesn't fit in 128 bits.");
                 y_overlap = -(y_overlap - 1);
             } else {
@@ -146,55 +146,55 @@ template <typename Composer> byte_array<Composer>::byte_array(const field_t<Comp
                 // The range constraint imposed here already holds implicitly. We only do this to get the top quad.
                 const auto low_accumulators = context->decompose_into_base4_accumulators(
                     y_lo.normalize().witness_index, 130, "byte_array: normalized y_lo too large.");
-                y_overlap = -(field_t<Composer>::from_witness_index(context, low_accumulators[0]) - 1);
+                y_overlap = -(field_t<Builder>::from_witness_index(context, low_accumulators[0]) - 1);
             }
             // define input_hi = shifted_high_limb/shift. We know input_hi is max 128 bits, and we're checking
             // s_hi - (input_hi + borrow) is non-negative
-            field_t<Composer> y_hi = -(shifted_high_limb / shift) + (s_hi);
+            field_t<Builder> y_hi = -(shifted_high_limb / shift) + (s_hi);
             y_hi -= y_overlap;
             y_hi.create_range_constraint(128, "byte_array: y_hi doesn't fit in 128 bits.");
         }
     }
 }
 
-template <typename Composer>
-byte_array<Composer>::byte_array(const safe_uint_t<Composer>& input, const size_t num_bytes)
+template <typename Builder>
+byte_array<Builder>::byte_array(const safe_uint_t<Builder>& input, const size_t num_bytes)
     : byte_array(input.value, num_bytes)
 {}
 
-template <typename Composer>
-byte_array<Composer>::byte_array(Composer* parent_context, bytes_t const& input)
+template <typename Builder>
+byte_array<Builder>::byte_array(Builder* parent_context, bytes_t const& input)
     : context(parent_context)
     , values(input)
 {}
 
-template <typename Composer>
-byte_array<Composer>::byte_array(Composer* parent_context, bytes_t&& input)
+template <typename Builder>
+byte_array<Builder>::byte_array(Builder* parent_context, bytes_t&& input)
     : context(parent_context)
     , values(input)
 {}
 
-template <typename Composer> byte_array<Composer>::byte_array(const byte_array& other)
+template <typename Builder> byte_array<Builder>::byte_array(const byte_array& other)
 {
     context = other.context;
     std::copy(other.values.begin(), other.values.end(), std::back_inserter(values));
 }
 
-template <typename Composer> byte_array<Composer>::byte_array(byte_array&& other)
+template <typename Builder> byte_array<Builder>::byte_array(byte_array&& other)
 {
     context = other.context;
     values = std::move(other.values);
 }
 
-template <typename Composer> byte_array<Composer>& byte_array<Composer>::operator=(const byte_array& other)
+template <typename Builder> byte_array<Builder>& byte_array<Builder>::operator=(const byte_array& other)
 {
     context = other.context;
-    values = std::vector<field_t<Composer>>();
+    values = std::vector<field_t<Builder>>();
     std::copy(other.values.begin(), other.values.end(), std::back_inserter(values));
     return *this;
 }
 
-template <typename Composer> byte_array<Composer>& byte_array<Composer>::operator=(byte_array&& other)
+template <typename Builder> byte_array<Builder>& byte_array<Builder>::operator=(byte_array&& other)
 {
     context = other.context;
     values = std::move(other.values);
@@ -209,27 +209,27 @@ template <typename Composer> byte_array<Composer>& byte_array<Composer>::operato
  * Larger byte arrays can still be cast to a single field element, but the value will wrap around the circuit
  *modulus
  **/
-template <typename Composer> byte_array<Composer>::operator field_t<Composer>() const
+template <typename Builder> byte_array<Builder>::operator field_t<Builder>() const
 {
     const size_t bytes = values.size();
     barretenberg::fr shift(256);
-    field_t<Composer> result(context, barretenberg::fr(0));
+    field_t<Builder> result(context, barretenberg::fr(0));
     for (size_t i = 0; i < values.size(); ++i) {
-        field_t<Composer> temp(values[i]);
+        field_t<Builder> temp(values[i]);
         barretenberg::fr scaling_factor_value = shift.pow(static_cast<uint64_t>(bytes - 1 - i));
-        field_t<Composer> scaling_factor(values[i].context, scaling_factor_value);
+        field_t<Builder> scaling_factor(values[i].context, scaling_factor_value);
         result = result + (scaling_factor * temp);
     }
     return result.normalize();
 }
 
-template <typename Composer> byte_array<Composer>& byte_array<Composer>::write(byte_array const& other)
+template <typename Builder> byte_array<Builder>& byte_array<Builder>::write(byte_array const& other)
 {
     values.insert(values.end(), other.bytes().begin(), other.bytes().end());
     return *this;
 }
 
-template <typename Composer> byte_array<Composer>& byte_array<Composer>::write_at(byte_array const& other, size_t index)
+template <typename Builder> byte_array<Builder>& byte_array<Builder>::write_at(byte_array const& other, size_t index)
 {
     ASSERT(index + other.values.size() <= values.size());
     for (size_t i = 0; i < other.values.size(); i++) {
@@ -238,7 +238,7 @@ template <typename Composer> byte_array<Composer>& byte_array<Composer>::write_a
     return *this;
 }
 
-template <typename Composer> byte_array<Composer> byte_array<Composer>::slice(size_t offset) const
+template <typename Builder> byte_array<Builder> byte_array<Builder>::slice(size_t offset) const
 {
     ASSERT(offset < values.size());
     return byte_array(context, bytes_t(values.begin() + (long)(offset), values.end()));
@@ -248,7 +248,7 @@ template <typename Composer> byte_array<Composer> byte_array<Composer>::slice(si
  * @brief Slice `length` bytes from the byte array, starting at `offset`. Does not add any constraints
  * @details Note that the syntax here differs for the syntax used for slicing uint256_t's.
  **/
-template <typename Composer> byte_array<Composer> byte_array<Composer>::slice(size_t offset, size_t length) const
+template <typename Builder> byte_array<Builder> byte_array<Builder>::slice(size_t offset, size_t length) const
 {
     ASSERT(offset < values.size());
     // it's <= cause vector constructor doesn't include end point
@@ -261,7 +261,7 @@ template <typename Composer> byte_array<Composer> byte_array<Composer>::slice(si
 /**
  * @brief Reverse the bytes in the byte array
  **/
-template <typename Composer> byte_array<Composer> byte_array<Composer>::reverse() const
+template <typename Builder> byte_array<Builder> byte_array<Builder>::reverse() const
 {
     bytes_t bytes(values.size());
     size_t offset = bytes.size() - 1;
@@ -271,7 +271,7 @@ template <typename Composer> byte_array<Composer> byte_array<Composer>::reverse(
     return byte_array(context, bytes);
 }
 
-template <typename Composer> std::vector<uint8_t> byte_array<Composer>::get_value() const
+template <typename Builder> std::vector<uint8_t> byte_array<Builder>::get_value() const
 {
     size_t length = values.size();
     size_t num = (length);
@@ -282,7 +282,7 @@ template <typename Composer> std::vector<uint8_t> byte_array<Composer>::get_valu
     return bytes;
 }
 
-template <typename Composer> std::string byte_array<Composer>::get_string() const
+template <typename Builder> std::string byte_array<Builder>::get_string() const
 {
     auto v = get_value();
     return std::string(v.begin(), v.end());
@@ -295,7 +295,7 @@ template <typename Composer> std::string byte_array<Composer>::get_string() cons
  * e.g. get_bit(1) corresponds to the second bit in the last, 'least significant' byte in the array.
  *
  **/
-template <typename Composer> bool_t<Composer> byte_array<Composer>::get_bit(size_t index_reversed) const
+template <typename Builder> bool_t<Builder> byte_array<Builder>::get_bit(size_t index_reversed) const
 {
     const size_t index = (values.size() * 8) - index_reversed - 1;
     const auto slice = split_byte(index);
@@ -317,14 +317,14 @@ template <typename Composer> bool_t<Composer> byte_array<Composer>::get_bit(size
  * The rationale behind reversing the bit index is so that we can more naturally contain integers inside byte arrays
  *and perform bit manipulation
  **/
-template <typename Composer> void byte_array<Composer>::set_bit(size_t index_reversed, bool_t<Composer> const& new_bit)
+template <typename Builder> void byte_array<Builder>::set_bit(size_t index_reversed, bool_t<Builder> const& new_bit)
 {
     const size_t index = (values.size() * 8) - index_reversed - 1;
     const auto slice = split_byte(index);
     const size_t byte_index = index / 8UL;
     const size_t bit_index = 7UL - (index % 8UL);
 
-    field_t<Composer> scaled_new_bit = field_t<Composer>(new_bit) * barretenberg::fr(uint256_t(1) << bit_index);
+    field_t<Builder> scaled_new_bit = field_t<Builder>(new_bit) * barretenberg::fr(uint256_t(1) << bit_index);
     const auto new_value = slice.low.add_two(slice.high, scaled_new_bit).normalize();
     values[byte_index] = new_value;
 }
@@ -334,8 +334,8 @@ template <typename Composer> void byte_array<Composer>::set_bit(size_t index_rev
  *
  * @details This is a private method used by `get_bit` and `set_bit`
  **/
-template <typename Composer>
-typename byte_array<Composer>::byte_slice byte_array<Composer>::split_byte(const size_t index) const
+template <typename Builder>
+typename byte_array<Builder>::byte_slice byte_array<Builder>::split_byte(const size_t index) const
 {
     const size_t byte_index = index / 8UL;
     const auto byte = values[byte_index];
@@ -350,14 +350,14 @@ typename byte_array<Composer>::byte_slice byte_array<Composer>::split_byte(const
     const uint64_t high_value = (bit_index == 7) ? 0ULL : (value >> (8 - num_high_bits));
 
     if (byte.is_constant()) {
-        field_t<Composer> low(context, low_value);
-        field_t<Composer> high(context, high_value);
-        bool_t<Composer> bit(context, static_cast<bool>(bit_value));
+        field_t<Builder> low(context, low_value);
+        field_t<Builder> high(context, high_value);
+        bool_t<Builder> bit(context, static_cast<bool>(bit_value));
         return { low, high, bit };
     }
-    field_t<Composer> low = witness_t<Composer>(context, low_value);
-    field_t<Composer> high = witness_t<Composer>(context, high_value);
-    bool_t<Composer> bit = witness_t<Composer>(context, static_cast<bool>(bit_value));
+    field_t<Builder> low = witness_t<Builder>(context, low_value);
+    field_t<Builder> high = witness_t<Builder>(context, high_value);
+    bool_t<Builder> bit = witness_t<Builder>(context, static_cast<bool>(bit_value));
 
     if (num_low_bits > 0) {
         low.create_range_constraint(static_cast<size_t>(num_low_bits), "byte_array: low bits split off incorrectly.");
@@ -372,9 +372,9 @@ typename byte_array<Composer>::byte_slice byte_array<Composer>::split_byte(const
         high.assert_equal(0);
     }
 
-    field_t<Composer> scaled_high = high * barretenberg::fr(uint256_t(1) << (8ULL - num_high_bits));
-    field_t<Composer> scaled_bit = field_t<Composer>(bit) * barretenberg::fr(uint256_t(1) << bit_index);
-    field_t<Composer> result = low.add_two(scaled_high, scaled_bit);
+    field_t<Builder> scaled_high = high * barretenberg::fr(uint256_t(1) << (8ULL - num_high_bits));
+    field_t<Builder> scaled_bit = field_t<Builder>(bit) * barretenberg::fr(uint256_t(1) << bit_index);
+    field_t<Builder> result = low.add_two(scaled_high, scaled_bit);
     result.assert_equal(byte);
 
     return { low, scaled_high, bit };
diff --git a/barretenberg/cpp/src/barretenberg/stdlib/primitives/byte_array/byte_array.fuzzer.hpp b/barretenberg/cpp/src/barretenberg/stdlib/primitives/byte_array/byte_array.fuzzer.hpp
index 1680e94b7f5..6aa4d3f3657 100644
--- a/barretenberg/cpp/src/barretenberg/stdlib/primitives/byte_array/byte_array.fuzzer.hpp
+++ b/barretenberg/cpp/src/barretenberg/stdlib/primitives/byte_array/byte_array.fuzzer.hpp
@@ -29,11 +29,11 @@ FastRandom VarianceRNG(0);
  * @brief The class parametrizing ByteArray fuzzing instructions, execution, etc
  *
  */
-template <typename Composer> class ByteArrayFuzzBase {
+template <typename Builder> class ByteArrayFuzzBase {
   private:
-    typedef proof_system::plonk::stdlib::byte_array<Composer> byte_array_t;
-    typedef proof_system::plonk::stdlib::field_t<Composer> field_t;
-    typedef proof_system::plonk::stdlib::safe_uint_t<Composer> suint_t;
+    typedef proof_system::plonk::stdlib::byte_array<Builder> byte_array_t;
+    typedef proof_system::plonk::stdlib::field_t<Builder> field_t;
+    typedef proof_system::plonk::stdlib::safe_uint_t<Builder> suint_t;
 
     template <class From, class To> static To from_to(const From& in, const std::optional<size_t> size = std::nullopt)
     {
@@ -454,7 +454,7 @@ template <typename Composer> class ByteArrayFuzzBase {
                                         this->byte_array.slice(offset, length));
             }
         }
-        ExecutionHandler get_bit(Composer* composer, const size_t bit) const
+        ExecutionHandler get_bit(Builder* builder, const size_t bit) const
         {
             if (bit >= this->reference_value.size() * 8) {
                 return ExecutionHandler(this->reference_value, this->byte_array);
@@ -464,7 +464,7 @@ template <typename Composer> class ByteArrayFuzzBase {
                                         /* Bit */ (1 << (bit % 8));
                 const bool is_set_ba = this->byte_array.get_bit(bit).get_value();
 
-                return ExecutionHandler(bool_to_vector(is_set_ref), byte_array_t(composer, bool_to_vector(is_set_ba)));
+                return ExecutionHandler(bool_to_vector(is_set_ref), byte_array_t(builder, bool_to_vector(is_set_ba)));
             }
         }
         /* Modifies the buffer at hand, so does not produce a return value */
@@ -496,7 +496,7 @@ template <typename Composer> class ByteArrayFuzzBase {
             }
         }
         /* Explicit re-instantiation using the various bit_array constructors */
-        ExecutionHandler set(Composer* composer)
+        ExecutionHandler set(Builder* builder)
         {
             const auto& ref = this->reference_value;
 
@@ -506,16 +506,16 @@ template <typename Composer> class ByteArrayFuzzBase {
                 return ExecutionHandler(ref, byte_array_t(this->byte_array));
             case 1:
                 /* Construct via std::string */
-                return ExecutionHandler(ref, byte_array_t(composer, this->byte_array.get_string()));
+                return ExecutionHandler(ref, byte_array_t(builder, this->byte_array.get_string()));
             case 2:
                 /* Construct via std::vector<uint8_t> */
-                return ExecutionHandler(ref, byte_array_t(composer, this->byte_array.get_value()));
+                return ExecutionHandler(ref, byte_array_t(builder, this->byte_array.get_value()));
             case 3:
                 /* Construct via bytes_t */
-                return ExecutionHandler(ref, byte_array_t(composer, this->byte_array.bytes()));
+                return ExecutionHandler(ref, byte_array_t(builder, this->byte_array.bytes()));
             case 4:
                 /* Construct via bytes_t move constructor */
-                return ExecutionHandler(ref, byte_array_t(composer, std::move(this->byte_array.bytes())));
+                return ExecutionHandler(ref, byte_array_t(builder, std::move(this->byte_array.bytes())));
             case 5: {
                 const auto field = to_field_t();
 
@@ -548,7 +548,7 @@ template <typename Composer> class ByteArrayFuzzBase {
                 for (size_t i = 0; i < gibberish_size; i++) {
                     gibberish[i] = static_cast<uint8_t>(VarianceRNG.next() % 0xFF);
                 }
-                auto ba = byte_array_t(composer, gibberish);
+                auto ba = byte_array_t(builder, gibberish);
 
                 /* Construct via assignment */
                 ba = this->byte_array;
@@ -579,36 +579,36 @@ template <typename Composer> class ByteArrayFuzzBase {
         /**
          * @brief Execute the constant instruction (push constant safeuint to the stack)
          *
-         * @param composer
+         * @param builder
          * @param stack
          * @param instruction
          * @return 0 if everything is ok, 1 if we should stop execution, since an expected error was encountered
          */
-        static inline size_t execute_CONSTANT(Composer* composer,
+        static inline size_t execute_CONSTANT(Builder* builder,
                                               std::vector<ExecutionHandler>& stack,
                                               Instruction& instruction)
         {
-            (void)composer;
+            (void)builder;
             if (static_cast<bool>(VarianceRNG.next() % 2)) {
-                stack.push_back(byte_array_t(composer, instruction.arguments.element.as_vector()));
+                stack.push_back(byte_array_t(builder, instruction.arguments.element.as_vector()));
             } else {
-                stack.push_back(byte_array_t(composer, instruction.arguments.element.as_string()));
+                stack.push_back(byte_array_t(builder, instruction.arguments.element.as_string()));
             }
             return 0;
         }
         /**
          * @brief Execute the REVERSE instruction
          *
-         * @param composer
+         * @param builder
          * @param stack
          * @param instruction
          * @return if everything is ok, 1 if we should stop execution, since an expected error was encountered
          */
-        static inline size_t execute_REVERSE(Composer* composer,
+        static inline size_t execute_REVERSE(Builder* builder,
                                              std::vector<ExecutionHandler>& stack,
                                              Instruction& instruction)
         {
-            (void)composer;
+            (void)builder;
             if (stack.size() == 0) {
                 return 1;
             }
@@ -628,17 +628,17 @@ template <typename Composer> class ByteArrayFuzzBase {
         /**
          * @brief Execute the slice instruction
          *
-         * @param composer
+         * @param builder
          * @param stack
          * @param instruction
          * @return if everything is ok, 1 if we should stop execution, since an expected error was encountered
         size_t
          */
-        static inline size_t execute_SLICE(Composer* composer,
+        static inline size_t execute_SLICE(Builder* builder,
                                            std::vector<ExecutionHandler>& stack,
                                            Instruction& instruction)
         {
-            (void)composer;
+            (void)builder;
             if (stack.size() == 0) {
                 return 1;
             }
@@ -659,16 +659,16 @@ template <typename Composer> class ByteArrayFuzzBase {
         /**
          * @brief Execute the GET_BIT instruction
          *
-         * @param composer
+         * @param builder
          * @param stack
          * @param instruction
          * @return if everything is ok, 1 if we should stop execution, since an expected error was encountered
          */
-        static inline size_t execute_GET_BIT(Composer* composer,
+        static inline size_t execute_GET_BIT(Builder* builder,
                                              std::vector<ExecutionHandler>& stack,
                                              Instruction& instruction)
         {
-            (void)composer;
+            (void)builder;
             if (stack.size() == 0) {
                 return 1;
             }
@@ -676,7 +676,7 @@ template <typename Composer> class ByteArrayFuzzBase {
             size_t output_index = instruction.arguments.getBitArgs.out;
             const uint32_t bit = instruction.arguments.getBitArgs.bit;
             ExecutionHandler result;
-            result = stack[first_index].get_bit(composer, bit);
+            result = stack[first_index].get_bit(builder, bit);
             // If the output index is larger than the number of elements in stack, append
             if (output_index >= stack.size()) {
                 stack.push_back(result);
@@ -688,16 +688,16 @@ template <typename Composer> class ByteArrayFuzzBase {
         /**
          * @brief Execute the SET_BIT instruction
          *
-         * @param composer
+         * @param builder
          * @param stack
          * @param instruction
          * @return if everything is ok, 1 if we should stop execution, since an expected error was encountered
          */
-        static inline size_t execute_SET_BIT(Composer* composer,
+        static inline size_t execute_SET_BIT(Builder* builder,
                                              std::vector<ExecutionHandler>& stack,
                                              Instruction& instruction)
         {
-            (void)composer;
+            (void)builder;
             if (stack.size() == 0) {
                 return 1;
             }
@@ -710,16 +710,16 @@ template <typename Composer> class ByteArrayFuzzBase {
         /**
          * @brief Execute the ADD (append) instruction
          *
-         * @param composer
+         * @param builder
          * @param stack
          * @param instruction
          * @return if everything is ok, 1 if we should stop execution, since an expected error was encountered
          */
-        static inline size_t execute_ADD(Composer* composer,
+        static inline size_t execute_ADD(Builder* builder,
                                          std::vector<ExecutionHandler>& stack,
                                          Instruction& instruction)
         {
-            (void)composer;
+            (void)builder;
             if (stack.size() == 0) {
                 return 1;
             }
@@ -740,23 +740,23 @@ template <typename Composer> class ByteArrayFuzzBase {
         /**
          * @brief Execute the SET instruction
          *
-         * @param composer
+         * @param builder
          * @param stack
          * @param instruction
          * @return if everything is ok, 1 if we should stop execution, since an expected error was encountered
          */
-        static inline size_t execute_SET(Composer* composer,
+        static inline size_t execute_SET(Builder* builder,
                                          std::vector<ExecutionHandler>& stack,
                                          Instruction& instruction)
         {
-            (void)composer;
+            (void)builder;
             if (stack.size() == 0) {
                 return 1;
             }
             size_t first_index = instruction.arguments.twoArgs.in % stack.size();
             size_t output_index = instruction.arguments.twoArgs.out;
             ExecutionHandler result;
-            result = stack[first_index].set(composer);
+            result = stack[first_index].set(builder);
             // If the output index is larger than the number of elements in stack, append
             if (output_index >= stack.size()) {
                 stack.push_back(result);
@@ -768,16 +768,16 @@ template <typename Composer> class ByteArrayFuzzBase {
         /**
          * @brief Execute the RANDOMSEED instruction
          *
-         * @param composer
+         * @param builder
          * @param stack
          * @param instruction
          * @return if everything is ok, 1 if we should stop execution, since an expected error was encountered
          */
-        static inline size_t execute_RANDOMSEED(Composer* composer,
+        static inline size_t execute_RANDOMSEED(Builder* builder,
                                                 std::vector<ExecutionHandler>& stack,
                                                 Instruction& instruction)
         {
-            (void)composer;
+            (void)builder;
             (void)stack;
 
             VarianceRNG.reseed(instruction.arguments.randomseed);
@@ -789,15 +789,15 @@ template <typename Composer> class ByteArrayFuzzBase {
     /**
      * @brief Check that the resulting values are equal to expected
      *
-     * @tparam Composer
-     * @param composer
+     * @tparam Builder
+     * @param builder
      * @param stack
      * @return true
      * @return false
      */
-    inline static bool postProcess(Composer* composer, std::vector<ByteArrayFuzzBase::ExecutionHandler>& stack)
+    inline static bool postProcess(Builder* builder, std::vector<ByteArrayFuzzBase::ExecutionHandler>& stack)
     {
-        (void)composer;
+        (void)builder;
         for (size_t i = 0; i < stack.size(); i++) {
             auto element = stack[i];
             if (element.byte_array.get_value() != element.reference_value) {
@@ -967,7 +967,7 @@ extern "C" size_t LLVMFuzzerCustomCrossOver(const uint8_t* Data1,
  */
 extern "C" size_t LLVMFuzzerTestOneInput(const uint8_t* Data, size_t Size)
 {
-    RunWithComposers<ByteArrayFuzzBase, FuzzerCircuitTypes>(Data, Size, VarianceRNG);
+    RunWithBuilders<ByteArrayFuzzBase, FuzzerCircuitTypes>(Data, Size, VarianceRNG);
     return 0;
 }
 
diff --git a/barretenberg/cpp/src/barretenberg/stdlib/primitives/byte_array/byte_array.hpp b/barretenberg/cpp/src/barretenberg/stdlib/primitives/byte_array/byte_array.hpp
index e1414986da9..e01280a5b77 100644
--- a/barretenberg/cpp/src/barretenberg/stdlib/primitives/byte_array/byte_array.hpp
+++ b/barretenberg/cpp/src/barretenberg/stdlib/primitives/byte_array/byte_array.hpp
@@ -6,21 +6,21 @@
 namespace proof_system::plonk {
 namespace stdlib {
 
-template <typename ComposerContext> class byte_array {
+template <typename Builder> class byte_array {
   public:
-    typedef std::vector<field_t<ComposerContext>> bytes_t;
+    typedef std::vector<field_t<Builder>> bytes_t;
 
-    byte_array(ComposerContext* parent_context = nullptr);
-    byte_array(ComposerContext* parent_context, size_t const n);
-    byte_array(ComposerContext* parent_context, std::string const& input);
-    byte_array(ComposerContext* parent_context, std::vector<uint8_t> const& input);
-    byte_array(ComposerContext* parent_context, bytes_t const& input);
-    byte_array(ComposerContext* parent_context, bytes_t&& input);
-    byte_array(const field_t<ComposerContext>& input, const size_t num_bytes = 32);
-    byte_array(const safe_uint_t<ComposerContext>& input, const size_t num_bytes = 32);
+    byte_array(Builder* parent_context = nullptr);
+    byte_array(Builder* parent_context, size_t const n);
+    byte_array(Builder* parent_context, std::string const& input);
+    byte_array(Builder* parent_context, std::vector<uint8_t> const& input);
+    byte_array(Builder* parent_context, bytes_t const& input);
+    byte_array(Builder* parent_context, bytes_t&& input);
+    byte_array(const field_t<Builder>& input, const size_t num_bytes = 32);
+    byte_array(const safe_uint_t<Builder>& input, const size_t num_bytes = 32);
 
     template <typename ItBegin, typename ItEnd>
-    byte_array(ComposerContext* parent_context, ItBegin const& begin, ItEnd const& end)
+    byte_array(Builder* parent_context, ItBegin const& begin, ItEnd const& end)
         : context(parent_context)
         , values(begin, end)
     {
@@ -35,9 +35,9 @@ template <typename ComposerContext> class byte_array {
     byte_array& operator=(const byte_array& other);
     byte_array& operator=(byte_array&& other);
 
-    explicit operator field_t<ComposerContext>() const;
+    explicit operator field_t<Builder>() const;
 
-    field_t<ComposerContext> operator[](const size_t index) const
+    field_t<Builder> operator[](const size_t index) const
     {
         assert(values.size() > 0);
         return values[index];
@@ -54,42 +54,41 @@ template <typename ComposerContext> class byte_array {
 
     bytes_t const& bytes() const { return values; }
 
-    bool_t<ComposerContext> get_bit(size_t index) const;
+    bool_t<Builder> get_bit(size_t index) const;
 
-    void set_bit(size_t index, bool_t<ComposerContext> const& value);
+    void set_bit(size_t index, bool_t<Builder> const& value);
 
-    void set_byte(size_t index, const field_t<ComposerContext>& byte_val)
+    void set_byte(size_t index, const field_t<Builder>& byte_val)
     {
         ASSERT(index < values.size());
         values[index] = byte_val;
     }
 
-    void set_context(ComposerContext* ctx)
+    void set_context(Builder* ctx)
     {
         ASSERT(context == nullptr);
         context = ctx;
     }
 
-    ComposerContext* get_context() const { return context; }
+    Builder* get_context() const { return context; }
 
     std::vector<uint8_t> get_value() const;
 
     std::string get_string() const;
 
   private:
-    ComposerContext* context;
+    Builder* context;
     bytes_t values;
 
     struct byte_slice {
-        field_t<ComposerContext> low;
-        field_t<ComposerContext> high;
-        bool_t<ComposerContext> bit;
+        field_t<Builder> low;
+        field_t<Builder> high;
+        bool_t<Builder> bit;
     };
     byte_slice split_byte(const size_t bit_index) const;
 };
 
-template <typename ComposerContext>
-inline std::ostream& operator<<(std::ostream& os, byte_array<ComposerContext> const& arr)
+template <typename Builder> inline std::ostream& operator<<(std::ostream& os, byte_array<Builder> const& arr)
 {
     std::ios_base::fmtflags f(os.flags());
     os << "[" << std::hex << std::setfill('0');
diff --git a/barretenberg/cpp/src/barretenberg/stdlib/primitives/byte_array/byte_array.test.cpp b/barretenberg/cpp/src/barretenberg/stdlib/primitives/byte_array/byte_array.test.cpp
index 77e71ec771f..26c83cb2023 100644
--- a/barretenberg/cpp/src/barretenberg/stdlib/primitives/byte_array/byte_array.test.cpp
+++ b/barretenberg/cpp/src/barretenberg/stdlib/primitives/byte_array/byte_array.test.cpp
@@ -12,15 +12,15 @@ using namespace barretenberg;
 using namespace proof_system::plonk::stdlib;
 
 #define STDLIB_TYPE_ALIASES                                                                                            \
-    using Composer = TypeParam;                                                                                        \
-    using witness_ct = witness_t<Composer>;                                                                            \
-    using byte_array_ct = byte_array<Composer>;                                                                        \
-    using field_ct = field_t<Composer>;                                                                                \
-    using bool_ct = bool_t<Composer>;
+    using Builder = TypeParam;                                                                                         \
+    using witness_ct = witness_t<Builder>;                                                                             \
+    using byte_array_ct = byte_array<Builder>;                                                                         \
+    using field_ct = field_t<Builder>;                                                                                 \
+    using bool_ct = bool_t<Builder>;
 
-template <class Composer> class ByteArrayTest : public ::testing::Test {};
+template <class Builder> class ByteArrayTest : public ::testing::Test {};
 
-template <class Composer> using byte_array_ct = byte_array<Composer>;
+template <class Builder> using byte_array_ct = byte_array<Builder>;
 
 using CircuitTypes = ::testing::
     Types<proof_system::StandardCircuitBuilder, proof_system::TurboCircuitBuilder, proof_system::UltraCircuitBuilder>;
@@ -29,10 +29,10 @@ TYPED_TEST_SUITE(ByteArrayTest, CircuitTypes);
 TYPED_TEST(ByteArrayTest, test_reverse)
 {
     STDLIB_TYPE_ALIASES
-    auto composer = Composer();
+    auto builder = Builder();
 
     std::vector<uint8_t> expected = { 0x04, 0x03, 0x02, 0x01 };
-    byte_array_ct arr(&composer, std::vector<uint8_t>{ 0x01, 0x02, 0x03, 0x04 });
+    byte_array_ct arr(&builder, std::vector<uint8_t>{ 0x01, 0x02, 0x03, 0x04 });
 
     EXPECT_EQ(arr.size(), 4UL);
     EXPECT_EQ(arr.reverse().get_value(), expected);
@@ -41,20 +41,20 @@ TYPED_TEST(ByteArrayTest, test_reverse)
 TYPED_TEST(ByteArrayTest, test_string_constructor)
 {
     STDLIB_TYPE_ALIASES
-    auto composer = Composer();
+    auto builder = Builder();
 
     std::string a = "ascii";
-    byte_array_ct arr(&composer, a);
+    byte_array_ct arr(&builder, a);
     EXPECT_EQ(arr.get_string(), a);
 }
 
 TYPED_TEST(ByteArrayTest, test_ostream_operator)
 {
     STDLIB_TYPE_ALIASES
-    auto composer = Composer();
+    auto builder = Builder();
 
     std::string a = "\1\2\3a";
-    byte_array_ct arr(&composer, a);
+    byte_array_ct arr(&builder, a);
     std::ostringstream os;
     os << arr;
     EXPECT_EQ(os.str(), "[ 01 02 03 61 ]");
@@ -63,15 +63,15 @@ TYPED_TEST(ByteArrayTest, test_ostream_operator)
 TYPED_TEST(ByteArrayTest, test_byte_array_input_output_consistency)
 {
     STDLIB_TYPE_ALIASES
-    auto composer = Composer();
+    auto builder = Builder();
 
     fr a_expected = fr::random_element();
     fr b_expected = fr::random_element();
 
-    field_ct a = witness_ct(&composer, a_expected);
-    field_ct b = witness_ct(&composer, b_expected);
+    field_ct a = witness_ct(&builder, a_expected);
+    field_ct b = witness_ct(&builder, b_expected);
 
-    byte_array_ct arr(&composer);
+    byte_array_ct arr(&builder);
 
     arr.write(static_cast<byte_array_ct>(a));
     arr.write(static_cast<byte_array_ct>(b));
@@ -84,16 +84,16 @@ TYPED_TEST(ByteArrayTest, test_byte_array_input_output_consistency)
     EXPECT_EQ(a_result.get_value(), a_expected);
     EXPECT_EQ(b_result.get_value(), b_expected);
 
-    bool verified = composer.check_circuit();
+    bool verified = builder.check_circuit();
     EXPECT_EQ(verified, true);
 }
 
 TYPED_TEST(ByteArrayTest, get_bit)
 {
     STDLIB_TYPE_ALIASES
-    auto composer = Composer();
+    auto builder = Builder();
 
-    byte_array_ct arr(&composer, std::vector<uint8_t>{ 0x01, 0x02, 0x03, 0x04 });
+    byte_array_ct arr(&builder, std::vector<uint8_t>{ 0x01, 0x02, 0x03, 0x04 });
 
     EXPECT_EQ(arr.get_bit(0).get_value(), false);
     EXPECT_EQ(arr.get_bit(1).get_value(), false);
@@ -115,28 +115,28 @@ TYPED_TEST(ByteArrayTest, get_bit)
 
     EXPECT_EQ(arr.size(), 4UL);
 
-    bool proof_result = composer.check_circuit();
+    bool proof_result = builder.check_circuit();
     EXPECT_EQ(proof_result, true);
 }
 
 TYPED_TEST(ByteArrayTest, set_bit)
 {
     STDLIB_TYPE_ALIASES
-    auto composer = Composer();
+    auto builder = Builder();
 
-    byte_array_ct arr(&composer, std::vector<uint8_t>{ 0x01, 0x02, 0x03, 0x04 });
+    byte_array_ct arr(&builder, std::vector<uint8_t>{ 0x01, 0x02, 0x03, 0x04 });
 
-    arr.set_bit(16, bool_ct(witness_ct(&composer, true)));
-    arr.set_bit(18, bool_ct(witness_ct(&composer, true)));
-    arr.set_bit(24, bool_ct(witness_ct(&composer, false)));
-    arr.set_bit(0, bool_ct(witness_ct(&composer, true)));
+    arr.set_bit(16, bool_ct(witness_ct(&builder, true)));
+    arr.set_bit(18, bool_ct(witness_ct(&builder, true)));
+    arr.set_bit(24, bool_ct(witness_ct(&builder, false)));
+    arr.set_bit(0, bool_ct(witness_ct(&builder, true)));
 
     const auto out = arr.get_value();
     EXPECT_EQ(out[0], uint8_t(0));
     EXPECT_EQ(out[1], uint8_t(7));
     EXPECT_EQ(out[3], uint8_t(5));
 
-    bool proof_result = composer.check_circuit();
+    bool proof_result = builder.check_circuit();
     EXPECT_EQ(proof_result, true);
 }
 
diff --git a/barretenberg/cpp/src/barretenberg/stdlib/primitives/circuit_builders/circuit_builders.hpp b/barretenberg/cpp/src/barretenberg/stdlib/primitives/circuit_builders/circuit_builders.hpp
index d12df90869f..8fbac8a643b 100644
--- a/barretenberg/cpp/src/barretenberg/stdlib/primitives/circuit_builders/circuit_builders.hpp
+++ b/barretenberg/cpp/src/barretenberg/stdlib/primitives/circuit_builders/circuit_builders.hpp
@@ -1,6 +1,6 @@
 /**
- * @brief Contains all the headers required to adequately compile the types defined in composers_fwd.hpp and instantiate
- * templates.
+ * @brief Contains all the headers required to adequately compile the types defined in circuit_builders_fwd.hpp and
+ * instantiate templates.
  */
 #pragma once
 #include "barretenberg/proof_system/circuit_builder/goblin_ultra_circuit_builder.hpp"
diff --git a/barretenberg/cpp/src/barretenberg/stdlib/primitives/circuit_builders/circuit_builders_fwd.hpp b/barretenberg/cpp/src/barretenberg/stdlib/primitives/circuit_builders/circuit_builders_fwd.hpp
index 197026406d4..9069cf1d992 100644
--- a/barretenberg/cpp/src/barretenberg/stdlib/primitives/circuit_builders/circuit_builders_fwd.hpp
+++ b/barretenberg/cpp/src/barretenberg/stdlib/primitives/circuit_builders/circuit_builders_fwd.hpp
@@ -1,5 +1,5 @@
 /**
- * @brief Defines particular composer and circuit builder types expected to be used for proof or circuit
+ * @brief Defines particular circuit builder types expected to be used for circuit
 construction in stdlib and contains macros for explicit instantiation.
  *
  * @details This file is designed to be included in header files to instruct the compiler that these classes exist and
diff --git a/barretenberg/cpp/src/barretenberg/stdlib/primitives/curves/bn254.hpp b/barretenberg/cpp/src/barretenberg/stdlib/primitives/curves/bn254.hpp
index 27ed0920797..5dfde40f293 100644
--- a/barretenberg/cpp/src/barretenberg/stdlib/primitives/curves/bn254.hpp
+++ b/barretenberg/cpp/src/barretenberg/stdlib/primitives/curves/bn254.hpp
@@ -30,7 +30,6 @@ template <typename CircuitBuilder> struct bn254 {
 
     // Additional types with no analog in the native description of the curve
     using Builder = CircuitBuilder;
-    using Composer = CircuitBuilder;
     using witness_ct = witness_t<CircuitBuilder>;
     using public_witness_ct = public_witness_t<CircuitBuilder>;
     using byte_array_ct = byte_array<CircuitBuilder>;
diff --git a/barretenberg/cpp/src/barretenberg/stdlib/primitives/curves/secp256k1.hpp b/barretenberg/cpp/src/barretenberg/stdlib/primitives/curves/secp256k1.hpp
index 78b590b405e..a3123b820e0 100644
--- a/barretenberg/cpp/src/barretenberg/stdlib/primitives/curves/secp256k1.hpp
+++ b/barretenberg/cpp/src/barretenberg/stdlib/primitives/curves/secp256k1.hpp
@@ -16,18 +16,18 @@ template <typename CircuitType> struct secp256k1 {
     typedef ::secp256k1::fr fr;
     typedef ::secp256k1::g1 g1;
 
-    typedef CircuitType Composer;
-    typedef witness_t<Composer> witness_ct;
-    typedef public_witness_t<Composer> public_witness_ct;
-    typedef field_t<Composer> fr_ct;
-    typedef byte_array<Composer> byte_array_ct;
-    typedef bool_t<Composer> bool_ct;
-    typedef stdlib::uint32<Composer> uint32_ct;
+    typedef CircuitType Builder;
+    typedef witness_t<Builder> witness_ct;
+    typedef public_witness_t<Builder> public_witness_ct;
+    typedef field_t<Builder> fr_ct;
+    typedef byte_array<Builder> byte_array_ct;
+    typedef bool_t<Builder> bool_ct;
+    typedef stdlib::uint32<Builder> uint32_ct;
 
-    typedef bigfield<Composer, typename ::secp256k1::Secp256k1FqParams> fq_ct;
-    typedef bigfield<Composer, typename ::secp256k1::Secp256k1FrParams> bigfr_ct;
-    typedef element<Composer, fq_ct, fr_ct, g1> g1_ct;
-    typedef element<Composer, fq_ct, bigfr_ct, g1> g1_bigfr_ct;
+    typedef bigfield<Builder, typename ::secp256k1::Secp256k1FqParams> fq_ct;
+    typedef bigfield<Builder, typename ::secp256k1::Secp256k1FrParams> bigfr_ct;
+    typedef element<Builder, fq_ct, fr_ct, g1> g1_ct;
+    typedef element<Builder, fq_ct, bigfr_ct, g1> g1_bigfr_ct;
 };
 } // namespace stdlib
 } // namespace proof_system::plonk
diff --git a/barretenberg/cpp/src/barretenberg/stdlib/primitives/curves/secp256r1.hpp b/barretenberg/cpp/src/barretenberg/stdlib/primitives/curves/secp256r1.hpp
index 8fead0894fe..e8f731560f0 100644
--- a/barretenberg/cpp/src/barretenberg/stdlib/primitives/curves/secp256r1.hpp
+++ b/barretenberg/cpp/src/barretenberg/stdlib/primitives/curves/secp256r1.hpp
@@ -16,18 +16,18 @@ template <typename CircuitType> struct secp256r1 {
     typedef ::secp256r1::fr fr;
     typedef ::secp256r1::g1 g1;
 
-    typedef CircuitType Composer;
-    typedef witness_t<Composer> witness_ct;
-    typedef public_witness_t<Composer> public_witness_ct;
-    typedef field_t<Composer> fr_ct;
-    typedef byte_array<Composer> byte_array_ct;
-    typedef bool_t<Composer> bool_ct;
-    typedef stdlib::uint32<Composer> uint32_ct;
+    typedef CircuitType Builder;
+    typedef witness_t<Builder> witness_ct;
+    typedef public_witness_t<Builder> public_witness_ct;
+    typedef field_t<Builder> fr_ct;
+    typedef byte_array<Builder> byte_array_ct;
+    typedef bool_t<Builder> bool_ct;
+    typedef stdlib::uint32<Builder> uint32_ct;
 
-    typedef bigfield<Composer, typename ::secp256r1::Secp256r1FqParams> fq_ct;
-    typedef bigfield<Composer, typename ::secp256r1::Secp256r1FrParams> bigfr_ct;
-    typedef element<Composer, fq_ct, fr_ct, g1> g1_ct;
-    typedef element<Composer, fq_ct, bigfr_ct, g1> g1_bigfr_ct;
+    typedef bigfield<Builder, typename ::secp256r1::Secp256r1FqParams> fq_ct;
+    typedef bigfield<Builder, typename ::secp256r1::Secp256r1FrParams> bigfr_ct;
+    typedef element<Builder, fq_ct, fr_ct, g1> g1_ct;
+    typedef element<Builder, fq_ct, bigfr_ct, g1> g1_bigfr_ct;
 };
 } // namespace stdlib
 } // namespace proof_system::plonk
diff --git a/barretenberg/cpp/src/barretenberg/stdlib/primitives/field/array.hpp b/barretenberg/cpp/src/barretenberg/stdlib/primitives/field/array.hpp
index d70cded5ae4..61999ee3c85 100644
--- a/barretenberg/cpp/src/barretenberg/stdlib/primitives/field/array.hpp
+++ b/barretenberg/cpp/src/barretenberg/stdlib/primitives/field/array.hpp
@@ -11,15 +11,15 @@ namespace stdlib {
  * Note: This assumes `0` always means 'not used', so be careful. As soon as we locate 0, we stop the counting.
  * If you actually want `0` to be counted, you'll need something else.
  */
-template <typename Composer, size_t SIZE> field_t<Composer> array_length(std::array<field_t<Composer>, SIZE> const& arr)
+template <typename Builder, size_t SIZE> field_t<Builder> array_length(std::array<field_t<Builder>, SIZE> const& arr)
 {
-    field_t<Composer> length = 0;
-    bool_t<Composer> hit_zero = false;
+    field_t<Builder> length = 0;
+    bool_t<Builder> hit_zero = false;
     for (const auto& e : arr) {
-        bool_t<Composer> is_zero = e.is_zero();
+        bool_t<Builder> is_zero = e.is_zero();
         hit_zero.must_imply(is_zero, "Once we've hit the first zero, there must only be zeros thereafter!");
         hit_zero |= is_zero;
-        const field_t<Composer> increment = !hit_zero;
+        const field_t<Builder> increment = !hit_zero;
         length += increment;
     }
     return length;
@@ -31,13 +31,13 @@ template <typename Composer, size_t SIZE> field_t<Composer> array_length(std::ar
  * something else.
  * If it returns `0`, the array is considered 'empty'.
  */
-template <typename Composer, size_t SIZE> field_t<Composer> array_pop(std::array<field_t<Composer>, SIZE> const& arr)
+template <typename Builder, size_t SIZE> field_t<Builder> array_pop(std::array<field_t<Builder>, SIZE> const& arr)
 {
-    field_t<Composer> popped_value = 0;
-    bool_t<Composer> already_popped = false;
+    field_t<Builder> popped_value = 0;
+    bool_t<Builder> already_popped = false;
     for (size_t i = arr.size() - 1; i != (size_t)-1; i--) {
-        bool_t<Composer> is_non_zero = arr[i] != 0;
-        popped_value = field_t<Composer>::conditional_assign(!already_popped && is_non_zero, arr[i], popped_value);
+        bool_t<Builder> is_non_zero = arr[i] != 0;
+        popped_value = field_t<Builder>::conditional_assign(!already_popped && is_non_zero, arr[i], popped_value);
 
         already_popped |= is_non_zero;
     }
@@ -50,13 +50,13 @@ template <typename Composer, size_t SIZE> field_t<Composer> array_pop(std::array
  * Note: this assumes `0` always means 'not used', so be careful. If you actually want `0` to be counted, you'll need
  * something else.
  */
-template <typename Composer, size_t SIZE>
-void array_push(std::array<field_t<Composer>, SIZE>& arr, field_t<Composer> const& value)
+template <typename Builder, size_t SIZE>
+void array_push(std::array<field_t<Builder>, SIZE>& arr, field_t<Builder> const& value)
 {
-    bool_t<Composer> already_pushed = false;
+    bool_t<Builder> already_pushed = false;
     for (size_t i = 0; i < arr.size(); ++i) {
-        bool_t<Composer> is_zero = arr[i] == 0;
-        arr[i] = field_t<Composer>::conditional_assign(!already_pushed && is_zero, value, arr[i]);
+        bool_t<Builder> is_zero = arr[i] == 0;
+        arr[i] = field_t<Builder>::conditional_assign(!already_pushed && is_zero, value, arr[i]);
 
         already_pushed |= is_zero;
     }
@@ -67,8 +67,8 @@ void array_push(std::array<field_t<Composer>, SIZE>& arr, field_t<Composer> cons
  * Note: this assumes `0` always means 'not used', so be careful. If you actually want `0` to be counted, you'll need
  * something else.
  */
-template <typename Composer, size_t SIZE>
-inline size_t array_push(std::array<std::optional<field_t<Composer>>, SIZE>& arr, field_t<Composer> const& value)
+template <typename Builder, size_t SIZE>
+inline size_t array_push(std::array<std::optional<field_t<Builder>>, SIZE>& arr, field_t<Builder> const& value)
 {
     for (size_t i = 0; i < arr.size(); ++i) {
         if (arr[i] == std::nullopt) {
@@ -99,11 +99,11 @@ inline size_t array_push(std::array<std::shared_ptr<T>, SIZE>& arr, std::shared_
  * Note: this assumes `0` always means 'not used', so be careful. If you actually want `0` to be counted, you'll need
  * something else.
  */
-template <typename Composer, typename T, size_t SIZE> inline void array_push(std::array<T, SIZE>& arr, T const& value)
+template <typename Builder, typename T, size_t SIZE> inline void array_push(std::array<T, SIZE>& arr, T const& value)
 {
-    bool_t<Composer> already_pushed = false;
+    bool_t<Builder> already_pushed = false;
     for (size_t i = 0; i < arr.size(); ++i) {
-        bool_t<Composer> is_zero = arr[i].is_empty();
+        bool_t<Builder> is_zero = arr[i].is_empty();
         arr[i].conditional_select(!already_pushed && is_zero, value);
 
         already_pushed |= is_zero;
@@ -115,12 +115,12 @@ template <typename Composer, typename T, size_t SIZE> inline void array_push(std
  * Note: this assumes `0` always means 'not used', so be careful. If you actually want `0` to be counted, you'll need
  * something else.
  */
-template <typename Composer, size_t SIZE>
-typename plonk::stdlib::bool_t<Composer> is_array_empty(std::array<field_t<Composer>, SIZE> const& arr)
+template <typename Builder, size_t SIZE>
+typename plonk::stdlib::bool_t<Builder> is_array_empty(std::array<field_t<Builder>, SIZE> const& arr)
 {
-    bool_t<Composer> nonzero_found = false;
+    bool_t<Builder> nonzero_found = false;
     for (size_t i = arr.size() - 1; i != (size_t)-1; i--) {
-        bool_t<Composer> is_non_zero = arr[i] != 0;
+        bool_t<Builder> is_non_zero = arr[i] != 0;
         nonzero_found |= is_non_zero;
     }
     return !nonzero_found;
@@ -130,19 +130,19 @@ typename plonk::stdlib::bool_t<Composer> is_array_empty(std::array<field_t<Compo
  * Inserts the `source` array at the first zero-valued index of the `target` array.
  * Fails if the `source` array is too large vs the remaining capacity of the `target` array.
  */
-template <typename Composer, size_t size_1, size_t size_2>
-void push_array_to_array(std::array<field_t<Composer>, size_1> const& source,
-                         std::array<field_t<Composer>, size_2>& target)
+template <typename Builder, size_t size_1, size_t size_2>
+void push_array_to_array(std::array<field_t<Builder>, size_1> const& source,
+                         std::array<field_t<Builder>, size_2>& target)
 {
-    field_t<Composer> target_length = array_length<Composer>(target);
-    const field_t<Composer> overflow_capacity = target.max_size() + 1;
+    field_t<Builder> target_length = array_length<Builder>(target);
+    const field_t<Builder> overflow_capacity = target.max_size() + 1;
 
-    field_t<Composer> j_ct = 0; // circuit-type index for the inner loop
+    field_t<Builder> j_ct = 0; // circuit-type index for the inner loop
     // Find the first empty slot in the target:
-    field_t<Composer> next_target_index = target_length;
+    field_t<Builder> next_target_index = target_length;
 
-    bool_t<Composer> hit_s_zero = false;
-    bool_t<Composer> not_hit_s_zero = true;
+    bool_t<Builder> hit_s_zero = false;
+    bool_t<Builder> not_hit_s_zero = true;
 
     for (size_t i = 0; i < source.max_size(); ++i) {
         // Loop over each source value we want to push:
@@ -160,9 +160,9 @@ void push_array_to_array(std::array<field_t<Composer>, size_1> const& source,
             auto& t = target[j];
 
             // Check whether we've reached the next target index at which we can push `s`:
-            bool_t<Composer> at_next_target_index = j_ct == next_target_index;
+            bool_t<Builder> at_next_target_index = j_ct == next_target_index;
 
-            t = field_t<Composer>::conditional_assign(at_next_target_index && not_hit_s_zero, s, t);
+            t = field_t<Builder>::conditional_assign(at_next_target_index && not_hit_s_zero, s, t);
 
             j_ct++;
         }
diff --git a/barretenberg/cpp/src/barretenberg/stdlib/primitives/field/array.test.cpp b/barretenberg/cpp/src/barretenberg/stdlib/primitives/field/array.test.cpp
index 401f426ddec..f0fcab3cdf7 100644
--- a/barretenberg/cpp/src/barretenberg/stdlib/primitives/field/array.test.cpp
+++ b/barretenberg/cpp/src/barretenberg/stdlib/primitives/field/array.test.cpp
@@ -17,16 +17,16 @@ template <class T> void ignore_unused(T&) {} // use to ignore unused variables i
 using namespace barretenberg;
 using namespace proof_system::plonk;
 
-template <typename Composer> class stdlib_array : public testing::Test {
-    typedef stdlib::bool_t<Composer> bool_ct;
-    typedef stdlib::field_t<Composer> field_ct;
-    typedef stdlib::witness_t<Composer> witness_ct;
-    typedef stdlib::public_witness_t<Composer> public_witness_ct;
+template <typename Builder> class stdlib_array : public testing::Test {
+    typedef stdlib::bool_t<Builder> bool_ct;
+    typedef stdlib::field_t<Builder> field_ct;
+    typedef stdlib::witness_t<Builder> witness_ct;
+    typedef stdlib::public_witness_t<Builder> public_witness_ct;
 
   public:
     static void test_array_length()
     {
-        Composer composer = Composer();
+        Builder builder = Builder();
 
         constexpr size_t ARRAY_LEN = 10;
         std::array<fr, ARRAY_LEN> values;
@@ -35,33 +35,33 @@ template <typename Composer> class stdlib_array : public testing::Test {
         constexpr size_t filled = 6;
         for (size_t i = 0; i < filled; i++) {
             values[i] = fr::random_element();
-            values_ct[i] = witness_ct(&composer, values[i]);
+            values_ct[i] = witness_ct(&builder, values[i]);
         }
-        auto filled_len = array_length<Composer>(values_ct);
+        auto filled_len = array_length<Builder>(values_ct);
         EXPECT_EQ(filled_len.get_value(), filled);
 
-        info("composer gates = ", composer.get_num_gates());
-        bool proof_result = composer.check_circuit();
+        info("num gates = ", builder.get_num_gates());
+        bool proof_result = builder.check_circuit();
         EXPECT_EQ(proof_result, true);
     }
 
     static void test_array_length_null()
     {
-        Composer composer = Composer();
+        Builder builder = Builder();
 
         std::array<field_ct, 0> values_ct;
-        auto filled_len = array_length<Composer>(values_ct);
+        auto filled_len = array_length<Builder>(values_ct);
         EXPECT_EQ(filled_len.get_value(), 0);
         EXPECT_TRUE(filled_len.is_constant());
 
-        info("composer gates = ", composer.get_num_gates());
-        bool proof_result = composer.check_circuit();
+        info("num gates = ", builder.get_num_gates());
+        bool proof_result = builder.check_circuit();
         EXPECT_EQ(proof_result, true);
     }
 
     static void test_array_length_fails()
     {
-        Composer composer = Composer();
+        Builder builder = Builder();
 
         constexpr size_t ARRAY_LEN = 10;
         std::array<fr, ARRAY_LEN> values;
@@ -70,22 +70,22 @@ template <typename Composer> class stdlib_array : public testing::Test {
         constexpr size_t filled = 6;
         for (size_t i = 0; i < filled; i++) {
             values[i] = fr::random_element();
-            values_ct[i] = witness_ct(&composer, values[i]);
+            values_ct[i] = witness_ct(&builder, values[i]);
         }
 
         // Put a zero in the middle of the array, so that the array_length function complains that all zeros thereafter
         // should be zero.
         values_ct[4] = 0;
 
-        array_length<Composer>(values_ct);
+        array_length<Builder>(values_ct);
 
-        EXPECT_EQ(composer.failed(), true);
-        EXPECT_EQ(composer.err(), "Once we've hit the first zero, there must only be zeros thereafter!");
+        EXPECT_EQ(builder.failed(), true);
+        EXPECT_EQ(builder.err(), "Once we've hit the first zero, there must only be zeros thereafter!");
     }
 
     static void test_array_pop()
     {
-        Composer composer = Composer();
+        Builder builder = Builder();
 
         constexpr size_t ARRAY_LEN = 10;
         std::array<fr, ARRAY_LEN> values;
@@ -94,19 +94,19 @@ template <typename Composer> class stdlib_array : public testing::Test {
         constexpr size_t filled = 6;
         for (size_t i = 0; i < filled; i++) {
             values[i] = fr::random_element();
-            values_ct[i] = witness_ct(&composer, values[i]);
+            values_ct[i] = witness_ct(&builder, values[i]);
         }
-        auto popped = array_pop<Composer>(values_ct);
+        auto popped = array_pop<Builder>(values_ct);
         EXPECT_EQ(popped.get_value(), values[filled - 1]);
 
-        info("composer gates = ", composer.get_num_gates());
-        bool proof_result = composer.check_circuit();
+        info("num gates = ", builder.get_num_gates());
+        bool proof_result = builder.check_circuit();
         EXPECT_EQ(proof_result, true);
     };
 
     static void test_array_pop_from_empty()
     {
-        Composer composer = Composer();
+        Builder builder = Builder();
 
         constexpr size_t ARRAY_LEN = 10;
         std::array<fr, ARRAY_LEN> values;
@@ -115,23 +115,23 @@ template <typename Composer> class stdlib_array : public testing::Test {
         constexpr size_t filled = 0;
         for (size_t i = 0; i < filled; i++) {
             values[i] = fr::random_element();
-            values_ct[i] = witness_ct(&composer, values[i]);
+            values_ct[i] = witness_ct(&builder, values[i]);
         }
         for (size_t i = filled; i < ARRAY_LEN; i++) {
             values[i] = 0;
-            values_ct[i] = witness_ct(&composer, values[i]);
+            values_ct[i] = witness_ct(&builder, values[i]);
         }
 
-        auto popped = array_pop<Composer>(values_ct);
+        auto popped = array_pop<Builder>(values_ct);
         EXPECT_EQ(popped.get_value(), 0);
 
-        EXPECT_EQ(composer.failed(), true);
-        EXPECT_EQ(composer.err(), "array_pop cannot pop from an empty array");
+        EXPECT_EQ(builder.failed(), true);
+        EXPECT_EQ(builder.err(), "array_pop cannot pop from an empty array");
     };
 
     static void test_array_push()
     {
-        Composer composer = Composer();
+        Builder builder = Builder();
 
         constexpr size_t ARRAY_LEN = 10;
         std::array<fr, ARRAY_LEN> values;
@@ -140,25 +140,25 @@ template <typename Composer> class stdlib_array : public testing::Test {
         constexpr size_t filled = 6;
         for (size_t i = 0; i < filled; i++) {
             values[i] = fr::random_element();
-            values_ct[i] = witness_ct(&composer, values[i]);
+            values_ct[i] = witness_ct(&builder, values[i]);
         }
         for (size_t i = filled; i < ARRAY_LEN; i++) {
             values[i] = 0;
-            values_ct[i] = witness_ct(&composer, values[i]);
+            values_ct[i] = witness_ct(&builder, values[i]);
         }
 
-        auto value_ct = field_ct(&composer, fr::random_element());
-        array_push<Composer>(values_ct, value_ct);
+        auto value_ct = field_ct(&builder, fr::random_element());
+        array_push<Builder>(values_ct, value_ct);
         EXPECT_EQ(value_ct.get_value(), values_ct[filled].get_value());
 
-        info("composer gates = ", composer.get_num_gates());
-        bool proof_result = composer.check_circuit();
+        info("num gates = ", builder.get_num_gates());
+        bool proof_result = builder.check_circuit();
         EXPECT_EQ(proof_result, true);
     }
 
     static void test_array_push_optional()
     {
-        Composer composer = Composer();
+        Builder builder = Builder();
 
         constexpr size_t ARRAY_LEN = 10;
         std::array<std::optional<fr>, ARRAY_LEN> values;
@@ -173,8 +173,8 @@ template <typename Composer> class stdlib_array : public testing::Test {
         // Push some values into the array
         size_t num_pushes = 0;
         for (size_t i = 0; i < ARRAY_LEN; i++) {
-            auto value = field_ct(&composer, fr::random_element());
-            size_t idx = array_push<Composer>(values_ct, value);
+            auto value = field_ct(&builder, fr::random_element());
+            size_t idx = array_push<Builder>(values_ct, value);
             EXPECT_TRUE(values_ct[idx].has_value());
             EXPECT_EQ(values_ct[idx].value().get_value(), value.get_value());
             num_pushes++;
@@ -182,8 +182,8 @@ template <typename Composer> class stdlib_array : public testing::Test {
 
         // Make sure the array is full now
         try {
-            auto value = field_ct(&composer, fr::random_element());
-            array_push<Composer>(values_ct, value);
+            auto value = field_ct(&builder, fr::random_element());
+            array_push<Builder>(values_ct, value);
             FAIL() << "array_push should have thrown an exception when trying to push to a full array";
         } catch (std::runtime_error& e) {
             EXPECT_EQ(e.what(), std::string("array_push cannot push to a full array"));
@@ -191,8 +191,8 @@ template <typename Composer> class stdlib_array : public testing::Test {
 
         EXPECT_EQ(num_pushes, ARRAY_LEN);
 
-        info("composer gates = ", composer.get_num_gates());
-        bool proof_result = composer.check_circuit();
+        info("num gates = ", builder.get_num_gates());
+        bool proof_result = builder.check_circuit();
         EXPECT_EQ(proof_result, true);
     }
 
@@ -211,7 +211,7 @@ template <typename Composer> class stdlib_array : public testing::Test {
 
         // Attempt to push a value to the array
         std::shared_ptr<int> new_value = std::make_shared<int>(42);
-        EXPECT_THROW(array_push<Composer>(arr, new_value), std::runtime_error);
+        EXPECT_THROW(array_push<Builder>(arr, new_value), std::runtime_error);
 
         // Ensure that the array was not modified
         for (size_t i = 0; i < arr.size(); ++i) {
@@ -221,7 +221,7 @@ template <typename Composer> class stdlib_array : public testing::Test {
 
     static void test_is_array_empty()
     {
-        Composer composer = Composer();
+        Builder builder = Builder();
 
         constexpr size_t ARRAY_LEN = 10;
         std::array<fr, ARRAY_LEN> values;
@@ -231,30 +231,30 @@ template <typename Composer> class stdlib_array : public testing::Test {
         constexpr size_t filled = 3;
         for (size_t i = 0; i < filled; i++) {
             values[i] = fr::random_element();
-            values_ct[i] = witness_ct(&composer, values[i]);
+            values_ct[i] = witness_ct(&builder, values[i]);
         }
         for (size_t i = filled; i < ARRAY_LEN; i++) {
             values[i] = 0;
-            values_ct[i] = witness_ct(&composer, values[i]);
+            values_ct[i] = witness_ct(&builder, values[i]);
         }
-        auto is_empty = is_array_empty<Composer>(values_ct);
+        auto is_empty = is_array_empty<Builder>(values_ct);
         EXPECT_EQ(is_empty.get_value(), false);
 
         // Test empty array
         for (size_t i = 0; i < ARRAY_LEN; i++) {
             values[i] = 0;
-            values_ct[i] = witness_ct(&composer, values[i]);
+            values_ct[i] = witness_ct(&builder, values[i]);
         }
-        is_empty = is_array_empty<Composer>(values_ct);
+        is_empty = is_array_empty<Builder>(values_ct);
         EXPECT_EQ(is_empty.get_value(), true);
 
-        info("composer gates = ", composer.get_num_gates());
-        bool proof_result = composer.check_circuit();
+        info("num gates = ", builder.get_num_gates());
+        bool proof_result = builder.check_circuit();
         EXPECT_EQ(proof_result, true);
     };
 
     template <size_t size_1, size_t size_2>
-    static auto test_push_array_to_array_helper(Composer& composer,
+    static auto test_push_array_to_array_helper(Builder& builder,
                                                 std::array<fr, size_1> const& source,
                                                 std::array<fr, size_2> const& target,
                                                 std::array<fr, size_2> const& expected_target,
@@ -263,13 +263,13 @@ template <typename Composer> class stdlib_array : public testing::Test {
         std::array<field_ct, size_1> source_ct;
         std::array<field_ct, size_2> target_ct;
         for (size_t i = 0; i < source.size(); i++) {
-            source_ct[i] = witness_ct(&composer, source[i]);
+            source_ct[i] = witness_ct(&builder, source[i]);
         }
         for (size_t i = 0; i < target.size(); i++) {
-            target_ct[i] = witness_ct(&composer, target[i]);
+            target_ct[i] = witness_ct(&builder, target[i]);
         }
 
-        push_array_to_array<Composer>(source_ct, target_ct);
+        push_array_to_array<Builder>(source_ct, target_ct);
 
         // Check that the source array has been inserted into the first available index of the target array.
         if (!expect_fail) {
@@ -279,18 +279,18 @@ template <typename Composer> class stdlib_array : public testing::Test {
         }
 
         bool proof_result = false;
-        if (!composer.failed()) {
-            info("composer gates = ", composer.get_num_gates());
-            proof_result = composer.check_circuit();
+        if (!builder.failed()) {
+            info("num gates = ", builder.get_num_gates());
+            proof_result = builder.check_circuit();
         }
 
-        return std::make_pair(proof_result, composer.err());
+        return std::make_pair(proof_result, builder.err());
     }
 
     static void test_pata_large_bench()
     {
         // Benchmark
-        Composer composer = Composer();
+        Builder builder = Builder();
 
         std::array<fr, 64> source;
         std::array<fr, 128> target = { 0 };
@@ -303,63 +303,63 @@ template <typename Composer> class stdlib_array : public testing::Test {
         };
         bool proof_result;
         std::string error;
-        std::tie(proof_result, error) = test_push_array_to_array_helper(composer, source, target, expected_target);
+        std::tie(proof_result, error) = test_push_array_to_array_helper(builder, source, target, expected_target);
 
         EXPECT_TRUE(proof_result);
     }
 
     static void test_pata_same_size_not_full_to_not_full()
     {
-        Composer composer = Composer();
+        Builder builder = Builder();
 
         std::array<fr, 4> source = { 1, 0, 0, 0 };
         std::array<fr, 4> target = { 3, 0, 0, 0 };
         std::array<fr, 4> expected_target = { 3, 1, 0, 0 };
         bool proof_result;
         std::string error;
-        std::tie(proof_result, error) = test_push_array_to_array_helper(composer, source, target, expected_target);
+        std::tie(proof_result, error) = test_push_array_to_array_helper(builder, source, target, expected_target);
 
         EXPECT_TRUE(proof_result);
     }
 
     static void test_pata_same_size_not_full_to_not_full_2()
     {
-        Composer composer = Composer();
+        Builder builder = Builder();
 
         std::array<fr, 4> source = { 3, 4, 0, 0 };
         std::array<fr, 4> target = { 1, 2, 0, 0 };
         std::array<fr, 4> expected_target = { 1, 2, 3, 4 };
         bool proof_result;
         std::string error;
-        std::tie(proof_result, error) = test_push_array_to_array_helper(composer, source, target, expected_target);
+        std::tie(proof_result, error) = test_push_array_to_array_helper(builder, source, target, expected_target);
 
         EXPECT_TRUE(proof_result);
     }
 
     static void test_pata_same_size_not_full_to_empty()
     {
-        Composer composer = Composer();
+        Builder builder = Builder();
 
         std::array<fr, 4> source = { 1, 2, 3, 0 };
         std::array<fr, 4> target = { 0, 0, 0, 0 };
         std::array<fr, 4> expected_target = { 1, 2, 3, 0 };
         bool proof_result;
         std::string error;
-        std::tie(proof_result, error) = test_push_array_to_array_helper(composer, source, target, expected_target);
+        std::tie(proof_result, error) = test_push_array_to_array_helper(builder, source, target, expected_target);
 
         EXPECT_TRUE(proof_result);
     }
 
     static void test_pata_smaller_source_full_to_not_full()
     {
-        Composer composer = Composer();
+        Builder builder = Builder();
 
         std::array<fr, 3> source = { 1, 2, 3 };
         std::array<fr, 6> target = { 4, 5, 6, 0, 0, 0 };
         std::array<fr, 6> expected_target = { 4, 5, 6, 1, 2, 3 };
         bool proof_result;
         std::string error;
-        std::tie(proof_result, error) = test_push_array_to_array_helper(composer, source, target, expected_target);
+        std::tie(proof_result, error) = test_push_array_to_array_helper(builder, source, target, expected_target);
 
         EXPECT_TRUE(proof_result);
     }
@@ -367,28 +367,28 @@ template <typename Composer> class stdlib_array : public testing::Test {
     static void test_pata_null_source()
     {
         // null means array size is 0
-        Composer composer = Composer();
+        Builder builder = Builder();
 
         std::array<fr, 0> source;
         std::array<fr, 4> target = { 1, 2, 0, 0 };
         std::array<fr, 4> expected_target = { 1, 2, 0, 0 };
         bool proof_result;
         std::string error;
-        std::tie(proof_result, error) = test_push_array_to_array_helper(composer, source, target, expected_target);
+        std::tie(proof_result, error) = test_push_array_to_array_helper(builder, source, target, expected_target);
 
         EXPECT_TRUE(proof_result);
     }
 
     static void test_pata_null_target_fails()
     {
-        Composer composer = Composer();
+        Builder builder = Builder();
 
         std::array<fr, 4> source = { 1, 2, 0, 0 };
         std::array<fr, 0> target;
         std::array<fr, 0> expected_target;
         bool proof_result;
         std::string error;
-        std::tie(proof_result, error) = test_push_array_to_array_helper(composer, source, target, expected_target);
+        std::tie(proof_result, error) = test_push_array_to_array_helper(builder, source, target, expected_target);
 
         EXPECT_FALSE(proof_result);
         EXPECT_EQ(error, "push_array_to_array target array capacity exceeded");
@@ -396,42 +396,42 @@ template <typename Composer> class stdlib_array : public testing::Test {
 
     static void test_pata_singletons_full_to_not_full()
     {
-        Composer composer = Composer();
+        Builder builder = Builder();
 
         std::array<fr, 1> source = { 1 };
         std::array<fr, 1> target = { 0 };
         std::array<fr, 1> expected_target = { 1 };
         bool proof_result;
         std::string error;
-        std::tie(proof_result, error) = test_push_array_to_array_helper(composer, source, target, expected_target);
+        std::tie(proof_result, error) = test_push_array_to_array_helper(builder, source, target, expected_target);
 
         EXPECT_TRUE(proof_result);
     }
 
     static void test_pata_singletons_not_full_to_full()
     {
-        Composer composer = Composer();
+        Builder builder = Builder();
 
         std::array<fr, 1> source = { 0 };
         std::array<fr, 1> target = { 1 };
         std::array<fr, 1> expected_target = { 1 };
         bool proof_result;
         std::string error;
-        std::tie(proof_result, error) = test_push_array_to_array_helper(composer, source, target, expected_target);
+        std::tie(proof_result, error) = test_push_array_to_array_helper(builder, source, target, expected_target);
 
         EXPECT_TRUE(proof_result);
     }
 
     static void test_pata_singletons_full_to_full()
     {
-        Composer composer = Composer();
+        Builder builder = Builder();
 
         std::array<fr, 1> source = { 2 };
         std::array<fr, 1> target = { 1 };
         std::array<fr, 1> expected_target = { 1 };
         bool proof_result;
         std::string error;
-        std::tie(proof_result, error) = test_push_array_to_array_helper(composer, source, target, expected_target);
+        std::tie(proof_result, error) = test_push_array_to_array_helper(builder, source, target, expected_target);
 
         EXPECT_FALSE(proof_result);
         EXPECT_EQ(error, "push_array_to_array target array capacity exceeded");
@@ -439,7 +439,7 @@ template <typename Composer> class stdlib_array : public testing::Test {
 
     static void test_pata_same_size_full_to_full_fails()
     {
-        Composer composer = Composer();
+        Builder builder = Builder();
 
         std::array<fr, 5> source = { 1, 2, 3, 4, 5 };
         std::array<fr, 5> target = { 5, 6, 7, 8, 9 };
@@ -448,7 +448,7 @@ template <typename Composer> class stdlib_array : public testing::Test {
         std::string error;
         bool expect_fail = true;
         std::tie(proof_result, error) =
-            test_push_array_to_array_helper(composer, source, target, expected_target, expect_fail);
+            test_push_array_to_array_helper(builder, source, target, expected_target, expect_fail);
 
         EXPECT_FALSE(proof_result);
         EXPECT_EQ(error, "push_array_to_array target array capacity exceeded");
@@ -456,7 +456,7 @@ template <typename Composer> class stdlib_array : public testing::Test {
 
     static void test_pata_nonzero_after_zero_source_fails()
     {
-        Composer composer = Composer();
+        Builder builder = Builder();
 
         std::array<fr, 4> source = { 1, 0, 2, 3 };
         std::array<fr, 6> target = { 4, 5, 6, 7, 8, 0 };
@@ -465,7 +465,7 @@ template <typename Composer> class stdlib_array : public testing::Test {
         std::string error;
         bool expect_fail = true;
         std::tie(proof_result, error) =
-            test_push_array_to_array_helper(composer, source, target, expected_target, expect_fail);
+            test_push_array_to_array_helper(builder, source, target, expected_target, expect_fail);
 
         EXPECT_FALSE(proof_result);
         EXPECT_EQ(error, "Once we've hit the first source zero, there must only be zeros thereafter!");
@@ -473,7 +473,7 @@ template <typename Composer> class stdlib_array : public testing::Test {
 
     static void test_pata_nonzero_after_zero_source_fails_2()
     {
-        Composer composer = Composer();
+        Builder builder = Builder();
 
         std::array<fr, 3> source = { 1, 0, 3 };
         std::array<fr, 6> target = { 4, 5, 2, 0, 0, 0 };
@@ -482,7 +482,7 @@ template <typename Composer> class stdlib_array : public testing::Test {
         std::string error;
         bool expect_fail = true;
         std::tie(proof_result, error) =
-            test_push_array_to_array_helper(composer, source, target, expected_target, expect_fail);
+            test_push_array_to_array_helper(builder, source, target, expected_target, expect_fail);
 
         EXPECT_FALSE(proof_result);
         EXPECT_EQ(error, "Once we've hit the first source zero, there must only be zeros thereafter!");
@@ -490,7 +490,7 @@ template <typename Composer> class stdlib_array : public testing::Test {
 
     static void test_pata_nonzero_after_zero_target_fails()
     {
-        Composer composer = Composer();
+        Builder builder = Builder();
 
         std::array<fr, 3> source = { 1, 2, 3 };
         std::array<fr, 6> target = { 4, 5, 0, 6, 7, 8 };
@@ -499,7 +499,7 @@ template <typename Composer> class stdlib_array : public testing::Test {
         std::string error;
         bool expect_fail = true;
         std::tie(proof_result, error) =
-            test_push_array_to_array_helper(composer, source, target, expected_target, expect_fail);
+            test_push_array_to_array_helper(builder, source, target, expected_target, expect_fail);
 
         EXPECT_FALSE(proof_result);
         EXPECT_EQ(error, "Once we've hit the first zero, there must only be zeros thereafter!");
@@ -507,7 +507,7 @@ template <typename Composer> class stdlib_array : public testing::Test {
 
     static void test_pata_nonzero_after_zero_target_fails_2()
     {
-        Composer composer = Composer();
+        Builder builder = Builder();
 
         std::array<fr, 3> source = { 1, 0, 3 };
         std::array<fr, 6> target = { 4, 5, 0, 6, 7, 8 };
@@ -516,7 +516,7 @@ template <typename Composer> class stdlib_array : public testing::Test {
         std::string error;
         bool expect_fail = true;
         std::tie(proof_result, error) =
-            test_push_array_to_array_helper(composer, source, target, expected_target, expect_fail);
+            test_push_array_to_array_helper(builder, source, target, expected_target, expect_fail);
 
         EXPECT_FALSE(proof_result);
         EXPECT_EQ(error, "Once we've hit the first zero, there must only be zeros thereafter!");
@@ -550,15 +550,15 @@ template <typename Composer> class stdlib_array : public testing::Test {
 
     void test_array_push_generic()
     {
-        Composer composer = Composer();
+        Builder builder = Builder();
 
         constexpr size_t SIZE = 5;
         std::array<MockClass, SIZE> arr{};
 
         // Push values into the array
-        stdlib::array_push<Composer>(arr, MockClass(witness_ct(&composer, 1), witness_ct(&composer, 10)));
-        stdlib::array_push<Composer>(arr, MockClass(witness_ct(&composer, 2), witness_ct(&composer, 20)));
-        stdlib::array_push<Composer>(arr, MockClass(witness_ct(&composer, 3), witness_ct(&composer, 30)));
+        stdlib::array_push<Builder>(arr, MockClass(witness_ct(&builder, 1), witness_ct(&builder, 10)));
+        stdlib::array_push<Builder>(arr, MockClass(witness_ct(&builder, 2), witness_ct(&builder, 20)));
+        stdlib::array_push<Builder>(arr, MockClass(witness_ct(&builder, 3), witness_ct(&builder, 30)));
 
         // Check the values in the array
         EXPECT_EQ(arr[0].get_values().first.get_value(), 1);
@@ -568,30 +568,30 @@ template <typename Composer> class stdlib_array : public testing::Test {
         EXPECT_EQ(arr[2].get_values().first.get_value(), 3);
         EXPECT_EQ(arr[2].get_values().second.get_value(), 30);
 
-        info("composer gates = ", composer.get_num_gates());
-        bool proof_result = composer.check_circuit();
+        info("num gates = ", builder.get_num_gates());
+        bool proof_result = builder.check_circuit();
         EXPECT_EQ(proof_result, true);
     }
 
     void test_array_push_generic_full()
     {
-        Composer composer = Composer();
+        Builder builder = Builder();
 
         constexpr size_t SIZE = 5;
         std::array<MockClass, SIZE> arr{};
 
         // Push values into the array
-        stdlib::array_push<Composer>(arr, MockClass(witness_ct(&composer, 1), witness_ct(&composer, 10)));
-        stdlib::array_push<Composer>(arr, MockClass(witness_ct(&composer, 2), witness_ct(&composer, 20)));
-        stdlib::array_push<Composer>(arr, MockClass(witness_ct(&composer, 3), witness_ct(&composer, 30)));
-        stdlib::array_push<Composer>(arr, MockClass(witness_ct(&composer, 4), witness_ct(&composer, 40)));
-        stdlib::array_push<Composer>(arr, MockClass(witness_ct(&composer, 5), witness_ct(&composer, 50)));
+        stdlib::array_push<Builder>(arr, MockClass(witness_ct(&builder, 1), witness_ct(&builder, 10)));
+        stdlib::array_push<Builder>(arr, MockClass(witness_ct(&builder, 2), witness_ct(&builder, 20)));
+        stdlib::array_push<Builder>(arr, MockClass(witness_ct(&builder, 3), witness_ct(&builder, 30)));
+        stdlib::array_push<Builder>(arr, MockClass(witness_ct(&builder, 4), witness_ct(&builder, 40)));
+        stdlib::array_push<Builder>(arr, MockClass(witness_ct(&builder, 5), witness_ct(&builder, 50)));
 
         // Try to push into a full array
-        stdlib::array_push<Composer>(arr, MockClass(witness_ct(&composer, 6), witness_ct(&composer, 60)));
+        stdlib::array_push<Builder>(arr, MockClass(witness_ct(&builder, 6), witness_ct(&builder, 60)));
 
-        EXPECT_EQ(composer.failed(), true);
-        EXPECT_EQ(composer.err(), "array_push cannot push to a full array");
+        EXPECT_EQ(builder.failed(), true);
+        EXPECT_EQ(builder.err(), "array_push cannot push to a full array");
     }
 };
 
diff --git a/barretenberg/cpp/src/barretenberg/stdlib/primitives/field/field.cpp b/barretenberg/cpp/src/barretenberg/stdlib/primitives/field/field.cpp
index a9b756f6180..01a98593090 100644
--- a/barretenberg/cpp/src/barretenberg/stdlib/primitives/field/field.cpp
+++ b/barretenberg/cpp/src/barretenberg/stdlib/primitives/field/field.cpp
@@ -9,16 +9,16 @@ using namespace proof_system;
 namespace proof_system::plonk {
 namespace stdlib {
 
-template <typename ComposerContext>
-field_t<ComposerContext>::field_t(ComposerContext* parent_context)
+template <typename Builder>
+field_t<Builder>::field_t(Builder* parent_context)
     : context(parent_context)
     , additive_constant(barretenberg::fr::zero())
     , multiplicative_constant(barretenberg::fr::one())
     , witness_index(IS_CONSTANT)
 {}
 
-template <typename ComposerContext>
-field_t<ComposerContext>::field_t(const witness_t<ComposerContext>& value)
+template <typename Builder>
+field_t<Builder>::field_t(const witness_t<Builder>& value)
     : context(value.context)
 {
     additive_constant = 0;
@@ -26,8 +26,8 @@ field_t<ComposerContext>::field_t(const witness_t<ComposerContext>& value)
     witness_index = value.witness_index;
 }
 
-template <typename ComposerContext>
-field_t<ComposerContext>::field_t(ComposerContext* parent_context, const barretenberg::fr& value)
+template <typename Builder>
+field_t<Builder>::field_t(Builder* parent_context, const barretenberg::fr& value)
     : context(parent_context)
 {
     additive_constant = value;
@@ -35,7 +35,7 @@ field_t<ComposerContext>::field_t(ComposerContext* parent_context, const barrete
     witness_index = IS_CONSTANT;
 }
 
-template <typename ComposerContext> field_t<ComposerContext>::field_t(const bool_t<ComposerContext>& other)
+template <typename Builder> field_t<Builder>::field_t(const bool_t<Builder>& other)
 {
     context = (other.context == nullptr) ? nullptr : other.context;
     if (other.witness_index == IS_CONSTANT) {
@@ -50,19 +50,18 @@ template <typename ComposerContext> field_t<ComposerContext>::field_t(const bool
     }
 }
 
-template <typename ComposerContext>
-field_t<ComposerContext> field_t<ComposerContext>::from_witness_index(ComposerContext* ctx,
-                                                                      const uint32_t witness_index)
+template <typename Builder>
+field_t<Builder> field_t<Builder>::from_witness_index(Builder* ctx, const uint32_t witness_index)
 {
-    field_t<ComposerContext> result(ctx);
+    field_t<Builder> result(ctx);
     result.witness_index = witness_index;
     return result;
 }
 
-template <typename ComposerContext> field_t<ComposerContext>::operator bool_t<ComposerContext>() const
+template <typename Builder> field_t<Builder>::operator bool_t<Builder>() const
 {
     if (witness_index == IS_CONSTANT) {
-        bool_t<ComposerContext> result(context);
+        bool_t<Builder> result(context);
         result.witness_bool = (additive_constant == barretenberg::fr::one());
         result.witness_inverted = false;
         result.witness_index = IS_CONSTANT;
@@ -78,7 +77,7 @@ template <typename ComposerContext> field_t<ComposerContext>::operator bool_t<Co
 
     barretenberg::fr witness = context->get_variable(witness_index);
     ASSERT((witness == barretenberg::fr::zero()) || (witness == barretenberg::fr::one()));
-    bool_t<ComposerContext> result(context);
+    bool_t<Builder> result(context);
     result.witness_bool = (witness == barretenberg::fr::one());
     result.witness_inverted = inverted_check;
     result.witness_index = witness_index;
@@ -86,11 +85,10 @@ template <typename ComposerContext> field_t<ComposerContext>::operator bool_t<Co
     return result;
 }
 
-template <typename ComposerContext>
-field_t<ComposerContext> field_t<ComposerContext>::operator+(const field_t& other) const
+template <typename Builder> field_t<Builder> field_t<Builder>::operator+(const field_t& other) const
 {
-    ComposerContext* ctx = (context == nullptr) ? other.context : context;
-    field_t<ComposerContext> result(ctx);
+    Builder* ctx = (context == nullptr) ? other.context : context;
+    field_t<Builder> result(ctx);
     ASSERT(ctx || (witness_index == IS_CONSTANT && other.witness_index == IS_CONSTANT));
 
     if (witness_index == other.witness_index) {
@@ -132,20 +130,18 @@ field_t<ComposerContext> field_t<ComposerContext>::operator+(const field_t& othe
     return result;
 }
 
-template <typename ComposerContext>
-field_t<ComposerContext> field_t<ComposerContext>::operator-(const field_t& other) const
+template <typename Builder> field_t<Builder> field_t<Builder>::operator-(const field_t& other) const
 {
-    field_t<ComposerContext> rhs(other);
+    field_t<Builder> rhs(other);
     rhs.additive_constant.self_neg();
     rhs.multiplicative_constant.self_neg();
     return operator+(rhs);
 }
 
-template <typename ComposerContext>
-field_t<ComposerContext> field_t<ComposerContext>::operator*(const field_t& other) const
+template <typename Builder> field_t<Builder> field_t<Builder>::operator*(const field_t& other) const
 {
-    ComposerContext* ctx = (context == nullptr) ? other.context : context;
-    field_t<ComposerContext> result(ctx);
+    Builder* ctx = (context == nullptr) ? other.context : context;
+    field_t<Builder> result(ctx);
     ASSERT(ctx || (witness_index == IS_CONSTANT && other.witness_index == IS_CONSTANT));
 
     if (witness_index == IS_CONSTANT && other.witness_index == IS_CONSTANT) {
@@ -246,17 +242,15 @@ field_t<ComposerContext> field_t<ComposerContext>::operator*(const field_t& othe
 
 // Since in divide_no_zero_check, we check a/b=c by the constraint a=b*c, if a=b=0, we can set c to *any value*
 // and it will pass the constraint. Hence, when not having prior knowledge of b not being zero it is essential to check.
-template <typename ComposerContext>
-field_t<ComposerContext> field_t<ComposerContext>::operator/(const field_t& other) const
+template <typename Builder> field_t<Builder> field_t<Builder>::operator/(const field_t& other) const
 {
     other.assert_is_not_zero("field_t::operator/ divisor is 0");
     return divide_no_zero_check(other);
 }
-template <typename ComposerContext>
-field_t<ComposerContext> field_t<ComposerContext>::divide_no_zero_check(const field_t& other) const
+template <typename Builder> field_t<Builder> field_t<Builder>::divide_no_zero_check(const field_t& other) const
 {
-    ComposerContext* ctx = (context == nullptr) ? other.context : context;
-    field_t<ComposerContext> result(ctx);
+    Builder* ctx = (context == nullptr) ? other.context : context;
+    field_t<Builder> result(ctx);
     ASSERT(ctx || (witness_index == IS_CONSTANT && other.witness_index == IS_CONSTANT));
 
     barretenberg::fr additive_multiplier = barretenberg::fr::one();
@@ -349,26 +343,24 @@ field_t<ComposerContext> field_t<ComposerContext>::divide_no_zero_check(const fi
  *
  * @returns this ** (exponent)
  */
-template <typename ComposerContext>
-field_t<ComposerContext> field_t<ComposerContext>::pow(const field_t& exponent) const
+template <typename Builder> field_t<Builder> field_t<Builder>::pow(const field_t& exponent) const
 {
     auto* ctx = get_context() ? get_context() : exponent.get_context();
 
     bool exponent_constant = exponent.is_constant();
 
     uint256_t exponent_value = exponent.get_value();
-    std::vector<bool_t<ComposerContext>> exponent_bits(32);
+    std::vector<bool_t<Builder>> exponent_bits(32);
     for (size_t i = 0; i < exponent_bits.size(); ++i) {
         uint256_t value_bit = exponent_value & 1;
-        bool_t<ComposerContext> bit;
-        bit = exponent_constant ? bool_t<ComposerContext>(ctx, value_bit.data[0])
-                                : witness_t<ComposerContext>(ctx, value_bit.data[0]);
+        bool_t<Builder> bit;
+        bit = exponent_constant ? bool_t<Builder>(ctx, value_bit.data[0]) : witness_t<Builder>(ctx, value_bit.data[0]);
         exponent_bits[31 - i] = (bit);
         exponent_value >>= 1;
     }
 
     if (!exponent_constant) {
-        field_t<ComposerContext> exponent_accumulator(ctx, 0);
+        field_t<Builder> exponent_accumulator(ctx, 0);
         for (const auto& bit : exponent_bits) {
             exponent_accumulator += exponent_accumulator;
             exponent_accumulator += bit;
@@ -389,11 +381,9 @@ field_t<ComposerContext> field_t<ComposerContext>::pow(const field_t& exponent)
 /**
  * @returns `this * to_mul + to_add`
  */
-template <typename ComposerContext>
-field_t<ComposerContext> field_t<ComposerContext>::madd(const field_t& to_mul, const field_t& to_add) const
+template <typename Builder> field_t<Builder> field_t<Builder>::madd(const field_t& to_mul, const field_t& to_add) const
 {
-    ComposerContext* ctx =
-        (context == nullptr) ? (to_mul.context == nullptr ? to_add.context : to_mul.context) : context;
+    Builder* ctx = (context == nullptr) ? (to_mul.context == nullptr ? to_add.context : to_mul.context) : context;
 
     if ((to_mul.witness_index == IS_CONSTANT) && (to_add.witness_index == IS_CONSTANT) &&
         (witness_index == IS_CONSTANT)) {
@@ -433,7 +423,7 @@ field_t<ComposerContext> field_t<ComposerContext>::madd(const field_t& to_mul, c
 
     barretenberg::fr out = a * b * q_m + a * q_1 + b * q_2 + c * q_3 + q_c;
 
-    field_t<ComposerContext> result(ctx);
+    field_t<Builder> result(ctx);
     result.witness_index = ctx->add_variable(out);
     ctx->create_big_mul_gate({
         .a = witness_index == IS_CONSTANT ? ctx->zero_idx : witness_index,
@@ -450,10 +440,9 @@ field_t<ComposerContext> field_t<ComposerContext>::madd(const field_t& to_mul, c
     return result;
 }
 
-template <typename ComposerContext>
-field_t<ComposerContext> field_t<ComposerContext>::add_two(const field_t& add_a, const field_t& add_b) const
+template <typename Builder> field_t<Builder> field_t<Builder>::add_two(const field_t& add_a, const field_t& add_b) const
 {
-    ComposerContext* ctx = (context == nullptr) ? (add_a.context == nullptr ? add_b.context : add_a.context) : context;
+    Builder* ctx = (context == nullptr) ? (add_a.context == nullptr ? add_b.context : add_a.context) : context;
 
     if ((add_a.witness_index == IS_CONSTANT) && (add_b.witness_index == IS_CONSTANT) &&
         (witness_index == IS_CONSTANT)) {
@@ -472,7 +461,7 @@ field_t<ComposerContext> field_t<ComposerContext>::add_two(const field_t& add_a,
 
     barretenberg::fr out = a * q_1 + b * q_2 + c * q_3 + q_c;
 
-    field_t<ComposerContext> result(ctx);
+    field_t<Builder> result(ctx);
     result.witness_index = ctx->add_variable(out);
 
     ctx->create_big_mul_gate({
@@ -490,7 +479,7 @@ field_t<ComposerContext> field_t<ComposerContext>::add_two(const field_t& add_a,
     return result;
 }
 
-template <typename ComposerContext> field_t<ComposerContext> field_t<ComposerContext>::normalize() const
+template <typename Builder> field_t<Builder> field_t<Builder>::normalize() const
 {
     if (witness_index == IS_CONSTANT ||
         ((multiplicative_constant == barretenberg::fr::one()) && (additive_constant == barretenberg::fr::zero()))) {
@@ -501,7 +490,7 @@ template <typename ComposerContext> field_t<ComposerContext> field_t<ComposerCon
     // Normalised result = result.v * 1 + 0;         // where result.v = this.v * this.mul + this.add
     // We need a new gate to enforce that the `result` was correctly calculated from `this`.
 
-    field_t<ComposerContext> result(context);
+    field_t<Builder> result(context);
     barretenberg::fr value = context->get_variable(witness_index);
     barretenberg::fr out;
     out = value * multiplicative_constant;
@@ -526,7 +515,7 @@ template <typename ComposerContext> field_t<ComposerContext> field_t<ComposerCon
     return result;
 }
 
-template <typename ComposerContext> void field_t<ComposerContext>::assert_is_zero(std::string const& msg) const
+template <typename Builder> void field_t<Builder>::assert_is_zero(std::string const& msg) const
 {
     if (get_value() != barretenberg::fr(0)) {
         context->failure(msg);
@@ -542,7 +531,7 @@ template <typename ComposerContext> void field_t<ComposerContext>::assert_is_zer
     // this.v * 0 * [ 0 ] + this.v * [this.mul] + 0 * [ 0 ] + 0 * [ 0 ] + [this.add] == 0
     // this.v * 0 * [q_m] + this.v * [   q_l  ] + 0 * [q_r] + 0 * [q_o] + [   q_c  ] == 0
 
-    ComposerContext* ctx = context;
+    Builder* ctx = context;
 
     context->create_poly_gate({
         .a = witness_index,
@@ -556,7 +545,7 @@ template <typename ComposerContext> void field_t<ComposerContext>::assert_is_zer
     });
 }
 
-template <typename ComposerContext> void field_t<ComposerContext>::assert_is_not_zero(std::string const& msg) const
+template <typename Builder> void field_t<Builder>::assert_is_not_zero(std::string const& msg) const
 {
     if (get_value() == barretenberg::fr(0)) {
         context->failure(msg);
@@ -568,14 +557,14 @@ template <typename ComposerContext> void field_t<ComposerContext>::assert_is_not
         return;
     }
 
-    ComposerContext* ctx = context;
+    Builder* ctx = context;
     if (get_value() == 0 && ctx) {
         ctx->failure(msg);
     }
 
     barretenberg::fr inverse_value = (get_value() == 0) ? 0 : get_value().invert();
 
-    field_t<ComposerContext> inverse(witness_t<ComposerContext>(ctx, inverse_value));
+    field_t<Builder> inverse(witness_t<Builder>(ctx, inverse_value));
 
     // Aim of new gate: `this` has an inverse (hence is not zero).
     // I.e.:
@@ -596,7 +585,7 @@ template <typename ComposerContext> void field_t<ComposerContext>::assert_is_not
     });
 }
 
-template <typename ComposerContext> bool_t<ComposerContext> field_t<ComposerContext>::is_zero() const
+template <typename Builder> bool_t<Builder> field_t<Builder>::is_zero() const
 {
     if (witness_index == IS_CONSTANT) {
         return bool_t(context, (get_value() == barretenberg::fr::zero()));
@@ -656,7 +645,7 @@ template <typename ComposerContext> bool_t<ComposerContext> field_t<ComposerCont
     return is_zero;
 }
 
-template <typename ComposerContext> barretenberg::fr field_t<ComposerContext>::get_value() const
+template <typename Builder> barretenberg::fr field_t<Builder>::get_value() const
 {
     if (witness_index != IS_CONSTANT) {
         ASSERT(context != nullptr);
@@ -667,10 +656,9 @@ template <typename ComposerContext> barretenberg::fr field_t<ComposerContext>::g
     }
 }
 
-template <typename ComposerContext>
-bool_t<ComposerContext> field_t<ComposerContext>::operator==(const field_t& other) const
+template <typename Builder> bool_t<Builder> field_t<Builder>::operator==(const field_t& other) const
 {
-    ComposerContext* ctx = (context == nullptr) ? other.context : context;
+    Builder* ctx = (context == nullptr) ? other.context : context;
 
     if (is_constant() && other.is_constant()) {
         return (get_value() == other.get_value());
@@ -697,31 +685,30 @@ bool_t<ComposerContext> field_t<ComposerContext>::operator==(const field_t& othe
     return result;
 }
 
-template <typename ComposerContext>
-bool_t<ComposerContext> field_t<ComposerContext>::operator!=(const field_t& other) const
+template <typename Builder> bool_t<Builder> field_t<Builder>::operator!=(const field_t& other) const
 {
     return !operator==(other);
 }
 
-template <typename ComposerContext>
-field_t<ComposerContext> field_t<ComposerContext>::conditional_negate(const bool_t<ComposerContext>& predicate) const
+template <typename Builder>
+field_t<Builder> field_t<Builder>::conditional_negate(const bool_t<Builder>& predicate) const
 {
-    field_t<ComposerContext> predicate_field(predicate);
-    field_t<ComposerContext> multiplicand = -(predicate_field + predicate_field);
+    field_t<Builder> predicate_field(predicate);
+    field_t<Builder> multiplicand = -(predicate_field + predicate_field);
     return multiplicand.madd(*this, *this);
 }
 
 // if predicate == true then return lhs, else return rhs
-template <typename ComposerContext>
-field_t<ComposerContext> field_t<ComposerContext>::conditional_assign(const bool_t<ComposerContext>& predicate,
-                                                                      const field_t& lhs,
-                                                                      const field_t& rhs)
+template <typename Builder>
+field_t<Builder> field_t<Builder>::conditional_assign(const bool_t<Builder>& predicate,
+                                                      const field_t& lhs,
+                                                      const field_t& rhs)
 {
     return (lhs - rhs).madd(predicate, rhs);
 }
 
-template <typename ComposerContext>
-void field_t<ComposerContext>::create_range_constraint(const size_t num_bits, std::string const& msg) const
+template <typename Builder>
+void field_t<Builder>::create_range_constraint(const size_t num_bits, std::string const& msg) const
 {
     if (num_bits == 0) {
         assert_is_zero("0-bit range_constraint on non-zero field_t.");
@@ -729,7 +716,7 @@ void field_t<ComposerContext>::create_range_constraint(const size_t num_bits, st
         if (is_constant()) {
             ASSERT(uint256_t(get_value()).get_msb() < num_bits);
         } else {
-            if constexpr (HasPlookup<ComposerContext>) {
+            if constexpr (HasPlookup<Builder>) {
                 context->decompose_into_default_range(normalize().get_witness_index(),
                                                       num_bits,
                                                       proof_system::UltraCircuitBuilder::DEFAULT_PLOOKUP_RANGE_BITNUM,
@@ -748,11 +735,10 @@ void field_t<ComposerContext>::create_range_constraint(const size_t num_bits, st
  * succeeds or fails. This can lead to confusion when debugging. If you want to log the inputs, do so before
  * calling this method.
  */
-template <typename ComposerContext>
-void field_t<ComposerContext>::assert_equal(const field_t& rhs, std::string const& msg) const
+template <typename Builder> void field_t<Builder>::assert_equal(const field_t& rhs, std::string const& msg) const
 {
     const field_t lhs = *this;
-    ComposerContext* ctx = lhs.get_context() ? lhs.get_context() : rhs.get_context();
+    Builder* ctx = lhs.get_context() ? lhs.get_context() : rhs.get_context();
 
     if (lhs.is_constant() && rhs.is_constant()) {
         ASSERT(lhs.get_value() == rhs.get_value());
@@ -769,16 +755,15 @@ void field_t<ComposerContext>::assert_equal(const field_t& rhs, std::string cons
     }
 }
 
-template <typename ComposerContext>
-void field_t<ComposerContext>::assert_not_equal(const field_t& rhs, std::string const& msg) const
+template <typename Builder> void field_t<Builder>::assert_not_equal(const field_t& rhs, std::string const& msg) const
 {
     const field_t lhs = *this;
     const field_t diff = lhs - rhs;
     diff.assert_is_not_zero(msg);
 }
 
-template <typename ComposerContext>
-void field_t<ComposerContext>::assert_is_in_set(const std::vector<field_t>& set, std::string const& msg) const
+template <typename Builder>
+void field_t<Builder>::assert_is_in_set(const std::vector<field_t>& set, std::string const& msg) const
 {
     const field_t input = *this;
     field_t product = (input - set[0]);
@@ -788,11 +773,11 @@ void field_t<ComposerContext>::assert_is_in_set(const std::vector<field_t>& set,
     product.assert_is_zero(msg);
 }
 
-template <typename ComposerContext>
-std::array<field_t<ComposerContext>, 4> field_t<ComposerContext>::preprocess_two_bit_table(const field_t& T0,
-                                                                                           const field_t& T1,
-                                                                                           const field_t& T2,
-                                                                                           const field_t& T3)
+template <typename Builder>
+std::array<field_t<Builder>, 4> field_t<Builder>::preprocess_two_bit_table(const field_t& T0,
+                                                                           const field_t& T1,
+                                                                           const field_t& T2,
+                                                                           const field_t& T3)
 {
     // (1 - t0)(1 - t1).T0 + t0(1 - t1).T1 + (1 - t0)t1.T2 + t0.t1.T3
 
@@ -810,15 +795,15 @@ std::array<field_t<ComposerContext>, 4> field_t<ComposerContext>::preprocess_two
 
 // Given T, stores the coefficients of the multilinear polynomial in t0,t1,t2, that on input a binary string b of
 // length 3, equals T_b
-template <typename ComposerContext>
-std::array<field_t<ComposerContext>, 8> field_t<ComposerContext>::preprocess_three_bit_table(const field_t& T0,
-                                                                                             const field_t& T1,
-                                                                                             const field_t& T2,
-                                                                                             const field_t& T3,
-                                                                                             const field_t& T4,
-                                                                                             const field_t& T5,
-                                                                                             const field_t& T6,
-                                                                                             const field_t& T7)
+template <typename Builder>
+std::array<field_t<Builder>, 8> field_t<Builder>::preprocess_three_bit_table(const field_t& T0,
+                                                                             const field_t& T1,
+                                                                             const field_t& T2,
+                                                                             const field_t& T3,
+                                                                             const field_t& T4,
+                                                                             const field_t& T5,
+                                                                             const field_t& T6,
+                                                                             const field_t& T7)
 {
     std::array<field_t, 8> table;
     table[0] = T0;                                    // const coeff
@@ -832,10 +817,10 @@ std::array<field_t<ComposerContext>, 8> field_t<ComposerContext>::preprocess_thr
     return table;
 }
 
-template <typename ComposerContext>
-field_t<ComposerContext> field_t<ComposerContext>::select_from_two_bit_table(const std::array<field_t, 4>& table,
-                                                                             const bool_t<ComposerContext>& t1,
-                                                                             const bool_t<ComposerContext>& t0)
+template <typename Builder>
+field_t<Builder> field_t<Builder>::select_from_two_bit_table(const std::array<field_t, 4>& table,
+                                                             const bool_t<Builder>& t1,
+                                                             const bool_t<Builder>& t0)
 {
     field_t R0 = static_cast<field_t>(t1).madd(table[3], table[1]);
     field_t R1 = R0.madd(static_cast<field_t>(t0), table[0]);
@@ -849,11 +834,11 @@ field_t<ComposerContext> field_t<ComposerContext>::select_from_two_bit_table(con
 // X:= ((t0*a012+a12)*t1+a2)*t2+a_const  - 3 gates
 // Y:= (t0*a01+a1)*t1+X - 2 gates
 // Z:= (t2*a02 + a0)*t0 + Y - 2 gates
-template <typename ComposerContext>
-field_t<ComposerContext> field_t<ComposerContext>::select_from_three_bit_table(const std::array<field_t, 8>& table,
-                                                                               const bool_t<ComposerContext>& t2,
-                                                                               const bool_t<ComposerContext>& t1,
-                                                                               const bool_t<ComposerContext>& t0)
+template <typename Builder>
+field_t<Builder> field_t<Builder>::select_from_three_bit_table(const std::array<field_t, 8>& table,
+                                                               const bool_t<Builder>& t2,
+                                                               const bool_t<Builder>& t1,
+                                                               const bool_t<Builder>& t0)
 {
     field_t R0 = static_cast<field_t>(t0).madd(table[7], table[6]);
     field_t R1 = static_cast<field_t>(t1).madd(R0, table[3]);
@@ -865,15 +850,12 @@ field_t<ComposerContext> field_t<ComposerContext>::select_from_three_bit_table(c
     return R6;
 }
 
-template <typename ComposerContext>
-void field_t<ComposerContext>::evaluate_linear_identity(const field_t& a,
-                                                        const field_t& b,
-                                                        const field_t& c,
-                                                        const field_t& d)
+template <typename Builder>
+void field_t<Builder>::evaluate_linear_identity(const field_t& a, const field_t& b, const field_t& c, const field_t& d)
 {
-    ComposerContext* ctx = a.context == nullptr
-                               ? (b.context == nullptr ? (c.context == nullptr ? d.context : c.context) : b.context)
-                               : a.context;
+    Builder* ctx = a.context == nullptr
+                       ? (b.context == nullptr ? (c.context == nullptr ? d.context : c.context) : b.context)
+                       : a.context;
 
     if (a.witness_index == IS_CONSTANT && b.witness_index == IS_CONSTANT && c.witness_index == IS_CONSTANT &&
         d.witness_index == IS_CONSTANT) {
@@ -900,15 +882,15 @@ void field_t<ComposerContext>::evaluate_linear_identity(const field_t& a,
     });
 }
 
-template <typename ComposerContext>
-void field_t<ComposerContext>::evaluate_polynomial_identity(const field_t& a,
-                                                            const field_t& b,
-                                                            const field_t& c,
-                                                            const field_t& d)
+template <typename Builder>
+void field_t<Builder>::evaluate_polynomial_identity(const field_t& a,
+                                                    const field_t& b,
+                                                    const field_t& c,
+                                                    const field_t& d)
 {
-    ComposerContext* ctx = a.context == nullptr
-                               ? (b.context == nullptr ? (c.context == nullptr ? d.context : c.context) : b.context)
-                               : a.context;
+    Builder* ctx = a.context == nullptr
+                       ? (b.context == nullptr ? (c.context == nullptr ? d.context : c.context) : b.context)
+                       : a.context;
 
     if (a.witness_index == IS_CONSTANT && b.witness_index == IS_CONSTANT && c.witness_index == IS_CONSTANT &&
         d.witness_index == IS_CONSTANT) {
@@ -940,17 +922,16 @@ void field_t<ComposerContext>::evaluate_polynomial_identity(const field_t& a,
 /**
  * Compute sum of inputs
  */
-template <typename ComposerContext>
-field_t<ComposerContext> field_t<ComposerContext>::accumulate(const std::vector<field_t>& input)
+template <typename Builder> field_t<Builder> field_t<Builder>::accumulate(const std::vector<field_t>& input)
 {
     if (input.size() == 0) {
-        return field_t<ComposerContext>(nullptr, 0);
+        return field_t<Builder>(nullptr, 0);
     }
     if (input.size() == 1) {
         return input[0]; //.normalize();
     }
     /**
-     * If we are using UltraPlonkComposer, we can accumulate 3 values into a sum per gate.
+     * If we are using UltraCircuitBuilder, we can accumulate 3 values into a sum per gate.
      * We track a decumulating sum of values in the 4th wire of every row.
      * i.e. the 4th wire of the first row is the total output value
      *
@@ -971,8 +952,8 @@ field_t<ComposerContext> field_t<ComposerContext>::accumulate(const std::vector<
      *
      * If num elements is not a multiple of 3, the final gate will be padded with zero_idx wires
      **/
-    if constexpr (HasPlookup<ComposerContext>) {
-        ComposerContext* ctx = nullptr;
+    if constexpr (HasPlookup<Builder>) {
+        Builder* ctx = nullptr;
         std::vector<field_t> accumulator;
         field_t constant_term = 0;
 
@@ -1001,7 +982,7 @@ field_t<ComposerContext> field_t<ComposerContext>::accumulate(const std::vector<
         // Step 3: pad accumulator to be a multiple of 3
         const size_t num_padding_wires = (num_elements % 3) == 0 ? 0 : 3 - (num_elements % 3);
         for (size_t i = 0; i < num_padding_wires; ++i) {
-            accumulator.emplace_back(field_t<ComposerContext>::from_witness_index(ctx, ctx->zero_idx));
+            accumulator.emplace_back(field_t<Builder>::from_witness_index(ctx, ctx->zero_idx));
         }
         num_elements = accumulator.size();
         const size_t num_gates = (num_elements / 3);
@@ -1026,10 +1007,10 @@ field_t<ComposerContext> field_t<ComposerContext>::accumulate(const std::vector<
                 ((i == num_gates - 1) ? false : true));
             barretenberg::fr new_total = accumulating_total.get_value() - accumulator[3 * i].get_value() -
                                          accumulator[3 * i + 1].get_value() - accumulator[3 * i + 2].get_value();
-            accumulating_total = witness_t<ComposerContext>(ctx, new_total);
+            accumulating_total = witness_t<Builder>(ctx, new_total);
         }
         return total.normalize();
-    } else if constexpr (std::same_as<ComposerContext, TurboCircuitBuilder>) {
+    } else if constexpr (std::same_as<Builder, TurboCircuitBuilder>) {
 
         field_t total(0);
         bool odd_number = (input.size() & 0x01UL) == 0x01ULL;
@@ -1042,20 +1023,20 @@ field_t<ComposerContext> field_t<ComposerContext>::accumulate(const std::vector<
         }
         return total.normalize();
     }
-    field_t<ComposerContext> total;
+    field_t<Builder> total;
     for (const auto& item : input) {
         total += item;
     }
     return total;
 }
 
-template <typename ComposerContext>
-std::array<field_t<ComposerContext>, 3> field_t<ComposerContext>::slice(const uint8_t msb, const uint8_t lsb) const
+template <typename Builder>
+std::array<field_t<Builder>, 3> field_t<Builder>::slice(const uint8_t msb, const uint8_t lsb) const
 {
     ASSERT(msb >= lsb);
     ASSERT(msb < grumpkin::MAX_NO_WRAP_INTEGER_BIT_LENGTH);
     const field_t lhs = *this;
-    ComposerContext* ctx = lhs.get_context();
+    Builder* ctx = lhs.get_context();
 
     const uint256_t value = uint256_t(get_value());
     const auto msb_plus_one = uint32_t(msb) + 1;
@@ -1106,24 +1087,23 @@ std::array<field_t<ComposerContext>, 3> field_t<ComposerContext>::slice(const ui
  * Here `b` is the boolean "a carry is necessary". Each of the resulting values can be checked for underflow by imposing
  * a small range constraint, since the negative of a small value in `Fr` is a large value in `Fr`.
  */
-template <typename ComposerContext>
-std::vector<bool_t<ComposerContext>> field_t<ComposerContext>::decompose_into_bits(
-    const size_t num_bits,
-    const std::function<witness_t<ComposerContext>(ComposerContext*, uint64_t, uint256_t)> get_bit) const
+template <typename Builder>
+std::vector<bool_t<Builder>> field_t<Builder>::decompose_into_bits(
+    const size_t num_bits, const std::function<witness_t<Builder>(Builder*, uint64_t, uint256_t)> get_bit) const
 {
     ASSERT(num_bits <= 256);
-    std::vector<bool_t<ComposerContext>> result(num_bits);
+    std::vector<bool_t<Builder>> result(num_bits);
 
     const uint256_t val_u256 = static_cast<uint256_t>(get_value());
-    field_t<ComposerContext> sum(context, 0);
-    field_t<ComposerContext> shifted_high_limb(context, 0); // will equal high 128 bits, left shifted by 128 bits
+    field_t<Builder> sum(context, 0);
+    field_t<Builder> shifted_high_limb(context, 0); // will equal high 128 bits, left shifted by 128 bits
     // TODO: Guido will make a PR that will fix an error here; hard-coded 127 is incorrect when 128 < num_bits < 256.
     // Extract bit vector and show that it has the same value as `this`.
     for (size_t i = 0; i < num_bits; ++i) {
-        bool_t<ComposerContext> bit = get_bit(context, num_bits - 1 - i, val_u256);
+        bool_t<Builder> bit = get_bit(context, num_bits - 1 - i, val_u256);
         result[num_bits - 1 - i] = bit;
         barretenberg::fr scaling_factor_value = fr(2).pow(static_cast<uint64_t>(num_bits - 1 - i));
-        field_t<ComposerContext> scaling_factor(context, scaling_factor_value);
+        field_t<Builder> scaling_factor(context, scaling_factor_value);
 
         sum = sum + (scaling_factor * bit);
         if (i == 127)
@@ -1143,7 +1123,7 @@ std::vector<bool_t<ComposerContext>> field_t<ComposerContext>::decompose_into_bi
         const fr shift = fr(uint256_t(1) << 128);
         // We always borrow from 2**128*p_hi. We handle whether this was necessary later.
         // y_lo = (2**128 + p_lo) - sum_lo
-        field_t<ComposerContext> y_lo = (-sum) + (p_lo + shift);
+        field_t<Builder> y_lo = (-sum) + (p_lo + shift);
         y_lo += shifted_high_limb;
         y_lo.normalize();
 
@@ -1155,10 +1135,10 @@ std::vector<bool_t<ComposerContext>> field_t<ComposerContext>::decompose_into_bi
         context->assert_equal(
             zeros.witness_index, context->zero_idx, "field_t: bit decomposition_fails: high limb non-zero");
         // y_borrow is the boolean "a carry was necessary"
-        field_t<ComposerContext> y_borrow = -(y_lo_hi - 1);
+        field_t<Builder> y_borrow = -(y_lo_hi - 1);
         // If a carry was necessary, subtract that carry from p_hi
         // y_hi = (p_hi - y_borrow) - sum_hi
-        field_t<ComposerContext> y_hi = -(shifted_high_limb / shift) + (p_hi);
+        field_t<Builder> y_hi = -(shifted_high_limb / shift) + (p_hi);
         y_hi -= y_borrow;
         // As before, except that now the range constraint is explicit, this shows that y_hi is non-negative.
         y_hi.create_range_constraint(128, "field_t: bit decomposition fails: y_hi is too large.");
diff --git a/barretenberg/cpp/src/barretenberg/stdlib/primitives/field/field.fuzzer.hpp b/barretenberg/cpp/src/barretenberg/stdlib/primitives/field/field.fuzzer.hpp
index c898d9d3763..d392310525b 100644
--- a/barretenberg/cpp/src/barretenberg/stdlib/primitives/field/field.fuzzer.hpp
+++ b/barretenberg/cpp/src/barretenberg/stdlib/primitives/field/field.fuzzer.hpp
@@ -118,12 +118,12 @@ FastRandom VarianceRNG(0);
  * @brief The class parametrizing Field fuzzing instructions, execution, etc
  *
  */
-template <typename Composer> class FieldBase {
+template <typename Builder> class FieldBase {
   private:
-    typedef proof_system::plonk::stdlib::bool_t<Composer> bool_t;
-    typedef proof_system::plonk::stdlib::field_t<Composer> field_t;
-    typedef proof_system::plonk::stdlib::witness_t<Composer> witness_t;
-    typedef proof_system::plonk::stdlib::public_witness_t<Composer> public_witness_t;
+    typedef proof_system::plonk::stdlib::bool_t<Builder> bool_t;
+    typedef proof_system::plonk::stdlib::field_t<Builder> field_t;
+    typedef proof_system::plonk::stdlib::witness_t<Builder> witness_t;
+    typedef proof_system::plonk::stdlib::public_witness_t<Builder> public_witness_t;
 
   public:
     /**
@@ -732,7 +732,7 @@ template <typename Composer> class FieldBase {
             const auto& ref = new_field;
             return ExecutionHandler(this->base, ref);
         }
-        static bool_t construct_predicate(Composer* composer, const bool predicate)
+        static bool_t construct_predicate(Builder* builder, const bool predicate)
         {
             /* The context field of a predicate can be nullptr;
              * in that case, the function that handles the predicate
@@ -740,7 +740,7 @@ template <typename Composer> class FieldBase {
              */
             const bool predicate_has_ctx = static_cast<bool>(VarianceRNG.next() % 2);
 
-            return bool_t(predicate_has_ctx ? composer : nullptr, predicate);
+            return bool_t(predicate_has_ctx ? builder : nullptr, predicate);
         }
         field_t f() const
         {
@@ -949,35 +949,35 @@ template <typename Composer> class FieldBase {
             this->f().assert_is_not_zero();
         }
 
-        ExecutionHandler conditional_negate(Composer* composer, const bool predicate)
+        ExecutionHandler conditional_negate(Builder* builder, const bool predicate)
         {
             return ExecutionHandler(predicate ? -(this->base) : this->base,
-                                    this->f().conditional_negate(construct_predicate(composer, predicate)));
+                                    this->f().conditional_negate(construct_predicate(builder, predicate)));
         }
 
-        ExecutionHandler conditional_select(Composer* composer, ExecutionHandler& other, const bool predicate)
+        ExecutionHandler conditional_select(Builder* builder, ExecutionHandler& other, const bool predicate)
         {
             return ExecutionHandler(
                 predicate ? other.base : this->base,
-                field_t(composer).conditional_assign(construct_predicate(composer, predicate), other.f(), this->f()));
+                field_t(builder).conditional_assign(construct_predicate(builder, predicate), other.f(), this->f()));
         }
 
-        ExecutionHandler select_if_zero(Composer* composer, ExecutionHandler& other1, ExecutionHandler& other2)
+        ExecutionHandler select_if_zero(Builder* builder, ExecutionHandler& other1, ExecutionHandler& other2)
         {
             return ExecutionHandler(other2.base.is_zero() ? other1.base : this->base,
-                                    field_t(composer).conditional_assign(other2.f().is_zero(), other1.f(), this->f()));
+                                    field_t(builder).conditional_assign(other2.f().is_zero(), other1.f(), this->f()));
         }
 
-        ExecutionHandler select_if_eq(Composer* composer, ExecutionHandler& other1, ExecutionHandler& other2)
+        ExecutionHandler select_if_eq(Builder* builder, ExecutionHandler& other1, ExecutionHandler& other2)
         {
             return ExecutionHandler(
                 other1.base == other2.base ? other1.base : this->base,
-                field_t(composer).conditional_assign(other1.f() == other2.f(), other1.f(), this->f()));
+                field_t(builder).conditional_assign(other1.f() == other2.f(), other1.f(), this->f()));
         }
         /* Explicit re-instantiation using the various constructors */
-        ExecutionHandler set(Composer* composer)
+        ExecutionHandler set(Builder* builder)
         {
-            (void)composer;
+            (void)builder;
 
             switch (VarianceRNG.next() % 9) {
             case 0:
@@ -1017,8 +1017,8 @@ template <typename Composer> class FieldBase {
                  *
                  * TEST(stdlib_field, test_construct_via_bool_t)
                  * {
-                 *     proof_system::StandardCircuitBuilder composer =
-                 * proof_system::proof_system::StandardCircuitBuilder(); field_t a(witness_t(&composer,
+                 *     proof_system::StandardCircuitBuilder builder =
+                 * proof_system::proof_system::StandardCircuitBuilder(); field_t a(witness_t(&builder,
                  * 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;
                  * }
@@ -1070,12 +1070,12 @@ template <typename Composer> class FieldBase {
                 case 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));
+                    return ExecutionHandler(this->base, field_t(builder, field_from_bits));
                 }
                 case 1: {
                     std::vector<field_t> fields;
                     for (const auto& fr : frs) {
-                        fields.push_back(field_t(composer, fr));
+                        fields.push_back(field_t(builder, fr));
                     }
                     /* This is a good opportunity to test
                      * field_t::accumulate with many elements
@@ -1102,18 +1102,18 @@ template <typename Composer> class FieldBase {
         /**
          * @brief Execute the constant instruction (push constant safeuint to the stack)
          *
-         * @param composer
+         * @param builder
          * @param stack
          * @param instruction
          * @return 0 if everything is ok, 1 if we should stop execution, since an expected error was encountered
          */
-        static inline size_t execute_CONSTANT(Composer* composer,
+        static inline size_t execute_CONSTANT(Builder* builder,
                                               std::vector<ExecutionHandler>& stack,
                                               Instruction& instruction)
         {
-            (void)composer;
+            (void)builder;
             stack.push_back(
-                ExecutionHandler(instruction.arguments.element, field_t(composer, instruction.arguments.element)));
+                ExecutionHandler(instruction.arguments.element, field_t(builder, instruction.arguments.element)));
 #ifdef SHOW_INFORMATION
             std::cout << "Pushed constant value " << instruction.arguments.element << " to position "
                       << stack.size() - 1 << std::endl;
@@ -1124,19 +1124,19 @@ template <typename Composer> class FieldBase {
         /**
          * @brief Execute the witness instruction (push witness safeuit to the stack)
          *
-         * @param composer
+         * @param builder
          * @param stack
          * @param instruction
          * @return if everything is ok, 1 if we should stop execution, since an expected error was encountered
          */
-        static inline size_t execute_WITNESS(Composer* composer,
+        static inline size_t execute_WITNESS(Builder* builder,
                                              std::vector<ExecutionHandler>& stack,
                                              Instruction& instruction)
         {
 
             // THis is strange
             stack.push_back(
-                ExecutionHandler(instruction.arguments.element, witness_t(composer, instruction.arguments.element)));
+                ExecutionHandler(instruction.arguments.element, witness_t(builder, instruction.arguments.element)));
 
 #ifdef SHOW_INFORMATION
             std::cout << "Pushed witness value " << instruction.arguments.element << " to position " << stack.size() - 1
@@ -1149,17 +1149,17 @@ template <typename Composer> class FieldBase {
          * @brief Execute the constant_witness instruction (push a safeuint witness equal to the constant to the
          * stack)
          *
-         * @param composer
+         * @param builder
          * @param stack
          * @param instruction
          * @return 0 if everything is ok, 1 if we should stop execution, since an expected error was encountered
          */
-        static inline size_t execute_CONSTANT_WITNESS(Composer* composer,
+        static inline size_t execute_CONSTANT_WITNESS(Builder* builder,
                                                       std::vector<ExecutionHandler>& stack,
                                                       Instruction& instruction)
         {
-            auto v = field_t(witness_t(composer, instruction.arguments.element));
-            v.convert_constant_to_fixed_witness(composer);
+            auto v = field_t(witness_t(builder, instruction.arguments.element));
+            v.convert_constant_to_fixed_witness(builder);
             stack.push_back(ExecutionHandler(instruction.arguments.element, std::move(v)));
 #ifdef SHOW_INFORMATION
             std::cout << "Pushed constant witness value " << instruction.arguments.element << " to position "
@@ -1170,17 +1170,17 @@ template <typename Composer> class FieldBase {
         /**
          * @brief Execute the multiply instruction
          *
-         * @param composer
+         * @param builder
          * @param stack
          * @param instruction
          * @return if everything is ok, 1 if we should stop execution, since an expected error was encountered
          */
-        static inline size_t execute_MULTIPLY(Composer* composer,
+        static inline size_t execute_MULTIPLY(Builder* builder,
                                               std::vector<ExecutionHandler>& stack,
                                               Instruction& instruction)
         {
 
-            (void)composer;
+            (void)builder;
             if (stack.size() == 0) {
                 return 1;
             }
@@ -1206,16 +1206,16 @@ template <typename Composer> class FieldBase {
         /**
          * @brief Execute the addition operator instruction
          *
-         * @param composer
+         * @param builder
          * @param stack
          * @param instruction
          * @return if everything is ok, 1 if we should stop execution, since an expected error was encountered
          */
-        static inline size_t execute_ADD(Composer* composer,
+        static inline size_t execute_ADD(Builder* builder,
                                          std::vector<ExecutionHandler>& stack,
                                          Instruction& instruction)
         {
-            (void)composer;
+            (void)builder;
             if (stack.size() == 0) {
                 return 1;
             }
@@ -1242,16 +1242,16 @@ template <typename Composer> class FieldBase {
         /**
          * @brief Execute the SQR  instruction
          *
-         * @param composer
+         * @param builder
          * @param stack
          * @param instruction
          * @return if everything is ok, 1 if we should stop execution, since an expected error was encountered
          */
-        static inline size_t execute_SQR(Composer* composer,
+        static inline size_t execute_SQR(Builder* builder,
                                          std::vector<ExecutionHandler>& stack,
                                          Instruction& instruction)
         {
-            (void)composer;
+            (void)builder;
             if (stack.size() == 0) {
                 return 1;
             }
@@ -1277,16 +1277,16 @@ template <typename Composer> class FieldBase {
         /**
          * @brief Execute the ASSERT_EQUAL  instruction
          *
-         * @param composer
+         * @param builder
          * @param stack
          * @param instruction
          * @return if everything is ok, 1 if we should stop execution, since an expected error was encountered
          */
-        static inline size_t execute_ASSERT_EQUAL(Composer* composer,
+        static inline size_t execute_ASSERT_EQUAL(Builder* builder,
                                                   std::vector<ExecutionHandler>& stack,
                                                   Instruction& instruction)
         {
-            (void)composer;
+            (void)builder;
             if (stack.size() == 0) {
                 return 1;
             }
@@ -1305,16 +1305,16 @@ template <typename Composer> class FieldBase {
         /**
          * @brief Execute the ASSERT_NOT_EQUAL  instruction
          *
-         * @param composer
+         * @param builder
          * @param stack
          * @param instruction
          * @return if everything is ok, 1 if we should stop execution, since an expected error was encountered
          */
-        static inline size_t execute_ASSERT_NOT_EQUAL(Composer* composer,
+        static inline size_t execute_ASSERT_NOT_EQUAL(Builder* builder,
                                                       std::vector<ExecutionHandler>& stack,
                                                       Instruction& instruction)
         {
-            (void)composer;
+            (void)builder;
             if (stack.size() == 0) {
                 return 1;
             }
@@ -1333,16 +1333,16 @@ template <typename Composer> class FieldBase {
         /**
          * @brief Execute the ASSERT_ZERO  instruction
          *
-         * @param composer
+         * @param builder
          * @param stack
          * @param instruction
          * @return if everything is ok, 1 if we should stop execution, since an expected error was encountered
          */
-        static inline size_t execute_ASSERT_ZERO(Composer* composer,
+        static inline size_t execute_ASSERT_ZERO(Builder* builder,
                                                  std::vector<ExecutionHandler>& stack,
                                                  Instruction& instruction)
         {
-            (void)composer;
+            (void)builder;
             if (stack.size() == 0) {
                 return 1;
             }
@@ -1364,16 +1364,16 @@ template <typename Composer> class FieldBase {
         /**
          * @brief Execute the ASSERT_NOT_ZERO  instruction
          *
-         * @param composer
+         * @param builder
          * @param stack
          * @param instruction
          * @return if everything is ok, 1 if we should stop execution, since an expected error was encountered
          */
-        static inline size_t execute_ASSERT_NOT_ZERO(Composer* composer,
+        static inline size_t execute_ASSERT_NOT_ZERO(Builder* builder,
                                                      std::vector<ExecutionHandler>& stack,
                                                      Instruction& instruction)
         {
-            (void)composer;
+            (void)builder;
             if (stack.size() == 0) {
                 return 1;
             }
@@ -1394,16 +1394,16 @@ template <typename Composer> class FieldBase {
         /**
          * @brief Execute the subtraction operator instruction
          *
-         * @param composer
+         * @param builder
          * @param stack
          * @param instruction
          * @return if everything is ok, 1 if we should stop execution, since an expected error was encountered
          */
-        static inline size_t execute_SUBTRACT(Composer* composer,
+        static inline size_t execute_SUBTRACT(Builder* builder,
                                               std::vector<ExecutionHandler>& stack,
                                               Instruction& instruction)
         {
-            (void)composer;
+            (void)builder;
             if (stack.size() == 0) {
                 return 1;
             }
@@ -1429,16 +1429,16 @@ template <typename Composer> class FieldBase {
         /**
          * @brief Execute the division operator instruction
          *
-         * @param composer
+         * @param builder
          * @param stack
          * @param instruction
          * @return if everything is ok, 1 if we should stop execution, since an expected error was encountered
          */
-        static inline size_t execute_DIVIDE(Composer* composer,
+        static inline size_t execute_DIVIDE(Builder* builder,
                                             std::vector<ExecutionHandler>& stack,
                                             Instruction& instruction)
         {
-            (void)composer;
+            (void)builder;
             if (stack.size() == 0) {
                 return 1;
             }
@@ -1471,17 +1471,17 @@ template <typename Composer> class FieldBase {
         /**
          * @brief Execute the ADD_TWO instruction
          *
-         * @param composer
+         * @param builder
          * @param stack
          * @param instruction
          * @return if everything is ok, 1 if we should stop execution, since an expected error was encountered
         size_t
          */
-        static inline size_t execute_ADD_TWO(Composer* composer,
+        static inline size_t execute_ADD_TWO(Builder* builder,
                                              std::vector<ExecutionHandler>& stack,
                                              Instruction& instruction)
         {
-            (void)composer;
+            (void)builder;
             if (stack.size() == 0) {
                 return 1;
             }
@@ -1507,17 +1507,17 @@ template <typename Composer> class FieldBase {
         /**
          * @brief Execute the MADD instruction
          *
-         * @param composer
+         * @param builder
          * @param stack
          * @param instruction
          * @return if everything is ok, 1 if we should stop execution, since an expected error was encountered
         size_t
          */
-        static inline size_t execute_MADD(Composer* composer,
+        static inline size_t execute_MADD(Builder* builder,
                                           std::vector<ExecutionHandler>& stack,
                                           Instruction& instruction)
         {
-            (void)composer;
+            (void)builder;
             if (stack.size() == 0) {
                 return 1;
             }
@@ -1544,17 +1544,17 @@ template <typename Composer> class FieldBase {
         /**
          * @brief Execute the slice instruction
          *
-         * @param composer
+         * @param builder
          * @param stack
          * @param instruction
          * @return if everything is ok, 1 if we should stop execution, since an expected error was encountered
         size_t
          */
-        static inline size_t execute_SLICE(Composer* composer,
+        static inline size_t execute_SLICE(Builder* builder,
                                            std::vector<ExecutionHandler>& stack,
                                            Instruction& instruction)
         {
-            (void)composer;
+            (void)builder;
             if (stack.size() == 0) {
                 return 1;
             }
@@ -1595,16 +1595,16 @@ template <typename Composer> class FieldBase {
         /**
          * @brief Execute the RANDOMSEED instruction
          *
-         * @param composer
+         * @param builder
          * @param stack
          * @param instruction
          * @return if everything is ok, 1 if we should stop execution, since an expected error was encountered
          */
-        static inline size_t execute_RANDOMSEED(Composer* composer,
+        static inline size_t execute_RANDOMSEED(Builder* builder,
                                                 std::vector<ExecutionHandler>& stack,
                                                 Instruction& instruction)
         {
-            (void)composer;
+            (void)builder;
             (void)stack;
 
             VarianceRNG.reseed(instruction.arguments.randomseed);
@@ -1613,16 +1613,16 @@ template <typename Composer> class FieldBase {
         /**
          * @brief Execute the COND_NEGATE instruction
          *
-         * @param composer
+         * @param builder
          * @param stack
          * @param instruction
          * @return if everything is ok, 1 if we should stop execution, since an expected error was encountered
          */
-        static inline size_t execute_COND_NEGATE(Composer* composer,
+        static inline size_t execute_COND_NEGATE(Builder* builder,
                                                  std::vector<ExecutionHandler>& stack,
                                                  Instruction& instruction)
         {
-            (void)composer;
+            (void)builder;
             if (stack.size() == 0) {
                 return 1;
             }
@@ -1631,7 +1631,7 @@ template <typename Composer> class FieldBase {
             bool predicate = instruction.arguments.threeArgs.in2 % 2;
 
             ExecutionHandler result;
-            result = stack[first_index].conditional_negate(composer, predicate);
+            result = stack[first_index].conditional_negate(builder, predicate);
             // If the output index is larger than the number of elements in stack, append
             if (output_index >= stack.size()) {
                 PRINT_RESULT("", "pushed to ", stack.size(), result)
@@ -1647,16 +1647,16 @@ template <typename Composer> class FieldBase {
         /**
          * @brief Execute the COND_SELECT instruction
          *
-         * @param composer
+         * @param builder
          * @param stack
          * @param instruction
          * @return if everything is ok, 1 if we should stop execution, since an expected error was encountered
          */
-        static inline size_t execute_COND_SELECT(Composer* composer,
+        static inline size_t execute_COND_SELECT(Builder* builder,
                                                  std::vector<ExecutionHandler>& stack,
                                                  Instruction& instruction)
         {
-            (void)composer;
+            (void)builder;
             if (stack.size() == 0) {
                 return 1;
             }
@@ -1666,7 +1666,7 @@ template <typename Composer> class FieldBase {
             bool predicate = instruction.arguments.fourArgs.in3 % 2;
 
             ExecutionHandler result;
-            result = stack[first_index].conditional_select(composer, stack[second_index], predicate);
+            result = stack[first_index].conditional_select(builder, stack[second_index], predicate);
             // If the output index is larger than the number of elements in stack, append
             if (output_index >= stack.size()) {
                 PRINT_RESULT("", "pushed to ", stack.size(), result)
@@ -1681,16 +1681,16 @@ template <typename Composer> class FieldBase {
         /**
          * @brief Execute the SELECT_IF_ZERO instruction
          *
-         * @param composer
+         * @param builder
          * @param stack
          * @param instruction
          * @return if everything is ok, 1 if we should stop execution, since an expected error was encountered
          */
-        static inline size_t execute_SELECT_IF_ZERO(Composer* composer,
+        static inline size_t execute_SELECT_IF_ZERO(Builder* builder,
                                                     std::vector<ExecutionHandler>& stack,
                                                     Instruction& instruction)
         {
-            (void)composer;
+            (void)builder;
             if (stack.size() == 0) {
                 return 1;
             }
@@ -1700,7 +1700,7 @@ template <typename Composer> class FieldBase {
             size_t output_index = instruction.arguments.fourArgs.out % stack.size();
 
             ExecutionHandler result;
-            result = stack[first_index].select_if_zero(composer, stack[second_index], stack[third_index]);
+            result = stack[first_index].select_if_zero(builder, stack[second_index], stack[third_index]);
             // If the output index is larger than the number of elements in stack, append
             if (output_index >= stack.size()) {
                 PRINT_RESULT("", "pushed to ", stack.size(), result)
@@ -1715,16 +1715,16 @@ template <typename Composer> class FieldBase {
         /**
          * @brief Execute the SELECT_IF_EQ instruction
          *
-         * @param composer
+         * @param builder
          * @param stack
          * @param instruction
          * @return if everything is ok, 1 if we should stop execution, since an expected error was encountered
          */
-        static inline size_t execute_SELECT_IF_EQ(Composer* composer,
+        static inline size_t execute_SELECT_IF_EQ(Builder* builder,
                                                   std::vector<ExecutionHandler>& stack,
                                                   Instruction& instruction)
         {
-            (void)composer;
+            (void)builder;
             if (stack.size() == 0) {
                 return 1;
             }
@@ -1734,7 +1734,7 @@ template <typename Composer> class FieldBase {
             size_t output_index = instruction.arguments.fourArgs.out % stack.size();
 
             ExecutionHandler result;
-            result = stack[first_index].select_if_eq(composer, stack[second_index], stack[third_index]);
+            result = stack[first_index].select_if_eq(builder, stack[second_index], stack[third_index]);
             // If the output index is larger than the number of elements in stack, append
             if (output_index >= stack.size()) {
                 PRINT_RESULT("", "pushed to ", stack.size(), result)
@@ -1749,16 +1749,16 @@ template <typename Composer> class FieldBase {
         /**
          * @brief Execute the SET instruction
          *
-         * @param composer
+         * @param builder
          * @param stack
          * @param instruction
          * @return if everything is ok, 1 if we should stop execution, since an expected error was encountered
          */
-        static inline size_t execute_SET(Composer* composer,
+        static inline size_t execute_SET(Builder* builder,
                                          std::vector<ExecutionHandler>& stack,
                                          Instruction& instruction)
         {
-            (void)composer;
+            (void)builder;
             if (stack.size() == 0) {
                 return 1;
             }
@@ -1768,7 +1768,7 @@ template <typename Composer> class FieldBase {
             PRINT_SINGLE_ARG_INSTRUCTION(first_index, stack, "Instantiating", "")
 
             ExecutionHandler result;
-            result = stack[first_index].set(composer);
+            result = stack[first_index].set(builder);
             // If the output index is larger than the number of elements in stack, append
             if (output_index >= stack.size()) {
                 PRINT_RESULT("", "pushed to ", stack.size(), result)
@@ -1782,16 +1782,16 @@ template <typename Composer> class FieldBase {
         /**
          * @brief Execute the INVERT instruction
          *
-         * @param composer
+         * @param builder
          * @param stack
          * @param instruction
          * @return if everything is ok, 1 if we should stop execution, since an expected error was encountered
          */
-        static inline size_t execute_INVERT(Composer* composer,
+        static inline size_t execute_INVERT(Builder* builder,
                                             std::vector<ExecutionHandler>& stack,
                                             Instruction& instruction)
         {
-            (void)composer;
+            (void)builder;
             if (stack.size() == 0) {
                 return 1;
             }
@@ -1821,15 +1821,15 @@ template <typename Composer> class FieldBase {
     /**
      * @brief Check that the resulting values are equal to expected
      *
-     * @tparam Composer
-     * @param composer
+     * @tparam Builder
+     * @param builder
      * @param stack
      * @return true
      * @return false
      */
-    inline static bool postProcess(Composer* composer, std::vector<FieldBase::ExecutionHandler>& stack)
+    inline static bool postProcess(Builder* builder, std::vector<FieldBase::ExecutionHandler>& stack)
     {
-        (void)composer;
+        (void)builder;
         for (size_t i = 0; i < stack.size(); i++) {
             auto element = stack[i];
             if (barretenberg::fr((uint256_t(element.field.get_value()) % barretenberg::fr::modulus)) != element.base) {
@@ -2007,7 +2007,7 @@ extern "C" size_t LLVMFuzzerCustomCrossOver(const uint8_t* Data1,
  */
 extern "C" size_t LLVMFuzzerTestOneInput(const uint8_t* Data, size_t Size)
 {
-    RunWithComposers<FieldBase, FuzzerCircuitTypes>(Data, Size, VarianceRNG);
+    RunWithBuilders<FieldBase, FuzzerCircuitTypes>(Data, Size, VarianceRNG);
     return 0;
 }
 
diff --git a/barretenberg/cpp/src/barretenberg/stdlib/primitives/field/field.hpp b/barretenberg/cpp/src/barretenberg/stdlib/primitives/field/field.hpp
index 9d81760b932..f4fafa515fa 100644
--- a/barretenberg/cpp/src/barretenberg/stdlib/primitives/field/field.hpp
+++ b/barretenberg/cpp/src/barretenberg/stdlib/primitives/field/field.hpp
@@ -7,11 +7,11 @@
 namespace proof_system::plonk {
 namespace stdlib {
 
-template <typename ComposerContext> class bool_t;
-template <typename ComposerContext> class field_t {
+template <typename Builder> class bool_t;
+template <typename Builder> class field_t {
   public:
-    field_t(ComposerContext* parent_context = nullptr);
-    field_t(ComposerContext* parent_context, const barretenberg::fr& value);
+    field_t(Builder* parent_context = nullptr);
+    field_t(Builder* parent_context, const barretenberg::fr& value);
 
     field_t(const int value)
         : context(nullptr)
@@ -59,7 +59,7 @@ template <typename ComposerContext> class field_t {
         , witness_index(IS_CONSTANT)
     {}
 
-    field_t(const witness_t<ComposerContext>& value);
+    field_t(const witness_t<Builder>& value);
 
     field_t(const field_t& other)
         : context(other.context)
@@ -75,14 +75,14 @@ template <typename ComposerContext> class field_t {
         , witness_index(other.witness_index)
     {}
 
-    field_t(const bool_t<ComposerContext>& other);
+    field_t(const bool_t<Builder>& other);
 
     static constexpr bool is_composite = false;
     static constexpr uint256_t modulus = barretenberg::fr::modulus;
 
-    static field_t from_witness_index(ComposerContext* parent_context, const uint32_t witness_index);
+    static field_t from_witness_index(Builder* parent_context, const uint32_t witness_index);
 
-    explicit operator bool_t<ComposerContext>() const;
+    explicit operator bool_t<Builder>() const;
 
     field_t& operator=(const field_t& other)
     {
@@ -102,9 +102,9 @@ template <typename ComposerContext> class field_t {
         return *this;
     }
 
-    static field_t copy_as_new_witness(ComposerContext& context, field_t const& other)
+    static field_t copy_as_new_witness(Builder& context, field_t const& other)
     {
-        auto result = field_t<ComposerContext>(witness_t<ComposerContext>(&context, other.get_value()));
+        auto result = field_t<Builder>(witness_t<Builder>(&context, other.get_value()));
         result.assert_equal(other, "field_t::copy_as_new_witness, assert_equal");
         return result;
     }
@@ -174,7 +174,7 @@ template <typename ComposerContext> class field_t {
         return result;
     }
 
-    field_t conditional_negate(const bool_t<ComposerContext>& predicate) const;
+    field_t conditional_negate(const bool_t<Builder>& predicate) const;
 
     void assert_equal(const field_t& rhs, std::string const& msg = "field_t::assert_equal") const;
 
@@ -182,15 +182,15 @@ template <typename ComposerContext> class field_t {
 
     void assert_is_in_set(const std::vector<field_t>& set, std::string const& msg = "field_t::assert_not_in_set") const;
 
-    static field_t conditional_assign(const bool_t<ComposerContext>& predicate, const field_t& lhs, const field_t& rhs);
+    static field_t conditional_assign(const bool_t<Builder>& predicate, const field_t& lhs, const field_t& rhs);
 
     static std::array<field_t, 4> preprocess_two_bit_table(const field_t& T0,
                                                            const field_t& T1,
                                                            const field_t& T2,
                                                            const field_t& T3);
     static field_t select_from_two_bit_table(const std::array<field_t, 4>& table,
-                                             const bool_t<ComposerContext>& t1,
-                                             const bool_t<ComposerContext>& t0);
+                                             const bool_t<Builder>& t1,
+                                             const bool_t<Builder>& t0);
 
     static std::array<field_t, 8> preprocess_three_bit_table(const field_t& T0,
                                                              const field_t& T1,
@@ -201,9 +201,9 @@ template <typename ComposerContext> class field_t {
                                                              const field_t& T6,
                                                              const field_t& T7);
     static field_t select_from_three_bit_table(const std::array<field_t, 8>& table,
-                                               const bool_t<ComposerContext>& t2,
-                                               const bool_t<ComposerContext>& t1,
-                                               const bool_t<ComposerContext>& t0);
+                                               const bool_t<Builder>& t2,
+                                               const bool_t<Builder>& t1,
+                                               const bool_t<Builder>& t0);
 
     static void evaluate_linear_identity(const field_t& a, const field_t& b, const field_t& c, const field_t& d);
     static void evaluate_polynomial_identity(const field_t& a, const field_t& b, const field_t& c, const field_t& d);
@@ -218,13 +218,13 @@ template <typename ComposerContext> class field_t {
 
     // add_two costs 1 constraint for turbo/ultra plonk
     field_t add_two(const field_t& add_a, const field_t& add_b) const;
-    bool_t<ComposerContext> operator==(const field_t& other) const;
-    bool_t<ComposerContext> operator!=(const field_t& other) const;
+    bool_t<Builder> operator==(const field_t& other) const;
+    bool_t<Builder> operator!=(const field_t& other) const;
 
     /**
      * normalize returns a field_t element with equivalent value to `this`, but where `multiplicative_constant = 1` and
      *`additive_constant = 0`.
-     * I.e. the returned value is defined entirely by the composer variable that `witness_index` points to (no scaling
+     * I.e. the returned value is defined entirely by the builder variable that `witness_index` points to (no scaling
      * factors).
      *
      * If the witness_index of `this` is ever needed, `normalize` should be called first.
@@ -238,7 +238,7 @@ template <typename ComposerContext> class field_t {
 
     barretenberg::fr get_value() const;
 
-    ComposerContext* get_context() const { return context; }
+    Builder* get_context() const { return context; }
 
     /**
      * Slices a `field_t` at given indices (msb, lsb) both included in the slice,
@@ -250,7 +250,7 @@ template <typename ComposerContext> class field_t {
      * is_zero will return a bool_t, and add constraints that enforce its correctness
      * N.B. If you want to ENFORCE that a field_t object is zero, use `assert_is_zero`
      **/
-    bool_t<ComposerContext> is_zero() const;
+    bool_t<Builder> is_zero() const;
 
     void create_range_constraint(const size_t num_bits, std::string const& msg = "field_t::range_constraint") const;
     void assert_is_not_zero(std::string const& msg = "field_t::assert_is_not_zero") const;
@@ -262,17 +262,17 @@ template <typename ComposerContext> class field_t {
      * Create a witness form a constant. This way the value of the witness is fixed and public (public, because the
      * value becomes hard-coded as an element of the q_c selector vector).
      */
-    void convert_constant_to_fixed_witness(ComposerContext* ctx)
+    void convert_constant_to_fixed_witness(Builder* ctx)
     {
         ASSERT(witness_index == IS_CONSTANT);
         context = ctx;
-        (*this) = field_t<ComposerContext>(witness_t<ComposerContext>(context, get_value()));
+        (*this) = field_t<Builder>(witness_t<Builder>(context, get_value()));
         context->fix_witness(witness_index, get_value());
     }
 
-    static field_t from_witness(ComposerContext* ctx, const barretenberg::fr& input)
+    static field_t from_witness(Builder* ctx, const barretenberg::fr& input)
     {
-        return field_t(witness_t<ComposerContext>(ctx, input));
+        return field_t(witness_t<Builder>(ctx, input));
     }
 
     /**
@@ -288,25 +288,23 @@ template <typename ComposerContext> class field_t {
 
     uint32_t get_witness_index() const { return witness_index; }
 
-    std::vector<bool_t<ComposerContext>> decompose_into_bits(
+    std::vector<bool_t<Builder>> decompose_into_bits(
         const size_t num_bits = 256,
-        std::function<witness_t<ComposerContext>(ComposerContext* ctx, uint64_t, uint256_t)> get_bit =
-            [](ComposerContext* ctx, uint64_t j, uint256_t val) {
-                return witness_t<ComposerContext>(ctx, val.get_bit(j));
-            }) const;
+        std::function<witness_t<Builder>(Builder* ctx, uint64_t, uint256_t)> get_bit =
+            [](Builder* ctx, uint64_t j, uint256_t val) { return witness_t<Builder>(ctx, val.get_bit(j)); }) const;
 
     /**
      * @brief Return (a < b) as bool circuit type.
      *        This method *assumes* that both a and b are < 2^{input_bits} - 1
      *        i.e. it is not checked here, we assume this has been done previously
      *
-     * @tparam Composer
+     * @tparam Builder
      * @tparam input_bits
      * @param a
      * @param b
-     * @return bool_t<Composer>
+     * @return bool_t<Builder>
      */
-    template <size_t num_bits> bool_t<ComposerContext> ranged_less_than(const field_t<ComposerContext>& other) const
+    template <size_t num_bits> bool_t<Builder> ranged_less_than(const field_t<Builder>& other) const
     {
         const auto& a = (*this);
         const auto& b = other;
@@ -324,13 +322,13 @@ template <typename ComposerContext> class field_t {
         // b - a + (K - 1) - (K).q = r
         uint256_t range_constant = (uint256_t(1) << num_bits);
         bool predicate_witness = uint256_t(a.get_value()) < uint256_t(b.get_value());
-        bool_t<ComposerContext> predicate(witness_t<ComposerContext>(ctx, predicate_witness));
+        bool_t<Builder> predicate(witness_t<Builder>(ctx, predicate_witness));
         field_t predicate_valid = b.add_two(-(a) + range_constant - 1, -field_t(predicate) * range_constant);
         predicate_valid.create_range_constraint(num_bits);
         return predicate;
     }
 
-    mutable ComposerContext* context = nullptr;
+    mutable Builder* context = nullptr;
 
     /**
      * `additive_constant` and `multiplicative_constant` are constant scaling factors applied to a field_t object.
@@ -371,7 +369,7 @@ template <typename ComposerContext> class field_t {
     mutable barretenberg::fr multiplicative_constant;
 
     /**
-     * Every composer object contains a vector `variables` (a.k.a. 'witnesses'); circuit variables that can be
+     * Every builder object contains a vector `variables` (a.k.a. 'witnesses'); circuit variables that can be
      * assigned to wires when creating constraints. `witness_index` describes a location in this container. I.e. it
      * 'points' to a circuit variable.
      *
@@ -390,7 +388,7 @@ template <typename ComposerContext> class field_t {
      * field_t baz = foo * (bar + 7);
      *
      * This will add 3 new circuit witnesses (10, 50, 570) to `variables`. One constraint will also be created, that
-     * validates `baz` has been correctly constructed. The composer will assign `foo, bar, baz` to wires `w_1, w_2, w_3`
+     * validates `baz` has been correctly constructed. The builder will assign `foo, bar, baz` to wires `w_1, w_2, w_3`
      * in a new gate which checks that:
      *
      *      w_1 * w_2 + w_1 * 7 - w_3 = 0
@@ -414,7 +412,7 @@ template <typename ComposerContext> class field_t {
     mutable uint32_t witness_index = IS_CONSTANT;
 };
 
-template <typename ComposerContext> inline std::ostream& operator<<(std::ostream& os, field_t<ComposerContext> const& v)
+template <typename Builder> inline std::ostream& operator<<(std::ostream& os, field_t<Builder> const& v)
 {
     return os << v.get_value();
 }
diff --git a/barretenberg/cpp/src/barretenberg/stdlib/primitives/field/field.test.cpp b/barretenberg/cpp/src/barretenberg/stdlib/primitives/field/field.test.cpp
index c0d2fc99cca..f539ef5d883 100644
--- a/barretenberg/cpp/src/barretenberg/stdlib/primitives/field/field.test.cpp
+++ b/barretenberg/cpp/src/barretenberg/stdlib/primitives/field/field.test.cpp
@@ -21,16 +21,16 @@ template <class T> void ignore_unused(T&) {} // use to ignore unused variables i
 using namespace barretenberg;
 using namespace proof_system::plonk;
 
-template <typename Composer> class stdlib_field : public testing::Test {
-    typedef stdlib::bool_t<Composer> bool_ct;
-    typedef stdlib::field_t<Composer> field_ct;
-    typedef stdlib::witness_t<Composer> witness_ct;
-    typedef stdlib::public_witness_t<Composer> public_witness_ct;
+template <typename Builder> class stdlib_field : public testing::Test {
+    typedef stdlib::bool_t<Builder> bool_ct;
+    typedef stdlib::field_t<Builder> field_ct;
+    typedef stdlib::witness_t<Builder> witness_ct;
+    typedef stdlib::public_witness_t<Builder> public_witness_ct;
 
-    static void fibbonaci(Composer& composer)
+    static void fibbonaci(Builder& builder)
     {
-        field_ct a(witness_ct(&composer, fr::one()));
-        field_ct b(witness_ct(&composer, fr::one()));
+        field_ct a(witness_ct(&builder, fr::one()));
+        field_ct b(witness_ct(&builder, fr::one()));
 
         field_ct c = a + b;
 
@@ -40,16 +40,16 @@ template <typename Composer> class stdlib_field : public testing::Test {
             c = a + b;
         }
     }
-    static uint64_t fidget(Composer& composer)
+    static uint64_t fidget(Builder& builder)
     {
-        field_ct a(public_witness_ct(&composer, fr::one())); // a is a legit wire value in our circuit
-        field_ct b(&composer,
+        field_ct a(public_witness_ct(&builder, fr::one())); // a is a legit wire value in our circuit
+        field_ct b(&builder,
                    (fr::one())); // b is just a constant, and should not turn up as a wire value in our circuit
 
         // this shouldn't create a constraint - we just need to scale the addition/multiplication gates that `a` is
         // involved in c should point to the same wire value as a
         field_ct c = a + b;
-        field_ct d(&composer, fr::coset_generator(0)); // like b, d is just a constant and not a wire value
+        field_ct d(&builder, fr::coset_generator(0)); // like b, d is just a constant and not a wire value
 
         // by this point, we shouldn't have added any constraints in our circuit
         for (size_t i = 0; i < 17; ++i) {
@@ -72,12 +72,12 @@ template <typename Composer> class stdlib_field : public testing::Test {
         return cc;
     }
 
-    static void generate_test_plonk_circuit(Composer& composer, size_t num_gates)
+    static void generate_test_plonk_circuit(Builder& builder, size_t num_gates)
     {
-        field_ct a(public_witness_ct(&composer, barretenberg::fr::random_element()));
-        field_ct b(public_witness_ct(&composer, barretenberg::fr::random_element()));
+        field_ct a(public_witness_ct(&builder, barretenberg::fr::random_element()));
+        field_ct b(public_witness_ct(&builder, barretenberg::fr::random_element()));
 
-        field_ct c(&composer);
+        field_ct c(&builder);
         for (size_t i = 0; i < (num_gates / 4) - 4; ++i) {
             c = a + b;
             c = a * c;
@@ -90,11 +90,11 @@ template <typename Composer> class stdlib_field : public testing::Test {
     static void create_range_constraint()
     {
         auto run_test = [&](fr elt, size_t num_bits, bool expect_verified) {
-            Composer composer = Composer();
-            field_ct a(witness_ct(&composer, elt));
+            Builder builder = Builder();
+            field_ct a(witness_ct(&builder, elt));
             a.create_range_constraint(num_bits, "field_tests: range_constraint on a fails");
 
-            bool verified = composer.check_circuit();
+            bool verified = builder.check_circuit();
             EXPECT_EQ(verified, expect_verified);
             if (verified != expect_verified) {
                 info("Range constraint malfunction on ", elt, " with num_bits ", num_bits);
@@ -121,9 +121,9 @@ template <typename Composer> class stdlib_field : public testing::Test {
     static void test_assert_equal()
     {
         auto run_test = [](bool constrain, bool true_when_y_val_zero = true) {
-            Composer composer = Composer();
-            field_ct x = witness_ct(&composer, 1);
-            field_ct y = witness_ct(&composer, 0);
+            Builder builder = Builder();
+            field_ct x = witness_ct(&builder, 1);
+            field_ct y = witness_ct(&builder, 0);
 
             // With no constraints, the proof verification will pass even though
             // we assert x and y are equal.
@@ -139,24 +139,24 @@ template <typename Composer> class stdlib_field : public testing::Test {
                 if (true_when_y_val_zero) {
                     // constraint: 0*x + 1*y + 0*0 + 0 == 0
 
-                    composer.create_add_gate({ .a = x.witness_index,
-                                               .b = y.witness_index,
-                                               .c = composer.zero_idx,
-                                               .a_scaling = 0,
-                                               .b_scaling = 1,
-                                               .c_scaling = 0,
-                                               .const_scaling = 0 });
+                    builder.create_add_gate({ .a = x.witness_index,
+                                              .b = y.witness_index,
+                                              .c = builder.zero_idx,
+                                              .a_scaling = 0,
+                                              .b_scaling = 1,
+                                              .c_scaling = 0,
+                                              .const_scaling = 0 });
                     expected_result = false;
                 } else {
                     // constraint: 0*x + 1*y + 0*0 - 1 == 0
 
-                    composer.create_add_gate({ .a = x.witness_index,
-                                               .b = y.witness_index,
-                                               .c = composer.zero_idx,
-                                               .a_scaling = 0,
-                                               .b_scaling = 1,
-                                               .c_scaling = 0,
-                                               .const_scaling = -1 });
+                    builder.create_add_gate({ .a = x.witness_index,
+                                              .b = y.witness_index,
+                                              .c = builder.zero_idx,
+                                              .a_scaling = 0,
+                                              .b_scaling = 1,
+                                              .c_scaling = 0,
+                                              .const_scaling = -1 });
                     expected_result = true;
                 }
             }
@@ -167,7 +167,7 @@ template <typename Composer> class stdlib_field : public testing::Test {
             EXPECT_EQ(x.get_value(), 1);
             EXPECT_EQ(y.get_value(), 1);
 
-            bool result = composer.check_circuit();
+            bool result = builder.check_circuit();
 
             EXPECT_EQ(result, expected_result);
         };
@@ -179,30 +179,30 @@ template <typename Composer> class stdlib_field : public testing::Test {
 
     static void test_add_mul_with_constants()
     {
-        Composer composer = Composer();
-        auto gates_before = composer.get_num_gates();
-        uint64_t expected = fidget(composer);
-        auto gates_after = composer.get_num_gates();
-        EXPECT_EQ(composer.get_variable(composer.w_o[gates_after - 1]), fr(expected));
+        Builder builder = Builder();
+        auto gates_before = builder.get_num_gates();
+        uint64_t expected = fidget(builder);
+        auto gates_after = builder.get_num_gates();
+        EXPECT_EQ(builder.get_variable(builder.w_o[gates_after - 1]), fr(expected));
         info("Number of gates added", gates_after - gates_before);
-        bool result = composer.check_circuit();
+        bool result = builder.check_circuit();
         EXPECT_EQ(result, true);
     }
 
     static void test_div()
     {
-        Composer composer = Composer();
+        Builder builder = Builder();
 
-        field_ct a = witness_ct(&composer, barretenberg::fr::random_element());
+        field_ct a = witness_ct(&builder, barretenberg::fr::random_element());
         a *= barretenberg::fr::random_element();
         a += barretenberg::fr::random_element();
 
-        field_ct b = witness_ct(&composer, barretenberg::fr::random_element());
+        field_ct b = witness_ct(&builder, barretenberg::fr::random_element());
         b *= barretenberg::fr::random_element();
         b += barretenberg::fr::random_element();
 
         // numerator constant
-        field_ct out = field_ct(&composer, b.get_value()) / a;
+        field_ct out = field_ct(&builder, b.get_value()) / a;
         EXPECT_EQ(out.get_value(), b.get_value() / a.get_value());
 
         out = b / a;
@@ -217,60 +217,60 @@ template <typename Composer> class stdlib_field : public testing::Test {
         EXPECT_EQ(out.get_value(), 0);
         EXPECT_EQ(out.is_constant(), true);
 
-        bool result = composer.check_circuit();
+        bool result = builder.check_circuit();
         EXPECT_EQ(result, true);
     }
 
     static void test_postfix_increment()
     {
-        Composer composer = Composer();
+        Builder builder = Builder();
 
-        field_ct a = witness_ct(&composer, 10);
+        field_ct a = witness_ct(&builder, 10);
 
         field_ct b = a++;
 
         EXPECT_EQ(b.get_value(), 10);
         EXPECT_EQ(a.get_value(), 11);
 
-        bool result = composer.check_circuit();
+        bool result = builder.check_circuit();
         EXPECT_EQ(result, true);
     }
 
     static void test_prefix_increment()
     {
-        Composer composer = Composer();
+        Builder builder = Builder();
 
-        field_ct a = witness_ct(&composer, 10);
+        field_ct a = witness_ct(&builder, 10);
 
         field_ct b = ++a;
 
         EXPECT_EQ(b.get_value(), 11);
         EXPECT_EQ(a.get_value(), 11);
 
-        bool result = composer.check_circuit();
+        bool result = builder.check_circuit();
         EXPECT_EQ(result, true);
     }
 
     static void test_field_fibbonaci()
     {
-        Composer composer = Composer();
-        auto gates_before = composer.get_num_gates();
-        fibbonaci(composer);
-        auto gates_after = composer.get_num_gates();
-        EXPECT_EQ(composer.get_variable(composer.w_l[composer.get_num_gates() - 1]), fr(4181));
+        Builder builder = Builder();
+        auto gates_before = builder.get_num_gates();
+        fibbonaci(builder);
+        auto gates_after = builder.get_num_gates();
+        EXPECT_EQ(builder.get_variable(builder.w_l[builder.get_num_gates() - 1]), fr(4181));
         EXPECT_EQ(gates_after - gates_before, 18UL);
 
-        bool result = composer.check_circuit();
+        bool result = builder.check_circuit();
         EXPECT_EQ(result, true);
     }
 
     static void test_field_pythagorean()
     {
-        Composer composer = Composer();
+        Builder builder = Builder();
 
-        field_ct a(witness_ct(&composer, 3));
-        field_ct b(witness_ct(&composer, 4));
-        field_ct c(witness_ct(&composer, 5));
+        field_ct a(witness_ct(&builder, 3));
+        field_ct b(witness_ct(&builder, 4));
+        field_ct c(witness_ct(&builder, 5));
 
         field_ct a_sqr = a * a;
         field_ct b_sqr = b * b;
@@ -278,123 +278,123 @@ template <typename Composer> class stdlib_field : public testing::Test {
         c_sqr.set_public();
         field_ct sum_sqrs = a_sqr + b_sqr;
 
-        // composer.assert_equal(sum_sqrs.witness_index, c_sqr.witness_index, "triple is not pythagorean");
+        // builder.assert_equal(sum_sqrs.witness_index, c_sqr.witness_index, "triple is not pythagorean");
         c_sqr.assert_equal(sum_sqrs);
 
-        bool verified = composer.check_circuit();
+        bool verified = builder.check_circuit();
 
-        for (size_t i = 0; i < composer.variables.size(); i++) {
-            info(i, composer.variables[i]);
+        for (size_t i = 0; i < builder.variables.size(); i++) {
+            info(i, builder.variables[i]);
         }
         ASSERT_TRUE(verified);
     }
 
     static void test_equality()
     {
-        Composer composer = Composer();
-        auto gates_before = composer.get_num_gates();
-        field_ct a(witness_ct(&composer, 4));
-        field_ct b(witness_ct(&composer, 4));
+        Builder builder = Builder();
+        auto gates_before = builder.get_num_gates();
+        field_ct a(witness_ct(&builder, 4));
+        field_ct b(witness_ct(&builder, 4));
         bool_ct r = a == b;
 
-        auto gates_after = composer.get_num_gates();
+        auto gates_after = builder.get_num_gates();
         EXPECT_EQ(r.get_value(), true);
 
-        fr x = composer.get_variable(r.witness_index);
+        fr x = builder.get_variable(r.witness_index);
         EXPECT_EQ(x, fr(1));
 
         // This logic requires on madd in field, which creates a big mul gate.
         // This gate is implemented in standard by create 2 actual gates, while in turbo and ultra there are 2
-        if constexpr (std::same_as<Composer, StandardCircuitBuilder>) {
+        if constexpr (std::same_as<Builder, StandardCircuitBuilder>) {
             EXPECT_EQ(gates_after - gates_before, 6UL);
         } else {
             EXPECT_EQ(gates_after - gates_before, 4UL);
         }
 
-        bool result = composer.check_circuit();
+        bool result = builder.check_circuit();
         EXPECT_EQ(result, true);
     }
 
     static void test_equality_false()
     {
-        Composer composer = Composer();
+        Builder builder = Builder();
 
-        auto gates_before = composer.get_num_gates();
-        field_ct a(witness_ct(&composer, 4));
-        field_ct b(witness_ct(&composer, 3));
+        auto gates_before = builder.get_num_gates();
+        field_ct a(witness_ct(&builder, 4));
+        field_ct b(witness_ct(&builder, 3));
         bool_ct r = a == b;
 
         EXPECT_EQ(r.get_value(), false);
 
-        auto gates_after = composer.get_num_gates();
+        auto gates_after = builder.get_num_gates();
 
-        fr x = composer.get_variable(r.witness_index);
+        fr x = builder.get_variable(r.witness_index);
         EXPECT_EQ(x, fr(0));
 
         // This logic requires on madd in field, which creates a big mul gate.
         // This gate is implemented in standard by create 2 actual gates, while in turbo and ultra there are 2
-        if constexpr (std::same_as<Composer, StandardCircuitBuilder>) {
+        if constexpr (std::same_as<Builder, StandardCircuitBuilder>) {
             EXPECT_EQ(gates_after - gates_before, 6UL);
         } else {
             EXPECT_EQ(gates_after - gates_before, 4UL);
         }
 
-        bool result = composer.check_circuit();
+        bool result = builder.check_circuit();
         EXPECT_EQ(result, true);
     }
 
     static void test_equality_with_constants()
     {
-        Composer composer = Composer();
+        Builder builder = Builder();
 
-        auto gates_before = composer.get_num_gates();
-        field_ct a(witness_ct(&composer, 4));
+        auto gates_before = builder.get_num_gates();
+        field_ct a(witness_ct(&builder, 4));
         field_ct b = 3;
         field_ct c = 7;
         bool_ct r = a * c == b * c + c && b + 1 == a;
 
         EXPECT_EQ(r.get_value(), true);
 
-        auto gates_after = composer.get_num_gates();
+        auto gates_after = builder.get_num_gates();
 
-        fr x = composer.get_variable(r.witness_index);
+        fr x = builder.get_variable(r.witness_index);
         EXPECT_EQ(x, fr(1));
 
         // This logic requires on madd in field, which creates a big mul gate.
         // This gate is implemented in standard by create 2 actual gates, while in turbo and ultra there are 2
-        if constexpr (std::same_as<Composer, StandardCircuitBuilder>) {
+        if constexpr (std::same_as<Builder, StandardCircuitBuilder>) {
             EXPECT_EQ(gates_after - gates_before, 11UL);
         } else {
             EXPECT_EQ(gates_after - gates_before, 7UL);
         }
 
-        bool result = composer.check_circuit();
+        bool result = builder.check_circuit();
         EXPECT_EQ(result, true);
     }
 
     static void test_larger_circuit()
     {
         size_t n = 16384;
-        Composer composer;
+        Builder builder;
 
-        generate_test_plonk_circuit(composer, n);
+        generate_test_plonk_circuit(builder, n);
 
-        bool result = composer.check_circuit();
+        bool result = builder.check_circuit();
         EXPECT_EQ(result, true);
     }
 
     static void is_zero()
     {
-        Composer composer = Composer();
+        Builder builder = Builder();
 
         // yuck
-        field_ct a = (public_witness_ct(&composer, fr::random_element()));
-        field_ct b = (public_witness_ct(&composer, fr::neg_one()));
-        field_ct c_1(&composer,
+        field_ct a = (public_witness_ct(&builder, fr::random_element()));
+        field_ct b = (public_witness_ct(&builder, fr::neg_one()));
+        field_ct c_1(&builder,
                      uint256_t(0x1122334455667788, 0x8877665544332211, 0xaabbccddeeff9933, 0x1122112211221122));
-        field_ct c_2(&composer,
+        field_ct c_2(&builder,
                      uint256_t(0xaabbccddeeff9933, 0x8877665544332211, 0x1122334455667788, 0x1122112211221122));
-        field_ct c_3(&composer, barretenberg::fr::one());
+        field_ct c_3(&builder, barretenberg::fr::one());
 
         field_ct c_4 = c_1 + c_2;
         a = a * c_4 + c_4; // add some constant terms in to validate our normalization check works
@@ -402,13 +402,13 @@ template <typename Composer> class stdlib_field : public testing::Test {
         b = (b - c_1 - c_2) / c_4;
         b = b + c_3;
 
-        field_ct d(&composer, fr::zero());
-        field_ct e(&composer, fr::one());
+        field_ct d(&builder, fr::zero());
+        field_ct e(&builder, fr::one());
 
-        const size_t old_n = composer.get_num_gates();
+        const size_t old_n = builder.get_num_gates();
         bool_ct d_zero = d.is_zero();
         bool_ct e_zero = e.is_zero();
-        const size_t new_n = composer.get_num_gates();
+        const size_t new_n = builder.get_num_gates();
         EXPECT_EQ(old_n, new_n);
 
         bool_ct a_zero = a.is_zero();
@@ -419,23 +419,23 @@ template <typename Composer> class stdlib_field : public testing::Test {
         EXPECT_EQ(d_zero.get_value(), true);
         EXPECT_EQ(e_zero.get_value(), false);
 
-        bool result = composer.check_circuit();
+        bool result = builder.check_circuit();
         EXPECT_EQ(result, true);
     }
 
     static void madd()
     {
-        Composer composer = Composer();
-
-        field_ct a(witness_ct(&composer, fr::random_element()));
-        field_ct b(witness_ct(&composer, fr::random_element()));
-        field_ct c(witness_ct(&composer, fr::random_element()));
-        field_ct ma(&composer, fr::random_element());
-        field_ct ca(&composer, fr::random_element());
-        field_ct mb(&composer, fr::random_element());
-        field_ct cb(&composer, fr::random_element());
-        field_ct mc(&composer, fr::random_element());
-        field_ct cc(&composer, fr::random_element());
+        Builder builder = Builder();
+
+        field_ct a(witness_ct(&builder, fr::random_element()));
+        field_ct b(witness_ct(&builder, fr::random_element()));
+        field_ct c(witness_ct(&builder, fr::random_element()));
+        field_ct ma(&builder, fr::random_element());
+        field_ct ca(&builder, fr::random_element());
+        field_ct mb(&builder, fr::random_element());
+        field_ct cb(&builder, fr::random_element());
+        field_ct mc(&builder, fr::random_element());
+        field_ct cc(&builder, fr::random_element());
 
         // test madd when all operands are witnesses
         field_ct d = a * ma + ca;
@@ -468,22 +468,22 @@ template <typename Composer> class stdlib_field : public testing::Test {
         n = n.normalize();
         EXPECT_EQ(m.get_value(), n.get_value());
 
-        bool result = composer.check_circuit();
+        bool result = builder.check_circuit();
         EXPECT_EQ(result, true);
     }
 
     static void two_bit_table()
     {
-        Composer composer = Composer();
-        field_ct a(witness_ct(&composer, fr::random_element()));
-        field_ct b(witness_ct(&composer, fr::random_element()));
-        field_ct c(witness_ct(&composer, fr::random_element()));
-        field_ct d(witness_ct(&composer, fr::random_element()));
+        Builder builder = Builder();
+        field_ct a(witness_ct(&builder, fr::random_element()));
+        field_ct b(witness_ct(&builder, fr::random_element()));
+        field_ct c(witness_ct(&builder, fr::random_element()));
+        field_ct d(witness_ct(&builder, fr::random_element()));
 
         std::array<field_ct, 4> table = field_ct::preprocess_two_bit_table(a, b, c, d);
 
-        bool_ct zero(witness_ct(&composer, false));
-        bool_ct one(witness_ct(&composer, true));
+        bool_ct zero(witness_ct(&builder, false));
+        bool_ct one(witness_ct(&builder, true));
 
         field_ct result_a = field_ct::select_from_two_bit_table(table, zero, zero).normalize();
         field_ct result_b = field_ct::select_from_two_bit_table(table, zero, one).normalize();
@@ -495,58 +495,58 @@ template <typename Composer> class stdlib_field : public testing::Test {
         EXPECT_EQ(result_c.get_value(), c.get_value());
         EXPECT_EQ(result_d.get_value(), d.get_value());
 
-        bool result = composer.check_circuit();
+        bool result = builder.check_circuit();
         EXPECT_EQ(result, true);
     }
 
     static void test_slice()
     {
-        Composer composer = Composer();
+        Builder builder = Builder();
         // 0b11110110101001011
         //         ^      ^
         //        msb    lsb
         //        10      3
         // hi=0x111101, lo=0x011, slice=0x10101001
         //
-        field_ct a(witness_ct(&composer, fr(126283)));
+        field_ct a(witness_ct(&builder, fr(126283)));
         auto slice_data = a.slice(10, 3);
 
         EXPECT_EQ(slice_data[0].get_value(), fr(3));
         EXPECT_EQ(slice_data[1].get_value(), fr(169));
         EXPECT_EQ(slice_data[2].get_value(), fr(61));
 
-        bool result = composer.check_circuit();
+        bool result = builder.check_circuit();
         EXPECT_EQ(result, true);
     }
 
     static void test_slice_equal_msb_lsb()
     {
-        Composer composer = Composer();
+        Builder builder = Builder();
         // 0b11110110101001011
         //             ^
         //         msb = lsb
         //             6
         // hi=0b1111011010, lo=0b001011, slice=0b1
         //
-        field_ct a(witness_ct(&composer, fr(126283)));
+        field_ct a(witness_ct(&builder, fr(126283)));
         auto slice_data = a.slice(6, 6);
 
         EXPECT_EQ(slice_data[0].get_value(), fr(11));
         EXPECT_EQ(slice_data[1].get_value(), fr(1));
         EXPECT_EQ(slice_data[2].get_value(), fr(986));
 
-        bool result = composer.check_circuit();
+        bool result = builder.check_circuit();
         EXPECT_EQ(result, true);
     }
 
     static void test_slice_random()
     {
-        Composer composer = Composer();
+        Builder builder = Builder();
 
         uint8_t lsb = 106;
         uint8_t msb = 189;
         fr a_ = fr(uint256_t(fr::random_element()) && ((uint256_t(1) << 252) - 1));
-        field_ct a(witness_ct(&composer, a_));
+        field_ct a(witness_ct(&builder, a_));
         auto slice = a.slice(msb, lsb);
 
         const uint256_t expected0 = uint256_t(a_) & ((uint256_t(1) << uint64_t(lsb)) - 1);
@@ -558,26 +558,26 @@ template <typename Composer> class stdlib_field : public testing::Test {
         EXPECT_EQ(slice[1].get_value(), fr(expected1));
         EXPECT_EQ(slice[2].get_value(), fr(expected2));
 
-        bool result = composer.check_circuit();
+        bool result = builder.check_circuit();
         EXPECT_EQ(result, true);
     }
 
     static void three_bit_table()
     {
-        Composer composer = Composer();
-        field_ct a(witness_ct(&composer, fr::random_element()));
-        field_ct b(witness_ct(&composer, fr::random_element()));
-        field_ct c(witness_ct(&composer, fr::random_element()));
-        field_ct d(witness_ct(&composer, fr::random_element()));
-        field_ct e(witness_ct(&composer, fr::random_element()));
-        field_ct f(witness_ct(&composer, fr::random_element()));
-        field_ct g(witness_ct(&composer, fr::random_element()));
-        field_ct h(witness_ct(&composer, fr::random_element()));
+        Builder builder = Builder();
+        field_ct a(witness_ct(&builder, fr::random_element()));
+        field_ct b(witness_ct(&builder, fr::random_element()));
+        field_ct c(witness_ct(&builder, fr::random_element()));
+        field_ct d(witness_ct(&builder, fr::random_element()));
+        field_ct e(witness_ct(&builder, fr::random_element()));
+        field_ct f(witness_ct(&builder, fr::random_element()));
+        field_ct g(witness_ct(&builder, fr::random_element()));
+        field_ct h(witness_ct(&builder, fr::random_element()));
 
         std::array<field_ct, 8> table = field_ct::preprocess_three_bit_table(a, b, c, d, e, f, g, h);
 
-        bool_ct zero(witness_ct(&composer, false));
-        bool_ct one(witness_ct(&composer, true));
+        bool_ct zero(witness_ct(&builder, false));
+        bool_ct one(witness_ct(&builder, true));
 
         field_ct result_a = field_ct::select_from_three_bit_table(table, zero, zero, zero).normalize();
         field_ct result_b = field_ct::select_from_three_bit_table(table, zero, zero, one).normalize();
@@ -597,7 +597,7 @@ template <typename Composer> class stdlib_field : public testing::Test {
         EXPECT_EQ(result_g.get_value(), g.get_value());
         EXPECT_EQ(result_h.get_value(), h.get_value());
 
-        bool result = composer.check_circuit();
+        bool result = builder.check_circuit();
         EXPECT_EQ(result, true);
     }
 
@@ -610,11 +610,11 @@ template <typename Composer> class stdlib_field : public testing::Test {
 
     static void decompose_into_bits()
     {
-        using witness_supplier_type = std::function<witness_ct(Composer * ctx, uint64_t, uint256_t)>;
+        using witness_supplier_type = std::function<witness_ct(Builder * ctx, uint64_t, uint256_t)>;
 
         // check that constraints are satisfied for a variety of inputs
         auto run_success_test = [&]() {
-            Composer composer = Composer();
+            Builder builder = Builder();
 
             constexpr uint256_t modulus_minus_one = fr::modulus - 1;
             const fr p_lo = modulus_minus_one.slice(0, 130);
@@ -628,7 +628,7 @@ template <typename Composer> class stdlib_field : public testing::Test {
             };
 
             for (auto a_expected : test_elements) {
-                field_ct a = witness_ct(&composer, a_expected);
+                field_ct a = witness_ct(&builder, a_expected);
                 std::vector<bool_ct> c = a.decompose_into_bits(256);
                 fr bit_sum = 0;
                 for (size_t i = 0; i < c.size(); i++) {
@@ -638,20 +638,20 @@ template <typename Composer> class stdlib_field : public testing::Test {
                 EXPECT_EQ(bit_sum, a_expected);
             };
 
-            bool verified = composer.check_circuit();
+            bool verified = builder.check_circuit();
             ASSERT_TRUE(verified);
         };
 
         // Now try to supply unintended witness values and test for failure.
         // Fr::modulus is equivalent to zero in Fr, but this should be forbidden by a range constraint.
-        witness_supplier_type supply_modulus_bits = [](Composer* ctx, uint64_t j, uint256_t val_256) {
+        witness_supplier_type supply_modulus_bits = [](Builder* ctx, uint64_t j, uint256_t val_256) {
             ignore_unused(val_256);
             // use this to get `sum` to be fr::modulus.
             return witness_ct(ctx, fr::modulus.get_bit(j));
         };
 
         // design a bit vector that will pass all range constraints, but it fails the copy constraint.
-        witness_supplier_type supply_half_modulus_bits = [](Composer* ctx, uint64_t j, uint256_t val_256) {
+        witness_supplier_type supply_half_modulus_bits = [](Builder* ctx, uint64_t j, uint256_t val_256) {
             // use this to fit y_hi into 128 bits
             if (j > 127) {
                 return witness_ct(ctx, val_256.get_bit(j));
@@ -660,13 +660,13 @@ template <typename Composer> class stdlib_field : public testing::Test {
         };
 
         auto run_failure_test = [&](witness_supplier_type witness_supplier) {
-            Composer composer = Composer();
+            Builder builder = Builder();
 
             fr a_expected = 0;
-            field_ct a = witness_ct(&composer, a_expected);
+            field_ct a = witness_ct(&builder, a_expected);
             std::vector<bool_ct> c = a.decompose_into_bits(256, witness_supplier);
 
-            bool verified = composer.check_circuit();
+            bool verified = builder.check_circuit();
             ASSERT_FALSE(verified);
         };
 
@@ -677,181 +677,181 @@ template <typename Composer> class stdlib_field : public testing::Test {
 
     static void test_assert_is_in_set()
     {
-        Composer composer = Composer();
+        Builder builder = Builder();
 
-        field_ct a(witness_ct(&composer, fr(1)));
-        field_ct b(witness_ct(&composer, fr(2)));
-        field_ct c(witness_ct(&composer, fr(3)));
-        field_ct d(witness_ct(&composer, fr(4)));
-        field_ct e(witness_ct(&composer, fr(5)));
+        field_ct a(witness_ct(&builder, fr(1)));
+        field_ct b(witness_ct(&builder, fr(2)));
+        field_ct c(witness_ct(&builder, fr(3)));
+        field_ct d(witness_ct(&builder, fr(4)));
+        field_ct e(witness_ct(&builder, fr(5)));
         std::vector<field_ct> set = { a, b, c, d, e };
 
         a.assert_is_in_set(set);
-        info("composer gates = ", composer.get_num_gates());
+        info("num gates = ", builder.get_num_gates());
 
-        bool result = composer.check_circuit();
+        bool result = builder.check_circuit();
         EXPECT_EQ(result, true);
     }
 
     static void test_assert_is_in_set_fails()
     {
-        Composer composer = Composer();
+        Builder builder = Builder();
 
-        field_ct a(witness_ct(&composer, fr(1)));
-        field_ct b(witness_ct(&composer, fr(2)));
-        field_ct c(witness_ct(&composer, fr(3)));
-        field_ct d(witness_ct(&composer, fr(4)));
-        field_ct e(witness_ct(&composer, fr(5)));
+        field_ct a(witness_ct(&builder, fr(1)));
+        field_ct b(witness_ct(&builder, fr(2)));
+        field_ct c(witness_ct(&builder, fr(3)));
+        field_ct d(witness_ct(&builder, fr(4)));
+        field_ct e(witness_ct(&builder, fr(5)));
         std::vector<field_ct> set = { a, b, c, d, e };
 
-        field_ct f(witness_ct(&composer, fr(6)));
+        field_ct f(witness_ct(&builder, fr(6)));
         f.assert_is_in_set(set);
 
-        info("composer gates = ", composer.get_num_gates());
-        bool result = composer.check_circuit();
+        info("num gates = ", builder.get_num_gates());
+        bool result = builder.check_circuit();
         EXPECT_EQ(result, false);
     }
 
     static void test_pow()
     {
-        Composer composer = Composer();
+        Builder builder = Builder();
 
         barretenberg::fr base_val(engine.get_random_uint256());
         uint32_t exponent_val = engine.get_random_uint32();
 
-        field_ct base = witness_ct(&composer, base_val);
-        field_ct exponent = witness_ct(&composer, exponent_val);
+        field_ct base = witness_ct(&builder, base_val);
+        field_ct exponent = witness_ct(&builder, exponent_val);
         field_ct result = base.pow(exponent);
         barretenberg::fr expected = base_val.pow(exponent_val);
 
         EXPECT_EQ(result.get_value(), expected);
 
-        info("composer gates = ", composer.get_num_gates());
-        bool check_result = composer.check_circuit();
+        info("num gates = ", builder.get_num_gates());
+        bool check_result = builder.check_circuit();
         EXPECT_EQ(check_result, true);
     }
 
     static void test_pow_zero()
     {
-        Composer composer = Composer();
+        Builder builder = Builder();
 
         barretenberg::fr base_val(engine.get_random_uint256());
         uint32_t exponent_val = 0;
 
-        field_ct base = witness_ct(&composer, base_val);
-        field_ct exponent = witness_ct(&composer, exponent_val);
+        field_ct base = witness_ct(&builder, base_val);
+        field_ct exponent = witness_ct(&builder, exponent_val);
         field_ct result = base.pow(exponent);
 
         EXPECT_EQ(result.get_value(), barretenberg::fr(1));
 
-        info("composer gates = ", composer.get_num_gates());
-        bool check_result = composer.check_circuit();
+        info("num gates = ", builder.get_num_gates());
+        bool check_result = builder.check_circuit();
         EXPECT_EQ(check_result, true);
     }
 
     static void test_pow_one()
     {
-        Composer composer = Composer();
+        Builder builder = Builder();
 
         barretenberg::fr base_val(engine.get_random_uint256());
         uint32_t exponent_val = 1;
 
-        field_ct base = witness_ct(&composer, base_val);
-        field_ct exponent = witness_ct(&composer, exponent_val);
+        field_ct base = witness_ct(&builder, base_val);
+        field_ct exponent = witness_ct(&builder, exponent_val);
         field_ct result = base.pow(exponent);
 
         EXPECT_EQ(result.get_value(), base_val);
-        info("composer gates = ", composer.get_num_gates());
+        info("num gates = ", builder.get_num_gates());
 
-        bool check_result = composer.check_circuit();
+        bool check_result = builder.check_circuit();
         EXPECT_EQ(check_result, true);
     }
 
     static void test_pow_both_constant()
     {
-        Composer composer = Composer();
+        Builder builder = Builder();
 
-        const size_t num_gates_start = composer.num_gates;
+        const size_t num_gates_start = builder.num_gates;
 
         barretenberg::fr base_val(engine.get_random_uint256());
         uint32_t exponent_val = engine.get_random_uint32();
 
-        field_ct base(&composer, base_val);
-        field_ct exponent(&composer, exponent_val);
+        field_ct base(&builder, base_val);
+        field_ct exponent(&builder, exponent_val);
         field_ct result = base.pow(exponent);
         barretenberg::fr expected = base_val.pow(exponent_val);
 
         EXPECT_EQ(result.get_value(), expected);
 
-        const size_t num_gates_end = composer.num_gates;
+        const size_t num_gates_end = builder.num_gates;
         EXPECT_EQ(num_gates_start, num_gates_end);
     }
 
     static void test_pow_base_constant()
     {
-        Composer composer = Composer();
+        Builder builder = Builder();
 
         barretenberg::fr base_val(engine.get_random_uint256());
         uint32_t exponent_val = engine.get_random_uint32();
 
-        field_ct base(&composer, base_val);
-        field_ct exponent = witness_ct(&composer, exponent_val);
+        field_ct base(&builder, base_val);
+        field_ct exponent = witness_ct(&builder, exponent_val);
         field_ct result = base.pow(exponent);
         barretenberg::fr expected = base_val.pow(exponent_val);
 
         EXPECT_EQ(result.get_value(), expected);
 
-        info("composer gates = ", composer.get_num_gates());
-        bool check_result = composer.check_circuit();
+        info("num gates = ", builder.get_num_gates());
+        bool check_result = builder.check_circuit();
         EXPECT_EQ(check_result, true);
     }
 
     static void test_pow_exponent_constant()
     {
-        Composer composer = Composer();
+        Builder builder = Builder();
 
         barretenberg::fr base_val(engine.get_random_uint256());
         uint32_t exponent_val = engine.get_random_uint32();
 
-        field_ct base = witness_ct(&composer, base_val);
-        field_ct exponent(&composer, exponent_val);
+        field_ct base = witness_ct(&builder, base_val);
+        field_ct exponent(&builder, exponent_val);
         field_ct result = base.pow(exponent);
         barretenberg::fr expected = base_val.pow(exponent_val);
 
         EXPECT_EQ(result.get_value(), expected);
-        info("composer gates = ", composer.get_num_gates());
+        info("num gates = ", builder.get_num_gates());
 
-        bool check_result = composer.check_circuit();
+        bool check_result = builder.check_circuit();
         EXPECT_EQ(check_result, true);
     };
 
     static void test_pow_exponent_out_of_range()
     {
-        Composer composer = Composer();
+        Builder builder = Builder();
 
         barretenberg::fr base_val(engine.get_random_uint256());
         uint64_t exponent_val = engine.get_random_uint32();
         exponent_val += (uint64_t(1) << 32);
 
-        field_ct base = witness_ct(&composer, base_val);
-        field_ct exponent = witness_ct(&composer, exponent_val);
+        field_ct base = witness_ct(&builder, base_val);
+        field_ct exponent = witness_ct(&builder, exponent_val);
         field_ct result = base.pow(exponent);
         barretenberg::fr expected = base_val.pow(exponent_val);
 
         EXPECT_NE(result.get_value(), expected);
-        EXPECT_EQ(composer.failed(), true);
-        EXPECT_EQ(composer.err(), "field_t::pow exponent accumulator incorrect");
+        EXPECT_EQ(builder.failed(), true);
+        EXPECT_EQ(builder.err(), "field_t::pow exponent accumulator incorrect");
     };
 
     static void test_copy_as_new_witness()
     {
-        Composer composer = Composer();
+        Builder builder = Builder();
 
         barretenberg::fr value(engine.get_random_uint256());
-        field_ct value_ct = witness_ct(&composer, value);
+        field_ct value_ct = witness_ct(&builder, value);
 
-        field_ct first_copy = witness_ct(&composer, value_ct.get_value());
-        field_ct second_copy = field_ct::copy_as_new_witness(composer, value_ct);
+        field_ct first_copy = witness_ct(&builder, value_ct.get_value());
+        field_ct second_copy = field_ct::copy_as_new_witness(builder, value_ct);
 
         EXPECT_EQ(value_ct.get_value(), value);
         EXPECT_EQ(first_copy.get_value(), value);
@@ -859,15 +859,15 @@ template <typename Composer> class stdlib_field : public testing::Test {
         EXPECT_EQ(value_ct.get_witness_index() + 1, first_copy.get_witness_index());
         EXPECT_EQ(value_ct.get_witness_index() + 2, second_copy.get_witness_index());
 
-        info("composer gates = ", composer.get_num_gates());
+        info("num gates = ", builder.get_num_gates());
 
-        bool result = composer.check_circuit();
+        bool result = builder.check_circuit();
         EXPECT_EQ(result, true);
     }
 
     static void test_ranged_less_than()
     {
-        Composer composer = Composer();
+        Builder builder = Builder();
 
         for (size_t i = 0; i < 10; ++i) {
             int a_val = static_cast<int>(engine.get_random_uint8());
@@ -896,8 +896,8 @@ template <typename Composer> class stdlib_field : public testing::Test {
             if (b_val > 255) {
                 b_val = 0;
             }
-            field_ct a = witness_ct(&composer, static_cast<uint64_t>(a_val));
-            field_ct b = witness_ct(&composer, static_cast<uint64_t>(b_val));
+            field_ct a = witness_ct(&builder, static_cast<uint64_t>(a_val));
+            field_ct b = witness_ct(&builder, static_cast<uint64_t>(b_val));
             a.create_range_constraint(8);
             b.create_range_constraint(8);
             bool_ct result = a.template ranged_less_than<8>(b);
@@ -905,7 +905,7 @@ template <typename Composer> class stdlib_field : public testing::Test {
 
             EXPECT_EQ(result.get_value(), expected);
         }
-        bool check_result = composer.check_circuit();
+        bool check_result = builder.check_circuit();
         EXPECT_EQ(check_result, true);
     }
 };
diff --git a/barretenberg/cpp/src/barretenberg/stdlib/primitives/group/group.hpp b/barretenberg/cpp/src/barretenberg/stdlib/primitives/group/group.hpp
index 90b666f9572..df7c2f9aa1e 100644
--- a/barretenberg/cpp/src/barretenberg/stdlib/primitives/group/group.hpp
+++ b/barretenberg/cpp/src/barretenberg/stdlib/primitives/group/group.hpp
@@ -13,38 +13,38 @@ namespace stdlib {
 using namespace barretenberg;
 using namespace crypto::generators;
 
-template <typename ComposerContext> class group {
+template <typename Builder> class group {
   public:
-    template <size_t num_bits> static auto fixed_base_scalar_mul_g1(const field_t<ComposerContext>& in);
-    static auto fixed_base_scalar_mul(const field_t<ComposerContext>& lo, const field_t<ComposerContext>& hi);
+    template <size_t num_bits> static auto fixed_base_scalar_mul_g1(const field_t<Builder>& in);
+    static auto fixed_base_scalar_mul(const field_t<Builder>& lo, const field_t<Builder>& hi);
 
     template <size_t num_bits>
-    static auto fixed_base_scalar_mul(const field_t<ComposerContext>& in, const size_t generator_index);
+    static auto fixed_base_scalar_mul(const field_t<Builder>& in, const size_t generator_index);
 
   private:
     template <size_t num_bits>
-    static auto fixed_base_scalar_mul_internal(const field_t<ComposerContext>& in,
+    static auto fixed_base_scalar_mul_internal(const field_t<Builder>& in,
                                                grumpkin::g1::affine_element const& generator,
                                                fixed_base_ladder const* ladder);
 };
 
-template <typename ComposerContext>
+template <typename Builder>
 template <size_t num_bits>
-auto group<ComposerContext>::fixed_base_scalar_mul_g1(const field_t<ComposerContext>& in)
+auto group<Builder>::fixed_base_scalar_mul_g1(const field_t<Builder>& in)
 {
     const auto ladder = get_g1_ladder(num_bits);
     auto generator = grumpkin::g1::one;
-    return group<ComposerContext>::fixed_base_scalar_mul_internal<num_bits>(in, generator, ladder);
+    return group<Builder>::fixed_base_scalar_mul_internal<num_bits>(in, generator, ladder);
 }
 
-template <typename ComposerContext>
+template <typename Builder>
 template <size_t num_bits>
-auto group<ComposerContext>::fixed_base_scalar_mul(const field_t<ComposerContext>& in, const size_t generator_index)
+auto group<Builder>::fixed_base_scalar_mul(const field_t<Builder>& in, const size_t generator_index)
 {
     // we assume for fixed_base_scalar_mul we're interested in the gen at subindex 0
     generator_index_t index = { generator_index, 0 };
     auto gen_data = get_generator_data(index);
-    return group<ComposerContext>::fixed_base_scalar_mul_internal<num_bits>(
+    return group<Builder>::fixed_base_scalar_mul_internal<num_bits>(
         in, gen_data.generator, gen_data.get_ladder(num_bits));
 }
 
@@ -57,9 +57,8 @@ auto group<ComposerContext>::fixed_base_scalar_mul(const field_t<ComposerContext
  *
  * maximum value is (2^257 + 2^129). Further range constraints are required for more precision
  **/
-template <typename ComposerContext>
-auto group<ComposerContext>::fixed_base_scalar_mul(const field_t<ComposerContext>& lo,
-                                                   const field_t<ComposerContext>& hi)
+template <typename Builder>
+auto group<Builder>::fixed_base_scalar_mul(const field_t<Builder>& lo, const field_t<Builder>& hi)
 {
     // This method does not work if lo or hi are 0. We don't apply the extra constraints to handle this edge case
     // (merely rule it out), because we can assume the scalar multipliers for schnorr are uniformly randomly distributed
@@ -77,14 +76,14 @@ auto group<ComposerContext>::fixed_base_scalar_mul(const field_t<ComposerContext
     const auto lambda = (high.y - low.y) / x_delta;
     const auto x_3 = lambda.madd(lambda, -(high.x + low.x));
     const auto y_3 = lambda.madd((low.x - x_3), -low.y);
-    return point<ComposerContext>{ x_3, y_3 };
+    return point<Builder>{ x_3, y_3 };
 }
 
-template <typename ComposerContext>
+template <typename Builder>
 template <size_t num_bits>
-auto group<ComposerContext>::fixed_base_scalar_mul_internal(const field_t<ComposerContext>& in,
-                                                            grumpkin::g1::affine_element const& generator,
-                                                            fixed_base_ladder const* ladder)
+auto group<Builder>::fixed_base_scalar_mul_internal(const field_t<Builder>& in,
+                                                    grumpkin::g1::affine_element const& generator,
+                                                    fixed_base_ladder const* ladder)
 {
     auto scalar = in.normalize();
     scalar.assert_is_not_zero("input scalar to fixed_base_scalar_mul_internal cannot be 0");
@@ -153,16 +152,16 @@ auto group<ComposerContext>::fixed_base_scalar_mul_internal(const field_t<Compos
 
     grumpkin::g1::element::batch_normalize(&multiplication_transcript[0], num_quads + 1);
 
-    fixed_group_init_quad_<typename ComposerContext::FF> init_quad{ origin_points[0].x,
-                                                                    (origin_points[0].x - origin_points[1].x),
-                                                                    origin_points[0].y,
-                                                                    (origin_points[0].y - origin_points[1].y) };
+    fixed_group_init_quad_<typename Builder::FF> init_quad{ origin_points[0].x,
+                                                            (origin_points[0].x - origin_points[1].x),
+                                                            origin_points[0].y,
+                                                            (origin_points[0].y - origin_points[1].y) };
 
     fr x_alpha = accumulator_offset;
     std::vector<uint32_t> accumulator_witnesses;
-    pedersen_gates<ComposerContext> pedersen_gates(ctx);
+    pedersen_gates<Builder> pedersen_gates(ctx);
     for (size_t i = 0; i < num_quads; ++i) {
-        fixed_group_add_quad_<typename ComposerContext::FF> round_quad;
+        fixed_group_add_quad_<typename Builder::FF> round_quad;
         round_quad.d = ctx->add_variable(accumulator_transcript[i]);
         round_quad.a = ctx->add_variable(multiplication_transcript[i].x);
         round_quad.b = ctx->add_variable(multiplication_transcript[i].y);
@@ -193,20 +192,20 @@ auto group<ComposerContext>::fixed_base_scalar_mul_internal(const field_t<Compos
         accumulator_witnesses.push_back(round_quad.d);
     }
 
-    add_quad_<typename ComposerContext::FF> add_quad{ ctx->add_variable(multiplication_transcript[num_quads].x),
-                                                      ctx->add_variable(multiplication_transcript[num_quads].y),
-                                                      ctx->add_variable(x_alpha),
-                                                      ctx->add_variable(accumulator_transcript[num_quads]),
-                                                      fr::zero(),
-                                                      fr::zero(),
-                                                      fr::zero(),
-                                                      fr::zero(),
-                                                      fr::zero() };
+    add_quad_<typename Builder::FF> add_quad{ ctx->add_variable(multiplication_transcript[num_quads].x),
+                                              ctx->add_variable(multiplication_transcript[num_quads].y),
+                                              ctx->add_variable(x_alpha),
+                                              ctx->add_variable(accumulator_transcript[num_quads]),
+                                              fr::zero(),
+                                              fr::zero(),
+                                              fr::zero(),
+                                              fr::zero(),
+                                              fr::zero() };
     ctx->create_big_add_gate(add_quad);
     accumulator_witnesses.push_back(add_quad.d);
 
     if (num_bits >= 254) {
-        plonk::stdlib::pedersen_hash<ComposerContext>::validate_wnaf_is_in_field(ctx, accumulator_witnesses);
+        plonk::stdlib::pedersen_hash<Builder>::validate_wnaf_is_in_field(ctx, accumulator_witnesses);
     }
     aligned_free(multiplication_transcript);
     aligned_free(accumulator_transcript);
@@ -214,7 +213,7 @@ auto group<ComposerContext>::fixed_base_scalar_mul_internal(const field_t<Compos
     auto constructed_scalar = field_t(ctx);
     constructed_scalar.witness_index = add_quad.d;
 
-    point<ComposerContext> result;
+    point<Builder> result;
     result.x = field_t(ctx);
     result.x.witness_index = add_quad.a;
     result.y = field_t(ctx);
diff --git a/barretenberg/cpp/src/barretenberg/stdlib/primitives/group/group.test.cpp b/barretenberg/cpp/src/barretenberg/stdlib/primitives/group/group.test.cpp
index 5861877d051..c8931bff21a 100644
--- a/barretenberg/cpp/src/barretenberg/stdlib/primitives/group/group.test.cpp
+++ b/barretenberg/cpp/src/barretenberg/stdlib/primitives/group/group.test.cpp
@@ -5,10 +5,10 @@
 #include <gtest/gtest.h>
 
 #define STDLIB_TYPE_ALIASES                                                                                            \
-    using Composer = TypeParam;                                                                                        \
-    using witness_ct = stdlib::witness_t<Composer>;                                                                    \
-    using field_ct = stdlib::field_t<Composer>;                                                                        \
-    using group_ct = stdlib::group<Composer>;
+    using Builder = TypeParam;                                                                                         \
+    using witness_ct = stdlib::witness_t<Builder>;                                                                     \
+    using field_ct = stdlib::field_t<Builder>;                                                                         \
+    using group_ct = stdlib::group<Builder>;
 
 namespace stdlib_group_tests {
 using namespace barretenberg;
@@ -18,7 +18,7 @@ namespace {
 auto& engine = numeric::random::get_debug_engine();
 }
 
-template <class Composer> class GroupTest : public ::testing::Test {};
+template <class Builder> class GroupTest : public ::testing::Test {};
 
 using CircuitTypes = ::testing::
     Types<proof_system::StandardCircuitBuilder, proof_system::TurboCircuitBuilder, proof_system::UltraCircuitBuilder>;
@@ -27,13 +27,13 @@ TYPED_TEST_SUITE(GroupTest, CircuitTypes);
 TYPED_TEST(GroupTest, TestFixedBaseScalarMul)
 {
     STDLIB_TYPE_ALIASES
-    auto composer = Composer();
+    auto builder = Builder();
 
     auto scalar = uint256_t(123, 0, 0, 0);
     auto priv_key = grumpkin::fr(scalar);
     auto pub_key = crypto::generators::get_generator_data(crypto::generators::DEFAULT_GEN_1).generator * priv_key;
 
-    auto priv_key_witness = field_ct(witness_ct(&composer, fr(scalar)));
+    auto priv_key_witness = field_ct(witness_ct(&builder, fr(scalar)));
 
     auto result = group_ct::template fixed_base_scalar_mul<128>(priv_key_witness, 0);
 
@@ -44,33 +44,33 @@ TYPED_TEST(GroupTest, TestFixedBaseScalarMul)
     EXPECT_EQ(native_result.x, pub_key.x);
     EXPECT_EQ(native_result.y, pub_key.y);
 
-    printf("composer gates = %zu\n", composer.get_num_gates());
+    printf("num gates = %zu\n", builder.get_num_gates());
 
-    bool proof_result = composer.check_circuit();
+    bool proof_result = builder.check_circuit();
     EXPECT_EQ(proof_result, true);
 }
 
 TYPED_TEST(GroupTest, TestFixedBaseScalarMulZeroFails)
 {
     STDLIB_TYPE_ALIASES
-    auto composer = Composer();
+    auto builder = Builder();
 
     auto scalar = uint256_t(0, 0, 0, 0);
 
-    auto priv_key_witness = field_ct(witness_ct(&composer, fr(scalar)));
+    auto priv_key_witness = field_ct(witness_ct(&builder, fr(scalar)));
     group_ct::template fixed_base_scalar_mul<128>(priv_key_witness, 0);
 
-    printf("composer gates = %zu\n", composer.get_num_gates());
+    printf("num gates = %zu\n", builder.get_num_gates());
 
-    bool proof_result = composer.check_circuit();
+    bool proof_result = builder.check_circuit();
     EXPECT_EQ(proof_result, false);
-    EXPECT_EQ(composer.err(), "input scalar to fixed_base_scalar_mul_internal cannot be 0");
+    EXPECT_EQ(builder.err(), "input scalar to fixed_base_scalar_mul_internal cannot be 0");
 }
 
 TYPED_TEST(GroupTest, TestFixedBaseScalarMulWithTwoLimbs)
 {
     STDLIB_TYPE_ALIASES
-    auto composer = Composer();
+    auto builder = Builder();
 
     const uint256_t scalar = engine.get_random_uint256();
 
@@ -79,17 +79,17 @@ TYPED_TEST(GroupTest, TestFixedBaseScalarMulWithTwoLimbs)
     auto priv_key = grumpkin::fr(scalar);
     auto pub_key = grumpkin::g1::one * priv_key;
     pub_key = pub_key.normalize();
-    auto priv_key_low_witness = field_ct(witness_ct(&composer, fr(priv_key_low)));
-    auto priv_key_high_witness = field_ct(witness_ct(&composer, fr(priv_key_high)));
+    auto priv_key_low_witness = field_ct(witness_ct(&builder, fr(priv_key_low)));
+    auto priv_key_high_witness = field_ct(witness_ct(&builder, fr(priv_key_high)));
 
     auto result = group_ct::fixed_base_scalar_mul(priv_key_low_witness, priv_key_high_witness);
 
     EXPECT_EQ(result.x.get_value(), pub_key.x);
     EXPECT_EQ(result.y.get_value(), pub_key.y);
 
-    printf("composer gates = %zu\n", composer.get_num_gates());
+    printf("num gates = %zu\n", builder.get_num_gates());
 
-    bool proof_result = composer.check_circuit();
+    bool proof_result = builder.check_circuit();
     EXPECT_EQ(proof_result, true);
 }
 } // namespace stdlib_group_tests
diff --git a/barretenberg/cpp/src/barretenberg/stdlib/primitives/logic/logic.cpp b/barretenberg/cpp/src/barretenberg/stdlib/primitives/logic/logic.cpp
index ef56235292a..c7e8e372240 100644
--- a/barretenberg/cpp/src/barretenberg/stdlib/primitives/logic/logic.cpp
+++ b/barretenberg/cpp/src/barretenberg/stdlib/primitives/logic/logic.cpp
@@ -11,19 +11,19 @@ namespace proof_system::plonk::stdlib {
 /**
  * @brief A logical AND or XOR over a variable number of bits.
  *
- * @details Defaults to basic Composer method if not using plookup-compatible composer. If the left and right operands
+ * @details Defaults to basic Builder method if not using plookup-compatible builder. If the left and right operands
  * are larger than num_bit, the result will be truncated to num_bits. However, the two operands could be
  * range-constrained to num_bits before the call, which would remove the need to range constrain inside this function.
  *
- * @tparam Composer
+ * @tparam Builder
  * @param a
  * @param b
  * @param num_bits
  * @param is_xor_gate
- * @return field_t<Composer>
+ * @return field_t<Builder>
  */
-template <typename Composer>
-field_t<Composer> logic<Composer>::create_logic_constraint(
+template <typename Builder>
+field_t<Builder> logic<Builder>::create_logic_constraint(
     field_pt& a,
     field_pt& b,
     size_t num_bits,
@@ -38,22 +38,22 @@ field_t<Composer> logic<Composer>::create_logic_constraint(
         uint256_t a_native(a.get_value());
         uint256_t b_native(b.get_value());
         uint256_t c_native = is_xor_gate ? (a_native ^ b_native) : (a_native & b_native);
-        return field_t<Composer>(c_native);
+        return field_t<Builder>(c_native);
     }
     if (a.is_constant() && !b.is_constant()) {
-        Composer* ctx = b.get_context();
+        Builder* ctx = b.get_context();
         uint256_t a_native(a.get_value());
         field_pt a_witness = field_pt::from_witness_index(ctx, ctx->put_constant_variable(a_native));
         return create_logic_constraint(a_witness, b, num_bits, is_xor_gate, get_chunk);
     }
     if (!a.is_constant() && b.is_constant()) {
-        Composer* ctx = a.get_context();
+        Builder* ctx = a.get_context();
         uint256_t b_native(b.get_value());
         field_pt b_witness = field_pt::from_witness_index(ctx, ctx->put_constant_variable(b_native));
         return create_logic_constraint(a, b_witness, num_bits, is_xor_gate, get_chunk);
     }
-    if constexpr (HasPlookup<Composer>) {
-        Composer* ctx = a.get_context();
+    if constexpr (HasPlookup<Builder>) {
+        Builder* ctx = a.get_context();
 
         const size_t num_chunks = (num_bits / 32) + ((num_bits % 32 == 0) ? 0 : 1);
         auto left((uint256_t)a.get_value());
@@ -71,11 +71,11 @@ field_t<Composer> logic<Composer>::create_logic_constraint(
             field_pt b_chunk = witness_pt(ctx, right_chunk);
             field_pt result_chunk = 0;
             if (is_xor_gate) {
-                result_chunk = stdlib::plookup_read<Composer>::read_from_2_to_1_table(
+                result_chunk = stdlib::plookup_read<Builder>::read_from_2_to_1_table(
                     plookup::MultiTableId::UINT32_XOR, a_chunk, b_chunk);
 
             } else {
-                result_chunk = stdlib::plookup_read<Composer>::read_from_2_to_1_table(
+                result_chunk = stdlib::plookup_read<Builder>::read_from_2_to_1_table(
                     plookup::MultiTableId::UINT32_AND, a_chunk, b_chunk);
             }
 
@@ -102,15 +102,15 @@ field_t<Composer> logic<Composer>::create_logic_constraint(
 
         return res;
     } else {
-        // If the composer doesn't have lookups we call the expensive logic constraint gate
+        // If the builder doesn't have lookups we call the expensive logic constraint gate
         // which creates constraints for each bit. We only create constraints up to num_bits.
-        Composer* ctx = a.get_context();
+        Builder* ctx = a.get_context();
         field_pt a_slice = a.slice(static_cast<uint8_t>(num_bits - 1), 0)[1];
         field_pt b_slice = b.slice(static_cast<uint8_t>(num_bits - 1), 0)[1];
         auto accumulator_triple = ctx->create_logic_constraint(
             a_slice.normalize().get_witness_index(), b_slice.normalize().get_witness_index(), num_bits, is_xor_gate);
         auto out_idx = accumulator_triple.out[accumulator_triple.out.size() - 1];
-        return field_t<Composer>::from_witness_index(ctx, out_idx);
+        return field_t<Builder>::from_witness_index(ctx, out_idx);
     }
 }
 INSTANTIATE_STDLIB_TYPE(logic);
diff --git a/barretenberg/cpp/src/barretenberg/stdlib/primitives/logic/logic.hpp b/barretenberg/cpp/src/barretenberg/stdlib/primitives/logic/logic.hpp
index dc97d81f7e1..ab57defc4b7 100644
--- a/barretenberg/cpp/src/barretenberg/stdlib/primitives/logic/logic.hpp
+++ b/barretenberg/cpp/src/barretenberg/stdlib/primitives/logic/logic.hpp
@@ -9,10 +9,10 @@
 
 namespace proof_system::plonk::stdlib {
 
-template <typename Composer> class logic {
+template <typename Builder> class logic {
   public:
-    using field_pt = field_t<Composer>;
-    using witness_pt = witness_t<Composer>;
+    using field_pt = field_t<Builder>;
+    using witness_pt = witness_t<Builder>;
 
   public:
     static field_pt create_logic_constraint(
diff --git a/barretenberg/cpp/src/barretenberg/stdlib/primitives/logic/logic.test.cpp b/barretenberg/cpp/src/barretenberg/stdlib/primitives/logic/logic.test.cpp
index 4d77e33231a..11a8f6277fa 100644
--- a/barretenberg/cpp/src/barretenberg/stdlib/primitives/logic/logic.test.cpp
+++ b/barretenberg/cpp/src/barretenberg/stdlib/primitives/logic/logic.test.cpp
@@ -10,11 +10,11 @@
 #pragma GCC diagnostic ignored "-Wunused-local-typedefs"
 
 #define STDLIB_TYPE_ALIASES                                                                                            \
-    using Composer = TypeParam;                                                                                        \
-    using witness_ct = stdlib::witness_t<Composer>;                                                                    \
-    using field_ct = stdlib::field_t<Composer>;                                                                        \
-    using bool_ct = stdlib::bool_t<Composer>;                                                                          \
-    using public_witness_ct = stdlib::public_witness_t<Composer>;
+    using Builder = TypeParam;                                                                                         \
+    using witness_ct = stdlib::witness_t<Builder>;                                                                     \
+    using field_ct = stdlib::field_t<Builder>;                                                                         \
+    using bool_ct = stdlib::bool_t<Builder>;                                                                           \
+    using public_witness_ct = stdlib::public_witness_t<Builder>;
 
 namespace test_stdlib_logic {
 
@@ -27,7 +27,7 @@ template <class T> void ignore_unused(T&) {} // use to ignore unused variables i
 using namespace barretenberg;
 using namespace proof_system::plonk;
 
-template <class Composer> class LogicTest : public testing::Test {};
+template <class Builder> class LogicTest : public testing::Test {};
 
 using CircuitTypes = ::testing::
     Types<proof_system::StandardCircuitBuilder, proof_system::TurboCircuitBuilder, proof_system::UltraCircuitBuilder>;
@@ -38,7 +38,7 @@ TYPED_TEST(LogicTest, TestCorrectLogic)
 {
     STDLIB_TYPE_ALIASES
 
-    auto run_test = [](size_t num_bits, Composer& composer) {
+    auto run_test = [](size_t num_bits, Builder& builder) {
         uint256_t mask = (uint256_t(1) << num_bits) - 1;
 
         uint256_t a = engine.get_random_uint256() & mask;
@@ -47,29 +47,28 @@ TYPED_TEST(LogicTest, TestCorrectLogic)
         uint256_t and_expected = a & b;
         uint256_t xor_expected = a ^ b;
 
-        field_ct x = witness_ct(&composer, a);
-        field_ct y = witness_ct(&composer, b);
+        field_ct x = witness_ct(&builder, a);
+        field_ct y = witness_ct(&builder, b);
 
-        field_ct x_const(&composer, a);
-        field_ct y_const(&composer, b);
+        field_ct x_const(&builder, a);
+        field_ct y_const(&builder, b);
 
-        field_ct and_result = stdlib::logic<Composer>::create_logic_constraint(x, y, num_bits, false);
-        field_ct xor_result = stdlib::logic<Composer>::create_logic_constraint(x, y, num_bits, true);
+        field_ct and_result = stdlib::logic<Builder>::create_logic_constraint(x, y, num_bits, false);
+        field_ct xor_result = stdlib::logic<Builder>::create_logic_constraint(x, y, num_bits, true);
 
         field_ct and_result_left_constant =
-            stdlib::logic<Composer>::create_logic_constraint(x_const, y, num_bits, false);
-        field_ct xor_result_left_constant =
-            stdlib::logic<Composer>::create_logic_constraint(x_const, y, num_bits, true);
+            stdlib::logic<Builder>::create_logic_constraint(x_const, y, num_bits, false);
+        field_ct xor_result_left_constant = stdlib::logic<Builder>::create_logic_constraint(x_const, y, num_bits, true);
 
         field_ct and_result_right_constant =
-            stdlib::logic<Composer>::create_logic_constraint(x, y_const, num_bits, false);
+            stdlib::logic<Builder>::create_logic_constraint(x, y_const, num_bits, false);
         field_ct xor_result_right_constant =
-            stdlib::logic<Composer>::create_logic_constraint(x, y_const, num_bits, true);
+            stdlib::logic<Builder>::create_logic_constraint(x, y_const, num_bits, true);
 
         field_ct and_result_both_constant =
-            stdlib::logic<Composer>::create_logic_constraint(x_const, y_const, num_bits, false);
+            stdlib::logic<Builder>::create_logic_constraint(x_const, y_const, num_bits, false);
         field_ct xor_result_both_constant =
-            stdlib::logic<Composer>::create_logic_constraint(x_const, y_const, num_bits, true);
+            stdlib::logic<Builder>::create_logic_constraint(x_const, y_const, num_bits, true);
 
         EXPECT_EQ(uint256_t(and_result.get_value()), and_expected);
         EXPECT_EQ(uint256_t(and_result_left_constant.get_value()), and_expected);
@@ -82,21 +81,21 @@ TYPED_TEST(LogicTest, TestCorrectLogic)
         EXPECT_EQ(uint256_t(xor_result_both_constant.get_value()), xor_expected);
     };
 
-    auto composer = Composer();
+    auto builder = Builder();
     for (size_t i = 8; i < 248; i += 8) {
-        run_test(i, composer);
+        run_test(i, builder);
     }
-    bool result = composer.check_circuit();
+    bool result = builder.check_circuit();
     EXPECT_EQ(result, true);
 }
 
 // Tests the constraints will fail if the operands are larger than expected even though the result contains the correct
-// number of bits when using the UltraPlonkComposer This is because the range constraints on the right and left operand
+// number of bits when using the UltraPlonkBuilder This is because the range constraints on the right and left operand
 // are not being satisfied.
 TYPED_TEST(LogicTest, LargeOperands)
 {
     STDLIB_TYPE_ALIASES
-    auto composer = Composer();
+    auto builder = Builder();
 
     uint256_t mask = (uint256_t(1) << 48) - 1;
     uint256_t a = engine.get_random_uint256() & mask;
@@ -106,31 +105,31 @@ TYPED_TEST(LogicTest, LargeOperands)
     uint256_t and_expected = (a & b) & expected_mask;
     uint256_t xor_expected = (a ^ b) & expected_mask;
 
-    field_ct x = witness_ct(&composer, a);
-    field_ct y = witness_ct(&composer, b);
+    field_ct x = witness_ct(&builder, a);
+    field_ct y = witness_ct(&builder, b);
 
-    field_ct xor_result = stdlib::logic<Composer>::create_logic_constraint(x, y, 40, true);
-    field_ct and_result = stdlib::logic<Composer>::create_logic_constraint(x, y, 40, false);
+    field_ct xor_result = stdlib::logic<Builder>::create_logic_constraint(x, y, 40, true);
+    field_ct and_result = stdlib::logic<Builder>::create_logic_constraint(x, y, 40, false);
     EXPECT_EQ(uint256_t(and_result.get_value()), and_expected);
     EXPECT_EQ(uint256_t(xor_result.get_value()), xor_expected);
 
-    bool result = composer.check_circuit();
+    bool result = builder.check_circuit();
     EXPECT_EQ(result, true);
 }
 
 // Ensures that malicious witnesses which produce the same result are detected. This potential security issue cannot
-// happen if the composer doesn't support lookup gates because constraints will be created for each bit of the left and
+// happen if the builder doesn't support lookup gates because constraints will be created for each bit of the left and
 // right operand.
 TYPED_TEST(LogicTest, DifferentWitnessSameResult)
 {
 
     STDLIB_TYPE_ALIASES
-    auto composer = Composer();
-    if (HasPlookup<Composer>) {
+    auto builder = Builder();
+    if (HasPlookup<Builder>) {
         uint256_t a = 3758096391;
         uint256_t b = 2147483649;
-        field_ct x = witness_ct(&composer, uint256_t(a));
-        field_ct y = witness_ct(&composer, uint256_t(b));
+        field_ct x = witness_ct(&builder, uint256_t(a));
+        field_ct y = witness_ct(&builder, uint256_t(b));
 
         uint256_t xor_expected = a ^ b;
         const std::function<std::pair<uint256_t, uint256_t>(uint256_t, uint256_t, size_t)>& get_bad_chunk =
@@ -143,10 +142,10 @@ TYPED_TEST(LogicTest, DifferentWitnessSameResult)
                 return std::make_pair(left_chunk, right_chunk);
             };
 
-        field_ct xor_result = stdlib::logic<Composer>::create_logic_constraint(x, y, 32, true, get_bad_chunk);
+        field_ct xor_result = stdlib::logic<Builder>::create_logic_constraint(x, y, 32, true, get_bad_chunk);
         EXPECT_EQ(uint256_t(xor_result.get_value()), xor_expected);
 
-        bool result = composer.check_circuit();
+        bool result = builder.check_circuit();
         EXPECT_EQ(result, false);
     }
 }
diff --git a/barretenberg/cpp/src/barretenberg/stdlib/primitives/memory/dynamic_array.cpp b/barretenberg/cpp/src/barretenberg/stdlib/primitives/memory/dynamic_array.cpp
index eea139a9578..f25f9b40d7f 100644
--- a/barretenberg/cpp/src/barretenberg/stdlib/primitives/memory/dynamic_array.cpp
+++ b/barretenberg/cpp/src/barretenberg/stdlib/primitives/memory/dynamic_array.cpp
@@ -7,7 +7,7 @@ namespace proof_system::plonk {
 namespace stdlib {
 
 /**
- * @brief Construct a new Dynamic Array< Composer>:: Dynamic Array object
+ * @brief Construct a new Dynamic Array< Builder>:: Dynamic Array object
  *
  * @details Dynamic arrays require a maximum size when created, that cannot be exceeded.
  *          Read and write operations cost 3.25 UltraPlonk gates.
@@ -15,17 +15,17 @@ namespace stdlib {
  *          If the dynamic array also requires a unique range constraint table due to its length (e.g. not a power of
  * 2), this will add an additional (maximum_size / 6) gates.
  *
- * @tparam Composer
- * @param composer
+ * @tparam Builder
+ * @param builder
  * @param maximum_size The maximum size of the array
  */
-template <typename Composer>
-DynamicArray<Composer>::DynamicArray(Composer* composer, const size_t maximum_size)
-    : _context(composer)
+template <typename Builder>
+DynamicArray<Builder>::DynamicArray(Builder* builder, const size_t maximum_size)
+    : _context(builder)
     , _max_size(maximum_size)
     , _length(0)
 {
-    static_assert(HasPlookup<Composer>);
+    static_assert(HasPlookup<Builder>);
     ASSERT(_context != nullptr);
     _inner_table = ram_table(_context, maximum_size);
     // Initialize the ram table with all zeroes
@@ -35,13 +35,13 @@ DynamicArray<Composer>::DynamicArray(Composer* composer, const size_t maximum_si
 }
 
 /**
- * @brief Construct a new Dynamic Array< Composer>:: Dynamic Array object
+ * @brief Construct a new Dynamic Array< Builder>:: Dynamic Array object
  *
- * @tparam Composer
+ * @tparam Builder
  * @param other
  */
-template <typename Composer>
-DynamicArray<Composer>::DynamicArray(const DynamicArray& other)
+template <typename Builder>
+DynamicArray<Builder>::DynamicArray(const DynamicArray& other)
     : _context(other._context)
     , _max_size(other._max_size)
     , _length(other._length)
@@ -49,13 +49,13 @@ DynamicArray<Composer>::DynamicArray(const DynamicArray& other)
 {}
 
 /**
- * @brief Construct a new Dynamic Array< Composer>:: Dynamic Array object
+ * @brief Construct a new Dynamic Array< Builder>:: Dynamic Array object
  *
- * @tparam Composer
+ * @tparam Builder
  * @param other
  */
-template <typename Composer>
-DynamicArray<Composer>::DynamicArray(DynamicArray&& other)
+template <typename Builder>
+DynamicArray<Builder>::DynamicArray(DynamicArray&& other)
     : _context(other._context)
     , _max_size(other._max_size)
     , _length(other._length)
@@ -65,11 +65,11 @@ DynamicArray<Composer>::DynamicArray(DynamicArray&& other)
 /**
  * @brief Assignment Operator
  *
- * @tparam Composer
+ * @tparam Builder
  * @param other
- * @return DynamicArray<Composer>&
+ * @return DynamicArray<Builder>&
  */
-template <typename Composer> DynamicArray<Composer>& DynamicArray<Composer>::operator=(const DynamicArray& other)
+template <typename Builder> DynamicArray<Builder>& DynamicArray<Builder>::operator=(const DynamicArray& other)
 {
     _context = other._context;
     _max_size = other._max_size;
@@ -81,11 +81,11 @@ template <typename Composer> DynamicArray<Composer>& DynamicArray<Composer>::ope
 /**
  * @brief Move Assignment Operator
  *
- * @tparam Composer
+ * @tparam Builder
  * @param other
- * @return DynamicArray<Composer>&
+ * @return DynamicArray<Builder>&
  */
-template <typename Composer> DynamicArray<Composer>& DynamicArray<Composer>::operator=(DynamicArray&& other)
+template <typename Builder> DynamicArray<Builder>& DynamicArray<Builder>::operator=(DynamicArray&& other)
 {
     _context = other._context;
     _max_size = other._max_size;
@@ -97,11 +97,10 @@ template <typename Composer> DynamicArray<Composer>& DynamicArray<Composer>::ope
 /**
  * @brief Resize array. Current method v. inefficient!
  *
- * @tparam Composer
+ * @tparam Builder
  * @param new_length
  */
-template <typename Composer>
-void DynamicArray<Composer>::resize(const field_pt& new_length, const field_pt default_value)
+template <typename Builder> void DynamicArray<Builder>::resize(const field_pt& new_length, const field_pt default_value)
 {
     // 1: assert new_length < max_size
     field_pt max_bounds_check = (field_pt(_max_size) - new_length - 1);
@@ -163,11 +162,11 @@ void DynamicArray<Composer>::resize(const field_pt& new_length, const field_pt d
 /**
  * @brief Read a field element from the dynamic array at an index value
  *
- * @tparam Composer
+ * @tparam Builder
  * @param index
- * @return field_t<Composer>
+ * @return field_t<Builder>
  */
-template <typename Composer> field_t<Composer> DynamicArray<Composer>::read(const field_pt& index) const
+template <typename Builder> field_t<Builder> DynamicArray<Builder>::read(const field_pt& index) const
 {
     const field_pt index_delta = (_length - index - 1);
 
@@ -187,11 +186,11 @@ template <typename Composer> field_t<Composer> DynamicArray<Composer>::read(cons
 /**
  * @brief Write a field element into the dynamic array at an index value
  *
- * @tparam Composer
+ * @tparam Builder
  * @param index
  * @param value
  */
-template <typename Composer> void DynamicArray<Composer>::write(const field_pt& index, const field_pt& value)
+template <typename Builder> void DynamicArray<Builder>::write(const field_pt& index, const field_pt& value)
 {
     const field_pt index_delta = (_length - index - 1);
 
@@ -211,10 +210,10 @@ template <typename Composer> void DynamicArray<Composer>::write(const field_pt&
 /**
  * @brief Push a field element onto the dynamic array
  *
- * @tparam Composer
+ * @tparam Builder
  * @param value
  */
-template <typename Composer> void DynamicArray<Composer>::push(const field_pt& value)
+template <typename Builder> void DynamicArray<Builder>::push(const field_pt& value)
 {
     if (native_size() >= _max_size) {
         _context->failure("DynamicArray::push array is already at its maximum size");
@@ -227,9 +226,9 @@ template <typename Composer> void DynamicArray<Composer>::push(const field_pt& v
 /**
  * @brief Pop a field element off of the dynamic array
  *
- * @tparam Composer
+ * @tparam Builder
  */
-template <typename Composer> void DynamicArray<Composer>::pop()
+template <typename Builder> void DynamicArray<Builder>::pop()
 {
     if (native_size() == 0) {
         _context->failure("DynamicArray::pop array is already empty");
@@ -242,12 +241,12 @@ template <typename Composer> void DynamicArray<Composer>::pop()
 /**
  * @brief Conditionally push a field element onto the dynamic array
  *
- * @tparam Composer
+ * @tparam Builder
  * @param predicate
  * @param value
  */
-template <typename Composer>
-void DynamicArray<Composer>::conditional_push(const bool_pt& predicate, const field_pt& value)
+template <typename Builder>
+void DynamicArray<Builder>::conditional_push(const bool_pt& predicate, const field_pt& value)
 {
     if (native_size() >= _max_size) {
         _context->failure("DynamicArray::push array is already at its maximum size");
@@ -260,10 +259,10 @@ void DynamicArray<Composer>::conditional_push(const bool_pt& predicate, const fi
 /**
  * @brief Conditionallhy pop a field element off of the dynamic array
  *
- * @tparam Composer
+ * @tparam Builder
  * @param predicate
  */
-template <typename Composer> void DynamicArray<Composer>::conditional_pop(const bool_pt& predicate)
+template <typename Builder> void DynamicArray<Builder>::conditional_pop(const bool_pt& predicate)
 {
     if (native_size() == 0) {
         _context->failure("DynamicArray::pop array is already empty");
diff --git a/barretenberg/cpp/src/barretenberg/stdlib/primitives/memory/dynamic_array.hpp b/barretenberg/cpp/src/barretenberg/stdlib/primitives/memory/dynamic_array.hpp
index fe8127d3fdc..c78299d5468 100644
--- a/barretenberg/cpp/src/barretenberg/stdlib/primitives/memory/dynamic_array.hpp
+++ b/barretenberg/cpp/src/barretenberg/stdlib/primitives/memory/dynamic_array.hpp
@@ -7,16 +7,16 @@ namespace stdlib {
 /**
  * @brief A dynamic array of field elements
  *
- * @tparam Composer (must support plookup)
+ * @tparam Builder (must support plookup)
  */
-template <typename Composer> class DynamicArray {
+template <typename Builder> class DynamicArray {
   private:
-    typedef field_t<Composer> field_pt;
-    typedef bool_t<Composer> bool_pt;
-    typedef witness_t<Composer> witness_pt;
+    typedef field_t<Builder> field_pt;
+    typedef bool_t<Builder> bool_pt;
+    typedef witness_t<Builder> witness_pt;
 
   public:
-    DynamicArray(Composer* composer, const size_t maximum_size);
+    DynamicArray(Builder* builder, const size_t maximum_size);
 
     DynamicArray(const DynamicArray& other);
     DynamicArray(DynamicArray&& other);
@@ -39,13 +39,13 @@ template <typename Composer> class DynamicArray {
     size_t native_size() const { return static_cast<size_t>(static_cast<uint256_t>(_length.get_value())); }
     size_t max_size() const { return _max_size; }
 
-    Composer* get_context() const { return _context; }
+    Builder* get_context() const { return _context; }
 
   private:
-    Composer* _context = nullptr;
+    Builder* _context = nullptr;
     size_t _max_size;
     field_pt _length = 0;
-    mutable ram_table<Composer> _inner_table;
+    mutable ram_table<Builder> _inner_table;
 };
 
 EXTERN_STDLIB_ULTRA_TYPE(DynamicArray);
diff --git a/barretenberg/cpp/src/barretenberg/stdlib/primitives/memory/dynamic_array.test.cpp b/barretenberg/cpp/src/barretenberg/stdlib/primitives/memory/dynamic_array.test.cpp
index 47927d69c43..c6b81b6d139 100644
--- a/barretenberg/cpp/src/barretenberg/stdlib/primitives/memory/dynamic_array.test.cpp
+++ b/barretenberg/cpp/src/barretenberg/stdlib/primitives/memory/dynamic_array.test.cpp
@@ -16,22 +16,22 @@ auto& engine = numeric::random::get_debug_engine();
 }
 
 // Defining ultra-specific types for local testing.
-using Composer = proof_system::UltraCircuitBuilder;
-using bool_ct = stdlib::bool_t<Composer>;
-using field_ct = stdlib::field_t<Composer>;
-using witness_ct = stdlib::witness_t<Composer>;
-using DynamicArray_ct = stdlib::DynamicArray<Composer>;
+using Builder = proof_system::UltraCircuitBuilder;
+using bool_ct = stdlib::bool_t<Builder>;
+using field_ct = stdlib::field_t<Builder>;
+using witness_ct = stdlib::witness_t<Builder>;
+using DynamicArray_ct = stdlib::DynamicArray<Builder>;
 
 TEST(DynamicArray, DynamicArrayReadWriteConsistency)
 {
 
-    Composer composer;
+    Builder builder;
     const size_t max_size = 10;
 
-    DynamicArray_ct array(&composer, max_size);
+    DynamicArray_ct array(&builder, max_size);
 
     for (size_t i = 0; i < max_size; ++i) {
-        array.push(field_ct::from_witness(&composer, i));
+        array.push(field_ct::from_witness(&builder, i));
         EXPECT_EQ(array.read(i).get_value(), i);
     }
 
@@ -61,7 +61,7 @@ TEST(DynamicArray, DynamicArrayReadWriteConsistency)
     array.conditional_pop(true);
     EXPECT_EQ(array.native_size(), max_size - 1);
 
-    bool verified = composer.check_circuit();
+    bool verified = builder.check_circuit();
     EXPECT_EQ(verified, true);
 }
 
diff --git a/barretenberg/cpp/src/barretenberg/stdlib/primitives/memory/ram_table.cpp b/barretenberg/cpp/src/barretenberg/stdlib/primitives/memory/ram_table.cpp
index 3f37b7e7c0d..82b704c3ec2 100644
--- a/barretenberg/cpp/src/barretenberg/stdlib/primitives/memory/ram_table.cpp
+++ b/barretenberg/cpp/src/barretenberg/stdlib/primitives/memory/ram_table.cpp
@@ -6,15 +6,15 @@ namespace proof_system::plonk {
 namespace stdlib {
 
 /**
- * @brief Construct a new ram table<Composer>::ram table object. It's dynamic memory!
+ * @brief Construct a new ram table<Builder>::ram table object. It's dynamic memory!
  *
- * @tparam Composer
+ * @tparam Builder
  * @param table_entries vector of field elements that will initialize the RAM table
  */
-template <typename Composer> ram_table<Composer>::ram_table(Composer* composer, const size_t table_size)
+template <typename Builder> ram_table<Builder>::ram_table(Builder* builder, const size_t table_size)
 {
-    static_assert(HasPlookup<Composer>);
-    _context = composer;
+    static_assert(HasPlookup<Builder>);
+    _context = builder;
     _length = table_size;
     _index_initialized.resize(table_size);
     for (size_t i = 0; i < _index_initialized.size(); ++i) {
@@ -22,21 +22,21 @@ template <typename Composer> ram_table<Composer>::ram_table(Composer* composer,
     }
 
     // do not initialize the table yet. The input entries might all be constant,
-    // if this is the case we might not have a valid pointer to a Composer
+    // if this is the case we might not have a valid pointer to a Builder
     // We get around this, by initializing the table when `read` or `write` operator is called
     // with a non-const field element.
 }
 
 /**
- * @brief Construct a new ram table<Composer>::ram table object. It's dynamic memory!
+ * @brief Construct a new ram table<Builder>::ram table object. It's dynamic memory!
  *
- * @tparam Composer
+ * @tparam Builder
  * @param table_entries vector of field elements that will initialize the RAM table
  */
-template <typename Composer> ram_table<Composer>::ram_table(const std::vector<field_pt>& table_entries)
+template <typename Builder> ram_table<Builder>::ram_table(const std::vector<field_pt>& table_entries)
 {
-    static_assert(HasPlookup<Composer>);
-    // get the composer _context
+    static_assert(HasPlookup<Builder>);
+    // get the builder _context
     for (const auto& entry : table_entries) {
         if (entry.get_context() != nullptr) {
             _context = entry.get_context();
@@ -50,23 +50,23 @@ template <typename Composer> ram_table<Composer>::ram_table(const std::vector<fi
         _index_initialized[i] = false;
     }
     // do not initialize the table yet. The input entries might all be constant,
-    // if this is the case we might not have a valid pointer to a Composer
+    // if this is the case we might not have a valid pointer to a Builder
     // We get around this, by initializing the table when `read` or `write` operator is called
     // with a non-const field element.
 }
 
 /**
- * @brief internal method, is used to call Composer methods that will generate RAM table.
+ * @brief internal method, is used to call Builder methods that will generate RAM table.
  *
- * @details initialize the table once we perform a read. This ensures we always have a pointer to a Composer.
- * (if both the table entries and the index are constant, we don't need a composer as we
+ * @details initialize the table once we perform a read. This ensures we always have a pointer to a Builder.
+ * (if both the table entries and the index are constant, we don't need a builder as we
  * can directly extract the desired value fram `_raw_entries`)
  *
- * @tparam Composer
+ * @tparam Builder
  */
-template <typename Composer> void ram_table<Composer>::initialize_table() const
+template <typename Builder> void ram_table<Builder>::initialize_table() const
 {
-    if (_ram_table_generated_in_composer) {
+    if (_ram_table_generated_in_builder) {
         return;
     }
     ASSERT(_context != nullptr);
@@ -89,39 +89,39 @@ template <typename Composer> void ram_table<Composer>::initialize_table() const
         }
     }
 
-    _ram_table_generated_in_composer = true;
+    _ram_table_generated_in_builder = true;
 }
 
 /**
- * @brief Construct a new ram table<Composer>::ram table object
+ * @brief Construct a new ram table<Builder>::ram table object
  *
- * @tparam Composer
+ * @tparam Builder
  * @param other
  */
-template <typename Composer>
-ram_table<Composer>::ram_table(const ram_table& other)
+template <typename Builder>
+ram_table<Builder>::ram_table(const ram_table& other)
     : _raw_entries(other._raw_entries)
     , _index_initialized(other._index_initialized)
     , _length(other._length)
     , _ram_id(other._ram_id)
-    , _ram_table_generated_in_composer(other._ram_table_generated_in_composer)
+    , _ram_table_generated_in_builder(other._ram_table_generated_in_builder)
     , _all_entries_written_to_with_constant_index(other._all_entries_written_to_with_constant_index)
     , _context(other._context)
 {}
 
 /**
- * @brief Construct a new ram table<Composer>::ram table object
+ * @brief Construct a new ram table<Builder>::ram table object
  *
- * @tparam Composer
+ * @tparam Builder
  * @param other
  */
-template <typename Composer>
-ram_table<Composer>::ram_table(ram_table&& other)
+template <typename Builder>
+ram_table<Builder>::ram_table(ram_table&& other)
     : _raw_entries(other._raw_entries)
     , _index_initialized(other._index_initialized)
     , _length(other._length)
     , _ram_id(other._ram_id)
-    , _ram_table_generated_in_composer(other._ram_table_generated_in_composer)
+    , _ram_table_generated_in_builder(other._ram_table_generated_in_builder)
     , _all_entries_written_to_with_constant_index(other._all_entries_written_to_with_constant_index)
     , _context(other._context)
 {}
@@ -129,17 +129,17 @@ ram_table<Composer>::ram_table(ram_table&& other)
 /**
  * @brief Copy assignment operator
  *
- * @tparam Composer
+ * @tparam Builder
  * @param other
- * @return ram_table<Composer>&
+ * @return ram_table<Builder>&
  */
-template <typename Composer> ram_table<Composer>& ram_table<Composer>::operator=(const ram_table& other)
+template <typename Builder> ram_table<Builder>& ram_table<Builder>::operator=(const ram_table& other)
 {
     _raw_entries = other._raw_entries;
     _length = other._length;
     _ram_id = other._ram_id;
     _index_initialized = other._index_initialized;
-    _ram_table_generated_in_composer = other._ram_table_generated_in_composer;
+    _ram_table_generated_in_builder = other._ram_table_generated_in_builder;
     _all_entries_written_to_with_constant_index = other._all_entries_written_to_with_constant_index;
 
     _context = other._context;
@@ -149,17 +149,17 @@ template <typename Composer> ram_table<Composer>& ram_table<Composer>::operator=
 /**
  * @brief Move assignment operator
  *
- * @tparam Composer
+ * @tparam Builder
  * @param other
- * @return ram_table<Composer>&
+ * @return ram_table<Builder>&
  */
-template <typename Composer> ram_table<Composer>& ram_table<Composer>::operator=(ram_table&& other)
+template <typename Builder> ram_table<Builder>& ram_table<Builder>::operator=(ram_table&& other)
 {
     _raw_entries = other._raw_entries;
     _length = other._length;
     _ram_id = other._ram_id;
     _index_initialized = other._index_initialized;
-    _ram_table_generated_in_composer = other._ram_table_generated_in_composer;
+    _ram_table_generated_in_builder = other._ram_table_generated_in_builder;
     _all_entries_written_to_with_constant_index = other._all_entries_written_to_with_constant_index;
     _context = other._context;
     return *this;
@@ -168,11 +168,11 @@ template <typename Composer> ram_table<Composer>& ram_table<Composer>::operator=
 /**
  * @brief Read a field element from the RAM table at an index value
  *
- * @tparam Composer
+ * @tparam Builder
  * @param index
- * @return field_t<Composer>
+ * @return field_t<Builder>
  */
-template <typename Composer> field_t<Composer> ram_table<Composer>::read(const field_pt& index) const
+template <typename Builder> field_t<Builder> ram_table<Builder>::read(const field_pt& index) const
 {
     if (_context == nullptr) {
         _context = index.get_context();
@@ -205,11 +205,11 @@ template <typename Composer> field_t<Composer> ram_table<Composer>::read(const f
 /**
  * @brief Write a field element from the RAM table at an index value
  *
- * @tparam Composer
+ * @tparam Builder
  * @param index
  * @param value
  */
-template <typename Composer> void ram_table<Composer>::write(const field_pt& index, const field_pt& value)
+template <typename Builder> void ram_table<Builder>::write(const field_pt& index, const field_pt& value)
 {
     if (_context == nullptr) {
         _context = index.get_context();
diff --git a/barretenberg/cpp/src/barretenberg/stdlib/primitives/memory/ram_table.hpp b/barretenberg/cpp/src/barretenberg/stdlib/primitives/memory/ram_table.hpp
index 8bdc472a6ce..9e84bfe67c7 100644
--- a/barretenberg/cpp/src/barretenberg/stdlib/primitives/memory/ram_table.hpp
+++ b/barretenberg/cpp/src/barretenberg/stdlib/primitives/memory/ram_table.hpp
@@ -6,14 +6,14 @@ namespace proof_system::plonk {
 namespace stdlib {
 
 // A runtime-defined read-only memory table. Table entries must be initialized in the constructor.
-// N.B. Only works with the UltraPlonkComposer at the moment!
-template <typename Composer> class ram_table {
+// N.B. Only works with the UltraPlonkBuilder at the moment!
+template <typename Builder> class ram_table {
   private:
-    typedef field_t<Composer> field_pt;
+    typedef field_t<Builder> field_pt;
 
   public:
     ram_table() {}
-    ram_table(Composer* composer, const size_t table_size);
+    ram_table(Builder* builder, const size_t table_size);
     ram_table(const std::vector<field_pt>& table_entries);
     ram_table(const ram_table& other);
     ram_table(ram_table&& other);
@@ -29,7 +29,7 @@ template <typename Composer> class ram_table {
 
     size_t size() const { return _length; }
 
-    Composer* get_context() const { return _context; }
+    Builder* get_context() const { return _context; }
 
     bool check_indices_initialized() const
     {
@@ -51,10 +51,10 @@ template <typename Composer> class ram_table {
     std::vector<field_pt> _raw_entries;
     mutable std::vector<bool> _index_initialized;
     size_t _length = 0;
-    mutable size_t _ram_id = 0; // Composer identifier for this ROM table
-    mutable bool _ram_table_generated_in_composer = false;
+    mutable size_t _ram_id = 0; // Builder identifier for this ROM table
+    mutable bool _ram_table_generated_in_builder = false;
     mutable bool _all_entries_written_to_with_constant_index = false;
-    mutable Composer* _context = nullptr;
+    mutable Builder* _context = nullptr;
 };
 
 EXTERN_STDLIB_ULTRA_TYPE(ram_table);
diff --git a/barretenberg/cpp/src/barretenberg/stdlib/primitives/memory/ram_table.test.cpp b/barretenberg/cpp/src/barretenberg/stdlib/primitives/memory/ram_table.test.cpp
index cd75ae5078b..920cf8bbdcd 100644
--- a/barretenberg/cpp/src/barretenberg/stdlib/primitives/memory/ram_table.test.cpp
+++ b/barretenberg/cpp/src/barretenberg/stdlib/primitives/memory/ram_table.test.cpp
@@ -8,10 +8,10 @@ namespace test_stdlib_ram_table {
 
 using namespace proof_system::plonk;
 // Defining ultra-specific types for local testing.
-using Composer = proof_system::UltraCircuitBuilder;
-using field_ct = stdlib::field_t<Composer>;
-using witness_ct = stdlib::witness_t<Composer>;
-using ram_table_ct = stdlib::ram_table<Composer>;
+using Builder = proof_system::UltraCircuitBuilder;
+using field_ct = stdlib::field_t<Builder>;
+using witness_ct = stdlib::witness_t<Builder>;
+using ram_table_ct = stdlib::ram_table<Builder>;
 
 namespace {
 auto& engine = numeric::random::get_debug_engine();
@@ -19,12 +19,12 @@ auto& engine = numeric::random::get_debug_engine();
 
 TEST(ram_table, ram_table_init_read_consistency)
 {
-    Composer composer;
+    Builder builder;
 
     std::vector<field_ct> table_values;
     const size_t table_size = 10;
     for (size_t i = 0; i < table_size; ++i) {
-        table_values.emplace_back(witness_ct(&composer, barretenberg::fr::random_element()));
+        table_values.emplace_back(witness_ct(&builder, barretenberg::fr::random_element()));
     }
 
     ram_table_ct table(table_values);
@@ -33,7 +33,7 @@ TEST(ram_table, ram_table_init_read_consistency)
     barretenberg::fr expected(0);
 
     for (size_t i = 0; i < 10; ++i) {
-        field_ct index(witness_ct(&composer, (uint64_t)i));
+        field_ct index(witness_ct(&builder, (uint64_t)i));
 
         if (i % 2 == 0) {
             const auto to_add = table.read(index);
@@ -47,18 +47,18 @@ TEST(ram_table, ram_table_init_read_consistency)
 
     EXPECT_EQ(result.get_value(), expected);
 
-    bool verified = composer.check_circuit();
+    bool verified = builder.check_circuit();
     EXPECT_EQ(verified, true);
 }
 
 TEST(ram_table, ram_table_read_write_consistency)
 {
-    Composer composer;
+    Builder builder;
     const size_t table_size = 10;
 
     std::vector<barretenberg::fr> table_values(table_size);
 
-    ram_table_ct table(&composer, table_size);
+    ram_table_ct table(&builder, table_size);
 
     for (size_t i = 0; i < table_size; ++i) {
         table.write(i, 0);
@@ -73,7 +73,7 @@ TEST(ram_table, ram_table_read_write_consistency)
 
             // init with both constant and variable values
             table.write(2 * i, table_values[2 * i]);
-            table.write(2 * i + 1, witness_ct(&composer, table_values[2 * i + 1]));
+            table.write(2 * i + 1, witness_ct(&builder, table_values[2 * i + 1]));
         }
     };
 
@@ -81,7 +81,7 @@ TEST(ram_table, ram_table_read_write_consistency)
         for (size_t i = 0; i < table_size / 2; ++i) {
             const size_t index = table_size - 2 - (i * 2); // access in something other than basic incremental order
 
-            result += table.read(witness_ct(&composer, index));
+            result += table.read(witness_ct(&builder, index));
             result += table.read(index + 1);
 
             expected += table_values[index];
@@ -97,7 +97,7 @@ TEST(ram_table, ram_table_read_write_consistency)
 
     EXPECT_EQ(result.get_value(), expected);
 
-    bool verified = composer.check_circuit();
+    bool verified = builder.check_circuit();
     EXPECT_EQ(verified, true);
 }
 } // namespace test_stdlib_ram_table
\ No newline at end of file
diff --git a/barretenberg/cpp/src/barretenberg/stdlib/primitives/memory/rom_table.cpp b/barretenberg/cpp/src/barretenberg/stdlib/primitives/memory/rom_table.cpp
index 071af3f55f2..00f15346dd4 100644
--- a/barretenberg/cpp/src/barretenberg/stdlib/primitives/memory/rom_table.cpp
+++ b/barretenberg/cpp/src/barretenberg/stdlib/primitives/memory/rom_table.cpp
@@ -7,10 +7,10 @@ using namespace barretenberg;
 namespace proof_system::plonk {
 namespace stdlib {
 
-template <typename Composer> rom_table<Composer>::rom_table(const std::vector<field_pt>& table_entries)
+template <typename Builder> rom_table<Builder>::rom_table(const std::vector<field_pt>& table_entries)
 {
-    static_assert(HasPlookup<Composer>);
-    // get the composer context
+    static_assert(HasPlookup<Builder>);
+    // get the builder context
     for (const auto& entry : table_entries) {
         if (entry.get_context() != nullptr) {
             context = entry.get_context();
@@ -20,16 +20,16 @@ template <typename Composer> rom_table<Composer>::rom_table(const std::vector<fi
     raw_entries = table_entries;
     length = raw_entries.size();
     // do not initialize the table yet. The input entries might all be constant,
-    // if this is the case we might not have a valid pointer to a Composer
+    // if this is the case we might not have a valid pointer to a Builder
     // We get around this, by initializing the table when `operator[]` is called
     // with a non-const field element.
 }
 
 // initialize the table once we perform a read. This ensures we always have a valid
-// pointer to a Composer.
-// (if both the table entries and the index are constant, we don't need a composer as we
+// pointer to a Builder.
+// (if both the table entries and the index are constant, we don't need a builder as we
 // can directly extract the desired value from `raw_entries`)
-template <typename Composer> void rom_table<Composer>::initialize_table() const
+template <typename Builder> void rom_table<Builder>::initialize_table() const
 {
     if (initialized) {
         return;
@@ -53,8 +53,8 @@ template <typename Composer> void rom_table<Composer>::initialize_table() const
     initialized = true;
 }
 
-template <typename Composer>
-rom_table<Composer>::rom_table(const rom_table& other)
+template <typename Builder>
+rom_table<Builder>::rom_table(const rom_table& other)
     : raw_entries(other.raw_entries)
     , entries(other.entries)
     , length(other.length)
@@ -63,8 +63,8 @@ rom_table<Composer>::rom_table(const rom_table& other)
     , context(other.context)
 {}
 
-template <typename Composer>
-rom_table<Composer>::rom_table(rom_table&& other)
+template <typename Builder>
+rom_table<Builder>::rom_table(rom_table&& other)
     : raw_entries(other.raw_entries)
     , entries(other.entries)
     , length(other.length)
@@ -73,7 +73,7 @@ rom_table<Composer>::rom_table(rom_table&& other)
     , context(other.context)
 {}
 
-template <typename Composer> rom_table<Composer>& rom_table<Composer>::operator=(const rom_table& other)
+template <typename Builder> rom_table<Builder>& rom_table<Builder>::operator=(const rom_table& other)
 {
     raw_entries = other.raw_entries;
     entries = other.entries;
@@ -84,7 +84,7 @@ template <typename Composer> rom_table<Composer>& rom_table<Composer>::operator=
     return *this;
 }
 
-template <typename Composer> rom_table<Composer>& rom_table<Composer>::operator=(rom_table&& other)
+template <typename Builder> rom_table<Builder>& rom_table<Builder>::operator=(rom_table&& other)
 {
     raw_entries = other.raw_entries;
     entries = other.entries;
@@ -95,7 +95,7 @@ template <typename Composer> rom_table<Composer>& rom_table<Composer>::operator=
     return *this;
 }
 
-template <typename Composer> field_t<Composer> rom_table<Composer>::operator[](const size_t index) const
+template <typename Builder> field_t<Builder> rom_table<Builder>::operator[](const size_t index) const
 {
     if (index >= length) {
         ASSERT(context != nullptr);
@@ -105,7 +105,7 @@ template <typename Composer> field_t<Composer> rom_table<Composer>::operator[](c
     return entries[index];
 }
 
-template <typename Composer> field_t<Composer> rom_table<Composer>::operator[](const field_pt& index) const
+template <typename Builder> field_t<Builder> rom_table<Builder>::operator[](const field_pt& index) const
 {
     if (index.is_constant()) {
         return operator[](static_cast<size_t>(uint256_t(index.get_value()).data[0]));
diff --git a/barretenberg/cpp/src/barretenberg/stdlib/primitives/memory/rom_table.hpp b/barretenberg/cpp/src/barretenberg/stdlib/primitives/memory/rom_table.hpp
index 56b953d68c9..859481b68ac 100644
--- a/barretenberg/cpp/src/barretenberg/stdlib/primitives/memory/rom_table.hpp
+++ b/barretenberg/cpp/src/barretenberg/stdlib/primitives/memory/rom_table.hpp
@@ -6,10 +6,10 @@ namespace proof_system::plonk {
 namespace stdlib {
 
 // A runtime-defined read-only memory table. Table entries must be initialized in the constructor.
-// N.B. Only works with the UltraPlonkComposer at the moment!
-template <typename Composer> class rom_table {
+// N.B. Only works with the UltraPlonkBuilder at the moment!
+template <typename Builder> class rom_table {
   private:
-    typedef field_t<Composer> field_pt;
+    typedef field_t<Builder> field_pt;
 
   public:
     rom_table(){};
@@ -30,15 +30,15 @@ template <typename Composer> class rom_table {
 
     size_t size() const { return length; }
 
-    Composer* get_context() const { return context; }
+    Builder* get_context() const { return context; }
 
   private:
     std::vector<field_pt> raw_entries;
     mutable std::vector<field_pt> entries;
     size_t length = 0;
-    mutable size_t rom_id = 0; // Composer identifier for this ROM table
+    mutable size_t rom_id = 0; // Builder identifier for this ROM table
     mutable bool initialized = false;
-    mutable Composer* context = nullptr;
+    mutable Builder* context = nullptr;
 };
 
 EXTERN_STDLIB_ULTRA_TYPE(rom_table);
diff --git a/barretenberg/cpp/src/barretenberg/stdlib/primitives/memory/rom_table.test.cpp b/barretenberg/cpp/src/barretenberg/stdlib/primitives/memory/rom_table.test.cpp
index 947ce35a234..2c716b3a5cc 100644
--- a/barretenberg/cpp/src/barretenberg/stdlib/primitives/memory/rom_table.test.cpp
+++ b/barretenberg/cpp/src/barretenberg/stdlib/primitives/memory/rom_table.test.cpp
@@ -10,10 +10,10 @@ using namespace barretenberg;
 using namespace proof_system::plonk;
 
 // Defining ultra-specific types for local testing.
-using Composer = proof_system::UltraCircuitBuilder;
-using field_ct = stdlib::field_t<Composer>;
-using witness_ct = stdlib::witness_t<Composer>;
-using rom_table_ct = stdlib::rom_table<Composer>;
+using Builder = proof_system::UltraCircuitBuilder;
+using field_ct = stdlib::field_t<Builder>;
+using witness_ct = stdlib::witness_t<Builder>;
+using rom_table_ct = stdlib::rom_table<Builder>;
 
 namespace {
 auto& engine = numeric::random::get_debug_engine();
@@ -21,12 +21,12 @@ auto& engine = numeric::random::get_debug_engine();
 
 TEST(rom_table, rom_table_read_write_consistency)
 {
-    Composer composer;
+    Builder builder;
 
     std::vector<field_ct> table_values;
     const size_t table_size = 10;
     for (size_t i = 0; i < table_size; ++i) {
-        table_values.emplace_back(witness_ct(&composer, barretenberg::fr::random_element()));
+        table_values.emplace_back(witness_ct(&builder, barretenberg::fr::random_element()));
     }
 
     rom_table_ct table(table_values);
@@ -35,12 +35,12 @@ TEST(rom_table, rom_table_read_write_consistency)
     barretenberg::fr expected(0);
 
     for (size_t i = 0; i < 10; ++i) {
-        field_ct index(witness_ct(&composer, (uint64_t)i));
+        field_ct index(witness_ct(&builder, (uint64_t)i));
 
         if (i % 2 == 0) {
-            const auto before_n = composer.num_gates;
+            const auto before_n = builder.num_gates;
             const auto to_add = table[index];
-            const auto after_n = composer.num_gates;
+            const auto after_n = builder.num_gates;
             // should cost 1 gates (the ROM read adds 1 extra gate when the proving key is constructed)
             // (but not for 1st entry, the 1st ROM read also builts the ROM table, which will cost table_size * 2 gates)
             if (i != 0) {
@@ -48,9 +48,9 @@ TEST(rom_table, rom_table_read_write_consistency)
             }
             result += to_add; // variable lookup
         } else {
-            const auto before_n = composer.num_gates;
+            const auto before_n = builder.num_gates;
             const auto to_add = table[i]; // constant lookup
-            const auto after_n = composer.num_gates;
+            const auto after_n = builder.num_gates;
             // should cost 0 gates. Constant lookups are free
             EXPECT_EQ(after_n - before_n, 0ULL);
             result += to_add;
@@ -60,7 +60,7 @@ TEST(rom_table, rom_table_read_write_consistency)
 
     EXPECT_EQ(result.get_value(), expected);
 
-    bool verified = composer.check_circuit();
+    bool verified = builder.check_circuit();
     EXPECT_EQ(verified, true);
 }
 
diff --git a/barretenberg/cpp/src/barretenberg/stdlib/primitives/memory/twin_rom_table.cpp b/barretenberg/cpp/src/barretenberg/stdlib/primitives/memory/twin_rom_table.cpp
index c4216478d00..b6a577e2b1f 100644
--- a/barretenberg/cpp/src/barretenberg/stdlib/primitives/memory/twin_rom_table.cpp
+++ b/barretenberg/cpp/src/barretenberg/stdlib/primitives/memory/twin_rom_table.cpp
@@ -7,11 +7,11 @@ using namespace barretenberg;
 namespace proof_system::plonk {
 namespace stdlib {
 
-template <typename Composer>
-twin_rom_table<Composer>::twin_rom_table(const std::vector<std::array<field_pt, 2>>& table_entries)
+template <typename Builder>
+twin_rom_table<Builder>::twin_rom_table(const std::vector<std::array<field_pt, 2>>& table_entries)
 {
-    static_assert(HasPlookup<Composer>);
-    // get the composer context
+    static_assert(HasPlookup<Builder>);
+    // get the builder context
     for (const auto& entry : table_entries) {
         if (entry[0].get_context() != nullptr) {
             context = entry[0].get_context();
@@ -25,16 +25,16 @@ twin_rom_table<Composer>::twin_rom_table(const std::vector<std::array<field_pt,
     raw_entries = table_entries;
     length = raw_entries.size();
     // do not initialize the table yet. The input entries might all be constant,
-    // if this is the case we might not have a valid pointer to a Composer
+    // if this is the case we might not have a valid pointer to a Builder
     // We get around this, by initializing the table when `operator[]` is called
     // with a non-const field element.
 }
 
 // initialize the table once we perform a read. This ensures we always have a valid
-// pointer to a Composer.
-// (if both the table entries and the index are constant, we don't need a composer as we
+// pointer to a Builder.
+// (if both the table entries and the index are constant, we don't need a builder as we
 // can directly extract the desired value from `raw_entries`)
-template <typename Composer> void twin_rom_table<Composer>::initialize_table() const
+template <typename Builder> void twin_rom_table<Builder>::initialize_table() const
 {
     if (initialized) {
         return;
@@ -65,8 +65,8 @@ template <typename Composer> void twin_rom_table<Composer>::initialize_table() c
     initialized = true;
 }
 
-template <typename Composer>
-twin_rom_table<Composer>::twin_rom_table(const twin_rom_table& other)
+template <typename Builder>
+twin_rom_table<Builder>::twin_rom_table(const twin_rom_table& other)
     : raw_entries(other.raw_entries)
     , entries(other.entries)
     , length(other.length)
@@ -75,8 +75,8 @@ twin_rom_table<Composer>::twin_rom_table(const twin_rom_table& other)
     , context(other.context)
 {}
 
-template <typename Composer>
-twin_rom_table<Composer>::twin_rom_table(twin_rom_table&& other)
+template <typename Builder>
+twin_rom_table<Builder>::twin_rom_table(twin_rom_table&& other)
     : raw_entries(other.raw_entries)
     , entries(other.entries)
     , length(other.length)
@@ -85,7 +85,7 @@ twin_rom_table<Composer>::twin_rom_table(twin_rom_table&& other)
     , context(other.context)
 {}
 
-template <typename Composer> twin_rom_table<Composer>& twin_rom_table<Composer>::operator=(const twin_rom_table& other)
+template <typename Builder> twin_rom_table<Builder>& twin_rom_table<Builder>::operator=(const twin_rom_table& other)
 {
     raw_entries = other.raw_entries;
     entries = other.entries;
@@ -96,7 +96,7 @@ template <typename Composer> twin_rom_table<Composer>& twin_rom_table<Composer>:
     return *this;
 }
 
-template <typename Composer> twin_rom_table<Composer>& twin_rom_table<Composer>::operator=(twin_rom_table&& other)
+template <typename Builder> twin_rom_table<Builder>& twin_rom_table<Builder>::operator=(twin_rom_table&& other)
 {
     raw_entries = other.raw_entries;
     entries = other.entries;
@@ -107,8 +107,8 @@ template <typename Composer> twin_rom_table<Composer>& twin_rom_table<Composer>:
     return *this;
 }
 
-template <typename Composer>
-std::array<field_t<Composer>, 2> twin_rom_table<Composer>::operator[](const size_t index) const
+template <typename Builder>
+std::array<field_t<Builder>, 2> twin_rom_table<Builder>::operator[](const size_t index) const
 {
     if (index >= length) {
         ASSERT(context != nullptr);
@@ -118,8 +118,8 @@ std::array<field_t<Composer>, 2> twin_rom_table<Composer>::operator[](const size
     return entries[index];
 }
 
-template <typename Composer>
-std::array<field_t<Composer>, 2> twin_rom_table<Composer>::operator[](const field_pt& index) const
+template <typename Builder>
+std::array<field_t<Builder>, 2> twin_rom_table<Builder>::operator[](const field_pt& index) const
 {
     if (index.is_constant()) {
         return operator[](static_cast<size_t>(uint256_t(index.get_value()).data[0]));
diff --git a/barretenberg/cpp/src/barretenberg/stdlib/primitives/memory/twin_rom_table.hpp b/barretenberg/cpp/src/barretenberg/stdlib/primitives/memory/twin_rom_table.hpp
index ceb63993118..3289f4394d8 100644
--- a/barretenberg/cpp/src/barretenberg/stdlib/primitives/memory/twin_rom_table.hpp
+++ b/barretenberg/cpp/src/barretenberg/stdlib/primitives/memory/twin_rom_table.hpp
@@ -7,10 +7,10 @@ namespace stdlib {
 
 // A runtime-defined read-only memory table. Table entries must be initialized in the constructor.
 // Each entry contains a pair of values
-// N.B. Only works with the UltraPlonkComposer at the moment!
-template <typename Composer> class twin_rom_table {
+// N.B. Only works with the UltraPlonkBuilder at the moment!
+template <typename Builder> class twin_rom_table {
   private:
-    typedef field_t<Composer> field_pt;
+    typedef field_t<Builder> field_pt;
     typedef std::array<field_pt, 2> field_pair_pt;
 
   public:
@@ -32,15 +32,15 @@ template <typename Composer> class twin_rom_table {
 
     size_t size() const { return length; }
 
-    Composer* get_context() const { return context; }
+    Builder* get_context() const { return context; }
 
   private:
     std::vector<field_pair_pt> raw_entries;
     mutable std::vector<field_pair_pt> entries;
     size_t length = 0;
-    mutable size_t rom_id = 0; // Composer identifier for this ROM table
+    mutable size_t rom_id = 0; // Builder identifier for this ROM table
     mutable bool initialized = false;
-    mutable Composer* context = nullptr;
+    mutable Builder* context = nullptr;
 };
 
 EXTERN_STDLIB_ULTRA_TYPE(twin_rom_table);
diff --git a/barretenberg/cpp/src/barretenberg/stdlib/primitives/packed_byte_array/packed_byte_array.cpp b/barretenberg/cpp/src/barretenberg/stdlib/primitives/packed_byte_array/packed_byte_array.cpp
index da8e4acdc34..053ee517d49 100644
--- a/barretenberg/cpp/src/barretenberg/stdlib/primitives/packed_byte_array/packed_byte_array.cpp
+++ b/barretenberg/cpp/src/barretenberg/stdlib/primitives/packed_byte_array/packed_byte_array.cpp
@@ -8,7 +8,7 @@ namespace proof_system::plonk {
 namespace stdlib {
 
 namespace {
-template <typename Composer> Composer* get_context_from_fields(const std::vector<field_t<Composer>>& input)
+template <typename Builder> Builder* get_context_from_fields(const std::vector<field_t<Builder>>& input)
 {
     for (const auto& element : input) {
         if (element.get_context()) {
@@ -19,8 +19,8 @@ template <typename Composer> Composer* get_context_from_fields(const std::vector
 }
 } // namespace
 
-template <typename Composer>
-packed_byte_array<Composer>::packed_byte_array(Composer* parent_context, const size_t n)
+template <typename Builder>
+packed_byte_array<Builder>::packed_byte_array(Builder* parent_context, const size_t n)
     : context(parent_context)
     , num_bytes(n)
 {
@@ -28,8 +28,8 @@ packed_byte_array<Composer>::packed_byte_array(Composer* parent_context, const s
     limbs = std::vector<field_pt>(num_elements);
 }
 
-template <typename Composer>
-packed_byte_array<Composer>::packed_byte_array(const std::vector<field_pt>& input, const size_t bytes_per_input)
+template <typename Builder>
+packed_byte_array<Builder>::packed_byte_array(const std::vector<field_pt>& input, const size_t bytes_per_input)
     : context(get_context_from_fields(input))
     , num_bytes(bytes_per_input * input.size())
 {
@@ -56,8 +56,8 @@ packed_byte_array<Composer>::packed_byte_array(const std::vector<field_pt>& inpu
     }
 }
 
-template <typename Composer>
-packed_byte_array<Composer>::packed_byte_array(Composer* parent_context, const std::vector<uint8_t>& input)
+template <typename Builder>
+packed_byte_array<Builder>::packed_byte_array(Builder* parent_context, const std::vector<uint8_t>& input)
     : context(parent_context)
     , num_bytes(input.size())
 {
@@ -79,8 +79,8 @@ packed_byte_array<Composer>::packed_byte_array(Composer* parent_context, const s
     }
 }
 
-template <typename Composer>
-packed_byte_array<Composer>::packed_byte_array(const byte_array_pt& input)
+template <typename Builder>
+packed_byte_array<Builder>::packed_byte_array(const byte_array_pt& input)
     : context(input.get_context())
     , num_bytes(input.size())
 {
@@ -99,27 +99,27 @@ packed_byte_array<Composer>::packed_byte_array(const byte_array_pt& input)
     }
 }
 
-template <typename Composer>
-packed_byte_array<Composer>::packed_byte_array(Composer* parent_context, const std::string& input)
+template <typename Builder>
+packed_byte_array<Builder>::packed_byte_array(Builder* parent_context, const std::string& input)
     : packed_byte_array(parent_context, std::vector<uint8_t>(input.begin(), input.end()))
 {}
 
-template <typename Composer>
-packed_byte_array<Composer>::packed_byte_array(const packed_byte_array& other)
+template <typename Builder>
+packed_byte_array<Builder>::packed_byte_array(const packed_byte_array& other)
     : context(other.context)
     , num_bytes(other.num_bytes)
     , limbs(other.limbs.begin(), other.limbs.end())
 {}
 
-template <typename Composer>
-packed_byte_array<Composer>::packed_byte_array(packed_byte_array&& other)
+template <typename Builder>
+packed_byte_array<Builder>::packed_byte_array(packed_byte_array&& other)
     : context(other.context)
     , num_bytes(other.num_bytes)
     , limbs(other.limbs.begin(), other.limbs.end())
 {}
 
-template <typename Composer>
-packed_byte_array<Composer>& packed_byte_array<Composer>::operator=(const packed_byte_array& other)
+template <typename Builder>
+packed_byte_array<Builder>& packed_byte_array<Builder>::operator=(const packed_byte_array& other)
 {
     context = other.context;
     num_bytes = other.num_bytes;
@@ -127,8 +127,7 @@ packed_byte_array<Composer>& packed_byte_array<Composer>::operator=(const packed
     return *this;
 }
 
-template <typename Composer>
-packed_byte_array<Composer>& packed_byte_array<Composer>::operator=(packed_byte_array&& other)
+template <typename Builder> packed_byte_array<Builder>& packed_byte_array<Builder>::operator=(packed_byte_array&& other)
 {
     context = other.context;
     num_bytes = other.num_bytes;
@@ -136,8 +135,8 @@ packed_byte_array<Composer>& packed_byte_array<Composer>::operator=(packed_byte_
     return *this;
 }
 
-template <typename Composer>
-packed_byte_array<Composer> packed_byte_array<Composer>::from_field_element_vector(const std::vector<field_pt>& input)
+template <typename Builder>
+packed_byte_array<Builder> packed_byte_array<Builder>::from_field_element_vector(const std::vector<field_pt>& input)
 {
     packed_byte_array result(get_context_from_fields(input), input.size() * 32);
 
@@ -154,7 +153,7 @@ packed_byte_array<Composer> packed_byte_array<Composer>::from_field_element_vect
     return result;
 }
 
-template <typename Composer> packed_byte_array<Composer>::operator byte_array_pt() const
+template <typename Builder> packed_byte_array<Builder>::operator byte_array_pt() const
 {
     std::vector<field_pt> bytes;
 
@@ -175,8 +174,8 @@ template <typename Composer> packed_byte_array<Composer>::operator byte_array_pt
     return byte_array_pt(context, bytes);
 }
 
-template <typename Composer>
-void packed_byte_array<Composer>::append(const field_pt& to_append, const size_t bytes_to_append)
+template <typename Builder>
+void packed_byte_array<Builder>::append(const field_pt& to_append, const size_t bytes_to_append)
 {
     const size_t current_capacity = limbs.size() * BYTES_PER_ELEMENT;
     const size_t current_size = size();
@@ -219,9 +218,8 @@ void packed_byte_array<Composer>::append(const field_pt& to_append, const size_t
     num_bytes += bytes_to_append;
 }
 
-template <typename Composer>
-std::vector<field_t<Composer>> packed_byte_array<Composer>::to_unverified_byte_slices(
-    const size_t bytes_per_slice) const
+template <typename Builder>
+std::vector<field_t<Builder>> packed_byte_array<Builder>::to_unverified_byte_slices(const size_t bytes_per_slice) const
 {
     std::vector<field_pt> slices;
     for (size_t i = 0; i < limbs.size(); ++i) {
@@ -251,7 +249,7 @@ std::vector<field_t<Composer>> packed_byte_array<Composer>::to_unverified_byte_s
     return slices;
 }
 
-template <typename Composer> std::string packed_byte_array<Composer>::get_value() const
+template <typename Builder> std::string packed_byte_array<Builder>::get_value() const
 {
     std::string bytes(num_bytes, 0);
     for (size_t i = 0; i < limbs.size(); ++i) {
diff --git a/barretenberg/cpp/src/barretenberg/stdlib/primitives/packed_byte_array/packed_byte_array.hpp b/barretenberg/cpp/src/barretenberg/stdlib/primitives/packed_byte_array/packed_byte_array.hpp
index a59cab0f8b0..78cd286859f 100644
--- a/barretenberg/cpp/src/barretenberg/stdlib/primitives/packed_byte_array/packed_byte_array.hpp
+++ b/barretenberg/cpp/src/barretenberg/stdlib/primitives/packed_byte_array/packed_byte_array.hpp
@@ -7,21 +7,21 @@
 namespace proof_system::plonk {
 namespace stdlib {
 
-template <typename Composer> class packed_byte_array {
+template <typename Builder> class packed_byte_array {
   private:
-    typedef field_t<Composer> field_pt;
-    typedef witness_t<Composer> witness_pt;
-    typedef bool_t<Composer> bool_pt;
-    typedef byte_array<Composer> byte_array_pt;
+    typedef field_t<Builder> field_pt;
+    typedef witness_t<Builder> witness_pt;
+    typedef bool_t<Builder> bool_pt;
+    typedef byte_array<Builder> byte_array_pt;
 
   public:
-    packed_byte_array(Composer* parent_context, size_t const num_bytes = 0);
+    packed_byte_array(Builder* parent_context, size_t const num_bytes = 0);
 
     // THIS CTOR ASSUMES INPUT ELEMENTS HAVE ALREADY BEEN REDUCED TO <16 BYTES PER ELEMENT
     // Use ::from_field_element_vector for raw vectors of unreduced prime field elements
     packed_byte_array(const std::vector<field_pt>& input, const size_t bytes_per_input = BYTES_PER_ELEMENT);
-    packed_byte_array(Composer* parent_context, const std::vector<uint8_t>& input);
-    packed_byte_array(Composer* parent_context, const std::string& input);
+    packed_byte_array(Builder* parent_context, const std::vector<uint8_t>& input);
+    packed_byte_array(Builder* parent_context, const std::string& input);
     packed_byte_array(const byte_array_pt& input);
 
     packed_byte_array(const packed_byte_array& other);
@@ -41,18 +41,18 @@ template <typename Composer> class packed_byte_array {
 
     size_t size() const { return num_bytes; }
 
-    Composer* get_context() const { return context; }
+    Builder* get_context() const { return context; }
 
     std::string get_value() const;
 
   private:
     static constexpr uint64_t BYTES_PER_ELEMENT = 16;
-    Composer* context;
+    Builder* context;
     size_t num_bytes;
     std::vector<field_pt> limbs;
 };
 
-template <typename Composer> inline std::ostream& operator<<(std::ostream& os, packed_byte_array<Composer> const& arr)
+template <typename Builder> inline std::ostream& operator<<(std::ostream& os, packed_byte_array<Builder> const& arr)
 {
     std::ios_base::fmtflags f(os.flags());
     os << "[" << std::hex << std::setfill('0');
diff --git a/barretenberg/cpp/src/barretenberg/stdlib/primitives/packed_byte_array/packed_byte_array.test.cpp b/barretenberg/cpp/src/barretenberg/stdlib/primitives/packed_byte_array/packed_byte_array.test.cpp
index a98be47b075..763d98fae46 100644
--- a/barretenberg/cpp/src/barretenberg/stdlib/primitives/packed_byte_array/packed_byte_array.test.cpp
+++ b/barretenberg/cpp/src/barretenberg/stdlib/primitives/packed_byte_array/packed_byte_array.test.cpp
@@ -15,11 +15,11 @@ namespace {
 auto& engine = numeric::random::get_debug_engine();
 }
 #define STDLIB_TYPE_ALIASES                                                                                            \
-    using Composer = TypeParam;                                                                                        \
-    using packed_byte_array_ct = stdlib::packed_byte_array<Composer>;                                                  \
-    using byte_array_ct = stdlib::byte_array<Composer>;
+    using Builder = TypeParam;                                                                                         \
+    using packed_byte_array_ct = stdlib::packed_byte_array<Builder>;                                                   \
+    using byte_array_ct = stdlib::byte_array<Builder>;
 
-template <class Composer> class PackedByteArrayTest : public ::testing::Test {};
+template <class Builder> class PackedByteArrayTest : public ::testing::Test {};
 
 using CircuitTypes = ::testing::
     Types<proof_system::StandardCircuitBuilder, proof_system::TurboCircuitBuilder, proof_system::UltraCircuitBuilder>;
@@ -28,51 +28,51 @@ TYPED_TEST_SUITE(PackedByteArrayTest, CircuitTypes);
 TYPED_TEST(PackedByteArrayTest, string_constructor_and_get_value_consistency)
 {
     STDLIB_TYPE_ALIASES
-    auto composer = Composer();
+    auto builder = Builder();
     std::string input = "the quick brown fox jumped over the lazy dog.";
 
-    packed_byte_array_ct arr(&composer, input);
+    packed_byte_array_ct arr(&builder, input);
 
     std::string output = arr.get_value();
 
     EXPECT_EQ(input, output);
 
-    EXPECT_TRUE(composer.check_circuit());
+    EXPECT_TRUE(builder.check_circuit());
 }
 
 TYPED_TEST(PackedByteArrayTest, byte_array_constructor_consistency)
 {
     STDLIB_TYPE_ALIASES
-    auto composer = Composer();
+    auto builder = Builder();
     std::string input = "the quick brown fox jumped over the lazy dog.";
 
-    byte_array_ct arr(&composer, input);
+    byte_array_ct arr(&builder, input);
     packed_byte_array_ct converted(arr);
     std::string output = converted.get_value();
 
     EXPECT_EQ(input, output);
 
-    EXPECT_TRUE(composer.check_circuit());
+    EXPECT_TRUE(builder.check_circuit());
 }
 
 TYPED_TEST(PackedByteArrayTest, byte_array_cast_consistency)
 {
     STDLIB_TYPE_ALIASES
-    auto composer = Composer();
+    auto builder = Builder();
     std::string input = "the quick brown fox jumped over the lazy dog.";
 
-    packed_byte_array_ct arr(&composer, input);
+    packed_byte_array_ct arr(&builder, input);
     byte_array_ct converted(arr);
     std::string output = converted.get_string();
 
     EXPECT_EQ(input, output);
-    EXPECT_TRUE(composer.check_circuit());
+    EXPECT_TRUE(builder.check_circuit());
 }
 
 TYPED_TEST(PackedByteArrayTest, TestUnverifiedByteSlices)
 {
     STDLIB_TYPE_ALIASES
-    auto composer = Composer();
+    auto builder = Builder();
 
     std::vector<uint8_t> bytes;
     for (size_t i = 0; i < 256; ++i) {
@@ -86,7 +86,7 @@ TYPED_TEST(PackedByteArrayTest, TestUnverifiedByteSlices)
         uint32s.push_back(result);
     }
 
-    packed_byte_array_ct arr(&composer, bytes);
+    packed_byte_array_ct arr(&builder, bytes);
 
     const auto result_elements = arr.to_unverified_byte_slices(4);
 
@@ -95,13 +95,13 @@ TYPED_TEST(PackedByteArrayTest, TestUnverifiedByteSlices)
         EXPECT_EQ(result, uint32s[i]);
     }
 
-    EXPECT_TRUE(composer.check_circuit());
+    EXPECT_TRUE(builder.check_circuit());
 }
 
 TYPED_TEST(PackedByteArrayTest, TestAppendUint8)
 {
     STDLIB_TYPE_ALIASES
-    auto composer = Composer();
+    auto builder = Builder();
     std::vector<uint8_t> bytes;
     const size_t initial_size = 100;
     auto floor = 1UL << numeric::get_msb(initial_size);
@@ -110,7 +110,7 @@ TYPED_TEST(PackedByteArrayTest, TestAppendUint8)
     for (size_t i = 0; i < initial_size; ++i) {
         bytes.push_back(engine.get_random_uint8());
     }
-    packed_byte_array_ct arr(&composer, bytes);
+    packed_byte_array_ct arr(&builder, bytes);
 
     // append upto size (16x)
     size_t num_bytes_to_append = next_pow_2 - initial_size;
@@ -145,13 +145,13 @@ TYPED_TEST(PackedByteArrayTest, TestAppendUint8)
         EXPECT_EQ(result, bytes[i]);
     }
 
-    EXPECT_TRUE(composer.check_circuit());
+    EXPECT_TRUE(builder.check_circuit());
 }
 
 TYPED_TEST(PackedByteArrayTest, TestAppendUint32)
 {
     STDLIB_TYPE_ALIASES
-    auto composer = Composer();
+    auto builder = Builder();
     std::vector<uint8_t> bytes;
     const size_t initial_size = 100;
     auto floor = 1UL << numeric::get_msb(initial_size);
@@ -167,7 +167,7 @@ TYPED_TEST(PackedByteArrayTest, TestAppendUint32)
                           ((uint32_t)bytes[i * 4 + 2] << 8) + ((uint32_t)bytes[i * 4 + 3]);
         uint32s.push_back(result);
     }
-    packed_byte_array_ct arr(&composer, bytes);
+    packed_byte_array_ct arr(&builder, bytes);
 
     // append over size (16x) (this creates new limb internally)
     size_t num_bytes_to_append = 20;
@@ -194,7 +194,7 @@ TYPED_TEST(PackedByteArrayTest, TestAppendUint32)
         EXPECT_EQ(result, uint32s[i]);
     }
 
-    EXPECT_TRUE(composer.check_circuit());
+    EXPECT_TRUE(builder.check_circuit());
 }
 
 } // namespace test_stdlib_packed_byte_array
diff --git a/barretenberg/cpp/src/barretenberg/stdlib/primitives/plookup/plookup.cpp b/barretenberg/cpp/src/barretenberg/stdlib/primitives/plookup/plookup.cpp
index 2816fde8d62..2e38777318c 100644
--- a/barretenberg/cpp/src/barretenberg/stdlib/primitives/plookup/plookup.cpp
+++ b/barretenberg/cpp/src/barretenberg/stdlib/primitives/plookup/plookup.cpp
@@ -4,7 +4,7 @@
 #include "barretenberg/stdlib/primitives/circuit_builders/circuit_builders.hpp"
 
 namespace proof_system::plonk {
-class UltraPlonkComposer;
+class UltraPlonkBuilder;
 } // namespace proof_system::plonk
 
 namespace proof_system::plonk {
@@ -14,25 +14,25 @@ using plookup::ColumnIdx;
 using plookup::MultiTableId;
 using namespace barretenberg;
 
-template <typename Composer>
-plookup::ReadData<field_t<Composer>> plookup_read<Composer>::get_lookup_accumulators(const MultiTableId id,
-                                                                                     const field_t<Composer>& key_a_in,
-                                                                                     const field_t<Composer>& key_b_in,
-                                                                                     const bool is_2_to_1_lookup)
+template <typename Builder>
+plookup::ReadData<field_t<Builder>> plookup_read<Builder>::get_lookup_accumulators(const MultiTableId id,
+                                                                                   const field_t<Builder>& key_a_in,
+                                                                                   const field_t<Builder>& key_b_in,
+                                                                                   const bool is_2_to_1_lookup)
 {
     auto key_a = key_a_in.normalize();
     auto key_b = key_b_in.normalize();
-    Composer* ctx = key_a.get_context() ? key_a.get_context() : key_b.get_context();
+    Builder* ctx = key_a.get_context() ? key_a.get_context() : key_b.get_context();
     const plookup::ReadData<barretenberg::fr> lookup_data =
         plookup::get_lookup_accumulators(id, key_a.get_value(), key_b.get_value(), is_2_to_1_lookup);
 
     const bool is_key_a_constant = key_a.is_constant();
-    plookup::ReadData<field_t<Composer>> lookup;
+    plookup::ReadData<field_t<Builder>> lookup;
     if (is_key_a_constant && (key_b.is_constant() || !is_2_to_1_lookup)) {
         for (size_t i = 0; i < lookup_data[ColumnIdx::C1].size(); ++i) {
-            lookup[ColumnIdx::C1].emplace_back(field_t<Composer>(ctx, lookup_data[ColumnIdx::C1][i]));
-            lookup[ColumnIdx::C2].emplace_back(field_t<Composer>(ctx, lookup_data[ColumnIdx::C2][i]));
-            lookup[ColumnIdx::C3].emplace_back(field_t<Composer>(ctx, lookup_data[ColumnIdx::C3][i]));
+            lookup[ColumnIdx::C1].emplace_back(field_t<Builder>(ctx, lookup_data[ColumnIdx::C1][i]));
+            lookup[ColumnIdx::C2].emplace_back(field_t<Builder>(ctx, lookup_data[ColumnIdx::C2][i]));
+            lookup[ColumnIdx::C3].emplace_back(field_t<Builder>(ctx, lookup_data[ColumnIdx::C3][i]));
         }
     } else {
         uint32_t lhs_index = key_a.witness_index;
@@ -54,37 +54,37 @@ plookup::ReadData<field_t<Composer>> plookup_read<Composer>::get_lookup_accumula
 
         for (size_t i = 0; i < lookup_data[ColumnIdx::C1].size(); ++i) {
             lookup[ColumnIdx::C1].emplace_back(
-                field_t<Composer>::from_witness_index(ctx, accumulator_witnesses[ColumnIdx::C1][i]));
+                field_t<Builder>::from_witness_index(ctx, accumulator_witnesses[ColumnIdx::C1][i]));
             lookup[ColumnIdx::C2].emplace_back(
-                field_t<Composer>::from_witness_index(ctx, accumulator_witnesses[ColumnIdx::C2][i]));
+                field_t<Builder>::from_witness_index(ctx, accumulator_witnesses[ColumnIdx::C2][i]));
             lookup[ColumnIdx::C3].emplace_back(
-                field_t<Composer>::from_witness_index(ctx, accumulator_witnesses[ColumnIdx::C3][i]));
+                field_t<Builder>::from_witness_index(ctx, accumulator_witnesses[ColumnIdx::C3][i]));
         }
     }
     return lookup;
 }
 
-template <typename Composer>
-std::pair<field_t<Composer>, field_t<Composer>> plookup_read<Composer>::read_pair_from_table(
-    const MultiTableId id, const field_t<Composer>& key)
+template <typename Builder>
+std::pair<field_t<Builder>, field_t<Builder>> plookup_read<Builder>::read_pair_from_table(const MultiTableId id,
+                                                                                          const field_t<Builder>& key)
 {
     const auto lookup = get_lookup_accumulators(id, key);
 
     return { lookup[ColumnIdx::C2][0], lookup[ColumnIdx::C3][0] };
 }
 
-template <typename Composer>
-field_t<Composer> plookup_read<Composer>::read_from_2_to_1_table(const MultiTableId id,
-                                                                 const field_t<Composer>& key_a,
-                                                                 const field_t<Composer>& key_b)
+template <typename Builder>
+field_t<Builder> plookup_read<Builder>::read_from_2_to_1_table(const MultiTableId id,
+                                                               const field_t<Builder>& key_a,
+                                                               const field_t<Builder>& key_b)
 {
     const auto lookup = get_lookup_accumulators(id, key_a, key_b, true);
 
     return lookup[ColumnIdx::C3][0];
 }
 
-template <typename Composer>
-field_t<Composer> plookup_read<Composer>::read_from_1_to_2_table(const MultiTableId id, const field_t<Composer>& key_a)
+template <typename Builder>
+field_t<Builder> plookup_read<Builder>::read_from_1_to_2_table(const MultiTableId id, const field_t<Builder>& key_a)
 {
     const auto lookup = get_lookup_accumulators(id, key_a);
 
diff --git a/barretenberg/cpp/src/barretenberg/stdlib/primitives/plookup/plookup.hpp b/barretenberg/cpp/src/barretenberg/stdlib/primitives/plookup/plookup.hpp
index 589c09133d9..260ef8f737a 100644
--- a/barretenberg/cpp/src/barretenberg/stdlib/primitives/plookup/plookup.hpp
+++ b/barretenberg/cpp/src/barretenberg/stdlib/primitives/plookup/plookup.hpp
@@ -9,8 +9,8 @@
 namespace proof_system::plonk {
 namespace stdlib {
 
-template <typename Composer> class plookup_read {
-    typedef field_t<Composer> field_pt;
+template <typename Builder> class plookup_read {
+    typedef field_t<Builder> field_pt;
 
   public:
     static std::pair<field_pt, field_pt> read_pair_from_table(const plookup::MultiTableId id, const field_pt& key);
diff --git a/barretenberg/cpp/src/barretenberg/stdlib/primitives/plookup/plookup.test.cpp b/barretenberg/cpp/src/barretenberg/stdlib/primitives/plookup/plookup.test.cpp
index 86765bbcd06..0dd0b1477f0 100644
--- a/barretenberg/cpp/src/barretenberg/stdlib/primitives/plookup/plookup.test.cpp
+++ b/barretenberg/cpp/src/barretenberg/stdlib/primitives/plookup/plookup.test.cpp
@@ -16,21 +16,21 @@ using namespace proof_system::plonk;
 using namespace plookup;
 
 // Defining ultra-specific types for local testing.
-using Composer = proof_system::UltraCircuitBuilder;
-using field_ct = stdlib::field_t<Composer>;
-using witness_ct = stdlib::witness_t<Composer>;
-using plookup_read = proof_system::plonk::stdlib::plookup_read<Composer>;
+using Builder = proof_system::UltraCircuitBuilder;
+using field_ct = stdlib::field_t<Builder>;
+using witness_ct = stdlib::witness_t<Builder>;
+using plookup_read = proof_system::plonk::stdlib::plookup_read<Builder>;
 namespace {
 auto& engine = numeric::random::get_debug_engine();
 }
 
 TEST(stdlib_plookup, pedersen_lookup_left)
 {
-    Composer composer = Composer();
+    Builder builder = Builder();
 
     barretenberg::fr input_value = fr::random_element();
-    field_ct input_hi = witness_ct(&composer, uint256_t(input_value).slice(126, 256));
-    field_ct input_lo = witness_ct(&composer, uint256_t(input_value).slice(0, 126));
+    field_ct input_hi = witness_ct(&builder, uint256_t(input_value).slice(126, 256));
+    field_ct input_lo = witness_ct(&builder, uint256_t(input_value).slice(0, 126));
 
     const auto lookup_hi = plookup_read::get_lookup_accumulators(MultiTableId::PEDERSEN_LEFT_HI, input_hi);
     const auto lookup_lo = plookup_read::get_lookup_accumulators(MultiTableId::PEDERSEN_LEFT_LO, input_lo);
@@ -95,18 +95,18 @@ TEST(stdlib_plookup, pedersen_lookup_left)
         EXPECT_EQ(lookup_hi[ColumnIdx::C3][i].get_value(), expected_y[i + num_lookups_lo]);
     }
 
-    bool result = composer.check_circuit();
+    bool result = builder.check_circuit();
 
     EXPECT_EQ(result, true);
 }
 
 TEST(stdlib_plookup, pedersen_lookup_right)
 {
-    Composer composer = Composer();
+    Builder builder = Builder();
 
     barretenberg::fr input_value = fr::random_element();
-    field_ct input_hi = witness_ct(&composer, uint256_t(input_value).slice(126, 256));
-    field_ct input_lo = witness_ct(&composer, uint256_t(input_value).slice(0, 126));
+    field_ct input_hi = witness_ct(&builder, uint256_t(input_value).slice(126, 256));
+    field_ct input_lo = witness_ct(&builder, uint256_t(input_value).slice(0, 126));
 
     const auto lookup_hi = plookup_read::get_lookup_accumulators(MultiTableId::PEDERSEN_RIGHT_HI, input_hi);
     const auto lookup_lo = plookup_read::get_lookup_accumulators(MultiTableId::PEDERSEN_RIGHT_LO, input_lo);
@@ -171,22 +171,22 @@ TEST(stdlib_plookup, pedersen_lookup_right)
         EXPECT_EQ(lookup_hi[ColumnIdx::C3][i].get_value(), expected_y[i + num_lookups_lo]);
     }
 
-    bool result = composer.check_circuit();
+    bool result = builder.check_circuit();
 
     EXPECT_EQ(result, true);
 }
 
 TEST(stdlib_plookup, uint32_xor)
 {
-    Composer composer = Composer();
+    Builder builder = Builder();
 
     const size_t num_lookups = (32 + 5) / 6;
 
     uint256_t left_value = (engine.get_random_uint256() & 0xffffffffULL);
     uint256_t right_value = (engine.get_random_uint256() & 0xffffffffULL);
 
-    field_ct left = witness_ct(&composer, barretenberg::fr(left_value));
-    field_ct right = witness_ct(&composer, barretenberg::fr(right_value));
+    field_ct left = witness_ct(&builder, barretenberg::fr(left_value));
+    field_ct right = witness_ct(&builder, barretenberg::fr(right_value));
 
     const auto lookup = plookup_read::get_lookup_accumulators(MultiTableId::UINT32_XOR, left, right, true);
 
@@ -215,22 +215,22 @@ TEST(stdlib_plookup, uint32_xor)
         EXPECT_EQ(lookup[ColumnIdx::C3][i].get_value(), barretenberg::fr(out_expected[i]));
     }
 
-    bool result = composer.check_circuit();
+    bool result = builder.check_circuit();
 
     EXPECT_EQ(result, true);
 }
 
 TEST(stdlib_plookup, blake2s_xor_rotate_16)
 {
-    Composer composer = Composer();
+    Builder builder = Builder();
 
     const size_t num_lookups = 6;
 
     uint256_t left_value = (engine.get_random_uint256() & 0xffffffffULL);
     uint256_t right_value = (engine.get_random_uint256() & 0xffffffffULL);
 
-    field_ct left = witness_ct(&composer, barretenberg::fr(left_value));
-    field_ct right = witness_ct(&composer, barretenberg::fr(right_value));
+    field_ct left = witness_ct(&builder, barretenberg::fr(left_value));
+    field_ct right = witness_ct(&builder, barretenberg::fr(right_value));
 
     const auto lookup = plookup_read::get_lookup_accumulators(MultiTableId::BLAKE_XOR_ROTATE_16, left, right, true);
 
@@ -286,22 +286,22 @@ TEST(stdlib_plookup, blake2s_xor_rotate_16)
     uint32_t xor_rotate_output = numeric::rotate32(uint32_t(left_value) ^ uint32_t(right_value), 16);
     EXPECT_EQ(barretenberg::fr(uint256_t(xor_rotate_output)), lookup_output);
 
-    bool result = composer.check_circuit();
+    bool result = builder.check_circuit();
 
     EXPECT_EQ(result, true);
 }
 
 TEST(stdlib_plookup, blake2s_xor_rotate_8)
 {
-    Composer composer = Composer();
+    Builder builder = Builder();
 
     const size_t num_lookups = 6;
 
     uint256_t left_value = (engine.get_random_uint256() & 0xffffffffULL);
     uint256_t right_value = (engine.get_random_uint256() & 0xffffffffULL);
 
-    field_ct left = witness_ct(&composer, barretenberg::fr(left_value));
-    field_ct right = witness_ct(&composer, barretenberg::fr(right_value));
+    field_ct left = witness_ct(&builder, barretenberg::fr(left_value));
+    field_ct right = witness_ct(&builder, barretenberg::fr(right_value));
 
     const auto lookup = plookup_read::get_lookup_accumulators(MultiTableId::BLAKE_XOR_ROTATE_8, left, right, true);
 
@@ -346,22 +346,22 @@ TEST(stdlib_plookup, blake2s_xor_rotate_8)
     uint32_t xor_rotate_output = numeric::rotate32(uint32_t(left_value) ^ uint32_t(right_value), 8);
     EXPECT_EQ(barretenberg::fr(uint256_t(xor_rotate_output)), lookup_output);
 
-    bool result = composer.check_circuit();
+    bool result = builder.check_circuit();
 
     EXPECT_EQ(result, true);
 }
 
 TEST(stdlib_plookup, blake2s_xor_rotate_7)
 {
-    Composer composer = Composer();
+    Builder builder = Builder();
 
     const size_t num_lookups = 6;
 
     uint256_t left_value = (engine.get_random_uint256() & 0xffffffffULL);
     uint256_t right_value = (engine.get_random_uint256() & 0xffffffffULL);
 
-    field_ct left = witness_ct(&composer, barretenberg::fr(left_value));
-    field_ct right = witness_ct(&composer, barretenberg::fr(right_value));
+    field_ct left = witness_ct(&builder, barretenberg::fr(left_value));
+    field_ct right = witness_ct(&builder, barretenberg::fr(right_value));
 
     const auto lookup = plookup_read::get_lookup_accumulators(MultiTableId::BLAKE_XOR_ROTATE_7, left, right, true);
 
@@ -406,22 +406,22 @@ TEST(stdlib_plookup, blake2s_xor_rotate_7)
     uint32_t xor_rotate_output = numeric::rotate32(uint32_t(left_value) ^ uint32_t(right_value), 7);
     EXPECT_EQ(barretenberg::fr(uint256_t(xor_rotate_output)), lookup_output);
 
-    bool result = composer.check_circuit();
+    bool result = builder.check_circuit();
 
     EXPECT_EQ(result, true);
 }
 
 TEST(stdlib_plookup, blake2s_xor)
 {
-    Composer composer = Composer();
+    Builder builder = Builder();
 
     const size_t num_lookups = 6;
 
     uint256_t left_value = (engine.get_random_uint256() & 0xffffffffULL);
     uint256_t right_value = (engine.get_random_uint256() & 0xffffffffULL);
 
-    field_ct left = witness_ct(&composer, barretenberg::fr(left_value));
-    field_ct right = witness_ct(&composer, barretenberg::fr(right_value));
+    field_ct left = witness_ct(&builder, barretenberg::fr(left_value));
+    field_ct right = witness_ct(&builder, barretenberg::fr(right_value));
 
     const auto lookup = plookup_read::get_lookup_accumulators(MultiTableId::BLAKE_XOR, left, right, true);
 
@@ -469,22 +469,22 @@ TEST(stdlib_plookup, blake2s_xor)
         EXPECT_EQ(lookup[ColumnIdx::C3][i].get_value(), barretenberg::fr(out_expected[i]));
     }
 
-    bool result = composer.check_circuit();
+    bool result = builder.check_circuit();
 
     EXPECT_EQ(result, true);
 }
 
 TEST(stdlib_plookup, uint32_and)
 {
-    Composer composer = Composer();
+    Builder builder = Builder();
 
     const size_t num_lookups = (32 + 5) / 6;
 
     uint256_t left_value = (engine.get_random_uint256() & 0xffffffffULL);
     uint256_t right_value = (engine.get_random_uint256() & 0xffffffffULL);
 
-    field_ct left = witness_ct(&composer, barretenberg::fr(left_value));
-    field_ct right = witness_ct(&composer, barretenberg::fr(right_value));
+    field_ct left = witness_ct(&builder, barretenberg::fr(left_value));
+    field_ct right = witness_ct(&builder, barretenberg::fr(right_value));
 
     const auto lookup = plookup_read::get_lookup_accumulators(MultiTableId::UINT32_AND, left, right, true);
     const auto left_slices = numeric::slice_input(left_value, 1 << 6, num_lookups);
@@ -511,15 +511,15 @@ TEST(stdlib_plookup, uint32_and)
         EXPECT_EQ(lookup[ColumnIdx::C3][i].get_value(), barretenberg::fr(out_expected[i]));
     }
 
-    bool result = composer.check_circuit();
+    bool result = builder.check_circuit();
 
     EXPECT_EQ(result, true);
 }
 
 TEST(stdlib_plookup, secp256k1_generator)
 {
-    using curve = stdlib::secp256k1<Composer>;
-    Composer composer = Composer();
+    using curve = stdlib::secp256k1<Builder>;
+    Builder builder = Builder();
 
     uint256_t input_value = (engine.get_random_uint256() >> 128);
 
@@ -541,7 +541,7 @@ TEST(stdlib_plookup, secp256k1_generator)
 
     std::vector<field_ct> circuit_naf_values;
     for (size_t i = 0; i < naf_values.size(); ++i) {
-        circuit_naf_values.emplace_back(witness_ct(&composer, naf_values[i]));
+        circuit_naf_values.emplace_back(witness_ct(&builder, naf_values[i]));
     }
 
     std::vector<field_ct> accumulators;
@@ -554,7 +554,7 @@ TEST(stdlib_plookup, secp256k1_generator)
     EXPECT_EQ(accumulator_field.get_value(), barretenberg::fr(input_value) + barretenberg::fr(skew));
 
     for (size_t i = 0; i < 256; ++i) {
-        field_ct index(witness_ct(&composer, barretenberg::fr(i)));
+        field_ct index(witness_ct(&builder, barretenberg::fr(i)));
         const auto xlo = plookup_read::read_pair_from_table(MultiTableId::SECP256K1_XLO, index);
         const auto xhi = plookup_read::read_pair_from_table(MultiTableId::SECP256K1_XHI, index);
         const auto ylo = plookup_read::read_pair_from_table(MultiTableId::SECP256K1_YLO, index);
@@ -600,14 +600,14 @@ TEST(stdlib_plookup, secp256k1_generator)
     }
 
     if (skew) {
-        accumulator = accumulator - curve::g1_ct::one(&composer);
+        accumulator = accumulator - curve::g1_ct::one(&builder);
     }
 
     curve::g1::affine_element result = accumulator.get_value();
     curve::g1::affine_element expected(curve::g1::one * input_value);
     EXPECT_EQ(result, expected);
 
-    bool proof_result = composer.check_circuit();
+    bool proof_result = builder.check_circuit();
     EXPECT_EQ(proof_result, true);
 }
 
diff --git a/barretenberg/cpp/src/barretenberg/stdlib/primitives/point/point.hpp b/barretenberg/cpp/src/barretenberg/stdlib/primitives/point/point.hpp
index c61756ac89c..4dfe0487a37 100644
--- a/barretenberg/cpp/src/barretenberg/stdlib/primitives/point/point.hpp
+++ b/barretenberg/cpp/src/barretenberg/stdlib/primitives/point/point.hpp
@@ -7,15 +7,15 @@
 namespace proof_system::plonk {
 namespace stdlib {
 
-template <typename Composer> struct point {
-    field_t<Composer> x;
-    field_t<Composer> y;
+template <typename Builder> struct point {
+    field_t<Builder> x;
+    field_t<Builder> y;
 
     void set_public()
     {
-        auto composer = x.context;
-        composer->set_public_input(x.witness_index);
-        composer->set_public_input(y.witness_index);
+        auto builder = x.context;
+        builder->set_public_input(x.witness_index);
+        builder->set_public_input(y.witness_index);
     }
 
     void assert_equal(const point& rhs, std::string const& msg = "point::assert_equal") const
@@ -36,40 +36,40 @@ template <typename Composer> struct point {
     {
         const auto lhs_eq = this->x == rhs.x;
         const auto rhs_eq = this->y == rhs.y;
-        field_t<Composer>(lhs_eq && rhs_eq).assert_is_zero(msg);
+        field_t<Builder>(lhs_eq && rhs_eq).assert_is_zero(msg);
     }
 
-    static point conditional_assign(const bool_t<Composer>& predicate, const point& lhs, const point& rhs)
+    static point conditional_assign(const bool_t<Builder>& predicate, const point& lhs, const point& rhs)
     {
-        return { field_t<Composer>::conditional_assign(predicate, lhs.x, rhs.x),
-                 field_t<Composer>::conditional_assign(predicate, lhs.y, rhs.y) };
+        return { field_t<Builder>::conditional_assign(predicate, lhs.x, rhs.x),
+                 field_t<Builder>::conditional_assign(predicate, lhs.y, rhs.y) };
     };
 
-    bool_t<Composer> operator==(const point& other) const { return (this->x == other.x) && (this->y == other.y); }
+    bool_t<Builder> operator==(const point& other) const { return (this->x == other.x) && (this->y == other.y); }
 
-    point<Composer> operator+(const point& other) const
+    point<Builder> operator+(const point& other) const
     {
-        const field_t<Composer>& x1 = this->x;
-        const field_t<Composer>& y1 = this->y;
+        const field_t<Builder>& x1 = this->x;
+        const field_t<Builder>& y1 = this->y;
 
-        const field_t<Composer>& x2 = other.x;
-        const field_t<Composer>& y2 = other.y;
+        const field_t<Builder>& x2 = other.x;
+        const field_t<Builder>& y2 = other.y;
 
-        const field_t<Composer> lambda = (y2 - y1) / (x2 - x1);
-        const field_t<Composer> x3 = lambda * lambda - x2 - x1;
-        const field_t<Composer> y3 = lambda * (x1 - x3) - y1;
+        const field_t<Builder> lambda = (y2 - y1) / (x2 - x1);
+        const field_t<Builder> x3 = lambda * lambda - x2 - x1;
+        const field_t<Builder> y3 = lambda * (x1 - x3) - y1;
 
         return { x3, y3 };
     }
 };
 
-template <typename Composer, typename E>
-point<Composer> create_point_witness(Composer& composer, E const& p, const bool validate_on_curve = true)
+template <typename Builder, typename E>
+point<Builder> create_point_witness(Builder& builder, E const& p, const bool validate_on_curve = true)
 {
     // validate point is on the grumpkin curve
-    field_t<Composer> x(witness_t<Composer>(&composer, p.x));
-    field_t<Composer> y(witness_t<Composer>(&composer, p.y));
-    point<Composer> result = { x, y };
+    field_t<Builder> x(witness_t<Builder>(&builder, p.x));
+    field_t<Builder> y(witness_t<Builder>(&builder, p.y));
+    point<Builder> result = { x, y };
 
     // we need to disable this for when we are conditionally creating a point (e.g. account output note spending keys)
     if (validate_on_curve) {
@@ -78,7 +78,7 @@ point<Composer> create_point_witness(Composer& composer, E const& p, const bool
     return { x, y };
 }
 
-template <typename Composer> std::ostream& operator<<(std::ostream& os, point<Composer> const& p)
+template <typename Builder> std::ostream& operator<<(std::ostream& os, point<Builder> const& p)
 {
     return os << "{ " << p.x << ", " << p.y << " }";
 }
diff --git a/barretenberg/cpp/src/barretenberg/stdlib/primitives/safe_uint/safe_uint.cpp b/barretenberg/cpp/src/barretenberg/stdlib/primitives/safe_uint/safe_uint.cpp
index ce07f16a27f..da119ef1712 100644
--- a/barretenberg/cpp/src/barretenberg/stdlib/primitives/safe_uint/safe_uint.cpp
+++ b/barretenberg/cpp/src/barretenberg/stdlib/primitives/safe_uint/safe_uint.cpp
@@ -6,15 +6,14 @@
 namespace proof_system::plonk {
 namespace stdlib {
 
-template <typename ComposerContext>
+template <typename Builder>
 
-safe_uint_t<ComposerContext> safe_uint_t<ComposerContext>::operator+(const safe_uint_t& other) const
+safe_uint_t<Builder> safe_uint_t<Builder>::operator+(const safe_uint_t& other) const
 {
     return safe_uint_t((value + other.value), current_max + other.current_max, IS_UNSAFE);
 }
 
-template <typename ComposerContext>
-safe_uint_t<ComposerContext> safe_uint_t<ComposerContext>::operator*(const safe_uint_t& other) const
+template <typename Builder> safe_uint_t<Builder> safe_uint_t<Builder>::operator*(const safe_uint_t& other) const
 {
 
     uint512_t new_max = uint512_t(current_max) * uint512_t(other.current_max);
@@ -22,51 +21,48 @@ safe_uint_t<ComposerContext> safe_uint_t<ComposerContext>::operator*(const safe_
     return safe_uint_t((value * other.value), new_max.lo, IS_UNSAFE);
 }
 
-template <typename ComposerContext> safe_uint_t<ComposerContext> safe_uint_t<ComposerContext>::normalize() const
+template <typename Builder> safe_uint_t<Builder> safe_uint_t<Builder>::normalize() const
 {
     auto norm_value = value.normalize();
     return safe_uint_t(norm_value, current_max, IS_UNSAFE);
 }
 
-template <typename ComposerContext> void safe_uint_t<ComposerContext>::assert_is_zero(std::string const& msg) const
+template <typename Builder> void safe_uint_t<Builder>::assert_is_zero(std::string const& msg) const
 {
     value.assert_is_zero(msg);
 }
 
-template <typename ComposerContext> void safe_uint_t<ComposerContext>::assert_is_not_zero(std::string const& msg) const
+template <typename Builder> void safe_uint_t<Builder>::assert_is_not_zero(std::string const& msg) const
 {
     value.assert_is_not_zero(msg);
 }
 
-template <typename ComposerContext> bool_t<ComposerContext> safe_uint_t<ComposerContext>::is_zero() const
+template <typename Builder> bool_t<Builder> safe_uint_t<Builder>::is_zero() const
 {
     return value.is_zero();
 }
 
-template <typename ComposerContext> barretenberg::fr safe_uint_t<ComposerContext>::get_value() const
+template <typename Builder> barretenberg::fr safe_uint_t<Builder>::get_value() const
 {
     return value.get_value();
 }
 
-template <typename ComposerContext>
-bool_t<ComposerContext> safe_uint_t<ComposerContext>::operator==(const safe_uint_t& other) const
+template <typename Builder> bool_t<Builder> safe_uint_t<Builder>::operator==(const safe_uint_t& other) const
 {
     return value == other.value;
 }
 
-template <typename ComposerContext>
-bool_t<ComposerContext> safe_uint_t<ComposerContext>::operator!=(const safe_uint_t& other) const
+template <typename Builder> bool_t<Builder> safe_uint_t<Builder>::operator!=(const safe_uint_t& other) const
 {
     return !operator==(other);
 }
-template <typename ComposerContext>
-std::array<safe_uint_t<ComposerContext>, 3> safe_uint_t<ComposerContext>::slice(const uint8_t msb,
-                                                                                const uint8_t lsb) const
+template <typename Builder>
+std::array<safe_uint_t<Builder>, 3> safe_uint_t<Builder>::slice(const uint8_t msb, const uint8_t lsb) const
 {
     ASSERT(msb >= lsb);
     ASSERT(static_cast<size_t>(msb) <= grumpkin::MAX_NO_WRAP_INTEGER_BIT_LENGTH);
     const safe_uint_t lhs = *this;
-    ComposerContext* ctx = lhs.get_context();
+    Builder* ctx = lhs.get_context();
 
     const uint256_t value = uint256_t(get_value());
     // This should be caught by the proof itself, but the circuit creator will have now way of knowing where the issue
diff --git a/barretenberg/cpp/src/barretenberg/stdlib/primitives/safe_uint/safe_uint.fuzzer.hpp b/barretenberg/cpp/src/barretenberg/stdlib/primitives/safe_uint/safe_uint.fuzzer.hpp
index c1fc716935e..2242f273905 100644
--- a/barretenberg/cpp/src/barretenberg/stdlib/primitives/safe_uint/safe_uint.fuzzer.hpp
+++ b/barretenberg/cpp/src/barretenberg/stdlib/primitives/safe_uint/safe_uint.fuzzer.hpp
@@ -108,13 +108,13 @@ FastRandom VarianceRNG(0);
  * @brief The class parametrizing SafeUint fuzzing instructions, execution, etc
  *
  */
-template <typename Composer> class SafeUintFuzzBase {
+template <typename Builder> class SafeUintFuzzBase {
   private:
-    typedef proof_system::plonk::stdlib::bool_t<Composer> bool_t;
-    typedef proof_system::plonk::stdlib::field_t<Composer> field_t;
-    typedef proof_system::plonk::stdlib::safe_uint_t<Composer> suint_t;
-    typedef proof_system::plonk::stdlib::witness_t<Composer> witness_t;
-    typedef proof_system::plonk::stdlib::public_witness_t<Composer> public_witness_t;
+    typedef proof_system::plonk::stdlib::bool_t<Builder> bool_t;
+    typedef proof_system::plonk::stdlib::field_t<Builder> field_t;
+    typedef proof_system::plonk::stdlib::safe_uint_t<Builder> suint_t;
+    typedef proof_system::plonk::stdlib::witness_t<Builder> witness_t;
+    typedef proof_system::plonk::stdlib::public_witness_t<Builder> public_witness_t;
 
   public:
     /**
@@ -704,16 +704,16 @@ template <typename Composer> class SafeUintFuzzBase {
         /**
          * @brief Execute the constant instruction (push constant safeuint to the stack)
          *
-         * @param composer
+         * @param builder
          * @param stack
          * @param instruction
          * @return 0 if everything is ok, 1 if we should stop execution, since an expected error was encountered
          */
-        static inline size_t execute_CONSTANT(Composer* composer,
+        static inline size_t execute_CONSTANT(Builder* builder,
                                               std::vector<ExecutionHandler>& stack,
                                               Instruction& instruction)
         {
-            (void)composer;
+            (void)builder;
             stack.push_back(suint_t(instruction.arguments.element.value));
 #ifdef SHOW_INFORMATION
             std::cout << "Pushed constant value " << instruction.arguments.element.value << " to position "
@@ -725,12 +725,12 @@ template <typename Composer> class SafeUintFuzzBase {
         /**
          * @brief Execute the witness instruction (push witness safeuit to the stack)
          *
-         * @param composer
+         * @param builder
          * @param stack
          * @param instruction
          * @return if everything is ok, 1 if we should stop execution, since an expected error was encountered
          */
-        static inline size_t execute_WITNESS(Composer* composer,
+        static inline size_t execute_WITNESS(Builder* builder,
                                              std::vector<ExecutionHandler>& stack,
                                              Instruction& instruction)
         {
@@ -745,7 +745,7 @@ template <typename Composer> class SafeUintFuzzBase {
                 circuit_should_fail = true;
             }
 
-            stack.push_back(suint_t(witness_t(composer, instruction.arguments.element.value),
+            stack.push_back(suint_t(witness_t(builder, instruction.arguments.element.value),
                                     instruction.arguments.element.bit_range));
 #ifdef SHOW_INFORMATION
             std::cout << "Pushed witness value " << instruction.arguments.element.value << " < 2^" << (size_t)bit_range
@@ -757,16 +757,16 @@ template <typename Composer> class SafeUintFuzzBase {
         /**
          * @brief Execute the constant_witness instruction (push a safeuint witness equal to the constant to the stack)
          *
-         * @param composer
+         * @param builder
          * @param stack
          * @param instruction
          * @return 0 if everything is ok, 1 if we should stop execution, since an expected error was encountered
          */
-        static inline size_t execute_CONSTANT_WITNESS(Composer* composer,
+        static inline size_t execute_CONSTANT_WITNESS(Builder* builder,
                                                       std::vector<ExecutionHandler>& stack,
                                                       Instruction& instruction)
         {
-            stack.push_back(suint_t::create_constant_witness(composer, instruction.arguments.element.value));
+            stack.push_back(suint_t::create_constant_witness(builder, instruction.arguments.element.value));
 #ifdef SHOW_INFORMATION
             std::cout << "Pushed constant witness value " << instruction.arguments.element.value << " to position "
                       << stack.size() - 1 << std::endl;
@@ -776,17 +776,17 @@ template <typename Composer> class SafeUintFuzzBase {
         /**
          * @brief Execute the multiply instruction
          *
-         * @param composer
+         * @param builder
          * @param stack
          * @param instruction
          * @return if everything is ok, 1 if we should stop execution, since an expected error was encountered
          */
-        static inline size_t execute_MULTIPLY(Composer* composer,
+        static inline size_t execute_MULTIPLY(Builder* builder,
                                               std::vector<ExecutionHandler>& stack,
                                               Instruction& instruction)
         {
 
-            (void)composer;
+            (void)builder;
             if (stack.size() == 0) {
                 return 1;
             }
@@ -828,16 +828,16 @@ template <typename Composer> class SafeUintFuzzBase {
         /**
          * @brief Execute the addition operator instruction
          *
-         * @param composer
+         * @param builder
          * @param stack
          * @param instruction
          * @return if everything is ok, 1 if we should stop execution, since an expected error was encountered
          */
-        static inline size_t execute_ADD(Composer* composer,
+        static inline size_t execute_ADD(Builder* builder,
                                          std::vector<ExecutionHandler>& stack,
                                          Instruction& instruction)
         {
-            (void)composer;
+            (void)builder;
             if (stack.size() == 0) {
                 return 1;
             }
@@ -872,16 +872,16 @@ template <typename Composer> class SafeUintFuzzBase {
         /**
          * @brief Execute the subtraction operator instruction
          *
-         * @param composer
+         * @param builder
          * @param stack
          * @param instruction
          * @return if everything is ok, 1 if we should stop execution, since an expected error was encountered
          */
-        static inline size_t execute_SUBTRACT(Composer* composer,
+        static inline size_t execute_SUBTRACT(Builder* builder,
                                               std::vector<ExecutionHandler>& stack,
                                               Instruction& instruction)
         {
-            (void)composer;
+            (void)builder;
             if (stack.size() == 0) {
                 return 1;
             }
@@ -939,16 +939,16 @@ template <typename Composer> class SafeUintFuzzBase {
         /**
          * @brief Execute the division operator instruction
          *
-         * @param composer
+         * @param builder
          * @param stack
          * @param instruction
          * @return if everything is ok, 1 if we should stop execution, since an expected error was encountered
          */
-        static inline size_t execute_DIVIDE(Composer* composer,
+        static inline size_t execute_DIVIDE(Builder* builder,
                                             std::vector<ExecutionHandler>& stack,
                                             Instruction& instruction)
         {
-            (void)composer;
+            (void)builder;
             if (stack.size() == 0) {
                 return 1;
             }
@@ -1002,17 +1002,17 @@ template <typename Composer> class SafeUintFuzzBase {
         /**
          * @brief Execute the ADD_TWO instruction
          *
-         * @param composer
+         * @param builder
          * @param stack
          * @param instruction
          * @return if everything is ok, 1 if we should stop execution, since an expected error was encountered
         size_t
          */
-        static inline size_t execute_ADD_TWO(Composer* composer,
+        static inline size_t execute_ADD_TWO(Builder* builder,
                                              std::vector<ExecutionHandler>& stack,
                                              Instruction& instruction)
         {
-            (void)composer;
+            (void)builder;
             if (stack.size() == 0) {
                 return 1;
             }
@@ -1053,17 +1053,17 @@ template <typename Composer> class SafeUintFuzzBase {
         /**
          * @brief Execute the MADD instruction
          *
-         * @param composer
+         * @param builder
          * @param stack
          * @param instruction
          * @return if everything is ok, 1 if we should stop execution, since an expected error was encountered
         size_t
          */
-        static inline size_t execute_MADD(Composer* composer,
+        static inline size_t execute_MADD(Builder* builder,
                                           std::vector<ExecutionHandler>& stack,
                                           Instruction& instruction)
         {
-            (void)composer;
+            (void)builder;
             if (stack.size() == 0) {
                 return 1;
             }
@@ -1106,17 +1106,17 @@ template <typename Composer> class SafeUintFuzzBase {
         /**
          * @brief Execute the SUBTRACT_WITH_CONSTRAINT instruction
          *
-         * @param composer
+         * @param builder
          * @param stack
          * @param instruction
          * @return if everything is ok, 1 if we should stop execution, since an expected error was encountered
         size_t
             */
-        static inline size_t execute_SUBTRACT_WITH_CONSTRAINT(Composer* composer,
+        static inline size_t execute_SUBTRACT_WITH_CONSTRAINT(Builder* builder,
                                                               std::vector<ExecutionHandler>& stack,
                                                               Instruction& instruction)
         {
-            (void)composer;
+            (void)builder;
             if (stack.size() == 0) {
                 return 1;
             }
@@ -1161,17 +1161,17 @@ template <typename Composer> class SafeUintFuzzBase {
         /**
          * @brief Execute the DIVIDE_WITH_CONSTRAINTS instruction
          *
-         * @param composer
+         * @param builder
          * @param stack
          * @param instruction
          * @return if everything is ok, 1 if we should stop execution, since an expected error was
  encountered
             */
-        static inline size_t execute_DIVIDE_WITH_CONSTRAINTS(Composer* composer,
+        static inline size_t execute_DIVIDE_WITH_CONSTRAINTS(Builder* builder,
                                                              std::vector<ExecutionHandler>& stack,
                                                              Instruction& instruction)
         {
-            (void)composer;
+            (void)builder;
             if (stack.size() == 0) {
                 return 1;
             }
@@ -1228,17 +1228,17 @@ template <typename Composer> class SafeUintFuzzBase {
         /**
          * @brief Execute the slice instruction
          *
-         * @param composer
+         * @param builder
          * @param stack
          * @param instruction
          * @return if everything is ok, 1 if we should stop execution, since an expected error was encountered
         size_t
          */
-        static inline size_t execute_SLICE(Composer* composer,
+        static inline size_t execute_SLICE(Builder* builder,
                                            std::vector<ExecutionHandler>& stack,
                                            Instruction& instruction)
         {
-            (void)composer;
+            (void)builder;
             if (stack.size() == 0) {
                 return 1;
             }
@@ -1278,16 +1278,16 @@ template <typename Composer> class SafeUintFuzzBase {
         /**
          * @brief Execute the RANDOMSEED instruction
          *
-         * @param composer
+         * @param builder
          * @param stack
          * @param instruction
          * @return if everything is ok, 1 if we should stop execution, since an expected error was encountered
          */
-        static inline size_t execute_RANDOMSEED(Composer* composer,
+        static inline size_t execute_RANDOMSEED(Builder* builder,
                                                 std::vector<ExecutionHandler>& stack,
                                                 Instruction& instruction)
         {
-            (void)composer;
+            (void)builder;
             (void)stack;
 
             VarianceRNG.reseed(instruction.arguments.randomseed);
@@ -1457,7 +1457,7 @@ extern "C" size_t LLVMFuzzerCustomCrossOver(const uint8_t* Data1,
  */
 extern "C" size_t LLVMFuzzerTestOneInput(const uint8_t* Data, size_t Size)
 {
-    RunWithComposers<SafeUintFuzzBase, FuzzerCircuitTypes>(Data, Size, VarianceRNG);
+    RunWithBuilders<SafeUintFuzzBase, FuzzerCircuitTypes>(Data, Size, VarianceRNG);
     return 0;
 }
 
diff --git a/barretenberg/cpp/src/barretenberg/stdlib/primitives/safe_uint/safe_uint.hpp b/barretenberg/cpp/src/barretenberg/stdlib/primitives/safe_uint/safe_uint.hpp
index 52b12c19f23..b022892b62b 100644
--- a/barretenberg/cpp/src/barretenberg/stdlib/primitives/safe_uint/safe_uint.hpp
+++ b/barretenberg/cpp/src/barretenberg/stdlib/primitives/safe_uint/safe_uint.hpp
@@ -14,10 +14,10 @@
 namespace proof_system::plonk {
 namespace stdlib {
 
-template <typename ComposerContext> class safe_uint_t {
+template <typename Builder> class safe_uint_t {
   private:
-    typedef field_t<ComposerContext> field_ct;
-    typedef bool_t<ComposerContext> bool_ct;
+    typedef field_t<Builder> field_ct;
+    typedef bool_t<Builder> bool_ct;
     // this constructor is private since we only want the operators to be able to define a positive int without a range
     // check.
     safe_uint_t(field_ct const& value, uint256_t current_max, size_t safety)
@@ -77,11 +77,10 @@ template <typename ComposerContext> class safe_uint_t {
         , current_max(other.current_max)
     {}
 
-    static safe_uint_t<ComposerContext> create_constant_witness(ComposerContext* parent_context,
-                                                                barretenberg::fr const& value)
+    static safe_uint_t<Builder> create_constant_witness(Builder* parent_context, barretenberg::fr const& value)
 
     {
-        witness_t<ComposerContext> out(parent_context, value);
+        witness_t<Builder> out(parent_context, value);
         parent_context->assert_equal_constant(out.witness_index, value);
         return safe_uint_t(value, uint256_t(value), IS_UNSAFE);
     }
@@ -94,7 +93,7 @@ template <typename ComposerContext> class safe_uint_t {
     {}
 
     explicit operator bool_ct() { return bool_ct(value); }
-    static safe_uint_t from_witness_index(ComposerContext* parent_context, const uint32_t witness_index);
+    static safe_uint_t from_witness_index(Builder* parent_context, const uint32_t witness_index);
 
     // Subtraction when you have a pre-determined bound on the difference size
     safe_uint_t subtract(const safe_uint_t& other,
@@ -104,7 +103,7 @@ template <typename ComposerContext> class safe_uint_t {
         ASSERT(difference_bit_size <= MAX_BIT_NUM);
         ASSERT(!(this->value.is_constant() && other.value.is_constant()));
         field_ct difference_val = this->value - other.value;
-        safe_uint_t<ComposerContext> difference(difference_val, difference_bit_size, format("subtract: ", description));
+        safe_uint_t<Builder> difference(difference_val, difference_bit_size, format("subtract: ", description));
         // This checks the subtraction is correct for integers without any wraps
         if (difference.current_max + other.current_max > MAX_VALUE)
             throw_or_abort("maximum value exceeded in safe_uint subtract");
@@ -117,7 +116,7 @@ template <typename ComposerContext> class safe_uint_t {
         ASSERT(!(this->value.is_constant() && other.value.is_constant() &&
                  static_cast<uint256_t>(value.get_value()) < static_cast<uint256_t>(other.value.get_value())));
         field_ct difference_val = this->value - other.value;
-        safe_uint_t<ComposerContext> difference(difference_val, (size_t)(current_max.get_msb() + 1), "- operator");
+        safe_uint_t<Builder> difference(difference_val, (size_t)(current_max.get_msb() + 1), "- operator");
         // This checks the subtraction is correct for integers without any wraps
         if (difference.current_max + other.current_max > MAX_VALUE)
             throw_or_abort("maximum value exceeded in safe_uint minus operator");
@@ -142,9 +141,9 @@ template <typename ComposerContext> class safe_uint_t {
         auto [quotient_val, remainder_val] = get_quotient(val, (uint256_t)other.value.get_value());
         field_ct quotient_field(witness_t(value.context, quotient_val));
         field_ct remainder_field(witness_t(value.context, remainder_val));
-        safe_uint_t<ComposerContext> quotient(
+        safe_uint_t<Builder> quotient(
             quotient_field, quotient_bit_size, format("divide method quotient: ", description));
-        safe_uint_t<ComposerContext> remainder(
+        safe_uint_t<Builder> remainder(
             remainder_field, remainder_bit_size, format("divide method remainder: ", description));
 
         // This line implicitly checks we are not overflowing
@@ -152,7 +151,7 @@ template <typename ComposerContext> class safe_uint_t {
 
         // We constrain divisor - remainder - 1 to be non-negative to ensure that remainder < divisor.
         // Define remainder_plus_one to avoid multiple subtractions
-        const safe_uint_t<ComposerContext> remainder_plus_one = remainder + 1;
+        const safe_uint_t<Builder> remainder_plus_one = remainder + 1;
         // Subtraction of safe_uint_t's imposes the desired range constraint
         other - remainder_plus_one;
 
@@ -169,9 +168,9 @@ template <typename ComposerContext> class safe_uint_t {
         auto [quotient_val, remainder_val] = val.divmod((uint256_t)other.value.get_value());
         field_ct quotient_field(witness_t(value.context, quotient_val));
         field_ct remainder_field(witness_t(value.context, remainder_val));
-        safe_uint_t<ComposerContext> quotient(
+        safe_uint_t<Builder> quotient(
             quotient_field, (size_t)(current_max.get_msb() + 1), format("/ operator quotient"));
-        safe_uint_t<ComposerContext> remainder(
+        safe_uint_t<Builder> remainder(
             remainder_field, (size_t)(other.current_max.get_msb() + 1), format("/ operator remainder"));
 
         // This line implicitly checks we are not overflowing
@@ -179,7 +178,7 @@ template <typename ComposerContext> class safe_uint_t {
 
         // We constrain divisor - remainder - 1 to be non-negative to ensure that remainder < divisor.
         // // define remainder_plus_one to avoid multiple subtractions
-        const safe_uint_t<ComposerContext> remainder_plus_one = remainder + 1;
+        const safe_uint_t<Builder> remainder_plus_one = remainder + 1;
         // // subtraction of safe_uint_t's imposes the desired range constraint
         other - remainder_plus_one;
 
@@ -231,7 +230,7 @@ template <typename ComposerContext> class safe_uint_t {
         return *this;
     }
 
-    std::array<safe_uint_t<ComposerContext>, 3> slice(const uint8_t msb, const uint8_t lsb) const;
+    std::array<safe_uint_t<Builder>, 3> slice(const uint8_t msb, const uint8_t lsb) const;
     void set_public() const { value.set_public(); }
     operator field_ct() { return value; }
     operator field_ct() const { return value; }
@@ -242,7 +241,7 @@ template <typename ComposerContext> class safe_uint_t {
 
     /**
      * normalize returns a safe_uint_t element where `multiplicative_constant = 1` and `additive_constant = 0`
-     * i.e. the value is defined entirely by the composer variable that `witness_index` points to
+     * i.e. the value is defined entirely by the builder variable that `witness_index` points to
      * If the witness_index is ever needed, `normalize` should be called first
      *
      * Will cost 1 constraint if the field element is not already normalized (or is constant)
@@ -251,7 +250,7 @@ template <typename ComposerContext> class safe_uint_t {
 
     barretenberg::fr get_value() const;
 
-    ComposerContext* get_context() const { return value.context; }
+    Builder* get_context() const { return value.context; }
 
     /**
      * is_zero will return a bool_ct, and add constraints that enforce its correctness
@@ -277,8 +276,7 @@ template <typename ComposerContext> class safe_uint_t {
     uint32_t get_witness_index() const { return value.get_witness_index(); }
 };
 
-template <typename ComposerContext>
-inline std::ostream& operator<<(std::ostream& os, safe_uint_t<ComposerContext> const& v)
+template <typename Builder> inline std::ostream& operator<<(std::ostream& os, safe_uint_t<Builder> const& v)
 {
     return os << v.value;
 }
diff --git a/barretenberg/cpp/src/barretenberg/stdlib/primitives/safe_uint/safe_uint.test.cpp b/barretenberg/cpp/src/barretenberg/stdlib/primitives/safe_uint/safe_uint.test.cpp
index 2662b61b523..ad9913aeb17 100644
--- a/barretenberg/cpp/src/barretenberg/stdlib/primitives/safe_uint/safe_uint.test.cpp
+++ b/barretenberg/cpp/src/barretenberg/stdlib/primitives/safe_uint/safe_uint.test.cpp
@@ -10,13 +10,13 @@
 #pragma GCC diagnostic ignored "-Wunused-local-typedefs"
 
 #define STDLIB_TYPE_ALIASES                                                                                            \
-    using Composer = TypeParam;                                                                                        \
-    using witness_ct = stdlib::witness_t<Composer>;                                                                    \
-    using field_ct = stdlib::field_t<Composer>;                                                                        \
-    using bool_ct = stdlib::bool_t<Composer>;                                                                          \
-    using suint_ct = stdlib::safe_uint_t<Composer>;                                                                    \
-    using byte_array_ct = stdlib::byte_array<Composer>;                                                                \
-    using public_witness_ct = stdlib::public_witness_t<Composer>;
+    using Builder = TypeParam;                                                                                         \
+    using witness_ct = stdlib::witness_t<Builder>;                                                                     \
+    using field_ct = stdlib::field_t<Builder>;                                                                         \
+    using bool_ct = stdlib::bool_t<Builder>;                                                                           \
+    using suint_ct = stdlib::safe_uint_t<Builder>;                                                                     \
+    using byte_array_ct = stdlib::byte_array<Builder>;                                                                 \
+    using public_witness_ct = stdlib::public_witness_t<Builder>;
 
 namespace {
 auto& engine = numeric::random::get_debug_engine();
@@ -28,7 +28,7 @@ using namespace proof_system::plonk;
 
 template <class T> void ignore_unused(T&) {} // use to ignore unused variables in lambdas
 
-template <class Composer> class SafeUintTest : public ::testing::Test {};
+template <class Builder> class SafeUintTest : public ::testing::Test {};
 
 using CircuitTypes = ::testing::
     Types<proof_system::StandardCircuitBuilder, proof_system::TurboCircuitBuilder, proof_system::UltraCircuitBuilder>;
@@ -39,25 +39,25 @@ TYPED_TEST_SUITE(SafeUintTest, CircuitTypes);
 TYPED_TEST(SafeUintTest, TestConstructorWithValueOutOfRangeFails)
 {
     STDLIB_TYPE_ALIASES
-    auto composer = Composer();
+    auto builder = Builder();
 
     // check incorrect range init causes failure
 
-    field_ct a(witness_ct(&composer, 100));
+    field_ct a(witness_ct(&builder, 100));
     suint_ct b(a, 2, "b");
 
-    EXPECT_FALSE(composer.check_circuit());
+    EXPECT_FALSE(builder.check_circuit());
 }
 
 TYPED_TEST(SafeUintTest, TestConstructorWithValueInRange)
 {
     STDLIB_TYPE_ALIASES
-    auto composer = Composer();
+    auto builder = Builder();
 
-    field_ct a(witness_ct(&composer, 100));
+    field_ct a(witness_ct(&builder, 100));
     suint_ct b(a, 7);
 
-    EXPECT_TRUE(composer.check_circuit());
+    EXPECT_TRUE(builder.check_circuit());
 }
 
 // * OPERATOR
@@ -66,13 +66,13 @@ TYPED_TEST(SafeUintTest, TestConstructorWithValueInRange)
 TYPED_TEST(SafeUintTest, TestMultiplyOperationOutOfRangeFails)
 {
     STDLIB_TYPE_ALIASES
-    auto composer = Composer();
+    auto builder = Builder();
     // Since max is initally set to (1 << 2) - 1 = 3 (as bit range checks are easier than generic integer bounds),
     // should allow largest power of 3 smaller than r iterations, which is 159. Hence below we should exceed r, and
     // expect a throw
     try {
 
-        field_ct a(witness_ct(&composer, 2));
+        field_ct a(witness_ct(&builder, 2));
         suint_ct c(a, 2);
         suint_ct d(a, 2);
         for (auto i = 0; i < 160; i++) {
@@ -89,11 +89,11 @@ TYPED_TEST(SafeUintTest, TestMultiplyOperationOutOfRangeFails)
 TYPED_TEST(SafeUintTest, TestMultiplyOperationOnConstantsOutOfRangeFails)
 {
     STDLIB_TYPE_ALIASES
-    auto composer = Composer();
+    auto builder = Builder();
     //  Now we check that when using constants the maximum grows more slowly - since they are bounded by themselves
     //  rather than the next 2^n-1
 
-    field_ct a(witness_ct(&composer, 2));
+    field_ct a(witness_ct(&builder, 2));
     suint_ct c(a, 2);
     suint_ct d(fr(2));
 
@@ -104,7 +104,7 @@ TYPED_TEST(SafeUintTest, TestMultiplyOperationOnConstantsOutOfRangeFails)
 
     try {
 
-        field_ct a(witness_ct(&composer, 2));
+        field_ct a(witness_ct(&builder, 2));
         suint_ct c(a, 2);
         suint_ct d(fr(2));
         for (auto i = 0; i < 253; i++) {
@@ -122,11 +122,11 @@ TYPED_TEST(SafeUintTest, TestMultiplyOperationOnConstantsOutOfRangeFails)
 TYPED_TEST(SafeUintTest, TestAddOperationOutOfRangeFails)
 {
     STDLIB_TYPE_ALIASES
-    auto composer = Composer();
+    auto builder = Builder();
     // Here we test the addition operator also causes a throw when exceeding r
     try {
 
-        field_ct a(witness_ct(&composer, 2));
+        field_ct a(witness_ct(&builder, 2));
         suint_ct c(a, 2);
         suint_ct d(a, 2);
         for (auto i = 0; i < 159; i++) {
@@ -146,40 +146,40 @@ TYPED_TEST(SafeUintTest, TestAddOperationOutOfRangeFails)
 TYPED_TEST(SafeUintTest, TestSubtractMethod)
 {
     STDLIB_TYPE_ALIASES
-    auto composer = Composer();
+    auto builder = Builder();
 
-    field_ct a(witness_ct(&composer, 2));
-    field_ct b(witness_ct(&composer, 9));
+    field_ct a(witness_ct(&builder, 2));
+    field_ct b(witness_ct(&builder, 9));
     suint_ct c(a, 2);
     suint_ct d(b, 4);
     c = d.subtract(c, 3);
 
-    EXPECT_TRUE(composer.check_circuit());
+    EXPECT_TRUE(builder.check_circuit());
 }
 
 TYPED_TEST(SafeUintTest, TestSubtractMethodMinuedGtLhsFails)
 {
     STDLIB_TYPE_ALIASES
-    auto composer = Composer();
+    auto builder = Builder();
     // test failure when range for difference too small
 
-    field_ct a(witness_ct(&composer, 2));
-    field_ct b(witness_ct(&composer, 9));
+    field_ct a(witness_ct(&builder, 2));
+    field_ct b(witness_ct(&builder, 9));
     suint_ct c(a, 2, "c");
     suint_ct d(b, 4, "d");
     c = d.subtract(c, 2, "d - c"); // we can't be sure that 4-bits minus 2-bits is 2-bits.
 
-    EXPECT_FALSE(composer.check_circuit());
+    EXPECT_FALSE(builder.check_circuit());
 }
 
 #if !defined(__wasm__)
 TYPED_TEST(SafeUintTest, TestSubtractMethodUnderflowFails)
 {
     STDLIB_TYPE_ALIASES
-    auto composer = Composer();
+    auto builder = Builder();
 
-    field_ct a(witness_ct(&composer, 2));
-    field_ct b(witness_ct(&composer, field_ct::modulus / 2));
+    field_ct a(witness_ct(&builder, 2));
+    field_ct b(witness_ct(&builder, field_ct::modulus / 2));
     suint_ct c(a, 2);
     suint_ct d(b, suint_ct::MAX_BIT_NUM);
     try {
@@ -197,25 +197,25 @@ TYPED_TEST(SafeUintTest, TestSubtractMethodUnderflowFails)
 TYPED_TEST(SafeUintTest, TestMinusOperator)
 {
     STDLIB_TYPE_ALIASES
-    auto composer = Composer();
+    auto builder = Builder();
 
-    field_ct a(witness_ct(&composer, 2));
-    field_ct b(witness_ct(&composer, 9));
+    field_ct a(witness_ct(&builder, 2));
+    field_ct b(witness_ct(&builder, 9));
     suint_ct c(a, 2);
     suint_ct d(b, 4);
     c = d - c;
 
-    EXPECT_TRUE(composer.check_circuit());
+    EXPECT_TRUE(builder.check_circuit());
 }
 
 #if !defined(__wasm__)
 TYPED_TEST(SafeUintTest, TestMinusOperatorUnderflowFails)
 {
     STDLIB_TYPE_ALIASES
-    auto composer = Composer();
+    auto builder = Builder();
 
-    field_ct a(witness_ct(&composer, 2));
-    field_ct b(witness_ct(&composer, field_ct::modulus / 2));
+    field_ct a(witness_ct(&builder, 2));
+    field_ct b(witness_ct(&builder, field_ct::modulus / 2));
     suint_ct c(a, 2);
     suint_ct d(b, suint_ct::MAX_BIT_NUM);
     try {
@@ -233,45 +233,45 @@ TYPED_TEST(SafeUintTest, TestMinusOperatorUnderflowFails)
 TYPED_TEST(SafeUintTest, TestDivideMethod)
 {
     STDLIB_TYPE_ALIASES
-    auto composer = Composer();
+    auto builder = Builder();
 
-    field_ct a1(witness_ct(&composer, 2));
-    field_ct b1(witness_ct(&composer, 9));
+    field_ct a1(witness_ct(&builder, 2));
+    field_ct b1(witness_ct(&builder, 9));
     suint_ct c1(a1, 2);
     suint_ct d1(b1, 4);
     c1 = d1.divide(c1, 3, 1);
 
-    field_ct a2(witness_ct(&composer, engine.get_random_uint8()));
-    field_ct b2(witness_ct(&composer, engine.get_random_uint32()));
+    field_ct a2(witness_ct(&builder, engine.get_random_uint8()));
+    field_ct b2(witness_ct(&builder, engine.get_random_uint32()));
     suint_ct c2(a2, 8);
     suint_ct d2(b2, 32);
     c2 = d2.divide(c2, 32, 8);
 
-    EXPECT_TRUE(composer.check_circuit());
+    EXPECT_TRUE(builder.check_circuit());
 }
 
 TYPED_TEST(SafeUintTest, TestDivideMethodQuotientRangeTooSmallFails)
 {
     STDLIB_TYPE_ALIASES
-    auto composer = Composer();
+    auto builder = Builder();
 
-    field_ct a(witness_ct(&composer, 2));
-    field_ct b(witness_ct(&composer, 32));
+    field_ct a(witness_ct(&builder, 2));
+    field_ct b(witness_ct(&builder, 32));
     suint_ct c(a, 2);
     suint_ct d(b, 6);
     d = d.divide(c, 4, 1, "d/c");
 
-    EXPECT_FALSE(composer.check_circuit());
+    EXPECT_FALSE(builder.check_circuit());
 }
 
 #if !defined(__wasm__)
 TYPED_TEST(SafeUintTest, TestDivideRemainderTooLarge)
 {
     STDLIB_TYPE_ALIASES
-    auto composer = Composer();
+    auto builder = Builder();
     // test failure when range for remainder too small
 
-    field_ct a(witness_ct(&composer, 5));
+    field_ct a(witness_ct(&builder, 5));
     suint_ct c(a, 3);
     suint_ct d((fr::modulus - 1) / 3);
     suint_ct b;
@@ -282,46 +282,46 @@ TYPED_TEST(SafeUintTest, TestDivideRemainderTooLarge)
 TYPED_TEST(SafeUintTest, TestDivideMethodQuotientRemainderIncorrectFails)
 {
     STDLIB_TYPE_ALIASES
-    auto composer = Composer();
+    auto builder = Builder();
     // test failure when quotient and remainder values are wrong
 
-    field_ct a(witness_ct(&composer, 5));
-    field_ct b(witness_ct(&composer, 19));
+    field_ct a(witness_ct(&builder, 5));
+    field_ct b(witness_ct(&builder, 19));
     suint_ct c(a, 3);
     suint_ct d(b, 5);
     d = d.divide(c, 3, 2, "d/c", [](uint256_t, uint256_t) { return std::make_pair(2, 3); });
 
-    EXPECT_FALSE(composer.check_circuit());
+    EXPECT_FALSE(builder.check_circuit());
 }
 
 TYPED_TEST(SafeUintTest, TestDivideMethodQuotientRemainderModRFails)
 {
     STDLIB_TYPE_ALIASES
-    auto composer = Composer();
+    auto builder = Builder();
     // test failure when quotient and remainder are only correct mod r
 
-    field_ct a(witness_ct(&composer, 5));
-    field_ct b(witness_ct(&composer, 19));
+    field_ct a(witness_ct(&builder, 5));
+    field_ct b(witness_ct(&builder, 19));
     suint_ct c(a, 3);
     suint_ct d(b, 5);
     d = d.divide(c, 3, 1, "d/c", [](uint256_t a, uint256_t b) { return std::make_pair((fr)a / (fr)b, 0); });
     // 19 / 5 in the field is 0x1d08fbde871dc67f6e96903a4db401d17e858b5eaf6f438a5bedf9bf2999999e, so the quotient
     // should fail the range check of 3-bits.
 
-    EXPECT_FALSE(composer.check_circuit());
+    EXPECT_FALSE(builder.check_circuit());
 }
 
 TYPED_TEST(SafeUintTest, TestDivOperator)
 {
     STDLIB_TYPE_ALIASES
-    auto composer = Composer();
+    auto builder = Builder();
 
-    suint_ct a(witness_ct(&composer, 1000), 10, "a");
+    suint_ct a(witness_ct(&builder, 1000), 10, "a");
     suint_ct b(2, 2, "b");
 
     a = a / b;
 
-    EXPECT_TRUE(composer.check_circuit());
+    EXPECT_TRUE(builder.check_circuit());
 }
 
 // / OPERATOR
@@ -329,67 +329,67 @@ TYPED_TEST(SafeUintTest, TestDivOperator)
 TYPED_TEST(SafeUintTest, TestDivideOperator)
 {
     STDLIB_TYPE_ALIASES
-    auto composer = Composer();
+    auto builder = Builder();
     // test success cases
     {
-        auto composer = Composer();
-        field_ct a1(witness_ct(&composer, 2));
-        field_ct b1(witness_ct(&composer, 9));
+        auto builder = Builder();
+        field_ct a1(witness_ct(&builder, 2));
+        field_ct b1(witness_ct(&builder, 9));
         suint_ct c1(a1, 2);
         suint_ct d1(b1, 4);
         d1 / c1;
 
-        field_ct a2(witness_ct(&composer, engine.get_random_uint8()));
-        field_ct b2(witness_ct(&composer, engine.get_random_uint32()));
+        field_ct a2(witness_ct(&builder, engine.get_random_uint8()));
+        field_ct b2(witness_ct(&builder, engine.get_random_uint32()));
         suint_ct c2(a2, 8);
         suint_ct d2(b2, 32);
         d2 / c2;
 
-        bool result = composer.check_circuit();
+        bool result = builder.check_circuit();
         EXPECT_EQ(result, true);
     }
     // test failure when range for quotient too small
     {
-        auto composer = Composer();
-        field_ct a(witness_ct(&composer, 2));
-        field_ct b(witness_ct(&composer, 32));
+        auto builder = Builder();
+        field_ct a(witness_ct(&builder, 2));
+        field_ct b(witness_ct(&builder, 32));
         suint_ct c(a, 2);
         suint_ct d(b, 5);
         d = d / c;
-        bool result = composer.check_circuit();
+        bool result = builder.check_circuit();
         EXPECT_EQ(result, false);
     }
     // test failure when range for remainder too small
     {
 
-        field_ct a(witness_ct(&composer, 5));
-        field_ct b(witness_ct(&composer, 19));
+        field_ct a(witness_ct(&builder, 5));
+        field_ct b(witness_ct(&builder, 19));
         suint_ct c(a, 2);
         suint_ct d(b, 5);
         d = d / c;
-        bool result = composer.check_circuit();
+        bool result = builder.check_circuit();
         EXPECT_EQ(result, false);
     }
     // test failure when quotient and remainder values are wrong
     {
-        auto composer = Composer();
-        field_ct a(witness_ct(&composer, 5));
-        field_ct b(witness_ct(&composer, 19));
+        auto builder = Builder();
+        field_ct a(witness_ct(&builder, 5));
+        field_ct b(witness_ct(&builder, 19));
         suint_ct c(a, 2);
         suint_ct d(b, 5);
         d = d / c;
-        bool result = composer.check_circuit();
+        bool result = builder.check_circuit();
         EXPECT_EQ(result, false);
     }
     // test failure when quotient and remainder are only correct mod r
     {
-        auto composer = Composer();
-        field_ct a(witness_ct(&composer, 5));
-        field_ct b(witness_ct(&composer, 19));
+        auto builder = Builder();
+        field_ct a(witness_ct(&builder, 5));
+        field_ct b(witness_ct(&builder, 19));
         suint_ct c(a, 2);
         suint_ct d(b, 5);
         d = d / c;
-        bool result = composer.check_circuit();
+        bool result = builder.check_circuit();
         EXPECT_EQ(result, false);
     }
 }
@@ -399,7 +399,7 @@ TYPED_TEST(SafeUintTest, TestDivideOperator)
 TYPED_TEST(SafeUintTest, TestSlice)
 {
     STDLIB_TYPE_ALIASES
-    auto composer = Composer();
+    auto builder = Builder();
 
     // 0b11110110101001011
     //         ^      ^
@@ -407,21 +407,21 @@ TYPED_TEST(SafeUintTest, TestSlice)
     //        10      3
     // hi=0x111101, lo=0x011, slice=0x10101001
     //
-    suint_ct a(witness_ct(&composer, fr(126283)), 17);
+    suint_ct a(witness_ct(&builder, fr(126283)), 17);
     auto slice_data = a.slice(10, 3);
 
     EXPECT_EQ(slice_data[0].get_value(), fr(3));
     EXPECT_EQ(slice_data[1].get_value(), fr(169));
     EXPECT_EQ(slice_data[2].get_value(), fr(61));
 
-    bool result = composer.check_circuit();
+    bool result = builder.check_circuit();
     EXPECT_TRUE(result);
 }
 
 TYPED_TEST(SafeUintTest, TestSliceEqualMsbLsb)
 {
     STDLIB_TYPE_ALIASES
-    auto composer = Composer();
+    auto builder = Builder();
 
     // 0b11110110101001011
     //             ^
@@ -429,26 +429,26 @@ TYPED_TEST(SafeUintTest, TestSliceEqualMsbLsb)
     //             6
     // hi=0b1111011010, lo=0b001011, slice=0b1
     //
-    suint_ct a(witness_ct(&composer, fr(126283)), 17);
+    suint_ct a(witness_ct(&builder, fr(126283)), 17);
     auto slice_data = a.slice(6, 6);
 
     EXPECT_EQ(slice_data[0].get_value(), fr(11));
     EXPECT_EQ(slice_data[1].get_value(), fr(1));
     EXPECT_EQ(slice_data[2].get_value(), fr(986));
 
-    bool result = composer.check_circuit();
+    bool result = builder.check_circuit();
     EXPECT_TRUE(result);
 }
 
 TYPED_TEST(SafeUintTest, TestSliceRandom)
 {
     STDLIB_TYPE_ALIASES
-    auto composer = Composer();
+    auto builder = Builder();
 
     uint8_t lsb = 106;
     uint8_t msb = 189;
     fr a_ = fr(uint256_t(fr::random_element()) && ((uint256_t(1) << 252) - 1));
-    suint_ct a(witness_ct(&composer, a_), 252);
+    suint_ct a(witness_ct(&builder, a_), 252);
     auto slice = a.slice(msb, lsb);
 
     const uint256_t expected0 = uint256_t(a_) & ((uint256_t(1) << uint64_t(lsb)) - 1);
@@ -460,7 +460,7 @@ TYPED_TEST(SafeUintTest, TestSliceRandom)
     EXPECT_EQ(slice[1].get_value(), fr(expected1));
     EXPECT_EQ(slice[2].get_value(), fr(expected2));
 
-    bool result = composer.check_circuit();
+    bool result = builder.check_circuit();
     EXPECT_TRUE(result);
 }
 
@@ -471,17 +471,17 @@ TYPED_TEST(SafeUintTest, TestSliceRandom)
 TYPED_TEST(SafeUintTest, TestOperatorDivRemainderConstraint)
 {
     STDLIB_TYPE_ALIASES
-    auto composer = Composer();
+    auto builder = Builder();
 
     uint256_t val = 5;
 
-    suint_ct a(witness_ct(&composer, val), 32);
-    suint_ct b(witness_ct(&composer, val), 32);
+    suint_ct a(witness_ct(&builder, val), 32);
+    suint_ct b(witness_ct(&builder, val), 32);
 
     uint256_t quotient_val = 0;
     uint256_t remainder_val = val;
-    field_ct quotient_field(witness_ct(&composer, quotient_val));
-    field_ct remainder_field(witness_ct(&composer, remainder_val));
+    field_ct quotient_field(witness_ct(&builder, quotient_val));
+    field_ct remainder_field(witness_ct(&builder, remainder_val));
     suint_ct quotient(quotient_field, (size_t)(a.current_max.get_msb() + 1));
     suint_ct remainder(remainder_field, (size_t)(a.current_max.get_msb() + 1));
     // This line implicitly checks we are not overflowing
@@ -496,7 +496,7 @@ TYPED_TEST(SafeUintTest, TestOperatorDivRemainderConstraint)
     // // More rudimentary constraint
     // // We constrain divisor - remainder - 1 to be positive to ensure that remainder < divisor.
     // const uint256_t delta = b.get_value() - remainder_val - 1;
-    // const uint32_t delta_idx = composer.add_variable(delta);
+    // const uint32_t delta_idx = builder.add_variable(delta);
 
     // // constraint: other - remainder - delta - 1 == 0
     //         const add_triple delta_gate{ .a = b.get_witness_index(),
@@ -507,14 +507,14 @@ TYPED_TEST(SafeUintTest, TestOperatorDivRemainderConstraint)
     //                                      .c_scaling = -1,
     //                                      .const_scaling = -1 };
 
-    // composer.create_add_gate(delta_gate);
+    // builder.create_add_gate(delta_gate);
 
     // // validate delta is in the correct range
-    // field_ct::from_witness_index(&composer, delta_idx).create_range_constraint(b.current_max.get_msb() + 1);
+    // field_ct::from_witness_index(&builder, delta_idx).create_range_constraint(b.current_max.get_msb() + 1);
 
     a.assert_equal(int_val);
 
-    bool result = composer.check_circuit();
+    bool result = builder.check_circuit();
     EXPECT_EQ(result, false);
 }
 
@@ -525,12 +525,12 @@ TYPED_TEST(SafeUintTest, TestOperatorDivRemainderConstraint)
 TYPED_TEST(SafeUintTest, TestDivRemainderConstraint)
 {
     STDLIB_TYPE_ALIASES
-    auto composer = Composer();
+    auto builder = Builder();
 
     uint256_t val = 5;
 
-    suint_ct a(witness_ct(&composer, val), 32);
-    suint_ct b(witness_ct(&composer, val), 32);
+    suint_ct a(witness_ct(&builder, val), 32);
+    suint_ct b(witness_ct(&builder, val), 32);
 
     // set quotient to 0 and remainder to val.
     auto supply_bad_witnesses = [](uint256_t val, uint256_t divisor) {
@@ -540,23 +540,23 @@ TYPED_TEST(SafeUintTest, TestDivRemainderConstraint)
 
     a.divide(b, 32, 32, "", supply_bad_witnesses);
 
-    bool result = composer.check_circuit();
+    bool result = builder.check_circuit();
     EXPECT_EQ(result, false);
 }
 
 TYPED_TEST(SafeUintTest, TestByteArrayConversion)
 {
     STDLIB_TYPE_ALIASES
-    auto composer = Composer();
+    auto builder = Builder();
 
-    field_ct elt = witness_ct(&composer, 0x7f6f5f4f00010203);
+    field_ct elt = witness_ct(&builder, 0x7f6f5f4f00010203);
     suint_ct safe(elt, 63);
     // safe.value is a uint256_t, so we serialize to a 32-byte array
     std::string expected = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                              0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                              0x00, 0x00, 0x7f, 0x6f, 0x5f, 0x4f, 0x00, 0x01, 0x02, 0x03 };
 
-    byte_array_ct arr(&composer);
+    byte_array_ct arr(&builder);
     arr.write(static_cast<byte_array_ct>(safe));
     EXPECT_EQ(arr.get_string(), expected);
 }
diff --git a/barretenberg/cpp/src/barretenberg/stdlib/primitives/uint/arithmetic.cpp b/barretenberg/cpp/src/barretenberg/stdlib/primitives/uint/arithmetic.cpp
index b1e5d26e6d9..c7b05fed693 100644
--- a/barretenberg/cpp/src/barretenberg/stdlib/primitives/uint/arithmetic.cpp
+++ b/barretenberg/cpp/src/barretenberg/stdlib/primitives/uint/arithmetic.cpp
@@ -36,26 +36,26 @@ namespace stdlib {
  * normalizes rem (i.e., constrains it to width-many bits), then rem is shown to be the desired remainder.
  */
 
-template <typename Composer, typename Native>
-uint<Composer, Native> uint<Composer, Native>::operator+(const uint& other) const
+template <typename Builder, typename Native>
+uint<Builder, Native> uint<Builder, Native>::operator+(const uint& other) const
 {
     ASSERT(context == other.context || (context != nullptr && other.context == nullptr) ||
            (context == nullptr && other.context != nullptr));
-    Composer* ctx = (context == nullptr) ? other.context : context;
+    Builder* ctx = (context == nullptr) ? other.context : context;
 
     if (is_constant() && other.is_constant()) {
-        return uint<Composer, Native>(context, (additive_constant + other.additive_constant) & MASK);
+        return uint<Builder, Native>(context, (additive_constant + other.additive_constant) & MASK);
     }
 
     if (is_constant() && !other.is_constant()) {
-        uint<Composer, Native> result(other);
+        uint<Builder, Native> result(other);
         result.additive_constant = (additive_constant + other.additive_constant) & MASK;
         result.witness_status = WitnessStatus::NOT_NORMALIZED;
         return result;
     }
 
     if (!is_constant() && other.is_constant()) {
-        uint<Composer, Native> result(*this);
+        uint<Builder, Native> result(*this);
         result.additive_constant = (additive_constant + other.additive_constant) & MASK;
         result.witness_status = WitnessStatus::NOT_NORMALIZED;
         return result;
@@ -80,7 +80,7 @@ uint<Composer, Native> uint<Composer, Native>::operator+(const uint& other) cons
      * is {0, 1, 2}.
      **/
 
-    const add_quad_<typename Composer::FF> gate{
+    const add_quad_<typename Builder::FF> gate{
         .a = witness_index,
         .b = other.witness_index,
         .c = ctx->add_variable(remainder),
@@ -94,7 +94,7 @@ uint<Composer, Native> uint<Composer, Native>::operator+(const uint& other) cons
 
     ctx->create_balanced_add_gate(gate);
 
-    uint<Composer, Native> result(ctx);
+    uint<Builder, Native> result(ctx);
     result.witness_index = gate.c;
     result.witness_status = WitnessStatus::WEAK_NORMALIZED;
 
@@ -126,17 +126,17 @@ uint<Composer, Native> uint<Composer, Native>::operator+(const uint& other) cons
  * and returns rem. These constraints do not show that rem is actually the desired remainder, but if the prover also
  * normalizes rem (i.e., constrains it to width-many bits), then rem is shown to be the desired remainder.
  */
-template <typename Composer, typename Native>
-uint<Composer, Native> uint<Composer, Native>::operator-(const uint& other) const
+template <typename Builder, typename Native>
+uint<Builder, Native> uint<Builder, Native>::operator-(const uint& other) const
 {
     // Assert contexts are equal unless one is null (e.g., from witness or uint without context)
     ASSERT(context == other.context || (context != nullptr && other.context == nullptr) ||
            (context == nullptr && other.context != nullptr));
     // If context is null, replace by other context.
-    Composer* ctx = (context == nullptr) ? other.context : context;
+    Builder* ctx = (context == nullptr) ? other.context : context;
 
     if (is_constant() && other.is_constant()) {
-        return uint<Composer, Native>(context, (additive_constant - other.additive_constant) & MASK);
+        return uint<Builder, Native>(context, (additive_constant - other.additive_constant) & MASK);
     }
 
     if (!is_constant() && witness_status == WitnessStatus::NOT_NORMALIZED) {
@@ -161,7 +161,7 @@ uint<Composer, Native> uint<Composer, Native>::operator-(const uint& other) cons
     //   witness - other_witness - remainder - 2**width . overflow + (2**width + constant_term) == 0
     // and
     //   overflow in {0, 1, 2}
-    const add_quad_<typename Composer::FF> gate{
+    const add_quad_<typename Builder::FF> gate{
         .a = lhs_idx,
         .b = rhs_idx,
         .c = ctx->add_variable(remainder),
@@ -175,7 +175,7 @@ uint<Composer, Native> uint<Composer, Native>::operator-(const uint& other) cons
 
     ctx->create_balanced_add_gate(gate);
 
-    uint<Composer, Native> result(ctx);
+    uint<Builder, Native> result(ctx);
     result.witness_index = gate.c;
     result.witness_status =
         (is_constant() || other.is_constant()) ? WitnessStatus::NOT_NORMALIZED : WitnessStatus::WEAK_NORMALIZED;
@@ -187,17 +187,17 @@ uint<Composer, Native> uint<Composer, Native>::operator-(const uint& other) cons
  * @brief Multiply two uint_ct's, trucating overflowing bits.
  */
 
-template <typename Composer, typename Native>
-uint<Composer, Native> uint<Composer, Native>::operator*(const uint& other) const
+template <typename Builder, typename Native>
+uint<Builder, Native> uint<Builder, Native>::operator*(const uint& other) const
 {
     // Assert contexts are equal unless one us null (e.g., from witness or uint without context)
     ASSERT(context == other.context || (context != nullptr && other.context == nullptr) ||
            (context == nullptr && other.context != nullptr));
 
-    Composer* ctx = (context == nullptr) ? other.context : context;
+    Builder* ctx = (context == nullptr) ? other.context : context;
 
     if (is_constant() && other.is_constant()) {
-        return uint<Composer, Native>(context, (additive_constant * other.additive_constant) & MASK);
+        return uint<Builder, Native>(context, (additive_constant * other.additive_constant) & MASK);
     }
 
     if (is_constant() && !other.is_constant()) {
@@ -232,7 +232,7 @@ uint<Composer, Native> uint<Composer, Native>::operator*(const uint& other) cons
      *      ab + a const_b + b const_a - r - (2**width) overflow + (const_a const_b % 2**width) == 0
      */
 
-    const mul_quad_<typename Composer::FF> gate{
+    const mul_quad_<typename Builder::FF> gate{
         .a = witness_index, // a
         .b = rhs_idx,       // b
         .c = ctx->add_variable(remainder),
@@ -248,7 +248,7 @@ uint<Composer, Native> uint<Composer, Native>::operator*(const uint& other) cons
     ctx->create_big_mul_gate(gate);
     constrain_accumulators(context, gate.d, width + 2, "arithmetic: uint mul overflow too large.");
 
-    uint<Composer, Native> result(ctx);
+    uint<Builder, Native> result(ctx);
 
     // Manually normalize the result. We do this here, and not for operator+, because
     // it is much easier to overflow the 252-bit modulus using multiplications. It is
@@ -260,14 +260,14 @@ uint<Composer, Native> uint<Composer, Native>::operator*(const uint& other) cons
     return result;
 }
 
-template <typename Composer, typename Native>
-uint<Composer, Native> uint<Composer, Native>::operator/(const uint& other) const
+template <typename Builder, typename Native>
+uint<Builder, Native> uint<Builder, Native>::operator/(const uint& other) const
 {
     return divmod(other).first;
 }
 
-template <typename Composer, typename Native>
-uint<Composer, Native> uint<Composer, Native>::operator%(const uint& other) const
+template <typename Builder, typename Native>
+uint<Builder, Native> uint<Builder, Native>::operator%(const uint& other) const
 {
     return divmod(other).second;
 }
@@ -286,15 +286,15 @@ uint<Composer, Native> uint<Composer, Native>::operator%(const uint& other) cons
  * to 64, we can use range constraints to impose non-negativity. Range constraining r, we have 0 <= r. Since b is range
  * constrained, range constraining b - r - 1 gives r < b.
  **/
-template <typename Composer, typename Native>
-std::pair<uint<Composer, Native>, uint<Composer, Native>> uint<Composer, Native>::divmod(const uint& other) const
+template <typename Builder, typename Native>
+std::pair<uint<Builder, Native>, uint<Builder, Native>> uint<Builder, Native>::divmod(const uint& other) const
 {
 
     // Assert contexts are equal unless one us null (e.g., from witness or uint without context)
     ASSERT(context == other.context || (context != nullptr && other.context == nullptr) ||
            (context == nullptr && other.context != nullptr));
 
-    Composer* ctx = (context == nullptr) ? other.context : context;
+    Builder* ctx = (context == nullptr) ? other.context : context;
 
     // we need to guarantee that these values are 32 bits
     if (!is_constant() && witness_status != WitnessStatus::OK) {
@@ -310,22 +310,22 @@ std::pair<uint<Composer, Native>, uint<Composer, Native>> uint<Composer, Native>
         // TODO: find some way of enabling the above assert that does not break
         //       stdlib_uint.test_divide_by_zero_fails.
         // impose failing constraint.
-        field_t<Composer> one = field_t<Composer>::from_witness_index(context, 1);
-        field_t<Composer> zero = field_t<Composer>::from_witness_index(context, 0);
+        field_t<Builder> one = field_t<Builder>::from_witness_index(context, 1);
+        field_t<Builder> zero = field_t<Builder>::from_witness_index(context, 0);
         one / zero;
     } else if (!other.is_constant()) {
-        const bool_t<Composer> is_divisor_zero = field_t<Composer>(other).is_zero();
-        field_t<Composer>(is_divisor_zero).assert_equal(0); // here 0 is a circuit constant
+        const bool_t<Builder> is_divisor_zero = field_t<Builder>(other).is_zero();
+        field_t<Builder>(is_divisor_zero).assert_equal(0); // here 0 is a circuit constant
     }
 
     // handle case of two constants and case of identical witness indices
     if (is_constant() && other.is_constant()) {
-        const uint<Composer, Native> remainder(ctx, additive_constant % other.additive_constant);
-        const uint<Composer, Native> quotient(ctx, additive_constant / other.additive_constant);
+        const uint<Builder, Native> remainder(ctx, additive_constant % other.additive_constant);
+        const uint<Builder, Native> quotient(ctx, additive_constant / other.additive_constant);
         return std::make_pair(quotient, remainder);
     } else if (witness_index == other.witness_index) {
-        const uint<Composer, Native> remainder(context, 0);
-        const uint<Composer, Native> quotient(context, 1);
+        const uint<Builder, Native> remainder(context, 0);
+        const uint<Builder, Native> quotient(context, 1);
         return std::make_pair(quotient, remainder);
     }
 
@@ -360,13 +360,13 @@ std::pair<uint<Composer, Native>, uint<Composer, Native>> uint<Composer, Native>
     const uint32_t delta_idx = ctx->add_variable(delta);
 
     // constraint: b - r - delta + const_b - 1 == 0
-    const add_triple_<typename Composer::FF> delta_gate{ .a = divisor_idx,
-                                                         .b = remainder_idx,
-                                                         .c = delta_idx,
-                                                         .a_scaling = fr::one(),
-                                                         .b_scaling = fr::neg_one(),
-                                                         .c_scaling = fr::neg_one(),
-                                                         .const_scaling = other.additive_constant + fr::neg_one() };
+    const add_triple_<typename Builder::FF> delta_gate{ .a = divisor_idx,
+                                                        .b = remainder_idx,
+                                                        .c = delta_idx,
+                                                        .a_scaling = fr::one(),
+                                                        .b_scaling = fr::neg_one(),
+                                                        .c_scaling = fr::neg_one(),
+                                                        .const_scaling = other.additive_constant + fr::neg_one() };
 
     ctx->create_add_gate(delta_gate);
 
@@ -375,14 +375,14 @@ std::pair<uint<Composer, Native>, uint<Composer, Native>> uint<Composer, Native>
 
     // normalize witness quotient and remainder
     // minimal bit range for quotient: from 0 (in case a = b-1) to width (when b = 1).
-    uint<Composer, Native> quotient(ctx);
+    uint<Builder, Native> quotient(ctx);
     quotient.accumulators = ctx->decompose_into_base4_accumulators(
         quotient_idx, width, "arithmetic: divmod quotient range constraint fails.");
     quotient.witness_index = quotient.accumulators[(width >> 1) - 1];
     quotient.witness_status = WitnessStatus::OK;
 
     // constrain remainder to lie in [0, 2^width-1]
-    uint<Composer, Native> remainder(ctx);
+    uint<Builder, Native> remainder(ctx);
     remainder.accumulators = ctx->decompose_into_base4_accumulators(
         remainder_idx, width, "arithmetic: divmod remaidner range constraint fails.");
     remainder.witness_index = remainder.accumulators[(width >> 1) - 1];
diff --git a/barretenberg/cpp/src/barretenberg/stdlib/primitives/uint/comparison.cpp b/barretenberg/cpp/src/barretenberg/stdlib/primitives/uint/comparison.cpp
index ff6473d8eb5..f62f240fdd9 100644
--- a/barretenberg/cpp/src/barretenberg/stdlib/primitives/uint/comparison.cpp
+++ b/barretenberg/cpp/src/barretenberg/stdlib/primitives/uint/comparison.cpp
@@ -6,7 +6,7 @@ using namespace barretenberg;
 namespace proof_system::plonk {
 namespace stdlib {
 
-template <typename Composer, typename Native>
+template <typename Builder, typename Native>
 /**
  * @brief Determine whether this > other.
  *
@@ -14,19 +14,19 @@ template <typename Composer, typename Native>
  * as satisfying either a > b or a <= b.
  *
  */
-bool_t<Composer> uint<Composer, Native>::operator>(const uint& other) const
+bool_t<Builder> uint<Builder, Native>::operator>(const uint& other) const
 {
-    Composer* ctx = (context == nullptr) ? other.context : context;
+    Builder* ctx = (context == nullptr) ? other.context : context;
 
-    field_t<Composer> a(*this);
-    field_t<Composer> b(other);
+    field_t<Builder> a(*this);
+    field_t<Builder> b(other);
     bool result_witness = uint256_t(a.get_value()) > uint256_t(b.get_value());
 
     if (is_constant() && other.is_constant()) {
-        return bool_t<Composer>(ctx, result_witness);
+        return bool_t<Builder>(ctx, result_witness);
     }
 
-    const bool_t<Composer> result = witness_t<Composer>(ctx, result_witness);
+    const bool_t<Builder> result = witness_t<Builder>(ctx, result_witness);
 
     /**
      * The field_t operator on uints normalizes its input, so a and be have
@@ -54,7 +54,7 @@ bool_t<Composer> uint<Composer, Native>::operator>(const uint& other) const
     const auto diff = a - b;
     // diff.result - result + diff.result - diff = diff.(2.result - 1) - result
     const auto comparison_check =
-        diff.madd(field_t<Composer>(result) * 2 - field_t<Composer>(1), -field_t<Composer>(result));
+        diff.madd(field_t<Builder>(result) * 2 - field_t<Builder>(1), -field_t<Builder>(result));
 
     ctx->decompose_into_base4_accumulators(
         comparison_check.witness_index, width, "comparison: uint comparison range constraint fails.");
@@ -62,44 +62,39 @@ bool_t<Composer> uint<Composer, Native>::operator>(const uint& other) const
     return result;
 }
 
-template <typename Composer, typename Native>
-bool_t<Composer> uint<Composer, Native>::operator<(const uint& other) const
+template <typename Builder, typename Native> bool_t<Builder> uint<Builder, Native>::operator<(const uint& other) const
 {
     return other > *this;
 }
 
-template <typename Composer, typename Native>
-bool_t<Composer> uint<Composer, Native>::operator>=(const uint& other) const
+template <typename Builder, typename Native> bool_t<Builder> uint<Builder, Native>::operator>=(const uint& other) const
 {
     return (!(other > *this)).normalize();
 }
 
-template <typename Composer, typename Native>
-bool_t<Composer> uint<Composer, Native>::operator<=(const uint& other) const
+template <typename Builder, typename Native> bool_t<Builder> uint<Builder, Native>::operator<=(const uint& other) const
 {
     return (!(*this > other)).normalize();
 }
 
-template <typename Composer, typename Native>
-bool_t<Composer> uint<Composer, Native>::operator==(const uint& other) const
+template <typename Builder, typename Native> bool_t<Builder> uint<Builder, Native>::operator==(const uint& other) const
 {
     // casting to a field type will ensure that lhs / rhs are both normalized
-    const field_t<Composer> lhs = static_cast<field_t<Composer>>(*this);
-    const field_t<Composer> rhs = static_cast<field_t<Composer>>(other);
+    const field_t<Builder> lhs = static_cast<field_t<Builder>>(*this);
+    const field_t<Builder> rhs = static_cast<field_t<Builder>>(other);
 
     return (lhs == rhs).normalize();
 }
 
-template <typename Composer, typename Native>
-bool_t<Composer> uint<Composer, Native>::operator!=(const uint& other) const
+template <typename Builder, typename Native> bool_t<Builder> uint<Builder, Native>::operator!=(const uint& other) const
 {
     return (!(*this == other)).normalize();
 }
 
-template <typename Composer, typename Native> bool_t<Composer> uint<Composer, Native>::operator!() const
+template <typename Builder, typename Native> bool_t<Builder> uint<Builder, Native>::operator!() const
 {
     // return true if this is zero, otherwise return false.
-    return (field_t<Composer>(*this).is_zero()).normalize();
+    return (field_t<Builder>(*this).is_zero()).normalize();
 }
 
 INSTANTIATE_STDLIB_BASIC_TYPE_VA(uint, uint8_t);
diff --git a/barretenberg/cpp/src/barretenberg/stdlib/primitives/uint/logic.cpp b/barretenberg/cpp/src/barretenberg/stdlib/primitives/uint/logic.cpp
index e22efc1e226..40c4dfb7b3c 100644
--- a/barretenberg/cpp/src/barretenberg/stdlib/primitives/uint/logic.cpp
+++ b/barretenberg/cpp/src/barretenberg/stdlib/primitives/uint/logic.cpp
@@ -7,25 +7,25 @@ using namespace proof_system;
 namespace proof_system::plonk {
 namespace stdlib {
 
-template <typename Composer, typename Native>
-uint<Composer, Native> uint<Composer, Native>::operator&(const uint& other) const
+template <typename Builder, typename Native>
+uint<Builder, Native> uint<Builder, Native>::operator&(const uint& other) const
 {
     return logic_operator(other, LogicOp::AND);
 }
 
-template <typename Composer, typename Native>
-uint<Composer, Native> uint<Composer, Native>::operator^(const uint& other) const
+template <typename Builder, typename Native>
+uint<Builder, Native> uint<Builder, Native>::operator^(const uint& other) const
 {
     return logic_operator(other, LogicOp::XOR);
 }
 
-template <typename Composer, typename Native>
-uint<Composer, Native> uint<Composer, Native>::operator|(const uint& other) const
+template <typename Builder, typename Native>
+uint<Builder, Native> uint<Builder, Native>::operator|(const uint& other) const
 {
     return (*this + other) - (*this & other);
 }
 
-template <typename Composer, typename Native> uint<Composer, Native> uint<Composer, Native>::operator~() const
+template <typename Builder, typename Native> uint<Builder, Native> uint<Builder, Native>::operator~() const
 {
     if (!is_constant() && witness_status != WitnessStatus::NOT_NORMALIZED) {
         weak_normalize();
@@ -38,8 +38,8 @@ template <typename Composer, typename Native> uint<Composer, Native> uint<Compos
  *
  * @details Note that the result is only weakly normalized.
  */
-template <typename Composer, typename Native>
-uint<Composer, Native> uint<Composer, Native>::operator>>(const size_t shift) const
+template <typename Builder, typename Native>
+uint<Builder, Native> uint<Builder, Native>::operator>>(const size_t shift) const
 {
     if (shift >= width) {
         return uint(context, 0);
@@ -134,7 +134,7 @@ uint<Composer, Native> uint<Composer, Native>::operator>>(const size_t shift) co
     const uint32_t left_index = shift == width - 1 ? context->zero_idx : accumulators[static_cast<size_t>(idx - 1)];
 
     // Constraint: -6.(self >> shift) + 12.a[idx-1] + 6.high bit of (a[idx] - 4.a[idx-1]) = 0.
-    const add_quad_<typename Composer::FF> gate{
+    const add_quad_<typename Builder::FF> gate{
         .a = context->zero_idx,
         .b = context->add_variable(output),
         .c = right_index,
@@ -155,8 +155,8 @@ uint<Composer, Native> uint<Composer, Native>::operator>>(const size_t shift) co
     return result;
 }
 
-template <typename Composer, typename Native>
-uint<Composer, Native> uint<Composer, Native>::operator<<(const size_t shift) const
+template <typename Builder, typename Native>
+uint<Builder, Native> uint<Builder, Native>::operator<<(const size_t shift) const
 {
     if (shift >= width) {
         return uint(context, 0);
@@ -199,13 +199,13 @@ uint<Composer, Native> uint<Composer, Native>::operator<<(const size_t shift) co
         const uint256_t output = (get_value() << shift) & MASK; // (value * 2**shift) % 2**32
 
         // constraint: A.2**shift - A_{x-1}.2**width + (value * 2**shift) % 2**32 == 0
-        const add_triple_<typename Composer::FF> gate{ .a = base_idx,
-                                                       .b = right_idx,
-                                                       .c = context->add_variable(output),
-                                                       .a_scaling = base_shift_factor,
-                                                       .b_scaling = -fr(right_shift_factor),
-                                                       .c_scaling = fr::neg_one(),
-                                                       .const_scaling = fr::zero() };
+        const add_triple_<typename Builder::FF> gate{ .a = base_idx,
+                                                      .b = right_idx,
+                                                      .c = context->add_variable(output),
+                                                      .a_scaling = base_shift_factor,
+                                                      .b_scaling = -fr(right_shift_factor),
+                                                      .c_scaling = fr::neg_one(),
+                                                      .const_scaling = fr::zero() };
 
         context->create_add_gate(gate);
 
@@ -272,15 +272,15 @@ uint<Composer, Native> uint<Composer, Native>::operator<<(const size_t shift) co
      *                       + 6 * high bit of A_x - 4 A_{x-1}                                   ,
      * where A = witness and shift = s = 2x + 1 and A_{-1} = 0.
      */
-    const add_quad_<typename Composer::FF> gate{ .a = context->add_variable(output),
-                                                 .b = base_index,
-                                                 .c = left_index,
-                                                 .d = right_index,
-                                                 .a_scaling = -q_1,
-                                                 .b_scaling = q_2,
-                                                 .c_scaling = fr::zero(),
-                                                 .d_scaling = -q_3,
-                                                 .const_scaling = fr::zero() };
+    const add_quad_<typename Builder::FF> gate{ .a = context->add_variable(output),
+                                                .b = base_index,
+                                                .c = left_index,
+                                                .d = right_index,
+                                                .a_scaling = -q_1,
+                                                .b_scaling = q_2,
+                                                .c_scaling = fr::zero(),
+                                                .d_scaling = -q_3,
+                                                .const_scaling = fr::zero() };
 
     context->create_big_add_gate_with_bit_extraction(gate);
 
@@ -291,8 +291,8 @@ uint<Composer, Native> uint<Composer, Native>::operator<<(const size_t shift) co
     return result;
 }
 
-template <typename Composer, typename Native>
-uint<Composer, Native> uint<Composer, Native>::ror(const size_t target_rotation) const
+template <typename Builder, typename Native>
+uint<Builder, Native> uint<Builder, Native>::ror(const size_t target_rotation) const
 {
     // reduce rotation modulo width (width is always assumed a power of 2)
     const size_t rotation = target_rotation & (width - 1);
@@ -344,13 +344,13 @@ uint<Composer, Native> uint<Composer, Native>::ror(const size_t target_rotation)
         const fr base_shift_factor = t1;
 
         // constraint: 4^{w-x} A + (1 - 4^w) A_pivot - out == 0
-        const add_triple_<typename Composer::FF> gate{ .a = base_idx,
-                                                       .b = left_idx,
-                                                       .c = context->add_variable(output),
-                                                       .a_scaling = base_shift_factor,
-                                                       .b_scaling = left_shift_factor,
-                                                       .c_scaling = fr::neg_one(),
-                                                       .const_scaling = fr::zero() };
+        const add_triple_<typename Builder::FF> gate{ .a = base_idx,
+                                                      .b = left_idx,
+                                                      .c = context->add_variable(output),
+                                                      .a_scaling = base_shift_factor,
+                                                      .b_scaling = left_shift_factor,
+                                                      .c_scaling = fr::neg_one(),
+                                                      .const_scaling = fr::zero() };
 
         context->create_add_gate(gate);
 
@@ -413,15 +413,15 @@ uint<Composer, Native> uint<Composer, Native>::ror(const size_t target_rotation)
      *   -out + (2 * 4^{w-x}) A + (2 - 2 * 4^{w}) A_{w-x-1} + (1 - 4^w) a_{x-1, 1} == 0.
      *
      */
-    const add_quad_<typename Composer::FF> gate{ .a = context->add_variable(output),
-                                                 .b = base_idx,
-                                                 .c = next_pivot_idx,
-                                                 .d = pivot_idx,
-                                                 .a_scaling = q_1,
-                                                 .b_scaling = q_2,
-                                                 .c_scaling = fr::zero(),
-                                                 .d_scaling = q_3,
-                                                 .const_scaling = fr::zero() };
+    const add_quad_<typename Builder::FF> gate{ .a = context->add_variable(output),
+                                                .b = base_idx,
+                                                .c = next_pivot_idx,
+                                                .d = pivot_idx,
+                                                .a_scaling = q_1,
+                                                .b_scaling = q_2,
+                                                .c_scaling = fr::zero(),
+                                                .d_scaling = q_3,
+                                                .const_scaling = fr::zero() };
 
     context->create_big_add_gate_with_bit_extraction(gate);
 
@@ -432,8 +432,8 @@ uint<Composer, Native> uint<Composer, Native>::ror(const size_t target_rotation)
     return result;
 }
 
-template <typename Composer, typename Native>
-uint<Composer, Native> uint<Composer, Native>::rol(const size_t target_rotation) const
+template <typename Builder, typename Native>
+uint<Builder, Native> uint<Builder, Native>::rol(const size_t target_rotation) const
 {
     // Rotating right by r in [0, w - 1] is the same as rotating left by w - r
     // In general, set r = target_rotation mod width = target_rotation & (width - 1),
@@ -444,10 +444,10 @@ uint<Composer, Native> uint<Composer, Native>::rol(const size_t target_rotation)
 /**
  * @brief Implement AND and XOR.
  */
-template <typename Composer, typename Native>
-uint<Composer, Native> uint<Composer, Native>::logic_operator(const uint& other, const LogicOp op_type) const
+template <typename Builder, typename Native>
+uint<Builder, Native> uint<Builder, Native>::logic_operator(const uint& other, const LogicOp op_type) const
 {
-    Composer* ctx = (context == nullptr) ? other.context : context;
+    Builder* ctx = (context == nullptr) ? other.context : context;
 
     // we need to ensure that we can decompose our integers into (width / 2) quads
     // we don't need to completely normalize, however, as our quaternary decomposition will do that by default
@@ -477,13 +477,13 @@ uint<Composer, Native> uint<Composer, Native>::logic_operator(const uint& other,
 
     if (is_constant() && other.is_constant()) {
         // returns a constant uint.
-        return uint<Composer, Native>(ctx, out);
+        return uint<Builder, Native>(ctx, out);
     }
 
     const uint32_t lhs_idx = is_constant() ? ctx->add_variable(lhs) : witness_index;
     const uint32_t rhs_idx = other.is_constant() ? ctx->add_variable(rhs) : other.witness_index;
 
-    accumulator_triple_<typename Composer::FF> logic_accumulators;
+    accumulator_triple_<typename Builder::FF> logic_accumulators;
 
     switch (op_type) {
     case AND: {
@@ -499,7 +499,7 @@ uint<Composer, Native> uint<Composer, Native>::logic_operator(const uint& other,
     }
 
     if (is_constant()) {
-        field_t<Composer>::from_witness_index(ctx, lhs_idx)
+        field_t<Builder>::from_witness_index(ctx, lhs_idx)
             .assert_equal(additive_constant, "uint logic operator assert equal fail");
     } else {
         accumulators = logic_accumulators.left;
@@ -508,7 +508,7 @@ uint<Composer, Native> uint<Composer, Native>::logic_operator(const uint& other,
     }
 
     if (other.is_constant()) {
-        field_t<Composer>::from_witness_index(ctx, rhs_idx)
+        field_t<Builder>::from_witness_index(ctx, rhs_idx)
             .assert_equal(other.additive_constant, "uint logic operator assert equal fail");
     } else {
         other.accumulators = logic_accumulators.right;
@@ -516,7 +516,7 @@ uint<Composer, Native> uint<Composer, Native>::logic_operator(const uint& other,
         witness_status = WitnessStatus::OK;
     }
 
-    uint<Composer, Native> result(ctx);
+    uint<Builder, Native> result(ctx);
     result.accumulators = logic_accumulators.out;
     result.witness_index = result.accumulators[num_accumulators() - 1];
     result.witness_status = WitnessStatus::OK;
diff --git a/barretenberg/cpp/src/barretenberg/stdlib/primitives/uint/plookup/arithmetic.cpp b/barretenberg/cpp/src/barretenberg/stdlib/primitives/uint/plookup/arithmetic.cpp
index ab461f3c14d..a8ad86a97dd 100644
--- a/barretenberg/cpp/src/barretenberg/stdlib/primitives/uint/plookup/arithmetic.cpp
+++ b/barretenberg/cpp/src/barretenberg/stdlib/primitives/uint/plookup/arithmetic.cpp
@@ -7,16 +7,16 @@ using namespace proof_system;
 namespace proof_system::plonk {
 namespace stdlib {
 
-template <typename Composer, typename Native>
-uint_plookup<Composer, Native> uint_plookup<Composer, Native>::operator+(const uint_plookup& other) const
+template <typename Builder, typename Native>
+uint_plookup<Builder, Native> uint_plookup<Builder, Native>::operator+(const uint_plookup& other) const
 {
 
     ASSERT(context == other.context || (context != nullptr && other.context == nullptr) ||
            (context == nullptr && other.context != nullptr));
-    Composer* ctx = (context == nullptr) ? other.context : context;
+    Builder* ctx = (context == nullptr) ? other.context : context;
 
     if (is_constant() && other.is_constant()) {
-        return uint_plookup<Composer, Native>(context, (additive_constant + other.additive_constant) & MASK);
+        return uint_plookup<Builder, Native>(context, (additive_constant + other.additive_constant) & MASK);
     }
 
     // N.B. We assume that additive_constant is nonzero ONLY if value is constant
@@ -41,24 +41,24 @@ uint_plookup<Composer, Native> uint_plookup<Composer, Native>::operator+(const u
 
     ctx->create_balanced_add_gate(gate);
 
-    uint_plookup<Composer, Native> result(ctx);
+    uint_plookup<Builder, Native> result(ctx);
     result.witness_index = gate.c;
     result.witness_status = WitnessStatus::WEAK_NORMALIZED;
 
     return result;
 }
 
-template <typename Composer, typename Native>
-uint_plookup<Composer, Native> uint_plookup<Composer, Native>::operator-(const uint_plookup& other) const
+template <typename Builder, typename Native>
+uint_plookup<Builder, Native> uint_plookup<Builder, Native>::operator-(const uint_plookup& other) const
 {
 
     ASSERT(context == other.context || (context != nullptr && other.context == nullptr) ||
            (context == nullptr && other.context != nullptr));
 
-    Composer* ctx = (context == nullptr) ? other.context : context;
+    Builder* ctx = (context == nullptr) ? other.context : context;
 
     if (is_constant() && other.is_constant()) {
-        return uint_plookup<Composer, Native>(context, (additive_constant - other.additive_constant) & MASK);
+        return uint_plookup<Builder, Native>(context, (additive_constant - other.additive_constant) & MASK);
     }
 
     // N.B. We assume that additive_constant is nonzero ONLY if value is constant
@@ -87,21 +87,21 @@ uint_plookup<Composer, Native> uint_plookup<Composer, Native>::operator-(const u
 
     ctx->create_balanced_add_gate(gate);
 
-    uint_plookup<Composer, Native> result(ctx);
+    uint_plookup<Builder, Native> result(ctx);
     result.witness_index = gate.c;
     result.witness_status = WitnessStatus::WEAK_NORMALIZED;
 
     return result;
 }
 
-template <typename Composer, typename Native>
-uint_plookup<Composer, Native> uint_plookup<Composer, Native>::operator*(const uint_plookup& other) const
+template <typename Builder, typename Native>
+uint_plookup<Builder, Native> uint_plookup<Builder, Native>::operator*(const uint_plookup& other) const
 {
 
-    Composer* ctx = (context == nullptr) ? other.context : context;
+    Builder* ctx = (context == nullptr) ? other.context : context;
 
     if (is_constant() && other.is_constant()) {
-        return uint_plookup<Composer, Native>(context, (additive_constant * other.additive_constant) & MASK);
+        return uint_plookup<Builder, Native>(context, (additive_constant * other.additive_constant) & MASK);
     }
     if (is_constant() && !other.is_constant()) {
         return other * (*this);
@@ -134,7 +134,7 @@ uint_plookup<Composer, Native> uint_plookup<Composer, Native>::operator*(const u
     // discard the high bits
     ctx->decompose_into_default_range(gate.d, width);
 
-    uint_plookup<Composer, Native> result(ctx);
+    uint_plookup<Builder, Native> result(ctx);
     result.accumulators = constrain_accumulators(ctx, gate.c);
     result.witness_index = gate.c;
     result.witness_status = WitnessStatus::OK;
@@ -142,20 +142,20 @@ uint_plookup<Composer, Native> uint_plookup<Composer, Native>::operator*(const u
     return result;
 }
 
-template <typename Composer, typename Native>
-uint_plookup<Composer, Native> uint_plookup<Composer, Native>::operator/(const uint_plookup& other) const
+template <typename Builder, typename Native>
+uint_plookup<Builder, Native> uint_plookup<Builder, Native>::operator/(const uint_plookup& other) const
 {
     return divmod(other).first;
 }
 
-template <typename Composer, typename Native>
-uint_plookup<Composer, Native> uint_plookup<Composer, Native>::operator%(const uint_plookup& other) const
+template <typename Builder, typename Native>
+uint_plookup<Builder, Native> uint_plookup<Builder, Native>::operator%(const uint_plookup& other) const
 {
     return divmod(other).second;
 }
 
-template <typename Composer, typename Native>
-std::pair<uint_plookup<Composer, Native>, uint_plookup<Composer, Native>> uint_plookup<Composer, Native>::divmod(
+template <typename Builder, typename Native>
+std::pair<uint_plookup<Builder, Native>, uint_plookup<Builder, Native>> uint_plookup<Builder, Native>::divmod(
     const uint_plookup& other) const
 {
     /**
@@ -178,7 +178,7 @@ std::pair<uint_plookup<Composer, Native>, uint_plookup<Composer, Native>> uint_p
      * We normalize a and b, as we need to be certain these values are within the range [0, 2**{width}]
      **/
 
-    Composer* ctx = (context == nullptr) ? other.context : context;
+    Builder* ctx = (context == nullptr) ? other.context : context;
 
     // We want to force the divisor to be non-zero, as this is an error state
     if (other.is_constant() && other.get_value() == 0) {
@@ -187,17 +187,17 @@ std::pair<uint_plookup<Composer, Native>, uint_plookup<Composer, Native>> uint_p
         ctx->assert_equal_constant(one, FF::zero());
         ctx->failure("plookup_arithmetic: divide by zero!");
     } else if (!other.is_constant()) {
-        const bool_t<Composer> is_divisor_zero = field_t<Composer>(other).is_zero();
+        const bool_t<Builder> is_divisor_zero = field_t<Builder>(other).is_zero();
         ctx->assert_equal_constant(is_divisor_zero.witness_index, FF::zero(), "plookup_arithmetic: divide by zero!");
     }
 
     if (is_constant() && other.is_constant()) {
-        const uint_plookup<Composer, Native> remainder(ctx, additive_constant % other.additive_constant);
-        const uint_plookup<Composer, Native> quotient(ctx, additive_constant / other.additive_constant);
+        const uint_plookup<Builder, Native> remainder(ctx, additive_constant % other.additive_constant);
+        const uint_plookup<Builder, Native> quotient(ctx, additive_constant / other.additive_constant);
         return std::make_pair(quotient, remainder);
     } else if (witness_index == other.witness_index) {
-        const uint_plookup<Composer, Native> remainder(context, 0);
-        const uint_plookup<Composer, Native> quotient(context, 1);
+        const uint_plookup<Builder, Native> remainder(context, 0);
+        const uint_plookup<Builder, Native> quotient(context, 1);
         return std::make_pair(quotient, remainder);
     }
 
@@ -244,12 +244,12 @@ std::pair<uint_plookup<Composer, Native>, uint_plookup<Composer, Native>> uint_p
 
     // validate delta is in the correct range
     ctx->decompose_into_default_range(delta_idx, width);
-    uint_plookup<Composer, Native> quotient(ctx);
+    uint_plookup<Builder, Native> quotient(ctx);
     quotient.witness_index = quotient_idx;
     quotient.accumulators = constrain_accumulators(ctx, quotient.witness_index);
     quotient.witness_status = WitnessStatus::OK;
 
-    uint_plookup<Composer, Native> remainder(ctx);
+    uint_plookup<Builder, Native> remainder(ctx);
     remainder.witness_index = remainder_idx;
     remainder.accumulators = constrain_accumulators(ctx, remainder.witness_index);
     remainder.witness_status = WitnessStatus::OK;
diff --git a/barretenberg/cpp/src/barretenberg/stdlib/primitives/uint/plookup/comparison.cpp b/barretenberg/cpp/src/barretenberg/stdlib/primitives/uint/plookup/comparison.cpp
index 14ec78a5e82..1b6d859439c 100644
--- a/barretenberg/cpp/src/barretenberg/stdlib/primitives/uint/plookup/comparison.cpp
+++ b/barretenberg/cpp/src/barretenberg/stdlib/primitives/uint/plookup/comparison.cpp
@@ -6,20 +6,20 @@ using namespace barretenberg;
 namespace proof_system::plonk {
 namespace stdlib {
 
-template <typename Composer, typename Native>
-bool_t<Composer> uint_plookup<Composer, Native>::operator>(const uint_plookup& other) const
+template <typename Builder, typename Native>
+bool_t<Builder> uint_plookup<Builder, Native>::operator>(const uint_plookup& other) const
 {
-    Composer* ctx = (context == nullptr) ? other.context : context;
+    Builder* ctx = (context == nullptr) ? other.context : context;
 
-    field_t<Composer> a(*this);
-    field_t<Composer> b(other);
+    field_t<Builder> a(*this);
+    field_t<Builder> b(other);
     bool result_witness = uint256_t(a.get_value()) > uint256_t(b.get_value());
 
     if (is_constant() && other.is_constant()) {
-        return bool_t<Composer>(ctx, result_witness);
+        return bool_t<Builder>(ctx, result_witness);
     }
 
-    const bool_t<Composer> result = witness_t<Composer>(ctx, result_witness);
+    const bool_t<Builder> result = witness_t<Builder>(ctx, result_witness);
 
     /**
      * if (a > b), then (a - b - 1) will be in the range [0, 2**{width}]
@@ -28,50 +28,50 @@ bool_t<Composer> uint_plookup<Composer, Native>::operator>(const uint_plookup& o
      **/
     const auto diff = a - b;
     const auto comparison_check =
-        diff.madd(field_t<Composer>(result) * 2 - field_t<Composer>(1), -field_t<Composer>(result));
+        diff.madd(field_t<Builder>(result) * 2 - field_t<Builder>(1), -field_t<Builder>(result));
 
     comparison_check.create_range_constraint(width);
 
     return result;
 }
 
-template <typename Composer, typename Native>
-bool_t<Composer> uint_plookup<Composer, Native>::operator<(const uint_plookup& other) const
+template <typename Builder, typename Native>
+bool_t<Builder> uint_plookup<Builder, Native>::operator<(const uint_plookup& other) const
 {
     return other > *this;
 }
 
-template <typename Composer, typename Native>
-bool_t<Composer> uint_plookup<Composer, Native>::operator>=(const uint_plookup& other) const
+template <typename Builder, typename Native>
+bool_t<Builder> uint_plookup<Builder, Native>::operator>=(const uint_plookup& other) const
 {
     return (!(other > *this)).normalize();
 }
 
-template <typename Composer, typename Native>
-bool_t<Composer> uint_plookup<Composer, Native>::operator<=(const uint_plookup& other) const
+template <typename Builder, typename Native>
+bool_t<Builder> uint_plookup<Builder, Native>::operator<=(const uint_plookup& other) const
 {
     return (!(*this > other)).normalize();
 }
 
-template <typename Composer, typename Native>
-bool_t<Composer> uint_plookup<Composer, Native>::operator==(const uint_plookup& other) const
+template <typename Builder, typename Native>
+bool_t<Builder> uint_plookup<Builder, Native>::operator==(const uint_plookup& other) const
 {
     // casting to a field type will ensure that lhs / rhs are both normalized
-    const field_t<Composer> lhs = static_cast<field_t<Composer>>(*this);
-    const field_t<Composer> rhs = static_cast<field_t<Composer>>(other);
+    const field_t<Builder> lhs = static_cast<field_t<Builder>>(*this);
+    const field_t<Builder> rhs = static_cast<field_t<Builder>>(other);
 
     return (lhs == rhs).normalize();
 }
 
-template <typename Composer, typename Native>
-bool_t<Composer> uint_plookup<Composer, Native>::operator!=(const uint_plookup& other) const
+template <typename Builder, typename Native>
+bool_t<Builder> uint_plookup<Builder, Native>::operator!=(const uint_plookup& other) const
 {
     return (!(*this == other)).normalize();
 }
 
-template <typename Composer, typename Native> bool_t<Composer> uint_plookup<Composer, Native>::operator!() const
+template <typename Builder, typename Native> bool_t<Builder> uint_plookup<Builder, Native>::operator!() const
 {
-    return (field_t<Composer>(*this).is_zero()).normalize();
+    return (field_t<Builder>(*this).is_zero()).normalize();
 }
 
 INSTANTIATE_STDLIB_ULTRA_TYPE_VA(uint_plookup, uint8_t);
diff --git a/barretenberg/cpp/src/barretenberg/stdlib/primitives/uint/plookup/logic.cpp b/barretenberg/cpp/src/barretenberg/stdlib/primitives/uint/plookup/logic.cpp
index d2c89e30730..134ab4bdfc3 100644
--- a/barretenberg/cpp/src/barretenberg/stdlib/primitives/uint/plookup/logic.cpp
+++ b/barretenberg/cpp/src/barretenberg/stdlib/primitives/uint/plookup/logic.cpp
@@ -8,32 +8,32 @@ namespace stdlib {
 
 using namespace plookup;
 
-template <typename Composer, typename Native>
-uint_plookup<Composer, Native> uint_plookup<Composer, Native>::operator&(const uint_plookup& other) const
+template <typename Builder, typename Native>
+uint_plookup<Builder, Native> uint_plookup<Builder, Native>::operator&(const uint_plookup& other) const
 {
     return logic_operator(other, LogicOp::AND);
 }
 
-template <typename Composer, typename Native>
-uint_plookup<Composer, Native> uint_plookup<Composer, Native>::operator^(const uint_plookup& other) const
+template <typename Builder, typename Native>
+uint_plookup<Builder, Native> uint_plookup<Builder, Native>::operator^(const uint_plookup& other) const
 {
     return logic_operator(other, LogicOp::XOR);
 }
 
-template <typename Composer, typename Native>
-uint_plookup<Composer, Native> uint_plookup<Composer, Native>::operator|(const uint_plookup& other) const
+template <typename Builder, typename Native>
+uint_plookup<Builder, Native> uint_plookup<Builder, Native>::operator|(const uint_plookup& other) const
 {
     return (*this + other) - (*this & other);
 }
 
-template <typename Composer, typename Native>
-uint_plookup<Composer, Native> uint_plookup<Composer, Native>::operator~() const
+template <typename Builder, typename Native>
+uint_plookup<Builder, Native> uint_plookup<Builder, Native>::operator~() const
 {
     return uint_plookup(context, MASK) - *this;
 }
 
-template <typename Composer, typename Native>
-uint_plookup<Composer, Native> uint_plookup<Composer, Native>::operator>>(const size_t shift) const
+template <typename Builder, typename Native>
+uint_plookup<Builder, Native> uint_plookup<Builder, Native>::operator>>(const size_t shift) const
 {
     if (shift >= width) {
         return uint_plookup(context, 0);
@@ -75,27 +75,27 @@ uint_plookup<Composer, Native> uint_plookup<Composer, Native>::operator>>(const
         context->create_new_range_constraint(slice_lo_idx, (1ULL << slice_bit_position) - 1);
     }
     context->create_new_range_constraint(slice_hi_idx, (1ULL << (bits_per_hi_limb - slice_bit_position)) - 1);
-    std::vector<field_t<Composer>> sublimbs;
-    sublimbs.emplace_back(field_t<Composer>::from_witness_index(context, slice_hi_idx));
+    std::vector<field_t<Builder>> sublimbs;
+    sublimbs.emplace_back(field_t<Builder>::from_witness_index(context, slice_hi_idx));
 
     const size_t start = accumulator_index + 1;
-    field_t<Composer> coefficient(context, uint64_t(1ULL << (start * bits_per_limb - shift)));
-    field_t<Composer> shifter(context, uint64_t(1ULL << bits_per_limb));
+    field_t<Builder> coefficient(context, uint64_t(1ULL << (start * bits_per_limb - shift)));
+    field_t<Builder> shifter(context, uint64_t(1ULL << bits_per_limb));
     for (size_t i = accumulator_index + 1; i < num_accumulators(); ++i) {
-        sublimbs.emplace_back(field_t<Composer>::from_witness_index(context, accumulators[i]) *
-                              field_t<Composer>(coefficient));
+        sublimbs.emplace_back(field_t<Builder>::from_witness_index(context, accumulators[i]) *
+                              field_t<Builder>(coefficient));
         coefficient *= shifter;
     }
 
-    uint32_t result_index = field_t<Composer>::accumulate(sublimbs).normalize().get_witness_index();
+    uint32_t result_index = field_t<Builder>::accumulate(sublimbs).normalize().get_witness_index();
     uint_plookup result(context);
     result.witness_index = result_index;
     result.witness_status = WitnessStatus::WEAK_NORMALIZED;
     return result;
 }
 
-template <typename Composer, typename Native>
-uint_plookup<Composer, Native> uint_plookup<Composer, Native>::operator<<(const size_t shift) const
+template <typename Builder, typename Native>
+uint_plookup<Builder, Native> uint_plookup<Builder, Native>::operator<<(const size_t shift) const
 {
     if (shift >= width) {
         return uint_plookup(context, 0);
@@ -146,27 +146,27 @@ uint_plookup<Composer, Native> uint_plookup<Composer, Native>::operator<<(const
         context->create_new_range_constraint(slice_hi_idx, (1ULL << (bits_per_hi_limb - slice_bit_position)) - 1);
     }
 
-    std::vector<field_t<Composer>> sublimbs;
-    sublimbs.emplace_back(field_t<Composer>::from_witness_index(context, slice_lo_idx) *
-                          field_t<Composer>(context, 1ULL << ((accumulator_index)*bits_per_limb + shift)));
+    std::vector<field_t<Builder>> sublimbs;
+    sublimbs.emplace_back(field_t<Builder>::from_witness_index(context, slice_lo_idx) *
+                          field_t<Builder>(context, 1ULL << ((accumulator_index)*bits_per_limb + shift)));
 
-    field_t<Composer> coefficient(context, uint64_t(1ULL << shift));
-    field_t<Composer> shifter(context, uint64_t(1ULL << bits_per_limb));
+    field_t<Builder> coefficient(context, uint64_t(1ULL << shift));
+    field_t<Builder> shifter(context, uint64_t(1ULL << bits_per_limb));
     for (size_t i = 0; i < accumulator_index; ++i) {
-        sublimbs.emplace_back(field_t<Composer>::from_witness_index(context, accumulators[i]) *
-                              field_t<Composer>(coefficient));
+        sublimbs.emplace_back(field_t<Builder>::from_witness_index(context, accumulators[i]) *
+                              field_t<Builder>(coefficient));
         coefficient *= shifter;
     }
 
-    uint32_t result_index = field_t<Composer>::accumulate(sublimbs).normalize().get_witness_index();
+    uint32_t result_index = field_t<Builder>::accumulate(sublimbs).normalize().get_witness_index();
     uint_plookup result(context);
     result.witness_index = result_index;
     result.witness_status = WitnessStatus::WEAK_NORMALIZED;
     return result;
 }
 
-template <typename Composer, typename Native>
-uint_plookup<Composer, Native> uint_plookup<Composer, Native>::ror(const size_t target_rotation) const
+template <typename Builder, typename Native>
+uint_plookup<Builder, Native> uint_plookup<Builder, Native>::ror(const size_t target_rotation) const
 {
     const size_t rotation = target_rotation & (width - 1);
 
@@ -214,45 +214,44 @@ uint_plookup<Composer, Native> uint_plookup<Composer, Native>::ror(const size_t
         context->create_new_range_constraint(slice_lo_idx, (1ULL << slice_bit_position) - 1);
     }
     context->create_new_range_constraint(slice_hi_idx, (1ULL << (bits_per_hi_limb - slice_bit_position)) - 1);
-    std::vector<field_t<Composer>> sublimbs;
-    sublimbs.emplace_back(field_t<Composer>::from_witness_index(context, slice_hi_idx));
+    std::vector<field_t<Builder>> sublimbs;
+    sublimbs.emplace_back(field_t<Builder>::from_witness_index(context, slice_hi_idx));
 
     const size_t start = accumulator_index + 1;
-    field_t<Composer> coefficient(context, uint64_t(1ULL << (start * bits_per_limb - shift)));
-    field_t<Composer> shifter(context, uint64_t(1ULL << bits_per_limb));
+    field_t<Builder> coefficient(context, uint64_t(1ULL << (start * bits_per_limb - shift)));
+    field_t<Builder> shifter(context, uint64_t(1ULL << bits_per_limb));
     for (size_t i = accumulator_index + 1; i < num_accumulators(); ++i) {
-        sublimbs.emplace_back(field_t<Composer>::from_witness_index(context, accumulators[i]) *
-                              field_t<Composer>(coefficient));
+        sublimbs.emplace_back(field_t<Builder>::from_witness_index(context, accumulators[i]) *
+                              field_t<Builder>(coefficient));
         coefficient *= shifter;
     }
 
-    coefficient = field_t<Composer>(context, uint64_t(1ULL << (width - shift)));
+    coefficient = field_t<Builder>(context, uint64_t(1ULL << (width - shift)));
     for (size_t i = 0; i < accumulator_index; ++i) {
-        sublimbs.emplace_back(field_t<Composer>::from_witness_index(context, accumulators[i]) *
-                              field_t<Composer>(coefficient));
+        sublimbs.emplace_back(field_t<Builder>::from_witness_index(context, accumulators[i]) *
+                              field_t<Builder>(coefficient));
         coefficient *= shifter;
     }
-    sublimbs.emplace_back(field_t<Composer>::from_witness_index(context, slice_lo_idx) *
-                          field_t<Composer>(coefficient));
+    sublimbs.emplace_back(field_t<Builder>::from_witness_index(context, slice_lo_idx) * field_t<Builder>(coefficient));
 
-    uint32_t result_index = field_t<Composer>::accumulate(sublimbs).normalize().get_witness_index();
+    uint32_t result_index = field_t<Builder>::accumulate(sublimbs).normalize().get_witness_index();
     uint_plookup result(context);
     result.witness_index = result_index;
     result.witness_status = WitnessStatus::WEAK_NORMALIZED;
     return result;
 }
 
-template <typename Composer, typename Native>
-uint_plookup<Composer, Native> uint_plookup<Composer, Native>::rol(const size_t target_rotation) const
+template <typename Builder, typename Native>
+uint_plookup<Builder, Native> uint_plookup<Builder, Native>::rol(const size_t target_rotation) const
 {
     return ror(width - (target_rotation & (width - 1)));
 }
 
-template <typename Composer, typename Native>
-uint_plookup<Composer, Native> uint_plookup<Composer, Native>::logic_operator(const uint_plookup& other,
-                                                                              const LogicOp op_type) const
+template <typename Builder, typename Native>
+uint_plookup<Builder, Native> uint_plookup<Builder, Native>::logic_operator(const uint_plookup& other,
+                                                                            const LogicOp op_type) const
 {
-    Composer* ctx = (context == nullptr) ? other.context : context;
+    Builder* ctx = (context == nullptr) ? other.context : context;
 
     // we need to ensure that we can decompose our integers into (width / 2) quads
     // we don't need to completely normalize, however, as our quaternary decomposition will do that by default
@@ -274,20 +273,20 @@ uint_plookup<Composer, Native> uint_plookup<Composer, Native>::logic_operator(co
     }
 
     if (is_constant() && other.is_constant()) {
-        return uint_plookup<Composer, Native>(ctx, out);
+        return uint_plookup<Builder, Native>(ctx, out);
     }
 
-    ReadData<field_t<Composer>> lookup;
+    ReadData<field_t<Builder>> lookup;
     if (op_type == XOR) {
-        lookup = plookup_read<Composer>::get_lookup_accumulators(
-            MultiTableId::UINT32_XOR, field_t<Composer>(*this), field_t<Composer>(other), true);
+        lookup = plookup_read<Builder>::get_lookup_accumulators(
+            MultiTableId::UINT32_XOR, field_t<Builder>(*this), field_t<Builder>(other), true);
     } else {
-        lookup = plookup_read<Composer>::get_lookup_accumulators(
-            MultiTableId::UINT32_AND, field_t<Composer>(*this), field_t<Composer>(other), true);
+        lookup = plookup_read<Builder>::get_lookup_accumulators(
+            MultiTableId::UINT32_AND, field_t<Builder>(*this), field_t<Builder>(other), true);
     }
-    uint_plookup<Composer, Native> result(ctx);
+    uint_plookup<Builder, Native> result(ctx);
     // result.accumulators.resize(num_accumulators());
-    field_t<Composer> scaling_factor(context, barretenberg::fr(1ULL << bits_per_limb));
+    field_t<Builder> scaling_factor(context, barretenberg::fr(1ULL << bits_per_limb));
 
     // N.B. THIS LOOP ONLY WORKS IF THE LOGIC TABLE SLICE SIZE IS HALF THAT OF `bits_per_limb`
     for (size_t i = 0; i < num_accumulators(); ++i) {
diff --git a/barretenberg/cpp/src/barretenberg/stdlib/primitives/uint/plookup/uint.cpp b/barretenberg/cpp/src/barretenberg/stdlib/primitives/uint/plookup/uint.cpp
index a60cc0393fb..e03e600955e 100644
--- a/barretenberg/cpp/src/barretenberg/stdlib/primitives/uint/plookup/uint.cpp
+++ b/barretenberg/cpp/src/barretenberg/stdlib/primitives/uint/plookup/uint.cpp
@@ -6,16 +6,16 @@ using namespace barretenberg;
 namespace proof_system::plonk {
 namespace stdlib {
 
-template <typename Composer, typename Native>
-std::vector<uint32_t> uint_plookup<Composer, Native>::constrain_accumulators(Composer* context,
-                                                                             const uint32_t witness_index) const
+template <typename Builder, typename Native>
+std::vector<uint32_t> uint_plookup<Builder, Native>::constrain_accumulators(Builder* context,
+                                                                            const uint32_t witness_index) const
 {
     const auto res = context->decompose_into_default_range(witness_index, width, bits_per_limb);
     return res;
 }
 
-template <typename Composer, typename Native>
-uint_plookup<Composer, Native>::uint_plookup(const witness_t<Composer>& witness)
+template <typename Builder, typename Native>
+uint_plookup<Builder, Native>::uint_plookup(const witness_t<Builder>& witness)
     : context(witness.context)
     , additive_constant(0)
     , witness_status(WitnessStatus::OK)
@@ -23,8 +23,8 @@ uint_plookup<Composer, Native>::uint_plookup(const witness_t<Composer>& witness)
     , witness_index(witness.witness_index)
 {}
 
-template <typename Composer, typename Native>
-uint_plookup<Composer, Native>::uint_plookup(const field_t<Composer>& value)
+template <typename Builder, typename Native>
+uint_plookup<Builder, Native>::uint_plookup(const field_t<Builder>& value)
     : context(value.context)
     , additive_constant(0)
     , witness_status(WitnessStatus::OK)
@@ -34,23 +34,23 @@ uint_plookup<Composer, Native>::uint_plookup(const field_t<Composer>& value)
     if (value.witness_index == IS_CONSTANT) {
         additive_constant = value.additive_constant;
     } else {
-        field_t<Composer> norm = value.normalize();
+        field_t<Builder> norm = value.normalize();
         accumulators = constrain_accumulators(context, norm.get_witness_index());
         witness_index = norm.get_witness_index();
     }
 }
 
-template <typename Composer, typename Native>
-uint_plookup<Composer, Native>::uint_plookup(Composer* composer, const uint256_t& value)
-    : context(composer)
+template <typename Builder, typename Native>
+uint_plookup<Builder, Native>::uint_plookup(Builder* builder, const uint256_t& value)
+    : context(builder)
     , additive_constant(value)
     , witness_status(WitnessStatus::OK)
     , accumulators()
     , witness_index(IS_CONSTANT)
 {}
 
-template <typename Composer, typename Native>
-uint_plookup<Composer, Native>::uint_plookup(const uint256_t& value)
+template <typename Builder, typename Native>
+uint_plookup<Builder, Native>::uint_plookup(const uint256_t& value)
     : context(nullptr)
     , additive_constant(value)
     , witness_status(WitnessStatus::OK)
@@ -58,16 +58,16 @@ uint_plookup<Composer, Native>::uint_plookup(const uint256_t& value)
     , witness_index(IS_CONSTANT)
 {}
 
-template <typename Composer, typename Native>
-uint_plookup<Composer, Native>::uint_plookup(const byte_array<Composer>& other)
+template <typename Builder, typename Native>
+uint_plookup<Builder, Native>::uint_plookup(const byte_array<Builder>& other)
     : context(other.get_context())
     , additive_constant(0)
     , witness_status(WitnessStatus::WEAK_NORMALIZED)
     , accumulators()
     , witness_index(IS_CONSTANT)
 {
-    field_t<Composer> accumulator(context, fr::zero());
-    field_t<Composer> scaling_factor(context, fr::one());
+    field_t<Builder> accumulator(context, fr::zero());
+    field_t<Builder> scaling_factor(context, fr::one());
     const auto bytes = other.bytes();
 
     // TODO JUMP IN STEPS OF TWO
@@ -83,25 +83,25 @@ uint_plookup<Composer, Native>::uint_plookup(const byte_array<Composer>& other)
     }
 }
 
-template <typename Composer, typename Native>
-uint_plookup<Composer, Native>::uint_plookup(Composer* parent_context, const std::array<bool_t<Composer>, width>& wires)
-    : uint_plookup<Composer, Native>(parent_context, std::vector<bool_t<Composer>>(wires.begin(), wires.end()))
+template <typename Builder, typename Native>
+uint_plookup<Builder, Native>::uint_plookup(Builder* parent_context, const std::array<bool_t<Builder>, width>& wires)
+    : uint_plookup<Builder, Native>(parent_context, std::vector<bool_t<Builder>>(wires.begin(), wires.end()))
 {}
 
-template <typename Composer, typename Native>
-uint_plookup<Composer, Native>::uint_plookup(Composer* parent_context, const std::vector<bool_t<Composer>>& wires)
+template <typename Builder, typename Native>
+uint_plookup<Builder, Native>::uint_plookup(Builder* parent_context, const std::vector<bool_t<Builder>>& wires)
     : context(parent_context)
     , additive_constant(0)
     , witness_status(WitnessStatus::WEAK_NORMALIZED)
     , accumulators()
     , witness_index(IS_CONSTANT)
 {
-    field_t<Composer> accumulator(context, fr::zero());
-    field_t<Composer> scaling_factor(context, fr::one());
+    field_t<Builder> accumulator(context, fr::zero());
+    field_t<Builder> scaling_factor(context, fr::one());
 
     // TODO JUMP IN STEPS OF TWO
     for (size_t i = 0; i < wires.size(); ++i) {
-        accumulator = accumulator + scaling_factor * field_t<Composer>(wires[i]);
+        accumulator = accumulator + scaling_factor * field_t<Builder>(wires[i]);
         scaling_factor = scaling_factor + scaling_factor;
     }
     accumulator = accumulator.normalize();
@@ -112,8 +112,8 @@ uint_plookup<Composer, Native>::uint_plookup(Composer* parent_context, const std
     }
 }
 
-template <typename Composer, typename Native>
-uint_plookup<Composer, Native>::uint_plookup(const uint_plookup& other)
+template <typename Builder, typename Native>
+uint_plookup<Builder, Native>::uint_plookup(const uint_plookup& other)
     : context(other.context)
     , additive_constant(other.additive_constant)
     , witness_status(other.witness_status)
@@ -121,8 +121,8 @@ uint_plookup<Composer, Native>::uint_plookup(const uint_plookup& other)
     , witness_index(other.witness_index)
 {}
 
-template <typename Composer, typename Native>
-uint_plookup<Composer, Native>::uint_plookup(uint_plookup&& other)
+template <typename Builder, typename Native>
+uint_plookup<Builder, Native>::uint_plookup(uint_plookup&& other)
     : context(other.context)
     , additive_constant(other.additive_constant)
     , witness_status(other.witness_status)
@@ -130,8 +130,8 @@ uint_plookup<Composer, Native>::uint_plookup(uint_plookup&& other)
     , witness_index(other.witness_index)
 {}
 
-template <typename Composer, typename Native>
-uint_plookup<Composer, Native>& uint_plookup<Composer, Native>::operator=(const uint_plookup& other)
+template <typename Builder, typename Native>
+uint_plookup<Builder, Native>& uint_plookup<Builder, Native>::operator=(const uint_plookup& other)
 {
     context = other.context;
     additive_constant = other.additive_constant;
@@ -141,8 +141,8 @@ uint_plookup<Composer, Native>& uint_plookup<Composer, Native>::operator=(const
     return *this;
 }
 
-template <typename Composer, typename Native>
-uint_plookup<Composer, Native>& uint_plookup<Composer, Native>::operator=(uint_plookup&& other)
+template <typename Builder, typename Native>
+uint_plookup<Builder, Native>& uint_plookup<Builder, Native>::operator=(uint_plookup&& other)
 {
     context = other.context;
     additive_constant = other.additive_constant;
@@ -166,8 +166,8 @@ template <typename Context, typename Native> uint_plookup<Context, Native>::oper
     return byte_array<Context>(static_cast<field_t<Context>>(*this), width / 8);
 }
 
-template <typename Composer, typename Native>
-uint_plookup<Composer, Native> uint_plookup<Composer, Native>::normalize() const
+template <typename Builder, typename Native>
+uint_plookup<Builder, Native> uint_plookup<Builder, Native>::normalize() const
 {
     if (!context || is_constant()) {
         return *this;
@@ -180,7 +180,7 @@ uint_plookup<Composer, Native> uint_plookup<Composer, Native>::normalize() const
     return *this;
 }
 
-template <typename Composer, typename Native> uint256_t uint_plookup<Composer, Native>::get_value() const
+template <typename Builder, typename Native> uint256_t uint_plookup<Builder, Native>::get_value() const
 {
     if (!context || is_constant()) {
         return additive_constant;
@@ -188,7 +188,7 @@ template <typename Composer, typename Native> uint256_t uint_plookup<Composer, N
     return (uint256_t(context->get_variable(witness_index))) & MASK;
 }
 
-template <typename Composer, typename Native> uint256_t uint_plookup<Composer, Native>::get_unbounded_value() const
+template <typename Builder, typename Native> uint256_t uint_plookup<Builder, Native>::get_unbounded_value() const
 {
     if (!context || is_constant()) {
         return additive_constant;
@@ -196,11 +196,11 @@ template <typename Composer, typename Native> uint256_t uint_plookup<Composer, N
     return (uint256_t(context->get_variable(witness_index)));
 }
 
-template <typename Composer, typename Native>
-bool_t<Composer> uint_plookup<Composer, Native>::at(const size_t bit_index) const
+template <typename Builder, typename Native>
+bool_t<Builder> uint_plookup<Builder, Native>::at(const size_t bit_index) const
 {
     if (is_constant()) {
-        return bool_t<Composer>(context, get_value().get_bit(bit_index));
+        return bool_t<Builder>(context, get_value().get_bit(bit_index));
     }
     if (witness_status != WitnessStatus::OK) {
         normalize();
@@ -236,7 +236,7 @@ bool_t<Composer> uint_plookup<Composer, Native>::at(const size_t bit_index) cons
     if (slice_bit_position + 1 != bits_per_limb) {
         context->create_new_range_constraint(slice_hi_idx, (1ULL << (bits_per_limb - (slice_bit_position + 1))) - 1);
     }
-    bool_t<Composer> result = witness_t<Composer>(context, bit_value);
+    bool_t<Builder> result = witness_t<Builder>(context, bit_value);
     return result;
 }
 
diff --git a/barretenberg/cpp/src/barretenberg/stdlib/primitives/uint/plookup/uint.hpp b/barretenberg/cpp/src/barretenberg/stdlib/primitives/uint/plookup/uint.hpp
index 1b7ed3d2775..ab08eabda62 100644
--- a/barretenberg/cpp/src/barretenberg/stdlib/primitives/uint/plookup/uint.hpp
+++ b/barretenberg/cpp/src/barretenberg/stdlib/primitives/uint/plookup/uint.hpp
@@ -8,24 +8,24 @@
 namespace proof_system::plonk {
 namespace stdlib {
 
-template <typename Composer, typename Native> class uint_plookup {
+template <typename Builder, typename Native> class uint_plookup {
   public:
-    using FF = typename Composer::FF;
+    using FF = typename Builder::FF;
     static constexpr size_t width = sizeof(Native) * 8;
 
-    uint_plookup(const witness_t<Composer>& other);
-    uint_plookup(const field_t<Composer>& other);
+    uint_plookup(const witness_t<Builder>& other);
+    uint_plookup(const field_t<Builder>& other);
     uint_plookup(const uint256_t& value = 0);
-    uint_plookup(Composer* composer, const uint256_t& value = 0);
-    uint_plookup(const byte_array<Composer>& other);
-    uint_plookup(Composer* parent_context, const std::vector<bool_t<Composer>>& wires);
-    uint_plookup(Composer* parent_context, const std::array<bool_t<Composer>, width>& wires);
+    uint_plookup(Builder* builder, const uint256_t& value = 0);
+    uint_plookup(const byte_array<Builder>& other);
+    uint_plookup(Builder* parent_context, const std::vector<bool_t<Builder>>& wires);
+    uint_plookup(Builder* parent_context, const std::array<bool_t<Builder>, width>& wires);
 
     uint_plookup(const Native v)
         : uint_plookup(static_cast<uint256_t>(v))
     {}
 
-    std::vector<uint32_t> constrain_accumulators(Composer* ctx, const uint32_t witness_index) const;
+    std::vector<uint32_t> constrain_accumulators(Builder* ctx, const uint32_t witness_index) const;
 
     static constexpr size_t bits_per_limb = 12;
     static constexpr size_t num_accumulators() { return (width + bits_per_limb - 1) / bits_per_limb; }
@@ -36,8 +36,8 @@ template <typename Composer, typename Native> class uint_plookup {
     uint_plookup& operator=(const uint_plookup& other);
     uint_plookup& operator=(uint_plookup&& other);
 
-    explicit operator byte_array<Composer>() const;
-    explicit operator field_t<Composer>() const;
+    explicit operator byte_array<Builder>() const;
+    explicit operator field_t<Builder>() const;
 
     uint_plookup operator+(const uint_plookup& other) const;
     uint_plookup operator-(const uint_plookup& other) const;
@@ -64,13 +64,13 @@ template <typename Composer, typename Native> class uint_plookup {
         return rol(static_cast<size_t>(target_rotation.data[0]));
     }
 
-    bool_t<Composer> operator>(const uint_plookup& other) const;
-    bool_t<Composer> operator<(const uint_plookup& other) const;
-    bool_t<Composer> operator>=(const uint_plookup& other) const;
-    bool_t<Composer> operator<=(const uint_plookup& other) const;
-    bool_t<Composer> operator==(const uint_plookup& other) const;
-    bool_t<Composer> operator!=(const uint_plookup& other) const;
-    bool_t<Composer> operator!() const;
+    bool_t<Builder> operator>(const uint_plookup& other) const;
+    bool_t<Builder> operator<(const uint_plookup& other) const;
+    bool_t<Builder> operator>=(const uint_plookup& other) const;
+    bool_t<Builder> operator<=(const uint_plookup& other) const;
+    bool_t<Builder> operator==(const uint_plookup& other) const;
+    bool_t<Builder> operator!=(const uint_plookup& other) const;
+    bool_t<Builder> operator!() const;
 
     uint_plookup operator+=(const uint_plookup& other)
     {
@@ -130,9 +130,9 @@ template <typename Composer, typename Native> class uint_plookup {
     uint256_t get_value() const;
 
     bool is_constant() const { return witness_index == IS_CONSTANT; }
-    Composer* get_context() const { return context; }
+    Builder* get_context() const { return context; }
 
-    bool_t<Composer> at(const size_t bit_index) const;
+    bool_t<Builder> at(const size_t bit_index) const;
 
     size_t get_width() const { return width; }
 
@@ -144,7 +144,7 @@ template <typename Composer, typename Native> class uint_plookup {
     uint256_t get_unbounded_value() const;
 
   protected:
-    Composer* context;
+    Builder* context;
 
     enum WitnessStatus { OK, NOT_NORMALIZED, WEAK_NORMALIZED };
 
diff --git a/barretenberg/cpp/src/barretenberg/stdlib/primitives/uint/uint.cpp b/barretenberg/cpp/src/barretenberg/stdlib/primitives/uint/uint.cpp
index 2e14c6c0bf9..0d48d22759a 100644
--- a/barretenberg/cpp/src/barretenberg/stdlib/primitives/uint/uint.cpp
+++ b/barretenberg/cpp/src/barretenberg/stdlib/primitives/uint/uint.cpp
@@ -10,18 +10,18 @@ namespace stdlib {
 /**
  * @brief  In the case of TurboPLONK, range constrain the given witness.
  */
-template <typename Composer, typename Native>
-std::vector<uint32_t> uint<Composer, Native>::constrain_accumulators(Composer* context,
-                                                                     const uint32_t witness_index,
-                                                                     const size_t num_bits,
-                                                                     std::string const& msg) const
+template <typename Builder, typename Native>
+std::vector<uint32_t> uint<Builder, Native>::constrain_accumulators(Builder* context,
+                                                                    const uint32_t witness_index,
+                                                                    const size_t num_bits,
+                                                                    std::string const& msg) const
 {
-    if constexpr (HasPlookup<Composer>) {
+    if constexpr (HasPlookup<Builder>) {
         // TODO: manage higher bit ranges
-        const auto sequence = plookup_read<Composer>::get_lookup_accumulators(
+        const auto sequence = plookup_read<Builder>::get_lookup_accumulators(
             plookup::MultiTableId::UINT32_XOR,
-            field_t<Composer>::from_witness_index(context, witness_index),
-            field_t<Composer>::from_witness_index(context, context->zero_idx),
+            field_t<Builder>::from_witness_index(context, witness_index),
+            field_t<Builder>::from_witness_index(context, context->zero_idx),
             true);
 
         std::vector<uint32_t> out(num_accumulators());
@@ -33,8 +33,8 @@ std::vector<uint32_t> uint<Composer, Native>::constrain_accumulators(Composer* c
     return context->decompose_into_base4_accumulators(witness_index, num_bits, msg);
 }
 
-template <typename Composer, typename Native>
-uint<Composer, Native>::uint(const witness_t<Composer>& witness)
+template <typename Builder, typename Native>
+uint<Builder, Native>::uint(const witness_t<Builder>& witness)
     : context(witness.context)
     , additive_constant(0)
     , witness_status(WitnessStatus::OK)
@@ -43,8 +43,8 @@ uint<Composer, Native>::uint(const witness_t<Composer>& witness)
     , witness_index(accumulators[num_accumulators() - 1])
 {}
 
-template <typename Composer, typename Native>
-uint<Composer, Native>::uint(const field_t<Composer>& value)
+template <typename Builder, typename Native>
+uint<Builder, Native>::uint(const field_t<Builder>& value)
     : context(value.context)
     , additive_constant(0)
     , witness_status(WitnessStatus::OK)
@@ -54,24 +54,24 @@ uint<Composer, Native>::uint(const field_t<Composer>& value)
     if (value.witness_index == IS_CONSTANT) {
         additive_constant = value.additive_constant;
     } else {
-        field_t<Composer> norm = value.normalize();
+        field_t<Builder> norm = value.normalize();
         accumulators = constrain_accumulators(
             context, norm.witness_index, width, "uint: range constraint fails in constructor of uint from field_t");
         witness_index = accumulators[num_accumulators() - 1];
     }
 }
 
-template <typename Composer, typename Native>
-uint<Composer, Native>::uint(Composer* composer, const uint256_t& value)
-    : context(composer)
+template <typename Builder, typename Native>
+uint<Builder, Native>::uint(Builder* builder, const uint256_t& value)
+    : context(builder)
     , additive_constant(value)
     , witness_status(WitnessStatus::OK)
     , accumulators()
     , witness_index(IS_CONSTANT)
 {}
 
-template <typename Composer, typename Native>
-uint<Composer, Native>::uint(const uint256_t& value)
+template <typename Builder, typename Native>
+uint<Builder, Native>::uint(const uint256_t& value)
     : context(nullptr)
     , additive_constant(value)
     , witness_status(WitnessStatus::OK)
@@ -79,8 +79,8 @@ uint<Composer, Native>::uint(const uint256_t& value)
     , witness_index(IS_CONSTANT)
 {}
 
-template <typename Composer, typename Native>
-uint<Composer, Native>::uint(const byte_array<Composer>& other)
+template <typename Builder, typename Native>
+uint<Builder, Native>::uint(const byte_array<Builder>& other)
     : context(other.get_context())
     , additive_constant(0)
     , witness_status(WitnessStatus::WEAK_NORMALIZED)
@@ -88,8 +88,8 @@ uint<Composer, Native>::uint(const byte_array<Composer>& other)
     , witness_index(IS_CONSTANT)
 {
     ASSERT(other.bytes().size() <= sizeof(Native));
-    field_t<Composer> accumulator(context, fr::zero());
-    field_t<Composer> scaling_factor(context, fr::one());
+    field_t<Builder> accumulator(context, fr::zero());
+    field_t<Builder> scaling_factor(context, fr::one());
     const auto bytes = other.bytes();
     for (size_t i = 0; i < bytes.size(); ++i) {
         accumulator = accumulator + scaling_factor * bytes[bytes.size() - 1 - i];
@@ -103,23 +103,23 @@ uint<Composer, Native>::uint(const byte_array<Composer>& other)
     }
 }
 
-template <typename Composer, typename Native>
-uint<Composer, Native>::uint(Composer* parent_context, const std::array<bool_t<Composer>, width>& wires)
-    : uint<Composer, Native>(parent_context, std::vector<bool_t<Composer>>(wires.begin(), wires.end()))
+template <typename Builder, typename Native>
+uint<Builder, Native>::uint(Builder* parent_context, const std::array<bool_t<Builder>, width>& wires)
+    : uint<Builder, Native>(parent_context, std::vector<bool_t<Builder>>(wires.begin(), wires.end()))
 {}
 
-template <typename Composer, typename Native>
-uint<Composer, Native>::uint(Composer* parent_context, const std::vector<bool_t<Composer>>& wires)
+template <typename Builder, typename Native>
+uint<Builder, Native>::uint(Builder* parent_context, const std::vector<bool_t<Builder>>& wires)
     : context(parent_context)
     , additive_constant(0)
     , witness_status(WitnessStatus::WEAK_NORMALIZED)
     , accumulators()
     , witness_index(IS_CONSTANT)
 {
-    field_t<Composer> accumulator(context, fr::zero());
-    field_t<Composer> scaling_factor(context, fr::one());
+    field_t<Builder> accumulator(context, fr::zero());
+    field_t<Builder> scaling_factor(context, fr::one());
     for (size_t i = 0; i < wires.size(); ++i) {
-        accumulator = accumulator + scaling_factor * field_t<Composer>(wires[i]);
+        accumulator = accumulator + scaling_factor * field_t<Builder>(wires[i]);
         scaling_factor = scaling_factor + scaling_factor;
     }
     accumulator = accumulator.normalize();
@@ -130,8 +130,8 @@ uint<Composer, Native>::uint(Composer* parent_context, const std::vector<bool_t<
     }
 }
 
-template <typename Composer, typename Native>
-uint<Composer, Native>::uint(const uint& other)
+template <typename Builder, typename Native>
+uint<Builder, Native>::uint(const uint& other)
     : context(other.context)
     , additive_constant(other.additive_constant)
     , witness_status(other.witness_status)
@@ -139,8 +139,8 @@ uint<Composer, Native>::uint(const uint& other)
     , witness_index(other.witness_index)
 {}
 
-template <typename Composer, typename Native>
-uint<Composer, Native>::uint(uint&& other)
+template <typename Builder, typename Native>
+uint<Builder, Native>::uint(uint&& other)
     : context(other.context)
     , additive_constant(other.additive_constant)
     , witness_status(other.witness_status)
@@ -148,8 +148,7 @@ uint<Composer, Native>::uint(uint&& other)
     , witness_index(other.witness_index)
 {}
 
-template <typename Composer, typename Native>
-uint<Composer, Native>& uint<Composer, Native>::operator=(const uint& other)
+template <typename Builder, typename Native> uint<Builder, Native>& uint<Builder, Native>::operator=(const uint& other)
 {
     context = other.context;
     additive_constant = other.additive_constant;
@@ -159,7 +158,7 @@ uint<Composer, Native>& uint<Composer, Native>::operator=(const uint& other)
     return *this;
 }
 
-template <typename Composer, typename Native> uint<Composer, Native>& uint<Composer, Native>::operator=(uint&& other)
+template <typename Builder, typename Native> uint<Builder, Native>& uint<Builder, Native>::operator=(uint&& other)
 {
     context = other.context;
     additive_constant = other.additive_constant;
@@ -189,7 +188,7 @@ template <typename Context, typename Native> uint<Context, Native>::operator byt
  * @details This function also updates the witness and zeroes out the additive constant.
  * It does not add any range constraints.
  */
-template <typename Composer, typename Native> uint<Composer, Native> uint<Composer, Native>::weak_normalize() const
+template <typename Builder, typename Native> uint<Builder, Native> uint<Builder, Native>::weak_normalize() const
 {
     if (!context || is_constant()) {
         return *this;
@@ -215,15 +214,15 @@ template <typename Composer, typename Native> uint<Composer, Native> uint<Compos
         const uint256_t value = get_unbounded_value();
         const uint256_t overflow = value >> width;
         const uint256_t remainder = value & MASK;
-        const add_quad_<typename Composer::FF> gate{ .a = witness_index,
-                                                     .b = context->zero_idx,
-                                                     .c = context->add_variable(remainder),
-                                                     .d = context->add_variable(overflow),
-                                                     .a_scaling = fr::one(),
-                                                     .b_scaling = fr::zero(),
-                                                     .c_scaling = fr::neg_one(),
-                                                     .d_scaling = -fr(CIRCUIT_UINT_MAX_PLUS_ONE),
-                                                     .const_scaling = (additive_constant & MASK) };
+        const add_quad_<typename Builder::FF> gate{ .a = witness_index,
+                                                    .b = context->zero_idx,
+                                                    .c = context->add_variable(remainder),
+                                                    .d = context->add_variable(overflow),
+                                                    .a_scaling = fr::one(),
+                                                    .b_scaling = fr::zero(),
+                                                    .c_scaling = fr::neg_one(),
+                                                    .d_scaling = -fr(CIRCUIT_UINT_MAX_PLUS_ONE),
+                                                    .const_scaling = (additive_constant & MASK) };
 
         context->create_balanced_add_gate(gate);
 
@@ -237,7 +236,7 @@ template <typename Composer, typename Native> uint<Composer, Native> uint<Compos
 /**
  * @brief For non-constants, weakly normalize and constrain the updated witness to width-many bits.
  */
-template <typename Composer, typename Native> uint<Composer, Native> uint<Composer, Native>::normalize() const
+template <typename Builder, typename Native> uint<Builder, Native> uint<Builder, Native>::normalize() const
 {
     if (!context || is_constant()) {
         return *this;
@@ -253,7 +252,7 @@ template <typename Composer, typename Native> uint<Composer, Native> uint<Compos
     if (witness_status == WitnessStatus::NOT_NORMALIZED) {
         weak_normalize();
         /**
-         * constrain_accumulators will do more for PlookupComposer, but in TurboPLONK it just imposes
+         * constrain_accumulators will do more for PlookupBuilder, but in TurboPLONK it just imposes
          * the range constraint that the witness can be expressed in width-many bits.
          *
          * The Turbo-only strategy for imposing a range constraint on a w is develop a base-4 expansion
@@ -269,7 +268,7 @@ template <typename Composer, typename Native> uint<Composer, Native> uint<Compos
     return *this;
 }
 
-template <typename Composer, typename Native> uint256_t uint<Composer, Native>::get_value() const
+template <typename Builder, typename Native> uint256_t uint<Builder, Native>::get_value() const
 {
     if (!context || is_constant()) {
         return additive_constant;
@@ -277,7 +276,7 @@ template <typename Composer, typename Native> uint256_t uint<Composer, Native>::
     return (uint256_t(context->get_variable(witness_index)) + additive_constant) & MASK;
 }
 
-template <typename Composer, typename Native> uint256_t uint<Composer, Native>::get_unbounded_value() const
+template <typename Builder, typename Native> uint256_t uint<Builder, Native>::get_unbounded_value() const
 {
     if (!context || is_constant()) {
         return additive_constant;
@@ -291,10 +290,10 @@ template <typename Composer, typename Native> uint256_t uint<Composer, Native>::
  * between the case where that bit is the low bit of a quad or a high bit of a quad.
  *
  **/
-template <typename Composer, typename Native> bool_t<Composer> uint<Composer, Native>::at(const size_t bit_index) const
+template <typename Builder, typename Native> bool_t<Builder> uint<Builder, Native>::at(const size_t bit_index) const
 {
     if (is_constant()) {
-        return bool_t<Composer>(context, get_value().get_bit(bit_index));
+        return bool_t<Builder>(context, get_value().get_bit(bit_index));
     }
 
     if (witness_status != WitnessStatus::OK) {
@@ -317,18 +316,18 @@ template <typename Composer, typename Native> bool_t<Composer> uint<Composer, Na
     uint256_t quad =
         uint256_t(context->get_variable(right_idx)) - uint256_t(context->get_variable(left_idx)) * uint256_t(4);
 
-    if constexpr (HasPlookup<Composer>) {
+    if constexpr (HasPlookup<Builder>) {
         uint256_t lo_bit = quad & 1;
         uint256_t hi_bit = (quad & 2) >> 1;
         // difference in quads = 0, 1, 2, 3 = delta
         // (delta - lo_bit) / 2 \in [0, 1]
         // lo_bit \in [0, 1]
-        add_quad_<typename Composer::FF> gate{
+        add_quad_<typename Builder::FF> gate{
             context->add_variable(lo_bit), context->add_variable(hi_bit), right_idx, left_idx, 1, 2, -1, 4, 0,
         };
         context->create_new_range_constraint(gate.a, 1);
         context->create_new_range_constraint(gate.b, 1);
-        bool_t<Composer> result;
+        bool_t<Builder> result;
 
         if ((bit_index & 1UL) == 0UL) {
             result.witness_index = gate.a;
@@ -352,22 +351,22 @@ template <typename Composer, typename Native> bool_t<Composer> uint<Composer, Na
     if ((bit_index & 1UL) == 0UL) {
         // we want a low bit
         uint256_t lo_bit = quad & 1;
-        add_quad_<typename Composer::FF> gate{ .a = context->add_variable(lo_bit),
-                                               .b = context->zero_idx,
-                                               .c = right_idx,
-                                               .d = left_idx,
-                                               .a_scaling = fr(3),
-                                               .b_scaling = fr::zero(),
-                                               .c_scaling = -fr(3),
-                                               .d_scaling = fr(12),
-                                               .const_scaling = fr::zero() };
+        add_quad_<typename Builder::FF> gate{ .a = context->add_variable(lo_bit),
+                                              .b = context->zero_idx,
+                                              .c = right_idx,
+                                              .d = left_idx,
+                                              .a_scaling = fr(3),
+                                              .b_scaling = fr::zero(),
+                                              .c_scaling = -fr(3),
+                                              .d_scaling = fr(12),
+                                              .const_scaling = fr::zero() };
         /** constraint:
          *    3 lo_bit + 0 * 0 - 3 a_pivot + 12 a_{pivot - 1} + 0 + 6 high bit of (A_pivot - 4 A_{pivot - 1}) == 0
          *  i.e.,
          *    lo_bit + 2 high bit of (A_pivot - 4 A_{pivot - 1}) = A_pivot - 4 A_{pivot - 1} == 0
          */
         context->create_big_add_gate_with_bit_extraction(gate);
-        bool_t<Composer> result(context);
+        bool_t<Builder> result(context);
         result.witness_index = gate.a;
         result.witness_bool = (lo_bit == 1) ? true : false;
         return result;
@@ -376,15 +375,15 @@ template <typename Composer, typename Native> bool_t<Composer> uint<Composer, Na
     // if 'index' is odd, we want a high bit
     uint256_t hi_bit = quad >> 1;
 
-    add_quad_<typename Composer::FF> gate{ .a = context->zero_idx,
-                                           .b = context->add_variable(hi_bit),
-                                           .c = right_idx,
-                                           .d = left_idx,
-                                           .a_scaling = fr::zero(),
-                                           .b_scaling = -fr(6),
-                                           .c_scaling = fr::zero(),
-                                           .d_scaling = fr::zero(),
-                                           .const_scaling = fr::zero() };
+    add_quad_<typename Builder::FF> gate{ .a = context->zero_idx,
+                                          .b = context->add_variable(hi_bit),
+                                          .c = right_idx,
+                                          .d = left_idx,
+                                          .a_scaling = fr::zero(),
+                                          .b_scaling = -fr(6),
+                                          .c_scaling = fr::zero(),
+                                          .d_scaling = fr::zero(),
+                                          .const_scaling = fr::zero() };
 
     /**
      * constraint:
@@ -393,7 +392,7 @@ template <typename Composer, typename Native> bool_t<Composer> uint<Composer, Na
      * bit extraction gate is trusted to correctly extract 6 * (high bit c - 4d).
      */
     context->create_big_add_gate_with_bit_extraction(gate);
-    bool_t<Composer> result(context);
+    bool_t<Builder> result(context);
     result.witness_index = gate.b;
     result.witness_bool = (hi_bit == 1) ? true : false;
     return result;
diff --git a/barretenberg/cpp/src/barretenberg/stdlib/primitives/uint/uint.fuzzer.hpp b/barretenberg/cpp/src/barretenberg/stdlib/primitives/uint/uint.fuzzer.hpp
index 20ab5fa3618..77c17242e4b 100644
--- a/barretenberg/cpp/src/barretenberg/stdlib/primitives/uint/uint.fuzzer.hpp
+++ b/barretenberg/cpp/src/barretenberg/stdlib/primitives/uint/uint.fuzzer.hpp
@@ -30,15 +30,15 @@ FastRandom VarianceRNG(0);
  * @brief The class parametrizing Uint fuzzing instructions, execution, etc
  *
  */
-template <typename Composer> class UintFuzzBase {
+template <typename Builder> class UintFuzzBase {
   private:
-    typedef proof_system::plonk::stdlib::bool_t<Composer> bool_t;
-    typedef proof_system::plonk::stdlib::uint<Composer, uint8_t> uint_8_t;
-    typedef proof_system::plonk::stdlib::uint<Composer, uint16_t> uint_16_t;
-    typedef proof_system::plonk::stdlib::uint<Composer, uint32_t> uint_32_t;
-    typedef proof_system::plonk::stdlib::uint<Composer, uint64_t> uint_64_t;
-    typedef proof_system::plonk::stdlib::field_t<Composer> field_t;
-    typedef proof_system::plonk::stdlib::byte_array<Composer> byte_array_t;
+    typedef proof_system::plonk::stdlib::bool_t<Builder> bool_t;
+    typedef proof_system::plonk::stdlib::uint<Builder, uint8_t> uint_8_t;
+    typedef proof_system::plonk::stdlib::uint<Builder, uint16_t> uint_16_t;
+    typedef proof_system::plonk::stdlib::uint<Builder, uint32_t> uint_32_t;
+    typedef proof_system::plonk::stdlib::uint<Builder, uint64_t> uint_64_t;
+    typedef proof_system::plonk::stdlib::field_t<Builder> field_t;
+    typedef proof_system::plonk::stdlib::byte_array<Builder> byte_array_t;
 
     template <class From, class To> static To from_to(const From& in, const std::optional<size_t> size = std::nullopt)
     {
@@ -387,9 +387,9 @@ template <typename Composer> class UintFuzzBase {
 
             return ret;
         }
-        template <class T> static T get_bit(Composer* composer, const T& v, const size_t bit)
+        template <class T> static T get_bit(Builder* builder, const T& v, const size_t bit)
         {
-            return T(composer, std::vector<bool_t>{ at<>(v, bit) });
+            return T(builder, std::vector<bool_t>{ at<>(v, bit) });
         }
         template <class T> static std::vector<bool_t> to_bit_vector(const T& v)
         {
@@ -457,11 +457,11 @@ template <typename Composer> class UintFuzzBase {
                 , v32(v32)
                 , v64(v64)
             {}
-            Uint(Composer* composer, const uint64_t v)
-                : v8(composer, static_cast<uint8_t>(v & 0xFF))
-                , v16(composer, static_cast<uint16_t>(v & 0xFFFF))
-                , v32(composer, static_cast<uint32_t>(v & 0xFFFFFFFF))
-                , v64(composer, v)
+            Uint(Builder* builder, const uint64_t v)
+                : v8(builder, static_cast<uint8_t>(v & 0xFF))
+                , v16(builder, static_cast<uint16_t>(v & 0xFFFF))
+                , v32(builder, static_cast<uint32_t>(v & 0xFFFFFFFF))
+                , v64(builder, v)
             {}
         };
         class Reference {
@@ -761,16 +761,16 @@ template <typename Composer> class UintFuzzBase {
                 abort();
             }
         }
-        ExecutionHandler get_bit(Composer* composer, const size_t bit) const
+        ExecutionHandler get_bit(Builder* builder, const size_t bit) const
         {
             return ExecutionHandler(Reference(this->get_bit<uint8_t>(this->ref.v8, bit),
                                               this->get_bit<uint16_t>(this->ref.v16, bit),
                                               this->get_bit<uint32_t>(this->ref.v32, bit),
                                               this->get_bit<uint64_t>(this->ref.v64, bit)),
-                                    Uint(this->get_bit<uint_8_t>(composer, this->uint.v8, bit),
-                                         this->get_bit<uint_16_t>(composer, this->uint.v16, bit),
-                                         this->get_bit<uint_32_t>(composer, this->uint.v32, bit),
-                                         this->get_bit<uint_64_t>(composer, this->uint.v64, bit)));
+                                    Uint(this->get_bit<uint_8_t>(builder, this->uint.v8, bit),
+                                         this->get_bit<uint_16_t>(builder, this->uint.v16, bit),
+                                         this->get_bit<uint_32_t>(builder, this->uint.v32, bit),
+                                         this->get_bit<uint_64_t>(builder, this->uint.v64, bit)));
         }
         ExecutionHandler shl(const size_t bits) const
         {
@@ -860,7 +860,7 @@ template <typename Composer> class UintFuzzBase {
                                     Uint(~this->uint.v8, ~this->uint.v16, ~this->uint.v32, ~this->uint.v64));
         }
         /* Explicit re-instantiation using the various constructors */
-        ExecutionHandler set(Composer* composer) const
+        ExecutionHandler set(Builder* builder) const
         {
             switch (VarianceRNG.next() % 7) {
             case 0:
@@ -871,10 +871,10 @@ template <typename Composer> class UintFuzzBase {
                                              uint_64_t(this->uint.v64)));
             case 1:
                 return ExecutionHandler(this->ref,
-                                        Uint(uint_8_t(composer, get_value<>(this->uint.v8)),
-                                             uint_16_t(composer, get_value<>(this->uint.v16)),
-                                             uint_32_t(composer, get_value<>(this->uint.v32)),
-                                             uint_64_t(composer, get_value<>(this->uint.v64))));
+                                        Uint(uint_8_t(builder, get_value<>(this->uint.v8)),
+                                             uint_16_t(builder, get_value<>(this->uint.v16)),
+                                             uint_32_t(builder, get_value<>(this->uint.v32)),
+                                             uint_64_t(builder, get_value<>(this->uint.v64))));
             case 2:
                 return ExecutionHandler(this->ref,
                                         Uint(uint_8_t(this->to_field_t(this->uint.v8)),
@@ -889,22 +889,22 @@ template <typename Composer> class UintFuzzBase {
                                              uint_64_t(this->to_byte_array(this->uint.v64))));
             case 4:
                 return ExecutionHandler(this->ref,
-                                        Uint(uint_8_t(composer, this->to_bit_vector(this->uint.v8)),
-                                             uint_16_t(composer, this->to_bit_vector(this->uint.v16)),
-                                             uint_32_t(composer, this->to_bit_vector(this->uint.v32)),
-                                             uint_64_t(composer, this->to_bit_vector(this->uint.v64))));
+                                        Uint(uint_8_t(builder, this->to_bit_vector(this->uint.v8)),
+                                             uint_16_t(builder, this->to_bit_vector(this->uint.v16)),
+                                             uint_32_t(builder, this->to_bit_vector(this->uint.v32)),
+                                             uint_64_t(builder, this->to_bit_vector(this->uint.v64))));
             case 5:
                 return ExecutionHandler(this->ref,
-                                        Uint(uint_8_t(composer, this->to_bit_array(this->uint.v8)),
-                                             uint_16_t(composer, this->to_bit_array(this->uint.v16)),
-                                             uint_32_t(composer, this->to_bit_array(this->uint.v32)),
-                                             uint_64_t(composer, this->to_bit_array(this->uint.v64))));
+                                        Uint(uint_8_t(builder, this->to_bit_array(this->uint.v8)),
+                                             uint_16_t(builder, this->to_bit_array(this->uint.v16)),
+                                             uint_32_t(builder, this->to_bit_array(this->uint.v32)),
+                                             uint_64_t(builder, this->to_bit_array(this->uint.v64))));
             case 6:
                 return ExecutionHandler(this->ref,
-                                        Uint(uint_8_t(composer, this->ref.v8),
-                                             uint_16_t(composer, this->ref.v16),
-                                             uint_32_t(composer, this->ref.v32),
-                                             uint_64_t(composer, this->ref.v64)));
+                                        Uint(uint_8_t(builder, this->ref.v8),
+                                             uint_16_t(builder, this->ref.v16),
+                                             uint_32_t(builder, this->ref.v32),
+                                             uint_64_t(builder, this->ref.v64)));
             default:
                 abort();
             }
@@ -912,31 +912,31 @@ template <typename Composer> class UintFuzzBase {
         /**
          * @brief Execute the constant instruction (push constant safeuint to the stack)
          *
-         * @param composer
+         * @param builder
          * @param stack
          * @param instruction
          * @return 0 if everything is ok, 1 if we should stop execution, since an expected error was encountered
          */
-        static inline size_t execute_CONSTANT(Composer* composer,
+        static inline size_t execute_CONSTANT(Builder* builder,
                                               std::vector<ExecutionHandler>& stack,
                                               Instruction& instruction)
         {
-            stack.push_back(Uint(composer, instruction.arguments.element));
+            stack.push_back(Uint(builder, instruction.arguments.element));
             return 0;
         }
         /**
          * @brief Execute the addition operator instruction
          *
-         * @param composer
+         * @param builder
          * @param stack
          * @param instruction
          * @return if everything is ok, 1 if we should stop execution, since an expected error was encountered
          */
-        static inline size_t execute_ADD(Composer* composer,
+        static inline size_t execute_ADD(Builder* builder,
                                          std::vector<ExecutionHandler>& stack,
                                          Instruction& instruction)
         {
-            (void)composer;
+            (void)builder;
             if (stack.size() == 0) {
                 return 1;
             }
@@ -957,16 +957,16 @@ template <typename Composer> class UintFuzzBase {
         /**
          * @brief Execute the subtraction operator instruction
          *
-         * @param composer
+         * @param builder
          * @param stack
          * @param instruction
          * @return if everything is ok, 1 if we should stop execution, since an expected error was encountered
          */
-        static inline size_t execute_SUBTRACT(Composer* composer,
+        static inline size_t execute_SUBTRACT(Builder* builder,
                                               std::vector<ExecutionHandler>& stack,
                                               Instruction& instruction)
         {
-            (void)composer;
+            (void)builder;
             if (stack.size() == 0) {
                 return 1;
             }
@@ -987,16 +987,16 @@ template <typename Composer> class UintFuzzBase {
         /**
          * @brief Execute the multiply instruction
          *
-         * @param composer
+         * @param builder
          * @param stack
          * @param instruction
          * @return if everything is ok, 1 if we should stop execution, since an expected error was encountered
          */
-        static inline size_t execute_MULTIPLY(Composer* composer,
+        static inline size_t execute_MULTIPLY(Builder* builder,
                                               std::vector<ExecutionHandler>& stack,
                                               Instruction& instruction)
         {
-            (void)composer;
+            (void)builder;
             if (stack.size() == 0) {
                 return 1;
             }
@@ -1017,16 +1017,16 @@ template <typename Composer> class UintFuzzBase {
         /**
          * @brief Execute the division operator instruction
          *
-         * @param composer
+         * @param builder
          * @param stack
          * @param instruction
          * @return if everything is ok, 1 if we should stop execution, since an expected error was encountered
          */
-        static inline size_t execute_DIVIDE(Composer* composer,
+        static inline size_t execute_DIVIDE(Builder* builder,
                                             std::vector<ExecutionHandler>& stack,
                                             Instruction& instruction)
         {
-            (void)composer;
+            (void)builder;
             if (stack.size() == 0) {
                 return 1;
             }
@@ -1047,16 +1047,16 @@ template <typename Composer> class UintFuzzBase {
         /**
          * @brief Execute the modulo operator instruction
          *
-         * @param composer
+         * @param builder
          * @param stack
          * @param instruction
          * @return if everything is ok, 1 if we should stop execution, since an expected error was encountered
          */
-        static inline size_t execute_MODULO(Composer* composer,
+        static inline size_t execute_MODULO(Builder* builder,
                                             std::vector<ExecutionHandler>& stack,
                                             Instruction& instruction)
         {
-            (void)composer;
+            (void)builder;
             if (stack.size() == 0) {
                 return 1;
             }
@@ -1077,16 +1077,16 @@ template <typename Composer> class UintFuzzBase {
         /**
          * @brief Execute the and operator instruction
          *
-         * @param composer
+         * @param builder
          * @param stack
          * @param instruction
          * @return if everything is ok, 1 if we should stop execution, since an expected error was encountered
          */
-        static inline size_t execute_AND(Composer* composer,
+        static inline size_t execute_AND(Builder* builder,
                                          std::vector<ExecutionHandler>& stack,
                                          Instruction& instruction)
         {
-            (void)composer;
+            (void)builder;
             if (stack.size() == 0) {
                 return 1;
             }
@@ -1107,16 +1107,16 @@ template <typename Composer> class UintFuzzBase {
         /**
          * @brief Execute the or operator instruction
          *
-         * @param composer
+         * @param builder
          * @param stack
          * @param instruction
          * @return if everything is ok, 1 if we should stop execution, since an expected error was encountered
          */
-        static inline size_t execute_OR(Composer* composer,
+        static inline size_t execute_OR(Builder* builder,
                                         std::vector<ExecutionHandler>& stack,
                                         Instruction& instruction)
         {
-            (void)composer;
+            (void)builder;
             if (stack.size() == 0) {
                 return 1;
             }
@@ -1137,16 +1137,16 @@ template <typename Composer> class UintFuzzBase {
         /**
          * @brief Execute the xor operator instruction
          *
-         * @param composer
+         * @param builder
          * @param stack
          * @param instruction
          * @return if everything is ok, 1 if we should stop execution, since an expected error was encountered
          */
-        static inline size_t execute_XOR(Composer* composer,
+        static inline size_t execute_XOR(Builder* builder,
                                          std::vector<ExecutionHandler>& stack,
                                          Instruction& instruction)
         {
-            (void)composer;
+            (void)builder;
             if (stack.size() == 0) {
                 return 1;
             }
@@ -1167,12 +1167,12 @@ template <typename Composer> class UintFuzzBase {
         /**
          * @brief Execute the GET_BIT instruction
          *
-         * @param composer
+         * @param builder
          * @param stack
          * @param instruction
          * @return if everything is ok, 1 if we should stop execution, since an expected error was encountered
          */
-        static inline size_t execute_GET_BIT(Composer* composer,
+        static inline size_t execute_GET_BIT(Builder* builder,
                                              std::vector<ExecutionHandler>& stack,
                                              Instruction& instruction)
         {
@@ -1183,7 +1183,7 @@ template <typename Composer> class UintFuzzBase {
             size_t output_index = instruction.arguments.bitArgs.out;
             const uint64_t bit = instruction.arguments.bitArgs.bit;
             ExecutionHandler result;
-            result = stack[first_index].get_bit(composer, bit);
+            result = stack[first_index].get_bit(builder, bit);
             // If the output index is larger than the number of elements in stack, append
             if (output_index >= stack.size()) {
                 stack.push_back(result);
@@ -1195,16 +1195,16 @@ template <typename Composer> class UintFuzzBase {
         /**
          * @brief Execute the left-shift operator instruction
          *
-         * @param composer
+         * @param builder
          * @param stack
          * @param instruction
          * @return if everything is ok, 1 if we should stop execution, since an expected error was encountered
          */
-        static inline size_t execute_SHL(Composer* composer,
+        static inline size_t execute_SHL(Builder* builder,
                                          std::vector<ExecutionHandler>& stack,
                                          Instruction& instruction)
         {
-            (void)composer;
+            (void)builder;
             if (stack.size() == 0) {
                 return 1;
             }
@@ -1224,16 +1224,16 @@ template <typename Composer> class UintFuzzBase {
         /**
          * @brief Execute the right-shift operator instruction
          *
-         * @param composer
+         * @param builder
          * @param stack
          * @param instruction
          * @return if everything is ok, 1 if we should stop execution, since an expected error was encountered
          */
-        static inline size_t execute_SHR(Composer* composer,
+        static inline size_t execute_SHR(Builder* builder,
                                          std::vector<ExecutionHandler>& stack,
                                          Instruction& instruction)
         {
-            (void)composer;
+            (void)builder;
             if (stack.size() == 0) {
                 return 1;
             }
@@ -1253,16 +1253,16 @@ template <typename Composer> class UintFuzzBase {
         /**
          * @brief Execute the left-rotate operator instruction
          *
-         * @param composer
+         * @param builder
          * @param stack
          * @param instruction
          * @return if everything is ok, 1 if we should stop execution, since an expected error was encountered
          */
-        static inline size_t execute_ROL(Composer* composer,
+        static inline size_t execute_ROL(Builder* builder,
                                          std::vector<ExecutionHandler>& stack,
                                          Instruction& instruction)
         {
-            (void)composer;
+            (void)builder;
             if (stack.size() == 0) {
                 return 1;
             }
@@ -1282,16 +1282,16 @@ template <typename Composer> class UintFuzzBase {
         /**
          * @brief Execute the right-rotate operator instruction
          *
-         * @param composer
+         * @param builder
          * @param stack
          * @param instruction
          * @return if everything is ok, 1 if we should stop execution, since an expected error was encountered
          */
-        static inline size_t execute_ROR(Composer* composer,
+        static inline size_t execute_ROR(Builder* builder,
                                          std::vector<ExecutionHandler>& stack,
                                          Instruction& instruction)
         {
-            (void)composer;
+            (void)builder;
             if (stack.size() == 0) {
                 return 1;
             }
@@ -1311,16 +1311,16 @@ template <typename Composer> class UintFuzzBase {
         /**
          * @brief Execute the NOT instruction
          *
-         * @param composer
+         * @param builder
          * @param stack
          * @param instruction
          * @return if everything is ok, 1 if we should stop execution, since an expected error was encountered
          */
-        static inline size_t execute_NOT(Composer* composer,
+        static inline size_t execute_NOT(Builder* builder,
                                          std::vector<ExecutionHandler>& stack,
                                          Instruction& instruction)
         {
-            (void)composer;
+            (void)builder;
             if (stack.size() == 0) {
                 return 1;
             }
@@ -1340,12 +1340,12 @@ template <typename Composer> class UintFuzzBase {
         /**
          * @brief Execute the SET instruction
          *
-         * @param composer
+         * @param builder
          * @param stack
          * @param instruction
          * @return if everything is ok, 1 if we should stop execution, since an expected error was encountered
          */
-        static inline size_t execute_SET(Composer* composer,
+        static inline size_t execute_SET(Builder* builder,
                                          std::vector<ExecutionHandler>& stack,
                                          Instruction& instruction)
         {
@@ -1356,7 +1356,7 @@ template <typename Composer> class UintFuzzBase {
             size_t output_index = instruction.arguments.twoArgs.out;
 
             ExecutionHandler result;
-            result = stack[first_index].set(composer);
+            result = stack[first_index].set(builder);
             // If the output index is larger than the number of elements in stack, append
             if (output_index >= stack.size()) {
                 stack.push_back(result);
@@ -1368,16 +1368,16 @@ template <typename Composer> class UintFuzzBase {
         /**
          * @brief Execute the RANDOMSEED instruction
          *
-         * @param composer
+         * @param builder
          * @param stack
          * @param instruction
          * @return if everything is ok, 1 if we should stop execution, since an expected error was encountered
          */
-        static inline size_t execute_RANDOMSEED(Composer* composer,
+        static inline size_t execute_RANDOMSEED(Builder* builder,
                                                 std::vector<ExecutionHandler>& stack,
                                                 Instruction& instruction)
         {
-            (void)composer;
+            (void)builder;
             (void)stack;
 
             VarianceRNG.reseed(instruction.arguments.randomseed);
@@ -1389,15 +1389,15 @@ template <typename Composer> class UintFuzzBase {
     /**
      * @brief Check that the resulting values are equal to expected
      *
-     * @tparam Composer
-     * @param composer
+     * @tparam Builder
+     * @param builder
      * @param stack
      * @return true
      * @return false
      */
-    inline static bool postProcess(Composer* composer, std::vector<UintFuzzBase::ExecutionHandler>& stack)
+    inline static bool postProcess(Builder* builder, std::vector<UintFuzzBase::ExecutionHandler>& stack)
     {
-        (void)composer;
+        (void)builder;
         for (size_t i = 0; i < stack.size(); i++) {
             auto element = stack[i];
             if (element.uint.v8.get_value() != element.ref.v8) {
@@ -1584,7 +1584,7 @@ extern "C" size_t LLVMFuzzerCustomCrossOver(const uint8_t* Data1,
  */
 extern "C" size_t LLVMFuzzerTestOneInput(const uint8_t* Data, size_t Size)
 {
-    RunWithComposers<UintFuzzBase, FuzzerCircuitTypes>(Data, Size, VarianceRNG);
+    RunWithBuilders<UintFuzzBase, FuzzerCircuitTypes>(Data, Size, VarianceRNG);
     return 0;
 }
 
diff --git a/barretenberg/cpp/src/barretenberg/stdlib/primitives/uint/uint.hpp b/barretenberg/cpp/src/barretenberg/stdlib/primitives/uint/uint.hpp
index f0606f2b425..06534c54d68 100644
--- a/barretenberg/cpp/src/barretenberg/stdlib/primitives/uint/uint.hpp
+++ b/barretenberg/cpp/src/barretenberg/stdlib/primitives/uint/uint.hpp
@@ -14,41 +14,41 @@ namespace stdlib {
  * @brief A standard library fixed-width unsigned integer type. Useful, e.g., for hashing.
  * Use safe_uint instead if looking to represent integer arithmetic inside of Fr.
  *
- * @tparam Composer The type of the composer context.
+ * @tparam Builder The type of the builder context.
  * @tparam Native   One of the native uint types uintN_t, where N = 8, 16, 32, 64.
  *
  * @details All arithmetic operations in Native is done modulo 2**N, and the same is true for
- * uint<Composer, Native>.
+ * uint<Builder, Native>.
  */
 
-template <typename Composer, typename Native> class uint {
+template <typename Builder, typename Native> class uint {
     // We only instantiate for widths 8, 16, 32 and 64, and only those widths were audited.
     static_assert((sizeof(Native) == 1) || (sizeof(Native) == 2) || (sizeof(Native) == 4) || (sizeof(Native) == 8));
 
   public:
     static constexpr size_t width = sizeof(Native) * 8;
 
-    uint(const witness_t<Composer>& other);
-    uint(const field_t<Composer>& other);
+    uint(const witness_t<Builder>& other);
+    uint(const field_t<Builder>& other);
     uint(const uint256_t& value = 0);
-    uint(Composer* composer, const uint256_t& value = 0);
-    uint(const byte_array<Composer>& other);
+    uint(Builder* builder, const uint256_t& value = 0);
+    uint(const byte_array<Builder>& other);
     // constructors used for bit arrays
-    uint(Composer* parent_context, const std::vector<bool_t<Composer>>& wires);
-    uint(Composer* parent_context, const std::array<bool_t<Composer>, width>& wires);
+    uint(Builder* parent_context, const std::vector<bool_t<Builder>>& wires);
+    uint(Builder* parent_context, const std::array<bool_t<Builder>, width>& wires);
 
     uint(const Native v)
         : uint(static_cast<uint256_t>(v))
     {}
 
-    std::vector<uint32_t> constrain_accumulators(Composer* ctx,
+    std::vector<uint32_t> constrain_accumulators(Builder* ctx,
                                                  const uint32_t witness_index,
                                                  const size_t num_bits,
                                                  std::string const& msg) const;
 
     static constexpr size_t num_accumulators()
     {
-        return (width + Composer::UINT_LOG2_BASE - 1) / Composer::UINT_LOG2_BASE;
+        return (width + Builder::UINT_LOG2_BASE - 1) / Builder::UINT_LOG2_BASE;
     }
 
     uint(const uint& other);
@@ -57,8 +57,8 @@ template <typename Composer, typename Native> class uint {
     uint& operator=(const uint& other);
     uint& operator=(uint&& other);
 
-    explicit operator byte_array<Composer>() const;
-    explicit operator field_t<Composer>() const;
+    explicit operator byte_array<Builder>() const;
+    explicit operator field_t<Builder>() const;
 
     uint operator+(const uint& other) const;
     uint operator-(const uint& other) const;
@@ -79,13 +79,13 @@ template <typename Composer, typename Native> class uint {
     uint ror(const uint256_t target_rotation) const { return ror(static_cast<size_t>(target_rotation.data[0])); }
     uint rol(const uint256_t target_rotation) const { return rol(static_cast<size_t>(target_rotation.data[0])); }
 
-    bool_t<Composer> operator>(const uint& other) const;
-    bool_t<Composer> operator<(const uint& other) const;
-    bool_t<Composer> operator>=(const uint& other) const;
-    bool_t<Composer> operator<=(const uint& other) const;
-    bool_t<Composer> operator==(const uint& other) const;
-    bool_t<Composer> operator!=(const uint& other) const;
-    bool_t<Composer> operator!() const;
+    bool_t<Builder> operator>(const uint& other) const;
+    bool_t<Builder> operator<(const uint& other) const;
+    bool_t<Builder> operator>=(const uint& other) const;
+    bool_t<Builder> operator<=(const uint& other) const;
+    bool_t<Builder> operator==(const uint& other) const;
+    bool_t<Builder> operator!=(const uint& other) const;
+    bool_t<Builder> operator!() const;
 
     uint operator+=(const uint& other)
     {
@@ -147,9 +147,9 @@ template <typename Composer, typename Native> class uint {
     uint256_t get_value() const;
 
     bool is_constant() const { return witness_index == IS_CONSTANT; }
-    Composer* get_context() const { return context; }
+    Builder* get_context() const { return context; }
 
-    bool_t<Composer> at(const size_t bit_index) const;
+    bool_t<Builder> at(const size_t bit_index) const;
 
     size_t get_width() const { return width; }
 
@@ -158,7 +158,7 @@ template <typename Composer, typename Native> class uint {
     uint256_t get_additive_constant() const { return additive_constant; }
 
   protected:
-    Composer* context;
+    Builder* context;
 
     enum WitnessStatus { OK, NOT_NORMALIZED, WEAK_NORMALIZED };
 
@@ -188,22 +188,18 @@ template <typename T, typename w> inline std::ostream& operator<<(std::ostream&
     return os << v.get_value();
 }
 
-template <typename ComposerContext>
-using uint8 = typename std::conditional<HasPlookup<ComposerContext>,
-                                        uint_plookup<ComposerContext, uint8_t>,
-                                        uint<ComposerContext, uint8_t>>::type;
-template <typename ComposerContext>
-using uint16 = typename std::conditional<HasPlookup<ComposerContext>,
-                                         uint_plookup<ComposerContext, uint16_t>,
-                                         uint<ComposerContext, uint16_t>>::type;
-template <typename ComposerContext>
-using uint32 = typename std::conditional<HasPlookup<ComposerContext>,
-                                         uint_plookup<ComposerContext, uint32_t>,
-                                         uint<ComposerContext, uint32_t>>::type;
-template <typename ComposerContext>
-using uint64 = typename std::conditional<HasPlookup<ComposerContext>,
-                                         uint_plookup<ComposerContext, uint64_t>,
-                                         uint<ComposerContext, uint64_t>>::type;
+template <typename Builder>
+using uint8 =
+    typename std::conditional<HasPlookup<Builder>, uint_plookup<Builder, uint8_t>, uint<Builder, uint8_t>>::type;
+template <typename Builder>
+using uint16 =
+    typename std::conditional<HasPlookup<Builder>, uint_plookup<Builder, uint16_t>, uint<Builder, uint16_t>>::type;
+template <typename Builder>
+using uint32 =
+    typename std::conditional<HasPlookup<Builder>, uint_plookup<Builder, uint32_t>, uint<Builder, uint32_t>>::type;
+template <typename Builder>
+using uint64 =
+    typename std::conditional<HasPlookup<Builder>, uint_plookup<Builder, uint64_t>, uint<Builder, uint64_t>>::type;
 
 EXTERN_STDLIB_BASIC_TYPE_VA(uint, uint8_t);
 EXTERN_STDLIB_BASIC_TYPE_VA(uint, uint16_t);
diff --git a/barretenberg/cpp/src/barretenberg/stdlib/primitives/uint/uint.test.cpp b/barretenberg/cpp/src/barretenberg/stdlib/primitives/uint/uint.test.cpp
index c51be33c6a3..afe25351e00 100644
--- a/barretenberg/cpp/src/barretenberg/stdlib/primitives/uint/uint.test.cpp
+++ b/barretenberg/cpp/src/barretenberg/stdlib/primitives/uint/uint.test.cpp
@@ -13,7 +13,7 @@ auto& engine = numeric::random::get_debug_engine();
 
 // NOTE: We only test width 32, but widths 8, 16, 32 and 64 can all be tested.
 //       In widths 8, 16, 32: all tests pass.
-//       In width 64, the following tests fail for UltraPlonkComposer.
+//       In width 64, the following tests fail for UltraPlonkBuilder.
 //           test_xor_special, test_xor_more_constants, test_and_constants, test_and_special, test_or_special,
 //           test_ror_special, test_hash_rounds, test_and, test_xor, test_or.
 // They fail with 'C++ exception with description"Last key slice greater than 64" thrown in the test body."'
@@ -74,13 +74,13 @@ uint_native rotate(uint_native value, size_t rotation)
                           static_cast<uint_native>(value << (uint_native_width - rotation))
                     : value;
 }
-template <typename Composer> class stdlib_uint : public testing::Test {
-    typedef typename std::conditional<std::same_as<Composer, UltraCircuitBuilder>,
-                                      stdlib::uint_plookup<Composer, uint_native>,
-                                      stdlib::uint<Composer, uint_native>>::type uint_ct;
-    typedef stdlib::bool_t<Composer> bool_ct;
-    typedef stdlib::witness_t<Composer> witness_ct;
-    typedef stdlib::byte_array<Composer> byte_array_ct;
+template <typename Builder> class stdlib_uint : public testing::Test {
+    typedef typename std::conditional<std::same_as<Builder, UltraCircuitBuilder>,
+                                      stdlib::uint_plookup<Builder, uint_native>,
+                                      stdlib::uint<Builder, uint_native>>::type uint_ct;
+    typedef stdlib::bool_t<Builder> bool_ct;
+    typedef stdlib::witness_t<Builder> witness_ct;
+    typedef stdlib::byte_array<Builder> byte_array_ct;
 
     static inline std::vector<uint_native> special_values{ 0U,
                                                            1U,
@@ -90,7 +90,7 @@ template <typename Composer> class stdlib_uint : public testing::Test {
                                                            static_cast<uint_native>((1 << uint_native_width / 2) + 1),
                                                            uint_native_max };
 
-    static std::vector<uint_ct> get_special_uints(Composer* ctx)
+    static std::vector<uint_ct> get_special_uints(Builder* ctx)
     {
         std::vector<uint_ct> special_uints;
         for (size_t i = 0; i != special_values.size(); ++i) {
@@ -103,7 +103,7 @@ template <typename Composer> class stdlib_uint : public testing::Test {
     static void test_weak_normalize()
     {
         auto run_test = [](bool constant_only, bool add_constant) {
-            Composer composer = Composer();
+            Builder builder = Builder();
             uint_ct a;
             uint_native a_val = get_random<uint_native>();
             uint_native const_a = get_random<uint_native>();
@@ -113,7 +113,7 @@ template <typename Composer> class stdlib_uint : public testing::Test {
                 a = const_a;
                 expected = const_a;
             } else {
-                a = witness_ct(&composer, a_val);
+                a = witness_ct(&builder, a_val);
                 expected = a_val;
                 if (add_constant) {
                     a += const_a;
@@ -122,7 +122,7 @@ template <typename Composer> class stdlib_uint : public testing::Test {
             };
 
             EXPECT_EQ(uint256_t(expected), a.get_value());
-            bool verified = composer.check_circuit();
+            bool verified = builder.check_circuit();
             EXPECT_EQ(verified, true);
         };
 
@@ -133,12 +133,12 @@ template <typename Composer> class stdlib_uint : public testing::Test {
 
     static void test_byte_array_conversion()
     {
-        Composer composer = Composer();
-        uint_ct a = witness_ct(&composer, 0x7f6f5f4f10111213);
+        Builder builder = Builder();
+        uint_ct a = witness_ct(&builder, 0x7f6f5f4f10111213);
         std::string longest_expected = { 0x7f, 0x6f, 0x5f, 0x4f, 0x10, 0x11, 0x12, 0x13 };
         // truncate, so we are running different tests for different choices of uint_native
         std::string expected = longest_expected.substr(longest_expected.length() - sizeof(uint_native));
-        byte_array_ct arr(&composer);
+        byte_array_ct arr(&builder);
         arr.write(static_cast<byte_array_ct>(a));
 
         EXPECT_EQ(arr.size(), sizeof(uint_native));
@@ -147,16 +147,16 @@ template <typename Composer> class stdlib_uint : public testing::Test {
 
     static void test_input_output_consistency()
     {
-        Composer composer = Composer();
+        Builder builder = Builder();
 
         for (size_t i = 1; i < 1024; i *= 2) {
             uint_native a_expected = (uint_native)i;
             uint_native b_expected = (uint_native)i;
 
-            uint_ct a = witness_ct(&composer, a_expected);
-            uint_ct b = witness_ct(&composer, b_expected);
+            uint_ct a = witness_ct(&builder, a_expected);
+            uint_ct b = witness_ct(&builder, b_expected);
 
-            byte_array_ct arr(&composer);
+            byte_array_ct arr(&builder);
 
             arr.write(static_cast<byte_array_ct>(a));
             arr.write(static_cast<byte_array_ct>(b));
@@ -173,9 +173,9 @@ template <typename Composer> class stdlib_uint : public testing::Test {
 
     static void test_create_from_wires()
     {
-        Composer composer = Composer();
+        Builder builder = Builder();
 
-        uint_ct a = uint_ct(&composer,
+        uint_ct a = uint_ct(&builder,
                             std::vector<bool_ct>{
                                 bool_ct(false),
                                 bool_ct(false),
@@ -184,7 +184,7 @@ template <typename Composer> class stdlib_uint : public testing::Test {
                                 bool_ct(false),
                                 bool_ct(false),
                                 bool_ct(false),
-                                witness_ct(&composer, true),
+                                witness_ct(&builder, true),
                             });
 
         EXPECT_EQ(a.at(0).get_value(), false);
@@ -197,10 +197,10 @@ template <typename Composer> class stdlib_uint : public testing::Test {
      * */
     static void test_add_special()
     {
-        Composer composer = Composer();
+        Builder builder = Builder();
 
-        witness_ct first_input(&composer, 1U);
-        witness_ct second_input(&composer, 0U);
+        witness_ct first_input(&builder, 1U);
+        witness_ct second_input(&builder, 0U);
 
         uint_ct a = first_input;
         uint_ct b = second_input;
@@ -217,7 +217,7 @@ template <typename Composer> class stdlib_uint : public testing::Test {
             c = a + b;
         }
 
-        auto special_uints = get_special_uints(&composer);
+        auto special_uints = get_special_uints(&builder);
         for (size_t i = 0; i != special_values.size(); ++i) {
             uint_native x = special_values[i];
             uint_ct x_ct = special_uints[i];
@@ -234,16 +234,16 @@ template <typename Composer> class stdlib_uint : public testing::Test {
             }
         };
 
-        bool result = composer.check_circuit();
+        bool result = builder.check_circuit();
         EXPECT_EQ(result, true);
     }
 
     static void test_sub_special()
     {
-        Composer composer = Composer();
+        Builder builder = Builder();
 
-        witness_ct a_val(&composer, static_cast<uint_native>(4));
-        // witness_ct b_val(&composer, static_cast<uint_native>(5));
+        witness_ct a_val(&builder, static_cast<uint_native>(4));
+        // witness_ct b_val(&builder, static_cast<uint_native>(5));
         uint_native const_a = 1;
         uint_native const_b = 2;
         uint_ct a = uint_ct(a_val) + const_a;
@@ -251,7 +251,7 @@ template <typename Composer> class stdlib_uint : public testing::Test {
         uint_ct b = const_b;
         uint_ct diff = a - b;
 
-        auto special_uints = get_special_uints(&composer);
+        auto special_uints = get_special_uints(&builder);
         for (size_t i = 0; i != special_values.size(); ++i) {
             uint_native x = special_values[i];
             uint_ct x_ct = special_uints[i];
@@ -268,7 +268,7 @@ template <typename Composer> class stdlib_uint : public testing::Test {
             }
         };
 
-        bool verified = composer.check_circuit();
+        bool verified = builder.check_circuit();
 
         EXPECT_EQ(verified, true);
     }
@@ -288,12 +288,12 @@ template <typename Composer> class stdlib_uint : public testing::Test {
             expected[6] = expected[3] + expected[4];
             expected[7] = expected[4] + expected[5];
         }
-        Composer composer = Composer();
+        Builder builder = Builder();
         uint_ct result[8];
         for (size_t i = 2; i < n; ++i) {
-            result[0] = uint_ct(&composer, witnesses[3 * i]);
-            result[1] = (witness_ct(&composer, witnesses[3 * i + 1]));
-            result[2] = (witness_ct(&composer, witnesses[3 * i + 2]));
+            result[0] = uint_ct(&builder, witnesses[3 * i]);
+            result[1] = (witness_ct(&builder, witnesses[3 * i + 1]));
+            result[2] = (witness_ct(&builder, witnesses[3 * i + 2]));
             result[3] = result[0] + result[1];
             result[4] = result[1] + result[0];
             result[5] = result[1] + result[2];
@@ -305,7 +305,7 @@ template <typename Composer> class stdlib_uint : public testing::Test {
             EXPECT_EQ(result[i].get_value(), expected[i]);
         }
 
-        bool proof_valid = composer.check_circuit();
+        bool proof_valid = builder.check_circuit();
         EXPECT_EQ(proof_valid, true);
     }
 
@@ -320,10 +320,10 @@ template <typename Composer> class stdlib_uint : public testing::Test {
             c_expected = a_expected * b_expected;
         }
 
-        Composer composer = Composer();
+        Builder builder = Builder();
 
-        witness_ct first_input(&composer, 1U);
-        witness_ct second_input(&composer, 2U);
+        witness_ct first_input(&builder, 1U);
+        witness_ct second_input(&builder, 2U);
 
         uint_ct a = first_input;
         uint_ct b = second_input;
@@ -334,10 +334,10 @@ template <typename Composer> class stdlib_uint : public testing::Test {
             c = a * b;
         }
         uint_native c_result =
-            static_cast<uint_native>(composer.get_variable(c.get_witness_index()).from_montgomery_form().data[0]);
+            static_cast<uint_native>(builder.get_variable(c.get_witness_index()).from_montgomery_form().data[0]);
         EXPECT_EQ(c_result, c_expected);
 
-        auto special_uints = get_special_uints(&composer);
+        auto special_uints = get_special_uints(&builder);
         for (size_t i = 0; i != special_values.size(); ++i) {
             uint_native x = special_values[i];
             uint_ct x_ct = special_uints[i];
@@ -354,7 +354,7 @@ template <typename Composer> class stdlib_uint : public testing::Test {
             }
         };
 
-        bool result = composer.check_circuit();
+        bool result = builder.check_circuit();
         EXPECT_EQ(result, true);
     }
 
@@ -362,13 +362,13 @@ template <typename Composer> class stdlib_uint : public testing::Test {
     {
         uint_native max = uint_native_max;
 
-        Composer composer = Composer();
-        uint_ct a = witness_ct(&composer, max);
+        Builder builder = Builder();
+        uint_ct a = witness_ct(&builder, max);
         a = a + max;
         uint_ct b = a;
         uint_ct c = a * b;
 
-        bool result = composer.check_circuit();
+        bool result = builder.check_circuit();
         EXPECT_EQ(result, true);
     }
 
@@ -384,10 +384,10 @@ template <typename Composer> class stdlib_uint : public testing::Test {
             a_expected = c_expected ^ a_expected;
         }
 
-        Composer composer = Composer();
+        Builder builder = Builder();
 
-        witness_ct first_input(&composer, static_cast<uint_native>(0x10000000a3b10422));
-        witness_ct second_input(&composer, static_cast<uint_native>(0xfafab007eac21343));
+        witness_ct first_input(&builder, static_cast<uint_native>(0x10000000a3b10422));
+        witness_ct second_input(&builder, static_cast<uint_native>(0xfafab007eac21343));
 
         uint_ct a = first_input;
         uint_ct b = second_input;
@@ -399,24 +399,24 @@ template <typename Composer> class stdlib_uint : public testing::Test {
             a = c ^ a;
         }
         uint_native a_result =
-            static_cast<uint_native>(composer.get_variable(a.get_witness_index()).from_montgomery_form().data[0]);
+            static_cast<uint_native>(builder.get_variable(a.get_witness_index()).from_montgomery_form().data[0]);
 
         EXPECT_EQ(a_result, a_expected);
 
-        bool result = composer.check_circuit();
+        bool result = builder.check_circuit();
         EXPECT_EQ(result, true);
     }
 
     static void test_xor_constants()
     {
-        Composer composer = Composer();
+        Builder builder = Builder();
 
         uint_native a_expected = static_cast<uint_native>(0x10000000a3b10422);
         uint_native b_expected = static_cast<uint_native>(0xfafab007eac21343);
         uint_native c_expected = a_expected ^ b_expected;
 
-        uint_ct const_a(&composer, static_cast<uint_native>(0x10000000a3b10422));
-        uint_ct const_b(&composer, static_cast<uint_native>(0xfafab007eac21343));
+        uint_ct const_a(&builder, static_cast<uint_native>(0x10000000a3b10422));
+        uint_ct const_b(&builder, static_cast<uint_native>(0xfafab007eac21343));
         uint_ct c = const_a ^ const_b;
         c.get_witness_index();
 
@@ -435,10 +435,10 @@ template <typename Composer> class stdlib_uint : public testing::Test {
                          (static_cast<uint_native>(0x10000000a3b10422) ^ static_cast<uint_native>(0xfafab007eac21343));
         }
 
-        Composer composer = Composer();
+        Builder builder = Builder();
 
-        witness_ct first_input(&composer, static_cast<uint_native>(0x10000000a3b10422));
-        witness_ct second_input(&composer, static_cast<uint_native>(0xfafab007eac21343));
+        witness_ct first_input(&builder, static_cast<uint_native>(0x10000000a3b10422));
+        witness_ct second_input(&builder, static_cast<uint_native>(0xfafab007eac21343));
 
         uint_ct a = first_input;
         uint_ct b = second_input;
@@ -452,9 +452,9 @@ template <typename Composer> class stdlib_uint : public testing::Test {
         }
         uint32_t c_witness_index = c.get_witness_index();
         uint_native c_result =
-            static_cast<uint_native>(composer.get_variable(c_witness_index).from_montgomery_form().data[0]);
+            static_cast<uint_native>(builder.get_variable(c_witness_index).from_montgomery_form().data[0]);
         EXPECT_EQ(c_result, c_expected);
-        bool result = composer.check_circuit();
+        bool result = builder.check_circuit();
         EXPECT_EQ(result, true);
     }
 
@@ -472,10 +472,10 @@ template <typename Composer> class stdlib_uint : public testing::Test {
             // static_cast<uint_native>(0xfafab007eac21343));
         }
 
-        Composer composer = Composer();
+        Builder builder = Builder();
 
-        witness_ct first_input(&composer, static_cast<uint_native>(0x10000000a3b10422));
-        witness_ct second_input(&composer, static_cast<uint_native>(0xfafab007eac21343));
+        witness_ct first_input(&builder, static_cast<uint_native>(0x10000000a3b10422));
+        witness_ct second_input(&builder, static_cast<uint_native>(0xfafab007eac21343));
 
         uint_ct a = first_input;
         uint_ct b = second_input;
@@ -489,9 +489,9 @@ template <typename Composer> class stdlib_uint : public testing::Test {
         }
         uint32_t c_witness_index = c.get_witness_index();
         uint_native c_result =
-            static_cast<uint_native>(composer.get_variable(c_witness_index).from_montgomery_form().data[0]);
+            static_cast<uint_native>(builder.get_variable(c_witness_index).from_montgomery_form().data[0]);
         EXPECT_EQ(c_result, c_expected);
-        bool result = composer.check_circuit();
+        bool result = builder.check_circuit();
         EXPECT_EQ(result, true);
     }
 
@@ -507,10 +507,10 @@ template <typename Composer> class stdlib_uint : public testing::Test {
             a_expected = c_expected & a_expected;
         }
 
-        Composer composer = Composer();
+        Builder builder = Builder();
 
-        witness_ct first_input(&composer, static_cast<uint_native>(0x10000000a3b10422));
-        witness_ct second_input(&composer, static_cast<uint_native>(0xfafab007eac21343));
+        witness_ct first_input(&builder, static_cast<uint_native>(0x10000000a3b10422));
+        witness_ct second_input(&builder, static_cast<uint_native>(0xfafab007eac21343));
 
         uint_ct a = first_input;
         uint_ct b = second_input;
@@ -522,10 +522,10 @@ template <typename Composer> class stdlib_uint : public testing::Test {
             a = c & a;
         }
         uint_native a_result =
-            static_cast<uint_native>(composer.get_variable(a.get_witness_index()).from_montgomery_form().data[0]);
+            static_cast<uint_native>(builder.get_variable(a.get_witness_index()).from_montgomery_form().data[0]);
         EXPECT_EQ(a_result, a_expected);
 
-        bool result = composer.check_circuit();
+        bool result = builder.check_circuit();
         EXPECT_EQ(result, true);
     }
 
@@ -541,10 +541,10 @@ template <typename Composer> class stdlib_uint : public testing::Test {
             a_expected = c_expected | a_expected;
         }
 
-        Composer composer = Composer();
+        Builder builder = Builder();
 
-        witness_ct first_input(&composer, static_cast<uint_native>(0x10000000a3b10422));
-        witness_ct second_input(&composer, static_cast<uint_native>(0xfafab007eac21343));
+        witness_ct first_input(&builder, static_cast<uint_native>(0x10000000a3b10422));
+        witness_ct second_input(&builder, static_cast<uint_native>(0xfafab007eac21343));
 
         uint_ct a = first_input;
         uint_ct b = second_input;
@@ -556,10 +556,10 @@ template <typename Composer> class stdlib_uint : public testing::Test {
             a = c | a;
         }
         uint_native a_result =
-            static_cast<uint_native>(composer.get_variable(a.get_witness_index()).from_montgomery_form().data[0]);
+            static_cast<uint_native>(builder.get_variable(a.get_witness_index()).from_montgomery_form().data[0]);
         EXPECT_EQ(a_result, a_expected);
 
-        bool result = composer.check_circuit();
+        bool result = builder.check_circuit();
         EXPECT_EQ(result, true);
     }
 
@@ -587,32 +587,32 @@ template <typename Composer> class stdlib_uint : public testing::Test {
             }
             bool c_expected = a_expected > b_expected;
 
-            Composer composer = Composer();
+            Builder builder = Builder();
 
             uint_ct a;
             uint_ct b;
             if (lhs_constant) {
                 a = uint_ct(nullptr, a_expected);
             } else {
-                a = witness_ct(&composer, a_expected);
+                a = witness_ct(&builder, a_expected);
             }
             if (rhs_constant) {
                 b = uint_ct(nullptr, b_expected);
             } else {
-                b = witness_ct(&composer, b_expected);
+                b = witness_ct(&builder, b_expected);
             }
             // mix in some constant terms for good measure
-            a *= uint_ct(&composer, 2);
-            a += uint_ct(&composer, 1);
-            b *= uint_ct(&composer, 2);
-            b += uint_ct(&composer, 1);
+            a *= uint_ct(&builder, 2);
+            a += uint_ct(&builder, 1);
+            b *= uint_ct(&builder, 2);
+            b += uint_ct(&builder, 1);
 
             bool_ct c = a > b;
 
             bool c_result = static_cast<bool>(c.get_value());
             EXPECT_EQ(c_result, c_expected);
 
-            bool result = composer.check_circuit();
+            bool result = builder.check_circuit();
             EXPECT_EQ(result, true);
         };
 
@@ -649,10 +649,10 @@ template <typename Composer> class stdlib_uint : public testing::Test {
             a_expected = rotate(c_expected, i % 31) + rotate(a_expected, (i + 1) % 31);
         }
 
-        Composer composer = Composer();
+        Builder builder = Builder();
 
-        witness_ct first_input(&composer, static_cast<uint_native>(0x10000000a3b10422));
-        witness_ct second_input(&composer, static_cast<uint_native>(0xfafab007eac21343));
+        witness_ct first_input(&builder, static_cast<uint_native>(0x10000000a3b10422));
+        witness_ct second_input(&builder, static_cast<uint_native>(0xfafab007eac21343));
 
         uint_ct a = first_input;
         uint_ct b = second_input;
@@ -664,10 +664,10 @@ template <typename Composer> class stdlib_uint : public testing::Test {
             a = c.ror(static_cast<uint_native>(i % 31)) + a.ror(static_cast<uint_native>((i + 1) % 31));
         }
         uint_native a_result =
-            static_cast<uint_native>(composer.get_variable(a.get_witness_index()).from_montgomery_form().data[0]);
+            static_cast<uint_native>(builder.get_variable(a.get_witness_index()).from_montgomery_form().data[0]);
         EXPECT_EQ(a_result, a_expected);
 
-        bool result = composer.check_circuit();
+        bool result = builder.check_circuit();
         EXPECT_EQ(result, true);
     }
 
@@ -756,22 +756,22 @@ template <typename Composer> class stdlib_uint : public testing::Test {
             b_alt = a_alt;
             a_alt = temp1_alt + temp2_alt;
         }
-        Composer composer = Composer();
+        Builder builder = Builder();
 
         std::vector<uint_ct> w;
         std::vector<uint_ct> k;
         for (size_t i = 0; i < 64; ++i) {
-            w.emplace_back(uint_ct(witness_ct(&composer, w_alt[i])));
-            k.emplace_back(uint_ct(&composer, k_constants[i % 64]));
+            w.emplace_back(uint_ct(witness_ct(&builder, w_alt[i])));
+            k.emplace_back(uint_ct(&builder, k_constants[i % 64]));
         }
-        uint_ct a = witness_ct(&composer, round_values[0]);
-        uint_ct b = witness_ct(&composer, round_values[1]);
-        uint_ct c = witness_ct(&composer, round_values[2]);
-        uint_ct d = witness_ct(&composer, round_values[3]);
-        uint_ct e = witness_ct(&composer, round_values[4]);
-        uint_ct f = witness_ct(&composer, round_values[5]);
-        uint_ct g = witness_ct(&composer, round_values[6]);
-        uint_ct h = witness_ct(&composer, round_values[7]);
+        uint_ct a = witness_ct(&builder, round_values[0]);
+        uint_ct b = witness_ct(&builder, round_values[1]);
+        uint_ct c = witness_ct(&builder, round_values[2]);
+        uint_ct d = witness_ct(&builder, round_values[3]);
+        uint_ct e = witness_ct(&builder, round_values[4]);
+        uint_ct f = witness_ct(&builder, round_values[5]);
+        uint_ct g = witness_ct(&builder, round_values[6]);
+        uint_ct h = witness_ct(&builder, round_values[7]);
         for (size_t i = 0; i < 64; ++i) {
             uint_ct S1 =
                 e.ror(7U % uint_native_width) ^ e.ror(11U % uint_native_width) ^ e.ror(25U % uint_native_width);
@@ -797,21 +797,21 @@ template <typename Composer> class stdlib_uint : public testing::Test {
         }
 
         uint_native a_result =
-            static_cast<uint_native>(composer.get_variable(a.get_witness_index()).from_montgomery_form().data[0]);
+            static_cast<uint_native>(builder.get_variable(a.get_witness_index()).from_montgomery_form().data[0]);
         uint_native b_result =
-            static_cast<uint_native>(composer.get_variable(b.get_witness_index()).from_montgomery_form().data[0]);
+            static_cast<uint_native>(builder.get_variable(b.get_witness_index()).from_montgomery_form().data[0]);
         uint_native c_result =
-            static_cast<uint_native>(composer.get_variable(c.get_witness_index()).from_montgomery_form().data[0]);
+            static_cast<uint_native>(builder.get_variable(c.get_witness_index()).from_montgomery_form().data[0]);
         uint_native d_result =
-            static_cast<uint_native>(composer.get_variable(d.get_witness_index()).from_montgomery_form().data[0]);
+            static_cast<uint_native>(builder.get_variable(d.get_witness_index()).from_montgomery_form().data[0]);
         uint_native e_result =
-            static_cast<uint_native>(composer.get_variable(e.get_witness_index()).from_montgomery_form().data[0]);
+            static_cast<uint_native>(builder.get_variable(e.get_witness_index()).from_montgomery_form().data[0]);
         uint_native f_result =
-            static_cast<uint_native>(composer.get_variable(f.get_witness_index()).from_montgomery_form().data[0]);
+            static_cast<uint_native>(builder.get_variable(f.get_witness_index()).from_montgomery_form().data[0]);
         uint_native g_result =
-            static_cast<uint_native>(composer.get_variable(g.get_witness_index()).from_montgomery_form().data[0]);
+            static_cast<uint_native>(builder.get_variable(g.get_witness_index()).from_montgomery_form().data[0]);
         uint_native h_result =
-            static_cast<uint_native>(composer.get_variable(h.get_witness_index()).from_montgomery_form().data[0]);
+            static_cast<uint_native>(builder.get_variable(h.get_witness_index()).from_montgomery_form().data[0]);
 
         EXPECT_EQ(a_result, a_alt);
         EXPECT_EQ(b_result, b_alt);
@@ -822,7 +822,7 @@ template <typename Composer> class stdlib_uint : public testing::Test {
         EXPECT_EQ(g_result, g_alt);
         EXPECT_EQ(h_result, h_alt);
 
-        bool result = composer.check_circuit();
+        bool result = builder.check_circuit();
         EXPECT_EQ(result, true);
     }
 
@@ -833,14 +833,14 @@ template <typename Composer> class stdlib_uint : public testing::Test {
      */
     static void test_add()
     {
-        Composer composer = Composer();
+        Builder builder = Builder();
 
-        const auto add_integers = [&composer](bool lhs_constant = false, bool rhs_constant = false) {
+        const auto add_integers = [&builder](bool lhs_constant = false, bool rhs_constant = false) {
             uint_native a_val = get_random<uint_native>();
             uint_native b_val = get_random<uint_native>();
             uint_native expected = a_val + b_val;
-            uint_ct a = lhs_constant ? uint_ct(&composer, a_val) : witness_ct(&composer, a_val);
-            uint_ct b = rhs_constant ? uint_ct(&composer, b_val) : witness_ct(&composer, b_val);
+            uint_ct a = lhs_constant ? uint_ct(&builder, a_val) : witness_ct(&builder, a_val);
+            uint_ct b = rhs_constant ? uint_ct(&builder, b_val) : witness_ct(&builder, b_val);
             uint_ct c = a + b;
             c = c.normalize();
 
@@ -854,22 +854,22 @@ template <typename Composer> class stdlib_uint : public testing::Test {
         add_integers(true, false);
         add_integers(true, true);
 
-        bool proof_result = composer.check_circuit();
+        bool proof_result = builder.check_circuit();
         EXPECT_EQ(proof_result, true);
     }
 
     static void test_sub()
     {
-        Composer composer = Composer();
+        Builder builder = Builder();
 
-        const auto sub_integers = [&composer](bool lhs_constant = false, bool rhs_constant = false) {
+        const auto sub_integers = [&builder](bool lhs_constant = false, bool rhs_constant = false) {
             uint_native a_val = get_random<uint_native>();
             uint_native b_val = get_random<uint_native>();
             uint_native const_shift_val = get_random<uint_native>();
             uint_native expected = a_val - (b_val + const_shift_val);
-            uint_ct a = lhs_constant ? uint_ct(&composer, a_val) : witness_ct(&composer, a_val);
-            uint_ct b = rhs_constant ? uint_ct(&composer, b_val) : witness_ct(&composer, b_val);
-            uint_ct b_shift = uint_ct(&composer, const_shift_val);
+            uint_ct a = lhs_constant ? uint_ct(&builder, a_val) : witness_ct(&builder, a_val);
+            uint_ct b = rhs_constant ? uint_ct(&builder, b_val) : witness_ct(&builder, b_val);
+            uint_ct b_shift = uint_ct(&builder, const_shift_val);
             uint_ct c = b + b_shift;
             uint_ct d = a - c;
             d = d.normalize();
@@ -884,27 +884,27 @@ template <typename Composer> class stdlib_uint : public testing::Test {
         sub_integers(true, false);
         sub_integers(true, true);
 
-        printf("composer gates = %zu\n", composer.get_num_gates());
+        printf("builder gates = %zu\n", builder.get_num_gates());
 
-        bool proof_result = composer.check_circuit();
+        bool proof_result = builder.check_circuit();
         EXPECT_EQ(proof_result, true);
     }
 
     static void test_mul()
     {
-        Composer composer = Composer();
+        Builder builder = Builder();
 
-        const auto mul_integers = [&composer](bool lhs_constant = false, bool rhs_constant = false) {
+        const auto mul_integers = [&builder](bool lhs_constant = false, bool rhs_constant = false) {
             uint_native a_val = get_random<uint_native>();
             uint_native b_val = get_random<uint_native>();
             uint_native const_a = get_random<uint_native>();
             uint_native const_b = get_random<uint_native>();
             uint_native expected =
                 static_cast<uint_native>(a_val + const_a) * static_cast<uint_native>(b_val + const_b);
-            uint_ct a = lhs_constant ? uint_ct(&composer, a_val) : witness_ct(&composer, a_val);
-            uint_ct b = rhs_constant ? uint_ct(&composer, b_val) : witness_ct(&composer, b_val);
-            uint_ct a_shift = uint_ct(&composer, const_a);
-            uint_ct b_shift = uint_ct(&composer, const_b);
+            uint_ct a = lhs_constant ? uint_ct(&builder, a_val) : witness_ct(&builder, a_val);
+            uint_ct b = rhs_constant ? uint_ct(&builder, b_val) : witness_ct(&builder, b_val);
+            uint_ct a_shift = uint_ct(&builder, const_a);
+            uint_ct b_shift = uint_ct(&builder, const_b);
             uint_ct c = a + a_shift;
             uint_ct d = b + b_shift;
             uint_ct e = c * d;
@@ -920,21 +920,21 @@ template <typename Composer> class stdlib_uint : public testing::Test {
         mul_integers(true, false);
         mul_integers(true, true);
 
-        printf("composer gates = %zu\n", composer.get_num_gates());
+        printf("builder gates = %zu\n", builder.get_num_gates());
 
-        bool proof_result = composer.check_circuit();
+        bool proof_result = builder.check_circuit();
         EXPECT_EQ(proof_result, true);
     }
 
     static void test_divide()
     {
-        Composer composer = Composer();
+        Builder builder = Builder();
 
-        const auto divide_integers = [&composer](bool lhs_constant = false,
-                                                 bool rhs_constant = false,
-                                                 bool dividend_is_divisor = false,
-                                                 bool dividend_zero = false,
-                                                 bool divisor_zero = false) {
+        const auto divide_integers = [&builder](bool lhs_constant = false,
+                                                bool rhs_constant = false,
+                                                bool dividend_is_divisor = false,
+                                                bool dividend_zero = false,
+                                                bool divisor_zero = false) {
             uint_native a_val = get_random<uint_native>();
             uint_native b_val = dividend_is_divisor ? a_val : get_random<uint_native>();
             uint_native const_a = dividend_zero ? 0 - a_val : get_random<uint_native>();
@@ -942,10 +942,10 @@ template <typename Composer> class stdlib_uint : public testing::Test {
                 divisor_zero ? 0 - b_val : (dividend_is_divisor ? const_a : get_random<uint_native>());
             uint_native expected =
                 static_cast<uint_native>(a_val + const_a) / static_cast<uint_native>(b_val + const_b);
-            uint_ct a = lhs_constant ? uint_ct(&composer, a_val) : witness_ct(&composer, a_val);
-            uint_ct b = rhs_constant ? uint_ct(&composer, b_val) : witness_ct(&composer, b_val);
-            uint_ct a_shift = uint_ct(&composer, const_a);
-            uint_ct b_shift = uint_ct(&composer, const_b);
+            uint_ct a = lhs_constant ? uint_ct(&builder, a_val) : witness_ct(&builder, a_val);
+            uint_ct b = rhs_constant ? uint_ct(&builder, b_val) : witness_ct(&builder, b_val);
+            uint_ct a_shift = uint_ct(&builder, const_a);
+            uint_ct b_shift = uint_ct(&builder, const_b);
             uint_ct c = a + a_shift;
             uint_ct d = b + b_shift;
             uint_ct e = c / d;
@@ -976,21 +976,21 @@ template <typename Composer> class stdlib_uint : public testing::Test {
         divide_integers(true, false, false, true, false);
         divide_integers(true, true, false, true, false);
 
-        printf("composer gates = %zu\n", composer.get_num_gates());
+        printf("builder gates = %zu\n", builder.get_num_gates());
 
-        bool proof_result = composer.check_circuit();
+        bool proof_result = builder.check_circuit();
         EXPECT_EQ(proof_result, true);
     }
 
     static void test_modulo()
     {
-        Composer composer = Composer();
+        Builder builder = Builder();
 
-        const auto mod_integers = [&composer](bool lhs_constant = false,
-                                              bool rhs_constant = false,
-                                              bool dividend_is_divisor = false,
-                                              bool dividend_zero = false,
-                                              bool divisor_zero = false) {
+        const auto mod_integers = [&builder](bool lhs_constant = false,
+                                             bool rhs_constant = false,
+                                             bool dividend_is_divisor = false,
+                                             bool dividend_zero = false,
+                                             bool divisor_zero = false) {
             uint_native a_val = get_random<uint_native>();
             uint_native b_val = dividend_is_divisor ? a_val : get_random<uint_native>();
             uint_native const_a = dividend_zero ? 0 - a_val : get_random<uint_native>();
@@ -998,10 +998,10 @@ template <typename Composer> class stdlib_uint : public testing::Test {
                 divisor_zero ? 0 - b_val : (dividend_is_divisor ? const_a : get_random<uint_native>());
             uint_native expected =
                 static_cast<uint_native>(a_val + const_a) % static_cast<uint_native>(b_val + const_b);
-            uint_ct a = lhs_constant ? uint_ct(&composer, a_val) : witness_ct(&composer, a_val);
-            uint_ct b = rhs_constant ? uint_ct(&composer, b_val) : witness_ct(&composer, b_val);
-            uint_ct a_shift = uint_ct(&composer, const_a);
-            uint_ct b_shift = uint_ct(&composer, const_b);
+            uint_ct a = lhs_constant ? uint_ct(&builder, a_val) : witness_ct(&builder, a_val);
+            uint_ct b = rhs_constant ? uint_ct(&builder, b_val) : witness_ct(&builder, b_val);
+            uint_ct a_shift = uint_ct(&builder, const_a);
+            uint_ct b_shift = uint_ct(&builder, const_b);
             uint_ct c = a + a_shift;
             uint_ct d = b + b_shift;
             uint_ct e = c % d;
@@ -1027,9 +1027,9 @@ template <typename Composer> class stdlib_uint : public testing::Test {
         mod_integers(true, false, false, true, false);
         mod_integers(true, true, false, true, false);
 
-        printf("composer gates = %zu\n", composer.get_num_gates());
+        printf("builder gates = %zu\n", builder.get_num_gates());
 
-        bool proof_result = composer.check_circuit();
+        bool proof_result = builder.check_circuit();
         EXPECT_EQ(proof_result, true);
     }
 
@@ -1041,23 +1041,23 @@ template <typename Composer> class stdlib_uint : public testing::Test {
                                         bool dividend_is_divisor = false,
                                         bool dividend_zero = false,
                                         bool divisor_zero = false) {
-            Composer composer = Composer();
+            Builder builder = Builder();
 
             uint_native a_val = get_random<uint_native>();
             uint_native b_val = dividend_is_divisor ? a_val : get_random<uint_native>();
             uint_native const_a = dividend_zero ? 0 - a_val : get_random<uint_native>();
             uint_native const_b =
                 divisor_zero ? 0 - b_val : (dividend_is_divisor ? const_a : get_random<uint_native>());
-            uint_ct a = lhs_constant ? uint_ct(&composer, a_val) : witness_ct(&composer, a_val);
-            uint_ct b = rhs_constant ? uint_ct(&composer, b_val) : witness_ct(&composer, b_val);
-            uint_ct a_shift = uint_ct(&composer, const_a);
-            uint_ct b_shift = uint_ct(&composer, const_b);
+            uint_ct a = lhs_constant ? uint_ct(&builder, a_val) : witness_ct(&builder, a_val);
+            uint_ct b = rhs_constant ? uint_ct(&builder, b_val) : witness_ct(&builder, b_val);
+            uint_ct a_shift = uint_ct(&builder, const_a);
+            uint_ct b_shift = uint_ct(&builder, const_b);
             uint_ct c = a + a_shift;
             uint_ct d = b + b_shift;
             uint_ct e = c / d;
             e = e.normalize();
 
-            bool proof_result = composer.check_circuit();
+            bool proof_result = builder.check_circuit();
             EXPECT_EQ(proof_result, false);
         };
 
@@ -1069,9 +1069,9 @@ template <typename Composer> class stdlib_uint : public testing::Test {
 
     static void test_divide_special()
     {
-        Composer composer = Composer();
+        Builder builder = Builder();
 
-        auto special_uints = get_special_uints(&composer);
+        auto special_uints = get_special_uints(&builder);
 
         for (size_t i = 0; i != special_values.size(); ++i) {
             uint_native x = special_values[i];
@@ -1095,7 +1095,7 @@ template <typename Composer> class stdlib_uint : public testing::Test {
             }
         };
 
-        bool result = composer.check_circuit();
+        bool result = builder.check_circuit();
         EXPECT_EQ(result, true);
     }
 
@@ -1107,12 +1107,12 @@ template <typename Composer> class stdlib_uint : public testing::Test {
      */
     static void div_remainder_constraint()
     {
-        Composer composer = Composer();
+        Builder builder = Builder();
 
         uint_native val = get_random<uint_native>();
 
-        uint_ct a = witness_ct(&composer, val);
-        uint_ct b = witness_ct(&composer, val);
+        uint_ct a = witness_ct(&builder, val);
+        uint_ct b = witness_ct(&builder, val);
 
         const uint32_t dividend_idx = a.get_witness_index();
         const uint32_t divisor_idx = b.get_witness_index();
@@ -1122,31 +1122,31 @@ template <typename Composer> class stdlib_uint : public testing::Test {
         const uint256_t q = 0;
         const uint256_t r = val;
 
-        const uint32_t quotient_idx = composer.add_variable(q);
-        const uint32_t remainder_idx = composer.add_variable(r);
+        const uint32_t quotient_idx = builder.add_variable(q);
+        const uint32_t remainder_idx = builder.add_variable(r);
 
         // In this example there are no additive constaints, so we just replace them by zero below.
 
         // constraint: qb + const_b q + 0 b - a + r - const_a == 0
         // i.e., a + const_a = q(b + const_b) + r
-        composer.create_big_mul_gate({ .a = quotient_idx,  // q
-                                       .b = divisor_idx,   // b
-                                       .c = dividend_idx,  // a
-                                       .d = remainder_idx, // r
-                                       .mul_scaling = fr::one(),
-                                       .a_scaling = b.get_additive_constant(),
-                                       .b_scaling = fr::zero(),
-                                       .c_scaling = fr::neg_one(),
-                                       .d_scaling = fr::one(),
-                                       .const_scaling = -a.get_additive_constant() });
+        builder.create_big_mul_gate({ .a = quotient_idx,  // q
+                                      .b = divisor_idx,   // b
+                                      .c = dividend_idx,  // a
+                                      .d = remainder_idx, // r
+                                      .mul_scaling = fr::one(),
+                                      .a_scaling = b.get_additive_constant(),
+                                      .b_scaling = fr::zero(),
+                                      .c_scaling = fr::neg_one(),
+                                      .d_scaling = fr::one(),
+                                      .const_scaling = -a.get_additive_constant() });
 
         // set delta = (b + const_b - r)
 
         // constraint: b - r - delta + const_b == 0
         const uint256_t delta = divisor - r - 1;
-        const uint32_t delta_idx = composer.add_variable(delta);
+        const uint32_t delta_idx = builder.add_variable(delta);
 
-        composer.create_add_gate({
+        builder.create_add_gate({
             .a = divisor_idx,   // b
             .b = remainder_idx, // r
             .c = delta_idx,     // d
@@ -1157,39 +1157,39 @@ template <typename Composer> class stdlib_uint : public testing::Test {
         });
 
         // validate delta is in the correct range
-        stdlib::field_t<Composer>::from_witness_index(&composer, delta_idx)
+        stdlib::field_t<Builder>::from_witness_index(&builder, delta_idx)
             .create_range_constraint(uint_native_width,
                                      "delta range constraint fails in div_remainder_constraint test");
 
         // normalize witness quotient and remainder
         // minimal bit range for quotient: from 0 (in case a = b-1) to width (when b = 1).
-        uint_ct quotient(&composer);
-        composer.create_range_constraint(
+        uint_ct quotient(&builder);
+        builder.create_range_constraint(
             quotient_idx, uint_native_width, "quotient range constraint fails in div_remainder_constraint test");
 
         // constrain remainder to lie in [0, 2^width-1]
-        uint_ct remainder(&composer);
-        composer.create_range_constraint(
+        uint_ct remainder(&builder);
+        builder.create_range_constraint(
             remainder_idx, uint_native_width, "remainder range constraint fails in div_remainder_constraint test");
 
-        bool result = composer.check_circuit();
+        bool result = builder.check_circuit();
         EXPECT_EQ(result, false);
     }
 
     static void test_and()
     {
-        Composer composer = Composer();
+        Builder builder = Builder();
 
-        const auto and_integers = [&composer](bool lhs_constant = false, bool rhs_constant = false) {
+        const auto and_integers = [&builder](bool lhs_constant = false, bool rhs_constant = false) {
             uint_native a_val = get_random<uint_native>();
             uint_native b_val = get_random<uint_native>();
             uint_native const_a = get_random<uint_native>();
             uint_native const_b = get_random<uint_native>();
             uint_native expected = (a_val + const_a) & (b_val + const_b);
-            uint_ct a = lhs_constant ? uint_ct(&composer, a_val) : witness_ct(&composer, a_val);
-            uint_ct b = rhs_constant ? uint_ct(&composer, b_val) : witness_ct(&composer, b_val);
-            uint_ct a_shift = uint_ct(&composer, const_a);
-            uint_ct b_shift = uint_ct(&composer, const_b);
+            uint_ct a = lhs_constant ? uint_ct(&builder, a_val) : witness_ct(&builder, a_val);
+            uint_ct b = rhs_constant ? uint_ct(&builder, b_val) : witness_ct(&builder, b_val);
+            uint_ct a_shift = uint_ct(&builder, const_a);
+            uint_ct b_shift = uint_ct(&builder, const_b);
             uint_ct c = a + a_shift;
             uint_ct d = b + b_shift;
             uint_ct e = c & d;
@@ -1205,26 +1205,26 @@ template <typename Composer> class stdlib_uint : public testing::Test {
         and_integers(true, false);
         and_integers(true, true);
 
-        printf("composer gates = %zu\n", composer.get_num_gates());
+        printf("builder gates = %zu\n", builder.get_num_gates());
 
-        bool proof_result = composer.check_circuit();
+        bool proof_result = builder.check_circuit();
         EXPECT_EQ(proof_result, true);
     }
 
     static void test_xor()
     {
-        Composer composer = Composer();
+        Builder builder = Builder();
 
-        const auto xor_integers = [&composer](bool lhs_constant = false, bool rhs_constant = false) {
+        const auto xor_integers = [&builder](bool lhs_constant = false, bool rhs_constant = false) {
             uint_native a_val = get_random<uint_native>();
             uint_native b_val = get_random<uint_native>();
             uint_native const_a = get_random<uint_native>();
             uint_native const_b = get_random<uint_native>();
             uint_native expected = (a_val + const_a) ^ (b_val + const_b);
-            uint_ct a = lhs_constant ? uint_ct(&composer, a_val) : witness_ct(&composer, a_val);
-            uint_ct b = rhs_constant ? uint_ct(&composer, b_val) : witness_ct(&composer, b_val);
-            uint_ct a_shift = uint_ct(&composer, const_a);
-            uint_ct b_shift = uint_ct(&composer, const_b);
+            uint_ct a = lhs_constant ? uint_ct(&builder, a_val) : witness_ct(&builder, a_val);
+            uint_ct b = rhs_constant ? uint_ct(&builder, b_val) : witness_ct(&builder, b_val);
+            uint_ct a_shift = uint_ct(&builder, const_a);
+            uint_ct b_shift = uint_ct(&builder, const_b);
             uint_ct c = a + a_shift;
             uint_ct d = b + b_shift;
             uint_ct e = c ^ d;
@@ -1240,26 +1240,26 @@ template <typename Composer> class stdlib_uint : public testing::Test {
         xor_integers(true, false);
         xor_integers(true, true);
 
-        printf("composer gates = %zu\n", composer.get_num_gates());
+        printf("builder gates = %zu\n", builder.get_num_gates());
 
-        bool proof_result = composer.check_circuit();
+        bool proof_result = builder.check_circuit();
         EXPECT_EQ(proof_result, true);
     }
 
     static void test_or()
     {
-        Composer composer = Composer();
+        Builder builder = Builder();
 
-        const auto or_integers = [&composer](bool lhs_constant = false, bool rhs_constant = false) {
+        const auto or_integers = [&builder](bool lhs_constant = false, bool rhs_constant = false) {
             uint_native a_val = get_random<uint_native>();
             uint_native b_val = get_random<uint_native>();
             uint_native const_a = get_random<uint_native>();
             uint_native const_b = get_random<uint_native>();
             uint_native expected = (a_val + const_a) | (b_val + const_b);
-            uint_ct a = lhs_constant ? uint_ct(&composer, a_val) : witness_ct(&composer, a_val);
-            uint_ct b = rhs_constant ? uint_ct(&composer, b_val) : witness_ct(&composer, b_val);
-            uint_ct a_shift = uint_ct(&composer, const_a);
-            uint_ct b_shift = uint_ct(&composer, const_b);
+            uint_ct a = lhs_constant ? uint_ct(&builder, a_val) : witness_ct(&builder, a_val);
+            uint_ct b = rhs_constant ? uint_ct(&builder, b_val) : witness_ct(&builder, b_val);
+            uint_ct a_shift = uint_ct(&builder, const_a);
+            uint_ct b_shift = uint_ct(&builder, const_b);
             uint_ct c = a + a_shift;
             uint_ct d = b + b_shift;
             uint_ct e = c | d;
@@ -1279,22 +1279,22 @@ template <typename Composer> class stdlib_uint : public testing::Test {
         or_integers(true, false);
         or_integers(true, true);
 
-        printf("composer gates = %zu\n", composer.get_num_gates());
+        printf("builder gates = %zu\n", builder.get_num_gates());
 
-        bool proof_result = composer.check_circuit();
+        bool proof_result = builder.check_circuit();
         EXPECT_EQ(proof_result, true);
     }
 
     static void test_not()
     {
-        Composer composer = Composer();
+        Builder builder = Builder();
 
-        const auto not_integers = [&composer](bool lhs_constant = false, bool = false) {
+        const auto not_integers = [&builder](bool lhs_constant = false, bool = false) {
             uint_native a_val = get_random<uint_native>();
             uint_native const_a = get_random<uint_native>();
             uint_native expected = ~(a_val + const_a);
-            uint_ct a = lhs_constant ? uint_ct(&composer, a_val) : witness_ct(&composer, a_val);
-            uint_ct a_shift = uint_ct(&composer, const_a);
+            uint_ct a = lhs_constant ? uint_ct(&builder, a_val) : witness_ct(&builder, a_val);
+            uint_ct a_shift = uint_ct(&builder, const_a);
             uint_ct c = a + a_shift;
             uint_ct e = ~c;
             e = e.normalize();
@@ -1309,27 +1309,27 @@ template <typename Composer> class stdlib_uint : public testing::Test {
         not_integers(true, false);
         not_integers(true, true);
 
-        printf("composer gates = %zu\n", composer.get_num_gates());
+        printf("builder gates = %zu\n", builder.get_num_gates());
 
-        bool proof_result = composer.check_circuit();
+        bool proof_result = builder.check_circuit();
         EXPECT_EQ(proof_result, true);
     }
 
     static void test_gt()
     {
-        Composer composer = Composer();
+        Builder builder = Builder();
         const auto compare_integers =
-            [&composer](bool force_equal = false, bool force_gt = false, bool force_lt = false) {
+            [&builder](bool force_equal = false, bool force_gt = false, bool force_lt = false) {
                 uint_native const_a = get_random<uint_native>();
                 uint_native const_b = get_random<uint_native>();
                 uint_native a_val = get_random<uint_native>();
                 uint_native b_val = impose_comparison(const_a, const_b, a_val, force_equal, force_gt, force_lt);
 
                 bool expected = static_cast<uint_native>(b_val + const_b) > static_cast<uint_native>(a_val + const_a);
-                uint_ct a = witness_ct(&composer, a_val);
-                uint_ct b = witness_ct(&composer, b_val);
-                uint_ct a_shift = uint_ct(&composer, const_a);
-                uint_ct b_shift = uint_ct(&composer, const_b);
+                uint_ct a = witness_ct(&builder, a_val);
+                uint_ct b = witness_ct(&builder, b_val);
+                uint_ct a_shift = uint_ct(&builder, const_a);
+                uint_ct b_shift = uint_ct(&builder, const_b);
                 uint_ct c = a + a_shift;
                 uint_ct d = b + b_shift;
                 bool_ct e = d > c;
@@ -1348,28 +1348,28 @@ template <typename Composer> class stdlib_uint : public testing::Test {
         compare_integers(false, true, false);  //      b > a
         compare_integers(true, false, false);  //      b = a
 
-        printf("composer gates = %zu\n", composer.get_num_gates());
+        printf("builder gates = %zu\n", builder.get_num_gates());
 
-        bool proof_result = composer.check_circuit();
+        bool proof_result = builder.check_circuit();
         EXPECT_EQ(proof_result, true);
     }
 
     static void test_lt()
     {
-        Composer composer = Composer();
+        Builder builder = Builder();
 
         const auto compare_integers =
-            [&composer](bool force_equal = false, bool force_gt = false, bool force_lt = false) {
+            [&builder](bool force_equal = false, bool force_gt = false, bool force_lt = false) {
                 uint_native const_a = get_random<uint_native>();
                 uint_native const_b = get_random<uint_native>();
                 uint_native a_val = get_random<uint_native>();
                 uint_native b_val = impose_comparison(const_a, const_b, a_val, force_equal, force_gt, force_lt);
 
                 bool expected = static_cast<uint_native>(b_val + const_b) < static_cast<uint_native>(a_val + const_a);
-                uint_ct a = witness_ct(&composer, a_val);
-                uint_ct b = witness_ct(&composer, b_val);
-                uint_ct a_shift = uint_ct(&composer, const_a);
-                uint_ct b_shift = uint_ct(&composer, const_b);
+                uint_ct a = witness_ct(&builder, a_val);
+                uint_ct b = witness_ct(&builder, b_val);
+                uint_ct a_shift = uint_ct(&builder, const_a);
+                uint_ct b_shift = uint_ct(&builder, const_b);
                 uint_ct c = a + a_shift;
                 uint_ct d = b + b_shift;
                 bool_ct e = d < c;
@@ -1389,28 +1389,28 @@ template <typename Composer> class stdlib_uint : public testing::Test {
         compare_integers(false, true, false);
         compare_integers(true, false, false);
 
-        printf("composer gates = %zu\n", composer.get_num_gates());
+        printf("builder gates = %zu\n", builder.get_num_gates());
 
-        bool proof_result = composer.check_circuit();
+        bool proof_result = builder.check_circuit();
         EXPECT_EQ(proof_result, true);
     }
 
     static void test_gte()
     {
-        Composer composer = Composer();
+        Builder builder = Builder();
 
         const auto compare_integers =
-            [&composer](bool force_equal = false, bool force_gt = false, bool force_lt = false) {
+            [&builder](bool force_equal = false, bool force_gt = false, bool force_lt = false) {
                 uint_native const_a = get_random<uint_native>();
                 uint_native const_b = get_random<uint_native>();
                 uint_native a_val = get_random<uint_native>();
                 uint_native b_val = impose_comparison(const_a, const_b, a_val, force_equal, force_gt, force_lt);
 
                 bool expected = static_cast<uint_native>(b_val + const_b) >= static_cast<uint_native>(a_val + const_a);
-                uint_ct a = witness_ct(&composer, a_val);
-                uint_ct b = witness_ct(&composer, b_val);
-                uint_ct a_shift = uint_ct(&composer, const_a);
-                uint_ct b_shift = uint_ct(&composer, const_b);
+                uint_ct a = witness_ct(&builder, a_val);
+                uint_ct b = witness_ct(&builder, b_val);
+                uint_ct a_shift = uint_ct(&builder, const_a);
+                uint_ct b_shift = uint_ct(&builder, const_b);
                 uint_ct c = a + a_shift;
                 uint_ct d = b + b_shift;
                 bool_ct e = d >= c;
@@ -1429,28 +1429,28 @@ template <typename Composer> class stdlib_uint : public testing::Test {
         compare_integers(false, true, false);
         compare_integers(true, false, false);
 
-        printf("composer gates = %zu\n", composer.get_num_gates());
+        printf("builder gates = %zu\n", builder.get_num_gates());
 
-        bool proof_result = composer.check_circuit();
+        bool proof_result = builder.check_circuit();
         EXPECT_EQ(proof_result, true);
     }
 
     static void test_lte()
     {
-        Composer composer = Composer();
+        Builder builder = Builder();
 
         const auto compare_integers =
-            [&composer](bool force_equal = false, bool force_gt = false, bool force_lt = false) {
+            [&builder](bool force_equal = false, bool force_gt = false, bool force_lt = false) {
                 uint_native const_a = get_random<uint_native>();
                 uint_native const_b = get_random<uint_native>();
                 uint_native a_val = get_random<uint_native>();
                 uint_native b_val = impose_comparison(const_a, const_b, a_val, force_equal, force_gt, force_lt);
 
                 bool expected = static_cast<uint_native>(b_val + const_b) <= static_cast<uint_native>(a_val + const_a);
-                uint_ct a = witness_ct(&composer, a_val);
-                uint_ct b = witness_ct(&composer, b_val);
-                uint_ct a_shift = uint_ct(&composer, const_a);
-                uint_ct b_shift = uint_ct(&composer, const_b);
+                uint_ct a = witness_ct(&builder, a_val);
+                uint_ct b = witness_ct(&builder, b_val);
+                uint_ct a_shift = uint_ct(&builder, const_a);
+                uint_ct b_shift = uint_ct(&builder, const_b);
                 uint_ct c = a + a_shift;
                 uint_ct d = b + b_shift;
                 bool_ct e = d <= c;
@@ -1470,28 +1470,28 @@ template <typename Composer> class stdlib_uint : public testing::Test {
         compare_integers(false, true, false);
         compare_integers(true, false, false);
 
-        printf("composer gates = %zu\n", composer.get_num_gates());
+        printf("builder gates = %zu\n", builder.get_num_gates());
 
-        bool proof_result = composer.check_circuit();
+        bool proof_result = builder.check_circuit();
         EXPECT_EQ(proof_result, true);
     }
 
     static void test_equality_operator()
     {
-        Composer composer = Composer();
+        Builder builder = Builder();
 
         const auto compare_integers =
-            [&composer](bool force_equal = false, bool force_gt = false, bool force_lt = false) {
+            [&builder](bool force_equal = false, bool force_gt = false, bool force_lt = false) {
                 uint_native const_a = get_random<uint_native>();
                 uint_native const_b = get_random<uint_native>();
                 uint_native a_val = get_random<uint_native>();
                 uint_native b_val = impose_comparison(const_a, const_b, a_val, force_equal, force_gt, force_lt);
 
                 bool expected = static_cast<uint_native>(b_val + const_b) == static_cast<uint_native>(a_val + const_a);
-                uint_ct a = witness_ct(&composer, a_val);
-                uint_ct b = witness_ct(&composer, b_val);
-                uint_ct a_shift = uint_ct(&composer, const_a);
-                uint_ct b_shift = uint_ct(&composer, const_b);
+                uint_ct a = witness_ct(&builder, a_val);
+                uint_ct b = witness_ct(&builder, b_val);
+                uint_ct a_shift = uint_ct(&builder, const_a);
+                uint_ct b_shift = uint_ct(&builder, const_b);
                 uint_ct c = a + a_shift;
                 uint_ct d = b + b_shift;
                 bool_ct e = d == c;
@@ -1511,28 +1511,28 @@ template <typename Composer> class stdlib_uint : public testing::Test {
         compare_integers(false, true, false);
         compare_integers(true, false, false);
 
-        printf("composer gates = %zu\n", composer.get_num_gates());
+        printf("builder gates = %zu\n", builder.get_num_gates());
 
-        bool proof_result = composer.check_circuit();
+        bool proof_result = builder.check_circuit();
         EXPECT_EQ(proof_result, true);
     }
 
     static void test_not_equality_operator()
     {
-        Composer composer = Composer();
+        Builder builder = Builder();
 
         const auto compare_integers =
-            [&composer](bool force_equal = false, bool force_gt = false, bool force_lt = false) {
+            [&builder](bool force_equal = false, bool force_gt = false, bool force_lt = false) {
                 uint_native const_a = get_random<uint_native>();
                 uint_native const_b = get_random<uint_native>();
                 uint_native a_val = get_random<uint_native>();
                 uint_native b_val = impose_comparison(const_a, const_b, a_val, force_equal, force_gt, force_lt);
 
                 bool expected = static_cast<uint_native>(b_val + const_b) != static_cast<uint_native>(a_val + const_a);
-                uint_ct a = witness_ct(&composer, a_val);
-                uint_ct b = witness_ct(&composer, b_val);
-                uint_ct a_shift = uint_ct(&composer, const_a);
-                uint_ct b_shift = uint_ct(&composer, const_b);
+                uint_ct a = witness_ct(&builder, a_val);
+                uint_ct b = witness_ct(&builder, b_val);
+                uint_ct a_shift = uint_ct(&builder, const_a);
+                uint_ct b_shift = uint_ct(&builder, const_b);
                 uint_ct c = a + a_shift;
                 uint_ct d = b + b_shift;
                 bool_ct e = d != c;
@@ -1552,22 +1552,22 @@ template <typename Composer> class stdlib_uint : public testing::Test {
         compare_integers(false, true, false);
         compare_integers(true, false, false);
 
-        printf("composer gates = %zu\n", composer.get_num_gates());
+        printf("builder gates = %zu\n", builder.get_num_gates());
 
-        bool proof_result = composer.check_circuit();
+        bool proof_result = builder.check_circuit();
         EXPECT_EQ(proof_result, true);
     }
 
     static void test_logical_not()
     {
-        Composer composer = Composer();
+        Builder builder = Builder();
 
-        const auto not_integer = [&composer](bool force_zero) {
+        const auto not_integer = [&builder](bool force_zero) {
             uint_native const_a = get_random<uint_native>();
             uint_native a_val = force_zero ? 0 - const_a : get_random<uint_native>();
             bool expected = !static_cast<uint_native>(const_a + a_val);
-            uint_ct a = witness_ct(&composer, a_val);
-            uint_ct a_shift = uint_ct(&composer, const_a);
+            uint_ct a = witness_ct(&builder, a_val);
+            uint_ct a_shift = uint_ct(&builder, const_a);
             uint_ct c = a + a_shift;
             bool_ct e = !c;
             bool result = bool(e.get_value());
@@ -1580,22 +1580,22 @@ template <typename Composer> class stdlib_uint : public testing::Test {
         not_integer(false);
         not_integer(false);
 
-        printf("composer gates = %zu\n", composer.get_num_gates());
+        printf("builder gates = %zu\n", builder.get_num_gates());
 
-        bool proof_result = composer.check_circuit();
+        bool proof_result = builder.check_circuit();
         EXPECT_EQ(proof_result, true);
     }
 
     static void test_right_shift()
     {
-        Composer composer = Composer();
+        Builder builder = Builder();
 
-        const auto shift_integer = [&composer](const bool is_constant, const uint_native shift) {
+        const auto shift_integer = [&builder](const bool is_constant, const uint_native shift) {
             uint_native const_a = get_random<uint_native>();
             uint_native a_val = get_random<uint_native>();
             uint_native expected = static_cast<uint_native>(a_val + const_a) >> shift;
-            uint_ct a = is_constant ? uint_ct(&composer, a_val) : witness_ct(&composer, a_val);
-            uint_ct a_shift = uint_ct(&composer, const_a);
+            uint_ct a = is_constant ? uint_ct(&builder, a_val) : witness_ct(&builder, a_val);
+            uint_ct a_shift = uint_ct(&builder, const_a);
             uint_ct c = a + a_shift;
             uint_ct d = c >> shift;
             uint_native result = uint_native(d.get_value());
@@ -1608,22 +1608,22 @@ template <typename Composer> class stdlib_uint : public testing::Test {
             shift_integer(true, i);
         }
 
-        printf("composer gates = %zu\n", composer.get_num_gates());
+        printf("builder gates = %zu\n", builder.get_num_gates());
 
-        bool proof_result = composer.check_circuit();
+        bool proof_result = builder.check_circuit();
         EXPECT_EQ(proof_result, true);
     }
 
     static void test_left_shift()
     {
-        Composer composer = Composer();
+        Builder builder = Builder();
 
-        const auto shift_integer = [&composer](const bool is_constant, const uint_native shift) {
+        const auto shift_integer = [&builder](const bool is_constant, const uint_native shift) {
             uint_native const_a = get_random<uint_native>();
             uint_native a_val = get_random<uint_native>();
             uint_native expected = static_cast<uint_native>((a_val + const_a) << shift);
-            uint_ct a = is_constant ? uint_ct(&composer, a_val) : witness_ct(&composer, a_val);
-            uint_ct a_shift = uint_ct(&composer, const_a);
+            uint_ct a = is_constant ? uint_ct(&builder, a_val) : witness_ct(&builder, a_val);
+            uint_ct a_shift = uint_ct(&builder, const_a);
             uint_ct c = a + a_shift;
             uint_ct d = c << shift;
             uint_native result = uint_native(d.get_value());
@@ -1636,17 +1636,17 @@ template <typename Composer> class stdlib_uint : public testing::Test {
             shift_integer(false, i);
         }
 
-        printf("composer gates = %zu\n", composer.get_num_gates());
+        printf("builder gates = %zu\n", builder.get_num_gates());
 
-        bool proof_result = composer.check_circuit();
+        bool proof_result = builder.check_circuit();
         EXPECT_EQ(proof_result, true);
     }
 
     static void test_ror()
     {
-        Composer composer = Composer();
+        Builder builder = Builder();
 
-        const auto ror_integer = [&composer](const bool is_constant, const uint_native rotation) {
+        const auto ror_integer = [&builder](const bool is_constant, const uint_native rotation) {
             const auto ror = [](const uint_native in, const uint_native rval) {
                 return rval ? (in >> rval) | (in << (uint_native_width - rval)) : in;
             };
@@ -1654,8 +1654,8 @@ template <typename Composer> class stdlib_uint : public testing::Test {
             uint_native const_a = get_random<uint_native>();
             uint_native a_val = get_random<uint_native>();
             uint_native expected = static_cast<uint_native>(ror(static_cast<uint_native>(const_a + a_val), rotation));
-            uint_ct a = is_constant ? uint_ct(&composer, a_val) : witness_ct(&composer, a_val);
-            uint_ct a_shift = uint_ct(&composer, const_a);
+            uint_ct a = is_constant ? uint_ct(&builder, a_val) : witness_ct(&builder, a_val);
+            uint_ct a_shift = uint_ct(&builder, const_a);
             uint_ct c = a + a_shift;
             uint_ct d = c.ror(rotation);
             uint_native result = uint_native(d.get_value());
@@ -1668,17 +1668,17 @@ template <typename Composer> class stdlib_uint : public testing::Test {
             ror_integer(false, i);
         }
 
-        printf("composer gates = %zu\n", composer.get_num_gates());
+        printf("builder gates = %zu\n", builder.get_num_gates());
 
-        bool proof_result = composer.check_circuit();
+        bool proof_result = builder.check_circuit();
         EXPECT_EQ(proof_result, true);
     }
 
     static void test_rol()
     {
-        Composer composer = Composer();
+        Builder builder = Builder();
 
-        const auto rol_integer = [&composer](const bool is_constant, const uint_native rotation) {
+        const auto rol_integer = [&builder](const bool is_constant, const uint_native rotation) {
             const auto rol = [](const uint_native in, const uint_native rval) {
                 return rval ? (in << rval) | (in >> (uint_native_width - rval)) : in;
             };
@@ -1686,8 +1686,8 @@ template <typename Composer> class stdlib_uint : public testing::Test {
             uint_native const_a = get_random<uint_native>();
             uint_native a_val = get_random<uint_native>();
             uint_native expected = static_cast<uint_native>(rol(static_cast<uint_native>(const_a + a_val), rotation));
-            uint_ct a = is_constant ? uint_ct(&composer, a_val) : witness_ct(&composer, a_val);
-            uint_ct a_shift = uint_ct(&composer, const_a);
+            uint_ct a = is_constant ? uint_ct(&builder, a_val) : witness_ct(&builder, a_val);
+            uint_ct a_shift = uint_ct(&builder, const_a);
             uint_ct c = a + a_shift;
             uint_ct d = c.rol(rotation);
             uint_native result = uint_native(d.get_value());
@@ -1700,9 +1700,9 @@ template <typename Composer> class stdlib_uint : public testing::Test {
             rol_integer(false, i);
         }
 
-        printf("composer gates = %zu\n", composer.get_num_gates());
+        printf("builder gates = %zu\n", builder.get_num_gates());
 
-        bool proof_result = composer.check_circuit();
+        bool proof_result = builder.check_circuit();
         EXPECT_EQ(proof_result, true);
     }
 
@@ -1711,16 +1711,16 @@ template <typename Composer> class stdlib_uint : public testing::Test {
      */
     static void test_at()
     {
-        Composer composer = Composer();
+        Builder builder = Builder();
 
-        const auto bit_test = [&composer](const bool is_constant) {
+        const auto bit_test = [&builder](const bool is_constant) {
             // construct a sum of uint_ct's, where at least one is a constant,
             // and validate its correctness bitwise
             uint_native const_a = get_random<uint_native>();
             uint_native a_val = get_random<uint_native>();
             uint_native c_val = const_a + a_val;
-            uint_ct a = is_constant ? uint_ct(&composer, a_val) : witness_ct(&composer, a_val);
-            uint_ct a_shift = uint_ct(&composer, const_a);
+            uint_ct a = is_constant ? uint_ct(&builder, a_val) : witness_ct(&builder, a_val);
+            uint_ct a_shift = uint_ct(&builder, const_a);
             uint_ct c = a + a_shift;
             for (size_t i = 0; i < uint_native_width; ++i) {
                 bool_ct result = c.at(i);
@@ -1733,9 +1733,9 @@ template <typename Composer> class stdlib_uint : public testing::Test {
         bit_test(false);
         bit_test(true);
 
-        printf("composer gates = %zu\n", composer.get_num_gates());
+        printf("builder gates = %zu\n", builder.get_num_gates());
 
-        bool proof_result = composer.check_circuit();
+        bool proof_result = builder.check_circuit();
         EXPECT_EQ(proof_result, true);
     }
 };
@@ -1922,26 +1922,26 @@ TEST(stdlib_uint32, test_accumulators_plookup_uint32)
     using uint32_ct = proof_system::plonk::stdlib::uint32<proof_system::UltraCircuitBuilder>;
     using witness_ct = proof_system::plonk::stdlib::witness_t<proof_system::UltraCircuitBuilder>;
 
-    proof_system::UltraCircuitBuilder composer;
+    proof_system::UltraCircuitBuilder builder;
 
     uint32_t a_val = engine.get_random_uint32();
     uint32_t b_val = engine.get_random_uint32();
-    uint32_ct a = witness_ct(&composer, a_val);
-    uint32_ct b = witness_ct(&composer, b_val);
+    uint32_ct a = witness_ct(&builder, a_val);
+    uint32_ct b = witness_ct(&builder, b_val);
     a = a ^ b;
     uint32_t val = a_val ^ b_val;
     uint32_t MASK = (1U << uint32_ct::bits_per_limb) - 1;
     const auto accumulators = a.get_accumulators();
     for (size_t i = 0; i < uint32_ct::num_accumulators(); ++i) {
-        const uint64_t result = uint256_t(composer.get_variable(accumulators[i])).data[0];
+        const uint64_t result = uint256_t(builder.get_variable(accumulators[i])).data[0];
         const uint64_t expected = val & MASK;
         val = val >> uint32_ct::bits_per_limb;
         EXPECT_EQ(result, expected);
     }
 
-    info("composer gates = ", composer.get_num_gates());
+    info("builder gates = ", builder.get_num_gates());
 
-    bool proof_result = composer.check_circuit();
+    bool proof_result = builder.check_circuit();
     EXPECT_EQ(proof_result, true);
 }
 } // namespace test_stdlib_uint
diff --git a/barretenberg/cpp/src/barretenberg/stdlib/primitives/witness/witness.hpp b/barretenberg/cpp/src/barretenberg/stdlib/primitives/witness/witness.hpp
index 267bf83e13c..1d3dea5890c 100644
--- a/barretenberg/cpp/src/barretenberg/stdlib/primitives/witness/witness.hpp
+++ b/barretenberg/cpp/src/barretenberg/stdlib/primitives/witness/witness.hpp
@@ -7,18 +7,18 @@ namespace stdlib {
 // indicates whether a witness index actually contains a constant
 static constexpr uint32_t IS_CONSTANT = UINT32_MAX;
 
-template <typename ComposerContext> class witness_t {
+template <typename Builder> class witness_t {
   public:
     witness_t() = default;
 
-    witness_t(ComposerContext* parent_context, const barretenberg::fr& in)
+    witness_t(Builder* parent_context, const barretenberg::fr& in)
     {
         context = parent_context;
         witness = in;
         witness_index = context->add_variable(witness);
     }
 
-    witness_t(ComposerContext* parent_context, const bool in)
+    witness_t(Builder* parent_context, const bool in)
     {
         context = parent_context;
         if (in) {
@@ -29,14 +29,14 @@ template <typename ComposerContext> class witness_t {
         witness_index = context->add_variable(witness);
     }
 
-    witness_t(ComposerContext* parent_context, IntegralOrEnum auto const in)
+    witness_t(Builder* parent_context, IntegralOrEnum auto const in)
     {
         context = parent_context;
         witness = barretenberg::fr{ static_cast<uint64_t>(in), 0, 0, 0 }.to_montgomery_form();
         witness_index = context->add_variable(witness);
     }
 
-    static witness_t create_constant_witness(ComposerContext* parent_context, const barretenberg::fr& in)
+    static witness_t create_constant_witness(Builder* parent_context, const barretenberg::fr& in)
     {
         witness_t out(parent_context, in);
         parent_context->assert_equal_constant(out.witness_index, in);
@@ -45,24 +45,24 @@ template <typename ComposerContext> class witness_t {
 
     barretenberg::fr witness;
     uint32_t witness_index = IS_CONSTANT;
-    ComposerContext* context = nullptr;
+    Builder* context = nullptr;
 };
 
-template <typename ComposerContext> class public_witness_t : public witness_t<ComposerContext> {
+template <typename Builder> class public_witness_t : public witness_t<Builder> {
   public:
-    using witness_t<ComposerContext>::context;
-    using witness_t<ComposerContext>::witness;
-    using witness_t<ComposerContext>::witness_index;
+    using witness_t<Builder>::context;
+    using witness_t<Builder>::witness;
+    using witness_t<Builder>::witness_index;
 
     public_witness_t() = default;
-    public_witness_t(ComposerContext* parent_context, const barretenberg::fr& in)
+    public_witness_t(Builder* parent_context, const barretenberg::fr& in)
     {
         context = parent_context;
         barretenberg::fr::__copy(in, witness);
         witness_index = context->add_public_variable(witness);
     }
 
-    public_witness_t(ComposerContext* parent_context, const bool in)
+    public_witness_t(Builder* parent_context, const bool in)
     {
         context = parent_context;
         if (in) {
@@ -73,7 +73,7 @@ template <typename ComposerContext> class public_witness_t : public witness_t<Co
         witness_index = context->add_public_variable(witness);
     }
 
-    template <typename T> public_witness_t(ComposerContext* parent_context, T const in)
+    template <typename T> public_witness_t(Builder* parent_context, T const in)
     {
         context = parent_context;
         witness = barretenberg::fr{ static_cast<uint64_t>(in), 0, 0, 0 }.to_montgomery_form();
diff --git a/barretenberg/cpp/src/barretenberg/stdlib/recursion/transcript/transcript.hpp b/barretenberg/cpp/src/barretenberg/stdlib/recursion/transcript/transcript.hpp
index c43aa994806..6ec9ad7d1bf 100644
--- a/barretenberg/cpp/src/barretenberg/stdlib/recursion/transcript/transcript.hpp
+++ b/barretenberg/cpp/src/barretenberg/stdlib/recursion/transcript/transcript.hpp
@@ -17,21 +17,21 @@
 #include "../verification_key/verification_key.hpp"
 
 namespace proof_system::plonk::stdlib::recursion {
-template <typename Composer> class Transcript {
+template <typename Builder> class Transcript {
   public:
-    using field_pt = field_t<Composer>;
-    using witness_pt = witness_t<Composer>;
-    using fq_pt = bigfield<Composer, barretenberg::Bn254FqParams>;
-    using group_pt = element<Composer, fq_pt, field_pt, barretenberg::g1>;
-    using Key = verification_key<stdlib::bn254<Composer>>;
+    using field_pt = field_t<Builder>;
+    using witness_pt = witness_t<Builder>;
+    using fq_pt = bigfield<Builder, barretenberg::Bn254FqParams>;
+    using group_pt = element<Builder, fq_pt, field_pt, barretenberg::g1>;
+    using Key = verification_key<stdlib::bn254<Builder>>;
 
-    Transcript(Composer* in_context, const transcript::Manifest input_manifest)
+    Transcript(Builder* in_context, const transcript::Manifest input_manifest)
         : context(in_context)
         , transcript_base(input_manifest, transcript::HashType::PedersenBlake3s, 16)
         , current_challenge(in_context)
     {}
 
-    Transcript(Composer* in_context,
+    Transcript(Builder* in_context,
                const std::vector<uint8_t>& input_transcript,
                const transcript::Manifest input_manifest)
         : context(in_context)
@@ -41,8 +41,8 @@ template <typename Composer> class Transcript {
     {
         // for (size_t i = 0; i < input_transcript.size(); ++i)
         // {
-        //     field_t<Composer> data(witness_pt<Composer>(context, input_transcript[i]));
-        //     transcript_bytes.write(byte_array<Composer>(data));
+        //     field_t<Builder> data(witness_pt<Builder>(context, input_transcript[i]));
+        //     transcript_bytes.write(byte_array<Builder>(data));
         // }
     }
 
@@ -56,7 +56,7 @@ template <typename Composer> class Transcript {
      * @param field_buffer
      * @param num_public_inputs
      */
-    Transcript(Composer* in_context,
+    Transcript(Builder* in_context,
                const transcript::Manifest input_manifest,
                const std::vector<field_pt>& field_buffer,
                const size_t num_public_inputs)
@@ -185,7 +185,7 @@ template <typename Composer> class Transcript {
         // while we could store more *bits*, we want `preimage_buffer` to mirror how data is formatted
         // when we serialize field/group elements natively (i.e. a byte array)
         static constexpr size_t NUM_BITS_PER_PREIMAGE_ELEMENT = 31UL * 8UL;
-        PedersenPreimageBuilder<Composer, NUM_BITS_PER_PREIMAGE_ELEMENT> preimage_buffer(context);
+        PedersenPreimageBuilder<Builder, NUM_BITS_PER_PREIMAGE_ELEMENT> preimage_buffer(context);
         if (current_round > 0) {
             preimage_buffer.add_element(current_challenge);
         }
@@ -256,7 +256,7 @@ template <typename Composer> class Transcript {
             field_pt borrow = field_pt::from_witness(context, need_borrow);
 
             // directly call `create_new_range_constraint` to avoid creating an arithmetic gate
-            if constexpr (HasPlookup<Composer>) {
+            if constexpr (HasPlookup<Builder>) {
                 context->create_new_range_constraint(borrow.get_witness_index(), 1, "borrow");
             } else {
                 context->create_range_constraint(borrow.get_witness_index(), 1, "borrow");
@@ -274,10 +274,10 @@ template <typename Composer> class Transcript {
         };
 
         field_pt base_hash;
-        if constexpr (HasPlookup<Composer>) {
-            base_hash = stdlib::pedersen_plookup_commitment<Composer>::compress(std::vector<field_pt>{ T0 }, 0);
+        if constexpr (HasPlookup<Builder>) {
+            base_hash = stdlib::pedersen_plookup_commitment<Builder>::compress(std::vector<field_pt>{ T0 }, 0);
         } else {
-            base_hash = stdlib::pedersen_commitment<Composer>::compress(std::vector<field_pt>{ T0 }, 0);
+            base_hash = stdlib::pedersen_commitment<Builder>::compress(std::vector<field_pt>{ T0 }, 0);
         }
         auto hash_halves = slice_into_halves(base_hash);
         round_challenges_new.push_back(hash_halves[1]);
@@ -293,11 +293,11 @@ template <typename Composer> class Transcript {
         for (size_t i = 2; i < num_challenges; i += 2) {
             // TODO(@zac-williamson) make this a Poseidon hash not a Pedersen hash
             field_pt hash_output;
-            if constexpr (HasPlookup<Composer>) {
-                hash_output = stdlib::pedersen_plookup_commitment<Composer>::compress(
+            if constexpr (HasPlookup<Builder>) {
+                hash_output = stdlib::pedersen_plookup_commitment<Builder>::compress(
                     std::vector<field_pt>{ (base_hash + field_pt(i / 2)).normalize() }, 0);
             } else {
-                hash_output = stdlib::pedersen_commitment<Composer>::compress(
+                hash_output = stdlib::pedersen_commitment<Builder>::compress(
                     std::vector<field_pt>{ (base_hash + field_pt(i / 2)).normalize() }, 0);
             }
             auto hash_halves = slice_into_halves(hash_output);
@@ -394,9 +394,9 @@ template <typename Composer> class Transcript {
         return result;
     }
 
-    static fq_pt convert_fq(Composer* ctx, const barretenberg::fq& input) { return fq_pt::from_witness(ctx, input); };
+    static fq_pt convert_fq(Builder* ctx, const barretenberg::fq& input) { return fq_pt::from_witness(ctx, input); };
 
-    static group_pt convert_g1(Composer* ctx, const barretenberg::g1::affine_element& input)
+    static group_pt convert_g1(Builder* ctx, const barretenberg::g1::affine_element& input)
     {
         return group_pt::from_witness(ctx, input);
     };
@@ -406,7 +406,7 @@ template <typename Composer> class Transcript {
         return transcript_base.get_num_challenges(challenge_name);
     }
 
-    Composer* context;
+    Builder* context;
 
   private:
     transcript::Transcript transcript_base;
diff --git a/barretenberg/cpp/src/barretenberg/stdlib/recursion/verification_key/verification_key.hpp b/barretenberg/cpp/src/barretenberg/stdlib/recursion/verification_key/verification_key.hpp
index 893bdf19ffb..fb0a20bdd15 100644
--- a/barretenberg/cpp/src/barretenberg/stdlib/recursion/verification_key/verification_key.hpp
+++ b/barretenberg/cpp/src/barretenberg/stdlib/recursion/verification_key/verification_key.hpp
@@ -34,16 +34,16 @@ namespace recursion {
  * @details When calling `pedersen::compress` on the final buffer, we can skip the range checks normally performed in
  * the compress method, because we know the sums of the scalar slices cannot exceed the field modulus. This requires
  * `bits_per_element < modulus bits`
- * @tparam Composer
+ * @tparam Builder
  * @tparam bits_per_element
  */
-template <class Composer, size_t bits_per_element = 248> struct PedersenPreimageBuilder {
-    using field_pt = field_t<Composer>;
-    using witness_pt = witness_t<Composer>;
+template <class Builder, size_t bits_per_element = 248> struct PedersenPreimageBuilder {
+    using field_pt = field_t<Builder>;
+    using witness_pt = witness_t<Builder>;
 
-    Composer* context;
+    Builder* context;
 
-    PedersenPreimageBuilder(Composer* ctx = nullptr)
+    PedersenPreimageBuilder(Builder* ctx = nullptr)
         : context(ctx){};
 
     field_pt compress(const size_t hash_index)
@@ -58,11 +58,11 @@ template <class Composer, size_t bits_per_element = 248> struct PedersenPreimage
             }
             preimage_data.push_back(field_pt::accumulate(work_element));
         }
-        if constexpr (HasPlookup<Composer>) {
-            return pedersen_plookup_commitment<Composer>::compress_with_relaxed_range_constraints(preimage_data,
-                                                                                                  hash_index);
+        if constexpr (HasPlookup<Builder>) {
+            return pedersen_plookup_commitment<Builder>::compress_with_relaxed_range_constraints(preimage_data,
+                                                                                                 hash_index);
         } else {
-            return pedersen_commitment<Composer>::compress(preimage_data, hash_index);
+            return pedersen_commitment<Builder>::compress(preimage_data, hash_index);
         }
     }
 
@@ -145,7 +145,7 @@ template <class Composer, size_t bits_per_element = 248> struct PedersenPreimage
             field_pt borrow = field_pt::from_witness(context, need_borrow);
 
             // directly call `create_new_range_constraint` to avoid creating an arithmetic gate
-            if constexpr (HasPlookup<Composer>) {
+            if constexpr (HasPlookup<Builder>) {
                 context->create_new_range_constraint(borrow.get_witness_index(), 1, "borrow");
             } else {
                 context->create_range_constraint(borrow.get_witness_index(), 1, "borrow");
@@ -177,8 +177,8 @@ template <class Composer, size_t bits_per_element = 248> struct PedersenPreimage
     };
 };
 
-template <typename Composer> struct evaluation_domain {
-    static evaluation_domain from_field_elements(const std::vector<field_t<Composer>>& fields)
+template <typename Builder> struct evaluation_domain {
+    static evaluation_domain from_field_elements(const std::vector<field_t<Builder>>& fields)
     {
         evaluation_domain domain;
         domain.root = fields[0];
@@ -192,47 +192,47 @@ template <typename Composer> struct evaluation_domain {
         return domain;
     }
 
-    static evaluation_domain from_witness(Composer* ctx, const barretenberg::evaluation_domain& input)
+    static evaluation_domain from_witness(Builder* ctx, const barretenberg::evaluation_domain& input)
     {
         evaluation_domain domain;
-        domain.root = witness_t<Composer>(ctx, input.root);
+        domain.root = witness_t<Builder>(ctx, input.root);
         domain.root_inverse = domain.root.invert();
-        domain.domain = witness_t<Composer>(ctx, input.domain);
+        domain.domain = witness_t<Builder>(ctx, input.domain);
         domain.domain_inverse = domain.domain.invert();
-        domain.generator = witness_t<Composer>(ctx, input.generator);
+        domain.generator = witness_t<Builder>(ctx, input.generator);
         domain.generator_inverse = domain.generator.invert();
         domain.size = domain.domain;
         return domain;
     }
 
-    static evaluation_domain from_constants(Composer* ctx, const barretenberg::evaluation_domain& input)
+    static evaluation_domain from_constants(Builder* ctx, const barretenberg::evaluation_domain& input)
     {
         evaluation_domain domain;
-        domain.root = field_t<Composer>(ctx, input.root);
-        domain.root_inverse = field_t<Composer>(ctx, input.root_inverse);
-        domain.domain = field_t<Composer>(ctx, input.domain);
-        domain.domain_inverse = field_t<Composer>(ctx, input.domain_inverse);
-        domain.generator = field_t<Composer>(ctx, input.generator);
-        domain.generator_inverse = field_t<Composer>(ctx, input.generator_inverse);
+        domain.root = field_t<Builder>(ctx, input.root);
+        domain.root_inverse = field_t<Builder>(ctx, input.root_inverse);
+        domain.domain = field_t<Builder>(ctx, input.domain);
+        domain.domain_inverse = field_t<Builder>(ctx, input.domain_inverse);
+        domain.generator = field_t<Builder>(ctx, input.generator);
+        domain.generator_inverse = field_t<Builder>(ctx, input.generator_inverse);
         domain.size = domain.domain;
         return domain;
     }
 
-    field_t<Composer> root;
-    field_t<Composer> root_inverse;
-    field_t<Composer> domain;
-    field_t<Composer> domain_inverse;
-    field_t<Composer> generator;
-    field_t<Composer> generator_inverse;
-    uint32<Composer> size;
+    field_t<Builder> root;
+    field_t<Builder> root_inverse;
+    field_t<Builder> domain;
+    field_t<Builder> domain_inverse;
+    field_t<Builder> generator;
+    field_t<Builder> generator_inverse;
+    uint32<Builder> size;
 };
 
 template <typename Curve> struct verification_key {
-    using Composer = typename Curve::Composer;
+    using Builder = typename Curve::Builder;
 
     static std::shared_ptr<verification_key> from_field_elements(
-        Composer* ctx,
-        const std::vector<field_t<Composer>>& fields,
+        Builder* ctx,
+        const std::vector<field_t<Builder>>& fields,
         bool inner_proof_contains_recursive_proof = false,
         std::array<uint32_t, 16> recursive_proof_public_input_indices = {})
     {
@@ -240,8 +240,8 @@ template <typename Curve> struct verification_key {
         std::shared_ptr<verification_key> key = std::make_shared<verification_key>();
         key->context = ctx;
 
-        key->polynomial_manifest = PolynomialManifest(Composer::CIRCUIT_TYPE);
-        key->domain = evaluation_domain<Composer>::from_field_elements({ fields[0], fields[1], fields[2] });
+        key->polynomial_manifest = PolynomialManifest(Builder::CIRCUIT_TYPE);
+        key->domain = evaluation_domain<Builder>::from_field_elements({ fields[0], fields[1], fields[2] });
 
         key->n = fields[3];
         key->num_public_inputs = fields[4];
@@ -278,7 +278,7 @@ template <typename Curve> struct verification_key {
      * as circuit variables. This allows the recursive verifier to accept arbitrary verification keys, where the circuit
      * being verified is not fixed as part of the recursive circuit.
      */
-    static std::shared_ptr<verification_key> from_witness(Composer* ctx,
+    static std::shared_ptr<verification_key> from_witness(Builder* ctx,
                                                           const std::shared_ptr<plonk::verification_key>& input_key)
     {
         std::shared_ptr<verification_key> key = std::make_shared<verification_key>();
@@ -288,9 +288,9 @@ template <typename Curve> struct verification_key {
         key->polynomial_manifest = input_key->polynomial_manifest;
 
         // Circuit types:
-        key->n = witness_t<Composer>(ctx, barretenberg::fr(input_key->circuit_size));
-        key->num_public_inputs = witness_t<Composer>(ctx, input_key->num_public_inputs);
-        key->domain = evaluation_domain<Composer>::from_witness(ctx, input_key->domain);
+        key->n = witness_t<Builder>(ctx, barretenberg::fr(input_key->circuit_size));
+        key->num_public_inputs = witness_t<Builder>(ctx, input_key->num_public_inputs);
+        key->domain = evaluation_domain<Builder>::from_witness(ctx, input_key->domain);
         key->contains_recursive_proof = input_key->contains_recursive_proof;
         key->recursive_proof_public_input_indices = input_key->recursive_proof_public_input_indices;
         for (const auto& [tag, value] : input_key->commitments) {
@@ -307,17 +307,17 @@ template <typename Curve> struct verification_key {
         return key;
     }
 
-    static std::shared_ptr<verification_key> from_constants(Composer* ctx,
+    static std::shared_ptr<verification_key> from_constants(Builder* ctx,
                                                             const std::shared_ptr<plonk::verification_key>& input_key)
     {
         std::shared_ptr<verification_key> key = std::make_shared<verification_key>();
         key->context = ctx;
-        key->n = field_t<Composer>(ctx, input_key->circuit_size);
-        key->num_public_inputs = field_t<Composer>(ctx, input_key->num_public_inputs);
+        key->n = field_t<Builder>(ctx, input_key->circuit_size);
+        key->num_public_inputs = field_t<Builder>(ctx, input_key->num_public_inputs);
         key->contains_recursive_proof = input_key->contains_recursive_proof;
         key->recursive_proof_public_input_indices = input_key->recursive_proof_public_input_indices;
 
-        key->domain = evaluation_domain<Composer>::from_constants(ctx, input_key->domain);
+        key->domain = evaluation_domain<Builder>::from_constants(ctx, input_key->domain);
 
         for (const auto& [tag, value] : input_key->commitments) {
             key->commitments.insert({ tag, typename Curve::Group(value) });
@@ -334,14 +334,14 @@ template <typename Curve> struct verification_key {
         const auto circuit_key_compressed = compress();
         bool found = false;
         // if we're using Plookup, use a ROM table to index the keys
-        if constexpr (HasPlookup<Composer>) {
-            field_t<Composer> key_index(witness_t<Composer>(context, 0));
-            std::vector<field_t<Composer>> compressed_keys;
+        if constexpr (HasPlookup<Builder>) {
+            field_t<Builder> key_index(witness_t<Builder>(context, 0));
+            std::vector<field_t<Builder>> compressed_keys;
             for (size_t i = 0; i < keys_in_set.size(); ++i) {
                 barretenberg::fr compressed = compress_native(keys_in_set[i]);
                 compressed_keys.emplace_back(compressed);
                 if (compressed == circuit_key_compressed.get_value()) {
-                    key_index = witness_t<Composer>(context, i);
+                    key_index = witness_t<Builder>(context, i);
                     found = true;
                 }
             }
@@ -349,12 +349,12 @@ template <typename Curve> struct verification_key {
                 context->failure(
                     "verification_key::validate_key_is_in_set failed - input key is not in the provided set!");
             }
-            rom_table<Composer> key_table(compressed_keys);
+            rom_table<Builder> key_table(compressed_keys);
 
             const auto output_key = key_table[key_index];
             output_key.assert_equal(circuit_key_compressed);
         } else {
-            bool_t<Composer> is_valid(false);
+            bool_t<Builder> is_valid(false);
             for (const auto& key : keys_in_set) {
                 barretenberg::fr compressed = compress_native(key);
                 is_valid = is_valid || (circuit_key_compressed == compressed);
@@ -365,12 +365,12 @@ template <typename Curve> struct verification_key {
     }
 
   public:
-    field_t<Composer> compress(size_t const hash_index = 0)
+    field_t<Builder> compress(size_t const hash_index = 0)
     {
-        PedersenPreimageBuilder<Composer> preimage_buffer(context);
+        PedersenPreimageBuilder<Builder> preimage_buffer(context);
 
-        field_t<Composer> circuit_type =
-            witness_t<Composer>::create_constant_witness(context, static_cast<uint32_t>(Composer::CIRCUIT_TYPE));
+        field_t<Builder> circuit_type =
+            witness_t<Builder>::create_constant_witness(context, static_cast<uint32_t>(Builder::CIRCUIT_TYPE));
         domain.generator.create_range_constraint(16, "domain.generator");
         domain.domain.create_range_constraint(32, "domain.generator");
         num_public_inputs.create_range_constraint(32, "num_public_inputs");
@@ -393,7 +393,7 @@ template <typename Curve> struct verification_key {
             preimage_buffer.add_element_with_existing_range_constraint(x.binary_basis_limbs[0].element, limb_bits);
         }
         preimage_buffer.add_element(domain.root);
-        field_t<Composer> compressed_key = preimage_buffer.compress(hash_index);
+        field_t<Builder> compressed_key = preimage_buffer.compress(hash_index);
         return compressed_key;
     }
 
@@ -402,7 +402,7 @@ template <typename Curve> struct verification_key {
     {
         std::vector<uint8_t> preimage_data;
 
-        preimage_data.push_back(static_cast<uint8_t>(Composer::CIRCUIT_TYPE));
+        preimage_data.push_back(static_cast<uint8_t>(Builder::CIRCUIT_TYPE));
 
         const uint256_t domain = key->domain.domain;
         const uint256_t generator = key->domain.generator;
@@ -423,7 +423,7 @@ template <typename Curve> struct verification_key {
         write(preimage_data, key->domain.root);
 
         barretenberg::fr compressed_key;
-        if constexpr (HasPlookup<Composer>) {
+        if constexpr (HasPlookup<Builder>) {
             compressed_key = from_buffer<barretenberg::fr>(
                 crypto::pedersen_commitment::lookup::compress_native(preimage_data, hash_index));
         } else {
@@ -434,11 +434,11 @@ template <typename Curve> struct verification_key {
 
   public:
     // Circuit Types:
-    field_t<Composer> n;
-    field_t<Composer> num_public_inputs;
-    field_t<Composer> z_pow_n;
+    field_t<Builder> n;
+    field_t<Builder> num_public_inputs;
+    field_t<Builder> z_pow_n;
 
-    evaluation_domain<Composer> domain;
+    evaluation_domain<Builder> domain;
 
     std::map<std::string, typename Curve::Group> commitments;
 
@@ -451,7 +451,7 @@ template <typename Curve> struct verification_key {
     bool contains_recursive_proof = false;
     std::vector<uint32_t> recursive_proof_public_input_indices;
     size_t program_width = 4;
-    Composer* context;
+    Builder* context;
 };
 
 } // namespace recursion
diff --git a/barretenberg/cpp/src/barretenberg/stdlib/recursion/verification_key/verification_key.test.cpp b/barretenberg/cpp/src/barretenberg/stdlib/recursion/verification_key/verification_key.test.cpp
index 440049eac32..fedf66d6cd1 100644
--- a/barretenberg/cpp/src/barretenberg/stdlib/recursion/verification_key/verification_key.test.cpp
+++ b/barretenberg/cpp/src/barretenberg/stdlib/recursion/verification_key/verification_key.test.cpp
@@ -15,13 +15,13 @@ using namespace proof_system::plonk;
 
 /**
  * @brief A test fixture that will let us generate VK data and run tests
- * for all composer types
+ * for all builder types
  *
- * @tparam Composer
+ * @tparam Builder
  */
-template <typename Composer> class VerificationKeyFixture : public testing::Test {
+template <typename Builder> class VerificationKeyFixture : public testing::Test {
   public:
-    using Curve = proof_system::plonk::stdlib::bn254<Composer>;
+    using Curve = proof_system::plonk::stdlib::bn254<Builder>;
     using RecursVk = proof_system::plonk::stdlib::recursion::verification_key<Curve>;
 
     static void SetUpTestSuite() { barretenberg::srs::init_crs_factory("../srs_db/ignition"); }
@@ -34,7 +34,7 @@ template <typename Composer> class VerificationKeyFixture : public testing::Test
     static verification_key_data rand_vk_data()
     {
         verification_key_data vk_data;
-        vk_data.circuit_type = static_cast<uint32_t>(Composer::CIRCUIT_TYPE);
+        vk_data.circuit_type = static_cast<uint32_t>(Builder::CIRCUIT_TYPE);
         vk_data.circuit_size = 1024; // not random - must be power of 2
         vk_data.num_public_inputs = engine.get_random_uint32();
         vk_data.commitments["test1"] = g1::element::random_element();
diff --git a/barretenberg/cpp/src/barretenberg/stdlib/recursion/verifier/program_settings.hpp b/barretenberg/cpp/src/barretenberg/stdlib/recursion/verifier/program_settings.hpp
index 228ef1bbc87..dbccf2f49dd 100644
--- a/barretenberg/cpp/src/barretenberg/stdlib/recursion/verifier/program_settings.hpp
+++ b/barretenberg/cpp/src/barretenberg/stdlib/recursion/verifier/program_settings.hpp
@@ -12,8 +12,8 @@ template <typename Curve> class recursive_ultra_verifier_settings : public plonk
   public:
     typedef typename Curve::ScalarField fr_ct;
     typedef typename Curve::GroupNative::affine_element g1;
-    typedef typename Curve::Composer Composer;
-    typedef proof_system::plonk::stdlib::recursion::Transcript<Composer> Transcript_pt;
+    typedef typename Curve::Builder Builder;
+    typedef proof_system::plonk::stdlib::recursion::Transcript<Builder> Transcript_pt;
     typedef proof_system::plonk::VerifierPermutationWidget<fr_ct, g1, Transcript_pt> PermutationWidget;
     typedef proof_system::plonk::VerifierPlookupWidget<fr_ct, g1, Transcript_pt> PlookupWidget;
 
@@ -90,8 +90,8 @@ class recursive_ultra_to_standard_verifier_settings : public recursive_ultra_ver
   public:
     typedef typename Curve::ScalarField fr_ct;
     typedef typename Curve::GroupNative::affine_element g1;
-    typedef typename Curve::Composer Composer;
-    typedef proof_system::plonk::stdlib::recursion::Transcript<Composer> Transcript_pt;
+    typedef typename Curve::Builder Builder;
+    typedef proof_system::plonk::stdlib::recursion::Transcript<Builder> Transcript_pt;
     typedef proof_system::plonk::VerifierPermutationWidget<fr_ct, g1, Transcript_pt> PermutationWidget;
     typedef proof_system::plonk::VerifierPlookupWidget<fr_ct, g1, Transcript_pt> PlookupWidget;
 
@@ -112,8 +112,8 @@ template <typename Curve> class recursive_turbo_verifier_settings : public plonk
   public:
     typedef typename Curve::ScalarField fr_ct;
     typedef typename Curve::GroupNative::affine_element g1;
-    typedef typename Curve::Composer Composer;
-    typedef Transcript<Composer> Transcript_pt;
+    typedef typename Curve::Builder Builder;
+    typedef Transcript<Builder> Transcript_pt;
     typedef proof_system::plonk::VerifierPermutationWidget<fr_ct, g1, Transcript_pt> PermutationWidget;
 
     typedef proof_system::plonk::turbo_settings base_settings;