diff --git a/build.rs b/build.rs
index 9d35be07..1e3b695e 100644
--- a/build.rs
+++ b/build.rs
@@ -1,8 +1,8 @@
-use convert_case::{Case, Casing};
 use std::collections::HashSet;
-use std::env;
-use std::fs;
 use std::path::Path;
+use std::{env, fs};
+
+use convert_case::{Case, Casing};
 
 // I hate to admit this, but a fair bit of this file was written by chatgpt to speed things up
 // and to allow me to continue to procrastinate about learning how to do i/o stuff in rust.
diff --git a/enum-field-getter/src/lib.rs b/enum-field-getter/src/lib.rs
index 637dc7e5..b5f6b9cc 100644
--- a/enum-field-getter/src/lib.rs
+++ b/enum-field-getter/src/lib.rs
@@ -1,12 +1,12 @@
 #![doc = include_str!("../README.md")]
 
+use std::collections::{HashMap, HashSet};
+
 use proc_macro::TokenStream;
 use proc_macro_error::{abort_call_site, emit_warning, proc_macro_error};
 use quote::{format_ident, quote};
 use syn::{parse_macro_input, Data, DeriveInput, Fields, Type};
 
-use std::collections::{HashMap, HashSet};
-
 /// See top-level crate documentation.
 #[proc_macro_error]
 #[proc_macro_derive(EnumFieldGetter)]
