diff --git a/barretenberg/cpp/pil/vm2/README.md b/barretenberg/cpp/pil/vm2/README.md
new file mode 100644
index 00000000000..4194d164843
--- /dev/null
+++ b/barretenberg/cpp/pil/vm2/README.md
@@ -0,0 +1,7 @@
+Compile with:
+
+```
+~/aztec-packages/bb-pilcom/target/release/bb_pil pil/vm2/execution.pil --name Avm2 -y -o src/barretenberg/vm2/generated && ./format.sh changed
+```
+
+while on the `barretenberg/cpp` directory.
diff --git a/barretenberg/cpp/pil/vm2/addressing.pil b/barretenberg/cpp/pil/vm2/addressing.pil
new file mode 100644
index 00000000000..19947f5f661
--- /dev/null
+++ b/barretenberg/cpp/pil/vm2/addressing.pil
@@ -0,0 +1,21 @@
+// This is a virtual gadget, which is part of the execution trace.
+namespace execution(256);
+
+pol commit stack_pointer_val;
+pol commit stack_pointer_tag;
+pol commit sel_addressing_error;  // true if any error type
+pol commit addressing_error_kind;  // TODO: might need to be selectors
+pol commit addressing_error_idx;  // operand index for error, if any
+
+// whether each operand is an address for the given opcode.
+// retrieved from the instruction spec.
+pol commit sel_op1_is_address;
+pol commit sel_op2_is_address;
+pol commit sel_op3_is_address;
+pol commit sel_op4_is_address;
+// operands after relative resolution
+pol commit op1_after_relative;
+pol commit op2_after_relative;
+pol commit op3_after_relative;
+pol commit op4_after_relative;
+// operands after indirect resolution are the resolved_operands rop1, ...
diff --git a/barretenberg/cpp/pil/vm2/alu.pil b/barretenberg/cpp/pil/vm2/alu.pil
new file mode 100644
index 00000000000..ee0de13f9ab
--- /dev/null
+++ b/barretenberg/cpp/pil/vm2/alu.pil
@@ -0,0 +1,16 @@
+namespace alu(256);
+
+pol commit sel_op_add;
+pol commit ia;
+pol commit ib;
+pol commit ic;
+pol commit op;
+pol commit ia_addr;
+pol commit ib_addr;
+pol commit dst_addr;
+
+#[SEL_ADD_BINARY]
+sel_op_add * (1 - sel_op_add) = 0;
+
+#[ALU_ADD]
+ia + ib = ic;
\ No newline at end of file
diff --git a/barretenberg/cpp/pil/vm2/execution.pil b/barretenberg/cpp/pil/vm2/execution.pil
new file mode 100644
index 00000000000..5718674edb5
--- /dev/null
+++ b/barretenberg/cpp/pil/vm2/execution.pil
@@ -0,0 +1,55 @@
+include "alu.pil";
+include "addressing.pil";
+include "precomputed.pil";
+
+namespace execution(256);
+
+pol commit sel; // subtrace selector
+
+pol commit ex_opcode;
+pol commit indirect;
+// operands
+pol commit op1;
+pol commit op2;
+pol commit op3;
+pol commit op4;
+// resolved operands
+pol commit rop1;
+pol commit rop2;
+pol commit rop3;
+pol commit rop4;
+
+pol commit pc;
+pol commit clk;
+pol commit last;
+
+// Selector constraints
+sel * (1 - sel) = 0;
+last * (1 - last) = 0;
+
+// If the current row is an execution row, then either
+// the next row is an execution row, or the current row is marked as the last row.
+// sel => (sel' v last) = 1              iff
+// ¬sel v (sel' v last) = 1              iff
+// ¬(¬sel v (sel' v last)) = 0           iff
+// sel ^ (¬sel' ^ ¬last) = 0             iff
+// sel * (1 - sel') * (1 - last) = 0
+#[TRACE_CONTINUITY_1]
+sel * (1 - sel') * (1 - last) = 0;
+// If the current row is not an execution row, then there are no more execution rows after that.
+// (not enforced for the first row)
+#[TRACE_CONTINUITY_2]
+(1 - precomputed.first_row) * (1 - sel) * sel' = 0;
+// If the current row is the last row, then the next row is not an execution row.
+#[LAST_IS_LAST]
+last * sel' = 0;
+
+// These are needed to have a non-empty set of columns for each type.
+pol public input;
+#[LOOKUP_DUMMY_PRECOMPUTED]
+sel {/*will be 1=OR*/ sel, clk, clk, clk} in
+precomputed.sel_bitwise {precomputed.bitwise_op_id, precomputed.bitwise_input_a, precomputed.bitwise_input_b, precomputed.bitwise_output};
+#[LOOKUP_DUMMY_DYNAMIC]  // Just a self-lookup for now, for testing.
+sel {op1, op2, op3, op4} in sel {op1, op2, op3, op4};
+#[PERM_DUMMY_DYNAMIC]  // Just a self-permutation for now, for testing.
+sel {op1, op2, op3, op4} is sel {op1, op2, op3, op4};
\ No newline at end of file
diff --git a/barretenberg/cpp/pil/vm2/precomputed.pil b/barretenberg/cpp/pil/vm2/precomputed.pil
new file mode 100644
index 00000000000..f5dc8ff2635
--- /dev/null
+++ b/barretenberg/cpp/pil/vm2/precomputed.pil
@@ -0,0 +1,17 @@
+// General/shared precomputed columns.
+namespace precomputed(256);
+
+// From 0 and incrementing up to the size of the circuit (2^21).
+pol constant clk;
+
+// 1 only at row 0.
+pol constant first_row;
+
+// AND/OR/XOR of all 8-bit numbers.
+// The tables are "stacked". First AND, then OR, then XOR.
+// Note: think if we can avoid the selector.
+pol constant sel_bitwise; // 1 in the first 3 * 256 rows.
+pol constant bitwise_op_id; // identifies if operation is AND/OR/XOR.
+pol constant bitwise_input_a; // column of all 8-bit numbers.
+pol constant bitwise_input_b; // column of all 8-bit numbers.
+pol constant bitwise_output; // output = a AND/OR/XOR b.
\ No newline at end of file
diff --git a/barretenberg/cpp/src/CMakeLists.txt b/barretenberg/cpp/src/CMakeLists.txt
index fd992566082..cd0965babb9 100644
--- a/barretenberg/cpp/src/CMakeLists.txt
+++ b/barretenberg/cpp/src/CMakeLists.txt
@@ -95,6 +95,7 @@ add_subdirectory(barretenberg/transcript)
 add_subdirectory(barretenberg/translator_vm)
 add_subdirectory(barretenberg/ultra_honk)
 add_subdirectory(barretenberg/vm)
+add_subdirectory(barretenberg/vm2)
 add_subdirectory(barretenberg/wasi)
 add_subdirectory(barretenberg/world_state)
 
@@ -171,6 +172,7 @@ set(BARRETENBERG_TARGET_OBJECTS
 if(NOT DISABLE_AZTEC_VM)
     # enable AVM
     list(APPEND BARRETENBERG_TARGET_OBJECTS $<TARGET_OBJECTS:vm_objects>)
+    list(APPEND BARRETENBERG_TARGET_OBJECTS $<TARGET_OBJECTS:vm2_objects>)
 endif()
 
 if(NOT WASM)
diff --git a/barretenberg/cpp/src/barretenberg/bb/main.cpp b/barretenberg/cpp/src/barretenberg/bb/main.cpp
index cf6f7fefba1..465d9732ac1 100644
--- a/barretenberg/cpp/src/barretenberg/bb/main.cpp
+++ b/barretenberg/cpp/src/barretenberg/bb/main.cpp
@@ -3,6 +3,7 @@
 #include "barretenberg/bb/file_io.hpp"
 #include "barretenberg/client_ivc/client_ivc.hpp"
 #include "barretenberg/common/benchmark.hpp"
+#include "barretenberg/common/log.hpp"
 #include "barretenberg/common/map.hpp"
 #include "barretenberg/common/serialize.hpp"
 #include "barretenberg/common/timer.hpp"
@@ -13,7 +14,6 @@
 #include "barretenberg/dsl/acir_format/proof_surgeon.hpp"
 #include "barretenberg/dsl/acir_proofs/acir_composer.hpp"
 #include "barretenberg/dsl/acir_proofs/honk_contract.hpp"
-#include "barretenberg/flavor/flavor.hpp"
 #include "barretenberg/honk/proof_system/types/proof.hpp"
 #include "barretenberg/numeric/bitop/get_msb.hpp"
 #include "barretenberg/plonk/proof_system/proving_key/serialize.hpp"
@@ -24,15 +24,17 @@
 #include "barretenberg/stdlib_circuit_builders/ultra_flavor.hpp"
 #include "barretenberg/stdlib_circuit_builders/ultra_keccak_flavor.hpp"
 #include "barretenberg/stdlib_circuit_builders/ultra_rollup_flavor.hpp"
-#include "barretenberg/vm/avm/trace/public_inputs.hpp"
-#include <cstdint>
 
 #ifndef DISABLE_AZTEC_VM
 #include "barretenberg/vm/avm/generated/flavor.hpp"
 #include "barretenberg/vm/avm/trace/common.hpp"
 #include "barretenberg/vm/avm/trace/execution.hpp"
+#include "barretenberg/vm/avm/trace/public_inputs.hpp"
 #include "barretenberg/vm/aztec_constants.hpp"
 #include "barretenberg/vm/stats.hpp"
+#include "barretenberg/vm2/avm_api.hpp"
+#include "barretenberg/vm2/common/aztec_types.hpp"
+#include "barretenberg/vm2/common/constants.hpp"
 #endif
 
 using namespace bb;
@@ -671,6 +673,16 @@ void vk_as_fields(const std::string& vk_path, const std::string& output_path)
 }
 
 #ifndef DISABLE_AZTEC_VM
+void print_avm_stats()
+{
+#ifdef AVM_TRACK_STATS
+    info("------- STATS -------");
+    const auto& stats = avm_trace::Stats::get();
+    const int levels = std::getenv("AVM_STATS_DEPTH") != nullptr ? std::stoi(std::getenv("AVM_STATS_DEPTH")) : 2;
+    info(stats.to_string(levels));
+#endif
+}
+
 /**
  * @brief Writes an avm proof and corresponding (incomplete) verification key to files.
  *
@@ -726,12 +738,34 @@ void avm_prove(const std::filesystem::path& public_inputs_path,
     write_file(vk_fields_path, { vk_json.begin(), vk_json.end() });
     vinfo("vk as fields written to: ", vk_fields_path);
 
-#ifdef AVM_TRACK_STATS
-    info("------- STATS -------");
-    const auto& stats = avm_trace::Stats::get();
-    const int levels = std::getenv("AVM_STATS_DEPTH") != nullptr ? std::stoi(std::getenv("AVM_STATS_DEPTH")) : 2;
-    info(stats.to_string(levels));
-#endif
+    print_avm_stats();
+}
+
+void avm2_prove(const std::filesystem::path& inputs_path, const std::filesystem::path& output_path)
+{
+    avm2::AvmAPI avm;
+    auto inputs = avm2::AvmAPI::ProvingInputs::from(read_file(inputs_path));
+
+    // This is bigger than CIRCUIT_SUBGROUP_SIZE because of BB inefficiencies.
+    init_bn254_crs(avm2::CIRCUIT_SUBGROUP_SIZE * 2);
+    auto [proof, vk] = avm.prove(inputs);
+
+    // NOTE: As opposed to Avm1 and other proof systems, the public inputs are NOT part of the proof.
+    write_file(output_path / "proof", to_buffer(proof));
+    write_file(output_path / "vk", vk);
+
+    print_avm_stats();
+}
+
+void avm2_check_circuit(const std::filesystem::path& inputs_path)
+{
+    avm2::AvmAPI avm;
+    auto inputs = avm2::AvmAPI::ProvingInputs::from(read_file(inputs_path));
+
+    bool res = avm.check_circuit(inputs);
+    info("circuit check: ", res ? "success" : "failure");
+
+    print_avm_stats();
 }
 
 /**
@@ -783,8 +817,28 @@ bool avm_verify(const std::filesystem::path& proof_path, const std::filesystem::
 
     const bool verified = AVM_TRACK_TIME_V("verify/all", avm_trace::Execution::verify(vk, proof));
     vinfo("verified: ", verified);
+
+    print_avm_stats();
     return verified;
 }
+
+// NOTE: The proof should NOT include the public inputs.
+bool avm2_verify(const std::filesystem::path& proof_path,
+                 const std::filesystem::path& public_inputs_path,
+                 const std::filesystem::path& vk_path)
+{
+    const auto proof = many_from_buffer<fr>(read_file(proof_path));
+    std::vector<uint8_t> vk_bytes = read_file(vk_path);
+    auto public_inputs = avm2::PublicInputs::from(read_file(public_inputs_path));
+
+    init_bn254_crs(1);
+    avm2::AvmAPI avm;
+    bool res = avm.verify(proof, public_inputs, vk_bytes);
+    info("verification: ", res ? "success" : "failure");
+
+    print_avm_stats();
+    return res;
+}
 #endif
 
 /**
@@ -1382,6 +1436,18 @@ int main(int argc, char* argv[])
             std::string output_path = get_option(args, "-o", "./target");
             write_recursion_inputs_honk<UltraRollupFlavor>(bytecode_path, witness_path, output_path, recursive);
 #ifndef DISABLE_AZTEC_VM
+        } else if (command == "avm2_prove") {
+            std::filesystem::path inputs_path = get_option(args, "--avm-inputs", "./target/avm_inputs.bin");
+            // This outputs both files: proof and vk, under the given directory.
+            std::filesystem::path output_path = get_option(args, "-o", "./proofs");
+            avm2_prove(inputs_path, output_path);
+        } else if (command == "avm2_check_circuit") {
+            std::filesystem::path inputs_path = get_option(args, "--avm-inputs", "./target/avm_inputs.bin");
+            avm2_check_circuit(inputs_path);
+        } else if (command == "avm2_verify") {
+            std::filesystem::path public_inputs_path =
+                get_option(args, "--avm-public-inputs", "./target/avm_public_inputs.bin");
+            return avm2_verify(proof_path, public_inputs_path, vk_path) ? 0 : 1;
         } else if (command == "avm_prove") {
             std::filesystem::path avm_public_inputs_path =
                 get_option(args, "--avm-public-inputs", "./target/avm_public_inputs.bin");
diff --git a/barretenberg/cpp/src/barretenberg/ecc/groups/affine_element.hpp b/barretenberg/cpp/src/barretenberg/ecc/groups/affine_element.hpp
index 883f8bcb017..3372899d730 100644
--- a/barretenberg/cpp/src/barretenberg/ecc/groups/affine_element.hpp
+++ b/barretenberg/cpp/src/barretenberg/ecc/groups/affine_element.hpp
@@ -170,6 +170,9 @@ template <typename Fq_, typename Fr_, typename Params> class alignas(64) affine_
     }
     Fq x;
     Fq y;
+
+    // Note: this serialization from typescript does not support infinity.
+    MSGPACK_FIELDS(x, y);
 };
 
 template <typename B, typename Fq_, typename Fr_, typename Params>
diff --git a/barretenberg/cpp/src/barretenberg/vm2/CMakeLists.txt b/barretenberg/cpp/src/barretenberg/vm2/CMakeLists.txt
new file mode 100644
index 00000000000..8084b7b8306
--- /dev/null
+++ b/barretenberg/cpp/src/barretenberg/vm2/CMakeLists.txt
@@ -0,0 +1,3 @@
+if(NOT DISABLE_AZTEC_VM)
+  barretenberg_module(vm2 sumcheck stdlib_honk_verifier)
+endif()
\ No newline at end of file
diff --git a/barretenberg/cpp/src/barretenberg/vm2/avm_api.cpp b/barretenberg/cpp/src/barretenberg/vm2/avm_api.cpp
new file mode 100644
index 00000000000..8dddc62058d
--- /dev/null
+++ b/barretenberg/cpp/src/barretenberg/vm2/avm_api.cpp
@@ -0,0 +1,58 @@
+#include "barretenberg/vm2/avm_api.hpp"
+
+#include "barretenberg/vm/stats.hpp"
+#include "barretenberg/vm2/proving_helper.hpp"
+#include "barretenberg/vm2/simulation_helper.hpp"
+#include "barretenberg/vm2/tracegen_helper.hpp"
+
+namespace bb::avm2 {
+
+using namespace bb::avm2::simulation;
+
+std::pair<AvmAPI::AvmProof, AvmAPI::AvmVerificationKey> AvmAPI::prove(const AvmAPI::ProvingInputs& inputs)
+{
+    // Simulate.
+    info("Simulating...");
+    AvmSimulationHelper simulation_helper(inputs);
+    auto events = AVM_TRACK_TIME_V("simulation/all", simulation_helper.simulate());
+
+    // Generate trace.
+    info("Generating trace...");
+    AvmTraceGenHelper tracegen_helper;
+    auto trace = AVM_TRACK_TIME_V("tracegen/all", tracegen_helper.generate_trace(std::move(events)));
+
+    // Prove.
+    info("Proving...");
+    AvmProvingHelper proving_helper;
+    auto [proof, vk] = AVM_TRACK_TIME_V("proving/all", proving_helper.prove(std::move(trace)));
+
+    info("Done!");
+    return { std::move(proof), std::move(vk) };
+}
+
+bool AvmAPI::check_circuit(const AvmAPI::ProvingInputs& inputs)
+{
+    // Simulate.
+    info("Simulating...");
+    AvmSimulationHelper simulation_helper(inputs);
+    auto events = AVM_TRACK_TIME_V("simulation/all", simulation_helper.simulate());
+
+    // Generate trace.
+    info("Generating trace...");
+    AvmTraceGenHelper tracegen_helper;
+    auto trace = AVM_TRACK_TIME_V("tracegen/all", tracegen_helper.generate_trace(std::move(events)));
+
+    // Check circuit.
+    info("Checking circuit...");
+    AvmProvingHelper proving_helper;
+    return proving_helper.check_circuit(std::move(trace));
+}
+
+bool AvmAPI::verify(const AvmProof& proof, const PublicInputs& pi, const AvmVerificationKey& vk_data)
+{
+    info("Verifying...");
+    AvmProvingHelper proving_helper;
+    return AVM_TRACK_TIME_V("verifing/all", proving_helper.verify(proof, pi, vk_data));
+}
+
+} // namespace bb::avm2
\ No newline at end of file
diff --git a/barretenberg/cpp/src/barretenberg/vm2/avm_api.hpp b/barretenberg/cpp/src/barretenberg/vm2/avm_api.hpp
new file mode 100644
index 00000000000..9e94e922c5a
--- /dev/null
+++ b/barretenberg/cpp/src/barretenberg/vm2/avm_api.hpp
@@ -0,0 +1,24 @@
+#pragma once
+
+#include <tuple>
+
+#include "barretenberg/vm2/common/avm_inputs.hpp"
+#include "barretenberg/vm2/proving_helper.hpp"
+
+namespace bb::avm2 {
+
+class AvmAPI {
+  public:
+    using AvmProof = AvmProvingHelper::Proof;
+    using AvmVerificationKey = std::vector<uint8_t>;
+    using ProvingInputs = AvmProvingInputs;
+
+    AvmAPI() = default;
+
+    // NOTE: The public inputs are NOT part of the proof.
+    std::pair<AvmProof, AvmVerificationKey> prove(const ProvingInputs& inputs);
+    bool check_circuit(const ProvingInputs& inputs);
+    bool verify(const AvmProof& proof, const PublicInputs& pi, const AvmVerificationKey& vk_data);
+};
+
+} // namespace bb::avm2
\ No newline at end of file
diff --git a/barretenberg/cpp/src/barretenberg/vm2/common/ankerl_map.hpp b/barretenberg/cpp/src/barretenberg/vm2/common/ankerl_map.hpp
new file mode 100644
index 00000000000..6342ce0171a
--- /dev/null
+++ b/barretenberg/cpp/src/barretenberg/vm2/common/ankerl_map.hpp
@@ -0,0 +1,2126 @@
+///////////////////////// ankerl::unordered_dense::{map, set} /////////////////////////
+
+// A fast & densely stored hashmap and hashset based on robin-hood backward shift deletion.
+// Version 4.5.0
+// https://github.com/martinus/unordered_dense
+//
+// Licensed under the MIT License <http://opensource.org/licenses/MIT>.
+// SPDX-License-Identifier: MIT
+// Copyright (c) 2022-2024 Martin Leitner-Ankerl <martin.ankerl@gmail.com>
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+
+#ifndef ANKERL_UNORDERED_DENSE_H
+#define ANKERL_UNORDERED_DENSE_H
+
+// see https://semver.org/spec/v2.0.0.html
+#define ANKERL_UNORDERED_DENSE_VERSION_MAJOR 4 // NOLINT(cppcoreguidelines-macro-usage) incompatible API changes
+#define ANKERL_UNORDERED_DENSE_VERSION_MINOR                                                                           \
+    5 // NOLINT(cppcoreguidelines-macro-usage) backwards compatible functionality
+#define ANKERL_UNORDERED_DENSE_VERSION_PATCH 0 // NOLINT(cppcoreguidelines-macro-usage) backwards compatible bug fixes
+
+// API versioning with inline namespace, see https://www.foonathan.net/2018/11/inline-namespaces/
+
+// NOLINTNEXTLINE(cppcoreguidelines-macro-usage)
+#define ANKERL_UNORDERED_DENSE_VERSION_CONCAT1(major, minor, patch) v##major##_##minor##_##patch
+// NOLINTNEXTLINE(cppcoreguidelines-macro-usage)
+#define ANKERL_UNORDERED_DENSE_VERSION_CONCAT(major, minor, patch)                                                     \
+    ANKERL_UNORDERED_DENSE_VERSION_CONCAT1(major, minor, patch)
+#define ANKERL_UNORDERED_DENSE_NAMESPACE                                                                               \
+    ANKERL_UNORDERED_DENSE_VERSION_CONCAT(ANKERL_UNORDERED_DENSE_VERSION_MAJOR,                                        \
+                                          ANKERL_UNORDERED_DENSE_VERSION_MINOR,                                        \
+                                          ANKERL_UNORDERED_DENSE_VERSION_PATCH)
+
+#if defined(_MSVC_LANG)
+#define ANKERL_UNORDERED_DENSE_CPP_VERSION _MSVC_LANG
+#else
+#define ANKERL_UNORDERED_DENSE_CPP_VERSION __cplusplus
+#endif
+
+#if defined(__GNUC__)
+// NOLINTNEXTLINE(cppcoreguidelines-macro-usage)
+#define ANKERL_UNORDERED_DENSE_PACK(decl) decl __attribute__((__packed__))
+#elif defined(_MSC_VER)
+// NOLINTNEXTLINE(cppcoreguidelines-macro-usage)
+#define ANKERL_UNORDERED_DENSE_PACK(decl) __pragma(pack(push, 1)) decl __pragma(pack(pop))
+#endif
+
+// exceptions
+#if defined(__cpp_exceptions) || defined(__EXCEPTIONS) || defined(_CPPUNWIND)
+#define ANKERL_UNORDERED_DENSE_HAS_EXCEPTIONS() 1 // NOLINT(cppcoreguidelines-macro-usage)
+#else
+#define ANKERL_UNORDERED_DENSE_HAS_EXCEPTIONS() 0 // NOLINT(cppcoreguidelines-macro-usage)
+#endif
+#ifdef _MSC_VER
+#define ANKERL_UNORDERED_DENSE_NOINLINE __declspec(noinline)
+#else
+#define ANKERL_UNORDERED_DENSE_NOINLINE __attribute__((noinline))
+#endif
+
+// defined in unordered_dense.cpp
+#if !defined(ANKERL_UNORDERED_DENSE_EXPORT)
+#define ANKERL_UNORDERED_DENSE_EXPORT
+#endif
+
+#if ANKERL_UNORDERED_DENSE_CPP_VERSION < 201703L
+#error ankerl::unordered_dense requires C++17 or higher
+#else
+#include <array>            // for array
+#include <cstdint>          // for uint64_t, uint32_t, uint8_t, UINT64_C
+#include <cstring>          // for size_t, memcpy, memset
+#include <functional>       // for equal_to, hash
+#include <initializer_list> // for initializer_list
+#include <iterator>         // for pair, distance
+#include <limits>           // for numeric_limits
+#include <memory>           // for allocator, allocator_traits, shared_ptr
+#include <optional>         // for optional
+#include <stdexcept>        // for out_of_range
+#include <string>           // for basic_string
+#include <string_view>      // for basic_string_view, hash
+#include <tuple>            // for forward_as_tuple
+#include <type_traits>      // for enable_if_t, declval, conditional_t, ena...
+#include <utility>          // for forward, exchange, pair, as_const, piece...
+#include <vector>           // for vector
+#if ANKERL_UNORDERED_DENSE_HAS_EXCEPTIONS() == 0
+#include <cstdlib> // for abort
+#endif
+
+#if defined(__has_include) && !defined(ANKERL_UNORDERED_DENSE_DISABLE_PMR)
+#if __has_include(<memory_resource>)
+#define ANKERL_UNORDERED_DENSE_PMR std::pmr // NOLINT(cppcoreguidelines-macro-usage)
+#include <memory_resource>                  // for polymorphic_allocator
+#elif __has_include(<experimental/memory_resource>)
+#define ANKERL_UNORDERED_DENSE_PMR std::experimental::pmr // NOLINT(cppcoreguidelines-macro-usage)
+#include <experimental/memory_resource>                   // for polymorphic_allocator
+#endif
+#endif
+
+#if defined(_MSC_VER) && defined(_M_X64)
+#include <intrin.h>
+#pragma intrinsic(_umul128)
+#endif
+
+#if defined(__GNUC__) || defined(__INTEL_COMPILER) || defined(__clang__)
+#define ANKERL_UNORDERED_DENSE_LIKELY(x) __builtin_expect(x, 1)   // NOLINT(cppcoreguidelines-macro-usage)
+#define ANKERL_UNORDERED_DENSE_UNLIKELY(x) __builtin_expect(x, 0) // NOLINT(cppcoreguidelines-macro-usage)
+#else
+#define ANKERL_UNORDERED_DENSE_LIKELY(x) (x)   // NOLINT(cppcoreguidelines-macro-usage)
+#define ANKERL_UNORDERED_DENSE_UNLIKELY(x) (x) // NOLINT(cppcoreguidelines-macro-usage)
+#endif
+
+namespace ankerl::unordered_dense {
+inline namespace ANKERL_UNORDERED_DENSE_NAMESPACE {
+
+namespace detail {
+
+#if ANKERL_UNORDERED_DENSE_HAS_EXCEPTIONS()
+
+// make sure this is not inlined as it is slow and dramatically enlarges code, thus making other
+// inlinings more difficult. Throws are also generally the slow path.
+[[noreturn]] inline ANKERL_UNORDERED_DENSE_NOINLINE void on_error_key_not_found()
+{
+    throw std::out_of_range("ankerl::unordered_dense::map::at(): key not found");
+}
+[[noreturn]] inline ANKERL_UNORDERED_DENSE_NOINLINE void on_error_bucket_overflow()
+{
+    throw std::overflow_error("ankerl::unordered_dense: reached max bucket size, cannot increase size");
+}
+[[noreturn]] inline ANKERL_UNORDERED_DENSE_NOINLINE void on_error_too_many_elements()
+{
+    throw std::out_of_range("ankerl::unordered_dense::map::replace(): too many elements");
+}
+
+#else
+
+[[noreturn]] inline void on_error_key_not_found()
+{
+    abort();
+}
+[[noreturn]] inline void on_error_bucket_overflow()
+{
+    abort();
+}
+[[noreturn]] inline void on_error_too_many_elements()
+{
+    abort();
+}
+
+#endif
+
+} // namespace detail
+
+// hash ///////////////////////////////////////////////////////////////////////
+
+// This is a stripped-down implementation of wyhash: https://github.com/wangyi-fudan/wyhash
+// No big-endian support (because different values on different machines don't matter),
+// hardcodes seed and the secret, reformats the code, and clang-tidy fixes.
+namespace detail::wyhash {
+
+inline void mum(uint64_t* a, uint64_t* b)
+{
+#if defined(__SIZEOF_INT128__)
+    __uint128_t r = *a;
+    r *= *b;
+    *a = static_cast<uint64_t>(r);
+    *b = static_cast<uint64_t>(r >> 64U);
+#elif defined(_MSC_VER) && defined(_M_X64)
+    *a = _umul128(*a, *b, b);
+#else
+    uint64_t ha = *a >> 32U;
+    uint64_t hb = *b >> 32U;
+    uint64_t la = static_cast<uint32_t>(*a);
+    uint64_t lb = static_cast<uint32_t>(*b);
+    uint64_t hi{};
+    uint64_t lo{};
+    uint64_t rh = ha * hb;
+    uint64_t rm0 = ha * lb;
+    uint64_t rm1 = hb * la;
+    uint64_t rl = la * lb;
+    uint64_t t = rl + (rm0 << 32U);
+    auto c = static_cast<uint64_t>(t < rl);
+    lo = t + (rm1 << 32U);
+    c += static_cast<uint64_t>(lo < t);
+    hi = rh + (rm0 >> 32U) + (rm1 >> 32U) + c;
+    *a = lo;
+    *b = hi;
+#endif
+}
+
+// multiply and xor mix function, aka MUM
+[[nodiscard]] inline auto mix(uint64_t a, uint64_t b) -> uint64_t
+{
+    mum(&a, &b);
+    return a ^ b;
+}
+
+// read functions. WARNING: we don't care about endianness, so results are different on big endian!
+[[nodiscard]] inline auto r8(const uint8_t* p) -> uint64_t
+{
+    uint64_t v{};
+    std::memcpy(&v, p, 8U);
+    return v;
+}
+
+[[nodiscard]] inline auto r4(const uint8_t* p) -> uint64_t
+{
+    uint32_t v{};
+    std::memcpy(&v, p, 4);
+    return v;
+}
+
+// reads 1, 2, or 3 bytes
+[[nodiscard]] inline auto r3(const uint8_t* p, size_t k) -> uint64_t
+{
+    return (static_cast<uint64_t>(p[0]) << 16U) | (static_cast<uint64_t>(p[k >> 1U]) << 8U) | p[k - 1];
+}
+
+[[maybe_unused]] [[nodiscard]] inline auto hash(void const* key, size_t len) -> uint64_t
+{
+    static constexpr auto secret = std::array{ UINT64_C(0xa0761d6478bd642f),
+                                               UINT64_C(0xe7037ed1a0b428db),
+                                               UINT64_C(0x8ebc6af09c88c6e3),
+                                               UINT64_C(0x589965cc75374cc3) };
+
+    auto const* p = static_cast<uint8_t const*>(key);
+    uint64_t seed = secret[0];
+    uint64_t a{};
+    uint64_t b{};
+    if (ANKERL_UNORDERED_DENSE_LIKELY(len <= 16)) {
+        if (ANKERL_UNORDERED_DENSE_LIKELY(len >= 4)) {
+            a = (r4(p) << 32U) | r4(p + ((len >> 3U) << 2U));
+            b = (r4(p + len - 4) << 32U) | r4(p + len - 4 - ((len >> 3U) << 2U));
+        } else if (ANKERL_UNORDERED_DENSE_LIKELY(len > 0)) {
+            a = r3(p, len);
+            b = 0;
+        } else {
+            a = 0;
+            b = 0;
+        }
+    } else {
+        size_t i = len;
+        if (ANKERL_UNORDERED_DENSE_UNLIKELY(i > 48)) {
+            uint64_t see1 = seed;
+            uint64_t see2 = seed;
+            do {
+                seed = mix(r8(p) ^ secret[1], r8(p + 8) ^ seed);
+                see1 = mix(r8(p + 16) ^ secret[2], r8(p + 24) ^ see1);
+                see2 = mix(r8(p + 32) ^ secret[3], r8(p + 40) ^ see2);
+                p += 48;
+                i -= 48;
+            } while (ANKERL_UNORDERED_DENSE_LIKELY(i > 48));
+            seed ^= see1 ^ see2;
+        }
+        while (ANKERL_UNORDERED_DENSE_UNLIKELY(i > 16)) {
+            seed = mix(r8(p) ^ secret[1], r8(p + 8) ^ seed);
+            i -= 16;
+            p += 16;
+        }
+        a = r8(p + i - 16);
+        b = r8(p + i - 8);
+    }
+
+    return mix(secret[1] ^ len, mix(a ^ secret[1], b ^ seed));
+}
+
+[[nodiscard]] inline auto hash(uint64_t x) -> uint64_t
+{
+    return detail::wyhash::mix(x, UINT64_C(0x9E3779B97F4A7C15));
+}
+
+} // namespace detail::wyhash
+
+ANKERL_UNORDERED_DENSE_EXPORT template <typename T, typename Enable = void> struct hash {
+    auto operator()(T const& obj) const
+        noexcept(noexcept(std::declval<std::hash<T>>().operator()(std::declval<T const&>()))) -> uint64_t
+    {
+        return std::hash<T>{}(obj);
+    }
+};
+
+template <typename T> struct hash<T, typename std::hash<T>::is_avalanching> {
+    using is_avalanching = void;
+    auto operator()(T const& obj) const
+        noexcept(noexcept(std::declval<std::hash<T>>().operator()(std::declval<T const&>()))) -> uint64_t
+    {
+        return std::hash<T>{}(obj);
+    }
+};
+
+template <typename CharT> struct hash<std::basic_string<CharT>> {
+    using is_avalanching = void;
+    auto operator()(std::basic_string<CharT> const& str) const noexcept -> uint64_t
+    {
+        return detail::wyhash::hash(str.data(), sizeof(CharT) * str.size());
+    }
+};
+
+template <typename CharT> struct hash<std::basic_string_view<CharT>> {
+    using is_avalanching = void;
+    auto operator()(std::basic_string_view<CharT> const& sv) const noexcept -> uint64_t
+    {
+        return detail::wyhash::hash(sv.data(), sizeof(CharT) * sv.size());
+    }
+};
+
+template <class T> struct hash<T*> {
+    using is_avalanching = void;
+    auto operator()(T* ptr) const noexcept -> uint64_t
+    {
+        // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
+        return detail::wyhash::hash(reinterpret_cast<uintptr_t>(ptr));
+    }
+};
+
+template <class T> struct hash<std::unique_ptr<T>> {
+    using is_avalanching = void;
+    auto operator()(std::unique_ptr<T> const& ptr) const noexcept -> uint64_t
+    {
+        // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
+        return detail::wyhash::hash(reinterpret_cast<uintptr_t>(ptr.get()));
+    }
+};
+
+template <class T> struct hash<std::shared_ptr<T>> {
+    using is_avalanching = void;
+    auto operator()(std::shared_ptr<T> const& ptr) const noexcept -> uint64_t
+    {
+        // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
+        return detail::wyhash::hash(reinterpret_cast<uintptr_t>(ptr.get()));
+    }
+};
+
+template <typename Enum> struct hash<Enum, typename std::enable_if<std::is_enum<Enum>::value>::type> {
+    using is_avalanching = void;
+    auto operator()(Enum e) const noexcept -> uint64_t
+    {
+        using underlying = typename std::underlying_type_t<Enum>;
+        return detail::wyhash::hash(static_cast<underlying>(e));
+    }
+};
+
+template <typename... Args> struct tuple_hash_helper {
+    // Converts the value into 64bit. If it is an integral type, just cast it. Mixing is doing the rest.
+    // If it isn't an integral we need to hash it.
+    template <typename Arg> [[nodiscard]] constexpr static auto to64(Arg const& arg) -> uint64_t
+    {
+        if constexpr (std::is_integral_v<Arg> || std::is_enum_v<Arg>) {
+            return static_cast<uint64_t>(arg);
+        } else {
+            return hash<Arg>{}(arg);
+        }
+    }
+
+    [[nodiscard]] static auto mix64(uint64_t state, uint64_t v) -> uint64_t
+    {
+        return detail::wyhash::mix(state + v, uint64_t{ 0x9ddfea08eb382d69 });
+    }
+
+    // Creates a buffer that holds all the data from each element of the tuple. If possible we memcpy the data directly.
+    // If not, we hash the object and use this for the array. Size of the array is known at compile time, and memcpy is
+    // optimized away, so filling the buffer is highly efficient. Finally, call wyhash with this buffer.
+    template <typename T, std::size_t... Idx>
+    [[nodiscard]] static auto calc_hash(T const& t, std::index_sequence<Idx...>) noexcept -> uint64_t
+    {
+        auto h = uint64_t{};
+        ((h = mix64(h, to64(std::get<Idx>(t)))), ...);
+        return h;
+    }
+};
+
+template <typename... Args> struct hash<std::tuple<Args...>> : tuple_hash_helper<Args...> {
+    using is_avalanching = void;
+    auto operator()(std::tuple<Args...> const& t) const noexcept -> uint64_t
+    {
+        return tuple_hash_helper<Args...>::calc_hash(t, std::index_sequence_for<Args...>{});
+    }
+};
+
+template <typename A, typename B> struct hash<std::pair<A, B>> : tuple_hash_helper<A, B> {
+    using is_avalanching = void;
+    auto operator()(std::pair<A, B> const& t) const noexcept -> uint64_t
+    {
+        return tuple_hash_helper<A, B>::calc_hash(t, std::index_sequence_for<A, B>{});
+    }
+};
+
+// NOLINTNEXTLINE(cppcoreguidelines-macro-usage)
+#define ANKERL_UNORDERED_DENSE_HASH_STATICCAST(T)                                                                      \
+    template <> struct hash<T> {                                                                                       \
+        using is_avalanching = void;                                                                                   \
+        auto operator()(T const& obj) const noexcept -> uint64_t                                                       \
+        {                                                                                                              \
+            return detail::wyhash::hash(static_cast<uint64_t>(obj));                                                   \
+        }                                                                                                              \
+    }
+
+#if defined(__GNUC__) && !defined(__clang__)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wuseless-cast"
+#endif
+// see https://en.cppreference.com/w/cpp/utility/hash
+ANKERL_UNORDERED_DENSE_HASH_STATICCAST(bool);
+ANKERL_UNORDERED_DENSE_HASH_STATICCAST(char);
+ANKERL_UNORDERED_DENSE_HASH_STATICCAST(signed char);
+ANKERL_UNORDERED_DENSE_HASH_STATICCAST(unsigned char);
+#if ANKERL_UNORDERED_DENSE_CPP_VERSION >= 202002L && defined(__cpp_char8_t)
+ANKERL_UNORDERED_DENSE_HASH_STATICCAST(char8_t);
+#endif
+ANKERL_UNORDERED_DENSE_HASH_STATICCAST(char16_t);
+ANKERL_UNORDERED_DENSE_HASH_STATICCAST(char32_t);
+ANKERL_UNORDERED_DENSE_HASH_STATICCAST(wchar_t);
+ANKERL_UNORDERED_DENSE_HASH_STATICCAST(short);
+ANKERL_UNORDERED_DENSE_HASH_STATICCAST(unsigned short);
+ANKERL_UNORDERED_DENSE_HASH_STATICCAST(int);
+ANKERL_UNORDERED_DENSE_HASH_STATICCAST(unsigned int);
+ANKERL_UNORDERED_DENSE_HASH_STATICCAST(long);
+ANKERL_UNORDERED_DENSE_HASH_STATICCAST(long long);
+ANKERL_UNORDERED_DENSE_HASH_STATICCAST(unsigned long);
+ANKERL_UNORDERED_DENSE_HASH_STATICCAST(unsigned long long);
+
+#if defined(__GNUC__) && !defined(__clang__)
+#pragma GCC diagnostic pop
+#endif
+
+// bucket_type //////////////////////////////////////////////////////////
+
+namespace bucket_type {
+
+struct standard {
+    static constexpr uint32_t dist_inc = 1U << 8U;             // skip 1 byte fingerprint
+    static constexpr uint32_t fingerprint_mask = dist_inc - 1; // mask for 1 byte of fingerprint
+
+    uint32_t m_dist_and_fingerprint; // upper 3 byte: distance to original bucket. lower byte: fingerprint from hash
+    uint32_t m_value_idx;            // index into the m_values vector.
+};
+
+ANKERL_UNORDERED_DENSE_PACK(struct big {
+    static constexpr uint32_t dist_inc = 1U << 8U;             // skip 1 byte fingerprint
+    static constexpr uint32_t fingerprint_mask = dist_inc - 1; // mask for 1 byte of fingerprint
+
+    uint32_t m_dist_and_fingerprint; // upper 3 byte: distance to original bucket. lower byte: fingerprint from hash
+    size_t m_value_idx;              // index into the m_values vector.
+});
+
+} // namespace bucket_type
+
+namespace detail {
+
+struct nonesuch {};
+struct default_container_t {};
+
+template <class Default, class AlwaysVoid, template <class...> class Op, class... Args> struct detector {
+    using value_t = std::false_type;
+    using type = Default;
+};
+
+template <class Default, template <class...> class Op, class... Args>
+struct detector<Default, std::void_t<Op<Args...>>, Op, Args...> {
+    using value_t = std::true_type;
+    using type = Op<Args...>;
+};
+
+template <template <class...> class Op, class... Args>
+using is_detected = typename detail::detector<detail::nonesuch, void, Op, Args...>::value_t;
+
+template <template <class...> class Op, class... Args> constexpr bool is_detected_v = is_detected<Op, Args...>::value;
+
+template <typename T> using detect_avalanching = typename T::is_avalanching;
+
+template <typename T> using detect_is_transparent = typename T::is_transparent;
+
+template <typename T> using detect_iterator = typename T::iterator;
+
+template <typename T> using detect_reserve = decltype(std::declval<T&>().reserve(size_t{}));
+
+// enable_if helpers
+
+template <typename Mapped> constexpr bool is_map_v = !std::is_void_v<Mapped>;
+
+// clang-format off
+template <typename Hash, typename KeyEqual>
+constexpr bool is_transparent_v = is_detected_v<detect_is_transparent, Hash> && is_detected_v<detect_is_transparent, KeyEqual>;
+// clang-format on
+
+template <typename From, typename To1, typename To2>
+constexpr bool is_neither_convertible_v = !std::is_convertible_v<From, To1> && !std::is_convertible_v<From, To2>;
+
+template <typename T> constexpr bool has_reserve = is_detected_v<detect_reserve, T>;
+
+// base type for map has mapped_type
+template <class T> struct base_table_type_map {
+    using mapped_type = T;
+};
+
+// base type for set doesn't have mapped_type
+struct base_table_type_set {};
+
+} // namespace detail
+
+// Very much like std::deque, but faster for indexing (in most cases). As of now this doesn't implement the full
+// std::vector API, but merely what's necessary to work as an underlying container for ankerl::unordered_dense::{map,
+// set}. It allocates blocks of equal size and puts them into the m_blocks vector. That means it can grow simply by
+// adding a new block to the back of m_blocks, and doesn't double its size like an std::vector. The disadvantage is that
+// memory is not linear and thus there is one more indirection necessary for indexing.
+template <typename T, typename Allocator = std::allocator<T>, size_t MaxSegmentSizeBytes = 4096>
+class segmented_vector {
+    template <bool IsConst> class iter_t;
+
+  public:
+    using allocator_type = Allocator;
+    using pointer = typename std::allocator_traits<allocator_type>::pointer;
+    using const_pointer = typename std::allocator_traits<allocator_type>::const_pointer;
+    using difference_type = typename std::allocator_traits<allocator_type>::difference_type;
+    using value_type = T;
+    using size_type = std::size_t;
+    using reference = T&;
+    using const_reference = T const&;
+    using iterator = iter_t<false>;
+    using const_iterator = iter_t<true>;
+
+  private:
+    using vec_alloc = typename std::allocator_traits<Allocator>::template rebind_alloc<pointer>;
+    std::vector<pointer, vec_alloc> m_blocks{};
+    size_t m_size{};
+
+    // Calculates the maximum number for x in  (s << x) <= max_val
+    static constexpr auto num_bits_closest(size_t max_val, size_t s) -> size_t
+    {
+        auto f = size_t{ 0 };
+        while (s << (f + 1) <= max_val) {
+            ++f;
+        }
+        return f;
+    }
+
+    using self_t = segmented_vector<T, Allocator, MaxSegmentSizeBytes>;
+    static constexpr auto num_bits = num_bits_closest(MaxSegmentSizeBytes, sizeof(T));
+    static constexpr auto num_elements_in_block = 1U << num_bits;
+    static constexpr auto mask = num_elements_in_block - 1U;
+
+    /**
+     * Iterator class doubles as const_iterator and iterator
+     */
+    template <bool IsConst> class iter_t {
+        using ptr_t =
+            typename std::conditional_t<IsConst, segmented_vector::const_pointer const*, segmented_vector::pointer*>;
+        ptr_t m_data{};
+        size_t m_idx{};
+
+        template <bool B> friend class iter_t;
+
+      public:
+        using difference_type = segmented_vector::difference_type;
+        using value_type = T;
+        using reference = typename std::conditional_t<IsConst, value_type const&, value_type&>;
+        using pointer =
+            typename std::conditional_t<IsConst, segmented_vector::const_pointer, segmented_vector::pointer>;
+        using iterator_category = std::forward_iterator_tag;
+
+        iter_t() noexcept = default;
+
+        template <bool OtherIsConst, typename = typename std::enable_if<IsConst && !OtherIsConst>::type>
+        // NOLINTNEXTLINE(google-explicit-constructor,hicpp-explicit-conversions)
+        constexpr iter_t(iter_t<OtherIsConst> const& other) noexcept
+            : m_data(other.m_data)
+            , m_idx(other.m_idx)
+        {}
+
+        constexpr iter_t(ptr_t data, size_t idx) noexcept
+            : m_data(data)
+            , m_idx(idx)
+        {}
+
+        template <bool OtherIsConst, typename = typename std::enable_if<IsConst && !OtherIsConst>::type>
+        constexpr auto operator=(iter_t<OtherIsConst> const& other) noexcept -> iter_t&
+        {
+            m_data = other.m_data;
+            m_idx = other.m_idx;
+            return *this;
+        }
+
+        constexpr auto operator++() noexcept -> iter_t&
+        {
+            ++m_idx;
+            return *this;
+        }
+
+        constexpr auto operator++(int) noexcept -> iter_t
+        {
+            iter_t prev(*this);
+            this->operator++();
+            return prev;
+        }
+
+        constexpr auto operator+(difference_type diff) noexcept -> iter_t
+        {
+            return { m_data, static_cast<size_t>(static_cast<difference_type>(m_idx) + diff) };
+        }
+
+        template <bool OtherIsConst>
+        constexpr auto operator-(iter_t<OtherIsConst> const& other) noexcept -> difference_type
+        {
+            return static_cast<difference_type>(m_idx) - static_cast<difference_type>(other.m_idx);
+        }
+
+        constexpr auto operator*() const noexcept -> reference { return m_data[m_idx >> num_bits][m_idx & mask]; }
+
+        constexpr auto operator->() const noexcept -> pointer { return &m_data[m_idx >> num_bits][m_idx & mask]; }
+
+        template <bool O> constexpr auto operator==(iter_t<O> const& o) const noexcept -> bool
+        {
+            return m_idx == o.m_idx;
+        }
+
+        template <bool O> constexpr auto operator!=(iter_t<O> const& o) const noexcept -> bool { return !(*this == o); }
+    };
+
+    // slow path: need to allocate a new segment every once in a while
+    void increase_capacity()
+    {
+        auto ba = Allocator(m_blocks.get_allocator());
+        pointer block = std::allocator_traits<Allocator>::allocate(ba, num_elements_in_block);
+        m_blocks.push_back(block);
+    }
+
+    // Moves everything from other
+    void append_everything_from(segmented_vector&& other)
+    {
+        reserve(size() + other.size());
+        for (auto&& o : other) {
+            emplace_back(std::move(o));
+        }
+    }
+
+    // Copies everything from other
+    void append_everything_from(segmented_vector const& other)
+    {
+        reserve(size() + other.size());
+        for (auto const& o : other) {
+            emplace_back(o);
+        }
+    }
+
+    void dealloc()
+    {
+        auto ba = Allocator(m_blocks.get_allocator());
+        for (auto ptr : m_blocks) {
+            std::allocator_traits<Allocator>::deallocate(ba, ptr, num_elements_in_block);
+        }
+    }
+
+    [[nodiscard]] static constexpr auto calc_num_blocks_for_capacity(size_t capacity)
+    {
+        return (capacity + num_elements_in_block - 1U) / num_elements_in_block;
+    }
+
+  public:
+    segmented_vector() = default;
+
+    // NOLINTNEXTLINE(google-explicit-constructor,hicpp-explicit-conversions)
+    segmented_vector(Allocator alloc)
+        : m_blocks(vec_alloc(alloc))
+    {}
+
+    segmented_vector(segmented_vector&& other, Allocator alloc)
+        : segmented_vector(alloc)
+    {
+        *this = std::move(other);
+    }
+
+    segmented_vector(segmented_vector const& other, Allocator alloc)
+        : m_blocks(vec_alloc(alloc))
+    {
+        append_everything_from(other);
+    }
+
+    segmented_vector(segmented_vector&& other) noexcept
+        : segmented_vector(std::move(other), get_allocator())
+    {}
+
+    segmented_vector(segmented_vector const& other) { append_everything_from(other); }
+
+    auto operator=(segmented_vector const& other) -> segmented_vector&
+    {
+        if (this == &other) {
+            return *this;
+        }
+        clear();
+        append_everything_from(other);
+        return *this;
+    }
+
+    auto operator=(segmented_vector&& other) noexcept -> segmented_vector&
+    {
+        clear();
+        dealloc();
+        if (other.get_allocator() == get_allocator()) {
+            m_blocks = std::move(other.m_blocks);
+            m_size = std::exchange(other.m_size, {});
+        } else {
+            // make sure to construct with other's allocator!
+            m_blocks = std::vector<pointer, vec_alloc>(vec_alloc(other.get_allocator()));
+            append_everything_from(std::move(other));
+        }
+        return *this;
+    }
+
+    ~segmented_vector()
+    {
+        clear();
+        dealloc();
+    }
+
+    [[nodiscard]] constexpr auto size() const -> size_t { return m_size; }
+
+    [[nodiscard]] constexpr auto capacity() const -> size_t { return m_blocks.size() * num_elements_in_block; }
+
+    // Indexing is highly performance critical
+    [[nodiscard]] constexpr auto operator[](size_t i) const noexcept -> T const&
+    {
+        return m_blocks[i >> num_bits][i & mask];
+    }
+
+    [[nodiscard]] constexpr auto operator[](size_t i) noexcept -> T& { return m_blocks[i >> num_bits][i & mask]; }
+
+    [[nodiscard]] constexpr auto begin() -> iterator { return { m_blocks.data(), 0U }; }
+    [[nodiscard]] constexpr auto begin() const -> const_iterator { return { m_blocks.data(), 0U }; }
+    [[nodiscard]] constexpr auto cbegin() const -> const_iterator { return { m_blocks.data(), 0U }; }
+
+    [[nodiscard]] constexpr auto end() -> iterator { return { m_blocks.data(), m_size }; }
+    [[nodiscard]] constexpr auto end() const -> const_iterator { return { m_blocks.data(), m_size }; }
+    [[nodiscard]] constexpr auto cend() const -> const_iterator { return { m_blocks.data(), m_size }; }
+
+    [[nodiscard]] constexpr auto back() -> reference { return operator[](m_size - 1); }
+    [[nodiscard]] constexpr auto back() const -> const_reference { return operator[](m_size - 1); }
+
+    void pop_back()
+    {
+        back().~T();
+        --m_size;
+    }
+
+    [[nodiscard]] auto empty() const { return 0 == m_size; }
+
+    void reserve(size_t new_capacity)
+    {
+        m_blocks.reserve(calc_num_blocks_for_capacity(new_capacity));
+        while (new_capacity > capacity()) {
+            increase_capacity();
+        }
+    }
+
+    [[nodiscard]] auto get_allocator() const -> allocator_type { return allocator_type{ m_blocks.get_allocator() }; }
+
+    template <class... Args> auto emplace_back(Args&&... args) -> reference
+    {
+        if (m_size == capacity()) {
+            increase_capacity();
+        }
+        auto* ptr = static_cast<void*>(&operator[](m_size));
+        auto& ref = *new (ptr) T(std::forward<Args>(args)...);
+        ++m_size;
+        return ref;
+    }
+
+    void clear()
+    {
+        if constexpr (!std::is_trivially_destructible_v<T>) {
+            for (size_t i = 0, s = size(); i < s; ++i) {
+                operator[](i).~T();
+            }
+        }
+        m_size = 0;
+    }
+
+    void shrink_to_fit()
+    {
+        auto ba = Allocator(m_blocks.get_allocator());
+        auto num_blocks_required = calc_num_blocks_for_capacity(m_size);
+        while (m_blocks.size() > num_blocks_required) {
+            std::allocator_traits<Allocator>::deallocate(ba, m_blocks.back(), num_elements_in_block);
+            m_blocks.pop_back();
+        }
+        m_blocks.shrink_to_fit();
+    }
+};
+
+namespace detail {
+
+// This is it, the table. Doubles as map and set, and uses `void` for T when its used as a set.
+template <class Key,
+          class T, // when void, treat it as a set.
+          class Hash,
+          class KeyEqual,
+          class AllocatorOrContainer,
+          class Bucket,
+          class BucketContainer,
+          bool IsSegmented>
+class table : public std::conditional_t<is_map_v<T>, base_table_type_map<T>, base_table_type_set> {
+    using underlying_value_type = typename std::conditional_t<is_map_v<T>, std::pair<Key, T>, Key>;
+    using underlying_container_type = std::conditional_t<IsSegmented,
+                                                         segmented_vector<underlying_value_type, AllocatorOrContainer>,
+                                                         std::vector<underlying_value_type, AllocatorOrContainer>>;
+
+  public:
+    using value_container_type = std::conditional_t<is_detected_v<detect_iterator, AllocatorOrContainer>,
+                                                    AllocatorOrContainer,
+                                                    underlying_container_type>;
+
+  private:
+    using bucket_alloc =
+        typename std::allocator_traits<typename value_container_type::allocator_type>::template rebind_alloc<Bucket>;
+    using default_bucket_container_type =
+        std::conditional_t<IsSegmented, segmented_vector<Bucket, bucket_alloc>, std::vector<Bucket, bucket_alloc>>;
+
+    using bucket_container_type = std::conditional_t<std::is_same_v<BucketContainer, detail::default_container_t>,
+                                                     default_bucket_container_type,
+                                                     BucketContainer>;
+
+    static constexpr uint8_t initial_shifts = 64 - 2; // 2^(64-m_shift) number of buckets
+    static constexpr float default_max_load_factor = 0.8F;
+
+  public:
+    using key_type = Key;
+    using value_type = typename value_container_type::value_type;
+    using size_type = typename value_container_type::size_type;
+    using difference_type = typename value_container_type::difference_type;
+    using hasher = Hash;
+    using key_equal = KeyEqual;
+    using allocator_type = typename value_container_type::allocator_type;
+    using reference = typename value_container_type::reference;
+    using const_reference = typename value_container_type::const_reference;
+    using pointer = typename value_container_type::pointer;
+    using const_pointer = typename value_container_type::const_pointer;
+    using const_iterator = typename value_container_type::const_iterator;
+    using iterator = std::conditional_t<is_map_v<T>, typename value_container_type::iterator, const_iterator>;
+    using bucket_type = Bucket;
+
+  private:
+    using value_idx_type = decltype(Bucket::m_value_idx);
+    using dist_and_fingerprint_type = decltype(Bucket::m_dist_and_fingerprint);
+
+    static_assert(std::is_trivially_destructible_v<Bucket>, "assert there's no need to call destructor / std::destroy");
+    static_assert(std::is_trivially_copyable_v<Bucket>, "assert we can just memset / memcpy");
+
+    value_container_type m_values{}; // Contains all the key-value pairs in one densely stored container. No holes.
+    bucket_container_type m_buckets{};
+    size_t m_max_bucket_capacity = 0;
+    float m_max_load_factor = default_max_load_factor;
+    Hash m_hash{};
+    KeyEqual m_equal{};
+    uint8_t m_shifts = initial_shifts;
+
+    [[nodiscard]] auto next(value_idx_type bucket_idx) const -> value_idx_type
+    {
+        return ANKERL_UNORDERED_DENSE_UNLIKELY(bucket_idx + 1U == bucket_count())
+                   ? 0
+                   : static_cast<value_idx_type>(bucket_idx + 1U);
+    }
+
+    // Helper to access bucket through pointer types
+    [[nodiscard]] static constexpr auto at(bucket_container_type& bucket, size_t offset) -> Bucket&
+    {
+        return bucket[offset];
+    }
+
+    [[nodiscard]] static constexpr auto at(const bucket_container_type& bucket, size_t offset) -> const Bucket&
+    {
+        return bucket[offset];
+    }
+
+    // use the dist_inc and dist_dec functions so that uint16_t types work without warning
+    [[nodiscard]] static constexpr auto dist_inc(dist_and_fingerprint_type x) -> dist_and_fingerprint_type
+    {
+        return static_cast<dist_and_fingerprint_type>(x + Bucket::dist_inc);
+    }
+
+    [[nodiscard]] static constexpr auto dist_dec(dist_and_fingerprint_type x) -> dist_and_fingerprint_type
+    {
+        return static_cast<dist_and_fingerprint_type>(x - Bucket::dist_inc);
+    }
+
+    // The goal of mixed_hash is to always produce a high quality 64bit hash.
+    template <typename K> [[nodiscard]] constexpr auto mixed_hash(K const& key) const -> uint64_t
+    {
+        if constexpr (is_detected_v<detect_avalanching, Hash>) {
+            // we know that the hash is good because is_avalanching.
+            if constexpr (sizeof(decltype(m_hash(key))) < sizeof(uint64_t)) {
+                // 32bit hash and is_avalanching => multiply with a constant to avalanche bits upwards
+                return m_hash(key) * UINT64_C(0x9ddfea08eb382d69);
+            } else {
+                // 64bit and is_avalanching => only use the hash itself.
+                return m_hash(key);
+            }
+        } else {
+            // not is_avalanching => apply wyhash
+            return wyhash::hash(m_hash(key));
+        }
+    }
+
+    [[nodiscard]] constexpr auto dist_and_fingerprint_from_hash(uint64_t hash) const -> dist_and_fingerprint_type
+    {
+        return Bucket::dist_inc | (static_cast<dist_and_fingerprint_type>(hash) & Bucket::fingerprint_mask);
+    }
+
+    [[nodiscard]] constexpr auto bucket_idx_from_hash(uint64_t hash) const -> value_idx_type
+    {
+        return static_cast<value_idx_type>(hash >> m_shifts);
+    }
+
+    [[nodiscard]] static constexpr auto get_key(value_type const& vt) -> key_type const&
+    {
+        if constexpr (is_map_v<T>) {
+            return vt.first;
+        } else {
+            return vt;
+        }
+    }
+
+    template <typename K> [[nodiscard]] auto next_while_less(K const& key) const -> Bucket
+    {
+        auto hash = mixed_hash(key);
+        auto dist_and_fingerprint = dist_and_fingerprint_from_hash(hash);
+        auto bucket_idx = bucket_idx_from_hash(hash);
+
+        while (dist_and_fingerprint < at(m_buckets, bucket_idx).m_dist_and_fingerprint) {
+            dist_and_fingerprint = dist_inc(dist_and_fingerprint);
+            bucket_idx = next(bucket_idx);
+        }
+        return { dist_and_fingerprint, bucket_idx };
+    }
+
+    void place_and_shift_up(Bucket bucket, value_idx_type place)
+    {
+        while (0 != at(m_buckets, place).m_dist_and_fingerprint) {
+            bucket = std::exchange(at(m_buckets, place), bucket);
+            bucket.m_dist_and_fingerprint = dist_inc(bucket.m_dist_and_fingerprint);
+            place = next(place);
+        }
+        at(m_buckets, place) = bucket;
+    }
+
+    [[nodiscard]] static constexpr auto calc_num_buckets(uint8_t shifts) -> size_t
+    {
+        return (std::min)(max_bucket_count(), size_t{ 1 } << (64U - shifts));
+    }
+
+    [[nodiscard]] constexpr auto calc_shifts_for_size(size_t s) const -> uint8_t
+    {
+        auto shifts = initial_shifts;
+        while (shifts > 0 &&
+               static_cast<size_t>(static_cast<float>(calc_num_buckets(shifts)) * max_load_factor()) < s) {
+            --shifts;
+        }
+        return shifts;
+    }
+
+    // assumes m_values has data, m_buckets=m_buckets_end=nullptr, m_shifts is INITIAL_SHIFTS
+    void copy_buckets(table const& other)
+    {
+        // assumes m_values has already the correct data copied over.
+        if (empty()) {
+            // when empty, at least allocate an initial buckets and clear them.
+            allocate_buckets_from_shift();
+            clear_buckets();
+        } else {
+            m_shifts = other.m_shifts;
+            allocate_buckets_from_shift();
+            if constexpr (IsSegmented || !std::is_same_v<BucketContainer, default_container_t>) {
+                for (auto i = 0UL; i < bucket_count(); ++i) {
+                    at(m_buckets, i) = at(other.m_buckets, i);
+                }
+            } else {
+                std::memcpy(m_buckets.data(), other.m_buckets.data(), sizeof(Bucket) * bucket_count());
+            }
+        }
+    }
+
+    /**
+     * True when no element can be added any more without increasing the size
+     */
+    [[nodiscard]] auto is_full() const -> bool { return size() > m_max_bucket_capacity; }
+
+    void deallocate_buckets()
+    {
+        m_buckets.clear();
+        m_buckets.shrink_to_fit();
+        m_max_bucket_capacity = 0;
+    }
+
+    void allocate_buckets_from_shift()
+    {
+        auto num_buckets = calc_num_buckets(m_shifts);
+        if constexpr (IsSegmented || !std::is_same_v<BucketContainer, default_container_t>) {
+            if constexpr (has_reserve<bucket_container_type>) {
+                m_buckets.reserve(num_buckets);
+            }
+            for (size_t i = m_buckets.size(); i < num_buckets; ++i) {
+                m_buckets.emplace_back();
+            }
+        } else {
+            m_buckets.resize(num_buckets);
+        }
+        if (num_buckets == max_bucket_count()) {
+            // reached the maximum, make sure we can use each bucket
+            m_max_bucket_capacity = max_bucket_count();
+        } else {
+            m_max_bucket_capacity = static_cast<value_idx_type>(static_cast<float>(num_buckets) * max_load_factor());
+        }
+    }
+
+    void clear_buckets()
+    {
+        if constexpr (IsSegmented || !std::is_same_v<BucketContainer, default_container_t>) {
+            for (auto&& e : m_buckets) {
+                std::memset(&e, 0, sizeof(e));
+            }
+        } else {
+            std::memset(m_buckets.data(), 0, sizeof(Bucket) * bucket_count());
+        }
+    }
+
+    void clear_and_fill_buckets_from_values()
+    {
+        clear_buckets();
+        for (value_idx_type value_idx = 0, end_idx = static_cast<value_idx_type>(m_values.size()); value_idx < end_idx;
+             ++value_idx) {
+            auto const& key = get_key(m_values[value_idx]);
+            auto [dist_and_fingerprint, bucket] = next_while_less(key);
+
+            // we know for certain that key has not yet been inserted, so no need to check it.
+            place_and_shift_up({ dist_and_fingerprint, value_idx }, bucket);
+        }
+    }
+
+    void increase_size()
+    {
+        if (m_max_bucket_capacity == max_bucket_count()) {
+            // remove the value again, we can't add it!
+            m_values.pop_back();
+            on_error_bucket_overflow();
+        }
+        --m_shifts;
+        if constexpr (!IsSegmented || std::is_same_v<BucketContainer, default_container_t>) {
+            deallocate_buckets();
+        }
+        allocate_buckets_from_shift();
+        clear_and_fill_buckets_from_values();
+    }
+
+    template <typename Op> void do_erase(value_idx_type bucket_idx, Op handle_erased_value)
+    {
+        auto const value_idx_to_remove = at(m_buckets, bucket_idx).m_value_idx;
+
+        // shift down until either empty or an element with correct spot is found
+        auto next_bucket_idx = next(bucket_idx);
+        while (at(m_buckets, next_bucket_idx).m_dist_and_fingerprint >= Bucket::dist_inc * 2) {
+            at(m_buckets, bucket_idx) = { dist_dec(at(m_buckets, next_bucket_idx).m_dist_and_fingerprint),
+                                          at(m_buckets, next_bucket_idx).m_value_idx };
+            bucket_idx = std::exchange(next_bucket_idx, next(next_bucket_idx));
+        }
+        at(m_buckets, bucket_idx) = {};
+        handle_erased_value(std::move(m_values[value_idx_to_remove]));
+
+        // update m_values
+        if (value_idx_to_remove != m_values.size() - 1) {
+            // no luck, we'll have to replace the value with the last one and update the index accordingly
+            auto& val = m_values[value_idx_to_remove];
+            val = std::move(m_values.back());
+
+            // update the values_idx of the moved entry. No need to play the info game, just look until we find the
+            // values_idx
+            auto mh = mixed_hash(get_key(val));
+            bucket_idx = bucket_idx_from_hash(mh);
+
+            auto const values_idx_back = static_cast<value_idx_type>(m_values.size() - 1);
+            while (values_idx_back != at(m_buckets, bucket_idx).m_value_idx) {
+                bucket_idx = next(bucket_idx);
+            }
+            at(m_buckets, bucket_idx).m_value_idx = value_idx_to_remove;
+        }
+        m_values.pop_back();
+    }
+
+    template <typename K, typename Op> auto do_erase_key(K&& key, Op handle_erased_value) -> size_t
+    {
+        if (empty()) {
+            return 0;
+        }
+
+        auto [dist_and_fingerprint, bucket_idx] = next_while_less(key);
+
+        while (dist_and_fingerprint == at(m_buckets, bucket_idx).m_dist_and_fingerprint &&
+               !m_equal(key, get_key(m_values[at(m_buckets, bucket_idx).m_value_idx]))) {
+            dist_and_fingerprint = dist_inc(dist_and_fingerprint);
+            bucket_idx = next(bucket_idx);
+        }
+
+        if (dist_and_fingerprint != at(m_buckets, bucket_idx).m_dist_and_fingerprint) {
+            return 0;
+        }
+        do_erase(bucket_idx, handle_erased_value);
+        return 1;
+    }
+
+    template <class K, class M> auto do_insert_or_assign(K&& key, M&& mapped) -> std::pair<iterator, bool>
+    {
+        auto it_isinserted = try_emplace(std::forward<K>(key), std::forward<M>(mapped));
+        if (!it_isinserted.second) {
+            it_isinserted.first->second = std::forward<M>(mapped);
+        }
+        return it_isinserted;
+    }
+
+    template <typename... Args>
+    auto do_place_element(dist_and_fingerprint_type dist_and_fingerprint, value_idx_type bucket_idx, Args&&... args)
+        -> std::pair<iterator, bool>
+    {
+
+        // emplace the new value. If that throws an exception, no harm done; index is still in a valid state
+        m_values.emplace_back(std::forward<Args>(args)...);
+
+        auto value_idx = static_cast<value_idx_type>(m_values.size() - 1);
+        if (ANKERL_UNORDERED_DENSE_UNLIKELY(is_full())) {
+            increase_size();
+        } else {
+            place_and_shift_up({ dist_and_fingerprint, value_idx }, bucket_idx);
+        }
+
+        // place element and shift up until we find an empty spot
+        return { begin() + static_cast<difference_type>(value_idx), true };
+    }
+
+    template <typename K, typename... Args> auto do_try_emplace(K&& key, Args&&... args) -> std::pair<iterator, bool>
+    {
+        auto hash = mixed_hash(key);
+        auto dist_and_fingerprint = dist_and_fingerprint_from_hash(hash);
+        auto bucket_idx = bucket_idx_from_hash(hash);
+
+        while (true) {
+            auto* bucket = &at(m_buckets, bucket_idx);
+            if (dist_and_fingerprint == bucket->m_dist_and_fingerprint) {
+                if (m_equal(key, get_key(m_values[bucket->m_value_idx]))) {
+                    return { begin() + static_cast<difference_type>(bucket->m_value_idx), false };
+                }
+            } else if (dist_and_fingerprint > bucket->m_dist_and_fingerprint) {
+                return do_place_element(dist_and_fingerprint,
+                                        bucket_idx,
+                                        std::piecewise_construct,
+                                        std::forward_as_tuple(std::forward<K>(key)),
+                                        std::forward_as_tuple(std::forward<Args>(args)...));
+            }
+            dist_and_fingerprint = dist_inc(dist_and_fingerprint);
+            bucket_idx = next(bucket_idx);
+        }
+    }
+
+    template <typename K> auto do_find(K const& key) -> iterator
+    {
+        if (ANKERL_UNORDERED_DENSE_UNLIKELY(empty())) {
+            return end();
+        }
+
+        auto mh = mixed_hash(key);
+        auto dist_and_fingerprint = dist_and_fingerprint_from_hash(mh);
+        auto bucket_idx = bucket_idx_from_hash(mh);
+        auto* bucket = &at(m_buckets, bucket_idx);
+
+        // unrolled loop. *Always* check a few directly, then enter the loop. This is faster.
+        if (dist_and_fingerprint == bucket->m_dist_and_fingerprint &&
+            m_equal(key, get_key(m_values[bucket->m_value_idx]))) {
+            return begin() + static_cast<difference_type>(bucket->m_value_idx);
+        }
+        dist_and_fingerprint = dist_inc(dist_and_fingerprint);
+        bucket_idx = next(bucket_idx);
+        bucket = &at(m_buckets, bucket_idx);
+
+        if (dist_and_fingerprint == bucket->m_dist_and_fingerprint &&
+            m_equal(key, get_key(m_values[bucket->m_value_idx]))) {
+            return begin() + static_cast<difference_type>(bucket->m_value_idx);
+        }
+        dist_and_fingerprint = dist_inc(dist_and_fingerprint);
+        bucket_idx = next(bucket_idx);
+        bucket = &at(m_buckets, bucket_idx);
+
+        while (true) {
+            if (dist_and_fingerprint == bucket->m_dist_and_fingerprint) {
+                if (m_equal(key, get_key(m_values[bucket->m_value_idx]))) {
+                    return begin() + static_cast<difference_type>(bucket->m_value_idx);
+                }
+            } else if (dist_and_fingerprint > bucket->m_dist_and_fingerprint) {
+                return end();
+            }
+            dist_and_fingerprint = dist_inc(dist_and_fingerprint);
+            bucket_idx = next(bucket_idx);
+            bucket = &at(m_buckets, bucket_idx);
+        }
+    }
+
+    template <typename K> auto do_find(K const& key) const -> const_iterator
+    {
+        return const_cast<table*>(this)->do_find(key); // NOLINT(cppcoreguidelines-pro-type-const-cast)
+    }
+
+    template <typename K, typename Q = T, std::enable_if_t<is_map_v<Q>, bool> = true> auto do_at(K const& key) -> Q&
+    {
+        if (auto it = find(key); ANKERL_UNORDERED_DENSE_LIKELY(end() != it)) {
+            return it->second;
+        }
+        on_error_key_not_found();
+    }
+
+    template <typename K, typename Q = T, std::enable_if_t<is_map_v<Q>, bool> = true>
+    auto do_at(K const& key) const -> Q const&
+    {
+        return const_cast<table*>(this)->at(key); // NOLINT(cppcoreguidelines-pro-type-const-cast)
+    }
+
+  public:
+    explicit table(size_t bucket_count,
+                   Hash const& hash = Hash(),
+                   KeyEqual const& equal = KeyEqual(),
+                   allocator_type const& alloc_or_container = allocator_type())
+        : m_values(alloc_or_container)
+        , m_buckets(alloc_or_container)
+        , m_hash(hash)
+        , m_equal(equal)
+    {
+        if (0 != bucket_count) {
+            reserve(bucket_count);
+        } else {
+            allocate_buckets_from_shift();
+            clear_buckets();
+        }
+    }
+
+    table()
+        : table(0)
+    {}
+
+    table(size_t bucket_count, allocator_type const& alloc)
+        : table(bucket_count, Hash(), KeyEqual(), alloc)
+    {}
+
+    table(size_t bucket_count, Hash const& hash, allocator_type const& alloc)
+        : table(bucket_count, hash, KeyEqual(), alloc)
+    {}
+
+    explicit table(allocator_type const& alloc)
+        : table(0, Hash(), KeyEqual(), alloc)
+    {}
+
+    template <class InputIt>
+    table(InputIt first,
+          InputIt last,
+          size_type bucket_count = 0,
+          Hash const& hash = Hash(),
+          KeyEqual const& equal = KeyEqual(),
+          allocator_type const& alloc = allocator_type())
+        : table(bucket_count, hash, equal, alloc)
+    {
+        insert(first, last);
+    }
+
+    template <class InputIt>
+    table(InputIt first, InputIt last, size_type bucket_count, allocator_type const& alloc)
+        : table(first, last, bucket_count, Hash(), KeyEqual(), alloc)
+    {}
+
+    template <class InputIt>
+    table(InputIt first, InputIt last, size_type bucket_count, Hash const& hash, allocator_type const& alloc)
+        : table(first, last, bucket_count, hash, KeyEqual(), alloc)
+    {}
+
+    table(table const& other)
+        : table(other, other.m_values.get_allocator())
+    {}
+
+    table(table const& other, allocator_type const& alloc)
+        : m_values(other.m_values, alloc)
+        , m_max_load_factor(other.m_max_load_factor)
+        , m_hash(other.m_hash)
+        , m_equal(other.m_equal)
+    {
+        copy_buckets(other);
+    }
+
+    table(table&& other) noexcept
+        : table(std::move(other), other.m_values.get_allocator())
+    {}
+
+    table(table&& other, allocator_type const& alloc) noexcept
+        : m_values(alloc)
+    {
+        *this = std::move(other);
+    }
+
+    table(std::initializer_list<value_type> ilist,
+          size_t bucket_count = 0,
+          Hash const& hash = Hash(),
+          KeyEqual const& equal = KeyEqual(),
+          allocator_type const& alloc = allocator_type())
+        : table(bucket_count, hash, equal, alloc)
+    {
+        insert(ilist);
+    }
+
+    table(std::initializer_list<value_type> ilist, size_type bucket_count, allocator_type const& alloc)
+        : table(ilist, bucket_count, Hash(), KeyEqual(), alloc)
+    {}
+
+    table(std::initializer_list<value_type> init, size_type bucket_count, Hash const& hash, allocator_type const& alloc)
+        : table(init, bucket_count, hash, KeyEqual(), alloc)
+    {}
+
+    ~table() {}
+
+    auto operator=(table const& other) -> table&
+    {
+        if (&other != this) {
+            deallocate_buckets(); // deallocate before m_values is set (might have another allocator)
+            m_values = other.m_values;
+            m_max_load_factor = other.m_max_load_factor;
+            m_hash = other.m_hash;
+            m_equal = other.m_equal;
+            m_shifts = initial_shifts;
+            copy_buckets(other);
+        }
+        return *this;
+    }
+
+    auto operator=(table&& other) noexcept(
+        noexcept(std::is_nothrow_move_assignable_v<value_container_type>&& std::is_nothrow_move_assignable_v<Hash>&&
+                     std::is_nothrow_move_assignable_v<KeyEqual>)) -> table&
+    {
+        if (&other != this) {
+            deallocate_buckets(); // deallocate before m_values is set (might have another allocator)
+            m_values = std::move(other.m_values);
+            other.m_values.clear();
+
+            // we can only reuse m_buckets when both maps have the same allocator!
+            if (get_allocator() == other.get_allocator()) {
+                m_buckets = std::move(other.m_buckets);
+                other.m_buckets.clear();
+                m_max_bucket_capacity = std::exchange(other.m_max_bucket_capacity, 0);
+                m_shifts = std::exchange(other.m_shifts, initial_shifts);
+                m_max_load_factor = std::exchange(other.m_max_load_factor, default_max_load_factor);
+                m_hash = std::exchange(other.m_hash, {});
+                m_equal = std::exchange(other.m_equal, {});
+                other.allocate_buckets_from_shift();
+                other.clear_buckets();
+            } else {
+                // set max_load_factor *before* copying the other's buckets, so we have the same
+                // behavior
+                m_max_load_factor = other.m_max_load_factor;
+
+                // copy_buckets sets m_buckets, m_num_buckets, m_max_bucket_capacity, m_shifts
+                copy_buckets(other);
+                // clear's the other's buckets so other is now already usable.
+                other.clear_buckets();
+                m_hash = other.m_hash;
+                m_equal = other.m_equal;
+            }
+            // map "other" is now already usable, it's empty.
+        }
+        return *this;
+    }
+
+    auto operator=(std::initializer_list<value_type> ilist) -> table&
+    {
+        clear();
+        insert(ilist);
+        return *this;
+    }
+
+    auto get_allocator() const noexcept -> allocator_type { return m_values.get_allocator(); }
+
+    // iterators //////////////////////////////////////////////////////////////
+
+    auto begin() noexcept -> iterator { return m_values.begin(); }
+
+    auto begin() const noexcept -> const_iterator { return m_values.begin(); }
+
+    auto cbegin() const noexcept -> const_iterator { return m_values.cbegin(); }
+
+    auto end() noexcept -> iterator { return m_values.end(); }
+
+    auto cend() const noexcept -> const_iterator { return m_values.cend(); }
+
+    auto end() const noexcept -> const_iterator { return m_values.end(); }
+
+    // capacity ///////////////////////////////////////////////////////////////
+
+    [[nodiscard]] auto empty() const noexcept -> bool { return m_values.empty(); }
+
+    [[nodiscard]] auto size() const noexcept -> size_t { return m_values.size(); }
+
+    [[nodiscard]] static constexpr auto max_size() noexcept -> size_t
+    {
+        if constexpr ((std::numeric_limits<value_idx_type>::max)() == (std::numeric_limits<size_t>::max)()) {
+            return size_t{ 1 } << (sizeof(value_idx_type) * 8 - 1);
+        } else {
+            return size_t{ 1 } << (sizeof(value_idx_type) * 8);
+        }
+    }
+
+    // modifiers //////////////////////////////////////////////////////////////
+
+    void clear()
+    {
+        m_values.clear();
+        clear_buckets();
+    }
+
+    auto insert(value_type const& value) -> std::pair<iterator, bool> { return emplace(value); }
+
+    auto insert(value_type&& value) -> std::pair<iterator, bool> { return emplace(std::move(value)); }
+
+    template <class P, std::enable_if_t<std::is_constructible_v<value_type, P&&>, bool> = true>
+    auto insert(P&& value) -> std::pair<iterator, bool>
+    {
+        return emplace(std::forward<P>(value));
+    }
+
+    auto insert(const_iterator /*hint*/, value_type const& value) -> iterator { return insert(value).first; }
+
+    auto insert(const_iterator /*hint*/, value_type&& value) -> iterator { return insert(std::move(value)).first; }
+
+    template <class P, std::enable_if_t<std::is_constructible_v<value_type, P&&>, bool> = true>
+    auto insert(const_iterator /*hint*/, P&& value) -> iterator
+    {
+        return insert(std::forward<P>(value)).first;
+    }
+
+    template <class InputIt> void insert(InputIt first, InputIt last)
+    {
+        while (first != last) {
+            insert(*first);
+            ++first;
+        }
+    }
+
+    void insert(std::initializer_list<value_type> ilist) { insert(ilist.begin(), ilist.end()); }
+
+    // nonstandard API: *this is emptied.
+    // Also see "A Standard flat_map" https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2022/p0429r9.pdf
+    auto extract() && -> value_container_type { return std::move(m_values); }
+
+    // nonstandard API:
+    // Discards the internally held container and replaces it with the one passed. Erases non-unique elements.
+    auto replace(value_container_type&& container)
+    {
+        if (ANKERL_UNORDERED_DENSE_UNLIKELY(container.size() > max_size())) {
+            on_error_too_many_elements();
+        }
+        auto shifts = calc_shifts_for_size(container.size());
+        if (0 == bucket_count() || shifts < m_shifts || container.get_allocator() != m_values.get_allocator()) {
+            m_shifts = shifts;
+            deallocate_buckets();
+            allocate_buckets_from_shift();
+        }
+        clear_buckets();
+
+        m_values = std::move(container);
+
+        // can't use clear_and_fill_buckets_from_values() because container elements might not be unique
+        auto value_idx = value_idx_type{};
+
+        // loop until we reach the end of the container. duplicated entries will be replaced with back().
+        while (value_idx != static_cast<value_idx_type>(m_values.size())) {
+            auto const& key = get_key(m_values[value_idx]);
+
+            auto hash = mixed_hash(key);
+            auto dist_and_fingerprint = dist_and_fingerprint_from_hash(hash);
+            auto bucket_idx = bucket_idx_from_hash(hash);
+
+            bool key_found = false;
+            while (true) {
+                auto const& bucket = at(m_buckets, bucket_idx);
+                if (dist_and_fingerprint > bucket.m_dist_and_fingerprint) {
+                    break;
+                }
+                if (dist_and_fingerprint == bucket.m_dist_and_fingerprint &&
+                    m_equal(key, get_key(m_values[bucket.m_value_idx]))) {
+                    key_found = true;
+                    break;
+                }
+                dist_and_fingerprint = dist_inc(dist_and_fingerprint);
+                bucket_idx = next(bucket_idx);
+            }
+
+            if (key_found) {
+                if (value_idx != static_cast<value_idx_type>(m_values.size() - 1)) {
+                    m_values[value_idx] = std::move(m_values.back());
+                }
+                m_values.pop_back();
+            } else {
+                place_and_shift_up({ dist_and_fingerprint, value_idx }, bucket_idx);
+                ++value_idx;
+            }
+        }
+    }
+
+    template <class M, typename Q = T, std::enable_if_t<is_map_v<Q>, bool> = true>
+    auto insert_or_assign(Key const& key, M&& mapped) -> std::pair<iterator, bool>
+    {
+        return do_insert_or_assign(key, std::forward<M>(mapped));
+    }
+
+    template <class M, typename Q = T, std::enable_if_t<is_map_v<Q>, bool> = true>
+    auto insert_or_assign(Key&& key, M&& mapped) -> std::pair<iterator, bool>
+    {
+        return do_insert_or_assign(std::move(key), std::forward<M>(mapped));
+    }
+
+    template <typename K,
+              typename M,
+              typename Q = T,
+              typename H = Hash,
+              typename KE = KeyEqual,
+              std::enable_if_t<is_map_v<Q> && is_transparent_v<H, KE>, bool> = true>
+    auto insert_or_assign(K&& key, M&& mapped) -> std::pair<iterator, bool>
+    {
+        return do_insert_or_assign(std::forward<K>(key), std::forward<M>(mapped));
+    }
+
+    template <class M, typename Q = T, std::enable_if_t<is_map_v<Q>, bool> = true>
+    auto insert_or_assign(const_iterator /*hint*/, Key const& key, M&& mapped) -> iterator
+    {
+        return do_insert_or_assign(key, std::forward<M>(mapped)).first;
+    }
+
+    template <class M, typename Q = T, std::enable_if_t<is_map_v<Q>, bool> = true>
+    auto insert_or_assign(const_iterator /*hint*/, Key&& key, M&& mapped) -> iterator
+    {
+        return do_insert_or_assign(std::move(key), std::forward<M>(mapped)).first;
+    }
+
+    template <typename K,
+              typename M,
+              typename Q = T,
+              typename H = Hash,
+              typename KE = KeyEqual,
+              std::enable_if_t<is_map_v<Q> && is_transparent_v<H, KE>, bool> = true>
+    auto insert_or_assign(const_iterator /*hint*/, K&& key, M&& mapped) -> iterator
+    {
+        return do_insert_or_assign(std::forward<K>(key), std::forward<M>(mapped)).first;
+    }
+
+    // Single arguments for unordered_set can be used without having to construct the value_type
+    template <class K,
+              typename Q = T,
+              typename H = Hash,
+              typename KE = KeyEqual,
+              std::enable_if_t<!is_map_v<Q> && is_transparent_v<H, KE>, bool> = true>
+    auto emplace(K&& key) -> std::pair<iterator, bool>
+    {
+        auto hash = mixed_hash(key);
+        auto dist_and_fingerprint = dist_and_fingerprint_from_hash(hash);
+        auto bucket_idx = bucket_idx_from_hash(hash);
+
+        while (dist_and_fingerprint <= at(m_buckets, bucket_idx).m_dist_and_fingerprint) {
+            if (dist_and_fingerprint == at(m_buckets, bucket_idx).m_dist_and_fingerprint &&
+                m_equal(key, m_values[at(m_buckets, bucket_idx).m_value_idx])) {
+                // found it, return without ever actually creating anything
+                return { begin() + static_cast<difference_type>(at(m_buckets, bucket_idx).m_value_idx), false };
+            }
+            dist_and_fingerprint = dist_inc(dist_and_fingerprint);
+            bucket_idx = next(bucket_idx);
+        }
+
+        // value is new, insert element first, so when exception happens we are in a valid state
+        return do_place_element(dist_and_fingerprint, bucket_idx, std::forward<K>(key));
+    }
+
+    template <class... Args> auto emplace(Args&&... args) -> std::pair<iterator, bool>
+    {
+        // we have to instantiate the value_type to be able to access the key.
+        // 1. emplace_back the object so it is constructed. 2. If the key is already there, pop it later in the loop.
+        auto& key = get_key(m_values.emplace_back(std::forward<Args>(args)...));
+        auto hash = mixed_hash(key);
+        auto dist_and_fingerprint = dist_and_fingerprint_from_hash(hash);
+        auto bucket_idx = bucket_idx_from_hash(hash);
+
+        while (dist_and_fingerprint <= at(m_buckets, bucket_idx).m_dist_and_fingerprint) {
+            if (dist_and_fingerprint == at(m_buckets, bucket_idx).m_dist_and_fingerprint &&
+                m_equal(key, get_key(m_values[at(m_buckets, bucket_idx).m_value_idx]))) {
+                m_values.pop_back(); // value was already there, so get rid of it
+                return { begin() + static_cast<difference_type>(at(m_buckets, bucket_idx).m_value_idx), false };
+            }
+            dist_and_fingerprint = dist_inc(dist_and_fingerprint);
+            bucket_idx = next(bucket_idx);
+        }
+
+        // value is new, place the bucket and shift up until we find an empty spot
+        auto value_idx = static_cast<value_idx_type>(m_values.size() - 1);
+        if (ANKERL_UNORDERED_DENSE_UNLIKELY(is_full())) {
+            // increase_size just rehashes all the data we have in m_values
+            increase_size();
+        } else {
+            // place element and shift up until we find an empty spot
+            place_and_shift_up({ dist_and_fingerprint, value_idx }, bucket_idx);
+        }
+        return { begin() + static_cast<difference_type>(value_idx), true };
+    }
+
+    template <class... Args> auto emplace_hint(const_iterator /*hint*/, Args&&... args) -> iterator
+    {
+        return emplace(std::forward<Args>(args)...).first;
+    }
+
+    template <class... Args, typename Q = T, std::enable_if_t<is_map_v<Q>, bool> = true>
+    auto try_emplace(Key const& key, Args&&... args) -> std::pair<iterator, bool>
+    {
+        return do_try_emplace(key, std::forward<Args>(args)...);
+    }
+
+    template <class... Args, typename Q = T, std::enable_if_t<is_map_v<Q>, bool> = true>
+    auto try_emplace(Key&& key, Args&&... args) -> std::pair<iterator, bool>
+    {
+        return do_try_emplace(std::move(key), std::forward<Args>(args)...);
+    }
+
+    template <class... Args, typename Q = T, std::enable_if_t<is_map_v<Q>, bool> = true>
+    auto try_emplace(const_iterator /*hint*/, Key const& key, Args&&... args) -> iterator
+    {
+        return do_try_emplace(key, std::forward<Args>(args)...).first;
+    }
+
+    template <class... Args, typename Q = T, std::enable_if_t<is_map_v<Q>, bool> = true>
+    auto try_emplace(const_iterator /*hint*/, Key&& key, Args&&... args) -> iterator
+    {
+        return do_try_emplace(std::move(key), std::forward<Args>(args)...).first;
+    }
+
+    template <typename K,
+              typename... Args,
+              typename Q = T,
+              typename H = Hash,
+              typename KE = KeyEqual,
+              std::enable_if_t<is_map_v<Q> && is_transparent_v<H, KE> &&
+                                   is_neither_convertible_v<K&&, iterator, const_iterator>,
+                               bool> = true>
+    auto try_emplace(K&& key, Args&&... args) -> std::pair<iterator, bool>
+    {
+        return do_try_emplace(std::forward<K>(key), std::forward<Args>(args)...);
+    }
+
+    template <typename K,
+              typename... Args,
+              typename Q = T,
+              typename H = Hash,
+              typename KE = KeyEqual,
+              std::enable_if_t<is_map_v<Q> && is_transparent_v<H, KE> &&
+                                   is_neither_convertible_v<K&&, iterator, const_iterator>,
+                               bool> = true>
+    auto try_emplace(const_iterator /*hint*/, K&& key, Args&&... args) -> iterator
+    {
+        return do_try_emplace(std::forward<K>(key), std::forward<Args>(args)...).first;
+    }
+
+    auto erase(iterator it) -> iterator
+    {
+        auto hash = mixed_hash(get_key(*it));
+        auto bucket_idx = bucket_idx_from_hash(hash);
+
+        auto const value_idx_to_remove = static_cast<value_idx_type>(it - cbegin());
+        while (at(m_buckets, bucket_idx).m_value_idx != value_idx_to_remove) {
+            bucket_idx = next(bucket_idx);
+        }
+
+        do_erase(bucket_idx, [](value_type&& /*unused*/) {});
+        return begin() + static_cast<difference_type>(value_idx_to_remove);
+    }
+
+    auto extract(iterator it) -> value_type
+    {
+        auto hash = mixed_hash(get_key(*it));
+        auto bucket_idx = bucket_idx_from_hash(hash);
+
+        auto const value_idx_to_remove = static_cast<value_idx_type>(it - cbegin());
+        while (at(m_buckets, bucket_idx).m_value_idx != value_idx_to_remove) {
+            bucket_idx = next(bucket_idx);
+        }
+
+        auto tmp = std::optional<value_type>{};
+        do_erase(bucket_idx, [&tmp](value_type&& val) { tmp = std::move(val); });
+        return std::move(tmp).value();
+    }
+
+    template <typename Q = T, std::enable_if_t<is_map_v<Q>, bool> = true> auto erase(const_iterator it) -> iterator
+    {
+        return erase(begin() + (it - cbegin()));
+    }
+
+    template <typename Q = T, std::enable_if_t<is_map_v<Q>, bool> = true> auto extract(const_iterator it) -> value_type
+    {
+        return extract(begin() + (it - cbegin()));
+    }
+
+    auto erase(const_iterator first, const_iterator last) -> iterator
+    {
+        auto const idx_first = first - cbegin();
+        auto const idx_last = last - cbegin();
+        auto const first_to_last = std::distance(first, last);
+        auto const last_to_end = std::distance(last, cend());
+
+        // remove elements from left to right which moves elements from the end back
+        auto const mid = idx_first + (std::min)(first_to_last, last_to_end);
+        auto idx = idx_first;
+        while (idx != mid) {
+            erase(begin() + idx);
+            ++idx;
+        }
+
+        // all elements from the right are moved, now remove the last element until all done
+        idx = idx_last;
+        while (idx != mid) {
+            --idx;
+            erase(begin() + idx);
+        }
+
+        return begin() + idx_first;
+    }
+
+    auto erase(Key const& key) -> size_t
+    {
+        return do_erase_key(key, [](value_type&& /*unused*/) {});
+    }
+
+    auto extract(Key const& key) -> std::optional<value_type>
+    {
+        auto tmp = std::optional<value_type>{};
+        do_erase_key(key, [&tmp](value_type&& val) { tmp = std::move(val); });
+        return tmp;
+    }
+
+    template <class K, class H = Hash, class KE = KeyEqual, std::enable_if_t<is_transparent_v<H, KE>, bool> = true>
+    auto erase(K&& key) -> size_t
+    {
+        return do_erase_key(std::forward<K>(key), [](value_type&& /*unused*/) {});
+    }
+
+    template <class K, class H = Hash, class KE = KeyEqual, std::enable_if_t<is_transparent_v<H, KE>, bool> = true>
+    auto extract(K&& key) -> std::optional<value_type>
+    {
+        auto tmp = std::optional<value_type>{};
+        do_erase_key(std::forward<K>(key), [&tmp](value_type&& val) { tmp = std::move(val); });
+        return tmp;
+    }
+
+    void swap(table& other) noexcept(
+        noexcept(std::is_nothrow_swappable_v<value_container_type>&& std::is_nothrow_swappable_v<Hash>&&
+                     std::is_nothrow_swappable_v<KeyEqual>))
+    {
+        using std::swap;
+        swap(other, *this);
+    }
+
+    // lookup /////////////////////////////////////////////////////////////////
+
+    template <typename Q = T, std::enable_if_t<is_map_v<Q>, bool> = true> auto at(key_type const& key) -> Q&
+    {
+        return do_at(key);
+    }
+
+    template <typename K,
+              typename Q = T,
+              typename H = Hash,
+              typename KE = KeyEqual,
+              std::enable_if_t<is_map_v<Q> && is_transparent_v<H, KE>, bool> = true>
+    auto at(K const& key) -> Q&
+    {
+        return do_at(key);
+    }
+
+    template <typename Q = T, std::enable_if_t<is_map_v<Q>, bool> = true> auto at(key_type const& key) const -> Q const&
+    {
+        return do_at(key);
+    }
+
+    template <typename K,
+              typename Q = T,
+              typename H = Hash,
+              typename KE = KeyEqual,
+              std::enable_if_t<is_map_v<Q> && is_transparent_v<H, KE>, bool> = true>
+    auto at(K const& key) const -> Q const&
+    {
+        return do_at(key);
+    }
+
+    template <typename Q = T, std::enable_if_t<is_map_v<Q>, bool> = true> auto operator[](Key const& key) -> Q&
+    {
+        return try_emplace(key).first->second;
+    }
+
+    template <typename Q = T, std::enable_if_t<is_map_v<Q>, bool> = true> auto operator[](Key&& key) -> Q&
+    {
+        return try_emplace(std::move(key)).first->second;
+    }
+
+    template <typename K,
+              typename Q = T,
+              typename H = Hash,
+              typename KE = KeyEqual,
+              std::enable_if_t<is_map_v<Q> && is_transparent_v<H, KE>, bool> = true>
+    auto operator[](K&& key) -> Q&
+    {
+        return try_emplace(std::forward<K>(key)).first->second;
+    }
+
+    auto count(Key const& key) const -> size_t { return find(key) == end() ? 0 : 1; }
+
+    template <class K, class H = Hash, class KE = KeyEqual, std::enable_if_t<is_transparent_v<H, KE>, bool> = true>
+    auto count(K const& key) const -> size_t
+    {
+        return find(key) == end() ? 0 : 1;
+    }
+
+    auto find(Key const& key) -> iterator { return do_find(key); }
+
+    auto find(Key const& key) const -> const_iterator { return do_find(key); }
+
+    template <class K, class H = Hash, class KE = KeyEqual, std::enable_if_t<is_transparent_v<H, KE>, bool> = true>
+    auto find(K const& key) -> iterator
+    {
+        return do_find(key);
+    }
+
+    template <class K, class H = Hash, class KE = KeyEqual, std::enable_if_t<is_transparent_v<H, KE>, bool> = true>
+    auto find(K const& key) const -> const_iterator
+    {
+        return do_find(key);
+    }
+
+    auto contains(Key const& key) const -> bool { return find(key) != end(); }
+
+    template <class K, class H = Hash, class KE = KeyEqual, std::enable_if_t<is_transparent_v<H, KE>, bool> = true>
+    auto contains(K const& key) const -> bool
+    {
+        return find(key) != end();
+    }
+
+    auto equal_range(Key const& key) -> std::pair<iterator, iterator>
+    {
+        auto it = do_find(key);
+        return { it, it == end() ? end() : it + 1 };
+    }
+
+    auto equal_range(const Key& key) const -> std::pair<const_iterator, const_iterator>
+    {
+        auto it = do_find(key);
+        return { it, it == end() ? end() : it + 1 };
+    }
+
+    template <class K, class H = Hash, class KE = KeyEqual, std::enable_if_t<is_transparent_v<H, KE>, bool> = true>
+    auto equal_range(K const& key) -> std::pair<iterator, iterator>
+    {
+        auto it = do_find(key);
+        return { it, it == end() ? end() : it + 1 };
+    }
+
+    template <class K, class H = Hash, class KE = KeyEqual, std::enable_if_t<is_transparent_v<H, KE>, bool> = true>
+    auto equal_range(K const& key) const -> std::pair<const_iterator, const_iterator>
+    {
+        auto it = do_find(key);
+        return { it, it == end() ? end() : it + 1 };
+    }
+
+    // bucket interface ///////////////////////////////////////////////////////
+
+    auto bucket_count() const noexcept -> size_t
+    { // NOLINT(modernize-use-nodiscard)
+        return m_buckets.size();
+    }
+
+    static constexpr auto max_bucket_count() noexcept -> size_t
+    { // NOLINT(modernize-use-nodiscard)
+        return max_size();
+    }
+
+    // hash policy ////////////////////////////////////////////////////////////
+
+    [[nodiscard]] auto load_factor() const -> float
+    {
+        return bucket_count() ? static_cast<float>(size()) / static_cast<float>(bucket_count()) : 0.0F;
+    }
+
+    [[nodiscard]] auto max_load_factor() const -> float { return m_max_load_factor; }
+
+    void max_load_factor(float ml)
+    {
+        m_max_load_factor = ml;
+        if (bucket_count() != max_bucket_count()) {
+            m_max_bucket_capacity = static_cast<value_idx_type>(static_cast<float>(bucket_count()) * max_load_factor());
+        }
+    }
+
+    void rehash(size_t count)
+    {
+        count = (std::min)(count, max_size());
+        auto shifts = calc_shifts_for_size((std::max)(count, size()));
+        if (shifts != m_shifts) {
+            m_shifts = shifts;
+            deallocate_buckets();
+            m_values.shrink_to_fit();
+            allocate_buckets_from_shift();
+            clear_and_fill_buckets_from_values();
+        }
+    }
+
+    void reserve(size_t capa)
+    {
+        capa = (std::min)(capa, max_size());
+        if constexpr (has_reserve<value_container_type>) {
+            // std::deque doesn't have reserve(). Make sure we only call when available
+            m_values.reserve(capa);
+        }
+        auto shifts = calc_shifts_for_size((std::max)(capa, size()));
+        if (0 == bucket_count() || shifts < m_shifts) {
+            m_shifts = shifts;
+            deallocate_buckets();
+            allocate_buckets_from_shift();
+            clear_and_fill_buckets_from_values();
+        }
+    }
+
+    // observers //////////////////////////////////////////////////////////////
+
+    auto hash_function() const -> hasher { return m_hash; }
+
+    auto key_eq() const -> key_equal { return m_equal; }
+
+    // nonstandard API: expose the underlying values container
+    [[nodiscard]] auto values() const noexcept -> value_container_type const& { return m_values; }
+
+    // non-member functions ///////////////////////////////////////////////////
+
+    friend auto operator==(table const& a, table const& b) -> bool
+    {
+        if (&a == &b) {
+            return true;
+        }
+        if (a.size() != b.size()) {
+            return false;
+        }
+        for (auto const& b_entry : b) {
+            auto it = a.find(get_key(b_entry));
+            if constexpr (is_map_v<T>) {
+                // map: check that key is here, then also check that value is the same
+                if (a.end() == it || !(b_entry.second == it->second)) {
+                    return false;
+                }
+            } else {
+                // set: only check that the key is here
+                if (a.end() == it) {
+                    return false;
+                }
+            }
+        }
+        return true;
+    }
+
+    friend auto operator!=(table const& a, table const& b) -> bool { return !(a == b); }
+};
+
+} // namespace detail
+
+ANKERL_UNORDERED_DENSE_EXPORT template <class Key,
+                                        class T,
+                                        class Hash = hash<Key>,
+                                        class KeyEqual = std::equal_to<Key>,
+                                        class AllocatorOrContainer = std::allocator<std::pair<Key, T>>,
+                                        class Bucket = bucket_type::standard,
+                                        class BucketContainer = detail::default_container_t>
+using map = detail::table<Key, T, Hash, KeyEqual, AllocatorOrContainer, Bucket, BucketContainer, false>;
+
+ANKERL_UNORDERED_DENSE_EXPORT template <class Key,
+                                        class T,
+                                        class Hash = hash<Key>,
+                                        class KeyEqual = std::equal_to<Key>,
+                                        class AllocatorOrContainer = std::allocator<std::pair<Key, T>>,
+                                        class Bucket = bucket_type::standard,
+                                        class BucketContainer = detail::default_container_t>
+using segmented_map = detail::table<Key, T, Hash, KeyEqual, AllocatorOrContainer, Bucket, BucketContainer, true>;
+
+ANKERL_UNORDERED_DENSE_EXPORT template <class Key,
+                                        class Hash = hash<Key>,
+                                        class KeyEqual = std::equal_to<Key>,
+                                        class AllocatorOrContainer = std::allocator<Key>,
+                                        class Bucket = bucket_type::standard,
+                                        class BucketContainer = detail::default_container_t>
+using set = detail::table<Key, void, Hash, KeyEqual, AllocatorOrContainer, Bucket, BucketContainer, false>;
+
+ANKERL_UNORDERED_DENSE_EXPORT template <class Key,
+                                        class Hash = hash<Key>,
+                                        class KeyEqual = std::equal_to<Key>,
+                                        class AllocatorOrContainer = std::allocator<Key>,
+                                        class Bucket = bucket_type::standard,
+                                        class BucketContainer = detail::default_container_t>
+using segmented_set = detail::table<Key, void, Hash, KeyEqual, AllocatorOrContainer, Bucket, BucketContainer, true>;
+
+#if defined(ANKERL_UNORDERED_DENSE_PMR)
+
+namespace pmr {
+
+ANKERL_UNORDERED_DENSE_EXPORT template <class Key,
+                                        class T,
+                                        class Hash = hash<Key>,
+                                        class KeyEqual = std::equal_to<Key>,
+                                        class Bucket = bucket_type::standard>
+using map = detail::table<Key,
+                          T,
+                          Hash,
+                          KeyEqual,
+                          ANKERL_UNORDERED_DENSE_PMR::polymorphic_allocator<std::pair<Key, T>>,
+                          Bucket,
+                          detail::default_container_t,
+                          false>;
+
+ANKERL_UNORDERED_DENSE_EXPORT template <class Key,
+                                        class T,
+                                        class Hash = hash<Key>,
+                                        class KeyEqual = std::equal_to<Key>,
+                                        class Bucket = bucket_type::standard>
+using segmented_map = detail::table<Key,
+                                    T,
+                                    Hash,
+                                    KeyEqual,
+                                    ANKERL_UNORDERED_DENSE_PMR::polymorphic_allocator<std::pair<Key, T>>,
+                                    Bucket,
+                                    detail::default_container_t,
+                                    true>;
+
+ANKERL_UNORDERED_DENSE_EXPORT template <class Key,
+                                        class Hash = hash<Key>,
+                                        class KeyEqual = std::equal_to<Key>,
+                                        class Bucket = bucket_type::standard>
+using set = detail::table<Key,
+                          void,
+                          Hash,
+                          KeyEqual,
+                          ANKERL_UNORDERED_DENSE_PMR::polymorphic_allocator<Key>,
+                          Bucket,
+                          detail::default_container_t,
+                          false>;
+
+ANKERL_UNORDERED_DENSE_EXPORT template <class Key,
+                                        class Hash = hash<Key>,
+                                        class KeyEqual = std::equal_to<Key>,
+                                        class Bucket = bucket_type::standard>
+using segmented_set = detail::table<Key,
+                                    void,
+                                    Hash,
+                                    KeyEqual,
+                                    ANKERL_UNORDERED_DENSE_PMR::polymorphic_allocator<Key>,
+                                    Bucket,
+                                    detail::default_container_t,
+                                    true>;
+
+} // namespace pmr
+
+#endif
+
+// deduction guides ///////////////////////////////////////////////////////////
+
+// deduction guides for alias templates are only possible since C++20
+// see https://en.cppreference.com/w/cpp/language/class_template_argument_deduction
+
+} // namespace ANKERL_UNORDERED_DENSE_NAMESPACE
+} // namespace ankerl::unordered_dense
+
+// std extensions /////////////////////////////////////////////////////////////
+
+namespace std { // NOLINT(cert-dcl58-cpp)
+
+ANKERL_UNORDERED_DENSE_EXPORT template <class Key,
+                                        class T,
+                                        class Hash,
+                                        class KeyEqual,
+                                        class AllocatorOrContainer,
+                                        class Bucket,
+                                        class Pred,
+                                        class BucketContainer,
+                                        bool IsSegmented>
+// NOLINTNEXTLINE(cert-dcl58-cpp)
+auto erase_if(ankerl::unordered_dense::detail::
+                  table<Key, T, Hash, KeyEqual, AllocatorOrContainer, Bucket, BucketContainer, IsSegmented>& map,
+              Pred pred) -> size_t
+{
+    using map_t = ankerl::unordered_dense::detail::
+        table<Key, T, Hash, KeyEqual, AllocatorOrContainer, Bucket, BucketContainer, IsSegmented>;
+
+    // going back to front because erase() invalidates the end iterator
+    auto const old_size = map.size();
+    auto idx = old_size;
+    while (idx) {
+        --idx;
+        auto it = map.begin() + static_cast<typename map_t::difference_type>(idx);
+        if (pred(*it)) {
+            map.erase(it);
+        }
+    }
+
+    return old_size - map.size();
+}
+
+} // namespace std
+
+#endif
+#endif
\ No newline at end of file
diff --git a/barretenberg/cpp/src/barretenberg/vm2/common/avm_inputs.cpp b/barretenberg/cpp/src/barretenberg/vm2/common/avm_inputs.cpp
new file mode 100644
index 00000000000..722454b62db
--- /dev/null
+++ b/barretenberg/cpp/src/barretenberg/vm2/common/avm_inputs.cpp
@@ -0,0 +1,23 @@
+#include "barretenberg/vm2/common/avm_inputs.hpp"
+
+#include <vector>
+
+#include "barretenberg/serialize/msgpack.hpp"
+
+namespace bb::avm2 {
+
+PublicInputs PublicInputs::from(const std::vector<uint8_t>& data)
+{
+    PublicInputs inputs;
+    msgpack::unpack(reinterpret_cast<const char*>(data.data()), data.size()).get().convert(inputs);
+    return inputs;
+}
+
+AvmProvingInputs AvmProvingInputs::from(const std::vector<uint8_t>& data)
+{
+    AvmProvingInputs inputs;
+    msgpack::unpack(reinterpret_cast<const char*>(data.data()), data.size()).get().convert(inputs);
+    return inputs;
+}
+
+} // namespace bb::avm2
\ No newline at end of file
diff --git a/barretenberg/cpp/src/barretenberg/vm2/common/avm_inputs.hpp b/barretenberg/cpp/src/barretenberg/vm2/common/avm_inputs.hpp
new file mode 100644
index 00000000000..a19ddd57d83
--- /dev/null
+++ b/barretenberg/cpp/src/barretenberg/vm2/common/avm_inputs.hpp
@@ -0,0 +1,95 @@
+// NOTE: names are in camel-case because they matter to messagepack.
+// DO NOT use camel-case outside of these structures.
+#pragma once
+
+#include <vector>
+
+#include "barretenberg/serialize/msgpack.hpp"
+#include "barretenberg/vm2/common/aztec_types.hpp"
+#include "barretenberg/vm2/common/field.hpp"
+
+namespace bb::avm2 {
+
+struct PublicKeysHint {
+    AffinePoint masterNullifierPublicKey;
+    AffinePoint masterIncomingViewingPublicKey;
+    AffinePoint masterOutgoingViewingPublicKey;
+    AffinePoint masterTaggingPublicKey;
+
+    bool operator==(const PublicKeysHint& other) const = default;
+
+    MSGPACK_FIELDS(masterNullifierPublicKey,
+                   masterIncomingViewingPublicKey,
+                   masterOutgoingViewingPublicKey,
+                   masterTaggingPublicKey);
+};
+
+struct ContractInstanceHint {
+    AztecAddress address;
+    bool exists;
+    FF salt;
+    AztecAddress deployer;
+    ContractClassId contractClassId;
+    FF initializationHash;
+    PublicKeysHint publicKeys;
+    // TODO: missing membership hints.
+
+    bool operator==(const ContractInstanceHint& other) const = default;
+
+    MSGPACK_FIELDS(address, exists, salt, deployer, contractClassId, initializationHash, publicKeys);
+};
+
+struct ContractClassHint {
+    FF artifactHash;
+    FF privateFunctionsRoot;
+    FF publicBytecodeCommitment;
+    std::vector<uint8_t> packedBytecode;
+
+    bool operator==(const ContractClassHint& other) const = default;
+
+    MSGPACK_FIELDS(artifactHash, privateFunctionsRoot, publicBytecodeCommitment, packedBytecode);
+};
+
+struct ExecutionHints {
+    std::vector<ContractInstanceHint> contractInstances;
+    std::vector<ContractClassHint> contractClasses;
+
+    bool operator==(const ExecutionHints& other) const = default;
+
+    MSGPACK_FIELDS(contractInstances, contractClasses);
+};
+
+struct PublicExecutionRequest {
+    AztecAddress contractAddress;
+    AztecAddress sender;
+    std::vector<FF> args;
+    bool isStatic;
+
+    bool operator==(const PublicExecutionRequest& other) const = default;
+
+    MSGPACK_FIELDS(contractAddress, sender, args, isStatic);
+};
+
+struct PublicInputs {
+    // Nothing yet.
+    std::vector<FF> dummy;
+
+    static PublicInputs from(const std::vector<uint8_t>& data);
+    std::vector<std::vector<FF>> to_columns() const { return { dummy }; }
+    bool operator==(const PublicInputs& other) const = default;
+
+    MSGPACK_FIELDS(dummy);
+};
+
+struct AvmProvingInputs {
+    std::vector<PublicExecutionRequest> enqueuedCalls;
+    PublicInputs publicInputs;
+    ExecutionHints hints;
+
+    static AvmProvingInputs from(const std::vector<uint8_t>& data);
+    bool operator==(const AvmProvingInputs& other) const = default;
+
+    MSGPACK_FIELDS(enqueuedCalls, publicInputs, hints);
+};
+
+} // namespace bb::avm2
\ No newline at end of file
diff --git a/barretenberg/cpp/src/barretenberg/vm2/common/avm_inputs.test.cpp b/barretenberg/cpp/src/barretenberg/vm2/common/avm_inputs.test.cpp
new file mode 100644
index 00000000000..46911c0d683
--- /dev/null
+++ b/barretenberg/cpp/src/barretenberg/vm2/common/avm_inputs.test.cpp
@@ -0,0 +1,122 @@
+#include <gmock/gmock.h>
+#include <gtest/gtest.h>
+
+#include "barretenberg/vm2/common/avm_inputs.hpp"
+
+#include <cstdint>
+
+#include "barretenberg/bb/file_io.hpp"
+#include "barretenberg/vm2/common/aztec_types.hpp"
+#include "barretenberg/vm2/common/field.hpp"
+
+namespace bb::avm2 {
+namespace {
+
+std::vector<uint8_t> string_to_buffer(const std::string& str)
+{
+    return { str.begin(), str.end() };
+}
+
+TEST(AvmInputsTest, Deserialization)
+{
+    // cwd is expected to be barretenberg/cpp/build.
+    auto data = read_file("../src/barretenberg/vm2/common/avm_inputs.testdata.bin");
+    auto inputs = AvmProvingInputs::from(data);
+
+    AvmProvingInputs expected = {
+        .enqueuedCalls = {
+            {
+                .contractAddress = AztecAddress(0x123456),
+                .sender = AztecAddress(0x000010),
+                .args = {
+                    FF(0x111111), FF(0x222222), FF(0x333333),
+                },
+                .isStatic = false,
+            },
+            {
+                .contractAddress = AztecAddress(0x654321),
+                .sender = AztecAddress(0x000020),
+                .args = {
+                    FF(0x222222), FF(0x333333), FF(0x444444),
+                },
+                .isStatic = true,
+            },
+        },
+        .publicInputs = {
+            .dummy = {}
+        },
+        .hints = {
+            .contractInstances = {
+                {
+                    .address = AztecAddress(0x123456),
+                    .exists = true,
+                    .salt = FF(0xdeadbeef),
+                    .deployer = AztecAddress(0x000010),
+                    .contractClassId = ContractClassId(0x41181337),
+                    .initializationHash = FF(0x111111),
+                    .publicKeys = {
+                        .masterNullifierPublicKey = AffinePoint(
+                            FF("0x16421839f863564fbe9035338aa8ef7bda077d04b178b1353e781cac7e83d155"),
+                            FF("0x2b6a73d9c017111f8223c81980e9ad167e1dec57d3f2fa649b11355b70b5f086")),
+                        .masterIncomingViewingPublicKey = AffinePoint(
+                            FF("0x047d001b3998ca8ae785c6a06870d4b56335f510743f3e68fda159fe60f22582"),
+                            FF("0x1500cab14a6ea87cb26389431b0739bcf4b159d0e25b2c3a1cab94944254dcc4")),
+                        .masterOutgoingViewingPublicKey = AffinePoint(
+                            FF("0x03e11607d5adc8ce958646d7ef7cdcd8f4f48e0af20eca0ab4b07e8d1fc23dee"),
+                            FF("0x1c89d3deed018ba1dbc81b9dfe265b367dbcf383f7e4374ba5c749028ba97158")),
+                        .masterTaggingPublicKey = AffinePoint(
+                            FF("0x268630a713908316c9af34f1d0f7f6e9dd80311b4973e2025bd86669a9955b23"),
+                            FF("0x227bca4c20b3000895ddb7f69d0cb375247d6ef49beffc54a8d264731d52fd24")),
+                    },
+                },
+                {
+                    .address = AztecAddress(0x654321),
+                    .exists = false,
+                    .salt = FF(0xdead0000),
+                    .deployer = AztecAddress(0x000020),
+                    .contractClassId = ContractClassId(0x51181337),
+                    .initializationHash = FF(0x222222),
+                    .publicKeys = {
+                        .masterNullifierPublicKey = AffinePoint(
+                            FF("0x16421839f863564fbe9035338aa8ef7bda077d04b178b1353e781cac7e83d155"),
+                            FF("0x2b6a73d9c017111f8223c81980e9ad167e1dec57d3f2fa649b11355b70b5f086")),
+                        .masterIncomingViewingPublicKey = AffinePoint(
+                            FF("0x047d001b3998ca8ae785c6a06870d4b56335f510743f3e68fda159fe60f22582"),
+                            FF("0x1500cab14a6ea87cb26389431b0739bcf4b159d0e25b2c3a1cab94944254dcc4")),
+                        .masterOutgoingViewingPublicKey = AffinePoint(
+                            FF("0x03e11607d5adc8ce958646d7ef7cdcd8f4f48e0af20eca0ab4b07e8d1fc23dee"),
+                            FF("0x1c89d3deed018ba1dbc81b9dfe265b367dbcf383f7e4374ba5c749028ba97158")),
+                        .masterTaggingPublicKey = AffinePoint(
+                            FF("0x268630a713908316c9af34f1d0f7f6e9dd80311b4973e2025bd86669a9955b23"),
+                            FF("0x227bca4c20b3000895ddb7f69d0cb375247d6ef49beffc54a8d264731d52fd24")),
+                    },
+                },
+            },
+            .contractClasses = {
+                {
+                    .artifactHash = FF(0xdeadbeef),
+                    .privateFunctionsRoot = FF(0x111111),
+                    .publicBytecodeCommitment = FF(0x222222),
+                    .packedBytecode = string_to_buffer("firstbuffer"),
+                },
+                {
+                    .artifactHash = FF(0xdead0000),
+                    .privateFunctionsRoot = FF(0x222222),
+                    .publicBytecodeCommitment = FF(0x333333),
+                    .packedBytecode = string_to_buffer("secondbuffer"),
+                },
+            },
+        },
+    };
+
+    // Sorry but if this fails you'll get no useful information!
+    // Limitations of GTEST.
+    EXPECT_EQ(inputs.enqueuedCalls, expected.enqueuedCalls);
+    EXPECT_EQ(inputs.publicInputs, expected.publicInputs);
+    EXPECT_EQ(inputs.hints.contractClasses, expected.hints.contractClasses);
+    EXPECT_EQ(inputs.hints.contractInstances, expected.hints.contractInstances);
+    EXPECT_EQ(inputs, expected); // Catch all.
+}
+
+} // namespace
+} // namespace bb::avm2
\ No newline at end of file
diff --git a/barretenberg/cpp/src/barretenberg/vm2/common/avm_inputs.testdata.bin b/barretenberg/cpp/src/barretenberg/vm2/common/avm_inputs.testdata.bin
new file mode 100644
index 00000000000..18ed5069e32
Binary files /dev/null and b/barretenberg/cpp/src/barretenberg/vm2/common/avm_inputs.testdata.bin differ
diff --git a/barretenberg/cpp/src/barretenberg/vm2/common/aztec_types.hpp b/barretenberg/cpp/src/barretenberg/vm2/common/aztec_types.hpp
new file mode 100644
index 00000000000..36603ef4e7a
--- /dev/null
+++ b/barretenberg/cpp/src/barretenberg/vm2/common/aztec_types.hpp
@@ -0,0 +1,37 @@
+#pragma once
+
+#include <cstdint>
+#include <vector>
+
+#include "barretenberg/vm2/common/field.hpp"
+
+namespace bb::avm2 {
+
+using AztecAddress = FF;
+using ContractClassId = FF;
+using AffinePoint = grumpkin::g1::affine_element;
+
+struct PublicKeys {
+    AffinePoint nullifier_key;
+    AffinePoint incoming_viewing_key;
+    AffinePoint outgoing_viewing_key;
+    AffinePoint tagging_key;
+};
+
+struct ContractInstance {
+    AztecAddress address;
+    FF salt;
+    AztecAddress deployer_addr;
+    ContractClassId contract_class_id;
+    FF initialisation_hash;
+    PublicKeys public_keys;
+};
+
+struct ContractClass {
+    FF artifact_hash;
+    FF private_function_root;
+    FF public_bytecode_commitment;
+    std::vector<uint8_t> packed_bytecode;
+};
+
+} // namespace bb::avm2
\ No newline at end of file
diff --git a/barretenberg/cpp/src/barretenberg/vm2/common/constants.hpp b/barretenberg/cpp/src/barretenberg/vm2/common/constants.hpp
new file mode 100644
index 00000000000..c1d1b56bfac
--- /dev/null
+++ b/barretenberg/cpp/src/barretenberg/vm2/common/constants.hpp
@@ -0,0 +1,9 @@
+#pragma once
+
+#include <cstdint>
+
+namespace bb::avm2 {
+
+constexpr uint32_t CIRCUIT_SUBGROUP_SIZE = 1 << 21;
+
+} // namespace bb::avm2
\ No newline at end of file
diff --git a/barretenberg/cpp/src/barretenberg/vm2/common/field.hpp b/barretenberg/cpp/src/barretenberg/vm2/common/field.hpp
new file mode 100644
index 00000000000..8752676f446
--- /dev/null
+++ b/barretenberg/cpp/src/barretenberg/vm2/common/field.hpp
@@ -0,0 +1,11 @@
+// WARNING: Use this field definition only for simulation and tracegen.
+// In the constraints we need to use the Flavor so that it works well with recursion.
+#pragma once
+
+#include "barretenberg/vm2/generated/flavor_settings.hpp"
+
+namespace bb::avm2 {
+
+using FF = AvmFlavorSettings::FF;
+
+} // namespace bb::avm2
\ No newline at end of file
diff --git a/barretenberg/cpp/src/barretenberg/vm2/common/instruction_spec.cpp b/barretenberg/cpp/src/barretenberg/vm2/common/instruction_spec.cpp
new file mode 100644
index 00000000000..0f29b795259
--- /dev/null
+++ b/barretenberg/cpp/src/barretenberg/vm2/common/instruction_spec.cpp
@@ -0,0 +1,41 @@
+#include "barretenberg/vm2/common/instruction_spec.hpp"
+
+#include "barretenberg/vm/aztec_constants.hpp" // Move over.
+#include "barretenberg/vm2/common/opcodes.hpp"
+
+namespace bb::avm2 {
+
+const std::unordered_map<ExecutionOpCode, InstructionSpec> INSTRUCTION_SPEC = {
+    { ExecutionOpCode::ADD,
+      { .num_addresses = 3, .gas_cost = { .base_l2 = AVM_ADD_BASE_L2_GAS, .base_da = 0, .dyn_l2 = 0, .dyn_da = 0 } } },
+    { ExecutionOpCode::SET,
+      { .num_addresses = 1, .gas_cost = { .base_l2 = AVM_SET_BASE_L2_GAS, .base_da = 0, .dyn_l2 = 0, .dyn_da = 0 } } },
+    { ExecutionOpCode::MOV,
+      { .num_addresses = 2, .gas_cost = { .base_l2 = AVM_MOV_BASE_L2_GAS, .base_da = 0, .dyn_l2 = 0, .dyn_da = 0 } } },
+    { ExecutionOpCode::CALL,
+      { .num_addresses = 5,
+        .gas_cost = { .base_l2 = AVM_CALL_BASE_L2_GAS, .base_da = 0, .dyn_l2 = AVM_CALL_DYN_L2_GAS, .dyn_da = 0 } } },
+    { ExecutionOpCode::RETURN,
+      { .num_addresses = 2,
+        .gas_cost = { .base_l2 = AVM_RETURN_BASE_L2_GAS,
+                      .base_da = 0,
+                      .dyn_l2 = AVM_RETURN_DYN_L2_GAS,
+                      .dyn_da = 0 } } },
+    { ExecutionOpCode::JUMP,
+      { .num_addresses = 0, .gas_cost = { .base_l2 = AVM_JUMP_BASE_L2_GAS, .base_da = 0, .dyn_l2 = 0, .dyn_da = 0 } } },
+    { ExecutionOpCode::JUMPI,
+      { .num_addresses = 1,
+        .gas_cost = { .base_l2 = AVM_JUMPI_BASE_L2_GAS, .base_da = 0, .dyn_l2 = 0, .dyn_da = 0 } } },
+};
+
+const std::unordered_map<WireOpCode, ExecutionOpCode> OPCODE_MAP = {
+    { WireOpCode::ADD_8, ExecutionOpCode::ADD },    { WireOpCode::ADD_16, ExecutionOpCode::ADD },
+    { WireOpCode::CALL, ExecutionOpCode::CALL },    { WireOpCode::RETURN, ExecutionOpCode::RETURN },
+    { WireOpCode::JUMP_32, ExecutionOpCode::JUMP }, { WireOpCode::JUMPI_32, ExecutionOpCode::JUMPI },
+    { WireOpCode::SET_8, ExecutionOpCode::SET },    { WireOpCode::SET_16, ExecutionOpCode::SET },
+    { WireOpCode::SET_32, ExecutionOpCode::SET },   { WireOpCode::SET_64, ExecutionOpCode::SET },
+    { WireOpCode::SET_128, ExecutionOpCode::SET },  { WireOpCode::SET_FF, ExecutionOpCode::SET },
+    { WireOpCode::MOV_8, ExecutionOpCode::MOV },    { WireOpCode::MOV_16, ExecutionOpCode::MOV },
+};
+
+} // namespace bb::avm2
\ No newline at end of file
diff --git a/barretenberg/cpp/src/barretenberg/vm2/common/instruction_spec.hpp b/barretenberg/cpp/src/barretenberg/vm2/common/instruction_spec.hpp
new file mode 100644
index 00000000000..80f3b4e56ea
--- /dev/null
+++ b/barretenberg/cpp/src/barretenberg/vm2/common/instruction_spec.hpp
@@ -0,0 +1,31 @@
+#pragma once
+
+#include <cstdint>
+#include <unordered_map>
+
+#include "barretenberg/vm2/common/opcodes.hpp"
+
+namespace bb::avm2 {
+
+struct InstructionSpec {
+    struct GasInfo {
+        uint16_t base_l2;
+        uint16_t base_da;
+        uint16_t dyn_l2;
+        uint16_t dyn_da;
+
+        bool operator==(const GasInfo& other) const = default;
+    };
+
+    uint8_t num_addresses;
+    GasInfo gas_cost;
+
+    bool operator==(const InstructionSpec& other) const = default;
+};
+
+// These are "extern" because the definition is in a different file.
+// Note: in the circuit, we can choose to merge both tables.
+extern const std::unordered_map<ExecutionOpCode, InstructionSpec> INSTRUCTION_SPEC;
+extern const std::unordered_map<WireOpCode, ExecutionOpCode> OPCODE_MAP;
+
+} // namespace bb::avm2
\ No newline at end of file
diff --git a/barretenberg/cpp/src/barretenberg/vm2/common/map.hpp b/barretenberg/cpp/src/barretenberg/vm2/common/map.hpp
new file mode 100644
index 00000000000..0f0d12514ec
--- /dev/null
+++ b/barretenberg/cpp/src/barretenberg/vm2/common/map.hpp
@@ -0,0 +1,19 @@
+#pragma once
+
+#include "barretenberg/vm2/common/ankerl_map.hpp"
+
+namespace bb::avm2 {
+
+// Who would've guessed that std::unordered_map is slow?
+// https://news.ycombinator.com/item?id=36521291
+//
+// We use an alternative single-header implementation that is faster and more memory efficient.
+// https://github.com/martinus/unordered_dense
+// https://martin.ankerl.com/2019/04/01/hashmap-benchmarks-01-overview/
+// https://github.com/martinus/robin-hood-hashing is archived and recommends ankerl::unordered_dense.
+// In our benchmarks this map is at least 25% faster for insertion and 2x faster for visits.
+template <class Key, class T> using unordered_flat_map = ::ankerl::unordered_dense::map<Key, T>;
+// Note: if we eventually want to have lower memory usage at the cost of some speed,
+// we can use ::ankerl::unordered_dense::segmented_map instead.
+
+} // namespace bb::avm2
\ No newline at end of file
diff --git a/barretenberg/cpp/src/barretenberg/vm2/common/memory_types.hpp b/barretenberg/cpp/src/barretenberg/vm2/common/memory_types.hpp
new file mode 100644
index 00000000000..3b99ddef135
--- /dev/null
+++ b/barretenberg/cpp/src/barretenberg/vm2/common/memory_types.hpp
@@ -0,0 +1,23 @@
+#pragma once
+
+#include <cstdint>
+
+#include "barretenberg/vm2/common/field.hpp"
+
+namespace bb::avm2 {
+
+enum class MemoryTag {
+    FF,
+    U1,
+    U8,
+    U16,
+    U32,
+    U64,
+    U128,
+};
+
+using MemoryAddress = uint32_t;
+using MemoryValue = FF;
+constexpr auto MemoryAddressTag = MemoryTag::U32;
+
+} // namespace bb::avm2
\ No newline at end of file
diff --git a/barretenberg/cpp/src/barretenberg/vm2/common/opcodes.cpp b/barretenberg/cpp/src/barretenberg/vm2/common/opcodes.cpp
new file mode 100644
index 00000000000..d8d89162950
--- /dev/null
+++ b/barretenberg/cpp/src/barretenberg/vm2/common/opcodes.cpp
@@ -0,0 +1,250 @@
+#include "barretenberg/vm2/common/opcodes.hpp"
+
+#include <ostream>
+#include <string>
+
+namespace bb::avm2 {
+
+std::ostream& operator<<(std::ostream& os, const WireOpCode& op)
+{
+    switch (op) {
+    case WireOpCode::ADD_8:
+        os << "ADD_8";
+        break;
+    case WireOpCode::ADD_16:
+        os << "ADD_16";
+        break;
+    case WireOpCode::SUB_8:
+        os << "SUB_8";
+        break;
+    case WireOpCode::SUB_16:
+        os << "SUB_16";
+        break;
+    case WireOpCode::MUL_8:
+        os << "MUL_8";
+        break;
+    case WireOpCode::MUL_16:
+        os << "MUL_16";
+        break;
+    case WireOpCode::DIV_8:
+        os << "DIV_8";
+        break;
+    case WireOpCode::DIV_16:
+        os << "DIV_16";
+        break;
+    case WireOpCode::FDIV_8:
+        os << "FDIV_8";
+        break;
+    case WireOpCode::FDIV_16:
+        os << "FDIV_16";
+        break;
+    case WireOpCode::EQ_8:
+        os << "EQ_8";
+        break;
+    case WireOpCode::EQ_16:
+        os << "EQ_16";
+        break;
+    case WireOpCode::LT_8:
+        os << "LT_8";
+        break;
+    case WireOpCode::LT_16:
+        os << "LT_16";
+        break;
+    case WireOpCode::LTE_8:
+        os << "LTE_8";
+        break;
+    case WireOpCode::LTE_16:
+        os << "LTE_16";
+        break;
+    case WireOpCode::AND_8:
+        os << "AND_8";
+        break;
+    case WireOpCode::AND_16:
+        os << "AND_16";
+        break;
+    case WireOpCode::OR_8:
+        os << "OR_8";
+        break;
+    case WireOpCode::OR_16:
+        os << "OR_16";
+        break;
+    case WireOpCode::XOR_8:
+        os << "XOR_8";
+        break;
+    case WireOpCode::XOR_16:
+        os << "XOR_16";
+        break;
+    case WireOpCode::NOT_8:
+        os << "NOT_8";
+        break;
+    case WireOpCode::NOT_16:
+        os << "NOT_16";
+        break;
+    case WireOpCode::SHL_8:
+        os << "SHL_8";
+        break;
+    case WireOpCode::SHL_16:
+        os << "SHL_16";
+        break;
+    case WireOpCode::SHR_8:
+        os << "SHR_8";
+        break;
+    case WireOpCode::SHR_16:
+        os << "SHR_16";
+        break;
+    case WireOpCode::CAST_8:
+        os << "CAST_8";
+        break;
+    case WireOpCode::CAST_16:
+        os << "CAST_16";
+        break;
+    case WireOpCode::GETENVVAR_16:
+        os << "GETENVVAR_16";
+        break;
+    case WireOpCode::CALLDATACOPY:
+        os << "CALLDATACOPY";
+        break;
+    case WireOpCode::RETURNDATASIZE:
+        os << "RETURNDATASIZE";
+        break;
+    case WireOpCode::RETURNDATACOPY:
+        os << "RETURNDATACOPY";
+        break;
+    case WireOpCode::JUMP_32:
+        os << "JUMP_32";
+        break;
+    case WireOpCode::JUMPI_32:
+        os << "JUMPI_32";
+        break;
+    case WireOpCode::INTERNALCALL:
+        os << "INTERNALCALL";
+        break;
+    case WireOpCode::INTERNALRETURN:
+        os << "INTERNALRETURN";
+        break;
+    case WireOpCode::SET_8:
+        os << "SET_8";
+        break;
+    case WireOpCode::SET_16:
+        os << "SET_16";
+        break;
+    case WireOpCode::SET_32:
+        os << "SET_32";
+        break;
+    case WireOpCode::SET_64:
+        os << "SET_64";
+        break;
+    case WireOpCode::SET_128:
+        os << "SET_128";
+        break;
+    case WireOpCode::SET_FF:
+        os << "SET_FF";
+        break;
+    case WireOpCode::MOV_8:
+        os << "MOV_8";
+        break;
+    case WireOpCode::MOV_16:
+        os << "MOV_16";
+        break;
+    case WireOpCode::SLOAD:
+        os << "SLOAD";
+        break;
+    case WireOpCode::SSTORE:
+        os << "SSTORE";
+        break;
+    case WireOpCode::NOTEHASHEXISTS:
+        os << "NOTEHASHEXISTS";
+        break;
+    case WireOpCode::EMITNOTEHASH:
+        os << "EMITNOTEHASH";
+        break;
+    case WireOpCode::NULLIFIEREXISTS:
+        os << "NULLIFIEREXISTS";
+        break;
+    case WireOpCode::EMITNULLIFIER:
+        os << "EMITNULLIFIER";
+        break;
+    case WireOpCode::L1TOL2MSGEXISTS:
+        os << "L1TOL2MSGEXISTS";
+        break;
+    case WireOpCode::GETCONTRACTINSTANCE:
+        os << "GETCONTRACTINSTANCE";
+        break;
+    case WireOpCode::EMITUNENCRYPTEDLOG:
+        os << "EMITUNENCRYPTEDLOG";
+        break;
+    case WireOpCode::SENDL2TOL1MSG:
+        os << "SENDL2TOL1MSG";
+        break;
+    case WireOpCode::CALL:
+        os << "CALL";
+        break;
+    case WireOpCode::STATICCALL:
+        os << "STATICCALL";
+        break;
+    case WireOpCode::RETURN:
+        os << "RETURN";
+        break;
+    case WireOpCode::REVERT_8:
+        os << "REVERT_8";
+        break;
+    case WireOpCode::REVERT_16:
+        os << "REVERT_16";
+        break;
+    case WireOpCode::DEBUGLOG:
+        os << "DEBUGLOG";
+        break;
+    case WireOpCode::POSEIDON2PERM:
+        os << "POSEIDON2PERM";
+        break;
+    case WireOpCode::SHA256COMPRESSION:
+        os << "SHA256COMPRESSION";
+        break;
+    case WireOpCode::KECCAKF1600:
+        os << "KECCAKF1600";
+        break;
+    case WireOpCode::ECADD:
+        os << "ECADD";
+        break;
+    case WireOpCode::MSM:
+        os << "MSM";
+        break;
+    case WireOpCode::TORADIXBE:
+        os << "TORADIXBE";
+        break;
+    case WireOpCode::LAST_OPCODE_SENTINEL:
+        os << "LAST_OPCODE_SENTINEL";
+        break;
+    }
+    return os;
+}
+
+std::ostream& operator<<(std::ostream& os, const ExecutionOpCode& op)
+{
+    switch (op) {
+    case ExecutionOpCode::ADD:
+        os << "ADD";
+        break;
+    case ExecutionOpCode::SET:
+        os << "SET";
+        break;
+    case ExecutionOpCode::MOV:
+        os << "MOV";
+        break;
+    case ExecutionOpCode::CALL:
+        os << "CALL";
+        break;
+    case ExecutionOpCode::JUMP:
+        os << "JUMP";
+        break;
+    case ExecutionOpCode::JUMPI:
+        os << "JUMPI";
+        break;
+    case ExecutionOpCode::RETURN:
+        os << "RETURN";
+        break;
+    }
+    return os;
+}
+
+} // namespace bb::avm2
\ No newline at end of file
diff --git a/barretenberg/cpp/src/barretenberg/vm2/common/opcodes.hpp b/barretenberg/cpp/src/barretenberg/vm2/common/opcodes.hpp
new file mode 100644
index 00000000000..77a0648d838
--- /dev/null
+++ b/barretenberg/cpp/src/barretenberg/vm2/common/opcodes.hpp
@@ -0,0 +1,118 @@
+#pragma once
+
+#include <ostream>
+#include <string>
+
+namespace bb::avm2 {
+
+enum class WireOpCode {
+    // Compute
+    ADD_8,
+    ADD_16,
+    SUB_8,
+    SUB_16,
+    MUL_8,
+    MUL_16,
+    DIV_8,
+    DIV_16,
+    FDIV_8,
+    FDIV_16,
+    EQ_8,
+    EQ_16,
+    LT_8,
+    LT_16,
+    LTE_8,
+    LTE_16,
+    AND_8,
+    AND_16,
+    OR_8,
+    OR_16,
+    XOR_8,
+    XOR_16,
+    NOT_8,
+    NOT_16,
+    SHL_8,
+    SHL_16,
+    SHR_8,
+    SHR_16,
+    CAST_8,
+    CAST_16,
+
+    // Execution Environment
+    GETENVVAR_16,
+    // Execution Environment - Calldata
+    CALLDATACOPY,
+    RETURNDATASIZE,
+    RETURNDATACOPY,
+
+    // Machine State
+    // Machine State - Internal Control Flow
+    JUMP_32,
+    JUMPI_32,
+    INTERNALCALL,
+    INTERNALRETURN,
+    // Machine State - Memory
+    SET_8,
+    SET_16,
+    SET_32,
+    SET_64,
+    SET_128,
+    SET_FF,
+    MOV_8,
+    MOV_16,
+
+    // World State
+    SLOAD,           // Public Storage
+    SSTORE,          // Public Storage
+    NOTEHASHEXISTS,  // Notes & Nullifiers
+    EMITNOTEHASH,    // Notes & Nullifiers
+    NULLIFIEREXISTS, // Notes & Nullifiers
+    EMITNULLIFIER,   // Notes & Nullifiers
+    L1TOL2MSGEXISTS, // Messages
+    GETCONTRACTINSTANCE,
+
+    // Accrued Substate
+    EMITUNENCRYPTEDLOG,
+    SENDL2TOL1MSG, // Messages
+
+    // Control Flow - Contract Calls
+    CALL,
+    STATICCALL,
+    RETURN,
+    REVERT_8,
+    REVERT_16,
+
+    // Misc
+    DEBUGLOG,
+
+    // Gadgets
+    POSEIDON2PERM,
+    SHA256COMPRESSION,
+    KECCAKF1600,
+    ECADD,
+    MSM,
+    // Conversions
+    TORADIXBE,
+
+    // Sentinel
+    LAST_OPCODE_SENTINEL,
+};
+
+std::ostream& operator<<(std::ostream& os, const WireOpCode& op);
+
+// List of opcodes that can be executed.
+// This is like WireOpCode but without the variants.
+// Order doesn't really matter as long as it's in sync with the circuit.
+enum class ExecutionOpCode {
+    ADD,
+    SET,
+    MOV,
+    CALL,
+    JUMP,
+    JUMPI,
+    RETURN,
+};
+
+std::ostream& operator<<(std::ostream& os, const ExecutionOpCode& op);
+
+} // namespace bb::avm2
\ No newline at end of file
diff --git a/barretenberg/cpp/src/barretenberg/vm2/constraining/README.md b/barretenberg/cpp/src/barretenberg/vm2/constraining/README.md
new file mode 100644
index 00000000000..71d29cfb0e5
--- /dev/null
+++ b/barretenberg/cpp/src/barretenberg/vm2/constraining/README.md
@@ -0,0 +1,8 @@
+# Some possible improvements
+
+Notes for self.
+
+## Prover
+
+- `commit_sparse` could avoid going through all the rows if we could provide it the set of rows where non-zero elements exist... and the trace object knows that! However, the improvement might not be amazing if `commit_sparse` already only considers the size of the polynomial (which it should) unless the column is mostly 0s and a non-zero elem at the end. Benchmarking should be done before trying this optimization.
+- Along the same line of committing, we now use `commit_sparse` which has both performance (likely not much) and memory (might be up to 2x) overhead over just using `commit`. Given that we now use tight polynomials, it might make sense to use just `commit` UNLESS, again, the column is mostly 0s and a non-zero elem at the end. HOWEVER, we could cheaply decide this on the fly using the trace object which can keep the number of non-zero elems, and we use `commit_sparse` if below certain % threshold.
diff --git a/barretenberg/cpp/src/barretenberg/vm2/constraining/check_circuit.cpp b/barretenberg/cpp/src/barretenberg/vm2/constraining/check_circuit.cpp
new file mode 100644
index 00000000000..d1e1b08da53
--- /dev/null
+++ b/barretenberg/cpp/src/barretenberg/vm2/constraining/check_circuit.cpp
@@ -0,0 +1,79 @@
+#include "barretenberg/vm2/constraining/check_circuit.hpp"
+
+#include <array>
+#include <bits/utility.h>
+#include <functional>
+#include <span>
+#include <stdexcept>
+
+#include "barretenberg/common/constexpr_utils.hpp"
+#include "barretenberg/common/log.hpp"
+#include "barretenberg/common/thread.hpp"
+#include "barretenberg/honk/proof_system/logderivative_library.hpp"
+#include "barretenberg/relations/relation_parameters.hpp"
+
+namespace bb::avm2::constraining {
+
+void run_check_circuit(AvmFlavor::ProverPolynomials& polys, size_t num_rows)
+{
+    bb::RelationParameters<AvmFlavor::FF> params = {
+        .eta = 0,
+        .beta = AvmFlavor::FF::random_element(),
+        .gamma = AvmFlavor::FF::random_element(),
+        .public_input_delta = 0,
+        .lookup_grand_product_delta = 0,
+        .beta_sqr = 0,
+        .beta_cube = 0,
+        .eccvm_set_permutation_delta = 0,
+    };
+
+    // Checks that we will run.
+    std::vector<std::function<void()>> checks;
+
+    // Add relation checks.
+    bb::constexpr_for<0, std::tuple_size_v<typename AvmFlavor::MainRelations>, 1>([&]<size_t i>() {
+        using Relation = std::tuple_element_t<i, typename AvmFlavor::MainRelations>;
+        checks.push_back([&]() {
+            typename Relation::SumcheckArrayOfValuesOverSubrelations result{};
+
+            for (size_t r = 0; r < num_rows; ++r) {
+                Relation::accumulate(result, polys.get_row(r), {}, 1);
+                for (size_t j = 0; j < result.size(); ++j) {
+                    if (!result[j].is_zero()) {
+                        throw std::runtime_error(format("Relation ",
+                                                        Relation::NAME,
+                                                        ", subrelation ",
+                                                        Relation::get_subrelation_label(j),
+                                                        " failed at row ",
+                                                        r));
+                    }
+                }
+            }
+        });
+    });
+
+    // Add calculation of logderivatives and lookup/permutation checks.
+    bb::constexpr_for<0, std::tuple_size_v<typename AvmFlavor::LookupRelations>, 1>([&]<size_t i>() {
+        using Relation = std::tuple_element_t<i, typename AvmFlavor::LookupRelations>;
+        checks.push_back([&, num_rows]() {
+            // Compute logderivs.
+            bb::compute_logderivative_inverse<AvmFlavor, Relation>(polys, params, num_rows);
+
+            // Check the logderivative relation
+            typename Relation::SumcheckArrayOfValuesOverSubrelations lookup_result{};
+            for (size_t r = 0; r < num_rows; ++r) {
+                Relation::accumulate(lookup_result, polys.get_row(r), params, 1);
+            }
+            for (auto r : lookup_result) {
+                if (!r.is_zero()) {
+                    throw std::runtime_error(format("Lookup ", Relation::NAME, " failed."));
+                }
+            }
+        });
+    });
+
+    // Do it!
+    bb::parallel_for(checks.size(), [&](size_t i) { checks[i](); });
+}
+
+} // namespace bb::avm2::constraining
\ No newline at end of file
diff --git a/barretenberg/cpp/src/barretenberg/vm2/constraining/check_circuit.hpp b/barretenberg/cpp/src/barretenberg/vm2/constraining/check_circuit.hpp
new file mode 100644
index 00000000000..109a23c211f
--- /dev/null
+++ b/barretenberg/cpp/src/barretenberg/vm2/constraining/check_circuit.hpp
@@ -0,0 +1,13 @@
+#pragma once
+
+#include <cstdint>
+
+#include "barretenberg/vm2/generated/flavor.hpp"
+
+namespace bb::avm2::constraining {
+
+// This is a version of check circuit that runs on the prover polynomials.
+// Better versions could be done, but since this is for debugging only, it is enough for now.
+void run_check_circuit(AvmFlavor::ProverPolynomials& polys, size_t num_rows);
+
+} // namespace bb::avm2::constraining
\ No newline at end of file
diff --git a/barretenberg/cpp/src/barretenberg/vm2/constraining/relations/alu.test.cpp b/barretenberg/cpp/src/barretenberg/vm2/constraining/relations/alu.test.cpp
new file mode 100644
index 00000000000..bf1dd5707a5
--- /dev/null
+++ b/barretenberg/cpp/src/barretenberg/vm2/constraining/relations/alu.test.cpp
@@ -0,0 +1,56 @@
+#include <gmock/gmock.h>
+#include <gtest/gtest.h>
+
+#include <cstdint>
+
+#include "barretenberg/vm2/constraining/testing/check_relation.hpp"
+#include "barretenberg/vm2/generated/flavor_settings.hpp"
+#include "barretenberg/vm2/generated/relations/alu.hpp"
+#include "barretenberg/vm2/testing/macros.hpp"
+#include "barretenberg/vm2/tracegen/test_trace_container.hpp"
+
+namespace bb::avm2::constraining {
+namespace {
+
+using tracegen::TestTraceContainer;
+using FF = AvmFlavorSettings::FF;
+using C = Column;
+using alu = bb::avm2::alu<FF>;
+
+TEST(AvmConstrainingTest, AluPositive)
+{
+    TestTraceContainer::RowTraceContainer trace = {
+        { .alu_ia = 1, .alu_ib = 2, .alu_ic = 3, .alu_sel_op_add = 1 },
+    };
+
+    check_relation<alu>(trace);
+}
+
+TEST(AvmConstrainingTest, AluNegativeBoolean)
+{
+    TestTraceContainer::RowTraceContainer trace = {
+        // Negative test, this should be a boolean only!
+        { .alu_sel_op_add = 23 },
+    };
+
+    EXPECT_THROW_WITH_MESSAGE(check_relation<alu>(trace, alu::SR_SEL_ADD_BINARY), "SEL_ADD_BINARY");
+}
+
+TEST(AvmConstrainingTest, AluNegativeAdd)
+{
+    TestTraceContainer::RowTraceContainer trace = {
+        {
+            // Wrong ADD.
+            .alu_ia = 1,
+            .alu_ib = 1,
+            .alu_ic = 0,
+            // Observe that I'm making subrelation SEL_ADD_BINARY fail too, but we'll only check subrelation ALU_ADD!
+            .alu_sel_op_add = 1,
+        },
+    };
+
+    EXPECT_THROW_WITH_MESSAGE(check_relation<alu>(trace, alu::SR_ALU_ADD), "ALU_ADD");
+}
+
+} // namespace
+} // namespace bb::avm2::constraining
\ No newline at end of file
diff --git a/barretenberg/cpp/src/barretenberg/vm2/constraining/relations/execution.test.cpp b/barretenberg/cpp/src/barretenberg/vm2/constraining/relations/execution.test.cpp
new file mode 100644
index 00000000000..13cfaec107a
--- /dev/null
+++ b/barretenberg/cpp/src/barretenberg/vm2/constraining/relations/execution.test.cpp
@@ -0,0 +1,108 @@
+#include <gmock/gmock.h>
+#include <gtest/gtest.h>
+
+#include <cstdint>
+
+#include "barretenberg/vm2/constraining/testing/check_relation.hpp"
+#include "barretenberg/vm2/generated/flavor_settings.hpp"
+#include "barretenberg/vm2/generated/relations/execution.hpp"
+#include "barretenberg/vm2/testing/macros.hpp"
+#include "barretenberg/vm2/tracegen/test_trace_container.hpp"
+
+namespace bb::avm2::constraining {
+namespace {
+
+using tracegen::TestTraceContainer;
+using FF = AvmFlavorSettings::FF;
+using C = Column;
+using execution = bb::avm2::execution<FF>;
+
+TEST(ExecutionConstrainingTest, AllPositive)
+{
+    // clang-format off
+    TestTraceContainer trace({
+         {{ C::execution_sel, 1 }, {C::execution_clk, 0}, { C::execution_pc, 0 }},
+        {{ C::execution_sel, 1 }, {C::execution_clk, 1}, { C::execution_pc, 20 }, { C::execution_last, 1 }}
+    });
+    // clang-format on
+
+    check_relation<execution>(trace.as_rows());
+}
+
+TEST(ExecutionConstrainingTest, ContinuityPositive)
+{
+    // clang-format off
+    TestTraceContainer trace({
+        {{ C::precomputed_first_row, 1 }},
+        {{ C::execution_sel, 1 }},
+        {{ C::execution_sel, 1 }},
+        {{ C::execution_sel, 1 }, {C::execution_last, 1}},
+    });
+    // clang-format on
+
+    check_relation<execution>(trace.as_rows(), execution::SR_TRACE_CONTINUITY_1, execution::SR_TRACE_CONTINUITY_2);
+}
+
+TEST(ExecutionConstrainingTest, ContinuityBrokenFirstRow)
+{
+    // clang-format off
+    TestTraceContainer trace({
+        {{ C::execution_sel, 0 }},  // End of trace!
+        {{ C::execution_sel, 1 }},
+        {{ C::execution_sel, 1 }},
+        {{ C::execution_sel, 1 }, {C::execution_last, 1}},
+    });
+    // clang-format on
+
+    EXPECT_THROW_WITH_MESSAGE(check_relation<execution>(trace.as_rows(), execution::SR_TRACE_CONTINUITY_2),
+                              "TRACE_CONTINUITY_2");
+}
+
+TEST(ExecutionConstrainingTest, ContinuityBrokenInMiddle)
+{
+    // clang-format off
+    TestTraceContainer trace({
+        {{ C::execution_sel, 1 }},
+        {{ C::execution_sel, 0 }},  // End of trace!
+        {{ C::execution_sel, 1 }},
+        {{ C::execution_sel, 1 }, {C::execution_last, 1}},
+    });
+    // clang-format on
+
+    EXPECT_THROW_WITH_MESSAGE(check_relation<execution>(trace.as_rows(), execution::SR_TRACE_CONTINUITY_1),
+                              "TRACE_CONTINUITY_1");
+    EXPECT_THROW_WITH_MESSAGE(check_relation<execution>(trace.as_rows(), execution::SR_TRACE_CONTINUITY_2),
+                              "TRACE_CONTINUITY_2");
+}
+
+TEST(ExecutionConstrainingTest, ContinuityBrokenAtTheEnd)
+{
+    // clang-format off
+    TestTraceContainer trace({
+        {{ C::execution_sel, 1 }},
+        {{ C::execution_sel, 1 }},
+        {{ C::execution_sel, 0 }}, // Not marked as last, should fail.
+    });
+    // clang-format on
+
+    EXPECT_THROW_WITH_MESSAGE(check_relation<execution>(trace.as_rows(), execution::SR_TRACE_CONTINUITY_1),
+                              "TRACE_CONTINUITY_1");
+}
+
+TEST(ExecutionConstrainingTest, ContinuityMultipleLast)
+{
+    // clang-format off
+    TestTraceContainer trace({
+        {{ C::execution_sel, 1 }},
+        {{ C::execution_sel, 0 }, {C::execution_last, 1}},
+        {{ C::execution_sel, 1 }},
+        {{ C::execution_sel, 1 }, {C::execution_last, 1}},
+    });
+    // clang-format on
+
+    EXPECT_THROW_WITH_MESSAGE(check_relation<execution>(trace.as_rows(), execution::SR_LAST_IS_LAST),
+                              "LAST_IS_LAST.*row 1");
+}
+
+} // namespace
+} // namespace bb::avm2::constraining
\ No newline at end of file
diff --git a/barretenberg/cpp/src/barretenberg/vm2/constraining/testing/check_relation.hpp b/barretenberg/cpp/src/barretenberg/vm2/constraining/testing/check_relation.hpp
new file mode 100644
index 00000000000..4fe3b59ab7b
--- /dev/null
+++ b/barretenberg/cpp/src/barretenberg/vm2/constraining/testing/check_relation.hpp
@@ -0,0 +1,44 @@
+#pragma once
+
+#include <array>
+#include <bits/utility.h>
+#include <span>
+#include <stdexcept>
+
+#include "barretenberg/common/log.hpp"
+
+namespace bb::avm2::constraining {
+
+template <typename Relation, typename Trace>
+void check_relation_internal(const Trace& trace, std::span<size_t> subrelations)
+{
+    typename Relation::SumcheckArrayOfValuesOverSubrelations result{};
+
+    for (size_t r = 0; r < trace.size(); ++r) {
+        Relation::accumulate(result, trace.at(r), {}, 1);
+        for (size_t j : subrelations) {
+            if (!result[j].is_zero()) {
+                throw std::runtime_error(format("Relation ",
+                                                Relation::NAME,
+                                                ", subrelation ",
+                                                Relation::get_subrelation_label(j),
+                                                " failed at row ",
+                                                r));
+            }
+        }
+    }
+}
+
+template <typename Relation, typename Trace, typename... Ts> void check_relation(const Trace& trace, Ts... subrelation)
+{
+    std::array<size_t, sizeof...(Ts)> subrelations = { subrelation... };
+    check_relation_internal<Relation>(trace, subrelations);
+}
+
+template <typename Relation, typename Trace> void check_relation(const Trace& trace)
+{
+    auto subrelations = std::make_index_sequence<Relation::SUBRELATION_PARTIAL_LENGTHS.size()>();
+    [&]<size_t... Is>(std::index_sequence<Is...>) { check_relation<Relation>(trace, Is...); }(subrelations);
+}
+
+} // namespace bb::avm2::constraining
\ No newline at end of file
diff --git a/barretenberg/cpp/src/barretenberg/vm2/generated/columns.hpp b/barretenberg/cpp/src/barretenberg/vm2/generated/columns.hpp
new file mode 100644
index 00000000000..caa5a36aeec
--- /dev/null
+++ b/barretenberg/cpp/src/barretenberg/vm2/generated/columns.hpp
@@ -0,0 +1,36 @@
+#pragma once
+
+#include <array>
+#include <optional>
+
+namespace bb::avm2 {
+
+// The entities that will be used in the flavor.
+// clang-format off
+#define AVM2_PRECOMPUTED_ENTITIES precomputed_bitwise_input_a, precomputed_bitwise_input_b, precomputed_bitwise_op_id, precomputed_bitwise_output, precomputed_clk, precomputed_first_row, precomputed_sel_bitwise
+#define AVM2_WIRE_ENTITIES execution_input, alu_dst_addr, alu_ia, alu_ia_addr, alu_ib, alu_ib_addr, alu_ic, alu_op, alu_sel_op_add, execution_addressing_error_idx, execution_addressing_error_kind, execution_clk, execution_ex_opcode, execution_indirect, execution_last, execution_op1, execution_op1_after_relative, execution_op2, execution_op2_after_relative, execution_op3, execution_op3_after_relative, execution_op4, execution_op4_after_relative, execution_pc, execution_rop1, execution_rop2, execution_rop3, execution_rop4, execution_sel, execution_sel_addressing_error, execution_sel_op1_is_address, execution_sel_op2_is_address, execution_sel_op3_is_address, execution_sel_op4_is_address, execution_stack_pointer_tag, execution_stack_pointer_val, lookup_dummy_precomputed_counts, lookup_dummy_dynamic_counts
+#define AVM2_DERIVED_WITNESS_ENTITIES perm_dummy_dynamic_inv, lookup_dummy_precomputed_inv, lookup_dummy_dynamic_inv
+#define AVM2_SHIFTED_ENTITIES execution_sel_shift
+#define AVM2_TO_BE_SHIFTED(e) e.execution_sel
+#define AVM2_ALL_ENTITIES AVM2_PRECOMPUTED_ENTITIES, AVM2_WIRE_ENTITIES, AVM2_DERIVED_WITNESS_ENTITIES, AVM2_SHIFTED_ENTITIES
+#define AVM2_UNSHIFTED_ENTITIES AVM2_PRECOMPUTED_ENTITIES, AVM2_WIRE_ENTITIES, AVM2_DERIVED_WITNESS_ENTITIES
+
+#define AVM2_TO_BE_SHIFTED_COLUMNS Column::execution_sel
+#define AVM2_SHIFTED_COLUMNS ColumnAndShifts::execution_sel_shift
+// clang-format on
+
+// All columns minus shifts.
+enum class Column { AVM2_UNSHIFTED_ENTITIES };
+
+// C++ doesn't allow enum extension, so we'll have to cast.
+enum class ColumnAndShifts {
+    AVM2_ALL_ENTITIES,
+    // Sentinel.
+    NUM_COLUMNS,
+};
+
+constexpr auto TO_BE_SHIFTED_COLUMNS_ARRAY = []() { return std::array{ AVM2_TO_BE_SHIFTED_COLUMNS }; }();
+constexpr auto SHIFTED_COLUMNS_ARRAY = []() { return std::array{ AVM2_SHIFTED_COLUMNS }; }();
+static_assert(TO_BE_SHIFTED_COLUMNS_ARRAY.size() == SHIFTED_COLUMNS_ARRAY.size());
+
+} // namespace bb::avm2
\ No newline at end of file
diff --git a/barretenberg/cpp/src/barretenberg/vm2/generated/flavor.cpp b/barretenberg/cpp/src/barretenberg/vm2/generated/flavor.cpp
new file mode 100644
index 00000000000..b1be0a0d762
--- /dev/null
+++ b/barretenberg/cpp/src/barretenberg/vm2/generated/flavor.cpp
@@ -0,0 +1,275 @@
+// AUTOGENERATED FILE
+#include "flavor.hpp"
+
+namespace bb::avm2 {
+
+AvmFlavor::AllConstRefValues::AllConstRefValues(
+    const RefArray<AvmFlavor::AllConstRefValues::BaseDataType, AvmFlavor::NUM_ALL_ENTITIES>& il)
+    : precomputed_bitwise_input_a(il[0])
+    , precomputed_bitwise_input_b(il[1])
+    , precomputed_bitwise_op_id(il[2])
+    , precomputed_bitwise_output(il[3])
+    , precomputed_clk(il[4])
+    , precomputed_first_row(il[5])
+    , precomputed_sel_bitwise(il[6])
+    , execution_input(il[7])
+    , alu_dst_addr(il[8])
+    , alu_ia(il[9])
+    , alu_ia_addr(il[10])
+    , alu_ib(il[11])
+    , alu_ib_addr(il[12])
+    , alu_ic(il[13])
+    , alu_op(il[14])
+    , alu_sel_op_add(il[15])
+    , execution_addressing_error_idx(il[16])
+    , execution_addressing_error_kind(il[17])
+    , execution_clk(il[18])
+    , execution_ex_opcode(il[19])
+    , execution_indirect(il[20])
+    , execution_last(il[21])
+    , execution_op1(il[22])
+    , execution_op1_after_relative(il[23])
+    , execution_op2(il[24])
+    , execution_op2_after_relative(il[25])
+    , execution_op3(il[26])
+    , execution_op3_after_relative(il[27])
+    , execution_op4(il[28])
+    , execution_op4_after_relative(il[29])
+    , execution_pc(il[30])
+    , execution_rop1(il[31])
+    , execution_rop2(il[32])
+    , execution_rop3(il[33])
+    , execution_rop4(il[34])
+    , execution_sel(il[35])
+    , execution_sel_addressing_error(il[36])
+    , execution_sel_op1_is_address(il[37])
+    , execution_sel_op2_is_address(il[38])
+    , execution_sel_op3_is_address(il[39])
+    , execution_sel_op4_is_address(il[40])
+    , execution_stack_pointer_tag(il[41])
+    , execution_stack_pointer_val(il[42])
+    , lookup_dummy_precomputed_counts(il[43])
+    , lookup_dummy_dynamic_counts(il[44])
+    , perm_dummy_dynamic_inv(il[45])
+    , lookup_dummy_precomputed_inv(il[46])
+    , lookup_dummy_dynamic_inv(il[47])
+    , execution_sel_shift(il[48])
+{}
+
+AvmFlavor::ProverPolynomials::ProverPolynomials(ProvingKey& proving_key)
+{
+    for (auto [prover_poly, key_poly] : zip_view(this->get_unshifted(), proving_key.get_all())) {
+        ASSERT(flavor_get_label(*this, prover_poly) == flavor_get_label(proving_key, key_poly));
+        prover_poly = key_poly.share();
+    }
+    for (auto [prover_poly, key_poly] : zip_view(this->get_shifted(), proving_key.get_to_be_shifted())) {
+        ASSERT(flavor_get_label(*this, prover_poly) == (flavor_get_label(proving_key, key_poly) + "_shift"));
+        prover_poly = key_poly.shifted();
+    }
+}
+
+AvmFlavor::AllConstRefValues AvmFlavor::ProverPolynomials::get_row(size_t row_idx) const
+{
+    return RefArray{ precomputed_bitwise_input_a[row_idx],
+                     precomputed_bitwise_input_b[row_idx],
+                     precomputed_bitwise_op_id[row_idx],
+                     precomputed_bitwise_output[row_idx],
+                     precomputed_clk[row_idx],
+                     precomputed_first_row[row_idx],
+                     precomputed_sel_bitwise[row_idx],
+                     execution_input[row_idx],
+                     alu_dst_addr[row_idx],
+                     alu_ia[row_idx],
+                     alu_ia_addr[row_idx],
+                     alu_ib[row_idx],
+                     alu_ib_addr[row_idx],
+                     alu_ic[row_idx],
+                     alu_op[row_idx],
+                     alu_sel_op_add[row_idx],
+                     execution_addressing_error_idx[row_idx],
+                     execution_addressing_error_kind[row_idx],
+                     execution_clk[row_idx],
+                     execution_ex_opcode[row_idx],
+                     execution_indirect[row_idx],
+                     execution_last[row_idx],
+                     execution_op1[row_idx],
+                     execution_op1_after_relative[row_idx],
+                     execution_op2[row_idx],
+                     execution_op2_after_relative[row_idx],
+                     execution_op3[row_idx],
+                     execution_op3_after_relative[row_idx],
+                     execution_op4[row_idx],
+                     execution_op4_after_relative[row_idx],
+                     execution_pc[row_idx],
+                     execution_rop1[row_idx],
+                     execution_rop2[row_idx],
+                     execution_rop3[row_idx],
+                     execution_rop4[row_idx],
+                     execution_sel[row_idx],
+                     execution_sel_addressing_error[row_idx],
+                     execution_sel_op1_is_address[row_idx],
+                     execution_sel_op2_is_address[row_idx],
+                     execution_sel_op3_is_address[row_idx],
+                     execution_sel_op4_is_address[row_idx],
+                     execution_stack_pointer_tag[row_idx],
+                     execution_stack_pointer_val[row_idx],
+                     lookup_dummy_precomputed_counts[row_idx],
+                     lookup_dummy_dynamic_counts[row_idx],
+                     perm_dummy_dynamic_inv[row_idx],
+                     lookup_dummy_precomputed_inv[row_idx],
+                     lookup_dummy_dynamic_inv[row_idx],
+                     execution_sel_shift[row_idx] };
+}
+
+AvmFlavor::CommitmentLabels::CommitmentLabels()
+{
+    Base::precomputed_bitwise_input_a = "PRECOMPUTED_BITWISE_INPUT_A";
+    Base::precomputed_bitwise_input_b = "PRECOMPUTED_BITWISE_INPUT_B";
+    Base::precomputed_bitwise_op_id = "PRECOMPUTED_BITWISE_OP_ID";
+    Base::precomputed_bitwise_output = "PRECOMPUTED_BITWISE_OUTPUT";
+    Base::precomputed_clk = "PRECOMPUTED_CLK";
+    Base::precomputed_first_row = "PRECOMPUTED_FIRST_ROW";
+    Base::precomputed_sel_bitwise = "PRECOMPUTED_SEL_BITWISE";
+    Base::execution_input = "EXECUTION_INPUT";
+    Base::alu_dst_addr = "ALU_DST_ADDR";
+    Base::alu_ia = "ALU_IA";
+    Base::alu_ia_addr = "ALU_IA_ADDR";
+    Base::alu_ib = "ALU_IB";
+    Base::alu_ib_addr = "ALU_IB_ADDR";
+    Base::alu_ic = "ALU_IC";
+    Base::alu_op = "ALU_OP";
+    Base::alu_sel_op_add = "ALU_SEL_OP_ADD";
+    Base::execution_addressing_error_idx = "EXECUTION_ADDRESSING_ERROR_IDX";
+    Base::execution_addressing_error_kind = "EXECUTION_ADDRESSING_ERROR_KIND";
+    Base::execution_clk = "EXECUTION_CLK";
+    Base::execution_ex_opcode = "EXECUTION_EX_OPCODE";
+    Base::execution_indirect = "EXECUTION_INDIRECT";
+    Base::execution_last = "EXECUTION_LAST";
+    Base::execution_op1 = "EXECUTION_OP1";
+    Base::execution_op1_after_relative = "EXECUTION_OP1_AFTER_RELATIVE";
+    Base::execution_op2 = "EXECUTION_OP2";
+    Base::execution_op2_after_relative = "EXECUTION_OP2_AFTER_RELATIVE";
+    Base::execution_op3 = "EXECUTION_OP3";
+    Base::execution_op3_after_relative = "EXECUTION_OP3_AFTER_RELATIVE";
+    Base::execution_op4 = "EXECUTION_OP4";
+    Base::execution_op4_after_relative = "EXECUTION_OP4_AFTER_RELATIVE";
+    Base::execution_pc = "EXECUTION_PC";
+    Base::execution_rop1 = "EXECUTION_ROP1";
+    Base::execution_rop2 = "EXECUTION_ROP2";
+    Base::execution_rop3 = "EXECUTION_ROP3";
+    Base::execution_rop4 = "EXECUTION_ROP4";
+    Base::execution_sel = "EXECUTION_SEL";
+    Base::execution_sel_addressing_error = "EXECUTION_SEL_ADDRESSING_ERROR";
+    Base::execution_sel_op1_is_address = "EXECUTION_SEL_OP1_IS_ADDRESS";
+    Base::execution_sel_op2_is_address = "EXECUTION_SEL_OP2_IS_ADDRESS";
+    Base::execution_sel_op3_is_address = "EXECUTION_SEL_OP3_IS_ADDRESS";
+    Base::execution_sel_op4_is_address = "EXECUTION_SEL_OP4_IS_ADDRESS";
+    Base::execution_stack_pointer_tag = "EXECUTION_STACK_POINTER_TAG";
+    Base::execution_stack_pointer_val = "EXECUTION_STACK_POINTER_VAL";
+    Base::perm_dummy_dynamic_inv = "PERM_DUMMY_DYNAMIC_INV";
+    Base::lookup_dummy_precomputed_inv = "LOOKUP_DUMMY_PRECOMPUTED_INV";
+    Base::lookup_dummy_dynamic_inv = "LOOKUP_DUMMY_DYNAMIC_INV";
+    Base::lookup_dummy_precomputed_counts = "LOOKUP_DUMMY_PRECOMPUTED_COUNTS";
+    Base::lookup_dummy_dynamic_counts = "LOOKUP_DUMMY_DYNAMIC_COUNTS";
+};
+
+void AvmFlavor::Transcript::deserialize_full_transcript()
+{
+    size_t num_frs_read = 0;
+    circuit_size = deserialize_from_buffer<uint32_t>(proof_data, num_frs_read);
+
+    for (auto& commitment : commitments) {
+        commitment = deserialize_from_buffer<Commitment>(proof_data, num_frs_read);
+    }
+
+    for (size_t i = 0; i < CONST_PROOF_SIZE_LOG_N; ++i) {
+        sumcheck_univariates.emplace_back(deserialize_from_buffer<bb::Univariate<FF, BATCHED_RELATION_PARTIAL_LENGTH>>(
+            Transcript::proof_data, num_frs_read));
+    }
+
+    sumcheck_evaluations =
+        deserialize_from_buffer<std::array<FF, NUM_ALL_ENTITIES>>(Transcript::proof_data, num_frs_read);
+
+    for (size_t i = 0; i < CONST_PROOF_SIZE_LOG_N - 1; ++i) {
+        gemini_fold_comms.push_back(deserialize_from_buffer<Commitment>(proof_data, num_frs_read));
+    }
+
+    for (size_t i = 0; i < CONST_PROOF_SIZE_LOG_N; ++i) {
+        gemini_fold_evals.push_back(deserialize_from_buffer<FF>(proof_data, num_frs_read));
+    }
+
+    shplonk_q_comm = deserialize_from_buffer<Commitment>(proof_data, num_frs_read);
+
+    kzg_w_comm = deserialize_from_buffer<Commitment>(proof_data, num_frs_read);
+}
+
+void AvmFlavor::Transcript::serialize_full_transcript()
+{
+    size_t old_proof_length = proof_data.size();
+    Transcript::proof_data.clear();
+
+    serialize_to_buffer(circuit_size, Transcript::proof_data);
+
+    for (const auto& commitment : commitments) {
+        serialize_to_buffer(commitment, Transcript::proof_data);
+    }
+
+    for (size_t i = 0; i < CONST_PROOF_SIZE_LOG_N; ++i) {
+        serialize_to_buffer(sumcheck_univariates[i], Transcript::proof_data);
+    }
+
+    serialize_to_buffer(sumcheck_evaluations, Transcript::proof_data);
+
+    for (size_t i = 0; i < CONST_PROOF_SIZE_LOG_N - 1; ++i) {
+        serialize_to_buffer(gemini_fold_comms[i], proof_data);
+    }
+
+    for (size_t i = 0; i < CONST_PROOF_SIZE_LOG_N; ++i) {
+        serialize_to_buffer(gemini_fold_evals[i], proof_data);
+    }
+
+    serialize_to_buffer(shplonk_q_comm, proof_data);
+    serialize_to_buffer(kzg_w_comm, proof_data);
+
+    // sanity check to make sure we generate the same length of proof as before.
+    ASSERT(proof_data.size() == old_proof_length);
+}
+
+AvmFlavor::PartiallyEvaluatedMultivariates::PartiallyEvaluatedMultivariates(const size_t circuit_size)
+{
+    // Storage is only needed after the first partial evaluation, hence polynomials of size (n / 2)
+    for (auto& poly : get_all()) {
+        poly = Polynomial(circuit_size / 2);
+    }
+}
+
+AvmFlavor::ProvingKey::ProvingKey(const size_t circuit_size, const size_t num_public_inputs)
+    : circuit_size(circuit_size)
+    , evaluation_domain(bb::EvaluationDomain<FF>(circuit_size, circuit_size))
+    , commitment_key(std::make_shared<CommitmentKey>(circuit_size + 1))
+{
+    // TODO: These come from PrecomputedEntitiesBase, ideal we'd just call that class's constructor.
+    this->log_circuit_size = numeric::get_msb(circuit_size);
+    this->num_public_inputs = num_public_inputs;
+
+    // The proving key's polynomials are not allocated here because they are later overwritten
+    // AvmComposer::compute_witness(). We should probably refactor this flow.
+};
+
+/**
+ * @brief Serialize verification key to field elements
+ *
+ * @return std::vector<FF>
+ */
+std::vector<AvmFlavor::VerificationKey::FF> AvmFlavor::VerificationKey::to_field_elements() const
+{
+    std::vector<FF> elements = { FF(circuit_size), FF(num_public_inputs) };
+
+    for (auto const& comm : get_all()) {
+        std::vector<FF> comm_as_fields = field_conversion::convert_to_bn254_frs(comm);
+        elements.insert(elements.end(), comm_as_fields.begin(), comm_as_fields.end());
+    }
+    return elements;
+}
+
+} // namespace bb::avm2
\ No newline at end of file
diff --git a/barretenberg/cpp/src/barretenberg/vm2/generated/flavor.hpp b/barretenberg/cpp/src/barretenberg/vm2/generated/flavor.hpp
new file mode 100644
index 00000000000..e32465455e5
--- /dev/null
+++ b/barretenberg/cpp/src/barretenberg/vm2/generated/flavor.hpp
@@ -0,0 +1,362 @@
+// AUTOGENERATED FILE
+#pragma once
+
+#include "barretenberg/commitment_schemes/kzg/kzg.hpp"
+#include "barretenberg/ecc/curves/bn254/g1.hpp"
+#include "barretenberg/flavor/relation_definitions.hpp"
+#include "barretenberg/polynomials/barycentric.hpp"
+#include "barretenberg/polynomials/univariate.hpp"
+
+#include "barretenberg/flavor/flavor.hpp"
+#include "barretenberg/flavor/flavor_macros.hpp"
+#include "barretenberg/polynomials/evaluation_domain.hpp"
+#include "barretenberg/transcript/transcript.hpp"
+
+#include "barretenberg/vm/aztec_constants.hpp"
+#include "columns.hpp"
+#include "flavor_settings.hpp"
+
+// Relations
+#include "relations/alu.hpp"
+#include "relations/execution.hpp"
+
+// Lookup and permutation relations
+#include "relations/lookup_dummy_dynamic.hpp"
+#include "relations/lookup_dummy_precomputed.hpp"
+#include "relations/perm_dummy_dynamic.hpp"
+
+// Metaprogramming to concatenate tuple types.
+template <typename... input_t> using tuple_cat_t = decltype(std::tuple_cat(std::declval<input_t>()...));
+
+namespace bb::avm2 {
+
+class AvmFlavor {
+  public:
+    using Curve = AvmFlavorSettings::Curve;
+    using G1 = AvmFlavorSettings::G1;
+    using PCS = AvmFlavorSettings::PCS;
+
+    using FF = AvmFlavorSettings::FF;
+    using Polynomial = AvmFlavorSettings::Polynomial;
+    using PolynomialHandle = AvmFlavorSettings::PolynomialHandle;
+    using GroupElement = AvmFlavorSettings::GroupElement;
+    using Commitment = AvmFlavorSettings::Commitment;
+    using CommitmentHandle = AvmFlavorSettings::CommitmentHandle;
+    using CommitmentKey = AvmFlavorSettings::CommitmentKey;
+    using VerifierCommitmentKey = AvmFlavorSettings::VerifierCommitmentKey;
+    using RelationSeparator = AvmFlavorSettings::RelationSeparator;
+
+    // indicates when evaluating sumcheck, edges must be extended to be MAX_TOTAL_RELATION_LENGTH
+    static constexpr bool USE_SHORT_MONOMIALS = false;
+
+    // This flavor would not be used with ZK Sumcheck
+    static constexpr bool HasZK = false;
+
+    static constexpr size_t NUM_PRECOMPUTED_ENTITIES = 7;
+    static constexpr size_t NUM_WITNESS_ENTITIES = 41;
+    static constexpr size_t NUM_SHIFTED_ENTITIES = 1;
+    static constexpr size_t NUM_WIRES = NUM_WITNESS_ENTITIES + NUM_PRECOMPUTED_ENTITIES;
+    // We have two copies of the witness entities, so we subtract the number of fixed ones (they have no shift), one for
+    // the unshifted and one for the shifted
+    static constexpr size_t NUM_ALL_ENTITIES = 49;
+    // The total number of witnesses including shifts and derived entities.
+    static constexpr size_t NUM_ALL_WITNESS_ENTITIES = NUM_WITNESS_ENTITIES + NUM_SHIFTED_ENTITIES;
+
+    // Need to be templated for recursive verifier
+    template <typename FF_>
+    using MainRelations_ = std::tuple<
+        // Relations
+        avm2::alu<FF_>,
+        avm2::execution<FF_>>;
+
+    using MainRelations = MainRelations_<FF>;
+
+    // Need to be templated for recursive verifier
+    template <typename FF_>
+    using LookupRelations_ = std::tuple<
+        // Lookups
+        lookup_dummy_dynamic_relation<FF_>,
+        lookup_dummy_precomputed_relation<FF_>,
+        perm_dummy_dynamic_relation<FF_>>;
+
+    using LookupRelations = LookupRelations_<FF>;
+
+    // Need to be templated for recursive verifier
+    template <typename FF_> using Relations_ = tuple_cat_t<MainRelations_<FF_>, LookupRelations_<FF_>>;
+    using Relations = Relations_<FF>;
+
+    static constexpr size_t MAX_PARTIAL_RELATION_LENGTH = compute_max_partial_relation_length<Relations>();
+
+    // BATCHED_RELATION_PARTIAL_LENGTH = algebraic degree of sumcheck relation *after* multiplying by the `pow_zeta`
+    // random polynomial e.g. For \sum(x) [A(x) * B(x) + C(x)] * PowZeta(X), relation length = 2 and random relation
+    // length = 3
+    static constexpr size_t BATCHED_RELATION_PARTIAL_LENGTH = MAX_PARTIAL_RELATION_LENGTH + 1;
+    static constexpr size_t NUM_RELATIONS = std::tuple_size_v<Relations>;
+
+    using SumcheckTupleOfTuplesOfUnivariates = decltype(create_sumcheck_tuple_of_tuples_of_univariates<Relations>());
+    using TupleOfArraysOfValues = decltype(create_tuple_of_arrays_of_values<Relations>());
+
+    static constexpr bool has_zero_row = true;
+
+    static constexpr size_t NUM_FRS_COM = field_conversion::calc_num_bn254_frs<Commitment>();
+    static constexpr size_t NUM_FRS_FR = field_conversion::calc_num_bn254_frs<FF>();
+
+    // After any circuit changes, hover `COMPUTED_AVM_PROOF_LENGTH_IN_FIELDS` in your IDE
+    // to see its value and then update `AVM_PROOF_LENGTH_IN_FIELDS` in constants.nr.
+    static constexpr size_t COMPUTED_AVM_PROOF_LENGTH_IN_FIELDS =
+        (NUM_WITNESS_ENTITIES + 1) * NUM_FRS_COM + (NUM_ALL_ENTITIES + 1) * NUM_FRS_FR +
+        CONST_PROOF_SIZE_LOG_N * (NUM_FRS_COM + NUM_FRS_FR * (BATCHED_RELATION_PARTIAL_LENGTH + 1));
+
+    template <typename DataType_> class PrecomputedEntities : public PrecomputedEntitiesBase {
+      public:
+        using DataType = DataType_;
+
+        DEFINE_FLAVOR_MEMBERS(DataType, AVM2_PRECOMPUTED_ENTITIES)
+
+        RefVector<DataType> get_selectors() { return get_all(); }
+        RefVector<DataType> get_sigma_polynomials() { return {}; }
+        RefVector<DataType> get_id_polynomials() { return {}; }
+        RefVector<DataType> get_table_polynomials() { return {}; }
+    };
+
+  private:
+    template <typename DataType> class WireEntities {
+      public:
+        DEFINE_FLAVOR_MEMBERS(DataType, AVM2_WIRE_ENTITIES)
+    };
+
+    template <typename DataType> class DerivedWitnessEntities {
+      public:
+        DEFINE_FLAVOR_MEMBERS(DataType, AVM2_DERIVED_WITNESS_ENTITIES)
+    };
+
+    template <typename DataType> class ShiftedEntities {
+      public:
+        DEFINE_FLAVOR_MEMBERS(DataType, AVM2_SHIFTED_ENTITIES)
+    };
+
+    template <typename DataType, typename PrecomputedAndWitnessEntitiesSuperset>
+    static auto get_to_be_shifted([[maybe_unused]] PrecomputedAndWitnessEntitiesSuperset& entities)
+    {
+        return RefArray<DataType, NUM_SHIFTED_ENTITIES>{ AVM2_TO_BE_SHIFTED(entities) };
+    }
+
+  public:
+    template <typename DataType>
+    class WitnessEntities : public WireEntities<DataType>, public DerivedWitnessEntities<DataType> {
+      public:
+        DEFINE_COMPOUND_GET_ALL(WireEntities<DataType>, DerivedWitnessEntities<DataType>)
+        auto get_wires() { return WireEntities<DataType>::get_all(); }
+        auto get_derived() { return DerivedWitnessEntities<DataType>::get_all(); }
+        auto get_derived_labels() { return DerivedWitnessEntities<DataType>::get_labels(); }
+    };
+
+    template <typename DataType>
+    class AllEntities : public PrecomputedEntities<DataType>,
+                        public WitnessEntities<DataType>,
+                        public ShiftedEntities<DataType> {
+      public:
+        DEFINE_COMPOUND_GET_ALL(PrecomputedEntities<DataType>, WitnessEntities<DataType>, ShiftedEntities<DataType>)
+
+        auto get_unshifted()
+        {
+            return concatenate(PrecomputedEntities<DataType>::get_all(), WitnessEntities<DataType>::get_all());
+        }
+
+        auto get_unshifted_labels()
+        {
+            return concatenate(PrecomputedEntities<DataType>::get_labels(), WitnessEntities<DataType>::get_labels());
+        }
+
+        auto get_to_be_shifted() { return AvmFlavor::get_to_be_shifted<DataType>(*this); }
+        auto get_shifted() { return ShiftedEntities<DataType>::get_all(); }
+        auto get_precomputed() { return PrecomputedEntities<DataType>::get_all(); }
+    };
+
+    class ProvingKey : public PrecomputedEntities<Polynomial>, public WitnessEntities<Polynomial> {
+      public:
+        using FF = typename Polynomial::FF;
+
+        ProvingKey() = default;
+        ProvingKey(const size_t circuit_size, const size_t num_public_inputs);
+
+        size_t circuit_size;
+        bb::EvaluationDomain<FF> evaluation_domain;
+        std::shared_ptr<CommitmentKey> commitment_key;
+
+        // Offset off the public inputs from the start of the execution trace
+        size_t pub_inputs_offset = 0;
+
+        // The number of public inputs has to be the same for all instances because they are
+        // folded element by element.
+        std::vector<FF> public_inputs;
+
+        std::vector<std::string> get_labels() const
+        {
+            return concatenate(PrecomputedEntities<Polynomial>::get_labels(),
+                               WitnessEntities<Polynomial>::get_labels());
+        }
+        auto get_witness_polynomials() { return WitnessEntities<Polynomial>::get_all(); }
+        auto get_precomputed_polynomials() { return PrecomputedEntities<Polynomial>::get_all(); }
+        auto get_selectors() { return PrecomputedEntities<Polynomial>::get_all(); }
+        auto get_to_be_shifted() { return AvmFlavor::get_to_be_shifted<Polynomial>(*this); }
+        // This order matters! must match get_unshifted in entity classes
+        auto get_all() { return concatenate(get_precomputed_polynomials(), get_witness_polynomials()); }
+    };
+
+    class VerificationKey : public VerificationKey_<PrecomputedEntities<Commitment>, VerifierCommitmentKey> {
+      public:
+        using FF = VerificationKey_::FF;
+        static constexpr size_t NUM_PRECOMPUTED_COMMITMENTS = NUM_PRECOMPUTED_ENTITIES;
+
+        VerificationKey() = default;
+
+        VerificationKey(const std::shared_ptr<ProvingKey>& proving_key)
+            : VerificationKey_(proving_key->circuit_size, static_cast<size_t>(proving_key->num_public_inputs))
+        {
+            for (auto [polynomial, commitment] :
+                 zip_view(proving_key->get_precomputed_polynomials(), this->get_all())) {
+                commitment = proving_key->commitment_key->commit(polynomial);
+            }
+            pcs_verification_key = std::make_shared<VerifierCommitmentKey>();
+        }
+
+        VerificationKey(const size_t circuit_size,
+                        const size_t num_public_inputs,
+                        std::array<Commitment, NUM_PRECOMPUTED_COMMITMENTS> const& precomputed_cmts)
+            : VerificationKey_(circuit_size, num_public_inputs)
+        {
+            for (auto [vk_cmt, cmt] : zip_view(this->get_all(), precomputed_cmts)) {
+                vk_cmt = cmt;
+            }
+            pcs_verification_key = std::make_shared<VerifierCommitmentKey>();
+        }
+
+        std::vector<FF> to_field_elements() const;
+    };
+
+    class AllValues : public AllEntities<FF> {
+      public:
+        using Base = AllEntities<FF>;
+        using Base::Base;
+    };
+
+    class AllConstRefValues {
+      public:
+        using BaseDataType = const FF;
+        using DataType = BaseDataType&;
+
+        DEFINE_FLAVOR_MEMBERS(DataType, AVM2_ALL_ENTITIES)
+
+        AllConstRefValues(const RefArray<BaseDataType, NUM_ALL_ENTITIES>& il);
+    };
+
+    /**
+     * @brief A container for the prover polynomials handles.
+     */
+    class ProverPolynomials : public AllEntities<Polynomial> {
+      public:
+        // Define all operations as default, except copy construction/assignment
+        ProverPolynomials() = default;
+        ProverPolynomials& operator=(const ProverPolynomials&) = delete;
+        ProverPolynomials(const ProverPolynomials& o) = delete;
+        ProverPolynomials(ProverPolynomials&& o) noexcept = default;
+        ProverPolynomials& operator=(ProverPolynomials&& o) noexcept = default;
+        ~ProverPolynomials() = default;
+
+        ProverPolynomials(ProvingKey& proving_key);
+
+        [[nodiscard]] size_t get_polynomial_size() const { return execution_input.size(); }
+        /**
+         * @brief Returns the evaluations of all prover polynomials at one point on the boolean hypercube, which
+         * represents one row in the execution trace.
+         */
+        [[nodiscard]] AllConstRefValues get_row(size_t row_idx) const;
+    };
+
+    class PartiallyEvaluatedMultivariates : public AllEntities<Polynomial> {
+      public:
+        PartiallyEvaluatedMultivariates() = default;
+        PartiallyEvaluatedMultivariates(const size_t circuit_size);
+    };
+
+    /**
+     * @brief A container for univariates used during Protogalaxy folding and sumcheck.
+     * @details During folding and sumcheck, the prover evaluates the relations on these univariates.
+     */
+    template <size_t LENGTH> using ProverUnivariates = AllEntities<bb::Univariate<FF, LENGTH>>;
+
+    /**
+     * @brief A container for univariates used during Protogalaxy folding and sumcheck with some of the computation
+     * optimistically ignored
+     * @details During folding and sumcheck, the prover evaluates the relations on these univariates.
+     */
+    template <size_t LENGTH, size_t SKIP_COUNT>
+    using ProverUnivariatesWithOptimisticSkipping = AllEntities<bb::Univariate<FF, LENGTH, 0, SKIP_COUNT>>;
+
+    /**
+     * @brief A container for univariates produced during the hot loop in sumcheck.
+     */
+    using ExtendedEdges = ProverUnivariates<MAX_PARTIAL_RELATION_LENGTH>;
+
+    /**
+     * @brief A container for the witness commitments.
+     *
+     */
+    using WitnessCommitments = WitnessEntities<Commitment>;
+
+    class CommitmentLabels : public AllEntities<std::string> {
+      private:
+        using Base = AllEntities<std::string>;
+
+      public:
+        CommitmentLabels();
+    };
+
+    // Templated for use in recursive verifier
+    template <typename Commitment_, typename VerificationKey>
+    class VerifierCommitments_ : public AllEntities<Commitment_> {
+      private:
+        using Base = AllEntities<Commitment_>;
+
+      public:
+        VerifierCommitments_(const std::shared_ptr<VerificationKey>& verification_key)
+        {
+            this->precomputed_bitwise_input_a = verification_key->precomputed_bitwise_input_a;
+            this->precomputed_bitwise_input_b = verification_key->precomputed_bitwise_input_b;
+            this->precomputed_bitwise_op_id = verification_key->precomputed_bitwise_op_id;
+            this->precomputed_bitwise_output = verification_key->precomputed_bitwise_output;
+            this->precomputed_clk = verification_key->precomputed_clk;
+            this->precomputed_first_row = verification_key->precomputed_first_row;
+            this->precomputed_sel_bitwise = verification_key->precomputed_sel_bitwise;
+        }
+    };
+
+    // Native version of the verifier commitments
+    using VerifierCommitments = VerifierCommitments_<Commitment, VerificationKey>;
+
+    class Transcript : public NativeTranscript {
+      public:
+        uint32_t circuit_size;
+
+        std::array<Commitment, NUM_WITNESS_ENTITIES> commitments;
+
+        std::vector<bb::Univariate<FF, BATCHED_RELATION_PARTIAL_LENGTH>> sumcheck_univariates;
+        std::array<FF, NUM_ALL_ENTITIES> sumcheck_evaluations;
+        std::vector<Commitment> gemini_fold_comms;
+        std::vector<FF> gemini_fold_evals;
+        Commitment shplonk_q_comm;
+        Commitment kzg_w_comm;
+
+        Transcript() = default;
+
+        Transcript(const std::vector<FF>& proof)
+            : NativeTranscript(proof)
+        {}
+
+        void deserialize_full_transcript();
+        void serialize_full_transcript();
+    };
+};
+
+} // namespace bb::avm2
diff --git a/barretenberg/cpp/src/barretenberg/vm2/generated/flavor_settings.hpp b/barretenberg/cpp/src/barretenberg/vm2/generated/flavor_settings.hpp
new file mode 100644
index 00000000000..3d4e4c9179d
--- /dev/null
+++ b/barretenberg/cpp/src/barretenberg/vm2/generated/flavor_settings.hpp
@@ -0,0 +1,29 @@
+// AUTOGENERATED FILE
+#pragma once
+
+#include "barretenberg/commitment_schemes/kzg/kzg.hpp"
+#include "barretenberg/ecc/curves/bn254/g1.hpp"
+#include "barretenberg/flavor/relation_definitions.hpp"
+#include "barretenberg/polynomials/barycentric.hpp"
+#include "barretenberg/polynomials/univariate.hpp"
+
+namespace bb::avm2 {
+
+class AvmFlavorSettings {
+  public:
+    using Curve = curve::BN254;
+    using G1 = Curve::Group;
+    using PCS = KZG<Curve>;
+
+    using FF = G1::subgroup_field;
+    using Polynomial = bb::Polynomial<FF>;
+    using PolynomialHandle = std::span<FF>;
+    using GroupElement = G1::element;
+    using Commitment = G1::affine_element;
+    using CommitmentHandle = G1::affine_element;
+    using CommitmentKey = bb::CommitmentKey<Curve>;
+    using VerifierCommitmentKey = bb::VerifierCommitmentKey<Curve>;
+    using RelationSeparator = FF;
+};
+
+} // namespace bb::avm2
\ No newline at end of file
diff --git a/barretenberg/cpp/src/barretenberg/vm2/generated/full_row.cpp b/barretenberg/cpp/src/barretenberg/vm2/generated/full_row.cpp
new file mode 100644
index 00000000000..99ed3da8619
--- /dev/null
+++ b/barretenberg/cpp/src/barretenberg/vm2/generated/full_row.cpp
@@ -0,0 +1,139 @@
+// AUTOGENERATED FILE
+#include "full_row.hpp"
+#include "flavor_settings.hpp"
+
+namespace bb::avm2 {
+namespace {
+
+template <typename FF> std::string field_to_string(const FF& ff)
+{
+    std::ostringstream os;
+    os << ff;
+    std::string raw = os.str();
+    auto first_not_zero = raw.find_first_not_of('0', 2);
+    std::string result = "0x" + (first_not_zero != std::string::npos ? raw.substr(first_not_zero) : "0");
+    return result;
+}
+
+} // namespace
+
+template <typename FF> std::vector<std::string> AvmFullRow<FF>::names()
+{
+    return { "precomputed_bitwise_input_a",
+             "precomputed_bitwise_input_b",
+             "precomputed_bitwise_op_id",
+             "precomputed_bitwise_output",
+             "precomputed_clk",
+             "precomputed_first_row",
+             "precomputed_sel_bitwise",
+             "execution_input",
+             "alu_dst_addr",
+             "alu_ia",
+             "alu_ia_addr",
+             "alu_ib",
+             "alu_ib_addr",
+             "alu_ic",
+             "alu_op",
+             "alu_sel_op_add",
+             "execution_addressing_error_idx",
+             "execution_addressing_error_kind",
+             "execution_clk",
+             "execution_ex_opcode",
+             "execution_indirect",
+             "execution_last",
+             "execution_op1",
+             "execution_op1_after_relative",
+             "execution_op2",
+             "execution_op2_after_relative",
+             "execution_op3",
+             "execution_op3_after_relative",
+             "execution_op4",
+             "execution_op4_after_relative",
+             "execution_pc",
+             "execution_rop1",
+             "execution_rop2",
+             "execution_rop3",
+             "execution_rop4",
+             "execution_sel",
+             "execution_sel_addressing_error",
+             "execution_sel_op1_is_address",
+             "execution_sel_op2_is_address",
+             "execution_sel_op3_is_address",
+             "execution_sel_op4_is_address",
+             "execution_stack_pointer_tag",
+             "execution_stack_pointer_val",
+             "perm_dummy_dynamic_inv",
+             "lookup_dummy_precomputed_inv",
+             "lookup_dummy_dynamic_inv",
+             "lookup_dummy_precomputed_counts",
+             "lookup_dummy_dynamic_counts" };
+}
+
+template <typename FF> RefVector<const FF> AvmFullRow<FF>::as_vector() const
+{
+    return RefVector<const FF>{
+        precomputed_bitwise_input_a,
+        precomputed_bitwise_input_b,
+        precomputed_bitwise_op_id,
+        precomputed_bitwise_output,
+        precomputed_clk,
+        precomputed_first_row,
+        precomputed_sel_bitwise,
+        execution_input,
+        alu_dst_addr,
+        alu_ia,
+        alu_ia_addr,
+        alu_ib,
+        alu_ib_addr,
+        alu_ic,
+        alu_op,
+        alu_sel_op_add,
+        execution_addressing_error_idx,
+        execution_addressing_error_kind,
+        execution_clk,
+        execution_ex_opcode,
+        execution_indirect,
+        execution_last,
+        execution_op1,
+        execution_op1_after_relative,
+        execution_op2,
+        execution_op2_after_relative,
+        execution_op3,
+        execution_op3_after_relative,
+        execution_op4,
+        execution_op4_after_relative,
+        execution_pc,
+        execution_rop1,
+        execution_rop2,
+        execution_rop3,
+        execution_rop4,
+        execution_sel,
+        execution_sel_addressing_error,
+        execution_sel_op1_is_address,
+        execution_sel_op2_is_address,
+        execution_sel_op3_is_address,
+        execution_sel_op4_is_address,
+        execution_stack_pointer_tag,
+        execution_stack_pointer_val,
+        perm_dummy_dynamic_inv,
+        lookup_dummy_precomputed_inv,
+        lookup_dummy_dynamic_inv,
+        lookup_dummy_precomputed_counts,
+        lookup_dummy_dynamic_counts,
+    };
+}
+
+template <typename FF> std::ostream& operator<<(std::ostream& os, AvmFullRow<FF> const& row)
+{
+    for (const auto& ff : row.as_vector()) {
+        os << field_to_string(ff) << ", ";
+    }
+    return os;
+}
+
+// Explicit template instantiation.
+template std::ostream& operator<<(std::ostream& os, AvmFullRow<AvmFlavorSettings::FF> const& row);
+template std::vector<std::string> AvmFullRow<AvmFlavorSettings::FF>::names();
+template RefVector<const AvmFlavorSettings::FF> AvmFullRow<AvmFlavorSettings::FF>::as_vector() const;
+
+} // namespace bb::avm2
diff --git a/barretenberg/cpp/src/barretenberg/vm2/generated/full_row.hpp b/barretenberg/cpp/src/barretenberg/vm2/generated/full_row.hpp
new file mode 100644
index 00000000000..6d08da72a49
--- /dev/null
+++ b/barretenberg/cpp/src/barretenberg/vm2/generated/full_row.hpp
@@ -0,0 +1,45 @@
+// AUTOGENERATED FILE
+#pragma once
+
+#include <sstream>
+#include <string>
+#include <vector>
+
+#include "barretenberg/common/ref_vector.hpp"
+#include "columns.hpp"
+
+namespace bb::avm2 {
+
+template <typename FF_> struct AvmFullRow {
+    using FF = FF_;
+
+    FF AVM2_ALL_ENTITIES;
+
+    RefVector<const FF> as_vector() const;
+    static std::vector<std::string> names();
+    static constexpr size_t SIZE = 48;
+
+    // Risky but oh so efficient.
+    FF& get_column(ColumnAndShifts col)
+    {
+        static_assert(sizeof(*this) == sizeof(FF) * static_cast<size_t>(ColumnAndShifts::NUM_COLUMNS));
+        return reinterpret_cast<FF*>(this)[static_cast<size_t>(col)];
+    }
+
+    const FF& get_column(ColumnAndShifts col) const
+    {
+        static_assert(sizeof(*this) == sizeof(FF) * static_cast<size_t>(ColumnAndShifts::NUM_COLUMNS));
+        return reinterpret_cast<FF*>(this)[static_cast<size_t>(col)];
+    }
+};
+
+template <typename FF> std::ostream& operator<<(std::ostream& os, AvmFullRow<FF> const& row);
+
+} // namespace bb::avm2
+
+namespace bb {
+
+// Expose this in the bb namespace. For compatibility with the old witgen.
+using avm2::AvmFullRow;
+
+} // namespace bb
\ No newline at end of file
diff --git a/barretenberg/cpp/src/barretenberg/vm2/generated/prover.cpp b/barretenberg/cpp/src/barretenberg/vm2/generated/prover.cpp
new file mode 100644
index 00000000000..ce767226599
--- /dev/null
+++ b/barretenberg/cpp/src/barretenberg/vm2/generated/prover.cpp
@@ -0,0 +1,156 @@
+// AUTOGENERATED FILE
+#include "prover.hpp"
+#include "barretenberg/commitment_schemes/claim.hpp"
+#include "barretenberg/commitment_schemes/commitment_key.hpp"
+#include "barretenberg/commitment_schemes/shplonk/shplemini.hpp"
+#include "barretenberg/common/constexpr_utils.hpp"
+#include "barretenberg/common/thread.hpp"
+#include "barretenberg/honk/proof_system/logderivative_library.hpp"
+#include "barretenberg/plonk_honk_shared/library/grand_product_library.hpp"
+#include "barretenberg/relations/permutation_relation.hpp"
+#include "barretenberg/sumcheck/sumcheck.hpp"
+#include "barretenberg/vm/stats.hpp"
+
+namespace bb::avm2 {
+
+using Flavor = AvmFlavor;
+using FF = Flavor::FF;
+
+/**
+ * Create AvmProver from proving key, witness and manifest.
+ *
+ * @param input_key Proving key.
+ * @param input_manifest Input manifest
+ *
+ * @tparam settings Settings class.
+ */
+AvmProver::AvmProver(std::shared_ptr<Flavor::ProvingKey> input_key, std::shared_ptr<PCSCommitmentKey> commitment_key)
+    : key(std::move(input_key))
+    , prover_polynomials(*key)
+    , commitment_key(std::move(commitment_key))
+{}
+
+/**
+ * @brief Add circuit size, public input size, and public inputs to transcript
+ *
+ */
+void AvmProver::execute_preamble_round()
+{
+    const auto circuit_size = static_cast<uint32_t>(key->circuit_size);
+
+    transcript->send_to_verifier("circuit_size", circuit_size);
+}
+
+/**
+ * @brief Compute commitments to all of the witness wires (apart from the logderivative inverse wires)
+ *
+ */
+void AvmProver::execute_wire_commitments_round()
+{
+    // Commit to all polynomials (apart from logderivative inverse polynomials, which are committed to in the later
+    // logderivative phase)
+    auto wire_polys = prover_polynomials.get_wires();
+    auto labels = commitment_labels.get_wires();
+    for (size_t idx = 0; idx < wire_polys.size(); ++idx) {
+        transcript->send_to_verifier(labels[idx], commitment_key->commit_sparse(wire_polys[idx]));
+    }
+}
+
+void AvmProver::execute_log_derivative_inverse_round()
+{
+    auto [beta, gamma] = transcript->template get_challenges<FF>("beta", "gamma");
+    relation_parameters.beta = beta;
+    relation_parameters.gamma = gamma;
+    std::vector<std::function<void()>> tasks;
+
+    bb::constexpr_for<0, std::tuple_size_v<Flavor::LookupRelations>, 1>([&]<size_t relation_idx>() {
+        using Relation = std::tuple_element_t<relation_idx, Flavor::LookupRelations>;
+        tasks.push_back([&]() {
+            AVM_TRACK_TIME(std::string("prove/execute_log_derivative_inverse_round/") + Relation::NAME,
+                           (compute_logderivative_inverse<Flavor, Relation>(
+                               prover_polynomials, relation_parameters, key->circuit_size)));
+        });
+    });
+
+    bb::parallel_for(tasks.size(), [&](size_t i) { tasks[i](); });
+}
+
+void AvmProver::execute_log_derivative_inverse_commitments_round()
+{
+    // Commit to all logderivative inverse polynomials
+    for (auto [commitment, key_poly] : zip_view(witness_commitments.get_derived(), key->get_derived())) {
+        commitment = commitment_key->commit(key_poly);
+    }
+
+    // Send all commitments to the verifier
+    for (auto [label, commitment] : zip_view(commitment_labels.get_derived(), witness_commitments.get_derived())) {
+        transcript->send_to_verifier(label, commitment);
+    }
+}
+
+/**
+ * @brief Run Sumcheck resulting in u = (u_1,...,u_d) challenges and all evaluations at u being calculated.
+ *
+ */
+void AvmProver::execute_relation_check_rounds()
+{
+    using Sumcheck = SumcheckProver<Flavor>;
+
+    auto sumcheck = Sumcheck(key->circuit_size, transcript);
+
+    FF alpha = transcript->template get_challenge<FF>("Sumcheck:alpha");
+    std::vector<FF> gate_challenges(numeric::get_msb(key->circuit_size));
+
+    for (size_t idx = 0; idx < gate_challenges.size(); idx++) {
+        gate_challenges[idx] = transcript->template get_challenge<FF>("Sumcheck:gate_challenge_" + std::to_string(idx));
+    }
+    sumcheck_output = sumcheck.prove(prover_polynomials, relation_parameters, alpha, gate_challenges);
+}
+
+void AvmProver::execute_pcs_rounds()
+{
+    using OpeningClaim = ProverOpeningClaim<Curve>;
+
+    const OpeningClaim prover_opening_claim = ShpleminiProver_<Curve>::prove(key->circuit_size,
+                                                                             prover_polynomials.get_unshifted(),
+                                                                             prover_polynomials.get_to_be_shifted(),
+                                                                             sumcheck_output.challenge,
+                                                                             commitment_key,
+                                                                             transcript);
+
+    PCS::compute_opening_proof(commitment_key, prover_opening_claim, transcript);
+}
+
+HonkProof AvmProver::export_proof()
+{
+    proof = transcript->proof_data;
+    return proof;
+}
+
+HonkProof AvmProver::construct_proof()
+{
+    // Add circuit size public input size and public inputs to transcript.
+    execute_preamble_round();
+
+    // Compute wire commitments
+    AVM_TRACK_TIME("prove/execute_wire_commitments_round", execute_wire_commitments_round());
+
+    // Compute sorted list accumulator
+    AVM_TRACK_TIME("prove/execute_log_derivative_inverse_round", execute_log_derivative_inverse_round());
+
+    // Compute commitments to logderivative inverse polynomials
+    AVM_TRACK_TIME("prove/execute_log_derivative_inverse_commitments_round",
+                   execute_log_derivative_inverse_commitments_round());
+
+    // Fiat-Shamir: alpha
+    // Run sumcheck subprotocol.
+    AVM_TRACK_TIME("prove/execute_relation_check_rounds", execute_relation_check_rounds());
+
+    // Fiat-Shamir: rho, y, x, z
+    // Execute Shplemini PCS
+    AVM_TRACK_TIME("prove/execute_pcs_rounds", execute_pcs_rounds());
+
+    return export_proof();
+}
+
+} // namespace bb::avm2
\ No newline at end of file
diff --git a/barretenberg/cpp/src/barretenberg/vm2/generated/prover.hpp b/barretenberg/cpp/src/barretenberg/vm2/generated/prover.hpp
new file mode 100644
index 00000000000..ebda9ec4cf3
--- /dev/null
+++ b/barretenberg/cpp/src/barretenberg/vm2/generated/prover.hpp
@@ -0,0 +1,66 @@
+// AUTOGENERATED FILE
+#pragma once
+
+#include "barretenberg/plonk/proof_system/types/proof.hpp"
+#include "barretenberg/relations/relation_parameters.hpp"
+#include "barretenberg/sumcheck/sumcheck_output.hpp"
+#include "barretenberg/transcript/transcript.hpp"
+#include "flavor.hpp"
+
+namespace bb::avm2 {
+
+class AvmProver {
+  public:
+    using Flavor = AvmFlavor;
+    using FF = Flavor::FF;
+    using PCS = Flavor::PCS;
+    using Curve = Flavor::Curve;
+    using PCSCommitmentKey = Flavor::CommitmentKey;
+    using ProvingKey = Flavor::ProvingKey;
+    using Polynomial = Flavor::Polynomial;
+    using ProverPolynomials = Flavor::ProverPolynomials;
+    using CommitmentLabels = Flavor::CommitmentLabels;
+    using Transcript = Flavor::Transcript;
+    using Proof = HonkProof;
+
+    explicit AvmProver(std::shared_ptr<ProvingKey> input_key, std::shared_ptr<PCSCommitmentKey> commitment_key);
+    AvmProver(AvmProver&& prover) = default;
+    virtual ~AvmProver() = default;
+
+    // Note: all the following methods are virtual to allow Avm2 to tweak the behaviour.
+    // We can remove this once the transition is done.
+    virtual void execute_preamble_round();
+    virtual void execute_wire_commitments_round();
+    virtual void execute_log_derivative_inverse_round();
+    virtual void execute_log_derivative_inverse_commitments_round();
+    virtual void execute_relation_check_rounds();
+    virtual void execute_pcs_rounds();
+
+    virtual HonkProof export_proof();
+    virtual HonkProof construct_proof();
+
+    std::shared_ptr<Transcript> transcript = std::make_shared<Transcript>();
+
+    std::vector<FF> public_inputs;
+
+    bb::RelationParameters<FF> relation_parameters;
+
+    std::shared_ptr<ProvingKey> key;
+
+    // Container for spans of all polynomials required by the prover (i.e. all multivariates evaluated by Sumcheck).
+    ProverPolynomials prover_polynomials;
+
+    CommitmentLabels commitment_labels;
+    typename Flavor::WitnessCommitments witness_commitments;
+
+    Polynomial quotient_W;
+
+    SumcheckOutput<Flavor> sumcheck_output;
+
+    std::shared_ptr<PCSCommitmentKey> commitment_key;
+
+  protected:
+    HonkProof proof;
+};
+
+} // namespace bb::avm2
\ No newline at end of file
diff --git a/barretenberg/cpp/src/barretenberg/vm2/generated/relations/alu.hpp b/barretenberg/cpp/src/barretenberg/vm2/generated/relations/alu.hpp
new file mode 100644
index 00000000000..c2316109c3f
--- /dev/null
+++ b/barretenberg/cpp/src/barretenberg/vm2/generated/relations/alu.hpp
@@ -0,0 +1,57 @@
+// AUTOGENERATED FILE
+#pragma once
+
+#include "barretenberg/relations/relation_parameters.hpp"
+#include "barretenberg/relations/relation_types.hpp"
+
+namespace bb::avm2 {
+
+template <typename FF_> class aluImpl {
+  public:
+    using FF = FF_;
+
+    static constexpr std::array<size_t, 2> SUBRELATION_PARTIAL_LENGTHS = { 3, 2 };
+
+    template <typename ContainerOverSubrelations, typename AllEntities>
+    void static accumulate(ContainerOverSubrelations& evals,
+                           const AllEntities& new_term,
+                           [[maybe_unused]] const RelationParameters<FF>&,
+                           [[maybe_unused]] const FF& scaling_factor)
+    {
+
+        {
+            using Accumulator = typename std::tuple_element_t<0, ContainerOverSubrelations>;
+            auto tmp = (new_term.alu_sel_op_add * (FF(1) - new_term.alu_sel_op_add));
+            tmp *= scaling_factor;
+            std::get<0>(evals) += typename Accumulator::View(tmp);
+        }
+        {
+            using Accumulator = typename std::tuple_element_t<1, ContainerOverSubrelations>;
+            auto tmp = ((new_term.alu_ia + new_term.alu_ib) - new_term.alu_ic);
+            tmp *= scaling_factor;
+            std::get<1>(evals) += typename Accumulator::View(tmp);
+        }
+    }
+};
+
+template <typename FF> class alu : public Relation<aluImpl<FF>> {
+  public:
+    static constexpr const char* NAME = "alu";
+
+    static std::string get_subrelation_label(size_t index)
+    {
+        switch (index) {
+        case 0:
+            return "SEL_ADD_BINARY";
+        case 1:
+            return "ALU_ADD";
+        }
+        return std::to_string(index);
+    }
+
+    // Subrelation indices constants, to be used in tests.
+    static constexpr size_t SR_SEL_ADD_BINARY = 0;
+    static constexpr size_t SR_ALU_ADD = 1;
+};
+
+} // namespace bb::avm2
\ No newline at end of file
diff --git a/barretenberg/cpp/src/barretenberg/vm2/generated/relations/execution.hpp b/barretenberg/cpp/src/barretenberg/vm2/generated/relations/execution.hpp
new file mode 100644
index 00000000000..0fa8aaecea3
--- /dev/null
+++ b/barretenberg/cpp/src/barretenberg/vm2/generated/relations/execution.hpp
@@ -0,0 +1,80 @@
+// AUTOGENERATED FILE
+#pragma once
+
+#include "barretenberg/relations/relation_parameters.hpp"
+#include "barretenberg/relations/relation_types.hpp"
+
+namespace bb::avm2 {
+
+template <typename FF_> class executionImpl {
+  public:
+    using FF = FF_;
+
+    static constexpr std::array<size_t, 5> SUBRELATION_PARTIAL_LENGTHS = { 3, 3, 4, 4, 3 };
+
+    template <typename ContainerOverSubrelations, typename AllEntities>
+    void static accumulate(ContainerOverSubrelations& evals,
+                           const AllEntities& new_term,
+                           [[maybe_unused]] const RelationParameters<FF>&,
+                           [[maybe_unused]] const FF& scaling_factor)
+    {
+
+        {
+            using Accumulator = typename std::tuple_element_t<0, ContainerOverSubrelations>;
+            auto tmp = (new_term.execution_sel * (FF(1) - new_term.execution_sel));
+            tmp *= scaling_factor;
+            std::get<0>(evals) += typename Accumulator::View(tmp);
+        }
+        {
+            using Accumulator = typename std::tuple_element_t<1, ContainerOverSubrelations>;
+            auto tmp = (new_term.execution_last * (FF(1) - new_term.execution_last));
+            tmp *= scaling_factor;
+            std::get<1>(evals) += typename Accumulator::View(tmp);
+        }
+        {
+            using Accumulator = typename std::tuple_element_t<2, ContainerOverSubrelations>;
+            auto tmp =
+                (new_term.execution_sel * ((FF(1) - new_term.execution_sel_shift) * (FF(1) - new_term.execution_last)));
+            tmp *= scaling_factor;
+            std::get<2>(evals) += typename Accumulator::View(tmp);
+        }
+        {
+            using Accumulator = typename std::tuple_element_t<3, ContainerOverSubrelations>;
+            auto tmp = (((FF(1) - new_term.precomputed_first_row) * (FF(1) - new_term.execution_sel)) *
+                        new_term.execution_sel_shift);
+            tmp *= scaling_factor;
+            std::get<3>(evals) += typename Accumulator::View(tmp);
+        }
+        {
+            using Accumulator = typename std::tuple_element_t<4, ContainerOverSubrelations>;
+            auto tmp = (new_term.execution_last * new_term.execution_sel_shift);
+            tmp *= scaling_factor;
+            std::get<4>(evals) += typename Accumulator::View(tmp);
+        }
+    }
+};
+
+template <typename FF> class execution : public Relation<executionImpl<FF>> {
+  public:
+    static constexpr const char* NAME = "execution";
+
+    static std::string get_subrelation_label(size_t index)
+    {
+        switch (index) {
+        case 2:
+            return "TRACE_CONTINUITY_1";
+        case 3:
+            return "TRACE_CONTINUITY_2";
+        case 4:
+            return "LAST_IS_LAST";
+        }
+        return std::to_string(index);
+    }
+
+    // Subrelation indices constants, to be used in tests.
+    static constexpr size_t SR_TRACE_CONTINUITY_1 = 2;
+    static constexpr size_t SR_TRACE_CONTINUITY_2 = 3;
+    static constexpr size_t SR_LAST_IS_LAST = 4;
+};
+
+} // namespace bb::avm2
\ No newline at end of file
diff --git a/barretenberg/cpp/src/barretenberg/vm2/generated/relations/lookup_dummy_dynamic.hpp b/barretenberg/cpp/src/barretenberg/vm2/generated/relations/lookup_dummy_dynamic.hpp
new file mode 100644
index 00000000000..303184e73dd
--- /dev/null
+++ b/barretenberg/cpp/src/barretenberg/vm2/generated/relations/lookup_dummy_dynamic.hpp
@@ -0,0 +1,83 @@
+// AUTOGENERATED FILE
+#pragma once
+
+#include "../columns.hpp"
+#include "barretenberg/relations/generic_lookup/generic_lookup_relation.hpp"
+
+#include <cstddef>
+#include <tuple>
+
+namespace bb::avm2 {
+
+class lookup_dummy_dynamic_lookup_settings {
+  public:
+    static constexpr size_t READ_TERMS = 1;
+    static constexpr size_t WRITE_TERMS = 1;
+    static constexpr size_t READ_TERM_TYPES[READ_TERMS] = { 0 };
+    static constexpr size_t WRITE_TERM_TYPES[WRITE_TERMS] = { 0 };
+    static constexpr size_t LOOKUP_TUPLE_SIZE = 4;
+    static constexpr size_t INVERSE_EXISTS_POLYNOMIAL_DEGREE = 4;
+    static constexpr size_t READ_TERM_DEGREE = 0;
+    static constexpr size_t WRITE_TERM_DEGREE = 0;
+
+    // Columns using the Column enum.
+    static constexpr Column SRC_SELECTOR = Column::execution_sel;
+    static constexpr Column DST_SELECTOR = Column::execution_sel;
+    static constexpr Column COUNTS = Column::lookup_dummy_dynamic_counts;
+    static constexpr Column INVERSES = Column::lookup_dummy_dynamic_inv;
+    static constexpr std::array<Column, LOOKUP_TUPLE_SIZE> SRC_COLUMNS = {
+        Column::execution_op1, Column::execution_op2, Column::execution_op3, Column::execution_op4
+    };
+    static constexpr std::array<Column, LOOKUP_TUPLE_SIZE> DST_COLUMNS = {
+        Column::execution_op1, Column::execution_op2, Column::execution_op3, Column::execution_op4
+    };
+
+    template <typename AllEntities> static inline auto inverse_polynomial_is_computed_at_row(const AllEntities& in)
+    {
+        return (in.execution_sel == 1 || in.execution_sel == 1);
+    }
+
+    template <typename Accumulator, typename AllEntities>
+    static inline auto compute_inverse_exists(const AllEntities& in)
+    {
+        using View = typename Accumulator::View;
+        const auto is_operation = View(in.execution_sel);
+        const auto is_table_entry = View(in.execution_sel);
+        return (is_operation + is_table_entry - is_operation * is_table_entry);
+    }
+
+    template <typename AllEntities> static inline auto get_const_entities(const AllEntities& in)
+    {
+        return get_entities(in);
+    }
+
+    template <typename AllEntities> static inline auto get_nonconst_entities(AllEntities& in)
+    {
+        return get_entities(in);
+    }
+
+    template <typename AllEntities> static inline auto get_entities(AllEntities&& in)
+    {
+        return std::forward_as_tuple(in.lookup_dummy_dynamic_inv,
+                                     in.lookup_dummy_dynamic_counts,
+                                     in.execution_sel,
+                                     in.execution_sel,
+                                     in.execution_op1,
+                                     in.execution_op2,
+                                     in.execution_op3,
+                                     in.execution_op4,
+                                     in.execution_op1,
+                                     in.execution_op2,
+                                     in.execution_op3,
+                                     in.execution_op4);
+    }
+};
+
+template <typename FF_>
+class lookup_dummy_dynamic_relation : public GenericLookupRelation<lookup_dummy_dynamic_lookup_settings, FF_> {
+  public:
+    static constexpr const char* NAME = "LOOKUP_DUMMY_DYNAMIC";
+};
+template <typename FF_> using lookup_dummy_dynamic = GenericLookup<lookup_dummy_dynamic_lookup_settings, FF_>;
+
+} // namespace bb::avm2
\ No newline at end of file
diff --git a/barretenberg/cpp/src/barretenberg/vm2/generated/relations/lookup_dummy_precomputed.hpp b/barretenberg/cpp/src/barretenberg/vm2/generated/relations/lookup_dummy_precomputed.hpp
new file mode 100644
index 00000000000..1bcdd954294
--- /dev/null
+++ b/barretenberg/cpp/src/barretenberg/vm2/generated/relations/lookup_dummy_precomputed.hpp
@@ -0,0 +1,84 @@
+// AUTOGENERATED FILE
+#pragma once
+
+#include "../columns.hpp"
+#include "barretenberg/relations/generic_lookup/generic_lookup_relation.hpp"
+
+#include <cstddef>
+#include <tuple>
+
+namespace bb::avm2 {
+
+class lookup_dummy_precomputed_lookup_settings {
+  public:
+    static constexpr size_t READ_TERMS = 1;
+    static constexpr size_t WRITE_TERMS = 1;
+    static constexpr size_t READ_TERM_TYPES[READ_TERMS] = { 0 };
+    static constexpr size_t WRITE_TERM_TYPES[WRITE_TERMS] = { 0 };
+    static constexpr size_t LOOKUP_TUPLE_SIZE = 4;
+    static constexpr size_t INVERSE_EXISTS_POLYNOMIAL_DEGREE = 4;
+    static constexpr size_t READ_TERM_DEGREE = 0;
+    static constexpr size_t WRITE_TERM_DEGREE = 0;
+
+    // Columns using the Column enum.
+    static constexpr Column SRC_SELECTOR = Column::execution_sel;
+    static constexpr Column DST_SELECTOR = Column::precomputed_sel_bitwise;
+    static constexpr Column COUNTS = Column::lookup_dummy_precomputed_counts;
+    static constexpr Column INVERSES = Column::lookup_dummy_precomputed_inv;
+    static constexpr std::array<Column, LOOKUP_TUPLE_SIZE> SRC_COLUMNS = {
+        Column::execution_sel, Column::execution_clk, Column::execution_clk, Column::execution_clk
+    };
+    static constexpr std::array<Column, LOOKUP_TUPLE_SIZE> DST_COLUMNS = { Column::precomputed_bitwise_op_id,
+                                                                           Column::precomputed_bitwise_input_a,
+                                                                           Column::precomputed_bitwise_input_b,
+                                                                           Column::precomputed_bitwise_output };
+
+    template <typename AllEntities> static inline auto inverse_polynomial_is_computed_at_row(const AllEntities& in)
+    {
+        return (in.execution_sel == 1 || in.precomputed_sel_bitwise == 1);
+    }
+
+    template <typename Accumulator, typename AllEntities>
+    static inline auto compute_inverse_exists(const AllEntities& in)
+    {
+        using View = typename Accumulator::View;
+        const auto is_operation = View(in.execution_sel);
+        const auto is_table_entry = View(in.precomputed_sel_bitwise);
+        return (is_operation + is_table_entry - is_operation * is_table_entry);
+    }
+
+    template <typename AllEntities> static inline auto get_const_entities(const AllEntities& in)
+    {
+        return get_entities(in);
+    }
+
+    template <typename AllEntities> static inline auto get_nonconst_entities(AllEntities& in)
+    {
+        return get_entities(in);
+    }
+
+    template <typename AllEntities> static inline auto get_entities(AllEntities&& in)
+    {
+        return std::forward_as_tuple(in.lookup_dummy_precomputed_inv,
+                                     in.lookup_dummy_precomputed_counts,
+                                     in.execution_sel,
+                                     in.precomputed_sel_bitwise,
+                                     in.execution_sel,
+                                     in.execution_clk,
+                                     in.execution_clk,
+                                     in.execution_clk,
+                                     in.precomputed_bitwise_op_id,
+                                     in.precomputed_bitwise_input_a,
+                                     in.precomputed_bitwise_input_b,
+                                     in.precomputed_bitwise_output);
+    }
+};
+
+template <typename FF_>
+class lookup_dummy_precomputed_relation : public GenericLookupRelation<lookup_dummy_precomputed_lookup_settings, FF_> {
+  public:
+    static constexpr const char* NAME = "LOOKUP_DUMMY_PRECOMPUTED";
+};
+template <typename FF_> using lookup_dummy_precomputed = GenericLookup<lookup_dummy_precomputed_lookup_settings, FF_>;
+
+} // namespace bb::avm2
\ No newline at end of file
diff --git a/barretenberg/cpp/src/barretenberg/vm2/generated/relations/perm_dummy_dynamic.hpp b/barretenberg/cpp/src/barretenberg/vm2/generated/relations/perm_dummy_dynamic.hpp
new file mode 100644
index 00000000000..29dbb3493d7
--- /dev/null
+++ b/barretenberg/cpp/src/barretenberg/vm2/generated/relations/perm_dummy_dynamic.hpp
@@ -0,0 +1,67 @@
+// AUTOGENERATED FILE
+#pragma once
+
+#include "../columns.hpp"
+#include "barretenberg/relations/generic_permutation/generic_permutation_relation.hpp"
+
+#include <cstddef>
+#include <tuple>
+
+namespace bb::avm2 {
+
+class perm_dummy_dynamic_permutation_settings {
+  public:
+    // This constant defines how many columns are bundled together to form each set.
+    constexpr static size_t COLUMNS_PER_SET = 4;
+
+    // Columns using the Column enum.
+    static constexpr Column SRC_SELECTOR = Column::execution_sel;
+    static constexpr Column DST_SELECTOR = Column::execution_sel;
+    static constexpr Column INVERSES = Column::perm_dummy_dynamic_inv;
+
+    template <typename AllEntities> static inline auto inverse_polynomial_is_computed_at_row(const AllEntities& in)
+    {
+        return (in.execution_sel == 1 || in.execution_sel == 1);
+    }
+
+    template <typename AllEntities> static inline auto get_const_entities(const AllEntities& in)
+    {
+        return std::forward_as_tuple(in.perm_dummy_dynamic_inv,
+                                     in.execution_sel,
+                                     in.execution_sel,
+                                     in.execution_sel,
+                                     in.execution_op1,
+                                     in.execution_op2,
+                                     in.execution_op3,
+                                     in.execution_op4,
+                                     in.execution_op1,
+                                     in.execution_op2,
+                                     in.execution_op3,
+                                     in.execution_op4);
+    }
+
+    template <typename AllEntities> static inline auto get_nonconst_entities(AllEntities& in)
+    {
+        return std::forward_as_tuple(in.perm_dummy_dynamic_inv,
+                                     in.execution_sel,
+                                     in.execution_sel,
+                                     in.execution_sel,
+                                     in.execution_op1,
+                                     in.execution_op2,
+                                     in.execution_op3,
+                                     in.execution_op4,
+                                     in.execution_op1,
+                                     in.execution_op2,
+                                     in.execution_op3,
+                                     in.execution_op4);
+    }
+};
+
+template <typename FF_>
+class perm_dummy_dynamic_relation : public GenericPermutationRelation<perm_dummy_dynamic_permutation_settings, FF_> {
+  public:
+    static constexpr const char* NAME = "PERM_DUMMY_DYNAMIC";
+};
+template <typename FF_> using perm_dummy_dynamic = GenericPermutation<perm_dummy_dynamic_permutation_settings, FF_>;
+
+} // namespace bb::avm2
\ No newline at end of file
diff --git a/barretenberg/cpp/src/barretenberg/vm2/generated/verifier.cpp b/barretenberg/cpp/src/barretenberg/vm2/generated/verifier.cpp
new file mode 100644
index 00000000000..e00177c7bc4
--- /dev/null
+++ b/barretenberg/cpp/src/barretenberg/vm2/generated/verifier.cpp
@@ -0,0 +1,128 @@
+// AUTOGENERATED FILE
+#include "verifier.hpp"
+#include "barretenberg/commitment_schemes/shplonk/shplemini.hpp"
+#include "barretenberg/common/log.hpp"
+#include "barretenberg/numeric/bitop/get_msb.hpp"
+#include "barretenberg/transcript/transcript.hpp"
+#include "barretenberg/vm/constants.hpp"
+
+namespace bb::avm2 {
+
+AvmVerifier::AvmVerifier(std::shared_ptr<Flavor::VerificationKey> verifier_key)
+    : key(std::move(verifier_key))
+{}
+
+AvmVerifier::AvmVerifier(AvmVerifier&& other) noexcept
+    : key(std::move(other.key))
+{}
+
+AvmVerifier& AvmVerifier::operator=(AvmVerifier&& other) noexcept
+{
+    key = other.key;
+    commitments.clear();
+    return *this;
+}
+
+using FF = AvmFlavor::FF;
+
+// Evaluate the given public input column over the multivariate challenge points
+inline FF AvmVerifier::evaluate_public_input_column(const std::vector<FF>& points, std::vector<FF> challenges)
+{
+    Polynomial<FF> polynomial(points, key->circuit_size);
+    return polynomial.evaluate_mle(challenges);
+}
+
+/**
+ * @brief This function verifies an Avm Honk proof for given program settings.
+ *
+ */
+bool AvmVerifier::verify_proof(const HonkProof& proof, const std::vector<std::vector<FF>>& public_inputs)
+{
+    using Flavor = AvmFlavor;
+    using FF = Flavor::FF;
+    using Commitment = Flavor::Commitment;
+    using PCS = Flavor::PCS;
+    using Curve = Flavor::Curve;
+    using VerifierCommitments = Flavor::VerifierCommitments;
+    using CommitmentLabels = Flavor::CommitmentLabels;
+    using Shplemini = ShpleminiVerifier_<Curve>;
+
+    RelationParameters<FF> relation_parameters;
+
+    transcript = std::make_shared<Transcript>(proof);
+
+    VerifierCommitments commitments{ key };
+    CommitmentLabels commitment_labels;
+
+    const auto circuit_size = transcript->template receive_from_prover<uint32_t>("circuit_size");
+    if (circuit_size != key->circuit_size) {
+        vinfo("Circuit size mismatch: expected", key->circuit_size, " got ", circuit_size);
+        return false;
+    }
+
+    // Get commitments to VM wires
+    for (auto [comm, label] : zip_view(commitments.get_wires(), commitment_labels.get_wires())) {
+        comm = transcript->template receive_from_prover<Commitment>(label);
+    }
+
+    auto [beta, gamm] = transcript->template get_challenges<FF>("beta", "gamma");
+    relation_parameters.beta = beta;
+    relation_parameters.gamma = gamm;
+
+    // Get commitments to inverses
+    for (auto [label, commitment] : zip_view(commitment_labels.get_derived(), commitments.get_derived())) {
+        commitment = transcript->template receive_from_prover<Commitment>(label);
+    }
+
+    // Execute Sumcheck Verifier
+    const size_t log_circuit_size = numeric::get_msb(circuit_size);
+    auto sumcheck = SumcheckVerifier<Flavor>(log_circuit_size, transcript);
+
+    FF alpha = transcript->template get_challenge<FF>("Sumcheck:alpha");
+
+    auto gate_challenges = std::vector<FF>(log_circuit_size);
+    for (size_t idx = 0; idx < log_circuit_size; idx++) {
+        gate_challenges[idx] = transcript->template get_challenge<FF>("Sumcheck:gate_challenge_" + std::to_string(idx));
+    }
+
+    auto [multivariate_challenge, claimed_evaluations, sumcheck_verified] =
+        sumcheck.verify(relation_parameters, alpha, gate_challenges);
+
+    // If Sumcheck did not verify, return false
+    if (!sumcheck_verified.has_value() || !sumcheck_verified.value()) {
+        vinfo("Sumcheck verification failed");
+        return false;
+    }
+
+    // Public columns evaluation checks
+    std::vector<FF> mle_challenge(multivariate_challenge.begin(),
+                                  multivariate_challenge.begin() + static_cast<int>(log_circuit_size));
+
+    FF execution_input_evaluation = evaluate_public_input_column(public_inputs[0], mle_challenge);
+    if (execution_input_evaluation != claimed_evaluations.execution_input) {
+        vinfo("execution_input_evaluation failed");
+        return false;
+    }
+
+    const BatchOpeningClaim<Curve> opening_claim =
+        Shplemini::compute_batch_opening_claim(circuit_size,
+                                               commitments.get_unshifted(),
+                                               commitments.get_to_be_shifted(),
+                                               claimed_evaluations.get_unshifted(),
+                                               claimed_evaluations.get_shifted(),
+                                               multivariate_challenge,
+                                               Commitment::one(),
+                                               transcript);
+
+    const auto pairing_points = PCS::reduce_verify_batch_opening_claim(opening_claim, transcript);
+    const auto shplemini_verified = key->pcs_verification_key->pairing_check(pairing_points[0], pairing_points[1]);
+
+    if (!shplemini_verified) {
+        vinfo("Shplemini verification failed");
+        return false;
+    }
+
+    return true;
+}
+
+} // namespace bb::avm2
diff --git a/barretenberg/cpp/src/barretenberg/vm2/generated/verifier.hpp b/barretenberg/cpp/src/barretenberg/vm2/generated/verifier.hpp
new file mode 100644
index 00000000000..c969e3c51d2
--- /dev/null
+++ b/barretenberg/cpp/src/barretenberg/vm2/generated/verifier.hpp
@@ -0,0 +1,39 @@
+// AUTOGENERATED FILE
+#pragma once
+
+#include "barretenberg/plonk/proof_system/types/proof.hpp"
+#include "barretenberg/sumcheck/sumcheck.hpp"
+#include "flavor.hpp"
+
+namespace bb::avm2 {
+
+class AvmVerifier {
+  public:
+    using Flavor = AvmFlavor;
+    using FF = Flavor::FF;
+    using Commitment = Flavor::Commitment;
+    using VerificationKey = Flavor::VerificationKey;
+    using VerifierCommitmentKey = Flavor::VerifierCommitmentKey;
+    using Transcript = Flavor::Transcript;
+
+    explicit AvmVerifier(std::shared_ptr<VerificationKey> verifier_key);
+    AvmVerifier(AvmVerifier&& other) noexcept;
+    AvmVerifier(const AvmVerifier& other) = delete;
+    virtual ~AvmVerifier() = default;
+
+    AvmVerifier& operator=(const AvmVerifier& other) = delete;
+    AvmVerifier& operator=(AvmVerifier&& other) noexcept;
+
+    // Note: all the following methods are virtual to allow Avm2 to tweak the behaviour.
+    // We can remove this once the transition is done.
+    virtual bool verify_proof(const HonkProof& proof, const std::vector<std::vector<FF>>& public_inputs);
+
+    std::shared_ptr<VerificationKey> key;
+    std::map<std::string, Commitment> commitments;
+    std::shared_ptr<Transcript> transcript;
+
+  private:
+    FF evaluate_public_input_column(const std::vector<FF>& points, std::vector<FF> challenges);
+};
+
+} // namespace bb::avm2
\ No newline at end of file
diff --git a/barretenberg/cpp/src/barretenberg/vm2/proving_helper.cpp b/barretenberg/cpp/src/barretenberg/vm2/proving_helper.cpp
new file mode 100644
index 00000000000..16ecc1ffcfb
--- /dev/null
+++ b/barretenberg/cpp/src/barretenberg/vm2/proving_helper.cpp
@@ -0,0 +1,184 @@
+#include "barretenberg/vm2/proving_helper.hpp"
+
+#include <memory>
+
+#include "barretenberg/common/serialize.hpp"
+#include "barretenberg/common/thread.hpp"
+#include "barretenberg/numeric/bitop/get_msb.hpp"
+#include "barretenberg/vm/stats.hpp"
+#include "barretenberg/vm2/common/constants.hpp"
+#include "barretenberg/vm2/constraining/check_circuit.hpp"
+#include "barretenberg/vm2/generated/prover.hpp"
+#include "barretenberg/vm2/generated/verifier.hpp"
+
+namespace bb::avm2 {
+namespace {
+
+// TODO: This doesn't need to be a shared_ptr, but BB requires it.
+std::shared_ptr<AvmProver::ProvingKey> create_proving_key(AvmProver::ProverPolynomials& polynomials)
+{
+    // TODO: Why is num_public_inputs 0?
+    auto proving_key = std::make_shared<AvmProver::ProvingKey>(CIRCUIT_SUBGROUP_SIZE, /*num_public_inputs=*/0);
+
+    for (auto [key_poly, prover_poly] : zip_view(proving_key->get_all(), polynomials.get_unshifted())) {
+        ASSERT(flavor_get_label(*proving_key, key_poly) == flavor_get_label(polynomials, prover_poly));
+        key_poly = std::move(prover_poly);
+    }
+
+    proving_key->commitment_key = std::make_shared<AvmProver::PCSCommitmentKey>(CIRCUIT_SUBGROUP_SIZE);
+
+    return proving_key;
+}
+
+AvmProver::ProverPolynomials compute_polynomials(tracegen::TraceContainer& trace)
+{
+    AvmProver::ProverPolynomials polys;
+
+    // Polynomials that will be shifted need special care.
+    AVM_TRACK_TIME("proving/init_polys_to_be_shifted", ({
+                       auto to_be_shifted = polys.get_to_be_shifted();
+
+                       // TODO: cannot parallelize because Polynomial construction uses parallelism.
+                       for (size_t i = 0; i < to_be_shifted.size(); i++) {
+                           auto& poly = to_be_shifted[i];
+                           // WARNING! Column-Polynomials order matters!
+                           Column col = static_cast<Column>(TO_BE_SHIFTED_COLUMNS_ARRAY.at(i));
+                           // We need at least 2 rows for the shifted columns.
+                           uint32_t num_rows = std::max<uint32_t>(trace.get_column_rows(col), 2);
+
+                           poly = AvmProver::Polynomial(
+                               /*memory size*/
+                               num_rows - 1,
+                               /*largest possible index*/ CIRCUIT_SUBGROUP_SIZE,
+                               /*make shiftable with offset*/ 1);
+                       }
+                   }));
+
+    // Catch-all with fully formed polynomials
+    // Note: derived polynomials (i.e., inverses) are not in the trace at this point, because they can only
+    // be computed after committing to the other witnesses. Therefore, they will be initialized as empty
+    // and they will be not set below. The derived polynomials will be reinitialized and set in the prover
+    // itself mid-proving. (TO BE DONE!).
+    //
+    // NOTE FOR SELF: however, the counts will be known here and the inv have the same size?
+    // think about it and check the formula.
+    AVM_TRACK_TIME("proving/init_polys_unshifted", ({
+                       auto unshifted = polys.get_unshifted();
+
+                       // Derived polynomials will be empty.
+                       bb::parallel_for(unshifted.size(), [&](size_t i) {
+                           auto& poly = unshifted[i];
+                           // FIXME: this is a bad way to check if the polynomial is already initialized.
+                           // It could be that it has been initialized, but it's all zeroes.
+                           if (!poly.is_empty()) {
+                               // Already initialized above.
+                               return;
+                           }
+
+                           // WARNING! Column-Polynomials order matters!
+                           Column col = static_cast<Column>(i);
+                           const auto num_rows = trace.get_column_rows(col);
+                           poly = AvmProver::Polynomial::create_non_parallel_zero_init(num_rows, CIRCUIT_SUBGROUP_SIZE);
+                       });
+                   }));
+
+    AVM_TRACK_TIME("proving/set_polys_unshifted", ({
+                       auto unshifted = polys.get_unshifted();
+
+                       // TODO: We are now visiting per-column. Profile if per-row is better.
+                       // This would need changes to the trace container.
+                       bb::parallel_for(unshifted.size(), [&](size_t i) {
+                           // WARNING! Column-Polynomials order matters!
+                           auto& poly = unshifted[i];
+                           Column col = static_cast<Column>(i);
+
+                           trace.visit_column(col, [&](size_t row, const AvmProver::FF& value) {
+                               // We use `at` because we are sure the row exists and the value is non-zero.
+                               poly.at(row) = value;
+                           });
+                           // We free columns as we go.
+                           // TODO: If we merge the init with the setting, this would be even more memory efficient.
+                           trace.clear_column(col);
+                       });
+                   }));
+
+    AVM_TRACK_TIME("proving/set_polys_shifted", ({
+                       for (auto [shifted, to_be_shifted] : zip_view(polys.get_shifted(), polys.get_to_be_shifted())) {
+                           shifted = to_be_shifted.shifted();
+                       }
+                   }));
+
+    return polys;
+}
+
+} // namespace
+
+std::pair<AvmProvingHelper::Proof, AvmProvingHelper::VkData> AvmProvingHelper::prove(tracegen::TraceContainer&& trace)
+{
+    auto polynomials = AVM_TRACK_TIME_V("proving/prove:compute_polynomials", compute_polynomials(trace));
+    auto proving_key = AVM_TRACK_TIME_V("proving/prove:proving_key", create_proving_key(polynomials));
+    auto prover =
+        AVM_TRACK_TIME_V("proving/prove:construct_prover", AvmProver(proving_key, proving_key->commitment_key));
+    auto verification_key =
+        AVM_TRACK_TIME_V("proving/prove:verification_key", std::make_shared<AvmVerifier::VerificationKey>(proving_key));
+
+    auto proof = AVM_TRACK_TIME_V("proving/construct_proof", prover.construct_proof());
+    auto serialized_vk = to_buffer(verification_key->to_field_elements());
+
+    return { std::move(proof), std::move(serialized_vk) };
+}
+
+bool AvmProvingHelper::check_circuit(tracegen::TraceContainer&& trace)
+{
+    // The proof is done over the whole circuit (2^21 rows).
+    // However, for check-circuit purposes we run only over the trace rows
+    // PLUS one extra row to catch any possible errors in the empty remainder
+    // of the circuit.
+    const size_t num_rows = trace.get_num_rows_without_clk() + 1;
+    info("Running check circuit over ", num_rows, " rows.");
+
+    auto polynomials = AVM_TRACK_TIME_V("proving/prove:compute_polynomials", compute_polynomials(trace));
+    try {
+        AVM_TRACK_TIME("proving/check_circuit", constraining::run_check_circuit(polynomials, num_rows));
+    } catch (const std::exception& e) {
+        info("Circuit check failed: ", e.what());
+        return false;
+    }
+
+    return true;
+}
+
+bool AvmProvingHelper::verify(const AvmProvingHelper::Proof& proof, const PublicInputs& pi, const VkData& vk_data)
+{
+    using VerificationKey = AvmVerifier::VerificationKey;
+    std::vector<fr> vk_as_fields = many_from_buffer<AvmFlavorSettings::FF>(vk_data);
+
+    auto circuit_size = uint64_t(vk_as_fields[0]);
+    auto num_public_inputs = uint64_t(vk_as_fields[1]);
+    std::span vk_span(vk_as_fields);
+
+    vinfo("vk fields size: ", vk_as_fields.size());
+    vinfo("circuit size: ",
+          circuit_size,
+          " (next or eq power: 2^",
+          numeric::get_msb(numeric::round_up_power_2(circuit_size)),
+          ")");
+    // WARNING: The number of public inputs in the verification key is always 0!
+    // Apparently we use some other mechanism to check the public inputs.
+    vinfo("num of pub inputs: ", num_public_inputs);
+
+    std::array<VerificationKey::Commitment, VerificationKey::NUM_PRECOMPUTED_COMMITMENTS> precomputed_cmts;
+    for (size_t i = 0; i < VerificationKey::NUM_PRECOMPUTED_COMMITMENTS; i++) {
+        // Start at offset 2 and adds 4 (NUM_FRS_COM) fr elements per commitment. Therefore, index = 4 * i + 2.
+        precomputed_cmts[i] = field_conversion::convert_from_bn254_frs<VerificationKey::Commitment>(
+            vk_span.subspan(AvmFlavor::NUM_FRS_COM * i + 2, AvmFlavor::NUM_FRS_COM));
+    }
+
+    auto vk = AVM_TRACK_TIME_V("proving/verify:verification_key",
+                               std::make_shared<VerificationKey>(circuit_size, num_public_inputs, precomputed_cmts));
+
+    auto verifier = AVM_TRACK_TIME_V("proving/verify:construct_verifier", AvmVerifier(std::move(vk)));
+    return AVM_TRACK_TIME_V("proving/verify_proof", verifier.verify_proof(proof, pi.to_columns()));
+}
+
+} // namespace bb::avm2
\ No newline at end of file
diff --git a/barretenberg/cpp/src/barretenberg/vm2/proving_helper.hpp b/barretenberg/cpp/src/barretenberg/vm2/proving_helper.hpp
new file mode 100644
index 00000000000..ce10f6ec7ec
--- /dev/null
+++ b/barretenberg/cpp/src/barretenberg/vm2/proving_helper.hpp
@@ -0,0 +1,22 @@
+#pragma once
+
+#include "barretenberg/honk/proof_system/types/proof.hpp"
+#include "barretenberg/vm2/common/avm_inputs.hpp"
+#include "barretenberg/vm2/generated/prover.hpp"
+#include "barretenberg/vm2/generated/verifier.hpp"
+#include "barretenberg/vm2/tracegen/trace_container.hpp"
+
+namespace bb::avm2 {
+
+class AvmProvingHelper {
+  public:
+    AvmProvingHelper() = default;
+    using Proof = AvmProver::Proof;
+    using VkData = std::vector<uint8_t>;
+
+    std::pair<Proof, VkData> prove(tracegen::TraceContainer&& trace);
+    bool check_circuit(tracegen::TraceContainer&& trace);
+    bool verify(const Proof& proof, const PublicInputs& pi, const VkData& vk_data);
+};
+
+} // namespace bb::avm2
\ No newline at end of file
diff --git a/barretenberg/cpp/src/barretenberg/vm2/simulation/addressing.cpp b/barretenberg/cpp/src/barretenberg/vm2/simulation/addressing.cpp
new file mode 100644
index 00000000000..80d964cd8f0
--- /dev/null
+++ b/barretenberg/cpp/src/barretenberg/vm2/simulation/addressing.cpp
@@ -0,0 +1,90 @@
+#include "barretenberg/vm2/simulation/addressing.hpp"
+
+#include <algorithm>
+#include <cstdint>
+#include <vector>
+
+#include "barretenberg/common/log.hpp"
+#include "barretenberg/vm2/common/memory_types.hpp"
+#include "barretenberg/vm2/simulation/events/addressing_event.hpp"
+#include "barretenberg/vm2/simulation/events/event_emitter.hpp"
+#include "barretenberg/vm2/simulation/events/memory_event.hpp"
+#include "barretenberg/vm2/simulation/lib/serialization.hpp"
+#include "barretenberg/vm2/simulation/memory.hpp"
+
+namespace bb::avm2::simulation {
+
+std::vector<Operand> Addressing::resolve(const Instruction& instruction, MemoryInterface& memory) const
+{
+    // We'll be filling in the event as we progress.
+    AddressingEvent event;
+    event.instruction = instruction;
+
+    try {
+        // Note: it's fine to query instruction info in here since it does not trigger events.
+        ExecutionOpCode opcode = instruction_info_db.map_wire_opcode_to_execution_opcode(instruction.opcode);
+        const InstructionSpec& spec = instruction_info_db.get(opcode);
+        event.spec = &spec;
+        // This represents either: (1) wrong info in the spec, or (2) a wrong witgen deserialization.
+        // Therefore, it is not an error the circuit should be able to prove.
+        assert(spec.num_addresses <= instruction.operands.size());
+
+        // We retrieve, cache first because this is probably what we'll do in the circuit.
+        // However, we can't check the value and tag yet! This should be done only if it's used.
+        // This is because the first few instructions might not YET have a valid stack pointer.
+        auto stack_pointer = memory.get(0);
+        event.stack_pointer_tag = stack_pointer.tag;
+        event.stack_pointer_val = stack_pointer.value;
+
+        // First process relative addressing for all the addresses.
+        event.after_relative = instruction.operands;
+        for (size_t i = 0; i < spec.num_addresses; ++i) {
+            if ((instruction.indirect >> i) & 1) {
+                if (!memory.is_valid_address(stack_pointer)) {
+                    throw AddressingException(AddressingEventError::STACK_POINTER_INVALID_ADDRESS, i);
+                }
+
+                MemoryValue offset(event.after_relative[i]);
+                offset += stack_pointer.value;
+                event.after_relative[i] = Operand::ff(offset);
+                if (!memory.is_valid_address(offset)) {
+                    throw AddressingException(AddressingEventError::RELATIVE_COMPUTATION_OOB, i);
+                }
+            }
+        }
+
+        // Then indirection.
+        event.resolved_operands = event.after_relative;
+        for (size_t i = 0; i < spec.num_addresses; ++i) {
+            if ((instruction.indirect >> (i + spec.num_addresses)) & 1) {
+                MemoryValue offset(event.resolved_operands[i]);
+                if (!memory.is_valid_address(offset)) {
+                    throw AddressingException(AddressingEventError::INDIRECT_INVALID_ADDRESS, i);
+                }
+                auto new_address = memory.get(static_cast<MemoryAddress>(offset));
+                event.resolved_operands[i] = Operand::ff(new_address.value);
+            }
+        }
+
+        // We guarantee that the resolved operands are valid addresses.
+        for (size_t i = 0; i < spec.num_addresses; ++i) {
+            if (!memory.is_valid_address(MemoryValue(event.resolved_operands[i]))) {
+                throw AddressingException(AddressingEventError::FINAL_ADDRESS_INVALID, i);
+            }
+            event.resolved_operands[i] =
+                static_cast<Operand>(static_cast<MemoryAddress>(event.resolved_operands[i].operator FF()));
+        }
+    } catch (const AddressingException& e) {
+        event.error = e;
+    }
+
+    events.emit(AddressingEvent(event));
+    if (event.error.has_value()) {
+        // Signal the error to the caller.
+        throw AddressingException(event.error.value());
+    }
+
+    return event.resolved_operands;
+}
+
+} // namespace bb::avm2::simulation
\ No newline at end of file
diff --git a/barretenberg/cpp/src/barretenberg/vm2/simulation/addressing.hpp b/barretenberg/cpp/src/barretenberg/vm2/simulation/addressing.hpp
new file mode 100644
index 00000000000..b44319effef
--- /dev/null
+++ b/barretenberg/cpp/src/barretenberg/vm2/simulation/addressing.hpp
@@ -0,0 +1,39 @@
+#pragma once
+
+#include <array>
+#include <cassert>
+#include <cstdint>
+#include <span>
+
+#include "barretenberg/vm2/common/memory_types.hpp"
+#include "barretenberg/vm2/simulation/events/addressing_event.hpp"
+#include "barretenberg/vm2/simulation/events/event_emitter.hpp"
+#include "barretenberg/vm2/simulation/lib/instruction_info.hpp"
+#include "barretenberg/vm2/simulation/lib/serialization.hpp"
+#include "barretenberg/vm2/simulation/memory.hpp"
+
+namespace bb::avm2::simulation {
+
+class AddressingInterface {
+  public:
+    virtual ~AddressingInterface() = default;
+    // @throws AddressingException.
+    virtual std::vector<Operand> resolve(const Instruction& instruction, MemoryInterface& memory) const = 0;
+};
+
+class Addressing final : public AddressingInterface {
+  public:
+    Addressing(const InstructionInfoDBInterface& instruction_info_db,
+               EventEmitterInterface<AddressingEvent>& event_emitter)
+        : instruction_info_db(instruction_info_db)
+        , events(event_emitter)
+    {}
+
+    std::vector<Operand> resolve(const Instruction& instruction, MemoryInterface& memory) const override;
+
+  private:
+    const InstructionInfoDBInterface& instruction_info_db;
+    EventEmitterInterface<AddressingEvent>& events;
+};
+
+} // namespace bb::avm2::simulation
\ No newline at end of file
diff --git a/barretenberg/cpp/src/barretenberg/vm2/simulation/alu.cpp b/barretenberg/cpp/src/barretenberg/vm2/simulation/alu.cpp
new file mode 100644
index 00000000000..d901499b85f
--- /dev/null
+++ b/barretenberg/cpp/src/barretenberg/vm2/simulation/alu.cpp
@@ -0,0 +1,29 @@
+#include "barretenberg/vm2/simulation/alu.hpp"
+
+#include <cstdint>
+#include <memory>
+
+namespace bb::avm2::simulation {
+
+void Alu::add(ContextInterface& context, MemoryAddress a_addr, MemoryAddress b_addr, MemoryAddress dst_addr)
+{
+    auto& memory = context.get_memory();
+
+    // TODO: check types and tags and propagate.
+    auto a = memory.get(a_addr);
+    auto b = memory.get(b_addr);
+    // TODO: handle different types, wrapping, etc.
+    auto c = a.value + b.value;
+    memory.set(dst_addr, c, a.tag);
+
+    // TODO: add tags to events.
+    events.emit({ .operation = AluOperation::ADD,
+                  .a_addr = a_addr,
+                  .b_addr = b_addr,
+                  .dst_addr = dst_addr,
+                  .a = a.value,
+                  .b = b.value,
+                  .res = c });
+}
+
+} // namespace bb::avm2::simulation
\ No newline at end of file
diff --git a/barretenberg/cpp/src/barretenberg/vm2/simulation/alu.hpp b/barretenberg/cpp/src/barretenberg/vm2/simulation/alu.hpp
new file mode 100644
index 00000000000..4d06ad2d34f
--- /dev/null
+++ b/barretenberg/cpp/src/barretenberg/vm2/simulation/alu.hpp
@@ -0,0 +1,33 @@
+#pragma once
+
+#include <cstdint>
+#include <memory>
+
+#include "barretenberg/vm2/common/memory_types.hpp"
+#include "barretenberg/vm2/simulation/context.hpp"
+#include "barretenberg/vm2/simulation/events/alu_event.hpp"
+#include "barretenberg/vm2/simulation/events/event_emitter.hpp"
+#include "barretenberg/vm2/simulation/memory.hpp"
+
+namespace bb::avm2::simulation {
+
+class AluInterface {
+  public:
+    virtual ~AluInterface() = default;
+    virtual void add(ContextInterface&, MemoryAddress a_addr, MemoryAddress b_addr, MemoryAddress dst_addr) = 0;
+};
+
+class Alu : public AluInterface {
+  public:
+    Alu(EventEmitterInterface<AluEvent>& event_emitter)
+        : events(event_emitter)
+    {}
+
+    // Operands are expected to be direct.
+    void add(ContextInterface& context, MemoryAddress a_addr, MemoryAddress b_addr, MemoryAddress dst_addr) override;
+
+  private:
+    EventEmitterInterface<AluEvent>& events;
+};
+
+} // namespace bb::avm2::simulation
\ No newline at end of file
diff --git a/barretenberg/cpp/src/barretenberg/vm2/simulation/alu.test.cpp b/barretenberg/cpp/src/barretenberg/vm2/simulation/alu.test.cpp
new file mode 100644
index 00000000000..92bbb76735d
--- /dev/null
+++ b/barretenberg/cpp/src/barretenberg/vm2/simulation/alu.test.cpp
@@ -0,0 +1,44 @@
+#include "barretenberg/vm2/simulation/alu.hpp"
+
+#include <gmock/gmock.h>
+#include <gtest/gtest.h>
+
+#include "barretenberg/vm2/common/memory_types.hpp"
+#include "barretenberg/vm2/simulation/events/event_emitter.hpp"
+#include "barretenberg/vm2/simulation/events/memory_event.hpp"
+#include "barretenberg/vm2/simulation/memory.hpp"
+#include "barretenberg/vm2/simulation/testing/mock_context.hpp"
+
+namespace bb::avm2::simulation {
+namespace {
+
+using ::testing::ReturnRef;
+using ::testing::StrictMock;
+
+TEST(AvmSimulationAluTest, Add)
+{
+    NoopEventEmitter<MemoryEvent> emitter;
+    Memory mem(/*space_id=*/0, emitter);
+    StrictMock<MockContext> context;
+    EXPECT_CALL(context, get_memory()).WillRepeatedly(ReturnRef(mem));
+
+    EventEmitter<AluEvent> alu_event_emitter;
+    Alu alu(alu_event_emitter);
+
+    // TODO: actually can choose to mock, not even use a memory, check the events, etc.
+    MemoryAddress a_addr = 0;
+    MemoryAddress b_addr = 1;
+    MemoryAddress dst_addr = 2;
+
+    mem.set(a_addr, 1, MemoryTag::U32);
+    mem.set(b_addr, 2, MemoryTag::U32);
+
+    alu.add(context, a_addr, b_addr, dst_addr);
+
+    auto c = mem.get(dst_addr);
+    EXPECT_EQ(c.value, 3);
+    EXPECT_EQ(c.tag, MemoryTag::U32);
+}
+
+} // namespace
+} // namespace bb::avm2::simulation
\ No newline at end of file
diff --git a/barretenberg/cpp/src/barretenberg/vm2/simulation/bytecode_manager.cpp b/barretenberg/cpp/src/barretenberg/vm2/simulation/bytecode_manager.cpp
new file mode 100644
index 00000000000..a94420bc14e
--- /dev/null
+++ b/barretenberg/cpp/src/barretenberg/vm2/simulation/bytecode_manager.cpp
@@ -0,0 +1,63 @@
+#include "barretenberg/vm2/simulation/bytecode_manager.hpp"
+
+#include "barretenberg/common/serialize.hpp"
+#include "barretenberg/vm2/common/aztec_types.hpp"
+#include "barretenberg/vm2/simulation/lib/contract_crypto.hpp"
+#include "barretenberg/vm2/simulation/lib/serialization.hpp"
+
+namespace bb::avm2::simulation {
+
+BytecodeId TxBytecodeManager::get_bytecode(const AztecAddress& address)
+{
+    // TODO: in principle we want to do this, but we can't make hints fail. Think about it.
+    // auto it = resolved_addresses.find(address);
+    // if (it != resolved_addresses.end()) {
+    //     return it->second;
+    // }
+
+    // TODO: catch errors etc.
+    // TODO: we should trigger the proper merkle checks etc. The raw DB doesn't.
+    ContractInstance instance = db.get_contract_instance(address);
+    ContractClass klass = db.get_contract_class(instance.contract_class_id);
+    FF hash = compute_public_bytecode_commitment(klass.packed_bytecode);
+    info("Bytecode for ", address, " successfully retrieved!");
+
+    // We convert the bytecode to a shared_ptr because it will be shared by some events.
+    auto shared_bytecode = std::make_shared<std::vector<uint8_t>>(std::move(klass.packed_bytecode));
+    hash_events.emit({ .class_id = instance.contract_class_id, .bytecode = shared_bytecode, .hash = hash });
+
+    // We now save the bytecode so that we don't repeat this process.
+    auto bytecode_id = next_bytecode_id++;
+    resolved_addresses[address] = bytecode_id;
+    bytecodes.emplace(bytecode_id, BytecodeInfo{ .bytecode = shared_bytecode, .class_id = instance.contract_class_id });
+
+    return bytecode_id;
+}
+
+Instruction TxBytecodeManager::read_instruction(BytecodeId bytecode_id, uint32_t pc)
+{
+    auto it = bytecodes.find(bytecode_id);
+    if (it == bytecodes.end()) {
+        throw std::runtime_error("Bytecode not found");
+    }
+
+    const auto& bytecode = *it->second.bytecode;
+    // TODO: catch errors etc.
+    Instruction instruction = decode_instruction(bytecode, pc);
+
+    decomposition_events.emit({ .class_id = it->second.class_id, .pc = pc, .instruction = instruction });
+
+    return instruction;
+}
+
+ContractClassId TxBytecodeManager::get_class_id(BytecodeId bytecode_id) const
+{
+    auto it = bytecodes.find(bytecode_id);
+    if (it == bytecodes.end()) {
+        throw std::runtime_error("Bytecode not found");
+    }
+
+    return it->second.class_id;
+}
+
+} // namespace bb::avm2::simulation
\ No newline at end of file
diff --git a/barretenberg/cpp/src/barretenberg/vm2/simulation/bytecode_manager.hpp b/barretenberg/cpp/src/barretenberg/vm2/simulation/bytecode_manager.hpp
new file mode 100644
index 00000000000..3fff445411d
--- /dev/null
+++ b/barretenberg/cpp/src/barretenberg/vm2/simulation/bytecode_manager.hpp
@@ -0,0 +1,93 @@
+#pragma once
+
+#include <cstdint>
+#include <memory>
+#include <span>
+#include <sys/types.h>
+#include <utility>
+#include <vector>
+
+#include "barretenberg/vm2/common/aztec_types.hpp"
+#include "barretenberg/vm2/common/map.hpp"
+#include "barretenberg/vm2/simulation/events/bytecode_events.hpp"
+#include "barretenberg/vm2/simulation/events/event_emitter.hpp"
+#include "barretenberg/vm2/simulation/lib/raw_data_db.hpp"
+#include "barretenberg/vm2/simulation/lib/serialization.hpp"
+
+namespace bb::avm2::simulation {
+
+using BytecodeId = uint32_t;
+
+// Manages the bytecode operations of all calls in a transaction.
+// In particular, it will not duplicate hashing and decomposition.
+class TxBytecodeManagerInterface {
+  public:
+    virtual ~TxBytecodeManagerInterface() = default;
+
+    // Retrieves the bytecode and
+    // (1) sets up the address-class id connection,
+    // (2) hashes it if needed.
+    virtual BytecodeId get_bytecode(const AztecAddress& address) = 0;
+    // Retrieves an instruction and decomposes it if needed.
+    virtual Instruction read_instruction(BytecodeId bytecode_id, uint32_t pc) = 0;
+    // Retrieves the class id of a bytecode, in case you need it.
+    virtual ContractClassId get_class_id(BytecodeId bytecode_id) const = 0;
+};
+
+class TxBytecodeManager : public TxBytecodeManagerInterface {
+  public:
+    TxBytecodeManager(RawDataDBInterface& db,
+                      EventEmitterInterface<BytecodeHashingEvent>& hash_events,
+                      EventEmitterInterface<BytecodeDecompositionEvent>& decomposition_events)
+        : db(db)
+        , hash_events(hash_events)
+        , decomposition_events(decomposition_events)
+    {}
+
+    BytecodeId get_bytecode(const AztecAddress& address) override;
+    Instruction read_instruction(BytecodeId bytecode_id, uint32_t pc) override;
+    ContractClassId get_class_id(BytecodeId bytecode_id) const override;
+
+  private:
+    struct BytecodeInfo {
+        std::shared_ptr<std::vector<uint8_t>> bytecode;
+        ContractClassId class_id;
+    };
+
+    RawDataDBInterface& db;
+    EventEmitterInterface<BytecodeHashingEvent>& hash_events;
+    EventEmitterInterface<BytecodeDecompositionEvent>& decomposition_events;
+    unordered_flat_map<BytecodeId, const BytecodeInfo> bytecodes;
+    unordered_flat_map<AztecAddress, BytecodeId> resolved_addresses;
+    BytecodeId next_bytecode_id = 0;
+};
+
+// Manages the bytecode of a single nested call.
+// Mostly a wrapper around a TxBytecodeManager.
+class BytecodeManagerInterface {
+  public:
+    virtual ~BytecodeManagerInterface() = default;
+
+    virtual Instruction read_instruction(uint32_t pc) const = 0;
+    virtual ContractClassId get_class_id() const = 0;
+};
+
+class BytecodeManager : public BytecodeManagerInterface {
+  public:
+    BytecodeManager(BytecodeId bytecode_id, TxBytecodeManagerInterface& tx_bytecode_manager)
+        : bytecode_id(bytecode_id)
+        , tx_bytecode_manager(tx_bytecode_manager)
+    {}
+
+    Instruction read_instruction(uint32_t pc) const override
+    {
+        return tx_bytecode_manager.read_instruction(bytecode_id, pc);
+    }
+    ContractClassId get_class_id() const override { return tx_bytecode_manager.get_class_id(bytecode_id); }
+
+  private:
+    BytecodeId bytecode_id;
+    TxBytecodeManagerInterface& tx_bytecode_manager;
+};
+
+} // namespace bb::avm2::simulation
\ No newline at end of file
diff --git a/barretenberg/cpp/src/barretenberg/vm2/simulation/context.hpp b/barretenberg/cpp/src/barretenberg/vm2/simulation/context.hpp
new file mode 100644
index 00000000000..f6c835a0f6f
--- /dev/null
+++ b/barretenberg/cpp/src/barretenberg/vm2/simulation/context.hpp
@@ -0,0 +1,124 @@
+#pragma once
+
+#include <cstdint>
+#include <memory>
+#include <span>
+#include <vector>
+
+#include "barretenberg/vm2/common/aztec_types.hpp"
+#include "barretenberg/vm2/common/field.hpp"
+#include "barretenberg/vm2/simulation/bytecode_manager.hpp"
+#include "barretenberg/vm2/simulation/events/event_emitter.hpp"
+#include "barretenberg/vm2/simulation/events/memory_event.hpp"
+#include "barretenberg/vm2/simulation/memory.hpp"
+
+namespace bb::avm2::simulation {
+
+class ContextInterface {
+  public:
+    virtual ~ContextInterface() = default;
+
+    // Machine state.
+    virtual MemoryInterface& get_memory() = 0;
+    virtual BytecodeManagerInterface& get_bytecode_manager() = 0;
+    virtual uint32_t get_pc() const = 0;
+    virtual void set_pc(uint32_t new_pc) = 0;
+    virtual uint32_t get_next_pc() const = 0;
+    virtual void set_next_pc(uint32_t new_next_pc) = 0;
+    virtual void set_nested_returndata(std::vector<FF> return_data) = 0;
+
+    // Environment.
+    virtual const AztecAddress& get_address() const = 0;
+    virtual const AztecAddress& get_msg_sender() const = 0;
+    virtual std::span<const FF> get_calldata() const = 0;
+    virtual bool get_is_static() const = 0;
+};
+
+// The context for a single nested call.
+class Context : public ContextInterface {
+  public:
+    Context(AztecAddress address,
+            AztecAddress msg_sender,
+            std::span<const FF> calldata,
+            bool is_static,
+            std::unique_ptr<BytecodeManagerInterface> bytecode,
+            std::unique_ptr<MemoryInterface> memory)
+        : address(address)
+        , msg_sender(msg_sender)
+        , calldata(calldata.begin(), calldata.end())
+        , is_static(is_static)
+        , bytecode(std::move(bytecode))
+        , memory(std::move(memory))
+    {}
+
+    // Having getters and setters make it easier to mock the context.
+    // Machine state.
+    MemoryInterface& get_memory() override { return *memory; }
+    BytecodeManagerInterface& get_bytecode_manager() override { return *bytecode; }
+    uint32_t get_pc() const override { return pc; }
+    void set_pc(uint32_t new_pc) override { pc = new_pc; }
+    uint32_t get_next_pc() const override { return next_pc; }
+    void set_next_pc(uint32_t new_next_pc) override { next_pc = new_next_pc; }
+    void set_nested_returndata(std::vector<FF> return_data) override { nested_returndata = std::move(return_data); }
+
+    // Environment.
+    const AztecAddress& get_address() const override { return address; }
+    const AztecAddress& get_msg_sender() const override { return msg_sender; }
+    std::span<const FF> get_calldata() const override { return calldata; }
+    bool get_is_static() const override { return is_static; }
+
+  private:
+    // Environment.
+    AztecAddress address;
+    AztecAddress msg_sender;
+    std::vector<FF> calldata;
+    bool is_static;
+
+    // Machine state.
+    uint32_t pc = 0;
+    uint32_t next_pc = 0;
+    std::vector<FF> nested_returndata;
+    std::unique_ptr<BytecodeManagerInterface> bytecode;
+    std::unique_ptr<MemoryInterface> memory;
+};
+
+class ContextProviderInterface {
+  public:
+    virtual ~ContextProviderInterface() = default;
+    virtual std::unique_ptr<ContextInterface> make(AztecAddress address,
+                                                   AztecAddress msg_sender,
+                                                   std::span<const FF> calldata,
+                                                   bool is_static) const = 0;
+};
+
+// This is the real thing. If you need a context made out of other objects, use a mock.
+class ContextProvider : public ContextProviderInterface {
+  public:
+    ContextProvider(TxBytecodeManagerInterface& tx_bytecode_manager, EventEmitterInterface<MemoryEvent>& memory_events)
+        : tx_bytecode_manager(tx_bytecode_manager)
+        , memory_events(memory_events)
+    {}
+    std::unique_ptr<ContextInterface> make(AztecAddress address,
+                                           AztecAddress msg_sender,
+                                           std::span<const FF> calldata,
+                                           bool is_static) const override
+    {
+        uint32_t space_id = static_cast<uint32_t>(address); // FIXME: space id.
+
+        // FIXME: doing too much in a "constructor"!
+        BytecodeId bytecode_id = tx_bytecode_manager.get_bytecode(address);
+
+        return std::make_unique<Context>(address,
+                                         msg_sender,
+                                         calldata,
+                                         is_static,
+                                         std::make_unique<BytecodeManager>(bytecode_id, tx_bytecode_manager),
+                                         std::make_unique<Memory>(space_id, memory_events));
+    }
+
+  private:
+    TxBytecodeManagerInterface& tx_bytecode_manager;
+    EventEmitterInterface<MemoryEvent>& memory_events;
+};
+
+} // namespace bb::avm2::simulation
\ No newline at end of file
diff --git a/barretenberg/cpp/src/barretenberg/vm2/simulation/context_stack.hpp b/barretenberg/cpp/src/barretenberg/vm2/simulation/context_stack.hpp
new file mode 100644
index 00000000000..871faebb2cc
--- /dev/null
+++ b/barretenberg/cpp/src/barretenberg/vm2/simulation/context_stack.hpp
@@ -0,0 +1,37 @@
+#pragma once
+
+#include <memory>
+#include <stack>
+
+#include "barretenberg/vm2/simulation/context.hpp"
+
+namespace bb::avm2::simulation {
+
+// Manages the stack of contexts.
+// Right now it's simple, but I'm pretty sure this will generate its own events (and trace).
+class ContextStackInterface {
+  public:
+    virtual ~ContextStackInterface() = default;
+
+    virtual void push(std::unique_ptr<ContextInterface> context) = 0;
+    virtual void pop() = 0;
+    virtual ContextInterface& current() = 0;
+    virtual bool empty() = 0;
+};
+
+class ContextStack : public ContextStackInterface {
+  public:
+    // TODO: When we push a new context, we'll have to emit an event with the serialized CURRENT top (if any).
+    // This would create a row in the subtrace, with the snapshot of the context to come back to once we pop.
+    void push(std::unique_ptr<ContextInterface> context) override { stack.push(std::move(context)); }
+
+    void pop() override { stack.pop(); }
+
+    ContextInterface& current() override { return *stack.top(); }
+    bool empty() override { return stack.empty(); }
+
+  private:
+    std::stack<std::unique_ptr<ContextInterface>> stack;
+};
+
+} // namespace bb::avm2::simulation
\ No newline at end of file
diff --git a/barretenberg/cpp/src/barretenberg/vm2/simulation/events/addressing_event.hpp b/barretenberg/cpp/src/barretenberg/vm2/simulation/events/addressing_event.hpp
new file mode 100644
index 00000000000..0a211c6a8ac
--- /dev/null
+++ b/barretenberg/cpp/src/barretenberg/vm2/simulation/events/addressing_event.hpp
@@ -0,0 +1,44 @@
+#pragma once
+
+#include <cstdint>
+#include <optional>
+#include <stdexcept>
+#include <vector>
+
+#include "barretenberg/vm2/common/instruction_spec.hpp"
+#include "barretenberg/vm2/common/memory_types.hpp"
+#include "barretenberg/vm2/simulation/lib/serialization.hpp"
+
+namespace bb::avm2::simulation {
+
+enum class AddressingEventError {
+    STACK_POINTER_INVALID_ADDRESS,
+    RELATIVE_COMPUTATION_OOB,
+    INDIRECT_INVALID_ADDRESS,
+    FINAL_ADDRESS_INVALID,
+};
+
+struct AddressingException : public std::runtime_error {
+    explicit AddressingException(AddressingEventError e, size_t operand_idx = 0)
+        : std::runtime_error("Addressing error: " + std::to_string(static_cast<int>(e)) + " at operand " +
+                             std::to_string(operand_idx))
+        , error(e)
+        , operand_idx(operand_idx)
+    {}
+    AddressingEventError error;
+    size_t operand_idx;
+};
+
+// See https://docs.google.com/document/d/1EgFj0OQYZCWufjzLgoAAiVL9jV0-fUAaCCIVlvRc8bY/ for circuit details.
+// - The activation mask can be derived from spec.num_addresses.
+struct AddressingEvent {
+    Instruction instruction;
+    std::vector<Operand> after_relative;
+    std::vector<Operand> resolved_operands;
+    MemoryValue stack_pointer_val;
+    MemoryTag stack_pointer_tag;
+    const InstructionSpec* spec = nullptr;
+    std::optional<AddressingException> error;
+};
+
+} // namespace bb::avm2::simulation
\ No newline at end of file
diff --git a/barretenberg/cpp/src/barretenberg/vm2/simulation/events/alu_event.hpp b/barretenberg/cpp/src/barretenberg/vm2/simulation/events/alu_event.hpp
new file mode 100644
index 00000000000..2e5a7ccdeab
--- /dev/null
+++ b/barretenberg/cpp/src/barretenberg/vm2/simulation/events/alu_event.hpp
@@ -0,0 +1,25 @@
+#pragma once
+
+#include <cstdint>
+#include <vector>
+
+#include "barretenberg/vm2/common/memory_types.hpp"
+#include "barretenberg/vm2/common/opcodes.hpp"
+
+namespace bb::avm2::simulation {
+
+enum class AluOperation {
+    ADD,
+};
+
+struct AluEvent {
+    AluOperation operation;
+    MemoryAddress a_addr;
+    MemoryAddress b_addr;
+    MemoryAddress dst_addr;
+    MemoryValue a;
+    MemoryValue b;
+    MemoryValue res;
+};
+
+} // namespace bb::avm2::simulation
\ No newline at end of file
diff --git a/barretenberg/cpp/src/barretenberg/vm2/simulation/events/bytecode_events.hpp b/barretenberg/cpp/src/barretenberg/vm2/simulation/events/bytecode_events.hpp
new file mode 100644
index 00000000000..43b281de53e
--- /dev/null
+++ b/barretenberg/cpp/src/barretenberg/vm2/simulation/events/bytecode_events.hpp
@@ -0,0 +1,35 @@
+#pragma once
+
+#include <cstdint>
+#include <memory>
+#include <vector>
+
+#include "barretenberg/vm2/common/aztec_types.hpp"
+#include "barretenberg/vm2/common/field.hpp"
+#include "barretenberg/vm2/common/memory_types.hpp"
+#include "barretenberg/vm2/common/opcodes.hpp"
+#include "barretenberg/vm2/simulation/lib/serialization.hpp"
+
+namespace bb::avm2::simulation {
+
+// Question: ideally we'd avoid exploding the whole thing here, but we could if needed to.
+// It really depends on how we want to separate the concerns between simulation and tracegen.
+// And wether we want to allow events to explode vertically in tracegen.
+struct BytecodeHashingEvent {
+    ContractClassId class_id;
+    std::shared_ptr<std::vector<uint8_t>> bytecode;
+    FF hash;
+};
+
+// WARNING: These events and the above will be "linked" by the bytecode column (1 byte per row).
+// Therefore, when generating the trace from this event, it will be absolutely necessary
+// to know where the first row of the bytecode is. That presents design challenges.
+// Question: consider processing in tandem?
+struct BytecodeDecompositionEvent {
+    ContractClassId class_id;
+    uint32_t pc;
+    // TODO: Do we want to have a dep on Instruction here or do we redefine what we need?
+    Instruction instruction;
+};
+
+} // namespace bb::avm2::simulation
\ No newline at end of file
diff --git a/barretenberg/cpp/src/barretenberg/vm2/simulation/events/event_emitter.hpp b/barretenberg/cpp/src/barretenberg/vm2/simulation/events/event_emitter.hpp
new file mode 100644
index 00000000000..ea1082b796a
--- /dev/null
+++ b/barretenberg/cpp/src/barretenberg/vm2/simulation/events/event_emitter.hpp
@@ -0,0 +1,67 @@
+#pragma once
+
+#include <list>
+#include <vector>
+
+namespace bb::avm2::simulation {
+
+template <typename Event> class EventEmitterInterface {
+  public:
+    using Container = std::vector<Event>;
+
+    virtual ~EventEmitterInterface() = default;
+    // Pushes the event to the event container.
+    virtual void emit(Event&& event) = 0;
+    // Transfers ownership of the events to the caller (clears the internal container).
+    virtual Container dump_events() = 0;
+};
+
+template <typename Event> class EventEmitter : public EventEmitterInterface<Event> {
+  public:
+    using Container = std::vector<Event>;
+
+    virtual ~EventEmitter() = default;
+    void emit(Event&& event) override { events.push_back(std::move(event)); };
+
+    const Container& get_events() const { return events; }
+    Container dump_events() override { return std::move(events); }
+
+  private:
+    Container events;
+};
+
+// This is an event emmiter that offers stable references to the events.
+// It lets you access the last event that was emitted.
+// Note: this is currently unused but it might be needed for the execution trace (calls).
+// Reconsider its existence in a while.
+template <typename Event> class StableEventEmitter : public EventEmitterInterface<Event> {
+  public:
+    using Container = std::list<Event>;
+
+    virtual ~StableEventEmitter() = default;
+    void emit(Event&& event) override { events.push_back(std::move(event)); };
+    Event& last() { return events.back(); }
+
+    const Container& get_events() const { return events; }
+    std::vector<Event> dump_events() override
+    {
+        std::vector<Event> result(events.begin(), events.end());
+        events.clear();
+        return result;
+    }
+
+  private:
+    Container events;
+};
+
+template <typename Event> class NoopEventEmitter : public EventEmitterInterface<Event> {
+  public:
+    using Container = std::vector<Event>;
+
+    virtual ~NoopEventEmitter() = default;
+
+    void emit(Event&&) override{};
+    Container dump_events() override { return {}; }
+};
+
+} // namespace bb::avm2::simulation
\ No newline at end of file
diff --git a/barretenberg/cpp/src/barretenberg/vm2/simulation/events/events_container.hpp b/barretenberg/cpp/src/barretenberg/vm2/simulation/events/events_container.hpp
new file mode 100644
index 00000000000..32ba9891c77
--- /dev/null
+++ b/barretenberg/cpp/src/barretenberg/vm2/simulation/events/events_container.hpp
@@ -0,0 +1,23 @@
+#pragma once
+
+#include <list>
+
+#include "barretenberg/vm2/simulation/events/addressing_event.hpp"
+#include "barretenberg/vm2/simulation/events/alu_event.hpp"
+#include "barretenberg/vm2/simulation/events/bytecode_events.hpp"
+#include "barretenberg/vm2/simulation/events/event_emitter.hpp"
+#include "barretenberg/vm2/simulation/events/execution_event.hpp"
+#include "barretenberg/vm2/simulation/events/memory_event.hpp"
+
+namespace bb::avm2::simulation {
+
+struct EventsContainer {
+    EventEmitterInterface<ExecutionEvent>::Container execution;
+    EventEmitterInterface<AluEvent>::Container alu;
+    EventEmitterInterface<MemoryEvent>::Container memory;
+    EventEmitterInterface<AddressingEvent>::Container addressing;
+    EventEmitterInterface<BytecodeHashingEvent>::Container bytecode_hashing;
+    EventEmitterInterface<BytecodeDecompositionEvent>::Container bytecode_decomposition;
+};
+
+} // namespace bb::avm2::simulation
\ No newline at end of file
diff --git a/barretenberg/cpp/src/barretenberg/vm2/simulation/events/execution_event.hpp b/barretenberg/cpp/src/barretenberg/vm2/simulation/events/execution_event.hpp
new file mode 100644
index 00000000000..e9ebe5b084b
--- /dev/null
+++ b/barretenberg/cpp/src/barretenberg/vm2/simulation/events/execution_event.hpp
@@ -0,0 +1,23 @@
+#pragma once
+
+#include <cstdint>
+#include <vector>
+
+#include "barretenberg/vm2/common/aztec_types.hpp"
+#include "barretenberg/vm2/common/instruction_spec.hpp"
+#include "barretenberg/vm2/common/memory_types.hpp"
+#include "barretenberg/vm2/common/opcodes.hpp"
+#include "barretenberg/vm2/simulation/lib/serialization.hpp"
+
+namespace bb::avm2::simulation {
+
+struct ExecutionEvent {
+    uint32_t pc;
+    ContractClassId contract_class_id;
+    Instruction wire_instruction;
+    const InstructionSpec& instruction_spec;
+    ExecutionOpCode opcode;
+    std::vector<Operand> resolved_operands;
+};
+
+} // namespace bb::avm2::simulation
\ No newline at end of file
diff --git a/barretenberg/cpp/src/barretenberg/vm2/simulation/events/memory_event.hpp b/barretenberg/cpp/src/barretenberg/vm2/simulation/events/memory_event.hpp
new file mode 100644
index 00000000000..a8eba158bec
--- /dev/null
+++ b/barretenberg/cpp/src/barretenberg/vm2/simulation/events/memory_event.hpp
@@ -0,0 +1,23 @@
+#pragma once
+
+#include <cstdint>
+#include <vector>
+
+#include "barretenberg/vm2/common/memory_types.hpp"
+
+namespace bb::avm2::simulation {
+
+enum class MemoryMode {
+    READ,
+    WRITE,
+};
+
+struct MemoryEvent {
+    MemoryMode mode;
+    MemoryAddress addr;
+    MemoryValue value;
+    MemoryTag tag;
+    uint32_t space_id;
+};
+
+} // namespace bb::avm2::simulation
\ No newline at end of file
diff --git a/barretenberg/cpp/src/barretenberg/vm2/simulation/execution.cpp b/barretenberg/cpp/src/barretenberg/vm2/simulation/execution.cpp
new file mode 100644
index 00000000000..a0500e1de26
--- /dev/null
+++ b/barretenberg/cpp/src/barretenberg/vm2/simulation/execution.cpp
@@ -0,0 +1,180 @@
+#include "barretenberg/vm2/simulation/execution.hpp"
+
+#include <algorithm>
+#include <concepts>
+#include <cstdint>
+#include <functional>
+
+#include "barretenberg/vm2/common/instruction_spec.hpp"
+#include "barretenberg/vm2/common/memory_types.hpp"
+#include "barretenberg/vm2/common/opcodes.hpp"
+#include "barretenberg/vm2/simulation/addressing.hpp"
+#include "barretenberg/vm2/simulation/context.hpp"
+#include "barretenberg/vm2/simulation/events/execution_event.hpp"
+
+namespace bb::avm2::simulation {
+
+void Execution::add(ContextInterface& context, MemoryAddress a_addr, MemoryAddress b_addr, MemoryAddress dst_addr)
+{
+    alu.add(context, a_addr, b_addr, dst_addr);
+}
+
+// TODO: My dispatch system makes me have a uint8_t tag. Rethink.
+void Execution::set(ContextInterface& context, MemoryAddress dst_addr, uint8_t tag, MemoryValue value)
+{
+    context.get_memory().set(dst_addr, std::move(value), static_cast<MemoryTag>(tag));
+}
+
+void Execution::mov(ContextInterface& context, MemoryAddress src_addr, MemoryAddress dst_addr)
+{
+    auto& memory = context.get_memory();
+    auto [value, tag] = memory.get(src_addr);
+    memory.set(dst_addr, value, tag);
+}
+
+// TODO: This will need to happen in its own gadget in any case.
+void Execution::call(ContextInterface& context, MemoryAddress addr)
+{
+    auto& memory = context.get_memory();
+
+    const auto [contract_address, _] = memory.get(addr);
+    std::vector<FF> calldata = {};
+
+    auto nested_context = context_provider.make(contract_address,
+                                                /*msg_sender=*/context.get_address(),
+                                                /*calldata=*/calldata,
+                                                /*is_static=*/false);
+    context_stack.push(std::move(nested_context));
+}
+
+// TODO: This will need to happen in its own gadget in any case.
+void Execution::ret(ContextInterface& context, MemoryAddress ret_offset, MemoryAddress ret_size_offset)
+{
+    auto& memory = context.get_memory();
+
+    // TODO: check tags and types (only for size, the return data is converted to FF).
+    size_t size = static_cast<size_t>(memory.get(ret_size_offset).value);
+    auto [values, _] = memory.get_slice(ret_offset, size);
+
+    context_stack.pop();
+    std::vector returndata(values.begin(), values.end());
+    if (!context_stack.empty()) {
+        auto& context = context_stack.current();
+        // TODO: We'll need more than just the return data. E.g., the space id, address and size.
+        context.set_nested_returndata(std::move(returndata));
+    } else {
+        top_level_result = {
+            .returndata = std::move(returndata),
+            .success = true,
+        };
+    }
+}
+
+void Execution::jump(ContextInterface& context, uint32_t loc)
+{
+    context.set_next_pc(loc);
+}
+
+void Execution::jumpi(ContextInterface& context, MemoryAddress cond_addr, uint32_t loc)
+{
+    auto& memory = context.get_memory();
+
+    // TODO: in gadget.
+    auto resolved_cond = memory.get(cond_addr);
+    if (!resolved_cond.value.is_zero()) {
+        context.set_next_pc(loc);
+    }
+}
+
+ExecutionResult Execution::execute(AztecAddress contract_address,
+                                   std::span<const FF> calldata,
+                                   AztecAddress msg_sender,
+                                   bool is_static)
+{
+    auto context = context_provider.make(contract_address, msg_sender, calldata, is_static);
+    context_stack.push(std::move(context));
+    execution_loop();
+    return std::move(top_level_result);
+}
+
+void Execution::execution_loop()
+{
+    while (!context_stack.empty()) {
+        auto& context = context_stack.current();
+
+        // This try-catch is here to ignore any unhandled opcodes.
+        try {
+            auto pc = context.get_pc();
+            Instruction instruction = context.get_bytecode_manager().read_instruction(pc);
+            context.set_next_pc(pc + instruction.size_in_bytes);
+            info("@", pc, " ", instruction.to_string());
+
+            ExecutionOpCode opcode = instruction_info_db.map_wire_opcode_to_execution_opcode(instruction.opcode);
+            const InstructionSpec& spec = instruction_info_db.get(opcode); // Unused for now.
+            std::vector<Operand> resolved_operands = addressing.resolve(instruction, context.get_memory());
+
+            dispatch_opcode(opcode, resolved_operands);
+
+            events.emit({ .pc = pc,
+                          .contract_class_id = context.get_bytecode_manager().get_class_id(),
+                          .wire_instruction = std::move(instruction),
+                          .instruction_spec = spec,
+                          .opcode = opcode,
+                          .resolved_operands = std::move(resolved_operands) });
+
+            context.set_pc(context.get_next_pc());
+        } catch (const std::exception& e) {
+            info("Error: ", e.what());
+            // Bah, we are done.
+            return;
+            // context.set_pc(context.get_next_pc());
+            // continue;
+        }
+    }
+}
+
+void Execution::dispatch_opcode(ExecutionOpCode opcode, const std::vector<Operand>& resolved_operands)
+{
+    switch (opcode) {
+    case ExecutionOpCode::ADD:
+        call_with_operands(&Execution::add, resolved_operands);
+        break;
+    case ExecutionOpCode::SET:
+        call_with_operands(&Execution::set, resolved_operands);
+        break;
+    case ExecutionOpCode::MOV:
+        call_with_operands(&Execution::mov, resolved_operands);
+        break;
+    case ExecutionOpCode::CALL:
+        call_with_operands(&Execution::call, resolved_operands);
+        break;
+    case ExecutionOpCode::RETURN:
+        call_with_operands(&Execution::ret, resolved_operands);
+        break;
+    case ExecutionOpCode::JUMP:
+        call_with_operands(&Execution::jump, resolved_operands);
+        break;
+    case ExecutionOpCode::JUMPI:
+        call_with_operands(&Execution::jumpi, resolved_operands);
+        break;
+    default:
+        // TODO: should be caught by parsing.
+        throw std::runtime_error("Unknown opcode");
+    }
+}
+
+// Some template magic to dispatch the opcode by deducing the number of arguments and types,
+// and making the appropriate checks and casts.
+template <typename... Ts>
+inline void Execution::call_with_operands(void (Execution::*f)(ContextInterface&, Ts...),
+                                          const std::vector<Operand>& resolved_operands)
+{
+    assert(resolved_operands.size() == sizeof...(Ts));
+    auto operand_indices = std::make_index_sequence<sizeof...(Ts)>{};
+    using types = std::tuple<Ts...>;
+    [f, this, &resolved_operands]<std::size_t... Is>(std::index_sequence<Is...>) {
+        (this->*f)(context_stack.current(), static_cast<std::tuple_element_t<Is, types>>(resolved_operands[Is])...);
+    }(operand_indices);
+}
+
+} // namespace bb::avm2::simulation
\ No newline at end of file
diff --git a/barretenberg/cpp/src/barretenberg/vm2/simulation/execution.hpp b/barretenberg/cpp/src/barretenberg/vm2/simulation/execution.hpp
new file mode 100644
index 00000000000..f4dbd559030
--- /dev/null
+++ b/barretenberg/cpp/src/barretenberg/vm2/simulation/execution.hpp
@@ -0,0 +1,89 @@
+#pragma once
+
+#include <cstdint>
+#include <memory>
+#include <span>
+#include <stack>
+#include <vector>
+
+#include "barretenberg/vm2/common/aztec_types.hpp"
+#include "barretenberg/vm2/common/field.hpp"
+#include "barretenberg/vm2/common/memory_types.hpp"
+#include "barretenberg/vm2/common/opcodes.hpp"
+#include "barretenberg/vm2/simulation/addressing.hpp"
+#include "barretenberg/vm2/simulation/alu.hpp"
+#include "barretenberg/vm2/simulation/context.hpp"
+#include "barretenberg/vm2/simulation/context_stack.hpp"
+#include "barretenberg/vm2/simulation/events/event_emitter.hpp"
+#include "barretenberg/vm2/simulation/events/execution_event.hpp"
+#include "barretenberg/vm2/simulation/lib/instruction_info.hpp"
+#include "barretenberg/vm2/simulation/lib/serialization.hpp"
+#include "barretenberg/vm2/simulation/memory.hpp"
+
+namespace bb::avm2::simulation {
+
+struct ExecutionResult {
+    std::vector<FF> returndata;
+    bool success;
+};
+
+class ExecutionInterface {
+  public:
+    virtual ~ExecutionInterface() = default;
+    // Returns the top-level execution result.
+    virtual ExecutionResult execute(AztecAddress contract_address,
+                                    std::span<const FF> calldata,
+                                    AztecAddress msg_sender,
+                                    bool is_static) = 0;
+};
+
+// In charge of executing a single enqueued call.
+class Execution : public ExecutionInterface {
+  public:
+    Execution(AluInterface& alu,
+              AddressingInterface& addressing,
+              ContextProviderInterface& context_provider,
+              ContextStackInterface& context_stack,
+              const InstructionInfoDBInterface& instruction_info_db,
+              EventEmitterInterface<ExecutionEvent>& event_emitter)
+        : context_provider(context_provider)
+        , context_stack(context_stack)
+        , instruction_info_db(instruction_info_db)
+        , alu(alu)
+        , addressing(addressing)
+        , events(event_emitter)
+    {}
+
+    ExecutionResult execute(AztecAddress contract_address,
+                            std::span<const FF> calldata,
+                            AztecAddress msg_sender,
+                            bool is_static) override;
+
+    // Opcode handlers. The order of the operands matters and should be the same as the wire format.
+    void add(ContextInterface& context, MemoryAddress a_addr, MemoryAddress b_addr, MemoryAddress dst_addr);
+    void set(ContextInterface& context, MemoryAddress dst_addr, uint8_t tag, MemoryValue value);
+    void mov(ContextInterface& context, MemoryAddress src_addr, MemoryAddress dst_addr);
+    void jump(ContextInterface& context, uint32_t loc);
+    void jumpi(ContextInterface& context, MemoryAddress cond_addr, uint32_t loc);
+    void call(ContextInterface& context, MemoryAddress addr);
+    void ret(ContextInterface& context, MemoryAddress ret_offset, MemoryAddress ret_size_offset);
+
+  private:
+    void execution_loop();
+    void dispatch_opcode(ExecutionOpCode opcode, const std::vector<Operand>& resolved_operands);
+    template <typename... Ts>
+    void call_with_operands(void (Execution::*f)(ContextInterface&, Ts...),
+                            const std::vector<Operand>& resolved_operands);
+    std::vector<Operand> resolve_operands(const Instruction& instruction, const InstructionSpec& spec);
+
+    ContextProviderInterface& context_provider;
+    ContextStackInterface& context_stack;
+    const InstructionInfoDBInterface& instruction_info_db;
+    ExecutionResult top_level_result;
+
+    AluInterface& alu;
+    AddressingInterface& addressing;
+    EventEmitterInterface<ExecutionEvent>& events;
+};
+
+} // namespace bb::avm2::simulation
\ No newline at end of file
diff --git a/barretenberg/cpp/src/barretenberg/vm2/simulation/execution.test.cpp b/barretenberg/cpp/src/barretenberg/vm2/simulation/execution.test.cpp
new file mode 100644
index 00000000000..c2cfc6667b6
--- /dev/null
+++ b/barretenberg/cpp/src/barretenberg/vm2/simulation/execution.test.cpp
@@ -0,0 +1,114 @@
+#include "barretenberg/vm2/simulation/execution.hpp"
+
+#include <gmock/gmock.h>
+#include <gtest/gtest.h>
+
+#include <memory>
+
+#include "barretenberg/vm2/common/field.hpp"
+#include "barretenberg/vm2/common/memory_types.hpp"
+#include "barretenberg/vm2/common/opcodes.hpp"
+#include "barretenberg/vm2/simulation/context.hpp"
+#include "barretenberg/vm2/simulation/events/event_emitter.hpp"
+#include "barretenberg/vm2/simulation/events/execution_event.hpp"
+#include "barretenberg/vm2/simulation/lib/instruction_info.hpp"
+#include "barretenberg/vm2/simulation/lib/serialization.hpp"
+#include "barretenberg/vm2/simulation/memory.hpp"
+#include "barretenberg/vm2/simulation/testing/mock_addressing.hpp"
+#include "barretenberg/vm2/simulation/testing/mock_alu.hpp"
+#include "barretenberg/vm2/simulation/testing/mock_bytecode_manager.hpp"
+#include "barretenberg/vm2/simulation/testing/mock_context.hpp"
+#include "barretenberg/vm2/simulation/testing/mock_context_stack.hpp"
+#include "barretenberg/vm2/simulation/testing/mock_memory.hpp"
+
+namespace bb::avm2::simulation {
+namespace {
+
+using ::testing::_;
+using ::testing::Ref;
+using ::testing::Return;
+using ::testing::ReturnRef;
+using ::testing::StrictMock;
+
+class AvmSimulationExecutionTest : public ::testing::Test {
+  protected:
+    AvmSimulationExecutionTest() { ON_CALL(context, get_memory).WillByDefault(ReturnRef(memory)); }
+
+    StrictMock<MockAlu> alu;
+    StrictMock<MockAddressing> addressing;
+    StrictMock<MockMemory> memory;
+    StrictMock<MockContextProvider> context_provider;
+    StrictMock<MockContextStack> context_stack;
+    InstructionInfoDB instruction_info_db; // Using the real thing.
+    StrictMock<MockContext> context;
+    EventEmitter<ExecutionEvent> execution_event_emitter;
+    Execution execution =
+        Execution(alu, addressing, context_provider, context_stack, instruction_info_db, execution_event_emitter);
+};
+
+TEST_F(AvmSimulationExecutionTest, Add)
+{
+    EXPECT_CALL(alu, add(Ref(context), 4, 5, 6));
+    execution.add(context, 4, 5, 6);
+}
+
+TEST_F(AvmSimulationExecutionTest, ReturnNotTopLevel)
+{
+    MemoryAddress ret_offset = 1;
+    MemoryAddress ret_size_offset = 2;
+    size_t ret_size = 7;
+    FF ret_size_ff = ret_size;
+    std::vector<FF> returndata = { 1, 2, 3, 4, 5 };
+
+    // The context that we have already set up will be the CHILD context.
+    EXPECT_CALL(context, get_memory);
+    EXPECT_CALL(memory, get(ret_size_offset)).WillOnce(Return<ValueRefAndTag>({ ret_size_ff, MemoryTag::U32 }));
+    EXPECT_CALL(memory, get_slice(ret_offset, ret_size)).WillOnce(Return<SliceWithTags>({ returndata, {} }));
+    EXPECT_CALL(context_stack, pop);
+
+    // After popping, we expect to get the parent context (since we are not at the top level).
+    StrictMock<MockContext> parent_context;
+    EXPECT_CALL(context_stack, empty).WillOnce(Return(false));
+    EXPECT_CALL(context_stack, current).WillOnce(ReturnRef(parent_context));
+    EXPECT_CALL(parent_context, set_nested_returndata(returndata));
+
+    execution.ret(context, 1, 2);
+}
+
+// FIXME: Way too long and complicated.
+// TEST_F(AvmSimulationExecutionTest, ExecutionLoop)
+// {
+//     MockBytecodeManager bytecode_manager;
+//     EXPECT_CALL(context, get_bytecode_manager).WillRepeatedly(ReturnRef(bytecode_manager));
+//     EXPECT_CALL(context, get_memory).Times(2);
+
+//     // First instruction is an ADD_8.
+//     Instruction add8(WireOpCode::ADD_8, 0, { Operand::u8(1), Operand::u8(2), Operand::u8(3) });
+//     EXPECT_CALL(context, get_pc).WillOnce(Return(0));
+//     EXPECT_CALL(bytecode_manager, read_instruction(0))
+//         .WillOnce(Return(std::pair<Instruction, uint32_t>(add8, /*bytes_read*/ 10)));
+//     EXPECT_CALL(context, set_next_pc(10));
+//     EXPECT_CALL(addressing, resolve).WillOnce(Return(std::vector<MemoryAddress>({ 4, 5, 6 })));
+//     EXPECT_CALL(alu, add);
+//     EXPECT_CALL(context, get_next_pc).WillOnce(Return(10));
+//     EXPECT_CALL(context, set_pc(10));
+
+//     // Then we just return.
+//     Instruction ret(WireOpCode::RETURN, 0, { Operand::u16(1), Operand::u16(2) });
+//     EXPECT_CALL(context, get_pc).WillOnce(Return(10));
+//     EXPECT_CALL(bytecode_manager, read_instruction(10))
+//         .WillOnce(Return(std::pair<Instruction, uint32_t>(ret, /*bytes_read*/ 5)));
+//     EXPECT_CALL(context, set_next_pc(15));
+//     EXPECT_CALL(addressing, resolve).WillOnce(Return(std::vector<MemoryAddress>({ 2, 1 })));
+//     FF zero = 0; // ugh
+//     EXPECT_CALL(memory, get(1)).WillOnce(Return(ValueRefAndTag({ zero, MemoryTag::U32 })));
+//     EXPECT_CALL(memory, get_slice(2, 0)).WillOnce(Return(SliceWithTags({}, {})));
+//     EXPECT_CALL(context, get_next_pc).WillOnce(Return(18));
+//     EXPECT_CALL(context, set_pc(18));
+
+//     execution.enter_context(std::move(context_obj));
+//     execution.run();
+// }
+
+} // namespace
+} // namespace bb::avm2::simulation
\ No newline at end of file
diff --git a/barretenberg/cpp/src/barretenberg/vm2/simulation/lib/README.md b/barretenberg/cpp/src/barretenberg/vm2/simulation/lib/README.md
new file mode 100644
index 00000000000..baa9a55151d
--- /dev/null
+++ b/barretenberg/cpp/src/barretenberg/vm2/simulation/lib/README.md
@@ -0,0 +1 @@
+The content of the simulation/lib folder should NOT emit events.
diff --git a/barretenberg/cpp/src/barretenberg/vm2/simulation/lib/contract_crypto.cpp b/barretenberg/cpp/src/barretenberg/vm2/simulation/lib/contract_crypto.cpp
new file mode 100644
index 00000000000..281a927d75b
--- /dev/null
+++ b/barretenberg/cpp/src/barretenberg/vm2/simulation/lib/contract_crypto.cpp
@@ -0,0 +1,44 @@
+#include "barretenberg/vm2/simulation/lib/contract_crypto.hpp"
+
+#include "barretenberg/crypto/poseidon2/poseidon2.hpp"
+#include "barretenberg/crypto/poseidon2/poseidon2_params.hpp"
+#include "barretenberg/vm/aztec_constants.hpp"
+
+namespace bb::avm2::simulation {
+
+using poseidon2 = crypto::Poseidon2<crypto::Poseidon2Bn254ScalarFieldParams>;
+
+FF compute_public_bytecode_commitment(std::span<const uint8_t> bytecode)
+{
+    auto encode_bytecode = [](std::span<const uint8_t> contract_bytes) -> std::vector<FF> {
+        // To make from_buffer<uint256_t> work properly, we need to make sure the contract is a multiple of 31 bytes
+        // Otherwise we will end up over-reading the buffer
+        size_t padded_size = 31 * ((contract_bytes.size() + 30) / 31);
+        // We dont want to mutate the original contract bytes, since we will (probably) need them later in the trace
+        // unpadded
+        std::vector<uint8_t> contract_bytes_padded(contract_bytes.begin(), contract_bytes.end());
+        contract_bytes_padded.resize(padded_size, 0);
+        std::vector<FF> contract_bytecode_fields;
+        for (size_t i = 0; i < contract_bytes_padded.size(); i += 31) {
+            uint256_t u256_elem = from_buffer<uint256_t>(contract_bytes_padded, i);
+            // Drop the last byte
+            contract_bytecode_fields.emplace_back(u256_elem >> 8);
+        }
+        return contract_bytecode_fields;
+    };
+
+    std::vector<FF> contract_bytecode_fields = encode_bytecode(bytecode);
+    FF running_hash = 0;
+    for (const auto& contract_bytecode_field : contract_bytecode_fields) {
+        running_hash = poseidon2::hash({ contract_bytecode_field, running_hash });
+    }
+    return running_hash;
+}
+
+FF compute_contract_class_id(const FF& artifact_hash, const FF& private_fn_root, const FF& public_bytecode_commitment)
+{
+    return poseidon2::hash(
+        { GENERATOR_INDEX__CONTRACT_LEAF, artifact_hash, private_fn_root, public_bytecode_commitment });
+}
+
+} // namespace bb::avm2::simulation
\ No newline at end of file
diff --git a/barretenberg/cpp/src/barretenberg/vm2/simulation/lib/contract_crypto.hpp b/barretenberg/cpp/src/barretenberg/vm2/simulation/lib/contract_crypto.hpp
new file mode 100644
index 00000000000..d7fa771e9e3
--- /dev/null
+++ b/barretenberg/cpp/src/barretenberg/vm2/simulation/lib/contract_crypto.hpp
@@ -0,0 +1,13 @@
+#pragma once
+
+#include <cstdint>
+#include <span>
+
+#include "barretenberg/vm2/common/field.hpp"
+
+namespace bb::avm2::simulation {
+
+FF compute_public_bytecode_commitment(std::span<const uint8_t> bytecode);
+FF compute_contract_class_id(const FF& artifact_hash, const FF& private_fn_root, const FF& public_bytecode_commitment);
+
+} // namespace bb::avm2::simulation
\ No newline at end of file
diff --git a/barretenberg/cpp/src/barretenberg/vm2/simulation/lib/instruction_info.hpp b/barretenberg/cpp/src/barretenberg/vm2/simulation/lib/instruction_info.hpp
new file mode 100644
index 00000000000..cfa2cd1b7d1
--- /dev/null
+++ b/barretenberg/cpp/src/barretenberg/vm2/simulation/lib/instruction_info.hpp
@@ -0,0 +1,41 @@
+#pragma once
+
+#include <cstdint>
+#include <memory>
+
+#include "barretenberg/vm2/common/instruction_spec.hpp"
+#include "barretenberg/vm2/common/opcodes.hpp"
+
+namespace bb::avm2::simulation {
+
+class InstructionInfoDBInterface {
+  public:
+    virtual ~InstructionInfoDBInterface() = default;
+
+    virtual const InstructionSpec& get(ExecutionOpCode opcode) const = 0;
+    virtual ExecutionOpCode map_wire_opcode_to_execution_opcode(WireOpCode opcode) const = 0;
+};
+
+class InstructionInfoDB : public InstructionInfoDBInterface {
+  public:
+    const InstructionSpec& get(ExecutionOpCode opcode) const override
+    {
+        auto it = INSTRUCTION_SPEC.find(opcode);
+        if (it == INSTRUCTION_SPEC.end()) {
+            throw std::runtime_error("Cannot find instruction spec for opcode: " +
+                                     std::to_string(static_cast<int>(opcode)));
+        }
+        return it->second;
+    }
+    ExecutionOpCode map_wire_opcode_to_execution_opcode(WireOpCode opcode) const override
+    {
+        auto it = OPCODE_MAP.find(opcode);
+        if (it == OPCODE_MAP.end()) {
+            throw std::runtime_error("Cannot map wire opcode to execution opcode: " +
+                                     std::to_string(static_cast<int>(opcode)));
+        }
+        return it->second;
+    }
+};
+
+} // namespace bb::avm2::simulation
\ No newline at end of file
diff --git a/barretenberg/cpp/src/barretenberg/vm2/simulation/lib/raw_data_db.cpp b/barretenberg/cpp/src/barretenberg/vm2/simulation/lib/raw_data_db.cpp
new file mode 100644
index 00000000000..d12eca2bc2f
--- /dev/null
+++ b/barretenberg/cpp/src/barretenberg/vm2/simulation/lib/raw_data_db.cpp
@@ -0,0 +1,55 @@
+#include "barretenberg/vm2/simulation/lib/raw_data_db.hpp"
+#include "barretenberg/vm2/simulation/lib/contract_crypto.hpp"
+
+#include <cassert>
+
+namespace bb::avm2::simulation {
+
+HintedRawDataDB::HintedRawDataDB(const ExecutionHints& hints)
+    : contract_instances(hints.contractInstances)
+    , contract_classes(hints.contractClasses)
+{}
+
+ContractInstance HintedRawDataDB::get_contract_instance(const AztecAddress& address) const
+{
+    assert(contract_instances_idx < contract_instances.size());
+    auto contract_instance_hint = contract_instances[contract_instances_idx];
+    assert(contract_instance_hint.address == address);
+    (void)address; // Avoid GCC unused parameter warning when asserts are disabled.
+
+    return {
+        .address = contract_instance_hint.address,
+        .salt = contract_instance_hint.salt,
+        .deployer_addr = contract_instance_hint.deployer,
+        .contract_class_id = contract_instance_hint.contractClassId,
+        .initialisation_hash = contract_instance_hint.initializationHash,
+        .public_keys =
+            [](const auto& pk) {
+                return PublicKeys{
+                    .nullifier_key = pk.masterNullifierPublicKey,
+                    .incoming_viewing_key = pk.masterIncomingViewingPublicKey,
+                    .outgoing_viewing_key = pk.masterOutgoingViewingPublicKey,
+                    .tagging_key = pk.masterTaggingPublicKey,
+                };
+            }(contract_instance_hint.publicKeys),
+    };
+}
+
+ContractClass HintedRawDataDB::get_contract_class(const ContractClassId& class_id) const
+{
+    assert(contract_classes_idx < contract_classes.size());
+    auto contract_class_hint = contract_classes[contract_classes_idx++];
+    assert(class_id == compute_contract_class_id(contract_class_hint.artifactHash,
+                                                 contract_class_hint.privateFunctionsRoot,
+                                                 contract_class_hint.publicBytecodeCommitment));
+    (void)class_id; // Avoid GCC unused parameter warning when asserts are disabled.
+
+    return {
+        .artifact_hash = contract_class_hint.artifactHash,
+        .private_function_root = contract_class_hint.privateFunctionsRoot,
+        .public_bytecode_commitment = contract_class_hint.publicBytecodeCommitment,
+        .packed_bytecode = contract_class_hint.packedBytecode,
+    };
+}
+
+} // namespace bb::avm2::simulation
\ No newline at end of file
diff --git a/barretenberg/cpp/src/barretenberg/vm2/simulation/lib/raw_data_db.hpp b/barretenberg/cpp/src/barretenberg/vm2/simulation/lib/raw_data_db.hpp
new file mode 100644
index 00000000000..98d810bc3ca
--- /dev/null
+++ b/barretenberg/cpp/src/barretenberg/vm2/simulation/lib/raw_data_db.hpp
@@ -0,0 +1,31 @@
+#pragma once
+
+#include "barretenberg/vm2/common/avm_inputs.hpp"
+#include "barretenberg/vm2/common/aztec_types.hpp"
+
+namespace bb::avm2::simulation {
+
+// This class interacts with the external world, without emiting any simulation events.
+class RawDataDBInterface {
+  public:
+    virtual ~RawDataDBInterface() = default;
+
+    virtual ContractInstance get_contract_instance(const AztecAddress& address) const = 0;
+    virtual ContractClass get_contract_class(const ContractClassId& class_id) const = 0;
+};
+
+class HintedRawDataDB : public RawDataDBInterface {
+  public:
+    HintedRawDataDB(const ExecutionHints& hints);
+
+    ContractInstance get_contract_instance(const AztecAddress& address) const override;
+    ContractClass get_contract_class(const ContractClassId& class_id) const override;
+
+  private:
+    std::vector<ContractInstanceHint> contract_instances;
+    std::vector<ContractClassHint> contract_classes;
+    mutable size_t contract_instances_idx = 0;
+    mutable size_t contract_classes_idx = 0;
+};
+
+} // namespace bb::avm2::simulation
diff --git a/barretenberg/cpp/src/barretenberg/vm2/simulation/lib/serialization.cpp b/barretenberg/cpp/src/barretenberg/vm2/simulation/lib/serialization.cpp
new file mode 100644
index 00000000000..619f5db9ff8
--- /dev/null
+++ b/barretenberg/cpp/src/barretenberg/vm2/simulation/lib/serialization.cpp
@@ -0,0 +1,467 @@
+#include "barretenberg/vm2/simulation/lib/serialization.hpp"
+
+#include <cassert>
+#include <cstdint>
+#include <format>
+#include <iomanip>
+#include <span>
+#include <sstream>
+#include <string>
+#include <unordered_map>
+#include <variant>
+#include <vector>
+
+#include "barretenberg/common/serialize.hpp"
+#include "barretenberg/numeric/uint256/uint256.hpp"
+#include "barretenberg/vm2/common/opcodes.hpp"
+
+namespace bb::avm2::simulation {
+namespace {
+
+// Possible types for an instruction's operand in its wire format.
+// Note that the TAG enum value is not supported in TS and is parsed as UINT8.
+// INDIRECT is parsed as UINT8 where the bits represent the operands that have indirect mem access.
+enum class OperandType : uint8_t { INDIRECT8, INDIRECT16, TAG, UINT8, UINT16, UINT32, UINT64, UINT128, FF };
+
+const std::unordered_map<OperandType, uint32_t> OPERAND_TYPE_SIZE_BYTES = {
+    { OperandType::INDIRECT8, 1 }, { OperandType::INDIRECT16, 2 }, { OperandType::TAG, 1 },
+    { OperandType::UINT8, 1 },     { OperandType::UINT16, 2 },     { OperandType::UINT32, 4 },
+    { OperandType::UINT64, 8 },    { OperandType::UINT128, 16 },   { OperandType::FF, 32 }
+};
+
+// Instruction wire formats.
+const std::vector<OperandType> three_operand_format8 = {
+    OperandType::INDIRECT8,
+    OperandType::UINT8,
+    OperandType::UINT8,
+    OperandType::UINT8,
+};
+const std::vector<OperandType> three_operand_format16 = {
+    OperandType::INDIRECT8,
+    OperandType::UINT16,
+    OperandType::UINT16,
+    OperandType::UINT16,
+};
+const std::vector<OperandType> kernel_input_operand_format = { OperandType::INDIRECT8, OperandType::UINT16 };
+
+const std::vector<OperandType> external_call_format = { OperandType::INDIRECT16,
+                                                        /*gasOffset=*/OperandType::UINT16,
+                                                        /*addrOffset=*/OperandType::UINT16,
+                                                        /*argsOffset=*/OperandType::UINT16,
+                                                        /*argsSizeOffset=*/OperandType::UINT16,
+                                                        /*successOffset=*/OperandType::UINT16 };
+
+// Contrary to TS, the format does not contain the WireOpCode byte which prefixes any instruction.
+// The format for WireOpCode::SET has to be handled separately as it is variable based on the tag.
+const std::unordered_map<WireOpCode, std::vector<OperandType>> WireOpCode_WIRE_FORMAT = {
+    // Compute
+    // Compute - Arithmetic
+    { WireOpCode::ADD_8, three_operand_format8 },
+    { WireOpCode::ADD_16, three_operand_format16 },
+    { WireOpCode::SUB_8, three_operand_format8 },
+    { WireOpCode::SUB_16, three_operand_format16 },
+    { WireOpCode::MUL_8, three_operand_format8 },
+    { WireOpCode::MUL_16, three_operand_format16 },
+    { WireOpCode::DIV_8, three_operand_format8 },
+    { WireOpCode::DIV_16, three_operand_format16 },
+    { WireOpCode::FDIV_8, three_operand_format8 },
+    { WireOpCode::FDIV_16, three_operand_format16 },
+    // Compute - Comparison
+    { WireOpCode::EQ_8, three_operand_format8 },
+    { WireOpCode::EQ_16, three_operand_format16 },
+    { WireOpCode::LT_8, three_operand_format8 },
+    { WireOpCode::LT_16, three_operand_format16 },
+    { WireOpCode::LTE_8, three_operand_format8 },
+    { WireOpCode::LTE_16, three_operand_format16 },
+    // Compute - Bitwise
+    { WireOpCode::AND_8, three_operand_format8 },
+    { WireOpCode::AND_16, three_operand_format16 },
+    { WireOpCode::OR_8, three_operand_format8 },
+    { WireOpCode::OR_16, three_operand_format16 },
+    { WireOpCode::XOR_8, three_operand_format8 },
+    { WireOpCode::XOR_16, three_operand_format16 },
+    { WireOpCode::NOT_8, { OperandType::INDIRECT8, OperandType::UINT8, OperandType::UINT8 } },
+    { WireOpCode::NOT_16, { OperandType::INDIRECT8, OperandType::UINT16, OperandType::UINT16 } },
+    { WireOpCode::SHL_8, three_operand_format8 },
+    { WireOpCode::SHL_16, three_operand_format16 },
+    { WireOpCode::SHR_8, three_operand_format8 },
+    { WireOpCode::SHR_16, three_operand_format16 },
+    // Compute - Type Conversions
+    { WireOpCode::CAST_8, { OperandType::INDIRECT8, OperandType::UINT8, OperandType::UINT8, OperandType::TAG } },
+    { WireOpCode::CAST_16, { OperandType::INDIRECT8, OperandType::UINT16, OperandType::UINT16, OperandType::TAG } },
+
+    // Execution Environment - Globals
+    { WireOpCode::GETENVVAR_16,
+      {
+          OperandType::INDIRECT8,
+          OperandType::UINT16,
+          OperandType::UINT8, // var idx
+      } },
+
+    // Execution Environment - Calldata
+    { WireOpCode::CALLDATACOPY,
+      { OperandType::INDIRECT8, OperandType::UINT16, OperandType::UINT16, OperandType::UINT16 } },
+    { WireOpCode::RETURNDATASIZE, { OperandType::INDIRECT8, OperandType::UINT16 } },
+    { WireOpCode::RETURNDATACOPY,
+      { OperandType::INDIRECT8, OperandType::UINT16, OperandType::UINT16, OperandType::UINT16 } },
+
+    // Machine State - Internal Control Flow
+    { WireOpCode::JUMP_32, { OperandType::UINT32 } },
+    { WireOpCode::JUMPI_32, { OperandType::INDIRECT8, OperandType::UINT16, OperandType::UINT32 } },
+    { WireOpCode::INTERNALCALL, { OperandType::UINT32 } },
+    { WireOpCode::INTERNALRETURN, {} },
+
+    // Machine State - Memory
+    { WireOpCode::SET_8, { OperandType::INDIRECT8, OperandType::UINT8, OperandType::TAG, OperandType::UINT8 } },
+    { WireOpCode::SET_16, { OperandType::INDIRECT8, OperandType::UINT16, OperandType::TAG, OperandType::UINT16 } },
+    { WireOpCode::SET_32, { OperandType::INDIRECT8, OperandType::UINT16, OperandType::TAG, OperandType::UINT32 } },
+    { WireOpCode::SET_64, { OperandType::INDIRECT8, OperandType::UINT16, OperandType::TAG, OperandType::UINT64 } },
+    { WireOpCode::SET_128, { OperandType::INDIRECT8, OperandType::UINT16, OperandType::TAG, OperandType::UINT128 } },
+    { WireOpCode::SET_FF, { OperandType::INDIRECT8, OperandType::UINT16, OperandType::TAG, OperandType::FF } },
+    { WireOpCode::MOV_8, { OperandType::INDIRECT8, OperandType::UINT8, OperandType::UINT8 } },
+    { WireOpCode::MOV_16, { OperandType::INDIRECT8, OperandType::UINT16, OperandType::UINT16 } },
+
+    // Side Effects - Public Storage
+    { WireOpCode::SLOAD, { OperandType::INDIRECT8, OperandType::UINT16, OperandType::UINT16 } },
+    { WireOpCode::SSTORE, { OperandType::INDIRECT8, OperandType::UINT16, OperandType::UINT16 } },
+    // Side Effects - Notes, Nullfiers, Logs, Messages
+    { WireOpCode::NOTEHASHEXISTS,
+      { OperandType::INDIRECT8, OperandType::UINT16, OperandType::UINT16, OperandType::UINT16 } },
+
+    { WireOpCode::EMITNOTEHASH,
+      {
+          OperandType::INDIRECT8,
+          OperandType::UINT16,
+      } },
+    { WireOpCode::NULLIFIEREXISTS,
+      { OperandType::INDIRECT8, OperandType::UINT16, OperandType::UINT16, OperandType::UINT16 } },
+    { WireOpCode::EMITNULLIFIER,
+      {
+          OperandType::INDIRECT8,
+          OperandType::UINT16,
+      } },
+    { WireOpCode::L1TOL2MSGEXISTS,
+      { OperandType::INDIRECT8, OperandType::UINT16, OperandType::UINT16, OperandType::UINT16 } },
+    { WireOpCode::GETCONTRACTINSTANCE,
+      { OperandType::INDIRECT8, OperandType::UINT16, OperandType::UINT16, OperandType::UINT16, OperandType::UINT8 } },
+    { WireOpCode::EMITUNENCRYPTEDLOG,
+      {
+          OperandType::INDIRECT8,
+          OperandType::UINT16,
+          OperandType::UINT16,
+      } },
+    { WireOpCode::SENDL2TOL1MSG, { OperandType::INDIRECT8, OperandType::UINT16, OperandType::UINT16 } },
+
+    // Control Flow - Contract Calls
+    { WireOpCode::CALL, external_call_format },
+    { WireOpCode::STATICCALL, external_call_format },
+    { WireOpCode::RETURN, { OperandType::INDIRECT8, OperandType::UINT16, OperandType::UINT16 } },
+    // REVERT,
+    { WireOpCode::REVERT_8, { OperandType::INDIRECT8, OperandType::UINT8, OperandType::UINT8 } },
+    { WireOpCode::REVERT_16, { OperandType::INDIRECT8, OperandType::UINT16, OperandType::UINT16 } },
+
+    // Misc
+    { WireOpCode::DEBUGLOG,
+      { OperandType::INDIRECT8, OperandType::UINT16, OperandType::UINT16, OperandType::UINT16, OperandType::UINT16 } },
+
+    // Gadgets
+    // Gadgets - Hashing
+    { WireOpCode::POSEIDON2PERM, { OperandType::INDIRECT8, OperandType::UINT16, OperandType::UINT16 } },
+    { WireOpCode::SHA256COMPRESSION,
+      { OperandType::INDIRECT8, OperandType::UINT16, OperandType::UINT16, OperandType::UINT16 } },
+    { WireOpCode::KECCAKF1600, { OperandType::INDIRECT8, OperandType::UINT16, OperandType::UINT16 } },
+    // TEMP ECADD without relative memory
+    { WireOpCode::ECADD,
+      { OperandType::INDIRECT16,
+        OperandType::UINT16,     // lhs.x
+        OperandType::UINT16,     // lhs.y
+        OperandType::UINT16,     // lhs.is_infinite
+        OperandType::UINT16,     // rhs.x
+        OperandType::UINT16,     // rhs.y
+        OperandType::UINT16,     // rhs.is_infinite
+        OperandType::UINT16 } }, // dst_offset
+    { WireOpCode::MSM,
+      { OperandType::INDIRECT8, OperandType::UINT16, OperandType::UINT16, OperandType::UINT16, OperandType::UINT16 } },
+    // Gadget - Conversion
+    { WireOpCode::TORADIXBE,
+      { OperandType::INDIRECT16,
+        OperandType::UINT16,
+        OperandType::UINT16,
+        OperandType::UINT16,
+        OperandType::UINT16,
+        OperandType::UINT16 } },
+};
+
+} // namespace
+
+Operand::Operand(const Operand& other)
+{
+    // Lazy implementation using the assignment operator.
+    *this = other;
+}
+
+Operand& Operand::operator=(const Operand& other)
+{
+    if (this != &other) {
+        if (std::holds_alternative<uint8_t>(other.value)) {
+            value = std::get<uint8_t>(other.value);
+        } else if (std::holds_alternative<uint16_t>(other.value)) {
+            value = std::get<uint16_t>(other.value);
+        } else if (std::holds_alternative<uint32_t>(other.value)) {
+            value = std::get<uint32_t>(other.value);
+        } else if (std::holds_alternative<uint64_t>(other.value)) {
+            value = std::get<uint64_t>(other.value);
+        } else if (std::holds_alternative<U128InHeap>(other.value)) {
+            value = std::make_unique<uint128_t>(*std::get<U128InHeap>(other.value));
+        } else {
+            value = std::make_unique<FF>(*std::get<FieldInHeap>(other.value));
+        }
+    }
+    return *this;
+}
+
+Operand::operator bool() const
+{
+    return (this->operator uint8_t() == 1);
+}
+
+Operand::operator uint8_t() const
+{
+    if (std::holds_alternative<uint8_t>(value)) {
+        return std::get<uint8_t>(value);
+    }
+
+    throw std::runtime_error("Operand does not fit in uint8_t");
+}
+
+Operand::operator uint16_t() const
+{
+    if (std::holds_alternative<uint8_t>(value)) {
+        return std::get<uint8_t>(value);
+    } else if (std::holds_alternative<uint16_t>(value)) {
+        return std::get<uint16_t>(value);
+    }
+
+    throw std::runtime_error("Operand does not fit in uint16_t");
+}
+
+Operand::operator uint32_t() const
+{
+    if (std::holds_alternative<uint8_t>(value)) {
+        return std::get<uint8_t>(value);
+    } else if (std::holds_alternative<uint16_t>(value)) {
+        return std::get<uint16_t>(value);
+    } else if (std::holds_alternative<uint32_t>(value)) {
+        return std::get<uint32_t>(value);
+    }
+
+    throw std::runtime_error("Operand does not fit in uint32_t");
+}
+
+Operand::operator uint64_t() const
+{
+    if (std::holds_alternative<uint8_t>(value)) {
+        return std::get<uint8_t>(value);
+    } else if (std::holds_alternative<uint16_t>(value)) {
+        return std::get<uint16_t>(value);
+    } else if (std::holds_alternative<uint32_t>(value)) {
+        return std::get<uint32_t>(value);
+    } else if (std::holds_alternative<uint64_t>(value)) {
+        return std::get<uint64_t>(value);
+    }
+
+    throw std::runtime_error("Operand does not fit in uint64_t");
+}
+
+Operand::operator uint128_t() const
+{
+    if (std::holds_alternative<uint8_t>(value)) {
+        return std::get<uint8_t>(value);
+    } else if (std::holds_alternative<uint16_t>(value)) {
+        return std::get<uint16_t>(value);
+    } else if (std::holds_alternative<uint32_t>(value)) {
+        return std::get<uint32_t>(value);
+    } else if (std::holds_alternative<uint64_t>(value)) {
+        return std::get<uint64_t>(value);
+    } else if (std::holds_alternative<U128InHeap>(value)) {
+        return *std::get<U128InHeap>(value);
+    }
+
+    throw std::runtime_error("Operand does not fit in uint128_t");
+}
+
+Operand::operator FF() const
+{
+    if (std::holds_alternative<uint8_t>(value)) {
+        return std::get<uint8_t>(value);
+    } else if (std::holds_alternative<uint16_t>(value)) {
+        return std::get<uint16_t>(value);
+    } else if (std::holds_alternative<uint32_t>(value)) {
+        return std::get<uint32_t>(value);
+    } else if (std::holds_alternative<uint64_t>(value)) {
+        return std::get<uint64_t>(value);
+    } else if (std::holds_alternative<U128InHeap>(value)) {
+        return uint256_t::from_uint128(*std::get<U128InHeap>(value));
+    } else {
+        return *std::get<FieldInHeap>(value);
+    }
+}
+
+std::string Operand::to_string() const
+{
+    if (std::holds_alternative<uint8_t>(value)) {
+        return std::to_string(std::get<uint8_t>(value));
+    } else if (std::holds_alternative<uint16_t>(value)) {
+        return std::to_string(std::get<uint16_t>(value));
+    } else if (std::holds_alternative<uint32_t>(value)) {
+        return std::to_string(std::get<uint32_t>(value));
+    } else if (std::holds_alternative<uint64_t>(value)) {
+        return std::to_string(std::get<uint64_t>(value));
+    } else if (std::holds_alternative<U128InHeap>(value)) {
+        return "someu128";
+    } else if (std::holds_alternative<FieldInHeap>(value)) {
+        return "someff";
+    }
+
+    __builtin_unreachable();
+}
+
+Instruction decode_instruction(std::span<const uint8_t> bytecode, size_t pos)
+{
+    const auto bytecode_length = bytecode.size();
+    const auto starting_pos = pos;
+
+    assert(pos < bytecode_length);
+    (void)bytecode_length; // Avoid GCC unused parameter warning when asserts are disabled.
+    // if (pos >= length) {
+    //     info("Position is out of range. Position: " + std::to_string(pos) +
+    //          " Bytecode length: " + std::to_string(length));
+    //     return InstructionWithError{
+    //         .instruction = Instruction(WireOpCode::LAST_WireOpCode_SENTINEL, {}),
+    //         .error = AvmError::INVALID_PROGRAM_COUNTER,
+    //     };
+    // }
+
+    const uint8_t opcode_byte = bytecode[pos];
+
+    // if (!Bytecode::is_valid(WireOpCode_byte)) {
+    //     info("Invalid WireOpCode byte: " + to_hex(WireOpCode_byte) + " at position: " + std::to_string(pos));
+    //     return InstructionWithError{
+    //         .instruction = Instruction(WireOpCode::LAST_WireOpCode_SENTINEL, {}),
+    //         .error = AvmError::INVALID_WireOpCode,
+    //     };
+    // }
+    pos++;
+
+    const auto opcode = static_cast<WireOpCode>(opcode_byte);
+    const auto iter = WireOpCode_WIRE_FORMAT.find(opcode);
+    assert(iter != WireOpCode_WIRE_FORMAT.end());
+    // if (iter == WireOpCode_WIRE_FORMAT.end()) {
+    //     info("WireOpCode not found in WireOpCode_WIRE_FORMAT: " + to_hex(opcode) + " name " + to_string(opcode));
+    //     return InstructionWithError{
+    //         .instruction = Instruction(WireOpCode::LAST_WireOpCode_SENTINEL, {}),
+    //         .error = AvmError::INVALID_WireOpCode,
+    //     };
+    // }
+    const auto& inst_format = iter->second;
+
+    uint16_t indirect = 0;
+    std::vector<Operand> operands;
+    for (const OperandType op_type : inst_format) {
+        // No underflow as above condition guarantees pos <= length (after pos++)
+        const auto operand_size = OPERAND_TYPE_SIZE_BYTES.at(op_type);
+        assert(pos + operand_size <= bytecode_length);
+        // if (length - pos < operand_size) {
+        //     info("Operand is missing at position " + std::to_string(pos) + " for WireOpCode " + to_hex(opcode) +
+        //          " not enough bytes for operand type " + std::to_string(static_cast<int>(op_type)));
+        //     return InstructionWithError{
+        //         .instruction = Instruction(WireOpCode::LAST_WireOpCode_SENTINEL, {}),
+        //         .error = AvmError::PARSING_ERROR,
+        //     };
+        // }
+
+        switch (op_type) {
+        case OperandType::TAG: {
+            uint8_t tag_u8 = bytecode[pos];
+            // if (tag_u8 > MAX_MEM_TAG) {
+            //     info("Instruction tag is invalid at position " + std::to_string(pos) +
+            //          " value: " + std::to_string(tag_u8) + " for WireOpCode: " + to_string(WireOpCode));
+            //     return InstructionWithError{
+            //         .instruction = Instruction(WireOpCode::LAST_WireOpCode_SENTINEL, {}),
+            //         .error = AvmError::INVALID_TAG_VALUE,
+            //     };
+            // }
+            operands.emplace_back(tag_u8);
+            break;
+        }
+        case OperandType::INDIRECT8: {
+            indirect = bytecode[pos];
+            break;
+        }
+        case OperandType::UINT8: {
+            operands.emplace_back(bytecode[pos]);
+            break;
+        }
+        case OperandType::INDIRECT16: {
+            uint16_t operand_u16 = 0;
+            uint8_t const* pos_ptr = &bytecode[pos];
+            serialize::read(pos_ptr, operand_u16);
+            indirect = operand_u16;
+            break;
+        }
+        case OperandType::UINT16: {
+            uint16_t operand_u16 = 0;
+            uint8_t const* pos_ptr = &bytecode[pos];
+            serialize::read(pos_ptr, operand_u16);
+            operands.emplace_back(operand_u16);
+            break;
+        }
+        case OperandType::UINT32: {
+            uint32_t operand_u32 = 0;
+            uint8_t const* pos_ptr = &bytecode[pos];
+            serialize::read(pos_ptr, operand_u32);
+            operands.emplace_back(operand_u32);
+            break;
+        }
+        case OperandType::UINT64: {
+            uint64_t operand_u64 = 0;
+            uint8_t const* pos_ptr = &bytecode[pos];
+            serialize::read(pos_ptr, operand_u64);
+            operands.emplace_back(operand_u64);
+            break;
+        }
+        case OperandType::UINT128: {
+            uint128_t operand_u128 = 0;
+            uint8_t const* pos_ptr = &bytecode[pos];
+            serialize::read(pos_ptr, operand_u128);
+            operands.emplace_back(Operand::u128(operand_u128));
+            break;
+        }
+        case OperandType::FF: {
+            FF operand_ff;
+            uint8_t const* pos_ptr = &bytecode[pos];
+            read(pos_ptr, operand_ff);
+            operands.emplace_back(Operand::ff(operand_ff));
+        }
+        }
+        pos += operand_size;
+    }
+
+    return { .opcode = opcode,
+             .indirect = indirect,
+             .operands = std::move(operands),
+             .size_in_bytes = static_cast<uint8_t>(pos - starting_pos) };
+};
+
+std::string Instruction::to_string() const
+{
+    std::ostringstream oss;
+    oss << opcode << " indirect: " << std::format("{:b}", indirect) << ", operands: [ ";
+    for (const auto& operand : operands) {
+        oss << operand.to_string() << " ";
+    }
+    oss << "], size: " << static_cast<int>(size_in_bytes);
+    return oss.str();
+}
+
+} // namespace bb::avm2::simulation
diff --git a/barretenberg/cpp/src/barretenberg/vm2/simulation/lib/serialization.hpp b/barretenberg/cpp/src/barretenberg/vm2/simulation/lib/serialization.hpp
new file mode 100644
index 00000000000..2e46e0baef3
--- /dev/null
+++ b/barretenberg/cpp/src/barretenberg/vm2/simulation/lib/serialization.hpp
@@ -0,0 +1,76 @@
+#pragma once
+
+#include "barretenberg/numeric/uint128/uint128.hpp"
+#include "barretenberg/vm2/common/field.hpp"
+#include "barretenberg/vm2/common/memory_types.hpp"
+#include "barretenberg/vm2/common/opcodes.hpp"
+
+#include <cstdint>
+#include <memory>
+#include <variant>
+#include <vector>
+
+namespace bb::avm2::simulation {
+
+class Operand {
+  private:
+    // We use unique ptrs to bound the size of the Operand class to the size of a pointer.
+    // FIXME: Not true! Sadly the variant is sizeof(ptr) + 1 = 8 + 1, but it's aligned,
+    // so it's 16 bytes which wastes 7 bytes. Still better than 32 + 1 + padding = 40 bytes,
+    // but worth it?
+    using FieldInHeap = std::unique_ptr<FF>;
+    using U128InHeap = std::unique_ptr<uint128_t>;
+    using Variant = std::variant<uint8_t, uint16_t, uint32_t, uint64_t, FieldInHeap, U128InHeap>;
+    Variant value;
+
+  public:
+    Operand(Variant value)
+        : value(std::move(value))
+    {}
+    Operand(const Operand& other);
+    Operand(Operand&&) = default;
+    Operand& operator=(const Operand& other);
+
+    // Helpers for when we want to pass a value without casting.
+    static Operand u8(uint8_t value) { return { value }; }
+    static Operand u16(uint16_t value) { return { value }; }
+    static Operand u32(uint32_t value) { return { value }; }
+    static Operand u64(uint64_t value) { return { value }; }
+    static Operand u128(uint128_t value) { return { std::make_unique<uint128_t>(value) }; }
+    static Operand ff(FF value) { return { std::make_unique<FF>(value) }; }
+
+    // We define conversion to supported types.
+    // The conversion will throw if the type would truncate.
+    explicit operator bool() const;
+    explicit operator uint8_t() const;
+    explicit operator uint16_t() const;
+    explicit operator uint32_t() const;
+    explicit operator uint64_t() const;
+    explicit operator uint128_t() const;
+    explicit operator FF() const;
+
+    std::string to_string() const;
+};
+
+struct Instruction {
+    WireOpCode opcode;
+    uint16_t indirect;
+    std::vector<Operand> operands;
+    uint8_t size_in_bytes;
+
+    std::string to_string() const;
+};
+
+/**
+ * @brief Parsing of an instruction in the supplied bytecode at byte position pos. This
+ *        checks that the WireOpCode value is in the defined range and extracts the operands
+ *        for each WireOpCode based on the specification from OPCODE_WIRE_FORMAT.
+ *
+ * @param bytecode The bytecode to be parsed as a vector of bytes/uint8_t
+ * @param pos Bytecode position
+ * @throws runtime_error exception when the bytecode is invalid or pos is out-of-range
+ * @return The instruction
+ */
+Instruction decode_instruction(std::span<const uint8_t> bytecode, size_t pos);
+
+} // namespace bb::avm2::simulation
diff --git a/barretenberg/cpp/src/barretenberg/vm2/simulation/memory.cpp b/barretenberg/cpp/src/barretenberg/vm2/simulation/memory.cpp
new file mode 100644
index 00000000000..811ebfbb32b
--- /dev/null
+++ b/barretenberg/cpp/src/barretenberg/vm2/simulation/memory.cpp
@@ -0,0 +1,56 @@
+#include "barretenberg/vm2/simulation/memory.hpp"
+#include "barretenberg/common/log.hpp"
+#include "barretenberg/vm2/common/memory_types.hpp"
+
+#include <cstdint>
+#include <memory>
+#include <unordered_map>
+
+namespace bb::avm2::simulation {
+
+bool MemoryInterface::is_valid_address(const MemoryValue& address)
+{
+    (void)address;
+    return true;
+    // This is failing and I don't know why.
+    // return address < static_cast<uint64_t>(0x100000000); // 2^32
+}
+
+bool MemoryInterface::is_valid_address(ValueRefAndTag address)
+{
+    return is_valid_address(address.value) && address.tag == MemoryAddressTag;
+}
+
+void Memory::set(MemoryAddress index, MemoryValue value, MemoryTag tag)
+{
+    // TODO: validate tag-value makes sense.
+    memory[index] = { value, tag };
+    vinfo("Memory write: ", index, " <- ", value, " (tag: ", static_cast<int>(tag), ")");
+    events.emit({ .mode = MemoryMode::WRITE, .addr = index, .value = value, .tag = tag, .space_id = space_id });
+}
+
+ValueRefAndTag Memory::get(MemoryAddress index) const
+{
+    static const ValueAndTag default_value = { 0, MemoryTag::FF };
+
+    auto it = memory.find(index);
+    const auto& vt = it != memory.end() ? it->second : default_value;
+    events.emit({ .mode = MemoryMode::READ, .addr = index, .value = vt.value, .tag = vt.tag, .space_id = space_id });
+
+    vinfo("Memory read: ", index, " -> ", vt.value, " (tag: ", static_cast<int>(vt.tag), ")");
+    return { vt.value, vt.tag };
+}
+
+std::pair<std::vector<MemoryValue>, std::vector<MemoryTag>> Memory::get_slice(MemoryAddress start, size_t size) const
+{
+    std::vector<MemoryValue> values(size);
+    std::vector<MemoryTag> tags(size);
+    for (size_t i = 0; i < size; ++i) {
+        auto vt = get(static_cast<MemoryAddress>(start + i));
+        values[i] = vt.value;
+        tags[i] = vt.tag;
+    }
+    return { std::move(values), std::move(tags) };
+}
+
+} // namespace bb::avm2::simulation
\ No newline at end of file
diff --git a/barretenberg/cpp/src/barretenberg/vm2/simulation/memory.hpp b/barretenberg/cpp/src/barretenberg/vm2/simulation/memory.hpp
new file mode 100644
index 00000000000..5e9ada80a5e
--- /dev/null
+++ b/barretenberg/cpp/src/barretenberg/vm2/simulation/memory.hpp
@@ -0,0 +1,57 @@
+#pragma once
+
+#include <memory>
+#include <unordered_map>
+
+#include "barretenberg/vm2/common/memory_types.hpp"
+#include "barretenberg/vm2/simulation/events/event_emitter.hpp"
+#include "barretenberg/vm2/simulation/events/memory_event.hpp"
+
+namespace bb::avm2::simulation {
+
+struct ValueRefAndTag {
+    const MemoryValue& value;
+    MemoryTag tag;
+};
+
+using SliceWithTags = std::pair<std::vector<MemoryValue>, std::vector<MemoryTag>>;
+
+class MemoryInterface {
+  public:
+    virtual ~MemoryInterface() = default;
+
+    virtual void set(MemoryAddress index, MemoryValue value, MemoryTag tag) = 0;
+    virtual ValueRefAndTag get(MemoryAddress index) const = 0;
+    virtual SliceWithTags get_slice(MemoryAddress start, size_t size) const = 0;
+
+    virtual uint32_t get_space_id() const = 0;
+
+    static bool is_valid_address(const MemoryValue& address);
+    static bool is_valid_address(ValueRefAndTag address);
+};
+
+class Memory : public MemoryInterface {
+  public:
+    Memory(uint32_t space_id, EventEmitterInterface<MemoryEvent>& event_emitter)
+        : space_id(space_id)
+        , events(event_emitter)
+    {}
+
+    void set(MemoryAddress index, MemoryValue value, MemoryTag tag) override;
+    ValueRefAndTag get(MemoryAddress index) const override;
+    SliceWithTags get_slice(MemoryAddress start, size_t size) const override;
+
+    uint32_t get_space_id() const override { return space_id; }
+
+  private:
+    struct ValueAndTag {
+        MemoryValue value;
+        MemoryTag tag;
+    };
+
+    uint32_t space_id;
+    std::unordered_map<size_t, ValueAndTag> memory;
+    EventEmitterInterface<MemoryEvent>& events;
+};
+
+} // namespace bb::avm2::simulation
\ No newline at end of file
diff --git a/barretenberg/cpp/src/barretenberg/vm2/simulation/testing/mock_addressing.hpp b/barretenberg/cpp/src/barretenberg/vm2/simulation/testing/mock_addressing.hpp
new file mode 100644
index 00000000000..5bc31f66921
--- /dev/null
+++ b/barretenberg/cpp/src/barretenberg/vm2/simulation/testing/mock_addressing.hpp
@@ -0,0 +1,26 @@
+#pragma once
+
+#include <gmock/gmock.h>
+
+#include <cstddef>
+#include <memory>
+#include <span>
+#include <vector>
+
+#include "barretenberg/vm2/common/memory_types.hpp"
+#include "barretenberg/vm2/simulation/addressing.hpp"
+#include "barretenberg/vm2/simulation/lib/serialization.hpp"
+#include "barretenberg/vm2/simulation/memory.hpp"
+
+namespace bb::avm2::simulation {
+
+class MockAddressing : public AddressingInterface {
+  public:
+    // https://google.github.io/googletest/gmock_cook_book.html#making-the-compilation-faster
+    MockAddressing();
+    ~MockAddressing() override;
+
+    MOCK_METHOD(std::vector<Operand>, resolve, (const Instruction&, MemoryInterface& memory), (const override));
+};
+
+} // namespace bb::avm2::simulation
\ No newline at end of file
diff --git a/barretenberg/cpp/src/barretenberg/vm2/simulation/testing/mock_addressing.test.cpp b/barretenberg/cpp/src/barretenberg/vm2/simulation/testing/mock_addressing.test.cpp
new file mode 100644
index 00000000000..336e75081d0
--- /dev/null
+++ b/barretenberg/cpp/src/barretenberg/vm2/simulation/testing/mock_addressing.test.cpp
@@ -0,0 +1,9 @@
+// This is not a test file but we need to use .test.cpp so that it is not included in non-test builds.
+#include "barretenberg/vm2/simulation/testing/mock_addressing.hpp"
+
+namespace bb::avm2::simulation {
+
+MockAddressing::MockAddressing() = default;
+MockAddressing::~MockAddressing() = default;
+
+} // namespace bb::avm2::simulation
\ No newline at end of file
diff --git a/barretenberg/cpp/src/barretenberg/vm2/simulation/testing/mock_alu.hpp b/barretenberg/cpp/src/barretenberg/vm2/simulation/testing/mock_alu.hpp
new file mode 100644
index 00000000000..cb4477164c8
--- /dev/null
+++ b/barretenberg/cpp/src/barretenberg/vm2/simulation/testing/mock_alu.hpp
@@ -0,0 +1,23 @@
+#pragma once
+
+#include <gmock/gmock.h>
+
+#include "barretenberg/vm2/common/memory_types.hpp"
+#include "barretenberg/vm2/simulation/alu.hpp"
+#include "barretenberg/vm2/simulation/context.hpp"
+
+namespace bb::avm2::simulation {
+
+class MockAlu : public AluInterface {
+  public:
+    // https://google.github.io/googletest/gmock_cook_book.html#making-the-compilation-faster
+    MockAlu();
+    ~MockAlu() override;
+
+    MOCK_METHOD(void,
+                add,
+                (ContextInterface&, MemoryAddress a_addr, MemoryAddress b_addr, MemoryAddress dst_addr),
+                (override));
+};
+
+} // namespace bb::avm2::simulation
\ No newline at end of file
diff --git a/barretenberg/cpp/src/barretenberg/vm2/simulation/testing/mock_alu.test.cpp b/barretenberg/cpp/src/barretenberg/vm2/simulation/testing/mock_alu.test.cpp
new file mode 100644
index 00000000000..2632ad598a1
--- /dev/null
+++ b/barretenberg/cpp/src/barretenberg/vm2/simulation/testing/mock_alu.test.cpp
@@ -0,0 +1,9 @@
+// This is not a test file but we need to use .test.cpp so that it is not included in non-test builds.
+#include "barretenberg/vm2/simulation/testing/mock_alu.hpp"
+
+namespace bb::avm2::simulation {
+
+MockAlu::MockAlu() = default;
+MockAlu::~MockAlu() = default;
+
+} // namespace bb::avm2::simulation
\ No newline at end of file
diff --git a/barretenberg/cpp/src/barretenberg/vm2/simulation/testing/mock_bytecode_manager.hpp b/barretenberg/cpp/src/barretenberg/vm2/simulation/testing/mock_bytecode_manager.hpp
new file mode 100644
index 00000000000..31bace15b7d
--- /dev/null
+++ b/barretenberg/cpp/src/barretenberg/vm2/simulation/testing/mock_bytecode_manager.hpp
@@ -0,0 +1,23 @@
+#pragma once
+
+#include <cstddef>
+#include <cstdint>
+#include <memory>
+
+#include <gmock/gmock.h>
+
+#include "barretenberg/vm2/simulation/bytecode_manager.hpp"
+
+namespace bb::avm2::simulation {
+
+class MockBytecodeManager : public BytecodeManagerInterface {
+  public:
+    // https://google.github.io/googletest/gmock_cook_book.html#making-the-compilation-faster
+    MockBytecodeManager();
+    ~MockBytecodeManager() override;
+
+    MOCK_METHOD(Instruction, read_instruction, (uint32_t pc), (const, override));
+    MOCK_METHOD(ContractClassId, get_class_id, (), (const, override));
+};
+
+} // namespace bb::avm2::simulation
\ No newline at end of file
diff --git a/barretenberg/cpp/src/barretenberg/vm2/simulation/testing/mock_bytecode_manager.test.cpp b/barretenberg/cpp/src/barretenberg/vm2/simulation/testing/mock_bytecode_manager.test.cpp
new file mode 100644
index 00000000000..db9907a5f97
--- /dev/null
+++ b/barretenberg/cpp/src/barretenberg/vm2/simulation/testing/mock_bytecode_manager.test.cpp
@@ -0,0 +1,9 @@
+// This is not a test file but we need to use .test.cpp so that it is not included in non-test builds.
+#include "barretenberg/vm2/simulation/testing/mock_bytecode_manager.hpp"
+
+namespace bb::avm2::simulation {
+
+MockBytecodeManager::MockBytecodeManager() = default;
+MockBytecodeManager::~MockBytecodeManager() = default;
+
+} // namespace bb::avm2::simulation
\ No newline at end of file
diff --git a/barretenberg/cpp/src/barretenberg/vm2/simulation/testing/mock_context.hpp b/barretenberg/cpp/src/barretenberg/vm2/simulation/testing/mock_context.hpp
new file mode 100644
index 00000000000..135b1054c40
--- /dev/null
+++ b/barretenberg/cpp/src/barretenberg/vm2/simulation/testing/mock_context.hpp
@@ -0,0 +1,43 @@
+#pragma once
+
+#include <cstdint>
+#include <memory>
+
+#include <gmock/gmock.h>
+
+#include "barretenberg/vm2/simulation/context.hpp"
+#include "barretenberg/vm2/simulation/memory.hpp"
+
+namespace bb::avm2::simulation {
+
+class MockContext : public ContextInterface {
+  public:
+    // https://google.github.io/googletest/gmock_cook_book.html#making-the-compilation-faster
+    MockContext();
+    ~MockContext() override;
+
+    // Machine state.
+    MOCK_METHOD(MemoryInterface&, get_memory, (), (override));
+    MOCK_METHOD(BytecodeManagerInterface&, get_bytecode_manager, (), (override));
+    MOCK_METHOD(uint32_t, get_pc, (), (const, override));
+    MOCK_METHOD(void, set_pc, (uint32_t new_pc), (override));
+    MOCK_METHOD(uint32_t, get_next_pc, (), (const, override));
+    MOCK_METHOD(void, set_next_pc, (uint32_t new_next_pc), (override));
+    MOCK_METHOD(void, set_nested_returndata, (std::vector<FF> return_data), (override));
+
+    // Environment.
+    MOCK_METHOD(const AztecAddress&, get_address, (), (const, override));
+    MOCK_METHOD(const AztecAddress&, get_msg_sender, (), (const, override));
+    MOCK_METHOD(std::span<const FF>, get_calldata, (), (const, override));
+    MOCK_METHOD(bool, get_is_static, (), (const, override));
+};
+
+class MockContextProvider : public ContextProviderInterface {
+  public:
+    MOCK_METHOD(std::unique_ptr<ContextInterface>,
+                make,
+                (AztecAddress contract_address, AztecAddress msg_sender, std::span<const FF> calldata, bool is_static),
+                (const override));
+};
+
+} // namespace bb::avm2::simulation
\ No newline at end of file
diff --git a/barretenberg/cpp/src/barretenberg/vm2/simulation/testing/mock_context.test.cpp b/barretenberg/cpp/src/barretenberg/vm2/simulation/testing/mock_context.test.cpp
new file mode 100644
index 00000000000..87a8cda14a7
--- /dev/null
+++ b/barretenberg/cpp/src/barretenberg/vm2/simulation/testing/mock_context.test.cpp
@@ -0,0 +1,8 @@
+#include "barretenberg/vm2/simulation/testing/mock_context.hpp"
+
+namespace bb::avm2::simulation {
+
+MockContext::MockContext() = default;
+MockContext::~MockContext() = default;
+
+} // namespace bb::avm2::simulation
\ No newline at end of file
diff --git a/barretenberg/cpp/src/barretenberg/vm2/simulation/testing/mock_context_stack.hpp b/barretenberg/cpp/src/barretenberg/vm2/simulation/testing/mock_context_stack.hpp
new file mode 100644
index 00000000000..2b314755d22
--- /dev/null
+++ b/barretenberg/cpp/src/barretenberg/vm2/simulation/testing/mock_context_stack.hpp
@@ -0,0 +1,25 @@
+#pragma once
+
+#include <cstdint>
+#include <memory>
+
+#include <gmock/gmock.h>
+
+#include "barretenberg/vm2/simulation/context_stack.hpp"
+
+namespace bb::avm2::simulation {
+
+class MockContextStack : public ContextStackInterface {
+  public:
+    // TODO: do later.
+    // https://google.github.io/googletest/gmock_cook_book.html#making-the-compilation-faster
+    // MockContextStack();
+    // ~MockContextStack() override;
+
+    MOCK_METHOD(void, push, (std::unique_ptr<ContextInterface> context), (override));
+    MOCK_METHOD(void, pop, (), (override));
+    MOCK_METHOD(ContextInterface&, current, (), (override));
+    MOCK_METHOD(bool, empty, (), (override));
+};
+
+} // namespace bb::avm2::simulation
\ No newline at end of file
diff --git a/barretenberg/cpp/src/barretenberg/vm2/simulation/testing/mock_memory.hpp b/barretenberg/cpp/src/barretenberg/vm2/simulation/testing/mock_memory.hpp
new file mode 100644
index 00000000000..b1632e0fda3
--- /dev/null
+++ b/barretenberg/cpp/src/barretenberg/vm2/simulation/testing/mock_memory.hpp
@@ -0,0 +1,23 @@
+#pragma once
+
+#include <gmock/gmock.h>
+
+#include "barretenberg/vm2/common/memory_types.hpp"
+#include "barretenberg/vm2/simulation/events/memory_event.hpp"
+#include "barretenberg/vm2/simulation/memory.hpp"
+
+namespace bb::avm2::simulation {
+
+class MockMemory : public MemoryInterface {
+  public:
+    // https://google.github.io/googletest/gmock_cook_book.html#making-the-compilation-faster
+    MockMemory();
+    ~MockMemory() override;
+
+    MOCK_METHOD(void, set, (MemoryAddress index, MemoryValue value, MemoryTag tag), (override));
+    MOCK_METHOD(ValueRefAndTag, get, (MemoryAddress index), (const, override));
+    MOCK_METHOD(SliceWithTags, get_slice, (MemoryAddress start, size_t size), (const, override));
+    MOCK_METHOD(uint32_t, get_space_id, (), (const, override));
+};
+
+} // namespace bb::avm2::simulation
\ No newline at end of file
diff --git a/barretenberg/cpp/src/barretenberg/vm2/simulation/testing/mock_memory.test.cpp b/barretenberg/cpp/src/barretenberg/vm2/simulation/testing/mock_memory.test.cpp
new file mode 100644
index 00000000000..4c6a1d8d7fd
--- /dev/null
+++ b/barretenberg/cpp/src/barretenberg/vm2/simulation/testing/mock_memory.test.cpp
@@ -0,0 +1,9 @@
+// This is not a test file but we need to use .test.cpp so that it is not included in non-test builds.
+#include "barretenberg/vm2/simulation/testing/mock_memory.hpp"
+
+namespace bb::avm2::simulation {
+
+MockMemory::MockMemory() = default;
+MockMemory::~MockMemory() = default;
+
+} // namespace bb::avm2::simulation
\ No newline at end of file
diff --git a/barretenberg/cpp/src/barretenberg/vm2/simulation/testing/mock_raw_data_db.hpp b/barretenberg/cpp/src/barretenberg/vm2/simulation/testing/mock_raw_data_db.hpp
new file mode 100644
index 00000000000..5f2d45ba240
--- /dev/null
+++ b/barretenberg/cpp/src/barretenberg/vm2/simulation/testing/mock_raw_data_db.hpp
@@ -0,0 +1,17 @@
+#include "barretenberg/vm2/simulation/lib/raw_data_db.hpp"
+
+#include <cassert>
+#include <gmock/gmock.h>
+
+namespace bb::avm2::simulation {
+
+class MockRawDataDB : public RawDataDBInterface {
+    // https://google.github.io/googletest/gmock_cook_book.html#making-the-compilation-faster
+    MockRawDataDB();
+    ~MockRawDataDB() override;
+
+    MOCK_METHOD(ContractInstance, get_contract_instance, (const AztecAddress& address), (const, override));
+    MOCK_METHOD(ContractClass, get_contract_class, (const ContractClassId& class_id), (const, override));
+};
+
+} // namespace bb::avm2::simulation
\ No newline at end of file
diff --git a/barretenberg/cpp/src/barretenberg/vm2/simulation/testing/mock_raw_data_db.test.cpp b/barretenberg/cpp/src/barretenberg/vm2/simulation/testing/mock_raw_data_db.test.cpp
new file mode 100644
index 00000000000..bd707bddd69
--- /dev/null
+++ b/barretenberg/cpp/src/barretenberg/vm2/simulation/testing/mock_raw_data_db.test.cpp
@@ -0,0 +1,9 @@
+// This is not a test file but we need to use .test.cpp so that it is not included in non-test builds.
+#include "barretenberg/vm2/simulation/testing/mock_raw_data_db.hpp"
+
+namespace bb::avm2::simulation {
+
+MockRawDataDB::MockRawDataDB() = default;
+MockRawDataDB::~MockRawDataDB() = default;
+
+} // namespace bb::avm2::simulation
\ No newline at end of file
diff --git a/barretenberg/cpp/src/barretenberg/vm2/simulation/tx_execution.cpp b/barretenberg/cpp/src/barretenberg/vm2/simulation/tx_execution.cpp
new file mode 100644
index 00000000000..34371a1aaab
--- /dev/null
+++ b/barretenberg/cpp/src/barretenberg/vm2/simulation/tx_execution.cpp
@@ -0,0 +1,21 @@
+#include "barretenberg/vm2/simulation/tx_execution.hpp"
+
+namespace bb::avm2::simulation {
+
+void TxExecution::simulate(const Tx& tx)
+{
+    // TODO: other inter-enqueued-call stuff will be done here.
+    for (const auto& call : tx.enqueued_calls) {
+        info("Executing enqueued call to ", call.contractAddress);
+        auto result = call_execution.execute(call.contractAddress, call.args, call.sender, call.isStatic);
+        info("Enqueued call to ",
+             call.contractAddress,
+             " was a ",
+             result.success ? "success" : "failure",
+             " and it returned ",
+             result.returndata.size(),
+             " elements.");
+    }
+}
+
+} // namespace bb::avm2::simulation
\ No newline at end of file
diff --git a/barretenberg/cpp/src/barretenberg/vm2/simulation/tx_execution.hpp b/barretenberg/cpp/src/barretenberg/vm2/simulation/tx_execution.hpp
new file mode 100644
index 00000000000..56a31356d45
--- /dev/null
+++ b/barretenberg/cpp/src/barretenberg/vm2/simulation/tx_execution.hpp
@@ -0,0 +1,25 @@
+#pragma once
+
+#include "barretenberg/vm2/common/avm_inputs.hpp"
+#include "barretenberg/vm2/simulation/execution.hpp"
+
+namespace bb::avm2::simulation {
+
+// Temporary.
+struct Tx {
+    std::vector<PublicExecutionRequest> enqueued_calls;
+};
+
+// In charge of executing a transaction.
+class TxExecution final {
+  public:
+    TxExecution(ExecutionInterface& call_execution)
+        : call_execution(call_execution){};
+
+    void simulate(const Tx& tx);
+
+  private:
+    ExecutionInterface& call_execution;
+};
+
+} // namespace bb::avm2::simulation
\ No newline at end of file
diff --git a/barretenberg/cpp/src/barretenberg/vm2/simulation_helper.cpp b/barretenberg/cpp/src/barretenberg/vm2/simulation_helper.cpp
new file mode 100644
index 00000000000..e47f2697b84
--- /dev/null
+++ b/barretenberg/cpp/src/barretenberg/vm2/simulation_helper.cpp
@@ -0,0 +1,86 @@
+#include "barretenberg/vm2/simulation_helper.hpp"
+
+#include <list>
+#include <vector>
+
+#include "barretenberg/common/log.hpp"
+#include "barretenberg/vm2/common/avm_inputs.hpp"
+#include "barretenberg/vm2/common/aztec_types.hpp"
+#include "barretenberg/vm2/common/field.hpp"
+#include "barretenberg/vm2/simulation/addressing.hpp"
+#include "barretenberg/vm2/simulation/alu.hpp"
+#include "barretenberg/vm2/simulation/bytecode_manager.hpp"
+#include "barretenberg/vm2/simulation/context.hpp"
+#include "barretenberg/vm2/simulation/context_stack.hpp"
+#include "barretenberg/vm2/simulation/execution.hpp"
+#include "barretenberg/vm2/simulation/lib/instruction_info.hpp"
+#include "barretenberg/vm2/simulation/lib/raw_data_db.hpp"
+#include "barretenberg/vm2/simulation/tx_execution.hpp"
+
+namespace bb::avm2 {
+
+using namespace bb::avm2::simulation;
+
+namespace {
+
+// Configuration for full simulation (for proving).
+struct ProvingSettings {
+    using ExecutionEventEmitter = EventEmitter<ExecutionEvent>;
+    using AluEventEmitter = EventEmitter<AluEvent>;
+    using MemoryEventEmitter = EventEmitter<MemoryEvent>;
+    using AddressingEventEmitter = EventEmitter<AddressingEvent>;
+    using BytecodeHashingEventEmitter = EventEmitter<BytecodeHashingEvent>;
+    using BytecodeDecompositionEventEmitter = EventEmitter<BytecodeDecompositionEvent>;
+};
+
+// Configuration for fast simulation.
+struct FastSettings {
+    using ExecutionEventEmitter = NoopEventEmitter<ExecutionEvent>;
+    using AluEventEmitter = NoopEventEmitter<AluEvent>;
+    using MemoryEventEmitter = NoopEventEmitter<MemoryEvent>;
+    using AddressingEventEmitter = NoopEventEmitter<AddressingEvent>;
+    using BytecodeHashingEventEmitter = NoopEventEmitter<BytecodeHashingEvent>;
+    using BytecodeDecompositionEventEmitter = NoopEventEmitter<BytecodeDecompositionEvent>;
+    // Customization can go here, for example a BytecodeManager that does NOT hash bytecodes.
+};
+
+} // namespace
+
+template <typename S> EventsContainer AvmSimulationHelper::simulate_with_settings()
+{
+    typename S::ExecutionEventEmitter execution_emitter;
+    typename S::AluEventEmitter alu_emitter;
+    typename S::MemoryEventEmitter memory_emitter;
+    typename S::AddressingEventEmitter addressing_emitter;
+    typename S::BytecodeHashingEventEmitter bytecode_hashing_emitter;
+    typename S::BytecodeDecompositionEventEmitter bytecode_decomposition_emitter;
+
+    HintedRawDataDB db(inputs.hints);
+    TxBytecodeManager bytecode_manager(db, bytecode_hashing_emitter, bytecode_decomposition_emitter);
+    ContextProvider context_provider(bytecode_manager, memory_emitter);
+
+    Alu alu(alu_emitter);
+    InstructionInfoDB instruction_info_db;
+    Addressing addressing(instruction_info_db, addressing_emitter);
+    ContextStack context_stack;
+    Execution execution(alu, addressing, context_provider, context_stack, instruction_info_db, execution_emitter);
+    TxExecution tx_execution(execution);
+
+    tx_execution.simulate({ .enqueued_calls = inputs.enqueuedCalls });
+
+    return { execution_emitter.dump_events(),        alu_emitter.dump_events(),
+             memory_emitter.dump_events(),           addressing_emitter.dump_events(),
+             bytecode_hashing_emitter.dump_events(), bytecode_decomposition_emitter.dump_events() };
+}
+
+EventsContainer AvmSimulationHelper::simulate()
+{
+    return simulate_with_settings<ProvingSettings>();
+}
+
+void AvmSimulationHelper::simulate_fast()
+{
+    simulate_with_settings<FastSettings>();
+}
+
+} // namespace bb::avm2
\ No newline at end of file
diff --git a/barretenberg/cpp/src/barretenberg/vm2/simulation_helper.hpp b/barretenberg/cpp/src/barretenberg/vm2/simulation_helper.hpp
new file mode 100644
index 00000000000..0cb64db217a
--- /dev/null
+++ b/barretenberg/cpp/src/barretenberg/vm2/simulation_helper.hpp
@@ -0,0 +1,28 @@
+#pragma once
+
+#include <list>
+
+#include "barretenberg/vm2/common/avm_inputs.hpp"
+#include "barretenberg/vm2/simulation/events/events_container.hpp"
+
+namespace bb::avm2 {
+
+class AvmSimulationHelper {
+  public:
+    AvmSimulationHelper(AvmProvingInputs inputs)
+        : inputs(std::move(inputs))
+    {}
+
+    // Full simulation with event collection.
+    simulation::EventsContainer simulate();
+
+    // Fast simulation without event collection.
+    void simulate_fast();
+
+  private:
+    template <typename S> simulation::EventsContainer simulate_with_settings();
+
+    AvmProvingInputs inputs;
+};
+
+} // namespace bb::avm2
\ No newline at end of file
diff --git a/barretenberg/cpp/src/barretenberg/vm2/testing/macros.hpp b/barretenberg/cpp/src/barretenberg/vm2/testing/macros.hpp
new file mode 100644
index 00000000000..b7db1dc2097
--- /dev/null
+++ b/barretenberg/cpp/src/barretenberg/vm2/testing/macros.hpp
@@ -0,0 +1,11 @@
+#pragma once
+
+#include <stdexcept>
+
+#define EXPECT_THROW_WITH_MESSAGE(code, expectedMessage)                                                               \
+    try {                                                                                                              \
+        code;                                                                                                          \
+        FAIL() << "Expected exception with message: " << expectedMessage;                                              \
+    } catch (const std::exception& e) {                                                                                \
+        EXPECT_THAT(e.what(), testing::ContainsRegex(expectedMessage));                                                \
+    }
diff --git a/barretenberg/cpp/src/barretenberg/vm2/tracegen/alu_trace.cpp b/barretenberg/cpp/src/barretenberg/vm2/tracegen/alu_trace.cpp
new file mode 100644
index 00000000000..f9a5636fe4d
--- /dev/null
+++ b/barretenberg/cpp/src/barretenberg/vm2/tracegen/alu_trace.cpp
@@ -0,0 +1,53 @@
+#include "barretenberg/vm2/tracegen/alu_trace.hpp"
+
+#include <cstddef>
+#include <cstdint>
+#include <ranges>
+#include <stdexcept>
+
+#include "barretenberg/vm2/simulation/events/alu_event.hpp"
+#include "barretenberg/vm2/simulation/events/event_emitter.hpp"
+
+namespace bb::avm2::tracegen {
+
+namespace {
+
+Column get_operation_selector(simulation::AluOperation operation)
+{
+    switch (operation) {
+    case simulation::AluOperation::ADD:
+        return Column::alu_sel_op_add;
+    default:
+        throw std::runtime_error("Unknown ALU operation");
+        break;
+    }
+}
+
+} // namespace
+
+void AluTraceBuilder::process(const simulation::EventEmitterInterface<simulation::AluEvent>::Container& events,
+                              TraceContainer& trace)
+{
+    using C = Column;
+
+    uint32_t row = 0;
+    for (const auto& event : events) {
+        C opcode_selector = get_operation_selector(event.operation);
+
+        trace.set(row,
+                  { {
+                      { opcode_selector, 1 },
+                      { C::alu_op, static_cast<uint8_t>(event.operation) },
+                      { C::alu_ia, event.a },
+                      { C::alu_ib, event.b },
+                      { C::alu_ic, event.res },
+                      { C::alu_ia_addr, event.a_addr },
+                      { C::alu_ib_addr, event.b_addr },
+                      { C::alu_dst_addr, event.dst_addr },
+                  } });
+
+        row++;
+    }
+}
+
+} // namespace bb::avm2::tracegen
\ No newline at end of file
diff --git a/barretenberg/cpp/src/barretenberg/vm2/tracegen/alu_trace.hpp b/barretenberg/cpp/src/barretenberg/vm2/tracegen/alu_trace.hpp
new file mode 100644
index 00000000000..f5bfdcb91bd
--- /dev/null
+++ b/barretenberg/cpp/src/barretenberg/vm2/tracegen/alu_trace.hpp
@@ -0,0 +1,18 @@
+#pragma once
+
+#include <list>
+
+#include "barretenberg/vm2/generated/columns.hpp"
+#include "barretenberg/vm2/simulation/events/alu_event.hpp"
+#include "barretenberg/vm2/simulation/events/event_emitter.hpp"
+#include "barretenberg/vm2/tracegen/trace_container.hpp"
+
+namespace bb::avm2::tracegen {
+
+class AluTraceBuilder final {
+  public:
+    void process(const simulation::EventEmitterInterface<simulation::AluEvent>::Container& events,
+                 TraceContainer& trace);
+};
+
+} // namespace bb::avm2::tracegen
\ No newline at end of file
diff --git a/barretenberg/cpp/src/barretenberg/vm2/tracegen/alu_trace.test.cpp b/barretenberg/cpp/src/barretenberg/vm2/tracegen/alu_trace.test.cpp
new file mode 100644
index 00000000000..cce74181f3e
--- /dev/null
+++ b/barretenberg/cpp/src/barretenberg/vm2/tracegen/alu_trace.test.cpp
@@ -0,0 +1,46 @@
+#include <gmock/gmock.h>
+#include <gtest/gtest.h>
+
+#include <cstdint>
+
+#include "barretenberg/vm2/generated/flavor_settings.hpp"
+#include "barretenberg/vm2/generated/full_row.hpp"
+#include "barretenberg/vm2/tracegen/alu_trace.hpp"
+#include "barretenberg/vm2/tracegen/test_trace_container.hpp"
+
+namespace bb::avm2::tracegen {
+namespace {
+
+using simulation::AluOperation;
+using testing::ElementsAre;
+using testing::Field;
+
+using R = TestTraceContainer::Row;
+using FF = R::FF;
+
+TEST(AvmTraceGenAluTest, TraceGeneration)
+{
+    TestTraceContainer trace;
+    AluTraceBuilder builder;
+
+    builder.process(
+        {
+            { .operation = AluOperation::ADD, .a_addr = 0, .b_addr = 1, .dst_addr = 2, .a = 1, .b = 2, .res = 3 },
+        },
+        trace);
+
+    EXPECT_THAT(trace.as_rows(),
+                ElementsAre(
+                    // Only one row.
+                    AllOf(Field(&R::alu_op, static_cast<uint8_t>(AluOperation::ADD)),
+                          Field(&R::alu_sel_op_add, 1),
+                          Field(&R::alu_ia_addr, 0),
+                          Field(&R::alu_ib_addr, 1),
+                          Field(&R::alu_dst_addr, 2),
+                          Field(&R::alu_ia, 1),
+                          Field(&R::alu_ib, 2),
+                          Field(&R::alu_ic, 3))));
+}
+
+} // namespace
+} // namespace bb::avm2::tracegen
\ No newline at end of file
diff --git a/barretenberg/cpp/src/barretenberg/vm2/tracegen/execution_trace.cpp b/barretenberg/cpp/src/barretenberg/vm2/tracegen/execution_trace.cpp
new file mode 100644
index 00000000000..a89a23dd8d4
--- /dev/null
+++ b/barretenberg/cpp/src/barretenberg/vm2/tracegen/execution_trace.cpp
@@ -0,0 +1,92 @@
+#include "barretenberg/vm2/tracegen/execution_trace.hpp"
+
+#include <cstddef>
+#include <cstdint>
+#include <ranges>
+#include <stdexcept>
+
+#include "barretenberg/common/log.hpp"
+#include "barretenberg/common/zip_view.hpp"
+#include "barretenberg/vm2/simulation/events/addressing_event.hpp"
+#include "barretenberg/vm2/simulation/events/event_emitter.hpp"
+#include "barretenberg/vm2/simulation/events/execution_event.hpp"
+#include "barretenberg/vm2/simulation/lib/serialization.hpp"
+
+namespace bb::avm2::tracegen {
+namespace {
+
+constexpr size_t operand_columns = 4;
+
+} // namespace
+
+void ExecutionTraceBuilder::process(
+    const simulation::EventEmitterInterface<simulation::ExecutionEvent>::Container& ex_events,
+    const simulation::EventEmitterInterface<simulation::AddressingEvent>::Container& addr_events,
+    TraceContainer& trace)
+{
+    using C = Column;
+    if (ex_events.size() != addr_events.size()) {
+        throw std::runtime_error(format(
+            "Execution and addressing events must have the same size: ", ex_events.size(), " != ", addr_events.size()));
+    }
+    uint32_t row = 1; // We start from row 1 because this trace contains shifted columns.
+
+    // We process the execution events and other virtual gadgets in parallel.
+    // Note that there is duplicated information in the events, for self-containment.
+    // TODO: Think the best approach for that.
+    for (const auto& [ex_event, addr_event] : zip_view(ex_events, addr_events)) {
+        auto operands = ex_event.wire_instruction.operands;
+        assert(operands.size() <= operand_columns);
+        operands.resize(operand_columns, simulation::Operand::ff(0));
+        auto resolved_operands = ex_event.resolved_operands;
+        assert(resolved_operands.size() <= operand_columns);
+        resolved_operands.resize(operand_columns, simulation::Operand::ff(0));
+
+        trace.set(row,
+                  { {
+                      { C::execution_sel, 1 },   // active execution trace
+                      { C::execution_clk, row }, // TODO: we may want this in the event
+                      { C::execution_ex_opcode, static_cast<size_t>(ex_event.opcode) },
+                      { C::execution_op1, static_cast<FF>(operands.at(0)) },
+                      { C::execution_op2, static_cast<FF>(operands.at(1)) },
+                      { C::execution_op3, static_cast<FF>(operands.at(2)) },
+                      { C::execution_op4, static_cast<FF>(operands.at(3)) },
+                      { C::execution_pc, ex_event.pc },
+                      { C::execution_rop1, static_cast<FF>(resolved_operands.at(0)) },
+                      { C::execution_rop2, static_cast<FF>(resolved_operands.at(1)) },
+                      { C::execution_rop3, static_cast<FF>(resolved_operands.at(2)) },
+                      { C::execution_rop4, static_cast<FF>(resolved_operands.at(3)) },
+                  } });
+
+        auto operands_after_relative = addr_event.after_relative;
+        assert(operands_after_relative.size() <= operand_columns);
+        operands_after_relative.resize(operand_columns, simulation::Operand::ff(0));
+
+        trace.set(
+            row,
+            { {
+                { C::execution_stack_pointer_val, addr_event.stack_pointer_val },
+                { C::execution_stack_pointer_tag, static_cast<size_t>(addr_event.stack_pointer_tag) },
+                { C::execution_sel_addressing_error, addr_event.error.has_value() ? 1 : 0 },
+                { C::execution_addressing_error_idx, addr_event.error.has_value() ? addr_event.error->operand_idx : 0 },
+                { C::execution_addressing_error_kind,
+                  addr_event.error.has_value() ? static_cast<size_t>(addr_event.error->error) : 0 },
+                { C::execution_sel_op1_is_address, addr_event.spec->num_addresses <= 1 ? 1 : 0 },
+                { C::execution_sel_op2_is_address, addr_event.spec->num_addresses <= 2 ? 1 : 0 },
+                { C::execution_sel_op3_is_address, addr_event.spec->num_addresses <= 3 ? 1 : 0 },
+                { C::execution_sel_op4_is_address, addr_event.spec->num_addresses <= 4 ? 1 : 0 },
+                { C::execution_op1_after_relative, static_cast<FF>(operands_after_relative.at(0)) },
+                { C::execution_op2_after_relative, static_cast<FF>(operands_after_relative.at(1)) },
+                { C::execution_op3_after_relative, static_cast<FF>(operands_after_relative.at(2)) },
+                { C::execution_op4_after_relative, static_cast<FF>(operands_after_relative.at(3)) },
+            } });
+
+        row++;
+    }
+
+    if (!ex_events.empty()) {
+        trace.set(C::execution_last, row - 1, 1);
+    }
+}
+
+} // namespace bb::avm2::tracegen
\ No newline at end of file
diff --git a/barretenberg/cpp/src/barretenberg/vm2/tracegen/execution_trace.hpp b/barretenberg/cpp/src/barretenberg/vm2/tracegen/execution_trace.hpp
new file mode 100644
index 00000000000..3a4d7e128bd
--- /dev/null
+++ b/barretenberg/cpp/src/barretenberg/vm2/tracegen/execution_trace.hpp
@@ -0,0 +1,20 @@
+#pragma once
+
+#include <list>
+
+#include "barretenberg/vm2/generated/columns.hpp"
+#include "barretenberg/vm2/simulation/events/addressing_event.hpp"
+#include "barretenberg/vm2/simulation/events/event_emitter.hpp"
+#include "barretenberg/vm2/simulation/events/execution_event.hpp"
+#include "barretenberg/vm2/tracegen/trace_container.hpp"
+
+namespace bb::avm2::tracegen {
+
+class ExecutionTraceBuilder final {
+  public:
+    void process(const simulation::EventEmitterInterface<simulation::ExecutionEvent>::Container& ex_events,
+                 const simulation::EventEmitterInterface<simulation::AddressingEvent>::Container& addr_events,
+                 TraceContainer& trace);
+};
+
+} // namespace bb::avm2::tracegen
\ No newline at end of file
diff --git a/barretenberg/cpp/src/barretenberg/vm2/tracegen/lib/README.md b/barretenberg/cpp/src/barretenberg/vm2/tracegen/lib/README.md
new file mode 100644
index 00000000000..342593745da
--- /dev/null
+++ b/barretenberg/cpp/src/barretenberg/vm2/tracegen/lib/README.md
@@ -0,0 +1,19 @@
+## Lookups
+
+**Current state**
+
+- Both lookups and permutations are supported.
+  - When you lookup into a precomputed table, you need to define a fast way to find the row for a tuple. See bitwise example.
+  - When you lookup into a non-precomputed (dynamic) table, you can use the class `LookupIntoDynamicTable`. There is an example.
+  - For permutations you need to use the `PermutationBuilder` class.
+- Lookups and permutations work but you need to manually create a LookupInto class and add it to the tracehelper. You can use the autogenerated `lookup_settings` class to specify the columns, etc. See examples.
+- Counts are computed for you, but you need to specify a way (`find_dst_row`) to find a row in the destination table.
+- Calculation of inverses is actually very inefficient for lookups into big tables, in particular for precomputed tables. This is not new in this design: the inverses are calculated for every row with either the source or destination selector active. See possible improvements (INVERSES_SELECTOR).
+- Calculation of inverses probes the whole circuit (not new in this design): the logderiv library probes every row and computes the inverse when needed. See possible improvements (INVERSES_PROBING)
+
+**Future work**
+
+Mostly notes for myself.
+
+- (INVERSES_SELECTOR) We should be able to compute inverses only for rows that either (1) have the source selector active or, (2) have a non-zero count. The easies way would be to add a new selector column sel_count_nonzero and use that as selector insted of the dst selector. We would also add a new constrain `sel_count_nonzero == 1 <=> count != 0`. We could possibly just bake this into the lookup relation (see predicates) and avoid the extra column.
+- (INVERSES_PROBING) The current implementation probes the whole circuit but the trace object lets you efficiently visit non-zero rows. Since we now set dummy values to the inverse column, we can just visit the non-zero elements and compute the inverses for them.
diff --git a/barretenberg/cpp/src/barretenberg/vm2/tracegen/lib/lookup_builder.hpp b/barretenberg/cpp/src/barretenberg/vm2/tracegen/lib/lookup_builder.hpp
new file mode 100644
index 00000000000..350d04b0a86
--- /dev/null
+++ b/barretenberg/cpp/src/barretenberg/vm2/tracegen/lib/lookup_builder.hpp
@@ -0,0 +1,102 @@
+#pragma once
+
+#include <array>
+#include <cstddef>
+#include <stdexcept>
+
+#include "barretenberg/vm2/common/field.hpp"
+#include "barretenberg/vm2/common/map.hpp"
+#include "barretenberg/vm2/generated/columns.hpp"
+#include "barretenberg/vm2/tracegen/trace_container.hpp"
+
+namespace bb::avm2::tracegen {
+
+template <typename LookupSettings_> class BaseLookupTraceBuilder {
+  public:
+    virtual ~BaseLookupTraceBuilder() = default;
+
+    void process(TraceContainer& trace)
+    {
+        init(trace);
+
+        // Let "src_sel {c1, c2, ...} in dst_sel {d1, d2, ...}" be a lookup,
+        // For each row that has a 1 in the src_sel, we take the values of {c1, c2, ...},
+        // find a row dst_row in the target columns {d1, d2, ...} where the values match.
+        // Then we increment the count in the counts column at dst_row.
+        // The complexity is O(|src_selector|) * O(find_in_dst).
+        trace.visit_column(LookupSettings::SRC_SELECTOR, [&](uint32_t row, const FF& src_sel_value) {
+            assert(src_sel_value == 1);
+            (void)src_sel_value; // Avoid GCC complaining of unused parameter when asserts are disabled.
+
+            auto src_values = trace.get_multiple(LookupSettings::SRC_COLUMNS, row);
+            uint32_t dst_row = find_in_dst(src_values); // Assumes an efficient implementation.
+            trace.set(LookupSettings::COUNTS, dst_row, trace.get(LookupSettings::COUNTS, dst_row) + 1);
+
+            // We set a dummy value in the inverse column so that the size of the column is right.
+            // The correct value will be set by the prover.
+            trace.set(LookupSettings::INVERSES, row, 0xdeadbeef);
+        });
+
+        // We set a dummy value in the inverse column so that the size of the column is right.
+        // The correct value will be set by the prover.
+        trace.visit_column(LookupSettings::DST_SELECTOR,
+                           [&](uint32_t row, const FF&) { trace.set(LookupSettings::INVERSES, row, 0xdeadbeef); });
+    }
+
+  protected:
+    using LookupSettings = LookupSettings_;
+    virtual uint32_t find_in_dst(const std::array<FF, LookupSettings::LOOKUP_TUPLE_SIZE>& tup) const = 0;
+    virtual void init(TraceContainer&){}; // Optional initialization step.
+};
+
+// This class is used when the lookup is into a non-precomputed table.
+// It calculates the counts by trying to find the tuple in the destination columns.
+// It creates an index of the destination columns on init, and uses it to find the tuple efficiently.
+template <typename LookupSettings_> class LookupIntoDynamicTable : public BaseLookupTraceBuilder<LookupSettings_> {
+  public:
+    virtual ~LookupIntoDynamicTable() = default;
+
+  protected:
+    using LookupSettings = LookupSettings_;
+
+    void init(TraceContainer& trace) override
+    {
+        row_idx.reserve(trace.get_column_rows(LookupSettings::DST_SELECTOR));
+        trace.visit_column(LookupSettings::DST_SELECTOR, [&](uint32_t row, const FF& dst_sel_value) {
+            assert(dst_sel_value == 1);
+            (void)dst_sel_value; // Avoid GCC complaining of unused parameter when asserts are disabled.
+
+            auto dst_values = trace.get_multiple(LookupSettings::DST_COLUMNS, row);
+            row_idx.insert({ get_key(dst_values), row });
+        });
+    }
+
+    uint32_t find_in_dst(const std::array<FF, LookupSettings::LOOKUP_TUPLE_SIZE>& tup) const override
+    {
+        auto it = row_idx.find(get_key(tup));
+        if (it != row_idx.end()) {
+            return it->second;
+        }
+        // throw std::runtime_error("Failed computing counts for " + std::string(LookupSettings::NAME) +
+        //                          ". Could not find tuple in destination.");
+        throw std::runtime_error("Failed computing counts. Could not find tuple in destination.");
+    }
+
+  private:
+    FF get_key(const std::array<FF, LookupSettings::LOOKUP_TUPLE_SIZE>& tup) const
+    {
+        FF acc = 0;
+        for (const auto& el : tup) {
+            acc = acc * beta + el;
+        }
+        return acc + gamma;
+    }
+
+    // We use an RLC for the key instead of the tuple, to save memory.
+    // FIXME: reconsider, what if beta is 0.
+    unordered_flat_map<FF, uint32_t> row_idx;
+    FF beta = FF::random_element();
+    FF gamma = FF::random_element();
+};
+
+} // namespace bb::avm2::tracegen
\ No newline at end of file
diff --git a/barretenberg/cpp/src/barretenberg/vm2/tracegen/lib/lookup_into_bitwise.hpp b/barretenberg/cpp/src/barretenberg/vm2/tracegen/lib/lookup_into_bitwise.hpp
new file mode 100644
index 00000000000..b4196563d08
--- /dev/null
+++ b/barretenberg/cpp/src/barretenberg/vm2/tracegen/lib/lookup_into_bitwise.hpp
@@ -0,0 +1,20 @@
+#pragma once
+
+#include <cassert>
+
+#include "barretenberg/vm2/tracegen/lib/lookup_builder.hpp"
+
+namespace bb::avm2::tracegen {
+
+template <typename LookupSettings> class LookupIntoBitwise : public BaseLookupTraceBuilder<LookupSettings> {
+  private:
+    // This is an efficient implementation of indexing into the precomputed table.
+    uint32_t find_in_dst(const std::array<FF, LookupSettings::LOOKUP_TUPLE_SIZE>& tup) const override
+    {
+        const auto& [op_id, a, b, _] = tup;
+        return (static_cast<uint32_t>(op_id) << static_cast<uint32_t>(16)) | (static_cast<uint32_t>(a) << 8) |
+               static_cast<uint32_t>(b);
+    }
+};
+
+} // namespace bb::avm2::tracegen
\ No newline at end of file
diff --git a/barretenberg/cpp/src/barretenberg/vm2/tracegen/lib/permutation_builder.hpp b/barretenberg/cpp/src/barretenberg/vm2/tracegen/lib/permutation_builder.hpp
new file mode 100644
index 00000000000..3a8d7f66d41
--- /dev/null
+++ b/barretenberg/cpp/src/barretenberg/vm2/tracegen/lib/permutation_builder.hpp
@@ -0,0 +1,38 @@
+#pragma once
+
+#include <array>
+#include <cstddef>
+#include <stdexcept>
+
+#include "barretenberg/vm2/common/field.hpp"
+#include "barretenberg/vm2/common/map.hpp"
+#include "barretenberg/vm2/generated/columns.hpp"
+#include "barretenberg/vm2/tracegen/trace_container.hpp"
+
+namespace bb::avm2::tracegen {
+
+// This class is only needed to set the correct size of the inverse column.
+// TODO: In the future we'll repurpose this class to keep track of the active rows,
+// and let the provers use it to more efficiently compute the inverses.
+template <typename PermutationSettings> class PermutationBuilder {
+  public:
+    void process(TraceContainer& trace)
+    {
+        // Let "src_sel {c1, c2, ...} is dst_sel {d1, d2, ...}" be a permutation.
+        trace.visit_column(PermutationSettings::SRC_SELECTOR, [&](uint32_t row, const FF& src_sel_value) {
+            assert(src_sel_value == 1);
+            (void)src_sel_value; // Avoid GCC complaining of unused parameter when asserts are disabled.
+
+            // We set a dummy value in the inverse column so that the size of the column is right.
+            // The correct value will be set by the prover.
+            trace.set(PermutationSettings::INVERSES, row, 0xdeadbeef);
+        });
+
+        // We set a dummy value in the inverse column so that the size of the column is right.
+        // The correct value will be set by the prover.
+        trace.visit_column(PermutationSettings::DST_SELECTOR,
+                           [&](uint32_t row, const FF&) { trace.set(PermutationSettings::INVERSES, row, 0xdeadbeef); });
+    }
+};
+
+} // namespace bb::avm2::tracegen
\ No newline at end of file
diff --git a/barretenberg/cpp/src/barretenberg/vm2/tracegen/precomputed_trace.cpp b/barretenberg/cpp/src/barretenberg/vm2/tracegen/precomputed_trace.cpp
new file mode 100644
index 00000000000..3e64da5237a
--- /dev/null
+++ b/barretenberg/cpp/src/barretenberg/vm2/tracegen/precomputed_trace.cpp
@@ -0,0 +1,67 @@
+#include "barretenberg/vm2/tracegen/precomputed_trace.hpp"
+#include "barretenberg/vm2/common/constants.hpp"
+
+#include <array>
+#include <cstddef>
+#include <cstdint>
+
+namespace bb::avm2::tracegen {
+
+void PrecomputedTraceBuilder::process_misc(TraceContainer& trace)
+{
+    using C = Column;
+
+    // First row.
+    trace.set(C::precomputed_first_row, 0, 1);
+
+    // Clk.
+    // TODO: What a waste of 64MB. Can we elegantly have a flag for this?
+    trace.reserve_column(C::precomputed_clk, CIRCUIT_SUBGROUP_SIZE);
+    for (uint32_t i = 0; i < CIRCUIT_SUBGROUP_SIZE; i++) {
+        trace.set(C::precomputed_clk, i, i);
+    }
+}
+
+void PrecomputedTraceBuilder::process_bitwise(TraceContainer& trace)
+{
+    using C = Column;
+
+    constexpr auto num_rows = 256 * 256 * 3;
+    trace.reserve_column(C::precomputed_sel_bitwise, num_rows);
+    trace.reserve_column(C::precomputed_bitwise_input_a, num_rows);
+    trace.reserve_column(C::precomputed_bitwise_input_b, num_rows);
+    trace.reserve_column(C::precomputed_bitwise_output, num_rows);
+
+    auto row_from_inputs = [](uint32_t op_id, uint32_t input_a, uint32_t input_b) -> uint32_t {
+        return (op_id << 16) | (input_a << 8) | input_b;
+    };
+    auto compute_operation = [](int op_id, uint32_t a, uint32_t b) -> uint32_t {
+        switch (op_id) {
+        case 0:
+            return a & b;
+        case 1:
+            return a | b;
+        case 2:
+            return a ^ b;
+        default:
+            return 0;
+        }
+    };
+
+    for (const auto op_id : { /*AND*/ 0, /*OR*/ 1, /*XOR*/ 2 }) {
+        for (uint32_t a = 0; a < 256; a++) {
+            for (uint32_t b = 0; b < 256; b++) {
+                trace.set(row_from_inputs(static_cast<uint32_t>(op_id), a, b),
+                          { {
+                              { C::precomputed_sel_bitwise, 1 },
+                              { C::precomputed_bitwise_op_id, op_id },
+                              { C::precomputed_bitwise_input_a, FF(a) },
+                              { C::precomputed_bitwise_input_b, FF(b) },
+                              { C::precomputed_bitwise_output, FF(compute_operation(op_id, a, b)) },
+                          } });
+            }
+        }
+    }
+}
+
+} // namespace bb::avm2::tracegen
\ No newline at end of file
diff --git a/barretenberg/cpp/src/barretenberg/vm2/tracegen/precomputed_trace.hpp b/barretenberg/cpp/src/barretenberg/vm2/tracegen/precomputed_trace.hpp
new file mode 100644
index 00000000000..83f2dcca89d
--- /dev/null
+++ b/barretenberg/cpp/src/barretenberg/vm2/tracegen/precomputed_trace.hpp
@@ -0,0 +1,15 @@
+#pragma once
+
+#include "barretenberg/vm2/tracegen/trace_container.hpp"
+
+namespace bb::avm2::tracegen {
+
+// This fills the trace for the "general" precomputed columns.
+// See precomputed.pil.
+class PrecomputedTraceBuilder final {
+  public:
+    void process_misc(TraceContainer& trace);
+    void process_bitwise(TraceContainer& trace);
+};
+
+} // namespace bb::avm2::tracegen
\ No newline at end of file
diff --git a/barretenberg/cpp/src/barretenberg/vm2/tracegen/test_trace_container.cpp b/barretenberg/cpp/src/barretenberg/vm2/tracegen/test_trace_container.cpp
new file mode 100644
index 00000000000..898ddb57604
--- /dev/null
+++ b/barretenberg/cpp/src/barretenberg/vm2/tracegen/test_trace_container.cpp
@@ -0,0 +1,49 @@
+#include "barretenberg/vm2/tracegen/test_trace_container.hpp"
+
+namespace bb::avm2::tracegen {
+namespace {
+
+std::optional<ColumnAndShifts> shift_column(Column c)
+{
+    static std::unordered_map<Column, ColumnAndShifts> shifts = []() {
+        std::unordered_map<Column, ColumnAndShifts> shifts;
+        for (size_t i = 0; i < TO_BE_SHIFTED_COLUMNS_ARRAY.size(); ++i) {
+            shifts[TO_BE_SHIFTED_COLUMNS_ARRAY[i]] = SHIFTED_COLUMNS_ARRAY[i];
+        }
+        return shifts;
+    }();
+
+    auto it = shifts.find(c);
+    return it == shifts.end() ? std::nullopt : std::make_optional(it->second);
+}
+
+} // namespace
+
+TestTraceContainer::RowTraceContainer TestTraceContainer::as_rows() const
+{
+    // Find the maximum size of any column.
+    const uint32_t max_rows = get_num_rows();
+
+    RowTraceContainer full_row_trace(max_rows);
+    // Write the values.
+    for (size_t col = 0; col < num_columns(); ++col) {
+        visit_column(static_cast<Column>(col), [&](size_t row, const FF& value) {
+            full_row_trace[row].get_column(static_cast<ColumnAndShifts>(col)) = value;
+        });
+    }
+
+    // Write the shifted values.
+    for (const auto& col : TO_BE_SHIFTED_COLUMNS_ARRAY) {
+        visit_column(col, [&](size_t row, const FF& value) {
+            if (row == 0) {
+                return;
+            }
+            auto shifted = shift_column(col);
+            full_row_trace[row - 1].get_column(shifted.value()) = value;
+        });
+    }
+
+    return full_row_trace;
+}
+
+} // namespace bb::avm2::tracegen
\ No newline at end of file
diff --git a/barretenberg/cpp/src/barretenberg/vm2/tracegen/test_trace_container.hpp b/barretenberg/cpp/src/barretenberg/vm2/tracegen/test_trace_container.hpp
new file mode 100644
index 00000000000..94987f325c8
--- /dev/null
+++ b/barretenberg/cpp/src/barretenberg/vm2/tracegen/test_trace_container.hpp
@@ -0,0 +1,29 @@
+#pragma once
+
+#include <unordered_map>
+#include <vector>
+
+#include "barretenberg/vm2/generated/columns.hpp"
+#include "barretenberg/vm2/generated/full_row.hpp"
+#include "barretenberg/vm2/tracegen/trace_container.hpp"
+
+namespace bb::avm2::tracegen {
+
+class TestTraceContainer : public TraceContainer {
+  public:
+    using Row = AvmFullRow<FF>;
+    using RowTraceContainer = std::vector<Row>;
+
+    TestTraceContainer() = default;
+    TestTraceContainer(const std::vector<std::vector<std::pair<Column, FF>>>& values)
+    {
+        for (uint32_t row = 0; row < values.size(); ++row) {
+            set(row, values[row]);
+        }
+    }
+
+    // Returns a trace in dense format with properly filled in shifted columns.
+    RowTraceContainer as_rows() const;
+};
+
+} // namespace bb::avm2::tracegen
\ No newline at end of file
diff --git a/barretenberg/cpp/src/barretenberg/vm2/tracegen/trace_container.cpp b/barretenberg/cpp/src/barretenberg/vm2/tracegen/trace_container.cpp
new file mode 100644
index 00000000000..506575de3f5
--- /dev/null
+++ b/barretenberg/cpp/src/barretenberg/vm2/tracegen/trace_container.cpp
@@ -0,0 +1,106 @@
+#include "barretenberg/vm2/tracegen/trace_container.hpp"
+
+#include "barretenberg/common/log.hpp"
+#include "barretenberg/vm2/common/field.hpp"
+
+namespace bb::avm2::tracegen {
+namespace {
+
+// We need a zero value to return (a reference to) when a value is not found.
+static const FF zero = FF::zero();
+constexpr auto clk_column = Column::precomputed_clk;
+
+} // namespace
+
+TraceContainer::TraceContainer()
+    : trace(std::make_unique<std::array<SparseColumn, NUM_COLUMNS>>())
+{}
+
+const FF& TraceContainer::get(Column col, uint32_t row) const
+{
+    auto& column_data = (*trace)[static_cast<size_t>(col)];
+    std::shared_lock lock(column_data.mutex);
+    const auto it = column_data.rows.find(row);
+    return it == column_data.rows.end() ? zero : it->second;
+}
+
+void TraceContainer::set(Column col, uint32_t row, const FF& value)
+{
+    auto& column_data = (*trace)[static_cast<size_t>(col)];
+    std::unique_lock lock(column_data.mutex);
+    if (!value.is_zero()) {
+        column_data.rows.insert_or_assign(row, value);
+        column_data.max_row_number = std::max(column_data.max_row_number, row);
+    } else {
+        auto num_erased = column_data.rows.erase(row);
+        if (column_data.max_row_number == row && num_erased > 0) {
+            // This shouldn't happen often. We delay recalculation of the max row number
+            // until someone actually needs it.
+            column_data.row_number_dirty = true;
+        }
+    }
+}
+
+void TraceContainer::set(uint32_t row, std::span<const std::pair<Column, FF>> values)
+{
+    for (const auto& [col, value] : values) {
+        set(col, row, value);
+    }
+}
+
+void TraceContainer::reserve_column(Column col, size_t size)
+{
+    auto& column_data = (*trace)[static_cast<size_t>(col)];
+    std::unique_lock lock(column_data.mutex);
+    column_data.rows.reserve(size);
+}
+
+uint32_t TraceContainer::get_column_rows(Column col) const
+{
+    auto& column_data = (*trace)[static_cast<size_t>(col)];
+    std::unique_lock lock(column_data.mutex);
+    if (column_data.row_number_dirty) {
+        // Trigger recalculation of max row number.
+        auto keys = std::views::keys(column_data.rows);
+        const auto it = std::max_element(keys.begin(), keys.end());
+        column_data.max_row_number = it == keys.end() ? 0 : *it;
+        column_data.row_number_dirty = false;
+    }
+    return column_data.max_row_number + 1;
+}
+
+uint32_t TraceContainer::get_num_rows_without_clk() const
+{
+    uint32_t max_rows = 0;
+    for (size_t col = 0; col < num_columns(); ++col) {
+        if (static_cast<Column>(col) != clk_column) {
+            max_rows = std::max(max_rows, get_column_rows(static_cast<Column>(col)));
+        }
+    }
+    return max_rows;
+}
+
+uint32_t TraceContainer::get_num_rows() const
+{
+    return std::max(get_column_rows(clk_column), get_num_rows_without_clk());
+}
+
+void TraceContainer::visit_column(Column col, const std::function<void(uint32_t, const FF&)>& visitor) const
+{
+    auto& column_data = (*trace)[static_cast<size_t>(col)];
+    std::shared_lock lock(column_data.mutex);
+    for (const auto& [row, value] : column_data.rows) {
+        visitor(row, value);
+    }
+}
+
+void TraceContainer::clear_column(Column col)
+{
+    auto& column_data = (*trace)[static_cast<size_t>(col)];
+    std::unique_lock lock(column_data.mutex);
+    column_data.rows.clear();
+    column_data.max_row_number = 0;
+    column_data.row_number_dirty = false;
+}
+
+} // namespace bb::avm2::tracegen
\ No newline at end of file
diff --git a/barretenberg/cpp/src/barretenberg/vm2/tracegen/trace_container.hpp b/barretenberg/cpp/src/barretenberg/vm2/tracegen/trace_container.hpp
new file mode 100644
index 00000000000..7c432dbb9ba
--- /dev/null
+++ b/barretenberg/cpp/src/barretenberg/vm2/tracegen/trace_container.hpp
@@ -0,0 +1,73 @@
+#pragma once
+
+#include <algorithm>
+#include <array>
+#include <cstddef>
+#include <functional>
+#include <memory>
+#include <shared_mutex>
+#include <span>
+#include <unordered_map>
+
+#include "barretenberg/vm2/common/field.hpp"
+#include "barretenberg/vm2/common/map.hpp"
+#include "barretenberg/vm2/generated/columns.hpp"
+#include "barretenberg/vm2/generated/flavor_settings.hpp"
+
+namespace bb::avm2::tracegen {
+
+// This container is thread-safe.
+// Contention can only happen when concurrently accessing the same column.
+class TraceContainer {
+  public:
+    TraceContainer();
+
+    const FF& get(Column col, uint32_t row) const;
+    template <size_t N> std::array<FF, N> get_multiple(const std::array<Column, N>& cols, uint32_t row) const
+    {
+        std::array<FF, N> result;
+        std::transform(cols.begin(), cols.end(), result.begin(), [&](Column col) { return get(col, row); });
+        return result;
+    }
+
+    void set(Column col, uint32_t row, const FF& value);
+    // Bulk setting for a given row.
+    void set(uint32_t row, std::span<const std::pair<Column, FF>> values);
+    // Reserve column size. Useful for precomputed columns.
+    void reserve_column(Column col, size_t size);
+
+    // Visits non-zero values in a column.
+    void visit_column(Column col, const std::function<void(uint32_t, const FF&)>& visitor) const;
+    // Returns the number of rows in a column. That is, the maximum non-zero row index + 1.
+    uint32_t get_column_rows(Column col) const;
+    // Maximum number of rows in any column.
+    uint32_t get_num_rows() const;
+    // Maximum number of rows in any column (ignoring clk which is always 2^21).
+    uint32_t get_num_rows_without_clk() const;
+    // Number of columns (without shifts).
+    static constexpr size_t num_columns() { return NUM_COLUMNS; }
+
+    // Free column memory.
+    void clear_column(Column col);
+
+  private:
+    // We use a mutex per column to allow for concurrent writes.
+    // Observe that therefore concurrent write access to different columns is cheap.
+    struct SparseColumn {
+        std::shared_mutex mutex;
+        uint32_t max_row_number = 0;
+        bool row_number_dirty; // needs recalculation
+        // Future memory optimization notes: we can do the same trick as in Operand.
+        // That is, store a variant with a unique_ptr. However, we should benchmark this.
+        // (see serialization.hpp).
+        unordered_flat_map<uint32_t, FF> rows;
+    };
+    static constexpr size_t NUM_COLUMNS = static_cast<size_t>(ColumnAndShifts::NUM_COLUMNS);
+    // We store the trace as a sparse matrix.
+    // We use a unique_ptr to allocate the array in the heap vs the stack.
+    // Even if the _content_ of each unordered_map is always heap-allocated, if we have 3k columns
+    // we could unnecessarily put strain on the stack with sizeof(unordered_map) * 3k bytes.
+    std::unique_ptr<std::array<SparseColumn, NUM_COLUMNS>> trace;
+};
+
+} // namespace bb::avm2::tracegen
\ No newline at end of file
diff --git a/barretenberg/cpp/src/barretenberg/vm2/tracegen_helper.cpp b/barretenberg/cpp/src/barretenberg/vm2/tracegen_helper.cpp
new file mode 100644
index 00000000000..7630aaa1672
--- /dev/null
+++ b/barretenberg/cpp/src/barretenberg/vm2/tracegen_helper.cpp
@@ -0,0 +1,119 @@
+#include "barretenberg/vm2/tracegen_helper.hpp"
+
+#include <array>
+#include <functional>
+#include <list>
+#include <span>
+
+#include "barretenberg/common/std_array.hpp"
+#include "barretenberg/common/thread.hpp"
+#include "barretenberg/numeric/bitop/get_msb.hpp"
+#include "barretenberg/vm/stats.hpp"
+#include "barretenberg/vm2/generated/relations/lookup_dummy_dynamic.hpp"
+#include "barretenberg/vm2/generated/relations/lookup_dummy_precomputed.hpp"
+#include "barretenberg/vm2/generated/relations/perm_dummy_dynamic.hpp"
+#include "barretenberg/vm2/tracegen/alu_trace.hpp"
+#include "barretenberg/vm2/tracegen/execution_trace.hpp"
+#include "barretenberg/vm2/tracegen/lib/lookup_into_bitwise.hpp"
+#include "barretenberg/vm2/tracegen/lib/permutation_builder.hpp"
+#include "barretenberg/vm2/tracegen/precomputed_trace.hpp"
+#include "barretenberg/vm2/tracegen/trace_container.hpp"
+
+namespace bb::avm2 {
+
+using namespace bb::avm2::simulation;
+using namespace bb::avm2::tracegen;
+
+namespace {
+
+auto build_precomputed_columns_jobs(TraceContainer& trace)
+{
+    return std::array<std::function<void()>, 2>{
+        [&]() {
+            PrecomputedTraceBuilder precomputed_builder;
+            AVM_TRACK_TIME("tracegen/precomputed/misc", precomputed_builder.process_misc(trace));
+        },
+        [&]() {
+            PrecomputedTraceBuilder precomputed_builder;
+            AVM_TRACK_TIME("tracegen/precomputed/bitwise", precomputed_builder.process_bitwise(trace));
+        },
+    };
+}
+
+void execute_jobs(std::span<std::function<void()>> jobs)
+{
+    parallel_for(jobs.size(), [&](size_t i) { jobs[i](); });
+}
+
+template <typename T> inline void clear_events(T& c)
+{
+    c.clear();
+    c.shrink_to_fit();
+}
+
+} // namespace
+
+TraceContainer AvmTraceGenHelper::generate_trace(EventsContainer&& events)
+{
+    TraceContainer trace;
+
+    // We process the events in parallel. Ideally the jobs should access disjoint column sets.
+    {
+        auto jobs = concatenate(
+            // Precomputed column jobs.
+            build_precomputed_columns_jobs(trace),
+            // Subtrace jobs.
+            std::array<std::function<void()>, 2>{
+                [&]() {
+                    ExecutionTraceBuilder exec_builder;
+                    AVM_TRACK_TIME("tracegen/execution",
+                                   exec_builder.process(events.execution, events.addressing, trace));
+                    clear_events(events.execution);
+                    clear_events(events.addressing);
+                },
+                [&]() {
+                    AluTraceBuilder alu_builder;
+                    AVM_TRACK_TIME("tracegen/alu", alu_builder.process(events.alu, trace));
+                    clear_events(events.alu);
+                },
+            });
+        AVM_TRACK_TIME("tracegen/traces", execute_jobs(jobs));
+    }
+
+    // Now we can compute lookups and permutations.
+    {
+        auto jobs_interactions = std::array<std::function<void()>, 3>{
+            [&]() {
+                LookupIntoBitwise<lookup_dummy_precomputed_lookup_settings> lookup_execution_bitwise;
+                lookup_execution_bitwise.process(trace);
+            },
+            [&]() {
+                LookupIntoDynamicTable<lookup_dummy_dynamic_lookup_settings> lookup_execution_execution;
+                lookup_execution_execution.process(trace);
+            },
+            [&]() {
+                PermutationBuilder<perm_dummy_dynamic_permutation_settings> perm_execution_execution;
+                perm_execution_execution.process(trace);
+            },
+        };
+        AVM_TRACK_TIME("tracegen/interactions", execute_jobs(jobs_interactions));
+    }
+
+    const auto rows = trace.get_num_rows_without_clk();
+    info("Generated trace with ",
+         rows,
+         " rows (closest power of 2: ",
+         numeric::get_msb(numeric::round_up_power_2(rows)),
+         ") and column clk with 2^21 rows.");
+    return trace;
+}
+
+TraceContainer AvmTraceGenHelper::generate_precomputed_columns()
+{
+    TraceContainer trace;
+    auto jobs = build_precomputed_columns_jobs(trace);
+    execute_jobs(jobs);
+    return trace;
+}
+
+} // namespace bb::avm2
\ No newline at end of file
diff --git a/barretenberg/cpp/src/barretenberg/vm2/tracegen_helper.hpp b/barretenberg/cpp/src/barretenberg/vm2/tracegen_helper.hpp
new file mode 100644
index 00000000000..d202f555880
--- /dev/null
+++ b/barretenberg/cpp/src/barretenberg/vm2/tracegen_helper.hpp
@@ -0,0 +1,16 @@
+#pragma once
+
+#include "barretenberg/vm2/simulation/events/events_container.hpp"
+#include "barretenberg/vm2/tracegen/trace_container.hpp"
+
+namespace bb::avm2 {
+
+class AvmTraceGenHelper {
+  public:
+    AvmTraceGenHelper() = default;
+
+    tracegen::TraceContainer generate_trace(simulation::EventsContainer&& events);
+    tracegen::TraceContainer generate_precomputed_columns();
+};
+
+} // namespace bb::avm2
\ No newline at end of file
diff --git a/bb-pilcom/bb-pil-backend/templates/flavor.hpp.hbs b/bb-pilcom/bb-pil-backend/templates/flavor.hpp.hbs
index 14837a81693..30ba9f58e11 100644
--- a/bb-pilcom/bb-pil-backend/templates/flavor.hpp.hbs
+++ b/bb-pilcom/bb-pil-backend/templates/flavor.hpp.hbs
@@ -106,6 +106,8 @@ class AvmFlavor {
         (NUM_WITNESS_ENTITIES + 1) * NUM_FRS_COM + (NUM_ALL_ENTITIES + 1) * NUM_FRS_FR +
         CONST_PROOF_SIZE_LOG_N * (NUM_FRS_COM + NUM_FRS_FR * (BATCHED_RELATION_PARTIAL_LENGTH + 1));
 
+    {{!-- TODO: recover asserts when we drop the old witgen. --}}
+    {{#if (ne name "Avm2")}}
     static_assert(AVM_PROOF_LENGTH_IN_FIELDS == COMPUTED_AVM_PROOF_LENGTH_IN_FIELDS,
                   "\nUnexpected AVM proof length. This might be due to some changes in the\n"
                   "AVM circuit layout. In this case, modify AVM_PROOF_LENGTH_IN_FIELDS \n"
@@ -119,6 +121,7 @@ class AvmFlavor {
                   "\nUnexpected AVM VK length. This might be due to some changes in the\n"
                   "AVM circuit. In this case, modify AVM_VERIFICATION_LENGTH_IN_FIELDS \n"
                   "in constants.nr accordingly.");
+    {{/if}}
 
     template <typename DataType_> class PrecomputedEntities : public PrecomputedEntitiesBase {
       public:
@@ -222,6 +225,7 @@ class AvmFlavor {
     class VerificationKey : public VerificationKey_<PrecomputedEntities<Commitment>, VerifierCommitmentKey> {
       public:
        using FF = VerificationKey_::FF;
+       static constexpr size_t NUM_PRECOMPUTED_COMMITMENTS = NUM_PRECOMPUTED_ENTITIES;
 
        VerificationKey() = default;
 
@@ -237,7 +241,7 @@ class AvmFlavor {
 
         VerificationKey(const size_t circuit_size,
                         const size_t num_public_inputs,
-                        std::array<Commitment, NUM_PRECOMPUTED_ENTITIES> const& precomputed_cmts)
+                        std::array<Commitment, NUM_PRECOMPUTED_COMMITMENTS> const& precomputed_cmts)
             : VerificationKey_(circuit_size, num_public_inputs)
         {
             for (auto [vk_cmt, cmt] : zip_view(this->get_all(), precomputed_cmts)) {
diff --git a/bb-pilcom/bb-pil-backend/templates/prover.hpp.hbs b/bb-pilcom/bb-pil-backend/templates/prover.hpp.hbs
index 77f5d9f6188..7ae2474f5c5 100644
--- a/bb-pilcom/bb-pil-backend/templates/prover.hpp.hbs
+++ b/bb-pilcom/bb-pil-backend/templates/prover.hpp.hbs
@@ -10,6 +10,7 @@
 namespace bb::{{snakeCase name}} {
 
 class AvmProver {
+  public:
     using Flavor = AvmFlavor;
     using FF = Flavor::FF;
     using PCS = Flavor::PCS;
@@ -20,8 +21,8 @@ class AvmProver {
     using ProverPolynomials = Flavor::ProverPolynomials;
     using CommitmentLabels = Flavor::CommitmentLabels;
     using Transcript = Flavor::Transcript;
+    using Proof = HonkProof;
 
-  public:
     explicit AvmProver(std::shared_ptr<ProvingKey> input_key, std::shared_ptr<PCSCommitmentKey> commitment_key);
     AvmProver(AvmProver&& prover) = default;
     virtual ~AvmProver() = default;
diff --git a/bb-pilcom/bb-pil-backend/templates/verifier.hpp.hbs b/bb-pilcom/bb-pil-backend/templates/verifier.hpp.hbs
index ae871abc83f..c7011d56e54 100644
--- a/bb-pilcom/bb-pil-backend/templates/verifier.hpp.hbs
+++ b/bb-pilcom/bb-pil-backend/templates/verifier.hpp.hbs
@@ -8,6 +8,7 @@
 namespace bb::{{snakeCase name}} {
 
 class AvmVerifier {
+  public:
     using Flavor = AvmFlavor;
     using FF = Flavor::FF;
     using Commitment = Flavor::Commitment;
@@ -15,7 +16,6 @@ class AvmVerifier {
     using VerifierCommitmentKey = Flavor::VerifierCommitmentKey;
     using Transcript = Flavor::Transcript;
 
-  public:
     explicit AvmVerifier(std::shared_ptr<VerificationKey> verifier_key);
     AvmVerifier(AvmVerifier&& other) noexcept;
     AvmVerifier(const AvmVerifier& other) = delete;
diff --git a/yarn-project/bb-prover/src/avm_proving.test.ts b/yarn-project/bb-prover/src/avm_proving.test.ts
index 0adfbab0607..255da9d331c 100644
--- a/yarn-project/bb-prover/src/avm_proving.test.ts
+++ b/yarn-project/bb-prover/src/avm_proving.test.ts
@@ -18,14 +18,21 @@ import fs from 'node:fs/promises';
 import { tmpdir } from 'node:os';
 import path from 'path';
 
-import { type BBSuccess, BB_RESULT, generateAvmProof, verifyAvmProof } from './bb/execute.js';
+import {
+  type BBSuccess,
+  BB_RESULT,
+  generateAvmProof,
+  generateAvmProofV2,
+  verifyAvmProof,
+  verifyAvmProofV2,
+} from './bb/execute.js';
 import { extractAvmVkData } from './verification_key/verification_key_data.js';
 
 const TIMEOUT = 300_000;
 
 describe('AVM WitGen, proof generation and verification', () => {
   it(
-    'Should prove and verify bulk_testing',
+    'Should prove and verify bulk_testing v1',
     async () => {
       await proveAndVerifyAvmTestContract(
         'bulk_testing',
@@ -199,17 +206,16 @@ async function proveAndVerifyAvmTestContract(
     contractDataSource,
   );
 
-  const internalLogger = createLogger('bb-prover:avm-proving-test');
-  const logger = (msg: string, _data?: any) => internalLogger.verbose(msg);
+  const logger = createLogger('bb-prover:avm-proving-test');
 
   // The paths for the barretenberg binary and the write path are hardcoded for now.
   const bbPath = path.resolve('../../barretenberg/cpp/build/bin/bb');
   const bbWorkingDirectory = await fs.mkdtemp(path.join(tmpdir(), 'bb-'));
 
   // Then we prove.
-  const proofRes = await generateAvmProof(bbPath, bbWorkingDirectory, avmCircuitInputs, internalLogger);
+  const proofRes = await generateAvmProof(bbPath, bbWorkingDirectory, avmCircuitInputs, logger);
   if (proofRes.status === BB_RESULT.FAILURE) {
-    internalLogger.error(`Proof generation failed: ${proofRes.reason}`);
+    logger.error(`Proof generation failed: ${proofRes.reason}`);
   }
   expect(proofRes.status).toEqual(BB_RESULT.SUCCESS);
 
@@ -223,3 +229,42 @@ async function proveAndVerifyAvmTestContract(
   const verificationRes = await verifyAvmProof(bbPath, succeededRes.proofPath!, rawVkPath, logger);
   expect(verificationRes.status).toBe(BB_RESULT.SUCCESS);
 }
+
+describe('AVM WitGen, proof generation and verification', () => {
+  it('Should prove and verify bulk_testing v2', async () => {
+    const functionName = 'bulk_testing';
+    const calldata = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10].map(x => new Fr(x));
+    const avmCircuitInputs = await simulateAvmTestContractGenerateCircuitInputs(functionName, calldata, false);
+
+    const logger = createLogger('bb-prover:avm-proving-test');
+
+    // The paths for the barretenberg binary and the write path are hardcoded for now.
+    const bbPath = path.resolve('../../barretenberg/cpp/build/bin/bb');
+    const bbWorkingDirectory = await fs.mkdtemp(path.join(tmpdir(), 'bb-'));
+
+    // Then we prove.
+    const proofRes = await generateAvmProofV2(bbPath, bbWorkingDirectory, avmCircuitInputs, logger);
+    if (proofRes.status === BB_RESULT.FAILURE) {
+      logger.error(`Proof generation failed: ${proofRes.reason}`);
+    }
+    expect(proofRes.status).toEqual(BB_RESULT.SUCCESS);
+    const succeededRes = proofRes as BBSuccess;
+
+    // Then we verify.
+    // Placeholder for now.
+    const publicInputs = {
+      dummy: [] as any[],
+    };
+
+    const rawVkPath = path.join(succeededRes.vkPath!, 'vk');
+    const verificationRes = await verifyAvmProofV2(
+      bbPath,
+      bbWorkingDirectory,
+      succeededRes.proofPath!,
+      publicInputs,
+      rawVkPath,
+      logger,
+    );
+    expect(verificationRes.status).toBe(BB_RESULT.SUCCESS);
+  }, 180_000);
+});
diff --git a/yarn-project/bb-prover/src/bb/execute.ts b/yarn-project/bb-prover/src/bb/execute.ts
index 48a68983126..42a054264e8 100644
--- a/yarn-project/bb-prover/src/bb/execute.ts
+++ b/yarn-project/bb-prover/src/bb/execute.ts
@@ -1,4 +1,4 @@
-import { type AvmCircuitInputs } from '@aztec/circuits.js';
+import { type AvmCircuitInputs, serializeWithMessagePack } from '@aztec/circuits.js';
 import { sha256 } from '@aztec/foundation/crypto';
 import { type LogFn, type Logger } from '@aztec/foundation/log';
 import { Timer } from '@aztec/foundation/timer';
@@ -75,7 +75,7 @@ export function executeBB(
     // spawn the bb process
     const { HARDWARE_CONCURRENCY: _, ...envWithoutConcurrency } = process.env;
     const env = process.env.HARDWARE_CONCURRENCY ? process.env : envWithoutConcurrency;
-    logger(`Executing BB with: ${command} ${args.join(' ')}`);
+    logger(`Executing BB with: ${pathToBB} ${command} ${args.join(' ')}`);
     const bb = proc.spawn(pathToBB, [command, ...args], {
       env,
     });
@@ -492,6 +492,86 @@ export async function generateTubeProof(
   }
 }
 
+/**
+ * Used for generating AVM proofs.
+ * It is assumed that the working directory is a temporary and/or random directory used solely for generating this proof.
+ * @param pathToBB - The full path to the bb binary
+ * @param workingDirectory - A working directory for use by bb
+ * @param input - The inputs for the public function to be proven
+ * @param log - A logging function
+ * @returns An object containing a result indication, the location of the proof and the duration taken
+ */
+export async function generateAvmProofV2(
+  pathToBB: string,
+  workingDirectory: string,
+  input: AvmCircuitInputs,
+  logger: Logger,
+): Promise<BBFailure | BBSuccess> {
+  // Check that the working directory exists
+  try {
+    await fs.access(workingDirectory);
+  } catch (error) {
+    return { status: BB_RESULT.FAILURE, reason: `Working directory ${workingDirectory} does not exist` };
+  }
+
+  // The proof is written to e.g. /workingDirectory/proof
+  const outputPath = workingDirectory;
+
+  const filePresent = async (file: string) =>
+    await fs
+      .access(file, fs.constants.R_OK)
+      .then(_ => true)
+      .catch(_ => false);
+
+  const binaryPresent = await filePresent(pathToBB);
+  if (!binaryPresent) {
+    return { status: BB_RESULT.FAILURE, reason: `Failed to find bb binary at ${pathToBB}` };
+  }
+
+  const inputsBuffer = input.serializeForAvm2();
+
+  try {
+    // Write the inputs to the working directory.
+    const avmInputsPath = join(workingDirectory, 'avm_inputs.bin');
+    await fs.writeFile(avmInputsPath, inputsBuffer);
+    if (!filePresent(avmInputsPath)) {
+      return { status: BB_RESULT.FAILURE, reason: `Could not write avm inputs to ${avmInputsPath}` };
+    }
+
+    const args = [
+      '--avm-inputs',
+      avmInputsPath,
+      '-o',
+      outputPath,
+      logger.level === 'debug' || logger.level === 'trace' ? '-d' : logger.level === 'verbose' ? '-v' : '',
+    ];
+    const timer = new Timer();
+    const logFunction = (message: string) => {
+      logger.verbose(`AvmCircuit (prove) BB out - ${message}`);
+    };
+    const result = await executeBB(pathToBB, 'avm2_prove', args, logFunction);
+    const duration = timer.ms();
+
+    if (result.status == BB_RESULT.SUCCESS) {
+      return {
+        status: BB_RESULT.SUCCESS,
+        durationMs: duration,
+        proofPath: join(outputPath, PROOF_FILENAME),
+        pkPath: undefined,
+        vkPath: outputPath,
+      };
+    }
+    // Not a great error message here but it is difficult to decipher what comes from bb
+    return {
+      status: BB_RESULT.FAILURE,
+      reason: `Failed to generate proof. Exit code ${result.exitCode}. Signal ${result.signal}.`,
+      retry: !!result.signal,
+    };
+  } catch (error) {
+    return { status: BB_RESULT.FAILURE, reason: `${error}` };
+  }
+}
+
 /**
  * Used for generating AVM proofs.
  * It is assumed that the working directory is a temporary and/or random directory used solely for generating this proof.
@@ -594,7 +674,7 @@ export async function verifyProof(
   proofFullPath: string,
   verificationKeyPath: string,
   ultraHonkFlavor: UltraHonkFlavor,
-  log: LogFn,
+  log: Logger,
 ): Promise<BBFailure | BBSuccess> {
   return await verifyProofInternal(pathToBB, proofFullPath, verificationKeyPath, `verify_${ultraHonkFlavor}`, log);
 }
@@ -611,9 +691,37 @@ export async function verifyAvmProof(
   pathToBB: string,
   proofFullPath: string,
   verificationKeyPath: string,
-  log: LogFn,
+  logger: Logger,
 ): Promise<BBFailure | BBSuccess> {
-  return await verifyProofInternal(pathToBB, proofFullPath, verificationKeyPath, 'avm_verify', log);
+  return await verifyProofInternal(pathToBB, proofFullPath, verificationKeyPath, 'avm_verify', logger);
+}
+
+export async function verifyAvmProofV2(
+  pathToBB: string,
+  workingDirectory: string,
+  proofFullPath: string,
+  publicInputs: any,
+  verificationKeyPath: string,
+  logger: Logger,
+): Promise<BBFailure | BBSuccess> {
+  const inputsBuffer = serializeWithMessagePack(publicInputs);
+
+  // Write the inputs to the working directory.
+  const filePresent = async (file: string) =>
+    await fs
+      .access(file, fs.constants.R_OK)
+      .then(_ => true)
+      .catch(_ => false);
+  const avmInputsPath = join(workingDirectory, 'avm_public_inputs.bin');
+  await fs.writeFile(avmInputsPath, inputsBuffer);
+  if (!filePresent(avmInputsPath)) {
+    return { status: BB_RESULT.FAILURE, reason: `Could not write avm inputs to ${avmInputsPath}` };
+  }
+
+  return await verifyProofInternal(pathToBB, proofFullPath, verificationKeyPath, 'avm2_verify', logger, [
+    '--avm-public-inputs',
+    avmInputsPath,
+  ]);
 }
 
 /**
@@ -670,8 +778,9 @@ async function verifyProofInternal(
   pathToBB: string,
   proofFullPath: string,
   verificationKeyPath: string,
-  command: 'verify_ultra_honk' | 'verify_ultra_rollup_honk' | 'verify_ultra_keccak_honk' | 'avm_verify',
-  log: LogFn,
+  command: 'verify_ultra_honk' | 'verify_ultra_rollup_honk' | 'verify_ultra_keccak_honk' | 'avm_verify' | 'avm2_verify',
+  logger: Logger,
+  extraArgs: string[] = [],
 ): Promise<BBFailure | BBSuccess> {
   const binaryPresent = await fs
     .access(pathToBB, fs.constants.R_OK)
@@ -681,10 +790,21 @@ async function verifyProofInternal(
     return { status: BB_RESULT.FAILURE, reason: `Failed to find bb binary at ${pathToBB}` };
   }
 
+  const logFunction = (message: string) => {
+    logger.verbose(`AvmCircuit (verify) BB out - ${message}`);
+  };
+
   try {
-    const args = ['-p', proofFullPath, '-k', verificationKeyPath];
+    const args = [
+      '-p',
+      proofFullPath,
+      '-k',
+      verificationKeyPath,
+      logger.level === 'debug' || logger.level === 'trace' ? '-d' : logger.level === 'verbose' ? '-v' : '',
+      ...extraArgs,
+    ];
     const timer = new Timer();
-    const result = await executeBB(pathToBB, command, args, log);
+    const result = await executeBB(pathToBB, command, args, logFunction);
     const duration = timer.ms();
     if (result.status == BB_RESULT.SUCCESS) {
       return { status: BB_RESULT.SUCCESS, durationMs: duration };
diff --git a/yarn-project/bb-prover/src/prover/bb_prover.ts b/yarn-project/bb-prover/src/prover/bb_prover.ts
index c702d668aa2..b983ccc18bb 100644
--- a/yarn-project/bb-prover/src/prover/bb_prover.ts
+++ b/yarn-project/bb-prover/src/prover/bb_prover.ts
@@ -680,13 +680,13 @@ export class BBNativeRollupProver implements ServerCircuitProver {
 
   public async verifyAvmProof(proof: Proof, verificationKey: VerificationKeyData) {
     return await this.verifyWithKeyInternal(proof, verificationKey, (proofPath, vkPath) =>
-      verifyAvmProof(this.config.bbBinaryPath, proofPath, vkPath, logger.debug),
+      verifyAvmProof(this.config.bbBinaryPath, proofPath, vkPath, logger),
     );
   }
 
   public async verifyWithKey(flavor: UltraHonkFlavor, verificationKey: VerificationKeyData, proof: Proof) {
     return await this.verifyWithKeyInternal(proof, verificationKey, (proofPath, vkPath) =>
-      verifyProof(this.config.bbBinaryPath, proofPath, vkPath, flavor, logger.debug),
+      verifyProof(this.config.bbBinaryPath, proofPath, vkPath, flavor, logger),
     );
   }
 
diff --git a/yarn-project/bb-prover/src/verifier/bb_verifier.ts b/yarn-project/bb-prover/src/verifier/bb_verifier.ts
index ccf19dcf057..09e52c192d6 100644
--- a/yarn-project/bb-prover/src/verifier/bb_verifier.ts
+++ b/yarn-project/bb-prover/src/verifier/bb_verifier.ts
@@ -103,16 +103,12 @@ export class BBCircuitVerifier implements ClientProtocolCircuitVerifier {
       await fs.writeFile(proofFileName, proof.buffer);
       await fs.writeFile(verificationKeyPath, verificationKey.keyAsBytes);
 
-      const logFunction = (message: string) => {
-        this.logger.debug(`${circuit} BB out - ${message}`);
-      };
-
       const result = await verifyProof(
         this.config.bbBinaryPath,
         proofFileName,
         verificationKeyPath!,
         getUltraHonkFlavorForCircuit(circuit),
-        logFunction,
+        this.logger,
       );
 
       if (result.status === BB_RESULT.FAILURE) {
diff --git a/yarn-project/circuits.js/package.json b/yarn-project/circuits.js/package.json
index b5941142e50..44bd0d79dfd 100644
--- a/yarn-project/circuits.js/package.json
+++ b/yarn-project/circuits.js/package.json
@@ -46,6 +46,7 @@
     "@aztec/foundation": "workspace:^",
     "@aztec/types": "workspace:^",
     "eslint": "^8.35.0",
+    "msgpackr": "^1.11.2",
     "tslib": "^2.4.0",
     "zod": "^3.23.8"
   },
diff --git a/yarn-project/circuits.js/src/structs/avm/avm.test.ts b/yarn-project/circuits.js/src/structs/avm/avm.test.ts
index 3b6f765e013..e9fbe35e0d6 100644
--- a/yarn-project/circuits.js/src/structs/avm/avm.test.ts
+++ b/yarn-project/circuits.js/src/structs/avm/avm.test.ts
@@ -1,7 +1,9 @@
+import { AztecAddress, Fr, Point, PublicKeys } from '@aztec/circuits.js';
 import { randomInt } from '@aztec/foundation/crypto';
+import { readTestData, writeTestData } from '@aztec/foundation/testing/files';
 
 import { makeAvmCircuitInputs } from '../../tests/factories.js';
-import { AvmCircuitInputs } from './avm.js';
+import { AvmCircuitInputs, serializeWithMessagePack } from './avm.js';
 
 describe('Avm circuit inputs', () => {
   it(`serializes to buffer and deserializes it back`, () => {
@@ -10,4 +12,122 @@ describe('Avm circuit inputs', () => {
     const res = AvmCircuitInputs.fromBuffer(buffer);
     expect(res).toEqual(avmCircuitInputs);
   });
+
+  it('serialization sample for avm2', () => {
+    const hints = {
+      contractInstances: [
+        {
+          address: AztecAddress.fromBigInt(0x123456n),
+          exists: true,
+          salt: new Fr(0xdeadbeefn),
+          deployer: AztecAddress.fromBigInt(0x000010n),
+          contractClassId: new Fr(0x41181337n),
+          initializationHash: new Fr(0x111111n),
+          publicKeys: new PublicKeys(
+            new Point(
+              new Fr(0x16421839f863564fbe9035338aa8ef7bda077d04b178b1353e781cac7e83d155n),
+              new Fr(0x2b6a73d9c017111f8223c81980e9ad167e1dec57d3f2fa649b11355b70b5f086n),
+              false,
+            ),
+            new Point(
+              new Fr(0x047d001b3998ca8ae785c6a06870d4b56335f510743f3e68fda159fe60f22582n),
+              new Fr(0x1500cab14a6ea87cb26389431b0739bcf4b159d0e25b2c3a1cab94944254dcc4n),
+              false,
+            ),
+            new Point(
+              new Fr(0x03e11607d5adc8ce958646d7ef7cdcd8f4f48e0af20eca0ab4b07e8d1fc23deen),
+              new Fr(0x1c89d3deed018ba1dbc81b9dfe265b367dbcf383f7e4374ba5c749028ba97158n),
+              false,
+            ),
+            new Point(
+              new Fr(0x268630a713908316c9af34f1d0f7f6e9dd80311b4973e2025bd86669a9955b23n),
+              new Fr(0x227bca4c20b3000895ddb7f69d0cb375247d6ef49beffc54a8d264731d52fd24n),
+              false,
+            ),
+          ),
+          // TODO: membershipHint
+        },
+        {
+          address: AztecAddress.fromBigInt(0x654321n),
+          exists: false,
+          salt: new Fr(0xdead0000n),
+          deployer: AztecAddress.fromBigInt(0x000020n),
+          contractClassId: new Fr(0x51181337n),
+          initializationHash: new Fr(0x222222n),
+          publicKeys: new PublicKeys(
+            new Point(
+              new Fr(0x16421839f863564fbe9035338aa8ef7bda077d04b178b1353e781cac7e83d155n),
+              new Fr(0x2b6a73d9c017111f8223c81980e9ad167e1dec57d3f2fa649b11355b70b5f086n),
+              false,
+            ),
+            new Point(
+              new Fr(0x047d001b3998ca8ae785c6a06870d4b56335f510743f3e68fda159fe60f22582n),
+              new Fr(0x1500cab14a6ea87cb26389431b0739bcf4b159d0e25b2c3a1cab94944254dcc4n),
+              false,
+            ),
+            new Point(
+              new Fr(0x03e11607d5adc8ce958646d7ef7cdcd8f4f48e0af20eca0ab4b07e8d1fc23deen),
+              new Fr(0x1c89d3deed018ba1dbc81b9dfe265b367dbcf383f7e4374ba5c749028ba97158n),
+              false,
+            ),
+            new Point(
+              new Fr(0x268630a713908316c9af34f1d0f7f6e9dd80311b4973e2025bd86669a9955b23n),
+              new Fr(0x227bca4c20b3000895ddb7f69d0cb375247d6ef49beffc54a8d264731d52fd24n),
+              false,
+            ),
+          ),
+          // TODO: membershipHint
+        },
+      ],
+      contractClasses: [
+        {
+          artifactHash: new Fr(0xdeadbeefn),
+          privateFunctionsRoot: new Fr(0x111111n),
+          publicBytecodeCommitment: new Fr(0x222222n),
+          packedBytecode: Buffer.from('firstbuffer'),
+        },
+        {
+          artifactHash: new Fr(0xdead0000n),
+          privateFunctionsRoot: new Fr(0x222222n),
+          publicBytecodeCommitment: new Fr(0x333333n),
+          packedBytecode: Buffer.from('secondbuffer'),
+        },
+      ],
+    };
+
+    const enqueuedCalls = [
+      {
+        contractAddress: AztecAddress.fromBigInt(0x123456n),
+        sender: AztecAddress.fromBigInt(0x000010n),
+        args: [new Fr(0x111111n), new Fr(0x222222n), new Fr(0x333333n)],
+        isStatic: false,
+      },
+      {
+        contractAddress: AztecAddress.fromBigInt(0x654321n),
+        sender: AztecAddress.fromBigInt(0x000020n),
+        args: [new Fr(0x222222n), new Fr(0x333333n), new Fr(0x444444n)],
+        isStatic: true,
+      },
+    ];
+
+    // Placeholder for now.
+    const publicInputs = { dummy: [] };
+
+    const inputs = {
+      hints: hints,
+      enqueuedCalls: enqueuedCalls,
+      publicInputs: publicInputs,
+    };
+
+    // FIXME: this should use inputs.serializeForAvm2(), but I don't want to construct
+    // an AvmCircuitInputs here, since that the "old" structure.
+    const buffer = serializeWithMessagePack(inputs);
+
+    // Run with AZTEC_GENERATE_TEST_DATA=1 to update test data
+    const path = 'barretenberg/cpp/src/barretenberg/vm2/common/avm_inputs.testdata.bin';
+    writeTestData(path, buffer);
+
+    const expected = readTestData(path);
+    expect(buffer).toEqual(expected);
+  });
 });
diff --git a/yarn-project/circuits.js/src/structs/avm/avm.ts b/yarn-project/circuits.js/src/structs/avm/avm.ts
index d65fea2beb1..dda6d42cafa 100644
--- a/yarn-project/circuits.js/src/structs/avm/avm.ts
+++ b/yarn-project/circuits.js/src/structs/avm/avm.ts
@@ -1,11 +1,14 @@
 import { PublicDataTreeLeafPreimage } from '@aztec/circuits.js';
 import { AztecAddress } from '@aztec/foundation/aztec-address';
-import { Fr } from '@aztec/foundation/fields';
+import { Fq, Fr, Point } from '@aztec/foundation/fields';
 import { bufferSchemaFor } from '@aztec/foundation/schemas';
 import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
 import { bufferToHex, hexToBuffer } from '@aztec/foundation/string';
 import { type FieldsOf } from '@aztec/foundation/types';
 
+import { strict as assert } from 'assert';
+import { Encoder, addExtension } from 'msgpackr';
+
 import { type ContractClassIdPreimage } from '../../contract/contract_class_id.js';
 import { PublicKeys } from '../../types/public_keys.js';
 import { PublicCircuitPublicInputs } from '../public_circuit_public_inputs.js';
@@ -936,4 +939,96 @@ export class AvmCircuitInputs {
   static get schema() {
     return bufferSchemaFor(AvmCircuitInputs);
   }
+
+  /** Serializes in format for the Avm2 */
+  serializeForAvm2(): Buffer {
+    // logger(`original: ${inspect(input)}`);
+    // logger.verbose(`original: ${inspect(this.avmHints.enqueuedCalls.items)}`);
+    // Convert the inputs to something that works with vm2 and messagepack.
+    // const inputSubset = {
+    //   ffs: [new Fr(0x123456789), new Fr(0x987654321)],
+    //   affine: new Point(new Fr(0x123456789), new Fr(0x987654321), false),
+    //   fq: new Fq(0x123456789),
+    //   addr: AztecAddress.fromBigInt(0x123456789n),
+    //   contract_instance_hints: this.avmHints.contractInstances,
+    // };
+    const hints = {
+      contractInstances: [] as any[],
+      contractClasses: [] as any[],
+    };
+    const inputs = {
+      hints: hints,
+      enqueuedCalls: [] as any[],
+      // Placeholder for now.
+      publicInputs: {
+        dummy: [] as any[],
+      },
+    };
+    // For now we only transform bytecode requests. If we ever have any other
+    // contract instance hint, this will clash!
+    // See https://aztecprotocol.slack.com/archives/C04DL2L1UP2/p1733485524309389.
+    for (const bytecodeHint of this.avmHints.contractBytecodeHints.values()) {
+      hints.contractInstances.push(bytecodeHint.contractInstanceHint);
+      hints.contractClasses.push({
+        artifactHash: bytecodeHint.contractClassHint.artifactHash,
+        privateFunctionsRoot: bytecodeHint.contractClassHint.privateFunctionsRoot,
+        publicBytecodeCommitment: bytecodeHint.contractClassHint.publicBytecodeCommitment,
+        packedBytecode: bytecodeHint.bytecode,
+      });
+    }
+    // TODO: for now I only convert app logic requests?
+    for (const enqueuedCall of this.avmHints.enqueuedCalls.items) {
+      inputs.enqueuedCalls.push({
+        contractAddress: enqueuedCall.contractAddress,
+        sender: new Fr(0), // FIXME
+        args: enqueuedCall.calldata.items,
+        isStatic: false, // FIXME
+      });
+    }
+
+    const inputsBuffer = serializeWithMessagePack(inputs);
+
+    return inputsBuffer;
+  }
+}
+
+export function serializeWithMessagePack(obj: any): Buffer {
+  setUpMessagePackExtensions();
+  const encoder = new Encoder({
+    // always encode JS objects as MessagePack maps
+    // this makes it compatible with other MessagePack decoders
+    useRecords: false,
+    int64AsType: 'bigint',
+  });
+  return encoder.encode(obj);
+}
+
+function setUpMessagePackExtensions() {
+  // C++ Fr and Fq classes work well with the buffer serialization.
+  addExtension({
+    Class: Fr,
+    write: (fr: Fr) => fr.toBuffer(),
+  });
+  addExtension({
+    Class: Fq,
+    write: (fq: Fq) => fq.toBuffer(),
+  });
+  // AztecAddress is a class that has a field in TS, but just a field in C++.
+  addExtension({
+    Class: AztecAddress,
+    write: (addr: AztecAddress) => addr.toField(),
+  });
+  // If we find a vector, we just use the underlying list.
+  addExtension({
+    Class: Vector,
+    write: v => v.items,
+  });
+  // Affine points are a mess, we do our best.
+  addExtension({
+    Class: Point,
+    write: (p: Point) => {
+      assert(!p.inf, 'Cannot serialize infinity');
+      return { x: new Fq(p.x.toBigInt()), y: new Fq(p.y.toBigInt()) };
+    },
+  });
 }
diff --git a/yarn-project/foundation/src/testing/files/index.ts b/yarn-project/foundation/src/testing/files/index.ts
index ee82490fbdf..2267a5702ea 100644
--- a/yarn-project/foundation/src/testing/files/index.ts
+++ b/yarn-project/foundation/src/testing/files/index.ts
@@ -17,6 +17,11 @@ export function writeTestData(targetFileFromRepoRoot: string, contents: string |
   logger(`Wrote test data to ${targetFile}`);
 }
 
+export function readTestData(repoPath: string): Buffer {
+  const targetFile = getPathToFile(repoPath);
+  return readFileSync(targetFile);
+}
+
 /**
  * Looks for a variable assignment in the target file and updates the value, only if test data generation is enabled.
  * Note that a magic inline comment would be a cleaner approach, like `/* TEST-DATA-START *\/` and `/* TEST-DATA-END *\/`,
diff --git a/yarn-project/ivc-integration/src/avm_integration.test.ts b/yarn-project/ivc-integration/src/avm_integration.test.ts
index b3619391f91..20f913b6a95 100644
--- a/yarn-project/ivc-integration/src/avm_integration.test.ts
+++ b/yarn-project/ivc-integration/src/avm_integration.test.ts
@@ -113,7 +113,7 @@ describe('AVM Integration', () => {
       path.join(bbWorkingDirectory, 'proof'),
       path.join(bbWorkingDirectory, 'vk'),
       'ultra_honk',
-      logger.info,
+      logger,
     );
 
     expect(verifyResult.status).toBe(BB_RESULT.SUCCESS);
diff --git a/yarn-project/yarn.lock b/yarn-project/yarn.lock
index cf4a8c93dd9..9d7882a01cb 100644
--- a/yarn-project/yarn.lock
+++ b/yarn-project/yarn.lock
@@ -453,6 +453,7 @@ __metadata:
     "@types/node": "npm:^18.7.23"
     eslint: "npm:^8.35.0"
     jest: "npm:^29.5.0"
+    msgpackr: "npm:^1.11.2"
     prettier: "npm:^2.8.4"
     ts-node: "npm:^10.9.1"
     tslib: "npm:^2.4.0"