diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 25438f9e861..a0928949d7a 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -253,6 +253,18 @@ jobs:
       - name: Cargo Run E2E Tests (EVM)
         run: cargo run --locked --release --bin test -- --target evm --locked
 
+  cargo-run-e2e-test-midenvm:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+      - name: Install toolchain
+        uses: dtolnay/rust-toolchain@master
+        with:
+          toolchain: ${{ env.RUST_VERSION }}
+      - uses: Swatinem/rust-cache@v2
+      - name: Cargo Run E2E Tests (EVM)
+        run: cargo run --locked --release --bin test -- --target midenvm --locked
+
   # TODO: Remove this upon merging std tests with the rest of the E2E tests.
   cargo-test-lib-std:
     runs-on: ubuntu-latest
diff --git a/Cargo.lock b/Cargo.lock
index 64d57a87d10..dd01a2d4c76 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -365,7 +365,21 @@ checksum = "afa748e348ad3be8263be728124b24a24f268266f6f5d58af9d75f6a40b5c587"
 dependencies = [
  "arrayref",
  "arrayvec 0.5.2",
- "constant_time_eq",
+ "constant_time_eq 0.1.5",
+]
+
+[[package]]
+name = "blake3"
+version = "1.3.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "42ae2468a89544a466886840aa467a25b766499f4f04bf7d9fcd10ecee9fccef"
+dependencies = [
+ "arrayref",
+ "arrayvec 0.7.2",
+ "cc",
+ "cfg-if 1.0.0",
+ "constant_time_eq 0.2.4",
+ "digest 0.10.6",
 ]
 
 [[package]]
@@ -795,6 +809,12 @@ version = "0.1.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "245097e9a4535ee1e3e3931fcfcd55a796a44c643e8596ff6566d68f09b87bbc"
 
+[[package]]
+name = "constant_time_eq"
+version = "0.2.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f3ad85c1f65dc7b37604eb0e89748faf0b9653065f2a8ef69f96a687ec1e9279"
+
 [[package]]
 name = "convert_case"
 version = "0.4.0"
@@ -3103,6 +3123,100 @@ dependencies = [
  "autocfg",
 ]
 
+[[package]]
+name = "miden"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e8d8a25e092075f58af207e2a42bad5fbbf40c5200f13d2432a806db751a52b5"
+dependencies = [
+ "log",
+ "miden-air",
+ "miden-assembly",
+ "miden-core",
+ "miden-processor",
+ "miden-prover",
+ "miden-stdlib",
+ "miden-verifier",
+]
+
+[[package]]
+name = "miden-air"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5046ab97d8c2b7136601e9430fd0a14e7d6c6cdd648c90c1e6b39186a38b9a8b"
+dependencies = [
+ "miden-core",
+ "winter-air",
+]
+
+[[package]]
+name = "miden-assembly"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a04eec160cbd5cf3051ad16a244c3d83e648eddbd3349120dc069f6e309259dc"
+dependencies = [
+ "miden-core",
+ "num_enum",
+ "winter-crypto",
+]
+
+[[package]]
+name = "miden-core"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e75a2446684f44e61afb27bbdbf2458e8ec58c5c55d9bd202981d7cd265f7cf4"
+dependencies = [
+ "winter-crypto",
+ "winter-math",
+ "winter-utils",
+]
+
+[[package]]
+name = "miden-processor"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fb7a467447a7d6236f3971f91f8c47c8880a01a43c29b0b08285ec50454f02ed"
+dependencies = [
+ "log",
+ "miden-core",
+ "winter-prover",
+]
+
+[[package]]
+name = "miden-prover"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2343eaf338770b78fe421f36a3445bb491123e0787006dfa2b98788cd6440ec6"
+dependencies = [
+ "log",
+ "miden-air",
+ "miden-core",
+ "miden-processor",
+ "winter-prover",
+]
+
+[[package]]
+name = "miden-stdlib"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6b2a52fd1a44b136dbce7a513ebe5a407dfebc17160af8a2707383df731fc098"
+dependencies = [
+ "miden-assembly",
+ "miden-core",
+]
+
+[[package]]
+name = "miden-verifier"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d942d5b0bdcad47359d52534ef6fbccebffc0c713d2c7ca65ab603c7965c0a8b"
+dependencies = [
+ "miden-air",
+ "miden-assembly",
+ "miden-core",
+ "winter-verifier",
+]
+
 [[package]]
 name = "mime"
 version = "0.3.16"
@@ -4143,7 +4257,7 @@ checksum = "4b18820d944b33caa75a71378964ac46f58517c92b6ae5f762636247c09e78fb"
 dependencies = [
  "base64 0.13.1",
  "blake2b_simd",
- "constant_time_eq",
+ "constant_time_eq 0.1.5",
  "crossbeam-utils",
 ]
 
@@ -4806,6 +4920,7 @@ dependencies = [
  "im",
  "itertools",
  "lazy_static",
+ "miden-core",
  "pest",
  "pest_derive",
  "petgraph",
@@ -5130,6 +5245,7 @@ dependencies = [
  "futures",
  "gag",
  "hex",
+ "miden",
  "prettydiff 0.6.2",
  "rand",
  "regex",
@@ -6000,6 +6116,83 @@ dependencies = [
  "winapi",
 ]
 
+[[package]]
+name = "winter-air"
+version = "0.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ef91b335c5fefa4e6d3c6274de75a7744b4eecae2d7ee3778c23570f35f83396"
+dependencies = [
+ "winter-crypto",
+ "winter-fri",
+ "winter-math",
+ "winter-utils",
+]
+
+[[package]]
+name = "winter-crypto"
+version = "0.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3bd17ea728ff42185c54dfbabaafd0b442207df6b2cc60f74c607d8c01e9c4db"
+dependencies = [
+ "blake3",
+ "sha3 0.10.6",
+ "winter-math",
+ "winter-utils",
+]
+
+[[package]]
+name = "winter-fri"
+version = "0.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2473f8b2c5c553e9f9d4d94b3b7a1e75806b4cdc964004f9bde4b5fc07c10c87"
+dependencies = [
+ "winter-crypto",
+ "winter-math",
+ "winter-utils",
+]
+
+[[package]]
+name = "winter-math"
+version = "0.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "824b459961e5d679a1eb62ec1a71c85ac25c5d3bfd126874fcd32b591202d896"
+dependencies = [
+ "winter-utils",
+]
+
+[[package]]
+name = "winter-prover"
+version = "0.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3831583fd662f49f23ea39427aba20a9b5ab6326230f7994e843d2bd34524411"
+dependencies = [
+ "log",
+ "winter-air",
+ "winter-crypto",
+ "winter-fri",
+ "winter-math",
+ "winter-utils",
+]
+
+[[package]]
+name = "winter-utils"
+version = "0.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7f0dbf7ca6aa5893b59928718bf1e7dbe7279bb277b5aa4c4898ddf5004f9417"
+
+[[package]]
+name = "winter-verifier"
+version = "0.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "922be4651b76aa80e132386a97d23788e2bc542d37b3c187a39998876a8094b6"
+dependencies = [
+ "winter-air",
+ "winter-crypto",
+ "winter-fri",
+ "winter-math",
+ "winter-utils",
+]
+
 [[package]]
 name = "wyz"
 version = "0.5.1"
diff --git a/forc-pkg/src/pkg.rs b/forc-pkg/src/pkg.rs
index 13b6cecc9db..f91184e37c3 100644
--- a/forc-pkg/src/pkg.rs
+++ b/forc-pkg/src/pkg.rs
@@ -432,6 +432,8 @@ impl BuiltPackage {
                     res?
                 }
             }
+            // TODO?
+            ProgramABI::MidenVM(_) => (),
         }
 
         info!("      Bytecode size: {} bytes", self.bytecode.len());
