diff --git a/Sources/CLI/Run/Run.swift b/Sources/CLI/Run/Run.swift
index f4d6602f..5e19a2c4 100644
--- a/Sources/CLI/Run/Run.swift
+++ b/Sources/CLI/Run/Run.swift
@@ -54,6 +54,11 @@ struct Run: ParsableCommand {
         }
 
         let interceptor = try deriveInterceptor()
+        #if !DEBUG
+        guard interceptor == nil else {
+            fatalError("Internal Error: Interceptor API is unavailable with Release build due to performance reasons")
+        }
+        #endif
         defer { interceptor?.finalize() }
 
         let invoke: () throws -> Void
diff --git a/Sources/WasmKit/Execution/Instructions/Control.swift b/Sources/WasmKit/Execution/Instructions/Control.swift
index aa875f74..0f48fb70 100644
--- a/Sources/WasmKit/Execution/Instructions/Control.swift
+++ b/Sources/WasmKit/Execution/Instructions/Control.swift
@@ -1,163 +1,164 @@
 /// > Note:
 /// <https://webassembly.github.io/spec/core/exec/instructions.html#control-instructions>
-enum ControlInstruction: Equatable {
-    case unreachable
-    case nop
-    case block(expression: Expression, type: ResultType)
-    case loop(expression: Expression, type: ResultType)
-    case `if`(then: Expression, else: Expression, type: ResultType)
-    case br(_ labelIndex: LabelIndex)
-    case brIf(_ labelIndex: LabelIndex)
-    case brTable(_ labelIndices: [LabelIndex], default: LabelIndex)
-    case `return`
-    case call(functionIndex: UInt32)
-    case callIndirect(tableIndex: TableIndex, typeIndex: TypeIndex)
-
-    func execute(runtime: Runtime, execution: inout ExecutionState) throws {
-        switch self {
-        case .unreachable:
-            throw Trap.unreachable
-
-        case .nop:
-            execution.programCounter += 1
-
-        case let .block(expression, type):
-            let (paramSize, resultSize) = type.arity(typeSection: { execution.stack.currentFrame.module.types })
-            let values = try execution.stack.popValues(count: paramSize)
-            execution.enter(expression, continuation: execution.programCounter + 1, arity: resultSize)
-            execution.stack.push(values: values)
-
-        case let .loop(expression, type):
-            let (paramSize, _) = type.arity(typeSection: { execution.stack.currentFrame.module.types })
-            let values = try execution.stack.popValues(count: paramSize)
-            execution.enter(expression, continuation: execution.programCounter, arity: paramSize)
-            execution.stack.push(values: values)
-
-        case let .if(then, `else`, type):
-            let isTrue = try execution.stack.popValue().i32 != 0
-
-            let expression: Expression
-            if isTrue {
-                expression = then
-            } else {
-                expression = `else`
-            }
-
-            if !expression.instructions.isEmpty {
-                let derived = ControlInstruction.block(expression: expression, type: type)
-                try derived.execute(runtime: runtime, execution: &execution)
-            } else {
-                execution.programCounter += 1
-            }
-
-        case let .brIf(labelIndex):
-            guard try execution.stack.popValue().i32 != 0 else {
-                execution.programCounter += 1
-                return
-            }
-
-            fallthrough
-
-        case let .br(labelIndex):
-            try execution.branch(labelIndex: Int(labelIndex))
-
-        case let .brTable(labelIndices, defaultLabelIndex):
-            let value = try execution.stack.popValue().i32
-            let labelIndex: LabelIndex
-            if labelIndices.indices.contains(Int(value)) {
-                labelIndex = labelIndices[Int(value)]
-            } else {
-                labelIndex = defaultLabelIndex
-            }
-
-            try execution.branch(labelIndex: Int(labelIndex))
-
-        case .return:
-            let values = try execution.stack.popValues(count: execution.stack.currentFrame.arity)
-
-            let currentFrame = Stack.Element.frame(execution.stack.currentFrame)
-            var lastLabel: Label?
-            while execution.stack.top != currentFrame {
-                execution.stack.discardTopValues()
-                lastLabel = try execution.stack.popLabel()
-            }
-            if let lastLabel {
-                execution.programCounter = lastLabel.continuation
-            }
-            execution.stack.push(values: values)
-
-        case let .call(functionIndex):
-            let functionAddresses = execution.stack.currentFrame.module.functionAddresses
-
-            guard functionAddresses.indices.contains(Int(functionIndex)) else {
-                throw Trap.invalidFunctionIndex(functionIndex)
-            }
-
-            try execution.invoke(functionAddress: functionAddresses[Int(functionIndex)], runtime: runtime)
-
-        case let .callIndirect(tableIndex, typeIndex):
-            let moduleInstance = execution.stack.currentFrame.module
-            let tableAddresses = moduleInstance.tableAddresses[Int(tableIndex)]
-            let tableInstance = runtime.store.tables[tableAddresses]
-            let expectedType = moduleInstance.types[Int(typeIndex)]
-            let value = try execution.stack.popValue().i32
-            let elementIndex = Int(value)
-            guard elementIndex < tableInstance.elements.count else {
-                throw Trap.undefinedElement
-            }
-            guard case let .function(functionAddress?) = tableInstance.elements[elementIndex]
-            else {
-                throw Trap.tableUninitialized(ElementIndex(elementIndex))
-            }
-            let function = runtime.store.functions[functionAddress]
-            guard function.type == expectedType else {
-                throw Trap.callIndirectFunctionTypeMismatch(actual: function.type, expected: expectedType)
-            }
-
-            try execution.invoke(functionAddress: functionAddress, runtime: runtime)
+extension ExecutionState {
+    func unreachable(runtime: Runtime) throws {
+        throw Trap.unreachable
+    }
+    mutating func nop(runtime: Runtime) throws {
+        programCounter += 1
+    }
+    private func getTypeSection(store: Store) -> [FunctionType] {
+        store.module(address: stack.currentFrame.module).types
+    }
+
+    typealias BlockType = Instruction.BlockType
+
+    mutating func block(runtime: Runtime, endRef: ExpressionRef, type: BlockType) {
+        enter(
+            jumpTo: programCounter + 1,
+            continuation: programCounter + endRef.relativeOffset,
+            arity: Int(type.results),
+            pushPopValues: Int(type.parameters)
+        )
+    }
+    mutating func loop(runtime: Runtime, type: BlockType) {
+        let paramSize = Int(type.parameters)
+        enter(jumpTo: programCounter + 1, continuation: programCounter, arity: paramSize, pushPopValues: paramSize)
+    }
+
+    mutating func ifThen(runtime: Runtime, endRef: ExpressionRef, type: BlockType) {
+        let isTrue = stack.popValue().i32 != 0
+        if isTrue {
+            enter(
+                jumpTo: programCounter + 1,
+                continuation: programCounter.advanced(by: endRef.relativeOffset),
+                arity: Int(type.results),
+                pushPopValues: Int(type.parameters)
+            )
+        } else {
+            programCounter += endRef.relativeOffset
         }
     }
-}
 
-extension ControlInstruction: CustomStringConvertible {
-    public var description: String {
-        switch self {
-        case .loop:
-            return "loop"
+    mutating func ifThenElse(runtime: Runtime, elseRef: ExpressionRef, endRef: ExpressionRef, type: BlockType) {
+        let isTrue = stack.popValue().i32 != 0
+        let addendToPC: Int
+        if isTrue {
+            addendToPC = 1
+        } else {
+            addendToPC = elseRef.relativeOffset
+        }
+        enter(
+            jumpTo: programCounter + addendToPC,
+            continuation: programCounter + endRef.relativeOffset,
+            arity: Int(type.results),
+            pushPopValues: Int(type.parameters)
+        )
+    }
+    mutating func end(runtime: Runtime) {
+        if let currentLabel = self.stack.currentLabel {
+            stack.exit(label: currentLabel)
+        }
+        programCounter += 1
+    }
+    mutating func `else`(runtime: Runtime) {
+        let label = self.stack.currentLabel!
+        stack.exit(label: label)
+        programCounter = label.continuation // if-then-else's continuation points the "end"
+    }
+
+    private mutating func branch(labelIndex: Int, runtime: Runtime) throws {
+        if stack.numberOfLabelsInCurrentFrame() == labelIndex {
+            try self.return(runtime: runtime)
+            return
+        }
+        let label = stack.getLabel(index: Int(labelIndex))
+        let values = stack.popValues(count: label.arity)
 
-        case .block:
-            return "block"
+        stack.unwindLabels(upto: labelIndex)
 
-        case let .br(i):
-            return "br \(i)"
+        stack.push(values: values)
+        programCounter = label.continuation
+    }
+    mutating func br(runtime: Runtime, labelIndex: LabelIndex) throws {
+        try branch(labelIndex: Int(labelIndex), runtime: runtime)
+    }
+    mutating func brIf(runtime: Runtime, labelIndex: LabelIndex) throws {
+        guard stack.popValue().i32 != 0 else {
+            programCounter += 1
+            return
+        }
+        try br(runtime: runtime, labelIndex: labelIndex)
+    }
+    mutating func brTable(runtime: Runtime, brTable: Instruction.BrTable) throws {
+        let labelIndices = brTable.labelIndices
+        let defaultIndex = brTable.defaultIndex
+        let value = stack.popValue().i32
+        let labelIndex: LabelIndex
+        if labelIndices.indices.contains(Int(value)) {
+            labelIndex = labelIndices[Int(value)]
+        } else {
+            labelIndex = defaultIndex
+        }
 
-        case let .brIf(i):
-            return "br_if \(i)"
+        try branch(labelIndex: Int(labelIndex), runtime: runtime)
+    }
+    mutating func `return`(runtime: Runtime) throws {
+        let currentFrame = stack.currentFrame!
+        _ = stack.exit(frame: currentFrame)
+        try endOfFunction(runtime: runtime, currentFrame: currentFrame)
+    }
 
-        case let .brTable(i, d):
-            return "br_if \(i.map(\.description).joined(separator: " ")) \(d)"
+    mutating func endOfFunction(runtime: Runtime) throws {
+        try self.endOfFunction(runtime: runtime, currentFrame: stack.currentFrame)
+    }
 
-        case let .call(functionIndex):
-            return "call \(functionIndex)"
+    mutating func endOfExecution(runtime: Runtime) throws {
+        reachedEndOfExecution = true
+    }
 
-        case let .callIndirect(tableIndex, typeIndex):
-            return "call_indirect \(tableIndex) \(typeIndex)"
+    private mutating func endOfFunction(runtime: Runtime, currentFrame: Frame) throws {
+        // When reached at "end" of function
+        #if DEBUG
+        if let address = currentFrame.address {
+            runtime.interceptor?.onExitFunction(address, store: runtime.store)
+        }
+        #endif
+        let values = stack.popValues(count: currentFrame.arity)
+        stack.popFrame()
+        stack.push(values: values)
+        programCounter = currentFrame.returnPC
+    }
 
-        case let .if(type, then, `else`):
-            return """
-                if \(type)\n  \(then)
-                else\n  \(`else`)
-                end
-                """
+    mutating func call(runtime: Runtime, functionIndex: UInt32) throws {
+        let functionAddresses = runtime.store.module(address: stack.currentFrame.module).functionAddresses
 
-        case .unreachable:
-            return "unreachable"
+        guard functionAddresses.indices.contains(Int(functionIndex)) else {
+            throw Trap.invalidFunctionIndex(functionIndex)
+        }
 
-        case .nop:
-            return "nop"
+        try invoke(functionAddress: functionAddresses[Int(functionIndex)], runtime: runtime)
+    }
 
-        case .return:
-            return "return"
+    mutating func callIndirect(runtime: Runtime, tableIndex: TableIndex, typeIndex: TypeIndex) throws {
+        let moduleInstance = runtime.store.module(address: stack.currentFrame.module)
+        let tableAddresses = moduleInstance.tableAddresses[Int(tableIndex)]
+        let tableInstance = runtime.store.tables[tableAddresses]
+        let expectedType = moduleInstance.types[Int(typeIndex)]
+        let value = stack.popValue().i32
+        let elementIndex = Int(value)
+        guard elementIndex < tableInstance.elements.count else {
+            throw Trap.undefinedElement
+        }
+        guard case let .function(functionAddress?) = tableInstance.elements[elementIndex]
+        else {
+            throw Trap.tableUninitialized(ElementIndex(elementIndex))
         }
+        let function = runtime.store.functions[functionAddress]
+        guard function.type == expectedType else {
+            throw Trap.callIndirectFunctionTypeMismatch(actual: function.type, expected: expectedType)
+        }
+
+        try invoke(functionAddress: functionAddress, runtime: runtime)
     }
 }
diff --git a/Sources/WasmKit/Execution/Instructions/Expression.swift b/Sources/WasmKit/Execution/Instructions/Expression.swift
index e2f3511a..1998256c 100644
--- a/Sources/WasmKit/Execution/Instructions/Expression.swift
+++ b/Sources/WasmKit/Execution/Instructions/Expression.swift
@@ -13,19 +13,50 @@ enum PseudoInstruction {
     case end
 }
 
-/// > Note:
-/// <https://webassembly.github.io/spec/core/syntax/instructions.html#expressions>
-struct Expression: Equatable {
-    /// Note that `end` or `else` pseudo instructions are omitted in this array
-    let instructions: [Instruction]
+struct InstructionSequence: Equatable {
+    let instructions: UnsafeBufferPointer<Instruction>
 
     init(instructions: [Instruction]) {
-        self.instructions = instructions
+        assert(_isPOD(Instruction.self))
+        let buffer = UnsafeMutableBufferPointer<Instruction>.allocate(capacity: instructions.count + 1)
+        for (idx, instruction) in instructions.enumerated() {
+            buffer[idx] = instruction
+        }
+        buffer[instructions.count] = .endOfFunction
+        self.instructions = UnsafeBufferPointer(buffer)
+    }
+
+    func deallocate() {
+        instructions.deallocate()
+    }
+
+    var baseAddress: UnsafePointer<Instruction> {
+        self.instructions.baseAddress!
+    }
+
+    static func == (lhs: InstructionSequence, rhs: InstructionSequence) -> Bool {
+        lhs.instructions.baseAddress == rhs.instructions.baseAddress
     }
 }
 
-extension Expression: ExpressibleByArrayLiteral {
+extension InstructionSequence: ExpressibleByArrayLiteral {
     init(arrayLiteral elements: Instruction...) {
         self.init(instructions: elements)
     }
 }
+
+struct ExpressionRef: Equatable {
+    let _relativeOffset: UInt32
+    var relativeOffset: Int {
+        Int(_relativeOffset)
+    }
+
+    init(_ relativeOffset: Int) {
+        self._relativeOffset = UInt32(relativeOffset)
+    }
+}
+
+/// > Note:
+/// <https://webassembly.github.io/spec/core/syntax/instructions.html#expressions>
+
+typealias Expression = [Instruction]
diff --git a/Sources/WasmKit/Execution/Instructions/Instruction.swift b/Sources/WasmKit/Execution/Instructions/Instruction.swift
index 5720149e..13dbd085 100644
--- a/Sources/WasmKit/Execution/Instructions/Instruction.swift
+++ b/Sources/WasmKit/Execution/Instructions/Instruction.swift
@@ -1,33 +1,107 @@
 enum Instruction: Equatable {
-    case control(ControlInstruction)
-    case memory(MemoryInstruction)
-    case numeric(NumericInstruction)
-    case parametric(ParametricInstruction)
-    case reference(ReferenceInstruction)
-    case table(TableInstruction)
-    case variable(VariableInstruction)
-    case pseudo(PseudoInstruction)
-}
-
-extension Instruction: CustomStringConvertible {
-    var description: String {
-        switch self {
-        case let .numeric(n):
-            return n.description
-        case let .variable(v):
-            return v.description
-        case let .control(c):
-            return String(reflecting: c)
-        case let .pseudo(p):
-            return String(reflecting: p)
-        case let .memory(m):
-            return String(reflecting: m)
-        case let .parametric(p):
-            return String(reflecting: p)
-        case let .reference(r):
-            return String(reflecting: r)
-        case let .table(t):
-            return String(reflecting: t)
-        }
-    }
+    case unreachable
+    case nop
+    case block(endRef: ExpressionRef, type: BlockType)
+    case loop(type: BlockType)
+    case ifThen(endRef: ExpressionRef, type: BlockType)
+    case ifThenElse(elseRef: ExpressionRef, endRef: ExpressionRef, type: BlockType)
+    case end
+    case `else`
+    case br(labelIndex: LabelIndex)
+    case brIf(labelIndex: LabelIndex)
+    case brTable(BrTable)
+    case `return`
+    case call(functionIndex: UInt32)
+    case callIndirect(tableIndex: TableIndex, typeIndex: TypeIndex)
+    case endOfFunction
+    case endOfExecution
+    case i32Load(memarg: Memarg)
+    case i64Load(memarg: Memarg)
+    case f32Load(memarg: Memarg)
+    case f64Load(memarg: Memarg)
+    case i32Load8S(memarg: Memarg)
+    case i32Load8U(memarg: Memarg)
+    case i32Load16S(memarg: Memarg)
+    case i32Load16U(memarg: Memarg)
+    case i64Load8S(memarg: Memarg)
+    case i64Load8U(memarg: Memarg)
+    case i64Load16S(memarg: Memarg)
+    case i64Load16U(memarg: Memarg)
+    case i64Load32S(memarg: Memarg)
+    case i64Load32U(memarg: Memarg)
+    case i32Store(memarg: Memarg)
+    case i64Store(memarg: Memarg)
+    case f32Store(memarg: Memarg)
+    case f64Store(memarg: Memarg)
+    case i32Store8(memarg: Memarg)
+    case i32Store16(memarg: Memarg)
+    case i64Store8(memarg: Memarg)
+    case i64Store16(memarg: Memarg)
+    case i64Store32(memarg: Memarg)
+    case memorySize
+    case memoryGrow
+    case memoryInit(DataIndex)
+    case memoryDataDrop(DataIndex)
+    case memoryCopy
+    case memoryFill
+    case numericConst(Value)
+    case numericIntUnary(NumericInstruction.IntUnary)
+    case numericFloatUnary(NumericInstruction.FloatUnary)
+    case numericIntBinary(NumericInstruction.IntBinary)
+    case numericFloatBinary(NumericInstruction.FloatBinary)
+    case numericConversion(NumericInstruction.Conversion)
+    case i32Add
+    case i64Add
+    case f32Add
+    case f64Add
+    case i32Sub
+    case i64Sub
+    case f32Sub
+    case f64Sub
+    case i32Mul
+    case i64Mul
+    case f32Mul
+    case f64Mul
+    case i32Eq
+    case i64Eq
+    case f32Eq
+    case f64Eq
+    case i32Ne
+    case i64Ne
+    case f32Ne
+    case f64Ne
+    case i32LtS
+    case i64LtS
+    case i32LtU
+    case i64LtU
+    case i32GtS
+    case i64GtS
+    case i32GtU
+    case i64GtU
+    case i32LeS
+    case i64LeS
+    case i32LeU
+    case i64LeU
+    case i32GeS
+    case i64GeS
+    case i32GeU
+    case i64GeU
+    case drop
+    case select
+    case refNull(ReferenceType)
+    case refIsNull
+    case refFunc(FunctionIndex)
+    case tableGet(TableIndex)
+    case tableSet(TableIndex)
+    case tableSize(TableIndex)
+    case tableGrow(TableIndex)
+    case tableFill(TableIndex)
+    case tableCopy(dest: TableIndex, src: TableIndex)
+    case tableInit(TableIndex, ElementIndex)
+    case tableElementDrop(ElementIndex)
+    case localGet(index: LocalIndex)
+    case localSet(index: LocalIndex)
+    case localTee(index: LocalIndex)
+    case globalGet(index: GlobalIndex)
+    case globalSet(index: GlobalIndex)
 }
diff --git a/Sources/WasmKit/Execution/Instructions/InstructionSupport.swift b/Sources/WasmKit/Execution/Instructions/InstructionSupport.swift
new file mode 100644
index 00000000..b5feb292
--- /dev/null
+++ b/Sources/WasmKit/Execution/Instructions/InstructionSupport.swift
@@ -0,0 +1,43 @@
+extension Instruction {
+    struct Memarg: Equatable {
+        let offset: UInt64
+        let align: UInt32
+    }
+
+    struct BlockType: Equatable {
+        let parameters: UInt16
+        let results: UInt16
+    }
+
+    struct BrTable: Equatable {
+        private let bufferBase: UnsafePointer<LabelIndex>
+        private let bufferCount: UInt32
+        var labelIndices: UnsafeBufferPointer<LabelIndex> {
+            UnsafeBufferPointer(start: bufferBase, count: Int(bufferCount - 1))
+        }
+        var defaultIndex: LabelIndex {
+            bufferBase[Int(bufferCount - 1)]
+        }
+
+        init(labelIndices: [LabelIndex], defaultIndex: LabelIndex) {
+            let buffer = UnsafeMutableBufferPointer<LabelIndex>.allocate(capacity: labelIndices.count + 1)
+            for (index, labelindex) in labelIndices.enumerated() {
+                buffer[index] = labelindex
+            }
+            buffer[labelIndices.count] = defaultIndex
+            self.bufferBase = UnsafePointer(buffer.baseAddress!)
+            self.bufferCount = UInt32(buffer.count)
+        }
+
+        static func == (lhs: Instruction.BrTable, rhs: Instruction.BrTable) -> Bool {
+            lhs.labelIndices.baseAddress == rhs.labelIndices.baseAddress
+        }
+    }
+
+    // Just for migration purpose
+    static func control(_ x: Instruction) -> Instruction { x }
+    static func numeric(_ x: Instruction) -> Instruction { x }
+    static func parametric(_ x: Instruction) -> Instruction { x }
+    static func variable(_ x: Instruction) -> Instruction { x }
+    static func reference(_ x: Instruction) -> Instruction { x }
+}
diff --git a/Sources/WasmKit/Execution/Instructions/Memory.swift b/Sources/WasmKit/Execution/Instructions/Memory.swift
index 263fdd05..8e8909c2 100644
--- a/Sources/WasmKit/Execution/Instructions/Memory.swift
+++ b/Sources/WasmKit/Execution/Instructions/Memory.swift
@@ -1,85 +1,160 @@
 /// > Note:
 /// <https://webassembly.github.io/spec/core/exec/instructions.html#memory-instructions>
-enum MemoryInstruction: Equatable {
-    struct Memarg: Equatable {
-        let offset: UInt64
-        let align: UInt32
-    }
-
-    case load(
-        _ memarg: Memarg,
-        bitWidth: UInt8,
-        _ type: NumericType,
-        isSigned: Bool = true
-    )
-    case store(_ memarg: Memarg, bitWidth: UInt8, _ type: ValueType)
-    case size
-    case grow
-    case `init`(DataIndex)
-    case dataDrop(DataIndex)
-    case copy
-    case fill
-
-    func execute(_ stack: inout Stack, _ store: Store) throws {
-        let moduleInstance = stack.currentFrame.module
-
-        switch self {
-        case let .load(memarg, bitWidth, type, isSigned):
-            let memoryAddress = moduleInstance.memoryAddresses[0]
+extension ExecutionState {
+    typealias Memarg = Instruction.Memarg
+
+    mutating func i32Load(runtime: Runtime, memarg: Memarg) throws {
+        try memoryLoad(runtime: runtime, memarg: memarg, loadAs: UInt32.self, castToValue: { .i32($0) })
+    }
+    mutating func i64Load(runtime: Runtime, memarg: Memarg) throws {
+        try memoryLoad(runtime: runtime, memarg: memarg, loadAs: UInt64.self, castToValue: { .i64($0) })
+    }
+    mutating func f32Load(runtime: Runtime, memarg: Memarg) throws {
+        try memoryLoad(runtime: runtime, memarg: memarg, loadAs: UInt32.self, castToValue: { .f32($0) })
+    }
+    mutating func f64Load(runtime: Runtime, memarg: Memarg) throws {
+        try memoryLoad(runtime: runtime, memarg: memarg, loadAs: UInt64.self, castToValue: { .f64($0) })
+    }
+    mutating func i32Load8S(runtime: Runtime, memarg: Memarg) throws {
+        try memoryLoad(runtime: runtime, memarg: memarg, loadAs: Int8.self, castToValue: { .init(signed: Int32($0)) })
+    }
+    mutating func i32Load8U(runtime: Runtime, memarg: Memarg) throws {
+        try memoryLoad(runtime: runtime, memarg: memarg, loadAs: UInt8.self, castToValue: { .i32(UInt32($0)) })
+    }
+    mutating func i32Load16S(runtime: Runtime, memarg: Memarg) throws {
+        try memoryLoad(runtime: runtime, memarg: memarg, loadAs: Int16.self, castToValue: { .init(signed: Int32($0)) })
+    }
+    mutating func i32Load16U(runtime: Runtime, memarg: Memarg) throws {
+        try memoryLoad(runtime: runtime, memarg: memarg, loadAs: UInt16.self, castToValue: { .i32(UInt32($0)) })
+    }
+    mutating func i64Load8S(runtime: Runtime, memarg: Memarg) throws {
+        try memoryLoad(runtime: runtime, memarg: memarg, loadAs: Int8.self, castToValue: { .init(signed: Int64($0)) })
+    }
+    mutating func i64Load8U(runtime: Runtime, memarg: Memarg) throws {
+        try memoryLoad(runtime: runtime, memarg: memarg, loadAs: UInt8.self, castToValue: { .i64(UInt64($0)) })
+    }
+    mutating func i64Load16S(runtime: Runtime, memarg: Memarg) throws {
+        try memoryLoad(runtime: runtime, memarg: memarg, loadAs: Int16.self, castToValue: { .init(signed: Int64($0)) })
+    }
+    mutating func i64Load16U(runtime: Runtime, memarg: Memarg) throws {
+        try memoryLoad(runtime: runtime, memarg: memarg, loadAs: UInt16.self, castToValue: { .i64(UInt64($0)) })
+    }
+    mutating func i64Load32S(runtime: Runtime, memarg: Memarg) throws {
+        try memoryLoad(runtime: runtime, memarg: memarg, loadAs: Int32.self, castToValue: { .init(signed: Int64($0)) })
+    }
+    mutating func i64Load32U(runtime: Runtime, memarg: Memarg) throws {
+        try memoryLoad(runtime: runtime, memarg: memarg, loadAs: UInt32.self, castToValue: { .i64(UInt64($0)) })
+    }
+
+    @_transparent
+    private mutating func memoryLoad<T: FixedWidthInteger>(
+        runtime: Runtime, memarg: Instruction.Memarg, loadAs _: T.Type = T.self, castToValue: (T) -> Value
+    ) throws {
+        let moduleInstance = currentModule(store: runtime.store)
+        let store = runtime.store
+
+        let memoryAddress = moduleInstance.memoryAddresses[0]
+        let memoryInstance = store.memories[memoryAddress]
+        let i = stack.popValue().asAddressOffset(memoryInstance.limit.isMemory64)
+        let (address, isOverflow) = memarg.offset.addingReportingOverflow(i)
+        guard !isOverflow else {
+            throw Trap.outOfBoundsMemoryAccess
+        }
+        let length = UInt64(T.bitWidth) / 8
+        let (endAddress, isEndOverflow) = address.addingReportingOverflow(length)
+        guard !isEndOverflow, endAddress <= memoryInstance.data.count else {
+            throw Trap.outOfBoundsMemoryAccess
+        }
+
+        let loaded = memoryInstance.data.withUnsafeBufferPointer { buffer in
+            let rawBuffer = UnsafeRawBufferPointer(buffer)
+            return rawBuffer.loadUnaligned(fromByteOffset: Int(address), as: T.self)
+        }
+        stack.push(value: castToValue(loaded))
+
+    }
+
+    mutating func i32Store(runtime: Runtime, memarg: Memarg) throws {
+        try memoryStore(runtime: runtime, memarg: memarg, castFromValue: { $0.i32 })
+    }
+    mutating func i64Store(runtime: Runtime, memarg: Memarg) throws {
+        try memoryStore(runtime: runtime, memarg: memarg, castFromValue: { $0.i64 })
+    }
+    mutating func f32Store(runtime: Runtime, memarg: Memarg) throws {
+        try memoryStore(runtime: runtime, memarg: memarg, castFromValue: { $0.f32 })
+    }
+    mutating func f64Store(runtime: Runtime, memarg: Memarg) throws {
+        try memoryStore(runtime: runtime, memarg: memarg, castFromValue: { $0.f64 })
+    }
+    mutating func i32Store8(runtime: Runtime, memarg: Memarg) throws {
+        try memoryStore(runtime: runtime, memarg: memarg, castFromValue: { UInt8(truncatingIfNeeded: $0.i32) })
+    }
+    mutating func i32Store16(runtime: Runtime, memarg: Memarg) throws {
+        try memoryStore(runtime: runtime, memarg: memarg, castFromValue: { UInt16(truncatingIfNeeded: $0.i32) })
+    }
+    mutating func i64Store8(runtime: Runtime, memarg: Memarg) throws {
+        try memoryStore(runtime: runtime, memarg: memarg, castFromValue: { UInt8(truncatingIfNeeded: $0.i64) })
+    }
+    mutating func i64Store16(runtime: Runtime, memarg: Memarg) throws {
+        try memoryStore(runtime: runtime, memarg: memarg, castFromValue: { UInt16(truncatingIfNeeded: $0.i64) })
+    }
+    mutating func i64Store32(runtime: Runtime, memarg: Memarg) throws {
+        try memoryStore(runtime: runtime, memarg: memarg, castFromValue: { UInt32(truncatingIfNeeded: $0.i64) })
+    }
+
+    /// `[type].store[bitWidth]`
+    @_transparent
+    private mutating func memoryStore<T: FixedWidthInteger>(runtime: Runtime, memarg: Instruction.Memarg, castFromValue: (Value) -> T) throws {
+        let moduleInstance = currentModule(store: runtime.store)
+        let store = runtime.store
+
+        let value = stack.popValue()
+
+        let memoryAddress = moduleInstance.memoryAddresses[0]
+        let address: UInt64
+        let endAddress: UInt64
+        let length: UInt64
+        do {
             let memoryInstance = store.memories[memoryAddress]
-            let i = try stack.popValue().asAddressOffset(memoryInstance.limit.isMemory64)
-            let (address, isOverflow) = memarg.offset.addingReportingOverflow(i)
+            let i = stack.popValue().asAddressOffset(memoryInstance.limit.isMemory64)
+            var isOverflow: Bool
+            (address, isOverflow) = memarg.offset.addingReportingOverflow(i)
             guard !isOverflow else {
                 throw Trap.outOfBoundsMemoryAccess
             }
-            let length = UInt64(bitWidth) / 8
-            let (endAddress, isEndOverflow) = address.addingReportingOverflow(length)
-            guard !isEndOverflow, endAddress <= memoryInstance.data.count else {
+            length = UInt64(T.bitWidth) / 8
+            (endAddress, isOverflow) = address.addingReportingOverflow(length)
+            guard !isOverflow, endAddress <= memoryInstance.data.count else {
                 throw Trap.outOfBoundsMemoryAccess
             }
+        }
 
-            let bytes = memoryInstance.data[Int(address)..<Int(endAddress)]
-
-            stack.push(value: Value(bytes, .numeric(type), isSigned: isSigned)!)
-
-        case let .store(memarg, bitWidth, _):
-            let value = try stack.popValue()
-
-            let memoryAddress = moduleInstance.memoryAddresses[0]
-            let address: UInt64
-            let endAddress: UInt64
-            let length: UInt64
-            do {
-                let memoryInstance = store.memories[memoryAddress]
-                let i = try stack.popValue().asAddressOffset(memoryInstance.limit.isMemory64)
-                var isOverflow: Bool
-                (address, isOverflow) = memarg.offset.addingReportingOverflow(i)
-                guard !isOverflow else {
-                    throw Trap.outOfBoundsMemoryAccess
-                }
-                length = UInt64(bitWidth) / 8
-                (endAddress, isOverflow) = address.addingReportingOverflow(length)
-                guard !isOverflow, endAddress <= memoryInstance.data.count else {
-                    throw Trap.outOfBoundsMemoryAccess
-                }
-            }
-
-            // NOTE: Swift.Array can't allocate 2^64-1 bytes, so we actually support 2^63-1 bytes at most
-            store.memories[memoryAddress].data
-                .replaceSubrange(Int(address)..<Int(endAddress), with: value.bytes![0..<Int(length)])
+        let toStore = castFromValue(value)
+        store.memories[memoryAddress].data.withUnsafeMutableBufferPointer { buffer in
+            let rawBuffer = UnsafeMutableRawBufferPointer(buffer)
+            rawBuffer.baseAddress!.advanced(by: Int(address)).bindMemory(to: T.self, capacity: 1).pointee = toStore.littleEndian
+        }
+    }
 
-        case .size:
-            let memoryAddress = moduleInstance.memoryAddresses[0]
+    mutating func memorySize(runtime: Runtime) {
+        let moduleInstance = currentModule(store: runtime.store)
+        let store = runtime.store
 
-            let memoryInstance = store.memories[memoryAddress]
-            let pageCount = memoryInstance.data.count / MemoryInstance.pageSize
-            stack.push(value: memoryInstance.limit.isMemory64 ? .i64(UInt64(pageCount)) : .i32(UInt32(pageCount)))
+        let memoryAddress = moduleInstance.memoryAddresses[0]
 
-        case .grow:
-            let memoryAddress = moduleInstance.memoryAddresses[0]
-            let isMemory64 = store.memories[memoryAddress].limit.isMemory64
+        let memoryInstance = store.memories[memoryAddress]
+        let pageCount = memoryInstance.data.count / MemoryInstance.pageSize
+        stack.push(value: memoryInstance.limit.isMemory64 ? .i64(UInt64(pageCount)) : .i32(UInt32(pageCount)))
+    }
+    mutating func memoryGrow(runtime: Runtime) throws {
+        let moduleInstance = currentModule(store: runtime.store)
+        let store = runtime.store
 
-            let value = try stack.popValue()
+        let memoryAddress = moduleInstance.memoryAddresses[0]
+        try store.withMemory(at: memoryAddress) { memoryInstance in
+            let isMemory64 = memoryInstance.limit.isMemory64
+            
+            let value = stack.popValue()
             let pageCount: UInt64
             switch (isMemory64, value) {
             case let (true, .i64(value)):
@@ -91,21 +166,25 @@ enum MemoryInstruction: Equatable {
                     expected: isMemory64 ? .i64 : .i32, actual: value.type
                 )
             }
-            let oldPageCount = store.memories[memoryAddress].grow(by: Int(pageCount))
+            let oldPageCount = memoryInstance.grow(by: Int(pageCount))
             stack.push(value: oldPageCount)
+        }
+    }
+    mutating func memoryInit(runtime: Runtime, dataIndex: DataIndex) throws {
+        let moduleInstance = currentModule(store: runtime.store)
+        let store = runtime.store
 
-        case let .`init`(dataIndex):
-            let memoryAddress = moduleInstance.memoryAddresses[0]
+        let memoryAddress = moduleInstance.memoryAddresses[0]
+        try store.withMemory(at: memoryAddress) { memoryInstance in
             let dataAddress = moduleInstance.dataAddresses[Int(dataIndex)]
             let dataInstance = store.datas[dataAddress]
-            let memoryInstance = store.memories[memoryAddress]
-
-            let copyCounter = try stack.popValue().i32
-            let sourceIndex = try stack.popValue().i32
-            let destinationIndex = try stack.popValue().asAddressOffset(memoryInstance.limit.isMemory64)
-
+            
+            let copyCounter = stack.popValue().i32
+            let sourceIndex = stack.popValue().i32
+            let destinationIndex = stack.popValue().asAddressOffset(memoryInstance.limit.isMemory64)
+            
             guard copyCounter > 0 else { return }
-
+            
             guard
                 !sourceIndex.addingReportingOverflow(copyCounter).overflow
                     && !destinationIndex.addingReportingOverflow(UInt64(copyCounter)).overflow
@@ -114,65 +193,72 @@ enum MemoryInstruction: Equatable {
             else {
                 throw Trap.outOfBoundsMemoryAccess
             }
-
+            
             // FIXME: benchmark if using `replaceSubrange` is faster than this loop
             for i in 0..<copyCounter {
-                store.memories[memoryAddress].data[Int(destinationIndex + UInt64(i))] =
-                    dataInstance.data[Int(sourceIndex + i)]
+                memoryInstance.data[Int(destinationIndex + UInt64(i))] =
+                dataInstance.data[Int(sourceIndex + i)]
             }
+        }
+    }
+    mutating func memoryDataDrop(runtime: Runtime, dataIndex: DataIndex) {
+        let moduleInstance = currentModule(store: runtime.store)
+        let store = runtime.store
+        let dataAddress = moduleInstance.dataAddresses[Int(dataIndex)]
+        store.datas[dataAddress] = DataInstance(data: [])
+    }
+    mutating func memoryCopy(runtime: Runtime) throws {
+        let moduleInstance = currentModule(store: runtime.store)
+        let store = runtime.store
 
-        case let .dataDrop(dataIndex):
-            let dataAddress = moduleInstance.dataAddresses[Int(dataIndex)]
-            store.datas[dataAddress] = DataInstance(data: [])
-
-        case .fill:
-            let memoryAddress = moduleInstance.memoryAddresses[0]
-
-            let copyCounter = try Int(stack.popValue().i32)
-            let value = try stack.popValue()
-            let destinationIndex = try Int(stack.popValue().i32)
-
-            guard
-                !destinationIndex.addingReportingOverflow(copyCounter).overflow
-                    && store.memories[memoryAddress].data.count >= destinationIndex + copyCounter
-            else {
-                throw Trap.outOfBoundsMemoryAccess
-            }
-
-            store.memories[memoryAddress].data.replaceSubrange(
-                destinationIndex..<destinationIndex + copyCounter,
-                with: [UInt8](repeating: value.bytes![0], count: copyCounter)
-            )
-
-        case .copy:
-            let memoryAddress = moduleInstance.memoryAddresses[0]
-
-            let copyCounter = try stack.popValue().i32
-            let sourceIndex = try stack.popValue().i32
-            let destinationIndex = try stack.popValue().i32
+        let memoryAddress = moduleInstance.memoryAddresses[0]
+        try store.withMemory(at: memoryAddress) { memoryInstance in
+            let copyCounter = stack.popValue().i32
+            let sourceIndex = stack.popValue().i32
+            let destinationIndex = stack.popValue().i32
 
             guard copyCounter > 0 else { return }
 
             guard
                 !sourceIndex.addingReportingOverflow(copyCounter).overflow
                     && !destinationIndex.addingReportingOverflow(copyCounter).overflow
-                    && store.memories[memoryAddress].data.count >= destinationIndex + copyCounter
-                    && store.memories[memoryAddress].data.count >= sourceIndex + copyCounter
+                    && memoryInstance.data.count >= destinationIndex + copyCounter
+                    && memoryInstance.data.count >= sourceIndex + copyCounter
             else {
                 throw Trap.outOfBoundsMemoryAccess
             }
 
             if destinationIndex <= sourceIndex {
                 for i in 0..<copyCounter {
-                    store.memories[memoryAddress].data[Int(destinationIndex + i)] =
-                        store.memories[memoryAddress].data[Int(sourceIndex + i)]
+                    memoryInstance.data[Int(destinationIndex + i)] = memoryInstance.data[Int(sourceIndex + i)]
                 }
             } else {
                 for i in 1...copyCounter {
-                    store.memories[memoryAddress].data[Int(destinationIndex + copyCounter - i)] =
-                        store.memories[memoryAddress].data[Int(sourceIndex + copyCounter - i)]
+                    memoryInstance.data[Int(destinationIndex + copyCounter - i)] = memoryInstance.data[Int(sourceIndex + copyCounter - i)]
                 }
             }
         }
     }
+    mutating func memoryFill(runtime: Runtime) throws {
+        let moduleInstance = currentModule(store: runtime.store)
+        let store = runtime.store
+        let memoryAddress = moduleInstance.memoryAddresses[0]
+        try store.withMemory(at: memoryAddress) { memoryInstance in
+            let copyCounter = Int(stack.popValue().i32)
+            let value = stack.popValue()
+            let destinationIndex = Int(stack.popValue().i32)
+            
+            guard
+                !destinationIndex.addingReportingOverflow(copyCounter).overflow
+                    && memoryInstance.data.count >= destinationIndex + copyCounter
+            else {
+                throw Trap.outOfBoundsMemoryAccess
+            }
+            
+            memoryInstance.data.replaceSubrange(
+                destinationIndex..<destinationIndex + copyCounter,
+                with: [UInt8](repeating: value.bytes![0], count: copyCounter)
+            )
+        }
+    }
 }
diff --git a/Sources/WasmKit/Execution/Instructions/Numeric.swift b/Sources/WasmKit/Execution/Instructions/Numeric.swift
index 7673cfe5..0effbc17 100644
--- a/Sources/WasmKit/Execution/Instructions/Numeric.swift
+++ b/Sources/WasmKit/Execution/Instructions/Numeric.swift
@@ -1,55 +1,177 @@
 /// > Note:
 /// <https://webassembly.github.io/spec/core/exec/instructions.html#numeric-instructions>
-enum NumericInstruction: Equatable {
-    case const(Value)
-    case intUnary(IntUnary)
-    case floatUnary(FloatUnary)
-    case binary(Binary)
-    case intBinary(IntBinary)
-    case floatBinary(FloatBinary)
-    case conversion(Conversion)
+extension ExecutionState {
+    mutating func numericConst(runtime: Runtime, value: Value) {
+        stack.push(value: value)
+    }
+    mutating func numericIntUnary(runtime: Runtime, intUnary: NumericInstruction.IntUnary) {
+        let value = stack.popValue()
 
-    func execute(_ stack: inout Stack) throws {
-        switch self {
-        case let .const(value):
-            stack.push(value: value)
+        stack.push(value: intUnary(value))
+    }
+    mutating func numericFloatUnary(runtime: Runtime, floatUnary: NumericInstruction.FloatUnary) {
+        let value = stack.popValue()
 
-        case let .intUnary(instruction):
-            let value = try stack.popValue()
+        stack.push(value: floatUnary(value))
+    }
+    @inline(__always)
+    private mutating func numericBinary<T>(castTo: (Value) -> T, binary: (T, T) -> Value) {
+        let value2 = stack.popValue()
+        let value1 = stack.popValue()
 
-            stack.push(value: instruction(value))
+        stack.push(value: binary(castTo(value1), castTo(value2)))
+    }
 
-        case let .floatUnary(instruction):
-            let value = try stack.popValue()
+    mutating func i32Add(runtime: Runtime) {
+        numericBinary(castTo: \.i32, binary: { .i32($0 &+ $1) })
+    }
 
-            stack.push(value: instruction(value))
+    mutating func i64Add(runtime: Runtime) {
+        numericBinary(castTo: \.i64, binary: { .i64($0 &+ $1) })
+    }
 
-        case let .binary(instruction):
-            let value2 = try stack.popValue()
-            let value1 = try stack.popValue()
+    mutating func f32Add(runtime: Runtime) {
+        numericBinary(castTo: \.f32, binary: { .f32((Float32(bitPattern: $0) + Float32(bitPattern: $1)).bitPattern) })
+    }
 
-            stack.push(value: instruction(value1, value2))
+    mutating func f64Add(runtime: Runtime) {
+        numericBinary(castTo: \.f64, binary: { .f64((Float64(bitPattern: $0) + Float64(bitPattern: $1)).bitPattern) })
+    }
 
-        case let .intBinary(instruction):
-            let value2 = try stack.popValue()
-            let value1 = try stack.popValue()
+    mutating func i32Sub(runtime: Runtime) {
+        numericBinary(castTo: \.i32, binary: { .i32($0 &- $1) })
+    }
 
-            try stack.push(value: instruction(value1, value2))
+    mutating func i64Sub(runtime: Runtime) {
+        numericBinary(castTo: \.i64, binary: { .i64($0 &- $1) })
+    }
 
-        case let .floatBinary(instruction):
-            let value2 = try stack.popValue()
-            let value1 = try stack.popValue()
+    mutating func f32Sub(runtime: Runtime) {
+        numericBinary(castTo: \.f32, binary: { .f32((Float32(bitPattern: $0) - Float32(bitPattern: $1)).bitPattern) })
+    }
 
-            try stack.push(value: instruction(value1, value2))
+    mutating func f64Sub(runtime: Runtime) {
+        numericBinary(castTo: \.f64, binary: { .f64((Float64(bitPattern: $0) - Float64(bitPattern: $1)).bitPattern) })
+    }
 
-        case let .conversion(instruction):
-            let value = try stack.popValue()
+    mutating func i32Mul(runtime: Runtime) {
+        numericBinary(castTo: \.i32, binary: { .i32($0 &* $1) })
+    }
 
-            try stack.push(value: instruction(value))
-        }
+    mutating func i64Mul(runtime: Runtime) {
+        numericBinary(castTo: \.i64, binary: { .i64($0 &* $1) })
+    }
+
+    mutating func f32Mul(runtime: Runtime) {
+        numericBinary(castTo: \.f32, binary: { .f32((Float32(bitPattern: $0) * Float32(bitPattern: $1)).bitPattern) })
+    }
+
+    mutating func f64Mul(runtime: Runtime) {
+        numericBinary(castTo: \.f64, binary: { .f64((Float64(bitPattern: $0) * Float64(bitPattern: $1)).bitPattern) })
+    }
+
+    mutating func i32Eq(runtime: Runtime) {
+        numericBinary(castTo: \.i32, binary: { $0 == $1 ? true : false })
+    }
+
+    mutating func i64Eq(runtime: Runtime) {
+        numericBinary(castTo: \.i64, binary: { $0 == $1 ? true : false })
+    }
+
+    mutating func f32Eq(runtime: Runtime) {
+        numericBinary(castTo: \.f32, binary: { Float32(bitPattern: $0) == Float32(bitPattern: $1) ? true : false })
+    }
+
+    mutating func f64Eq(runtime: Runtime) {
+        numericBinary(castTo: \.f64, binary: { Float64(bitPattern: $0) == Float64(bitPattern: $1) ? true : false })
+    }
+
+    mutating func i32Ne(runtime: Runtime) {
+        numericBinary(castTo: \.i32, binary: { $0 == $1 ? false : true })
+    }
+
+    mutating func i64Ne(runtime: Runtime) {
+        numericBinary(castTo: \.i64, binary: { $0 == $1 ? false : true })
+    }
+
+    mutating func f32Ne(runtime: Runtime) {
+        numericBinary(castTo: \.f32, binary: { Float32(bitPattern: $0) == Float32(bitPattern: $1) ? false : true })
+    }
+
+    mutating func f64Ne(runtime: Runtime) {
+        numericBinary(castTo: \.f64, binary: { Float64(bitPattern: $0) == Float64(bitPattern: $1) ? false : true })
+    }
+
+    mutating func i32LtS(runtime: Runtime) {
+        numericBinary(castTo: \.i32, binary: { $0.signed < $1.signed ? true : false })
+    }
+    mutating func i64LtS(runtime: Runtime) {
+        numericBinary(castTo: \.i64, binary: { $0.signed < $1.signed ? true : false })
+    }
+    mutating func i32LtU(runtime: Runtime) {
+        numericBinary(castTo: \.i32, binary: { $0 < $1 ? true : false })
+    }
+    mutating func i64LtU(runtime: Runtime) {
+        numericBinary(castTo: \.i64, binary: { $0 < $1 ? true : false })
+    }
+    mutating func i32GtS(runtime: Runtime) {
+        numericBinary(castTo: \.i32, binary: { $0.signed > $1.signed ? true : false })
+    }
+    mutating func i64GtS(runtime: Runtime) {
+        numericBinary(castTo: \.i64, binary: { $0.signed > $1.signed ? true : false })
+    }
+    mutating func i32GtU(runtime: Runtime) {
+        numericBinary(castTo: \.i32, binary: { $0 > $1 ? true : false })
+    }
+    mutating func i64GtU(runtime: Runtime) {
+        numericBinary(castTo: \.i64, binary: { $0 > $1 ? true : false })
+    }
+    mutating func i32LeS(runtime: Runtime) {
+        numericBinary(castTo: \.i32, binary: { $0.signed <= $1.signed ? true : false })
+    }
+    mutating func i64LeS(runtime: Runtime) {
+        numericBinary(castTo: \.i64, binary: { $0.signed <= $1.signed ? true : false })
+    }
+    mutating func i32LeU(runtime: Runtime) {
+        numericBinary(castTo: \.i32, binary: { $0 <= $1 ? true : false })
+    }
+    mutating func i64LeU(runtime: Runtime) {
+        numericBinary(castTo: \.i64, binary: { $0 <= $1 ? true : false })
+    }
+    mutating func i32GeS(runtime: Runtime) {
+        numericBinary(castTo: \.i32, binary: { $0.signed >= $1.signed ? true : false })
+    }
+    mutating func i64GeS(runtime: Runtime) {
+        numericBinary(castTo: \.i64, binary: { $0.signed >= $1.signed ? true : false })
+    }
+    mutating func i32GeU(runtime: Runtime) {
+        numericBinary(castTo: \.i32, binary: { $0 >= $1 ? true : false })
+    }
+    mutating func i64GeU(runtime: Runtime) {
+        numericBinary(castTo: \.i64, binary: { $0 >= $1 ? true : false })
+    }
+
+    mutating func numericIntBinary(runtime: Runtime, intBinary: NumericInstruction.IntBinary) throws {
+        let value2 = stack.popValue()
+        let value1 = stack.popValue()
+
+        try stack.push(value: intBinary(value1, value2))
+    }
+    mutating func numericFloatBinary(runtime: Runtime, floatBinary: NumericInstruction.FloatBinary) {
+        let value2 = stack.popValue()
+        let value1 = stack.popValue()
+
+        stack.push(value: floatBinary(value1, value2))
+    }
+    mutating func numericConversion(runtime: Runtime, conversion: NumericInstruction.Conversion) throws {
+        let value = stack.popValue()
+
+        try stack.push(value: conversion(value))
     }
 }
 
+enum NumericInstruction {}
+
 /// Numeric Instructions
 extension NumericInstruction {
     internal enum Constant {
@@ -135,44 +257,6 @@ extension NumericInstruction {
         }
     }
 
-    public enum Binary: Equatable {
-        // binop
-        case add(NumericType)
-        case sub(NumericType)
-        case mul(NumericType)
-
-        // relop
-        case eq(NumericType)
-        case ne(NumericType)
-
-        var type: NumericType {
-            switch self {
-            case let .add(type),
-                let .sub(type),
-                let .mul(type),
-                let .eq(type),
-                let .ne(type):
-                return type
-            }
-        }
-
-        func callAsFunction(_ value1: Value, _ value2: Value) -> Value {
-            switch self {
-            case .add:
-                return value1 + value2
-            case .sub:
-                return value1 - value2
-            case .mul:
-                return value1 * value2
-
-            case .eq:
-                return value1 == value2 ? true : false
-            case .ne:
-                return value1 == value2 ? false : true
-            }
-        }
-    }
-
     public enum IntBinary: Equatable {
         // ibinop
         case divS(IntValueType)
@@ -188,16 +272,6 @@ extension NumericInstruction {
         case rotl(IntValueType)
         case rotr(IntValueType)
 
-        // irelop
-        case ltS(IntValueType)
-        case ltU(IntValueType)
-        case gtS(IntValueType)
-        case gtU(IntValueType)
-        case leS(IntValueType)
-        case leU(IntValueType)
-        case geS(IntValueType)
-        case geU(IntValueType)
-
         var type: NumericType {
             switch self {
             case let .divS(type),
@@ -211,15 +285,7 @@ extension NumericInstruction {
                 let .shrS(type),
                 let .shrU(type),
                 let .rotl(type),
-                let .rotr(type),
-                let .ltS(type),
-                let .ltU(type),
-                let .gtS(type),
-                let .gtU(type),
-                let .leS(type),
-                let .leU(type),
-                let .geS(type),
-                let .geU(type):
+                let .rotr(type):
                 return .int(type)
             }
         }
@@ -261,43 +327,6 @@ extension NumericInstruction {
                 return value1.rotl(value2)
             case (.rotr, _):
                 return value1.rotr(value2)
-
-            case (.ltS, .int(.i32)):
-                return value1.i32.signed < value2.i32.signed ? true : false
-            case (.ltU, .int(.i32)):
-                return value1.i32 < value2.i32 ? true : false
-            case (.gtS, .int(.i32)):
-                return value1.i32.signed > value2.i32.signed ? true : false
-            case (.gtU, .int(.i32)):
-                return value1.i32 > value2.i32 ? true : false
-            case (.leS, .int(.i32)):
-                return value1.i32.signed <= value2.i32.signed ? true : false
-            case (.leU, .int(.i32)):
-                return value1.i32 <= value2.i32 ? true : false
-            case (.geS, .int(.i32)):
-                return value1.i32.signed >= value2.i32.signed ? true : false
-            case (.geU, .int(.i32)):
-                return value1.i32 >= value2.i32 ? true : false
-
-            case (.ltS, .int(.i64)):
-                return value1.i64.signed < value2.i64.signed ? true : false
-            case (.ltU, .int(.i64)):
-                return value1.i64 < value2.i64 ? true : false
-            case (.gtS, .int(.i64)):
-                return value1.i64.signed > value2.i64.signed ? true : false
-            case (.gtU, .int(.i64)):
-                return value1.i64 > value2.i64 ? true : false
-            case (.leS, .int(.i64)):
-                return value1.i64.signed <= value2.i64.signed ? true : false
-            case (.leU, .int(.i64)):
-                return value1.i64 <= value2.i64 ? true : false
-            case (.geS, .int(.i64)):
-                return value1.i64.signed >= value2.i64.signed ? true : false
-            case (.geU, .int(.i64)):
-                return value1.i64 >= value2.i64 ? true : false
-
-            default:
-                fatalError("Invalid type \(type) for instruction \(self)")
             }
         }
     }
@@ -329,7 +358,7 @@ extension NumericInstruction {
             }
         }
 
-        func callAsFunction(_ value1: Value, _ value2: Value) throws -> Value {
+        func callAsFunction(_ value1: Value, _ value2: Value) -> Value {
             switch self {
             case .div:
                 guard !value1.isNan && !value2.isNan else {
@@ -816,72 +845,3 @@ extension NumericInstruction {
         }
     }
 }
-
-extension NumericInstruction: CustomStringConvertible {
-    public var description: String {
-        switch self {
-        case let .const(v):
-            switch v {
-            case let .f32(f32): return "f32.const \(f32)"
-            case let .f64(f64): return "f64.const \(f64)"
-            case let .i32(i32): return "i32.const \(i32.signed)"
-            case let .i64(i64): return "i64.const \(i64.signed)"
-            case let .ref(.function(f?)): return "ref.func \(f)"
-            case .ref(.function(nil)): return "ref.null funcref"
-            case .ref(.extern(nil)): return "ref.null externref"
-            default: fatalError("unsuppported const instruction for value \(v)")
-            }
-
-        case let .binary(b):
-            switch b {
-            case let .add(t):
-                return "\(t).add"
-
-            case let .eq(t):
-                return "\(t).eq"
-
-            case let .mul(t):
-                return "\(t).mul"
-
-            case let .ne(t):
-                return "\(t).ne"
-
-            case let .sub(t):
-                return "\(t).sub"
-            }
-
-        case let .intBinary(ib):
-            switch ib {
-            case let .and(it): return "\(it).and"
-            case let .xor(it): return "\(it).xor"
-            case let .or(it): return "\(it).or"
-            case let .shl(it): return "\(it).shl"
-            case let .shrS(it): return "\(it).shr_s"
-            case let .shrU(it): return "\(it).shr_u"
-            case let .rotl(it): return "\(it).rotl"
-            case let .rotr(it): return "\(it).rotr"
-            case let .remS(it): return "\(it).rem_s"
-            case let .remU(it): return "\(it).rem_u"
-            case let .divS(it): return "\(it).div_s"
-            case let .divU(it): return "\(it).div_u"
-            case let .ltS(it): return "\(it).lt_s"
-            case let .ltU(it): return "\(it).lt_u"
-            case let .gtS(it): return "\(it).gt_s"
-            case let .gtU(it): return "\(it).gt_u"
-            case let .leS(it): return "\(it).le_s"
-            case let .leU(it): return "\(it).le_u"
-            case let .geS(it): return "\(it).ge_s"
-            case let .geU(it): return "\(it).ge_u"
-            }
-
-        case let .conversion(c):
-            return String(reflecting: c)
-        case let .intUnary(iu):
-            return String(reflecting: iu)
-        case let .floatUnary(fu):
-            return String(reflecting: fu)
-        case let .floatBinary(fb):
-            return String(reflecting: fb)
-        }
-    }
-}
diff --git a/Sources/WasmKit/Execution/Instructions/Parametric.swift b/Sources/WasmKit/Execution/Instructions/Parametric.swift
index 603bd4b7..a12f3660 100644
--- a/Sources/WasmKit/Execution/Instructions/Parametric.swift
+++ b/Sources/WasmKit/Execution/Instructions/Parametric.swift
@@ -1,27 +1,24 @@
 /// > Note:
 /// <https://webassembly.github.io/spec/core/exec/instructions.html#parametric-instructions>
-enum ParametricInstruction: Equatable {
-    case drop
-    case select
-    case typedSelect([ValueType])
-
-    func execute(_ stack: inout Stack) throws {
-        switch self {
-        case .drop:
-            _ = try stack.popValue()
+extension ExecutionState {
+    mutating func drop(runtime: Runtime) {
+        _ = stack.popValue()
+    }
+    mutating func select(runtime: Runtime) throws {
+        try doSelect()
+    }
 
-        case .select, .typedSelect:
-            let flagValue = try stack.popValue()
-            guard case let .i32(flag) = flagValue else {
-                throw Trap.stackValueTypesMismatch(expected: .i32, actual: flagValue.type)
-            }
-            let value2 = try stack.popValue()
-            let value1 = try stack.popValue()
-            if flag != 0 {
-                stack.push(value: value1)
-            } else {
-                stack.push(value: value2)
-            }
+    private mutating func doSelect() throws {
+        let flagValue = stack.popValue()
+        guard case let .i32(flag) = flagValue else {
+            throw Trap.stackValueTypesMismatch(expected: .i32, actual: flagValue.type)
+        }
+        let value2 = stack.popValue()
+        let value1 = stack.popValue()
+        if flag != 0 {
+            stack.push(value: value1)
+        } else {
+            stack.push(value: value2)
         }
     }
 }
diff --git a/Sources/WasmKit/Execution/Instructions/Reference.swift b/Sources/WasmKit/Execution/Instructions/Reference.swift
index fa759680..514c3cbd 100644
--- a/Sources/WasmKit/Execution/Instructions/Reference.swift
+++ b/Sources/WasmKit/Execution/Instructions/Reference.swift
@@ -1,36 +1,30 @@
 /// > Note:
 /// <https://webassembly.github.io/spec/core/exec/instructions.html#reference-instructions>
-enum ReferenceInstruction: Equatable {
-    case refNull(ReferenceType)
-    case refIsNull
-    case refFunc(FunctionIndex)
-
-    func execute(_ stack: inout Stack) throws {
-        switch self {
-        case let .refNull(type):
-            switch type {
-            case .externRef:
-                stack.push(value: .ref(.extern(nil)))
-            case .funcRef:
-                stack.push(value: .ref(.function(nil)))
-            }
-
-        case .refIsNull:
-            let value = try stack.popValue()
-
-            switch value {
-            case .ref(.extern(nil)), .ref(.function(nil)):
-                stack.push(value: .i32(1))
-            case .ref(.extern(_)), .ref(.function(_)):
-                stack.push(value: .i32(0))
-            default:
-                fatalError("Invalid type \(value.type) for `\(#function)` implementation")
-            }
-
-        case let .refFunc(functionIndex):
-            let functionAddress = stack.currentFrame.module.functionAddresses[Int(functionIndex)]
+extension ExecutionState {
+    mutating func refNull(runtime: Runtime, referenceType: ReferenceType) {
+        switch referenceType {
+        case .externRef:
+            stack.push(value: .ref(.extern(nil)))
+        case .funcRef:
+            stack.push(value: .ref(.function(nil)))
+        }
+    }
+    mutating func refIsNull(runtime: Runtime) {
+        let value = stack.popValue()
 
-            stack.push(value: .ref(.function(functionAddress)))
+        switch value {
+        case .ref(.extern(nil)), .ref(.function(nil)):
+            stack.push(value: .i32(1))
+        case .ref(.extern(_)), .ref(.function(_)):
+            stack.push(value: .i32(0))
+        default:
+            fatalError("Invalid type \(value.type) for `\(#function)` implementation")
         }
     }
+    mutating func refFunc(runtime: Runtime, functionIndex: FunctionIndex) {
+        let module = runtime.store.module(address: stack.currentFrame.module)
+        let functionAddress = module.functionAddresses[Int(functionIndex)]
+
+        stack.push(value: .ref(.function(functionAddress)))
+    }
 }
diff --git a/Sources/WasmKit/Execution/Instructions/Table.swift b/Sources/WasmKit/Execution/Instructions/Table.swift
index 2ee957c6..30ba970e 100644
--- a/Sources/WasmKit/Execution/Instructions/Table.swift
+++ b/Sources/WasmKit/Execution/Instructions/Table.swift
@@ -1,153 +1,141 @@
 /// > Note:
 /// <https://webassembly.github.io/spec/core/exec/instructions.html#table-instructions>
-enum TableInstruction: Equatable {
-    case get(TableIndex)
-    case set(TableIndex)
-    case size(TableIndex)
-    case grow(TableIndex)
-    case fill(TableIndex)
-    case copy(TableIndex, TableIndex)
-    case `init`(TableIndex, ElementIndex)
-    case elementDrop(ElementIndex)
-
-    func execute(runtime: Runtime, execution: inout ExecutionState) throws {
-        switch self {
-        case let .get(tableIndex):
-            let (_, table) = try execution.getTable(tableIndex, store: runtime.store)
-
-            let elementIndex = try execution.getElementIndex(table)
-
-            guard let reference = table.elements[Int(elementIndex)] else {
-                throw Trap.readingDroppedReference(index: elementIndex)
-            }
-
-            execution.stack.push(value: .ref(reference))
-
-        case let .set(tableIndex):
-            let (tableAddress, table) = try execution.getTable(tableIndex, store: runtime.store)
-
-            let reference = try execution.stack.getReference()
-            let elementIndex = try execution.getElementIndex(table)
-            setTableElement(store: runtime.store, tableAddress: tableAddress, elementIndex, reference)
-
-        case let .size(tableIndex):
-            let (_, table) = try execution.getTable(tableIndex, store: runtime.store)
-
-            execution.stack.push(value: .i32(UInt32(table.elements.count)))
-
-        case let .grow(tableIndex):
-            let (tableAddress, table) = try execution.getTable(tableIndex, store: runtime.store)
-
-            let growthSize = try execution.stack.popValue()
-
-            guard case let .i32(growthSize) = growthSize else {
-                fatalError("invalid value at the top of the stack \(growthSize)")
-            }
-
-            let growthValue = try execution.stack.getReference()
-
-            let oldSize = UInt32(table.elements.count)
-            guard runtime.store.tables[tableAddress].grow(by: growthSize, value: growthValue) else {
-                execution.stack.push(value: .i32(Int32(-1).unsigned))
-                break
-            }
-
-            execution.stack.push(value: .i32(oldSize))
-
-        case let .fill(tableIndex):
-            let (tableAddress, table) = try execution.getTable(tableIndex, store: runtime.store)
-            let fillCounter = try execution.stack.popValue().i32
-            let fillValue = try execution.stack.getReference()
-            let startIndex = try execution.stack.popValue().i32
-
-            guard fillCounter > 0 else {
-                break
-            }
-
-            guard Int(startIndex + fillCounter) <= table.elements.count else {
-                throw Trap.outOfBoundsTableAccess(index: startIndex + fillCounter)
-            }
-
-            for i in 0..<fillCounter {
-                setTableElement(store: runtime.store, tableAddress: tableAddress, startIndex + i, fillValue)
-            }
-
-        case let .copy(destinationTableIndex, sourceTableIndex):
-            let (_, sourceTable) = try execution.getTable(sourceTableIndex, store: runtime.store)
-            let (destinationTableAddress, destinationTable) = try execution.getTable(destinationTableIndex, store: runtime.store)
-
-            let copyCounter = try execution.stack.popValue().i32
-            let sourceIndex = try execution.stack.popValue().i32
-            let destinationIndex = try execution.stack.popValue().i32
-
-            guard copyCounter > 0 else {
-                break
-            }
-
-            guard
-                !sourceIndex.addingReportingOverflow(copyCounter).overflow && !destinationIndex.addingReportingOverflow(copyCounter).overflow
-            else {
-                throw Trap.tableSizeOverflow
-            }
-            guard destinationIndex + copyCounter <= sourceTable.elements.count else {
-                throw Trap.outOfBoundsTableAccess(index: destinationIndex + copyCounter)
-            }
-            guard destinationIndex + copyCounter <= sourceTable.elements.count && sourceIndex + copyCounter <= destinationTable.elements.count else {
-                throw Trap.outOfBoundsTableAccess(index: destinationIndex + copyCounter)
-            }
-
-            for i in 0..<copyCounter {
-                setTableElement(
-                    store: runtime.store,
-                    tableAddress: destinationTableAddress,
-                    destinationIndex + i,
-                    sourceTable.elements[Int(sourceIndex + i)]
-                )
-            }
-
-        case let .`init`(tableIndex, elementIndex):
-            let (destinationTableAddress, destinationTable) = try execution.getTable(tableIndex, store: runtime.store)
-            let elementAddress = execution.stack.currentFrame.module.elementAddresses[Int(elementIndex)]
-            let sourceElement = runtime.store.elements[elementAddress]
-
-            let copyCounter = try execution.stack.popValue().i32
-            let sourceIndex = try execution.stack.popValue().i32
-            let destinationIndex = try execution.stack.popValue().i32
-
-            guard copyCounter > 0 else {
-                break
-            }
-
-            guard
-                !sourceIndex.addingReportingOverflow(copyCounter).overflow && !destinationIndex.addingReportingOverflow(copyCounter).overflow
-            else {
-                throw Trap.tableSizeOverflow
-            }
-
-            guard sourceIndex + copyCounter <= sourceElement.references.count else {
-                throw Trap.outOfBoundsTableAccess(index: sourceIndex + copyCounter)
-            }
-            guard destinationIndex + copyCounter <= destinationTable.elements.count else {
-                throw Trap.outOfBoundsTableAccess(index: destinationIndex + copyCounter)
-            }
-
-            for i in 0..<copyCounter {
-                let reference = sourceElement.references[Int(sourceIndex + i)]
-
-                setTableElement(
-                    store: runtime.store,
-                    tableAddress: destinationTableAddress,
-                    destinationIndex + i,
-                    reference
-                )
-            }
-
-        case let .elementDrop(elementIndex):
-            let elementAddress = execution.stack.currentFrame.module.elementAddresses[Int(elementIndex)]
-            runtime.store.elements[elementAddress].drop()
+extension ExecutionState {
+    mutating func tableGet(runtime: Runtime, tableIndex: TableIndex) throws {
+        let (_, table) = getTable(tableIndex, store: runtime.store)
+
+        let elementIndex = try getElementIndex(table)
+
+        guard let reference = table.elements[Int(elementIndex)] else {
+            throw Trap.readingDroppedReference(index: elementIndex)
+        }
+
+        stack.push(value: .ref(reference))
+    }
+    mutating func tableSet(runtime: Runtime, tableIndex: TableIndex) throws {
+        let (tableAddress, table) = getTable(tableIndex, store: runtime.store)
+
+        let reference = stack.getReference()
+        let elementIndex = try getElementIndex(table)
+        setTableElement(store: runtime.store, tableAddress: tableAddress, elementIndex, reference)
+
+    }
+    mutating func tableSize(runtime: Runtime, tableIndex: TableIndex) {
+        let (_, table) = getTable(tableIndex, store: runtime.store)
+        stack.push(value: .i32(UInt32(table.elements.count)))
+    }
+    mutating func tableGrow(runtime: Runtime, tableIndex: TableIndex) {
+        let (tableAddress, table) = getTable(tableIndex, store: runtime.store)
+
+        let growthSize = stack.popValue()
+
+        guard case let .i32(growthSize) = growthSize else {
+            fatalError("invalid value at the top of the stack \(growthSize)")
+        }
+
+        let growthValue = stack.getReference()
+
+        let oldSize = UInt32(table.elements.count)
+        guard runtime.store.tables[tableAddress].grow(by: growthSize, value: growthValue) else {
+            stack.push(value: .i32(Int32(-1).unsigned))
+            return
+        }
+
+        stack.push(value: .i32(oldSize))
+    }
+    mutating func tableFill(runtime: Runtime, tableIndex: TableIndex) throws {
+        let (tableAddress, table) = getTable(tableIndex, store: runtime.store)
+        let fillCounter = stack.popValue().i32
+        let fillValue = stack.getReference()
+        let startIndex = stack.popValue().i32
+
+        guard fillCounter > 0 else {
+            return
+        }
+
+        guard Int(startIndex + fillCounter) <= table.elements.count else {
+            throw Trap.outOfBoundsTableAccess(index: startIndex + fillCounter)
+        }
+
+        for i in 0..<fillCounter {
+            setTableElement(store: runtime.store, tableAddress: tableAddress, startIndex + i, fillValue)
         }
     }
+    mutating func tableCopy(runtime: Runtime, dest destinationTableIndex: TableIndex, src sourceTableIndex: TableIndex) throws {
+        let (_, sourceTable) = getTable(sourceTableIndex, store: runtime.store)
+        let (destinationTableAddress, destinationTable) = getTable(destinationTableIndex, store: runtime.store)
 
+        let copyCounter = stack.popValue().i32
+        let sourceIndex = stack.popValue().i32
+        let destinationIndex = stack.popValue().i32
+
+        guard copyCounter > 0 else {
+            return
+        }
+
+        guard
+            !sourceIndex.addingReportingOverflow(copyCounter).overflow && !destinationIndex.addingReportingOverflow(copyCounter).overflow
+        else {
+            throw Trap.tableSizeOverflow
+        }
+        guard destinationIndex + copyCounter <= sourceTable.elements.count else {
+            throw Trap.outOfBoundsTableAccess(index: destinationIndex + copyCounter)
+        }
+        guard destinationIndex + copyCounter <= sourceTable.elements.count && sourceIndex + copyCounter <= destinationTable.elements.count else {
+            throw Trap.outOfBoundsTableAccess(index: destinationIndex + copyCounter)
+        }
+
+        for i in 0..<copyCounter {
+            setTableElement(
+                store: runtime.store,
+                tableAddress: destinationTableAddress,
+                destinationIndex + i,
+                sourceTable.elements[Int(sourceIndex + i)]
+            )
+        }
+    }
+    mutating func tableInit(runtime: Runtime, tableIndex: TableIndex, elementIndex: ElementIndex) throws {
+        let (destinationTableAddress, destinationTable) = getTable(tableIndex, store: runtime.store)
+        let elementAddress = currentModule(store: runtime.store).elementAddresses[Int(elementIndex)]
+        let sourceElement = runtime.store.elements[elementAddress]
+
+        let copyCounter = stack.popValue().i32
+        let sourceIndex = stack.popValue().i32
+        let destinationIndex = stack.popValue().i32
+
+        guard copyCounter > 0 else {
+            return
+        }
+
+        guard
+            !sourceIndex.addingReportingOverflow(copyCounter).overflow && !destinationIndex.addingReportingOverflow(copyCounter).overflow
+        else {
+            throw Trap.tableSizeOverflow
+        }
+
+        guard sourceIndex + copyCounter <= sourceElement.references.count else {
+            throw Trap.outOfBoundsTableAccess(index: sourceIndex + copyCounter)
+        }
+        guard destinationIndex + copyCounter <= destinationTable.elements.count else {
+            throw Trap.outOfBoundsTableAccess(index: destinationIndex + copyCounter)
+        }
+
+        for i in 0..<copyCounter {
+            let reference = sourceElement.references[Int(sourceIndex + i)]
+
+            setTableElement(
+                store: runtime.store,
+                tableAddress: destinationTableAddress,
+                destinationIndex + i,
+                reference
+            )
+        }
+    }
+    mutating func tableElementDrop(runtime: Runtime, elementIndex: ElementIndex) {
+        let elementAddress = currentModule(store: runtime.store).elementAddresses[Int(elementIndex)]
+        runtime.store.elements[elementAddress].drop()
+    }
+    
     fileprivate func setTableElement(
         store: Store,
         tableAddress: TableAddress,
@@ -159,13 +147,13 @@ enum TableInstruction: Equatable {
 }
 
 extension ExecutionState {
-    fileprivate func getTable(_ tableIndex: UInt32, store: Store) throws -> (TableAddress, TableInstance) {
-        let address = stack.currentFrame.module.tableAddresses[Int(tableIndex)]
+    fileprivate func getTable(_ tableIndex: UInt32, store: Store) -> (TableAddress, TableInstance) {
+        let address = currentModule(store: store).tableAddresses[Int(tableIndex)]
         return (address, store.tables[address])
     }
 
     fileprivate mutating func getElementIndex(_ table: TableInstance) throws -> ElementIndex {
-        let elementIndex = try stack.popValue().i32
+        let elementIndex = stack.popValue().i32
 
         guard elementIndex < table.elements.count else {
             throw Trap.outOfBoundsTableAccess(index: elementIndex)
@@ -176,8 +164,8 @@ extension ExecutionState {
 }
 
 extension Stack {
-    fileprivate mutating func getReference() throws -> Reference {
-        let value = try popValue()
+    fileprivate mutating func getReference() -> Reference {
+        let value = popValue()
 
         guard case let .ref(reference) = value else {
             fatalError("invalid value at the top of the stack \(value)")
diff --git a/Sources/WasmKit/Execution/Instructions/Variable.swift b/Sources/WasmKit/Execution/Instructions/Variable.swift
index af3a6b57..27fd7393 100644
--- a/Sources/WasmKit/Execution/Instructions/Variable.swift
+++ b/Sources/WasmKit/Execution/Instructions/Variable.swift
@@ -1,68 +1,31 @@
 /// > Note:
 /// <https://webassembly.github.io/spec/core/syntax/instructions.html#variable-instructions>
-enum VariableInstruction: Equatable {
-    case localGet(index: LocalIndex)
-    case localSet(index: LocalIndex)
-    case localTee(index: LocalIndex)
-    case globalGet(index: GlobalIndex)
-    case globalSet(index: GlobalIndex)
-
-    func execute(_ stack: inout Stack, _ globals: inout [GlobalInstance]) throws {
-        switch self {
-        case let .localGet(index):
-            let value = try stack.currentFrame.localGet(index: index)
-            stack.push(value: value)
-
-        case let .localSet(index):
-            let value = try stack.popValue()
-            try stack.currentFrame.localSet(index: index, value: value)
-
-        case let .localTee(index):
-            guard case let .value(value) = stack.top else {
-                throw Trap.stackTypeMismatch(expected: Value.self, actual: stack.top)
-            }
-            try stack.currentFrame.localSet(index: index, value: value)
-
-        case let .globalGet(index):
-            let address = Int(stack.currentFrame.module.globalAddresses[Int(index)])
-
-            guard globals.indices.contains(address) else {
-                throw Trap.globalAddressOutOfRange(index: address)
-            }
-            let value = globals[address].value
-            stack.push(value: value)
-
-        case let .globalSet(index):
-            let address = Int(stack.currentFrame.module.globalAddresses[Int(index)])
-            let value = try stack.popValue()
-
-            guard globals.indices.contains(address) else {
-                throw Trap.globalAddressOutOfRange(index: address)
-            }
-
-            let mutability = globals[address].globalType.mutability
-            guard mutability == .variable else {
-                throw Trap.globalImmutable(index: address)
-            }
-
-            globals[address].value = value
-        }
+extension ExecutionState {
+    mutating func localGet(runtime: Runtime, locals: UnsafeMutablePointer<Value>, index: LocalIndex) {
+        let value = locals[Int(index)]
+        stack.push(value: value)
+    }
+    mutating func localSet(runtime: Runtime, locals: UnsafeMutablePointer<Value>, index: LocalIndex) {
+        let value = stack.popValue()
+        locals[Int(index)] = value
+    }
+    mutating func localTee(runtime: Runtime, locals: UnsafeMutablePointer<Value>, index: LocalIndex) {
+        let value = stack.topValue
+        locals[Int(index)] = value
+    }
+    mutating func globalGet(runtime: Runtime, index: GlobalIndex) throws {
+        let address = Int(currentModule(store: runtime.store).globalAddresses[Int(index)])
+        let globals = runtime.store.globals
+        let value = globals[address].value
+        stack.push(value: value)
     }
-}
 
-extension VariableInstruction: CustomStringConvertible {
-    public var description: String {
-        switch self {
-        case let .globalGet(index: i):
-            return "global.get \(i)"
-        case let .globalSet(index: i):
-            return "global.set \(i)"
-        case let .localGet(index: i):
-            return "local.get \(i)"
-        case let .localSet(index: i):
-            return "local.set \(i)"
-        case let .localTee(index: i):
-            return "local.tee \(i)"
-        }
+    mutating func globalSet(runtime: Runtime, index: GlobalIndex) throws {
+        let address = Int(currentModule(store: runtime.store).globalAddresses[Int(index)])
+        try doGlobalSet(address: address, &runtime.store.globals)
+    }
+    mutating func doGlobalSet(address: GlobalAddress, _ globals: inout [GlobalInstance]) throws {
+        let value = stack.popValue()
+        globals[address].value = value
     }
 }
diff --git a/Sources/WasmKit/Execution/Runtime/ExecutionState.swift b/Sources/WasmKit/Execution/Runtime/ExecutionState.swift
index 18f89f6e..285567df 100644
--- a/Sources/WasmKit/Execution/Runtime/ExecutionState.swift
+++ b/Sources/WasmKit/Execution/Runtime/ExecutionState.swift
@@ -1,3 +1,5 @@
+typealias ProgramCounter = UnsafePointer<Instruction>
+
 /// An execution state of an invocation of exported function.
 ///
 /// Each new invocation through exported function has a separate ``ExecutionState``
@@ -5,126 +7,110 @@
 struct ExecutionState {
     var stack = Stack()
     /// Index of an instruction to be executed in the current function.
-    var programCounter = 0
+    var programCounter: ProgramCounter
+    var reachedEndOfExecution: Bool = false
 
     var isStackEmpty: Bool {
-        stack.top == nil
+        stack.isEmpty
     }
-}
-
-extension ExecutionState {
-    mutating func execute(_ instruction: Instruction, runtime: Runtime) throws {
-        switch instruction {
-        case let .control(instruction):
-            return try instruction.execute(runtime: runtime, execution: &self)
-
-        case let .memory(instruction):
-            try instruction.execute(&stack, runtime.store)
-
-        case let .numeric(instruction):
-            try instruction.execute(&stack)
-
-        case let .parametric(instruction):
-            try instruction.execute(&stack)
 
-        case let .reference(instruction):
-            try instruction.execute(&stack)
-
-        case let .table(instruction):
-            try instruction.execute(runtime: runtime, execution: &self)
-
-        case let .variable(instruction):
-            try instruction.execute(&stack, &runtime.store.globals)
-        case .pseudo:
-            // Structured pseudo instructions (end/else) should not appear at runtime
-            throw Trap.unreachable
-        }
-
-        programCounter += 1
+    fileprivate init(stack: Stack = Stack(), programCounter: ProgramCounter) {
+        self.stack = stack
+        self.programCounter = programCounter
     }
+}
 
-    mutating func branch(labelIndex: Int) throws {
-        let label = try stack.getLabel(index: Int(labelIndex))
-        let values = try stack.popValues(count: label.arity)
+@_transparent
+func withExecution<Return>(_ body: (inout ExecutionState) throws -> Return) rethrows -> Return {
+    try withUnsafeTemporaryAllocation(of: Instruction.self, capacity: 1) { rootISeq in
+        rootISeq.baseAddress?.pointee = .endOfExecution
+        // NOTE: unwinding a function jump into previous frame's PC + 1, so initial PC is -1ed
+        var execution = ExecutionState(programCounter: rootISeq.baseAddress! - 1)
+        return try body(&execution)
+    }
+}
 
-        var lastLabel: Label?
-        for _ in 0...labelIndex {
-            stack.discardTopValues()
-            lastLabel = try stack.popLabel()
-        }
+extension ExecutionState: CustomStringConvertible {
+    var description: String {
+        var result = "======== PC=\(programCounter) =========\n"
+        result += "\(stack.debugDescription)"
 
-        stack.push(values: values)
-        programCounter = lastLabel!.continuation
+        return result
     }
+}
 
+extension ExecutionState {
     /// > Note:
     /// <https://webassembly.github.io/spec/core/exec/instructions.html#entering-xref-syntax-instructions-syntax-instr-mathit-instr-ast-with-label-l>
-    mutating func enter(_ expression: Expression, continuation: Int, arity: Int) {
-        let exit = programCounter + 1
-        let label = Label(arity: arity, expression: expression, continuation: continuation, exit: exit)
-        stack.push(label: label)
-        programCounter = label.expression.instructions.startIndex
+    @inline(__always)
+    mutating func enter(jumpTo targetPC: ProgramCounter, continuation: ProgramCounter, arity: Int, pushPopValues: Int = 0) {
+        stack.pushLabel(
+            arity: arity,
+            continuation: continuation,
+            popPushValues: pushPopValues
+        )
+        programCounter = targetPC
     }
 
     /// > Note:
     /// <https://webassembly.github.io/spec/core/exec/instructions.html#exiting-xref-syntax-instructions-syntax-instr-mathit-instr-ast-with-label-l>
     mutating func exit(label: Label) throws {
-        let values = try stack.popTopValues()
-        let lastLabel = try stack.popLabel()
-        assert(lastLabel == label)
-        stack.push(values: values)
-        programCounter = label.exit
+        stack.exit(label: label)
+        programCounter += 1
     }
 
     /// > Note:
     /// <https://webassembly.github.io/spec/core/exec/instructions.html#invocation-of-function-address>
     mutating func invoke(functionAddress address: FunctionAddress, runtime: Runtime) throws {
+        #if DEBUG
         runtime.interceptor?.onEnterFunction(address, store: runtime.store)
+        #endif
 
         switch try runtime.store.function(at: address) {
         case let .host(function):
-            let parameters = try stack.popValues(count: function.type.parameters.count)
-            let caller = Caller(runtime: runtime, instance: stack.currentFrame.module)
-            stack.push(values: try function.implementation(caller, parameters))
+            let parameters = stack.popValues(count: function.type.parameters.count)
+            let moduleInstance = runtime.store.module(address: stack.currentFrame.module)
+            let caller = Caller(runtime: runtime, instance: moduleInstance)
+            stack.push(values: try function.implementation(caller, Array(parameters)))
 
             programCounter += 1
 
         case let .wasm(function, body: body):
-            let locals = function.code.locals.map { $0.defaultValue }
             let expression = body
 
-            let arguments = try stack.popValues(count: function.type.parameters.count)
-
             let arity = function.type.results.count
-            try stack.push(frame: .init(arity: arity, module: function.module, locals: arguments + locals, address: address))
-
-            self.enter(
-                expression, continuation: programCounter + 1,
-                arity: arity
+            try stack.pushFrame(
+                iseq: expression,
+                arity: arity,
+                module: function.module,
+                argc: function.type.parameters.count,
+                defaultLocals: function.code.defaultLocals,
+                returnPC: programCounter.advanced(by: 1),
+                address: address
             )
+            programCounter = expression.baseAddress
         }
     }
 
-    public mutating func step(runtime: Runtime) throws {
-        if let label = stack.currentLabel {
-            if programCounter < label.expression.instructions.count {
-                try execute(stack.currentLabel.expression.instructions[programCounter], runtime: runtime)
-            } else {
-                try self.exit(label: label)
-            }
-        } else {
-            if let address = stack.currentFrame.address {
-                runtime.interceptor?.onExitFunction(address, store: runtime.store)
-            }
-            let values = try stack.popValues(count: stack.currentFrame.arity)
-            try stack.popFrame()
-            stack.push(values: values)
+    mutating func run(runtime: Runtime) throws {
+        while !reachedEndOfExecution {
+            let locals = self.stack.currentLocalsPointer
+            // Regular path
+            var inst: Instruction
+            // `doExecute` returns false when current frame *may* be updated
+            repeat {
+                inst = programCounter.pointee
+            } while try doExecute(inst, runtime: runtime, locals: locals)
         }
     }
 
-    public mutating func run(runtime: Runtime) throws {
-        while stack.currentFrame != nil {
-            try step(runtime: runtime)
-        }
+    func currentModule(store: Store) -> ModuleInstance {
+        store.module(address: stack.currentFrame.module)
+    }
+}
+
+extension ExecutionState {
+    mutating func pseudo(runtime: Runtime, pseudoInstruction: PseudoInstruction) throws {
+        fatalError("Unimplemented instruction: pseudo")
     }
 }
diff --git a/Sources/WasmKit/Execution/Runtime/Function.swift b/Sources/WasmKit/Execution/Runtime/Function.swift
index 1fc3dbce..be982417 100644
--- a/Sources/WasmKit/Execution/Runtime/Function.swift
+++ b/Sources/WasmKit/Execution/Runtime/Function.swift
@@ -4,10 +4,11 @@ public struct Function: Equatable {
 
     /// Invokes a function of the given address with the given parameters.
     public func invoke(_ arguments: [Value] = [], runtime: Runtime) throws -> [Value] {
-        var execution = ExecutionState()
-        try invoke(execution: &execution, with: arguments, runtime: runtime)
-        try execution.run(runtime: runtime)
-        return try execution.stack.popTopValues()
+        try withExecution { execution in
+            try invoke(execution: &execution, with: arguments, runtime: runtime)
+            try execution.run(runtime: runtime)
+            return try Array(execution.stack.popTopValues())
+        }
     }
 
     private func invoke(execution: inout ExecutionState, with arguments: [Value], runtime: Runtime) throws {
@@ -15,10 +16,11 @@ public struct Function: Equatable {
         case let .host(function):
             try check(functionType: function.type, parameters: arguments)
 
-            let parameters = try execution.stack.popValues(count: function.type.parameters.count)
+            let parameters = execution.stack.popValues(count: function.type.parameters.count)
 
-            let caller = Caller(runtime: runtime, instance: execution.stack.currentFrame.module)
-            let results = try function.implementation(caller, parameters)
+            let moduleInstance = runtime.store.module(address: execution.stack.currentFrame.module)
+            let caller = Caller(runtime: runtime, instance: moduleInstance)
+            let results = try function.implementation(caller, Array(parameters))
             try check(functionType: function.type, results: results)
             execution.stack.push(values: results)
 
diff --git a/Sources/WasmKit/Execution/Runtime/InstDispatch.swift b/Sources/WasmKit/Execution/Runtime/InstDispatch.swift
new file mode 100644
index 00000000..12b0657f
--- /dev/null
+++ b/Sources/WasmKit/Execution/Runtime/InstDispatch.swift
@@ -0,0 +1,348 @@
+// This file is generated by Utilities/generate_inst_dispatch.swift
+extension ExecutionState {
+    @inline(__always)
+    mutating func doExecute(_ instruction: Instruction, runtime: Runtime, locals: UnsafeMutablePointer<Value>) throws -> Bool {
+        switch instruction {
+        case .unreachable:
+            try self.unreachable(runtime: runtime)
+            return true
+        case .nop:
+            try self.nop(runtime: runtime)
+            return true
+        case .block(let endRef, let type):
+            self.block(runtime: runtime, endRef: endRef, type: type)
+            return true
+        case .loop(let type):
+            self.loop(runtime: runtime, type: type)
+            return true
+        case .ifThen(let endRef, let type):
+            self.ifThen(runtime: runtime, endRef: endRef, type: type)
+            return true
+        case .ifThenElse(let elseRef, let endRef, let type):
+            self.ifThenElse(runtime: runtime, elseRef: elseRef, endRef: endRef, type: type)
+            return true
+        case .end:
+            self.end(runtime: runtime)
+            return true
+        case .`else`:
+            self.`else`(runtime: runtime)
+            return true
+        case .br(let labelIndex):
+            try self.br(runtime: runtime, labelIndex: labelIndex)
+            return false
+        case .brIf(let labelIndex):
+            try self.brIf(runtime: runtime, labelIndex: labelIndex)
+            return false
+        case .brTable(let brTable):
+            try self.brTable(runtime: runtime, brTable: brTable)
+            return false
+        case .`return`:
+            try self.`return`(runtime: runtime)
+            return false
+        case .call(let functionIndex):
+            try self.call(runtime: runtime, functionIndex: functionIndex)
+            return false
+        case .callIndirect(let tableIndex, let typeIndex):
+            try self.callIndirect(runtime: runtime, tableIndex: tableIndex, typeIndex: typeIndex)
+            return false
+        case .endOfFunction:
+            try self.endOfFunction(runtime: runtime)
+            return false
+        case .endOfExecution:
+            try self.endOfExecution(runtime: runtime)
+            return false
+        case .i32Load(let memarg):
+            try self.i32Load(runtime: runtime, memarg: memarg)
+        case .i64Load(let memarg):
+            try self.i64Load(runtime: runtime, memarg: memarg)
+        case .f32Load(let memarg):
+            try self.f32Load(runtime: runtime, memarg: memarg)
+        case .f64Load(let memarg):
+            try self.f64Load(runtime: runtime, memarg: memarg)
+        case .i32Load8S(let memarg):
+            try self.i32Load8S(runtime: runtime, memarg: memarg)
+        case .i32Load8U(let memarg):
+            try self.i32Load8U(runtime: runtime, memarg: memarg)
+        case .i32Load16S(let memarg):
+            try self.i32Load16S(runtime: runtime, memarg: memarg)
+        case .i32Load16U(let memarg):
+            try self.i32Load16U(runtime: runtime, memarg: memarg)
+        case .i64Load8S(let memarg):
+            try self.i64Load8S(runtime: runtime, memarg: memarg)
+        case .i64Load8U(let memarg):
+            try self.i64Load8U(runtime: runtime, memarg: memarg)
+        case .i64Load16S(let memarg):
+            try self.i64Load16S(runtime: runtime, memarg: memarg)
+        case .i64Load16U(let memarg):
+            try self.i64Load16U(runtime: runtime, memarg: memarg)
+        case .i64Load32S(let memarg):
+            try self.i64Load32S(runtime: runtime, memarg: memarg)
+        case .i64Load32U(let memarg):
+            try self.i64Load32U(runtime: runtime, memarg: memarg)
+        case .i32Store(let memarg):
+            try self.i32Store(runtime: runtime, memarg: memarg)
+        case .i64Store(let memarg):
+            try self.i64Store(runtime: runtime, memarg: memarg)
+        case .f32Store(let memarg):
+            try self.f32Store(runtime: runtime, memarg: memarg)
+        case .f64Store(let memarg):
+            try self.f64Store(runtime: runtime, memarg: memarg)
+        case .i32Store8(let memarg):
+            try self.i32Store8(runtime: runtime, memarg: memarg)
+        case .i32Store16(let memarg):
+            try self.i32Store16(runtime: runtime, memarg: memarg)
+        case .i64Store8(let memarg):
+            try self.i64Store8(runtime: runtime, memarg: memarg)
+        case .i64Store16(let memarg):
+            try self.i64Store16(runtime: runtime, memarg: memarg)
+        case .i64Store32(let memarg):
+            try self.i64Store32(runtime: runtime, memarg: memarg)
+        case .memorySize:
+            self.memorySize(runtime: runtime)
+        case .memoryGrow:
+            try self.memoryGrow(runtime: runtime)
+        case .memoryInit(let dataIndex):
+            try self.memoryInit(runtime: runtime, dataIndex: dataIndex)
+        case .memoryDataDrop(let dataIndex):
+            self.memoryDataDrop(runtime: runtime, dataIndex: dataIndex)
+        case .memoryCopy:
+            try self.memoryCopy(runtime: runtime)
+        case .memoryFill:
+            try self.memoryFill(runtime: runtime)
+        case .numericConst(let value):
+            self.numericConst(runtime: runtime, value: value)
+        case .numericIntUnary(let intUnary):
+            self.numericIntUnary(runtime: runtime, intUnary: intUnary)
+        case .numericFloatUnary(let floatUnary):
+            self.numericFloatUnary(runtime: runtime, floatUnary: floatUnary)
+        case .numericIntBinary(let intBinary):
+            try self.numericIntBinary(runtime: runtime, intBinary: intBinary)
+        case .numericFloatBinary(let floatBinary):
+            self.numericFloatBinary(runtime: runtime, floatBinary: floatBinary)
+        case .numericConversion(let conversion):
+            try self.numericConversion(runtime: runtime, conversion: conversion)
+        case .i32Add:
+            self.i32Add(runtime: runtime)
+        case .i64Add:
+            self.i64Add(runtime: runtime)
+        case .f32Add:
+            self.f32Add(runtime: runtime)
+        case .f64Add:
+            self.f64Add(runtime: runtime)
+        case .i32Sub:
+            self.i32Sub(runtime: runtime)
+        case .i64Sub:
+            self.i64Sub(runtime: runtime)
+        case .f32Sub:
+            self.f32Sub(runtime: runtime)
+        case .f64Sub:
+            self.f64Sub(runtime: runtime)
+        case .i32Mul:
+            self.i32Mul(runtime: runtime)
+        case .i64Mul:
+            self.i64Mul(runtime: runtime)
+        case .f32Mul:
+            self.f32Mul(runtime: runtime)
+        case .f64Mul:
+            self.f64Mul(runtime: runtime)
+        case .i32Eq:
+            self.i32Eq(runtime: runtime)
+        case .i64Eq:
+            self.i64Eq(runtime: runtime)
+        case .f32Eq:
+            self.f32Eq(runtime: runtime)
+        case .f64Eq:
+            self.f64Eq(runtime: runtime)
+        case .i32Ne:
+            self.i32Ne(runtime: runtime)
+        case .i64Ne:
+            self.i64Ne(runtime: runtime)
+        case .f32Ne:
+            self.f32Ne(runtime: runtime)
+        case .f64Ne:
+            self.f64Ne(runtime: runtime)
+        case .i32LtS:
+            self.i32LtS(runtime: runtime)
+        case .i64LtS:
+            self.i64LtS(runtime: runtime)
+        case .i32LtU:
+            self.i32LtU(runtime: runtime)
+        case .i64LtU:
+            self.i64LtU(runtime: runtime)
+        case .i32GtS:
+            self.i32GtS(runtime: runtime)
+        case .i64GtS:
+            self.i64GtS(runtime: runtime)
+        case .i32GtU:
+            self.i32GtU(runtime: runtime)
+        case .i64GtU:
+            self.i64GtU(runtime: runtime)
+        case .i32LeS:
+            self.i32LeS(runtime: runtime)
+        case .i64LeS:
+            self.i64LeS(runtime: runtime)
+        case .i32LeU:
+            self.i32LeU(runtime: runtime)
+        case .i64LeU:
+            self.i64LeU(runtime: runtime)
+        case .i32GeS:
+            self.i32GeS(runtime: runtime)
+        case .i64GeS:
+            self.i64GeS(runtime: runtime)
+        case .i32GeU:
+            self.i32GeU(runtime: runtime)
+        case .i64GeU:
+            self.i64GeU(runtime: runtime)
+        case .drop:
+            self.drop(runtime: runtime)
+        case .select:
+            try self.select(runtime: runtime)
+        case .refNull(let referenceType):
+            self.refNull(runtime: runtime, referenceType: referenceType)
+        case .refIsNull:
+            self.refIsNull(runtime: runtime)
+        case .refFunc(let functionIndex):
+            self.refFunc(runtime: runtime, functionIndex: functionIndex)
+        case .tableGet(let tableIndex):
+            try self.tableGet(runtime: runtime, tableIndex: tableIndex)
+        case .tableSet(let tableIndex):
+            try self.tableSet(runtime: runtime, tableIndex: tableIndex)
+        case .tableSize(let tableIndex):
+            self.tableSize(runtime: runtime, tableIndex: tableIndex)
+        case .tableGrow(let tableIndex):
+            self.tableGrow(runtime: runtime, tableIndex: tableIndex)
+        case .tableFill(let tableIndex):
+            try self.tableFill(runtime: runtime, tableIndex: tableIndex)
+        case .tableCopy(let dest, let src):
+            try self.tableCopy(runtime: runtime, dest: dest, src: src)
+        case .tableInit(let tableIndex, let elementIndex):
+            try self.tableInit(runtime: runtime, tableIndex: tableIndex, elementIndex: elementIndex)
+        case .tableElementDrop(let elementIndex):
+            self.tableElementDrop(runtime: runtime, elementIndex: elementIndex)
+        case .localGet(let index):
+            self.localGet(runtime: runtime, locals: locals, index: index)
+        case .localSet(let index):
+            self.localSet(runtime: runtime, locals: locals, index: index)
+        case .localTee(let index):
+            self.localTee(runtime: runtime, locals: locals, index: index)
+        case .globalGet(let index):
+            try self.globalGet(runtime: runtime, index: index)
+        case .globalSet(let index):
+            try self.globalSet(runtime: runtime, index: index)
+        }
+        programCounter += 1
+        return true
+    }
+}
+
+extension Instruction {
+    var name: String {
+        switch self {
+        case .unreachable: return "unreachable"
+        case .nop: return "nop"
+        case .block: return "block"
+        case .loop: return "loop"
+        case .ifThen: return "ifThen"
+        case .ifThenElse: return "ifThenElse"
+        case .end: return "end"
+        case .`else`: return "`else`"
+        case .br: return "br"
+        case .brIf: return "brIf"
+        case .brTable: return "brTable"
+        case .`return`: return "`return`"
+        case .call: return "call"
+        case .callIndirect: return "callIndirect"
+        case .endOfFunction: return "endOfFunction"
+        case .endOfExecution: return "endOfExecution"
+        case .i32Load: return "i32Load"
+        case .i64Load: return "i64Load"
+        case .f32Load: return "f32Load"
+        case .f64Load: return "f64Load"
+        case .i32Load8S: return "i32Load8S"
+        case .i32Load8U: return "i32Load8U"
+        case .i32Load16S: return "i32Load16S"
+        case .i32Load16U: return "i32Load16U"
+        case .i64Load8S: return "i64Load8S"
+        case .i64Load8U: return "i64Load8U"
+        case .i64Load16S: return "i64Load16S"
+        case .i64Load16U: return "i64Load16U"
+        case .i64Load32S: return "i64Load32S"
+        case .i64Load32U: return "i64Load32U"
+        case .i32Store: return "i32Store"
+        case .i64Store: return "i64Store"
+        case .f32Store: return "f32Store"
+        case .f64Store: return "f64Store"
+        case .i32Store8: return "i32Store8"
+        case .i32Store16: return "i32Store16"
+        case .i64Store8: return "i64Store8"
+        case .i64Store16: return "i64Store16"
+        case .i64Store32: return "i64Store32"
+        case .memorySize: return "memorySize"
+        case .memoryGrow: return "memoryGrow"
+        case .memoryInit: return "memoryInit"
+        case .memoryDataDrop: return "memoryDataDrop"
+        case .memoryCopy: return "memoryCopy"
+        case .memoryFill: return "memoryFill"
+        case .numericConst: return "numericConst"
+        case .numericIntUnary: return "numericIntUnary"
+        case .numericFloatUnary: return "numericFloatUnary"
+        case .numericIntBinary: return "numericIntBinary"
+        case .numericFloatBinary: return "numericFloatBinary"
+        case .numericConversion: return "numericConversion"
+        case .i32Add: return "i32Add"
+        case .i64Add: return "i64Add"
+        case .f32Add: return "f32Add"
+        case .f64Add: return "f64Add"
+        case .i32Sub: return "i32Sub"
+        case .i64Sub: return "i64Sub"
+        case .f32Sub: return "f32Sub"
+        case .f64Sub: return "f64Sub"
+        case .i32Mul: return "i32Mul"
+        case .i64Mul: return "i64Mul"
+        case .f32Mul: return "f32Mul"
+        case .f64Mul: return "f64Mul"
+        case .i32Eq: return "i32Eq"
+        case .i64Eq: return "i64Eq"
+        case .f32Eq: return "f32Eq"
+        case .f64Eq: return "f64Eq"
+        case .i32Ne: return "i32Ne"
+        case .i64Ne: return "i64Ne"
+        case .f32Ne: return "f32Ne"
+        case .f64Ne: return "f64Ne"
+        case .i32LtS: return "i32LtS"
+        case .i64LtS: return "i64LtS"
+        case .i32LtU: return "i32LtU"
+        case .i64LtU: return "i64LtU"
+        case .i32GtS: return "i32GtS"
+        case .i64GtS: return "i64GtS"
+        case .i32GtU: return "i32GtU"
+        case .i64GtU: return "i64GtU"
+        case .i32LeS: return "i32LeS"
+        case .i64LeS: return "i64LeS"
+        case .i32LeU: return "i32LeU"
+        case .i64LeU: return "i64LeU"
+        case .i32GeS: return "i32GeS"
+        case .i64GeS: return "i64GeS"
+        case .i32GeU: return "i32GeU"
+        case .i64GeU: return "i64GeU"
+        case .drop: return "drop"
+        case .select: return "select"
+        case .refNull: return "refNull"
+        case .refIsNull: return "refIsNull"
+        case .refFunc: return "refFunc"
+        case .tableGet: return "tableGet"
+        case .tableSet: return "tableSet"
+        case .tableSize: return "tableSize"
+        case .tableGrow: return "tableGrow"
+        case .tableFill: return "tableFill"
+        case .tableCopy: return "tableCopy"
+        case .tableInit: return "tableInit"
+        case .tableElementDrop: return "tableElementDrop"
+        case .localGet: return "localGet"
+        case .localSet: return "localSet"
+        case .localTee: return "localTee"
+        case .globalGet: return "globalGet"
+        case .globalSet: return "globalSet"
+        }
+    }
+}
diff --git a/Sources/WasmKit/Execution/Runtime/Runtime.swift b/Sources/WasmKit/Execution/Runtime/Runtime.swift
index b4243114..3d9a4978 100644
--- a/Sources/WasmKit/Execution/Runtime/Runtime.swift
+++ b/Sources/WasmKit/Execution/Runtime/Runtime.swift
@@ -64,31 +64,27 @@ extension Runtime {
             initialGlobals: initialGlobals
         )
 
-        // Step 12.
-        let frame = Frame(arity: 0, module: instance, locals: [])
-
-        // Step 13.
-        var initExecution = ExecutionState()
-        try initExecution.stack.push(frame: frame)
+        // Step 12-13.
 
         // Steps 14-15.
         do {
             for (elementIndex, element) in module.elements.enumerated() {
                 let elementIndex = UInt32(elementIndex)
-
                 switch element.mode {
                 case let .active(tableIndex, offsetExpression):
-                    for i in offsetExpression.instructions + [
-                        .numeric(.const(.i32(0))),
-                        .numeric(.const(.i32(UInt32(element.initializer.count)))),
-                        .table(.`init`(tableIndex, elementIndex)),
-                        .table(.elementDrop(elementIndex)),
-                    ] {
-                        try initExecution.execute(i, runtime: self)
-                    }
+                    let initIseq = InstructionSequence(instructions: offsetExpression + [
+                        .numericConst(.i32(0)),
+                        .numericConst(.i32(UInt32(element.initializer.count))),
+                        .tableInit(tableIndex, elementIndex),
+                        .tableElementDrop(elementIndex),
+                    ])
+                    defer { initIseq.deallocate() }
+                    try evaluateConstExpr(initIseq, instance: instance)
 
                 case .declarative:
-                    try initExecution.execute(.table(.elementDrop(elementIndex)), runtime: self)
+                    let initIseq: InstructionSequence = [.tableElementDrop(elementIndex)]
+                    defer { initIseq.deallocate() }
+                    try evaluateConstExpr(initIseq, instance: instance)
 
                 case .passive:
                     continue
@@ -104,15 +100,14 @@ extension Runtime {
         do {
             for case let (dataIndex, .active(data)) in module.data.enumerated() {
                 assert(data.index == 0)
-
-                for i in data.offset.instructions + [
-                    .numeric(.const(.i32(0))),
-                    .numeric(.const(.i32(UInt32(data.initializer.count)))),
-                    .memory(.`init`(UInt32(dataIndex))),
-                    .memory(.dataDrop(UInt32(dataIndex))),
-                ] {
-                    try initExecution.execute(i, runtime: self)
-                }
+                let iseq = InstructionSequence(instructions: data.offset + [
+                    .numericConst(.i32(0)),
+                    .numericConst(.i32(UInt32(data.initializer.count))),
+                    .memoryInit(UInt32(dataIndex)),
+                    .memoryDataDrop(UInt32(dataIndex)),
+                ])
+                defer { iseq.deallocate() }
+                try evaluateConstExpr(iseq, instance: instance)
             }
         } catch Trap.outOfBoundsMemoryAccess {
             throw InstantiationError.outOfBoundsMemoryAccess
@@ -122,53 +117,70 @@ extension Runtime {
 
         // Step 17.
         if let startIndex = module.start {
-            try initExecution.invoke(functionAddress: instance.functionAddresses[Int(startIndex)], runtime: self)
-            while initExecution.stack.elements.count != 1 || initExecution.stack.currentFrame != frame {
-                try initExecution.step(runtime: self)
+            try withExecution { initExecution in
+                try initExecution.invoke(functionAddress: instance.functionAddresses[Int(startIndex)], runtime: self)
+                try initExecution.run(runtime: self)
             }
         }
 
-        // Steps 18-19.
-        try initExecution.stack.popFrame()
-
         return instance
     }
 
     private func evaluateGlobals(module: Module, externalValues: [ExternalValue]) throws -> [Value] {
-        let globalModuleInstance = ModuleInstance()
-
-        for externalValue in externalValues {
-            switch externalValue {
-            case let .global(address):
-                globalModuleInstance.globalAddresses.append(address)
-            case let .function(address):
-                globalModuleInstance.functionAddresses.append(address.address)
-            default:
-                continue
+        try store.withTemporaryModuleInstance { globalModuleInstance in
+            for externalValue in externalValues {
+                switch externalValue {
+                case let .global(address):
+                    globalModuleInstance.globalAddresses.append(address)
+                case let .function(address):
+                    globalModuleInstance.functionAddresses.append(address.address)
+                default:
+                    continue
+                }
             }
-        }
-
-        globalModuleInstance.types = module.types
-
-        for function in module.functions {
-            let address = store.allocate(function: function, module: globalModuleInstance)
-            globalModuleInstance.functionAddresses.append(address)
-        }
-
-        var initExecution = ExecutionState()
-        try initExecution.stack.push(frame: .init(arity: 0, module: globalModuleInstance, locals: []))
-
-        let globalInitializers = try module.globals.map { global in
-            for i in global.initializer.instructions {
-                try initExecution.execute(i, runtime: self)
+            
+            globalModuleInstance.types = module.types
+            
+            for function in module.functions {
+                let address = store.allocate(function: function, module: globalModuleInstance)
+                globalModuleInstance.functionAddresses.append(address)
             }
-
-            return try initExecution.stack.popValue()
+            
+            let globalInitializers = try module.globals.map { global in
+                let iseq = InstructionSequence(instructions: global.initializer)
+                defer { iseq.deallocate() }
+                return try evaluateConstExpr(iseq, instance: globalModuleInstance, arity: 1) { initExecution in
+                    return initExecution.stack.popValue()
+                }
+            }
+            
+            return globalInitializers
         }
+    }
 
-        try initExecution.stack.popFrame()
+    func evaluateConstExpr(_ iseq: InstructionSequence, instance: ModuleInstance, arity: Int = 0) throws {
+        try evaluateConstExpr(iseq, instance: instance, arity: arity, body: { _ in })
+    }
 
-        return globalInitializers
+    func evaluateConstExpr<T>(
+        _ iseq: InstructionSequence,
+        instance: ModuleInstance,
+        arity: Int = 0,
+        body: (inout ExecutionState) throws -> T
+    ) throws -> T {
+        try withExecution { initExecution in
+            try initExecution.stack.pushFrame(
+                iseq: iseq,
+                arity: arity,
+                module: instance.selfAddress,
+                argc: 0,
+                defaultLocals: nil,
+                returnPC: initExecution.programCounter + 1
+            )
+            initExecution.programCounter = iseq.baseAddress
+            try initExecution.run(runtime: self)
+            return try body(&initExecution)
+        }
     }
 }
 
diff --git a/Sources/WasmKit/Execution/Runtime/Stack.swift b/Sources/WasmKit/Execution/Runtime/Stack.swift
index 4df02bac..1b0551ba 100644
--- a/Sources/WasmKit/Execution/Runtime/Stack.swift
+++ b/Sources/WasmKit/Execution/Runtime/Stack.swift
@@ -8,159 +8,269 @@ public struct Stack {
         case frame(Frame)
     }
 
-    private(set) var limit = UInt16.max
-    private(set) var elements = [Element]()
-    private(set) var currentFrame: Frame!
-    private(set) var currentLabel: Label!
-
-    var top: Element? { elements.last }
+    private var limit: UInt16 { UInt16.max }
+    private var valueStack: ValueStack
+    private var numberOfValues: Int { valueStack.count }
+    private var labels: FixedSizeStack<Label> {
+        didSet {
+            self.currentLabel = self.labels.peek()
+        }
+    }
+    private var frames: FixedSizeStack<Frame>
+    var currentFrame: Frame!
+    var currentLabel: Label!
 
-    mutating func push(value: Value) {
-        elements.append(.value(value))
+    var isEmpty: Bool {
+        self.frames.isEmpty && self.labels.isEmpty && self.numberOfValues == 0
     }
 
-    mutating func push(values: some Sequence<Value>) {
-        for value in values {
-            push(value: value)
-        }
+    init() {
+        let limit = UInt16.max
+        self.valueStack = ValueStack(capacity: Int(limit))
+        self.frames = FixedSizeStack(capacity: Int(limit))
+        self.labels = FixedSizeStack(capacity: Int(limit))
     }
 
-    mutating func push(label: Label) {
-        currentLabel = label
-        elements.append(.label(label))
+    @inline(__always)
+    mutating func pushLabel(arity: Int, continuation: ProgramCounter, popPushValues: Int = 0) {
+        let label = Label(
+            arity: arity,
+            continuation: continuation,
+            baseValueIndex: self.numberOfValues - popPushValues
+        )
+        labels.push(label)
     }
 
-    mutating func push(frame: Frame) throws {
-        guard elements.count < limit else {
+    mutating func pushFrame(
+        iseq: InstructionSequence,
+        arity: Int,
+        module: ModuleAddress,
+        argc: Int,
+        defaultLocals: UnsafeBufferPointer<Value>?,
+        returnPC: ProgramCounter,
+        address: FunctionAddress? = nil
+    ) throws {
+        // TODO: Stack overflow check can be done at the entry of expression
+        guard (frames.count + labels.count + numberOfValues) < limit else {
             throw Trap.callStackExhausted
         }
+        let valueFrameIndex = self.numberOfValues - argc
+        if let defaultLocals {
+            valueStack.push(values: defaultLocals)
+        }
+        let baseStackAddress = BaseStackAddress(
+            valueFrameIndex: valueFrameIndex,
+            // Consume argment values from value stack
+            valueIndex: self.numberOfValues,
+            labelIndex: self.labels.count
+        )
+        let frame = Frame(arity: arity, module: module, baseStackAddress: baseStackAddress, iseq: iseq, returnPC: returnPC, address: address)
+        frames.push(frame)
+        self.currentFrame = frame
+    }
 
-        currentFrame = frame
-        elements.append(.frame(frame))
+    func numberOfLabelsInCurrentFrame() -> Int {
+        self.labels.count - currentFrame.baseStackAddress.labelIndex
     }
 
-    @discardableResult
-    mutating func pop() -> Element? {
-        guard !elements.isEmpty else { return nil }
+    func numberOfValuesInCurrentLabel() -> Int {
+        self.numberOfValues - currentLabel.baseValueIndex
+    }
 
-        return elements.removeLast()
+    mutating func exit(label: Label) {
+        // labelIndex = 0 means jumping to the current head label
+        self.labels.pop()
     }
 
-    mutating func popLabel() throws -> Label {
-        guard let popped = pop() else {
-            throw Trap.stackOverflow
-        }
+    mutating func exit(frame: Frame) -> Label? {
+        let results = valueStack.popValues(count: frame.arity)
+        self.valueStack.truncate(length: frame.baseStackAddress.valueFrameIndex)
+        valueStack.push(values: results)
+        let labelToRemove = self.labels[frame.baseStackAddress.labelIndex]
+        self.labels.pop(self.labels.count - frame.baseStackAddress.labelIndex)
+        return labelToRemove
+    }
 
-        guard case let .label(label) = popped else {
-            throw Trap.stackTypeMismatch(expected: Label.self, actual: popped)
+    @discardableResult
+    mutating func unwindLabels(upto labelIndex: Int) -> Label? {
+        // labelIndex = 0 means jumping to the current head label
+        let labelToRemove = self.labels[self.labels.count - labelIndex - 1]
+        self.labels.pop(labelIndex + 1)
+        if self.numberOfValues > labelToRemove.baseValueIndex {
+            self.valueStack.truncate(length: labelToRemove.baseValueIndex)
         }
+        return labelToRemove
+    }
 
-        // Check if more labels are left on the stack, and a single element left can't be a label, it must be a frame.
-        guard elements.count > 1 else {
-            currentLabel = nil
-            return label
+    mutating func popTopValues() throws -> Array<Value> {
+        guard let currentLabel = self.currentLabel else {
+            return self.valueStack.popValues(count: self.valueStack.count)
+        }
+        guard currentLabel.baseValueIndex < self.numberOfValues else {
+            return []
         }
+        let values = self.valueStack.popValues(count: self.numberOfValues - currentLabel.baseValueIndex)
+        return values
+    }
 
-        loop: for i in stride(from: elements.count - 1, to: 0, by: -1) {
-            switch elements[i] {
-            case .frame:
-                currentLabel = nil
-                break loop
+    mutating func popFrame() {
+        let popped = self.frames.pop()
+        self.currentFrame = self.frames.peek()
+        self.valueStack.truncate(length: popped.baseStackAddress.valueFrameIndex)
+    }
 
-            case let .label(l):
-                currentLabel = l
-                break loop
+    func getLabel(index: Int) -> Label {
+        return self.labels[self.labels.count - index - 1]
+    }
 
-            case .value:
-                continue
-            }
-        }
+    mutating func popValues(count: Int) -> Array<Value> {
+        self.valueStack.popValues(count: count)
+    }
+    mutating func popValue() -> Value {
+        self.valueStack.popValue()
+    }
+    mutating func push(values: [Value]) {
+        self.valueStack.push(values: values)
+    }
+    mutating func push(value: Value) {
+        self.valueStack.push(value: value)
+    }
 
-        return label
+    var topValue: Value {
+        self.valueStack.topValue
     }
 
-    mutating func discardTopValues() {
-        while case .value = top {
-            pop()
-        }
+    var currentLocalsPointer: UnsafeMutablePointer<Value> {
+        self.valueStack.baseAddress.advanced(by: currentFrame?.baseStackAddress.valueFrameIndex ?? 0)
     }
+}
 
-    mutating func popValue() throws -> Value {
-        if case let .value(v) = top {
-            elements.removeLast()
-            return v
-        } else {
-            guard
-                let i = elements.lastIndex(where: { if case .value = $0 { return true } else { return false } }),
-                case let .value(v) = elements.remove(at: i)
-            else {
-                throw Trap.stackOverflow
-            }
+struct ValueStack {
+    private let values: UnsafeMutableBufferPointer<Value>
+    private var nextPointer: UnsafeMutablePointer<Value>
+    private let capacity: Int
+    var baseAddress: UnsafeMutablePointer<Value> {
+        values.baseAddress!
+    }
 
-            return v
+    init(capacity: Int) {
+        self.values = .allocate(capacity: capacity)
+        self.nextPointer = self.values.baseAddress!
+        self.capacity = capacity
+    }
+
+    func deallocate() {
+        self.values.deallocate()
+    }
+
+    var count: Int { nextPointer - values.baseAddress! }
+
+    var topValue: Value {
+        nextPointer.advanced(by: -1).pointee
+    }
+
+    subscript(_ index: Int) -> Value {
+        get { values[index] }
+        set {
+            values[index] = newValue
         }
     }
 
-    mutating func popTopValues() throws -> [Value] {
-        var values = [Value]()
-        while case .value = top {
-            try values.insert(popValue(), at: 0)
+    mutating func push(value: Value) {
+        self.nextPointer.pointee = value
+        self.nextPointer = self.nextPointer.advanced(by: 1)
+    }
+
+    mutating func push(values: [Value]) {
+        values.withUnsafeBufferPointer { copyingBuffer in
+            self.push(values: copyingBuffer)
         }
+    }
 
-        return values
+    mutating func push(values copyingBuffer: UnsafeBufferPointer<Value>) {
+        let rawBuffer = UnsafeMutableRawBufferPointer(
+            start: self.nextPointer,
+            count: MemoryLayout<Value>.stride * copyingBuffer.count
+        )
+        rawBuffer.copyMemory(from: UnsafeRawBufferPointer(copyingBuffer))
+        self.nextPointer = nextPointer.advanced(by: copyingBuffer.count)
     }
 
-    mutating func popValues(count: Int) throws -> [Value] {
+    mutating func popValue() -> Value {
+        // TODO: Check too many pop
+        self.nextPointer = nextPointer.advanced(by: -1)
+        let value = self.nextPointer.pointee
+        return value
+    }
+
+    mutating func truncate(length: Int) {
+        self.nextPointer = self.values.baseAddress!.advanced(by: length)
+    }
+    mutating func popValues(count: Int) -> Array<Value> {
+        guard count > 0 else { return [] }
         var values = [Value]()
-        for _ in 0..<count {
-            try values.insert(popValue(), at: 0)
+        values.reserveCapacity(count)
+        for idx in self.count-count..<self.count {
+            values.append(self.values[idx])
         }
+        self.nextPointer = self.nextPointer.advanced(by: -count)
         return values
     }
+}
 
-    mutating func popFrame() throws {
-        guard let popped = pop() else {
-            throw Trap.stackOverflow
-        }
+extension ValueStack: Sequence {
+    func makeIterator() -> some IteratorProtocol {
+        self.values[..<count].makeIterator()
+    }
+}
 
-        guard case .frame = popped else {
-            throw Trap.stackTypeMismatch(expected: Frame.self, actual: popped)
-        }
+struct FixedSizeStack<Element> {
+    private let buffer: UnsafeMutableBufferPointer<Element>
+    private var numberOfElements: Int = 0
 
-        for i in stride(from: elements.count - 1, to: -1, by: -1) {
-            switch elements[i] {
-            case let .frame(f):
-                currentFrame = f
-                return
+    var isEmpty: Bool {
+        numberOfElements == 0
+    }
 
-            case let .label(l):
-                if currentLabel == nil {
-                    currentLabel = l
-                }
+    var count: Int { numberOfElements }
 
-            case .value:
-                continue
-            }
-        }
+    init(capacity: Int) {
+        self.buffer = .allocate(capacity: capacity)
+    }
+
+    mutating func push(_ element: Element) {
+        self.buffer[numberOfElements] = element
+        self.numberOfElements += 1
+    }
+
+    @discardableResult
+    mutating func pop() -> Element {
+        let element = self.buffer[self.numberOfElements - 1]
+        self.numberOfElements -= 1
+        return element
+    }
+
+    mutating func pop(_ n: Int) {
+        self.numberOfElements -= n
+    }
+
+    mutating func popAll() {
+        self.numberOfElements = 0
+    }
+
+    func peek() -> Element! {
+        guard self.numberOfElements > 0 else { return nil }
+        return self.buffer[self.numberOfElements - 1]
+    }
+
+    subscript(_ index: Int) -> Element {
+        self.buffer[index]
+    }
+}
 
-        currentLabel = nil
-        currentFrame = nil
-    }
-
-    func getLabel(index: Int) throws -> Label {
-        var currentIndex: Int = -1
-        var entryIndex = elements.endIndex - 1
-        repeat {
-            defer { entryIndex -= 1 }
-            guard case let .label(label) = elements[entryIndex] else {
-                continue
-            }
-            currentIndex += 1
-            if currentIndex == index {
-                return label
-            }
-        } while entryIndex >= 0
-        throw Trap.stackElementNotFound(Label.self, index: index)
+extension FixedSizeStack: Sequence {
+    func makeIterator() -> some IteratorProtocol<Element> {
+        self.buffer[..<numberOfElements].makeIterator()
     }
 }
 
@@ -169,50 +279,100 @@ public struct Stack {
 public struct Label: Equatable {
     let arity: Int
 
-    let expression: Expression
-
     /// Index of an instruction to jump to when this label is popped off the stack.
-    let continuation: Int
+    let continuation: ProgramCounter
+
+    let baseValueIndex: Int
+}
 
-    /// The index after the  of the structured control instruction associated with the label
-    let exit: Int
+struct BaseStackAddress {
+    /// Locals are placed between `valueFrameIndex..<valueIndex`
+    let valueFrameIndex: Int
+    /// The base index of Wasm value stack
+    let valueIndex: Int
+    /// The base index of Wasm label stack
+    let labelIndex: Int
 }
 
 /// > Note:
 /// <https://webassembly.github.io/spec/core/exec/runtime.html#frames>
-public final class Frame {
+public struct Frame {
     let arity: Int
-    let module: ModuleInstance
-    var locals: [Value]
+    let module: ModuleAddress
+    let baseStackAddress: BaseStackAddress
+    let iseq: InstructionSequence
+    let returnPC: ProgramCounter
     /// An optional function address for debugging/profiling purpose
     let address: FunctionAddress?
 
-    init(arity: Int, module: ModuleInstance, locals: [Value], address: FunctionAddress? = nil) {
+    init(
+        arity: Int,
+        module: ModuleAddress,
+        baseStackAddress: BaseStackAddress,
+        iseq: InstructionSequence,
+        returnPC: ProgramCounter,
+        address: FunctionAddress? = nil
+    ) {
         self.arity = arity
         self.module = module
-        self.locals = locals
+        self.baseStackAddress = baseStackAddress
+        self.iseq = iseq
+        self.returnPC = returnPC
         self.address = address
     }
 }
 
 extension Frame: Equatable {
     public static func == (_ lhs: Frame, _ rhs: Frame) -> Bool {
-        lhs.module === rhs.module && lhs.arity == rhs.arity && lhs.locals == rhs.locals
+        lhs.module == rhs.module && lhs.arity == rhs.arity
     }
 }
 
-extension Frame {
-    func localGet(index: UInt32) throws -> Value {
-        guard locals.indices.contains(Int(index)) else {
-            throw Trap.localIndexOutOfRange(index: index)
-        }
-        return locals[Int(index)]
+extension Stack {
+    func localGet(index: UInt32) -> Value {
+        let base = currentFrame.baseStackAddress.valueFrameIndex
+        return valueStack[base + Int(index)]
     }
 
-    func localSet(index: UInt32, value: Value) throws {
-        guard locals.indices.contains(Int(index)) else {
-            throw Trap.localIndexOutOfRange(index: index)
+    mutating func localSet(index: UInt32, value: Value) {
+        let base = currentFrame.baseStackAddress.valueFrameIndex
+        valueStack[base + Int(index)] = value
+    }
+}
+
+extension Frame: CustomDebugStringConvertible {
+    public var debugDescription: String {
+        "[A=\(arity), BA=\(baseStackAddress), F=\(address?.description ?? "nil")]"
+    }
+}
+
+extension Label: CustomDebugStringConvertible {
+    public var debugDescription: String {
+        "[A=\(arity), C=\(continuation), BVI=\(baseValueIndex)]"
+    }
+}
+
+extension Stack: CustomDebugStringConvertible {
+    public var debugDescription: String {
+        var result = ""
+
+        result += "==================================================\n"
+        for (index, frame) in frames.enumerated() {
+            result += "FRAME[\(index)]: \(frame.debugDescription)\n"
+        }
+        result += "==================================================\n"
+
+        for (index, label) in labels.enumerated() {
+            result += "LABEL[\(index)]: \(label.debugDescription)\n"
         }
-        locals[Int(index)] = value
+
+        result += "==================================================\n"
+
+        for (index, value) in valueStack.enumerated() {
+            result += "VALUE[\(index)]: \(value)\n"
+        }
+        result += "==================================================\n"
+
+        return result
     }
 }
diff --git a/Sources/WasmKit/Execution/Runtime/Store.swift b/Sources/WasmKit/Execution/Runtime/Store.swift
index 25d76491..e87f1118 100644
--- a/Sources/WasmKit/Execution/Runtime/Store.swift
+++ b/Sources/WasmKit/Execution/Runtime/Store.swift
@@ -7,6 +7,7 @@ public typealias GlobalAddress = Int
 public typealias ElementAddress = Int
 public typealias DataAddress = Int
 public typealias ExternAddress = Int
+internal typealias ModuleAddress = Int
 
 /// A collection of globals and functions that are exported from a host module.
 public struct HostModule {
@@ -38,6 +39,7 @@ public final class Store {
     private var hostGlobals: [GlobalInstance] = []
     var nameRegistry = NameRegistry()
 
+    private var modules: [ModuleInstance] = []
     public internal(set) var namedModuleInstances: [String: ModuleInstance] = [:]
 
     /// This property is separate from `registeredModuleInstances`, as host exports
@@ -56,6 +58,19 @@ public final class Store {
             registerUniqueHostModule(hostModule, as: moduleName)
         }
     }
+
+    internal func module(address: ModuleAddress) -> ModuleInstance {
+        return self.modules[address]
+    }
+
+    internal func withTemporaryModuleInstance<T>(_ body: (ModuleInstance) throws -> T) rethrows -> T {
+        let tempAddress = self.modules.count
+        let module = ModuleInstance(selfAddress: tempAddress)
+        self.modules.append(module)
+        let result = try body(module)
+        self.modules.removeLast()
+        return result
+    }
 }
 
 /// A caller context passed to host functions
@@ -107,7 +122,7 @@ public struct HostFunction {
 }
 
 enum StoreFunction {
-    case wasm(FunctionInstance, body: Expression)
+    case wasm(FunctionInstance, body: InstructionSequence)
     case host(HostFunction)
 }
 
@@ -162,6 +177,7 @@ extension Store {
         try body(&self.memories[address])
     }
 
+    @_transparent
     func function(at address: FunctionAddress) throws -> StoreFunction {
         if address < 0 {
             return .host(hostFunctions[-address - 1])
@@ -227,7 +243,7 @@ extension Store {
         initialGlobals: [Value]
     ) -> ModuleInstance {
         // Step 1 of module allocation algorithm, according to Wasm 2.0 spec.
-        let moduleInstance = ModuleInstance()
+        let moduleInstance = ModuleInstance(selfAddress: modules.count)
 
         moduleInstance.types = module.types
 
@@ -278,13 +294,13 @@ extension Store {
         // Step 6.
         for element in module.elements {
             let references = element.initializer.map { expression -> Reference in
-                switch expression.instructions[0] {
-                case let .reference(.refFunc(index)):
+                switch expression[0] {
+                case let .refFunc(index):
                     let addr = moduleInstance.functionAddresses[Int(index)]
                     return .function(addr)
-                case .reference(.refNull(.funcRef)):
+                case .refNull(.funcRef):
                     return .function(nil)
-                case .reference(.refNull(.externRef)):
+                case .refNull(.externRef):
                     return .extern(nil)
                 default:
                     fatalError("Unexpected element initializer expression: \(expression)")
@@ -318,6 +334,7 @@ extension Store {
             try? nameRegistry.register(instance: moduleInstance, nameSection: nameSection)
         }
 
+        self.modules.append(moduleInstance)
         // Steps 20-21.
         return moduleInstance
     }
diff --git a/Sources/WasmKit/Execution/Types/Instances.swift b/Sources/WasmKit/Execution/Types/Instances.swift
index b0d40a9f..d0b81608 100644
--- a/Sources/WasmKit/Execution/Types/Instances.swift
+++ b/Sources/WasmKit/Execution/Types/Instances.swift
@@ -11,6 +11,11 @@ public final class ModuleInstance {
     public internal(set) var elementAddresses: [ElementAddress] = []
     public internal(set) var dataAddresses: [DataAddress] = []
     public internal(set) var exportInstances: [ExportInstance] = []
+    internal let selfAddress: ModuleAddress
+
+    init(selfAddress: ModuleAddress) {
+        self.selfAddress = selfAddress
+    }
 
     public typealias Exports = [String: ExternalValue]
 
@@ -36,11 +41,15 @@ public final class ModuleInstance {
 /// <https://webassembly.github.io/spec/core/exec/runtime.html#function-instances>
 public struct FunctionInstance {
     public let type: FunctionType
-    public let module: ModuleInstance
+    let module: ModuleAddress
     var code: GuestFunction
 
     init(_ function: GuestFunction, module: ModuleInstance) {
-        type = module.types[Int(function.type)]
+        self.init(function, module: module.selfAddress, type: module.types[Int(function.type)])
+    }
+
+    init(_ function: GuestFunction, module: ModuleAddress, type: FunctionType) {
+        self.type = type
         self.module = module
         code = function
     }
diff --git a/Sources/WasmKit/Parser/Wasm/WasmParser.swift b/Sources/WasmKit/Parser/Wasm/WasmParser.swift
index d22c766d..324e0d8a 100644
--- a/Sources/WasmKit/Parser/Wasm/WasmParser.swift
+++ b/Sources/WasmKit/Parser/Wasm/WasmParser.swift
@@ -76,6 +76,7 @@ public enum WasmParserError: Swift.Error {
     case dataCountSectionRequired
     case malformedLimit(UInt8)
     case malformedIndirectCall
+    case invalidTypeSectionReference
 }
 
 /// > Note:
@@ -300,10 +301,10 @@ extension WasmParser {
 
     /// > Note:
     /// <https://webassembly.github.io/spec/core/binary/instructions.html#memory-instructions>
-    func parseMemarg() throws -> MemoryInstruction.Memarg {
+    func parseMemarg() throws -> Instruction.Memarg {
         let align: UInt32 = try parseUnsigned()
         let offset: UInt64 = try features.contains(.memory64) ? parseUnsigned(UInt64.self) : UInt64(parseUnsigned(UInt32.self))
-        return MemoryInstruction.Memarg(offset: offset, align: align)
+        return Instruction.Memarg(offset: offset, align: align)
     }
 
     func parseVectorBytes() throws -> ArraySlice<UInt8> {
@@ -318,11 +319,12 @@ extension WasmParser {
 
     enum ParseInstructionResult {
         /// The instruction is not fully parsed yet but need expression to continue
-        case requestExpression(resume: (Expression, PseudoInstruction) throws -> ParseInstructionResult)
+        case requestExpression(resume: ([Instruction], PseudoInstruction) throws -> ParseInstructionResult)
         case `value`(Instruction)
+        case multiValue([Instruction])
     }
 
-    func parseInstruction() throws -> ParseInstructionResult {
+    func parseInstruction(typeSection: [FunctionType]?) throws -> ParseInstructionResult {
         let rawCode = try stream.consumeAny()
         guard let code = InstructionCode(rawValue: rawCode) else {
             throw WasmParserError.illegalOpcode(rawCode)
@@ -336,40 +338,49 @@ extension WasmParser {
         case .block:
             let type = try parseResultType()
             return .requestExpression { expr, _ in
-                return .value(.control(.block(expression: expr, type: type)))
+                let type = try type.arity(typeSection: typeSection)
+                return .multiValue([.block(endRef: ExpressionRef(expr.count + 1 + 1), type: type)] + expr + [.end])
             }
         case .loop:
             let type = try parseResultType()
             return .requestExpression { expr, _ in
-                return .value(.control(.loop(expression: expr, type: type)))
+                let type = try type.arity(typeSection: typeSection)
+                return .multiValue([.loop(type: type)] + expr + [.end])
             }
         case .if:
             let type = try parseResultType()
-            return .requestExpression { then, end in
+            return ParseInstructionResult.requestExpression { (thenExpr: [Instruction], end: PseudoInstruction) -> ParseInstructionResult in
                 switch end {
                 case .else:
-                    return .requestExpression { `else`, _ in
-                        return .value(.control(.if(then: then, else: `else`, type: type)))
+                    return .requestExpression { (elseExpr: [Instruction], end2: PseudoInstruction) -> ParseInstructionResult in
+                        let type = try type.arity(typeSection: typeSection)
+                        let control = Instruction.ifThenElse(
+                            elseRef: ExpressionRef(thenExpr.count + 1 + 1),
+                            endRef: ExpressionRef(thenExpr.count + 1 + elseExpr.count + 1 + 1),
+                            type: type
+                        )
+                        return .multiValue([control] + thenExpr + [.else] + elseExpr + [.end])
                     }
                 case .end:
-                    let `else` = Expression(instructions: [])
-                    return .value(.control(.if(then: then, else: `else`, type: type)))
+                    let type = try type.arity(typeSection: typeSection)
+                    let control = Instruction.ifThen(endRef: ExpressionRef(thenExpr.count + 2), type: type)
+                    return .multiValue([control] + thenExpr + [.end])
                 }
             }
         case .else:
-            return .value(.pseudo(.else))
+            return .value(.else)
         case .end:
-            return .value(.pseudo(.end))
+            return .value(.end)
         case .br:
             let label: UInt32 = try parseUnsigned()
-            return .value(.control(.br(label)))
+            return .value(.control(.br(labelIndex: label)))
         case .br_if:
             let label: UInt32 = try parseUnsigned()
-            return .value(.control(.brIf(label)))
+            return .value(.control(.brIf(labelIndex: label)))
         case .br_table:
             let labelIndices: [UInt32] = try parseVector { try parseUnsigned() }
             let labelIndex: UInt32 = try parseUnsigned()
-            return .value(.control(.brTable(labelIndices, default: labelIndex)))
+            return .value(.control(.brTable(.init(labelIndices: labelIndices, defaultIndex: labelIndex))))
         case .return:
             return .value(.control(.return))
         case .call:
@@ -389,7 +400,9 @@ extension WasmParser {
         case .select:
             return .value(.parametric(.select))
         case .typed_select:
-            return .value(try .parametric(.typedSelect(parseVector { try parseValueType() })))
+            // Just discard since our executor doesn't use it
+            _ = try parseVector { try parseValueType() }
+            return .value(.parametric(.select))
 
         case .local_get:
             let index: UInt32 = try parseUnsigned()
@@ -408,344 +421,344 @@ extension WasmParser {
             return .value(.variable(.globalSet(index: index)))
 
         case .i32_load:
-            return .value(try .memory(.load(parseMemarg(), bitWidth: 32, .i32)))
+            return .value(try .i32Load(memarg: parseMemarg()))
         case .i64_load:
-            return .value(try .memory(.load(parseMemarg(), bitWidth: 64, .i64)))
+            return .value(try .i64Load(memarg: parseMemarg()))
         case .f32_load:
-            return .value(try .memory(.load(parseMemarg(), bitWidth: 32, .f32)))
+            return .value(try .f32Load(memarg: parseMemarg()))
         case .f64_load:
-            return .value(try .memory(.load(parseMemarg(), bitWidth: 64, .f64)))
+            return .value(try .f64Load(memarg: parseMemarg()))
         case .i32_load8_s:
-            return .value(try .memory(.load(parseMemarg(), bitWidth: 8, .i32, isSigned: true)))
+            return .value(try .i32Load8S(memarg: parseMemarg()))
         case .i32_load8_u:
-            return .value(try .memory(.load(parseMemarg(), bitWidth: 8, .i32, isSigned: false)))
+            return .value(try .i32Load8U(memarg: parseMemarg()))
         case .i32_load16_s:
-            return .value(try .memory(.load(parseMemarg(), bitWidth: 16, .i32, isSigned: true)))
+            return .value(try .i32Load16S(memarg: parseMemarg()))
         case .i32_load16_u:
-            return .value(try .memory(.load(parseMemarg(), bitWidth: 16, .i32, isSigned: false)))
+            return .value(try .i32Load16U(memarg: parseMemarg()))
         case .i64_load8_s:
-            return .value(try .memory(.load(parseMemarg(), bitWidth: 8, .i64, isSigned: true)))
+            return .value(try .i64Load8S(memarg: parseMemarg()))
         case .i64_load8_u:
-            return .value(try .memory(.load(parseMemarg(), bitWidth: 8, .i64, isSigned: false)))
+            return .value(try .i64Load8U(memarg: parseMemarg()))
         case .i64_load16_s:
-            return .value(try .memory(.load(parseMemarg(), bitWidth: 16, .i64, isSigned: true)))
+            return .value(try .i64Load16S(memarg: parseMemarg()))
         case .i64_load16_u:
-            return .value(try .memory(.load(parseMemarg(), bitWidth: 16, .i64, isSigned: false)))
+            return .value(try .i64Load16U(memarg: parseMemarg()))
         case .i64_load32_s:
-            return .value(try .memory(.load(parseMemarg(), bitWidth: 32, .i64, isSigned: true)))
+            return .value(try .i64Load32S(memarg: parseMemarg()))
         case .i64_load32_u:
-            return .value(try .memory(.load(parseMemarg(), bitWidth: 32, .i64, isSigned: false)))
+            return .value(try .i64Load32U(memarg: parseMemarg()))
         case .i32_store:
-            return .value(try .memory(.store(parseMemarg(), bitWidth: 32, .i32)))
+            return .value(try .i32Store(memarg: parseMemarg()))
         case .i64_store:
-            return .value(try .memory(.store(parseMemarg(), bitWidth: 64, .i64)))
+            return .value(try .i64Store(memarg: parseMemarg()))
         case .f32_store:
-            return .value(try .memory(.store(parseMemarg(), bitWidth: 32, .i32)))
+            return .value(try .f32Store(memarg: parseMemarg()))
         case .f64_store:
-            return .value(try .memory(.store(parseMemarg(), bitWidth: 64, .i64)))
+            return .value(try .f64Store(memarg: parseMemarg()))
         case .i32_store8:
-            return .value(try .memory(.store(parseMemarg(), bitWidth: 8, .i32)))
+            return .value(try .i32Store8(memarg: parseMemarg()))
         case .i32_store16:
-            return .value(try .memory(.store(parseMemarg(), bitWidth: 16, .i32)))
+            return .value(try .i32Store16(memarg: parseMemarg()))
         case .i64_store8:
-            return .value(try .memory(.store(parseMemarg(), bitWidth: 8, .i64)))
+            return .value(try .i64Store8(memarg: parseMemarg()))
         case .i64_store16:
-            return .value(try .memory(.store(parseMemarg(), bitWidth: 16, .i64)))
+            return .value(try .i64Store16(memarg: parseMemarg()))
         case .i64_store32:
-            return .value(try .memory(.store(parseMemarg(), bitWidth: 32, .i64)))
+            return .value(try .i64Store32(memarg: parseMemarg()))
         case .memory_size:
             let zero = try stream.consumeAny()
             guard zero == 0x00 else {
                 throw WasmParserError.zeroExpected(actual: zero, index: currentIndex)
             }
-            return .value(.memory(.size))
+            return .value(.memorySize)
         case .memory_grow:
             let zero = try stream.consumeAny()
             guard zero == 0x00 else {
                 throw WasmParserError.zeroExpected(actual: zero, index: currentIndex)
             }
-            return .value(.memory(.grow))
+            return .value(.memoryGrow)
 
         case .i32_const:
             let n: UInt32 = try parseInteger()
-            return .value(.numeric(.const(.i32(n))))
+            return .value(.numericConst((.i32(n))))
         case .i64_const:
             let n: UInt64 = try parseInteger()
-            return .value(.numeric(.const(.i64(n))))
+            return .value(.numericConst((.i64(n))))
         case .f32_const:
             let n = try parseFloat()
-            return .value(.numeric(.const(.f32(n))))
+            return .value(.numericConst((.f32(n))))
         case .f64_const:
             let n = try parseDouble()
-            return .value(.numeric(.const(.f64(n))))
+            return .value(.numericConst((.f64(n))))
 
         case .i32_eqz:
-            return .value(.numeric(.intUnary(.eqz(.i32))))
+            return .value(.numericIntUnary((.eqz(.i32))))
         case .i32_eq:
-            return .value(.numeric(.binary(.eq(.int(.i32)))))
+            return .value(.i32Eq)
         case .i32_ne:
-            return .value(.numeric(.binary(.ne(.int(.i32)))))
+            return .value(.i32Ne)
         case .i32_lt_s:
-            return .value(.numeric(.intBinary(.ltS(.i32))))
+            return .value(.i32LtS)
         case .i32_lt_u:
-            return .value(.numeric(.intBinary(.ltU(.i32))))
+            return .value(.i32LtU)
         case .i32_gt_s:
-            return .value(.numeric(.intBinary(.gtS(.i32))))
+            return .value(.i32GtS)
         case .i32_gt_u:
-            return .value(.numeric(.intBinary(.gtU(.i32))))
+            return .value(.i32GtU)
         case .i32_le_s:
-            return .value(.numeric(.intBinary(.leS(.i32))))
+            return .value(.i32LeS)
         case .i32_le_u:
-            return .value(.numeric(.intBinary(.leU(.i32))))
+            return .value(.i32LeU)
         case .i32_ge_s:
-            return .value(.numeric(.intBinary(.geS(.i32))))
+            return .value(.i32GeS)
         case .i32_ge_u:
-            return .value(.numeric(.intBinary(.geU(.i32))))
+            return .value(.i32GeU)
 
         case .i64_eqz:
-            return .value(.numeric(.intUnary(.eqz(.i64))))
+            return .value(.numericIntUnary((.eqz(.i64))))
         case .i64_eq:
-            return .value(.numeric(.binary(.eq(.int(.i64)))))
+            return .value(.i64Eq)
         case .i64_ne:
-            return .value(.numeric(.binary(.ne(.int(.i64)))))
+            return .value(.i64Ne)
         case .i64_lt_s:
-            return .value(.numeric(.intBinary(.ltS(.i64))))
+            return .value(.i64LtS)
         case .i64_lt_u:
-            return .value(.numeric(.intBinary(.ltU(.i64))))
+            return .value(.i64LtU)
         case .i64_gt_s:
-            return .value(.numeric(.intBinary(.gtS(.i64))))
+            return .value(.i64GtS)
         case .i64_gt_u:
-            return .value(.numeric(.intBinary(.gtU(.i64))))
+            return .value(.i64GtU)
         case .i64_le_s:
-            return .value(.numeric(.intBinary(.leS(.i64))))
+            return .value(.i64LeS)
         case .i64_le_u:
-            return .value(.numeric(.intBinary(.leU(.i64))))
+            return .value(.i64LeU)
         case .i64_ge_s:
-            return .value(.numeric(.intBinary(.geS(.i64))))
+            return .value(.i64GeS)
         case .i64_ge_u:
-            return .value(.numeric(.intBinary(.geU(.i64))))
+            return .value(.i64GeU)
 
         case .f32_eq:
-            return .value(.numeric(.binary(.eq(.float(.f32)))))
+            return .value(.f32Eq)
         case .f32_ne:
-            return .value(.numeric(.binary(.ne(.float(.f32)))))
+            return .value(.f32Ne)
         case .f32_lt:
-            return .value(.numeric(.floatBinary(.lt(.f32))))
+            return .value(.numericFloatBinary((.lt(.f32))))
         case .f32_gt:
-            return .value(.numeric(.floatBinary(.gt(.f32))))
+            return .value(.numericFloatBinary((.gt(.f32))))
         case .f32_le:
-            return .value(.numeric(.floatBinary(.le(.f32))))
+            return .value(.numericFloatBinary((.le(.f32))))
         case .f32_ge:
-            return .value(.numeric(.floatBinary(.ge(.f32))))
+            return .value(.numericFloatBinary((.ge(.f32))))
 
         case .f64_eq:
-            return .value(.numeric(.binary(.eq(.float(.f64)))))
+            return .value(.f64Eq)
         case .f64_ne:
-            return .value(.numeric(.binary(.ne(.float(.f64)))))
+            return .value(.f64Ne)
         case .f64_lt:
-            return .value(.numeric(.floatBinary(.lt(.f64))))
+            return .value(.numericFloatBinary((.lt(.f64))))
         case .f64_gt:
-            return .value(.numeric(.floatBinary(.gt(.f64))))
+            return .value(.numericFloatBinary((.gt(.f64))))
         case .f64_le:
-            return .value(.numeric(.floatBinary(.le(.f64))))
+            return .value(.numericFloatBinary((.le(.f64))))
         case .f64_ge:
-            return .value(.numeric(.floatBinary(.ge(.f64))))
+            return .value(.numericFloatBinary((.ge(.f64))))
 
         case .i32_clz:
-            return .value(.numeric(.intUnary(.clz(.i32))))
+            return .value(.numericIntUnary((.clz(.i32))))
         case .i32_ctz:
-            return .value(.numeric(.intUnary(.ctz(.i32))))
+            return .value(.numericIntUnary((.ctz(.i32))))
         case .i32_popcnt:
-            return .value(.numeric(.intUnary(.popcnt(.i32))))
+            return .value(.numericIntUnary((.popcnt(.i32))))
         case .i32_add:
-            return .value(.numeric(.binary(.add(.int(.i32)))))
+            return .value(.i32Add)
         case .i32_sub:
-            return .value(.numeric(.binary(.sub(.int(.i32)))))
+            return .value(.i32Sub)
         case .i32_mul:
-            return .value(.numeric(.binary(.mul(.int(.i32)))))
+            return .value(.i32Mul)
         case .i32_div_s:
-            return .value(.numeric(.intBinary(.divS(.i32))))
+            return .value(.numericIntBinary((.divS(.i32))))
         case .i32_div_u:
-            return .value(.numeric(.intBinary(.divU(.i32))))
+            return .value(.numericIntBinary((.divU(.i32))))
         case .i32_rem_s:
-            return .value(.numeric(.intBinary(.remS(.i32))))
+            return .value(.numericIntBinary((.remS(.i32))))
         case .i32_rem_u:
-            return .value(.numeric(.intBinary(.remU(.i32))))
+            return .value(.numericIntBinary((.remU(.i32))))
         case .i32_and:
-            return .value(.numeric(.intBinary(.and(.i32))))
+            return .value(.numericIntBinary((.and(.i32))))
         case .i32_or:
-            return .value(.numeric(.intBinary(.or(.i32))))
+            return .value(.numericIntBinary((.or(.i32))))
         case .i32_xor:
-            return .value(.numeric(.intBinary(.xor(.i32))))
+            return .value(.numericIntBinary((.xor(.i32))))
         case .i32_shl:
-            return .value(.numeric(.intBinary(.shl(.i32))))
+            return .value(.numericIntBinary((.shl(.i32))))
         case .i32_shr_s:
-            return .value(.numeric(.intBinary(.shrS(.i32))))
+            return .value(.numericIntBinary((.shrS(.i32))))
         case .i32_shr_u:
-            return .value(.numeric(.intBinary(.shrU(.i32))))
+            return .value(.numericIntBinary((.shrU(.i32))))
         case .i32_rotl:
-            return .value(.numeric(.intBinary(.rotl(.i32))))
+            return .value(.numericIntBinary((.rotl(.i32))))
         case .i32_rotr:
-            return .value(.numeric(.intBinary(.rotr(.i32))))
+            return .value(.numericIntBinary((.rotr(.i32))))
 
         case .i64_clz:
-            return .value(.numeric(.intUnary(.clz(.i64))))
+            return .value(.numericIntUnary((.clz(.i64))))
         case .i64_ctz:
-            return .value(.numeric(.intUnary(.ctz(.i64))))
+            return .value(.numericIntUnary((.ctz(.i64))))
         case .i64_popcnt:
-            return .value(.numeric(.intUnary(.popcnt(.i64))))
+            return .value(.numericIntUnary((.popcnt(.i64))))
         case .i64_add:
-            return .value(.numeric(.binary(.add(.int(.i64)))))
+            return .value(.i64Add)
         case .i64_sub:
-            return .value(.numeric(.binary(.sub(.int(.i64)))))
+            return .value(.i64Sub)
         case .i64_mul:
-            return .value(.numeric(.binary(.mul(.int(.i64)))))
+            return .value(.i64Mul)
         case .i64_div_s:
-            return .value(.numeric(.intBinary(.divS(.i64))))
+            return .value(.numericIntBinary((.divS(.i64))))
         case .i64_div_u:
-            return .value(.numeric(.intBinary(.divU(.i64))))
+            return .value(.numericIntBinary((.divU(.i64))))
         case .i64_rem_s:
-            return .value(.numeric(.intBinary(.remS(.i64))))
+            return .value(.numericIntBinary((.remS(.i64))))
         case .i64_rem_u:
-            return .value(.numeric(.intBinary(.remU(.i64))))
+            return .value(.numericIntBinary((.remU(.i64))))
         case .i64_and:
-            return .value(.numeric(.intBinary(.and(.i64))))
+            return .value(.numericIntBinary((.and(.i64))))
         case .i64_or:
-            return .value(.numeric(.intBinary(.or(.i64))))
+            return .value(.numericIntBinary((.or(.i64))))
         case .i64_xor:
-            return .value(.numeric(.intBinary(.xor(.i64))))
+            return .value(.numericIntBinary((.xor(.i64))))
         case .i64_shl:
-            return .value(.numeric(.intBinary(.shl(.i64))))
+            return .value(.numericIntBinary((.shl(.i64))))
         case .i64_shr_s:
-            return .value(.numeric(.intBinary(.shrS(.i64))))
+            return .value(.numericIntBinary((.shrS(.i64))))
         case .i64_shr_u:
-            return .value(.numeric(.intBinary(.shrU(.i64))))
+            return .value(.numericIntBinary((.shrU(.i64))))
         case .i64_rotl:
-            return .value(.numeric(.intBinary(.rotl(.i64))))
+            return .value(.numericIntBinary((.rotl(.i64))))
         case .i64_rotr:
-            return .value(.numeric(.intBinary(.rotr(.i64))))
+            return .value(.numericIntBinary((.rotr(.i64))))
 
         case .f32_abs:
-            return .value(.numeric(.floatUnary(.abs(.f32))))
+            return .value(.numericFloatUnary((.abs(.f32))))
         case .f32_neg:
-            return .value(.numeric(.floatUnary(.neg(.f32))))
+            return .value(.numericFloatUnary((.neg(.f32))))
         case .f32_ceil:
-            return .value(.numeric(.floatUnary(.ceil(.f32))))
+            return .value(.numericFloatUnary((.ceil(.f32))))
         case .f32_floor:
-            return .value(.numeric(.floatUnary(.floor(.f32))))
+            return .value(.numericFloatUnary((.floor(.f32))))
         case .f32_trunc:
-            return .value(.numeric(.floatUnary(.trunc(.f32))))
+            return .value(.numericFloatUnary((.trunc(.f32))))
         case .f32_nearest:
-            return .value(.numeric(.floatUnary(.nearest(.f32))))
+            return .value(.numericFloatUnary((.nearest(.f32))))
         case .f32_sqrt:
-            return .value(.numeric(.floatUnary(.sqrt(.f32))))
+            return .value(.numericFloatUnary((.sqrt(.f32))))
 
         case .f32_add:
-            return .value(.numeric(.binary(.add(.float(.f32)))))
+            return .value(.f32Add)
         case .f32_sub:
-            return .value(.numeric(.binary(.sub(.float(.f32)))))
+            return .value(.f32Sub)
         case .f32_mul:
-            return .value(.numeric(.binary(.mul(.float(.f32)))))
+            return .value(.f32Mul)
         case .f32_div:
-            return .value(.numeric(.floatBinary(.div(.f32))))
+            return .value(.numericFloatBinary((.div(.f32))))
         case .f32_min:
-            return .value(.numeric(.floatBinary(.min(.f32))))
+            return .value(.numericFloatBinary((.min(.f32))))
         case .f32_max:
-            return .value(.numeric(.floatBinary(.max(.f32))))
+            return .value(.numericFloatBinary((.max(.f32))))
         case .f32_copysign:
-            return .value(.numeric(.floatBinary(.copysign(.f32))))
+            return .value(.numericFloatBinary((.copysign(.f32))))
 
         case .f64_abs:
-            return .value(.numeric(.floatUnary(.abs(.f64))))
+            return .value(.numericFloatUnary((.abs(.f64))))
         case .f64_neg:
-            return .value(.numeric(.floatUnary(.neg(.f64))))
+            return .value(.numericFloatUnary((.neg(.f64))))
         case .f64_ceil:
-            return .value(.numeric(.floatUnary(.ceil(.f64))))
+            return .value(.numericFloatUnary((.ceil(.f64))))
         case .f64_floor:
-            return .value(.numeric(.floatUnary(.floor(.f64))))
+            return .value(.numericFloatUnary((.floor(.f64))))
         case .f64_trunc:
-            return .value(.numeric(.floatUnary(.trunc(.f64))))
+            return .value(.numericFloatUnary((.trunc(.f64))))
         case .f64_nearest:
-            return .value(.numeric(.floatUnary(.nearest(.f64))))
+            return .value(.numericFloatUnary((.nearest(.f64))))
         case .f64_sqrt:
-            return .value(.numeric(.floatUnary(.sqrt(.f64))))
+            return .value(.numericFloatUnary((.sqrt(.f64))))
 
         case .f64_add:
-            return .value(.numeric(.binary(.add(.float(.f64)))))
+            return .value(.f64Add)
         case .f64_sub:
-            return .value(.numeric(.binary(.sub(.float(.f64)))))
+            return .value(.f64Sub)
         case .f64_mul:
-            return .value(.numeric(.binary(.mul(.float(.f64)))))
+            return .value(.f64Mul)
         case .f64_div:
-            return .value(.numeric(.floatBinary(.div(.f64))))
+            return .value(.numericFloatBinary((.div(.f64))))
         case .f64_min:
-            return .value(.numeric(.floatBinary(.min(.f64))))
+            return .value(.numericFloatBinary((.min(.f64))))
         case .f64_max:
-            return .value(.numeric(.floatBinary(.max(.f64))))
+            return .value(.numericFloatBinary((.max(.f64))))
         case .f64_copysign:
-            return .value(.numeric(.floatBinary(.copysign(.f64))))
+            return .value(.numericFloatBinary((.copysign(.f64))))
 
         case .i32_wrap_i64:
-            return .value(.numeric(.conversion(.wrap)))
+            return .value(.numericConversion((.wrap)))
         case .i32_trunc_f32_s:
-            return .value(.numeric(.conversion(.truncSigned(.i32, .f32))))
+            return .value(.numericConversion((.truncSigned(.i32, .f32))))
         case .i32_trunc_f32_u:
-            return .value(.numeric(.conversion(.truncUnsigned(.i32, .f32))))
+            return .value(.numericConversion((.truncUnsigned(.i32, .f32))))
         case .i32_trunc_f64_s:
-            return .value(.numeric(.conversion(.truncSigned(.i32, .f64))))
+            return .value(.numericConversion((.truncSigned(.i32, .f64))))
         case .i32_trunc_f64_u:
-            return .value(.numeric(.conversion(.truncUnsigned(.i32, .f64))))
+            return .value(.numericConversion((.truncUnsigned(.i32, .f64))))
         case .i64_extend_i32_s:
-            return .value(.numeric(.conversion(.extendSigned)))
+            return .value(.numericConversion((.extendSigned)))
         case .i64_extend_i32_u:
-            return .value(.numeric(.conversion(.extendUnsigned)))
+            return .value(.numericConversion((.extendUnsigned)))
         case .i64_trunc_f32_s:
-            return .value(.numeric(.conversion(.truncSigned(.i64, .f32))))
+            return .value(.numericConversion((.truncSigned(.i64, .f32))))
         case .i64_trunc_f32_u:
-            return .value(.numeric(.conversion(.truncUnsigned(.i64, .f32))))
+            return .value(.numericConversion((.truncUnsigned(.i64, .f32))))
         case .i64_trunc_f64_s:
-            return .value(.numeric(.conversion(.truncSigned(.i64, .f64))))
+            return .value(.numericConversion((.truncSigned(.i64, .f64))))
         case .i64_trunc_f64_u:
-            return .value(.numeric(.conversion(.truncUnsigned(.i64, .f64))))
+            return .value(.numericConversion((.truncUnsigned(.i64, .f64))))
         case .f32_convert_i32_s:
-            return .value(.numeric(.conversion(.convertSigned(.f32, .i32))))
+            return .value(.numericConversion((.convertSigned(.f32, .i32))))
         case .f32_convert_i32_u:
-            return .value(.numeric(.conversion(.convertUnsigned(.f32, .i32))))
+            return .value(.numericConversion((.convertUnsigned(.f32, .i32))))
         case .f32_convert_i64_s:
-            return .value(.numeric(.conversion(.convertSigned(.f32, .i64))))
+            return .value(.numericConversion((.convertSigned(.f32, .i64))))
         case .f32_convert_i64_u:
-            return .value(.numeric(.conversion(.convertUnsigned(.f32, .i64))))
+            return .value(.numericConversion((.convertUnsigned(.f32, .i64))))
         case .f32_demote_f64:
-            return .value(.numeric(.conversion(.demote)))
+            return .value(.numericConversion((.demote)))
         case .f64_convert_i32_s:
-            return .value(.numeric(.conversion(.convertSigned(.f64, .i32))))
+            return .value(.numericConversion((.convertSigned(.f64, .i32))))
         case .f64_convert_i32_u:
-            return .value(.numeric(.conversion(.convertUnsigned(.f64, .i32))))
+            return .value(.numericConversion((.convertUnsigned(.f64, .i32))))
         case .f64_convert_i64_s:
-            return .value(.numeric(.conversion(.convertSigned(.f64, .i64))))
+            return .value(.numericConversion((.convertSigned(.f64, .i64))))
         case .f64_convert_i64_u:
-            return .value(.numeric(.conversion(.convertUnsigned(.f64, .i64))))
+            return .value(.numericConversion((.convertUnsigned(.f64, .i64))))
         case .f64_promote_f32:
-            return .value(.numeric(.conversion(.promote)))
+            return .value(.numericConversion((.promote)))
         case .i32_reinterpret_f32:
-            return .value(.numeric(.conversion(.reinterpret(.int(.i32), .float(.f32)))))
+            return .value(.numericConversion((.reinterpret(.int(.i32), .float(.f32)))))
         case .i64_reinterpret_f64:
-            return .value(.numeric(.conversion(.reinterpret(.int(.i64), .float(.f64)))))
+            return .value(.numericConversion((.reinterpret(.int(.i64), .float(.f64)))))
         case .f32_reinterpret_i32:
-            return .value(.numeric(.conversion(.reinterpret(.float(.f32), .int(.i32)))))
+            return .value(.numericConversion((.reinterpret(.float(.f32), .int(.i32)))))
         case .f64_reinterpret_i64:
-            return .value(.numeric(.conversion(.reinterpret(.float(.f64), .int(.i64)))))
+            return .value(.numericConversion((.reinterpret(.float(.f64), .int(.i64)))))
 
         case .i32_extend8_s:
-            return .value(.numeric(.conversion(.extend8Signed(.i32))))
+            return .value(.numericConversion((.extend8Signed(.i32))))
         case .i32_extend16_s:
-            return .value(.numeric(.conversion(.extend16Signed(.i32))))
+            return .value(.numericConversion((.extend16Signed(.i32))))
         case .i64_extend8_s:
-            return .value(.numeric(.conversion(.extend8Signed(.i64))))
+            return .value(.numericConversion((.extend8Signed(.i64))))
         case .i64_extend16_s:
-            return .value(.numeric(.conversion(.extend16Signed(.i64))))
+            return .value(.numericConversion((.extend16Signed(.i64))))
         case .i64_extend32_s:
-            return .value(.numeric(.conversion(.extend32Signed)))
+            return .value(.numericConversion((.extend32Signed)))
 
         case .ref_null:
             let type = try parseValueType()
@@ -763,32 +776,32 @@ extension WasmParser {
             return .value(try .reference(.refFunc(parseUnsigned())))
 
         case .table_get:
-            return .value(try .table(.get(parseUnsigned())))
+            return .value(try .tableGet(parseUnsigned()))
 
         case .table_set:
-            return .value(try .table(.set(parseUnsigned())))
+            return .value(try .tableSet(parseUnsigned()))
 
         case .wasm2InstructionPrefix:
             let codeSuffix: UInt32 = try parseUnsigned()
             switch codeSuffix {
             case 0:
-                return .value(.numeric(.conversion(.truncSaturatingSigned(.i32, .f32))))
+                return .value(.numericConversion((.truncSaturatingSigned(.i32, .f32))))
             case 1:
-                return .value(.numeric(.conversion(.truncSaturatingUnsigned(.i32, .f32))))
+                return .value(.numericConversion((.truncSaturatingUnsigned(.i32, .f32))))
             case 2:
-                return .value(.numeric(.conversion(.truncSaturatingSigned(.i32, .f64))))
+                return .value(.numericConversion((.truncSaturatingSigned(.i32, .f64))))
             case 3:
-                return .value(.numeric(.conversion(.truncSaturatingUnsigned(.i32, .f64))))
+                return .value(.numericConversion((.truncSaturatingUnsigned(.i32, .f64))))
             case 4:
-                return .value(.numeric(.conversion(.truncSaturatingSigned(.i64, .f32))))
+                return .value(.numericConversion((.truncSaturatingSigned(.i64, .f32))))
             case 5:
-                return .value(.numeric(.conversion(.truncSaturatingUnsigned(.i64, .f32))))
+                return .value(.numericConversion((.truncSaturatingUnsigned(.i64, .f32))))
             case 6:
-                return .value(.numeric(.conversion(.truncSaturatingSigned(.i64, .f64))))
+                return .value(.numericConversion((.truncSaturatingSigned(.i64, .f64))))
             case 7:
-                return .value(.numeric(.conversion(.truncSaturatingUnsigned(.i64, .f64))))
+                return .value(.numericConversion((.truncSaturatingUnsigned(.i64, .f64))))
             case 8:
-                let result = try Instruction.memory(.`init`(parseUnsigned()))
+                let result = try Instruction.memoryInit(parseUnsigned())
                 // memory.init requires data count section
                 // https://webassembly.github.io/spec/core/binary/modules.html#data-count-section
                 guard hasDataCount else {
@@ -808,14 +821,14 @@ extension WasmParser {
                 guard hasDataCount else {
                     throw WasmParserError.dataCountSectionRequired
                 }
-                return .value(try .memory(.dataDrop(parseUnsigned())))
+                return .value(try .memoryDataDrop(parseUnsigned()))
 
             case 10:
                 let (zero1, zero2) = try (stream.consumeAny(), stream.consumeAny())
                 guard zero1 == 0x00 && zero2 == 0x00 else {
                     throw WasmParserError.zeroExpected(actual: zero2, index: currentIndex)
                 }
-                return .value(.memory(.copy))
+                return .value(.memoryCopy)
 
             case 11:
                 let zero = try stream.consumeAny()
@@ -823,29 +836,29 @@ extension WasmParser {
                     throw WasmParserError.zeroExpected(actual: zero, index: currentIndex)
                 }
 
-                return .value(.memory(.fill))
+                return .value(.memoryFill)
 
             case 12:
                 let elementIndex: ElementIndex = try parseUnsigned()
                 let tableIndex: TableIndex = try parseUnsigned()
-                return .value(.table(.`init`(tableIndex, elementIndex)))
+                return .value(.tableInit(tableIndex, elementIndex))
 
             case 13:
-                return .value(try .table(.elementDrop(parseUnsigned())))
+                return .value(try .tableElementDrop(parseUnsigned()))
 
             case 14:
                 let sourceTableIndex: TableIndex = try parseUnsigned()
                 let destinationTableIndex: TableIndex = try parseUnsigned()
-                return .value(.table(.copy(sourceTableIndex, destinationTableIndex)))
+                return .value(.tableCopy(dest: sourceTableIndex, src: destinationTableIndex))
 
             case 15:
-                return .value(try .table(.grow(parseUnsigned())))
+                return .value(try .tableGrow(parseUnsigned()))
 
             case 16:
-                return .value(try .table(.size(parseUnsigned())))
+                return .value(try .tableSize(parseUnsigned()))
 
             case 17:
-                return .value(try .table(.fill(parseUnsigned())))
+                return .value(try .tableFill(parseUnsigned()))
 
             default:
                 throw WasmParserError.unimplementedInstruction(rawCode, suffix: codeSuffix)
@@ -853,41 +866,51 @@ extension WasmParser {
         }
     }
 
-    func parseExpression() throws -> (result: Expression, end: PseudoInstruction) {
+    func parseExpression(typeSection: [FunctionType]? = nil) throws -> (result: Expression, end: PseudoInstruction) {
         typealias PendingWork = (
             instructions: [Instruction],
-            resume: (Expression, PseudoInstruction) throws -> ParseInstructionResult
+            resume: ([Instruction], PseudoInstruction) throws -> ParseInstructionResult
         )
         var pendingWorks: [PendingWork] = []
         var instructions: [Instruction] = []
 
-        var nextResult = try parseInstruction()
+        func parseSingleInst() throws -> ParseInstructionResult {
+            return try parseInstruction(typeSection: typeSection)
+        }
+        var nextResult = try parseSingleInst()
 
         while true {
             switch nextResult {
-            case .value(.pseudo(let end)):
-                let expr = Expression(instructions: instructions)
+            case .value(let end) where end == .end || end == .else:
+                let end: PseudoInstruction = end == .end ? .end : .else
                 if let nextWork = pendingWorks.popLast() {
                     // If there is a pending parse, then restore the parsing
                     // state and resume the rest of the work
+                    nextResult = try nextWork.resume(instructions, end)
                     instructions = nextWork.instructions
-                    nextResult = try nextWork.resume(expr, end)
                 } else {
                     // If no more pending expression, the expression is top-level
-                    return (expr, end)
+                    return (instructions, end)
                 }
             case let .value(nextInstruction):
                 instructions.append(nextInstruction)
-                nextResult = try parseInstruction()
+                nextResult = try parseSingleInst()
+            case let .multiValue(nextInsts):
+                instructions.append(contentsOf: nextInsts)
+                nextResult = try parseSingleInst()
             case let .requestExpression(resume):
                 // If nested expression is requested, stop parsing the current expression
                 // and start parsing the nested one
                 pendingWorks.append((instructions, resume))
                 instructions = []
-                nextResult = try parseInstruction()
+                nextResult = try parseSingleInst()
             }
         }
     }
+    func parseInstructionSequence(typeSection: [FunctionType]) throws -> (result: InstructionSequence, end: PseudoInstruction) {
+        let (instructions, end) = try parseExpression(typeSection: typeSection)
+        return (InstructionSequence(instructions: instructions), end)
+    }
 }
 
 /// > Note:
@@ -1060,9 +1083,7 @@ extension WasmParser {
                 initializer = try parseVector { try parseExpression().result }
             } else {
                 initializer = try parseVector {
-                    try Expression(
-                        instructions: [.reference(.refFunc(parseUnsigned() as UInt32))]
-                    )
+                    try [.reference(.refFunc(parseUnsigned() as UInt32))]
                 }
             }
 
@@ -1267,10 +1288,10 @@ extension WasmParser {
         let functions = codes.enumerated().map { [hasDataCount, features] index, code in
             GuestFunction(
                 type: typeIndices[index], locals: code.locals,
-                body: {
+                body: { [types = module.types] in
                     let stream = StaticByteStream(bytes: Array(code.expression))
                     let parser = WasmParser<StaticByteStream>(stream: stream, features: features, hasDataCount: hasDataCount)
-                    let (result, end) = try parser.parseExpression()
+                    let (result, end) = try parser.parseInstructionSequence(typeSection: types)
                     guard end == .end else {
                         throw WasmParserError.endOpcodeExpected
                     }
diff --git a/Sources/WasmKit/Types/Module.swift b/Sources/WasmKit/Types/Module.swift
index d373fcb5..bfd58cc3 100644
--- a/Sources/WasmKit/Types/Module.swift
+++ b/Sources/WasmKit/Types/Module.swift
@@ -68,17 +68,22 @@ public typealias LabelIndex = UInt32
 /// > Note:
 /// <https://webassembly.github.io/spec/core/syntax/modules.html#functions>
 struct GuestFunction {
-    init(type: TypeIndex, locals: [ValueType], body: @escaping () throws -> Expression) {
+    init(type: TypeIndex, locals: [ValueType], body: @escaping () throws -> InstructionSequence) {
         self.type = type
-        self.locals = locals
+        // TODO: Deallocate const default locals after the module is deallocated
+        let defaultLocals = UnsafeMutableBufferPointer<Value>.allocate(capacity: locals.count)
+        for (index, localType) in locals.enumerated() {
+            defaultLocals[index] = localType.defaultValue
+        }
+        self.defaultLocals = UnsafeBufferPointer(defaultLocals)
         self.materializer = body
     }
 
     public let type: TypeIndex
-    public let locals: [ValueType]
-    private var _bodyStorage: Expression? = nil
-    private let materializer: () throws -> Expression
-    var body: Expression {
+    public let defaultLocals: UnsafeBufferPointer<Value>
+    private var _bodyStorage: InstructionSequence? = nil
+    private let materializer: () throws -> InstructionSequence
+    var body: InstructionSequence {
         mutating get throws {
             if let materialized = _bodyStorage {
                 return materialized
diff --git a/Sources/WasmKit/Types/Types.swift b/Sources/WasmKit/Types/Types.swift
index 2bf2a5a3..463f976e 100644
--- a/Sources/WasmKit/Types/Types.swift
+++ b/Sources/WasmKit/Types/Types.swift
@@ -9,15 +9,22 @@ public enum ResultType: Equatable {
     /// Empty result type
     case empty
 
-    func arity(typeSection: () -> [FunctionType]) -> (parameters: Int, results: Int) {
+    func arity(typeSection: [FunctionType]?) throws -> Instruction.BlockType {
         switch self {
         case .single:
-            return (0, 1)
+            return Instruction.BlockType(parameters: 0, results: 1)
         case .empty:
-            return (0, 0)
+            return Instruction.BlockType(parameters: 0, results: 0)
         case let .multi(typeIndex):
-            let funcType = typeSection()[Int(typeIndex)]
-            return (funcType.parameters.count, funcType.results.count)
+            let typeIndex = Int(typeIndex)
+            guard let typeSection, typeIndex < typeSection.count else {
+                throw WasmParserError.invalidTypeSectionReference
+            }
+            let funcType = typeSection[typeIndex]
+            return Instruction.BlockType(
+                parameters: UInt16(funcType.parameters.count),
+                results: UInt16(funcType.results.count)
+            )
         }
     }
 }
diff --git a/Tests/WasmKitTests/Execution/HostModuleTests.swift b/Tests/WasmKitTests/Execution/HostModuleTests.swift
index 456de681..a60ffecc 100644
--- a/Tests/WasmKitTests/Execution/HostModuleTests.swift
+++ b/Tests/WasmKitTests/Execution/HostModuleTests.swift
@@ -30,17 +30,21 @@ final class HostModuleTests: XCTestCase {
                 // [2] "foo"
                 GuestFunction(
                     type: 0, locals: [],
-                    body: [
-                        .control(.call(functionIndex: 0)),
-                        .control(.call(functionIndex: 0)),
-                        .control(.call(functionIndex: 0)),
-                    ]),
+                    body: {
+                        [
+                            .call(functionIndex: 0),
+                            .call(functionIndex: 0),
+                            .call(functionIndex: 0),
+                        ]
+                    }),
                 // [3] "bar"
                 GuestFunction(
                     type: 0, locals: [],
-                    body: [
-                        .control(.call(functionIndex: 1))
-                    ]),
+                    body: {
+                        [
+                            .control(.call(functionIndex: 1))
+                        ]
+                    }),
             ],
             imports: [
                 Import(module: "env", name: "bar", descriptor: .function(0)),
diff --git a/Tests/WasmKitTests/Execution/Instructions/ControlInstructionTests.swift b/Tests/WasmKitTests/Execution/Instructions/ControlInstructionTests.swift
deleted file mode 100644
index 06911433..00000000
--- a/Tests/WasmKitTests/Execution/Instructions/ControlInstructionTests.swift
+++ /dev/null
@@ -1,413 +0,0 @@
-import XCTest
-
-@testable import WasmKit
-
-final class ControlInstructionTests: XCTestCase {
-    func testUnreachable() {
-        let instruction = Instruction.control(.unreachable)
-        var execution = ExecutionState()
-        XCTAssertThrowsError(try execution.execute(instruction, runtime: Runtime())) { error in
-            guard case Trap.unreachable = error else {
-                return XCTFail("unknown error thrown: \(error)")
-            }
-        }
-    }
-
-    func testNop() throws {
-        let instruction = Instruction.control(.nop)
-        var execution = ExecutionState()
-        try execution.execute(instruction, runtime: Runtime())
-        XCTAssertEqual(execution.programCounter, 1)
-    }
-
-    func testBlock() throws {
-        let dummyExpression = Expression(instructions: [
-            .numeric(.const(.i32(42)))
-        ])
-
-        let instruction = Instruction.control(
-            .block(
-                expression: dummyExpression, type: .single(.i32)
-            )
-        )
-
-        var execution = ExecutionState()
-        try execution.execute(instruction, runtime: Runtime())
-
-        XCTAssertEqual(
-            execution.stack.top,
-            .label(.init(arity: 1, expression: dummyExpression, continuation: 1, exit: 1))
-        )
-        XCTAssertEqual(execution.programCounter, 0)
-    }
-
-    func testLoop() throws {
-        let dummyExpression = Expression(instructions: [
-            .numeric(.const(.i32(42)))
-        ])
-
-        let instruction = Instruction.control(
-            .loop(
-                expression: dummyExpression, type: .single(.i32)
-            )
-        )
-
-        var execution = ExecutionState()
-        try execution.execute(instruction, runtime: Runtime())
-        XCTAssertEqual(
-            execution.stack.top,
-            .label(.init(arity: 0, expression: dummyExpression, continuation: 0, exit: 1))
-        )
-        XCTAssertEqual(execution.programCounter, 0)
-    }
-
-    func testIf_true() throws {
-        let thenExpression = Expression(instructions: [
-            .numeric(.const(.i32(42)))
-        ])
-
-        let elseExpression = Expression(instructions: [
-            .control(.unreachable)
-        ])
-
-        let instruction = Instruction.control(
-            .if(
-                then: thenExpression,
-                else: elseExpression,
-                type: .single(.i32)
-            )
-        )
-
-        var execution = ExecutionState()
-        execution.stack.push(value: .i32(1))
-        try execution.execute(instruction, runtime: Runtime())
-
-        XCTAssertEqual(
-            execution.stack.top,
-            .label(.init(arity: 1, expression: thenExpression, continuation: 1, exit: 1))
-        )
-    }
-
-    func testIf_false() throws {
-        let thenExpression = Expression(instructions: [
-            .control(.unreachable)
-        ])
-
-        let elseExpression = Expression(instructions: [
-            .numeric(.const(.i32(42)))
-        ])
-
-        let instruction = Instruction.control(
-            .if(
-                then: thenExpression,
-                else: elseExpression,
-                type: .single(.i32)
-            )
-        )
-
-        var execution = ExecutionState()
-        let runtime = Runtime()
-        execution.stack.push(value: .i32(0))
-
-        try execution.execute(instruction, runtime: runtime)
-
-        XCTAssertEqual(
-            execution.stack.top,
-            .label(.init(arity: 1, expression: elseExpression, continuation: 1, exit: 1))
-        )
-    }
-
-    func testIf_noElse() throws {
-        let thenExpression = Expression(instructions: [
-            .control(.unreachable)
-        ])
-
-        let elseExpression = Expression(instructions: [])
-
-        let instruction = Instruction.control(
-            .if(
-                then: thenExpression,
-                else: elseExpression,
-                type: .single(.i32)
-            )
-        )
-
-        var execution = ExecutionState()
-        let runtime = Runtime()
-        execution.stack.push(value: .i32(0))
-
-        try execution.execute(instruction, runtime: runtime)
-
-        XCTAssertEqual(execution.stack.top, nil)
-
-        execution.stack.push(value: .i32(1))
-        execution.programCounter = 0
-
-        try execution.execute(instruction, runtime: runtime)
-
-        XCTAssertEqual(
-            execution.stack.top,
-            .label(.init(arity: 1, expression: thenExpression, continuation: 1, exit: 1))
-        )
-    }
-
-    func testIf_bareBreak() throws {
-        let expression1 = Expression(instructions: [
-            .numeric(.const(.i32(1))),
-            .control(
-                .if(
-                    then: [.control(.br(0))],
-                    else: [.control(.unreachable)],
-                    type: .empty
-                )),
-        ])
-
-        let module = Module(
-            types: [
-                FunctionType(parameters: [], results: [])
-            ],
-            functions: [
-                .init(type: 0, locals: [], body: expression1)
-            ]
-        )
-
-        var execution = ExecutionState()
-        let runtime = Runtime()
-        _ = try runtime.instantiate(module: module)
-
-        try execution.invoke(functionAddress: 0, runtime: runtime)
-
-        // Step a limited number of times to avoid infinite loops in case of test failure.
-        for _ in 0..<5 {
-            try execution.step(runtime: runtime)
-        }
-
-        XCTAssertEqual(execution.stack.elements, [])
-    }
-
-    func testElse() throws {
-        let instruction = Instruction.pseudo(.else)
-
-        var execution = ExecutionState()
-        XCTAssertThrowsError(try execution.execute(instruction, runtime: Runtime())) { error in
-            guard case Trap.unreachable = error else {
-                return XCTFail("unknown error thrown: \(error)")
-            }
-        }
-    }
-
-    func testEnd() {
-        let instruction = Instruction.pseudo(.end)
-
-        var execution = ExecutionState()
-        XCTAssertThrowsError(try execution.execute(instruction, runtime: Runtime())) { error in
-            guard case Trap.unreachable = error else {
-                return XCTFail("unknown error thrown: \(error)")
-            }
-        }
-    }
-
-    func testBr0() throws {
-        let instruction = Instruction.control(.br(0))
-        let arity0 = Label(arity: 0, expression: [instruction], continuation: 123, exit: 0)
-        var execution = ExecutionState()
-        let runtime = Runtime()
-        execution.stack.push(label: arity0)
-
-        try execution.execute(instruction, runtime: runtime)
-
-        XCTAssertNil(execution.stack.top)
-        XCTAssertEqual(execution.programCounter, 123)
-
-        let arity1 = Label(arity: 1, expression: [instruction], continuation: 321, exit: 0)
-        execution.stack.push(label: arity1)
-        execution.stack.push(value: .i32(42))
-        try execution.execute(instruction, runtime: runtime)
-
-        XCTAssertEqual(execution.stack.top, .value(.i32(42)))
-        XCTAssertEqual(execution.programCounter, 321)
-    }
-
-    func testBr1() throws {
-        let instruction = Instruction.control(.br(1))
-        let arity0 = Label(arity: 0, expression: [instruction], continuation: 123, exit: 0)
-        var execution = ExecutionState()
-        let runtime = Runtime()
-        execution.stack.push(label: arity0)
-        execution.stack.push(label: arity0)
-
-        try execution.execute(instruction, runtime: runtime)
-
-        XCTAssertNil(execution.stack.top)
-        XCTAssertEqual(execution.programCounter, 123)
-
-        let arity1 = Label(arity: 1, expression: [instruction], continuation: 321, exit: 0)
-        execution.stack.push(label: arity1)
-        execution.stack.push(label: arity1)
-        execution.stack.push(value: .i32(42))
-        try execution.execute(instruction, runtime: runtime)
-
-        XCTAssertEqual(execution.stack.top, .value(.i32(42)))
-        XCTAssertEqual(execution.programCounter, 321)
-    }
-
-    func testBrIf_true() throws {
-        let instruction = Instruction.control(.brIf(0))
-        let label = Label(arity: 0, expression: [instruction], continuation: 123, exit: 0)
-        var execution = ExecutionState()
-        let runtime = Runtime()
-        execution.stack.push(label: label)
-        execution.stack.push(value: .i32(1))
-        try execution.execute(instruction, runtime: runtime)
-
-        XCTAssertNil(execution.stack.top)
-        XCTAssertEqual(execution.programCounter, 123)
-
-        let arity1 = Label(arity: 1, expression: [instruction], continuation: 321, exit: 0)
-        execution.stack.push(label: arity1)
-        execution.stack.push(value: .i32(42))
-        execution.stack.push(value: .i32(1))
-        try execution.execute(instruction, runtime: runtime)
-
-        XCTAssertEqual(execution.stack.top, .value(.i32(42)))
-        XCTAssertEqual(execution.programCounter, 321)
-    }
-
-    func testBrIf_false() throws {
-        let instruction = Instruction.control(.brIf(0))
-        let label = Label(arity: 0, expression: [instruction], continuation: 123, exit: 0)
-        var execution = ExecutionState()
-        let runtime = Runtime()
-        execution.stack.push(label: label)
-        execution.stack.push(value: .i32(0))
-        try execution.execute(instruction, runtime: runtime)
-
-        XCTAssertEqual(execution.stack.top, .label(label))
-        XCTAssertEqual(execution.programCounter, 1)
-    }
-
-    func testCall() throws {
-        let func1Expression = Expression(instructions: [
-            .numeric(.const(.i32(42))),
-            .control(.call(functionIndex: 1)),
-            .numeric(.const(.i32(2))),
-            .numeric(.binary(.add(.int(.i32)))),
-        ])
-        let func2Expression = Expression(instructions: [
-            .variable(.localGet(index: 0)),
-            .numeric(.const(.i32(1))),
-            .numeric(.binary(.add(.int(.i32)))),
-        ])
-
-        let module = Module(
-            types: [
-                FunctionType(parameters: [], results: [.i32]),
-                FunctionType(parameters: [.i32], results: [.i32]),
-            ],
-            functions: [
-                .init(type: 0, locals: [], body: func1Expression),
-                .init(type: 1, locals: [], body: func2Expression),
-            ],
-            exports: [.init(name: "start", descriptor: .function(0))]
-        )
-
-        let runtime = Runtime()
-        let moduleInstance = try runtime.instantiate(module: module)
-
-        let results = try runtime.invoke(moduleInstance, function: "start", with: [])
-        XCTAssertEqual(results, [.i32(45)])
-    }
-
-    func testLoopBranch() throws {
-        let expression1 = Expression(instructions: [
-            .control(
-                .loop(
-                    expression: [
-                        .numeric(.const(.i32(0))),
-                        .control(.brIf(0)),
-                    ],
-                    type: .empty
-                ))
-        ])
-
-        let loopRange = 5
-        let loopRangeValue = Value.i32(.init(loopRange))
-
-        let expression2 = Expression(instructions: [
-            .control(
-                .loop(
-                    expression: [
-                        .numeric(.const(.i32(1))),
-                        .variable(.localGet(index: 0)),
-                        .numeric(.binary(.add(.int(.i32)))),
-                        .variable(.localTee(index: 0)),
-                        .numeric(.const(loopRangeValue)),
-                        .numeric(.intBinary(.ltU(.i32))),
-                        .control(.brIf(0)),
-                    ],
-                    type: .empty
-                )),
-            .variable(.localGet(index: 0)),
-        ])
-
-        let module = Module(
-            types: [
-                FunctionType(parameters: [], results: []),
-                FunctionType(parameters: [], results: [.i32]),
-            ],
-            functions: [
-                .init(type: 0, locals: [], body: expression1),
-                .init(type: 1, locals: [.i32], body: expression2),
-            ]
-        )
-
-        var execution = ExecutionState()
-        let runtime = Runtime()
-        _ = try runtime.instantiate(module: module)
-
-        try execution.invoke(functionAddress: 0, runtime: runtime)
-
-        // Step a limited number of times to avoid infinite loops in case of test failure.
-        for _ in 0..<6 {
-            try execution.step(runtime: runtime)
-        }
-
-        XCTAssertEqual(execution.stack.elements, [])
-
-        try execution.invoke(functionAddress: 1, runtime: runtime)
-
-        // Step a limited number of times to avoid infinite loops in case of test failure.
-        for _ in 0..<(loopRange * 8 + 4) {
-            try execution.step(runtime: runtime)
-        }
-
-        XCTAssertEqual(execution.stack.elements, [.value(loopRangeValue)])
-    }
-
-    func testI32Load8() throws {
-        var memory = MemoryInstance(.init(min: 1, max: nil))
-        memory.data[0..<3] = [97, 98, 99, 100]  // ASCII "abcd"
-        var execution = ExecutionState()
-        let runtime = Runtime()
-        runtime.store.memories.append(memory)
-
-        let module = ModuleInstance()
-        module.memoryAddresses = [0]
-
-        let frame = Frame(arity: 0, module: module, locals: [])
-        try execution.stack.push(frame: frame)
-        execution.stack.push(value: .i32(0))
-
-        let instruction = Instruction.memory(.load(.init(offset: 0, align: 1), bitWidth: 8, .i32, isSigned: false))
-
-        try execution.execute(instruction, runtime: runtime)
-        XCTAssertEqual(execution.programCounter, 1)
-        XCTAssertEqual(execution.stack.elements, [.frame(frame), .value(.i32(97))])
-    }
-}
-
-extension GuestFunction {
-    init(type: TypeIndex, locals: [ValueType], body: Expression) {
-        self.init(type: type, locals: locals, body: { body })
-    }
-}
diff --git a/Tests/WasmKitTests/Execution/Instructions/VariableInstructionTests.swift b/Tests/WasmKitTests/Execution/Instructions/VariableInstructionTests.swift
deleted file mode 100644
index 8c331ef3..00000000
--- a/Tests/WasmKitTests/Execution/Instructions/VariableInstructionTests.swift
+++ /dev/null
@@ -1,94 +0,0 @@
-import XCTest
-
-@testable import WasmKit
-
-final class VariableInstructionTests: XCTestCase {
-    func testLocalSet() throws {
-        let expression = Expression(instructions: [
-            .numeric(.const(.i32(42))),
-            .variable(.localSet(index: 0)),
-        ])
-
-        let module = Module(
-            types: [
-                FunctionType(parameters: [], results: [.i32])
-            ],
-            functions: [
-                .init(type: 0, locals: [.i32], body: expression)
-            ]
-        )
-
-        var execution = ExecutionState()
-        let runtime = Runtime()
-
-        _ = try runtime.instantiate(module: module)
-
-        try execution.invoke(functionAddress: 0, runtime: runtime)
-
-        try execution.step(runtime: runtime)
-        try execution.step(runtime: runtime)
-
-        XCTAssertEqual(execution.stack.top, .label(.init(arity: 1, expression: expression, continuation: 1, exit: 1)))
-        XCTAssertEqual(execution.stack.currentFrame.locals, [.i32(42)])
-    }
-
-    func testLocalGet() throws {
-        let module = Module(
-            types: [
-                FunctionType(parameters: [], results: [.i32])
-            ],
-            functions: [
-                .init(
-                    type: 0, locals: [.i32],
-                    body: [
-                        .numeric(.const(.i32(42))),
-                        .variable(.localSet(index: 0)),
-                        .variable(.localGet(index: 0)),
-                    ])
-            ]
-        )
-
-        var execution = ExecutionState()
-        let runtime = Runtime()
-
-        _ = try runtime.instantiate(module: module)
-
-        try execution.invoke(functionAddress: 0, runtime: runtime)
-
-        try execution.step(runtime: runtime)
-        try execution.step(runtime: runtime)
-        try execution.step(runtime: runtime)
-
-        XCTAssertEqual(execution.stack.top, .value(.i32(42)))
-        XCTAssertEqual(execution.stack.currentFrame.locals, [.i32(42)])
-    }
-
-    func testLocalTee() throws {
-        let module = Module(
-            types: [
-                FunctionType(parameters: [], results: [.i32])
-            ],
-            functions: [
-                .init(
-                    type: 0, locals: [.i32],
-                    body: [
-                        .numeric(.const(.i32(42))),
-                        .variable(.localTee(index: 0)),
-                    ])
-            ]
-        )
-
-        var execution = ExecutionState()
-        let runtime = Runtime()
-
-        _ = try runtime.instantiate(module: module)
-
-        try execution.invoke(functionAddress: 0, runtime: runtime)
-
-        try execution.step(runtime: runtime)
-        try execution.step(runtime: runtime)
-
-        XCTAssertEqual(execution.stack.top, .value(.i32(42)))
-        XCTAssertEqual(execution.stack.currentFrame.locals, [.i32(42)])
-    }
-}
diff --git a/Tests/WasmKitTests/Execution/StackTests.swift b/Tests/WasmKitTests/Execution/StackTests.swift
deleted file mode 100644
index 270e2149..00000000
--- a/Tests/WasmKitTests/Execution/StackTests.swift
+++ /dev/null
@@ -1,107 +0,0 @@
-import XCTest
-
-@testable import WasmKit
-
-final class StackTests: XCTestCase {
-    func testStack() throws {
-        var stack = Stack()
-        XCTAssertNil(stack.top)
-
-        let values = [UInt32](1...10)
-
-        for v in values {
-            stack.push(value: .i32(v))
-            let top = try XCTUnwrap(stack.top)
-            XCTAssertEqual(top, .value(.i32(v)))
-        }
-
-        let expected = values.reversed()
-        for v in expected {
-            XCTAssertEqual(try stack.popValue().i32, v)
-        }
-
-        XCTAssertNil(stack.top)
-    }
-
-    func testPushMultipleValues() {
-        var stack = Stack()
-        XCTAssertNil(stack.top)
-
-        let values = [UInt32](1...10).map { Value($0) }
-        stack.push(values: values)
-        XCTAssertEqual(stack.top, .value(.i32(10)))
-
-        XCTAssertEqual(stack.elements, values.map { Stack.Element.value($0) })
-    }
-
-    func testPopMultipleValues() throws {
-        var stack = Stack()
-        XCTAssertNil(stack.top)
-
-        let values = [UInt32](1...10).map { Value($0) }
-        stack.push(values: values)
-
-        XCTAssertEqual(try stack.popValues(count: 10), values)
-    }
-
-    func testPopTopValues() throws {
-        var stack = Stack()
-        XCTAssertNil(stack.top)
-
-        let frame = Frame(arity: 0, module: ModuleInstance(), locals: [])
-        try stack.push(frame: frame)
-        let values = [UInt32](1...10).map { Value($0) }
-        stack.push(values: values)
-
-        XCTAssertEqual(try stack.popTopValues(), values)
-        XCTAssertEqual(stack.top, .frame(frame))
-    }
-
-    func testPopFrame() throws {
-        var stack = Stack()
-        XCTAssertNil(stack.top)
-
-        let values = [UInt32](1...10).map { Value($0) }
-        stack.push(values: values)
-
-        let frame0 = Frame(arity: 0, module: .init(), locals: [])
-        try stack.push(frame: frame0)
-
-        stack.push(values: values)
-
-        let frame1 = Frame(arity: 1, module: .init(), locals: [])
-        try stack.push(frame: frame1)
-
-        XCTAssertEqual(stack.currentFrame, frame1)
-
-        try stack.popFrame()
-        XCTAssertEqual(stack.currentFrame, frame0)
-
-        stack.discardTopValues()
-        try stack.popFrame()
-        XCTAssertNil(stack.currentFrame)
-    }
-
-    func testPopLabel() throws {
-        var stack = Stack()
-        try stack.push(frame: .init(arity: 1, module: .init(), locals: []))
-        let label24 = Label(arity: 1, expression: [], continuation: 24, exit: 0)
-        stack.push(label: label24)
-        let label123 = Label(arity: 1, expression: [], continuation: 123, exit: 0)
-        stack.push(label: label123)
-
-        try stack.push(frame: .init(arity: 1, module: .init(), locals: []))
-        let label42 = Label(arity: 1, expression: [], continuation: 42, exit: 0)
-        stack.push(label: label42)
-        let label0 = Label(arity: 1, expression: [], continuation: 0, exit: 0)
-        stack.push(label: label0)
-
-        XCTAssertEqual(stack.currentLabel, label0)
-        _ = try stack.popLabel()
-        XCTAssertEqual(stack.currentLabel, label42)
-        _ = try stack.popLabel()
-        XCTAssertNil(stack.currentLabel)
-        try stack.popFrame()
-        XCTAssertEqual(stack.currentLabel, label123)
-    }
-}
diff --git a/Utilities/generate_inst_dispatch.swift b/Utilities/generate_inst_dispatch.swift
new file mode 100644
index 00000000..634fbbb7
--- /dev/null
+++ b/Utilities/generate_inst_dispatch.swift
@@ -0,0 +1,318 @@
+import Foundation
+
+struct Immediate {
+    let name: String?
+    let type: String
+}
+struct Instruction {
+    let name: String
+    let isControl: Bool
+    let mayThrow: Bool
+    let mayUpdateFrame: Bool
+    let hasLocals: Bool
+    let immediates: [Immediate]
+
+    init(name: String, isControl: Bool = false, mayThrow: Bool = false, mayUpdateFrame: Bool = false, hasLocals: Bool = false, immediates: [Immediate]) {
+        self.name = name
+        self.isControl = isControl
+        self.mayThrow = mayThrow
+        self.mayUpdateFrame = mayUpdateFrame
+        self.hasLocals = hasLocals
+        self.immediates = immediates
+        assert(isControl || !mayUpdateFrame, "non-control instruction should not update frame")
+    }
+}
+
+let intValueTypes = ["i32", "i64"]
+let valueTypes = intValueTypes + ["f32", "f64"]
+let numericBinaryInsts: [Instruction] = ["Add", "Sub", "Mul", "Eq", "Ne"].flatMap { op -> [Instruction] in
+    valueTypes.map { type in
+        Instruction(name: "\(type)\(op)", immediates: [])
+    }
+}
+let numericIntBinaryInsts: [Instruction] = ["LtS", "LtU", "GtS", "GtU", "LeS", "LeU", "GeS", "GeU"].flatMap { op -> [Instruction] in
+    intValueTypes.map { type in
+        Instruction(name: "\(type)\(op)", immediates: [])
+    }
+}
+
+let instructions = [
+    // Controls
+    Instruction(name: "unreachable", isControl: true, mayThrow: true, immediates: []),
+    Instruction(name: "nop", isControl: true, mayThrow: true, immediates: []),
+    Instruction(name: "block", isControl: true, immediates: [
+        Immediate(name: "endRef", type: "ExpressionRef"),
+        Immediate(name: "type", type: "BlockType")
+    ]),
+    Instruction(name: "loop", isControl: true, immediates: [
+        Immediate(name: "type", type: "BlockType")
+    ]),
+    Instruction(name: "ifThen", isControl: true, immediates: [
+        Immediate(name: "endRef", type: "ExpressionRef"),
+        Immediate(name: "type", type: "BlockType")
+    ]),
+    Instruction(name: "ifThenElse", isControl: true, immediates: [
+        Immediate(name: "elseRef", type: "ExpressionRef"),
+        Immediate(name: "endRef", type: "ExpressionRef"),
+        Immediate(name: "type", type: "BlockType")
+    ]),
+    Instruction(name: "end", isControl: true, immediates: []),
+    Instruction(name: "`else`", isControl: true, immediates: []),
+    // NOTE: A branch can unwind a frame by "br 0"
+    Instruction(name: "br", isControl: true, mayThrow: true, mayUpdateFrame: true, immediates: [
+        Immediate(name: "labelIndex", type: "LabelIndex")
+    ]),
+    Instruction(name: "brIf", isControl: true, mayThrow: true, mayUpdateFrame: true, immediates: [
+        Immediate(name: "labelIndex", type: "LabelIndex")
+    ]),
+    Instruction(name: "brTable", isControl: true, mayThrow: true, mayUpdateFrame: true, immediates: [
+        Immediate(name: nil, type: "BrTable"),
+    ]),
+    Instruction(name: "`return`", isControl: true, mayThrow: true, mayUpdateFrame: true, immediates: []),
+    Instruction(name: "call", isControl: true, mayThrow: true, mayUpdateFrame: true, immediates: [
+        Immediate(name: "functionIndex", type: "UInt32")
+    ]),
+    Instruction(name: "callIndirect", isControl: true, mayThrow: true, mayUpdateFrame: true, immediates: [
+        Immediate(name: "tableIndex", type: "TableIndex"),
+        Immediate(name: "typeIndex", type: "TypeIndex")
+    ]),
+    Instruction(name: "endOfFunction", isControl: true, mayThrow: true, mayUpdateFrame: true, immediates: []),
+    Instruction(name: "endOfExecution", isControl: true, mayThrow: true, mayUpdateFrame: true, immediates: []),
+]
+// Memory
++ [
+        "i32Load",
+        "i64Load",
+        "f32Load",
+        "f64Load",
+        "i32Load8S",
+        "i32Load8U",
+        "i32Load16S",
+        "i32Load16U",
+        "i64Load8S",
+        "i64Load8U",
+        "i64Load16S",
+        "i64Load16U",
+        "i64Load32S",
+        "i64Load32U",
+        "i32Store",
+        "i64Store",
+        "f32Store",
+        "f64Store",
+        "i32Store8",
+        "i32Store16",
+        "i64Store8",
+        "i64Store16",
+        "i64Store32",
+    ].map {
+        Instruction(name: $0, mayThrow: true, immediates: [Immediate(name: "memarg", type: "Memarg")])
+    }
++ [
+    Instruction(name: "memorySize", immediates: []),
+    Instruction(name: "memoryGrow", mayThrow: true, immediates: []),
+    Instruction(name: "memoryInit", mayThrow: true, immediates: [Immediate(name: nil, type: "DataIndex")]),
+    Instruction(name: "memoryDataDrop", immediates: [Immediate(name: nil, type: "DataIndex")]),
+    Instruction(name: "memoryCopy", mayThrow: true, immediates: []),
+    Instruction(name: "memoryFill", mayThrow: true, immediates: []),
+    // Numeric
+    Instruction(name: "numericConst", immediates: [Immediate(name: nil, type: "Value")]),
+    Instruction(name: "numericIntUnary", immediates: [Immediate(name: nil, type: "NumericInstruction.IntUnary")]),
+    Instruction(name: "numericFloatUnary", immediates: [Immediate(name: nil, type: "NumericInstruction.FloatUnary")]),
+    Instruction(name: "numericIntBinary", mayThrow: true, immediates: [Immediate(name: nil, type: "NumericInstruction.IntBinary")]),
+    Instruction(name: "numericFloatBinary", immediates: [Immediate(name: nil, type: "NumericInstruction.FloatBinary")]),
+    Instruction(name: "numericConversion", mayThrow: true, immediates: [Immediate(name: nil, type: "NumericInstruction.Conversion")]),
+]
++ numericBinaryInsts
++ numericIntBinaryInsts
++ [
+    // Parametric
+    Instruction(name: "drop", immediates: []),
+    Instruction(name: "select", mayThrow: true, immediates: []),
+    // Reference
+    Instruction(name: "refNull", immediates: [Immediate(name: nil, type: "ReferenceType")]),
+    Instruction(name: "refIsNull", immediates: []),
+    Instruction(name: "refFunc", immediates: [Immediate(name: nil, type: "FunctionIndex")]),
+    // Table
+    Instruction(name: "tableGet", mayThrow: true, immediates: [Immediate(name: nil, type: "TableIndex")]),
+    Instruction(name: "tableSet", mayThrow: true, immediates: [Immediate(name: nil, type: "TableIndex")]),
+    Instruction(name: "tableSize", immediates: [Immediate(name: nil, type: "TableIndex")]),
+    Instruction(name: "tableGrow", immediates: [Immediate(name: nil, type: "TableIndex")]),
+    Instruction(name: "tableFill", mayThrow: true, immediates: [Immediate(name: nil, type: "TableIndex")]),
+    Instruction(name: "tableCopy", mayThrow: true, immediates: [Immediate(name: "dest", type: "TableIndex"), Immediate(name: "src", type: "TableIndex")]),
+    Instruction(name: "tableInit", mayThrow: true, immediates: [Immediate(name: nil, type: "TableIndex"), Immediate(name: nil, type: "ElementIndex")]),
+    Instruction(name: "tableElementDrop", immediates: [Immediate(name: nil, type: "ElementIndex")]),
+    // Variable
+    Instruction(name: "localGet", hasLocals: true, immediates: [Immediate(name: "index", type: "LocalIndex")]),
+    Instruction(name: "localSet", hasLocals: true, immediates: [Immediate(name: "index", type: "LocalIndex")]),
+    Instruction(name: "localTee", hasLocals: true, immediates: [Immediate(name: "index", type: "LocalIndex")]),
+    Instruction(name: "globalGet", mayThrow: true, immediates: [Immediate(name: "index", type: "GlobalIndex")]),
+    Instruction(name: "globalSet", mayThrow: true, immediates: [Immediate(name: "index", type: "GlobalIndex")]),
+]
+
+func camelCase(pascalCase: String) -> String {
+    let first = pascalCase.first!.lowercased()
+    return first + pascalCase.dropFirst()
+}
+
+func generateDispatcher(instructions: [Instruction]) -> String {
+    var output = """
+    extension ExecutionState {
+        @inline(__always)
+        mutating func doExecute(_ instruction: Instruction, runtime: Runtime, locals: UnsafeMutablePointer<Value>) throws -> Bool {
+            switch instruction {
+    """
+
+    for inst in instructions {
+        let tryPrefix = inst.mayThrow ? "try " : ""
+        let labels = inst.immediates.map {
+            $0.name ?? camelCase(pascalCase: String($0.type.split(separator: ".").last!))
+        }
+        let args = (["runtime"] + (inst.hasLocals ? ["locals"] : []) + labels).map { "\($0): \($0)" }
+        if inst.immediates.isEmpty {
+            output += """
+
+                    case .\(inst.name):
+            """
+        } else {
+            let labels = inst.immediates.map {
+                $0.name ?? camelCase(pascalCase: String($0.type.split(separator: ".").last!))
+            }
+            output += """
+
+                    case .\(inst.name)(\(labels.map { "let \($0)" }.joined(separator: ", "))):
+            """
+        }
+        output += """
+
+                    \(tryPrefix)self.\(inst.name)(\(args.joined(separator: ", ")))
+        """
+        if inst.isControl {
+            output += """
+
+                        return \(!inst.mayUpdateFrame)
+            """
+        }
+    }
+    output += """
+
+            }
+            programCounter += 1
+            return true
+        }
+    }
+    """
+    return output
+}
+
+func generatePrototype(instructions: [Instruction]) -> String {
+    var output = """
+
+    extension ExecutionState {
+    """
+    for inst in instructions {
+        let throwsKwd = inst.mayThrow ? " throws" : ""
+        if inst.immediates.isEmpty {
+            output += """
+
+            mutating func \(inst.name)(runtime: Runtime)\(throwsKwd) {
+                fatalError("Unimplemented instruction: \(inst.name)")
+            }
+        """
+        } else {
+            let labelTypes = inst.immediates.map {
+                let label = $0.name ?? camelCase(pascalCase: String($0.type.split(separator: ".").last!))
+                return (label, $0.type)
+            }
+            output += """
+
+            mutating func \(inst.name)(runtime: Runtime, \(labelTypes.map { "\($0): \($1)" }.joined(separator: ", ")))\(throwsKwd) {
+                fatalError("Unimplemented instruction: \(inst.name)")
+            }
+        """
+        }
+    }
+    output += """
+
+    }
+
+    """
+    return output
+}
+
+func generateInstName(instructions: [Instruction]) -> String {
+    var output = """
+    extension Instruction {
+        var name: String {
+            switch self {
+    """
+    for inst in instructions {
+        output += """
+
+                case .\(inst.name): return "\(inst.name)"
+        """
+    }
+    output += """
+
+            }
+        }
+    }
+
+    """
+    return output
+}
+
+func generateEnumDefinition(instructions: [Instruction]) -> String {
+    var output = "enum Instruction: Equatable {\n"
+    for inst in instructions {
+        output += "    case \(inst.name)"
+        if !inst.immediates.isEmpty {
+            output += "("
+            output += inst.immediates.map { immediate in
+                if let name = immediate.name {
+                    return name + ": " + immediate.type
+                } else {
+                    return immediate.type
+                }
+            }.joined(separator: ", ")
+            output += ")"
+        }
+        output += "\n"
+    }
+    output += "}\n"
+    return output
+}
+
+func main(arguments: [String]) throws {
+    let sourceRoot = URL(fileURLWithPath: #filePath).deletingLastPathComponent().deletingLastPathComponent()
+
+    if arguments.count > 1 {
+        switch arguments[1] {
+        case "prototype":
+            print(generatePrototype(instructions: instructions))
+            return
+        default: break
+        }
+    }
+
+    do {
+        var output = """
+        // This file is generated by Utilities/generate_inst_dispatch.swift
+
+        """
+
+        output += generateDispatcher(instructions: instructions)
+        output += "\n\n"
+        output += generateInstName(instructions: instructions)
+
+        let outputFile = sourceRoot.appending(path: "Sources/WasmKit/Execution/Runtime/InstDispatch.swift")
+        try output.write(to: outputFile, atomically: true, encoding: .utf8)
+    }
+
+    do {
+        let outputFile = sourceRoot.appending(path: "Sources/WasmKit/Execution/Instructions/Instruction.swift")
+        let output = generateEnumDefinition(instructions: instructions)
+        try output.write(to: outputFile, atomically: true, encoding: .utf8)
+    }
+}
+
+try main(arguments: CommandLine.arguments)