@@ -25,29 +25,45 @@ pub fn enum_field_getter(stream: TokenStream) -> TokenStream {
                     let ident = field.ident.clone().unwrap().to_string();
                     let field_ty = field.ty.clone();
                     let df = (field_ty.clone(), vec![variant.ident.to_string()]);
-                    field_info.entry(ident.clone()).and_modify(|info| {
-                        let (ty, used_variants) = info;
-                        if quote!{#field_ty}.to_string() != quote!{#ty}.to_string() {
-                            emit_warning!(field, "fields must be the same type across all variants - no getter will be emitted for this field");
-                            incompatible.insert(ident.clone());
-                        } else {
-                            used_variants.push(variant.ident.to_string());
-                        }
-                    }).or_insert(df);
+                    field_info
+                        .entry(ident.clone())
+                        .and_modify(|info| {
+                            let (ty, used_variants) = info;
+                            if quote! {#field_ty}.to_string() != quote! {#ty}.to_string() {
+                                emit_warning!(
+                                    field,
+                                    "fields must be the same type across all variants - no getter \
+                                     will be emitted for this field"
+                                );
+                                incompatible.insert(ident.clone());
+                            } else {
+                                used_variants.push(variant.ident.to_string());
+                            }
+                        })
+                        .or_insert(df);
                 }
             } else if let Fields::Unnamed(_) = variant.fields {
                 for (i, field) in variant.fields.iter().enumerate() {
                     let field_ty = field.ty.clone();
                     let df = (field_ty.clone(), vec![variant.ident.to_string()]);
-                    tuple_field_info.entry(i).and_modify(|info| {
-                        let (ty, used_variants) = info;
-                        if quote!{#field_ty}.to_string() != quote!{#ty}.to_string() {
-                            emit_warning!(field, "Fields must be the same type across all variants - no getter will be emitted for this field.\nExpected type {}, got {}.", quote!{#ty}.to_string(), quote!{#field_ty}.to_string());
-                            tuple_incompatible.insert(i);
-                        } else {
-                            used_variants.push(variant.ident.to_string());
-                        }
-                    }).or_insert(df);
+                    tuple_field_info
+                        .entry(i)
+                        .and_modify(|info| {
+                            let (ty, used_variants) = info;
+                            if quote! {#field_ty}.to_string() != quote! {#ty}.to_string() {
+                                emit_warning!(
+                                    field,
+                                    "Fields must be the same type across all variants - no getter \
+                                     will be emitted for this field.\nExpected type {}, got {}.",
+                                    quote! {#ty}.to_string(),
+                                    quote! {#field_ty}.to_string()
+                                );
+                                tuple_incompatible.insert(i);
+                            } else {
+                                used_variants.push(variant.ident.to_string());
+                            }
+                        })
+                        .or_insert(df);
                 }
             }
         }
diff --git a/playground/components/ProjectIdPlayer.vue b/playground/components/ProjectIdPlayer.vue
index 66ba4504..20c866c7 100644
--- a/playground/components/ProjectIdPlayer.vue
+++ b/playground/components/ProjectIdPlayer.vue
@@ -7,7 +7,7 @@
     :title="title"
     :instructions="instructions"
     :description="description"
-    :zip="null"
+    :zip="zip"
   ></ProjectPlayer>
   <template v-else>
     <h1>Project not found</h1>
@@ -21,12 +21,14 @@
 </template>
 
 <script setup>
+import { unpackProject } from "../lib/project-loader";
 import ProjectPlayer from "./ProjectPlayer.vue";
-import { ref } from "vue";
+import { ref, nextTick } from "vue";
 
 const props = defineProps(["id"]);
 const success = ref(null);
 const json = ref("");
+const zip = ref("");
 const title = ref("");
 const author = ref("");
 const instructions = ref("");
@@ -39,14 +41,16 @@ try {
   author.value = apiRes.author.username;
   instructions.value = apiRes.instructions;
   description.value = apiRes.description;
-  json.value = await fetch(
-    `https://projects.scratch.mit.edu/${props.id}/?token=${apiRes.project_token}`,
-  ).then((res) => {
-    if (!res.ok) {
-      throw new Error("response was not OK");
-    }
-    return res.json();
-  });
+  const res = await fetch(
+    `https://projects.scratch.mit.edu/${props.id}?token=${apiRes.project_token}`,
+  );
+  if (!res.ok) {
+    throw new Error("response was not OK");
+  }
+  const [_json, _zip] = await unpackProject(await res.arrayBuffer());
+  console.log(json);
+  zip.value = _zip;
+  json.value = _json;
   success.value = true;
 } catch (e) {
   success.value = e;
diff --git a/playground/components/ProjectPlayer.vue b/playground/components/ProjectPlayer.vue
index 5771f160..677b74cd 100644
--- a/playground/components/ProjectPlayer.vue
+++ b/playground/components/ProjectPlayer.vue
@@ -113,6 +113,8 @@ onMounted(async () => {
   let assets = null;
   let wasmProject;
 
+  console.log(props);
+
   try {
     // we need to convert settings to and from a JsValue because the WasmFlags exported from the
     // no-compiler version is not the same as that exported by the compiler... because reasons
diff --git a/playground/lib/project-loader.js b/playground/lib/project-loader.js
index 544f60a1..5741dc8c 100644
--- a/playground/lib/project-loader.js
+++ b/playground/lib/project-loader.js
@@ -10,6 +10,7 @@ export const unpackProject = (input) => {
   if (typeof input !== "string") {
     input = Buffer.from(input);
   }
+  console.log(input);
   return new Promise((resolve, reject) => {
     // The second argument of false below indicates to the validator that the
     // input should be parsed/validated as an entire project (and not a single sprite)
@@ -39,6 +40,7 @@ export const unpackProject = (input) => {
       return Promise.reject(error);
     })
     .then(async ([json, zip]) => {
+      console.log(Object.keys(json), json.projectVersion);
       if (json.projectVersion === 3) {
         return [json, zip];
       }
diff --git a/playground/lib/project-runner.js b/playground/lib/project-runner.js
index 9f3716e7..99b99f54 100644
--- a/playground/lib/project-runner.js
+++ b/playground/lib/project-runner.js
@@ -155,6 +155,7 @@ export async function instantiateProject({
     requests_refresh,
     threads,
     unreachable_dbg,
+    sensing_timer,
   } = instance.exports;
   if (typeof window === "object") {
     window.memory = memory;
@@ -180,11 +181,17 @@ export async function instantiateProject({
     renderer.draw();
 
     let startTime = Date.now();
+    let previousTickStartTime = startTime;
     $outertickloop: while (running) {
       if (timeout && Date.now() - startTime > timeout) {
         return onTimeout();
       }
       let thisTickStartTime = Date.now();
+      if (typeof sensing_timer !== "undefined") {
+        sensing_timer.value +=
+          (thisTickStartTime - previousTickStartTime) / 1000;
+      }
+      previousTickStartTime = thisTickStartTime;
       do {
         tick();
         if (threads_count.value === 0) {
@@ -213,6 +220,9 @@ export async function instantiateProject({
   return {
     greenFlag: () => {
       console.log("green flag clicked");
+      if (typeof sensing_timer !== "undefined") {
+        sensing_timer.value = 0.0;
+      }
       flag_clicked();
       run();
     },
diff --git a/playground/views/HomeView.vue b/playground/views/HomeView.vue
index b3ef21c1..9a75067f 100644
--- a/playground/views/HomeView.vue
+++ b/playground/views/HomeView.vue
@@ -110,6 +110,10 @@ li.block-category-control {
   color: #ffab19;
 }
 
+li.block-category-event {
+  color: #ffbf00;
+}
+
 li.block-category-pen {
   color: #0fbd8c;
 }
diff --git a/rustfmt.toml b/rustfmt.toml
index a5e1c6cd..b637feb0 100644
--- a/rustfmt.toml
+++ b/rustfmt.toml
@@ -1 +1,4 @@
-unstable_features = true
\ No newline at end of file
+unstable_features = true
+format_strings = true
+imports_granularity = "Module"
+group_imports = "StdExternalCrate"
\ No newline at end of file
diff --git a/src/error.rs b/src/error.rs
index 08b8c5c5..18210a82 100644
--- a/src/error.rs
+++ b/src/error.rs
@@ -1,6 +1,6 @@
+use alloc::boxed::Box;
 use core::cell::{BorrowError, BorrowMutError};
 
-use alloc::boxed::Box;
 use wasm_bindgen::JsValue;
 
 pub type HQResult<T> = Result<T, HQError>;
diff --git a/src/instructions.rs b/src/instructions.rs
index fbd1bc0f..7ffac82c 100644
--- a/src/instructions.rs
+++ b/src/instructions.rs
@@ -3,18 +3,21 @@
 
 #![allow(
     clippy::unnecessary_wraps,
-    reason = "many functions here needlessly return `Result`s in order to keep type signatures consistent"
+    reason = "many functions here needlessly return `Result`s in order to keep type signatures \
+              consistent"
 )]
 #![allow(
     clippy::needless_pass_by_value,
     reason = "there are so many `Rc<T>`s here which I don't want to change"
 )]
 
+use crate::ir::Step;
 pub use crate::optimisation::{ConstFold, ConstFoldItem, ConstFoldState};
 use crate::prelude::*;
 
 mod control;
 mod data;
+mod event;
 mod hq;
 mod looks;
 mod motion;
@@ -98,10 +101,55 @@ where
 
 include!(concat!(env!("OUT_DIR"), "/ir-opcodes.rs"));
 
-pub mod input_switcher;
-pub use input_switcher::wrap_instruction;
+impl IrOpcode {
+    pub fn yields_to_next_step(&self) -> Option<Rc<Step>> {
+        #[expect(
+            clippy::wildcard_enum_match_arm,
+            reason = "too many variants to match explicitly"
+        )]
+        match self {
+            Self::hq_yield(HqYieldFields {
+                mode: YieldMode::Schedule(next_step),
+            }) => Weak::upgrade(next_step),
+            Self::event_broadcast_and_wait(EventBroadcastAndWaitFields { next_step, .. })
+            | Self::procedures_call_nonwarp(ProceduresCallNonwarpFields { next_step, .. })
+            | Self::control_wait(ControlWaitFields { next_step, .. }) => Some(Rc::clone(next_step)),
+            _ => None,
+        }
+    }
+
+    pub fn inline_steps(&self) -> Option<Box<[Rc<Step>]>> {
+        #[expect(
+            clippy::wildcard_enum_match_arm,
+            reason = "too many variants to match explicitly"
+        )]
+        match self {
+            Self::hq_yield(HqYieldFields {
+                mode: YieldMode::Inline(inline_step),
+            }) => Some(Box::from([Rc::clone(inline_step)])),
+            Self::control_if_else(ControlIfElseFields {
+                branch_if,
+                branch_else,
+            }) => Some(Box::from([Rc::clone(branch_if), Rc::clone(branch_else)])),
+            Self::control_loop(ControlLoopFields {
+                first_condition,
+                condition,
+                body,
+                ..
+            }) => Some(
+                [first_condition.as_ref(), Some(condition), Some(body)]
+                    .into_iter()
+                    .filter_map(Option::<&_>::cloned)
+                    .collect(),
+            ),
+            _ => None,
+        }
+    }
+}
 
+pub mod input_switcher;
 pub use hq::r#yield::YieldMode;
+pub use input_switcher::wrap_instruction;
 
 /// Canonical NaN + bit 33, + string pointer in bits 1-32
 pub const BOXED_STRING_PATTERN: i64 = 0x7FF8_0001 << 32;
@@ -114,11 +162,6 @@ pub const BOXED_COLOR_RGB_PATTERN: i64 = 0x7ff8_0008 << 32;
 /// Canonical NaN + bit 37, + i32 in bits 1-32
 pub const BOXED_COLOR_ARGB_PATTERN: i64 = 0x7ff8_000f << 32;
 mod prelude {
-    pub use crate::ir::{ReturnType, Type as IrType};
-    pub use crate::optimisation::{ConstFold, ConstFoldItem, ConstFoldState};
-    pub use crate::prelude::*;
-    pub use crate::sb3::VarVal;
-    pub use crate::wasm::{InternalInstruction, StepFunc};
     pub use ConstFold::NotFoldable;
     pub use ReturnType::{MultiValue, Singleton};
     pub use wasm_encoder::{RefType, ValType};
@@ -128,4 +171,9 @@ mod prelude {
         BOXED_BOOL_PATTERN, BOXED_COLOR_ARGB_PATTERN, BOXED_COLOR_RGB_PATTERN, BOXED_INT_PATTERN,
         BOXED_STRING_PATTERN,
     };
+    pub use crate::ir::{ReturnType, Type as IrType};
+    pub use crate::optimisation::{ConstFold, ConstFoldItem, ConstFoldState};
+    pub use crate::prelude::*;
+    pub use crate::sb3::VarVal;
+    pub use crate::wasm::{InternalInstruction, StepFunc};
 }
diff --git a/src/instructions/control.rs b/src/instructions/control.rs
index cf906933..884a31ab 100644
--- a/src/instructions/control.rs
+++ b/src/instructions/control.rs
@@ -1,2 +1,4 @@
+pub mod get_thread_timeout;
 pub mod if_else;
 pub mod r#loop;
+pub mod wait;
diff --git a/src/instructions/control/get_thread_timeout.rs b/src/instructions/control/get_thread_timeout.rs
new file mode 100644
index 00000000..1f8a426f
--- /dev/null
+++ b/src/instructions/control/get_thread_timeout.rs
@@ -0,0 +1,36 @@
+use wasm_encoder::{FieldType, HeapType, StorageType};
+
+use super::super::prelude::*;
+
+pub fn wasm(func: &StepFunc, _inputs: Rc<[IrType]>) -> HQResult<Vec<InternalInstruction>> {
+    let struct_type_index = func.registries().types().struct_(vec![FieldType {
+        element_type: StorageType::Val(ValType::F64),
+        mutable: false,
+    }])?;
+
+    Ok(wasm![
+        LocalGet(1),
+        RefCastNonNull(HeapType::Concrete(struct_type_index)),
+        StructGet {
+            struct_type_index,
+            field_index: 0
+        }
+    ])
+}
+
+pub fn acceptable_inputs() -> HQResult<Rc<[IrType]>> {
+    Ok(Rc::from([]))
+}
+
+pub fn output_type(_inputs: Rc<[IrType]>) -> HQResult<ReturnType> {
+    Ok(Singleton(IrType::FloatPos))
+}
+
+pub const REQUESTS_SCREEN_REFRESH: bool = false;
+
+pub const fn const_fold(
+    _inputs: &[ConstFoldItem],
+    _state: &mut ConstFoldState,
+) -> HQResult<ConstFold> {
+    Ok(NotFoldable)
+}
diff --git a/src/instructions/control/if_else.rs b/src/instructions/control/if_else.rs
index abb7a7bb..7efaa224 100644
--- a/src/instructions/control/if_else.rs
+++ b/src/instructions/control/if_else.rs
@@ -1,6 +1,7 @@
+use wasm_encoder::BlockType;
+
 use super::super::prelude::*;
 use crate::ir::Step;
-use wasm_encoder::BlockType;
 
 #[derive(Debug)]
 pub struct Fields {
diff --git a/src/instructions/control/loop.rs b/src/instructions/control/loop.rs
index 0b5ecc3d..8e1cef6c 100644
--- a/src/instructions/control/loop.rs
+++ b/src/instructions/control/loop.rs
@@ -1,8 +1,9 @@
 // for use in warped contexts only.
 
+use wasm_encoder::BlockType;
+
 use super::super::prelude::*;
 use crate::ir::Step;
-use wasm_encoder::BlockType;
 
 #[derive(Debug)]
 pub struct Fields {
diff --git a/src/instructions/control/wait.rs b/src/instructions/control/wait.rs
new file mode 100644
index 00000000..2d6a67b8
--- /dev/null
+++ b/src/instructions/control/wait.rs
@@ -0,0 +1,104 @@
+use wasm_encoder::{AbstractHeapType, ConstExpr, FieldType, HeapType, StorageType};
+
+use super::super::prelude::*;
+use crate::ir::Step;
+use crate::wasm::registries::functions::static_functions::SpawnThreadInStack;
+use crate::wasm::{GlobalExportable, GlobalMutable, StepFunc};
+
+#[derive(Clone, Debug)]
+pub struct Fields {
+    pub poll_step: Rc<Step>,
+    pub next_step: Rc<Step>,
+}
+
+impl fmt::Display for Fields {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(
+            f,
+            r#"{{
+        "poll_step": {},
+        "next_step": {}
+    }}"#,
+            self.poll_step, self.next_step,
+        )
+    }
+}
+
+pub fn wasm(
+    func: &StepFunc,
+    inputs: Rc<[IrType]>,
+    Fields {
+        poll_step,
+        next_step,
+    }: &Fields,
+) -> HQResult<Vec<InternalInstruction>> {
+    let t1 = inputs[0];
+
+    let spawn_thread_in_stack_func = func
+        .registries()
+        .static_functions()
+        .register::<SpawnThreadInStack, _>()?;
+
+    let struct_type = func.registries().types().struct_(vec![FieldType {
+        element_type: StorageType::Val(ValType::F64),
+        mutable: false,
+    }])?;
+
+    let struct_local = func.local(ValType::Ref(RefType {
+        nullable: false,
+        heap_type: HeapType::Concrete(struct_type),
+    }))?;
+
+    let timer_global_index = func.registries().globals().register(
+        "sensing_timer".into(),
+        (
+            ValType::F64,
+            ConstExpr::f64_const(0.0.into()),
+            GlobalMutable(true),
+            GlobalExportable(true),
+        ),
+    )?;
+
+    Ok(
+        if t1.contains(IrType::FloatNeg) {
+            wasm![
+                F64Abs,
+            ]
+        } else {
+            vec![]
+        }
+        .into_iter()
+        .chain(
+            wasm![
+                #LazyGlobalGet(timer_global_index),
+                F64Add,
+                StructNew(struct_type),
+                LocalSet(struct_local),
+                LocalGet((func.params().len() - 2).try_into().map_err(|_| make_hq_bug!("local index out of bounds"))?),
+                #LazyStepRef(Rc::downgrade(poll_step)),
+                LocalGet(struct_local),
+                RefCastNullable(HeapType::Abstract { shared: false, ty: AbstractHeapType::Struct }),
+                #LazyStepRef(Rc::downgrade(next_step)),
+                #StaticFunctionCall(spawn_thread_in_stack_func),
+            ]
+        ).collect()
+    )
+}
+
+pub fn acceptable_inputs(_fields: &Fields) -> HQResult<Rc<[IrType]>> {
+    Ok(Rc::from([IrType::Float]))
+}
+
+pub fn output_type(_inputs: Rc<[IrType]>, _fields: &Fields) -> HQResult<ReturnType> {
+    Ok(ReturnType::None)
+}
+
+pub const REQUESTS_SCREEN_REFRESH: bool = false;
+
+pub const fn const_fold(
+    _inputs: &[ConstFoldItem],
+    _state: &mut ConstFoldState,
+    _fields: &Fields,
+) -> HQResult<ConstFold> {
+    Ok(NotFoldable)
+}
diff --git a/src/instructions/data/addtolist.rs b/src/instructions/data/addtolist.rs
index ac60466c..58dd098e 100644
--- a/src/instructions/data/addtolist.rs
+++ b/src/instructions/data/addtolist.rs
@@ -1,9 +1,9 @@
+use wasm_encoder::BlockType as WasmBlockType;
+
 use super::super::prelude::*;
 use crate::ir::RcList;
 use crate::wasm::WasmProject;
 
-use wasm_encoder::BlockType as WasmBlockType;
-
 /// we need these fields to be mutable for optimisations to be feasible
 #[derive(Debug, Clone)]
 pub struct Fields {
diff --git a/src/instructions/data/deleteoflist.rs b/src/instructions/data/deleteoflist.rs
index 0f1566b4..7029d019 100644
--- a/src/instructions/data/deleteoflist.rs
+++ b/src/instructions/data/deleteoflist.rs
@@ -1,8 +1,8 @@
+use wasm_encoder::BlockType as WasmBlockType;
+
 use super::super::prelude::*;
 use crate::ir::RcList;
 
-use wasm_encoder::BlockType as WasmBlockType;
-
 /// we need these fields to be mutable for optimisations to be feasible
 #[derive(Debug, Clone)]
 pub struct Fields {
diff --git a/src/instructions/data/insertatlist.rs b/src/instructions/data/insertatlist.rs
index 7ae2bee1..d18cea68 100644
--- a/src/instructions/data/insertatlist.rs
+++ b/src/instructions/data/insertatlist.rs
@@ -1,9 +1,9 @@
+use wasm_encoder::BlockType as WasmBlockType;
+
 use super::super::prelude::*;
 use crate::ir::RcList;
 use crate::wasm::WasmProject;
 
-use wasm_encoder::BlockType as WasmBlockType;
-
 /// we need these fields to be mutable for optimisations to be feasible
 #[derive(Debug, Clone)]
 pub struct Fields {
diff --git a/src/instructions/data/itemoflist.rs b/src/instructions/data/itemoflist.rs
index 63ddd9f4..59a28f92 100644
--- a/src/instructions/data/itemoflist.rs
+++ b/src/instructions/data/itemoflist.rs
@@ -1,9 +1,9 @@
+use wasm_encoder::BlockType as WasmBlockType;
+
 use super::super::prelude::*;
 use crate::ir::RcList;
 use crate::wasm::WasmProject;
 
-use wasm_encoder::BlockType as WasmBlockType;
-
 /// we need these fields to be mutable for optimisations to be feasible
 #[derive(Debug, Clone)]
 pub struct Fields {
diff --git a/src/instructions/data/listcontents.rs b/src/instructions/data/listcontents.rs
index 1221783f..885b7638 100644
--- a/src/instructions/data/listcontents.rs
+++ b/src/instructions/data/listcontents.rs
@@ -1,9 +1,9 @@
+use wasm_encoder::{BlockType as WasmBlockType, HeapType};
+
 use super::super::prelude::*;
 use crate::ir::RcList;
 use crate::wasm::StringsTable;
 
-use wasm_encoder::{BlockType as WasmBlockType, HeapType};
-
 /// we need these fields to be mutable for optimisations to be feasible
 #[derive(Debug, Clone)]
 pub struct Fields {
@@ -66,10 +66,7 @@ pub fn wasm(
         vec![]
     })
     .chain(
-        if elem_type.intersects(
-            IrType::StringNan
-                .or(IrType::StringNumber),
-        ) {
+        if elem_type.intersects(IrType::StringNan.or(IrType::StringNumber)) {
             let string_length = func.registries().external_functions().register(
                 ("wasm:js-string", "length".into()),
                 (vec![ValType::EXTERNREF], vec![ValType::I32]),
@@ -82,40 +79,39 @@ pub fn wasm(
                 #LazyGlobalGet(list_global),
                 LocalGet(i_local),
                 ArrayGet(array_type),
-            ].into_iter()
-            .chain(
-                match list.possible_types().base_type() {
-                    Some(IrType::String) => {
-                        wasm![
-                            Call(string_length),
-                            I32Const(1),
-                            I32Eq,
-                        ]
-                    },
-                    None => {
-                        let i64_local = func.local(ValType::I64)?;
-                        let strings_table = func.registries().tables().register::<StringsTable, _>()?;
-                        wasm![
-                            LocalTee(i64_local),
-                            I64Const(BOXED_STRING_PATTERN),
-                            I64And,
-                            I64Const(BOXED_STRING_PATTERN),
-                            I64Eq,
-                            If(WasmBlockType::Result(ValType::I32)),
-                            LocalGet(i64_local),
-                            I32WrapI64,
-                            TableGet(strings_table),
-                            Call(string_length),
-                            I32Const(1),
-                            I32Eq,
-                            Else,
-                            I32Const(0),
-                            End,
-                        ]
-                    },
-                    _ => hq_bug!("shouldn't be checking for single chars in list contents for list with possible types {}", *list.possible_types())
+            ]
+            .into_iter()
+            .chain(match list.possible_types().base_type() {
+                Some(IrType::String) => {
+                    wasm![Call(string_length), I32Const(1), I32Eq,]
                 }
-            )
+                None => {
+                    let i64_local = func.local(ValType::I64)?;
+                    let strings_table = func.registries().tables().register::<StringsTable, _>()?;
+                    wasm![
+                        LocalTee(i64_local),
+                        I64Const(BOXED_STRING_PATTERN),
+                        I64And,
+                        I64Const(BOXED_STRING_PATTERN),
+                        I64Eq,
+                        If(WasmBlockType::Result(ValType::I32)),
+                        LocalGet(i64_local),
+                        I32WrapI64,
+                        TableGet(strings_table),
+                        Call(string_length),
+                        I32Const(1),
+                        I32Eq,
+                        Else,
+                        I32Const(0),
+                        End,
+                    ]
+                }
+                _ => hq_bug!(
+                    "shouldn't be checking for single chars in list contents for list with \
+                     possible types {}",
+                    *list.possible_types()
+                ),
+            })
             .chain(wasm![
                 LocalTee(is_single_chars_local),
                 I32Eqz,
@@ -132,12 +128,7 @@ pub fn wasm(
                     |_| make_hq_bug!("list initial value length out of bounds")
                 )?)]
             })
-            .chain(wasm![
-                I32LtS,
-                BrIf(1),
-                End,
-                End,
-            ])
+            .chain(wasm![I32LtS, BrIf(1), End, End,])
             .collect()
         } else {
             wasm![I32Const(0), LocalSet(is_single_chars_local)]
@@ -182,8 +173,14 @@ pub fn wasm(
             wasm![Call(int_to_string)]
         }
         Some(IrType::Boolean) => {
-            let true_string = func.registries().strings().register_default("true".into())?;
-            let false_string = func.registries().strings().register_default("false".into())?;
+            let true_string = func
+                .registries()
+                .strings()
+                .register_default("true".into())?;
+            let false_string = func
+                .registries()
+                .strings()
+                .register_default("false".into())?;
             let bool_local = func.local(ValType::I32)?;
             wasm![
                 LocalSet(bool_local),
@@ -232,7 +229,10 @@ pub fn wasm(
                 End,
             ]
         }
-        _ => hq_bug!("unexpected list type for list contents, {}", *list.possible_types())
+        _ => hq_bug!(
+            "unexpected list type for list contents, {}",
+            *list.possible_types()
+        ),
     })
     .chain(wasm![
         Call(string_concat),
@@ -241,18 +241,15 @@ pub fn wasm(
         I32Const(1),
         I32Add,
         LocalTee(i_local),
-    ]).chain(if let Some(length_global) = maybe_length_global {
+    ])
+    .chain(if let Some(length_global) = maybe_length_global {
         wasm![#LazyGlobalGet(length_global)]
     } else {
         wasm![I32Const(list.initial_value().len().try_into().map_err(
             |_| make_hq_bug!("list initial value length out of bounds")
         )?)]
-    }).chain(wasm![
-        I32LtS,
-        BrIf(0),
-        End,
-        LocalGet(output_local),
-    ])
+    })
+    .chain(wasm![I32LtS, BrIf(0), End, LocalGet(output_local),])
     .chain(wasm![End])
     .collect())
 }
diff --git a/src/instructions/data/replaceitemoflist.rs b/src/instructions/data/replaceitemoflist.rs
index 61745e87..b5f8a6b5 100644
--- a/src/instructions/data/replaceitemoflist.rs
+++ b/src/instructions/data/replaceitemoflist.rs
@@ -1,9 +1,9 @@
+use wasm_encoder::BlockType as WasmBlockType;
+
 use super::super::prelude::*;
 use crate::ir::RcList;
 use crate::wasm::WasmProject;
 
-use wasm_encoder::BlockType as WasmBlockType;
-
 /// we need these fields to be mutable for optimisations to be feasible
 #[derive(Debug, Clone)]
 pub struct Fields {
diff --git a/src/instructions/event.rs b/src/instructions/event.rs
new file mode 100644
index 00000000..f623923a
--- /dev/null
+++ b/src/instructions/event.rs
@@ -0,0 +1,3 @@
+pub mod broadcast;
+pub mod broadcast_and_wait;
+pub mod poll_waiting_threads;
diff --git a/src/instructions/event/broadcast.rs b/src/instructions/event/broadcast.rs
new file mode 100644
index 00000000..fba38342
--- /dev/null
+++ b/src/instructions/event/broadcast.rs
@@ -0,0 +1,45 @@
+use super::super::prelude::*;
+use crate::wasm::StepFunc;
+
+#[derive(Clone, Debug)]
+pub struct Fields(pub Box<str>);
+
+impl fmt::Display for Fields {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(
+            f,
+            r#"{{
+        "broadcast": "{:}",
+    }}"#,
+            self.0
+        )
+    }
+}
+
+pub fn wasm(
+    _func: &StepFunc,
+    _inputs: Rc<[IrType]>,
+    Fields(broadcast): &Fields,
+) -> HQResult<Vec<InternalInstruction>> {
+    Ok(wasm![
+        #LazyBroadcastSpawn(broadcast.clone())
+    ])
+}
+
+pub fn acceptable_inputs(_fields: &Fields) -> HQResult<Rc<[IrType]>> {
+    Ok(Rc::from([]))
+}
+
+pub fn output_type(_inputs: Rc<[IrType]>, _fields: &Fields) -> HQResult<ReturnType> {
+    Ok(ReturnType::None)
+}
+
+pub const REQUESTS_SCREEN_REFRESH: bool = false;
+
+pub const fn const_fold(
+    _inputs: &[ConstFoldItem],
+    _state: &mut ConstFoldState,
+    _fields: &Fields,
+) -> HQResult<ConstFold> {
+    Ok(NotFoldable)
+}
diff --git a/src/instructions/event/broadcast_and_wait.rs b/src/instructions/event/broadcast_and_wait.rs
new file mode 100644
index 00000000..2ce63a31
--- /dev/null
+++ b/src/instructions/event/broadcast_and_wait.rs
@@ -0,0 +1,68 @@
+use wasm_encoder::{HeapType, StorageType};
+
+use super::super::prelude::*;
+use crate::ir::Step;
+use crate::wasm::StepFunc;
+
+#[derive(Clone, Debug)]
+pub struct Fields {
+    pub broadcast: Box<str>,
+    pub poll_step: Rc<Step>,
+    pub next_step: Rc<Step>,
+}
+
+impl fmt::Display for Fields {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(
+            f,
+            r#"{{
+        "broadcast": "{}",
+        "poll_step": {},
+        "next_step": {}
+    }}"#,
+            self.broadcast, self.poll_step, self.next_step,
+        )
+    }
+}
+
+pub fn wasm(
+    func: &StepFunc,
+    _inputs: Rc<[IrType]>,
+    Fields {
+        broadcast,
+        poll_step,
+        next_step,
+    }: &Fields,
+) -> HQResult<Vec<InternalInstruction>> {
+    let i32_array_type = func
+        .registries()
+        .types()
+        .array(StorageType::Val(ValType::I32), true)?;
+    let arr_local = func.local(ValType::Ref(RefType {
+        nullable: false,
+        heap_type: HeapType::Concrete(i32_array_type),
+    }))?;
+
+    Ok(wasm![
+        LocalGet((func.params().len() - 2).try_into().map_err(|_| make_hq_bug!("local index out of bounds"))?),
+        #LazyBroadcastSpawnAndWait((broadcast.clone(), Rc::clone(poll_step), Rc::clone(next_step), arr_local))
+    ])
+}
+
+pub fn acceptable_inputs(_fields: &Fields) -> HQResult<Rc<[IrType]>> {
+    Ok(Rc::from([]))
+}
+
+pub fn output_type(_inputs: Rc<[IrType]>, _fields: &Fields) -> HQResult<ReturnType> {
+    Ok(ReturnType::None)
+}
+
+pub const REQUESTS_SCREEN_REFRESH: bool = false;
+
+pub const fn const_fold(
+    _inputs: &[ConstFoldItem],
+    _state: &mut ConstFoldState,
+    _fields: &Fields,
+) -> HQResult<ConstFold> {
+    Ok(NotFoldable)
+}
diff --git a/src/instructions/event/poll_waiting_threads.rs b/src/instructions/event/poll_waiting_threads.rs
new file mode 100644
index 00000000..7f5ec564
--- /dev/null
+++ b/src/instructions/event/poll_waiting_threads.rs
@@ -0,0 +1,100 @@
+//! This is a bit of a strange instruction in that it relies on only ever being used inside a step
+//! that was spawned from an `event_broadcast_and_wait` block. Any other use will cause invalid
+//! WASM to be generated.
+//!
+//! Returns 1 if still waiting on any threads, 0 otherwise.
+
+use wasm_encoder::{BlockType as WasmBlockType, FieldType, HeapType, StorageType};
+
+use super::super::prelude::*;
+use crate::wasm::{StepFunc, ThreadsTable};
+
+pub fn wasm(func: &StepFunc, _inputs: Rc<[IrType]>) -> HQResult<Vec<InternalInstruction>> {
+    let i32_array_type = func
+        .registries()
+        .types()
+        .array(StorageType::Val(ValType::I32), true)?;
+    let poll_struct_type = func.registries().types().struct_(vec![FieldType {
+        mutable: false,
+        element_type: StorageType::Val(ValType::Ref(RefType {
+            nullable: false,
+            heap_type: HeapType::Concrete(i32_array_type),
+        })),
+    }])?;
+
+    let arr_local = func.local(ValType::Ref(RefType {
+        nullable: false,
+        heap_type: HeapType::Concrete(i32_array_type),
+    }))?;
+
+    let arr_len_local = func.local(ValType::I32)?;
+    let i_local = func.local(ValType::I32)?;
+    let wait_local = func.local(ValType::I32)?;
+
+    let threads_table = func.registries().tables().register::<ThreadsTable, _>()?;
+
+    Ok(wasm![
+        LocalGet(1), // this should never have additional function arguments so this is fine
+        RefCastNonNull(HeapType::Concrete(poll_struct_type)),
+        StructGet {
+            struct_type_index: poll_struct_type,
+            field_index: 0
+        },
+        LocalTee(arr_local),
+        ArrayLen,
+        LocalSet(arr_len_local),
+        I32Const(-1),
+        LocalSet(i_local),
+        I32Const(0),
+        LocalSet(wait_local),
+        Block(WasmBlockType::Empty),
+        Loop(WasmBlockType::Empty),
+        LocalGet(i_local),
+        I32Const(1),
+        I32Add,
+        LocalTee(i_local),
+        LocalGet(arr_len_local),
+        I32Eq,
+        BrIf(1),
+        LocalGet(i_local),
+        I32Const(0),
+        I32LtS,
+        BrIf(0),
+        Block(WasmBlockType::Empty),
+        LocalGet(arr_local),
+        LocalGet(i_local),
+        ArrayGet(i32_array_type),
+        TableGet(threads_table),
+        RefIsNull,
+        BrIf(0),
+        I32Const(1),
+        LocalSet(wait_local),
+        Br(1),
+        End,
+        LocalGet(arr_local),
+        LocalGet(i_local),
+        I32Const(-1),
+        ArraySet(i32_array_type),
+        Br(0),
+        End,
+        End,
+        LocalGet(wait_local),
+    ])
+}
+
+pub fn acceptable_inputs() -> HQResult<Rc<[IrType]>> {
+    Ok(Rc::from([]))
+}
+
+pub fn output_type(_inputs: Rc<[IrType]>) -> HQResult<ReturnType> {
+    Ok(Singleton(IrType::Boolean))
+}
+
+pub const REQUESTS_SCREEN_REFRESH: bool = false;
+
+pub const fn const_fold(
+    _inputs: &[ConstFoldItem],
+    _state: &mut ConstFoldState,
+) -> HQResult<ConstFold> {
+    Ok(NotFoldable)
+}
diff --git a/src/instructions/hq/cast.rs b/src/instructions/hq/cast.rs
index a44b6bc5..42075e95 100644
--- a/src/instructions/hq/cast.rs
+++ b/src/instructions/hq/cast.rs
@@ -51,7 +51,8 @@ fn best_cast_candidate(from: IrType, to: IrType) -> HQResult<IrType> {
                 IrType::Boolean,
             ] as &[IrType],
             IrType::ColorRGB | IrType::ColorARGB => hq_bad_proj!(
-                "should not be casting from colour. this is probably a project using 'hacked' blocks, or a bug"
+                "should not be casting from colour. this is probably a project using 'hacked' \
+                 blocks, or a bug"
             ),
             _ => unreachable!(),
         } {
diff --git a/src/instructions/hq/dup.rs b/src/instructions/hq/dup.rs
index 012bb57d..87708683 100644
--- a/src/instructions/hq/dup.rs
+++ b/src/instructions/hq/dup.rs
@@ -1,6 +1,5 @@
-use crate::wasm::WasmProject;
-
 use super::super::prelude::*;
+use crate::wasm::WasmProject;
 
 pub fn wasm(func: &StepFunc, inputs: Rc<[IrType]>) -> HQResult<Vec<InternalInstruction>> {
     let local = func.local(WasmProject::ir_type_to_wasm(inputs[0])?)?;
diff --git a/src/instructions/hq/swap.rs b/src/instructions/hq/swap.rs
index af3f3fa6..f06f30ac 100644
--- a/src/instructions/hq/swap.rs
+++ b/src/instructions/hq/swap.rs
@@ -1,6 +1,5 @@
-use crate::wasm::WasmProject;
-
 use super::super::prelude::*;
+use crate::wasm::WasmProject;
 
 pub fn wasm(func: &StepFunc, inputs: Rc<[IrType]>) -> HQResult<Vec<InternalInstruction>> {
     hq_assert!(inputs.len() == 2);
diff --git a/src/instructions/hq/yield.rs b/src/instructions/hq/yield.rs
index f0386227..04439ecd 100644
--- a/src/instructions/hq/yield.rs
+++ b/src/instructions/hq/yield.rs
@@ -1,7 +1,8 @@
+use wasm_encoder::{BlockType, ConstExpr, HeapType};
+
 use super::super::prelude::*;
 use crate::ir::Step;
 use crate::wasm::{GlobalExportable, GlobalMutable, StepFunc, ThreadsTable};
-use wasm_encoder::{BlockType, ConstExpr, HeapType};
 
 #[derive(Debug)]
 pub enum YieldMode {
@@ -225,14 +226,14 @@ crate::instructions_test! {
     @ super::Fields {
         mode: super::YieldMode::Schedule(
             crate::rc::Rc::downgrade(&crate::ir::Step::new_empty(
-                &crate::rc::Rc::downgrade(&Rc::new(crate::ir::IrProject::new(BTreeMap::default(), BTreeMap::default()))),
+                &crate::rc::Rc::downgrade(&Rc::new(crate::ir::IrProject::new(BTreeMap::default(), BTreeMap::default(), Box::from([])))),
                 true,
                 Rc::new(
                     crate::ir::Target::new(
                         false,
                         BTreeMap::default(),
                         BTreeMap::default(),
-                        crate::rc::Rc::downgrade(&Rc::new(crate::ir::IrProject::new(BTreeMap::default(), BTreeMap::default()))),
+                        crate::rc::Rc::downgrade(&Rc::new(crate::ir::IrProject::new(BTreeMap::default(), BTreeMap::default(), Box::from([])))),
                         RefCell::default(),
                         0,
                         Box::from([])
diff --git a/src/instructions/input_switcher.rs b/src/instructions/input_switcher.rs
index ce94515f..2fc59706 100644
--- a/src/instructions/input_switcher.rs
+++ b/src/instructions/input_switcher.rs
@@ -1,19 +1,14 @@
 //! Provides the logic for having boxed input types to blocks
 
-use super::HqCastFields;
-use super::IrOpcode;
-use super::prelude::*;
-use crate::ir::{Type as IrType, base_types};
-use crate::wasm::GlobalExportable;
-use crate::wasm::GlobalMutable;
-use crate::wasm::StepFunc;
-use crate::wasm::StringsTable;
-use crate::wasm::WasmProject;
 use itertools::Itertools;
-use wasm_encoder::ConstExpr;
-use wasm_encoder::{BlockType, Instruction as WInstruction};
+use wasm_encoder::{BlockType, ConstExpr, Instruction as WInstruction};
 use wasm_gen::wasm;
 
+use super::prelude::*;
+use super::{HqCastFields, IrOpcode};
+use crate::ir::{Type as IrType, base_types};
+use crate::wasm::{GlobalExportable, GlobalMutable, StepFunc, StringsTable, WasmProject};
+
 /// Takes a base type and gives the NaN-boxed pattern for that type
 fn boxed_pattern(ty: IrType) -> HQResult<i64> {
     Ok(match ty {
@@ -113,7 +108,8 @@ fn generate_branches(
                     wasm.append(&mut wasm![@boxed(this_base_type)]);
                 } else if let ReturnType::MultiValue(_) = this_output {
                     crate::warn(
-                        "found multi-valued output type for this block in `generate_branches`... suspicious.",
+                        "found multi-valued output type for this block in `generate_branches`... \
+                         suspicious.",
                     );
                 }
             }
diff --git a/src/instructions/motion/direction.rs b/src/instructions/motion/direction.rs
index ca54abe6..a6102437 100644
--- a/src/instructions/motion/direction.rs
+++ b/src/instructions/motion/direction.rs
@@ -1,8 +1,9 @@
-use super::super::prelude::*;
-use crate::wasm::{StepTarget, mem_layout};
 use mem_layout::{sprite as sprite_layout, stage as stage_layout};
 use wasm_encoder::MemArg;
 
+use super::super::prelude::*;
+use crate::wasm::{StepTarget, mem_layout};
+
 pub fn wasm(func: &StepFunc, _inputs: Rc<[IrType]>) -> HQResult<Vec<InternalInstruction>> {
     let StepTarget::Sprite(wasm_target_index) = func.target() else {
         hq_bad_proj!("motion_direction called in stage")
diff --git a/src/instructions/motion/gotoxy.rs b/src/instructions/motion/gotoxy.rs
index f6c9cb52..54fcd320 100644
--- a/src/instructions/motion/gotoxy.rs
+++ b/src/instructions/motion/gotoxy.rs
@@ -1,8 +1,9 @@
-use super::super::prelude::*;
-use crate::wasm::{StepTarget, mem_layout};
 use mem_layout::{sprite as sprite_layout, stage as stage_layout};
 use wasm_encoder::MemArg;
 
+use super::super::prelude::*;
+use crate::wasm::{StepTarget, mem_layout};
+
 pub fn wasm(func: &StepFunc, _inputs: Rc<[IrType]>) -> HQResult<Vec<InternalInstruction>> {
     let ir_target_index: i32 = func
         .target_index()
diff --git a/src/instructions/motion/pointindirection.rs b/src/instructions/motion/pointindirection.rs
index 73fe62ab..2e16e46e 100644
--- a/src/instructions/motion/pointindirection.rs
+++ b/src/instructions/motion/pointindirection.rs
@@ -1,8 +1,9 @@
-use super::super::prelude::*;
-use crate::wasm::{StepTarget, mem_layout};
 use mem_layout::{sprite as sprite_layout, stage as stage_layout};
 use wasm_encoder::MemArg;
 
+use super::super::prelude::*;
+use crate::wasm::{StepTarget, mem_layout};
+
 pub fn wasm(func: &StepFunc, inputs: Rc<[IrType]>) -> HQResult<Vec<InternalInstruction>> {
     let StepTarget::Sprite(wasm_target_index) = func.target() else {
         hq_bad_proj!("motion_pointindirection called in stage")
diff --git a/src/instructions/operator/modulo.rs b/src/instructions/operator/modulo.rs
index 28afe008..817d54d8 100644
--- a/src/instructions/operator/modulo.rs
+++ b/src/instructions/operator/modulo.rs
@@ -1,8 +1,9 @@
 //! this is called modulo rather than mod, just because mod.rs has a special meaning in rust
 
-use super::super::prelude::*;
 use wasm_encoder::BlockType as WasmBlockType;
 
+use super::super::prelude::*;
+
 pub fn wasm(func: &StepFunc, inputs: Rc<[IrType]>) -> HQResult<Vec<InternalInstruction>> {
     hq_assert_eq!(inputs.len(), 2);
     let t1 = inputs[0];
diff --git a/src/instructions/operator/random.rs b/src/instructions/operator/random.rs
index 36e5a17c..fdc9562c 100644
--- a/src/instructions/operator/random.rs
+++ b/src/instructions/operator/random.rs
@@ -1,6 +1,7 @@
-use super::super::prelude::*;
 use wasm_encoder::BlockType as WasmBlockType;
 
+use super::super::prelude::*;
+
 pub fn wasm(func: &StepFunc, inputs: Rc<[IrType]>) -> HQResult<Vec<InternalInstruction>> {
     hq_assert_eq!(inputs.len(), 2);
     let t1 = inputs[0];
diff --git a/src/instructions/pen/setpencolorparamto.rs b/src/instructions/pen/setpencolorparamto.rs
index fd5ad663..947024cb 100644
--- a/src/instructions/pen/setpencolorparamto.rs
+++ b/src/instructions/pen/setpencolorparamto.rs
@@ -1,8 +1,9 @@
+use registries::functions::static_functions::UpdatePenColorFromHSV;
+use wasm_encoder::{BlockType as WasmBlockType, MemArg};
+
 use super::super::prelude::*;
 use crate::instructions::{HqTextFields, IrOpcode};
 use crate::wasm::{StepTarget, mem_layout, registries};
-use registries::functions::static_functions::UpdatePenColorFromHSV;
-use wasm_encoder::{BlockType as WasmBlockType, MemArg};
 
 pub fn wasm(func: &StepFunc, _inputs: Rc<[IrType]>) -> HQResult<Vec<InternalInstruction>> {
     let StepTarget::Sprite(wasm_target_index) = func.target() else {
diff --git a/src/instructions/pen/setpencolortocolor.rs b/src/instructions/pen/setpencolortocolor.rs
index 6f1383e7..92928ed9 100644
--- a/src/instructions/pen/setpencolortocolor.rs
+++ b/src/instructions/pen/setpencolortocolor.rs
@@ -1,8 +1,9 @@
-use super::super::prelude::*;
-use crate::wasm::{StepTarget, mem_layout, registries};
 use registries::functions::static_functions::UpdatePenColorFromRGB;
 use wasm_encoder::{BlockType, MemArg};
 
+use super::super::prelude::*;
+use crate::wasm::{StepTarget, mem_layout, registries};
+
 pub fn wasm(func: &StepFunc, inputs: Rc<[IrType]>) -> HQResult<Vec<InternalInstruction>> {
     let t1 = inputs[0];
     let StepTarget::Sprite(wasm_target_index) = func.target() else {
diff --git a/src/instructions/procedures/argument.rs b/src/instructions/procedures/argument.rs
index 5bde78f9..28ef3068 100644
--- a/src/instructions/procedures/argument.rs
+++ b/src/instructions/procedures/argument.rs
@@ -1,10 +1,9 @@
 use wasm_encoder::{AbstractHeapType, HeapType};
 
 use super::super::prelude::*;
-use crate::{
-    ir::RcVar,
-    wasm::{StepFunc, WasmProject, registries::types::WasmType},
-};
+use crate::ir::RcVar;
+use crate::wasm::registries::types::WasmType;
+use crate::wasm::{StepFunc, WasmProject};
 
 #[derive(Clone, Debug)]
 pub struct Fields {
@@ -64,7 +63,8 @@ pub fn wasm(
                     }
                 })
             ),
-            "struct parameter did not match the expected type shape; expected (structref), got {:?}",
+            "struct parameter did not match the expected type shape; expected (structref), got \
+             {:?}",
             func.params().get(1)
         );
         let struct_type_index = func
diff --git a/src/instructions/procedures/call_nonwarp.rs b/src/instructions/procedures/call_nonwarp.rs
index b2b65c0f..3d61f212 100644
--- a/src/instructions/procedures/call_nonwarp.rs
+++ b/src/instructions/procedures/call_nonwarp.rs
@@ -1,7 +1,9 @@
+use wasm_encoder::{FieldType, HeapType, Instruction as WInstruction, StorageType};
+
 use super::super::prelude::*;
 use crate::ir::{Proc, Step};
-use crate::wasm::{StepFunc, ThreadsTable, WasmProject};
-use wasm_encoder::{FieldType, HeapType, Instruction as WInstruction, StorageType};
+use crate::wasm::registries::functions::static_functions::SpawnThreadInStack;
+use crate::wasm::{StepFunc, WasmProject};
 
 #[derive(Clone, Debug)]
 pub struct Fields {
@@ -50,18 +52,11 @@ pub fn wasm(
         nullable: false,
         heap_type: HeapType::Concrete(arg_struct_type),
     }))?;
-    let stack_struct_type = func.registries().types().stack_struct_type()?;
-    let stack_struct_local = func.local(ValType::Ref(RefType {
-        nullable: false,
-        heap_type: HeapType::Concrete(stack_struct_type),
-    }))?;
-    let stack_array_type = func.registries().types().stack_array_type()?;
-    let thread_struct_type = func.registries().types().thread_struct_type()?;
-    let thread_struct_local = func.local(ValType::Ref(RefType {
-        nullable: false,
-        heap_type: HeapType::Concrete(thread_struct_type),
-    }))?;
-    let threads_table = func.registries().tables().register::<ThreadsTable, _>()?;
+
+    let spawn_thread_in_stack = func
+        .registries()
+        .static_functions()
+        .register::<SpawnThreadInStack, _>()?;
 
     let locals = inputs
         .iter()
@@ -96,57 +91,11 @@ pub fn wasm(
     wasm.extend(wasm![
         StructNew(arg_struct_type),
         LocalSet(arg_struct_local),
+        LocalGet((func.params().len() - 2).try_into().map_err(|_| make_hq_bug!("local index out of bounds"))?),
         #LazyNonWarpedProcRef(Rc::clone(proc)),
         LocalGet(arg_struct_local),
-        StructNew(stack_struct_type),
-        LocalSet(stack_struct_local),
-        LocalGet((func.params().len() - 2).try_into().map_err(|_| make_hq_bug!("local index out of bounds"))?),
-        TableGet(threads_table),
-        RefAsNonNull,
-        LocalTee(thread_struct_local),
-        StructGet {
-            struct_type_index: thread_struct_type,
-            field_index: 1,
-        },
-        LocalGet(thread_struct_local),
-        StructGet {
-            struct_type_index: thread_struct_type,
-            field_index: 0,
-        },
-        LocalGet(stack_struct_local),
-        // todo: consider the case where we need to resize the array
-        ArraySet(stack_array_type),
-        LocalGet(thread_struct_local),
-        StructGet {
-            struct_type_index: thread_struct_type,
-            field_index: 1,
-        },
-        LocalGet(thread_struct_local),
-        StructGet {
-            struct_type_index: thread_struct_type,
-            field_index: 0,
-        },
-        I32Const(1),
-        I32Sub,
-        ArrayGet(stack_array_type),
         #LazyStepRef(Rc::downgrade(next_step)),
-        StructSet {
-            struct_type_index: stack_struct_type,
-            field_index: 0,
-        },
-
-        LocalGet(thread_struct_local),
-        LocalGet(thread_struct_local),
-        StructGet {
-            struct_type_index: thread_struct_type,
-            field_index: 0,
-        },
-        I32Const(1),
-        I32Add,
-        StructSet {
-            struct_type_index: thread_struct_type,
-            field_index: 0,
-        },
+        #StaticFunctionCall(spawn_thread_in_stack),
         LocalGet((func.params().len() - 2).try_into().map_err(|_| make_hq_bug!("local index out of bounds"))?),
         LocalGet(arg_struct_local),
         #LazyNonWarpedProcRef(Rc::clone(proc)),
diff --git a/src/instructions/procedures/call_warp.rs b/src/instructions/procedures/call_warp.rs
index a10b3ab7..e64a6a9b 100644
--- a/src/instructions/procedures/call_warp.rs
+++ b/src/instructions/procedures/call_warp.rs
@@ -1,7 +1,8 @@
+use wasm_encoder::Instruction as WInstruction;
+
 use super::super::prelude::*;
 use crate::ir::Proc;
 use crate::wasm::{StepFunc, WasmProject};
-use wasm_encoder::Instruction as WInstruction;
 
 #[derive(Clone, Debug)]
 pub struct Fields {
diff --git a/src/instructions/sensing.rs b/src/instructions/sensing.rs
index e7458afe..afa8c348 100644
--- a/src/instructions/sensing.rs
+++ b/src/instructions/sensing.rs
@@ -1 +1,3 @@
 pub mod dayssince2000;
+pub mod reset_timer;
+pub mod timer;
diff --git a/src/instructions/sensing/reset_timer.rs b/src/instructions/sensing/reset_timer.rs
new file mode 100644
index 00000000..d280533e
--- /dev/null
+++ b/src/instructions/sensing/reset_timer.rs
@@ -0,0 +1,39 @@
+use wasm_encoder::ConstExpr;
+
+use super::super::prelude::*;
+use crate::wasm::{GlobalExportable, GlobalMutable};
+
+pub fn wasm(func: &StepFunc, _inputs: Rc<[IrType]>) -> HQResult<Vec<InternalInstruction>> {
+    let global_index = func.registries().globals().register(
+        "sensing_timer".into(),
+        (
+            ValType::F64,
+            ConstExpr::f64_const(0.0.into()),
+            GlobalMutable(true),
+            GlobalExportable(true),
+        ),
+    )?;
+    Ok(wasm![
+        F64Const(0.0.into()),
+        #LazyGlobalSet(global_index),
+    ])
+}
+
+pub fn acceptable_inputs() -> HQResult<Rc<[IrType]>> {
+    Ok(Rc::from([]))
+}
+
+pub fn output_type(_inputs: Rc<[IrType]>) -> HQResult<ReturnType> {
+    Ok(ReturnType::None)
+}
+
+pub const REQUESTS_SCREEN_REFRESH: bool = false;
+
+pub const fn const_fold(
+    _inputs: &[ConstFoldItem],
+    _state: &mut ConstFoldState,
+) -> HQResult<ConstFold> {
+    Ok(NotFoldable)
+}
+
+crate::instructions_test! {tests; sensing_reset_timer; ;}
diff --git a/src/instructions/sensing/timer.rs b/src/instructions/sensing/timer.rs
new file mode 100644
index 00000000..ff42f6e9
--- /dev/null
+++ b/src/instructions/sensing/timer.rs
@@ -0,0 +1,38 @@
+use wasm_encoder::ConstExpr;
+
+use super::super::prelude::*;
+use crate::wasm::{GlobalExportable, GlobalMutable};
+
+pub fn wasm(func: &StepFunc, _inputs: Rc<[IrType]>) -> HQResult<Vec<InternalInstruction>> {
+    let global_index = func.registries().globals().register(
+        "sensing_timer".into(),
+        (
+            ValType::F64,
+            ConstExpr::f64_const(0.0.into()),
+            GlobalMutable(true),
+            GlobalExportable(true),
+        ),
+    )?;
+    Ok(wasm![
+        #LazyGlobalGet(global_index),
+    ])
+}
+
+pub fn acceptable_inputs() -> HQResult<Rc<[IrType]>> {
+    Ok(Rc::from([]))
+}
+
+pub fn output_type(_inputs: Rc<[IrType]>) -> HQResult<ReturnType> {
+    Ok(Singleton(IrType::FloatPos))
+}
+
+pub const REQUESTS_SCREEN_REFRESH: bool = false;
+
+pub const fn const_fold(
+    _inputs: &[ConstFoldItem],
+    _state: &mut ConstFoldState,
+) -> HQResult<ConstFold> {
+    Ok(NotFoldable)
+}
+
+crate::instructions_test! {tests; sensing_timer; ;}
diff --git a/src/instructions/tests.rs b/src/instructions/tests.rs
index 66e2da33..666e23a5 100644
--- a/src/instructions/tests.rs
+++ b/src/instructions/tests.rs
@@ -90,7 +90,7 @@ macro_rules! instructions_test {
                         println!("skipping failed output_type");
                         continue;
                     };
-                    let ir = Rc::new(IrProject::new(BTreeMap::default(), BTreeMap::default()));
+                    let ir = Rc::new(IrProject::new(BTreeMap::default(), BTreeMap::default(), Box::from([])));
                     let proj = WasmProject::new(flags(), ExternalEnvironment::WebBrowser);
                     let registries = proj.registries();
                     let types: &[IrType] = &[$($type_arg,)*];
@@ -144,7 +144,7 @@ macro_rules! instructions_test {
                         continue;
                     };
                     println!("{output_type:?}");
-                    let ir = Rc::new(IrProject::new(BTreeMap::default(), BTreeMap::default()));
+                    let ir = Rc::new(IrProject::new(BTreeMap::default(), BTreeMap::default(), Box::from([])));
                     let proj = WasmProject::new(flags(), ExternalEnvironment::WebBrowser);
                     let registries = proj.registries();
                     let types: &[IrType] = &[$($type_arg,)*];
diff --git a/src/ir/blocks.rs b/src/ir/blocks.rs
index 3a405f07..4a3722bc 100644
--- a/src/ir/blocks.rs
+++ b/src/ir/blocks.rs
@@ -1,28 +1,25 @@
+use lazy_regex::{Lazy, lazy_regex};
+use regex::Regex;
+use sb3::{Block, BlockArray, BlockArrayOrId, BlockInfo, BlockMap, BlockOpcode, Input};
+
 use super::context::StepContext;
 use super::target::Target;
 use super::{IrProject, RcVar, Step, Type as IrType};
 use crate::instructions::{
-    DataAddtolistFields, DataDeletealloflistFields, DataDeleteoflistFields, DataInsertatlistFields,
+    ControlIfElseFields, ControlLoopFields, ControlWaitFields, DataAddtolistFields,
+    DataDeletealloflistFields, DataDeleteoflistFields, DataInsertatlistFields,
     DataItemoflistFields, DataLengthoflistFields, DataListcontentsFields,
-    DataReplaceitemoflistFields, ProceduresCallNonwarpFields,
-};
-use crate::instructions::{
-    IrOpcode, YieldMode,
-    fields::{
-        ControlIfElseFields, ControlLoopFields, DataSetvariabletoFields, DataTeevariableFields,
-        DataVariableFields, HqBooleanFields, HqCastFields, HqColorRgbFields, HqFloatFields,
-        HqIntegerFields, HqTextFields, HqYieldFields, LooksSayFields, LooksThinkFields,
-        ProceduresArgumentFields, ProceduresCallWarpFields,
-    },
+    DataReplaceitemoflistFields, DataSetvariabletoFields, DataTeevariableFields,
+    DataVariableFields, EventBroadcastAndWaitFields, EventBroadcastFields, HqBooleanFields,
+    HqCastFields, HqColorRgbFields, HqFloatFields, HqIntegerFields, HqTextFields, HqYieldFields,
+    IrOpcode, LooksSayFields, LooksThinkFields, ProceduresArgumentFields,
+    ProceduresCallNonwarpFields, ProceduresCallWarpFields, YieldMode,
 };
 use crate::ir::{RcList, ReturnType};
 use crate::prelude::*;
 use crate::sb3::{self, Field, VarVal};
 use crate::wasm::WasmFlags;
 use crate::wasm::flags::Switch;
-use lazy_regex::{Lazy, lazy_regex};
-use regex::Regex;
-use sb3::{Block, BlockArray, BlockArrayOrId, BlockInfo, BlockMap, BlockOpcode, Input};
 
 pub fn insert_casts(blocks: &mut Vec<IrOpcode>, ignore_variables: bool) -> HQResult<()> {
     let mut type_stack: Vec<(IrType, usize)> = vec![]; // a vector of types, and where they came from
@@ -77,8 +74,9 @@ pub fn insert_casts(blocks: &mut Vec<IrOpcode>, ignore_variables: bool) -> HQRes
                         | IrOpcode::data_replaceitemoflist(_)
                 ) {
                     hq_bug!(
-                        "attempted to insert a cast before a variable/list operation - variables should \
-                        encompass all possible types, rather than causing values to be coerced.
+                        "attempted to insert a cast before a variable/list operation - variables \
+                         should encompass all possible types, rather than causing values to be \
+                         coerced.
                         Tried to cast from {} to {}, at position {}.
                         Occurred on these opcodes: [
                         {}
@@ -248,14 +246,22 @@ pub fn input_names(block_info: &BlockInfo, context: &StepContext) -> HQResult<Ve
             | BlockOpcode::data_deletealloflist
             | BlockOpcode::data_lengthoflist
             | BlockOpcode::data_listcontents
-            | BlockOpcode::control_stop => vec![],
+            | BlockOpcode::control_stop
+            | BlockOpcode::event_broadcast_menu
+            | BlockOpcode::sensing_timer
+            | BlockOpcode::sensing_resettimer => vec![],
+            BlockOpcode::event_broadcast | BlockOpcode::event_broadcastandwait => {
+                vec!["BROADCAST_INPUT"]
+            }
+            BlockOpcode::control_wait => vec!["DURATION"],
             BlockOpcode::data_setvariableto | BlockOpcode::data_changevariableby => vec!["VALUE"],
             BlockOpcode::operator_random => vec!["FROM", "TO"],
             BlockOpcode::pen_setPenColorParamTo => vec!["COLOR_PARAM", "VALUE"],
             BlockOpcode::control_if
             | BlockOpcode::control_if_else
             | BlockOpcode::control_repeat_until
-            | BlockOpcode::control_while => vec!["CONDITION"],
+            | BlockOpcode::control_while
+            | BlockOpcode::control_wait_until => vec!["CONDITION"],
             BlockOpcode::operator_not => vec!["OPERAND"],
             BlockOpcode::control_repeat => vec!["TIMES"],
             BlockOpcode::operator_length => vec!["STRING"],
@@ -453,31 +459,44 @@ fn generate_loop(
     condition_instructions: Vec<IrOpcode>,
     flip_if: bool,
     setup_instructions: Vec<IrOpcode>,
-    empty_instructions: Vec<IrOpcode>,
     flags: &WasmFlags,
 ) -> HQResult<Vec<IrOpcode>> {
-    let BlockArrayOrId::Id(substack_id) = (match block_info.inputs.get("SUBSTACK") {
+    let substack_id = match block_info.inputs.get("SUBSTACK") {
         Some(
             Input::NoShadow(_, Some(substack_input)) | Input::Shadow(_, Some(substack_input), _),
-        ) => substack_input,
-        _ => return Ok(empty_instructions),
-    }) else {
-        hq_bad_proj!("malformed SUBSTACK input")
+        ) => {
+            let BlockArrayOrId::Id(id) = substack_input else {
+                hq_bad_proj!("malformed SUBSTACK input")
+            };
+            Some(id)
+        }
+        _ => None,
     };
-    let Some(substack_block) = blocks.get(substack_id) else {
-        hq_bad_proj!("SUBSTACK block doesn't seem to exist")
+
+    let substack_block = if let Some(id) = substack_id {
+        Some(
+            blocks
+                .get(id)
+                .ok_or_else(|| make_hq_bad_proj!("SUBSTACK block doesn't seem to exist"))?,
+        )
+    } else {
+        None
     };
     if warp {
         // TODO: can this be expressed in the same way as non-warping loops,
         // just with yield_first: false?
-        let substack_blocks = from_block(
-            substack_block,
-            blocks,
-            context,
-            &context.target().project(),
-            NextBlocks::new(false),
-            flags,
-        )?;
+        let substack_blocks = if let Some(block) = substack_block {
+            from_block(
+                block,
+                blocks,
+                context,
+                &context.target().project(),
+                NextBlocks::new(false),
+                flags,
+            )?
+        } else {
+            vec![]
+        };
         let substack_step = Step::new_rc(
             None,
             context.clone(),
@@ -536,18 +555,26 @@ fn generate_loop(
                 branch_if: Rc::clone(if flip_if { &next_step } else { &substack_step }),
                 branch_else: Rc::clone(if flip_if { &substack_step } else { &next_step }),
             }));
-        let substack_blocks = from_block(
-            substack_block,
-            blocks,
-            context,
-            &context.target().project(),
-            NextBlocks::new(false).extend_with_inner(NextBlockInfo {
-                yield_first: true,
-                block: NextBlock::Step(Rc::downgrade(&condition_step)),
-            }),
-            flags,
-        )?;
-        substack_step.opcodes_mut()?.extend(substack_blocks);
+        if let Some(block) = substack_block {
+            let substack_blocks = from_block(
+                block,
+                blocks,
+                context,
+                &context.target().project(),
+                NextBlocks::new(false).extend_with_inner(NextBlockInfo {
+                    yield_first: true,
+                    block: NextBlock::Step(Rc::downgrade(&condition_step)),
+                }),
+                flags,
+            )?;
+            substack_step.opcodes_mut()?.extend(substack_blocks);
+        } else {
+            substack_step
+                .opcodes_mut()?
+                .push(IrOpcode::hq_yield(HqYieldFields {
+                    mode: YieldMode::Schedule(Rc::downgrade(&condition_step)),
+                }));
+        }
         Ok(setup_instructions
             .into_iter()
             .chain(first_condition_instructions.map_or(condition_instructions, |instrs| instrs))
@@ -592,6 +619,7 @@ fn generate_if_else(
     let dummy_project = Rc::new(IrProject::new(
         this_project.global_variables().clone(),
         this_project.global_lists().clone(),
+        Box::from(this_project.broadcasts()),
     ));
     let dummy_target = Rc::new(Target::new(
         false,
@@ -642,7 +670,7 @@ fn generate_if_else(
     // let if_step_yields = dummy_if_step.does_yield()?;
     // let else_step_yields = dummy_else_step.does_yield()?;
     // crate::log(format!("if yields: {if_step_yields}, else yields: {else_step_yields}").as_str());
-    if !context.warp && (dummy_if_step.does_yield()? || dummy_else_step.does_yield()?) {
+    if !context.warp && (dummy_if_step.does_yield() || dummy_else_step.does_yield()) {
         // TODO: ideally if only one branch yields then we'd duplicate the next step and put one
         // version inline after the branch, and the other tagged on in the substep's NextBlocks
         // as usual, to allow for extra variable type optimisations.
@@ -1025,6 +1053,67 @@ where
     .collect())
 }
 
+fn generate_exhaustive_string_comparison<I, S, F>(
+    string_source: I,
+    instruction: F,
+    fallback: Vec<IrOpcode>,
+    context: &StepContext,
+    project: &Weak<IrProject>,
+) -> HQResult<Vec<IrOpcode>>
+where
+    I: IntoIterator<Item = S>,
+    S: Into<Box<str>> + Clone,
+    F: Fn(Box<str>) -> IrOpcode,
+{
+    let var = RcVar::new(IrType::String, VarVal::String("".into()))?;
+    Ok(vec![
+        IrOpcode::hq_cast(HqCastFields(IrType::String)),
+        IrOpcode::data_setvariableto(DataSetvariabletoFields {
+            var: RefCell::new(var.clone()),
+            local_write: RefCell::new(true),
+        }),
+    ]
+    .into_iter()
+    .chain(
+        string_source
+            .into_iter()
+            .try_fold(
+                Step::new_rc(None, context.clone(), fallback, project, false)?,
+                |branch_else, string| {
+                    let branch_if = Step::new_rc(
+                        None,
+                        context.clone(),
+                        vec![instruction(string.clone().into())],
+                        project,
+                        false,
+                    )?;
+                    Step::new_rc(
+                        None,
+                        context.clone(),
+                        vec![
+                            IrOpcode::data_variable(DataVariableFields {
+                                var: RefCell::new(var.clone()),
+                                local_read: RefCell::new(true),
+                            }),
+                            IrOpcode::hq_text(HqTextFields(string.into())),
+                            IrOpcode::operator_equals, // todo: this should be a case-sensitive comparison
+                            IrOpcode::control_if_else(ControlIfElseFields {
+                                branch_if,
+                                branch_else,
+                            }),
+                        ],
+                        project,
+                        false,
+                    )
+                },
+            )?
+            .opcodes()
+            .borrow()
+            .clone(),
+    )
+    .collect())
+}
+
 #[expect(
     clippy::too_many_lines,
     reason = "a big monolithic function is somewhat unavoidable here"
@@ -1086,6 +1175,8 @@ fn from_normal_block(
                         BlockOpcode::operator_contains => vec![IrOpcode::operator_contains],
                         BlockOpcode::operator_letter_of => vec![IrOpcode::operator_letter_of],
                         BlockOpcode::sensing_dayssince2000 => vec![IrOpcode::sensing_dayssince2000],
+                        BlockOpcode::sensing_timer => vec![IrOpcode::sensing_timer],
+                        BlockOpcode::sensing_resettimer => vec![IrOpcode::sensing_reset_timer],
                         BlockOpcode::operator_lt => vec![IrOpcode::operator_lt],
                         BlockOpcode::operator_gt => vec![IrOpcode::operator_gt],
                         BlockOpcode::operator_equals => vec![IrOpcode::operator_equals],
@@ -1129,6 +1220,83 @@ fn from_normal_block(
                             }
                         }
                         BlockOpcode::operator_random => vec![IrOpcode::operator_random],
+                        BlockOpcode::event_broadcast_menu => {
+                            let sb3::Field::ValueId(val, _id) =
+                                block_info.fields.get("BROADCAST_OPTION").ok_or_else(|| {
+                                    make_hq_bad_proj!(
+                                        "invalid project.json - missing field BROADCAST_OPTION"
+                                    )
+                                })?
+                            else {
+                                hq_bad_proj!(
+                                    "invalid project.json - missing broadcast name for \
+                                     BROADCAST_OPTION field"
+                                );
+                            };
+                            let VarVal::String(name) = val.clone().ok_or_else(|| {
+                                make_hq_bad_proj!(
+                                    "invalid project.json - null broadcast name for \
+                                     BROADCAST_OPTION field"
+                                )
+                            })?
+                            else {
+                                hq_bad_proj!("non-string broadcast name")
+                            };
+                            vec![IrOpcode::hq_text(HqTextFields(name))]
+                        }
+                        BlockOpcode::event_broadcast => generate_exhaustive_string_comparison(
+                            context.project()?.broadcasts().iter().cloned(),
+                            |broadcast| IrOpcode::event_broadcast(EventBroadcastFields(broadcast)),
+                            vec![],
+                            context,
+                            project,
+                        )?,
+                        BlockOpcode::event_broadcastandwait => {
+                            let poll_step =
+                                Step::new_poll_waiting_threads(context.clone(), project)?;
+                            should_break = true;
+                            let next_step = generate_next_step(
+                                true,
+                                block_info,
+                                blocks,
+                                context,
+                                final_next_blocks.clone(),
+                                flags,
+                            )?;
+                            generate_exhaustive_string_comparison(
+                                context.project()?.broadcasts().iter().cloned(),
+                                |broadcast| {
+                                    IrOpcode::event_broadcast_and_wait(
+                                        EventBroadcastAndWaitFields {
+                                            broadcast,
+                                            poll_step: Rc::clone(&poll_step),
+                                            next_step: Rc::clone(&next_step),
+                                        },
+                                    )
+                                },
+                                vec![IrOpcode::hq_yield(HqYieldFields {
+                                    mode: YieldMode::Schedule(Rc::downgrade(&next_step)),
+                                })],
+                                context,
+                                project,
+                            )?
+                        }
+                        BlockOpcode::control_wait => {
+                            let poll_step = Step::new_poll_timer(context.clone(), project)?;
+                            should_break = true;
+                            let next_step = generate_next_step(
+                                true,
+                                block_info,
+                                blocks,
+                                context,
+                                final_next_blocks.clone(),
+                                flags,
+                            )?;
+                            vec![IrOpcode::control_wait(ControlWaitFields {
+                                poll_step,
+                                next_step,
+                            })]
+                        }
                         BlockOpcode::data_setvariableto => {
                             let sb3::Field::ValueId(_val, maybe_id) =
                                 block_info.fields.get("VARIABLE").ok_or_else(|| {
@@ -1703,7 +1871,6 @@ fn from_normal_block(
                                 condition_instructions,
                                 false,
                                 vec![],
-                                vec![],
                                 flags,
                             )?
                         }
@@ -1745,11 +1912,10 @@ fn from_normal_block(
                                 condition_instructions,
                                 false,
                                 setup_instructions,
-                                vec![IrOpcode::hq_drop],
                                 flags,
                             )?
                         }
-                        BlockOpcode::control_repeat_until => {
+                        BlockOpcode::control_repeat_until | BlockOpcode::control_wait_until => {
                             let condition_instructions = inputs(
                                 block_info,
                                 blocks,
@@ -1770,7 +1936,6 @@ fn from_normal_block(
                                 condition_instructions,
                                 true,
                                 setup_instructions,
-                                vec![IrOpcode::hq_drop],
                                 flags,
                             )?
                         }
@@ -1795,7 +1960,6 @@ fn from_normal_block(
                                 condition_instructions,
                                 false,
                                 setup_instructions,
-                                vec![IrOpcode::hq_drop],
                                 flags,
                             )?
                         }
@@ -1903,12 +2067,14 @@ fn from_normal_block(
                             let sb3::VarVal::String(number_name) =
                                 val.clone().ok_or_else(|| {
                                     make_hq_bad_proj!(
-                                    "invalid project.json - null costume name for NUMBER_NAME field"
-                                )
+                                        "invalid project.json - null costume name for NUMBER_NAME \
+                                         field"
+                                    )
                                 })?
                             else {
                                 hq_bad_proj!(
-                                    "invalid project.json - NUMBER_NAME field is not of type String"
+                                    "invalid project.json - NUMBER_NAME field is not of type \
+                                     String"
                                 );
                             };
                             match &*number_name {
@@ -2181,9 +2347,9 @@ fn from_special_block(
             }
             _ => hq_bad_proj!("bad project json (block array of type ({}, string))", ty),
         },
-        BlockArray::Broadcast(ty, _name, id) | BlockArray::VariableOrList(ty, _name, id, _, _) => {
+        BlockArray::Broadcast(ty, name, id) | BlockArray::VariableOrList(ty, name, id, _, _) => {
             match ty {
-                11 => hq_todo!("broadcast input"),
+                11 => IrOpcode::hq_text(HqTextFields(name.clone())),
                 12 => {
                     let target = context.target();
                     let variable = if let Some(var) = target.variables().get(id) {
diff --git a/src/ir/context.rs b/src/ir/context.rs
index 2b542924..173cc6f8 100644
--- a/src/ir/context.rs
+++ b/src/ir/context.rs
@@ -1,5 +1,6 @@
 use super::{IrProject, Target};
-use crate::{ir::RcVar, prelude::*};
+use crate::ir::RcVar;
+use crate::prelude::*;
 
 #[derive(Debug, Clone)]
 pub struct ProcContext {
diff --git a/src/ir/event.rs b/src/ir/event.rs
index ba34b02a..b6c59d59 100644
--- a/src/ir/event.rs
+++ b/src/ir/event.rs
@@ -1,5 +1,6 @@
 // Ord is required to be used in a BTreeMap; Ord requires PartialOrd, Eq and PartialEq
-#[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord)]
+#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord)]
 pub enum Event {
     FlagCLicked,
+    Broadcast(Box<str>),
 }
diff --git a/src/ir/proc.rs b/src/ir/proc.rs
index fe309a2e..f6ef6150 100644
--- a/src/ir/proc.rs
+++ b/src/ir/proc.rs
@@ -2,6 +2,11 @@
 //! we can (we do this to improve variable type analysis). Procedures can return as many values
 //! as we want, because we can use the WASM multi-value proposal.
 
+use core::cell::{Ref, RefMut};
+
+use lazy_regex::{Lazy, lazy_regex};
+use regex::Regex;
+
 use super::blocks::NextBlocks;
 use super::context::StepContext;
 use super::{Step, Target as IrTarget};
@@ -9,9 +14,6 @@ use crate::ir::{ProcContext, RcVar};
 use crate::prelude::*;
 use crate::sb3::{Block, BlockArrayOrId, BlockMap, BlockOpcode, Input, Target as Sb3Target};
 use crate::wasm::WasmFlags;
-use core::cell::{Ref, RefMut};
-use lazy_regex::{Lazy, lazy_regex};
-use regex::Regex;
 
 #[derive(Clone, Debug, PartialEq, Eq)]
 pub enum PartialStep {
diff --git a/src/ir/project.rs b/src/ir/project.rs
index 4a8ad3ff..46a46c3d 100644
--- a/src/ir/project.rs
+++ b/src/ir/project.rs
@@ -2,8 +2,7 @@ use super::proc::{ProcMap, procs_from_target};
 use super::variable::{TargetLists, TargetVars, lists_from_target, variables_from_target};
 use super::{Step, Target, Thread};
 use crate::instructions::{
-    ControlIfElseFields, ControlLoopFields, DataSetvariabletoFields, DataVariableFields,
-    HqYieldFields, IrOpcode, YieldMode,
+    DataSetvariabletoFields, DataVariableFields, HqYieldFields, IrOpcode, YieldMode,
 };
 use crate::ir::target::IrCostume;
 use crate::ir::{PartialStep, RcVar};
@@ -20,6 +19,7 @@ pub struct IrProject {
     inlined_steps: RefCell<StepSet>,
     global_variables: TargetVars,
     global_lists: TargetLists,
+    broadcasts: Box<[Box<str>]>,
     targets: RefCell<IndexMap<Box<str>, Rc<Target>>>,
 }
 
@@ -48,14 +48,23 @@ impl IrProject {
         &self.global_lists
     }
 
+    pub const fn broadcasts(&self) -> &[Box<str>] {
+        &self.broadcasts
+    }
+
     #[must_use]
-    pub fn new(global_variables: TargetVars, global_lists: TargetLists) -> Self {
+    pub fn new(
+        global_variables: TargetVars,
+        global_lists: TargetLists,
+        broadcasts: Box<[Box<str>]>,
+    ) -> Self {
         Self {
             threads: RefCell::new(Box::new([])),
             steps: RefCell::new(IndexSet::default()),
             inlined_steps: RefCell::new(IndexSet::default()),
             global_variables,
             global_lists,
+            broadcasts,
             targets: RefCell::new(IndexMap::default()),
         }
     }
@@ -76,7 +85,14 @@ impl IrProject {
             flags,
         )?;
 
-        let project = Rc::new(Self::new(global_variables, global_lists));
+        let broadcasts = sb3
+            .targets
+            .iter()
+            .flat_map(|target| target.broadcasts.values())
+            .cloned()
+            .collect();
+
+        let project = Rc::new(Self::new(global_variables, global_lists, broadcasts));
 
         let (threads_vec, targets): (Vec<_>, Vec<_>) = sb3
             .targets
@@ -183,36 +199,22 @@ where
     let mut has_return = false;
     checked_steps.insert(Rc::clone(step));
     for (i, opcode) in step.opcodes().borrow().iter().enumerate() {
-        #[expect(
-            clippy::wildcard_enum_match_arm,
-            reason = "too many variants to match explicitly"
-        )]
-        match opcode {
+        if matches!(
+            opcode,
             IrOpcode::hq_yield(HqYieldFields {
                 mode: YieldMode::Return,
-            }) => {
-                hq_assert!(
-                    i == step.opcodes().borrow().len() - 1,
-                    "found yield return in non-tail position"
-                );
-                has_return = true;
-            }
-            IrOpcode::hq_yield(HqYieldFields {
-                mode: YieldMode::Inline(inline_step),
-            }) => {
-                add_proc_return_vars_before_return(inline_step, var_ops.clone(), checked_steps)?;
-            }
-            IrOpcode::control_if_else(ControlIfElseFields {
-                branch_if,
-                branch_else,
-            }) => {
-                add_proc_return_vars_before_return(branch_if, var_ops.clone(), checked_steps)?;
-                add_proc_return_vars_before_return(branch_else, var_ops.clone(), checked_steps)?;
-            }
-            IrOpcode::control_loop(ControlLoopFields { body, .. }) => {
-                add_proc_return_vars_before_return(body, var_ops.clone(), checked_steps)?;
-            }
-            _ => (),
+            })
+        ) {
+            hq_assert!(
+                i == step.opcodes().borrow().len() - 1,
+                "found yield return in non-tail position"
+            );
+            has_return = true;
+        }
+        if let Some(inline_steps) = opcode.inline_steps() {
+            inline_steps.iter().try_for_each(|inline_step| {
+                add_proc_return_vars_before_return(inline_step, var_ops.clone(), checked_steps)
+            })?;
         }
     }
 
@@ -338,6 +340,11 @@ impl fmt::Display for IrProject {
             .iter()
             .map(|thread| format!("{thread}"))
             .join(", ");
+        let broadcasts = self
+            .broadcasts()
+            .iter()
+            .map(|name| format!(r#""{name}""#))
+            .join(", ");
         let steps = self
             .steps()
             .borrow()
@@ -356,6 +363,7 @@ impl fmt::Display for IrProject {
         "targets": {{{targets}}},
         "global_variables": {{{variables}}},
         "global_lists": {{{lists}}},
+        "broadcasts": [{broadcasts}],
         "threads": [{threads}],
         "steps": [{steps}],
         "inlined_steps": [{inlined_steps}]
diff --git a/src/ir/step.rs b/src/ir/step.rs
index 4052b5a0..9ba49acd 100644
--- a/src/ir/step.rs
+++ b/src/ir/step.rs
@@ -1,3 +1,7 @@
+use core::cell::RefMut;
+
+use uuid::Uuid;
+
 use super::blocks::{self, NextBlocks};
 use super::{IrProject, StepContext};
 use crate::instructions::{ControlIfElseFields, HqYieldFields, IrOpcode, YieldMode};
@@ -5,8 +9,6 @@ use crate::ir::{RcVar, Target, used_vars};
 use crate::prelude::*;
 use crate::sb3::{Block, BlockMap};
 use crate::wasm::WasmFlags;
-use core::cell::RefMut;
-use uuid::Uuid;
 
 #[derive(Debug)]
 pub struct Step {
@@ -145,6 +147,43 @@ impl Step {
         )
     }
 
+    pub fn new_poll_waiting_threads(
+        context: StepContext,
+        project: &Weak<IrProject>,
+    ) -> HQResult<Rc<Self>> {
+        Self::new_rc(
+            None,
+            context.clone(),
+            vec![
+                IrOpcode::event_poll_waiting_threads,
+                IrOpcode::control_if_else(ControlIfElseFields {
+                    branch_if: Self::new_rc(None, context.clone(), vec![], project, false)?,
+                    branch_else: Self::new_terminating(context, project, false)?,
+                }),
+            ],
+            project,
+            true,
+        )
+    }
+
+    pub fn new_poll_timer(context: StepContext, project: &Weak<IrProject>) -> HQResult<Rc<Self>> {
+        Self::new_rc(
+            None,
+            context.clone(),
+            vec![
+                IrOpcode::control_get_thread_timeout,
+                IrOpcode::sensing_timer,
+                IrOpcode::operator_gt,
+                IrOpcode::control_if_else(ControlIfElseFields {
+                    branch_if: Self::new_rc(None, context.clone(), vec![], project, false)?,
+                    branch_else: Self::new_terminating(context, project, false)?,
+                }),
+            ],
+            project,
+            true,
+        )
+    }
+
     pub fn opcodes_mut(&self) -> HQResult<RefMut<'_, Vec<IrOpcode>>> {
         self.opcodes
             .try_borrow_mut()
@@ -191,28 +230,19 @@ impl Step {
         )
     }
 
-    pub fn does_yield(&self) -> HQResult<bool> {
-        for opcode in &*self.opcodes().try_borrow()? {
-            // if opcode.requests_screen_refresh() {
-            //     return Ok(true);
-            // }
-            #[expect(clippy::wildcard_enum_match_arm, reason = "too many variants to match")]
-            match opcode {
-                IrOpcode::hq_yield(HqYieldFields {
-                    mode: YieldMode::Schedule(_),
-                }) => return Ok(true),
-                IrOpcode::control_if_else(ControlIfElseFields {
-                    branch_else,
-                    branch_if,
-                }) => {
-                    if branch_if.does_yield()? || branch_else.does_yield()? {
-                        return Ok(true);
-                    }
-                }
-                _ => (),
+    pub fn does_yield(&self) -> bool {
+        for opcode in &*self.opcodes().borrow() {
+            if opcode.yields_to_next_step().is_some() {
+                return true;
+            }
+            if opcode
+                .inline_steps()
+                .is_some_and(|steps| steps.iter().any(|step| step.does_yield()))
+            {
+                return true;
             }
         }
-        Ok(false)
+        false
     }
 
     /// An iterator of variables that are global (in the WASM sense, not the scratch sense)
diff --git a/src/ir/target.rs b/src/ir/target.rs
index b18ed833..5dd54258 100644
--- a/src/ir/target.rs
+++ b/src/ir/target.rs
@@ -1,8 +1,10 @@
-use super::{IrProject, proc::Proc};
+use core::cell::{Ref, RefMut};
+
+use super::IrProject;
+use super::proc::Proc;
 use crate::ir::variable::{TargetLists, TargetVars};
 use crate::prelude::*;
 use crate::sb3::CostumeDataFormat;
-use core::cell::{Ref, RefMut};
 
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct IrCostume {
diff --git a/src/ir/thread.rs b/src/ir/thread.rs
index ec5bef7e..159d2c02 100644
--- a/src/ir/thread.rs
+++ b/src/ir/thread.rs
@@ -1,7 +1,8 @@
 use super::blocks::NextBlocks;
 use super::{Event, IrProject, Step, StepContext, Target};
 use crate::prelude::*;
-use crate::sb3::{Block, BlockMap, BlockOpcode};
+use crate::sb3;
+use crate::sb3::{Block, BlockMap, BlockOpcode, VarVal};
 use crate::wasm::WasmFlags;
 
 #[derive(Clone, Debug)]
@@ -11,8 +12,8 @@ pub struct Thread {
 }
 
 impl Thread {
-    pub const fn event(&self) -> Event {
-        self.event
+    pub const fn event(&self) -> &Event {
+        &self.event
     }
 
     pub const fn first_step(&self) -> &Rc<Step> {
@@ -35,8 +36,27 @@ impl Thread {
         #[expect(clippy::wildcard_enum_match_arm, reason = "too many variants to match")]
         let event = match block_info.opcode {
             BlockOpcode::event_whenflagclicked => Event::FlagCLicked,
+            BlockOpcode::event_whenbroadcastreceived => {
+                let sb3::Field::ValueId(val, _id) =
+                    block_info.fields.get("BROADCAST_OPTION").ok_or_else(|| {
+                        make_hq_bad_proj!("invalid project.json - missing field BROADCAST_OPTION")
+                    })?
+                else {
+                    hq_bad_proj!(
+                        "invalid project.json - missing broadcast name for BROADCAST_OPTION field"
+                    );
+                };
+                let VarVal::String(name) = val.clone().ok_or_else(|| {
+                    make_hq_bad_proj!(
+                        "invalid project.json - null broadcast name for BROADCAST_OPTION field"
+                    )
+                })?
+                else {
+                    hq_bad_proj!("non-string broadcast name")
+                };
+                Event::Broadcast(name)
+            }
             BlockOpcode::event_whenbackdropswitchesto
-            | BlockOpcode::event_whenbroadcastreceived
             | BlockOpcode::event_whengreaterthan
             | BlockOpcode::event_whenkeypressed
             | BlockOpcode::event_whenstageclicked
@@ -78,7 +98,7 @@ impl fmt::Display for Thread {
         write!(
             f,
             r#"{{
-            "event": "{event:?}",
+            "event": '{event:?}',
             "first_step": "{first_step}",
         }}"#
         )
diff --git a/src/ir/types.rs b/src/ir/types.rs
index 72a89fc0..9032b574 100644
--- a/src/ir/types.rs
+++ b/src/ir/types.rs
@@ -1,9 +1,10 @@
+use bitmask_enum::bitmask;
+
 use crate::instructions::{
     HqBooleanFields, HqFloatFields, HqIntegerFields, HqTextFields, IrOpcode,
 };
 use crate::prelude::*;
 use crate::sb3::VarVal;
-use bitmask_enum::bitmask;
 
 /// a bitmask of possible IR types
 #[bitmask(u32)]
diff --git a/src/ir/variable.rs b/src/ir/variable.rs
index ac6434fc..588a4fa8 100644
--- a/src/ir/variable.rs
+++ b/src/ir/variable.rs
@@ -1,14 +1,14 @@
+use core::cell::Ref;
+use core::hash::{Hash, Hasher};
+
 use uuid::Uuid;
 
 use super::Type;
-use crate::{
-    ir::types::var_val_type,
-    prelude::*,
-    sb3::{Target as Sb3Target, VarVal},
-    wasm::{WasmFlags, flags::Switch},
-};
-use core::cell::Ref;
-use core::hash::{Hash, Hasher};
+use crate::ir::types::var_val_type;
+use crate::prelude::*;
+use crate::sb3::{Target as Sb3Target, VarVal};
+use crate::wasm::WasmFlags;
+use crate::wasm::flags::Switch;
 
 #[derive(Debug)]
 struct Variable {
diff --git a/src/lib.rs b/src/lib.rs
index aed74bde..82c27f23 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -13,7 +13,8 @@
 )]
 #![allow(
     clippy::missing_errors_doc,
-    reason = "Too many Results everywhere to document every possible error case. Errors should be self-descriptive and user readable anyway."
+    reason = "Too many Results everywhere to document every possible error case. Errors should be \
+              self-descriptive and user readable anyway."
 )]
 #![allow(clippy::too_many_arguments, reason = "unavoidable at this stage")]
 #![allow(
@@ -72,11 +73,6 @@ pub mod rc;
 
 /// commonly used _things_ which would be nice not to have to type out every time
 pub mod prelude {
-    pub use crate::registry::{
-        NamedRegistrar, NamedRegistry, NamedRegistryItem, NamedRegistryItemOverride, Registry,
-        RegistryDefault, RegistryType, TryNamedRegistryItemOverride,
-    };
-    pub use crate::{HQError, HQResult};
     pub use alloc::borrow::Cow;
     pub use alloc::boxed::Box;
     pub use alloc::collections::{BTreeMap, BTreeSet};
@@ -85,14 +81,19 @@ pub mod prelude {
     pub use core::borrow::Borrow;
     pub use core::cell::RefCell;
     pub use core::fmt;
+    use core::hash::BuildHasherDefault;
     pub use core::marker::PhantomPinned;
     pub use core::pin::Pin;
 
-    pub use crate::rc::{Rc, Weak};
-
-    use core::hash::BuildHasherDefault;
     use hashers::fnv::FNV1aHasher64;
     use indexmap;
+
+    pub use crate::rc::{Rc, Weak};
+    pub use crate::registry::{
+        NamedRegistrar, NamedRegistry, NamedRegistryItem, NamedRegistryItemOverride, Registry,
+        RegistryDefault, RegistryType, TryNamedRegistryItemOverride,
+    };
+    pub use crate::{HQError, HQResult};
     pub type IndexMap<K, V> = indexmap::IndexMap<K, V, BuildHasherDefault<FNV1aHasher64>>;
     pub type IndexSet<T> = indexmap::IndexSet<T, BuildHasherDefault<FNV1aHasher64>>;
 
diff --git a/src/optimisation.rs b/src/optimisation.rs
index fb5c4b92..0b4ef248 100644
--- a/src/optimisation.rs
+++ b/src/optimisation.rs
@@ -1,6 +1,7 @@
+use crate::ir::IrProject;
 use crate::prelude::*;
+use crate::wasm::WasmFlags;
 use crate::wasm::flags::Switch;
-use crate::{ir::IrProject, wasm::WasmFlags};
 
 mod const_folding;
 mod loop_unrolling;
diff --git a/src/optimisation/loop_unrolling.rs b/src/optimisation/loop_unrolling.rs
index a4b12753..6aea6fd1 100644
--- a/src/optimisation/loop_unrolling.rs
+++ b/src/optimisation/loop_unrolling.rs
@@ -9,25 +9,12 @@ fn unroll_loops_in_step(step: &Rc<Step>) -> HQResult<()> {
     let mut loops = vec![];
 
     for (i, opcode) in step.opcodes().borrow().iter().enumerate().rev() {
-        if let IrOpcode::control_loop(loop_fields) = opcode {
-            unroll_loops_in_step(&loop_fields.body)?;
-            loops.push((i, loop_fields.clone()));
-        }
-
-        if let IrOpcode::control_if_else(ControlIfElseFields {
-            branch_if,
-            branch_else,
-        }) = opcode
-        {
-            unroll_loops_in_step(branch_if)?;
-            unroll_loops_in_step(branch_else)?;
+        if let Some(inline_steps) = opcode.inline_steps() {
+            inline_steps.iter().try_for_each(unroll_loops_in_step)?;
         }
 
-        if let IrOpcode::hq_yield(HqYieldFields {
-            mode: YieldMode::Inline(inline_step),
-        }) = opcode
-        {
-            unroll_loops_in_step(inline_step)?;
+        if let IrOpcode::control_loop(loop_fields) = opcode {
+            loops.push((i, loop_fields.clone()));
         }
     }
 
diff --git a/src/optimisation/ssa.rs b/src/optimisation/ssa.rs
index 538d6cc7..5ace5f9a 100644
--- a/src/optimisation/ssa.rs
+++ b/src/optimisation/ssa.rs
@@ -88,6 +88,18 @@
     reason = "implementations of Eq and Ord for RcVar and Step are independent of actual contents"
 )]
 
+use alloc::collections::btree_map::Entry;
+use core::convert::identity;
+use core::hash::{Hash, Hasher};
+use core::marker::PhantomData;
+use core::mem;
+
+// use petgraph::dot::Dot;
+use petgraph::graph::{EdgeIndex, NodeIndex};
+use petgraph::stable_graph::StableDiGraph;
+use petgraph::visit::EdgeRef;
+use petgraph::{Incoming as EdgeIn, Outgoing as EdgeOut};
+
 use crate::instructions::{
     ControlIfElseFields, ControlLoopFields, DataAddtolistFields, DataInsertatlistFields,
     DataItemoflistFields, DataReplaceitemoflistFields, DataSetvariabletoFields,
@@ -99,17 +111,6 @@ use crate::ir::{
 };
 use crate::prelude::*;
 
-use alloc::collections::btree_map::Entry;
-use core::convert::identity;
-use core::hash::{Hash, Hasher};
-use core::marker::PhantomData;
-use core::mem;
-// use petgraph::dot::Dot;
-
-use petgraph::graph::{EdgeIndex, NodeIndex};
-use petgraph::visit::EdgeRef;
-use petgraph::{Incoming as EdgeIn, Outgoing as EdgeOut, stable_graph::StableDiGraph};
-
 #[derive(Clone, Debug)]
 enum StackElement {
     Drop,
@@ -401,7 +402,16 @@ impl VarGraph {
                                         index: var_index,
                                         arg_var: arg_var.clone(),
                                         in_warped: true,
-                                        arg_vars: Rc::clone(&maybe_proc_context.ok_or_else(|| make_hq_bug!("tried to access proc argument when proc context was None"))?.arg_vars)
+                                        arg_vars: Rc::clone(
+                                            &maybe_proc_context
+                                                .ok_or_else(|| {
+                                                    make_hq_bug!(
+                                                        "tried to access proc argument when proc \
+                                                         context was None"
+                                                    )
+                                                })?
+                                                .arg_vars,
+                                        ),
                                     }),
                                 ));
                                 Ok(arg_var.clone())
@@ -522,7 +532,17 @@ impl VarGraph {
                                                         index: arg_index,
                                                         arg_var: arg_var.clone(),
                                                         in_warped: true,
-                                                        arg_vars: Rc::clone(&maybe_proc_context.ok_or_else(|| make_hq_bug!("tried to access proc argument when proc context was None"))?.arg_vars)
+                                                        arg_vars: Rc::clone(
+                                                            &maybe_proc_context
+                                                                .ok_or_else(|| {
+                                                                    make_hq_bug!(
+                                                                        "tried to access proc \
+                                                                         argument when proc \
+                                                                         context was None"
+                                                                    )
+                                                                })?
+                                                                .arg_vars,
+                                                        ),
                                                     },
                                                 ),
                                                 arg_var.clone(),
@@ -723,19 +743,7 @@ impl VarGraph {
                         step_ended_on_stop = true;
                         break 'opcode_loop;
                     }
-                    YieldMode::Schedule(step) => {
-                        // crate::log("found a scheduled step, scheduling and breaking");
-                        if let Some(rcstep) = step.upgrade() {
-                            next_steps.push(rcstep);
-                        } else {
-                            crate::warn(
-                                "couldn't upgrade Weak<Step> in Schedule in variables optimisation pass;\
-                    what's going on here?",
-                            );
-                        }
-                        should_propagate_ssa = true;
-                        break 'opcode_loop;
-                    }
+                    YieldMode::Schedule(_) => (), // handled at bottom of loop
                 },
                 _ => {
                     let inputs_len = opcode.acceptable_inputs()?.len();
@@ -765,6 +773,11 @@ impl VarGraph {
                     }
                 }
             }
+            if let Some(next_step) = opcode.yields_to_next_step() {
+                next_steps.push(next_step);
+                should_propagate_ssa = true;
+                break 'opcode_loop;
+            }
         }
 
         if !type_stack.is_empty()
@@ -773,7 +786,8 @@ impl VarGraph {
             && let Some(proc_context) = maybe_proc_context
         {
             crate::log!(
-                "found spare items on type stack at end of step visit, in warped proc: {type_stack:?}"
+                "found spare items on type stack at end of step visit, in warped proc: \
+                 {type_stack:?}"
             );
             // crate::log!(
             //     "return vars: {}",
@@ -1182,27 +1196,10 @@ fn box_proc_returns(
     visited_steps.insert(Rc::clone(step));
 
     for opcode in step.opcodes().borrow().iter() {
-        #[expect(
-            clippy::wildcard_enum_match_arm,
-            reason = "too many variants to match explicitly"
-        )]
-        match opcode {
-            IrOpcode::hq_yield(HqYieldFields {
-                mode: YieldMode::Inline(inline_step),
-            }) => {
-                box_proc_returns(inline_step, rev_ret_vars, visited_steps)?;
-            }
-            IrOpcode::control_loop(ControlLoopFields { body, .. }) => {
-                box_proc_returns(body, rev_ret_vars, visited_steps)?;
-            }
-            IrOpcode::control_if_else(ControlIfElseFields {
-                branch_if,
-                branch_else,
-            }) => {
-                box_proc_returns(branch_if, rev_ret_vars, visited_steps)?;
-                box_proc_returns(branch_else, rev_ret_vars, visited_steps)?;
-            }
-            _ => (),
+        if let Some(inline_steps) = opcode.inline_steps() {
+            inline_steps.iter().try_for_each(|inline_step| {
+                box_proc_returns(inline_step, rev_ret_vars, visited_steps)
+            })?;
         }
     }
 
diff --git a/src/registry.rs b/src/registry.rs
index aadc2e96..858e1550 100644
--- a/src/registry.rs
+++ b/src/registry.rs
@@ -1,6 +1,7 @@
-use crate::prelude::*;
 use core::hash::Hash;
 
+use crate::prelude::*;
+
 #[derive(Clone)]
 pub struct MapRegistry<K, V>(RefCell<IndexMap<K, V>>)
 where
diff --git a/src/sb3.rs b/src/sb3.rs
index 5e45e261..ad9a3507 100644
--- a/src/sb3.rs
+++ b/src/sb3.rs
@@ -5,11 +5,12 @@
 //! `sb3` files must be unzipped first. See <https://en.scratch-wiki.info/wiki/Scratch_File_Format>
 //! for a loose informal specification.
 
-use crate::prelude::*;
 use enum_field_getter::EnumFieldGetter;
 use serde::{Deserialize, Serialize};
 use serde_json::Value;
 
+use crate::prelude::*;
+
 /// A scratch project
 #[derive(Serialize, Deserialize, Debug, Clone)]
 pub struct Sb3Project {
@@ -77,6 +78,7 @@ pub enum BlockOpcode {
     data_hidelist,
     data_showlist,
     event_broadcast,
+    event_broadcast_menu,
     event_broadcastandwait,
     event_whenflagclicked,
     event_whenkeypressed,
diff --git a/src/wasm.rs b/src/wasm.rs
index 2a9d708e..1449ae7c 100644
--- a/src/wasm.rs
+++ b/src/wasm.rs
@@ -10,8 +10,9 @@ pub use external::ExternalEnvironment;
 pub use flags::WasmFlags;
 pub use func::{Instruction as InternalInstruction, StepFunc, StepTarget};
 pub use project::{FinishedWasm, WasmProject};
-pub use registries::Registries;
-pub use registries::{GlobalExportable, GlobalMutable, StepsTable, StringsTable, ThreadsTable};
+pub use registries::{
+    GlobalExportable, GlobalMutable, Registries, StepsTable, StringsTable, ThreadsTable,
+};
 
 /// the same as Into, but `const`.
 #[must_use]
diff --git a/src/wasm/flags.rs b/src/wasm/flags.rs
index e3e1817a..a5a265a0 100644
--- a/src/wasm/flags.rs
+++ b/src/wasm/flags.rs
@@ -1,9 +1,10 @@
 #![allow(clippy::enum_glob_use, reason = "easier and little risk of pollution")]
 
-use crate::prelude::*;
 use serde::{Deserialize, Serialize};
 use wasm_bindgen::prelude::*;
 
+use crate::prelude::*;
+
 #[derive(Copy, Clone, Serialize, Deserialize)]
 #[wasm_bindgen]
 pub enum WasmStringType {
diff --git a/src/wasm/func.rs b/src/wasm/func.rs
index 535ea73b..08d3aba3 100644
--- a/src/wasm/func.rs
+++ b/src/wasm/func.rs
@@ -1,16 +1,17 @@
-use super::{Registries, WasmFlags, WasmProject};
-use crate::instructions::IrOpcode;
-use crate::ir::{PartialStep, RcVar, ReturnType, Step};
-use crate::prelude::*;
-use crate::wasm::registries::TypeRegistry;
-use crate::{instructions::wrap_instruction, ir::Proc};
 use alloc::collections::btree_map;
+
 use wasm_encoder::{
-    self, CodeSection, Function, FunctionSection, HeapType, Instruction as WInstruction, RefType,
-    ValType,
+    self, AbstractHeapType, CodeSection, FieldType, Function, FunctionSection, HeapType,
+    Instruction as WInstruction, RefType, StorageType, ValType,
 };
 use wasm_gen::wasm;
 
+use super::{Registries, WasmFlags, WasmProject};
+use crate::instructions::{IrOpcode, wrap_instruction};
+use crate::ir::{Event, PartialStep, Proc, RcVar, ReturnType, Step};
+use crate::prelude::*;
+use crate::wasm::registries::TypeRegistry;
+
 #[derive(Clone, Debug)]
 pub enum Instruction {
     Immediate(wasm_encoder::Instruction<'static>),
@@ -20,6 +21,8 @@ pub enum Instruction {
     LazyNonWarpedProcRef(Rc<Proc>),
     LazyGlobalGet(u32),
     LazyGlobalSet(u32),
+    LazyBroadcastSpawn(Box<str>),
+    LazyBroadcastSpawnAndWait((Box<str>, Rc<Step>, Rc<Step>, u32)),
     StaticFunctionCall(u32),
 }
 
@@ -27,16 +30,22 @@ impl Instruction {
     pub fn eval(
         &self,
         steps: &Rc<RefCell<IndexMap<Rc<Step>, StepFunc>>>,
+        events: &BTreeMap<Event, Vec<u32>>,
+        types: &Rc<TypeRegistry>,
+        threads_count_global: u32,
+        spawn_new_thread_func: u32,
+        spawn_thread_in_stack_func: u32,
+        threads_table: u32,
         imported_func_count: u32,
         static_func_count: u32,
         imported_global_count: u32,
-    ) -> HQResult<WInstruction<'static>> {
+    ) -> HQResult<Box<[WInstruction<'static>]>> {
         Ok(match self {
-            Self::Immediate(instr) => instr.clone(),
+            Self::Immediate(instr) => Box::from([instr.clone()]),
             #[cfg(test)]
-            Self::LazyStepRef(_step) => {
-                WInstruction::RefFunc(imported_func_count + static_func_count)
-            }
+            Self::LazyStepRef(_step) => Box::from([WInstruction::RefFunc(
+                imported_func_count + static_func_count,
+            )]),
             #[cfg(not(test))]
             Self::LazyStepRef(step) => {
                 let step_index: u32 = steps
@@ -49,7 +58,121 @@ impl Instruction {
                     .ok_or_else(|| make_hq_bug!("couldn't find step in step map"))?
                     .try_into()
                     .map_err(|_| make_hq_bug!("step index out of bounds"))?;
-                WInstruction::RefFunc(imported_func_count + static_func_count + step_index)
+                Box::from([WInstruction::RefFunc(
+                    imported_func_count + static_func_count + step_index,
+                )])
+            }
+            Self::LazyBroadcastSpawn(broadcast) => {
+                let broadcast_indices = events
+                    .get(&Event::Broadcast(broadcast.clone()))
+                    .cloned()
+                    .unwrap_or_default();
+
+                // todo: these should begin execution in the same step, I think, possibly immediately?
+
+                broadcast_indices
+                    .iter()
+                    .flat_map(|&i| {
+                        [
+                            WInstruction::RefFunc(i + imported_func_count + static_func_count),
+                            WInstruction::RefNull(HeapType::Abstract {
+                                shared: false,
+                                ty: AbstractHeapType::Struct,
+                            }),
+                            WInstruction::Call(spawn_new_thread_func + imported_func_count),
+                        ]
+                    })
+                    .chain([
+                        WInstruction::GlobalGet(threads_count_global + imported_global_count),
+                        WInstruction::I32Const(
+                            i32::try_from(broadcast_indices.len())
+                                .map_err(|_| make_hq_bug!("indices len out of bounds"))?,
+                        ),
+                        WInstruction::I32Add,
+                        WInstruction::GlobalSet(threads_count_global + imported_global_count),
+                    ])
+                    .collect()
+            }
+            Self::LazyBroadcastSpawnAndWait((broadcast, poll_step, next_step, arr_local)) => {
+                let broadcast_indices = events
+                    .get(&Event::Broadcast(broadcast.clone()))
+                    .cloned()
+                    .unwrap_or_default();
+
+                let i32_array_type = types.array(StorageType::Val(ValType::I32), true)?;
+                let thread_poll_struct = types.struct_(vec![FieldType {
+                    element_type: StorageType::Val(ValType::Ref(RefType {
+                        nullable: false,
+                        heap_type: HeapType::Concrete(i32_array_type),
+                    })),
+                    mutable: false,
+                }])?;
+
+                let poll_step_index: u32 = steps
+                    .try_borrow()?
+                    .get_index_of(poll_step)
+                    .ok_or_else(|| make_hq_bug!("couldn't find poll_step in step map"))?
+                    .try_into()
+                    .map_err(|_| make_hq_bug!("poll_step index out of bounds"))?;
+
+                let next_step_index: u32 = steps
+                    .try_borrow()?
+                    .get_index_of(next_step)
+                    .ok_or_else(|| make_hq_bug!("couldn't find next_step in step map"))?
+                    .try_into()
+                    .map_err(|_| make_hq_bug!("next_step index out of bounds"))?;
+
+                let broadcast_num = i32::try_from(broadcast_indices.len())
+                    .map_err(|_| make_hq_bug!("indices len out of bounds"))?;
+
+                [
+                    WInstruction::I32Const(broadcast_num),
+                    WInstruction::ArrayNewDefault(i32_array_type),
+                    WInstruction::LocalSet(*arr_local),
+                ]
+                .into_iter()
+                .chain(
+                    broadcast_indices
+                        .iter()
+                        .enumerate()
+                        .map(|(j, &i)| {
+                            // todo: should these should begin execution in the same step?
+                            Ok([
+                                WInstruction::LocalGet(*arr_local),
+                                WInstruction::I32Const(
+                                    j.try_into()
+                                        .map_err(|_| make_hq_bug!("index out of bounds"))?,
+                                ),
+                                WInstruction::TableSize(threads_table),
+                                WInstruction::ArraySet(i32_array_type),
+                                WInstruction::RefFunc(i + imported_func_count + static_func_count),
+                                WInstruction::RefNull(HeapType::Abstract {
+                                    shared: false,
+                                    ty: AbstractHeapType::Struct,
+                                }),
+                                WInstruction::Call(spawn_new_thread_func + imported_func_count),
+                            ])
+                        })
+                        .collect::<HQResult<Box<[_]>>>()?
+                        .into_iter()
+                        .flatten(),
+                )
+                .chain([
+                    WInstruction::GlobalGet(threads_count_global + imported_global_count),
+                    WInstruction::I32Const(broadcast_num),
+                    WInstruction::I32Add,
+                    WInstruction::GlobalSet(threads_count_global + imported_global_count),
+                    WInstruction::RefFunc(
+                        poll_step_index + imported_func_count + static_func_count,
+                    ),
+                    WInstruction::LocalGet(*arr_local),
+                    WInstruction::StructNew(thread_poll_struct),
+                    WInstruction::RefFunc(
+                        next_step_index + imported_func_count + static_func_count,
+                    ),
+                    WInstruction::Call(spawn_thread_in_stack_func + imported_func_count),
+                ])
+                .collect()
             }
             Self::LazyStepIndex(step) => {
                 let step_index: i32 = steps
@@ -62,7 +185,7 @@ impl Instruction {
                     .ok_or_else(|| make_hq_bug!("couldn't find step in step map"))?
                     .try_into()
                     .map_err(|_| make_hq_bug!("step index out of bounds"))?;
-                WInstruction::I32Const(step_index)
+                Box::from([WInstruction::I32Const(step_index)])
             }
             Self::LazyWarpedProcCall(proc) => {
                 let Some(ref warped_specific_proc) = *proc.warped_specific_proc() else {
@@ -77,7 +200,9 @@ impl Instruction {
                     .ok_or_else(|| make_hq_bug!("couldn't find step in step map"))?
                     .try_into()
                     .map_err(|_| make_hq_bug!("step index out of bounds"))?;
-                WInstruction::Call(imported_func_count + static_func_count + step_index)
+                Box::from([WInstruction::Call(
+                    imported_func_count + static_func_count + step_index,
+                )])
             }
             Self::LazyNonWarpedProcRef(proc) => {
                 let Some(ref nonwarped_specific_proc) = *proc.nonwarped_specific_proc() else {
@@ -92,17 +217,21 @@ impl Instruction {
                     .ok_or_else(|| make_hq_bug!("couldn't find step in step map"))?
                     .try_into()
                     .map_err(|_| make_hq_bug!("step index out of bounds"))?;
-                WInstruction::RefFunc(imported_func_count + static_func_count + step_index)
+                Box::from([WInstruction::RefFunc(
+                    imported_func_count + static_func_count + step_index,
+                )])
             }
             Self::LazyGlobalGet(idx) => {
                 // crate::log!("global get {idx}. imported globals: {imported_global_count}");
-                WInstruction::GlobalGet(idx + imported_global_count)
+                Box::from([WInstruction::GlobalGet(idx + imported_global_count)])
             }
             Self::LazyGlobalSet(idx) => {
                 // crate::log!("global get {idx}. imported globals: {imported_global_count}");
-                WInstruction::GlobalSet(idx + imported_global_count)
+                Box::from([WInstruction::GlobalSet(idx + imported_global_count)])
+            }
+            Self::StaticFunctionCall(idx) => {
+                Box::from([WInstruction::Call(imported_func_count + idx)])
             }
-            Self::StaticFunctionCall(idx) => WInstruction::Call(imported_func_count + idx),
         })
     }
 }
@@ -252,18 +381,32 @@ impl StepFunc {
         funcs: &mut FunctionSection,
         code: &mut CodeSection,
         steps: &Rc<RefCell<IndexMap<Rc<Step>, Self>>>,
+        events: &BTreeMap<Event, Vec<u32>>,
+        types: &Rc<TypeRegistry>,
+        threads_count_global: u32,
+        spawn_new_thread_func: u32,
+        spawn_thread_in_stack_func: u32,
+        threads_table: u32,
         imported_func_count: u32,
         static_func_count: u32,
         imported_global_count: u32,
     ) -> HQResult<()> {
         let mut func = Function::new_with_locals_types(self.locals.take());
         for instruction in self.instructions().take() {
-            func.instruction(&instruction.eval(
+            for real_instruction in instruction.eval(
                 steps,
+                events,
+                types,
+                threads_count_global,
+                spawn_new_thread_func,
+                spawn_thread_in_stack_func,
+                threads_table,
                 imported_func_count,
                 static_func_count,
                 imported_global_count,
-            )?);
+            )? {
+                func.instruction(&real_instruction);
+            }
         }
         func.instruction(&wasm_encoder::Instruction::End);
         let type_index = self
diff --git a/src/wasm/project.rs b/src/wasm/project.rs
index 6be3bd50..7a727e40 100644
--- a/src/wasm/project.rs
+++ b/src/wasm/project.rs
@@ -1,7 +1,3 @@
-use super::{ExternalEnvironment, GlobalExportable, GlobalMutable, Registries};
-use crate::ir::{Event, IrProject, Step, Target as IrTarget, Type as IrType};
-use crate::prelude::*;
-use crate::wasm::{StepFunc, StringsTable, ThreadsTable, WasmFlags};
 use itertools::Itertools;
 use wasm_bindgen::prelude::*;
 use wasm_encoder::{
@@ -12,6 +8,12 @@ use wasm_encoder::{
 };
 use wasm_gen::wasm;
 
+use super::{ExternalEnvironment, GlobalExportable, GlobalMutable, Registries};
+use crate::ir::{Event, IrProject, Step, Target as IrTarget, Type as IrType};
+use crate::prelude::*;
+use crate::wasm::registries::functions::static_functions::{SpawnNewThread, SpawnThreadInStack};
+use crate::wasm::{StepFunc, StringsTable, ThreadsTable, WasmFlags};
+
 /// A respresentation of a WASM representation of a project. Cannot be created directly;
 /// use `TryFrom<IrProject>`.
 pub struct WasmProject {
@@ -130,6 +132,26 @@ impl WasmProject {
             .clone()
             .finish(&mut imports, self.registries().types())?;
 
+        self.registries()
+            .static_functions()
+            .register_override::<SpawnNewThread, usize, _>((
+                self.registries().types().step_func_type()?,
+                self.registries().types().stack_struct_type()?,
+                self.registries().types().stack_array_type()?,
+                self.registries().types().thread_struct_type()?,
+                self.threads_table_index()?,
+            ))?;
+
+        self.registries()
+            .static_functions()
+            .register_override::<SpawnThreadInStack, usize, _>((
+                self.registries().types().step_func_type()?,
+                self.registries().types().stack_struct_type()?,
+                self.registries().types().stack_array_type()?,
+                self.registries().types().thread_struct_type()?,
+                self.threads_table_index()?,
+            ))?;
+
         self.registries().static_functions().clone().finish(
             &mut functions,
             &mut codes,
@@ -141,6 +163,12 @@ impl WasmProject {
                 &mut functions,
                 &mut codes,
                 self.steps(),
+                &self.events,
+                self.registries().types(),
+                self.threads_count_global()?,
+                self.spawn_new_thread_func()?,
+                self.spawn_thread_in_stack_func()?,
+                self.threads_table_index()?,
                 self.imported_func_count()?,
                 self.static_func_count()?,
                 self.imported_global_count()?,
@@ -168,7 +196,10 @@ impl WasmProject {
 
         elements.declared(Elements::Functions(
             (self.imported_func_count()? + self.static_func_count()?
-                ..functions.len() + self.imported_func_count()? + self.static_func_count()? - 2)
+                ..self.imported_func_count()?
+                    + self.static_func_count()?
+                    + u32::try_from(self.steps().try_borrow()?.len())
+                        .map_err(|_| make_hq_bug!("steps len out of bounds"))?)
                 .collect(),
         ));
 
@@ -293,6 +324,42 @@ impl WasmProject {
         self.registries().tables().register::<ThreadsTable, _>()
     }
 
+    fn spawn_new_thread_func<N>(&self) -> HQResult<N>
+    where
+        N: TryFrom<usize>,
+        <N as TryFrom<usize>>::Error: fmt::Debug,
+    {
+        self.registries()
+            .static_functions()
+            .register::<SpawnNewThread, _>()
+    }
+
+    fn spawn_thread_in_stack_func<N>(&self) -> HQResult<N>
+    where
+        N: TryFrom<usize>,
+        <N as TryFrom<usize>>::Error: fmt::Debug,
+    {
+        self.registries()
+            .static_functions()
+            .register::<SpawnThreadInStack, _>()
+    }
+
+    fn threads_count_global<N>(&self) -> HQResult<N>
+    where
+        N: TryFrom<usize>,
+        <N as TryFrom<usize>>::Error: fmt::Debug,
+    {
+        self.registries().globals().register(
+            "threads_count".into(),
+            (
+                ValType::I32,
+                ConstExpr::i32_const(0),
+                GlobalMutable(true),
+                GlobalExportable(true),
+            ),
+        )
+    }
+
     fn finish_event(
         &self,
         export_name: &str,
@@ -303,59 +370,40 @@ impl WasmProject {
     ) -> HQResult<()> {
         let mut func = Function::new(vec![]);
 
-        let threads_count = self.registries().globals().register(
-            "threads_count".into(),
-            (
-                ValType::I32,
-                ConstExpr::i32_const(0),
-                GlobalMutable(true),
-                GlobalExportable(true),
-            ),
-        )?;
+        let threads_count = self.threads_count_global()?;
 
-        let stack_struct_ty = self.registries().types().stack_struct_type()?;
-        let stack_array_ty = self.registries().types().stack_array_type()?;
-        let thread_struct_ty = self.registries().types().thread_struct_type()?;
+        let spawn_new_thread = self.spawn_new_thread_func()?;
 
         let instrs = indices
             .iter()
             .map(|&i| {
                 Ok(wasm![
-                    I32Const(1),
                     RefFunc(i + self.imported_func_count()? + self.static_func_count()?),
                     RefNull(HeapType::Abstract {
                         shared: false,
                         ty: AbstractHeapType::Struct
                     }),
-                    StructNew(stack_struct_ty),
-                    // todo: play around with initial size of stack array
-                    RefNull(HeapType::Concrete(stack_struct_ty)),
-                    RefNull(HeapType::Concrete(stack_struct_ty)),
-                    RefNull(HeapType::Concrete(stack_struct_ty)),
-                    RefNull(HeapType::Concrete(stack_struct_ty)),
-                    RefNull(HeapType::Concrete(stack_struct_ty)),
-                    RefNull(HeapType::Concrete(stack_struct_ty)),
-                    RefNull(HeapType::Concrete(stack_struct_ty)),
-                    ArrayNewFixed {
-                        array_size: 8,
-                        array_type_index: stack_array_ty,
-                    },
-                    StructNew(thread_struct_ty),
-                    I32Const(1),
-                    TableGrow(self.threads_table_index()?),
-                    Drop,
+                    #StaticFunctionCall(spawn_new_thread),
                 ])
             })
             .flatten_ok()
             .collect::<HQResult<Vec<_>>>()?;
 
         for instruction in instrs {
-            func.instruction(&instruction.eval(
+            for real_instruction in instruction.eval(
                 self.steps(),
+                &self.events,
+                self.registries().types(),
+                self.threads_count_global()?,
+                self.spawn_new_thread_func()?,
+                self.spawn_thread_in_stack_func()?,
+                self.threads_table_index()?,
                 self.imported_func_count()?,
                 self.static_func_count()?,
                 self.imported_global_count()?,
-            )?);
+            )? {
+                func.instruction(&real_instruction);
+            }
         }
         for instruction in wasm![
             #LazyGlobalGet(threads_count),
@@ -366,12 +414,20 @@ impl WasmProject {
             I32Add,
             #LazyGlobalSet(threads_count)
         ] {
-            func.instruction(&instruction.eval(
+            for real_instruction in instruction.eval(
                 self.steps(),
+                &self.events,
+                self.registries().types(),
+                self.threads_count_global()?,
+                self.spawn_new_thread_func()?,
+                self.spawn_thread_in_stack_func()?,
+                self.threads_table_index()?,
                 self.imported_func_count()?,
                 self.static_func_count()?,
                 self.imported_global_count()?,
-            )?);
+            )? {
+                func.instruction(&real_instruction);
+            }
         }
         func.instruction(&Instruction::End);
 
@@ -396,6 +452,7 @@ impl WasmProject {
             self.finish_event(
                 match event {
                     Event::FlagCLicked => "flag_clicked",
+                    Event::Broadcast(_) => continue, // broadcasts handled in the sender blocks
                 },
                 indices,
                 funcs,
@@ -498,12 +555,20 @@ impl WasmProject {
             End,
         ];
         for instr in instructions {
-            tick_func.instruction(&instr.eval(
+            for real_instruction in instr.eval(
                 self.steps(),
+                &self.events,
+                self.registries().types(),
+                self.threads_count_global()?,
+                self.spawn_new_thread_func()?,
+                self.spawn_thread_in_stack_func()?,
+                self.threads_table_index()?,
                 self.imported_func_count()?,
                 self.static_func_count()?,
                 self.imported_global_count()?,
-            )?);
+            )? {
+                tick_func.instruction(&real_instruction);
+            }
         }
         tick_func.instruction(&Instruction::End);
         funcs.function(self.registries().types().function(vec![], vec![])?);
@@ -549,7 +614,7 @@ impl WasmProject {
         }
         // add thread event handlers for them
         for thread in ir_project.threads().try_borrow()?.iter() {
-            events.entry(thread.event()).or_default().push(
+            events.entry(thread.event().clone()).or_default().push(
                 u32::try_from(
                     steps
                         .try_borrow()?
@@ -588,12 +653,17 @@ mod tests {
     use super::{Registries, WasmProject};
     use crate::ir::{IrProject, Step, Target as IrTarget};
     use crate::prelude::*;
-    use crate::wasm::{ExternalEnvironment, StepFunc, WasmFlags, flags::all_wasm_features};
+    use crate::wasm::flags::all_wasm_features;
+    use crate::wasm::{ExternalEnvironment, StepFunc, WasmFlags};
 
     #[test]
     fn empty_project_is_valid_wasm() {
         let registries = Rc::new(Registries::default());
-        let project = Rc::new(IrProject::new(BTreeMap::default(), BTreeMap::default()));
+        let project = Rc::new(IrProject::new(
+            BTreeMap::default(),
+            BTreeMap::default(),
+            Box::from([]),
+        ));
         let steps = Rc::new(RefCell::new(IndexMap::default()));
         StepFunc::compile_step(
             Step::new_empty(
diff --git a/src/wasm/registries.rs b/src/wasm/registries.rs
index da558666..b12a1ff5 100644
--- a/src/wasm/registries.rs
+++ b/src/wasm/registries.rs
@@ -7,7 +7,6 @@ pub mod targets;
 pub mod types;
 pub mod variables;
 
-use crate::prelude::*;
 pub use functions::{ExternalFunctionRegistry, StaticFunctionRegistry};
 pub use globals::{GlobalExportable, GlobalMutable, GlobalRegistry};
 pub use lists::ListRegistry;
@@ -17,6 +16,8 @@ pub use targets::SpriteRegistry;
 pub use types::TypeRegistry;
 pub use variables::VariableRegistry;
 
+use crate::prelude::*;
+
 pub struct Registries {
     strings: Rc<StringRegistry>,
     tabled_strings: Rc<TabledStringRegistry>,
diff --git a/src/wasm/registries/functions.rs b/src/wasm/registries/functions.rs
index 48e6df30..8a61cde7 100644
--- a/src/wasm/registries/functions.rs
+++ b/src/wasm/registries/functions.rs
@@ -1,13 +1,14 @@
 #![allow(clippy::cast_possible_wrap, reason = "can't use try_into in const")]
 
-use super::TypeRegistry;
-use crate::prelude::*;
-use crate::registry::{MapRegistry, Registry};
 use wasm_encoder::{
     CodeSection, EntityType, Function, FunctionSection, ImportSection, Instruction as WInstruction,
     ValType,
 };
 
+use super::TypeRegistry;
+use crate::prelude::*;
+use crate::registry::{MapRegistry, Registry};
+
 pub type ExternalFunctionRegistry =
     MapRegistry<(&'static str, Box<str>), (Vec<ValType>, Vec<ValType>)>;
 
@@ -23,15 +24,21 @@ impl ExternalFunctionRegistry {
 
 #[derive(Clone)]
 pub struct StaticFunction {
-    pub instructions: &'static [WInstruction<'static>],
-    pub params: &'static [ValType],
-    pub returns: &'static [ValType],
-    pub locals: &'static [ValType],
+    pub instructions: Box<[WInstruction<'static>]>,
+    pub params: Box<[ValType]>,
+    pub returns: Box<[ValType]>,
+    pub locals: Box<[ValType]>,
+}
+
+#[derive(Clone)]
+pub struct MaybeStaticFunction {
+    pub static_function: Option<StaticFunction>,
+    pub maybe_populate: fn() -> Option<StaticFunction>,
 }
 
 pub struct StaticFunctionRegistrar;
 impl RegistryType for StaticFunctionRegistrar {
-    type Value = StaticFunction;
+    type Value = MaybeStaticFunction;
 }
 pub type StaticFunctionRegistry = NamedRegistry<StaticFunctionRegistrar>;
 
@@ -44,19 +51,29 @@ impl StaticFunctionRegistry {
     ) -> HQResult<()> {
         for (
             _name,
-            StaticFunction {
+            MaybeStaticFunction {
+                static_function,
+                maybe_populate,
+            },
+        ) in self.registry().take()
+        {
+            let Some(StaticFunction {
                 instructions,
                 params,
                 returns,
                 locals,
-            },
-        ) in self.registry().take()
-        {
+            }) = static_function.map_or_else(maybe_populate, Some)
+            else {
+                hq_bug!(
+                    "static functions must either be overriden, or have a non-None maybe_populate \
+                     field"
+                )
+            };
             let type_index = type_registry.function(params.into(), returns.into())?;
             functions.function(type_index);
             let mut func = Function::new_with_locals_types(locals.iter().copied());
             for instruction in instructions {
-                func.instruction(instruction);
+                func.instruction(&instruction);
             }
             codes.function(&func);
         }
@@ -65,13 +82,187 @@ impl StaticFunctionRegistry {
 }
 
 pub mod static_functions {
-    use super::StaticFunction;
-    use crate::prelude::*;
-    use crate::wasm::{f32_to_ieeef32, mem_layout};
     use mem_layout::{sprite as sprite_layout, stage as stage_layout};
-    use wasm_encoder::{BlockType as WasmBlockType, MemArg, ValType};
+    use wasm_encoder::{
+        AbstractHeapType, BlockType as WasmBlockType, HeapType, MemArg, RefType, ValType,
+    };
     use wasm_gen::wasm_const;
 
+    use super::{MaybeStaticFunction, StaticFunction};
+    use crate::prelude::*;
+    use crate::wasm::{f32_to_ieeef32, mem_layout};
+
+    /// Spawns a new thread in the same stack (i.e. a thread that yields back to the current
+    /// thread once it completes.)
+    ///
+    /// Takes 4 parameters:
+    /// - i32 - the current thread index
+    /// - step funcref - the step to spawn
+    /// - structref - the structref to pass to the step being spawned
+    /// - step funcref - the step to return to after
+    pub struct SpawnThreadInStack;
+    impl NamedRegistryItem<MaybeStaticFunction> for SpawnThreadInStack {
+        const VALUE: MaybeStaticFunction = MaybeStaticFunction {
+            static_function: None,
+            maybe_populate: || None,
+        };
+    }
+    pub type SpawnThreadInStackOverride = (u32, u32, u32, u32, u32);
+    impl NamedRegistryItemOverride<MaybeStaticFunction, SpawnThreadInStackOverride>
+        for SpawnThreadInStack
+    {
+        fn r#override(
+            (func_ty, stack_struct_type, stack_array_type, thread_struct_type, threads_table): SpawnThreadInStackOverride,
+        ) -> MaybeStaticFunction {
+            MaybeStaticFunction {
+                static_function: Some(StaticFunction {
+                    instructions: Box::from(wasm_const![
+                        LocalGet(1),
+                        LocalGet(2),
+                        StructNew(stack_struct_type),
+                        LocalSet(4),
+                        LocalGet(0),
+                        TableGet(threads_table),
+                        RefAsNonNull,
+                        LocalTee(5),
+                        StructGet {
+                            struct_type_index: thread_struct_type,
+                            field_index: 1,
+                        },
+                        LocalGet(5),
+                        StructGet {
+                            struct_type_index: thread_struct_type,
+                            field_index: 0,
+                        },
+                        LocalGet(4),
+                        // todo: consider the case where we need to resize the array
+                        ArraySet(stack_array_type),
+                        LocalGet(5),
+                        StructGet {
+                            struct_type_index: thread_struct_type,
+                            field_index: 1,
+                        },
+                        LocalGet(5),
+                        StructGet {
+                            struct_type_index: thread_struct_type,
+                            field_index: 0,
+                        },
+                        I32Const(1),
+                        I32Sub,
+                        ArrayGet(stack_array_type),
+                        LocalGet(3),
+                        StructSet {
+                            struct_type_index: stack_struct_type,
+                            field_index: 0,
+                        },
+                        LocalGet(5),
+                        LocalGet(5),
+                        StructGet {
+                            struct_type_index: thread_struct_type,
+                            field_index: 0,
+                        },
+                        I32Const(1),
+                        I32Add,
+                        StructSet {
+                            struct_type_index: thread_struct_type,
+                            field_index: 0,
+                        },
+                        End
+                    ] as &[_]),
+                    params: Box::from([
+                        ValType::I32,
+                        ValType::Ref(RefType {
+                            nullable: false,
+                            heap_type: HeapType::Concrete(func_ty),
+                        }),
+                        ValType::Ref(RefType {
+                            nullable: true,
+                            heap_type: wasm_encoder::HeapType::Abstract {
+                                shared: false,
+                                ty: AbstractHeapType::Struct,
+                            },
+                        }),
+                        ValType::Ref(RefType {
+                            nullable: false,
+                            heap_type: HeapType::Concrete(func_ty),
+                        }),
+                    ]),
+                    returns: Box::from([]),
+                    locals: Box::from([
+                        ValType::Ref(RefType {
+                            nullable: false,
+                            heap_type: HeapType::Concrete(stack_struct_type),
+                        }),
+                        ValType::Ref(RefType {
+                            nullable: false,
+                            heap_type: HeapType::Concrete(thread_struct_type),
+                        }),
+                    ]),
+                }),
+                maybe_populate: || None,
+            }
+        }
+    }
+
+    pub struct SpawnNewThread;
+    impl NamedRegistryItem<MaybeStaticFunction> for SpawnNewThread {
+        const VALUE: MaybeStaticFunction = MaybeStaticFunction {
+            static_function: None,
+            maybe_populate: || None,
+        };
+    }
+    pub type SpawnNewThreadOverride = (u32, u32, u32, u32, u32);
+    impl NamedRegistryItemOverride<MaybeStaticFunction, SpawnNewThreadOverride> for SpawnNewThread {
+        fn r#override(
+            (func_ty, stack_struct_ty, stack_array_ty, thread_struct_ty, threads_table_index): SpawnNewThreadOverride,
+        ) -> MaybeStaticFunction {
+            MaybeStaticFunction {
+                static_function: Some(StaticFunction {
+                    params: Box::from([
+                        ValType::Ref(RefType {
+                            nullable: false,
+                            heap_type: HeapType::Concrete(func_ty),
+                        }),
+                        ValType::Ref(RefType {
+                            nullable: true,
+                            heap_type: wasm_encoder::HeapType::Abstract {
+                                shared: false,
+                                ty: AbstractHeapType::Struct,
+                            },
+                        }),
+                    ]),
+                    returns: Box::from([]),
+                    locals: Box::from([]),
+                    instructions: (wasm_const![
+                        I32Const(1),
+                        LocalGet(0),
+                        LocalGet(1),
+                        StructNew(stack_struct_ty),
+                        // todo: play around with initial size of stack array
+                        RefNull(HeapType::Concrete(stack_struct_ty)),
+                        RefNull(HeapType::Concrete(stack_struct_ty)),
+                        RefNull(HeapType::Concrete(stack_struct_ty)),
+                        RefNull(HeapType::Concrete(stack_struct_ty)),
+                        RefNull(HeapType::Concrete(stack_struct_ty)),
+                        RefNull(HeapType::Concrete(stack_struct_ty)),
+                        RefNull(HeapType::Concrete(stack_struct_ty)),
+                        ArrayNewFixed {
+                            array_size: 8,
+                            array_type_index: stack_array_ty,
+                        },
+                        StructNew(thread_struct_ty),
+                        I32Const(1),
+                        TableGrow(threads_table_index),
+                        Drop,
+                        End,
+                    ] as &[_])
+                        .into(),
+                }),
+                maybe_populate: || None,
+            }
+        }
+    }
+
     index_counter! {
         hsv2rgb_locals
         SPRITE_INDEX
@@ -85,259 +276,266 @@ pub mod static_functions {
     }
 
     pub struct UpdatePenColorFromHSV;
-    impl NamedRegistryItem<StaticFunction> for UpdatePenColorFromHSV {
-        const VALUE: StaticFunction = StaticFunction {
-            params: &[ValType::I32],
-            returns: &[],
-            locals: &const {
-                const PARAMS_NUM: usize = 1;
-                let mut locals = [ValType::I32; hsv2rgb_locals::BLOCK_SIZE as usize - PARAMS_NUM];
-                locals[hsv2rgb_locals::VAL_F as usize - PARAMS_NUM] = ValType::F32;
-                locals
+    impl NamedRegistryItem<MaybeStaticFunction> for UpdatePenColorFromHSV {
+        const VALUE: MaybeStaticFunction = MaybeStaticFunction {
+            static_function: None,
+            maybe_populate: || {
+                Some(StaticFunction {
+                    params: Box::from([ValType::I32]),
+                    returns: Box::from([]),
+                    locals: Box::from({
+                        const PARAMS_NUM: usize = 1;
+                        let mut locals =
+                            [ValType::I32; hsv2rgb_locals::BLOCK_SIZE as usize - PARAMS_NUM];
+                        locals[hsv2rgb_locals::VAL_F as usize - PARAMS_NUM] = ValType::F32;
+                        locals
+                    }),
+                    instructions: (wasm_const![
+                        // hsv->rgb based off of https://stackoverflow.com/a/14733008
+                        LocalGet(hsv2rgb_locals::SPRITE_INDEX),
+                        I32Const(sprite_layout::BLOCK_SIZE as i32),
+                        I32Mul,
+                        I32Const(stage_layout::BLOCK_SIZE as i32),
+                        I32Add,
+                        LocalTee(hsv2rgb_locals::MEM_POS), // position in memory of sprite info
+                        F32Load(MemArg {
+                            offset: sprite_layout::PEN_COLOR.into(),
+                            align: 2,
+                            memory_index: 0,
+                        }),
+                        F32Const(f32_to_ieeef32(2.55)),
+                        F32Mul,
+                        I32TruncF32S,
+                        LocalSet(hsv2rgb_locals::HUE),
+                        LocalGet(hsv2rgb_locals::MEM_POS),
+                        F32Load(MemArg {
+                            offset: sprite_layout::PEN_SATURATION.into(),
+                            align: 2,
+                            memory_index: 0,
+                        }),
+                        F32Const(f32_to_ieeef32(2.55)),
+                        F32Mul,
+                        I32TruncF32S,
+                        LocalSet(hsv2rgb_locals::SAT), // saturation ∈ [0, 256)
+                        LocalGet(hsv2rgb_locals::MEM_POS),
+                        F32Load(MemArg {
+                            offset: sprite_layout::PEN_BRIGHTNESS.into(),
+                            align: 2,
+                            memory_index: 0,
+                        }),
+                        F32Const(f32_to_ieeef32(2.55)),
+                        F32Mul,
+                        I32TruncF32S,
+                        LocalSet(hsv2rgb_locals::VAL), // value ∈ [0, 256)
+                        LocalGet(hsv2rgb_locals::MEM_POS),
+                        F32Const(f32_to_ieeef32(100.0)),
+                        LocalGet(hsv2rgb_locals::MEM_POS),
+                        F32Load(MemArg {
+                            offset: sprite_layout::PEN_TRANSPARENCY.into(),
+                            align: 2,
+                            memory_index: 0,
+                        }), // transparency ∈ [0, 100]
+                        F32Sub,
+                        F32Const(f32_to_ieeef32(100.0)),
+                        F32Div, // alpha ∈ [0, 1]
+                        F32Store(MemArg {
+                            offset: sprite_layout::PEN_COLOR_A.into(),
+                            align: 2,
+                            memory_index: 0,
+                        }),
+                        LocalGet(hsv2rgb_locals::MEM_POS),
+                        F32Load(MemArg {
+                            offset: sprite_layout::PEN_COLOR_A.into(),
+                            align: 2,
+                            memory_index: 0,
+                        }),
+                        F32Const(f32_to_ieeef32(0.01)),
+                        F32Lt,
+                        If(WasmBlockType::Empty),
+                        LocalGet(hsv2rgb_locals::MEM_POS),
+                        F32Const(f32_to_ieeef32(0.0)),
+                        F32Store(MemArg {
+                            offset: sprite_layout::PEN_COLOR_A.into(),
+                            align: 2,
+                            memory_index: 0,
+                        }),
+                        Return, // if alpha is 0, return (it is already set to 0 so it doesn't matter what r, g & b are)
+                        End,
+                        LocalGet(hsv2rgb_locals::SAT),
+                        I32Eqz,
+                        If(WasmBlockType::Empty),
+                        LocalGet(hsv2rgb_locals::VAL),
+                        F32ConvertI32S,
+                        F32Const(f32_to_ieeef32(255.0)),
+                        F32Div,
+                        LocalSet(hsv2rgb_locals::VAL_F),
+                        LocalGet(hsv2rgb_locals::MEM_POS),
+                        LocalGet(hsv2rgb_locals::VAL_F),
+                        F32Store(MemArg {
+                            offset: sprite_layout::PEN_COLOR_R.into(),
+                            align: 2,
+                            memory_index: 0,
+                        }),
+                        LocalGet(hsv2rgb_locals::MEM_POS),
+                        LocalGet(hsv2rgb_locals::VAL_F),
+                        F32Store(MemArg {
+                            offset: sprite_layout::PEN_COLOR_G.into(),
+                            align: 2,
+                            memory_index: 0,
+                        }),
+                        LocalGet(hsv2rgb_locals::MEM_POS),
+                        LocalGet(hsv2rgb_locals::VAL_F),
+                        F32Store(MemArg {
+                            offset: sprite_layout::PEN_COLOR_B.into(),
+                            align: 2,
+                            memory_index: 0,
+                        }),
+                        Return,
+                        End,
+                        LocalGet(hsv2rgb_locals::HUE),
+                        I32Const(43),
+                        I32DivU,
+                        LocalSet(hsv2rgb_locals::REGION), // 'region'
+                        LocalGet(hsv2rgb_locals::HUE),
+                        I32Const(43),
+                        I32RemU,
+                        I32Const(6),
+                        I32Mul,
+                        LocalSet(hsv2rgb_locals::REMAINDER), // 'remainder'
+                        I32Const(255),
+                        LocalGet(hsv2rgb_locals::SAT),
+                        I32Sub,
+                        LocalGet(hsv2rgb_locals::VAL),
+                        I32Mul,
+                        I32Const(8),
+                        I32ShrU,
+                        LocalSet(hsv2rgb_locals::P), // 'p'
+                        I32Const(255),
+                        LocalGet(hsv2rgb_locals::REMAINDER),
+                        LocalGet(hsv2rgb_locals::SAT),
+                        I32Mul,
+                        I32Const(8),
+                        I32ShrU,
+                        I32Sub,
+                        LocalGet(hsv2rgb_locals::VAL),
+                        I32Mul,
+                        I32Const(8),
+                        I32ShrU,
+                        LocalSet(hsv2rgb_locals::Q), // 'q'
+                        I32Const(255),
+                        I32Const(255),
+                        LocalGet(hsv2rgb_locals::REMAINDER),
+                        I32Sub,
+                        LocalGet(hsv2rgb_locals::SAT),
+                        I32Mul,
+                        I32Const(8),
+                        I32ShrU,
+                        I32Sub,
+                        LocalGet(hsv2rgb_locals::VAL),
+                        I32Mul,
+                        I32Const(8),
+                        I32ShrU,
+                        LocalSet(hsv2rgb_locals::T), // 't'
+                        LocalGet(hsv2rgb_locals::REGION),
+                        I32Eqz,
+                        If(WasmBlockType::Empty),
+                        LocalGet(hsv2rgb_locals::VAL),
+                        LocalSet(hsv2rgb_locals::R),
+                        LocalGet(hsv2rgb_locals::T),
+                        LocalSet(hsv2rgb_locals::G),
+                        LocalGet(hsv2rgb_locals::P),
+                        LocalSet(hsv2rgb_locals::B),
+                        End,
+                        LocalGet(hsv2rgb_locals::REGION),
+                        I32Const(1),
+                        I32Eq,
+                        If(WasmBlockType::Empty),
+                        LocalGet(hsv2rgb_locals::Q),
+                        LocalSet(hsv2rgb_locals::R),
+                        LocalGet(hsv2rgb_locals::VAL),
+                        LocalSet(hsv2rgb_locals::G),
+                        LocalGet(hsv2rgb_locals::P),
+                        LocalSet(hsv2rgb_locals::B),
+                        End,
+                        LocalGet(hsv2rgb_locals::REGION),
+                        I32Const(2),
+                        I32Eq,
+                        If(WasmBlockType::Empty),
+                        LocalGet(hsv2rgb_locals::P),
+                        LocalSet(hsv2rgb_locals::R),
+                        LocalGet(hsv2rgb_locals::VAL),
+                        LocalSet(hsv2rgb_locals::G),
+                        LocalGet(hsv2rgb_locals::T),
+                        LocalSet(hsv2rgb_locals::B),
+                        End,
+                        LocalGet(hsv2rgb_locals::REGION),
+                        I32Const(3),
+                        I32Eq,
+                        If(WasmBlockType::Empty),
+                        LocalGet(hsv2rgb_locals::P),
+                        LocalSet(hsv2rgb_locals::R),
+                        LocalGet(hsv2rgb_locals::Q),
+                        LocalSet(hsv2rgb_locals::G),
+                        LocalGet(hsv2rgb_locals::VAL),
+                        LocalSet(hsv2rgb_locals::B),
+                        End,
+                        LocalGet(hsv2rgb_locals::REGION),
+                        I32Const(4),
+                        I32Eq,
+                        If(WasmBlockType::Empty),
+                        LocalGet(hsv2rgb_locals::T),
+                        LocalSet(hsv2rgb_locals::R),
+                        LocalGet(hsv2rgb_locals::P),
+                        LocalSet(hsv2rgb_locals::G),
+                        LocalGet(hsv2rgb_locals::VAL),
+                        LocalSet(hsv2rgb_locals::B),
+                        End,
+                        LocalGet(hsv2rgb_locals::REGION),
+                        I32Const(5),
+                        I32Eq,
+                        If(WasmBlockType::Empty),
+                        LocalGet(hsv2rgb_locals::VAL),
+                        LocalSet(hsv2rgb_locals::R),
+                        LocalGet(hsv2rgb_locals::P),
+                        LocalSet(hsv2rgb_locals::G),
+                        LocalGet(hsv2rgb_locals::Q),
+                        LocalSet(hsv2rgb_locals::B),
+                        End,
+                        LocalGet(hsv2rgb_locals::MEM_POS),
+                        LocalGet(hsv2rgb_locals::R),
+                        F32ConvertI32S,
+                        F32Const(f32_to_ieeef32(255.0)),
+                        F32Div,
+                        F32Store(MemArg {
+                            offset: sprite_layout::PEN_COLOR_R.into(),
+                            align: 2,
+                            memory_index: 0,
+                        }),
+                        LocalGet(hsv2rgb_locals::MEM_POS),
+                        LocalGet(hsv2rgb_locals::G),
+                        F32ConvertI32S,
+                        F32Const(f32_to_ieeef32(255.0)),
+                        F32Div,
+                        F32Store(MemArg {
+                            offset: sprite_layout::PEN_COLOR_G.into(),
+                            align: 2,
+                            memory_index: 0,
+                        }),
+                        LocalGet(hsv2rgb_locals::MEM_POS),
+                        LocalGet(hsv2rgb_locals::B),
+                        F32ConvertI32S,
+                        F32Const(f32_to_ieeef32(255.0)),
+                        F32Div,
+                        F32Store(MemArg {
+                            offset: sprite_layout::PEN_COLOR_B.into(),
+                            align: 2,
+                            memory_index: 0,
+                        }),
+                        End,
+                    ] as &[_])
+                        .into(),
+                })
             },
-            instructions: wasm_const![
-                // hsv->rgb based off of https://stackoverflow.com/a/14733008
-                LocalGet(hsv2rgb_locals::SPRITE_INDEX),
-                I32Const(sprite_layout::BLOCK_SIZE as i32),
-                I32Mul,
-                I32Const(stage_layout::BLOCK_SIZE as i32),
-                I32Add,
-                LocalTee(hsv2rgb_locals::MEM_POS), // position in memory of sprite info
-                F32Load(MemArg {
-                    offset: sprite_layout::PEN_COLOR as u64,
-                    align: 2,
-                    memory_index: 0,
-                }),
-                F32Const(f32_to_ieeef32(2.55)),
-                F32Mul,
-                I32TruncF32S,
-                LocalSet(hsv2rgb_locals::HUE),
-                LocalGet(hsv2rgb_locals::MEM_POS),
-                F32Load(MemArg {
-                    offset: sprite_layout::PEN_SATURATION as u64,
-                    align: 2,
-                    memory_index: 0,
-                }),
-                F32Const(f32_to_ieeef32(2.55)),
-                F32Mul,
-                I32TruncF32S,
-                LocalSet(hsv2rgb_locals::SAT), // saturation ∈ [0, 256)
-                LocalGet(hsv2rgb_locals::MEM_POS),
-                F32Load(MemArg {
-                    offset: sprite_layout::PEN_BRIGHTNESS as u64,
-                    align: 2,
-                    memory_index: 0,
-                }),
-                F32Const(f32_to_ieeef32(2.55)),
-                F32Mul,
-                I32TruncF32S,
-                LocalSet(hsv2rgb_locals::VAL), // value ∈ [0, 256)
-                LocalGet(hsv2rgb_locals::MEM_POS),
-                F32Const(f32_to_ieeef32(100.0)),
-                LocalGet(hsv2rgb_locals::MEM_POS),
-                F32Load(MemArg {
-                    offset: sprite_layout::PEN_TRANSPARENCY as u64,
-                    align: 2,
-                    memory_index: 0,
-                }), // transparency ∈ [0, 100]
-                F32Sub,
-                F32Const(f32_to_ieeef32(100.0)),
-                F32Div, // alpha ∈ [0, 1]
-                F32Store(MemArg {
-                    offset: sprite_layout::PEN_COLOR_A as u64,
-                    align: 2,
-                    memory_index: 0,
-                }),
-                LocalGet(hsv2rgb_locals::MEM_POS),
-                F32Load(MemArg {
-                    offset: sprite_layout::PEN_COLOR_A as u64,
-                    align: 2,
-                    memory_index: 0,
-                }),
-                F32Const(f32_to_ieeef32(0.01)),
-                F32Lt,
-                If(WasmBlockType::Empty),
-                LocalGet(hsv2rgb_locals::MEM_POS),
-                F32Const(f32_to_ieeef32(0.0)),
-                F32Store(MemArg {
-                    offset: sprite_layout::PEN_COLOR_A as u64,
-                    align: 2,
-                    memory_index: 0,
-                }),
-                Return, // if alpha is 0, return (it is already set to 0 so it doesn't matter what r, g & b are)
-                End,
-                LocalGet(hsv2rgb_locals::SAT),
-                I32Eqz,
-                If(WasmBlockType::Empty),
-                LocalGet(hsv2rgb_locals::VAL),
-                F32ConvertI32S,
-                F32Const(f32_to_ieeef32(255.0)),
-                F32Div,
-                LocalSet(hsv2rgb_locals::VAL_F),
-                LocalGet(hsv2rgb_locals::MEM_POS),
-                LocalGet(hsv2rgb_locals::VAL_F),
-                F32Store(MemArg {
-                    offset: sprite_layout::PEN_COLOR_R as u64,
-                    align: 2,
-                    memory_index: 0,
-                }),
-                LocalGet(hsv2rgb_locals::MEM_POS),
-                LocalGet(hsv2rgb_locals::VAL_F),
-                F32Store(MemArg {
-                    offset: sprite_layout::PEN_COLOR_G as u64,
-                    align: 2,
-                    memory_index: 0,
-                }),
-                LocalGet(hsv2rgb_locals::MEM_POS),
-                LocalGet(hsv2rgb_locals::VAL_F),
-                F32Store(MemArg {
-                    offset: sprite_layout::PEN_COLOR_B as u64,
-                    align: 2,
-                    memory_index: 0,
-                }),
-                Return,
-                End,
-                LocalGet(hsv2rgb_locals::HUE),
-                I32Const(43),
-                I32DivU,
-                LocalSet(hsv2rgb_locals::REGION), // 'region'
-                LocalGet(hsv2rgb_locals::HUE),
-                I32Const(43),
-                I32RemU,
-                I32Const(6),
-                I32Mul,
-                LocalSet(hsv2rgb_locals::REMAINDER), // 'remainder'
-                I32Const(255),
-                LocalGet(hsv2rgb_locals::SAT),
-                I32Sub,
-                LocalGet(hsv2rgb_locals::VAL),
-                I32Mul,
-                I32Const(8),
-                I32ShrU,
-                LocalSet(hsv2rgb_locals::P), // 'p'
-                I32Const(255),
-                LocalGet(hsv2rgb_locals::REMAINDER),
-                LocalGet(hsv2rgb_locals::SAT),
-                I32Mul,
-                I32Const(8),
-                I32ShrU,
-                I32Sub,
-                LocalGet(hsv2rgb_locals::VAL),
-                I32Mul,
-                I32Const(8),
-                I32ShrU,
-                LocalSet(hsv2rgb_locals::Q), // 'q'
-                I32Const(255),
-                I32Const(255),
-                LocalGet(hsv2rgb_locals::REMAINDER),
-                I32Sub,
-                LocalGet(hsv2rgb_locals::SAT),
-                I32Mul,
-                I32Const(8),
-                I32ShrU,
-                I32Sub,
-                LocalGet(hsv2rgb_locals::VAL),
-                I32Mul,
-                I32Const(8),
-                I32ShrU,
-                LocalSet(hsv2rgb_locals::T), // 't'
-                LocalGet(hsv2rgb_locals::REGION),
-                I32Eqz,
-                If(WasmBlockType::Empty),
-                LocalGet(hsv2rgb_locals::VAL),
-                LocalSet(hsv2rgb_locals::R),
-                LocalGet(hsv2rgb_locals::T),
-                LocalSet(hsv2rgb_locals::G),
-                LocalGet(hsv2rgb_locals::P),
-                LocalSet(hsv2rgb_locals::B),
-                End,
-                LocalGet(hsv2rgb_locals::REGION),
-                I32Const(1),
-                I32Eq,
-                If(WasmBlockType::Empty),
-                LocalGet(hsv2rgb_locals::Q),
-                LocalSet(hsv2rgb_locals::R),
-                LocalGet(hsv2rgb_locals::VAL),
-                LocalSet(hsv2rgb_locals::G),
-                LocalGet(hsv2rgb_locals::P),
-                LocalSet(hsv2rgb_locals::B),
-                End,
-                LocalGet(hsv2rgb_locals::REGION),
-                I32Const(2),
-                I32Eq,
-                If(WasmBlockType::Empty),
-                LocalGet(hsv2rgb_locals::P),
-                LocalSet(hsv2rgb_locals::R),
-                LocalGet(hsv2rgb_locals::VAL),
-                LocalSet(hsv2rgb_locals::G),
-                LocalGet(hsv2rgb_locals::T),
-                LocalSet(hsv2rgb_locals::B),
-                End,
-                LocalGet(hsv2rgb_locals::REGION),
-                I32Const(3),
-                I32Eq,
-                If(WasmBlockType::Empty),
-                LocalGet(hsv2rgb_locals::P),
-                LocalSet(hsv2rgb_locals::R),
-                LocalGet(hsv2rgb_locals::Q),
-                LocalSet(hsv2rgb_locals::G),
-                LocalGet(hsv2rgb_locals::VAL),
-                LocalSet(hsv2rgb_locals::B),
-                End,
-                LocalGet(hsv2rgb_locals::REGION),
-                I32Const(4),
-                I32Eq,
-                If(WasmBlockType::Empty),
-                LocalGet(hsv2rgb_locals::T),
-                LocalSet(hsv2rgb_locals::R),
-                LocalGet(hsv2rgb_locals::P),
-                LocalSet(hsv2rgb_locals::G),
-                LocalGet(hsv2rgb_locals::VAL),
-                LocalSet(hsv2rgb_locals::B),
-                End,
-                LocalGet(hsv2rgb_locals::REGION),
-                I32Const(5),
-                I32Eq,
-                If(WasmBlockType::Empty),
-                LocalGet(hsv2rgb_locals::VAL),
-                LocalSet(hsv2rgb_locals::R),
-                LocalGet(hsv2rgb_locals::P),
-                LocalSet(hsv2rgb_locals::G),
-                LocalGet(hsv2rgb_locals::Q),
-                LocalSet(hsv2rgb_locals::B),
-                End,
-                LocalGet(hsv2rgb_locals::MEM_POS),
-                LocalGet(hsv2rgb_locals::R),
-                F32ConvertI32S,
-                F32Const(f32_to_ieeef32(255.0)),
-                F32Div,
-                F32Store(MemArg {
-                    offset: sprite_layout::PEN_COLOR_R as u64,
-                    align: 2,
-                    memory_index: 0,
-                }),
-                LocalGet(hsv2rgb_locals::MEM_POS),
-                LocalGet(hsv2rgb_locals::G),
-                F32ConvertI32S,
-                F32Const(f32_to_ieeef32(255.0)),
-                F32Div,
-                F32Store(MemArg {
-                    offset: sprite_layout::PEN_COLOR_G as u64,
-                    align: 2,
-                    memory_index: 0,
-                }),
-                LocalGet(hsv2rgb_locals::MEM_POS),
-                LocalGet(hsv2rgb_locals::B),
-                F32ConvertI32S,
-                F32Const(f32_to_ieeef32(255.0)),
-                F32Div,
-                F32Store(MemArg {
-                    offset: sprite_layout::PEN_COLOR_B as u64,
-                    align: 2,
-                    memory_index: 0,
-                }),
-                End,
-            ],
         };
     }
 
@@ -351,217 +549,224 @@ pub mod static_functions {
     }
 
     pub struct UpdatePenColorFromRGB;
-    impl NamedRegistryItem<StaticFunction> for UpdatePenColorFromRGB {
-        const VALUE: StaticFunction = StaticFunction {
-            params: &[ValType::I32],
-            returns: &[],
-            locals: &const {
-                const PARAMS_NUM: usize = 1;
-                let mut locals = [ValType::I32; rgb2hsv_locals::BLOCK_SIZE as usize - PARAMS_NUM];
-                locals[rgb2hsv_locals::A as usize - PARAMS_NUM] = ValType::F32;
-                locals
+    impl NamedRegistryItem<MaybeStaticFunction> for UpdatePenColorFromRGB {
+        const VALUE: MaybeStaticFunction = MaybeStaticFunction {
+            static_function: None,
+            maybe_populate: || {
+                Some(StaticFunction {
+                    params: Box::from([ValType::I32]),
+                    returns: Box::from([]),
+                    locals: Box::from({
+                        const PARAMS_NUM: usize = 1;
+                        let mut locals =
+                            [ValType::I32; rgb2hsv_locals::BLOCK_SIZE as usize - PARAMS_NUM];
+                        locals[rgb2hsv_locals::A as usize - PARAMS_NUM] = ValType::F32;
+                        locals
+                    }),
+                    instructions: (wasm_const![
+                        // rgb->hsv based off of https://stackoverflow.com/a/14733008
+                        LocalGet(rgb2hsv_locals::SPRITE_INDEX),
+                        I32Const(sprite_layout::BLOCK_SIZE as i32),
+                        I32Mul,
+                        I32Const(stage_layout::BLOCK_SIZE as i32),
+                        I32Add,
+                        LocalTee(rgb2hsv_locals::MEM_POS), // position in memory of sprite info
+                        F32Load(MemArg {
+                            offset: sprite_layout::PEN_COLOR_R.into(),
+                            align: 2,
+                            memory_index: 0,
+                        }),
+                        F32Const(f32_to_ieeef32(255.0)),
+                        F32Mul,
+                        I32TruncF32S,
+                        LocalSet(rgb2hsv_locals::R),
+                        LocalGet(rgb2hsv_locals::MEM_POS),
+                        F32Load(MemArg {
+                            offset: sprite_layout::PEN_COLOR_G.into(),
+                            align: 2,
+                            memory_index: 0,
+                        }),
+                        F32Const(f32_to_ieeef32(255.0)),
+                        F32Mul,
+                        I32TruncF32S,
+                        LocalSet(rgb2hsv_locals::G),
+                        LocalGet(rgb2hsv_locals::MEM_POS),
+                        F32Load(MemArg {
+                            offset: sprite_layout::PEN_COLOR_B.into(),
+                            align: 2,
+                            memory_index: 0,
+                        }),
+                        F32Const(f32_to_ieeef32(255.0)),
+                        F32Mul,
+                        I32TruncF32S,
+                        LocalSet(rgb2hsv_locals::B),
+                        LocalGet(rgb2hsv_locals::MEM_POS),
+                        LocalGet(rgb2hsv_locals::MEM_POS),
+                        F32Load(MemArg {
+                            offset: sprite_layout::PEN_COLOR_A.into(),
+                            align: 2,
+                            memory_index: 0,
+                        }), // transparency ∈ [0, 100]
+                        F32Const(f32_to_ieeef32(100.0)),
+                        F32Mul, // alpha ∈ [0, 1]
+                        LocalTee(rgb2hsv_locals::A),
+                        F32Const(f32_to_ieeef32(100.0)),
+                        F32Sub,
+                        F32Store(MemArg {
+                            offset: sprite_layout::PEN_TRANSPARENCY.into(),
+                            align: 2,
+                            memory_index: 0,
+                        }),
+                        // we don't need to check for alpha=0 to shortcircuit, because scratch doesn't allow
+                        // alpha=0 for rgb colours
+                        LocalGet(rgb2hsv_locals::R),
+                        LocalGet(rgb2hsv_locals::G),
+                        LocalGet(rgb2hsv_locals::R),
+                        LocalGet(rgb2hsv_locals::G),
+                        I32LtS,
+                        Select,
+                        LocalTee(rgb2hsv_locals::RGB_MIN),
+                        LocalGet(rgb2hsv_locals::B),
+                        LocalGet(rgb2hsv_locals::RGB_MIN),
+                        LocalGet(rgb2hsv_locals::B),
+                        I32LtS,
+                        Select,
+                        LocalSet(rgb2hsv_locals::RGB_MIN),
+                        LocalGet(rgb2hsv_locals::R),
+                        LocalGet(rgb2hsv_locals::G),
+                        LocalGet(rgb2hsv_locals::R),
+                        LocalGet(rgb2hsv_locals::G),
+                        I32GtS,
+                        Select,
+                        LocalTee(rgb2hsv_locals::RGB_MAX),
+                        LocalGet(rgb2hsv_locals::B),
+                        LocalGet(rgb2hsv_locals::RGB_MAX),
+                        LocalGet(rgb2hsv_locals::B),
+                        I32GtS,
+                        Select,
+                        LocalSet(rgb2hsv_locals::RGB_MAX),
+                        LocalGet(rgb2hsv_locals::MEM_POS),
+                        LocalGet(rgb2hsv_locals::RGB_MAX),
+                        F32ConvertI32S,
+                        F32Const(f32_to_ieeef32(2.55)),
+                        F32Div,
+                        F32Store(MemArg {
+                            offset: sprite_layout::PEN_BRIGHTNESS.into(),
+                            align: 2,
+                            memory_index: 0,
+                        }),
+                        LocalGet(rgb2hsv_locals::RGB_MAX),
+                        I32Eqz,
+                        If(WasmBlockType::Empty),
+                        LocalGet(rgb2hsv_locals::MEM_POS),
+                        F32Const(f32_to_ieeef32(0.0)),
+                        F32Store(MemArg {
+                            offset: sprite_layout::PEN_COLOR.into(),
+                            align: 2,
+                            memory_index: 0,
+                        }),
+                        LocalGet(rgb2hsv_locals::MEM_POS),
+                        F32Const(f32_to_ieeef32(0.0)),
+                        F32Store(MemArg {
+                            offset: sprite_layout::PEN_SATURATION.into(),
+                            align: 2,
+                            memory_index: 0,
+                        }),
+                        Return,
+                        End,
+                        LocalGet(rgb2hsv_locals::RGB_MAX),
+                        LocalGet(rgb2hsv_locals::RGB_MIN),
+                        I32Sub,
+                        I32Const(255),
+                        I32Mul,
+                        LocalGet(rgb2hsv_locals::RGB_MAX),
+                        I32DivS,
+                        LocalTee(rgb2hsv_locals::SAT),
+                        I32Eqz,
+                        If(WasmBlockType::Empty),
+                        LocalGet(rgb2hsv_locals::MEM_POS),
+                        F32Const(f32_to_ieeef32(0.0)),
+                        F32Store(MemArg {
+                            offset: sprite_layout::PEN_COLOR.into(),
+                            align: 2,
+                            memory_index: 0,
+                        }),
+                        LocalGet(rgb2hsv_locals::MEM_POS),
+                        F32Const(f32_to_ieeef32(0.0)),
+                        F32Store(MemArg {
+                            offset: sprite_layout::PEN_SATURATION.into(),
+                            align: 2,
+                            memory_index: 0,
+                        }),
+                        Return,
+                        End,
+                        LocalGet(rgb2hsv_locals::MEM_POS),
+                        LocalGet(rgb2hsv_locals::SAT),
+                        F32ConvertI32S,
+                        F32Const(f32_to_ieeef32(2.55)),
+                        F32Div,
+                        F32Store(MemArg {
+                            offset: sprite_layout::PEN_SATURATION.into(),
+                            align: 2,
+                            memory_index: 0,
+                        }),
+                        LocalGet(rgb2hsv_locals::MEM_POS),
+                        LocalGet(rgb2hsv_locals::RGB_MAX),
+                        LocalGet(rgb2hsv_locals::R),
+                        I32Eq,
+                        If(WasmBlockType::Result(ValType::I32)),
+                        LocalGet(rgb2hsv_locals::G),
+                        LocalGet(rgb2hsv_locals::B),
+                        I32Sub,
+                        LocalGet(rgb2hsv_locals::RGB_MAX),
+                        LocalGet(rgb2hsv_locals::RGB_MIN),
+                        I32Sub,
+                        I32DivS,
+                        I32Const(43),
+                        I32Mul,
+                        Else,
+                        LocalGet(rgb2hsv_locals::RGB_MAX),
+                        LocalGet(rgb2hsv_locals::G),
+                        I32Eq,
+                        If(WasmBlockType::Result(ValType::I32)),
+                        LocalGet(rgb2hsv_locals::B),
+                        LocalGet(rgb2hsv_locals::R),
+                        I32Sub,
+                        LocalGet(rgb2hsv_locals::RGB_MAX),
+                        LocalGet(rgb2hsv_locals::RGB_MIN),
+                        I32Sub,
+                        I32DivS,
+                        I32Const(43),
+                        I32Mul,
+                        I32Const(85),
+                        I32Add,
+                        Else,
+                        LocalGet(rgb2hsv_locals::R),
+                        LocalGet(rgb2hsv_locals::G),
+                        I32Sub,
+                        LocalGet(rgb2hsv_locals::RGB_MAX),
+                        LocalGet(rgb2hsv_locals::RGB_MIN),
+                        I32Sub,
+                        I32DivS,
+                        I32Const(43),
+                        I32Mul,
+                        I32Const(171),
+                        I32Add,
+                        End,
+                        End,
+                        F32ConvertI32S,
+                        F32Const(f32_to_ieeef32(2.55)),
+                        F32Div,
+                        F32Store(MemArg {
+                            offset: sprite_layout::PEN_COLOR.into(),
+                            align: 2,
+                            memory_index: 0,
+                        }),
+                        End,
+                    ] as &[_])
+                        .into(),
+                })
             },
-            instructions: wasm_const![
-                // rgb->hsv based off of https://stackoverflow.com/a/14733008
-                LocalGet(rgb2hsv_locals::SPRITE_INDEX),
-                I32Const(sprite_layout::BLOCK_SIZE as i32),
-                I32Mul,
-                I32Const(stage_layout::BLOCK_SIZE as i32),
-                I32Add,
-                LocalTee(rgb2hsv_locals::MEM_POS), // position in memory of sprite info
-                F32Load(MemArg {
-                    offset: sprite_layout::PEN_COLOR_R as u64,
-                    align: 2,
-                    memory_index: 0,
-                }),
-                F32Const(f32_to_ieeef32(255.0)),
-                F32Mul,
-                I32TruncF32S,
-                LocalSet(rgb2hsv_locals::R),
-                LocalGet(rgb2hsv_locals::MEM_POS),
-                F32Load(MemArg {
-                    offset: sprite_layout::PEN_COLOR_G as u64,
-                    align: 2,
-                    memory_index: 0,
-                }),
-                F32Const(f32_to_ieeef32(255.0)),
-                F32Mul,
-                I32TruncF32S,
-                LocalSet(rgb2hsv_locals::G),
-                LocalGet(rgb2hsv_locals::MEM_POS),
-                F32Load(MemArg {
-                    offset: sprite_layout::PEN_COLOR_B as u64,
-                    align: 2,
-                    memory_index: 0,
-                }),
-                F32Const(f32_to_ieeef32(255.0)),
-                F32Mul,
-                I32TruncF32S,
-                LocalSet(rgb2hsv_locals::B),
-                LocalGet(rgb2hsv_locals::MEM_POS),
-                LocalGet(rgb2hsv_locals::MEM_POS),
-                F32Load(MemArg {
-                    offset: sprite_layout::PEN_COLOR_A as u64,
-                    align: 2,
-                    memory_index: 0,
-                }), // transparency ∈ [0, 100]
-                F32Const(f32_to_ieeef32(100.0)),
-                F32Mul, // alpha ∈ [0, 1]
-                LocalTee(rgb2hsv_locals::A),
-                F32Const(f32_to_ieeef32(100.0)),
-                F32Sub,
-                F32Store(MemArg {
-                    offset: sprite_layout::PEN_TRANSPARENCY as u64,
-                    align: 2,
-                    memory_index: 0,
-                }),
-                // we don't need to check for alpha=0 to shortcircuit, because scratch doesn't allow
-                // alpha=0 for rgb colours
-                LocalGet(rgb2hsv_locals::R),
-                LocalGet(rgb2hsv_locals::G),
-                LocalGet(rgb2hsv_locals::R),
-                LocalGet(rgb2hsv_locals::G),
-                I32LtS,
-                Select,
-                LocalTee(rgb2hsv_locals::RGB_MIN),
-                LocalGet(rgb2hsv_locals::B),
-                LocalGet(rgb2hsv_locals::RGB_MIN),
-                LocalGet(rgb2hsv_locals::B),
-                I32LtS,
-                Select,
-                LocalSet(rgb2hsv_locals::RGB_MIN),
-                LocalGet(rgb2hsv_locals::R),
-                LocalGet(rgb2hsv_locals::G),
-                LocalGet(rgb2hsv_locals::R),
-                LocalGet(rgb2hsv_locals::G),
-                I32GtS,
-                Select,
-                LocalTee(rgb2hsv_locals::RGB_MAX),
-                LocalGet(rgb2hsv_locals::B),
-                LocalGet(rgb2hsv_locals::RGB_MAX),
-                LocalGet(rgb2hsv_locals::B),
-                I32GtS,
-                Select,
-                LocalSet(rgb2hsv_locals::RGB_MAX),
-                LocalGet(rgb2hsv_locals::MEM_POS),
-                LocalGet(rgb2hsv_locals::RGB_MAX),
-                F32ConvertI32S,
-                F32Const(f32_to_ieeef32(2.55)),
-                F32Div,
-                F32Store(MemArg {
-                    offset: sprite_layout::PEN_BRIGHTNESS as u64,
-                    align: 2,
-                    memory_index: 0,
-                }),
-                LocalGet(rgb2hsv_locals::RGB_MAX),
-                I32Eqz,
-                If(WasmBlockType::Empty),
-                LocalGet(rgb2hsv_locals::MEM_POS),
-                F32Const(f32_to_ieeef32(0.0)),
-                F32Store(MemArg {
-                    offset: sprite_layout::PEN_COLOR as u64,
-                    align: 2,
-                    memory_index: 0,
-                }),
-                LocalGet(rgb2hsv_locals::MEM_POS),
-                F32Const(f32_to_ieeef32(0.0)),
-                F32Store(MemArg {
-                    offset: sprite_layout::PEN_SATURATION as u64,
-                    align: 2,
-                    memory_index: 0,
-                }),
-                Return,
-                End,
-                LocalGet(rgb2hsv_locals::RGB_MAX),
-                LocalGet(rgb2hsv_locals::RGB_MIN),
-                I32Sub,
-                I32Const(255),
-                I32Mul,
-                LocalGet(rgb2hsv_locals::RGB_MAX),
-                I32DivS,
-                LocalTee(rgb2hsv_locals::SAT),
-                I32Eqz,
-                If(WasmBlockType::Empty),
-                LocalGet(rgb2hsv_locals::MEM_POS),
-                F32Const(f32_to_ieeef32(0.0)),
-                F32Store(MemArg {
-                    offset: sprite_layout::PEN_COLOR as u64,
-                    align: 2,
-                    memory_index: 0,
-                }),
-                LocalGet(rgb2hsv_locals::MEM_POS),
-                F32Const(f32_to_ieeef32(0.0)),
-                F32Store(MemArg {
-                    offset: sprite_layout::PEN_SATURATION as u64,
-                    align: 2,
-                    memory_index: 0,
-                }),
-                Return,
-                End,
-                LocalGet(rgb2hsv_locals::MEM_POS),
-                LocalGet(rgb2hsv_locals::SAT),
-                F32ConvertI32S,
-                F32Const(f32_to_ieeef32(2.55)),
-                F32Div,
-                F32Store(MemArg {
-                    offset: sprite_layout::PEN_SATURATION as u64,
-                    align: 2,
-                    memory_index: 0,
-                }),
-                LocalGet(rgb2hsv_locals::MEM_POS),
-                LocalGet(rgb2hsv_locals::RGB_MAX),
-                LocalGet(rgb2hsv_locals::R),
-                I32Eq,
-                If(WasmBlockType::Result(ValType::I32)),
-                LocalGet(rgb2hsv_locals::G),
-                LocalGet(rgb2hsv_locals::B),
-                I32Sub,
-                LocalGet(rgb2hsv_locals::RGB_MAX),
-                LocalGet(rgb2hsv_locals::RGB_MIN),
-                I32Sub,
-                I32DivS,
-                I32Const(43),
-                I32Mul,
-                Else,
-                LocalGet(rgb2hsv_locals::RGB_MAX),
-                LocalGet(rgb2hsv_locals::G),
-                I32Eq,
-                If(WasmBlockType::Result(ValType::I32)),
-                LocalGet(rgb2hsv_locals::B),
-                LocalGet(rgb2hsv_locals::R),
-                I32Sub,
-                LocalGet(rgb2hsv_locals::RGB_MAX),
-                LocalGet(rgb2hsv_locals::RGB_MIN),
-                I32Sub,
-                I32DivS,
-                I32Const(43),
-                I32Mul,
-                I32Const(85),
-                I32Add,
-                Else,
-                LocalGet(rgb2hsv_locals::R),
-                LocalGet(rgb2hsv_locals::G),
-                I32Sub,
-                LocalGet(rgb2hsv_locals::RGB_MAX),
-                LocalGet(rgb2hsv_locals::RGB_MIN),
-                I32Sub,
-                I32DivS,
-                I32Const(43),
-                I32Mul,
-                I32Const(171),
-                I32Add,
-                End,
-                End,
-                F32ConvertI32S,
-                F32Const(f32_to_ieeef32(2.55)),
-                F32Div,
-                F32Store(MemArg {
-                    offset: sprite_layout::PEN_COLOR as u64,
-                    align: 2,
-                    memory_index: 0,
-                }),
-                End,
-            ],
         };
     }
 }
diff --git a/src/wasm/registries/globals.rs b/src/wasm/registries/globals.rs
index f205aba7..9cdd522e 100644
--- a/src/wasm/registries/globals.rs
+++ b/src/wasm/registries/globals.rs
@@ -1,8 +1,10 @@
-use crate::prelude::*;
-use crate::registry::MapRegistry;
 use core::ops::Deref;
+
 use wasm_encoder::{ConstExpr, ExportKind, ExportSection, GlobalSection, GlobalType, ValType};
 
+use crate::prelude::*;
+use crate::registry::MapRegistry;
+
 #[derive(Copy, Clone, Debug)]
 pub struct GlobalMutable(pub bool);
 
diff --git a/src/wasm/registries/lists.rs b/src/wasm/registries/lists.rs
index bc2e5a2b..65d0e926 100644
--- a/src/wasm/registries/lists.rs
+++ b/src/wasm/registries/lists.rs
@@ -1,3 +1,8 @@
+use wasm_encoder::{
+    ConstExpr, DataSection, ElementSection, Elements, Function, HeapType, Instruction, RefType,
+    StorageType, ValType,
+};
+
 use super::super::WasmProject;
 use super::{GlobalExportable, GlobalMutable, GlobalRegistry, TypeRegistry};
 use crate::instructions::{BOXED_BOOL_PATTERN, BOXED_INT_PATTERN, BOXED_STRING_PATTERN};
@@ -7,11 +12,6 @@ use crate::registry::MapRegistry;
 use crate::sb3::VarVal;
 use crate::wasm::registries::{StringRegistry, TabledStringRegistry};
 
-use wasm_encoder::{
-    ConstExpr, DataSection, ElementSection, Elements, Function, HeapType, Instruction, RefType,
-    StorageType, ValType,
-};
-
 #[derive(Clone)]
 pub struct ListRegistry(
     MapRegistry<RcList, u32>, // for keeping track of initialisers
diff --git a/src/wasm/registries/strings.rs b/src/wasm/registries/strings.rs
index 5f4b5be2..73738ca8 100644
--- a/src/wasm/registries/strings.rs
+++ b/src/wasm/registries/strings.rs
@@ -1,6 +1,7 @@
+use wasm_encoder::{EntityType, Function, GlobalType, ImportSection, Instruction, ValType};
+
 use crate::prelude::*;
 use crate::registry::SetRegistry;
-use wasm_encoder::{EntityType, Function, GlobalType, ImportSection, Instruction, ValType};
 
 #[derive(Clone, Default)]
 pub struct StringRegistry(SetRegistry<Box<str>>);
diff --git a/src/wasm/registries/tables.rs b/src/wasm/registries/tables.rs
index cba2b40e..35546452 100644
--- a/src/wasm/registries/tables.rs
+++ b/src/wasm/registries/tables.rs
@@ -1,8 +1,9 @@
-use crate::prelude::*;
 use wasm_encoder::{
     ConstExpr, ExportKind, ExportSection, HeapType, RefType, TableSection, TableType,
 };
 
+use crate::prelude::*;
+
 #[derive(Clone, Debug)]
 pub struct TableOptions {
     pub element_type: RefType,
diff --git a/src/wasm/registries/types.rs b/src/wasm/registries/types.rs
index c17ad517..af44053d 100644
--- a/src/wasm/registries/types.rs
+++ b/src/wasm/registries/types.rs
@@ -1,10 +1,12 @@
-use crate::registry::SetRegistry;
-use crate::wasm::WasmProject;
-use crate::{ir::RcVar, prelude::*};
 use wasm_encoder::{
     AbstractHeapType, FieldType, HeapType, RefType, StorageType, TypeSection, ValType,
 };
 
+use crate::ir::RcVar;
+use crate::prelude::*;
+use crate::registry::SetRegistry;
+use crate::wasm::WasmProject;
+
 #[derive(Clone, Debug, PartialEq, Eq, Hash)]
 pub enum WasmType {
     Function(Vec<ValType>, Vec<ValType>),
diff --git a/src/wasm/registries/variables.rs b/src/wasm/registries/variables.rs
index 5491406c..58309df3 100644
--- a/src/wasm/registries/variables.rs
+++ b/src/wasm/registries/variables.rs
@@ -1,10 +1,11 @@
+use wasm_encoder::ConstExpr;
+
 use super::super::WasmProject;
 use super::{GlobalExportable, GlobalMutable, GlobalRegistry};
 use crate::ir::{RcVar, Type as IrType};
 use crate::prelude::*;
 use crate::sb3::VarVal;
 use crate::wasm::registries::{StringRegistry, TabledStringRegistry};
-use wasm_encoder::ConstExpr;
 
 pub struct VariableRegistry(
     Rc<GlobalRegistry>,
diff --git a/wasm-gen/src/lib.rs b/wasm-gen/src/lib.rs
index c1eb0a8f..2c6cffbb 100644
--- a/wasm-gen/src/lib.rs
+++ b/wasm-gen/src/lib.rs
@@ -1,7 +1,8 @@
+use std::collections::{HashMap, HashSet};
+
 use proc_macro::TokenStream;
 use proc_macro2::TokenStream as TokenStream2;
 use quote::{format_ident, quote, quote_spanned};
-use std::collections::{HashMap, HashSet};
 use syn::parse::{Parse, ParseStream};
 use syn::{parenthesized, Error as SynError, Expr, Ident, Token};