@@ -1727,6 +1729,8 @@ pub fn compile(
 
             ProgramABI::Evm(ops)
         }
+
+        BuildTarget::MidenVM => ProgramABI::MidenVM(()),
     };
 
     let entries = asm_res
diff --git a/sway-core/Cargo.toml b/sway-core/Cargo.toml
index 3025de63c20..8567e1e2579 100644
--- a/sway-core/Cargo.toml
+++ b/sway-core/Cargo.toml
@@ -24,6 +24,7 @@ hex = { version = "0.4", optional = true }
 im = "15.0"
 itertools = "0.10"
 lazy_static = "1.4"
+miden-core = "0.3.0"
 pest = "2.1.3"
 pest_derive = "2.1"
 petgraph = "0.6"
diff --git a/sway-core/src/asm_generation/abi.rs b/sway-core/src/asm_generation/abi.rs
index 5a45ecdb811..4dd5e2bc28a 100644
--- a/sway-core/src/asm_generation/abi.rs
+++ b/sway-core/src/asm_generation/abi.rs
@@ -4,4 +4,5 @@ use super::EvmAbiResult;
 pub enum ProgramABI {
     Fuel(fuel_abi_types::program_abi::ProgramABI),
     Evm(EvmAbiResult),
+    MidenVM(()),
 }
diff --git a/sway-core/src/asm_generation/asm_builder.rs b/sway-core/src/asm_generation/asm_builder.rs
index 5c511532625..ff1f4f8827a 100644
--- a/sway-core/src/asm_generation/asm_builder.rs
+++ b/sway-core/src/asm_generation/asm_builder.rs
@@ -2,11 +2,15 @@ use sway_ir::Function;
 
 use crate::{asm_lang::Label, CompileResult};
 
-use super::{evm::EvmAsmBuilderResult, fuel::fuel_asm_builder::FuelAsmBuilderResult};
+use super::{
+    evm::EvmAsmBuilderResult, fuel::fuel_asm_builder::FuelAsmBuilderResult,
+    miden_vm::MidenVMAsmBuilderResult,
+};
 
 pub enum AsmBuilderResult {
     Fuel(FuelAsmBuilderResult),
     Evm(EvmAsmBuilderResult),
+    MidenVM(MidenVMAsmBuilderResult),
 }
 
 pub trait AsmBuilder {
diff --git a/sway-core/src/asm_generation/finalized_asm.rs b/sway-core/src/asm_generation/finalized_asm.rs
index ff12f21e911..8434ecdaaef 100644
--- a/sway-core/src/asm_generation/finalized_asm.rs
+++ b/sway-core/src/asm_generation/finalized_asm.rs
@@ -1,4 +1,5 @@
 use super::instruction_set::InstructionSet;
+use super::ToMidenBytecode;
 use super::{
     fuel::{checks, data_section::DataSection},
     ProgramABI, ProgramKind,
@@ -73,6 +74,14 @@ impl FinalizedAsm {
                     )
                 }
             }
+            InstructionSet::MidenVM { ops } => ok(
+                CompiledBytecode {
+                    bytecode: ops.to_bytecode().into(),
+                    config_const_offsets: Default::default(),
+                },
+                vec![],
+                vec![],
+            ),
         }
     }
 }
@@ -192,5 +201,6 @@ pub fn check_invalid_opcodes(asm: &FinalizedAsm) -> CompileResult<()> {
             ProgramKind::Predicate => checks::check_predicate_opcodes(&ops[..]),
         },
         InstructionSet::Evm { ops: _ } => ok((), vec![], vec![]),
+        InstructionSet::MidenVM { ops: _ } => ok((), vec![], vec![]),
     }
 }
diff --git a/sway-core/src/asm_generation/from_ir.rs b/sway-core/src/asm_generation/from_ir.rs
index c03ebecd312..864bd7c6397 100644
--- a/sway-core/src/asm_generation/from_ir.rs
+++ b/sway-core/src/asm_generation/from_ir.rs
@@ -8,6 +8,7 @@ use super::{
         register_sequencer::RegisterSequencer,
     },
     programs::{AbstractEntry, AbstractProgram, FinalProgram, ProgramKind},
+    MidenVMAsmBuilder,
 };
 
 use crate::{err, ok, BuildConfig, BuildTarget, CompileResult, CompileWarning};
@@ -82,6 +83,7 @@ fn compile_module_to_asm(
             context,
         )),
         BuildTarget::EVM => Box::new(EvmAsmBuilder::new(kind, context)),
+        BuildTarget::MidenVM => Box::new(MidenVMAsmBuilder::new(kind, context)),
     };
 
     // Pre-create labels for all functions before we generate other code, so we can call them
@@ -159,6 +161,7 @@ fn compile_module_to_asm(
             ops: result.ops,
             abi: result.abi,
         },
+        AsmBuilderResult::MidenVM(result) => FinalProgram::MidenVM { ops: result.ops },
     };
 
     ok(final_program, warnings, errors)
diff --git a/sway-core/src/asm_generation/fuel/fuel_asm_builder.rs b/sway-core/src/asm_generation/fuel/fuel_asm_builder.rs
index 52f700eaf64..eb3badb1c55 100644
--- a/sway-core/src/asm_generation/fuel/fuel_asm_builder.rs
+++ b/sway-core/src/asm_generation/fuel/fuel_asm_builder.rs
@@ -2072,8 +2072,8 @@ impl<'ir> FuelAsmBuilder<'ir> {
             })
     }
 
