diff --git a/sway-core/src/asm_generation/asm_builder.rs b/sway-core/src/asm_generation/asm_builder.rs
index e1e9324de87..bae2de432ea 100644
--- a/sway-core/src/asm_generation/asm_builder.rs
+++ b/sway-core/src/asm_generation/asm_builder.rs
@@ -1,25 +1,20 @@
+use super::FinalizedAsm;
+use crate::{asm_lang::Label, BuildConfig};
 use sway_error::handler::{ErrorEmitted, Handler};
-use sway_ir::Function;
-
-use crate::asm_lang::Label;
-
-use super::{
-    evm::EvmAsmBuilderResult, fuel::fuel_asm_builder::FuelAsmBuilderResult,
-    miden_vm::MidenVMAsmBuilderResult,
-};
-
-pub enum AsmBuilderResult {
-    Fuel(FuelAsmBuilderResult),
-    Evm(EvmAsmBuilderResult),
-    MidenVM(MidenVMAsmBuilderResult),
-}
+use sway_ir::{ConfigurableContent, Function};
 
 pub trait AsmBuilder {
     fn func_to_labels(&mut self, func: &Function) -> (Label, Label);
+    fn compile_configurable(&mut self, config: &ConfigurableContent);
     fn compile_function(
         &mut self,
         handler: &Handler,
         function: Function,
     ) -> Result<(), ErrorEmitted>;
-    fn finalize(&self) -> AsmBuilderResult;
+    fn finalize(
+        self,
+        handler: &Handler,
+        build_config: Option<&BuildConfig>,
+        fallback_fn: Option<Label>,
+    ) -> Result<FinalizedAsm, ErrorEmitted>;
 }