-    // Same as `opt_value_to_register` but returns a new register if no register is found or if
-    // `value` is not a constant.
+    /// Same as [`opt_value_to_register`] but returns a new register if no register is found or if
+    /// `value` is not a constant.
     pub(super) fn value_to_register(&mut self, value: &Value) -> VirtualRegister {
         match self.opt_value_to_register(value) {
             Some(reg) => reg,
diff --git a/sway-core/src/asm_generation/instruction_set.rs b/sway-core/src/asm_generation/instruction_set.rs
index c96c3f69df0..6e5f007e305 100644
--- a/sway-core/src/asm_generation/instruction_set.rs
+++ b/sway-core/src/asm_generation/instruction_set.rs
@@ -4,8 +4,15 @@ use std::fmt;
 /// An [InstructionSet] is produced by allocating registers on an [AbstractInstructionSet].
 #[derive(Clone)]
 pub enum InstructionSet {
-    Fuel { ops: Vec<AllocatedOp> },
-    Evm { ops: Vec<etk_asm::ops::AbstractOp> },
+    Fuel {
+        ops: Vec<AllocatedOp>,
+    },
+    Evm {
+        ops: Vec<etk_asm::ops::AbstractOp>,
+    },
+    MidenVM {
+        ops: Vec<crate::asm_generation::DirectOp>,
+    },
 }
 
 impl fmt::Display for InstructionSet {
@@ -24,6 +31,12 @@ impl fmt::Display for InstructionSet {
                     .map(|x| format!("{x}"))
                     .collect::<Vec<_>>()
                     .join("\n"),
+                InstructionSet::MidenVM { ops } => {
+                    ops.iter()
+                        .map(|x| format!("{x}"))
+                        .collect::<Vec<_>>()
+                        .join("\n")
+                }
             }
         )
     }
diff --git a/sway-core/src/asm_generation/miden_vm.rs b/sway-core/src/asm_generation/miden_vm.rs
new file mode 100644
index 00000000000..53e83db203a
--- /dev/null
+++ b/sway-core/src/asm_generation/miden_vm.rs
@@ -0,0 +1,2 @@
+mod miden_vm_asm_builder;
+pub use miden_vm_asm_builder::*;
diff --git a/sway-core/src/asm_generation/miden_vm/miden_vm_asm_builder.rs b/sway-core/src/asm_generation/miden_vm/miden_vm_asm_builder.rs
new file mode 100644
index 00000000000..913d5bbd572
--- /dev/null
+++ b/sway-core/src/asm_generation/miden_vm/miden_vm_asm_builder.rs
@@ -0,0 +1,652 @@
+#![allow(dead_code)]
+use std::{collections::HashMap, sync::Arc};
+mod miden_op;
+pub use miden_op::MidenAsmOp;
+
+use crate::{
+    asm_generation::{
+        asm_builder::{AsmBuilder, AsmBuilderResult},
+        from_ir::StateAccessType,
+        miden_vm::miden_vm_asm_builder::miden_op::{MidenStackValue, Push},
+        ProgramKind,
+    },
+    asm_lang::Label,
+    error::*,
+    metadata::MetadataManager,
+};
+
+use sway_error::error::CompileError;
+use sway_ir::{Context, *};
+use sway_types::Span;
+
+pub use miden_op::DirectOp;
+
+#[derive(Default)]
+pub struct MidenVMAsmSection {
+    ops: Vec<miden_core::Operation>,
+}
+
+/// A procedure block is used to define a frequently-used sequence of instructions. A procedure must
+/// start with a proc.<label>.<number of locals> instruction and terminate with an end instruction.
+/// [ref](https://wiki.polygon.technology/docs/miden/user_docs/assembly/code_organization#procedures)
+pub struct Procedure {
+    number_of_locals: u32,
+    ops: Vec<MidenAsmOp>,
+}
+
+#[derive(Default, Copy, Clone)]
+pub struct StackLabel(usize);
+
+#[derive(Default)]
+/// an abstract stack, used to organize instruction code
+pub struct StackManager {
+    idx: StackLabel,
+}
+
+impl StackManager {
+    pub fn insert_value(&mut self) -> StackLabel {
+        let label = self.idx;
+        self.idx.0 += 1;
+        label
+    }
+    pub fn size(&self) -> usize {
+        self.idx.0
+    }
+}
+// will likely want to minimize these names eventually
+// for now, we can use function names for readability
+pub type ProcedureName = String;
+
+pub type ProcedureMap = HashMap<ProcedureName, Procedure>;
+
+/// MidenVM Asm is built in the following way:
+/// Function bodies are abstracted into [Procedures]
+/// Arguments to functions are evaluated before the exec.proc is issued
+pub struct MidenVMAsmBuilder<'ir> {
+    procedure_map: ProcedureMap,
+    buf: Vec<MidenAsmOp>,
+    #[allow(dead_code)]
+    program_kind: ProgramKind,
+    pub(super) func_label_map: HashMap<Function, (Label, Label)>,
+    /// If we are currently compiling a procedure, then ops get inserted to that procedure
+    /// otherwise, we push to the main procedure
+    active_procedure: Option<ProcedureName>,
+
+    // IR context we're compiling.
+    context: &'ir Context,
+
+    // Metadata manager for converting metadata to Spans, etc.
+    md_mgr: MetadataManager,
+
+    // Monotonically increasing unique identifier for label generation.
+    label_idx: usize,
+
+    // stack label generator
+    stack_manager: StackManager,
+}
+
+impl std::fmt::Debug for MidenVMAsmBuilder<'_> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        let ops = self
+            .buf
+            .iter()
+            .map(|x| format!("{x}"))
+            .collect::<Vec<_>>()
+            .join("\n");
+        writeln!(f, "Stack size: {}", self.stack_manager.size())?;
+        write!(f, "{ops}")
+    }
+}
+
+impl MidenVMAsmSection {
+    pub fn new() -> Self {
+        Self::default()
+    }
+
+    pub fn size(&self) -> usize {
+        todo!()
+    }
+}
+
+pub struct MidenVMAsmBuilderResult {
+    pub ops: Vec<miden_op::DirectOp>,
+}
+
+pub type MidenVMAbiResult = ();
+
+impl<'ir> AsmBuilder for MidenVMAsmBuilder<'ir> {
+    fn compile_function(&mut self, function: Function) -> CompileResult<()> {
+        self.compile_function(function)
+    }
+
+    fn finalize(&self) -> AsmBuilderResult {
+        self.finalize_inner()
+    }
+
+    fn func_to_labels(&mut self, func: &Function) -> (Label, Label) {
+        self.func_label_map.get(func).cloned().unwrap_or_else(|| {
+            let labels = (self.get_label(), self.get_label());
+            self.func_label_map.insert(*func, labels);
+            labels
+        })
+    }
+}
+
+#[allow(unused_variables)]
+#[allow(dead_code)]
+impl<'ir> MidenVMAsmBuilder<'ir> {
+    pub fn new(program_kind: ProgramKind, context: &'ir Context) -> Self {
+        MidenVMAsmBuilder {
+            procedure_map: Default::default(),
+            buf: Default::default(),
+            func_label_map: Default::default(),
+            program_kind,
+            context,
+            md_mgr: MetadataManager::default(),
+            label_idx: 0,
+            stack_manager: Default::default(),
+            active_procedure: None,
+        }
+    }
+
+    #[allow(unreachable_code)]
+    pub fn finalize(&self) -> AsmBuilderResult {
+        AsmBuilderResult::MidenVM(MidenVMAsmBuilderResult { ops: todo!() })
+    }
+
+    fn generate_constructor(
+        &self,
+        is_payable: bool,
+        data_size: u32,
+        data_offset: u32,
+    ) -> MidenVMAsmSection {
+        todo!()
+    }
+
+    fn copy_contract_code_to_memory(
+        &self,
+        s: &mut MidenVMAsmSection,
+        data_size: u32,
+        data_offset: u32,
+    ) {
+        todo!()
+    }
+
+    fn generate_function(&mut self) -> MidenVMAsmSection {
+        todo!()
+    }
+
+    fn finalize_procedure_map(&self) -> Vec<DirectOp> {
+        let mut buf: Vec<DirectOp> = Vec::with_capacity(self.procedure_map.len());
+        for (ref proc_name, proc) in &self.procedure_map {
+            buf.push(DirectOp::procedure_decl(
+                proc_name.to_string(),
+                proc.number_of_locals,
+            ));
+            for op in &proc.ops {
+                buf.append(&mut self.render_op(op))
+            }
+        }
+        buf
+    }
+
+    pub fn finalize_inner(&self) -> AsmBuilderResult {
+        // take each procedure and serialize it with the format described [here](https://wiki.polygon.technology/docs/miden/user_docs/assembly/code_organization/#procedures)
+        let mut program = self.finalize_procedure_map();
+        // main fn is a call into one of the procedure_map fns
+        program.push(DirectOp::begin());
+        for op in &self.buf {
+            program.append(&mut self.render_op(op))
+        }
+        program.push(DirectOp::end());
+
+        AsmBuilderResult::MidenVM(MidenVMAsmBuilderResult { ops: program })
+    }
+
+    fn empty_span() -> Span {
+        let msg = "unknown source location";
+        Span::new(Arc::from(msg), 0, msg.len(), None).unwrap()
+    }
+
+    fn get_label(&mut self) -> Label {
+        let next_val = self.label_idx;
+        self.label_idx += 1;
+        Label(self.label_idx)
+    }
+
+    /// compiles some value and ensures it is on the top of the stack
+    fn push_value_to_stack(&mut self, value: &Value) -> CompileResult<()> {
+        todo!()
+    }
+
+    /// ref: https://wiki.polygon.technology/docs/miden/user_docs/assembly/flow_control#conditional-execution
+    /// TODO:
+    /// Potentially use conditional dropping if the cost of the branches is less than the cost to execute the if
+    /// op
+
+    fn compile_conditional_branch(
+        &mut self,
+        cond_value: &Value,
+        true_block: &BranchToWithArgs,
+        false_block: &BranchToWithArgs,
+    ) {
+        // compile the condition, make sure it is at the top of the stack
+        // generate the `if.true`
+        // generate the body
+        // generate the `else`
+        // generate the else block
+        self.push_value_to_stack(cond_value);
+        self.compile_branch(true_block);
+        self.compile_branch(true_block);
+        // todo need to figure out how to handle the compile results here
+
+        /*
+        self.buf.push(MidenAsmOp::If {
+            condition,
+            true_branch,
+            else_branch,
+        });
+        */
+        todo!()
+    }
+
+    fn compile_branch(&mut self, to_block: &BranchToWithArgs) {
+        todo!()
+        // self.compile_branch_to_phi_value(to_block);
+
+        // let label = self.block_to_label(&to_block.block);
+        // self.cur_bytecode.push(Op::jump_to_label(label));
+    }
+    pub(super) fn compile_call(&mut self, instr_val: &Value, function: &Function, args: &[Value]) {
+        // Assume the arguments have been compiled
+        // We standardize on the arguments being the top N values in the stack
+        // This compilation task simply has to run the procedure
+
+        // The `args` are already on the top of the stack, in the correct order. Load them into local memory
+        // let mut arg_mapping = Vec::new();
+
+        todo!(
+            "Unable to compile fn call {}, need to design function calls.",
+            function.get_name(self.context)
+        )
+    }
+    pub(super) fn compile_instruction(&mut self, instr_val: &Value) {
+        if let Some(instruction) = instr_val.get_instruction(self.context) {
+            match instruction {
+                Instruction::AddrOf(arg) => todo!(),
+                Instruction::AsmBlock(asm, args) => todo!(),
+                Instruction::BitCast(val, ty) => todo!(),
+                Instruction::BinaryOp { op, arg1, arg2 } => {
+                    todo!()
+                }
+                Instruction::Branch(to_block) => todo!(),
+                Instruction::Call(func, args) => self.compile_call(instr_val, func, args),
+                Instruction::CastPtr(val, ty, offs) => {
+                    todo!()
+                }
+                Instruction::Cmp(pred, lhs_value, rhs_value) => {
+                    todo!()
+                }
+                Instruction::ConditionalBranch {
+                    cond_value,
+                    true_block,
+                    false_block,
+                } => self.compile_conditional_branch(cond_value, true_block, false_block),
+                Instruction::ContractCall {
+                    params,
+                    coins,
+                    asset_id,
+                    gas,
+                    ..
+                } => todo!(),
+                Instruction::ExtractElement {
+                    array,
+                    ty,
+                    index_val,
+                } => todo!(),
+                Instruction::ExtractValue {
+                    aggregate, indices, ..
+                } => todo!(),
+                Instruction::FuelVm(fuel_vm_instr) => todo!(),
+                Instruction::GetLocal(local_var) => todo!(),
+                Instruction::InsertElement {
+                    array,
+                    ty,
+                    value,
+                    index_val,
+                } => todo!(),
+                Instruction::InsertValue {
+                    aggregate,
+                    value,
+                    indices,
+                    ..
+                } => todo!(),
+                Instruction::IntToPtr(val, _) => todo!(),
+                Instruction::Load(src_val) => todo!(),
+                Instruction::MemCopy {
+                    dst_val,
+                    src_val,
+                    byte_len,
+                } => todo!(),
+                Instruction::Nop => (),
+                Instruction::Ret(ret_val, ty) => self.compile_return(ret_val, ty),
+                Instruction::Store {
+                    dst_val,
+                    stored_val,
+                } => todo!(),
+            }
+        } else {
+            panic!(
+                "{:?}",
+                CompileError::Internal(
+                    "Value not an instruction.",
+                    self.md_mgr
+                        .val_to_span(self.context, *instr_val)
+                        .unwrap_or_else(Self::empty_span),
+                )
+            )
+        }
+    }
+
+    fn compile_asm_block(
+        &mut self,
+        instr_val: &Value,
+        asm: &AsmBlock,
+        asm_args: &[AsmArg],
+    ) -> CompileResult<()> {
+        todo!();
+    }
+
+    fn compile_addr_of(&mut self, instr_val: &Value, arg: &Value) {
+        todo!();
+    }
+
+    fn compile_bitcast(&mut self, instr_val: &Value, bitcast_val: &Value, to_type: &Type) {
+        todo!();
+    }
+
+    fn compile_binary_op(
+        &mut self,
+        instr_val: &Value,
+        op: &BinaryOpKind,
+        arg1: &Value,
+        arg2: &Value,
+    ) {
+        todo!();
+    }
+
+    fn compile_cast_ptr(&mut self, instr_val: &Value, val: &Value, ty: &Type, offs: u64) {
+        todo!();
+    }
+
+    fn compile_cmp(
+        &mut self,
+        instr_val: &Value,
+        pred: &Predicate,
+        lhs_value: &Value,
+        rhs_value: &Value,
+    ) {
+        todo!();
+    }
+
+    fn compile_branch_to_phi_value(&mut self, to_block: &BranchToWithArgs) {
+        todo!();
+    }
+
+    #[allow(clippy::too_many_arguments)]
+    fn compile_contract_call(
+        &mut self,
+        instr_val: &Value,
+        params: &Value,
+        coins: &Value,
+        asset_id: &Value,
+        gas: &Value,
+    ) {
+        todo!();
+    }
+
+    fn compile_extract_element(
+        &mut self,
+        instr_val: &Value,
+        array: &Value,
+        ty: &Type,
+        index_val: &Value,
+    ) {
+        todo!();
+    }
+
+    fn compile_extract_value(&mut self, instr_val: &Value, aggregate_val: &Value, indices: &[u64]) {
+        todo!();
+    }
+
+    fn compile_get_storage_key(&mut self, instr_val: &Value) -> CompileResult<()> {
+        todo!();
+    }
+
+    fn compile_get_local(&mut self, instr_val: &Value, local_var: &LocalVar) {
+        todo!();
+    }
+
+    fn compile_gtf(&mut self, instr_val: &Value, index: &Value, tx_field_id: u64) {
+        todo!();
+    }
+
+    fn compile_insert_element(
+        &mut self,
+        instr_val: &Value,
+        array: &Value,
+        ty: &Type,
+        value: &Value,
+        index_val: &Value,
+    ) {
+        todo!();
+    }
+
+    fn compile_insert_value(
+        &mut self,
+        instr_val: &Value,
+        aggregate_val: &Value,
+        value: &Value,
+        indices: &[u64],
+    ) {
+        todo!();
+    }
+
+    fn compile_int_to_ptr(&mut self, instr_val: &Value, int_to_ptr_val: &Value) {
+        todo!();
+    }
+
+    fn compile_load(&mut self, instr_val: &Value, src_val: &Value) -> CompileResult<()> {
+        todo!();
+    }
+
+    fn compile_mem_copy(
+        &mut self,
+        instr_val: &Value,
+        dst_val: &Value,
+        src_val: &Value,
+        byte_len: u64,
+    ) {
+        todo!();
+    }
+
+    fn compile_log(&mut self, instr_val: &Value, log_val: &Value, log_ty: &Type, log_id: &Value) {
+        todo!();
+    }
+
+    fn compile_read_register(&mut self, instr_val: &Value, reg: &sway_ir::Register) {
+        todo!();
+    }
+
+    fn compile_ret_from_entry(&mut self, instr_val: &Value, ret_val: &Value, ret_type: &Type) {
+        todo!();
+    }
+
+    fn compile_revert(&mut self, instr_val: &Value, revert_val: &Value) {
+        todo!();
+    }
+
+    fn compile_smo(
+        &mut self,
+        instr_val: &Value,
+        recipient_and_message: &Value,
+        message_size: &Value,
+        output_index: &Value,
+        coins: &Value,
+    ) {
+        todo!();
+    }
+
+    fn compile_state_access_quad_word(
+        &mut self,
+        instr_val: &Value,
+        val: &Value,
+        key: &Value,
+        number_of_slots: &Value,
+        access_type: StateAccessType,
+    ) -> CompileResult<()> {
+        todo!();
+    }
+
+    fn compile_state_load_word(&mut self, instr_val: &Value, key: &Value) -> CompileResult<()> {
+        todo!();
+    }
+
+    fn compile_state_store_word(
+        &mut self,
+        instr_val: &Value,
+        store_val: &Value,
+        key: &Value,
+    ) -> CompileResult<()> {
+        todo!();
+    }
+
+    fn compile_store(
+        &mut self,
+        instr_val: &Value,
+        dst_val: &Value,
+        stored_val: &Value,
+    ) -> CompileResult<()> {
+        todo!();
+    }
+
+    pub fn compile_function(&mut self, function: Function) -> CompileResult<()> {
+        if function.get_name(self.context).to_lowercase() != "main" {
+            self.set_active_procedure(&function);
+        }
+        self.compile_code_block(function.block_iter(self.context));
+        self.end_active_procedure();
+        ok((), vec![], vec![])
+    }
+
+    fn compile_code_block(&mut self, block: BlockIterator) {
+        for block in block {
+            for instr_val in block.instruction_iter(self.context) {
+                self.compile_instruction(&instr_val);
+            }
+        }
+    }
+
+    pub(super) fn compile_ret_from_call(&mut self, instr_val: &Value, ret_val: &Value) {
+        todo!();
+    }
+
+    /// Compiles a return instruction.
+    /// https://0xpolygonmiden.github.io/miden-vm/design/stack/main.html#operand-stack
+    /// By the end of program execution, exactly 16 items must remain on the stack (again,
+    ///  all of them could be 0's). These items comprise the output of the program.
+
+    /// all we have to do here is make sure the returned value is on top of the stack
+    /// this works in both internal procedure returns and external main returns
+    pub fn compile_return(&mut self, ret_val: &Value, ty: &Type) {
+        self.compile_value_access(ret_val)
+    }
+
+    fn compile_value_access(&mut self, ret_val: &Value) {
+        self.push_op(MidenAsmOp::access_value(*ret_val));
+    }
+
+    fn push_op(&mut self, op: MidenAsmOp) {
+        if let Some(ref proc_name) = self.active_procedure {
+            let res = self.procedure_map.get_mut(proc_name);
+            if let Some(res) = res {
+                res.ops.push(op);
+            } else {
+                unreachable!("It is an invariant that a proc name would be in the mapping already. This is an internal compiler error.")
+            }
+        } else {
+            self.buf.push(op);
+        }
+    }
+
+    fn set_active_procedure(&mut self, function: &Function) {
+        self.procedure_map.insert(
+            function.get_name(self.context).into(),
+            Procedure {
+                number_of_locals: function.num_args(self.context) as u32,
+                ops: Default::default(),
+            },
+        );
+    }
+
+    fn end_active_procedure(&mut self) {
+        self.active_procedure = None;
+    }
+
+    fn render_abstract_op(&self, op: &miden_op::AbstractOp) -> Vec<DirectOp> {
+        use miden_op::AbstractOp::*;
+        match op {
+            AccessValue(val) => {
+                // TODO: configurables, instructions, etc
+                //        todo!("check chained or-else stuff in fuel asm builder")
+                let rendered = val
+                    .get_constant(self.context)
+                    .map(|constant| self.render_constant(constant))
+                    .or_else(|| val.get_configurable(self.context).map(|config| todo!()))
+                    .or_else(|| todo!());
+                if let Some(rendered) = rendered {
+                    rendered
+                } else {
+                    panic!("Not sure what this value is -- is'nt a constant or a configurable. {val:?}")
+                }
+            }
+        }
+    }
+
+    fn render_op(&self, op: &MidenAsmOp) -> Vec<DirectOp> {
+        match op {
+            MidenAsmOp::DirectOp(a) => vec![a.clone()],
+            MidenAsmOp::AbstractOp(op) => self.render_abstract_op(op),
+        }
+    }
+
+    /// Pushes a constant to the top of the stack
+    pub(crate) fn render_constant(&self, constant: &Constant) -> Vec<DirectOp> {
+        use sway_ir::ConstantValue::*;
+        match constant.value {
+            Undef => todo!(),
+            Unit => vec![DirectOp::push(MidenStackValue::Unit)],
+            Bool(b) => vec![DirectOp::push(b)],
+            Uint(x) => vec![DirectOp::push(x)],
+            B256(_) => todo!(),
+            String(_) => todo!(),
+            Array(_) => todo!(),
+            Struct(_) => todo!(),
+        }
+    }
+}
+
+pub trait ToMidenBytecode {
+    // the midenVM expects assembly in String form
+    fn to_bytecode(&self) -> String;
+}
+
+impl ToMidenBytecode for Vec<DirectOp> {
+    fn to_bytecode(&self) -> String {
+        // TODO nice indentation and stuff
+        self.iter()
+            .map(|x| format!("{x}"))
+            .collect::<Vec<_>>()
+            .join("\n")
+    }
+}
diff --git a/sway-core/src/asm_generation/miden_vm/miden_vm_asm_builder/miden_op.rs b/sway-core/src/asm_generation/miden_vm/miden_vm_asm_builder/miden_op.rs
new file mode 100644
index 00000000000..870094cfaa1
--- /dev/null
+++ b/sway-core/src/asm_generation/miden_vm/miden_vm_asm_builder/miden_op.rs
@@ -0,0 +1,394 @@
+use std::fmt::Display;
+
+#[derive(Clone, PartialEq, Eq, Debug)]
+pub enum AbstractOp {
+    // corresponds to "Ensure this value is on top of the stack"
+    AccessValue(sway_ir::Value),
+}
+
+#[derive(Clone, PartialEq, Eq, Debug)]
+pub enum DirectOp {
+    Exec(super::ProcedureName),
+
+    ProcedureDecl {
+        name: super::ProcedureName,
+        number_of_locals: u32,
+    },
+    Begin,
+    End,
+    If {
+        condition: Vec<MidenAsmOp>,
+        true_branch: Vec<MidenAsmOp>,
+        else_branch: Vec<MidenAsmOp>,
+    },
+    Push(MidenStackValue),
+}
+
+#[derive(Clone, PartialEq, Eq, Debug)]
+pub enum MidenStackValue {
+    Unit,
+    Number(u64),
+    Bool(bool),
+}
+
+impl Display for MidenStackValue {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(
+            f,
+            "{}",
+            match self {
+                MidenStackValue::Unit => "0".into(),
+                MidenStackValue::Number(x) => x.to_string(),
+                MidenStackValue::Bool(b) => if *b { "1" } else { "0" }.into(),
+            },
+        )
+    }
+}
+impl From<bool> for MidenStackValue {
+    fn from(value: bool) -> Self {
+        MidenStackValue::Bool(value)
+    }
+}
+
+impl From<u64> for MidenStackValue {
+    fn from(value: u64) -> Self {
+        MidenStackValue::Number(value)
+    }
+}
+
+#[derive(Clone, PartialEq, Eq, Debug)]
+pub enum MidenAsmOp {
+    DirectOp(DirectOp),
+    /// This is an abstract Op. Meaning, this doesn't correspond to an
+    /// individual MidenVM asm op.     
+    AbstractOp(AbstractOp),
+    /*
+    Assert,
+    AssertEq,
+    Assertz,
+    Add,
+    AddImm(Felt),
+    Sub,
+    SubImm(Felt),
+    Mul,
+    MulImm(Felt),
+    Div,
+    DivImm(Felt),
+    Neg,
+    Inv,
+    Pow2,
+    Exp,
+    ExpImm(Felt),
+    ExpBitLength(u8),
+    Not,
+    And,
+    Or,
+    Xor,
+    Eq,
+    EqImm(Felt),
+    Neq,
+    NeqImm(Felt),
+    Eqw,
+    Lt,
+    Lte,
+    Gt,
+    Gte,
+
+    // ----- u32 manipulation ---------------------------------------------------------------
+    U32Test,
+    U32TestW,
+    U32Assert,
+    U32Assert2,
+    U32AssertW,
+    U32Split,
+    U32Cast,
+    U32CheckedAdd,
+    U32CheckedAddImm(u32),
+    U32WrappingAdd,
+    U32WrappingAddImm(u32),
+    U32OverflowingAdd,
+    U32OverflowingAddImm(u32),
+    U32OverflowingAdd3,
+    U32WrappingAdd3,
+    U32CheckedSub,
+    U32CheckedSubImm(u32),
+    U32WrappingSub,
+    U32WrappingSubImm(u32),
+    U32OverflowingSub,
+    U32OverflowingSubImm(u32),
+    U32CheckedMul,
+    U32CheckedMulImm(u32),
+    U32WrappingMul,
+    U32WrappingMulImm(u32),
+    U32OverflowingMul,
+    U32OverflowingMulImm(u32),
+    U32OverflowingMadd,
+    U32WrappingMadd,
+    U32CheckedDiv,
+    U32CheckedDivImm(u32),
+    U32UncheckedDiv,
+    U32UncheckedDivImm(u32),
+    U32CheckedMod,
+    U32CheckedModImm(u32),
+    U32UncheckedMod,
+    U32UncheckedModImm(u32),
+    U32CheckedDivMod,
+    U32CheckedDivModImm(u32),
+    U32UncheckedDivMod,
+    U32UncheckedDivModImm(u32),
+    U32CheckedAnd,
+    U32CheckedOr,
+    U32CheckedXor,
+    U32CheckedNot,
+    U32CheckedShr,
+    U32CheckedShrImm(u8),
+    U32UncheckedShr,
+    U32UncheckedShrImm(u8),
+    U32CheckedShl,
+    U32CheckedShlImm(u8),
+    U32UncheckedShl,
+    U32UncheckedShlImm(u8),
+    U32CheckedRotr,
+    U32CheckedRotrImm(u8),
+    U32UncheckedRotr,
+    U32UncheckedRotrImm(u8),
+    U32CheckedRotl,
+    U32CheckedRotlImm(u8),
+    U32UncheckedRotl,
+    U32UncheckedRotlImm(u8),
+    U32CheckedEq,
+    U32CheckedEqImm(u32),
+    U32CheckedNeq,
+    U32CheckedNeqImm(u32),
+    U32CheckedLt,
+    U32UncheckedLt,
+    U32CheckedLte,
+    U32UncheckedLte,
+    U32CheckedGt,
+    U32UncheckedGt,
+    U32CheckedGte,
+    U32UncheckedGte,
+    U32CheckedMin,
+    U32UncheckedMin,
+    U32CheckedMax,
+    U32UncheckedMax,
+
+    // ----- stack manipulation ---------------------------------------------------------------
+    Drop,
+    DropW,
+    PadW,
+    Dup0,
+    Dup1,
+    Dup2,
+    Dup3,
+    Dup4,
+    Dup5,
+    Dup6,
+    Dup7,
+    Dup8,
+    Dup9,
+    Dup10,
+    Dup11,
+    Dup12,
+    Dup13,
+    Dup14,
+    Dup15,
+    DupW0,
+    DupW1,
+    DupW2,
+    DupW3,
+    Swap1,
+    Swap2,
+    Swap3,
+    Swap4,
+    Swap5,
+    Swap6,
+    Swap7,
+    Swap8,
+    Swap9,
+    Swap10,
+    Swap11,
+    Swap12,
+    Swap13,
+    Swap14,
+    Swap15,
+    SwapW1,
+    SwapW2,
+    SwapW3,
+    SwapDw,
+    MovUp2,
+    MovUp3,
+    MovUp4,
+    MovUp5,
+    MovUp6,
+    MovUp7,
+    MovUp8,
+    MovUp9,
+    MovUp10,
+    MovUp11,
+    MovUp12,
+    MovUp13,
+    MovUp14,
+    MovUp15,
+    MovUpW2,
+    MovUpW3,
+    MovDn2,
+    MovDn3,
+    MovDn4,
+    MovDn5,
+    MovDn6,
+    MovDn7,
+    MovDn8,
+    MovDn9,
+    MovDn10,
+    MovDn11,
+    MovDn12,
+    MovDn13,
+    MovDn14,
+    MovDn15,
+    MovDnW2,
+    MovDnW3,
+    CSwap,
+    CSwapW,
+    CDrop,
+    CDropW,
+
+    // ----- input / output operations --------------------------------------------------------
+    PushConstants(Vec<Felt>),
+    Locaddr(u16),
+    Sdepth,
+    Caller,
+
+    MemLoad,
+    MemLoadImm(u32),
+    MemLoadW,
+    MemLoadWImm(u32),
+    LocLoad(u16),
+    LocLoadW(u16),
+
+    MemStore,
+    MemStoreImm(u32),
+    LocStore(u16),
+    MemStoreW,
+    MemStoreWImm(u32),
+    LocStoreW(u16),
+
+    MemStream,
+    AdvPipe,
+
+    AdvPush(u8),
+    AdvLoadW,
+
+    AdvU64Div,
+    AdvKeyval,
+    AdvMem(u32, u32),
+
+    // ----- cryptographic operations ---------------------------------------------------------
+    RpHash,
+    RpPerm,
+    MTreeGet,
+    MTreeSet,
+    MTreeCwm,
+
+    // ----- exec / call ----------------------------------------------------------------------
+    ExecLocal(u16),
+    ExecImported(ProcedureId),
+    CallLocal(u16),
+    CallImported(ProcedureId),
+    SysCall(ProcedureId),
+    */
+}
+
+impl DirectOp {
+    pub(crate) fn begin() -> DirectOp {
+        DirectOp::Begin
+    }
+
+    pub(crate) fn end() -> DirectOp {
+        DirectOp::End
+    }
+    pub(crate) fn procedure_decl(name: String, number_of_locals: u32) -> DirectOp {
+        DirectOp::ProcedureDecl {
+            name,
+            number_of_locals,
+        }
+    }
+}
+impl<T> Push<T> for DirectOp
+where
+    T: Into<MidenStackValue>,
+{
+    fn push(val: T) -> Self {
+        let num = val.into();
+        DirectOp::Push(num)
+    }
+}
+
+pub trait Push<T> {
+    fn push(val: T) -> Self;
+}
+
+impl MidenAsmOp {
+    pub(crate) fn access_value(value: sway_ir::Value) -> MidenAsmOp {
+        MidenAsmOp::AbstractOp(AbstractOp::AccessValue(value))
+    }
+
+    pub(crate) fn procedure_decl(name: String, number_of_locals: u32) -> MidenAsmOp {
+        MidenAsmOp::DirectOp(DirectOp::procedure_decl(name, number_of_locals))
+    }
+}
+
+impl Display for DirectOp {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        use DirectOp::*;
+        f.write_str(&match self {
+            Begin => "begin".into(),
+            End => "end".into(),
+            Exec(name) => format!("exec.{name}"),
+            If {
+                condition: _,
+                true_branch,
+                else_branch,
+            } => format!(
+                "if.true\n{}{}",
+                indented(true_branch),
+                if else_branch.is_empty() {
+                    "".into()
+                } else {
+                    format!("else\n{}\nend", indented(else_branch))
+                }
+            ),
+
+            ProcedureDecl {
+                name,
+                number_of_locals,
+            } => format!("proc.{name}.{number_of_locals}"),
+            Push(val) => format!("push.{val}"),
+        })
+    }
+}
+
+impl Display for AbstractOp {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        use AbstractOp::*;
+        f.write_str(&match self {
+            AccessValue(ref v) => format!("~access {v:?}"),
+        })
+    }
+}
+impl Display for MidenAsmOp {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        use MidenAsmOp::*;
+        let text = match self {
+            DirectOp(op) => format!("{op}"),
+            AbstractOp(op) => format!("{op}"),
+        };
+        f.write_str(&text)
+    }
+}
+
+/// indents some ops by 1 tab
+fn indented(raw: &[MidenAsmOp]) -> String {
+    let ops = raw.iter().map(|x| x.to_string()).collect::<Vec<_>>();
+    ops.join("\n\t")
+}
diff --git a/sway-core/src/asm_generation/mod.rs b/sway-core/src/asm_generation/mod.rs
index 7e7dcb5382c..401e7ce7605 100644
--- a/sway-core/src/asm_generation/mod.rs
+++ b/sway-core/src/asm_generation/mod.rs
@@ -3,6 +3,8 @@ pub use abi::*;
 pub mod asm_builder;
 pub mod evm;
 pub use evm::*;
+mod miden_vm;
+pub use miden_vm::*;
 pub mod from_ir;
 pub mod fuel;
 mod instruction_set;
diff --git a/sway-core/src/asm_generation/programs.rs b/sway-core/src/asm_generation/programs.rs
index 0084e2f0beb..e4c8ec4e97f 100644
--- a/sway-core/src/asm_generation/programs.rs
+++ b/sway-core/src/asm_generation/programs.rs
@@ -69,4 +69,7 @@ pub(super) enum FinalProgram {
         ops: Vec<etk_asm::ops::AbstractOp>,
         abi: Vec<ethabi::operation::Operation>,
     },
+    MidenVM {
+        ops: Vec<crate::asm_generation::DirectOp>,
+    },
 }
diff --git a/sway-core/src/asm_generation/programs/final.rs b/sway-core/src/asm_generation/programs/final.rs
index 9e8a670aa9f..68483de1622 100644
--- a/sway-core/src/asm_generation/programs/final.rs
+++ b/sway-core/src/asm_generation/programs/final.rs
@@ -39,6 +39,16 @@ impl FinalProgram {
                 entries: vec![],
                 abi: Some(ProgramABI::Evm(abi)),
             },
+            FinalProgram::MidenVM { ops } => FinalizedAsm {
+                data_section: DataSection {
+                    ..Default::default()
+                },
+                program_section: InstructionSet::MidenVM { ops },
+                // should this be a script? :think:
+                program_kind: super::ProgramKind::Script,
+                entries: vec![],
+                abi: None, /* TODO? */
+            },
         }
     }
 }