diff --git a/sway-core/src/asm_generation/evm/evm_asm_builder.rs b/sway-core/src/asm_generation/evm/evm_asm_builder.rs
index 9a67c081cc7..65ca0a303f3 100644
--- a/sway-core/src/asm_generation/evm/evm_asm_builder.rs
+++ b/sway-core/src/asm_generation/evm/evm_asm_builder.rs
@@ -2,9 +2,8 @@ use std::{collections::HashMap, sync::Arc};
 
 use crate::{
     asm_generation::{
-        asm_builder::{AsmBuilder, AsmBuilderResult},
-        from_ir::StateAccessType,
-        ProgramKind,
+        asm_builder::AsmBuilder, from_ir::StateAccessType, fuel::data_section::DataSection,
+        instruction_set::InstructionSet, FinalizedAsm, ProgramABI, ProgramKind,
     },
     asm_lang::Label,
     metadata::MetadataManager,
@@ -108,28 +107,16 @@ impl<'ir, 'eng> AsmBuilder for EvmAsmBuilder<'ir, 'eng> {
         self.compile_function(handler, function)
     }
 
-    fn finalize(&self) -> AsmBuilderResult {
-        self.finalize()
-    }
-}
-
-#[allow(unused_variables)]
-#[allow(dead_code)]
-impl<'ir, 'eng> EvmAsmBuilder<'ir, 'eng> {
-    pub fn new(program_kind: ProgramKind, context: &'ir Context<'eng>) -> Self {
-        Self {
-            program_kind,
-            sections: Vec::new(),
-            func_label_map: HashMap::new(),
-            block_label_map: HashMap::new(),
-            context,
-            md_mgr: MetadataManager::default(),
-            label_idx: 0,
-            cur_section: None,
-        }
+    fn compile_configurable(&mut self, _config: &ConfigurableContent) {
+        todo!()
     }
 
-    pub fn finalize(&self) -> AsmBuilderResult {
+    fn finalize(
+        self,
+        _handler: &Handler,
+        _build_config: Option<&crate::BuildConfig>,
+        _fallback_fn: Option<Label>,
+    ) -> Result<FinalizedAsm, ErrorEmitted> {
         let mut global_ops = Vec::new();
         let mut global_abi = Vec::new();
 
@@ -156,11 +143,29 @@ impl<'ir, 'eng> EvmAsmBuilder<'ir, 'eng> {
         ctor.ops.append(&mut global_ops);
         global_abi.append(&mut ctor.abi);
 
-        AsmBuilderResult::Evm(EvmAsmBuilderResult {
+        let final_program = EvmFinalProgram {
             ops: ctor.ops.clone(),
-            ops_runtime: ctor.ops,
             abi: global_abi,
-        })
+        };
+
+        Ok(final_program.finalize())
+    }
+}
+
+#[allow(unused_variables)]
+#[allow(dead_code)]
+impl<'ir, 'eng> EvmAsmBuilder<'ir, 'eng> {
+    pub fn new(program_kind: ProgramKind, context: &'ir Context<'eng>) -> Self {
+        Self {
+            program_kind,
+            sections: Vec::new(),
+            func_label_map: HashMap::new(),
+            block_label_map: HashMap::new(),
+            context,
+            md_mgr: MetadataManager::default(),
+            label_idx: 0,
+            cur_section: None,
+        }
     }
 
     fn generate_constructor(
@@ -340,6 +345,7 @@ impl<'ir, 'eng> EvmAsmBuilder<'ir, 'eng> {
                     indices,
                 } => self.compile_get_elem_ptr(instr_val, base, elem_ptr_ty, indices),
                 InstOp::GetLocal(local_var) => self.compile_get_local(instr_val, local_var),
+                InstOp::GetConfig(_, name) => self.compile_get_config(instr_val, name),
                 InstOp::IntToPtr(val, _) => self.compile_int_to_ptr(instr_val, val),
                 InstOp::Load(src_val) => self.compile_load(handler, instr_val, src_val)?,
                 InstOp::MemCopyBytes {
@@ -472,6 +478,10 @@ impl<'ir, 'eng> EvmAsmBuilder<'ir, 'eng> {
         todo!();
     }
 
+    fn compile_get_config(&mut self, instr_val: &Value, name: &str) {
+        todo!();
+    }
+
     fn compile_gtf(&mut self, instr_val: &Value, index: &Value, tx_field_id: u64) {
         todo!();
     }
@@ -708,3 +718,22 @@ impl<'ir, 'eng> EvmAsmBuilder<'ir, 'eng> {
         })
     }
 }
+
+struct EvmFinalProgram {
+    ops: Vec<etk_asm::ops::AbstractOp>,
+    abi: Vec<ethabi::operation::Operation>,
+}
+
+impl EvmFinalProgram {
+    fn finalize(self) -> FinalizedAsm {
+        FinalizedAsm {
+            data_section: DataSection {
+                ..Default::default()
+            },
+            program_section: InstructionSet::Evm { ops: self.ops },
+            program_kind: ProgramKind::Script,
+            entries: vec![],
+            abi: Some(ProgramABI::Evm(self.abi)),
+        }
+    }
+}
diff --git a/sway-core/src/asm_generation/finalized_asm.rs b/sway-core/src/asm_generation/finalized_asm.rs
index 5de93b021c9..c9920271093 100644
--- a/sway-core/src/asm_generation/finalized_asm.rs
+++ b/sway-core/src/asm_generation/finalized_asm.rs
@@ -10,6 +10,7 @@ use crate::source_map::SourceMap;
 use crate::BuildConfig;
 
 use etk_asm::asm::Assembler;
+use fuel_vm::fuel_asm::{Imm06, Imm12, Imm18, Imm24, Instruction, RegId};
 use sway_error::error::CompileError;
 use sway_error::handler::{ErrorEmitted, Handler};
 use sway_types::span::Span;
@@ -164,7 +165,8 @@ fn to_bytecode_mut(
         match fuel_op {
             Either::Right(data) => {
                 if build_config.print_bytecode {
-                    println!("{:?}", data);
+                    print!("{:#010x} ", buf.len());
+                    println!("                                ;; {:?}", data);
                 }
                 // Static assert to ensure that we're only dealing with DataSectionOffsetPlaceholder,
                 // a one-word (8 bytes) data within the code. No other uses are known.
@@ -175,12 +177,20 @@ fn to_bytecode_mut(
             Either::Left(ops) => {
                 for op in ops {
                     if build_config.print_bytecode {
-                        println!("{:?}", op);
+                        print!("{:#010x} ", buf.len());
+                        print_instruction(&op);
                     }
                     if let Some(span) = &span {
                         source_map.insert(source_engine, half_word_ix, span);
                     }
-                    buf.extend(op.to_bytes().iter());
+
+                    let bytes = op.to_bytes();
+
+                    if build_config.print_bytecode {
+                        println!(";; {bytes:?}")
+                    }
+
+                    buf.extend(bytes.iter());
                     half_word_ix += 1;
                 }
             }
@@ -215,6 +225,229 @@ fn to_bytecode_mut(
     }
 }
 
+// Code to pretty print bytecode
+fn print_reg(r: RegId) -> String {
+    if r == RegId::BAL {
+        "$bal".to_string()
+    } else if r == RegId::CGAS {
+        "$cgas".to_string()
+    } else if r == RegId::ERR {
+        "$err".to_string()
+    } else if r == RegId::FLAG {
+        "$flag".to_string()
+    } else if r == RegId::FP {
+        "$fp".to_string()
+    } else if r == RegId::GGAS {
+        "$ggas".to_string()
+    } else if r == RegId::HP {
+        "$hp".to_string()
+    } else if r == RegId::IS {
+        "$is".to_string()
+    } else if r == RegId::OF {
+        "$of".to_string()
+    } else if r == RegId::ONE {
+        "$one".to_string()
+    } else if r == RegId::PC {
+        "$pc".to_string()
+    } else if r == RegId::RET {
+        "$ret".to_string()
+    } else if r == RegId::RETL {
+        "$retl".to_string()
+    } else if r == RegId::SP {
+        "$sp".to_string()
+    } else if r == RegId::SSP {
+        "$ssp".to_string()
+    } else if r == RegId::WRITABLE {
+        "$writable".to_string()
+    } else if r == RegId::ZERO {
+        "$zero".to_string()
+    } else {
+        format!("R{:?}", r.to_u8())
+    }
+}
+
+trait Args {
+    fn print(&self) -> String;
+}
+
+impl Args for RegId {
+    fn print(&self) -> String {
+        print_reg(*self)
+    }
+}
+impl Args for Imm06 {
+    fn print(&self) -> String {
+        format!("{:#x}", self.to_u8())
+    }
+}
+impl Args for Imm12 {
+    fn print(&self) -> String {
+        format!("{:#x}", self.to_u16())
+    }
+}
+impl Args for Imm18 {
+    fn print(&self) -> String {
+        format!("{:#x}", self.to_u32())
+    }
+}
+impl Args for Imm24 {
+    fn print(&self) -> String {
+        format!("{:#x}", self.to_u32())
+    }
+}
+impl Args for () {
+    fn print(&self) -> String {
+        String::new()
+    }
+}
+impl<A: Args> Args for (A,) {
+    fn print(&self) -> String {
+        self.0.print()
+    }
+}
+impl<A: Args, B: Args> Args for (A, B) {
+    fn print(&self) -> String {
+        format!("{} {}", self.0.print(), self.1.print())
+    }
+}
+impl<A: Args, B: Args, C: Args> Args for (A, B, C) {
+    fn print(&self) -> String {
+        format!("{} {} {}", self.0.print(), self.1.print(), self.2.print())
+    }
+}
+impl<A: Args, B: Args, C: Args, D: Args> Args for (A, B, C, D) {
+    fn print(&self) -> String {
+        format!(
+            "{} {} {} {}",
+            self.0.print(),
+            self.1.print(),
+            self.2.print(),
+            self.3.print()
+        )
+    }
+}
+
+fn f(name: &str, args: impl Args) {
+    let mut line = format!("{name} {}", args.print());
+    let s = " ".repeat(32 - line.len());
+    line.push_str(&s);
+    print!("{line}")
+}
+
+fn print_instruction(op: &Instruction) {
+    match op {
+        Instruction::ADD(x) => f("ADD", x.unpack()),
+        Instruction::AND(x) => f("AND", x.unpack()),
+        Instruction::DIV(x) => f("DIV", x.unpack()),
+        Instruction::EQ(x) => f("EQ", x.unpack()),
+        Instruction::EXP(x) => f("EXP", x.unpack()),
+        Instruction::GT(x) => f("GT", x.unpack()),
+        Instruction::LT(x) => f("LT", x.unpack()),
+        Instruction::MLOG(x) => f("MLOG", x.unpack()),
+        Instruction::MROO(x) => f("MROO", x.unpack()),
+        Instruction::MOD(x) => f("MOD", x.unpack()),
+        Instruction::MOVE(x) => f("MOVE", x.unpack()),
+        Instruction::MUL(x) => f("MUL", x.unpack()),
+        Instruction::NOT(x) => f("NOT", x.unpack()),
+        Instruction::OR(x) => f("OR", x.unpack()),
+        Instruction::SLL(x) => f("SLL", x.unpack()),
+        Instruction::SRL(x) => f("SRL", x.unpack()),
+        Instruction::SUB(x) => f("SUB", x.unpack()),
+        Instruction::XOR(x) => f("XOR", x.unpack()),
+        Instruction::MLDV(x) => f("MLDV", x.unpack()),
+        Instruction::RET(x) => f("RET", x.unpack()),
+        Instruction::RETD(x) => f("RETD", x.unpack()),
+        Instruction::ALOC(x) => f("ALOC", x.unpack()),
+        Instruction::MCL(x) => f("MCL", x.unpack()),
+        Instruction::MCP(x) => f("MCP", x.unpack()),
+        Instruction::MEQ(x) => f("MEQ", x.unpack()),
+        Instruction::BHSH(x) => f("BHSH", x.unpack()),
+        Instruction::BHEI(x) => f("BHEI", x.unpack()),
+        Instruction::BURN(x) => f("BURN", x.unpack()),
+        Instruction::CALL(x) => f("CALL", x.unpack()),
+        Instruction::CCP(x) => f("CCP", x.unpack()),
+        Instruction::CROO(x) => f("CROO", x.unpack()),
+        Instruction::CSIZ(x) => f("CSIZ", x.unpack()),
+        Instruction::CB(x) => f("CB", x.unpack()),
+        Instruction::LDC(x) => f("LDC", x.unpack()),
+        Instruction::LOG(x) => f("LOG", x.unpack()),
+        Instruction::LOGD(x) => f("LOGD", x.unpack()),
+        Instruction::MINT(x) => f("MINT", x.unpack()),
+        Instruction::RVRT(x) => f("RVRT", x.unpack()),
+        Instruction::SCWQ(x) => f("SCWQ", x.unpack()),
+        Instruction::SRW(x) => f("SRW", x.unpack()),
+        Instruction::SRWQ(x) => f("SRWQ", x.unpack()),
+        Instruction::SWW(x) => f("SWW", x.unpack()),
+        Instruction::SWWQ(x) => f("SWWQ", x.unpack()),
+        Instruction::TR(x) => f("TR", x.unpack()),
+        Instruction::TRO(x) => f("TRO", x.unpack()),
+        Instruction::ECK1(x) => f("ECK1", x.unpack()),
+        Instruction::ECR1(x) => f("ECR1", x.unpack()),
+        Instruction::ED19(x) => f("ED19", x.unpack()),
+        Instruction::K256(x) => f("K256", x.unpack()),
+        Instruction::S256(x) => f("S256", x.unpack()),
+        Instruction::TIME(x) => f("TIME", x.unpack()),
+        Instruction::NOOP(_) => f("NOOP", ()),
+        Instruction::FLAG(x) => f("FLAG", x.unpack()),
+        Instruction::BAL(x) => f("BAL", x.unpack()),
+        Instruction::JMP(x) => f("JMP", x.unpack()),
+        Instruction::JNE(x) => f("JNE", x.unpack()),
+        Instruction::SMO(x) => f("SMO", x.unpack()),
+        Instruction::ADDI(x) => f("ADDI", x.unpack()),
+        Instruction::ANDI(x) => f("ANDI", x.unpack()),
+        Instruction::DIVI(x) => f("DIVI", x.unpack()),
+        Instruction::EXPI(x) => f("EXPI", x.unpack()),
+        Instruction::MODI(x) => f("MODI", x.unpack()),
+        Instruction::MULI(x) => f("MULI", x.unpack()),
+        Instruction::ORI(x) => f("ORI", x.unpack()),
+        Instruction::SLLI(x) => f("SLLI", x.unpack()),
+        Instruction::SRLI(x) => f("SRLI", x.unpack()),
+        Instruction::SUBI(x) => f("SUBI", x.unpack()),
+        Instruction::XORI(x) => f("XORI", x.unpack()),
+        Instruction::JNEI(x) => f("JNEI", x.unpack()),
+        Instruction::LB(x) => f("LB", x.unpack()),
+        Instruction::LW(x) => f("LW", x.unpack()),
+        Instruction::SB(x) => f("SB", x.unpack()),
+        Instruction::SW(x) => f("SW", x.unpack()),
+        Instruction::MCPI(x) => f("MCPI", x.unpack()),
+        Instruction::GTF(x) => f("GTF", x.unpack()),
+        Instruction::MCLI(x) => f("MCLI", x.unpack()),
+        Instruction::GM(x) => f("GM", x.unpack()),
+        Instruction::MOVI(x) => f("MOVI", x.unpack()),
+        Instruction::JNZI(x) => f("JNZI", x.unpack()),
+        Instruction::JMPF(x) => f("JMPF", x.unpack()),
+        Instruction::JMPB(x) => f("JMPB", x.unpack()),
+        Instruction::JNZF(x) => f("JNZF", x.unpack()),
+        Instruction::JNZB(x) => f("JNZB", x.unpack()),
+        Instruction::JNEF(x) => f("JNEF", x.unpack()),
+        Instruction::JNEB(x) => f("JNEB", x.unpack()),
+        Instruction::JI(x) => f("JI", x.unpack()),
+        Instruction::CFEI(x) => f("CFEI", x.unpack()),
+        Instruction::CFSI(x) => f("CFSI", x.unpack()),
+        Instruction::CFE(x) => f("CFE", x.unpack()),
+        Instruction::CFS(x) => f("CFS", x.unpack()),
+        Instruction::PSHL(x) => f("PSHL", x.unpack()),
+        Instruction::PSHH(x) => f("PSHH", x.unpack()),
+        Instruction::POPL(x) => f("POPL", x.unpack()),
+        Instruction::POPH(x) => f("POPH", x.unpack()),
+        Instruction::WDCM(x) => f("WDCM", x.unpack()),
+        Instruction::WQCM(x) => f("WQCM", x.unpack()),
+        Instruction::WDOP(x) => f("WDOP", x.unpack()),
+        Instruction::WQOP(x) => f("WQOP", x.unpack()),
+        Instruction::WDML(x) => f("WDML", x.unpack()),
+        Instruction::WQML(x) => f("WQML", x.unpack()),
+        Instruction::WDDV(x) => f("WDDV", x.unpack()),
+        Instruction::WQDV(x) => f("WQDV", x.unpack()),
+        Instruction::WDMD(x) => f("WDMD", x.unpack()),
+        Instruction::WQMD(x) => f("WQMD", x.unpack()),
+        Instruction::WDAM(x) => f("WDAM", x.unpack()),
+        Instruction::WQAM(x) => f("WQAM", x.unpack()),
+        Instruction::WDMM(x) => f("WDMM", x.unpack()),
+        Instruction::WQMM(x) => f("WQMM", x.unpack()),
+        Instruction::ECAL(x) => f("ECAL", x.unpack()),
+    }
+}
+
 /// Checks for disallowed opcodes in non-contract code.
 /// i.e., if this is a script or predicate, we can't use certain contract opcodes.
 /// See https://github.com/FuelLabs/sway/issues/350 for details.
diff --git a/sway-core/src/asm_generation/from_ir.rs b/sway-core/src/asm_generation/from_ir.rs
index 04fc9b51325..56f7a36f714 100644
--- a/sway-core/src/asm_generation/from_ir.rs
+++ b/sway-core/src/asm_generation/from_ir.rs
@@ -1,5 +1,5 @@
 use super::{
-    asm_builder::{AsmBuilder, AsmBuilderResult},
+    asm_builder::AsmBuilder,
     evm::EvmAsmBuilder,
     finalized_asm::{check_invalid_opcodes, FinalizedAsm},
     fuel::{
@@ -7,16 +7,13 @@ use super::{
         fuel_asm_builder::FuelAsmBuilder,
         register_sequencer::RegisterSequencer,
     },
-    programs::{AbstractEntry, AbstractProgram, FinalProgram, ProgramKind},
     MidenVMAsmBuilder,
 };
-
-use crate::{BuildConfig, BuildTarget, ExperimentalFlags};
-
+use crate::{asm_generation::ProgramKind, BuildConfig, BuildTarget};
 use sway_error::handler::{ErrorEmitted, Handler};
 use sway_ir::{Context, Kind, Module};
 
-pub fn compile_ir_to_asm(
+pub fn compile_ir_context_to_finalized_asm(
     handler: &Handler,
     ir: &Context,
     build_config: Option<&BuildConfig>,
@@ -28,24 +25,9 @@ pub fn compile_ir_to_asm(
     assert!(ir.module_iter().count() == 1);
 
     let module = ir.module_iter().next().unwrap();
-    let final_program =
-        compile_module_to_asm(handler, RegisterSequencer::new(), ir, module, build_config)?;
-
-    let final_asm = final_program.finalize();
-
-    check_invalid_opcodes(handler, &final_asm)?;
-
-    Ok(final_asm)
-}
 
-fn compile_module_to_asm(
-    handler: &Handler,
-    reg_seqr: RegisterSequencer,
-    context: &Context,
-    module: Module,
-    build_config: Option<&BuildConfig>,
-) -> Result<FinalProgram, ErrorEmitted> {
-    let kind = match module.get_kind(context) {
+    let reg_seqr = RegisterSequencer::new();
+    let kind = match module.get_kind(ir) {
         Kind::Contract => ProgramKind::Contract,
         Kind::Library => ProgramKind::Library,
         Kind::Predicate => ProgramKind::Predicate,
@@ -57,17 +39,42 @@ fn compile_module_to_asm(
         None => BuildTarget::default(),
     };
 
-    let mut builder: Box<dyn AsmBuilder> = match build_target {
-        BuildTarget::Fuel => Box::new(FuelAsmBuilder::new(
-            kind,
-            DataSection::default(),
-            reg_seqr,
-            context,
-        )),
-        BuildTarget::EVM => Box::new(EvmAsmBuilder::new(kind, context)),
-        BuildTarget::MidenVM => Box::new(MidenVMAsmBuilder::new(kind, context)),
-    };
+    let finalized_asm = match build_target {
+        BuildTarget::Fuel => compile(
+            handler,
+            ir,
+            module,
+            build_config,
+            FuelAsmBuilder::new(kind, DataSection::default(), reg_seqr, ir),
+        ),
+        BuildTarget::EVM => compile(
+            handler,
+            ir,
+            module,
+            build_config,
+            EvmAsmBuilder::new(kind, ir),
+        ),
+        BuildTarget::MidenVM => compile(
+            handler,
+            ir,
+            module,
+            build_config,
+            MidenVMAsmBuilder::new(kind, ir),
+        ),
+    }?;
+
+    check_invalid_opcodes(handler, &finalized_asm)?;
+
+    Ok(finalized_asm)
+}
 
+fn compile(
+    handler: &Handler,
+    context: &Context,
+    module: Module,
+    build_config: Option<&BuildConfig>,
+    mut builder: impl AsmBuilder,
+) -> Result<FinalizedAsm, ErrorEmitted> {
     let mut fallback_fn = None;
 
     // Pre-create labels for all functions before we generate other code, so we can call them
@@ -79,89 +86,15 @@ fn compile_module_to_asm(
         }
     }
 
+    for config in module.iter_configurables(context) {
+        builder.compile_configurable(config);
+    }
+
     for function in module.function_iter(context) {
         builder.compile_function(handler, function)?;
     }
 
-    // Get the compiled result and massage a bit for the AbstractProgram.
-    let result = builder.finalize();
-    let final_program = match result {
-        AsmBuilderResult::Fuel(result) => {
-            let (data_section, reg_seqr, entries, non_entries) = result;
-            let entries = entries
-                .into_iter()
-                .map(|(func, label, ops, test_decl_ref)| {
-                    let selector = func.get_selector(context);
-                    let name = func.get_name(context).to_string();
-                    AbstractEntry {
-                        test_decl_ref,
-                        selector,
-                        label,
-                        ops,
-                        name,
-                    }
-                })
-                .collect();
-
-            let abstract_program = AbstractProgram::new(
-                kind,
-                data_section,
-                entries,
-                non_entries,
-                reg_seqr,
-                ExperimentalFlags {
-                    new_encoding: context.experimental.new_encoding,
-                },
-            );
-
-            // Compiled dependencies will not have any content and we
-            // do not want to display their empty ASM structures.
-            // If printing ASM is requested, we want to emit the
-            // actual ASMs generated for the whole program.
-            let program_has_content = !abstract_program.is_empty();
-
-            if build_config
-                .map(|cfg| cfg.print_asm.virtual_abstract && program_has_content)
-                .unwrap_or(false)
-            {
-                println!(";; ASM: Virtual abstract program");
-                println!("{abstract_program}\n");
-            }
-
-            let allocated_program = abstract_program
-                .into_allocated_program(fallback_fn)
-                .map_err(|e| handler.emit_err(e))?;
-
-            if build_config
-                .map(|cfg| cfg.print_asm.allocated_abstract && program_has_content)
-                .unwrap_or(false)
-            {
-                println!(";; ASM: Allocated abstract program");
-                println!("{allocated_program}");
-            }
-
-            let final_program = allocated_program
-                .into_final_program()
-                .map_err(|e| handler.emit_err(e))?;
-
-            if build_config
-                .map(|cfg| cfg.print_asm.r#final && program_has_content)
-                .unwrap_or(false)
-            {
-                println!(";; ASM: Final program");
-                println!("{final_program}");
-            }
-
-            final_program
-        }
-        AsmBuilderResult::Evm(result) => FinalProgram::Evm {
-            ops: result.ops,
-            abi: result.abi,
-        },
-        AsmBuilderResult::MidenVM(result) => FinalProgram::MidenVM { ops: result.ops },
-    };
-
-    Ok(final_program)
+    builder.finalize(handler, build_config, fallback_fn)
 }
 
 // -------------------------------------------------------------------------------------------------
diff --git a/sway-core/src/asm_generation/fuel/abstract_instruction_set.rs b/sway-core/src/asm_generation/fuel/abstract_instruction_set.rs
index 91f0673247c..cd1156f38e8 100644
--- a/sway-core/src/asm_generation/fuel/abstract_instruction_set.rs
+++ b/sway-core/src/asm_generation/fuel/abstract_instruction_set.rs
@@ -123,12 +123,11 @@ impl AbstractInstructionSet {
         self
     }
 
+    // At the moment the only verification we do is to make sure used registers are
+    // initialised.  Without doing dataflow analysis we still can't guarantee the init is
+    // _before_ the use, but future refactoring to convert abstract ops into SSA and BBs will
+    // make this possible or even make this check redundant.
     pub(crate) fn verify(self) -> Result<AbstractInstructionSet, CompileError> {
-        // At the moment the only verification we do is to make sure used registers are
-        // initialised.  Without doing dataflow analysis we still can't guarantee the init is
-        // _before_ the use, but future refactoring to convert abstract ops into SSA and BBs will
-        // make this possible or even make this check redundant.
-
         macro_rules! add_virt_regs {
             ($regs: expr, $set: expr) => {
                 let mut regs = $regs;
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 d18d6d2ae4c..f1e5aa26f41 100644
--- a/sway-core/src/asm_generation/fuel/fuel_asm_builder.rs
+++ b/sway-core/src/asm_generation/fuel/fuel_asm_builder.rs
@@ -1,6 +1,10 @@
+use super::{
+    globals_section::GlobalsSection,
+    programs::{AbstractEntry, AbstractProgram},
+};
 use crate::{
     asm_generation::{
-        asm_builder::{AsmBuilder, AsmBuilderResult},
+        asm_builder::AsmBuilder,
         from_ir::{StateAccessType, Storage},
         fuel::{
             abstract_instruction_set::AbstractInstructionSet,
@@ -8,7 +12,7 @@ use crate::{
             data_section::{DataId, DataSection, Entry},
             register_sequencer::RegisterSequencer,
         },
-        ProgramKind,
+        FinalizedAsm, ProgramKind,
     },
     asm_lang::{
         virtual_register::*, Label, Op, VirtualImmediate06, VirtualImmediate12, VirtualImmediate18,
@@ -16,6 +20,7 @@ use crate::{
     },
     decl_engine::DeclRefFunction,
     metadata::MetadataManager,
+    BuildConfig,
 };
 
 use sway_error::{
@@ -36,6 +41,12 @@ pub struct FuelAsmBuilder<'ir, 'eng> {
     // Data section is used by the rest of code gen to layout const memory.
     pub(super) data_section: DataSection,
 
+    // Globals will be allocated at SSP uninitialized (they will not be zeroed)
+    pub(super) globals_section: GlobalsSection,
+
+    // Maps configurable name to data id, only used by encoding v0
+    pub(super) configurable_v0_data_id: HashMap<String, DataId>,
+
     // Register sequencer dishes out new registers and labels.
     pub(super) reg_seqr: RegisterSequencer,
 
@@ -74,25 +85,95 @@ pub struct FuelAsmBuilder<'ir, 'eng> {
 
     // In progress VM bytecode ops.
     pub(super) cur_bytecode: Vec<Op>,
-}
 
-pub type FuelAsmBuilderResult = (
-    DataSection,
-    RegisterSequencer,
-    Vec<(
-        Function,
-        Label,
-        AbstractInstructionSet,
-        Option<DeclRefFunction>,
-    )>,
-    Vec<AbstractInstructionSet>,
-);
+    pub(super) before_entries: Vec<Op>,
+}
 
 impl<'ir, 'eng> AsmBuilder for FuelAsmBuilder<'ir, 'eng> {
     fn func_to_labels(&mut self, func: &Function) -> (Label, Label) {
         self.func_to_labels(func)
     }
 
+    fn compile_configurable(&mut self, config: &ConfigurableContent) {
+        match config {
+            ConfigurableContent::V0 { name, constant, .. } => {
+                let entry = Entry::from_constant(self.context, constant, Some(name.clone()), None);
+                let dataid = self.data_section.insert_data_value(entry);
+                self.configurable_v0_data_id.insert(name.clone(), dataid);
+            }
+            ConfigurableContent::V1 {
+                name,
+                ty,
+                encoded_bytes,
+                decode_fn,
+                ..
+            } => {
+                let size_in_bytes = ty.size(self.context).in_bytes();
+
+                self.globals_section.insert(name, size_in_bytes);
+                let global = self.globals_section.get_by_name(name).unwrap();
+
+                let (decode_fn_label, _) = self.func_label_map.get(decode_fn).unwrap();
+                let dataid = self.data_section.insert_data_value(Entry::new_byte_array(
+                    encoded_bytes.clone(),
+                    None,
+                    None,
+                ));
+
+                self.before_entries.push(Op {
+                    opcode: Either::Left(VirtualOp::AddrDataId(
+                        VirtualRegister::Constant(ConstantRegister::FuncArg0),
+                        dataid,
+                    )),
+                    comment: format!("ptr to {} default value", name),
+                    owning_span: None,
+                });
+
+                self.before_entries.push(Op {
+                    opcode: Either::Left(VirtualOp::ADDI(
+                        VirtualRegister::Constant(ConstantRegister::FuncArg1),
+                        VirtualRegister::Constant(ConstantRegister::Zero),
+                        VirtualImmediate12 {
+                            value: encoded_bytes.len() as u16,
+                        },
+                    )),
+                    comment: format!("length of {} default value", name),
+                    owning_span: None,
+                });
+
+                self.before_entries.push(Op {
+                    opcode: Either::Left(VirtualOp::ADDI(
+                        VirtualRegister::Constant(ConstantRegister::FuncArg2),
+                        VirtualRegister::Constant(ConstantRegister::StackStartPointer),
+                        VirtualImmediate12 {
+                            value: global.offset_in_bytes as u16,
+                        },
+                    )),
+                    comment: format!("ptr to global {} stack address", name),
+                    owning_span: None,
+                });
+
+                // Set a new return address.
+                let ret_label = self.reg_seqr.get_label();
+                self.before_entries.push(Op::save_ret_addr(
+                    VirtualRegister::Constant(ConstantRegister::CallReturnAddress),
+                    ret_label,
+                    "",
+                    None,
+                ));
+
+                // call decode
+                self.before_entries.push(Op {
+                    opcode: Either::Right(crate::asm_lang::ControlFlowOp::Call(*decode_fn_label)),
+                    comment: format!("decode {}", name),
+                    owning_span: None,
+                });
+
+                self.before_entries.push(Op::unowned_jump_label(ret_label));
+            }
+        }
+    }
+
     fn compile_function(
         &mut self,
         handler: &Handler,
@@ -101,8 +182,105 @@ impl<'ir, 'eng> AsmBuilder for FuelAsmBuilder<'ir, 'eng> {
         self.compile_function(handler, function)
     }
 
-    fn finalize(&self) -> AsmBuilderResult {
-        self.finalize()
+    fn finalize(
+        self,
+        handler: &Handler,
+        build_config: Option<&BuildConfig>,
+        fallback_fn: Option<Label>,
+    ) -> Result<FinalizedAsm, ErrorEmitted> {
+        let FuelAsmBuilder {
+            program_kind,
+            data_section,
+            globals_section,
+            reg_seqr,
+            context,
+            entries,
+            non_entries,
+            before_entries: before_entry,
+            ..
+        } = self;
+
+        let entries = entries
+            .clone()
+            .into_iter()
+            .map(|(f, l, ops, test_decl_ref)| (f, l, AbstractInstructionSet { ops }, test_decl_ref))
+            .collect::<Vec<_>>();
+
+        let non_entries = non_entries
+            .clone()
+            .into_iter()
+            .map(|ops| AbstractInstructionSet { ops })
+            .collect::<Vec<_>>();
+
+        let entries = entries
+            .into_iter()
+            .map(|(func, label, ops, test_decl_ref)| {
+                let selector = func.get_selector(context);
+                let name = func.get_name(context).to_string();
+                AbstractEntry {
+                    test_decl_ref,
+                    selector,
+                    label,
+                    ops,
+                    name,
+                }
+            })
+            .collect();
+
+        let before_entry = AbstractInstructionSet { ops: before_entry };
+
+        let virtual_abstract_program = AbstractProgram::new(
+            program_kind,
+            data_section,
+            globals_section,
+            before_entry,
+            entries,
+            non_entries,
+            reg_seqr,
+            crate::ExperimentalFlags {
+                new_encoding: context.experimental.new_encoding,
+            },
+        );
+
+        // Compiled dependencies will not have any content and we
+        // do not want to display their empty ASM structures.
+        // If printing ASM is requested, we want to emit the
+        // actual ASMs generated for the whole program.
+        let program_has_content = !virtual_abstract_program.is_empty();
+
+        if build_config
+            .map(|cfg| cfg.print_asm.virtual_abstract && program_has_content)
+            .unwrap_or(false)
+        {
+            println!(";; ASM: Virtual abstract program");
+            println!("{virtual_abstract_program}\n");
+        }
+
+        let allocated_program = virtual_abstract_program
+            .into_allocated_program(fallback_fn)
+            .map_err(|e| handler.emit_err(e))?;
+
+        if build_config
+            .map(|cfg| cfg.print_asm.allocated_abstract && program_has_content)
+            .unwrap_or(false)
+        {
+            println!(";; ASM: Allocated abstract program");
+            println!("{allocated_program}");
+        }
+
+        let final_program = allocated_program
+            .into_final_program()
+            .map_err(|e| handler.emit_err(e))?;
+
+        if build_config
+            .map(|cfg| cfg.print_asm.r#final && program_has_content)
+            .unwrap_or(false)
+        {
+            println!(";; ASM: Final program");
+            println!("{final_program}");
+        }
+
+        Ok(final_program.finalize())
     }
 }
 
@@ -116,6 +294,8 @@ impl<'ir, 'eng> FuelAsmBuilder<'ir, 'eng> {
         FuelAsmBuilder {
             program_kind,
             data_section,
+            globals_section: GlobalsSection::default(),
+            configurable_v0_data_id: HashMap::default(),
             reg_seqr,
             func_label_map: HashMap::new(),
             block_label_map: HashMap::new(),
@@ -129,28 +309,10 @@ impl<'ir, 'eng> FuelAsmBuilder<'ir, 'eng> {
             entries: Vec::new(),
             non_entries: Vec::new(),
             cur_bytecode: Vec::new(),
+            before_entries: vec![],
         }
     }
 
-    pub fn finalize(&self) -> AsmBuilderResult {
-        AsmBuilderResult::Fuel((
-            self.data_section.clone(),
-            self.reg_seqr,
-            self.entries
-                .clone()
-                .into_iter()
-                .map(|(f, l, ops, test_decl_ref)| {
-                    (f, l, AbstractInstructionSet { ops }, test_decl_ref)
-                })
-                .collect(),
-            self.non_entries
-                .clone()
-                .into_iter()
-                .map(|ops| AbstractInstructionSet { ops })
-                .collect(),
-        ))
-    }
-
     pub(super) fn compile_block(
         &mut self,
         handler: &Handler,
@@ -314,6 +476,7 @@ impl<'ir, 'eng> FuelAsmBuilder<'ir, 'eng> {
                     indices,
                 } => self.compile_get_elem_ptr(instr_val, base, elem_ptr_ty, indices),
                 InstOp::GetLocal(local_var) => self.compile_get_local(instr_val, local_var),
+                InstOp::GetConfig(_, name) => self.compile_get_config(instr_val, name),
                 InstOp::IntToPtr(val, _) => self.compile_no_op_move(instr_val, val),
                 InstOp::Load(src_val) => self.compile_load(instr_val, src_val),
                 InstOp::MemCopyBytes {
@@ -440,7 +603,7 @@ impl<'ir, 'eng> FuelAsmBuilder<'ir, 'eng> {
 
             inline_ops.push(Op {
                 opcode: either::Either::Left(opcode),
-                comment: "asm block".into(),
+                comment: op_span.as_str().into(),
                 owning_span: Some(op_span),
             });
         }
@@ -465,7 +628,7 @@ impl<'ir, 'eng> FuelAsmBuilder<'ir, 'eng> {
             let instr_reg = self.reg_seqr.next();
             inline_ops.push(Op {
                 opcode: Either::Left(VirtualOp::MOVE(instr_reg.clone(), ret_reg)),
-                comment: "return value from inline asm".into(),
+                comment: format!("return value from inline asm ({})", ret_reg_name),
                 owning_span: self.md_mgr.val_to_span(self.context, *instr_val),
             });
             self.reg_map.insert(*instr_val, instr_reg);
@@ -1124,6 +1287,40 @@ impl<'ir, 'eng> FuelAsmBuilder<'ir, 'eng> {
         }
     }
 
+    fn compile_get_config(&mut self, addr_val: &Value, name: &String) -> Result<(), CompileError> {
+        let addr_reg = self.reg_seqr.next();
+
+        // if configurable is at the global_section, it is v1
+        if let Some(g) = self.globals_section.get_by_name(name) {
+            self.cur_bytecode.push(Op {
+                opcode: either::Either::Left(VirtualOp::ADDI(
+                    addr_reg.clone(),
+                    VirtualRegister::Constant(ConstantRegister::StackStartPointer),
+                    VirtualImmediate12 {
+                        value: g.offset_in_bytes as u16,
+                    },
+                )),
+                comment: format!("configurable {} address", name),
+                owning_span: self.md_mgr.val_to_span(self.context, *addr_val),
+            });
+            self.reg_map.insert(*addr_val, addr_reg);
+        } else {
+            // Otherwise is configurable with encoding v0 and must be at configurable_v0_data_id
+            let dataid = self.configurable_v0_data_id.get(name).unwrap();
+            self.cur_bytecode.push(Op {
+                opcode: either::Either::Left(VirtualOp::AddrDataId(
+                    addr_reg.clone(),
+                    dataid.clone(),
+                )),
+                comment: format!("configurable {} address", name),
+                owning_span: self.md_mgr.val_to_span(self.context, *addr_val),
+            });
+            self.reg_map.insert(*addr_val, addr_reg);
+        }
+
+        Ok(())
+    }
+
     fn compile_gtf(
         &mut self,
         instr_val: &Value,
@@ -1721,18 +1918,10 @@ impl<'ir, 'eng> FuelAsmBuilder<'ir, 'eng> {
             .get_type(self.context)
             .map_or(true, |ty| !self.is_copy_type(&ty))
         {
-            // NOTE: Very hacky special case here which must be fixed.  We've been given a
-            // configurable constant which doesn't have a pointer type and shouldn't still be using
-            // `store`.
-            if stored_val.is_configurable(self.context) {
-                // So we know it's not a copy type so we actually need a MCP.
-                self.compile_mem_copy_val(instr_val, dst_val, stored_val)
-            } else {
-                Err(CompileError::Internal(
-                    "Attempt to store a non-copy type.",
-                    owning_span.unwrap_or_else(Span::dummy),
-                ))
-            }
+            Err(CompileError::Internal(
+                "Attempt to store a non-copy type.",
+                owning_span.unwrap_or_else(Span::dummy),
+            ))
         } else {
             let stored_ty = stored_val.get_type(self.context).unwrap();
             let byte_len = stored_ty.size(self.context).in_bytes();
@@ -1869,27 +2058,13 @@ impl<'ir, 'eng> FuelAsmBuilder<'ir, 'eng> {
                     self.initialise_constant(constant, None, span).0
                 })
             })
-            .or_else(|| {
-                value.get_configurable(self.context).map(|constant| {
-                    let span = self.md_mgr.val_to_span(self.context, *value);
-                    let config_name = self
-                        .md_mgr
-                        .md_to_config_const_name(self.context, value.get_metadata(self.context))
-                        .unwrap()
-                        .to_string();
-
-                    let initialized =
-                        self.initialise_constant(constant, Some(config_name.clone()), span);
-                    if let Some(data_id) = initialized.1 {
-                        self.data_section.config_map.insert(config_name, data_id.0);
-                    }
-                    initialized.0
-                })
-            })
             .ok_or_else(|| {
+                let span = self.md_mgr.val_to_span(self.context, *value);
+                dbg!(value.with_context(self.context));
+                eprintln!("{}", std::backtrace::Backtrace::force_capture());
                 CompileError::Internal(
                     "An attempt to get register for unknown Value.",
-                    Span::dummy(),
+                    span.unwrap_or(Span::dummy()),
                 )
             })
     }
diff --git a/sway-core/src/asm_generation/fuel/functions.rs b/sway-core/src/asm_generation/fuel/functions.rs
index 7a643724539..55dfaa9ee5e 100644
--- a/sway-core/src/asm_generation/fuel/functions.rs
+++ b/sway-core/src/asm_generation/fuel/functions.rs
@@ -273,6 +273,7 @@ impl<'ir, 'eng> FuelAsmBuilder<'ir, 'eng> {
             "--- start of function: {} ---",
             function.get_name(self.context)
         );
+
         self.cur_bytecode.push(match span {
             Some(span) => Op::jump_label_comment(start_label, span, comment),
             None => Op::unowned_jump_label_comment(start_label, comment),
@@ -380,13 +381,13 @@ impl<'ir, 'eng> FuelAsmBuilder<'ir, 'eng> {
     fn compile_fn_call_args(&mut self, function: Function) {
         if function.num_args(self.context) <= compiler_constants::NUM_ARG_REGISTERS as usize {
             // All arguments are passed through registers.
-            for (idx, (_, arg_val)) in function.args_iter(self.context).enumerate() {
+            for (idx, (arg, arg_val)) in function.args_iter(self.context).enumerate() {
                 // Make a copy of the args in case we make calls and need to use the arg registers.
                 let arg_copy_reg = self.reg_seqr.next();
                 self.cur_bytecode.push(Op::register_move(
                     arg_copy_reg.clone(),
                     VirtualRegister::Constant(ConstantRegister::ARG_REGS[idx]),
-                    format!("save arg {idx}"),
+                    format!("save arg {idx} ({arg})"),
                     self.md_mgr.val_to_span(self.context, *arg_val),
                 ));
 
diff --git a/sway-core/src/asm_generation/fuel/globals_section.rs b/sway-core/src/asm_generation/fuel/globals_section.rs
new file mode 100644
index 00000000000..9c4d65f568d
--- /dev/null
+++ b/sway-core/src/asm_generation/fuel/globals_section.rs
@@ -0,0 +1,31 @@
+pub struct GlobalContent {
+    pub name: String,
+    pub size_in_bytes: u64,
+    pub offset_in_bytes: u64,
+}
+
+#[derive(Default)]
+pub struct GlobalsSection {
+    entries: Vec<GlobalContent>,
+    current_offset_in_bytes: u64,
+}
+
+impl GlobalsSection {
+    pub fn insert(&mut self, name: &str, size_in_bytes: u64) {
+        let g = GlobalContent {
+            name: name.to_string(),
+            size_in_bytes,
+            offset_in_bytes: self.current_offset_in_bytes,
+        };
+        self.entries.push(g);
+        self.current_offset_in_bytes += size_in_bytes;
+    }
+
+    pub fn len_in_bytes(&self) -> u64 {
+        self.entries.iter().map(|x| x.size_in_bytes).sum()
+    }
+
+    pub fn get_by_name(&self, name: &str) -> Option<&GlobalContent> {
+        self.entries.iter().find(|x| x.name == name)
+    }
+}
diff --git a/sway-core/src/asm_generation/fuel/mod.rs b/sway-core/src/asm_generation/fuel/mod.rs
index 5bc2e9a4c36..9f35255c7f4 100644
--- a/sway-core/src/asm_generation/fuel/mod.rs
+++ b/sway-core/src/asm_generation/fuel/mod.rs
@@ -8,6 +8,10 @@ pub(super) mod checks;
 pub(super) mod fuel_asm_builder;
 pub(super) mod register_sequencer;
 
+pub(super) mod programs;
+
+mod globals_section;
+
 mod analyses;
 mod functions;
 mod optimizations;
diff --git a/sway-core/src/asm_generation/fuel/optimizations.rs b/sway-core/src/asm_generation/fuel/optimizations.rs
index c45761ba140..ed293d04908 100644
--- a/sway-core/src/asm_generation/fuel/optimizations.rs
+++ b/sway-core/src/asm_generation/fuel/optimizations.rs
@@ -20,13 +20,14 @@ impl AbstractInstructionSet {
     // computations left untouched, to be later removed by a DCE pass.
     pub(crate) fn const_indexing_aggregates_function(mut self, data_section: &DataSection) -> Self {
         // Poor man's SSA (local ... per block).
-        #[derive(PartialEq, Eq, Hash, Clone)]
+        #[derive(PartialEq, Eq, Hash, Clone, Debug)]
         struct VRegDef {
             reg: VirtualRegister,
             ver: u32,
         }
 
         // What does a register contain?
+        #[derive(Debug)]
         enum RegContents {
             Constant(u64),
             BaseOffset(VRegDef, u64),
@@ -57,6 +58,9 @@ impl AbstractInstructionSet {
         }
 
         for op in &mut self.ops {
+            // Uncomment to debug what this optimization is doing
+            // let op_before = op.clone();
+
             fn process_add(
                 reg_contents: &mut FxHashMap<VirtualRegister, RegContents>,
                 latest_version: &mut FxHashMap<VirtualRegister, u32>,
@@ -134,16 +138,19 @@ impl AbstractInstructionSet {
                                 && ((offset / 8) + imm.value as u64)
                                     < compiler_constants::TWELVE_BITS =>
                         {
-                            let new_imm = VirtualImmediate12::new_unchecked(
-                                (offset / 8) + imm.value as u64,
-                                "Immediate offset too big for LW",
-                            );
-                            let new_lw = VirtualOp::LW(dest.clone(), base_reg.reg.clone(), new_imm);
-                            // The register defined is no more useful for us. Forget anything from its past.
-                            reg_contents.remove(dest);
-                            record_new_def(&mut latest_version, dest);
-                            // Replace the LW with a new one in-place.
-                            *op = new_lw;
+                            if offset % 8 == 0 {
+                                let new_imm = VirtualImmediate12::new_unchecked(
+                                    (offset / 8) + imm.value as u64,
+                                    "Immediate offset too big for LW",
+                                );
+                                let new_lw =
+                                    VirtualOp::LW(dest.clone(), base_reg.reg.clone(), new_imm);
+                                // The register defined is no more useful for us. Forget anything from its past.
+                                reg_contents.remove(dest);
+                                record_new_def(&mut latest_version, dest);
+                                // Replace the LW with a new one in-place.
+                                *op = new_lw;
+                            }
                         }
                         _ => {
                             reg_contents.remove(dest);
@@ -181,6 +188,20 @@ impl AbstractInstructionSet {
                     reg_contents.clear();
                 }
             }
+
+            // Uncomment to debug what this optimization is doing
+            // let before = op_before.opcode.to_string();
+            // let after = op.opcode.to_string();
+
+            // println!("{}", before);
+            // if before != after {
+            //     println!("    optimized to");
+            //     println!("    {}", after);
+            //     println!("    using");
+            //     for (k, v) in reg_contents.iter() {
+            //         println!("    - {:?} -> {:?}", k, v);
+            //     }
+            // }
         }
 
         self
diff --git a/sway-core/src/asm_generation/fuel/programs.rs b/sway-core/src/asm_generation/fuel/programs.rs
new file mode 100644
index 00000000000..b08453fa6df
--- /dev/null
+++ b/sway-core/src/asm_generation/fuel/programs.rs
@@ -0,0 +1,11 @@
+mod r#abstract;
+mod allocated;
+mod r#final;
+
+pub(crate) use allocated::AllocatedProgram;
+pub(crate) use r#abstract::{AbstractEntry, AbstractProgram};
+pub(crate) use r#final::FinalProgram;
+
+pub(crate) type SelectorOpt = Option<[u8; 4]>;
+pub(crate) type FnName = String;
+pub(crate) type ImmOffset = u64;
diff --git a/sway-core/src/asm_generation/programs/abstract.rs b/sway-core/src/asm_generation/fuel/programs/abstract.rs
similarity index 70%
rename from sway-core/src/asm_generation/programs/abstract.rs
rename to sway-core/src/asm_generation/fuel/programs/abstract.rs
index 979152aca8a..0ab17d7f924 100644
--- a/sway-core/src/asm_generation/programs/abstract.rs
+++ b/sway-core/src/asm_generation/fuel/programs/abstract.rs
@@ -1,29 +1,59 @@
-use super::{AbstractEntry, AbstractProgram, AllocatedProgram, ProgramKind};
-
+use super::{AllocatedProgram, FnName, SelectorOpt};
 use crate::{
-    asm_generation::fuel::{
-        abstract_instruction_set::AbstractInstructionSet,
-        allocated_abstract_instruction_set::AllocatedAbstractInstructionSet,
-        compiler_constants,
-        data_section::{DataSection, Entry},
-        register_sequencer::RegisterSequencer,
+    asm_generation::{
+        fuel::{
+            abstract_instruction_set::AbstractInstructionSet,
+            allocated_abstract_instruction_set::AllocatedAbstractInstructionSet,
+            compiler_constants,
+            data_section::{DataSection, Entry},
+            globals_section::GlobalsSection,
+            register_sequencer::RegisterSequencer,
+        },
+        ProgramKind,
     },
     asm_lang::{
         allocated_ops::{AllocatedOpcode, AllocatedRegister},
-        AllocatedAbstractOp, ConstantRegister, ControlFlowOp, VirtualImmediate12,
-        VirtualImmediate18,
+        AllocatedAbstractOp, ConstantRegister, ControlFlowOp, Label, VirtualImmediate12,
+        VirtualImmediate18, VirtualImmediate24,
     },
+    decl_engine::DeclRefFunction,
     ExperimentalFlags,
 };
-
+use either::Either;
 use sway_error::error::CompileError;
 
-use either::Either;
+/// The entry point of an abstract program.
+pub(crate) struct AbstractEntry {
+    pub(crate) selector: SelectorOpt,
+    pub(crate) label: Label,
+    pub(crate) ops: AbstractInstructionSet,
+    pub(crate) name: FnName,
+    pub(crate) test_decl_ref: Option<DeclRefFunction>,
+}
+
+/// An [AbstractProgram] represents code generated by the compilation from IR, with virtual registers
+/// and abstract control flow.
+///
+/// Use `AbstractProgram::to_allocated_program()` to perform register allocation.
+///
+pub(crate) struct AbstractProgram {
+    kind: ProgramKind,
+    data_section: DataSection,
+    globals_section: GlobalsSection,
+    before_entries: AbstractInstructionSet,
+    entries: Vec<AbstractEntry>,
+    non_entries: Vec<AbstractInstructionSet>,
+    reg_seqr: RegisterSequencer,
+    experimental: ExperimentalFlags,
+}
 
 impl AbstractProgram {
+    #[allow(clippy::too_many_arguments)]
     pub(crate) fn new(
         kind: ProgramKind,
         data_section: DataSection,
+        globals_section: GlobalsSection,
+        before_entry: AbstractInstructionSet,
         entries: Vec<AbstractEntry>,
         non_entries: Vec<AbstractInstructionSet>,
         reg_seqr: RegisterSequencer,
@@ -32,6 +62,8 @@ impl AbstractProgram {
         AbstractProgram {
             kind,
             data_section,
+            globals_section,
+            before_entries: before_entry,
             entries,
             non_entries,
             reg_seqr,
@@ -46,20 +78,25 @@ impl AbstractProgram {
             && self.data_section.value_pairs.is_empty()
     }
 
+    /// Adds prologue, contract method switch, and allocates virtual register
     pub(crate) fn into_allocated_program(
         mut self,
         fallback_fn: Option<crate::asm_lang::Label>,
     ) -> Result<AllocatedProgram, CompileError> {
-        // Build our bytecode prologue which has a preamble and for contracts is the switch based on
-        // function selector.
-        let mut prologue = self.build_preamble();
+        let mut prologue = self.build_prologue();
+        self.append_globals(&mut prologue);
+
+        let before_entries = self.before_entries.clone().optimize(&self.data_section);
+        let before_entries = before_entries.verify()?;
+        let mut before_entries = before_entries.allocate_registers()?;
+        prologue.ops.append(&mut before_entries.ops);
 
         match (self.experimental.new_encoding, self.kind) {
             (true, ProgramKind::Contract) => {
-                self.build_jump_to_entry(&mut prologue);
+                self.append_jump_to_entry(&mut prologue);
             }
             (false, ProgramKind::Contract) => {
-                self.build_contract_abi_switch(&mut prologue, fallback_fn);
+                self.append_encoding_v0_contract_abi_switch(&mut prologue, fallback_fn);
             }
             _ => {}
         }
@@ -78,25 +115,27 @@ impl AbstractProgram {
             })
             .collect();
 
-        // Gather all the functions together, optimise and then verify the instructions.
-        let abstract_functions = self
+        // Gather all functions
+        let all_functions = self
             .entries
             .into_iter()
             .map(|entry| entry.ops)
-            .chain(self.non_entries)
-            .map(|ais| ais.optimize(&self.data_section))
+            .chain(self.non_entries);
+
+        // optimise and then verify these functions.
+        let abstract_functions = all_functions
+            .map(|instruction_set| instruction_set.optimize(&self.data_section))
             .map(AbstractInstructionSet::verify)
-            .collect::<Result<Vec<_>, _>>()?;
+            .collect::<Result<Vec<AbstractInstructionSet>, CompileError>>()?;
 
         // Allocate the registers for each function.
         let functions = abstract_functions
             .into_iter()
-            .map(|fn_ops| {
-                fn_ops
-                    .allocate_registers()
-                    .map(AllocatedAbstractInstructionSet::emit_pusha_popa)
+            .map(|abstract_instruction_set| {
+                let allocated = abstract_instruction_set.allocate_registers()?;
+                Ok(allocated.emit_pusha_popa())
             })
-            .collect::<Result<Vec<_>, _>>()?;
+            .collect::<Result<Vec<AllocatedAbstractInstructionSet>, CompileError>>()?;
 
         // XXX need to verify that the stack use for each function is balanced.
 
@@ -120,7 +159,7 @@ impl AbstractProgram {
     /// 3    LW $ds $scratch 1
     /// -    ADD $ds $ds $scratch
     /// 4    .program_start:
-    fn build_preamble(&mut self) -> AllocatedAbstractInstructionSet {
+    fn build_prologue(&mut self) -> AllocatedAbstractInstructionSet {
         let label = self.reg_seqr.get_label();
         AllocatedAbstractInstructionSet {
             ops: [
@@ -175,9 +214,9 @@ impl AbstractProgram {
     }
 
     // WHen the new encoding is used, jumps to the `__entry`  function
-    fn build_jump_to_entry(&mut self, asm_buf: &mut AllocatedAbstractInstructionSet) {
+    fn append_jump_to_entry(&mut self, asm: &mut AllocatedAbstractInstructionSet) {
         let entry = self.entries.iter().find(|x| x.name == "__entry").unwrap();
-        asm_buf.ops.push(AllocatedAbstractOp {
+        asm.ops.push(AllocatedAbstractOp {
             opcode: Either::Right(ControlFlowOp::Jump(entry.label)),
             comment: "jump to abi method selector".into(),
             owning_span: None,
@@ -188,9 +227,9 @@ impl AbstractProgram {
     /// 'selector'.
     /// See https://fuellabs.github.io/fuel-specs/master/vm#call-frames which
     /// describes the first argument to be at word offset 73.
-    fn build_contract_abi_switch(
+    fn append_encoding_v0_contract_abi_switch(
         &mut self,
-        asm_buf: &mut AllocatedAbstractInstructionSet,
+        asm: &mut AllocatedAbstractInstructionSet,
         fallback_fn: Option<crate::asm_lang::Label>,
     ) {
         const SELECTOR_WORD_OFFSET: u64 = 73;
@@ -199,14 +238,14 @@ impl AbstractProgram {
         const CMP_RESULT_REG: AllocatedRegister = AllocatedRegister::Allocated(2);
 
         // Build the switch statement for selectors.
-        asm_buf.ops.push(AllocatedAbstractOp {
+        asm.ops.push(AllocatedAbstractOp {
             opcode: Either::Right(ControlFlowOp::Comment),
             comment: "Begin contract ABI selector switch".into(),
             owning_span: None,
         });
 
         // Load the selector from the call frame.
-        asm_buf.ops.push(AllocatedAbstractOp {
+        asm.ops.push(AllocatedAbstractOp {
             opcode: Either::Left(AllocatedOpcode::LW(
                 INPUT_SELECTOR_REG,
                 AllocatedRegister::Constant(ConstantRegister::FramePointer),
@@ -235,14 +274,14 @@ impl AbstractProgram {
             ));
 
             // Load the data into a register for comparison.
-            asm_buf.ops.push(AllocatedAbstractOp {
+            asm.ops.push(AllocatedAbstractOp {
                 opcode: Either::Left(AllocatedOpcode::LoadDataId(PROG_SELECTOR_REG, data_label)),
                 comment: format!("load fn selector for comparison {}", entry.name),
                 owning_span: None,
             });
 
             // Compare with the input selector.
-            asm_buf.ops.push(AllocatedAbstractOp {
+            asm.ops.push(AllocatedAbstractOp {
                 opcode: Either::Left(AllocatedOpcode::EQ(
                     CMP_RESULT_REG,
                     INPUT_SELECTOR_REG,
@@ -253,7 +292,7 @@ impl AbstractProgram {
             });
 
             // Jump to the function label if the selector was equal.
-            asm_buf.ops.push(AllocatedAbstractOp {
+            asm.ops.push(AllocatedAbstractOp {
                 // If the comparison result is _not_ equal to 0, then it was indeed equal.
                 opcode: Either::Right(ControlFlowOp::JumpIfNotZero(CMP_RESULT_REG, entry.label)),
                 comment: "jump to selected function".into(),
@@ -262,14 +301,14 @@ impl AbstractProgram {
         }
 
         if let Some(fallback_fn) = fallback_fn {
-            asm_buf.ops.push(AllocatedAbstractOp {
+            asm.ops.push(AllocatedAbstractOp {
                 opcode: Either::Right(ControlFlowOp::Call(fallback_fn)),
                 comment: "call fallback function".into(),
                 owning_span: None,
             });
         }
 
-        asm_buf.ops.push(AllocatedAbstractOp {
+        asm.ops.push(AllocatedAbstractOp {
             opcode: Either::Left(AllocatedOpcode::MOVI(
                 AllocatedRegister::Constant(ConstantRegister::Scratch),
                 VirtualImmediate18 {
@@ -279,7 +318,7 @@ impl AbstractProgram {
             comment: "special code for mismatched selector".into(),
             owning_span: None,
         });
-        asm_buf.ops.push(AllocatedAbstractOp {
+        asm.ops.push(AllocatedAbstractOp {
             opcode: Either::Left(AllocatedOpcode::RVRT(AllocatedRegister::Constant(
                 ConstantRegister::Scratch,
             ))),
@@ -287,11 +326,26 @@ impl AbstractProgram {
             owning_span: None,
         });
     }
+
+    fn append_globals(&self, asm: &mut AllocatedAbstractInstructionSet) {
+        let len_in_bytes = self.globals_section.len_in_bytes();
+        asm.ops.push(AllocatedAbstractOp {
+            opcode: Either::Left(AllocatedOpcode::CFEI(VirtualImmediate24 {
+                value: len_in_bytes as u32,
+            })),
+            comment: "stack space for globals".into(),
+            owning_span: None,
+        });
+    }
 }
 
 impl std::fmt::Display for AbstractProgram {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         writeln!(f, ";; Program kind: {:?}", self.kind)?;
+
+        writeln!(f, ";; --- Before Entries ---")?;
+        writeln!(f, "{}\n", self.before_entries)?;
+
         writeln!(f, ";; --- Entries ---")?;
         for entry in &self.entries {
             writeln!(f, "{}\n", entry.ops)?;
diff --git a/sway-core/src/asm_generation/programs/allocated.rs b/sway-core/src/asm_generation/fuel/programs/allocated.rs
similarity index 67%
rename from sway-core/src/asm_generation/programs/allocated.rs
rename to sway-core/src/asm_generation/fuel/programs/allocated.rs
index 1f5b160af1d..a9f69de7f34 100644
--- a/sway-core/src/asm_generation/programs/allocated.rs
+++ b/sway-core/src/asm_generation/fuel/programs/allocated.rs
@@ -1,6 +1,26 @@
-use super::{AllocatedProgram, FinalProgram};
+use super::{FinalProgram, FnName, SelectorOpt};
 
-use crate::asm_generation::fuel::allocated_abstract_instruction_set::AllocatedAbstractInstructionSet;
+use crate::{
+    asm_generation::{
+        fuel::{
+            allocated_abstract_instruction_set::AllocatedAbstractInstructionSet,
+            data_section::DataSection,
+        },
+        ProgramKind,
+    },
+    asm_lang::Label,
+    decl_engine::DeclRefFunction,
+};
+
+/// An [AllocatedProgram] represents code which has allocated registers but still has abstract
+/// control flow.
+pub(crate) struct AllocatedProgram {
+    pub(crate) kind: ProgramKind,
+    pub(crate) data_section: DataSection,
+    pub(crate) prologue: AllocatedAbstractInstructionSet,
+    pub(crate) functions: Vec<AllocatedAbstractInstructionSet>,
+    pub(crate) entries: Vec<(SelectorOpt, Label, FnName, Option<DeclRefFunction>)>,
+}
 
 impl AllocatedProgram {
     pub(crate) fn into_final_program(mut self) -> Result<FinalProgram, crate::CompileError> {
@@ -29,7 +49,7 @@ impl AllocatedProgram {
             })
             .collect();
 
-        Ok(FinalProgram::Fuel {
+        Ok(FinalProgram {
             kind: self.kind,
             data_section: self.data_section,
             ops,
diff --git a/sway-core/src/asm_generation/fuel/programs/final.rs b/sway-core/src/asm_generation/fuel/programs/final.rs
new file mode 100644
index 00000000000..b91021612b0
--- /dev/null
+++ b/sway-core/src/asm_generation/fuel/programs/final.rs
@@ -0,0 +1,99 @@
+use crate::{
+    asm_generation::{
+        fuel::data_section::DataSection, instruction_set::InstructionSet, ProgramKind,
+    },
+    asm_lang::allocated_ops::AllocatedOp,
+    decl_engine::DeclRefFunction,
+    FinalizedAsm, FinalizedEntry,
+};
+
+use super::{FnName, ImmOffset, SelectorOpt};
+
+/// A [FinalProgram] represents code which may be serialized to VM bytecode.
+pub(crate) struct FinalProgram {
+    pub(crate) kind: ProgramKind,
+    pub(crate) data_section: DataSection,
+    pub(crate) ops: Vec<AllocatedOp>,
+    pub(crate) entries: Vec<(SelectorOpt, ImmOffset, FnName, Option<DeclRefFunction>)>,
+}
+
+impl FinalProgram {
+    pub(crate) fn finalize(self) -> FinalizedAsm {
+        let FinalProgram {
+            kind,
+            data_section,
+            ops,
+            entries,
+        } = self;
+
+        FinalizedAsm {
+            data_section,
+            program_section: InstructionSet::Fuel { ops },
+            program_kind: kind,
+            entries: entries
+                .into_iter()
+                .map(|(selector, imm, fn_name, test_decl_ref)| FinalizedEntry {
+                    imm,
+                    fn_name,
+                    selector,
+                    test_decl_ref,
+                })
+                .collect(),
+            abi: None,
+        }
+    }
+}
+
+impl std::fmt::Display for FinalProgram {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        let FinalProgram {
+            kind,
+            data_section,
+            ops,
+            ..
+        } = self;
+
+        writeln!(f, ";; Program kind: {:?}", kind)?;
+        writeln!(
+            f,
+            ".program:\n{}\n{}",
+            ops.iter()
+                .map(|x| format!("{x}"))
+                .collect::<Vec<_>>()
+                .join("\n"),
+            data_section,
+        )
+    }
+}
+
+// }
+// FinalProgram::Evm { ops, .. } => {
+//     let mut separator = etk_dasm::blocks::basic::Separator::new();
+
+//     let ctx = etk_asm::ops::Context::new();
+//     let concretized_ops = ops
+//         .iter()
+//         .map(|op| etk_asm::disasm::Offset {
+//             item: op.clone().concretize(ctx).unwrap(),
+//             offset: 0,
+//         })
+//         .collect::<Vec<_>>();
+//     separator.push_all(concretized_ops);
+
+//     let basic_blocks = separator.take().into_iter().chain(separator.finish());
+
+//     for block in basic_blocks {
+//         let mut offset = block.offset;
+//         for op in block.ops {
+//             let len = op.size();
+//             let off = etk_asm::disasm::Offset::new(offset, etk_dasm::DisplayOp(op));
+//             offset += len;
+
+//             writeln!(f, "{}", off.item)?;
+//         }
+//     }
+
+//     Ok(())
+// }
+// FinalProgram::MidenVM { ops } => write!(f, "{ops:?}"),
+// }
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
index ffde0c3eb4e..ff2d0708c5d 100644
--- 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
@@ -6,13 +6,16 @@ pub use miden_op::MidenAsmOp;
 
 use crate::{
     asm_generation::{
-        asm_builder::{AsmBuilder, AsmBuilderResult},
+        asm_builder::AsmBuilder,
         from_ir::StateAccessType,
+        fuel::data_section::DataSection,
+        instruction_set::InstructionSet,
         miden_vm::miden_vm_asm_builder::miden_op::{MidenStackValue, Push},
-        ProgramKind,
+        FinalizedAsm, ProgramKind,
     },
     asm_lang::Label,
     metadata::MetadataManager,
+    BuildConfig,
 };
 
 use sway_error::{
@@ -126,10 +129,6 @@ impl<'ir, 'eng> AsmBuilder for MidenVMAsmBuilder<'ir, 'eng> {
         self.compile_function(handler, 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());
@@ -137,6 +136,29 @@ impl<'ir, 'eng> AsmBuilder for MidenVMAsmBuilder<'ir, 'eng> {
             labels
         })
     }
+
+    fn compile_configurable(&mut self, _config: &ConfigurableContent) {
+        todo!()
+    }
+
+    fn finalize(
+        self,
+        _handler: &Handler,
+        _build_config: Option<&BuildConfig>,
+        _fallback_fn: Option<Label>,
+    ) -> Result<FinalizedAsm, ErrorEmitted> {
+        // 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());
+
+        let final_program = MidenFinalProgram { ops: program };
+        Ok(final_program.finalize())
+    }
 }
 
 #[allow(unused_variables)]
@@ -156,11 +178,6 @@ impl<'ir, 'eng> MidenVMAsmBuilder<'ir, 'eng> {
         }
     }
 
-    #[allow(unreachable_code)]
-    pub fn finalize(&self) -> AsmBuilderResult {
-        AsmBuilderResult::MidenVM(MidenVMAsmBuilderResult { ops: todo!() })
-    }
-
     fn generate_constructor(
         &self,
         is_payable: bool,
@@ -197,19 +214,6 @@ impl<'ir, 'eng> MidenVMAsmBuilder<'ir, 'eng> {
         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()
@@ -320,6 +324,7 @@ impl<'ir, 'eng> MidenVMAsmBuilder<'ir, 'eng> {
                     indices,
                 } => todo!(),
                 InstOp::GetLocal(local_var) => todo!(),
+                InstOp::GetConfig(_, name) => todo!(),
                 InstOp::IntToPtr(val, _) => todo!(),
                 InstOp::Load(src_val) => todo!(),
                 InstOp::MemCopyBytes {
@@ -628,7 +633,6 @@ impl<'ir, 'eng> MidenVMAsmBuilder<'ir, 'eng> {
                 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
@@ -679,3 +683,22 @@ impl ToMidenBytecode for Vec<DirectOp> {
             .join("\n")
     }
 }
+
+struct MidenFinalProgram {
+    ops: Vec<crate::asm_generation::DirectOp>,
+}
+
+impl MidenFinalProgram {
+    fn finalize(self) -> FinalizedAsm {
+        FinalizedAsm {
+            data_section: DataSection {
+                ..Default::default()
+            },
+            program_section: InstructionSet::MidenVM { ops: self.ops },
+            // should this be a script? :think:
+            program_kind: ProgramKind::Script,
+            entries: vec![],
+            abi: None, /* TODO? */
+        }
+    }
+}
diff --git a/sway-core/src/asm_generation/miden_vm.rs b/sway-core/src/asm_generation/miden_vm/mod.rs
similarity index 100%
rename from sway-core/src/asm_generation/miden_vm.rs
rename to sway-core/src/asm_generation/miden_vm/mod.rs
diff --git a/sway-core/src/asm_generation/mod.rs b/sway-core/src/asm_generation/mod.rs
index ae16a346f60..3e2a78bfda5 100644
--- a/sway-core/src/asm_generation/mod.rs
+++ b/sway-core/src/asm_generation/mod.rs
@@ -8,9 +8,14 @@ pub use miden_vm::*;
 pub mod from_ir;
 pub mod fuel;
 pub mod instruction_set;
-mod programs;
 
 mod finalized_asm;
 pub use finalized_asm::{CompiledBytecode, FinalizedAsm, FinalizedEntry};
 
-pub(crate) use programs::ProgramKind;
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub enum ProgramKind {
+    Contract,
+    Library,
+    Predicate,
+    Script,
+}
diff --git a/sway-core/src/asm_generation/programs.rs b/sway-core/src/asm_generation/programs.rs
deleted file mode 100644
index 930751d5cba..00000000000
--- a/sway-core/src/asm_generation/programs.rs
+++ /dev/null
@@ -1,77 +0,0 @@
-mod r#abstract;
-mod allocated;
-mod r#final;
-
-use super::fuel::{
-    abstract_instruction_set::AbstractInstructionSet,
-    allocated_abstract_instruction_set::AllocatedAbstractInstructionSet, data_section::DataSection,
-    register_sequencer::RegisterSequencer,
-};
-
-use crate::{
-    asm_lang::{allocated_ops::AllocatedOp, Label},
-    decl_engine::DeclRefFunction,
-    ExperimentalFlags,
-};
-
-type SelectorOpt = Option<[u8; 4]>;
-type FnName = String;
-type ImmOffset = u64;
-
-#[derive(Clone, Copy, Debug, Eq, PartialEq)]
-pub enum ProgramKind {
-    Contract,
-    Library,
-    Predicate,
-    Script,
-}
-
-/// An [AbstractProgram] represents code generated by the compilation from IR, with virtual registers
-/// and abstract control flow.
-///
-/// Use `AbstractProgram::to_allocated_program()` to perform register allocation.
-///
-pub(super) struct AbstractProgram {
-    kind: ProgramKind,
-    data_section: DataSection,
-    entries: Vec<AbstractEntry>,
-    non_entries: Vec<AbstractInstructionSet>,
-    reg_seqr: RegisterSequencer,
-    experimental: ExperimentalFlags,
-}
-
-/// The entry point of an abstract program.
-pub(super) struct AbstractEntry {
-    pub(super) selector: SelectorOpt,
-    pub(super) label: Label,
-    pub(super) ops: AbstractInstructionSet,
-    pub(super) name: FnName,
-    pub(super) test_decl_ref: Option<DeclRefFunction>,
-}
-
-/// An [AllocatedProgram] represents code which has allocated registers but still has abstract
-/// control flow.
-pub(super) struct AllocatedProgram {
-    kind: ProgramKind,
-    data_section: DataSection,
-    prologue: AllocatedAbstractInstructionSet,
-    functions: Vec<AllocatedAbstractInstructionSet>,
-    entries: Vec<(SelectorOpt, Label, FnName, Option<DeclRefFunction>)>,
-}
-
-/// A [FinalProgram] represents code which may be serialized to VM bytecode.
-pub(super) enum FinalProgram {
-    Fuel {
-        kind: ProgramKind,
-        data_section: DataSection,
-        ops: Vec<AllocatedOp>,
-        entries: Vec<(SelectorOpt, ImmOffset, FnName, Option<DeclRefFunction>)>,
-    },
-    Evm {
-        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
deleted file mode 100644
index ec9968fd485..00000000000
--- a/sway-core/src/asm_generation/programs/final.rs
+++ /dev/null
@@ -1,107 +0,0 @@
-use super::FinalProgram;
-
-use crate::{
-    asm_generation::{
-        fuel::data_section::DataSection, instruction_set::InstructionSet, ProgramABI,
-    },
-    FinalizedAsm, FinalizedEntry,
-};
-
-impl FinalProgram {
-    pub(crate) fn finalize(self) -> FinalizedAsm {
-        match self {
-            FinalProgram::Fuel {
-                kind,
-                data_section,
-                ops,
-                entries,
-            } => FinalizedAsm {
-                data_section,
-                program_section: InstructionSet::Fuel { ops },
-                program_kind: kind,
-                entries: entries
-                    .into_iter()
-                    .map(|(selector, imm, fn_name, test_decl_ref)| FinalizedEntry {
-                        imm,
-                        fn_name,
-                        selector,
-                        test_decl_ref,
-                    })
-                    .collect(),
-                abi: None,
-            },
-            FinalProgram::Evm { ops, abi } => FinalizedAsm {
-                data_section: DataSection {
-                    ..Default::default()
-                },
-                program_section: InstructionSet::Evm { ops },
-                program_kind: super::ProgramKind::Script,
-                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? */
-            },
-        }
-    }
-}
-
-impl std::fmt::Display for FinalProgram {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        match self {
-            FinalProgram::Fuel {
-                kind,
-                data_section,
-                ops,
-                ..
-            } => {
-                writeln!(f, ";; Program kind: {:?}", kind)?;
-                writeln!(
-                    f,
-                    ".program:\n{}\n{}",
-                    ops.iter()
-                        .map(|x| format!("{x}"))
-                        .collect::<Vec<_>>()
-                        .join("\n"),
-                    data_section,
-                )
-            }
-            FinalProgram::Evm { ops, .. } => {
-                let mut separator = etk_dasm::blocks::basic::Separator::new();
-
-                let ctx = etk_asm::ops::Context::new();
-                let concretized_ops = ops
-                    .iter()
-                    .map(|op| etk_asm::disasm::Offset {
-                        item: op.clone().concretize(ctx).unwrap(),
-                        offset: 0,
-                    })
-                    .collect::<Vec<_>>();
-                separator.push_all(concretized_ops);
-
-                let basic_blocks = separator.take().into_iter().chain(separator.finish());
-
-                for block in basic_blocks {
-                    let mut offset = block.offset;
-                    for op in block.ops {
-                        let len = op.size();
-                        let off = etk_asm::disasm::Offset::new(offset, etk_dasm::DisplayOp(op));
-                        offset += len;
-
-                        writeln!(f, "{}", off.item)?;
-                    }
-                }
-
-                Ok(())
-            }
-            FinalProgram::MidenVM { ops } => write!(f, "{ops:?}"),
-        }
-    }
-}
diff --git a/sway-core/src/asm_lang/allocated_ops.rs b/sway-core/src/asm_lang/allocated_ops.rs
index 54315b69aac..b6f78fec72b 100644
--- a/sway-core/src/asm_lang/allocated_ops.rs
+++ b/sway-core/src/asm_lang/allocated_ops.rs
@@ -18,6 +18,7 @@ use crate::{
     fuel_prelude::fuel_asm::{self, op},
 };
 use either::Either;
+use fuel_vm::fuel_asm::{op::ADDI, Imm12};
 use std::fmt::{self, Write};
 use sway_types::span::Span;
 
@@ -241,6 +242,7 @@ pub(crate) enum AllocatedOpcode {
     BLOB(VirtualImmediate24),
     DataSectionOffsetPlaceholder,
     LoadDataId(AllocatedRegister, DataId),
+    AddrDataId(AllocatedRegister, DataId),
     Undefined,
 }
 
@@ -360,6 +362,7 @@ impl AllocatedOpcode {
             BLOB(_imm) => vec![],
             DataSectionOffsetPlaceholder => vec![],
             LoadDataId(r1, _i) => vec![r1],
+            AddrDataId(r1, _i) => vec![r1],
             Undefined => vec![],
         })
         .into_iter()
@@ -488,6 +491,7 @@ impl fmt::Display for AllocatedOpcode {
                 )
             }
             LoadDataId(a, b) => write!(fmtr, "load {a} {b}"),
+            AddrDataId(a, b) => write!(fmtr, "addr {a} {b}"),
             Undefined => write!(fmtr, "undefined op"),
         }
     }
@@ -686,11 +690,26 @@ impl AllocatedOp {
                     offset_from_instr_start,
                 ))
             }
+            AddrDataId(a, b) => return Either::Left(addr_of(a, b, data_section)),
             Undefined => unreachable!("Sway cannot generate undefined ASM opcodes"),
         }])
     }
 }
 
+/// Address of a data section item
+fn addr_of(
+    dest: &AllocatedRegister,
+    data_id: &DataId,
+    data_section: &mut DataSection,
+) -> Vec<fuel_asm::Instruction> {
+    let offset_bytes = data_section.data_id_to_offset(data_id) as u64;
+    vec![fuel_asm::Instruction::ADDI(ADDI::new(
+        dest.to_reg_id(),
+        fuel_asm::RegId::new(DATA_SECTION_REGISTER),
+        Imm12::new(offset_bytes as u16),
+    ))]
+}
+
 /// Converts a virtual load word instruction which uses data labels into one which uses
 /// actual bytewise offsets for use in bytecode.
 /// Returns one op if the type is less than one word big, but two ops if it has to construct
diff --git a/sway-core/src/asm_lang/mod.rs b/sway-core/src/asm_lang/mod.rs
index be1b0df0ef2..afe223f68c3 100644
--- a/sway-core/src/asm_lang/mod.rs
+++ b/sway-core/src/asm_lang/mod.rs
@@ -1105,6 +1105,7 @@ impl fmt::Display for VirtualOp {
             BLOB(a) => write!(fmtr, "blob {a}"),
             DataSectionOffsetPlaceholder => write!(fmtr, "data section offset placeholder"),
             LoadDataId(a, b) => write!(fmtr, "load {a} {b}"),
+            AddrDataId(a, b) => write!(fmtr, "addr {a} {b}"),
             Undefined => write!(fmtr, "undefined op"),
         }
     }
diff --git a/sway-core/src/asm_lang/virtual_ops.rs b/sway-core/src/asm_lang/virtual_ops.rs
index e2d11328fd1..3a636083c35 100644
--- a/sway-core/src/asm_lang/virtual_ops.rs
+++ b/sway-core/src/asm_lang/virtual_ops.rs
@@ -203,6 +203,7 @@ pub(crate) enum VirtualOp {
     // subtly complex: $rB is in bytes and points to some mem address. The immediate
     // third argument is a _word_ offset from that byte address.
     LoadDataId(VirtualRegister, DataId),
+    AddrDataId(VirtualRegister, DataId),
     Undefined,
 }
 
@@ -314,6 +315,8 @@ impl VirtualOp {
             BLOB(_imm) => vec![],
             DataSectionOffsetPlaceholder => vec![],
             LoadDataId(r1, _i) => vec![r1],
+            AddrDataId(r1, _) => vec![r1],
+
             Undefined => vec![],
         })
         .into_iter()
@@ -370,6 +373,7 @@ impl VirtualOp {
             | GTF(_, _, _)
             // Virtual OPs
             | LoadDataId(_, _)
+            | AddrDataId(_, _)
              => self.def_registers().iter().any(|vreg| matches!(vreg, VirtualRegister::Constant(_))),
             // Memory write and jump
             WQOP(_, _, _, _)
@@ -527,6 +531,7 @@ impl VirtualOp {
             | BLOB(_)
             | DataSectionOffsetPlaceholder
             | LoadDataId(_, _)
+            | AddrDataId(_, _)
             | Undefined => vec![],
         })
         .into_iter()
@@ -640,6 +645,8 @@ impl VirtualOp {
             BLOB(_imm) => vec![],
             DataSectionOffsetPlaceholder => vec![],
             LoadDataId(_r1, _i) => vec![],
+            AddrDataId(_r1, _i) => vec![],
+
             Undefined => vec![],
         })
         .into_iter()
@@ -754,6 +761,7 @@ impl VirtualOp {
             /* Non-VM Instructions */
             BLOB(_imm) => vec![],
             LoadDataId(r1, _i) => vec![r1],
+            AddrDataId(r1, _i) => vec![r1],
             DataSectionOffsetPlaceholder => vec![],
             Undefined => vec![],
         })
@@ -1180,6 +1188,7 @@ impl VirtualOp {
             BLOB(i) => Self::BLOB(i.clone()),
             DataSectionOffsetPlaceholder => Self::DataSectionOffsetPlaceholder,
             LoadDataId(r1, i) => Self::LoadDataId(update_reg(reg_to_reg_map, r1), i.clone()),
+            AddrDataId(r1, i) => Self::AddrDataId(update_reg(reg_to_reg_map, r1), i.clone()),
             Undefined => Self::Undefined,
         }
     }
@@ -1638,6 +1647,9 @@ impl VirtualOp {
             LoadDataId(reg1, label) => {
                 AllocatedOpcode::LoadDataId(map_reg(&mapping, reg1), label.clone())
             }
+            AddrDataId(reg1, label) => {
+                AllocatedOpcode::AddrDataId(map_reg(&mapping, reg1), label.clone())
+            }
             Undefined => AllocatedOpcode::Undefined,
         }
     }
diff --git a/sway-core/src/control_flow_analysis/analyze_return_paths.rs b/sway-core/src/control_flow_analysis/analyze_return_paths.rs
index 322079f7f67..ae18d50f7e5 100644
--- a/sway-core/src/control_flow_analysis/analyze_return_paths.rs
+++ b/sway-core/src/control_flow_analysis/analyze_return_paths.rs
@@ -206,7 +206,9 @@ fn connect_declaration<'eng: 'cfg, 'cfg>(
         | ty::TyDecl::TypeAliasDecl(_)
         | ty::TyDecl::TraitTypeDecl(_)
         | ty::TyDecl::GenericTypeForFunctionScope(_) => Ok(leaves.to_vec()),
-        ty::TyDecl::VariableDecl(_) | ty::TyDecl::ConstantDecl(_) => {
+        ty::TyDecl::VariableDecl(_)
+        | ty::TyDecl::ConstantDecl(_)
+        | ty::TyDecl::ConfigurableDecl(_) => {
             let entry_node = graph.add_node(ControlFlowGraphNode::from_node(node));
             for leaf in leaves {
                 graph.add_edge(*leaf, entry_node, "".into());
diff --git a/sway-core/src/control_flow_analysis/dead_code_analysis.rs b/sway-core/src/control_flow_analysis/dead_code_analysis.rs
index 15a2b7fa69f..5fc719a81be 100644
--- a/sway-core/src/control_flow_analysis/dead_code_analysis.rs
+++ b/sway-core/src/control_flow_analysis/dead_code_analysis.rs
@@ -564,6 +564,30 @@ fn connect_declaration<'eng: 'cfg, 'cfg>(
                 Ok(leaves.to_vec())
             }
         }
+        ty::TyDecl::ConfigurableDecl(ty::ConfigurableDecl { decl_id, .. }) => {
+            let config_decl = decl_engine.get_configurable(decl_id);
+            let ty::TyConfigurableDecl {
+                call_path, value, ..
+            } = &*config_decl;
+            graph
+                .namespace
+                .insert_global_constant(call_path.suffix.clone(), entry_node);
+            if let Some(value) = &value {
+                connect_expression(
+                    engines,
+                    &value.expression,
+                    graph,
+                    &[entry_node],
+                    exit_node,
+                    "constant declaration expression",
+                    tree_type,
+                    value.span.clone(),
+                    options,
+                )
+            } else {
+                Ok(leaves.to_vec())
+            }
+        }
         ty::TyDecl::FunctionDecl(ty::FunctionDecl { decl_id, .. }) => {
             let fn_decl = decl_engine.get_function(decl_id);
             connect_typed_fn_decl(
@@ -1462,6 +1486,20 @@ fn connect_expression<'eng: 'cfg, 'cfg>(
             }
             Ok(vec![node])
         }
+        ConfigurableExpression { const_decl, .. } => {
+            let node = if let Some(node) = graph.namespace.get_global_constant(const_decl.name()) {
+                *node
+            } else if let Some(node) = graph.namespace.get_configurable(const_decl) {
+                *node
+            } else {
+                return Ok(leaves.to_vec());
+            };
+
+            for leaf in leaves {
+                graph.add_edge(*leaf, node, "".into());
+            }
+            Ok(vec![node])
+        }
         EnumInstantiation {
             enum_ref,
             variant_name,
@@ -2460,6 +2498,9 @@ fn allow_dead_code_ast_node(decl_engine: &DeclEngine, node: &ty::TyAstNode) -> b
             ty::TyDecl::ConstantDecl(ty::ConstantDecl { decl_id, .. }) => {
                 allow_dead_code(decl_engine.get_constant(decl_id).attributes.clone())
             }
+            ty::TyDecl::ConfigurableDecl(ty::ConfigurableDecl { decl_id, .. }) => {
+                allow_dead_code(decl_engine.get_configurable(decl_id).attributes.clone())
+            }
             ty::TyDecl::TraitTypeDecl(ty::TraitTypeDecl { decl_id, .. }) => {
                 allow_dead_code(decl_engine.get_type(decl_id).attributes.clone())
             }
diff --git a/sway-core/src/control_flow_analysis/flow_graph/namespace.rs b/sway-core/src/control_flow_analysis/flow_graph/namespace.rs
index d07113e153b..d57eba27e57 100644
--- a/sway-core/src/control_flow_analysis/flow_graph/namespace.rs
+++ b/sway-core/src/control_flow_analysis/flow_graph/namespace.rs
@@ -2,7 +2,7 @@ use super::{EntryPoint, ExitPoint};
 use crate::{
     language::{
         parsed::TreeType,
-        ty::{self, TyConstantDecl, TyFunctionDecl, TyFunctionSig},
+        ty::{self, TyConfigurableDecl, TyConstantDecl, TyFunctionDecl, TyFunctionSig},
         CallPath,
     },
     type_system::TypeInfo,
@@ -83,9 +83,15 @@ impl ControlFlowNamespace {
         self.function_namespace
             .insert((ident, TyFunctionSig::from_fn_decl(fn_decl)), entry);
     }
+
     pub(crate) fn get_constant(&self, const_decl: &TyConstantDecl) -> Option<&NodeIndex> {
         self.const_namespace.get(&const_decl.name().clone())
     }
+
+    pub(crate) fn get_configurable(&self, _const_decl: &TyConfigurableDecl) -> Option<&NodeIndex> {
+        todo!()
+    }
+
     #[allow(dead_code)]
     pub(crate) fn insert_constant(
         &mut self,
@@ -95,9 +101,11 @@ impl ControlFlowNamespace {
         self.const_namespace
             .insert(const_decl.name().clone(), declaration_node);
     }
+
     pub(crate) fn get_global_constant(&self, ident: &Ident) -> Option<&NodeIndex> {
         self.const_namespace.get(ident)
     }
+
     pub(crate) fn insert_global_constant(
         &mut self,
         const_name: Ident,
@@ -105,6 +113,7 @@ impl ControlFlowNamespace {
     ) {
         self.const_namespace.insert(const_name, declaration_node);
     }
+
     pub(crate) fn insert_enum(&mut self, enum_name: Ident, enum_decl_index: NodeIndex) {
         self.enum_namespace
             .insert(enum_name.into(), (enum_decl_index, HashMap::new()));
diff --git a/sway-core/src/decl_engine/associated_item_decl_id.rs b/sway-core/src/decl_engine/associated_item_decl_id.rs
index ea91c1730ed..19560eee9fe 100644
--- a/sway-core/src/decl_engine/associated_item_decl_id.rs
+++ b/sway-core/src/decl_engine/associated_item_decl_id.rs
@@ -3,7 +3,7 @@ use sway_types::{Named, Span, Spanned};
 
 use crate::{
     decl_engine::*,
-    engine_threading::DisplayWithEngines,
+    engine_threading::{DebugWithEngines, DisplayWithEngines},
     language::ty::{self, TyFunctionDecl},
     Engines,
 };
@@ -133,6 +133,38 @@ impl DisplayWithEngines for AssociatedItemDeclId {
     }
 }
 
+impl DebugWithEngines for AssociatedItemDeclId {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>, engines: &Engines) -> std::fmt::Result {
+        match self {
+            Self::TraitFn(decl_id) => {
+                let decl = engines.de().get(decl_id);
+                write!(f, "decl(trait function {:?})", engines.help_out(decl))
+            }
+            Self::Function(decl_id) => {
+                write!(
+                    f,
+                    "decl(function {:?})",
+                    engines.help_out(engines.de().get(decl_id))
+                )
+            }
+            Self::Constant(decl_id) => {
+                write!(
+                    f,
+                    "decl(constant {:?})",
+                    engines.help_out(engines.de().get(decl_id))
+                )
+            }
+            Self::Type(decl_id) => {
+                write!(
+                    f,
+                    "decl(type {:?})",
+                    engines.help_out(engines.de().get(decl_id))
+                )
+            }
+        }
+    }
+}
+
 impl TryFrom<DeclRefMixedFunctional> for DeclRefFunction {
     type Error = CompileError;
     fn try_from(value: DeclRefMixedFunctional) -> Result<Self, Self::Error> {
diff --git a/sway-core/src/decl_engine/engine.rs b/sway-core/src/decl_engine/engine.rs
index f0ded945908..c4c9b8acf48 100644
--- a/sway-core/src/decl_engine/engine.rs
+++ b/sway-core/src/decl_engine/engine.rs
@@ -12,8 +12,9 @@ use crate::{
     decl_engine::*,
     engine_threading::*,
     language::ty::{
-        self, TyAbiDecl, TyConstantDecl, TyEnumDecl, TyFunctionDecl, TyImplTrait, TyStorageDecl,
-        TyStructDecl, TyTraitDecl, TyTraitFn, TyTraitType, TyTypeAliasDecl,
+        self, TyAbiDecl, TyConfigurableDecl, TyConstantDecl, TyEnumDecl, TyFunctionDecl,
+        TyImplTrait, TyStorageDecl, TyStructDecl, TyTraitDecl, TyTraitFn, TyTraitType,
+        TyTypeAliasDecl,
     },
 };
 
@@ -29,6 +30,7 @@ pub struct DeclEngine {
     storage_slab: ConcurrentSlab<TyStorageDecl>,
     abi_slab: ConcurrentSlab<TyAbiDecl>,
     constant_slab: ConcurrentSlab<TyConstantDecl>,
+    configurable_slab: ConcurrentSlab<TyConfigurableDecl>,
     enum_slab: ConcurrentSlab<TyEnumDecl>,
     type_alias_slab: ConcurrentSlab<TyTypeAliasDecl>,
 
@@ -47,6 +49,7 @@ impl Clone for DeclEngine {
             storage_slab: self.storage_slab.clone(),
             abi_slab: self.abi_slab.clone(),
             constant_slab: self.constant_slab.clone(),
+            configurable_slab: self.configurable_slab.clone(),
             enum_slab: self.enum_slab.clone(),
             type_alias_slab: self.type_alias_slab.clone(),
             parents: RwLock::new(self.parents.read().clone()),
@@ -107,6 +110,7 @@ decl_engine_get!(struct_slab, ty::TyStructDecl);
 decl_engine_get!(storage_slab, ty::TyStorageDecl);
 decl_engine_get!(abi_slab, ty::TyAbiDecl);
 decl_engine_get!(constant_slab, ty::TyConstantDecl);
+decl_engine_get!(configurable_slab, ty::TyConfigurableDecl);
 decl_engine_get!(enum_slab, ty::TyEnumDecl);
 decl_engine_get!(type_alias_slab, ty::TyTypeAliasDecl);
 
@@ -143,6 +147,7 @@ decl_engine_insert!(struct_slab, ty::TyStructDecl);
 decl_engine_insert!(storage_slab, ty::TyStorageDecl);
 decl_engine_insert!(abi_slab, ty::TyAbiDecl);
 decl_engine_insert!(constant_slab, ty::TyConstantDecl);
+decl_engine_insert!(configurable_slab, ty::TyConfigurableDecl);
 decl_engine_insert!(enum_slab, ty::TyEnumDecl);
 decl_engine_insert!(type_alias_slab, ty::TyTypeAliasDecl);
 
@@ -164,6 +169,7 @@ decl_engine_replace!(struct_slab, ty::TyStructDecl);
 decl_engine_replace!(storage_slab, ty::TyStorageDecl);
 decl_engine_replace!(abi_slab, ty::TyAbiDecl);
 decl_engine_replace!(constant_slab, ty::TyConstantDecl);
+decl_engine_replace!(configurable_slab, ty::TyConfigurableDecl);
 decl_engine_replace!(enum_slab, ty::TyEnumDecl);
 decl_engine_replace!(type_alias_slab, ty::TyTypeAliasDecl);
 
@@ -181,6 +187,7 @@ decl_engine_index!(struct_slab, ty::TyStructDecl);
 decl_engine_index!(storage_slab, ty::TyStorageDecl);
 decl_engine_index!(abi_slab, ty::TyAbiDecl);
 decl_engine_index!(constant_slab, ty::TyConstantDecl);
+decl_engine_index!(configurable_slab, ty::TyConfigurableDecl);
 decl_engine_index!(enum_slab, ty::TyEnumDecl);
 decl_engine_index!(type_alias_slab, ty::TyTypeAliasDecl);
 
@@ -226,6 +233,7 @@ decl_engine_clear_module!(
     storage_slab, ty::TyStorageDecl;
     abi_slab, ty::TyAbiDecl;
     constant_slab, ty::TyConstantDecl;
+    configurable_slab, ty::TyConfigurableDecl;
     enum_slab, ty::TyEnumDecl;
     type_alias_slab, ty::TyTypeAliasDecl;
 );
@@ -407,6 +415,18 @@ impl DeclEngine {
         self.get(index)
     }
 
+    /// Friendly helper method for calling the `get` method from the
+    /// implementation of [DeclEngineGet] for [DeclEngine]
+    ///
+    /// Calling [DeclEngine][get] directly is equivalent to this method, but
+    /// this method adds additional syntax that some users may find helpful.
+    pub fn get_configurable<I>(&self, index: &I) -> Arc<ty::TyConfigurableDecl>
+    where
+        DeclEngine: DeclEngineGet<I, ty::TyConfigurableDecl>,
+    {
+        self.get(index)
+    }
+
     /// Friendly helper method for calling the `get` method from the
     /// implementation of [DeclEngineGet] for [DeclEngine]
     ///
diff --git a/sway-core/src/decl_engine/mapping.rs b/sway-core/src/decl_engine/mapping.rs
index ddd57ab5a47..ebfa21e8ce0 100644
--- a/sway-core/src/decl_engine/mapping.rs
+++ b/sway-core/src/decl_engine/mapping.rs
@@ -17,7 +17,7 @@ type DestinationDecl = AssociatedItemDeclId;
 /// and a [DestinationDecl] (RHS).
 #[derive(Clone)]
 pub struct DeclMapping {
-    mapping: Vec<(SourceDecl, DestinationDecl)>,
+    pub mapping: Vec<(SourceDecl, DestinationDecl)>,
 }
 
 impl fmt::Display for DeclMapping {
@@ -61,21 +61,14 @@ impl fmt::Debug for DeclMapping {
 
 impl DebugWithEngines for DeclMapping {
     fn fmt(&self, f: &mut fmt::Formatter<'_>, engines: &Engines) -> fmt::Result {
-        write!(
-            f,
-            "DeclMapping {{ {} }}",
-            self.mapping
-                .iter()
-                .map(|(source_type, dest_type)| {
-                    format!(
-                        "{} -> {}",
-                        engines.help_out(source_type.0.clone()),
-                        engines.help_out(dest_type)
-                    )
-                })
-                .collect::<Vec<_>>()
-                .join(", ")
-        )
+        f.write_str("DeclMapping ").unwrap();
+        let mut map = f.debug_map();
+        for (source_type, dest_type) in self.mapping.iter() {
+            let key = engines.help_out(source_type.0.clone());
+            let value = engines.help_out(dest_type);
+            map.entry(&key, &value);
+        }
+        map.finish()
     }
 }
 
diff --git a/sway-core/src/decl_engine/parsed_engine.rs b/sway-core/src/decl_engine/parsed_engine.rs
index 463117735fd..963466c001a 100644
--- a/sway-core/src/decl_engine/parsed_engine.rs
+++ b/sway-core/src/decl_engine/parsed_engine.rs
@@ -2,9 +2,9 @@ use crate::{
     concurrent_slab::ConcurrentSlab,
     decl_engine::*,
     language::parsed::{
-        AbiDeclaration, ConstantDeclaration, EnumDeclaration, FunctionDeclaration, ImplSelf,
-        ImplTrait, StorageDeclaration, StructDeclaration, TraitDeclaration, TraitFn,
-        TraitTypeDeclaration, TypeAliasDeclaration, VariableDeclaration,
+        AbiDeclaration, ConfigurableDeclaration, ConstantDeclaration, EnumDeclaration,
+        FunctionDeclaration, ImplSelf, ImplTrait, StorageDeclaration, StructDeclaration,
+        TraitDeclaration, TraitFn, TraitTypeDeclaration, TypeAliasDeclaration, VariableDeclaration,
     },
 };
 
@@ -27,6 +27,7 @@ pub struct ParsedDeclEngine {
     storage_slab: ConcurrentSlab<StorageDeclaration>,
     abi_slab: ConcurrentSlab<AbiDeclaration>,
     constant_slab: ConcurrentSlab<ConstantDeclaration>,
+    configurable_slab: ConcurrentSlab<ConfigurableDeclaration>,
     enum_slab: ConcurrentSlab<EnumDeclaration>,
     type_alias_slab: ConcurrentSlab<TypeAliasDeclaration>,
 }
@@ -72,6 +73,7 @@ decl_engine_get!(struct_slab, StructDeclaration);
 decl_engine_get!(storage_slab, StorageDeclaration);
 decl_engine_get!(abi_slab, AbiDeclaration);
 decl_engine_get!(constant_slab, ConstantDeclaration);
+decl_engine_get!(configurable_slab, ConfigurableDeclaration);
 decl_engine_get!(enum_slab, EnumDeclaration);
 decl_engine_get!(type_alias_slab, TypeAliasDeclaration);
 
@@ -101,6 +103,7 @@ decl_engine_insert!(struct_slab, StructDeclaration);
 decl_engine_insert!(storage_slab, StorageDeclaration);
 decl_engine_insert!(abi_slab, AbiDeclaration);
 decl_engine_insert!(constant_slab, ConstantDeclaration);
+decl_engine_insert!(configurable_slab, ConfigurableDeclaration);
 decl_engine_insert!(enum_slab, EnumDeclaration);
 decl_engine_insert!(type_alias_slab, TypeAliasDeclaration);
 
@@ -280,6 +283,18 @@ impl ParsedDeclEngine {
         self.get(index)
     }
 
+    /// Friendly helper method for calling the `get` method from the
+    /// implementation of [ParsedDeclEngineGet] for [ParsedDeclEngine]
+    ///
+    /// Calling [ParsedDeclEngine][get] directly is equivalent to this method, but
+    /// this method adds additional syntax that some users may find helpful.
+    pub fn get_configurable<I>(&self, index: &I) -> Arc<ConfigurableDeclaration>
+    where
+        ParsedDeclEngine: ParsedDeclEngineGet<I, ConfigurableDeclaration>,
+    {
+        self.get(index)
+    }
+
     /// Friendly helper method for calling the `get` method from the
     /// implementation of [ParsedDeclEngineGet] for [ParsedDeclEngine]
     ///
diff --git a/sway-core/src/ir_generation.rs b/sway-core/src/ir_generation.rs
index 4506aaec7fb..f5ba90d85e5 100644
--- a/sway-core/src/ir_generation.rs
+++ b/sway-core/src/ir_generation.rs
@@ -7,13 +7,123 @@ mod purity;
 pub mod storage;
 mod types;
 
+use std::collections::HashMap;
+
 use sway_error::error::CompileError;
-use sway_ir::{Context, Kind};
-use sway_types::span::Span;
+use sway_ir::{Context, Function, Kind, Module};
+use sway_types::{span::Span, Ident, Spanned};
 
 pub(crate) use purity::{check_function_purity, PurityEnv};
 
-use crate::{language::ty, Engines, ExperimentalFlags};
+use crate::{
+    language::ty,
+    metadata::MetadataManager,
+    types::{LogId, MessageId},
+    Engines, ExperimentalFlags, TypeId,
+};
+
+#[derive(Default)]
+pub(crate) struct CompiledFunctionCache {
+    recreated_fns: HashMap<(Span, Vec<TypeId>, Vec<TypeId>), Function>,
+}
+
+impl CompiledFunctionCache {
+    #[allow(clippy::too_many_arguments)]
+    fn ty_function_decl_to_unique_function(
+        &mut self,
+        engines: &Engines,
+        context: &mut Context,
+        module: Module,
+        md_mgr: &mut MetadataManager,
+        decl: &ty::TyFunctionDecl,
+        logged_types_map: &HashMap<TypeId, LogId>,
+        messages_types_map: &HashMap<TypeId, MessageId>,
+    ) -> Result<Function, CompileError> {
+        // The compiler inlines everything very lazily.  Function calls include the body of the
+        // callee (i.e., the callee_body arg above). Library functions are provided in an initial
+        // namespace from Forc and when the parser builds the AST (or is it during type checking?)
+        // these function bodies are embedded.
+        //
+        // Here we build little single-use instantiations of the callee and then call them.  Naming
+        // is not yet absolute so we must ensure the function names are unique.
+        //
+
+        // Eventually we need to Do It Properly and inline into the AST only when necessary, and
+        // compile the standard library to an actual module.
+
+        // Get the callee from the cache if we've already compiled it.  We can't insert it with
+        // .entry() since `compile_function()` returns a Result we need to handle.  The key to our
+        // cache, to uniquely identify a function instance, is the span and the type IDs of any
+        // args and type parameters.  It's using the Sway types rather than IR types, which would
+        // be more accurate but also more fiddly.
+
+        let no_span = decl.span().as_str().is_empty();
+        let is_autogenerated = if let Some(s) = decl.span.source_id() {
+            context
+                .source_engine
+                .get_path(s)
+                .starts_with("<autogenerated>")
+        } else {
+            false
+        };
+        let (fn_key, item) = if no_span || is_autogenerated {
+            (None, None)
+        } else {
+            let fn_key = (
+                decl.span(),
+                decl.parameters
+                    .iter()
+                    .map(|p| p.type_argument.type_id)
+                    .collect(),
+                decl.type_parameters.iter().map(|tp| tp.type_id).collect(),
+            );
+
+            (
+                Some(fn_key.clone()),
+                self.recreated_fns.get(&fn_key).copied(),
+            )
+        };
+
+        let new_callee = match item {
+            Some(func) => func,
+            None => {
+                let callee_fn_decl = ty::TyFunctionDecl {
+                    type_parameters: Vec::new(),
+                    name: Ident::new(Span::from_string(format!(
+                        "{}_{}",
+                        decl.name,
+                        context.get_unique_id()
+                    ))),
+                    parameters: decl.parameters.clone(),
+                    ..decl.clone()
+                };
+                let is_entry = false;
+                let new_func = compile::compile_function(
+                    engines,
+                    context,
+                    md_mgr,
+                    module,
+                    &callee_fn_decl,
+                    logged_types_map,
+                    messages_types_map,
+                    is_entry,
+                    None,
+                    self,
+                )
+                .map_err(|mut x| x.pop().unwrap())?
+                .unwrap();
+
+                if let Some(fn_key) = fn_key {
+                    self.recreated_fns.insert(fn_key, new_func);
+                }
+
+                new_func
+            }
+        };
+
+        Ok(new_callee)
+    }
+}
 
 pub fn compile_program<'eng>(
     program: &ty::TyProgram,
@@ -60,6 +170,8 @@ pub fn compile_program<'eng>(
         ty::TyProgramKind::Library { .. } => Kind::Library,
     };
 
+    let mut cache = CompiledFunctionCache::default();
+
     match kind {
         // Predicates and scripts have the same codegen, their only difference is static
         // type-check time checks.
@@ -71,6 +183,7 @@ pub fn compile_program<'eng>(
             &logged_types,
             &messages_types,
             &test_fns,
+            &mut cache,
         ),
         ty::TyProgramKind::Predicate { entry_function, .. } => compile::compile_predicate(
             engines,
@@ -80,6 +193,7 @@ pub fn compile_program<'eng>(
             &logged_types,
             &messages_types,
             &test_fns,
+            &mut cache,
         ),
         ty::TyProgramKind::Contract {
             entry_function,
@@ -94,6 +208,7 @@ pub fn compile_program<'eng>(
             &messages_types,
             &test_fns,
             engines,
+            &mut cache,
         ),
         ty::TyProgramKind::Library { .. } => compile::compile_library(
             engines,
@@ -102,6 +217,7 @@ pub fn compile_program<'eng>(
             &logged_types,
             &messages_types,
             &test_fns,
+            &mut cache,
         ),
     }?;
 
diff --git a/sway-core/src/ir_generation/compile.rs b/sway-core/src/ir_generation/compile.rs
index 1b19e39bef4..d3622f03ca0 100644
--- a/sway-core/src/ir_generation/compile.rs
+++ b/sway-core/src/ir_generation/compile.rs
@@ -12,6 +12,7 @@ use super::{
     const_eval::{compile_const_decl, LookupEnv},
     convert::convert_resolved_typeid,
     function::FnCompiler,
+    CompiledFunctionCache,
 };
 
 use sway_error::{error::CompileError, handler::Handler};
@@ -29,11 +30,23 @@ pub(super) fn compile_script(
     logged_types_map: &HashMap<TypeId, LogId>,
     messages_types_map: &HashMap<TypeId, MessageId>,
     test_fns: &[(Arc<ty::TyFunctionDecl>, DeclRefFunction)],
+    cache: &mut CompiledFunctionCache,
 ) -> Result<Module, Vec<CompileError>> {
     let module = Module::new(context, Kind::Script);
     let mut md_mgr = MetadataManager::default();
 
     compile_constants(engines, context, &mut md_mgr, module, namespace).map_err(|err| vec![err])?;
+    compile_configurables(
+        engines,
+        context,
+        &mut md_mgr,
+        module,
+        namespace,
+        logged_types_map,
+        messages_types_map,
+        cache,
+    )
+    .map_err(|err| vec![err])?;
     compile_entry_function(
         engines,
         context,
@@ -43,6 +56,7 @@ pub(super) fn compile_script(
         logged_types_map,
         messages_types_map,
         None,
+        cache,
     )?;
     compile_tests(
         engines,
@@ -52,6 +66,7 @@ pub(super) fn compile_script(
         logged_types_map,
         messages_types_map,
         test_fns,
+        cache,
     )?;
 
     Ok(module)
@@ -66,11 +81,23 @@ pub(super) fn compile_predicate(
     logged_types: &HashMap<TypeId, LogId>,
     messages_types: &HashMap<TypeId, MessageId>,
     test_fns: &[(Arc<ty::TyFunctionDecl>, DeclRefFunction)],
+    cache: &mut CompiledFunctionCache,
 ) -> Result<Module, Vec<CompileError>> {
     let module = Module::new(context, Kind::Predicate);
     let mut md_mgr = MetadataManager::default();
 
     compile_constants(engines, context, &mut md_mgr, module, namespace).map_err(|err| vec![err])?;
+    compile_configurables(
+        engines,
+        context,
+        &mut md_mgr,
+        module,
+        namespace,
+        logged_types,
+        messages_types,
+        cache,
+    )
+    .map_err(|err| vec![err])?;
     compile_entry_function(
         engines,
         context,
@@ -80,6 +107,7 @@ pub(super) fn compile_predicate(
         &HashMap::new(),
         &HashMap::new(),
         None,
+        cache,
     )?;
     compile_tests(
         engines,
@@ -89,6 +117,7 @@ pub(super) fn compile_predicate(
         logged_types,
         messages_types,
         test_fns,
+        cache,
     )?;
 
     Ok(module)
@@ -105,11 +134,23 @@ pub(super) fn compile_contract(
     messages_types_map: &HashMap<TypeId, MessageId>,
     test_fns: &[(Arc<ty::TyFunctionDecl>, DeclRefFunction)],
     engines: &Engines,
+    cache: &mut CompiledFunctionCache,
 ) -> Result<Module, Vec<CompileError>> {
     let module = Module::new(context, Kind::Contract);
     let mut md_mgr = MetadataManager::default();
 
     compile_constants(engines, context, &mut md_mgr, module, namespace).map_err(|err| vec![err])?;
+    compile_configurables(
+        engines,
+        context,
+        &mut md_mgr,
+        module,
+        namespace,
+        logged_types_map,
+        messages_types_map,
+        cache,
+    )
+    .map_err(|err| vec![err])?;
 
     if let Some(entry_function) = entry_function {
         compile_entry_function(
@@ -121,6 +162,7 @@ pub(super) fn compile_contract(
             logged_types_map,
             messages_types_map,
             None,
+            cache,
         )?;
     }
 
@@ -133,6 +175,7 @@ pub(super) fn compile_contract(
             logged_types_map,
             messages_types_map,
             engines,
+            cache,
         )?;
     }
 
@@ -150,6 +193,7 @@ pub(super) fn compile_contract(
                     logged_types_map,
                     messages_types_map,
                     engines,
+                    cache,
                 )?;
             }
         }
@@ -163,6 +207,7 @@ pub(super) fn compile_contract(
         logged_types_map,
         messages_types_map,
         test_fns,
+        cache,
     )?;
 
     Ok(module)
@@ -176,6 +221,7 @@ pub(super) fn compile_library(
     logged_types_map: &HashMap<TypeId, LogId>,
     messages_types_map: &HashMap<TypeId, MessageId>,
     test_fns: &[(Arc<ty::TyFunctionDecl>, DeclRefFunction)],
+    cache: &mut CompiledFunctionCache,
 ) -> Result<Module, Vec<CompileError>> {
     let module = Module::new(context, Kind::Library);
     let mut md_mgr = MetadataManager::default();
@@ -189,6 +235,7 @@ pub(super) fn compile_library(
         logged_types_map,
         messages_types_map,
         test_fns,
+        cache,
     )?;
 
     Ok(module)
@@ -230,6 +277,97 @@ pub(crate) fn compile_constants(
     Ok(())
 }
 
+#[allow(clippy::too_many_arguments)]
+pub(crate) fn compile_configurables(
+    engines: &Engines,
+    context: &mut Context,
+    md_mgr: &mut MetadataManager,
+    module: Module,
+    module_ns: &namespace::Module,
+    logged_types_map: &HashMap<TypeId, LogId>,
+    messages_types_map: &HashMap<TypeId, MessageId>,
+    cache: &mut CompiledFunctionCache,
+) -> Result<(), CompileError> {
+    for decl_name in module_ns.current_items().get_all_declared_symbols() {
+        if let Some(ty::TyDecl::ConfigurableDecl(ty::ConfigurableDecl { decl_id, .. })) =
+            module_ns.current_items().symbols.get(decl_name)
+        {
+            let decl = engines.de().get(decl_id);
+
+            let ty = convert_resolved_typeid(
+                engines.te(),
+                engines.de(),
+                context,
+                &decl.type_ascription.type_id,
+                &decl.type_ascription.span,
+            )
+            .unwrap();
+            let ptr_ty = Type::new_ptr(context, ty);
+
+            let constant = super::const_eval::compile_constant_expression_to_constant(
+                engines,
+                context,
+                md_mgr,
+                module,
+                Some(module_ns),
+                None,
+                decl.value.as_ref().unwrap(),
+                false,
+            )
+            .unwrap();
+
+            let opt_metadata = md_mgr.span_to_md(context, &decl.span);
+
+            if context.experimental.new_encoding {
+                let encoded_bytes = match constant.value {
+                    ConstantValue::RawUntypedSlice(bytes) => bytes,
+                    _ => unreachable!(),
+                };
+
+                let decode_fn = engines.de().get(decl.decode_fn.as_ref().unwrap().id());
+                let decode_fn = cache.ty_function_decl_to_unique_function(
+                    engines,
+                    context,
+                    module,
+                    md_mgr,
+                    &decode_fn,
+                    logged_types_map,
+                    messages_types_map,
+                )?;
+
+                let name = decl_name.as_str().to_string();
+                module.add_global_configurable(
+                    context,
+                    name.clone(),
+                    ConfigurableContent::V1 {
+                        name,
+                        ty,
+                        ptr_ty,
+                        encoded_bytes,
+                        decode_fn,
+                        opt_metadata,
+                    },
+                );
+            } else {
+                let name = decl_name.as_str().to_string();
+                module.add_global_configurable(
+                    context,
+                    name.clone(),
+                    ConfigurableContent::V0 {
+                        name,
+                        ty,
+                        ptr_ty,
+                        constant,
+                        opt_metadata,
+                    },
+                );
+            }
+        }
+    }
+
+    Ok(())
+}
+
 #[allow(clippy::too_many_arguments)]
 pub(super) fn compile_function(
     engines: &Engines,
@@ -241,6 +379,7 @@ pub(super) fn compile_function(
     messages_types_map: &HashMap<TypeId, MessageId>,
     is_entry: bool,
     test_decl_ref: Option<DeclRefFunction>,
+    cache: &mut CompiledFunctionCache,
 ) -> Result<Option<Function>, Vec<CompileError>> {
     // Currently monomorphization of generics is inlined into main() and the functions with generic
     // args are still present in the AST declarations, but they can be ignored.
@@ -258,6 +397,7 @@ pub(super) fn compile_function(
             logged_types_map,
             messages_types_map,
             test_decl_ref,
+            cache,
         )
         .map(Some)
     }
@@ -273,6 +413,7 @@ pub(super) fn compile_entry_function(
     logged_types_map: &HashMap<TypeId, LogId>,
     messages_types_map: &HashMap<TypeId, MessageId>,
     test_decl_ref: Option<DeclRefFunction>,
+    cache: &mut CompiledFunctionCache,
 ) -> Result<Function, Vec<CompileError>> {
     let is_entry = true;
     let ast_fn_decl = engines.de().get_function(ast_fn_decl);
@@ -286,6 +427,7 @@ pub(super) fn compile_entry_function(
         messages_types_map,
         is_entry,
         test_decl_ref,
+        cache,
     )
     .map(|f| f.expect("entry point should never contain generics"))
 }
@@ -299,6 +441,7 @@ pub(super) fn compile_tests(
     logged_types_map: &HashMap<TypeId, LogId>,
     messages_types_map: &HashMap<TypeId, MessageId>,
     test_fns: &[(Arc<ty::TyFunctionDecl>, DeclRefFunction)],
+    cache: &mut CompiledFunctionCache,
 ) -> Result<Vec<Function>, Vec<CompileError>> {
     test_fns
         .iter()
@@ -312,6 +455,7 @@ pub(super) fn compile_tests(
                 logged_types_map,
                 messages_types_map,
                 Some(decl_ref.clone()),
+                cache,
             )
         })
         .collect()
@@ -329,6 +473,7 @@ fn compile_fn(
     logged_types_map: &HashMap<TypeId, LogId>,
     messages_types_map: &HashMap<TypeId, MessageId>,
     test_decl_ref: Option<DeclRefFunction>,
+    cache: &mut CompiledFunctionCache,
 ) -> Result<Function, Vec<CompileError>> {
     let type_engine = engines.te();
     let decl_engine = engines.de();
@@ -424,6 +569,7 @@ fn compile_fn(
         func,
         logged_types_map,
         messages_types_map,
+        cache,
     );
     let mut ret_val = compiler.compile_code_block_to_value(context, md_mgr, body)?;
 
@@ -474,6 +620,7 @@ fn compile_abi_method(
     logged_types_map: &HashMap<TypeId, LogId>,
     messages_types_map: &HashMap<TypeId, MessageId>,
     engines: &Engines,
+    cache: &mut CompiledFunctionCache,
 ) -> Result<Function, Vec<CompileError>> {
     // Use the error from .to_fn_selector_value() if possible, else make an CompileError::Internal.
     let handler = Handler::default();
@@ -509,5 +656,6 @@ fn compile_abi_method(
         logged_types_map,
         messages_types_map,
         None,
+        cache,
     )
 }
diff --git a/sway-core/src/ir_generation/const_eval.rs b/sway-core/src/ir_generation/const_eval.rs
index 43ded69d60b..0ead6870973 100644
--- a/sway-core/src/ir_generation/const_eval.rs
+++ b/sway-core/src/ir_generation/const_eval.rs
@@ -8,7 +8,7 @@ use crate::{
     },
     metadata::MetadataManager,
     semantic_analysis::*,
-    AbiEncodeSizeHint, TypeInfo, UnifyCheck,
+    TypeInfo, UnifyCheck,
 };
 
 use super::{
@@ -22,7 +22,6 @@ use sway_error::error::CompileError;
 use sway_ir::{
     constant::{Constant, ConstantValue},
     context::Context,
-    metadata::combine as md_combine,
     module::Module,
     value::Value,
     InstOp, Instruction, Type, TypeContent,
@@ -117,8 +116,7 @@ pub(crate) fn compile_const_decl(
     match (
         env.module
             .get_global_constant(env.context, &call_path.as_vec_string()),
-        env.module
-            .get_global_configurable(env.context, &call_path.as_vec_string()),
+        None,
         env.module_ns,
     ) {
         (Some(const_val), _, _) => Ok(Some(const_val)),
@@ -164,6 +162,7 @@ pub(crate) fn compile_const_decl(
                         is_configurable,
                     )?;
 
+                    assert!(!is_configurable);
                     if !is_configurable {
                         env.module.add_global_constant(
                             env.context,
@@ -171,77 +170,7 @@ pub(crate) fn compile_const_decl(
                             const_val,
                         );
                     } else {
-                        let const_val = if env.context.experimental.new_encoding {
-                            // This expression must be `encode(something)`.
-                            // We want the something here
-                            let value_type = match &value.expression {
-                                ty::TyExpressionVariant::FunctionApplication {
-                                    arguments, ..
-                                } => arguments[0].1.return_type,
-                                _ => unreachable!("non encoded configurable inside encoding v1"),
-                            };
-
-                            let abi_encode_size_hint = env
-                                .engines
-                                .te()
-                                .get(value_type)
-                                .abi_encode_size_hint(env.engines);
-
-                            let buffer_size = match abi_encode_size_hint {
-                                AbiEncodeSizeHint::CustomImpl
-                                | AbiEncodeSizeHint::PotentiallyInfinite => {
-                                    return Err(
-                                        CompileError::CannotBeEvaluatedToConfigurableSizeUnknown {
-                                            span: value.span.clone(),
-                                        },
-                                    );
-                                }
-                                AbiEncodeSizeHint::Exact(len) => len,
-                                AbiEncodeSizeHint::Range(_, max) => max,
-                            };
-
-                            let mut bytes =
-                                match &const_val.get_configurable(env.context).unwrap().value {
-                                    ConstantValue::RawUntypedSlice(bytes) => Some(bytes.clone()),
-                                    _ => {
-                                        return Err(CompileError::NonConstantDeclValue {
-                                            span: call_path.span(),
-                                        });
-                                    }
-                                }
-                                .unwrap();
-
-                            // Pad the encoded buffer if needed
-                            assert!(
-                                buffer_size >= bytes.len(),
-                                "assert {} >= {}",
-                                buffer_size,
-                                bytes.len()
-                            );
-                            let padding_size = buffer_size.saturating_sub(bytes.len());
-                            bytes.extend((0..padding_size).map(|_| 0));
-
-                            let elements = bytes
-                                .iter()
-                                .map(|x| Constant::new_uint(env.context, 8, *x as u64))
-                                .collect();
-                            let array = Constant::new_array(
-                                env.context,
-                                Type::get_uint8(env.context),
-                                elements,
-                            );
-                            let md_idx = const_val.get_metadata(env.context);
-                            Value::new_configurable(env.context, array)
-                                .add_metadatum(env.context, md_idx)
-                        } else {
-                            const_val
-                        };
-
-                        env.module.add_global_configurable(
-                            env.context,
-                            call_path.as_vec_string().to_vec(),
-                            const_val,
-                        );
+                        unreachable!()
                     }
                     Ok(Some(const_val))
                 }
@@ -260,7 +189,7 @@ pub(super) fn compile_constant_expression(
     module: Module,
     module_ns: Option<&namespace::Module>,
     function_compiler: Option<&FnCompiler>,
-    call_path: &CallPath,
+    _call_path: &CallPath,
     const_expr: &ty::TyExpression,
     is_configurable: bool,
 ) -> Result<Value, CompileError> {
@@ -277,13 +206,12 @@ pub(super) fn compile_constant_expression(
         is_configurable,
     )?;
 
+    assert!(!is_configurable);
+
     if !is_configurable {
         Ok(Value::new_constant(context, constant_evaluated).add_metadatum(context, span_id_idx))
     } else {
-        let config_const_name =
-            md_mgr.config_const_name_to_md(context, &std::rc::Rc::from(call_path.suffix.as_str()));
-        let metadata = md_combine(context, &span_id_idx, &config_const_name);
-        Ok(Value::new_configurable(context, constant_evaluated).add_metadatum(context, metadata))
+        unreachable!()
     }
 }
 
@@ -421,6 +349,9 @@ fn const_eval_typed_expr(
                 }
             }
         }
+        ty::TyExpressionVariant::ConfigurableExpression { span, .. } => {
+            return Err(ConstEvalError::CannotBeEvaluatedToConst { span: span.clone() });
+        }
         ty::TyExpressionVariant::VariableExpression {
             name, call_path, ..
         } => match known_consts.get(name) {
diff --git a/sway-core/src/ir_generation/function.rs b/sway-core/src/ir_generation/function.rs
index e433f9ee6e5..67637d8cf02 100644
--- a/sway-core/src/ir_generation/function.rs
+++ b/sway-core/src/ir_generation/function.rs
@@ -1,9 +1,9 @@
 use super::{
-    compile::compile_function,
     convert::*,
     lexical_map::LexicalMap,
     storage::{add_to_b256, get_storage_key},
     types::*,
+    CompiledFunctionCache,
 };
 use crate::{
     engine_threading::*,
@@ -11,7 +11,7 @@ use crate::{
         compile_constant_expression, compile_constant_expression_to_constant,
     },
     language::{
-        ty::{self, ProjectionKind, TyConstantDecl, TyExpressionVariant},
+        ty::{self, ProjectionKind, TyConfigurableDecl, TyConstantDecl, TyExpressionVariant},
         *,
     },
     metadata::MetadataManager,
@@ -95,7 +95,7 @@ pub(crate) struct FnCompiler<'eng> {
     block_to_continue_to: Option<Block>,
     current_fn_param: Option<ty::TyFunctionParameter>,
     lexical_map: LexicalMap,
-    recreated_fns: HashMap<(Span, Vec<TypeId>, Vec<TypeId>), Function>,
+    cache: &'eng mut CompiledFunctionCache,
     // This is a map from the type IDs of a logged type and the ID of the corresponding log
     logged_types_map: HashMap<TypeId, LogId>,
     // This is a map from the type IDs of a message data type and the ID of the corresponding smo
@@ -111,6 +111,7 @@ impl<'eng> FnCompiler<'eng> {
         function: Function,
         logged_types_map: &HashMap<TypeId, LogId>,
         messages_types_map: &HashMap<TypeId, MessageId>,
+        cache: &'eng mut CompiledFunctionCache,
     ) -> Self {
         let lexical_map = LexicalMap::from_iter(
             function
@@ -125,7 +126,7 @@ impl<'eng> FnCompiler<'eng> {
             block_to_break_to: None,
             block_to_continue_to: None,
             lexical_map,
-            recreated_fns: HashMap::new(),
+            cache,
             current_fn_param: None,
             logged_types_map: logged_types_map.clone(),
             messages_types_map: messages_types_map.clone(),
@@ -208,6 +209,9 @@ impl<'eng> FnCompiler<'eng> {
                     self.compile_const_decl(context, md_mgr, &tcd, span_md_idx, false)?;
                     Ok(None)
                 }
+                ty::TyDecl::ConfigurableDecl(ty::ConfigurableDecl { .. }) => {
+                    unreachable!()
+                }
                 ty::TyDecl::EnumDecl(ty::EnumDecl { decl_id, .. }) => {
                     let ted = self.engines.de().get_enum(decl_id);
                     create_tagged_union_type(
@@ -487,6 +491,9 @@ impl<'eng> FnCompiler<'eng> {
             ty::TyExpressionVariant::ConstantExpression { const_decl, .. } => {
                 self.compile_const_expr(context, md_mgr, const_decl, span_md_idx)
             }
+            ty::TyExpressionVariant::ConfigurableExpression { const_decl, .. } => {
+                self.compile_config_expr(context, const_decl, span_md_idx)
+            }
             ty::TyExpressionVariant::VariableExpression {
                 name, call_path, ..
             } => self.compile_var_expr(context, call_path, name, span_md_idx),
@@ -2438,87 +2445,15 @@ impl<'eng> FnCompiler<'eng> {
         callee: &ty::TyFunctionDecl,
         span_md_idx: Option<MetadataIndex>,
     ) -> Result<TerminatorValue, CompileError> {
-        // The compiler inlines everything very lazily.  Function calls include the body of the
-        // callee (i.e., the callee_body arg above). Library functions are provided in an initial
-        // namespace from Forc and when the parser builds the AST (or is it during type checking?)
-        // these function bodies are embedded.
-        //
-        // Here we build little single-use instantiations of the callee and then call them.  Naming
-        // is not yet absolute so we must ensure the function names are unique.
-        //
-
-        // Eventually we need to Do It Properly and inline into the AST only when necessary, and
-        // compile the standard library to an actual module.
-
-        // Get the callee from the cache if we've already compiled it.  We can't insert it with
-        // .entry() since `compile_function()` returns a Result we need to handle.  The key to our
-        // cache, to uniquely identify a function instance, is the span and the type IDs of any
-        // args and type parameters.  It's using the Sway types rather than IR types, which would
-        // be more accurate but also more fiddly.
-
-        let no_span = callee.span().as_str().is_empty();
-        let is_autogenerated = if let Some(s) = callee.span.source_id() {
-            context
-                .source_engine
-                .get_path(s)
-                .starts_with("<autogenerated>")
-        } else {
-            false
-        };
-        let (fn_key, item) = if no_span || is_autogenerated {
-            (None, None)
-        } else {
-            let fn_key = (
-                callee.span(),
-                callee
-                    .parameters
-                    .iter()
-                    .map(|p| p.type_argument.type_id)
-                    .collect(),
-                callee.type_parameters.iter().map(|tp| tp.type_id).collect(),
-            );
-
-            (
-                Some(fn_key.clone()),
-                self.recreated_fns.get(&fn_key).copied(),
-            )
-        };
-
-        let new_callee = match item {
-            Some(func) => func,
-            None => {
-                let callee_fn_decl = ty::TyFunctionDecl {
-                    type_parameters: Vec::new(),
-                    name: Ident::new(Span::from_string(format!(
-                        "{}_{}",
-                        callee.name,
-                        context.get_unique_id()
-                    ))),
-                    parameters: callee.parameters.clone(),
-                    ..callee.clone()
-                };
-                let is_entry = false;
-                let new_func = compile_function(
-                    self.engines,
-                    context,
-                    md_mgr,
-                    self.module,
-                    &callee_fn_decl,
-                    &self.logged_types_map,
-                    &self.messages_types_map,
-                    is_entry,
-                    None,
-                )
-                .map_err(|mut x| x.pop().unwrap())?
-                .unwrap();
-
-                if let Some(fn_key) = fn_key {
-                    self.recreated_fns.insert(fn_key, new_func);
-                }
-
-                new_func
-            }
-        };
+        let new_callee = self.cache.ty_function_decl_to_unique_function(
+            self.engines,
+            context,
+            self.module,
+            md_mgr,
+            callee,
+            &self.logged_types_map,
+            &self.messages_types_map,
+        )?;
 
         // Now actually call the new function.
         let mut args = Vec::with_capacity(ast_args.len());
@@ -2830,6 +2765,21 @@ impl<'eng> FnCompiler<'eng> {
         Ok(result)
     }
 
+    fn compile_config_expr(
+        &mut self,
+        context: &mut Context,
+        decl: &TyConfigurableDecl,
+        span_md_idx: Option<MetadataIndex>,
+    ) -> Result<TerminatorValue, CompileError> {
+        let name = decl.call_path.suffix.as_str();
+        let val = self
+            .current_block
+            .append(context)
+            .get_config(self.module, name.to_string())
+            .add_metadatum(context, span_md_idx);
+        Ok(TerminatorValue::new(val, context))
+    }
+
     fn compile_var_expr(
         &mut self,
         context: &mut Context,
@@ -2857,10 +2807,17 @@ impl<'eng> FnCompiler<'eng> {
             .get_global_constant(context, &call_path.as_vec_string())
         {
             Ok(TerminatorValue::new(const_val, context))
-        } else if let Some(config_val) = self
+        } else if self
             .module
-            .get_global_configurable(context, &call_path.as_vec_string())
+            .get_global_configurable(context, &call_path.suffix.to_string())
+            .is_some()
         {
+            let name = call_path.suffix.to_string();
+            let config_val = Value::new_instruction(
+                context,
+                self.current_block,
+                InstOp::GetConfig(self.module, name),
+            );
             Ok(TerminatorValue::new(config_val, context))
         } else {
             Err(CompileError::InternalOwned(
diff --git a/sway-core/src/language/parsed/declaration.rs b/sway-core/src/language/parsed/declaration.rs
index 3eb784956ab..450a4f9f81c 100644
--- a/sway-core/src/language/parsed/declaration.rs
+++ b/sway-core/src/language/parsed/declaration.rs
@@ -1,4 +1,5 @@
 mod abi;
+mod configurable;
 mod constant;
 mod r#enum;
 pub mod function;
@@ -12,6 +13,7 @@ mod variable;
 use std::fmt;
 
 pub use abi::*;
+pub use configurable::*;
 pub use constant::*;
 pub use function::*;
 pub use impl_trait::*;
@@ -40,6 +42,7 @@ pub enum Declaration {
     ImplSelf(ParsedDeclId<ImplSelf>),
     AbiDeclaration(ParsedDeclId<AbiDeclaration>),
     ConstantDeclaration(ParsedDeclId<ConstantDeclaration>),
+    ConfigurableDeclaration(ParsedDeclId<ConfigurableDeclaration>),
     StorageDeclaration(ParsedDeclId<StorageDeclaration>),
     TypeAliasDeclaration(ParsedDeclId<TypeAliasDeclaration>),
     TraitTypeDeclaration(ParsedDeclId<TraitTypeDeclaration>),
@@ -63,6 +66,7 @@ impl Declaration {
         match self {
             VariableDeclaration(_) => "variable",
             ConstantDeclaration(_) => "constant",
+            ConfigurableDeclaration(_) => "config",
             TraitTypeDeclaration(_) => "type",
             FunctionDeclaration(_) => "function",
             TraitDeclaration(_) => "trait",
@@ -90,6 +94,7 @@ impl Declaration {
             ImplSelf(decl_id) => pe.get_impl_self(decl_id).span(),
             AbiDeclaration(decl_id) => pe.get_abi(decl_id).span(),
             ConstantDeclaration(decl_id) => pe.get_constant(decl_id).span(),
+            ConfigurableDeclaration(decl_id) => pe.get_configurable(decl_id).span(),
             StorageDeclaration(decl_id) => pe.get_storage(decl_id).span(),
             TypeAliasDeclaration(decl_id) => pe.get_type_alias(decl_id).span(),
             TraitTypeDeclaration(decl_id) => pe.get_trait_type(decl_id).span(),
diff --git a/sway-core/src/language/parsed/declaration/configurable.rs b/sway-core/src/language/parsed/declaration/configurable.rs
new file mode 100644
index 00000000000..9a269e64680
--- /dev/null
+++ b/sway-core/src/language/parsed/declaration/configurable.rs
@@ -0,0 +1,34 @@
+use crate::{
+    engine_threading::DebugWithEngines,
+    language::{parsed::Expression, Visibility},
+    transform, Engines, TypeArgument,
+};
+use sway_types::{Ident, Named, Span, Spanned};
+
+#[derive(Debug, Clone)]
+pub struct ConfigurableDeclaration {
+    pub name: Ident,
+    pub attributes: transform::AttributesMap,
+    pub type_ascription: TypeArgument,
+    pub value: Option<Expression>,
+    pub visibility: Visibility,
+    pub span: Span,
+}
+
+impl Named for ConfigurableDeclaration {
+    fn name(&self) -> &sway_types::BaseIdent {
+        &self.name
+    }
+}
+
+impl Spanned for ConfigurableDeclaration {
+    fn span(&self) -> sway_types::Span {
+        self.span.clone()
+    }
+}
+
+impl DebugWithEngines for ConfigurableDeclaration {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>, _engines: &Engines) -> std::fmt::Result {
+        f.write_fmt(format_args!("{}", self.name))
+    }
+}
diff --git a/sway-core/src/language/ty/ast_node.rs b/sway-core/src/language/ty/ast_node.rs
index d43bc71bf97..35020a34c99 100644
--- a/sway-core/src/language/ty/ast_node.rs
+++ b/sway-core/src/language/ty/ast_node.rs
@@ -221,6 +221,12 @@ impl TyAstNode {
                         value.check_deprecated(engines, handler, allow_deprecated);
                     }
                 }
+                TyDecl::ConfigurableDecl(decl) => {
+                    let decl = engines.de().get(&decl.decl_id);
+                    if let Some(value) = &decl.value {
+                        value.check_deprecated(engines, handler, allow_deprecated);
+                    }
+                }
                 TyDecl::TraitTypeDecl(_) => {}
                 TyDecl::FunctionDecl(decl) => {
                     let decl = engines.de().get(&decl.decl_id);
@@ -279,6 +285,7 @@ impl TyAstNode {
                 TyAstNodeContent::Declaration(node) => match node {
                     TyDecl::VariableDecl(_decl) => {}
                     TyDecl::ConstantDecl(_decl) => {}
+                    TyDecl::ConfigurableDecl(_decl) => {}
                     TyDecl::TraitTypeDecl(_) => {}
                     TyDecl::FunctionDecl(decl) => {
                         let fn_decl_id = decl.decl_id;
diff --git a/sway-core/src/language/ty/declaration/configurable.rs b/sway-core/src/language/ty/declaration/configurable.rs
new file mode 100644
index 00000000000..6c7cb3e393d
--- /dev/null
+++ b/sway-core/src/language/ty/declaration/configurable.rs
@@ -0,0 +1,119 @@
+use std::{
+    fmt,
+    hash::{Hash, Hasher},
+};
+
+use sway_error::handler::{ErrorEmitted, Handler};
+use sway_types::{Ident, Named, Span, Spanned};
+
+use crate::{
+    decl_engine::{DeclId, DeclMapping, DeclRef, ReplaceDecls},
+    engine_threading::*,
+    has_changes,
+    language::{ty::*, CallPath, Visibility},
+    semantic_analysis::TypeCheckContext,
+    transform,
+    type_system::*,
+};
+
+#[derive(Clone, Debug)]
+pub struct TyConfigurableDecl {
+    pub call_path: CallPath,
+    pub value: Option<TyExpression>,
+    pub decode_fn: Option<DeclRef<DeclId<TyFunctionDecl>>>,
+    pub visibility: Visibility,
+    pub attributes: transform::AttributesMap,
+    pub return_type: TypeId,
+    pub type_ascription: TypeArgument,
+    pub span: Span,
+    // TODO can we remove this?
+    pub implementing_type: Option<TyDecl>,
+}
+
+impl DebugWithEngines for TyConfigurableDecl {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>, _engines: &Engines) -> fmt::Result {
+        write!(f, "{}", self.call_path)
+    }
+}
+
+impl EqWithEngines for TyConfigurableDecl {}
+impl PartialEqWithEngines for TyConfigurableDecl {
+    fn eq(&self, other: &Self, ctx: &PartialEqWithEnginesContext) -> bool {
+        let type_engine = ctx.engines().te();
+        self.call_path == other.call_path
+            && self.value.eq(&other.value, ctx)
+            && self.visibility == other.visibility
+            && self.type_ascription.eq(&other.type_ascription, ctx)
+            && type_engine
+                .get(self.return_type)
+                .eq(&type_engine.get(other.return_type), ctx)
+            && match (&self.implementing_type, &other.implementing_type) {
+                (Some(self_), Some(other)) => self_.eq(other, ctx),
+                _ => false,
+            }
+    }
+}
+
+impl HashWithEngines for TyConfigurableDecl {
+    fn hash<H: Hasher>(&self, state: &mut H, engines: &Engines) {
+        let type_engine = engines.te();
+        let TyConfigurableDecl {
+            call_path,
+            value,
+            visibility,
+            return_type,
+            type_ascription,
+            implementing_type,
+            // these fields are not hashed because they aren't relevant/a
+            // reliable source of obj v. obj distinction
+            attributes: _,
+            span: _,
+            decode_fn: _, // this is defined entirely by the type ascription
+        } = self;
+        call_path.hash(state);
+        value.hash(state, engines);
+        visibility.hash(state);
+        type_engine.get(*return_type).hash(state, engines);
+        type_ascription.hash(state, engines);
+        if let Some(implementing_type) = implementing_type {
+            (*implementing_type).hash(state, engines);
+        }
+    }
+}
+
+impl Named for TyConfigurableDecl {
+    fn name(&self) -> &Ident {
+        &self.call_path.suffix
+    }
+}
+
+impl Spanned for TyConfigurableDecl {
+    fn span(&self) -> Span {
+        self.span.clone()
+    }
+}
+
+impl SubstTypes for TyConfigurableDecl {
+    fn subst_inner(&mut self, type_mapping: &TypeSubstMap, engines: &Engines) -> HasChanges {
+        has_changes! {
+            self.return_type.subst(type_mapping, engines);
+            self.type_ascription.subst(type_mapping, engines);
+            self.value.subst(type_mapping, engines);
+        }
+    }
+}
+
+impl ReplaceDecls for TyConfigurableDecl {
+    fn replace_decls_inner(
+        &mut self,
+        decl_mapping: &DeclMapping,
+        handler: &Handler,
+        ctx: &mut TypeCheckContext,
+    ) -> Result<bool, ErrorEmitted> {
+        if let Some(expr) = &mut self.value {
+            expr.replace_decls(decl_mapping, handler, ctx)
+        } else {
+            Ok(false)
+        }
+    }
+}
diff --git a/sway-core/src/language/ty/declaration/declaration.rs b/sway-core/src/language/ty/declaration/declaration.rs
index d911433da46..b59064ddbbe 100644
--- a/sway-core/src/language/ty/declaration/declaration.rs
+++ b/sway-core/src/language/ty/declaration/declaration.rs
@@ -21,6 +21,7 @@ use crate::{
 pub enum TyDecl {
     VariableDecl(Box<TyVariableDecl>),
     ConstantDecl(ConstantDecl),
+    ConfigurableDecl(ConfigurableDecl),
     TraitTypeDecl(TraitTypeDecl),
     FunctionDecl(FunctionDecl),
     TraitDecl(TraitDecl),
@@ -42,6 +43,11 @@ pub struct ConstantDecl {
     pub decl_id: DeclId<TyConstantDecl>,
 }
 
+#[derive(Clone, Debug)]
+pub struct ConfigurableDecl {
+    pub decl_id: DeclId<TyConfigurableDecl>,
+}
+
 #[derive(Clone, Debug)]
 pub struct TraitTypeDecl {
     pub decl_id: DeclId<TyTraitType>,
@@ -188,6 +194,9 @@ impl HashWithEngines for TyDecl {
             TyDecl::ConstantDecl(ConstantDecl { decl_id, .. }) => {
                 decl_engine.get(decl_id).hash(state, engines);
             }
+            TyDecl::ConfigurableDecl(ConfigurableDecl { decl_id, .. }) => {
+                decl_engine.get(decl_id).hash(state, engines);
+            }
             TyDecl::TraitTypeDecl(TraitTypeDecl { decl_id, .. }) => {
                 decl_engine.get(decl_id).hash(state, engines);
             }
@@ -263,6 +272,7 @@ impl SubstTypes for TyDecl {
             // generics in an ABI is unsupported by design
             TyDecl::AbiDecl(_)
             | TyDecl::ConstantDecl(_)
+            | TyDecl::ConfigurableDecl(_)
             | TyDecl::StorageDecl(_)
             | TyDecl::GenericTypeForFunctionScope(_)
             | TyDecl::ErrorRecovery(..) => HasChanges::No,
@@ -277,6 +287,10 @@ impl SpannedWithEngines for TyDecl {
                 let const_decl = engines.de().get(decl_id);
                 const_decl.span.clone()
             }
+            TyDecl::ConfigurableDecl(ConfigurableDecl { decl_id, .. }) => {
+                let const_decl = engines.de().get(decl_id);
+                const_decl.span.clone()
+            }
             TyDecl::TraitTypeDecl(TraitTypeDecl { decl_id }) => {
                 engines.de().get_type(decl_id).span.clone()
             }
@@ -404,6 +418,15 @@ impl CollectTypesMetadata for TyDecl {
                     return Ok(vec![]);
                 }
             }
+            TyDecl::ConfigurableDecl(ConfigurableDecl { decl_id, .. }) => {
+                let const_decl = decl_engine.get_configurable(decl_id);
+                let TyConfigurableDecl { value, .. } = &*const_decl;
+                if let Some(value) = value {
+                    value.collect_types_metadata(handler, ctx)?
+                } else {
+                    return Ok(vec![]);
+                }
+            }
             TyDecl::ErrorRecovery(..)
             | TyDecl::StorageDecl(_)
             | TyDecl::TraitDecl(_)
@@ -426,6 +449,9 @@ impl GetDeclIdent for TyDecl {
             TyDecl::ConstantDecl(ConstantDecl { decl_id }) => {
                 Some(engines.de().get_constant(decl_id).name().clone())
             }
+            TyDecl::ConfigurableDecl(ConfigurableDecl { decl_id }) => {
+                Some(engines.de().get_configurable(decl_id).name().clone())
+            }
             TyDecl::TraitTypeDecl(TraitTypeDecl { decl_id }) => {
                 Some(engines.de().get_type(decl_id).name().clone())
             }
@@ -663,6 +689,7 @@ impl TyDecl {
         match self {
             VariableDecl(_) => "variable",
             ConstantDecl(_) => "constant",
+            ConfigurableDecl(_) => "configurable",
             TraitTypeDecl(_) => "type",
             FunctionDecl(_) => "function",
             TraitDecl(_) => "trait",
@@ -775,6 +802,9 @@ impl TyDecl {
             TyDecl::ConstantDecl(ConstantDecl { decl_id, .. }) => {
                 decl_engine.get_constant(decl_id).visibility
             }
+            TyDecl::ConfigurableDecl(ConfigurableDecl { decl_id, .. }) => {
+                decl_engine.get_configurable(decl_id).visibility
+            }
             TyDecl::StructDecl(StructDecl { decl_id, .. }) => {
                 decl_engine.get_struct(decl_id).visibility
             }
@@ -815,6 +845,14 @@ impl From<DeclRef<DeclId<TyConstantDecl>>> for TyDecl {
     }
 }
 
+impl From<DeclRef<DeclId<TyConfigurableDecl>>> for TyDecl {
+    fn from(decl_ref: DeclRef<DeclId<TyConfigurableDecl>>) -> Self {
+        TyDecl::ConfigurableDecl(ConfigurableDecl {
+            decl_id: *decl_ref.id(),
+        })
+    }
+}
+
 impl From<DeclRef<DeclId<TyEnumDecl>>> for TyDecl {
     fn from(decl_ref: DeclRef<DeclId<TyEnumDecl>>) -> Self {
         TyDecl::EnumDecl(EnumDecl {
diff --git a/sway-core/src/language/ty/declaration/mod.rs b/sway-core/src/language/ty/declaration/mod.rs
index f391a6dadba..c7e7201d899 100644
--- a/sway-core/src/language/ty/declaration/mod.rs
+++ b/sway-core/src/language/ty/declaration/mod.rs
@@ -1,4 +1,5 @@
 mod abi;
+mod configurable;
 mod constant;
 #[allow(clippy::module_inception)]
 mod declaration;
@@ -14,6 +15,7 @@ mod type_alias;
 mod variable;
 
 pub use abi::*;
+pub use configurable::*;
 pub use constant::*;
 pub use declaration::*;
 pub use function::*;
diff --git a/sway-core/src/language/ty/expression/expression.rs b/sway-core/src/language/ty/expression/expression.rs
index ce827eba146..d940f40115c 100644
--- a/sway-core/src/language/ty/expression/expression.rs
+++ b/sway-core/src/language/ty/expression/expression.rs
@@ -306,6 +306,7 @@ impl CollectTypesMetadata for TyExpression {
             // `TyExpression::return_type`. Variable expressions are just names of variables.
             VariableExpression { .. }
             | ConstantExpression { .. }
+            | ConfigurableExpression { .. }
             | StorageAccess { .. }
             | Literal(_)
             | AbiName(_)
diff --git a/sway-core/src/language/ty/expression/expression_variant.rs b/sway-core/src/language/ty/expression/expression_variant.rs
index 1746b92a819..37b8bed8fb1 100644
--- a/sway-core/src/language/ty/expression/expression_variant.rs
+++ b/sway-core/src/language/ty/expression/expression_variant.rs
@@ -48,6 +48,11 @@ pub enum TyExpressionVariant {
         const_decl: Box<TyConstantDecl>,
         call_path: Option<CallPath>,
     },
+    ConfigurableExpression {
+        span: Span,
+        const_decl: Box<TyConfigurableDecl>,
+        call_path: Option<CallPath>,
+    },
     VariableExpression {
         name: Ident,
         span: Span,
@@ -462,6 +467,13 @@ impl HashWithEngines for TyExpressionVariant {
             } => {
                 const_decl.hash(state, engines);
             }
+            Self::ConfigurableExpression {
+                const_decl,
+                span: _,
+                call_path: _,
+            } => {
+                const_decl.hash(state, engines);
+            }
             Self::VariableExpression {
                 name,
                 mutability,
@@ -656,6 +668,7 @@ impl SubstTypes for TyExpressionVariant {
                 rhs.subst(type_mapping, engines);
             },
             ConstantExpression { const_decl, .. } => const_decl.subst(type_mapping, engines),
+            ConfigurableExpression { const_decl, .. } => const_decl.subst(type_mapping, engines),
             VariableExpression { .. } => HasChanges::No,
             Tuple { fields } => fields.subst(type_mapping, engines),
             Array {
@@ -846,6 +859,9 @@ impl ReplaceDecls for TyExpressionVariant {
                 ConstantExpression { const_decl, .. } => {
                     const_decl.replace_decls(decl_mapping, handler, ctx)
                 }
+                ConfigurableExpression { const_decl, .. } => {
+                    const_decl.replace_decls(decl_mapping, handler, ctx)
+                }
                 VariableExpression { .. } => Ok(false),
                 Tuple { fields } => {
                     let mut has_changes = false;
@@ -1007,6 +1023,9 @@ impl TypeCheckAnalysis for TyExpressionVariant {
             TyExpressionVariant::ConstantExpression { const_decl, .. } => {
                 const_decl.type_check_analyze(handler, ctx)?
             }
+            TyExpressionVariant::ConfigurableExpression { const_decl, .. } => {
+                const_decl.type_check_analyze(handler, ctx)?
+            }
             TyExpressionVariant::VariableExpression { .. } => {}
             TyExpressionVariant::Tuple { fields } => {
                 for field in fields.iter() {
@@ -1124,6 +1143,9 @@ impl TypeCheckFinalization for TyExpressionVariant {
                 TyExpressionVariant::ConstantExpression { const_decl, .. } => {
                     const_decl.type_check_finalize(handler, ctx)?
                 }
+                TyExpressionVariant::ConfigurableExpression { const_decl, .. } => {
+                    const_decl.type_check_finalize(handler, ctx)?
+                }
                 TyExpressionVariant::VariableExpression { .. } => {}
                 TyExpressionVariant::Tuple { fields } => {
                     for field in fields.iter_mut() {
@@ -1243,6 +1265,9 @@ impl UpdateConstantExpression for TyExpressionVariant {
                     *const_decl = Box::new(impl_const);
                 }
             }
+            ConfigurableExpression { .. } => {
+                unreachable!()
+            }
             VariableExpression { .. } => (),
             Tuple { fields } => fields
                 .iter_mut()
@@ -1428,6 +1453,9 @@ impl DebugWithEngines for TyExpressionVariant {
             TyExpressionVariant::ConstantExpression { const_decl, .. } => {
                 format!("\"{}\" constant exp", const_decl.name().as_str())
             }
+            TyExpressionVariant::ConfigurableExpression { const_decl, .. } => {
+                format!("\"{}\" config exp", const_decl.name().as_str())
+            }
             TyExpressionVariant::VariableExpression { name, .. } => {
                 format!("\"{}\" variable exp", name.as_str())
             }
diff --git a/sway-core/src/language/ty/expression/scrutinee.rs b/sway-core/src/language/ty/expression/scrutinee.rs
index 68c51af26eb..240865dcda3 100644
--- a/sway-core/src/language/ty/expression/scrutinee.rs
+++ b/sway-core/src/language/ty/expression/scrutinee.rs
@@ -20,6 +20,7 @@ pub enum TyScrutineeVariant {
     Literal(Literal),
     Variable(Ident),
     Constant(Ident, Literal, TyConstantDecl),
+    Configurable(Ident, Literal, TyConfigurableDecl),
     StructScrutinee {
         struct_ref: DeclRefStruct,
         fields: Vec<TyStructScrutineeField>,
diff --git a/sway-core/src/lib.rs b/sway-core/src/lib.rs
index da9c8939521..dcd3cd9c77c 100644
--- a/sway-core/src/lib.rs
+++ b/sway-core/src/lib.rs
@@ -25,7 +25,7 @@ pub mod type_system;
 use crate::ir_generation::check_function_purity;
 use crate::query_engine::ModuleCacheEntry;
 use crate::source_map::SourceMap;
-pub use asm_generation::from_ir::compile_ir_to_asm;
+pub use asm_generation::from_ir::compile_ir_context_to_finalized_asm;
 use asm_generation::FinalizedAsm;
 pub use asm_generation::{CompiledBytecode, FinalizedEntry};
 pub use build_config::{BuildConfig, BuildTarget, LspConfig, OptLevel, PrintAsm, PrintIr};
@@ -934,7 +934,7 @@ pub(crate) fn compile_ast_to_ir_to_asm(
         };
     res?;
 
-    let final_asm = compile_ir_to_asm(handler, &ir, Some(build_config))?;
+    let final_asm = compile_ir_context_to_finalized_asm(handler, &ir, Some(build_config))?;
 
     Ok(final_asm)
 }
diff --git a/sway-core/src/metadata.rs b/sway-core/src/metadata.rs
index ecfdd9753d9..b55d03ed1a7 100644
--- a/sway-core/src/metadata.rs
+++ b/sway-core/src/metadata.rs
@@ -6,7 +6,7 @@ use crate::{
 use sway_ir::{Context, MetadataIndex, Metadatum, Value};
 use sway_types::{SourceId, Span};
 
-use std::{collections::HashMap, path::PathBuf, rc::Rc, sync::Arc};
+use std::{collections::HashMap, path::PathBuf, sync::Arc};
 
 /// IR metadata needs to be consistent between IR generation (converting Spans, etc. to metadata)
 /// and ASM generation (converting the metadata back again).  Here we consolidate all of
@@ -23,14 +23,12 @@ pub(crate) struct MetadataManager {
     md_storage_op_cache: HashMap<MetadataIndex, StorageOperation>,
     md_inline_cache: HashMap<MetadataIndex, Inline>,
     md_test_decl_index_cache: HashMap<MetadataIndex, DeclId<TyFunctionDecl>>,
-    md_config_const_name_cache: HashMap<MetadataIndex, Rc<str>>,
 
     span_md_cache: HashMap<Span, MetadataIndex>,
     file_loc_md_cache: HashMap<SourceId, MetadataIndex>,
     storage_op_md_cache: HashMap<Purity, MetadataIndex>,
     inline_md_cache: HashMap<Inline, MetadataIndex>,
     test_decl_index_md_cache: HashMap<DeclId<TyFunctionDecl>, MetadataIndex>,
-    config_const_name_md_cache: HashMap<Rc<str>, MetadataIndex>,
 }
 
 #[derive(Clone, Copy)]
@@ -180,30 +178,6 @@ impl MetadataManager {
         })
     }
 
-    pub(crate) fn md_to_config_const_name(
-        &mut self,
-        context: &Context,
-        md_idx: Option<MetadataIndex>,
-    ) -> Option<Rc<str>> {
-        Self::for_each_md_idx(context, md_idx, |md_idx| {
-            self.md_config_const_name_cache
-                .get(&md_idx)
-                .cloned()
-                .or_else(|| {
-                    md_idx
-                        .get_content(context)
-                        .unwrap_struct("config_name", 1)
-                        .and_then(|fields| {
-                            fields[0].unwrap_string().map(|name| {
-                                let name: Rc<str> = Rc::from(name);
-                                self.md_config_const_name_cache.insert(md_idx, name.clone());
-                                name
-                            })
-                        })
-                })
-        })
-    }
-
     pub(crate) fn val_to_span(&mut self, context: &Context, value: Value) -> Option<Span> {
         self.md_to_span(context, value.get_metadata(context))
     }
@@ -326,27 +300,6 @@ impl MetadataManager {
         })
     }
 
-    pub(crate) fn config_const_name_to_md(
-        &mut self,
-        context: &mut Context,
-        name: &Rc<str>,
-    ) -> Option<MetadataIndex> {
-        self.config_const_name_md_cache
-            .get(name)
-            .copied()
-            .or_else(|| {
-                let md_idx = MetadataIndex::new_struct(
-                    context,
-                    "config_name",
-                    vec![Metadatum::String(name.to_string())],
-                );
-
-                self.config_const_name_md_cache.insert(name.clone(), md_idx);
-
-                Some(md_idx)
-            })
-    }
-
     fn for_each_md_idx<T, F: FnMut(MetadataIndex) -> Option<T>>(
         context: &Context,
         md_idx: Option<MetadataIndex>,
diff --git a/sway-core/src/semantic_analysis/ast_node/declaration/configurable.rs b/sway-core/src/semantic_analysis/ast_node/declaration/configurable.rs
new file mode 100644
index 00000000000..6b7ed38bb2a
--- /dev/null
+++ b/sway-core/src/semantic_analysis/ast_node/declaration/configurable.rs
@@ -0,0 +1,200 @@
+use std::collections::VecDeque;
+
+use sway_error::{
+    handler::{ErrorEmitted, Handler},
+    warning::{CompileWarning, Warning},
+};
+use sway_types::{style::is_screaming_snake_case, Spanned};
+
+use crate::{
+    decl_engine::{DeclEngineInsert, ReplaceDecls},
+    language::{
+        parsed::*,
+        ty::{self, TyConfigurableDecl},
+        CallPath,
+    },
+    semantic_analysis::{type_check_context::EnforceTypeArguments, *},
+    SubstTypes, TypeArgument, TypeBinding, TypeCheckTypeBinding, TypeInfo,
+};
+
+impl ty::TyConfigurableDecl {
+    pub fn type_check(
+        handler: &Handler,
+        mut ctx: TypeCheckContext,
+        decl: ConfigurableDeclaration,
+    ) -> Result<Self, ErrorEmitted> {
+        let type_engine = ctx.engines.te();
+        let engines = ctx.engines();
+
+        let ConfigurableDeclaration {
+            name,
+            span,
+            mut type_ascription,
+            value,
+            attributes,
+            visibility,
+        } = decl;
+
+        type_ascription.type_id = ctx
+            .resolve_type(
+                handler,
+                type_ascription.type_id,
+                &type_ascription.span,
+                EnforceTypeArguments::No,
+                None,
+            )
+            .unwrap_or_else(|err| type_engine.insert(engines, TypeInfo::ErrorRecovery(err), None));
+
+        // this subst is required to replace associated types, namely TypeInfo::TraitType.
+        type_ascription.type_id.subst(&ctx.type_subst(), engines);
+
+        if !is_screaming_snake_case(name.as_str()) {
+            handler.emit_warn(CompileWarning {
+                span: name.span(),
+                warning_content: Warning::NonScreamingSnakeCaseConstName { name: name.clone() },
+            })
+        }
+
+        // Configurables will be encoded and must be type_checked into "slice"
+        let value = if ctx.experimental.new_encoding {
+            let mut ctx = ctx
+                .by_ref()
+                .with_type_annotation(type_engine.insert(engines, TypeInfo::RawUntypedSlice, None))
+                .with_help_text("Configurables must evaluate to slices.");
+
+            let value = value.map(|value| {
+                ty::TyExpression::type_check(handler, ctx.by_ref(), &value)
+                    .unwrap_or_else(|err| ty::TyExpression::error(err, name.span(), engines))
+            });
+
+            value
+        } else {
+            let mut ctx = ctx
+                .by_ref()
+                .with_type_annotation(type_ascription.type_id)
+                .with_help_text(
+                    "This declaration's type annotation does not match up with the assigned \
+            expression's type.",
+                );
+
+            let value = value.map(|value| {
+                ty::TyExpression::type_check(handler, ctx.by_ref(), &value)
+                    .unwrap_or_else(|err| ty::TyExpression::error(err, name.span(), engines))
+            });
+
+            value
+        };
+
+        let mut call_path: CallPath = name.into();
+        call_path = call_path.to_fullpath(engines, ctx.namespace());
+
+        let mut arguments = VecDeque::default();
+        arguments.push_back(
+            engines
+                .te()
+                .insert(engines, TypeInfo::RawUntypedSlice, None),
+        );
+        arguments.push_back(engines.te().insert(
+            engines,
+            TypeInfo::UnsignedInteger(sway_types::integer_bits::IntegerBits::SixtyFour),
+            None,
+        ));
+        arguments.push_back(
+            engines
+                .te()
+                .insert(engines, TypeInfo::RawUntypedSlice, None),
+        );
+
+        let (decode_fn_ref, _, _): (crate::decl_engine::DeclRefFunction, _, _) =
+            crate::TypeBinding::type_check(
+                &mut TypeBinding::<CallPath> {
+                    inner: CallPath {
+                        prefixes: vec![],
+                        suffix: sway_types::Ident::new_no_span("abi_decode_in_place".into()),
+                        is_absolute: false,
+                    },
+                    type_arguments: crate::TypeArgs::Regular(vec![TypeArgument {
+                        type_id: type_ascription.type_id,
+                        initial_type_id: type_ascription.type_id,
+                        span: sway_types::Span::dummy(),
+                        call_path_tree: None,
+                    }]),
+                    span: sway_types::Span::dummy(),
+                },
+                handler,
+                ctx.by_ref(),
+            )
+            .unwrap();
+
+        let mut decode_fn_decl = (*engines.de().get_function(&decode_fn_ref)).clone();
+        let decl_mapping = crate::TypeParameter::gather_decl_mapping_from_trait_constraints(
+            handler,
+            ctx.by_ref(),
+            &decode_fn_decl.type_parameters,
+            decode_fn_decl.name.as_str(),
+            &span,
+        )?;
+        decode_fn_decl.replace_decls(&decl_mapping, handler, &mut ctx)?;
+        let decode_fn_ref = engines
+            .de()
+            .insert(decode_fn_decl)
+            .with_parent(engines.de(), (*decode_fn_ref.id()).into());
+
+        // let (decode_fn, _) = resolve_method_name(
+        //     handler,
+        //     ctx,
+        //     &crate::TypeBinding {
+        //         inner: MethodName::FromModule {
+        //             method_name: sway_types::Ident::new_no_span("abi_decode".into()),
+        //         },
+        //         type_arguments: crate::TypeArgs::Regular(vec![TypeArgument {
+        //             type_id: type_ascription.type_id,
+        //             initial_type_id: type_ascription.type_id,
+        //             span: sway_types::Span::dummy(),
+        //             call_path_tree: None,
+        //         }]),
+        //         span: sway_types::Span::dummy(),
+        //     },
+        //     arguments,
+        // )
+        // .unwrap();
+
+        Ok(ty::TyConfigurableDecl {
+            call_path,
+            attributes,
+            return_type: type_ascription.type_id,
+            type_ascription,
+            span,
+            value,
+            decode_fn: Some(decode_fn_ref),
+            visibility,
+            implementing_type: None,
+        })
+    }
+}
+
+impl TypeCheckAnalysis for TyConfigurableDecl {
+    fn type_check_analyze(
+        &self,
+        handler: &Handler,
+        ctx: &mut TypeCheckAnalysisContext,
+    ) -> Result<(), ErrorEmitted> {
+        if let Some(value) = self.value.as_ref() {
+            value.type_check_analyze(handler, ctx)?;
+        }
+        Ok(())
+    }
+}
+
+impl TypeCheckFinalization for TyConfigurableDecl {
+    fn type_check_finalize(
+        &mut self,
+        handler: &Handler,
+        ctx: &mut TypeCheckFinalizationContext,
+    ) -> Result<(), ErrorEmitted> {
+        if let Some(value) = self.value.as_mut() {
+            value.type_check_finalize(handler, ctx)?;
+        }
+        Ok(())
+    }
+}
diff --git a/sway-core/src/semantic_analysis/ast_node/declaration/declaration.rs b/sway-core/src/semantic_analysis/ast_node/declaration/declaration.rs
index 4ca4a44f19c..a1c4a45bceb 100644
--- a/sway-core/src/semantic_analysis/ast_node/declaration/declaration.rs
+++ b/sway-core/src/semantic_analysis/ast_node/declaration/declaration.rs
@@ -34,6 +34,10 @@ impl TyDecl {
                 let const_decl = engines.pe().get_constant(decl_id).as_ref().clone();
                 ctx.insert_parsed_symbol(handler, engines, const_decl.name.clone(), decl)?;
             }
+            parsed::Declaration::ConfigurableDeclaration(decl_id) => {
+                let const_decl = engines.pe().get_configurable(decl_id).as_ref().clone();
+                ctx.insert_parsed_symbol(handler, engines, const_decl.name.clone(), decl)?;
+            }
             parsed::Declaration::TraitTypeDeclaration(decl_id) => {
                 let trait_type_decl = engines.pe().get_trait_type(decl_id).as_ref().clone();
                 ctx.insert_parsed_symbol(handler, engines, trait_type_decl.name.clone(), decl)?;
@@ -172,6 +176,22 @@ impl TyDecl {
                 ctx.insert_symbol(handler, const_decl.name().clone(), typed_const_decl.clone())?;
                 typed_const_decl
             }
+            parsed::Declaration::ConfigurableDeclaration(decl_id) => {
+                let decl = engines.pe().get_configurable(&decl_id).as_ref().clone();
+                let span = decl.span.clone();
+                let config_decl =
+                    match ty::TyConfigurableDecl::type_check(handler, ctx.by_ref(), decl) {
+                        Ok(res) => res,
+                        Err(err) => return Ok(ty::TyDecl::ErrorRecovery(span, err)),
+                    };
+                let typed_const_decl: ty::TyDecl = decl_engine.insert(config_decl.clone()).into();
+                ctx.insert_symbol(
+                    handler,
+                    config_decl.name().clone(),
+                    typed_const_decl.clone(),
+                )?;
+                typed_const_decl
+            }
             parsed::Declaration::TraitTypeDeclaration(decl_id) => {
                 let decl = engines.pe().get_trait_type(&decl_id).as_ref().clone();
                 let span = decl.span.clone();
@@ -538,6 +558,10 @@ impl TypeCheckAnalysis for TyDecl {
                 let const_decl = ctx.engines.de().get_constant(&node.decl_id);
                 const_decl.type_check_analyze(handler, ctx)?;
             }
+            TyDecl::ConfigurableDecl(node) => {
+                let const_decl = ctx.engines.de().get_configurable(&node.decl_id);
+                const_decl.type_check_analyze(handler, ctx)?;
+            }
             TyDecl::FunctionDecl(node) => {
                 let fn_decl = ctx.engines.de().get_function(&node.decl_id);
                 fn_decl.type_check_analyze(handler, ctx)?;
@@ -591,6 +615,10 @@ impl TypeCheckFinalization for TyDecl {
                 let mut const_decl = (*ctx.engines.de().get_constant(&node.decl_id)).clone();
                 const_decl.type_check_finalize(handler, ctx)?;
             }
+            TyDecl::ConfigurableDecl(node) => {
+                let mut config_decl = (*ctx.engines.de().get_configurable(&node.decl_id)).clone();
+                config_decl.type_check_finalize(handler, ctx)?;
+            }
             TyDecl::FunctionDecl(node) => {
                 let mut fn_decl = (*ctx.engines.de().get_function(&node.decl_id)).clone();
                 fn_decl.type_check_finalize(handler, ctx)?;
diff --git a/sway-core/src/semantic_analysis/ast_node/declaration/mod.rs b/sway-core/src/semantic_analysis/ast_node/declaration/mod.rs
index ea8acf3c99a..525055e892e 100644
--- a/sway-core/src/semantic_analysis/ast_node/declaration/mod.rs
+++ b/sway-core/src/semantic_analysis/ast_node/declaration/mod.rs
@@ -1,5 +1,6 @@
 mod abi;
 pub mod auto_impl;
+mod configurable;
 mod constant;
 #[allow(clippy::module_inception)]
 mod declaration;
diff --git a/sway-core/src/semantic_analysis/ast_node/expression/match_expression/analysis/duplicates.rs b/sway-core/src/semantic_analysis/ast_node/expression/match_expression/analysis/duplicates.rs
index 218901904cd..f368e01eeec 100644
--- a/sway-core/src/semantic_analysis/ast_node/expression/match_expression/analysis/duplicates.rs
+++ b/sway-core/src/semantic_analysis/ast_node/expression/match_expression/analysis/duplicates.rs
@@ -175,6 +175,7 @@ pub(crate) fn collect_duplicate_match_pattern_variables(
             ty::TyScrutineeVariant::Variable(ident) => add_variable(left_most_branch, ident, false),
             ty::TyScrutineeVariant::Literal(_) => (),
             ty::TyScrutineeVariant::Constant { .. } => (),
+            ty::TyScrutineeVariant::Configurable { .. } => (),
             ty::TyScrutineeVariant::StructScrutinee { fields, .. } => {
                 // If a field does not have a scrutinee, the field itself is a variable.
                 for field in fields {
diff --git a/sway-core/src/semantic_analysis/ast_node/expression/match_expression/analysis/pattern.rs b/sway-core/src/semantic_analysis/ast_node/expression/match_expression/analysis/pattern.rs
index 7de4cc88dc4..3a0458d4fed 100644
--- a/sway-core/src/semantic_analysis/ast_node/expression/match_expression/analysis/pattern.rs
+++ b/sway-core/src/semantic_analysis/ast_node/expression/match_expression/analysis/pattern.rs
@@ -120,6 +120,7 @@ impl Pattern {
             ty::TyScrutineeVariant::Variable(_) => Pattern::Wildcard,
             ty::TyScrutineeVariant::Literal(value) => Pattern::from_literal(value),
             ty::TyScrutineeVariant::Constant(_, value, _) => Pattern::from_literal(value),
+            ty::TyScrutineeVariant::Configurable(_, value, _) => Pattern::from_literal(value),
             ty::TyScrutineeVariant::StructScrutinee {
                 struct_ref,
                 fields,
diff --git a/sway-core/src/semantic_analysis/ast_node/expression/match_expression/typed/matcher.rs b/sway-core/src/semantic_analysis/ast_node/expression/match_expression/typed/matcher.rs
index 21f49112d36..e731a824714 100644
--- a/sway-core/src/semantic_analysis/ast_node/expression/match_expression/typed/matcher.rs
+++ b/sway-core/src/semantic_analysis/ast_node/expression/match_expression/typed/matcher.rs
@@ -2,7 +2,7 @@ use indexmap::IndexMap;
 
 use crate::{
     language::{
-        ty::{self, TyConstantDecl},
+        ty::{self, TyConfigurableDecl, TyConstantDecl},
         CallPath, Literal,
     },
     semantic_analysis::{
@@ -229,6 +229,9 @@ pub(super) fn matcher(
         ty::TyScrutineeVariant::Constant(_, _, const_decl) => {
             Ok(match_constant(ctx, exp, const_decl, span))
         }
+        ty::TyScrutineeVariant::Configurable(_, _, config_decl) => {
+            Ok(match_configurable(ctx, exp, config_decl, span))
+        }
         ty::TyScrutineeVariant::StructScrutinee {
             struct_ref: _,
             fields,
@@ -403,6 +406,8 @@ fn match_constant(
     let name = const_decl.name().clone();
     let return_type = const_decl.type_ascription.type_id;
 
+    assert!(!const_decl.is_configurable);
+
     let req = (
         exp.to_owned(),
         ty::TyExpression {
@@ -419,6 +424,31 @@ fn match_constant(
     ReqDeclTree::req(req)
 }
 
+fn match_configurable(
+    ctx: TypeCheckContext,
+    exp: &ty::TyExpression,
+    const_decl: TyConfigurableDecl,
+    span: Span,
+) -> ReqDeclTree {
+    let name = const_decl.name().clone();
+    let return_type = const_decl.type_ascription.type_id;
+
+    let req = (
+        exp.to_owned(),
+        ty::TyExpression {
+            expression: ty::TyExpressionVariant::ConfigurableExpression {
+                span: span.clone(),
+                const_decl: Box::new(const_decl),
+                call_path: Some(CallPath::from(name).to_fullpath(ctx.engines(), ctx.namespace())),
+            },
+            return_type,
+            span,
+        },
+    );
+
+    ReqDeclTree::req(req)
+}
+
 fn match_struct(
     handler: &Handler,
     mut ctx: TypeCheckContext,
diff --git a/sway-core/src/semantic_analysis/ast_node/expression/match_expression/typed/typed_scrutinee.rs b/sway-core/src/semantic_analysis/ast_node/expression/match_expression/typed/typed_scrutinee.rs
index 4e0887c3b81..f8b06853ac1 100644
--- a/sway-core/src/semantic_analysis/ast_node/expression/match_expression/typed/typed_scrutinee.rs
+++ b/sway-core/src/semantic_analysis/ast_node/expression/match_expression/typed/typed_scrutinee.rs
@@ -143,6 +143,7 @@ impl TyScrutinee {
             ty::TyScrutineeVariant::Variable(_) => true,
             ty::TyScrutineeVariant::Literal(_) => false,
             ty::TyScrutineeVariant::Constant { .. } => false,
+            ty::TyScrutineeVariant::Configurable { .. } => false,
             ty::TyScrutineeVariant::StructScrutinee { fields, .. } => fields
                 .iter()
                 .filter_map(|x| x.scrutinee.as_ref())
diff --git a/sway-core/src/semantic_analysis/ast_node/expression/typed_expression.rs b/sway-core/src/semantic_analysis/ast_node/expression/typed_expression.rs
index cc0f2cce114..b1f4fd4cd90 100644
--- a/sway-core/src/semantic_analysis/ast_node/expression/typed_expression.rs
+++ b/sway-core/src/semantic_analysis/ast_node/expression/typed_expression.rs
@@ -488,7 +488,7 @@ impl ty::TyExpression {
 
     pub(crate) fn type_check_variable_expression(
         handler: &Handler,
-        mut ctx: TypeCheckContext,
+        ctx: TypeCheckContext,
         name: Ident,
         span: Span,
     ) -> Result<ty::TyExpression, ErrorEmitted> {
@@ -525,98 +525,33 @@ impl ty::TyExpression {
                 let const_decl = (*decl_engine.get_constant(&decl_id)).clone();
                 let decl_name = const_decl.name().clone();
 
-                if !ctx.inside_configurable
-                    && const_decl.is_configurable
-                    && ctx.experimental.new_encoding
-                {
-                    ctx.inside_configurable = true;
-
-                    let name_span = name.span();
-                    let the_configurable = Expression {
-                        kind: ExpressionKind::Variable(name),
-                        span: name_span.clone(),
-                    };
-                    // get configurable address
-                    let ptr = Expression {
-                        kind: ExpressionKind::IntrinsicFunction(IntrinsicFunctionExpression {
-                            name: Ident::new_no_span("addr_of".into()),
-                            kind_binding: TypeBinding {
-                                inner: Intrinsic::AddrOf,
-                                type_arguments: TypeArgs::Regular(vec![]),
-                                span: Span::dummy(),
-                            },
-                            arguments: vec![the_configurable.clone()],
-                        }),
-                        span: name_span.clone(),
-                    };
-                    let len = Expression {
-                        kind: ExpressionKind::IntrinsicFunction(IntrinsicFunctionExpression {
-                            name: Ident::new_no_span("size_of_val".into()),
-                            kind_binding: TypeBinding {
-                                inner: Intrinsic::SizeOfVal,
-                                type_arguments: TypeArgs::Regular(vec![]),
-                                span: Span::dummy(),
-                            },
-                            arguments: vec![the_configurable],
-                        }),
-                        span: Span::dummy(),
-                    };
-                    let as_slice = Expression {
-                        kind: ExpressionKind::Asm(Box::new(AsmExpression {
-                            registers: vec![AsmRegisterDeclaration {
-                                name: Ident::new_no_span("slice".into()),
-                                initializer: Some(Expression {
-                                    kind: ExpressionKind::Tuple(vec![ptr, len]),
-                                    span: Span::dummy(),
-                                }),
-                            }],
-                            body: vec![],
-                            returns: Some((
-                                AsmRegister {
-                                    name: "slice".into(),
-                                },
-                                Span::dummy(),
-                            )),
-                            return_type: TypeInfo::RawUntypedSlice,
-                            whole_block_span: Span::dummy(),
-                        })),
-                        span,
-                    };
+                assert!(!const_decl.is_configurable);
+                ty::TyExpression {
+                    return_type: const_decl.return_type,
+                    expression: ty::TyExpressionVariant::ConstantExpression {
+                        const_decl: Box::new(const_decl),
+                        span: name.span(),
+                        call_path: Some(
+                            CallPath::from(decl_name).to_fullpath(ctx.engines(), ctx.namespace()),
+                        ),
+                    },
+                    span,
+                }
+            }
+            Some(ty::TyDecl::ConfigurableDecl(ty::ConfigurableDecl { decl_id, .. })) => {
+                let config_decl = (*decl_engine.get_configurable(&decl_id)).clone();
+                let decl_name = config_decl.name().clone();
 
-                    // decode it
-                    Self::type_check_function_application(
-                        handler,
-                        ctx,
-                        TypeBinding {
-                            inner: CallPath {
-                                prefixes: vec![],
-                                suffix: Ident::new_with_override(
-                                    "abi_decode".into(),
-                                    name_span.clone(),
-                                ),
-                                is_absolute: false,
-                            },
-                            type_arguments: TypeArgs::Regular(vec![const_decl
-                                .type_ascription
-                                .clone()]),
-                            span: name_span.clone(),
-                        },
-                        &[as_slice],
-                        name_span.clone(),
-                    )?
-                } else {
-                    ty::TyExpression {
-                        return_type: const_decl.return_type,
-                        expression: ty::TyExpressionVariant::ConstantExpression {
-                            const_decl: Box::new(const_decl),
-                            span: name.span(),
-                            call_path: Some(
-                                CallPath::from(decl_name)
-                                    .to_fullpath(ctx.engines(), ctx.namespace()),
-                            ),
-                        },
-                        span,
-                    }
+                ty::TyExpression {
+                    return_type: config_decl.return_type,
+                    expression: ty::TyExpressionVariant::ConfigurableExpression {
+                        const_decl: Box::new(config_decl),
+                        span: name.span(),
+                        call_path: Some(
+                            CallPath::from(decl_name).to_fullpath(ctx.engines(), ctx.namespace()),
+                        ),
+                    },
+                    span,
                 }
             }
             Some(ty::TyDecl::AbiDecl(ty::AbiDecl { decl_id, .. })) => {
@@ -2214,10 +2149,22 @@ impl ty::TyExpression {
                                 TyDecl::ConstantDecl(constant_decl) => {
                                     let constant_decl =
                                         engines.de().get_constant(&constant_decl.decl_id);
+                                    assert!(!constant_decl.is_configurable);
+                                    return Err(handler.emit_err(
+                                        CompileError::AssignmentToConstantOrConfigurable {
+                                            decl_name: constant_decl.name().clone(),
+                                            is_configurable: false,
+                                            lhs_span,
+                                        },
+                                    ));
+                                }
+                                TyDecl::ConfigurableDecl(configurable_decl) => {
+                                    let constant_decl =
+                                        engines.de().get_configurable(&configurable_decl.decl_id);
                                     return Err(handler.emit_err(
                                         CompileError::AssignmentToConstantOrConfigurable {
                                             decl_name: constant_decl.name().clone(),
-                                            is_configurable: constant_decl.is_configurable,
+                                            is_configurable: true,
                                             lhs_span,
                                         },
                                     ));
diff --git a/sway-core/src/semantic_analysis/cei_pattern_analysis.rs b/sway-core/src/semantic_analysis/cei_pattern_analysis.rs
index 1dd97707f30..91a2b7f9c4a 100644
--- a/sway-core/src/semantic_analysis/cei_pattern_analysis.rs
+++ b/sway-core/src/semantic_analysis/cei_pattern_analysis.rs
@@ -215,6 +215,7 @@ fn analyze_expression(
         // base cases: no warnings can be emitted
         Literal(_)
         | ConstantExpression { .. }
+        | ConfigurableExpression { .. }
         | VariableExpression { .. }
         | FunctionParameter
         | StorageAccess(_)
@@ -494,6 +495,7 @@ fn effects_of_expression(engines: &Engines, expr: &ty::TyExpression) -> HashSet<
     match &expr.expression {
         Literal(_)
         | ConstantExpression { .. }
+        | ConfigurableExpression { .. }
         | VariableExpression { .. }
         | FunctionParameter
         | Break
diff --git a/sway-core/src/semantic_analysis/coins_analysis.rs b/sway-core/src/semantic_analysis/coins_analysis.rs
index 9f2fdec1e6b..0fd49ed3dfb 100644
--- a/sway-core/src/semantic_analysis/coins_analysis.rs
+++ b/sway-core/src/semantic_analysis/coins_analysis.rs
@@ -21,6 +21,10 @@ pub fn possibly_nonzero_u64_expression(
             Some(expr) => possibly_nonzero_u64_expression(namespace, engines, expr),
             None => false,
         },
+        ConfigurableExpression { const_decl, .. } => match &const_decl.value {
+            Some(expr) => possibly_nonzero_u64_expression(namespace, engines, expr),
+            None => false,
+        },
         VariableExpression { name, .. } => {
             match namespace
                 .resolve_symbol_typed(&Handler::default(), engines, name, None)
diff --git a/sway-core/src/semantic_analysis/node_dependencies.rs b/sway-core/src/semantic_analysis/node_dependencies.rs
index 2112b57c1a9..fa9ea6a84fc 100644
--- a/sway-core/src/semantic_analysis/node_dependencies.rs
+++ b/sway-core/src/semantic_analysis/node_dependencies.rs
@@ -307,6 +307,10 @@ impl Dependencies {
                 let decl = engines.pe().get_constant(decl_id);
                 self.gather_from_constant_decl(engines, &decl)
             }
+            Declaration::ConfigurableDeclaration(decl_id) => {
+                let decl = engines.pe().get_configurable(decl_id);
+                self.gather_from_configurable_decl(engines, &decl)
+            }
             Declaration::TraitTypeDeclaration(decl_id) => {
                 let decl = engines.pe().get_trait_type(decl_id);
                 self.gather_from_type_decl(engines, &decl)
@@ -490,6 +494,24 @@ impl Dependencies {
         }
     }
 
+    fn gather_from_configurable_decl(
+        self,
+        engines: &Engines,
+        const_decl: &ConfigurableDeclaration,
+    ) -> Self {
+        let ConfigurableDeclaration {
+            type_ascription,
+            value,
+            ..
+        } = const_decl;
+        match value {
+            Some(value) => self
+                .gather_from_type_argument(engines, type_ascription)
+                .gather_from_expr(engines, value),
+            None => self,
+        }
+    }
+
     fn gather_from_type_decl(self, engines: &Engines, type_decl: &TraitTypeDeclaration) -> Self {
         let TraitTypeDeclaration { ty_opt, .. } = type_decl;
         match ty_opt {
@@ -879,6 +901,10 @@ fn decl_name(engines: &Engines, decl: &Declaration) -> Option<DependentSymbol> {
             let decl = engines.pe().get_constant(decl_id);
             dep_sym(decl.name.clone())
         }
+        Declaration::ConfigurableDeclaration(decl_id) => {
+            let decl = engines.pe().get_configurable(decl_id);
+            dep_sym(decl.name.clone())
+        }
         Declaration::TraitTypeDeclaration(decl_id) => {
             let decl = engines.pe().get_trait_type(decl_id);
             dep_sym(decl.name.clone())
diff --git a/sway-core/src/semantic_analysis/type_check_context.rs b/sway-core/src/semantic_analysis/type_check_context.rs
index e31a582dfd5..2da949e18bc 100644
--- a/sway-core/src/semantic_analysis/type_check_context.rs
+++ b/sway-core/src/semantic_analysis/type_check_context.rs
@@ -103,8 +103,6 @@ pub struct TypeCheckContext<'a> {
 
     /// Set of experimental flags
     pub experimental: ExperimentalFlags,
-
-    pub inside_configurable: bool,
 }
 
 impl<'a> TypeCheckContext<'a> {
@@ -132,7 +130,6 @@ impl<'a> TypeCheckContext<'a> {
             defer_monomorphization: false,
             storage_declaration: false,
             experimental,
-            inside_configurable: false,
         }
     }
 
@@ -175,7 +172,6 @@ impl<'a> TypeCheckContext<'a> {
             defer_monomorphization: false,
             storage_declaration: false,
             experimental,
-            inside_configurable: false,
         }
     }
 
@@ -206,7 +202,6 @@ impl<'a> TypeCheckContext<'a> {
             defer_monomorphization: self.defer_monomorphization,
             storage_declaration: self.storage_declaration,
             experimental: self.experimental,
-            inside_configurable: self.inside_configurable,
         }
     }
 
@@ -234,7 +229,6 @@ impl<'a> TypeCheckContext<'a> {
             defer_monomorphization: self.defer_monomorphization,
             storage_declaration: self.storage_declaration,
             experimental: self.experimental,
-            inside_configurable: self.inside_configurable,
         };
         with_scoped_ctx(ctx)
     }
@@ -263,7 +257,6 @@ impl<'a> TypeCheckContext<'a> {
             defer_monomorphization: self.defer_monomorphization,
             storage_declaration: self.storage_declaration,
             experimental: self.experimental,
-            inside_configurable: self.inside_configurable,
         };
         Ok((with_scoped_ctx(ctx)?, namespace))
     }
diff --git a/sway-core/src/transform/to_parsed_lang/convert_parse_tree.rs b/sway-core/src/transform/to_parsed_lang/convert_parse_tree.rs
index 86e9869a2d6..fc9d5a55ae8 100644
--- a/sway-core/src/transform/to_parsed_lang/convert_parse_tree.rs
+++ b/sway-core/src/transform/to_parsed_lang/convert_parse_tree.rs
@@ -225,16 +225,18 @@ pub fn item_to_ast_nodes(
                 attributes,
             )?,
         )),
-        ItemKind::Configurable(item_configurable) => item_configurable_to_constant_declarations(
-            context,
-            handler,
-            engines,
-            item_configurable,
-            &attributes,
-        )?
-        .into_iter()
-        .map(|decl| AstNodeContent::Declaration(Declaration::ConstantDeclaration(decl)))
-        .collect(),
+        ItemKind::Configurable(item_configurable) => {
+            item_configurable_to_configurable_declarations(
+                context,
+                handler,
+                engines,
+                item_configurable,
+                &attributes,
+            )?
+            .into_iter()
+            .map(|decl| AstNodeContent::Declaration(Declaration::ConfigurableDeclaration(decl)))
+            .collect()
+        }
         ItemKind::TypeAlias(item_type_alias) => decl(Declaration::TypeAliasDeclaration(
             item_type_alias_to_type_alias_declaration(
                 context,
@@ -1048,13 +1050,13 @@ fn item_storage_to_storage_declaration(
     Ok(storage_declaration)
 }
 
-fn item_configurable_to_constant_declarations(
+fn item_configurable_to_configurable_declarations(
     context: &mut Context,
     handler: &Handler,
     engines: &Engines,
     item_configurable: ItemConfigurable,
     _attributes: &AttributesMap,
-) -> Result<Vec<ParsedDeclId<ConstantDeclaration>>, ErrorEmitted> {
+) -> Result<Vec<ParsedDeclId<ConfigurableDeclaration>>, ErrorEmitted> {
     let mut errors = Vec::new();
 
     if context.module_has_configurable_block() {
@@ -1063,7 +1065,13 @@ fn item_configurable_to_constant_declarations(
         });
     }
 
-    let declarations: Vec<ParsedDeclId<ConstantDeclaration>> = item_configurable
+    if let Some(TreeType::Library) = context.program_type() {
+        handler.emit_err(CompileError::ConfigurableInLibrary {
+            span: item_configurable.span(),
+        });
+    }
+
+    let declarations: Vec<ParsedDeclId<ConfigurableDeclaration>> = item_configurable
         .fields
         .into_inner()
         .into_iter()
@@ -1073,7 +1081,7 @@ fn item_configurable_to_constant_declarations(
             if !cfg_eval(context, handler, &attributes, context.experimental)? {
                 return Ok(None);
             }
-            Ok(Some(configurable_field_to_constant_declaration(
+            Ok(Some(configurable_field_to_configurable_declaration(
                 context,
                 handler,
                 engines,
@@ -1087,7 +1095,7 @@ fn item_configurable_to_constant_declarations(
     // Make sure each configurable is declared once
     let mut names_of_declarations = std::collections::HashSet::new();
     declarations.iter().for_each(|decl_id| {
-        let v = engines.pe().get_constant(decl_id);
+        let v = engines.pe().get_configurable(decl_id);
         if !names_of_declarations.insert(v.name.clone()) {
             errors.push(ConvertParseTreeError::DuplicateConfigurable {
                 name: v.name.clone(),
@@ -2488,13 +2496,13 @@ fn storage_field_to_storage_field(
     Ok(storage_field)
 }
 
-fn configurable_field_to_constant_declaration(
+fn configurable_field_to_configurable_declaration(
     context: &mut Context,
     handler: &Handler,
     engines: &Engines,
     configurable_field: sway_ast::ConfigurableField,
     attributes: AttributesMap,
-) -> Result<ParsedDeclId<ConstantDeclaration>, ErrorEmitted> {
+) -> Result<ParsedDeclId<ConfigurableDeclaration>, ErrorEmitted> {
     let span = configurable_field.name.span();
 
     let type_ascription = ty_to_type_argument(context, handler, engines, configurable_field.ty)?;
@@ -2522,17 +2530,15 @@ fn configurable_field_to_constant_declaration(
         value
     };
 
-    let const_decl = ConstantDeclaration {
+    let config_decl = ConfigurableDeclaration {
         name: configurable_field.name,
         type_ascription,
         value: Some(value),
         visibility: Visibility::Public,
-        is_configurable: true,
         attributes,
         span: span.clone(),
     };
-    let const_decl = engines.pe().insert(const_decl);
-    Ok(const_decl)
+    Ok(engines.pe().insert(config_decl))
 }
 
 fn statement_to_ast_nodes(
diff --git a/sway-ir/src/analysis/memory_utils.rs b/sway-ir/src/analysis/memory_utils.rs
index 8c3ed672e05..10f841f5ae6 100644
--- a/sway-ir/src/analysis/memory_utils.rs
+++ b/sway-ir/src/analysis/memory_utils.rs
@@ -308,6 +308,7 @@ pub fn compute_escaped_symbols(context: &Context, function: &Function) -> Escape
             InstOp::ContractCall { params, .. } => add_from_val(&mut result, params),
             InstOp::FuelVm(_) => (),
             InstOp::GetLocal(_) => (),
+            InstOp::GetConfig(_, _) => (),
             InstOp::GetElemPtr { .. } => (),
             InstOp::IntToPtr(_, _) => (),
             InstOp::Load(_) => (),
@@ -335,6 +336,7 @@ pub fn get_loaded_ptr_values(context: &Context, val: Value) -> Vec<Value> {
         | InstOp::Nop
         | InstOp::CastPtr(_, _)
         | InstOp::GetLocal(_)
+        | InstOp::GetConfig(_, _)
         | InstOp::GetElemPtr { .. }
         | InstOp::IntToPtr(_, _) => vec![],
         InstOp::PtrToInt(src_val_ptr, _) => vec![*src_val_ptr],
@@ -415,6 +417,7 @@ pub fn get_stored_ptr_values(context: &Context, val: Value) -> Vec<Value> {
         | InstOp::Ret(_, _)
         | InstOp::CastPtr(_, _)
         | InstOp::GetLocal(_)
+        | InstOp::GetConfig(_, _)
         | InstOp::GetElemPtr { .. }
         | InstOp::IntToPtr(_, _) => vec![],
         InstOp::ContractCall { params, .. } => vec![*params],
diff --git a/sway-ir/src/block.rs b/sway-ir/src/block.rs
index f98e8628221..b16e7212ad7 100644
--- a/sway-ir/src/block.rs
+++ b/sway-ir/src/block.rs
@@ -19,7 +19,7 @@ use crate::{
     instruction::{FuelVmInstruction, InstOp},
     value::{Value, ValueDatum},
     BranchToWithArgs, DebugWithContext, Instruction, InstructionInserter, InstructionIterator,
-    Type,
+    Module, Type,
 };
 
 /// A wrapper around an [ECS](https://github.com/orlp/slotmap) handle into the
@@ -27,6 +27,13 @@ use crate::{
 #[derive(Clone, Copy, Debug, Eq, PartialEq, Hash, DebugWithContext)]
 pub struct Block(pub slotmap::DefaultKey);
 
+impl Block {
+    pub fn get_module<'a>(&self, context: &'a Context) -> &'a Module {
+        let f = context.blocks[self.0].function;
+        &context.functions[f.0].module
+    }
+}
+
 #[doc(hidden)]
 pub struct BlockContent {
     /// Block label, useful for printing.
diff --git a/sway-ir/src/context.rs b/sway-ir/src/context.rs
index 50588505382..aae892bff79 100644
--- a/sway-ir/src/context.rs
+++ b/sway-ir/src/context.rs
@@ -11,9 +11,13 @@ use slotmap::{DefaultKey, SlotMap};
 use sway_types::SourceEngine;
 
 use crate::{
-    block::BlockContent, function::FunctionContent, local_var::LocalVarContent,
-    metadata::Metadatum, module::Kind, module::ModuleContent, module::ModuleIterator,
-    value::ValueContent, Type, TypeContent,
+    block::BlockContent,
+    function::FunctionContent,
+    local_var::LocalVarContent,
+    metadata::Metadatum,
+    module::{Kind, ModuleContent, ModuleIterator},
+    value::ValueContent,
+    Type, TypeContent,
 };
 
 /// The main IR context handle.
diff --git a/sway-ir/src/instruction.rs b/sway-ir/src/instruction.rs
index 202fe08fb20..51d60f9c171 100644
--- a/sway-ir/src/instruction.rs
+++ b/sway-ir/src/instruction.rs
@@ -19,7 +19,7 @@ use crate::{
     local_var::LocalVar,
     pretty::DebugWithContext,
     value::{Value, ValueDatum},
-    AsmInstruction, Constant,
+    AsmInstruction, Constant, Module,
 };
 
 #[derive(Debug, Clone, DebugWithContext)]
@@ -85,6 +85,8 @@ pub enum InstOp {
     FuelVm(FuelVmInstruction),
     /// Return a local variable.
     GetLocal(LocalVar),
+    /// Return a ptr to a config
+    GetConfig(Module, String),
     /// Translate a pointer from a base to a nested element in an aggregate type.
     GetElemPtr {
         base: Value,
@@ -286,7 +288,6 @@ impl InstOp {
             // Load needs to strip the pointer from the source type.
             InstOp::Load(ptr_val) => match &context.values[ptr_val.0].value {
                 ValueDatum::Argument(arg) => arg.ty.get_pointee_type(context),
-                ValueDatum::Configurable(conf) => conf.ty.get_pointee_type(context),
                 ValueDatum::Constant(cons) => cons.ty.get_pointee_type(context),
                 ValueDatum::Instruction(ins) => ins
                     .get_type(context)
@@ -296,6 +297,12 @@ impl InstOp {
             // These return pointer types.
             InstOp::GetElemPtr { elem_ptr_ty, .. } => Some(*elem_ptr_ty),
             InstOp::GetLocal(local_var) => Some(local_var.get_type(context)),
+            InstOp::GetConfig(module, name) => {
+                Some(match module.get_global_configurable(context, name)? {
+                    crate::ConfigurableContent::V0 { ptr_ty, .. } => *ptr_ty,
+                    crate::ConfigurableContent::V1 { ptr_ty, .. } => *ptr_ty,
+                })
+            }
 
             // Use for casting between pointers and pointer-width integers.
             InstOp::IntToPtr(_, ptr_ty) => Some(*ptr_ty),
@@ -379,6 +386,9 @@ impl InstOp {
                 // TODO: Not sure.
                 vec![]
             }
+            InstOp::GetConfig(_, _) => {
+                vec![]
+            }
             InstOp::IntToPtr(v, _) => vec![*v],
             InstOp::Load(v) => vec![*v],
             InstOp::MemCopyBytes {
@@ -508,6 +518,7 @@ impl InstOp {
                 replace(gas);
             }
             InstOp::GetLocal(_) => (),
+            InstOp::GetConfig(_, _) => (),
             InstOp::GetElemPtr {
                 base,
                 elem_ptr_ty: _,
@@ -668,6 +679,7 @@ impl InstOp {
             | InstOp::FuelVm(FuelVmInstruction::StateLoadWord(_))
             | InstOp::GetElemPtr { .. }
             | InstOp::GetLocal(_)
+            | InstOp::GetConfig(_, _)
             | InstOp::IntToPtr(..)
             | InstOp::Load(_)
             | InstOp::Nop
@@ -1021,6 +1033,10 @@ impl<'a, 'eng> InstructionInserter<'a, 'eng> {
         insert_instruction!(self, InstOp::GetLocal(local_var))
     }
 
+    pub fn get_config(self, module: Module, name: String) -> Value {
+        insert_instruction!(self, InstOp::GetConfig(module, name))
+    }
+
     pub fn int_to_ptr(self, value: Value, ty: Type) -> Value {
         insert_instruction!(self, InstOp::IntToPtr(value, ty))
     }
diff --git a/sway-ir/src/module.rs b/sway-ir/src/module.rs
index d432ea8988d..5240aa642f6 100644
--- a/sway-ir/src/module.rs
+++ b/sway-ir/src/module.rs
@@ -8,6 +8,7 @@ use crate::{
     context::Context,
     function::{Function, FunctionIterator},
     value::Value,
+    Constant, MetadataIndex, Type,
 };
 
 /// A wrapper around an [ECS](https://github.com/orlp/slotmap) handle into the
@@ -20,7 +21,26 @@ pub struct ModuleContent {
     pub kind: Kind,
     pub functions: Vec<Function>,
     pub global_constants: HashMap<Vec<String>, Value>,
-    pub global_configurable: BTreeMap<Vec<String>, Value>,
+    pub global_configurable: BTreeMap<String, ConfigurableContent>,
+}
+
+#[derive(Clone, Debug)]
+pub enum ConfigurableContent {
+    V0 {
+        name: String,
+        ty: Type,
+        ptr_ty: Type,
+        constant: Constant,
+        opt_metadata: Option<MetadataIndex>,
+    },
+    V1 {
+        name: String,
+        ty: Type,
+        ptr_ty: Type,
+        encoded_bytes: Vec<u8>,
+        decode_fn: Function,
+        opt_metadata: Option<MetadataIndex>,
+    },
 }
 
 /// The different 'kinds' of Sway module: `Contract`, `Library`, `Predicate` or `Script`.
@@ -78,24 +98,21 @@ impl Module {
     pub fn add_global_configurable(
         &self,
         context: &mut Context,
-        call_path: Vec<String>,
-        config_val: Value,
+        name: String,
+        config_val: ConfigurableContent,
     ) {
         context.modules[self.0]
             .global_configurable
-            .insert(call_path, config_val);
+            .insert(name, config_val);
     }
 
     /// Get a named global configurable value from this module, if found.
-    pub fn get_global_configurable(
+    pub fn get_global_configurable<'a>(
         &self,
-        context: &Context,
-        call_path: &Vec<String>,
-    ) -> Option<Value> {
-        context.modules[self.0]
-            .global_configurable
-            .get(call_path)
-            .copied()
+        context: &'a Context,
+        name: &str,
+    ) -> Option<&'a ConfigurableContent> {
+        context.modules[self.0].global_configurable.get(name)
     }
 
     /// Removed a function from the module.  Returns true if function was found and removed.
@@ -109,6 +126,13 @@ impl Module {
             .functions
             .retain(|mod_fn| mod_fn != function);
     }
+
+    pub fn iter_configurables<'a>(
+        &'a self,
+        context: &'a Context,
+    ) -> impl Iterator<Item = &ConfigurableContent> + 'a {
+        context.modules[self.0].global_configurable.values()
+    }
 }
 
 /// An iterator over [`Module`]s within a [`Context`].
diff --git a/sway-ir/src/optimize/dce.rs b/sway-ir/src/optimize/dce.rs
index 4c988099309..ed3e005ee28 100644
--- a/sway-ir/src/optimize/dce.rs
+++ b/sway-ir/src/optimize/dce.rs
@@ -130,8 +130,7 @@ pub fn dce(
                         .and_modify(|count| *count += 1)
                         .or_insert(1);
                 }
-                ValueDatum::Configurable(_) | ValueDatum::Constant(_) | ValueDatum::Argument(_) => {
-                }
+                ValueDatum::Constant(_) | ValueDatum::Argument(_) => {}
             }
         }
     }
@@ -165,8 +164,7 @@ pub fn dce(
                         worklist.push(v);
                     }
                 }
-                ValueDatum::Configurable(_) | ValueDatum::Constant(_) | ValueDatum::Argument(_) => {
-                }
+                ValueDatum::Constant(_) | ValueDatum::Argument(_) => {}
             }
         }
         for sym in memory_utils::get_loaded_symbols(context, dead) {
@@ -216,36 +214,22 @@ pub fn dce(
 /// Functions which are `pub` will not be removed and only functions within the passed [`Module`]
 /// are considered for removal.
 pub fn fn_dce(context: &mut Context, _: &AnalysisResults, module: Module) -> Result<bool, IrError> {
+    let mut called_fns: HashSet<Function> = HashSet::new();
+
+    // config decode fns
+    for config in context.modules[module.0].global_configurable.iter() {
+        if let crate::ConfigurableContent::V1 { decode_fn, .. } = config.1 {
+            grow_called_function_set(context, *decode_fn, &mut called_fns);
+        }
+    }
+
+    // entry fns and fallback
     let entry_fns = module
         .function_iter(context)
         .filter(|func| func.is_entry(context) || func.is_fallback(context))
         .collect::<Vec<_>>();
-    // Recursively find all the functions called by an entry function.
-    fn grow_called_function_set(
-        context: &Context,
-        caller: Function,
-        called_set: &mut HashSet<Function>,
-    ) {
-        if called_set.insert(caller) {
-            // We haven't seen caller before.  Iterate for all that it calls.
-            for func in caller
-                .instruction_iter(context)
-                .filter_map(|(_block, ins_value)| {
-                    ins_value
-                        .get_instruction(context)
-                        .and_then(|ins| match &ins.op {
-                            InstOp::Call(f, _args) => Some(f),
-                            _otherwise => None,
-                        })
-                })
-            {
-                grow_called_function_set(context, *func, called_set);
-            }
-        }
-    }
 
-    // Gather our entry functions together into a set.
-    let mut called_fns: HashSet<Function> = HashSet::new();
+    // expand all called fns
     for entry_fn in entry_fns {
         grow_called_function_set(context, entry_fn, &mut called_fns);
     }
@@ -264,3 +248,27 @@ pub fn fn_dce(context: &mut Context, _: &AnalysisResults, module: Module) -> Res
 
     Ok(modified)
 }
+
+// Recursively find all the functions called by an entry function.
+fn grow_called_function_set(
+    context: &Context,
+    caller: Function,
+    called_set: &mut HashSet<Function>,
+) {
+    if called_set.insert(caller) {
+        // We haven't seen caller before.  Iterate for all that it calls.
+        for func in caller
+            .instruction_iter(context)
+            .filter_map(|(_block, ins_value)| {
+                ins_value
+                    .get_instruction(context)
+                    .and_then(|ins| match &ins.op {
+                        InstOp::Call(f, _args) => Some(f),
+                        _otherwise => None,
+                    })
+            })
+        {
+            grow_called_function_set(context, *func, called_set);
+        }
+    }
+}
diff --git a/sway-ir/src/optimize/fn_dedup.rs b/sway-ir/src/optimize/fn_dedup.rs
index 39fd55febb9..257db379a72 100644
--- a/sway-ir/src/optimize/fn_dedup.rs
+++ b/sway-ir/src/optimize/fn_dedup.rs
@@ -82,7 +82,7 @@ fn hash_fn(
             crate::ValueDatum::Argument(_) | crate::ValueDatum::Instruction(_) => {
                 get_localised_id(v, localised_value_id).hash(hasher)
             }
-            crate::ValueDatum::Configurable(c) | crate::ValueDatum::Constant(c) => c.hash(hasher),
+            crate::ValueDatum::Constant(c) => c.hash(hasher),
         }
         if let Some(m) = &context.values.get(v.0).unwrap().metadata {
             if !ignore_metadata {
@@ -259,6 +259,7 @@ fn hash_fn(
                     .lookup_local_name(context, local)
                     .unwrap()
                     .hash(state),
+                crate::InstOp::GetConfig(_, name) => name.hash(state),
                 crate::InstOp::GetElemPtr { elem_ptr_ty, .. } => elem_ptr_ty.hash(state),
                 crate::InstOp::IntToPtr(_, ty) => ty.hash(state),
                 crate::InstOp::Load(_) => (),
diff --git a/sway-ir/src/optimize/inline.rs b/sway-ir/src/optimize/inline.rs
index beb42eedb3d..e396cc90df7 100644
--- a/sway-ir/src/optimize/inline.rs
+++ b/sway-ir/src/optimize/inline.rs
@@ -592,6 +592,7 @@ fn inline_instruction(
             InstOp::GetLocal(local_var) => {
                 new_block.append(context).get_local(map_local(local_var))
             }
+            InstOp::GetConfig(module, name) => new_block.append(context).get_config(module, name),
             InstOp::IntToPtr(value, ty) => {
                 new_block.append(context).int_to_ptr(map_value(value), ty)
             }
diff --git a/sway-ir/src/parser.rs b/sway-ir/src/parser.rs
index 9c11c2cf057..6e58c0c53fe 100644
--- a/sway-ir/src/parser.rs
+++ b/sway-ir/src/parser.rs
@@ -25,6 +25,7 @@ pub fn parse<'eng>(
 // -------------------------------------------------------------------------------------------------
 
 mod ir_builder {
+    use slotmap::KeyData;
     use sway_types::{ident::Ident, span::Span, u256::U256, SourceEngine};
 
     type MdIdxRef = u64;
@@ -66,13 +67,19 @@ mod ir_builder {
                     }
                 }
 
+            rule config_encoded_bytes() -> Vec<u8>
+                = "0x" s:$(hex_digit()*<64>) _ {
+                    hex_string_to_vec(s)
+                }
+
             rule init_config() -> IrAstConfig
-                = value_name:value_assign() "config" _ val_ty:ast_ty() cv:constant()
+                = value_name:value_assign() "config" _ val_ty:ast_ty() _ "," _ decode_fn:id() _ "," _ encoded_bytes:config_encoded_bytes()
                 metadata:comma_metadata_idx()? {
                     IrAstConfig {
                         value_name,
                         ty: val_ty,
-                        const_val: cv,
+                        encoded_bytes,
+                        decode_fn,
                         metadata,
                     }
                 }
@@ -197,6 +204,7 @@ mod ir_builder {
                 / op_contract_call()
                 / op_get_elem_ptr()
                 / op_get_local()
+                / op_get_config()
                 / op_gtf()
                 / op_int_to_ptr()
                 / op_load()
@@ -313,6 +321,11 @@ mod ir_builder {
                     IrAstOperation::GetLocal(name)
                 }
 
+            rule op_get_config() -> IrAstOperation
+                = "get_config" _ ast_ty() comma() name:id() {
+                    IrAstOperation::GetConfig(name)
+                }
+
             rule op_gtf() -> IrAstOperation
                 = "gtf" _ index:id() comma() tx_field_id:decimal()  {
                     IrAstOperation::Gtf(index, tx_field_id)
@@ -663,7 +676,8 @@ mod ir_builder {
         metadata::{MetadataIndex, Metadatum},
         module::{Kind, Module},
         value::Value,
-        BinaryOpKind, BlockArgument, ExperimentalFlags, Instruction, UnaryOpKind, B256,
+        BinaryOpKind, BlockArgument, ConfigurableContent, ExperimentalFlags, Instruction,
+        UnaryOpKind, B256,
     };
 
     #[derive(Debug)]
@@ -723,6 +737,7 @@ mod ir_builder {
         ContractCall(IrAstTy, String, String, String, String, String),
         GetElemPtr(String, IrAstTy, Vec<String>),
         GetLocal(String),
+        GetConfig(String),
         Gtf(String, u64),
         IntToPtr(String, IrAstTy),
         Load(String),
@@ -752,7 +767,8 @@ mod ir_builder {
     struct IrAstConfig {
         value_name: String,
         ty: IrAstTy,
-        const_val: IrAstConst,
+        encoded_bytes: Vec<u8>,
+        decode_fn: String,
         metadata: Option<MdIdxRef>,
     }
 
@@ -925,7 +941,10 @@ mod ir_builder {
 
     // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 
-    use std::{collections::HashMap, iter::FromIterator};
+    use std::{
+        collections::{BTreeMap, HashMap},
+        iter::FromIterator,
+    };
 
     pub(super) fn build_context(
         ir_ast_mod: IrAstModule,
@@ -945,6 +964,7 @@ mod ir_builder {
         for fn_decl in ir_ast_mod.fn_decls {
             builder.add_fn_decl(&mut ctx, fn_decl)?;
         }
+
         builder.resolve_calls(&mut ctx)?;
 
         Ok(ctx)
@@ -952,7 +972,7 @@ mod ir_builder {
 
     struct IrBuilder {
         module: Module,
-        configs_map: HashMap<String, Value>,
+        configs_map: BTreeMap<String, String>,
         md_map: HashMap<MdIdxRef, MetadataIndex>,
         unresolved_calls: Vec<PendingCall>,
     }
@@ -992,9 +1012,7 @@ mod ir_builder {
                 convert_md_idx(&fn_decl.metadata),
             );
 
-            // Gather all the (new) arg values by name into a map. Initialize this map with all
-            // config variables as they are globally available
-            let mut arg_map = self.configs_map.clone();
+            let mut arg_map = HashMap::default();
             let mut local_map = HashMap::<String, LocalVar>::new();
             for (ty, name, initializer, mutable) in fn_decl.locals {
                 let initializer = initializer.map(|const_init| {
@@ -1278,6 +1296,10 @@ mod ir_builder {
                         .append(context)
                         .get_local(*local_map.get(&local_name).unwrap())
                         .add_metadatum(context, opt_metadata),
+                    IrAstOperation::GetConfig(name) => block
+                        .append(context)
+                        .get_config(self.module, name)
+                        .add_metadatum(context, opt_metadata),
                     IrAstOperation::Gtf(index, tx_field_id) => block
                         .append(context)
                         .gtf(*val_map.get(&index).unwrap(), tx_field_id)
@@ -1417,6 +1439,24 @@ mod ir_builder {
         }
 
         fn resolve_calls(self, context: &mut Context) -> Result<(), IrError> {
+            for (configurable_name, fn_name) in self.configs_map {
+                let f = self
+                    .module
+                    .function_iter(context)
+                    .find(|x| x.get_name(context) == fn_name)
+                    .unwrap();
+
+                if let Some(ConfigurableContent::V1 { decode_fn, .. }) = context
+                    .modules
+                    .get_mut(self.module.0)
+                    .unwrap()
+                    .global_configurable
+                    .get_mut(&configurable_name)
+                {
+                    *decode_fn = f;
+                }
+            }
+
             // All of the call instructions are currently invalid (recursive) CALLs to their own
             // function, which need to be replaced with the proper callee function.  We couldn't do
             // it above until we'd gone and created all the functions first.
@@ -1450,28 +1490,36 @@ mod ir_builder {
     fn build_configs_map(
         context: &mut Context,
         module: &Module,
-        ir_configs: Vec<IrAstConfig>,
+        configs: Vec<IrAstConfig>,
         md_map: &HashMap<MdIdxRef, MetadataIndex>,
-    ) -> HashMap<String, Value> {
-        ir_configs
-            .iter()
+    ) -> BTreeMap<String, String> {
+        configs
+            .into_iter()
             .map(|config| {
                 let opt_metadata = config
                     .metadata
                     .map(|mdi| md_map.get(&mdi).unwrap())
                     .copied();
-                let as_const = config
-                    .const_val
-                    .value
-                    .as_constant(context, config.ty.clone());
-                let config_val =
-                    Value::new_configurable(context, as_const).add_metadatum(context, opt_metadata);
+
+                let ty = config.ty.to_ir_type(context);
+
+                let config_val = ConfigurableContent::V1 {
+                    name: config.value_name.clone(),
+                    ty,
+                    ptr_ty: Type::new_ptr(context, ty),
+                    encoded_bytes: config.encoded_bytes,
+                    // this will point to the correct function after all functions are compiled
+                    decode_fn: Function(KeyData::default().into()),
+                    opt_metadata,
+                };
+
                 module.add_global_configurable(
                     context,
-                    vec![config.value_name.clone()],
-                    config_val,
+                    config.value_name.clone(),
+                    config_val.clone(),
                 );
-                (config.value_name.clone(), config_val)
+
+                (config.value_name.clone(), config.decode_fn.clone())
             })
             .collect()
     }
@@ -1533,6 +1581,19 @@ mod ir_builder {
         }
         bytes
     }
+
+    fn hex_string_to_vec(s: &str) -> Vec<u8> {
+        let mut bytes = vec![];
+        let mut cur_byte: u8 = 0;
+        for (idx, ch) in s.chars().enumerate() {
+            cur_byte = (cur_byte << 4) | ch.to_digit(16).unwrap() as u8;
+            if idx % 2 == 1 {
+                bytes.push(cur_byte);
+                cur_byte = 0;
+            }
+        }
+        bytes
+    }
 }
 
 // -------------------------------------------------------------------------------------------------
diff --git a/sway-ir/src/printer.rs b/sway-ir/src/printer.rs
index 3c8db5557ff..08bce2b18fa 100644
--- a/sway-ir/src/printer.rs
+++ b/sway-ir/src/printer.rs
@@ -18,8 +18,8 @@ use crate::{
     metadata::{MetadataIndex, Metadatum},
     module::{Kind, ModuleContent},
     value::{Value, ValueContent, ValueDatum},
-    AnalysisResult, AnalysisResultT, AnalysisResults, BinaryOpKind, BlockArgument, IrError, Module,
-    Pass, PassMutability, ScopedPass, UnaryOpKind,
+    AnalysisResult, AnalysisResultT, AnalysisResults, BinaryOpKind, BlockArgument,
+    ConfigurableContent, IrError, Module, Pass, PassMutability, ScopedPass, UnaryOpKind,
 };
 
 #[derive(Debug)]
@@ -147,7 +147,7 @@ pub fn function_print(context: &Context, function: Function) {
         function_to_doc(
             context,
             &mut md_namer,
-            &mut Namer::new(function, GlobalNamer::new()),
+            &mut Namer::new(function),
             context.functions.get(function.0).unwrap()
         )
         .append(md_namer.to_doc(context))
@@ -171,7 +171,6 @@ fn module_to_doc<'a>(
     md_namer: &mut MetadataNamer,
     module: &'a ModuleContent,
 ) -> Doc {
-    let mut global_namer = GlobalNamer::new();
     Doc::line(Doc::Text(format!(
         "{} {{",
         match module.kind {
@@ -187,7 +186,7 @@ fn module_to_doc<'a>(
             module
                 .global_configurable
                 .values()
-                .map(|value| config_to_doc(context, md_namer, &mut global_namer, value))
+                .map(|value| config_to_doc(context, value, md_namer))
                 .collect(),
         ),
     ))
@@ -206,7 +205,7 @@ fn module_to_doc<'a>(
                     function_to_doc(
                         context,
                         md_namer,
-                        &mut Namer::new(*function, global_namer.clone()),
+                        &mut Namer::new(*function),
                         &context.functions[function.0],
                     )
                 })
@@ -217,6 +216,53 @@ fn module_to_doc<'a>(
     .append(Doc::text_line("}"))
 }
 
+fn config_to_doc(
+    context: &Context,
+    configurable: &ConfigurableContent,
+    md_namer: &mut MetadataNamer,
+) -> Doc {
+    match configurable {
+        ConfigurableContent::V0 {
+            name,
+            constant,
+            opt_metadata,
+            ..
+        } => Doc::line(
+            Doc::text(format!(
+                "{} = config {}",
+                name,
+                constant.as_lit_string(context)
+            ))
+            .append(md_namer.md_idx_to_doc(context, opt_metadata)),
+        ),
+        ConfigurableContent::V1 {
+            name,
+            ty,
+            encoded_bytes,
+            decode_fn,
+            opt_metadata,
+            ..
+        } => {
+            let ty = ty.as_string(context);
+            let bytes = encoded_bytes
+                .iter()
+                .map(|b| format!("{b:02x}"))
+                .collect::<Vec<String>>()
+                .concat();
+            Doc::line(
+                Doc::text(format!(
+                    "{} = config {}, {}, 0x{}",
+                    name,
+                    ty,
+                    decode_fn.get_name(context),
+                    bytes,
+                ))
+                .append(md_namer.md_idx_to_doc(context, opt_metadata)),
+            )
+        }
+    }
+}
+
 fn function_to_doc<'a>(
     context: &'a Context,
     md_namer: &mut MetadataNamer,
@@ -350,30 +396,6 @@ fn block_to_doc(
     ))
 }
 
-fn config_to_doc(
-    context: &Context,
-    md_namer: &mut MetadataNamer,
-    global_namer: &mut GlobalNamer,
-    const_val: &Value,
-) -> Doc {
-    if let ValueContent {
-        value: ValueDatum::Configurable(configurable),
-        metadata,
-    } = &context.values[const_val.0]
-    {
-        Doc::line(
-            Doc::text(format!(
-                "{} = config {}",
-                global_namer.name(context, const_val),
-                configurable.as_lit_string(context)
-            ))
-            .append(md_namer.md_idx_to_doc(context, metadata)),
-        )
-    } else {
-        unreachable!("Not a constant value.")
-    }
-}
-
 fn constant_to_doc(
     context: &Context,
     md_namer: &mut MetadataNamer,
@@ -893,6 +915,22 @@ fn instruction_to_doc<'a>(
                     .append(md_namer.md_idx_to_doc(context, metadata)),
                 )
             }
+            InstOp::GetConfig(_, name) => Doc::line(
+                match block
+                    .get_module(context)
+                    .get_global_configurable(context, name)
+                    .unwrap()
+                {
+                    ConfigurableContent::V0 { name, ptr_ty, .. }
+                    | ConfigurableContent::V1 { name, ptr_ty, .. } => Doc::text(format!(
+                        "{} = get_config {}, {}",
+                        namer.name(context, ins_value),
+                        ptr_ty.as_string(context),
+                        name,
+                    )),
+                }
+                .append(md_namer.md_idx_to_doc(context, metadata)),
+            ),
             InstOp::IntToPtr(value, ty) => maybe_constant_to_doc(context, md_namer, namer, value)
                 .append(Doc::line(
                     Doc::text(format!(
@@ -1135,52 +1173,16 @@ impl Constant {
     }
 }
 
-#[derive(Clone)]
-struct GlobalNamer {
-    names: HashMap<Value, String>,
-    next_configurable_idx: u64,
-}
-
-impl GlobalNamer {
-    fn new() -> Self {
-        GlobalNamer {
-            names: HashMap::new(),
-            next_configurable_idx: 0,
-        }
-    }
-
-    fn name(&mut self, context: &Context, value: &Value) -> String {
-        match &context.values[value.0].value {
-            ValueDatum::Configurable(_) => self.default_configurable_name(value),
-            _ => todo!(),
-        }
-    }
-
-    fn default_configurable_name(&mut self, value: &Value) -> String {
-        self.names.get(value).cloned().unwrap_or_else(|| {
-            let new_name = format!("c{}", self.next_configurable_idx);
-            self.next_configurable_idx += 1;
-            self.names.insert(*value, new_name.clone());
-            new_name
-        })
-    }
-}
-
 struct Namer {
     function: Function,
-
-    // To make things easier, each `Namer` also gets a `GlobalNamer` which includes all globally
-    // available names (such as config constants).
-    global_namer: GlobalNamer,
     names: HashMap<Value, String>,
     next_value_idx: u64,
 }
 
 impl Namer {
-    fn new(function: Function, global_namer: GlobalNamer) -> Self {
+    fn new(function: Function) -> Self {
         Namer {
             function,
-            global_namer,
             names: HashMap::new(),
             next_value_idx: 0,
         }
@@ -1193,7 +1195,6 @@ impl Namer {
                 .lookup_arg_name(context, value)
                 .cloned()
                 .unwrap_or_else(|| self.default_name(value)),
-            ValueDatum::Configurable(_) => self.global_namer.name(context, value),
             ValueDatum::Constant(_) => self.default_name(value),
             ValueDatum::Instruction(_) => self.default_name(value),
         }
diff --git a/sway-ir/src/value.rs b/sway-ir/src/value.rs
index 3f87325da22..73a51f04ac6 100644
--- a/sway-ir/src/value.rs
+++ b/sway-ir/src/value.rs
@@ -35,7 +35,6 @@ pub struct ValueContent {
 #[derive(Debug, Clone, DebugWithContext)]
 pub enum ValueDatum {
     Argument(BlockArgument),
-    Configurable(Constant),
     Constant(Constant),
     Instruction(Instruction),
 }
@@ -50,15 +49,6 @@ impl Value {
         Value(context.values.insert(content))
     }
 
-    /// Return a new constant [`Value`].
-    pub fn new_configurable(context: &mut Context, constant: Constant) -> Value {
-        let content = ValueContent {
-            value: ValueDatum::Configurable(constant),
-            metadata: None,
-        };
-        Value(context.values.insert(content))
-    }
-
     /// Return a new constant [`Value`].
     pub fn new_constant(context: &mut Context, constant: Constant) -> Value {
         let content = ValueContent {
@@ -101,11 +91,6 @@ impl Value {
         context.values[self.0].metadata
     }
 
-    /// Return whether this is a constant value.
-    pub fn is_configurable(&self, context: &Context) -> bool {
-        matches!(context.values[self.0].value, ValueDatum::Configurable(_))
-    }
-
     /// Return whether this is a constant value.
     pub fn is_constant(&self, context: &Context) -> bool {
         matches!(context.values[self.0].value, ValueDatum::Constant(_))
@@ -124,9 +109,7 @@ impl Value {
                     | InstOp::Ret(_, _)
                     | InstOp::FuelVm(FuelVmInstruction::Revert(_) | FuelVmInstruction::JmpMem)
             ),
-            ValueDatum::Argument(..) | ValueDatum::Configurable(..) | ValueDatum::Constant(..) => {
-                false
-            }
+            ValueDatum::Argument(..) | ValueDatum::Constant(..) => false,
         }
     }
 
@@ -175,15 +158,6 @@ impl Value {
         }
     }
 
-    /// Get a reference to this value as a constant, iff it is one.
-    pub fn get_configurable<'a>(&self, context: &'a Context) -> Option<&'a Constant> {
-        if let ValueDatum::Configurable(cn) = &context.values[self.0].value {
-            Some(cn)
-        } else {
-            None
-        }
-    }
-
     /// Get a reference to this value as a constant, iff it is one.
     pub fn get_constant<'a>(&self, context: &'a Context) -> Option<&'a Constant> {
         if let ValueDatum::Constant(cn) = &context.values[self.0].value {
@@ -206,7 +180,6 @@ impl Value {
     pub fn get_constant_or_configurable<'a>(&self, context: &'a Context) -> Option<&'a Constant> {
         match &context.values[self.0].value {
             ValueDatum::Constant(cn) => Some(cn),
-            ValueDatum::Configurable(cn) => Some(cn),
             _ => None,
         }
     }
@@ -217,7 +190,6 @@ impl Value {
     pub fn get_type(&self, context: &Context) -> Option<Type> {
         match &context.values[self.0].value {
             ValueDatum::Argument(BlockArgument { ty, .. }) => Some(*ty),
-            ValueDatum::Configurable(c) => Some(c.ty),
             ValueDatum::Constant(c) => Some(c.ty),
             ValueDatum::Instruction(ins) => ins.get_type(context),
         }
diff --git a/sway-ir/src/verify.rs b/sway-ir/src/verify.rs
index f394c8d5593..884e32a1e8a 100644
--- a/sway-ir/src/verify.rs
+++ b/sway-ir/src/verify.rs
@@ -293,6 +293,7 @@ impl<'a, 'eng> InstructionVerifier<'a, 'eng> {
                         indices,
                     } => self.verify_get_elem_ptr(base, elem_ptr_ty, indices)?,
                     InstOp::GetLocal(local_var) => self.verify_get_local(local_var)?,
+                    InstOp::GetConfig(_, name) => self.verify_get_config(self.cur_module, name)?,
                     InstOp::IntToPtr(value, ty) => self.verify_int_to_ptr(value, ty)?,
                     InstOp::Load(ptr) => self.verify_load(ptr)?,
                     InstOp::MemCopyBytes {
@@ -786,6 +787,17 @@ impl<'a, 'eng> InstructionVerifier<'a, 'eng> {
         }
     }
 
+    fn verify_get_config(&self, module: Module, name: &str) -> Result<(), IrError> {
+        if !self.context.modules[module.0]
+            .global_configurable
+            .contains_key(name)
+        {
+            Err(IrError::VerifyGetNonExistentPointer)
+        } else {
+            Ok(())
+        }
+    }
+
     fn verify_gtf(&self, index: &Value, _tx_field_id: &u64) -> Result<(), IrError> {
         // We should perhaps verify that _tx_field_id fits in a twelve bit immediate
         if !index.get_type(self.context).is(Type::is_uint, self.context) {
diff --git a/sway-lib-core/src/codec.sw b/sway-lib-core/src/codec.sw
index 977743056c5..bc045a460be 100644
--- a/sway-lib-core/src/codec.sw
+++ b/sway-lib-core/src/codec.sw
@@ -2505,6 +2505,22 @@ where
     T::abi_decode(buffer)
 }
 
+#[inline(never)]
+pub fn abi_decode_in_place<T>(ptr: raw_ptr, len: u64, target: raw_ptr)
+where
+    T: AbiDecode,
+{
+    let mut buffer = BufferReader::from_parts(ptr, len);
+    let temp = T::abi_decode(buffer);
+    asm(
+        target: target,
+        temp: __addr_of(temp),
+        size: __size_of::<T>(),
+    ) {
+        mcp target temp size;
+    }
+}
+
 // Decode 
 
 pub trait AbiDecode {
diff --git a/sway-lsp/src/core/token.rs b/sway-lsp/src/core/token.rs
index 1f4a72373ea..2ad19cfcb02 100644
--- a/sway-lsp/src/core/token.rs
+++ b/sway-lsp/src/core/token.rs
@@ -65,6 +65,7 @@ pub enum TypedAstToken {
     TypedScrutinee(ty::TyScrutinee),
     TyStructScrutineeField(ty::TyStructScrutineeField),
     TypedConstantDeclaration(ty::TyConstantDecl),
+    TypedConfigurableDeclaration(ty::TyConfigurableDecl),
     TypedTraitTypeDeclaration(ty::TyTraitType),
     TypedFunctionDeclaration(ty::TyFunctionDecl),
     TypedFunctionParameter(ty::TyFunctionParameter),
diff --git a/sway-lsp/src/traverse/parsed_tree.rs b/sway-lsp/src/traverse/parsed_tree.rs
index b6a173afbff..3c449996e92 100644
--- a/sway-lsp/src/traverse/parsed_tree.rs
+++ b/sway-lsp/src/traverse/parsed_tree.rs
@@ -19,11 +19,12 @@ use sway_core::{
     language::{
         parsed::{
             AbiCastExpression, AbiDeclaration, AmbiguousPathExpression, ArrayExpression,
-            ArrayIndexExpression, AstNode, AstNodeContent, ConstantDeclaration, Declaration,
-            DelineatedPathExpression, EnumDeclaration, EnumVariant, Expression, ExpressionKind,
-            ForLoopExpression, FunctionApplicationExpression, FunctionDeclaration,
-            FunctionParameter, IfExpression, ImplItem, ImplSelf, ImplTrait, ImportType,
-            IncludeStatement, IntrinsicFunctionExpression, LazyOperatorExpression, MatchExpression,
+            ArrayIndexExpression, AstNode, AstNodeContent, ConfigurableDeclaration,
+            ConstantDeclaration, Declaration, DelineatedPathExpression, EnumDeclaration,
+            EnumVariant, Expression, ExpressionKind, ForLoopExpression,
+            FunctionApplicationExpression, FunctionDeclaration, FunctionParameter, IfExpression,
+            ImplItem, ImplSelf, ImplTrait, ImportType, IncludeStatement,
+            IntrinsicFunctionExpression, LazyOperatorExpression, MatchExpression,
             MethodApplicationExpression, MethodName, ParseModule, ParseProgram, ParseSubmodule,
             QualifiedPathType, ReassignmentExpression, ReassignmentTarget, RefExpression,
             Scrutinee, StorageAccessExpression, StorageDeclaration, StorageField,
@@ -128,6 +129,7 @@ impl Parse for Declaration {
             Declaration::ImplSelf(decl_id) => decl_id.parse(ctx),
             Declaration::AbiDeclaration(decl_id) => decl_id.parse(ctx),
             Declaration::ConstantDeclaration(decl_id) => decl_id.parse(ctx),
+            Declaration::ConfigurableDeclaration(decl_id) => decl_id.parse(ctx),
             Declaration::StorageDeclaration(decl_id) => decl_id.parse(ctx),
             Declaration::TypeAliasDeclaration(decl_id) => decl_id.parse(ctx),
             Declaration::TraitTypeDeclaration(decl_id) => decl_id.parse(ctx),
@@ -864,6 +866,24 @@ impl Parse for ParsedDeclId<ConstantDeclaration> {
     }
 }
 
+impl Parse for ParsedDeclId<ConfigurableDeclaration> {
+    fn parse(&self, ctx: &ParseContext) {
+        let const_decl = ctx.engines.pe().get_configurable(self);
+        ctx.tokens.insert(
+            ctx.ident(&const_decl.name),
+            Token::from_parsed(
+                AstToken::Declaration(Declaration::ConfigurableDeclaration(*self)),
+                SymbolKind::Const,
+            ),
+        );
+        const_decl.type_ascription.parse(ctx);
+        if let Some(value) = &const_decl.value {
+            value.parse(ctx);
+        }
+        const_decl.attributes.parse(ctx);
+    }
+}
+
 impl Parse for ParsedDeclId<TraitTypeDeclaration> {
     fn parse(&self, ctx: &ParseContext) {
         let trait_type_decl = ctx.engines.pe().get_trait_type(self);
diff --git a/sway-lsp/src/traverse/typed_tree.rs b/sway-lsp/src/traverse/typed_tree.rs
index ab597d9c903..b0fc8e5daff 100644
--- a/sway-lsp/src/traverse/typed_tree.rs
+++ b/sway-lsp/src/traverse/typed_tree.rs
@@ -76,6 +76,7 @@ impl Parse for ty::TyDecl {
         match self {
             ty::TyDecl::VariableDecl(decl) => decl.parse(ctx),
             ty::TyDecl::ConstantDecl(decl) => decl.parse(ctx),
+            ty::TyDecl::ConfigurableDecl(decl) => decl.parse(ctx),
             ty::TyDecl::FunctionDecl(decl) => decl.parse(ctx),
             ty::TyDecl::TraitDecl(decl) => decl.parse(ctx),
             ty::TyDecl::StructDecl(decl) => decl.parse(ctx),
@@ -279,6 +280,17 @@ impl Parse for ty::TyExpression {
                     collect_call_path_prefixes(ctx, &call_path.prefixes);
                 }
             }
+            ty::TyExpressionVariant::ConfigurableExpression {
+                ref const_decl,
+                span,
+                call_path,
+                ..
+            } => {
+                collect_configurable_decl(ctx, const_decl, Some(&Ident::new(span.clone())));
+                if let Some(call_path) = call_path {
+                    collect_call_path_prefixes(ctx, &call_path.prefixes);
+                }
+            }
             ty::TyExpressionVariant::VariableExpression {
                 ref name,
                 ref span,
@@ -591,6 +603,13 @@ impl Parse for ty::ConstantDecl {
     }
 }
 
+impl Parse for ty::ConfigurableDecl {
+    fn parse(&self, ctx: &ParseContext) {
+        let configurable_decl = ctx.engines.de().get_configurable(&self.decl_id);
+        collect_configurable_decl(ctx, &configurable_decl, None);
+    }
+}
+
 impl Parse for ty::TraitTypeDecl {
     fn parse(&self, ctx: &ParseContext) {
         let type_decl = ctx.engines.de().get_type(&self.decl_id);
@@ -960,7 +979,8 @@ impl Parse for ty::TyIntrinsicFunctionKind {
 impl Parse for ty::TyScrutinee {
     fn parse(&self, ctx: &ParseContext) {
         use ty::TyScrutineeVariant::{
-            CatchAll, Constant, EnumScrutinee, Literal, Or, StructScrutinee, Tuple, Variable,
+            CatchAll, Configurable, Constant, EnumScrutinee, Literal, Or, StructScrutinee, Tuple,
+            Variable,
         };
         match &self.variant {
             CatchAll => {}
@@ -971,6 +991,13 @@ impl Parse for ty::TyScrutinee {
                         Some(TypeDefinition::Ident(const_decl.call_path.suffix.clone()));
                 }
             }
+            Configurable(name, _, const_decl) => {
+                if let Some(mut token) = ctx.tokens.try_get_mut_with_retry(&ctx.ident(name)) {
+                    token.typed = Some(TypedAstToken::TypedScrutinee(self.clone()));
+                    token.type_def =
+                        Some(TypeDefinition::Ident(const_decl.call_path.suffix.clone()));
+                }
+            }
             Literal(_) => {
                 if let Some(mut token) = ctx
                     .tokens
@@ -1206,6 +1233,27 @@ fn collect_const_decl(ctx: &ParseContext, const_decl: &ty::TyConstantDecl, ident
     }
 }
 
+fn collect_configurable_decl(
+    ctx: &ParseContext,
+    const_decl: &ty::TyConfigurableDecl,
+    ident: Option<&Ident>,
+) {
+    let key = ctx.ident(ident.unwrap_or(const_decl.name()));
+
+    if let Some(mut token) = ctx.tokens.try_get_mut_with_retry(&key) {
+        token.typed = Some(TypedAstToken::TypedConfigurableDeclaration(
+            const_decl.clone(),
+        ));
+        token.type_def = Some(TypeDefinition::Ident(const_decl.call_path.suffix.clone()));
+    }
+    if let Some(call_path_tree) = &const_decl.type_ascription.call_path_tree {
+        collect_call_path_tree(ctx, call_path_tree, &const_decl.type_ascription);
+    }
+    if let Some(value) = &const_decl.value {
+        value.parse(ctx);
+    }
+}
+
 fn collect_trait_type_decl(ctx: &ParseContext, type_decl: &ty::TyTraitType, span: &Span) {
     if let Some(mut token) = ctx
         .tokens
diff --git a/test/src/e2e_vm_tests/harness.rs b/test/src/e2e_vm_tests/harness.rs
index 1655c2acce4..4133feb08d5 100644
--- a/test/src/e2e_vm_tests/harness.rs
+++ b/test/src/e2e_vm_tests/harness.rs
@@ -276,7 +276,7 @@ pub(crate) async fn compile_to_bytes(file_name: &str, run_config: &RunConfig) ->
             dca_graph: None,
             dca_graph_url_format: None,
             asm: run_config.print_asm,
-            bytecode: false,
+            bytecode: run_config.print_bytecode,
             ir: run_config.print_ir.clone(),
             reverse_order: false,
         },
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/configurables_and_consts_are_immutable/Forc.lock b/test/src/e2e_vm_tests/test_programs/should_fail/configurables_and_consts_are_immutable/Forc.lock
index d140027eee3..a60427dcf2d 100644
--- a/test/src/e2e_vm_tests/test_programs/should_fail/configurables_and_consts_are_immutable/Forc.lock
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/configurables_and_consts_are_immutable/Forc.lock
@@ -1,3 +1,8 @@
 [[package]]
 name = "configurables_and_consts_are_immutable"
 source = "member"
+dependencies = ["core"]
+
+[[package]]
+name = "core"
+source = "path+from-root-4356F81B463050D4"
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/configurables_and_consts_are_immutable/Forc.toml b/test/src/e2e_vm_tests/test_programs/should_fail/configurables_and_consts_are_immutable/Forc.toml
index e5f2c65ad38..9e721485cb0 100644
--- a/test/src/e2e_vm_tests/test_programs/should_fail/configurables_and_consts_are_immutable/Forc.toml
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/configurables_and_consts_are_immutable/Forc.toml
@@ -4,3 +4,6 @@ entry = "main.sw"
 implicit-std = false
 license = "Apache-2.0"
 name = "configurables_and_consts_are_immutable"
+
+[dependencies]
+core = { path = "../../../../../../sway-lib-core" }
diff --git a/test/src/e2e_vm_tests/test_programs/should_fail/configurables_in_lib/test.toml b/test/src/e2e_vm_tests/test_programs/should_fail/configurables_in_lib/test.toml
index 6b99932cd34..cc337f10d46 100644
--- a/test/src/e2e_vm_tests/test_programs/should_fail/configurables_in_lib/test.toml
+++ b/test/src/e2e_vm_tests/test_programs/should_fail/configurables_in_lib/test.toml
@@ -1,5 +1,8 @@
 category = "fail"
 
-# check: $()C0: bool = true,
-# nextln: $()Configurable constants are not allowed in libraries.
+# check: $()configurable {
+# nextln: $()C0: bool = true,
 # nextln: $()C1: u64 = 42,
+# nextln: $()C2: b256 = 0x1111111111111111111111111111111111111111111111111111111111111111,
+# nextln: $()}
+# nextln: $()Configurable constants are not allowed in libraries.
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/configurable_consts/json_abi_oracle_new_encoding.json b/test/src/e2e_vm_tests/test_programs/should_pass/language/configurable_consts/json_abi_oracle_new_encoding.json
index 95447cea8da..e60dda965d4 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/configurable_consts/json_abi_oracle_new_encoding.json
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/configurable_consts/json_abi_oracle_new_encoding.json
@@ -1,168 +1,5 @@
 {
-  "configurables": [
-    {
-      "configurableType": {
-        "name": "",
-        "type": 5,
-        "typeArguments": null
-      },
-      "name": "C0",
-      "offset": 14264
-    },
-    {
-      "configurableType": {
-        "name": "",
-        "type": 12,
-        "typeArguments": null
-      },
-      "name": "C1",
-      "offset": 14288
-    },
-    {
-      "configurableType": {
-        "name": "",
-        "type": 4,
-        "typeArguments": null
-      },
-      "name": "C2",
-      "offset": 14304
-    },
-    {
-      "configurableType": {
-        "name": "",
-        "type": 8,
-        "typeArguments": []
-      },
-      "name": "C3",
-      "offset": 14336
-    },
-    {
-      "configurableType": {
-        "name": "",
-        "type": 6,
-        "typeArguments": []
-      },
-      "name": "C4",
-      "offset": 14352
-    },
-    {
-      "configurableType": {
-        "name": "",
-        "type": 6,
-        "typeArguments": []
-      },
-      "name": "C5",
-      "offset": 14368
-    },
-    {
-      "configurableType": {
-        "name": "",
-        "type": 7,
-        "typeArguments": null
-      },
-      "name": "C6",
-      "offset": 14384
-    },
-    {
-      "configurableType": {
-        "name": "",
-        "type": 2,
-        "typeArguments": null
-      },
-      "name": "C7",
-      "offset": 14400
-    },
-    {
-      "configurableType": {
-        "name": "",
-        "type": 12,
-        "typeArguments": null
-      },
-      "name": "C9",
-      "offset": 14448
-    },
-    {
-      "configurableType": {
-        "name": "",
-        "type": 5,
-        "typeArguments": null
-      },
-      "name": "BOOL",
-      "offset": 14472
-    },
-    {
-      "configurableType": {
-        "name": "",
-        "type": 13,
-        "typeArguments": null
-      },
-      "name": "U8",
-      "offset": 14480
-    },
-    {
-      "configurableType": {
-        "name": "",
-        "type": 13,
-        "typeArguments": null
-      },
-      "name": "ANOTHERU8",
-      "offset": 14496
-    },
-    {
-      "configurableType": {
-        "name": "",
-        "type": 9,
-        "typeArguments": null
-      },
-      "name": "U16",
-      "offset": 14504
-    },
-    {
-      "configurableType": {
-        "name": "",
-        "type": 11,
-        "typeArguments": null
-      },
-      "name": "U32",
-      "offset": 14512
-    },
-    {
-      "configurableType": {
-        "name": "",
-        "type": 12,
-        "typeArguments": null
-      },
-      "name": "U64",
-      "offset": 14528
-    },
-    {
-      "configurableType": {
-        "name": "",
-        "type": 10,
-        "typeArguments": null
-      },
-      "name": "U256",
-      "offset": 14544
-    },
-    {
-      "configurableType": {
-        "name": "",
-        "type": 3,
-        "typeArguments": null
-      },
-      "name": "ARRAY_U8",
-      "offset": 14576
-    },
-    {
-      "configurableType": {
-        "name": "",
-        "type": 1,
-        "typeArguments": null
-      },
-      "name": "ARRAY_U32",
-      "offset": 14608
-    }
-  ],
+  "configurables": [],
   "encoding": "1",
   "functions": [
     {
@@ -176,16 +13,7 @@
       }
     }
   ],
-  "loggedTypes": [
-    {
-      "logId": "3330666440490685604",
-      "loggedType": {
-        "name": "",
-        "type": 0,
-        "typeArguments": null
-      }
-    }
-  ],
+  "loggedTypes": [],
   "messagesTypes": [],
   "types": [
     {
@@ -193,124 +21,6 @@
       "type": "()",
       "typeId": 0,
       "typeParameters": null
-    },
-    {
-      "components": [
-        {
-          "name": "__array_element",
-          "type": 11,
-          "typeArguments": null
-        }
-      ],
-      "type": "[_; 3]",
-      "typeId": 1,
-      "typeParameters": null
-    },
-    {
-      "components": [
-        {
-          "name": "__array_element",
-          "type": 12,
-          "typeArguments": null
-        }
-      ],
-      "type": "[_; 4]",
-      "typeId": 2,
-      "typeParameters": null
-    },
-    {
-      "components": [
-        {
-          "name": "__array_element",
-          "type": 13,
-          "typeArguments": null
-        }
-      ],
-      "type": "[_; 4]",
-      "typeId": 3,
-      "typeParameters": null
-    },
-    {
-      "components": null,
-      "type": "b256",
-      "typeId": 4,
-      "typeParameters": null
-    },
-    {
-      "components": null,
-      "type": "bool",
-      "typeId": 5,
-      "typeParameters": null
-    },
-    {
-      "components": [
-        {
-          "name": "A",
-          "type": 12,
-          "typeArguments": null
-        },
-        {
-          "name": "B",
-          "type": 5,
-          "typeArguments": null
-        }
-      ],
-      "type": "enum MyEnum",
-      "typeId": 6,
-      "typeParameters": null
-    },
-    {
-      "components": null,
-      "type": "str[4]",
-      "typeId": 7,
-      "typeParameters": null
-    },
-    {
-      "components": [
-        {
-          "name": "x",
-          "type": 12,
-          "typeArguments": null
-        },
-        {
-          "name": "y",
-          "type": 5,
-          "typeArguments": null
-        }
-      ],
-      "type": "struct MyStruct",
-      "typeId": 8,
-      "typeParameters": null
-    },
-    {
-      "components": null,
-      "type": "u16",
-      "typeId": 9,
-      "typeParameters": null
-    },
-    {
-      "components": null,
-      "type": "u256",
-      "typeId": 10,
-      "typeParameters": null
-    },
-    {
-      "components": null,
-      "type": "u32",
-      "typeId": 11,
-      "typeParameters": null
-    },
-    {
-      "components": null,
-      "type": "u64",
-      "typeId": 12,
-      "typeParameters": null
-    },
-    {
-      "components": null,
-      "type": "u8",
-      "typeId": 13,
-      "typeParameters": null
     }
   ]
 }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/language/configurable_consts/src/main.sw b/test/src/e2e_vm_tests/test_programs/should_pass/language/configurable_consts/src/main.sw
index 45241ed9f44..6e0e94ba5e1 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/language/configurable_consts/src/main.sw
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/language/configurable_consts/src/main.sw
@@ -1,22 +1,22 @@
-script;
-
+ script;
+ 
 use std::hash::*;
 
-struct MyStruct {
-    x: u64,
-    y: bool,
+struct ConfigurableStruct {
+    a: bool,
+    b: u64,
 }
 
-enum MyEnum {
-    A: u64,
-    B: bool,
+enum ConfigurableEnum {
+    A: bool,
+    B: u64,
 }
 
-impl core::ops::Eq for MyEnum {
-    fn eq(self, other: MyEnum) -> bool {
+impl core::ops::Eq for ConfigurableEnum {
+    fn eq(self, other: ConfigurableEnum) -> bool {
         match (self, other) {
-            (MyEnum::A(inner1), MyEnum::A(inner2)) => inner1 == inner2,
-            (MyEnum::B(inner1), MyEnum::B(inner2)) => inner1 == inner2,
+            (ConfigurableEnum::A(inner1), ConfigurableEnum::A(inner2)) => inner1 == inner2,
+            (ConfigurableEnum::B(inner1), ConfigurableEnum::B(inner2)) => inner1 == inner2,
             _ => false,
         }
     }
@@ -24,126 +24,55 @@ impl core::ops::Eq for MyEnum {
 
 type AnotherU8 = u8;
 
-configurable {
-    C0: bool = true,
-    C1: u64 = 42,
-    C2: b256 = 0x1111111111111111111111111111111111111111111111111111111111111111,
-    C3: MyStruct = MyStruct { x: 42, y: true },
-    C4: MyEnum = MyEnum::A(42),
-    C5: MyEnum = MyEnum::B(true),
-    C6: str[4] = __to_str_array("fuel"),
-    C7: [u64; 4] = [1, 2, 3, 4],
-    
-    C8: u64 = 0, // Unused - should not show up in the JSON file
-    C9: u64 =  10 + 9 - 8 * 7 / 6 << 5 >> 4 ^ 3 | 2 & 1,
-
-    UNIT: () = (),
-    BOOL: bool = true,
-    U8: u8 = 8,
-    ANOTHERU8: AnotherU8 = 8,
-    U16: u16 = 16,
-    U32: u32 = 32,
-    U64: u64 = 64,
-    U256: u256 = 0x1234567812345678123456781234567812345678123456781234567812345678u256,
-    ARRAY_U8: [u8; 4] = [1, 2, 3, 4],
-    ARRAY_U32: [u32; 3] = [1, 2, 3],
-}
-
-#[inline(never)]
-fn test_first_use() {
-    assert(C0 == true);
-    assert(C1 == 42);
-    assert(C2 == 0x1111111111111111111111111111111111111111111111111111111111111111);
-    assert(C3.x == 42);
-    assert(C3.y == true);
-    assert(C4 == MyEnum::A(42));
-    assert(C5 == MyEnum::B(true));
-    assert(sha256_str_array(C6) == sha256("fuel"));
-    assert(C7[0] == 1);
-    assert(C7[1] == 2);
-    assert(C7[2] == 3);
-    assert(C7[3] == 4);
-    assert(C9 == 23);
-
-    __log(UNIT);
-
-    assert(BOOL);
-    assert(U8 == 8);
-    assert(ANOTHERU8 == 8);
-    assert(U16 == 16);
-    assert(U32 == 32);
-    assert(U64 == 64);
-    assert(U256 == 0x1234567812345678123456781234567812345678123456781234567812345678u256);
-
-    assert(ARRAY_U8[0] == 1);
-    assert(ARRAY_U8[1] == 2);
-    assert(ARRAY_U8[2] == 3);
-    assert(ARRAY_U8[3] == 4);
-    
-    assert(ARRAY_U32[0] == 1);
-    assert(ARRAY_U32[1] == 2);
-    assert(ARRAY_U32[2] == 3);
-}
-
-#[inline(never)]
-fn test_second_use() {
-    assert(C0 == true);
-    assert(C1 == 42);
-    assert(C2 == 0x1111111111111111111111111111111111111111111111111111111111111111);
-    assert(C3.x == 42);
-    assert(C3.y == true);
-    assert(C4 == MyEnum::A(42));
-    assert(C5 == MyEnum::B(true));
-    assert(sha256_str_array(C6) == sha256("fuel"));
-    assert(C7[0] == 1);
-    assert(C7[1] == 2);
-    assert(C7[2] == 3);
-    assert(C7[3] == 4);
-    assert(C9 == 23);
-
-    assert(ARRAY_U8[0] == 1);
-    assert(ARRAY_U8[1] == 2);
-    assert(ARRAY_U8[2] == 3);
-    assert(ARRAY_U8[3] == 4);
-
-    assert(ARRAY_U32[0] == 1);
-    assert(ARRAY_U32[1] == 2);
-    assert(ARRAY_U32[2] == 3);
-}
-
-#[inline(always)]
-fn test_inline_use() {
-    assert(C0 == true);
-    assert(C1 == 42);
-    assert(C2 == 0x1111111111111111111111111111111111111111111111111111111111111111);
-    assert(C3.x == 42);
-    assert(C3.y == true);
-    assert(C4 == MyEnum::A(42));
-    assert(C5 == MyEnum::B(true));
-    assert(sha256_str_array(C6) == sha256("fuel"));
-    assert(C7[0] == 1);
-    assert(C7[1] == 2);
-    assert(C7[2] == 3);
-    assert(C7[3] == 4);
-    assert(C9 == 23);
-
-    assert(ARRAY_U8[0] == 1);
-    assert(ARRAY_U8[1] == 2);
-    assert(ARRAY_U8[2] == 3);
-    assert(ARRAY_U8[3] == 4);
-
-    assert(ARRAY_U32[0] == 1);
-    assert(ARRAY_U32[1] == 2);
-    assert(ARRAY_U32[2] == 3);
-}
-
-#[inline(never)]
-fn test_various_uses() {
-    test_first_use();
-    test_second_use();
-    test_inline_use();
-}
-
-fn main() {
-    test_various_uses();
-}
+ configurable {
+     BOOL: bool = true,
+    U8: u8 = 1,
+    ANOTHER_U8: AnotherU8 = 3,
+    U16: u16 = 2,
+    U32: u32 = 3,
+    U64: u32 = 4,
+    U256: u256 = 0xAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAu256,
+    B256: b256 = 0xBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB,
+    CONFIGURABLE_STRUCT: ConfigurableStruct = ConfigurableStruct { 
+        a: true,
+        b: 5,
+    },
+    CONFIGURABLE_ENUM_A: ConfigurableEnum = ConfigurableEnum::A(true),
+    CONFIGURABLE_ENUM_B: ConfigurableEnum = ConfigurableEnum::B(12),
+    ARRAY_BOOL: [bool; 3] = [true, false, true],
+    ARRAY_U64: [u64; 3] = [9, 8, 7],
+    TUPLE_BOOL_U64: (bool, u64) = (true, 11),
+    STR_4: str[4] = __to_str_array("abcd"),
+ }
+ 
+ fn main() {
+     assert(BOOL == true);
+    assert(U8 == 1);
+    assert(ANOTHER_U8 == 3);
+    assert(U16 == 2);
+    assert(U64 == 4);
+    assert(U256 == 0xAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAu256);
+    assert(B256 == 0xBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB);
+    assert(CONFIGURABLE_STRUCT.a == true);
+    assert(CONFIGURABLE_STRUCT.b == 5);
+    assert(CONFIGURABLE_ENUM_A == ConfigurableEnum::A(true));
+    assert(CONFIGURABLE_ENUM_B == ConfigurableEnum::B(12));
+    assert(ARRAY_BOOL[0] == true);
+    assert(ARRAY_BOOL[1] == false);
+    assert(ARRAY_BOOL[2] == true);
+    assert(ARRAY_U64[0] == 9);
+    assert(ARRAY_U64[1] == 8);
+    assert(ARRAY_U64[2] == 7);
+    assert(TUPLE_BOOL_U64.0 == true);
+    assert(TUPLE_BOOL_U64.1 == 11);
+    assert(sha256_str_array(STR_4) == sha256("abcd"));
+
+    // Assert address do not change
+    let addr_1 = asm(addr: __addr_of(&BOOL)) {
+        addr: u64
+    };
+    let addr_2 = asm(addr: __addr_of(&BOOL)) {
+        addr: u64
+    };
+    assert(addr_1 == addr_2);
+ }
\ No newline at end of file
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/unit_tests/workspace_test/contract_multi_test/src/main.sw b/test/src/e2e_vm_tests/test_programs/should_pass/unit_tests/workspace_test/contract_multi_test/src/main.sw
index 4d47659c554..416dc26e3b2 100644
--- a/test/src/e2e_vm_tests/test_programs/should_pass/unit_tests/workspace_test/contract_multi_test/src/main.sw
+++ b/test/src/e2e_vm_tests/test_programs/should_pass/unit_tests/workspace_test/contract_multi_test/src/main.sw
@@ -17,7 +17,7 @@ fn test_foo() {
 
 #[test(should_revert)]
 fn test_fail() {
-    let contract_id = 0x560e2f6bec6074f6c05dbb838f7c1d49b4e5f22530ca8db9345f38dad89820d3;
+    let contract_id = 0x868759ecba526aa54f3965ca05f73b7bb5d36bfa6b1d67fbf780affc0c7c1e87;
     let caller = abi(MyContract, contract_id);
     let result = caller.test_function {}();
     assert(result == false)
@@ -25,7 +25,7 @@ fn test_fail() {
 
 #[test]
 fn test_success() {
-    let contract_id = 0x560e2f6bec6074f6c05dbb838f7c1d49b4e5f22530ca8db9345f38dad89820d3;
+    let contract_id = 0x868759ecba526aa54f3965ca05f73b7bb5d36bfa6b1d67fbf780affc0c7c1e87;
     let caller = abi(MyContract, contract_id);
     let result = caller.test_function {}();
     assert(result == true)
diff --git a/test/src/ir_generation/mod.rs b/test/src/ir_generation/mod.rs
index b371b710bc3..2c21d60c91e 100644
--- a/test/src/ir_generation/mod.rs
+++ b/test/src/ir_generation/mod.rs
@@ -8,8 +8,8 @@ use std::{
 use anyhow::Result;
 use colored::Colorize;
 use sway_core::{
-    compile_ir_to_asm, compile_to_ast, ir_generation::compile_program, namespace, BuildTarget,
-    Engines,
+    compile_ir_context_to_finalized_asm, compile_to_ast, ir_generation::compile_program, namespace,
+    BuildTarget, Engines,
 };
 use sway_error::handler::Handler;
 
@@ -421,7 +421,7 @@ pub(super) async fn run(
 
                             // Compile to ASM.
                             let handler = Handler::default();
-                            let asm_result = compile_ir_to_asm(&handler, &ir, None);
+                            let asm_result = compile_ir_context_to_finalized_asm(&handler, &ir, None);
                             let (errors, _warnings) = handler.consume();
 
                             if asm_result.is_err() || !errors.is_empty() {
diff --git a/test/src/ir_generation/tests/configs_1.sw b/test/src/ir_generation/tests/configs_1.sw
deleted file mode 100644
index 0191985efef..00000000000
--- a/test/src/ir_generation/tests/configs_1.sw
+++ /dev/null
@@ -1,20 +0,0 @@
-script;
-
-configurable {
-    X: u64 = 42,
-}
-
-fn main() -> u64 {
-    X
-}
-
-// ::check-ir::
-
-// regex: CONFIG=c\d+
-
-// check: script {
-// check: $(c0=$CONFIG) = config u64 42, $(config_mds=$MD)
-
-// check: ret u64 $c0
-// check: $(config_name=$MD) = config_name "X"
-// check: $config_mds = ($MD $config_name)
diff --git a/test/src/ir_generation/tests/configs_2.sw b/test/src/ir_generation/tests/configs_2.sw
deleted file mode 100644
index 81c92db7a4e..00000000000
--- a/test/src/ir_generation/tests/configs_2.sw
+++ /dev/null
@@ -1,37 +0,0 @@
-script;
-
-configurable {
-    Y: b256 = 0x0101010101010101010101010101010101010101010101010101010101010101,
-    X: u64 = 42,
-}
-
-fn main() -> (b256, u64) {
-    (Y, X)
-}
-
-// ::check-ir::
-
-// regex: CONFIG=c\d+
-
-// check: script {
-// check: $(c0=$CONFIG) = config u64 42, $(config0_mds=$MD)
-// check: $(c1=$CONFIG) = config b256 0x0101010101010101010101010101010101010101010101010101010101010101, $(config1_mds=$MD)
-
-// check: $(tuple_ptr=$VAL) = get_local ptr { b256, u64 }, $ID
-
-// check: $(zero_idx=$VAL) = const u64 0
-// check: $(tuple_val=$VAL) = get_elem_ptr $tuple_ptr, ptr b256, $zero_idx
-// check: store $c1 to $tuple_val
-
-// check: $(one_idx=$VAL) = const u64 1
-// check: $(tuple_val=$VAL) = get_elem_ptr $tuple_ptr, ptr u64, $one_idx
-// check: store $c0 to $tuple_val
-
-// check: $(ret_val=$VAL) = load $tuple_ptr
-// check: ret { b256, u64 } $ret_val
-
-// unordered: $(config_name_X=$MD) = config_name "X"
-// unordered: $config0_mds = ($MD $config_name_X)
-
-// unordered: $(config_name_Y=$MD) = config_name "Y"
-// unordered: $config1_mds = ($MD $config_name_Y)
diff --git a/test/src/ir_generation/tests/configs_3.sw b/test/src/ir_generation/tests/configs_3.sw
deleted file mode 100644
index d6fe1bd2bb7..00000000000
--- a/test/src/ir_generation/tests/configs_3.sw
+++ /dev/null
@@ -1,48 +0,0 @@
-// target-fuelvm
-
-script;
-
-configurable {
-    X: u64 = 42,
-    Y: u64 = 42,
-}
-
-fn main() -> (u64, u64) {
-    (X, Y)
-}
-
-// ::check-ir::
-
-// regex: CONFIG=c\d+
-
-// check: script {
-// check: $(c0=$CONFIG) = config u64 42, $(config0_mds=$MD)
-// check: $(c1=$CONFIG) = config u64 42, $(config1_mds=$MD)
-
-// First one is for __ret_value
-// check: get_local ptr { u64, u64 }, $ID
-
-// check: $(temp_ptr=$VAL) = get_local ptr { u64, u64 }, $ID
-
-// check: $(idx_val=$VAL) = const u64 0
-// check: $(field_ptr=$VAL) = get_elem_ptr $temp_ptr, ptr u64, $idx_val
-// check: store c0 to $field_ptr
-
-// check: $(idx_val=$VAL) = const u64 1
-// check: $(field_ptr=$VAL) = get_elem_ptr $temp_ptr, ptr u64, $idx_val
-// check: store c1 to $field_ptr
-
-
-// unordered: $(config_name_X=$MD) = config_name "X"
-// unordered: $config0_mds = ($MD $config_name_X)
-
-// unordered: $(config_name_Y=$MD) = config_name "Y"
-// unordered: $config1_mds = ($MD $config_name_Y)
-
-// ::check-asm::
-
-// regex: DATA=data_\d+
-
-// Make sure there are two data locations, one for each config variable
-// check: $DATA .word 42
-// check: $DATA .word 42
diff --git a/test/src/ir_generation/tests/configs_4.sw b/test/src/ir_generation/tests/configs_4.sw
deleted file mode 100644
index 4f16d17bace..00000000000
--- a/test/src/ir_generation/tests/configs_4.sw
+++ /dev/null
@@ -1,31 +0,0 @@
-// target-fuelvm
-
-script;
-
-const A: u64 = 42;
-const B: u64 = 42;
-
-configurable {
-    X: u64 = 11,
-    Y: u64 = 11,
-}
-
-fn main() -> (u64, u64, u64, u64) {
-    (A, B, X, Y)
-}
-
-// ::check-ir::
-
-// check: script
-
-// ::check-asm::
-
-// regex: DATA=data_\d+
-// regex: REG=\$r\d+
-
-// There should only be 3 data entries here. One shared by `A` and `B` and the
-// other two are for `X` and `Y` respectively
-
-// unordered: $DATA .word 42
-// unordered: $DATA .word 11
-// unordered: $DATA .word 11
diff --git a/test/src/main.rs b/test/src/main.rs
index fbcd5d6203c..8ea0f1b1c5e 100644
--- a/test/src/main.rs
+++ b/test/src/main.rs
@@ -61,13 +61,17 @@ struct Cli {
     #[arg(long)]
     update_output_files: bool,
 
-    /// Print out the final IR, if the verbose option is on
+    /// Print out the specifiec IR (separate options with comma), if the verbose option is on
     #[arg(long, num_args(1..=18), value_parser = clap::builder::PossibleValuesParser::new(PrintIrCliOpt::cli_options()))]
     print_ir: Option<Vec<String>>,
 
-    /// Print out the ASM, if the verbose option is on
+    /// Print out the specified ASM (separate options with comma), if the verbose option is on
     #[arg(long, num_args(1..=5), value_parser = clap::builder::PossibleValuesParser::new(&PrintAsmCliOpt::CLI_OPTIONS))]
     print_asm: Option<Vec<String>>,
+
+    /// Print out the final bytecode, if the verbose option is on
+    #[arg(long)]
+    print_bytecode: bool,
 }
 
 #[derive(Debug, Clone)]
@@ -90,6 +94,7 @@ pub struct RunConfig {
     pub update_output_files: bool,
     pub print_ir: PrintIr,
     pub print_asm: PrintAsm,
+    pub print_bytecode: bool,
 }
 
 #[tokio::main]
@@ -130,6 +135,7 @@ async fn main() -> Result<()> {
             .print_asm
             .as_ref()
             .map_or(PrintAsm::default(), |opts| PrintAsmCliOpt::from(opts).0),
+        print_bytecode: cli.print_bytecode,
     };
 
     // Check that the tests are consistent