@@ -80,6 +90,7 @@ impl std::fmt::Display for FinalProgram {
 
                 Ok(())
             }
+            FinalProgram::MidenVM { ops } => write!(f, "{ops:?}"),
         }
     }
 }
diff --git a/sway-core/src/build_config.rs b/sway-core/src/build_config.rs
index 5e80915b121..5bb1ee08404 100644
--- a/sway-core/src/build_config.rs
+++ b/sway-core/src/build_config.rs
@@ -9,6 +9,7 @@ pub enum BuildTarget {
     #[default]
     Fuel,
     EVM,
+    MidenVM,
 }
 
 /// Configuration for the overall build and compilation process.
diff --git a/test/Cargo.toml b/test/Cargo.toml
index 89f2f22b326..5d903acc62c 100644
--- a/test/Cargo.toml
+++ b/test/Cargo.toml
@@ -21,6 +21,7 @@ fuel-vm = { workspace = true, features = ["random"] }
 futures = "0.3.24"
 gag = "1.0"
 hex = "0.4.3"
+miden = "0.3.0"
 prettydiff = "0.6"
 rand = "0.8"
 regex = "1.7"
diff --git a/test/src/e2e_vm_tests/harness.rs b/test/src/e2e_vm_tests/harness.rs
index 3ea7e7812f6..12626197911 100644
--- a/test/src/e2e_vm_tests/harness.rs
+++ b/test/src/e2e_vm_tests/harness.rs
@@ -127,6 +127,7 @@ pub(crate) async fn runs_on_node(
 pub(crate) enum VMExecutionResult {
     Fuel(ProgramState, Vec<Receipt>),
     Evm(revm::ExecutionResult),
+    MidenVM(miden::ExecutionTrace),
 }
 
 /// Very basic check that code does indeed run in the VM.
@@ -189,6 +190,25 @@ pub(crate) fn runs_in_vm(
                 }
             }
         }
+        BuildTarget::MidenVM => {
+            use miden::{Assembler, ProgramInputs};
+
+            // instantiate the assembler
+            let assembler = Assembler::default();
+
+            let bytecode_str = std::str::from_utf8(&script.bytecode)?;
+
+            // compile Miden assembly source code into a program
+            let program = assembler.compile(bytecode_str).unwrap();
+
+            // execute the program with no inputs
+            let _trace = miden::execute(&program, &ProgramInputs::none()).unwrap();
+
+            let execution_trace = miden::execute(&program, &ProgramInputs::none())
+                .map_err(|e| anyhow::anyhow!("Failed to execute on MidenVM: {e:?}"))?;
+
+            Ok(VMExecutionResult::MidenVM(execution_trace))
+        }
     }
 }
 
@@ -201,7 +221,7 @@ pub(crate) async fn compile_to_bytes(file_name: &str, run_config: &RunConfig) ->
         build_target: run_config.build_target,
         pkg: forc_pkg::PkgOpts {
             path: Some(format!(
-                "{manifest_dir}/src/e2e_vm_tests/test_programs/{file_name}"
+                "{manifest_dir}/src/e2e_vm_tests/test_programs/{file_name}",
             )),
             locked: run_config.locked,
             terse: false,
@@ -289,6 +309,7 @@ fn emit_json_abi(file_name: &str, built_package: &BuiltPackage) -> Result<()> {
     let json_abi = match &built_package.json_abi_program {
         ProgramABI::Fuel(abi) => serde_json::json!(abi),
         ProgramABI::Evm(abi) => serde_json::json!(abi),
+        ProgramABI::MidenVM(_) => todo!(),
     };
     let manifest_dir = env!("CARGO_MANIFEST_DIR");
     let file = std::fs::File::create(format!(
diff --git a/test/src/e2e_vm_tests/mod.rs b/test/src/e2e_vm_tests/mod.rs
index b973adf7e66..cd9bb386b60 100644
--- a/test/src/e2e_vm_tests/mod.rs
+++ b/test/src/e2e_vm_tests/mod.rs
@@ -158,6 +158,13 @@ impl TestContext {
                             panic!("EVM exited with unhandled reason: {:?}", state.exit_reason);
                         }
                     },
+                    harness::VMExecutionResult::MidenVM(trace) => {
+                        let outputs = trace.program_outputs();
+                        let stack = outputs.stack();
+                        // for now, just test primitive u64s.
+                        // Later on, we can test stacks that have more elements in them.
+                        TestResult::Return(stack[0])
+                    }
                 };
 
                 if result != res {
@@ -677,6 +684,7 @@ fn get_test_abi_from_value(value: &toml::Value) -> Result<BuildTarget> {
         Some(target) => match target {
             "fuel" => Ok(BuildTarget::Fuel),
             "evm" => Ok(BuildTarget::EVM),
+            "miden-vm" | "midenvm" => Ok(BuildTarget::MidenVM),
             _ => Err(anyhow!(format!("Unknown build target: {target}"))),
         },
         None => Err(anyhow!("Invalid TOML value")),
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/midenvm/midenvm_trivial/Forc.lock b/test/src/e2e_vm_tests/test_programs/should_pass/midenvm/midenvm_trivial/Forc.lock
new file mode 100644
index 00000000000..7ff747315c0
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/midenvm/midenvm_trivial/Forc.lock
@@ -0,0 +1,3 @@
+[[package]]
+name = 'midenvm-trivial'
+source = 'member'
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/midenvm/midenvm_trivial/Forc.toml b/test/src/e2e_vm_tests/test_programs/should_pass/midenvm/midenvm_trivial/Forc.toml
new file mode 100644
index 00000000000..a09dc0181bc
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/midenvm/midenvm_trivial/Forc.toml
@@ -0,0 +1,8 @@
+[project]
+authors = ["Fuel Labs <contact@fuel.sh>"]
+license = "Apache-2.0"
+name = "midenvm-trivial"
+entry = "main.sw"
+implicit-std = false
+target = "miden-vm"
+
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/midenvm/midenvm_trivial/src/main.sw b/test/src/e2e_vm_tests/test_programs/should_pass/midenvm/midenvm_trivial/src/main.sw
new file mode 100644
index 00000000000..294bca5abeb
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/midenvm/midenvm_trivial/src/main.sw
@@ -0,0 +1,3 @@
+script;
+
+fn main() -> u64 { 42 }
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/midenvm/midenvm_trivial/test.toml b/test/src/e2e_vm_tests/test_programs/should_pass/midenvm/midenvm_trivial/test.toml
new file mode 100644
index 00000000000..185e2e2fae5
--- /dev/null
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/midenvm/midenvm_trivial/test.toml
@@ -0,0 +1,3 @@
+category = "run"
+expected_result = { action = "return", value = 42 }
+supported_targets = ["miden-vm"]
diff --git a/test/src/main.rs b/test/src/main.rs
index 7646093973a..75d278feaa6 100644
--- a/test/src/main.rs
+++ b/test/src/main.rs
@@ -81,6 +81,7 @@ async fn main() -> Result<()> {
         Some(target) => match target.to_lowercase().as_str() {
             "fuel" => BuildTarget::Fuel,
             "evm" => BuildTarget::EVM,
+            "miden" | "midenvm" => BuildTarget::MidenVM,
             _ => panic!("unexpected build target"),
         },
         None => BuildTarget::default(),