diff --git a/js/data/update_var_val_boolean.ts b/js/data/update_var_val_boolean.ts
new file mode 100644
index 00000000..c6850f21
--- /dev/null
+++ b/js/data/update_var_val_boolean.ts
@@ -0,0 +1,5 @@
+import { update_var_val } from "../shared.ts";
+
+export function update_var_val_boolean(val: boolean, id: string) {
+  update_var_val(id, val);
+}
diff --git a/js/data/update_var_val_float.ts b/js/data/update_var_val_float.ts
new file mode 100644
index 00000000..1874843e
--- /dev/null
+++ b/js/data/update_var_val_float.ts
@@ -0,0 +1,5 @@
+import { update_var_val } from "../shared.ts";
+
+export function update_var_val_float(val: number, id: string) {
+  update_var_val(id, val);
+}
diff --git a/js/data/update_var_val_int.ts b/js/data/update_var_val_int.ts
new file mode 100644
index 00000000..f7acc710
--- /dev/null
+++ b/js/data/update_var_val_int.ts
@@ -0,0 +1,5 @@
+import { update_var_val } from "../shared.ts";
+
+export function update_var_val_int(val: number, id: string) {
+  update_var_val(id, val);
+}
diff --git a/js/data/update_var_val_string.ts b/js/data/update_var_val_string.ts
new file mode 100644
index 00000000..3e367056
--- /dev/null
+++ b/js/data/update_var_val_string.ts
@@ -0,0 +1,5 @@
+import { update_var_val } from "../shared.ts";
+
+export function update_var_val_string(val: string, id: string) {
+  update_var_val(id, val);
+}
diff --git a/js/data/update_var_visible.ts b/js/data/update_var_visible.ts
new file mode 100644
index 00000000..df84d28a
--- /dev/null
+++ b/js/data/update_var_visible.ts
@@ -0,0 +1,5 @@
+import { update_var_visible as update_var_visibility } from "../shared.ts";
+
+export function update_var_visible(id: string, visible: boolean) {
+  update_var_visibility(id, visible);
+}
diff --git a/js/looks/switchbackdropto.ts b/js/looks/switchbackdropto.ts
new file mode 100644
index 00000000..7783782e
--- /dev/null
+++ b/js/looks/switchbackdropto.ts
@@ -0,0 +1,8 @@
+import { renderer, costumes, target_skins, stageIndex } from "../shared";
+
+export function switchbackdropto(costume_num: number) {
+  console.log("switch backdrop to", costume_num);
+  console.log(stageIndex(), costumes());
+  const costume = costumes()[stageIndex()][costume_num];
+  renderer().getSkin(target_skins()[stageIndex()][0]).setSVG(costume.data);
+}
diff --git a/js/sensing/queue_ask.ts b/js/sensing/queue_ask.ts
new file mode 100644
index 00000000..a3644c60
--- /dev/null
+++ b/js/sensing/queue_ask.ts
@@ -0,0 +1,3 @@
+import { queue_question } from "../shared";
+
+export const queue_ask = queue_question;
diff --git a/js/shared.ts b/js/shared.ts
index bab55bec..014df406 100644
--- a/js/shared.ts
+++ b/js/shared.ts
@@ -5,18 +5,40 @@ let _renderer: object;
 let _pen_skin: number;
 let _target_skins: Array<[number, number]>;
 let _costumes: Array<Array<Costume>>;
+let _queue_question: (question: string, struct: object) => void = () => {};
+let _stageIndex: number;
+let _update_var_val: (id: string, val: any) => void = () => {};
+let _update_var_visible: (id: string, visible: boolean) => void = () => {};
 
 type Costume = {
   data: string;
   dataFormat: string;
 };
 
+export function unsetup() {
+  _target_names = null;
+  _target_bubbles = null;
+  _renderer = null;
+  _pen_skin = null;
+  _target_skins = null;
+  _costumes = null;
+  _queue_question = () => {};
+  _stageIndex = null;
+  _update_var_val = () => {};
+  _update_var_visible = () => {};
+  _setup = false;
+}
+
 export function setup(
   target_names: Array<string>,
   renderer: object,
   pen_skin: number,
   target_skins: Array<[number, number]>,
   costumes: Array<Array<Costume>>,
+  queue_question: (question: string, struct: object) => void,
+  stageIndex: number,
+  update_var_val: (id: string, val: any) => void,
+  update_var_visible: (id: string, visible: boolean) => void,
 ) {
   _target_names = target_names;
   _target_bubbles = _target_names.map((_) => null);
@@ -25,6 +47,10 @@ export function setup(
   _pen_skin = pen_skin;
   _target_skins = target_skins;
   _costumes = costumes;
+  _queue_question = queue_question;
+  _stageIndex = stageIndex;
+  _update_var_val = update_var_val;
+  _update_var_visible = update_var_visible;
   _setup = true;
 }
 
@@ -63,13 +89,18 @@ export function costumes(): Array<Array<Costume>> {
   return _costumes;
 }
 
+export function stageIndex(): number {
+  check_setup();
+  return _stageIndex;
+}
+
 export function update_bubble(
   target_index: number,
   verb: "say" | "think",
   text: string,
 ) {
   check_setup();
-  if (!_target_bubbles[target_index]) {
+  if (!_target_bubbles[target_index] && text !== "") {
     _target_bubbles[target_index] = _renderer.createSkin(
       "text",
       "sprite",
@@ -77,6 +108,11 @@ export function update_bubble(
       text,
       false,
     );
+  } else if (text == "") {
+    if (!_target_bubbles[target_index]) return;
+    _renderer.destroyDrawable(_target_bubbles[target_index][1], "sprite");
+    _renderer.destroySkin(_target_bubbles[target_index][0]);
+    _target_bubbles[target_index] = null;
   } else {
     _renderer.updateTextSkin(
       _target_bubbles[target_index][0],
@@ -86,3 +122,18 @@ export function update_bubble(
     );
   }
 }
+
+export function queue_question(question: string, struct: object) {
+  check_setup();
+  _queue_question(question, struct);
+}
+
+export function update_var_val(id: string, val: any) {
+  check_setup();
+  _update_var_val(id, val);
+}
+
+export function update_var_visible(id: string, visible: boolean) {
+  check_setup();
+  _update_var_visible(id, visible);
+}
diff --git a/opcodes.mjs b/opcodes.mjs
index fe046a78..34e8f7a0 100644
--- a/opcodes.mjs
+++ b/opcodes.mjs
@@ -7,6 +7,11 @@ const opcodes = [
       .match(/BlockOpcode::[a-zA-Z_0-9]+? (?==>)/g)
       .map((op) => op.replace("BlockOpcode::", "").trim()),
   ),
+  "event_whenflagclicked",
+  "event_whenbroadcastreceived",
+  "event_whenthisspriteclicked",
+  "event_whenstageclicked",
+  "procedures_definition",
 ].sort();
 await writeFile(
   "/tmp/hq-build/js/opcodes.js",
diff --git a/playground/App.vue b/playground/App.vue
index 841fd90a..eb26016e 100644
--- a/playground/App.vue
+++ b/playground/App.vue
@@ -50,6 +50,7 @@ main {
   position: sticky;
   top: 5px;
   background-color: var(--color-background);
+  z-index: 999;
 }
 </style>
 
diff --git a/playground/components/ProjectPlayer.vue b/playground/components/ProjectPlayer.vue
index 677b74cd..0ae953c1 100644
--- a/playground/components/ProjectPlayer.vue
+++ b/playground/components/ProjectPlayer.vue
@@ -20,7 +20,41 @@
       <input type="checkbox" id="turbo" :value="turbo" />
       <label for="turbo">turbo mode</label>
     </div>
-    <canvas width="480" height="360" ref="canvas"></canvas>
+    <div id="stage-container">
+      <canvas width="480" height="360" ref="canvas"></canvas>
+      <div
+        v-for="[id, { visible, x, y, name, sprite, value }] in Object.entries(
+          monitors,
+        )"
+        :key="id"
+        class="variable-monitor"
+        v-show="visible"
+        :style="{
+          left: x.toString() + 'px',
+          top: y.toString() + 'px',
+        }"
+      >
+        <span>
+          <span v-if="!!sprite">{{ sprite }}: </span>{{ name }}
+        </span>
+        <span class="variable-value">{{ value }}</span>
+      </div>
+      <div v-show="queued_questions.length > 0" id="question-div">
+        <div v-if="!!queued_questions[0]?.[0]?.length">
+          {{ queued_questions[0]?.[0] }}
+        </div>
+        <form @submit.prevent="submitQuestion">
+          <input
+            type="text"
+            name="answer"
+            v-model="question_response"
+            ref="questionInput"
+            autocomplete="off"
+          />
+          <button type="submit">✓</button>
+        </form>
+      </div>
+    </div>
     <div class="instructions">
       <div v-if="props.instructions">
         <h2>Instructions</h2>
@@ -37,15 +71,11 @@
 
 <script setup>
 import Loading from "./Loading.vue";
-import {
-  sb3_to_wasm,
-  FinishedWasm,
-  WasmFlags,
-} from "../../js/compiler/hyperquark.js";
-import { instantiateProject } from "../lib/project-runner.js";
-import { ref, onMounted, registerRuntimeCompiler } from "vue";
+import { ProjectRunner } from "../lib/project-runner.js";
+import { ref, onMounted, reactive, watch, onBeforeUnmount } from "vue";
 import { getSettings } from "../lib/settings.js";
 import { useDebugModeStore } from "../stores/debug.js";
+import { unsetup } from "../../js/shared.js";
 
 const debugModeStore = useDebugModeStore();
 
@@ -67,6 +97,8 @@ let turbo = ref(false);
 let canvas = ref(null);
 let loadingMsg = ref("compiling project");
 let loaded = ref(false);
+let questionInput = ref(null);
+let monitors = ref({});
 
 let greenFlag = () => null;
 let stop = () => null;
@@ -89,6 +121,40 @@ const declareError = (e, terminate, mode, stage, extra) => {
   }
 };
 
+const queued_questions = reactive([]);
+let question_response = ref("");
+let mark_question_resolved = () => {};
+
+let setAnswer = () => {};
+
+function submitQuestion() {
+  setAnswer(question_response.value);
+  question_response.value = "";
+  const [_, struct] = queued_questions.shift();
+  mark_question_resolved(struct);
+}
+
+watch(queued_questions, () => {
+  if (queued_questions.length > 0) {
+    questionInput.value.focus();
+  }
+});
+
+function queue_question(question, struct) {
+  queued_questions.push([question, struct]);
+}
+
+let mouseMove, mouseDown, mouseUp, runner, compileWorker;
+
+onBeforeUnmount(() => {
+  document.removeEventListener("mousemove", mouseMove);
+  canvas.value.removeEventListener("mousedown", mouseDown);
+  canvas.value.removeEventListener("mouseup", mouseUp);
+  runner?.stop?.();
+  unsetup();
+  compileWorker?.terminate?.();
+});
+
 onMounted(async () => {
   const load_asset = async (md5ext) => {
     try {
@@ -116,16 +182,35 @@ onMounted(async () => {
   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
-    wasmProject = sb3_to_wasm(
-      JSON.stringify(props.json),
-      WasmFlags.from_js(getSettings().to_js()),
+    // imports can take a long time, so need to wait for worker to tell us that it's initialised
+    await new Promise((resolve) => {
+      compileWorker = new Worker(
+        new URL("../lib/compile-worker.js", import.meta.url),
+        { type: "module" },
+      );
+      compileWorker.onmessage = resolve;
+    });
+    wasmProject = await new Promise((resolve, reject) => {
+      compileWorker.onmessage = ({ data }) => resolve(data);
+      compileWorker.onerror = (e) => {
+        reject(e.message);
+      };
+      compileWorker.postMessage({
+        proj: JSON.stringify(props.json),
+        flags: getSettings().to_js(),
+      });
+      console.log("message posted!");
+    });
+
+    console.log(
+      wasmProject.target_names,
+      wasmProject.strings,
+      wasmProject.wasm_bytes,
     );
 
-    if ((!wasmProject) instanceof FinishedWasm) {
-      throw new Error("unknown error occurred when compiling project");
-    }
+    // if ((!wasmProject instanceof FinishedWasm)) {
+    //   throw new Error("unknown error occurred when compiling project");
+    // }
 
     wasmBytes = wasmProject.wasm_bytes;
   } catch (e) {
@@ -188,7 +273,8 @@ onMounted(async () => {
 
   try {
     loadingMsg.value = "instantiating project";
-    const runner = await instantiateProject({
+    runner = new ProjectRunner();
+    await runner.init({
       framerate: 30,
       turbo: turbo.value,
       wasm_bytes: wasmBytes,
@@ -207,8 +293,55 @@ onMounted(async () => {
 
     loaded.value = true;
 
-    greenFlag = runner.greenFlag;
-    stop = runner.stop;
+    runner.addEventListener("stopped", () => queued_questions.splice(0));
+    runner.addEventListener(
+      "queueQuestion",
+      ({ detail: { question, struct } }) => queue_question(question, struct),
+    );
+    runner.addEventListener(
+      "updateVariableVal",
+      ({ detail: { id, value } }) => {
+        monitors.value[id].value = value;
+      },
+    );
+    runner.addEventListener(
+      "updateVariableVisibility",
+      ({ detail: { id, visible } }) => {
+        monitors.value[id].visible = visible;
+      },
+    );
+
+    const onMouseMove = (e, isDown) => {
+      const rect = canvas.value.getBoundingClientRect();
+      runner.onMouseMove({
+        clientX: e.clientX,
+        clientY: e.clientY,
+        rect,
+        isDown,
+      });
+    };
+
+    mouseMove = (e) => {
+      onMouseMove(e);
+    };
+    document.addEventListener("mousemove", mouseMove);
+    mouseDown = (e) => {
+      onMouseMove(e, true);
+      e.preventDefault();
+    };
+    canvas.value.addEventListener("mousedown", mouseDown);
+    mouseUp = (e) => {
+      onMouseMove(e, false);
+      e.preventDefault();
+    };
+    canvas.value.addEventListener("mouseup", mouseUp);
+
+    greenFlag = runner.greenFlag.bind(runner);
+    stop = runner.stop.bind(runner);
+    setAnswer = runner.setAnswer.bind(runner);
+    mark_question_resolved = runner.mark_question_resolved.bind(runner);
+    monitors.value = runner.monitors;
+    console.log(monitors.value);
   } catch (e) {
     declareError(e, true, "An error", "instantiating");
   }
@@ -219,10 +352,44 @@ onMounted(async () => {
 canvas {
   border: 1px solid black;
   background: white;
-  max-width: calc((100vw - 1rem) * 0.95);
+  width: 100%;
+  height: 100%;
+}
+
+div#stage-container {
   float: left;
   margin-right: 1em;
   margin-bottom: 1.5em;
+  width: 480px;
+  height: 360px;
+  position: relative;
+
+  & > div#question-div {
+    width: calc(100% - 1em);
+    position: absolute;
+    bottom: 0;
+    margin: 0.5em;
+    padding: 0.5em;
+    background: var(--color-background-soft);
+    border-radius: 5px;
+    box-sizing: border-box;
+
+    & > div {
+      padding: 0;
+      margin-top: 0;
+      line-height: 1em;
+      margin-bottom: 0.4em;
+    }
+
+    & > form {
+      display: flex;
+
+      & > input {
+        flex-grow: 100;
+        border-radius: 5px;
+      }
+    }
+  }
 }
 
 div.instructions {
@@ -242,4 +409,25 @@ div.instructions {
 
   white-space: pre-wrap;
 }
+
+div.variable-monitor {
+  position: absolute;
+  background-color: var(--color-background-soft);
+  border-radius: 5px;
+  padding: 0 0.4em 0.2em 0.4em;
+
+  & span {
+    padding: 0;
+    margin: 0;
+    vertical-align: middle;
+  }
+
+  & > span.variable-value {
+    background-color: hsl(39.3, 100%, 37%);
+    color: var(--color-background);
+    border-radius: 5px;
+    padding: 0 0.3em;
+    margin-left: 0.3em;
+  }
+}
 </style>
diff --git a/playground/lib/compile-worker.js b/playground/lib/compile-worker.js
new file mode 100644
index 00000000..79882739
--- /dev/null
+++ b/playground/lib/compile-worker.js
@@ -0,0 +1,15 @@
+import { sb3_to_wasm, WasmFlags } from "../../js/compiler/hyperquark.js";
+
+console.log("web worker initialised");
+
+postMessage("ready");
+
+addEventListener("message", ({ data }) => {
+  console.log("message received");
+  let wasmProject = sb3_to_wasm(data.proj, WasmFlags.from_js(data.flags));
+  postMessage({
+    wasm_bytes: wasmProject.wasm_bytes,
+    strings: wasmProject.strings,
+    target_names: wasmProject.target_names,
+  });
+});
diff --git a/playground/lib/project-runner.js b/playground/lib/project-runner.js
index 99b99f54..a5d9d96b 100644
--- a/playground/lib/project-runner.js
+++ b/playground/lib/project-runner.js
@@ -1,243 +1,327 @@
 import { getSettings } from "./settings.js";
 import { imports as baseImports } from "./imports.js";
 import {
-  setup as sharedSetup,
-  is_setup,
   renderer as get_renderer,
+  stageIndex,
+  target_skins,
 } from "../../js/shared.ts";
 import { WasmStringType } from "../../js/no-compiler/hyperquark.js";
+import { setup } from "./setup.js";
 
-function createSkin(renderer, type, layer, ...params) {
-  let drawableId = renderer.createDrawable(layer.toString());
-  const realType = {
-    pen: "Pen",
-    text: "Text",
-    svg: "SVG",
-  }[type.toLowerCase()];
-  let skin = renderer[`create${realType}Skin`](...params);
-  renderer.updateDrawableSkinId(drawableId, skin);
-  return [skin, drawableId];
+function sleep(ms) {
+  return new Promise((resolve) => {
+    setTimeout(resolve, ms);
+  });
 }
 
-async function setup(makeRenderer, project_json, assets, target_names) {
-  if (is_setup()) return;
-
-  let renderer = await makeRenderer();
-
-  renderer.getDrawable = (id) => renderer._allDrawables[id];
-  renderer.getSkin = (id) => renderer._allSkins[id];
-  renderer.createSkin = (type, layer, ...params) =>
-    createSkin(renderer, type, layer, ...params);
-
-  const costumes = project_json.targets.map((target, index) =>
-    target.costumes.map(({ md5ext }) => assets[md5ext]),
-  );
+function waitAnimationFrame() {
+  return new Promise((resolve) => {
+    if (typeof requestAnimationFrame === "function")
+      requestAnimationFrame(resolve);
+    else setTimeout(resolve, 1);
+  });
+}
 
-  if (typeof window === "object") {
-    window.renderer = renderer;
-  }
-  renderer.setLayerGroupOrdering(["background", "video", "pen", "sprite"]);
-  //window.open(URL.createObjectURL(new Blob([wasm_bytes], { type: "octet/stream" })));
-  const pen_skin = renderer.createSkin("pen", "pen")[0];
-
-  const target_skins = project_json.targets.map((target, index) => {
-    const realCostume = target.costumes[target.currentCostume];
-    const costume = costumes[index][target.currentCostume];
-    if (costume.dataFormat.toLowerCase() !== "svg") {
-      throw new Error("todo: non-svg costumes");
-    }
+export class ProjectRunner extends EventTarget {
+  #sensing_answer;
+  #mark_question_resolved_func;
+  #running = false;
+  #renderer;
+  #tick;
+  #timeout;
+  #framerate_wait;
+  #requests_refresh;
+  turbo;
+  #sensing_timer;
+  #threads_count;
+  flag_clicked;
+  #threads;
+  #mouseX;
+  #mouseY;
+  #mouseDown;
+  #triggerSpriteClicked;
+  monitors;
 
-    const [skin, drawableId] = renderer.createSkin(
-      costume.dataFormat,
-      "sprite",
-      costume.data,
-      [realCostume.rotationCenterX, realCostume.rotationCenterY],
+  #initProps({
+    renderer,
+    timeout,
+    framerate_wait,
+    turbo,
+    exports,
+    project_json,
+  }) {
+    this.#sensing_answer = exports.sensing_answer;
+    this.#mark_question_resolved_func = exports.mark_waiting_flag;
+    this.#renderer = renderer;
+    this.#tick = exports.tick;
+    this.#timeout = timeout;
+    this.#framerate_wait = framerate_wait;
+    this.#requests_refresh = exports.requests_refresh;
+    this.turbo = turbo;
+    this.#sensing_timer = exports.sensing_timer;
+    this.#threads_count = exports.threads_count;
+    this.flag_clicked = exports.flag_clicked;
+    this.#threads = exports.threads;
+    this.#mouseX = exports.mouseX ?? { value: 0 };
+    this.#mouseY = exports.mouseY ?? { value: 0 };
+    this.#mouseDown = exports.mouseDown ?? { value: false };
+    this.#triggerSpriteClicked = exports.trigger_sprite_clicked;
+    this.monitors = Object.fromEntries(
+      project_json.monitors?.map?.((monitor) => {
+        return [
+          monitor.id,
+          {
+            name: monitor.params.VARIABLE,
+            x: monitor.x,
+            y: monitor.y,
+            visible: monitor.visible,
+            value: monitor.value,
+            sprite: monitor.spriteName,
+          },
+        ];
+      }) ?? [],
     );
+  }
 
-    const drawable = renderer.getDrawable(drawableId);
-    if (!target.is_stage) {
-      drawable.updateVisible(!!target.visible);
-      drawable.updatePosition([target.x, target.y]);
-      drawable.updateDirection(target.direction);
-      drawable.updateScale([target.size, target.size]);
-    }
-    return [skin, drawableId];
-  });
-  console.log(target_skins);
-
-  sharedSetup(target_names, renderer, pen_skin, target_skins, costumes);
-}
+  async init({
+    framerate = 30,
+    turbo,
+    wasm_bytes,
+    target_names,
+    strings,
+    project_json,
+    assets,
+    makeRenderer,
+    isDebug = () => false,
+    timeout,
+    importOverrides,
+  }) {
+    if (isDebug() && typeof window === "object")
+      window.open(
+        URL.createObjectURL(
+          new Blob([wasm_bytes], { type: "application/wasm" }),
+        ),
+      );
 
-// @ts-ignore
-export async function instantiateProject({
-  framerate = 30,
-  turbo,
-  wasm_bytes,
-  target_names,
-  strings,
-  project_json,
-  assets,
-  makeRenderer,
-  isDebug = () => false,
-  timeout,
-  onTimeout = () => null,
-  importOverrides,
-}) {
-  if (isDebug() && typeof window === "object")
-    window.open(
-      URL.createObjectURL(new Blob([wasm_bytes], { type: "application/wasm" })),
+    await setup(
+      makeRenderer,
+      project_json,
+      assets,
+      target_names,
+      (question, struct) => {
+        this.dispatchEvent(
+          new CustomEvent("queueQuestion", { detail: { question, struct } }),
+        );
+      },
+      (id, value) => {
+        this.dispatchEvent(
+          new CustomEvent("updateVariableVal", { detail: { id, value } }),
+        );
+      },
+      (id, visible) => {
+        this.dispatchEvent(
+          new CustomEvent("updateVariableVisibility", {
+            detail: { id, visible },
+          }),
+        );
+      },
     );
 
-  await setup(makeRenderer, project_json, assets, target_names);
+    const renderer = get_renderer();
 
-  const renderer = get_renderer();
+    const framerate_wait = Math.round(1000 / framerate);
 
-  console.log("project setup complete");
+    const settings = getSettings();
+    const builtins = [
+      ...(WasmStringType[settings.string_type] === "JsStringBuiltins"
+        ? ["js-string"]
+        : []),
+    ];
 
-  const framerate_wait = Math.round(1000 / framerate);
+    const imports = Object.assign(baseImports, {
+      "": Object.fromEntries(strings.map((string) => [string, string])),
+    });
 
-  const settings = getSettings();
-  const builtins = [
-    ...(WasmStringType[settings.string_type] === "JsStringBuiltins"
-      ? ["js-string"]
-      : []),
-  ];
+    for (const [module, _obj] of Object.entries(importOverrides ?? {})) {
+      for (const [name, val] of Object.entries(importOverrides[module])) {
+        imports[module][name] = val;
+      }
+    }
 
-  const imports = Object.assign(baseImports, {
-    "": Object.fromEntries(strings.map((string) => [string, string])),
-  });
+    try {
+      if (
+        !WebAssembly.validate(wasm_bytes, {
+          builtins,
+        })
+      ) {
+        throw Error();
+      }
+    } catch {
+      try {
+        new WebAssembly.Module(wasm_bytes);
+        throw new Error("invalid WASM module");
+      } catch (e) {
+        throw new Error("invalid WASM module: " + e.message);
+      }
+    }
 
-  console.log(importOverrides);
+    let { instance } = await WebAssembly.instantiate(wasm_bytes, imports, {
+      builtins,
+      importedStringConstants: "",
+    });
 
-  for (const [module, obj] of Object.entries(importOverrides ?? {})) {
-    for (const [name, val] of Object.entries(importOverrides[module])) {
-      imports[module][name] = val;
-    }
-  }
+    const { flag_clicked, tick, memory, unreachable_dbg } = instance.exports;
 
-  try {
-    if (
-      !WebAssembly.validate(wasm_bytes, {
-        builtins,
-      })
-    ) {
-      throw Error();
+    if (typeof window === "object") {
+      window.memory = memory;
+      window.flag_clicked = flag_clicked;
+      window.tick = tick;
     }
-  } catch {
+
     try {
-      new WebAssembly.Module(wasm_bytes);
-      throw new Error("invalid WASM module");
-    } catch (e) {
-      throw new Error("invalid WASM module: " + e.message);
+      // expose the module to devtools
+      unreachable_dbg();
+    } catch (error) {
+      console.info("synthetic error to expose wasm module to devtools:", error);
     }
-  }
-  function sleep(ms) {
-    return new Promise((resolve) => {
-      setTimeout(resolve, ms);
-    });
-  }
-  function waitAnimationFrame() {
-    return new Promise((resolve) => {
-      if (typeof requestAnimationFrame === "function")
-        requestAnimationFrame(resolve);
-      else setTimeout(resolve, 1);
+
+    this.#initProps({
+      renderer,
+      exports: instance.exports,
+      timeout,
+      framerate_wait,
+      turbo,
+      project_json,
     });
-  }
-  let { instance } = await WebAssembly.instantiate(wasm_bytes, imports, {
-    builtins,
-    importedStringConstants: "",
-  });
-  const {
-    flag_clicked,
-    tick,
-    memory,
-    threads_count,
-    requests_refresh,
-    threads,
-    unreachable_dbg,
-    sensing_timer,
-  } = instance.exports;
-  if (typeof window === "object") {
-    window.memory = memory;
-    window.flag_clicked = flag_clicked;
-    window.tick = tick;
-  }
 
-  try {
-    // expose the module to devtools
-    unreachable_dbg();
-  } catch (error) {
-    console.info("synthetic error to expose wasm module to devtools:", error);
+    return this;
   }
 
-  let running = false;
-
-  const run = async () => {
+  async run() {
     console.log("running");
-    if (running) return;
+    if (this.#running) return;
 
-    running = true;
+    this.#running = true;
 
-    renderer.draw();
+    this.#renderer.draw();
 
     let startTime = Date.now();
     let previousTickStartTime = startTime;
-    $outertickloop: while (running) {
-      if (timeout && Date.now() - startTime > timeout) {
-        return onTimeout();
+    $outertickloop: while (this.#running) {
+      if (this.#timeout && Date.now() - startTime > this.#timeout) {
+        return this.dispatchEcent(new CustomEvent("timeout"));
       }
       let thisTickStartTime = Date.now();
-      if (typeof sensing_timer !== "undefined") {
-        sensing_timer.value +=
+      if (typeof this.#sensing_timer !== "undefined") {
+        this.#sensing_timer.value +=
           (thisTickStartTime - previousTickStartTime) / 1000;
       }
       previousTickStartTime = thisTickStartTime;
       do {
-        tick();
-        if (threads_count.value === 0) {
+        if (this.#threads_count.value === 0) {
           break $outertickloop;
         }
+        this.#tick();
       } while (
-        Date.now() - thisTickStartTime < framerate_wait * 0.8 &&
-        !turbo &&
-        requests_refresh.value === 0
+        Date.now() - thisTickStartTime < this.#framerate_wait * 0.8 &&
+        !this.turbo &&
+        this.#requests_refresh.value === 0
       );
-      requests_refresh.value = 0;
-      renderer.draw();
-      if (framerate_wait > 0) {
+      this.#requests_refresh.value = 0;
+      this.#renderer.draw();
+      if (this.#framerate_wait > 0) {
         await sleep(
-          Math.max(0, framerate_wait - (Date.now() - thisTickStartTime)),
+          Math.max(0, this.#framerate_wait - (Date.now() - thisTickStartTime)),
         );
       } else {
         await waitAnimationFrame();
       }
     }
-    renderer.draw();
-    running = false;
+    await waitAnimationFrame();
+    this.#renderer.draw();
+    this.#running = false;
     console.log("project stopped (or maybe paused)");
-  };
+  }
+
+  greenFlag() {
+    console.log("green flag clicked");
+    if (typeof this.#sensing_timer !== "undefined") {
+      this.#sensing_timer.value = 0.0;
+    }
+    this.flag_clicked();
+    this.run();
+  }
+
+  pause() {
+    this.#running = false;
+  }
+
+  stop() {
+    console.log("stopping");
+    if (!!this.#threads_count) {
+      this.#threads_count.value = 0;
+    }
+    this.#running = false;
+    if (!!this.#threads) {
+      for (let i = 0; i < this.#threads.length; i++) {
+        this.#threads.set(i, null);
+      }
+    }
+    this.dispatchEvent(new CustomEvent("stopped"));
+  }
+
+  mark_question_resolved(struct) {
+    this.#mark_question_resolved_func(struct);
+  }
+
+  setAnswer(answerText) {
+    this.#sensing_answer.value = answerText;
+  }
+
+  onMouseMove({ clientX, clientY, rect, isDown }) {
+    const x = clamp((clientX - rect.left) / rect.width, 0, 1) * 480 - 240;
+    const y = clamp((clientY - rect.top) / rect.height, 0, 1) * 360 - 180;
+    this.#mouseX.value = x;
+    this.#mouseY.value = y;
 
-  return {
-    greenFlag: () => {
-      console.log("green flag clicked");
-      if (typeof sensing_timer !== "undefined") {
-        sensing_timer.value = 0.0;
+    if (typeof isDown !== "undefined") {
+      const prevIsDown = this.#mouseDown.value;
+      if (prevIsDown && !isDown) {
+        // TODO: update 'this sprite clicked?' values to be not clicked
       }
-      flag_clicked();
-      run();
-    },
-    flag_clicked,
-    stop: () => {
-      console.log("stopping");
-      threads_count.value = 0;
-      running = false;
-      for (let i = 0; i < threads.length; i++) {
-        threads.set(i, null);
+      if (!prevIsDown && isDown) {
+        const clickedTarget = this.#pickMouseOverTarget(
+          clientX - rect.left,
+          clientY - rect.top,
+        );
+        this.#triggerSpriteClicked?.(clickedTarget);
+        if (!this.#running) this.run();
+      }
+
+      this.#mouseDown.value = isDown;
+    }
+
+    if (this.#mouseDown.value) {
+      // TODO: update 'this sprite clicked?' values to be maybe clicked depending on mouse position
+    }
+  }
+
+  #pickMouseOverTarget(x, y) {
+    // adapted from https://github.com/scratchfoundation/scratch-vm/blob/8dbcc1f/src/io/mouse.js#L40
+    // (licensed under BSD-3.0 - see https://raw.githubusercontent.com/scratchfoundation/scratch-vm/8dbcc1f/LICENSE)
+    const drawableID = this.#renderer.pick(x, y);
+    const targetSkins = target_skins();
+    for (let i = 0; i < targetSkins.length; i++) {
+      const thisDrawableID = targetSkins[i][1];
+      if (thisDrawableID === drawableID) {
+        return i;
       }
-    },
-    pause: () => {
-      running = false;
-    },
-    run,
-  };
+    }
+    // Return the stage if no target was found
+    return stageIndex();
+  }
+}
+
+function clamp(val, min, max) {
+  return Math.max(Math.min(val, max), min);
 }
diff --git a/playground/lib/setup.js b/playground/lib/setup.js
new file mode 100644
index 00000000..f9f3d40a
--- /dev/null
+++ b/playground/lib/setup.js
@@ -0,0 +1,87 @@
+import { setup as sharedSetup, is_setup } from "../../js/shared.ts";
+
+function createSkin(renderer, type, layer, ...params) {
+  let drawableId = renderer.createDrawable(layer.toString());
+  const realType = {
+    pen: "Pen",
+    text: "Text",
+    svg: "SVG",
+  }[type.toLowerCase()];
+  let skin = renderer[`create${realType}Skin`](...params);
+  renderer.updateDrawableSkinId(drawableId, skin);
+  return [skin, drawableId];
+}
+
+export async function setup(
+  makeRenderer,
+  project_json,
+  assets,
+  target_names,
+  queue_question,
+  update_var_val,
+  update_var_visible,
+) {
+  if (is_setup()) return;
+
+  let renderer = await makeRenderer();
+
+  renderer.getDrawable = (id) => renderer._allDrawables[id];
+  renderer.getSkin = (id) => renderer._allSkins[id];
+  renderer.createSkin = (type, layer, ...params) =>
+    createSkin(renderer, type, layer, ...params);
+
+  const costumes = project_json.targets.map((target, index) =>
+    target.costumes.map(({ md5ext }) => assets[md5ext]),
+  );
+
+  if (typeof window === "object") {
+    window.renderer = renderer;
+  }
+  renderer.setLayerGroupOrdering(["background", "video", "pen", "sprite"]);
+  //window.open(URL.createObjectURL(new Blob([wasm_bytes], { type: "octet/stream" })));
+  const pen_skin = renderer.createSkin("pen", "pen")[0];
+
+  const target_skins = project_json.targets.map((target, index) => {
+    const realCostume = target.costumes[target.currentCostume];
+    const costume = costumes[index][target.currentCostume];
+    if (costume.dataFormat.toLowerCase() !== "svg") {
+      throw new Error("todo: non-svg costumes");
+    }
+
+    const [skin, drawableId] = renderer.createSkin(
+      costume.dataFormat,
+      target.isStage ? "background" : "sprite",
+      costume.data,
+      [realCostume.rotationCenterX, realCostume.rotationCenterY],
+    );
+
+    const drawable = renderer.getDrawable(drawableId);
+    if (!target.isStage) {
+      drawable.updateVisible(!!target.visible);
+      drawable.updatePosition([target.x, target.y]);
+      drawable.updateDirection(target.direction);
+      drawable.updateScale([target.size, target.size]);
+    } else {
+      drawable.updateVisible(true);
+      drawable.updatePosition([0, 0]);
+      drawable.updateDirection(90);
+      drawable.updateScale([100, 100]);
+    }
+    return [skin, drawableId];
+  });
+  console.log(target_skins);
+
+  const stageIndex = project_json.targets.findIndex((target) => target.isStage);
+
+  sharedSetup(
+    target_names,
+    renderer,
+    pen_skin,
+    target_skins,
+    costumes,
+    queue_question,
+    stageIndex,
+    update_var_val,
+    update_var_visible,
+  );
+}
diff --git a/src/instructions.rs b/src/instructions.rs
index 3bfcdc4d..1bf6245e 100644
--- a/src/instructions.rs
+++ b/src/instructions.rs
@@ -113,12 +113,15 @@ impl IrOpcode {
             })
             | Self::event_broadcast_and_wait(EventBroadcastAndWaitFields { next_step, .. })
             | Self::procedures_call_nonwarp(ProceduresCallNonwarpFields { next_step, .. })
-            | Self::control_wait(ControlWaitFields { next_step, .. }) => Some(*next_step),
+            | Self::control_wait(ControlWaitFields { next_step, .. })
+            | Self::sensing_askandwait(SensingAskandwaitFields { next_step, .. }) => {
+                Some(*next_step)
+            }
             _ => None,
         }
     }
 
-    pub fn inline_steps(&self) -> Option<Box<[Rc<RefCell<Step>>]>> {
+    pub fn inline_steps(&self, ignore_conditions: bool) -> Option<Box<[Rc<RefCell<Step>>]>> {
         #[expect(
             clippy::wildcard_enum_match_arm,
             reason = "too many variants to match explicitly"
@@ -135,18 +138,31 @@ impl IrOpcode {
                 first_condition,
                 condition,
                 body,
+                pre_body,
                 ..
             }) => Some(
-                [first_condition.as_ref(), Some(condition), Some(body)]
-                    .into_iter()
-                    .filter_map(Option::<&_>::cloned)
-                    .collect(),
+                if ignore_conditions {
+                    vec![pre_body.as_ref(), Some(body)]
+                } else {
+                    vec![
+                        first_condition.as_ref(),
+                        Some(condition),
+                        pre_body.as_ref(),
+                        Some(body),
+                    ]
+                }
+                .into_iter()
+                .filter_map(Option::<&_>::cloned)
+                .collect(),
             ),
             _ => None,
         }
     }
 
-    pub fn inline_steps_mut(&mut self) -> Option<Box<[&mut Rc<RefCell<Step>>]>> {
+    pub fn inline_steps_mut(
+        &mut self,
+        ignore_conditions: bool,
+    ) -> Option<Box<[&mut Rc<RefCell<Step>>]>> {
         #[expect(
             clippy::wildcard_enum_match_arm,
             reason = "too many variants to match explicitly"
@@ -163,12 +179,22 @@ impl IrOpcode {
                 first_condition,
                 condition,
                 body,
+                pre_body,
                 ..
             }) => Some(
-                [first_condition.as_mut(), Some(condition), Some(body)]
-                    .into_iter()
-                    .flatten()
-                    .collect(),
+                if ignore_conditions {
+                    vec![pre_body.as_mut(), Some(body)]
+                } else {
+                    vec![
+                        first_condition.as_mut(),
+                        Some(condition),
+                        pre_body.as_mut(),
+                        Some(body),
+                    ]
+                }
+                .into_iter()
+                .flatten()
+                .collect(),
             ),
             _ => None,
         }
diff --git a/src/instructions/control.rs b/src/instructions/control.rs
index 884a31ab..83af48a9 100644
--- a/src/instructions/control.rs
+++ b/src/instructions/control.rs
@@ -1,4 +1,5 @@
 pub mod get_thread_timeout;
 pub mod if_else;
 pub mod r#loop;
+pub mod stop_all;
 pub mod wait;
diff --git a/src/instructions/control/loop.rs b/src/instructions/control/loop.rs
index 6c0336a3..a169317e 100644
--- a/src/instructions/control/loop.rs
+++ b/src/instructions/control/loop.rs
@@ -10,6 +10,7 @@ pub struct Fields {
     pub first_condition: Option<Rc<RefCell<Step>>>,
     pub condition: Rc<RefCell<Step>>,
     pub body: Rc<RefCell<Step>>,
+    pub pre_body: Option<Rc<RefCell<Step>>>,
     pub flip_if: bool,
 }
 
@@ -41,6 +42,7 @@ pub fn wasm(
         condition,
         body,
         flip_if,
+        pre_body,
     }: &Fields,
 ) -> HQResult<Vec<InternalInstruction>> {
     let inner_instructions = func.compile_inner_step(Rc::clone(body))?;
@@ -50,6 +52,10 @@ pub fn wasm(
             .unwrap_or_else(|| Rc::clone(condition)),
     )?;
     let condition_instructions = func.compile_inner_step(Rc::clone(condition))?;
+    let pre_body_instructions = pre_body.as_ref().map_or_else(
+        || Ok(vec![]),
+        |pre_body_step| func.compile_inner_step(Rc::clone(pre_body_step)),
+    )?;
     Ok(wasm![Block(BlockType::Empty),]
         .into_iter()
         .chain(first_condition_instructions)
@@ -58,6 +64,7 @@ pub fn wasm(
         } else {
             wasm![I32Eqz, BrIf(0), Loop(BlockType::Empty)]
         })
+        .chain(pre_body_instructions)
         .chain(inner_instructions)
         .chain(condition_instructions)
         .chain(if *flip_if {
diff --git a/src/instructions/control/stop_all.rs b/src/instructions/control/stop_all.rs
new file mode 100644
index 00000000..46a605a6
--- /dev/null
+++ b/src/instructions/control/stop_all.rs
@@ -0,0 +1,45 @@
+use wasm_encoder::{ConstExpr, HeapType};
+
+use super::super::prelude::*;
+use crate::wasm::{GlobalExportable, GlobalMutable, ThreadsTable};
+
+pub fn wasm(func: &StepFunc, _inputs: Rc<[IrType]>) -> HQResult<Vec<InternalInstruction>> {
+    let threads_count = func.registries().globals().register(
+        "threads_count".into(),
+        (
+            ValType::I32,
+            ConstExpr::i32_const(0),
+            GlobalMutable(true),
+            GlobalExportable(true),
+        ),
+    )?;
+
+    let threads_table = func.registries().tables().register::<ThreadsTable, _>()?;
+    let thread_struct_type = func.registries().types().thread_struct_type()?;
+
+    Ok(wasm![
+        I32Const(0),
+        #LazyGlobalSet(threads_count),
+        I32Const(0),
+        RefNull(HeapType::Concrete(thread_struct_type)),
+        TableSize(threads_table),
+        TableFill(threads_table),
+    ])
+}
+
+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)
+}
diff --git a/src/instructions/data.rs b/src/instructions/data.rs
index 55e729ec..c5525252 100644
--- a/src/instructions/data.rs
+++ b/src/instructions/data.rs
@@ -9,3 +9,4 @@ pub mod replaceitemoflist;
 pub mod setvariableto;
 pub mod teevariable;
 pub mod variable;
+pub mod visvariable;
diff --git a/src/instructions/data/setvariableto.rs b/src/instructions/data/setvariableto.rs
index a9dc40c8..c8454f1f 100644
--- a/src/instructions/data/setvariableto.rs
+++ b/src/instructions/data/setvariableto.rs
@@ -1,5 +1,6 @@
 use super::super::prelude::*;
 use crate::ir::RcVar;
+use crate::wasm::WasmProject;
 
 /// we need these fields to be mutable for optimisations to be feasible
 #[derive(Debug, Clone)]
@@ -28,15 +29,48 @@ pub fn wasm(
     Fields { var, local_write }: &Fields,
 ) -> HQResult<Vec<InternalInstruction>> {
     let t1 = inputs[0];
-    if *local_write.try_borrow()? {
+    Ok(if let Some(monitor) = var.borrow().monitor().as_ref()
+        && *monitor.is_ever_visible.borrow()
+    {
+        let wasm_input_ty = WasmProject::ir_type_to_wasm(t1)?;
+        let local = func.local(wasm_input_ty)?;
+        let update_func = func.registries().external_functions().register(
+            (
+                "data",
+                match t1.base_type() {
+                    Some(IrType::Boolean) => "update_var_val_bool",
+                    Some(IrType::String) => "update_var_val_string",
+                    Some(IrType::Int) => "update_var_val_int",
+                    Some(IrType::Float) => "update_var_val_float",
+                    _ => hq_bug!("bad input type for variable with monitor"),
+                }
+                .into(),
+            ),
+            (vec![wasm_input_ty, ValType::EXTERNREF], vec![]),
+        )?;
+        let variable_string = func
+            .registries()
+            .strings()
+            .register_default(monitor.id.clone())?;
+        wasm![
+            LocalTee(local),
+            GlobalGet(variable_string),
+            Call(update_func),
+            LocalGet(local),
+        ]
+    } else {
+        wasm![]
+    }
+    .into_iter()
+    .chain(if *local_write.try_borrow()? {
         let local_index: u32 = func.local_variable(&*var.try_borrow()?)?;
         if var.borrow().possible_types().is_base_type() {
-            Ok(wasm![LocalSet(local_index)])
+            wasm![LocalSet(local_index)]
         } else {
-            Ok(wasm![
+            wasm![
                 @boxed(t1),
                 LocalSet(local_index)
-            ])
+            ]
         }
     } else {
         let global_index: u32 = func
@@ -44,14 +78,15 @@ pub fn wasm(
             .variables()
             .register(&*var.try_borrow()?)?;
         if var.try_borrow()?.possible_types().is_base_type() {
-            Ok(wasm![#LazyGlobalSet(global_index)])
+            wasm![#LazyGlobalSet(global_index)]
         } else {
-            Ok(wasm![
+            wasm![
                 @boxed(t1),
                 #LazyGlobalSet(global_index),
-            ])
+            ]
         }
-    }
+    })
+    .collect())
 }
 
 pub fn acceptable_inputs(Fields { var, .. }: &Fields) -> HQResult<Rc<[IrType]>> {
@@ -102,6 +137,7 @@ crate::instructions_test!(
                 crate::ir::RcVar::new(
                     IrType::Any,
                     crate::sb3::VarVal::Float(0.0),
+                    None,
             ).unwrap()),
         local_write: RefCell::new(false)
     }
@@ -115,6 +151,7 @@ crate::instructions_test!(
                 crate::ir::RcVar::new(
                     IrType::Float,
                     crate::sb3::VarVal::Float(0.0),
+                    None,
             ).unwrap()),
         local_write: RefCell::new(false)
     }
@@ -128,6 +165,7 @@ crate::instructions_test!(
                 crate::ir::RcVar::new(
                     IrType::String,
                     crate::sb3::VarVal::String("".into()),
+                    None,
             ).unwrap()),
         local_write: RefCell::new(false)
     }
@@ -141,6 +179,7 @@ crate::instructions_test!(
                 crate::ir::RcVar::new(
                     IrType::Int,
                     crate::sb3::VarVal::Int(1),
+                    None,
             ).unwrap()),
         local_write: RefCell::new(false)
     }
@@ -154,6 +193,7 @@ crate::instructions_test!(
                 crate::ir::RcVar::new(
                     IrType::Any,
                     crate::sb3::VarVal::Float(0.0),
+                    None,
             ).unwrap()),
         local_write: RefCell::new(true)
     }
@@ -167,6 +207,7 @@ crate::instructions_test!(
                 crate::ir::RcVar::new(
                     IrType::Float,
                     crate::sb3::VarVal::Float(0.0),
+                    None,
             ).unwrap()),
         local_write: RefCell::new(true)
     }
@@ -180,6 +221,7 @@ crate::instructions_test!(
                 crate::ir::RcVar::new(
                     IrType::String,
                     crate::sb3::VarVal::String("".into()),
+                    None,
             ).unwrap()),
         local_write: RefCell::new(true)
     }
@@ -193,6 +235,7 @@ crate::instructions_test!(
                 crate::ir::RcVar::new(
                     IrType::Int,
                     crate::sb3::VarVal::Int(1),
+                    None,
             ).unwrap()),
         local_write: RefCell::new(true)
     }
diff --git a/src/instructions/data/teevariable.rs b/src/instructions/data/teevariable.rs
index 6efa06fa..a9409e8a 100644
--- a/src/instructions/data/teevariable.rs
+++ b/src/instructions/data/teevariable.rs
@@ -2,6 +2,7 @@
 /// (i.e. locals) then this can actually use the wasm tee instruction.
 use super::super::prelude::*;
 use crate::ir::RcVar;
+use crate::wasm::WasmProject;
 
 #[derive(Debug, Clone)]
 pub struct Fields {
@@ -32,15 +33,48 @@ pub fn wasm(
     }: &Fields,
 ) -> HQResult<Vec<InternalInstruction>> {
     let t1 = inputs[0];
-    if *local_read_write.try_borrow()? {
+    Ok(if let Some(monitor) = var.borrow().monitor().as_ref()
+        && *monitor.is_ever_visible.borrow()
+    {
+        let wasm_input_ty = WasmProject::ir_type_to_wasm(t1)?;
+        let local = func.local(wasm_input_ty)?;
+        let update_func = func.registries().external_functions().register(
+            (
+                "data",
+                match t1.base_type() {
+                    Some(IrType::Boolean) => "update_var_val_bool",
+                    Some(IrType::String) => "update_var_val_string",
+                    Some(IrType::Int) => "update_var_val_int",
+                    Some(IrType::Float) => "update_var_val_float",
+                    _ => hq_bug!("bad input type for variable with monitor"),
+                }
+                .into(),
+            ),
+            (vec![wasm_input_ty, ValType::EXTERNREF], vec![]),
+        )?;
+        let variable_string = func
+            .registries()
+            .strings()
+            .register_default(monitor.id.clone())?;
+        wasm![
+            LocalTee(local),
+            GlobalGet(variable_string),
+            Call(update_func),
+            LocalGet(local),
+        ]
+    } else {
+        wasm![]
+    }
+    .into_iter()
+    .chain(if *local_read_write.try_borrow()? {
         let local_index: u32 = func.local_variable(&*var.try_borrow()?)?;
         if var.borrow().possible_types().is_base_type() {
-            Ok(wasm![LocalTee(local_index)])
+            wasm![LocalTee(local_index)]
         } else {
-            Ok(wasm![
+            wasm![
                 @boxed(t1),
                 LocalTee(local_index)
-            ])
+            ]
         }
     } else {
         let global_index: u32 = func
@@ -48,15 +82,16 @@ pub fn wasm(
             .variables()
             .register(&*var.try_borrow()?)?;
         if var.borrow().possible_types().is_base_type() {
-            Ok(wasm![#LazyGlobalSet(global_index), #LazyGlobalGet(global_index)])
+            wasm![#LazyGlobalSet(global_index), #LazyGlobalGet(global_index)]
         } else {
-            Ok(wasm![
+            wasm![
                 @boxed(t1),
                 #LazyGlobalSet(global_index),
                 #LazyGlobalGet(global_index)
-            ])
+            ]
         }
-    }
+    })
+    .collect())
 }
 
 pub fn acceptable_inputs(Fields { var, .. }: &Fields) -> HQResult<Rc<[IrType]>> {
@@ -108,6 +143,7 @@ crate::instructions_test!(
                 crate::ir::RcVar::new(
                     IrType::Any,
                     crate::sb3::VarVal::Float(0.0),
+                    None,
                 ).unwrap())
             ,
         local_read_write: RefCell::new(false),
@@ -123,6 +159,7 @@ crate::instructions_test!(
                 crate::ir::RcVar::new(
                     IrType::Float,
                     crate::sb3::VarVal::Float(0.0),
+                    None,
                 ).unwrap())
             ,
         local_read_write: RefCell::new(false),
@@ -138,6 +175,7 @@ crate::instructions_test!(
                 crate::ir::RcVar::new(
                     IrType::String,
                     crate::sb3::VarVal::String("".into()),
+                    None,
                 ).unwrap())
             ,
         local_read_write: RefCell::new(false),
@@ -153,6 +191,7 @@ crate::instructions_test!(
                 crate::ir::RcVar::new(
                     IrType::Int,
                     crate::sb3::VarVal::Int(1),
+                    None,
                 ).unwrap())
             ,
         local_read_write: RefCell::new(false),
@@ -168,6 +207,7 @@ crate::instructions_test!(
                 crate::ir::RcVar::new(
                     IrType::Any,
                     crate::sb3::VarVal::Float(0.0),
+                    None,
                 ).unwrap()
             ),
         local_read_write: RefCell::new(true),
@@ -183,6 +223,7 @@ crate::instructions_test!(
                 crate::ir::RcVar::new(
                     IrType::Float,
                     crate::sb3::VarVal::Float(0.0),
+                    None,
                 ).unwrap()
             ),
         local_read_write: RefCell::new(true),
@@ -198,6 +239,7 @@ crate::instructions_test!(
                 crate::ir::RcVar::new(
                     IrType::String,
                     crate::sb3::VarVal::String("".into()),
+                    None,
             ).unwrap()),
         local_read_write: RefCell::new(true),
     }
@@ -212,6 +254,7 @@ crate::instructions_test!(
                 crate::ir::RcVar::new(
                     IrType::Int,
                     crate::sb3::VarVal::Int(1),
+                    None,
             ).unwrap()),
         local_read_write: RefCell::new(true),
     }
diff --git a/src/instructions/data/variable.rs b/src/instructions/data/variable.rs
index 269d6db3..248aa7ab 100644
--- a/src/instructions/data/variable.rs
+++ b/src/instructions/data/variable.rs
@@ -85,6 +85,7 @@ crate::instructions_test!(
                 crate::ir::RcVar::new(
                     IrType::Any,
                     crate::sb3::VarVal::Float(0.0),
+                    None,
                 ).unwrap()
             )
         ,
@@ -100,6 +101,7 @@ crate::instructions_test!(
                 crate::ir::RcVar::new(
                     IrType::Float,
                     crate::sb3::VarVal::Float(0.0),
+                    None,
                 ).unwrap()
             ),
         local_read: RefCell::new(false)
@@ -115,6 +117,7 @@ crate::instructions_test!(
                 crate::ir::RcVar::new(
                     IrType::String,
                     crate::sb3::VarVal::String("".into()),
+                    None,
                 ).unwrap()
             )
         ,
@@ -131,6 +134,7 @@ crate::instructions_test!(
                 crate::ir::RcVar::new(
                     IrType::Int,
                     crate::sb3::VarVal::Int(1),
+                    None,
                 ).unwrap()
             )
         ,
@@ -147,6 +151,7 @@ crate::instructions_test!(
                 crate::ir::RcVar::new(
                     IrType::Any,
                     crate::sb3::VarVal::Float(0.0),
+                    None,
                 ).unwrap()
             )
         ,
@@ -163,6 +168,7 @@ crate::instructions_test!(
                 crate::ir::RcVar::new(
                     IrType::Float,
                     crate::sb3::VarVal::Float(0.0),
+                    None,
                 ).unwrap()
             )
         ,
@@ -178,6 +184,7 @@ crate::instructions_test!(
                 crate::ir::RcVar::new(
                     IrType::String,
                     crate::sb3::VarVal::String("".into()),
+                    None,
                 ).unwrap()
 
         ),
@@ -193,6 +200,7 @@ crate::instructions_test!(
                 crate::ir::RcVar::new(
                     IrType::Int,
                     crate::sb3::VarVal::Int(1),
+                    None,
                 ).unwrap()
         ),
         local_read: RefCell::new(true)
diff --git a/src/instructions/data/visvariable.rs b/src/instructions/data/visvariable.rs
new file mode 100644
index 00000000..908b722e
--- /dev/null
+++ b/src/instructions/data/visvariable.rs
@@ -0,0 +1,88 @@
+/// this is currently just a convenience block. if we get thread-scoped variables
+/// (i.e. locals) then this can actually use the wasm tee instruction.
+use super::super::prelude::*;
+use crate::ir::RcVar;
+
+#[derive(Debug, Clone)]
+pub struct Fields {
+    pub var: RefCell<RcVar>,
+    pub visible: bool,
+}
+
+impl fmt::Display for Fields {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(
+            f,
+            r#"{{
+        "variable": {},
+        "visible": {}
+    }}"#,
+            self.var.borrow(),
+            self.visible,
+        )
+    }
+}
+
+pub fn wasm(
+    func: &StepFunc,
+    _inputs: Rc<[IrType]>,
+    Fields { var, visible }: &Fields,
+) -> HQResult<Vec<InternalInstruction>> {
+    let borrowed_var = var.borrow();
+    let Some(monitor) = borrowed_var.monitor().as_ref() else {
+        hq_bug!("tried to change visibility of variable without monitor")
+    };
+    hq_assert!(
+        *monitor.is_ever_visible.borrow(),
+        "tried to change visibility of unused monitor"
+    );
+    let update_func = func.registries().external_functions().register(
+        ("data", "update_var_visible".into()),
+        (vec![ValType::EXTERNREF, ValType::I32], vec![]),
+    )?;
+    let variable_string = func
+        .registries()
+        .strings()
+        .register_default(monitor.id.clone())?;
+    Ok(wasm![
+        GlobalGet(variable_string),
+        I32Const((*visible).into()),
+        Call(update_func),
+    ])
+}
+
+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)
+}
+
+crate::instructions_test!(
+    test;
+    data_visvariable;
+    @ super::Fields {
+        var: RefCell::new(
+                crate::ir::RcVar::new(
+                    IrType::Any,
+                    crate::sb3::VarVal::Float(0.0),
+                    Some(crate::ir::IrMonitor {
+                        id: "".into(),
+                        is_ever_visible: RefCell::new(true,)
+                    }),
+                ).unwrap())
+            ,
+        visible: true
+    }
+);
diff --git a/src/instructions/hq.rs b/src/instructions/hq.rs
index 5c273ea2..d62c1f17 100644
--- a/src/instructions/hq.rs
+++ b/src/instructions/hq.rs
@@ -6,6 +6,7 @@ pub mod drop;
 pub mod dup;
 pub mod float;
 pub mod integer;
+pub mod poll_waiting_event;
 pub mod swap;
 pub mod text;
 pub mod r#yield;
diff --git a/src/instructions/hq/poll_waiting_event.rs b/src/instructions/hq/poll_waiting_event.rs
new file mode 100644
index 00000000..dc17ec58
--- /dev/null
+++ b/src/instructions/hq/poll_waiting_event.rs
@@ -0,0 +1,44 @@
+//! This is a bit of a strange instruction in that it relies on only ever being used inside a step
+//! that was spawned from a `sensing_askandwait` block (for now; there is potential to be expanded
+//! to other usecases which is why this is in the hq category rather than sensing). Any other usage
+//! will result in invalid wasm.
+//!
+//! Returns 1 if still waiting on any threads, 0 otherwise.
+
+use wasm_encoder::{FieldType, HeapType, StorageType};
+
+use super::super::prelude::*;
+use crate::wasm::StepFunc;
+
+pub fn wasm(func: &StepFunc, _inputs: Rc<[IrType]>) -> HQResult<Vec<InternalInstruction>> {
+    let i8_struct_type = func.registries().types().struct_(vec![FieldType {
+        element_type: StorageType::I8,
+        mutable: true,
+    }])?;
+
+    Ok(wasm![
+        LocalGet(1), // this should never have additional function arguments so this is fine
+        RefCastNonNull(HeapType::Concrete(i8_struct_type)),
+        StructGetS {
+            struct_type_index: i8_struct_type,
+            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::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/looks.rs b/src/instructions/looks.rs
index 1b86638a..2f143123 100644
--- a/src/instructions/looks.rs
+++ b/src/instructions/looks.rs
@@ -1,7 +1,10 @@
+pub mod backdropnumber;
+pub mod costumename;
 pub mod costumenumber;
 pub mod say;
 pub mod setsizeto;
 pub mod setvisible;
 pub mod size;
+pub mod switchbackdropto;
 pub mod switchcostumeto;
 pub mod think;
diff --git a/src/instructions/looks/backdropnumber.rs b/src/instructions/looks/backdropnumber.rs
new file mode 100644
index 00000000..fb677d80
--- /dev/null
+++ b/src/instructions/looks/backdropnumber.rs
@@ -0,0 +1,36 @@
+use wasm_encoder::MemArg;
+
+use super::super::prelude::*;
+use crate::wasm::mem_layout;
+
+pub fn wasm(_func: &StepFunc, _inputs: Rc<[IrType]>) -> HQResult<Vec<InternalInstruction>> {
+    let offset = mem_layout::stage::COSTUME;
+
+    Ok(wasm![
+        I32Const(0),
+        I32Load(MemArg {
+            offset: offset.into(),
+            align: 2,
+            memory_index: 0,
+        }),
+    ])
+}
+
+pub fn acceptable_inputs() -> HQResult<Rc<[IrType]>> {
+    Ok(Rc::from([]))
+}
+
+pub fn output_type(_inputs: Rc<[IrType]>) -> HQResult<ReturnType> {
+    Ok(ReturnType::Singleton(IrType::IntPos))
+}
+
+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; looks_backdropnumber; ; }
diff --git a/src/instructions/looks/costumename.rs b/src/instructions/looks/costumename.rs
new file mode 100644
index 00000000..266be5d5
--- /dev/null
+++ b/src/instructions/looks/costumename.rs
@@ -0,0 +1,67 @@
+use wasm_encoder::MemArg;
+
+use super::super::prelude::*;
+use crate::wasm::registries::tables::TableOptions;
+use crate::wasm::{StepTarget, mem_layout};
+
+pub fn wasm(func: &StepFunc, _inputs: Rc<[IrType]>) -> HQResult<Vec<InternalInstruction>> {
+    let wasm_target_index = match func.target() {
+        StepTarget::Sprite(index) => index,
+        StepTarget::Stage => 0,
+    };
+    let offset = mem_layout::stage::BLOCK_SIZE
+        + wasm_target_index * mem_layout::sprite::BLOCK_SIZE
+        + mem_layout::sprite::COSTUME;
+
+    let costume_names = func
+        .costume_names()
+        .get(func.target_index() as usize)
+        .ok_or_else(|| make_hq_bug!("target index out of bounds in costume names vec"))?;
+
+    let costume_name_table = func.registries().tables().register_dyn(
+        format!("costume_names_{}", func.target_index()).into_boxed_str(),
+        TableOptions {
+            element_type: RefType::EXTERNREF,
+            min: costume_names.len() as u64,
+            max: Some(costume_names.len() as u64),
+            init: None,
+            export_name: None,
+        },
+    )?;
+
+    for costume_name in costume_names {
+        // make sure that strings are all registered so that the element segment can refer to globals that actually exist
+        func.registries()
+            .strings()
+            .register_default::<usize>(costume_name.clone())?;
+    }
+
+    Ok(wasm![
+        I32Const(0),
+        I32Load(MemArg {
+            offset: offset.into(),
+            align: 2,
+            memory_index: 0,
+        }),
+        TableGet(costume_name_table),
+    ])
+}
+
+pub fn acceptable_inputs() -> HQResult<Rc<[IrType]>> {
+    Ok(Rc::from([]))
+}
+
+pub fn output_type(_inputs: Rc<[IrType]>) -> HQResult<ReturnType> {
+    Ok(ReturnType::Singleton(IrType::String))
+}
+
+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; looks_costumename; ; }
diff --git a/src/instructions/looks/switchbackdropto.rs b/src/instructions/looks/switchbackdropto.rs
new file mode 100644
index 00000000..c35dbf6e
--- /dev/null
+++ b/src/instructions/looks/switchbackdropto.rs
@@ -0,0 +1,50 @@
+use wasm_encoder::MemArg;
+
+use super::super::prelude::*;
+use crate::wasm::mem_layout;
+
+pub fn wasm(func: &StepFunc, inputs: Rc<[IrType]>) -> HQResult<Vec<InternalInstruction>> {
+    let func_index = func.registries().external_functions().register(
+        ("looks", "switchbackdropto".into()),
+        (vec![ValType::I32], vec![]),
+    )?;
+    let offset = mem_layout::stage::COSTUME;
+
+    let local_index = func.local(ValType::I32)?;
+    Ok(if IrType::QuasiInt.contains(inputs[0]) {
+        wasm![
+            LocalSet(local_index),
+            I32Const(0),
+            LocalGet(local_index),
+            I32Store(MemArg {
+                offset: offset.into(),
+                align: 2,
+                memory_index: 0,
+            }),
+            LocalGet(local_index),
+            Call(func_index),
+        ]
+    } else {
+        hq_todo!("non-integer input types for looks_switchbackdropto")
+    })
+}
+
+pub fn acceptable_inputs() -> HQResult<Rc<[IrType]>> {
+    // TODO: accept non-integer values (try to find costume name)
+    Ok(Rc::from([IrType::Int]))
+}
+
+pub fn output_type(_inputs: Rc<[IrType]>) -> HQResult<ReturnType> {
+    Ok(ReturnType::None)
+}
+
+pub const REQUESTS_SCREEN_REFRESH: bool = true;
+
+pub const fn const_fold(
+    _inputs: &[ConstFoldItem],
+    _state: &mut ConstFoldState,
+) -> HQResult<ConstFold> {
+    Ok(NotFoldable)
+}
+
+crate::instructions_test! {tests; looks_switchbackdropto; t ; }
diff --git a/src/instructions/looks/switchcostumeto.rs b/src/instructions/looks/switchcostumeto.rs
index 14d57ee2..dae9ba69 100644
--- a/src/instructions/looks/switchcostumeto.rs
+++ b/src/instructions/looks/switchcostumeto.rs
@@ -12,13 +12,14 @@ pub fn wasm(func: &StepFunc, inputs: Rc<[IrType]>) -> HQResult<Vec<InternalInstr
         ("looks", "switchcostumeto".into()),
         (vec![ValType::I32, ValType::I32], vec![]),
     )?;
-    let wasm_target_index = match func.target() {
-        StepTarget::Sprite(index) => index,
-        StepTarget::Stage => 0,
+    let offset = match func.target() {
+        StepTarget::Sprite(index) => {
+            mem_layout::stage::BLOCK_SIZE
+                + index * mem_layout::sprite::BLOCK_SIZE
+                + mem_layout::sprite::COSTUME
+        }
+        StepTarget::Stage => mem_layout::stage::COSTUME,
     };
-    let offset = mem_layout::stage::BLOCK_SIZE
-        + wasm_target_index * mem_layout::sprite::BLOCK_SIZE
-        + mem_layout::sprite::COSTUME;
 
     let local_index = func.local(ValType::I32)?;
     Ok(if IrType::QuasiInt.contains(inputs[0]) {
diff --git a/src/instructions/motion.rs b/src/instructions/motion.rs
index 38827ca6..03d36511 100644
--- a/src/instructions/motion.rs
+++ b/src/instructions/motion.rs
@@ -1,3 +1,7 @@
 pub mod direction;
 pub mod gotoxy;
 pub mod pointindirection;
+pub mod setx;
+pub mod sety;
+pub mod xposition;
+pub mod yposition;
diff --git a/src/instructions/motion/setx.rs b/src/instructions/motion/setx.rs
new file mode 100644
index 00000000..a3959cd6
--- /dev/null
+++ b/src/instructions/motion/setx.rs
@@ -0,0 +1,171 @@
+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()
+        .try_into()
+        .map_err(|_| make_hq_bug!("target index out of bounds"))?;
+    let move_func_index = func.registries().external_functions().register(
+        ("motion", "gotoxy".into()),
+        (vec![ValType::F64, ValType::F64, ValType::I32], vec![]),
+    )?;
+    let pen_func_index = func.registries().external_functions().register(
+        ("pen", "line".into()),
+        (
+            vec![
+                ValType::F64,
+                ValType::F64,
+                ValType::F64,
+                ValType::F64,
+                ValType::F64,
+                ValType::F32,
+                ValType::F32,
+                ValType::F32,
+                ValType::F32,
+            ],
+            vec![],
+        ),
+    )?;
+    let StepTarget::Sprite(wasm_target_index) = func.target() else {
+        hq_bad_proj!("motion_setx called in stage")
+    };
+    let x_local = func.local(ValType::F64)?;
+    let y_local = func.local(ValType::F64)?;
+    Ok(wasm![
+        LocalSet(x_local),
+        I32Const(0),
+        F64Load(MemArg {
+            offset: (stage_layout::BLOCK_SIZE
+                + wasm_target_index * sprite_layout::BLOCK_SIZE
+                + sprite_layout::Y)
+                .into(),
+            align: 3,
+            memory_index: 0
+        }),
+        LocalSet(y_local),
+        I32Const(0),
+        I32Load8U(MemArg {
+            offset: (stage_layout::BLOCK_SIZE
+                + wasm_target_index * sprite_layout::BLOCK_SIZE
+                + sprite_layout::PEN_DOWN)
+                .into(),
+            align: 0,
+            memory_index: 0
+        }),
+        If(wasm_encoder::BlockType::Empty),
+        I32Const(0),
+        F64Load(MemArg {
+            offset: (stage_layout::BLOCK_SIZE
+                + wasm_target_index * sprite_layout::BLOCK_SIZE
+                + sprite_layout::PEN_SIZE)
+                .into(),
+            align: 3,
+            memory_index: 0
+        }),
+        I32Const(0),
+        F64Load(MemArg {
+            offset: (stage_layout::BLOCK_SIZE
+                + wasm_target_index * sprite_layout::BLOCK_SIZE
+                + sprite_layout::X)
+                .into(),
+            align: 3,
+            memory_index: 0
+        }),
+        I32Const(0),
+        F64Load(MemArg {
+            offset: (stage_layout::BLOCK_SIZE
+                + wasm_target_index * sprite_layout::BLOCK_SIZE
+                + sprite_layout::Y)
+                .into(),
+            align: 3,
+            memory_index: 0
+        }),
+        LocalGet(x_local),
+        LocalGet(y_local),
+        I32Const(0),
+        F32Load(MemArg {
+            offset: (stage_layout::BLOCK_SIZE
+                + wasm_target_index * sprite_layout::BLOCK_SIZE
+                + sprite_layout::PEN_COLOR_R)
+                .into(),
+            align: 2,
+            memory_index: 0
+        }),
+        I32Const(0),
+        F32Load(MemArg {
+            offset: (stage_layout::BLOCK_SIZE
+                + wasm_target_index * sprite_layout::BLOCK_SIZE
+                + sprite_layout::PEN_COLOR_G)
+                .into(),
+            align: 2,
+            memory_index: 0
+        }),
+        I32Const(0),
+        F32Load(MemArg {
+            offset: (stage_layout::BLOCK_SIZE
+                + wasm_target_index * sprite_layout::BLOCK_SIZE
+                + sprite_layout::PEN_COLOR_B)
+                .into(),
+            align: 2,
+            memory_index: 0
+        }),
+        I32Const(0),
+        F32Load(MemArg {
+            offset: (stage_layout::BLOCK_SIZE
+                + wasm_target_index * sprite_layout::BLOCK_SIZE
+                + sprite_layout::PEN_COLOR_A)
+                .into(),
+            align: 2,
+            memory_index: 0
+        }),
+        Call(pen_func_index),
+        End,
+        I32Const(0),
+        LocalGet(x_local),
+        F64Store(MemArg {
+            offset: (stage_layout::BLOCK_SIZE
+                + wasm_target_index * sprite_layout::BLOCK_SIZE
+                + sprite_layout::X)
+                .into(),
+            align: 3,
+            memory_index: 0,
+        }),
+        I32Const(0),
+        LocalGet(y_local),
+        F64Store(MemArg {
+            offset: (stage_layout::BLOCK_SIZE
+                + wasm_target_index * sprite_layout::BLOCK_SIZE
+                + sprite_layout::Y)
+                .into(),
+            align: 3,
+            memory_index: 0,
+        }),
+        LocalGet(x_local),
+        LocalGet(y_local),
+        I32Const(ir_target_index),
+        Call(move_func_index),
+    ])
+}
+
+pub fn acceptable_inputs() -> HQResult<Rc<[IrType]>> {
+    Ok(Rc::from([IrType::Float]))
+}
+
+pub fn output_type(_inputs: Rc<[IrType]>) -> HQResult<ReturnType> {
+    Ok(ReturnType::None)
+}
+
+pub const REQUESTS_SCREEN_REFRESH: bool = true;
+
+pub const fn const_fold(
+    _inputs: &[ConstFoldItem],
+    _state: &mut ConstFoldState,
+) -> HQResult<ConstFold> {
+    Ok(NotFoldable)
+}
+
+crate::instructions_test! {tests; motion_setx; t ; }
diff --git a/src/instructions/motion/sety.rs b/src/instructions/motion/sety.rs
new file mode 100644
index 00000000..103858c7
--- /dev/null
+++ b/src/instructions/motion/sety.rs
@@ -0,0 +1,171 @@
+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()
+        .try_into()
+        .map_err(|_| make_hq_bug!("target index out of bounds"))?;
+    let move_func_index = func.registries().external_functions().register(
+        ("motion", "gotoxy".into()),
+        (vec![ValType::F64, ValType::F64, ValType::I32], vec![]),
+    )?;
+    let pen_func_index = func.registries().external_functions().register(
+        ("pen", "line".into()),
+        (
+            vec![
+                ValType::F64,
+                ValType::F64,
+                ValType::F64,
+                ValType::F64,
+                ValType::F64,
+                ValType::F32,
+                ValType::F32,
+                ValType::F32,
+                ValType::F32,
+            ],
+            vec![],
+        ),
+    )?;
+    let StepTarget::Sprite(wasm_target_index) = func.target() else {
+        hq_bad_proj!("motion_sety called in stage")
+    };
+    let x_local = func.local(ValType::F64)?;
+    let y_local = func.local(ValType::F64)?;
+    Ok(wasm![
+        LocalSet(y_local),
+        I32Const(0),
+        F64Load(MemArg {
+            offset: (stage_layout::BLOCK_SIZE
+                + wasm_target_index * sprite_layout::BLOCK_SIZE
+                + sprite_layout::X)
+                .into(),
+            align: 3,
+            memory_index: 0
+        }),
+        LocalSet(x_local),
+        I32Const(0),
+        I32Load8U(MemArg {
+            offset: (stage_layout::BLOCK_SIZE
+                + wasm_target_index * sprite_layout::BLOCK_SIZE
+                + sprite_layout::PEN_DOWN)
+                .into(),
+            align: 0,
+            memory_index: 0
+        }),
+        If(wasm_encoder::BlockType::Empty),
+        I32Const(0),
+        F64Load(MemArg {
+            offset: (stage_layout::BLOCK_SIZE
+                + wasm_target_index * sprite_layout::BLOCK_SIZE
+                + sprite_layout::PEN_SIZE)
+                .into(),
+            align: 3,
+            memory_index: 0
+        }),
+        I32Const(0),
+        F64Load(MemArg {
+            offset: (stage_layout::BLOCK_SIZE
+                + wasm_target_index * sprite_layout::BLOCK_SIZE
+                + sprite_layout::X)
+                .into(),
+            align: 3,
+            memory_index: 0
+        }),
+        I32Const(0),
+        F64Load(MemArg {
+            offset: (stage_layout::BLOCK_SIZE
+                + wasm_target_index * sprite_layout::BLOCK_SIZE
+                + sprite_layout::Y)
+                .into(),
+            align: 3,
+            memory_index: 0
+        }),
+        LocalGet(x_local),
+        LocalGet(y_local),
+        I32Const(0),
+        F32Load(MemArg {
+            offset: (stage_layout::BLOCK_SIZE
+                + wasm_target_index * sprite_layout::BLOCK_SIZE
+                + sprite_layout::PEN_COLOR_R)
+                .into(),
+            align: 2,
+            memory_index: 0
+        }),
+        I32Const(0),
+        F32Load(MemArg {
+            offset: (stage_layout::BLOCK_SIZE
+                + wasm_target_index * sprite_layout::BLOCK_SIZE
+                + sprite_layout::PEN_COLOR_G)
+                .into(),
+            align: 2,
+            memory_index: 0
+        }),
+        I32Const(0),
+        F32Load(MemArg {
+            offset: (stage_layout::BLOCK_SIZE
+                + wasm_target_index * sprite_layout::BLOCK_SIZE
+                + sprite_layout::PEN_COLOR_B)
+                .into(),
+            align: 2,
+            memory_index: 0
+        }),
+        I32Const(0),
+        F32Load(MemArg {
+            offset: (stage_layout::BLOCK_SIZE
+                + wasm_target_index * sprite_layout::BLOCK_SIZE
+                + sprite_layout::PEN_COLOR_A)
+                .into(),
+            align: 2,
+            memory_index: 0
+        }),
+        Call(pen_func_index),
+        End,
+        I32Const(0),
+        LocalGet(x_local),
+        F64Store(MemArg {
+            offset: (stage_layout::BLOCK_SIZE
+                + wasm_target_index * sprite_layout::BLOCK_SIZE
+                + sprite_layout::X)
+                .into(),
+            align: 3,
+            memory_index: 0,
+        }),
+        I32Const(0),
+        LocalGet(y_local),
+        F64Store(MemArg {
+            offset: (stage_layout::BLOCK_SIZE
+                + wasm_target_index * sprite_layout::BLOCK_SIZE
+                + sprite_layout::Y)
+                .into(),
+            align: 3,
+            memory_index: 0,
+        }),
+        LocalGet(x_local),
+        LocalGet(y_local),
+        I32Const(ir_target_index),
+        Call(move_func_index),
+    ])
+}
+
+pub fn acceptable_inputs() -> HQResult<Rc<[IrType]>> {
+    Ok(Rc::from([IrType::Float]))
+}
+
+pub fn output_type(_inputs: Rc<[IrType]>) -> HQResult<ReturnType> {
+    Ok(ReturnType::None)
+}
+
+pub const REQUESTS_SCREEN_REFRESH: bool = true;
+
+pub const fn const_fold(
+    _inputs: &[ConstFoldItem],
+    _state: &mut ConstFoldState,
+) -> HQResult<ConstFold> {
+    Ok(NotFoldable)
+}
+
+crate::instructions_test! {tests; motion_setx; t ; }
diff --git a/src/instructions/motion/xposition.rs b/src/instructions/motion/xposition.rs
new file mode 100644
index 00000000..fc260381
--- /dev/null
+++ b/src/instructions/motion/xposition.rs
@@ -0,0 +1,41 @@
+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_xposition called in stage")
+    };
+    Ok(wasm![
+        I32Const(0),
+        F64Load(MemArg {
+            offset: (stage_layout::BLOCK_SIZE
+                + wasm_target_index * sprite_layout::BLOCK_SIZE
+                + sprite_layout::X)
+                .into(),
+            align: 3,
+            memory_index: 0
+        }),
+    ])
+}
+
+pub fn acceptable_inputs() -> HQResult<Rc<[IrType]>> {
+    Ok(Rc::from([]))
+}
+
+pub fn output_type(_inputs: Rc<[IrType]>) -> HQResult<ReturnType> {
+    Ok(ReturnType::Singleton(IrType::FloatReal))
+}
+
+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; motion_xposition; }
diff --git a/src/instructions/motion/yposition.rs b/src/instructions/motion/yposition.rs
new file mode 100644
index 00000000..5d77a6e4
--- /dev/null
+++ b/src/instructions/motion/yposition.rs
@@ -0,0 +1,41 @@
+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_yposition called in stage")
+    };
+    Ok(wasm![
+        I32Const(0),
+        F64Load(MemArg {
+            offset: (stage_layout::BLOCK_SIZE
+                + wasm_target_index * sprite_layout::BLOCK_SIZE
+                + sprite_layout::Y)
+                .into(),
+            align: 3,
+            memory_index: 0
+        }),
+    ])
+}
+
+pub fn acceptable_inputs() -> HQResult<Rc<[IrType]>> {
+    Ok(Rc::from([]))
+}
+
+pub fn output_type(_inputs: Rc<[IrType]>) -> HQResult<ReturnType> {
+    Ok(ReturnType::Singleton(IrType::FloatReal))
+}
+
+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; motion_yposition; }
diff --git a/src/instructions/operator.rs b/src/instructions/operator.rs
index 9357401c..ce821e37 100644
--- a/src/instructions/operator.rs
+++ b/src/instructions/operator.rs
@@ -24,6 +24,7 @@ pub mod not;
 pub mod or;
 pub mod pow10;
 pub mod random;
+pub mod round;
 pub mod sin;
 pub mod sqrt;
 pub mod subtract;
diff --git a/src/instructions/operator/gt.rs b/src/instructions/operator/gt.rs
index 9b30d5e5..e8a8b4b5 100644
--- a/src/instructions/operator/gt.rs
+++ b/src/instructions/operator/gt.rs
@@ -28,7 +28,10 @@ pub fn wasm(func: &StepFunc, inputs: Rc<[IrType]>) -> HQResult<Vec<InternalInstr
                 End,
             ]
         } else if IrType::String.contains(t2) {
-            // TODO: try converting string to number first (if applicable)
+            let string2float = func.registries().external_functions().register(
+                ("cast", "string2float".into()),
+                (vec![ValType::EXTERNREF], vec![ValType::F64]),
+            )?;
             let int2string = func.registries().external_functions().register(
                 ("cast", "int2string".into()),
                 (vec![ValType::I32], vec![ValType::EXTERNREF]),
@@ -41,11 +44,26 @@ pub fn wasm(func: &StepFunc, inputs: Rc<[IrType]>) -> HQResult<Vec<InternalInstr
                 ),
             )?;
             let extern_local = func.local(ValType::EXTERNREF)?;
+            let float_local = func.local(ValType::F64)?;
+            let block_type = func
+                .registries()
+                .types()
+                .function(vec![ValType::I32], vec![ValType::I32])?;
             wasm![
-                LocalSet(extern_local),
+                LocalTee(extern_local),
+                Call(string2float),
+                LocalTee(float_local),
+                LocalGet(float_local),
+                F64Ne, // test if float_local is NaN
+                If(BlockType::FunctionType(block_type)),
                 Call(int2string),
                 LocalGet(extern_local),
-                Call(string_gt)
+                Call(string_gt),
+                Else,
+                F64ConvertI32S,
+                LocalGet(float_local),
+                F64Gt,
+                End,
             ]
         } else {
             hq_bug!("bad input")
@@ -89,6 +107,10 @@ pub fn wasm(func: &StepFunc, inputs: Rc<[IrType]>) -> HQResult<Vec<InternalInstr
                 End,
             ]
         } else if IrType::String.contains(t2) {
+            let string2float = func.registries().external_functions().register(
+                ("cast", "string2float".into()),
+                (vec![ValType::EXTERNREF], vec![ValType::F64]),
+            )?;
             let float2string = func.registries().external_functions().register(
                 ("cast", "float2string".into()),
                 (vec![ValType::F64], vec![ValType::EXTERNREF]),
@@ -101,18 +123,41 @@ pub fn wasm(func: &StepFunc, inputs: Rc<[IrType]>) -> HQResult<Vec<InternalInstr
                 ),
             )?;
             let extern_local = func.local(ValType::EXTERNREF)?;
+            let float1_local = func.local(ValType::F64)?;
+            let float2_local = func.local(ValType::F64)?;
+            let block_type = func
+                .registries()
+                .types()
+                .function(vec![ValType::F64], vec![ValType::I32])?;
             wasm![
                 LocalSet(extern_local),
+                LocalTee(float1_local),
+                LocalGet(extern_local),
+                Call(string2float),
+                LocalTee(float2_local),
+                LocalGet(float2_local),
+                F64Ne, // test if float_local is NaN
+                LocalGet(float1_local),
+                @isnan(t1),
+                I32Or,
+                If(BlockType::FunctionType(block_type)),
                 Call(float2string),
                 LocalGet(extern_local),
-                Call(string_gt)
+                Call(string_gt),
+                Else,
+                LocalGet(float2_local),
+                F64Gt,
+                End,
             ]
         } else {
             hq_bug!("bad input")
         }
     } else if IrType::String.contains(t1) {
         if IrType::QuasiInt.contains(t2) {
-            // TODO: try converting string to number first
+            let string2float = func.registries().external_functions().register(
+                ("cast", "string2float".into()),
+                (vec![ValType::EXTERNREF], vec![ValType::F64]),
+            )?;
             let int2string = func.registries().external_functions().register(
                 ("cast", "int2string".into()),
                 (vec![ValType::I32], vec![ValType::EXTERNREF]),
@@ -124,9 +169,33 @@ pub fn wasm(func: &StepFunc, inputs: Rc<[IrType]>) -> HQResult<Vec<InternalInstr
                     vec![ValType::I32],
                 ),
             )?;
-            wasm![Call(int2string), Call(string_gt)]
+            let extern_local = func.local(ValType::EXTERNREF)?;
+            let float_local = func.local(ValType::F64)?;
+            let int_local = func.local(ValType::I32)?;
+            wasm![
+                LocalSet(int_local),
+                LocalTee(extern_local),
+                Call(string2float),
+                LocalTee(float_local),
+                LocalGet(float_local),
+                F64Ne, // test if float_local is NaN
+                If(BlockType::Result(ValType::I32)),
+                LocalGet(extern_local),
+                LocalGet(int_local),
+                Call(int2string),
+                Call(string_gt),
+                Else,
+                LocalGet(float_local),
+                LocalGet(int_local),
+                F64ConvertI32S,
+                F64Gt,
+                End,
+            ]
         } else if IrType::Float.contains(t2) {
-            // TODO: try converting string to number first
+            let string2float = func.registries().external_functions().register(
+                ("cast", "string2float".into()),
+                (vec![ValType::EXTERNREF], vec![ValType::F64]),
+            )?;
             let float2string = func.registries().external_functions().register(
                 ("cast", "float2string".into()),
                 (vec![ValType::F64], vec![ValType::EXTERNREF]),
@@ -138,8 +207,35 @@ pub fn wasm(func: &StepFunc, inputs: Rc<[IrType]>) -> HQResult<Vec<InternalInstr
                     vec![ValType::I32],
                 ),
             )?;
-            wasm![Call(float2string), Call(string_gt)]
+            let extern_local = func.local(ValType::EXTERNREF)?;
+            let float2_local = func.local(ValType::F64)?;
+            let float1_local = func.local(ValType::F64)?;
+            wasm![
+                LocalSet(float2_local),
+                LocalTee(extern_local),
+                Call(string2float),
+                LocalTee(float1_local),
+                LocalGet(float1_local),
+                F64Ne, // test if float_local is NaN
+                LocalGet(float2_local),
+                @isnan(t2),
+                I32Or,
+                If(BlockType::Result(ValType::I32)),
+                LocalGet(extern_local),
+                LocalGet(float2_local),
+                Call(float2string),
+                Call(string_gt),
+                Else,
+                LocalGet(float1_local),
+                LocalGet(float2_local),
+                F64Gt,
+                End,
+            ]
         } else if IrType::String.contains(t2) {
+            let string2float = func.registries().external_functions().register(
+                ("cast", "string2float".into()),
+                (vec![ValType::EXTERNREF], vec![ValType::F64]),
+            )?;
             let string_gt = func.registries().external_functions().register(
                 ("operator", "gt_string".into()),
                 (
@@ -147,7 +243,33 @@ pub fn wasm(func: &StepFunc, inputs: Rc<[IrType]>) -> HQResult<Vec<InternalInstr
                     vec![ValType::I32],
                 ),
             )?;
-            wasm![Call(string_gt)]
+            let extern1_local = func.local(ValType::EXTERNREF)?;
+            let extern2_local = func.local(ValType::EXTERNREF)?;
+            let float1_local = func.local(ValType::F64)?;
+            let float2_local = func.local(ValType::F64)?;
+            wasm![
+                LocalTee(extern2_local),
+                Call(string2float),
+                LocalSet(float2_local),
+                LocalTee(extern1_local),
+                Call(string2float),
+                LocalTee(float1_local),
+                LocalGet(float1_local),
+                F64Ne,
+                LocalGet(float2_local),
+                LocalGet(float2_local),
+                F64Ne,
+                I32Or,
+                If(BlockType::Result(ValType::I32)),
+                LocalGet(extern1_local),
+                LocalGet(extern2_local),
+                Call(string_gt),
+                Else,
+                LocalGet(float1_local),
+                LocalGet(float2_local),
+                F64Gt,
+                End,
+            ]
         } else {
             hq_bug!("bad input")
         }
diff --git a/src/instructions/operator/lt.rs b/src/instructions/operator/lt.rs
index fe689297..a22a57cc 100644
--- a/src/instructions/operator/lt.rs
+++ b/src/instructions/operator/lt.rs
@@ -28,7 +28,10 @@ pub fn wasm(func: &StepFunc, inputs: Rc<[IrType]>) -> HQResult<Vec<InternalInstr
                 End,
             ]
         } else if IrType::String.contains(t2) {
-            // TODO: try converting string to number first (if applicable)
+            let string2float = func.registries().external_functions().register(
+                ("cast", "string2float".into()),
+                (vec![ValType::EXTERNREF], vec![ValType::F64]),
+            )?;
             let int2string = func.registries().external_functions().register(
                 ("cast", "int2string".into()),
                 (vec![ValType::I32], vec![ValType::EXTERNREF]),
@@ -41,11 +44,26 @@ pub fn wasm(func: &StepFunc, inputs: Rc<[IrType]>) -> HQResult<Vec<InternalInstr
                 ),
             )?;
             let extern_local = func.local(ValType::EXTERNREF)?;
+            let float_local = func.local(ValType::F64)?;
+            let block_type = func
+                .registries()
+                .types()
+                .function(vec![ValType::I32], vec![ValType::I32])?;
             wasm![
-                LocalSet(extern_local),
+                LocalTee(extern_local),
+                Call(string2float),
+                LocalTee(float_local),
+                LocalGet(float_local),
+                F64Ne, // test if float_local is NaN
+                If(BlockType::FunctionType(block_type)),
                 Call(int2string),
                 LocalGet(extern_local),
-                Call(string_lt)
+                Call(string_lt),
+                Else,
+                F64ConvertI32S,
+                LocalGet(float_local),
+                F64Lt,
+                End,
             ]
         } else {
             hq_bug!("bad input")
@@ -93,6 +111,10 @@ pub fn wasm(func: &StepFunc, inputs: Rc<[IrType]>) -> HQResult<Vec<InternalInstr
                 End,
             ]
         } else if IrType::String.contains(t2) {
+            let string2float = func.registries().external_functions().register(
+                ("cast", "string2float".into()),
+                (vec![ValType::EXTERNREF], vec![ValType::F64]),
+            )?;
             let float2string = func.registries().external_functions().register(
                 ("cast", "float2string".into()),
                 (vec![ValType::F64], vec![ValType::EXTERNREF]),
@@ -105,18 +127,41 @@ pub fn wasm(func: &StepFunc, inputs: Rc<[IrType]>) -> HQResult<Vec<InternalInstr
                 ),
             )?;
             let extern_local = func.local(ValType::EXTERNREF)?;
+            let float1_local = func.local(ValType::F64)?;
+            let float2_local = func.local(ValType::F64)?;
+            let block_type = func
+                .registries()
+                .types()
+                .function(vec![ValType::F64], vec![ValType::I32])?;
             wasm![
                 LocalSet(extern_local),
+                LocalTee(float1_local),
+                LocalGet(extern_local),
+                Call(string2float),
+                LocalTee(float2_local),
+                LocalGet(float2_local),
+                F64Ne, // test if float_local is NaN
+                LocalGet(float1_local),
+                @isnan(t1),
+                I32Or,
+                If(BlockType::FunctionType(block_type)),
                 Call(float2string),
                 LocalGet(extern_local),
-                Call(string_lt)
+                Call(string_lt),
+                Else,
+                LocalGet(float2_local),
+                F64Lt,
+                End,
             ]
         } else {
             hq_bug!("bad input")
         }
     } else if IrType::String.contains(t1) {
         if IrType::QuasiInt.contains(t2) {
-            // TODO: try converting string to number first
+            let string2float = func.registries().external_functions().register(
+                ("cast", "string2float".into()),
+                (vec![ValType::EXTERNREF], vec![ValType::F64]),
+            )?;
             let int2string = func.registries().external_functions().register(
                 ("cast", "int2string".into()),
                 (vec![ValType::I32], vec![ValType::EXTERNREF]),
@@ -128,9 +173,33 @@ pub fn wasm(func: &StepFunc, inputs: Rc<[IrType]>) -> HQResult<Vec<InternalInstr
                     vec![ValType::I32],
                 ),
             )?;
-            wasm![Call(int2string), Call(string_lt)]
+            let extern_local = func.local(ValType::EXTERNREF)?;
+            let float_local = func.local(ValType::F64)?;
+            let int_local = func.local(ValType::I32)?;
+            wasm![
+                LocalSet(int_local),
+                LocalTee(extern_local),
+                Call(string2float),
+                LocalTee(float_local),
+                LocalGet(float_local),
+                F64Ne, // test if float_local is NaN
+                If(BlockType::Result(ValType::I32)),
+                LocalGet(extern_local),
+                LocalGet(int_local),
+                Call(int2string),
+                Call(string_lt),
+                Else,
+                LocalGet(float_local),
+                LocalGet(int_local),
+                F64ConvertI32S,
+                F64Lt,
+                End,
+            ]
         } else if IrType::Float.contains(t2) {
-            // TODO: try converting string to number first
+            let string2float = func.registries().external_functions().register(
+                ("cast", "string2float".into()),
+                (vec![ValType::EXTERNREF], vec![ValType::F64]),
+            )?;
             let float2string = func.registries().external_functions().register(
                 ("cast", "float2string".into()),
                 (vec![ValType::F64], vec![ValType::EXTERNREF]),
@@ -142,8 +211,32 @@ pub fn wasm(func: &StepFunc, inputs: Rc<[IrType]>) -> HQResult<Vec<InternalInstr
                     vec![ValType::I32],
                 ),
             )?;
-            wasm![Call(float2string), Call(string_lt)]
+            let extern_local = func.local(ValType::EXTERNREF)?;
+            let float2_local = func.local(ValType::F64)?;
+            let float1_local = func.local(ValType::F64)?;
+            wasm![
+                LocalSet(float2_local),
+                LocalTee(extern_local),
+                Call(string2float),
+                LocalTee(float1_local),
+                LocalGet(float1_local),
+                F64Ne, // test if float_local is NaN
+                LocalGet(float2_local),
+                @isnan(t2),
+                I32Or,
+                If(BlockType::Result(ValType::I32)),
+                LocalGet(extern_local),
+                LocalGet(float2_local),
+                Call(float2string),
+                Call(string_lt),
+                Else,
+                LocalGet(float1_local),
+                LocalGet(float2_local),
+                F64Lt,
+                End,
+            ]
         } else if IrType::String.contains(t2) {
+            // TODO: try converting to numbers first
             let string_lt = func.registries().external_functions().register(
                 ("operator", "lt_string".into()),
                 (
diff --git a/src/instructions/operator/round.rs b/src/instructions/operator/round.rs
new file mode 100644
index 00000000..5f2c297a
--- /dev/null
+++ b/src/instructions/operator/round.rs
@@ -0,0 +1,41 @@
+use super::super::prelude::*;
+
+pub fn wasm(func: &StepFunc, inputs: Rc<[IrType]>) -> HQResult<Vec<InternalInstruction>> {
+    hq_assert_eq!(inputs.len(), 1);
+    let t1 = inputs[0];
+    Ok(if IrType::QuasiInt.contains(t1) {
+        wasm![]
+    } else if IrType::Float.contains(t1) {
+        wasm![
+            @nanreduce(t1),
+            F64Nearest,
+        ]
+    } else {
+        hq_bug!("bad input: {:?}", inputs)
+    })
+}
+
+pub fn acceptable_inputs() -> HQResult<Rc<[IrType]>> {
+    Ok(Rc::from([IrType::Number]))
+}
+
+pub fn output_type(inputs: Rc<[IrType]>) -> HQResult<ReturnType> {
+    hq_assert_eq!(inputs.len(), 1);
+    let t1 = inputs[0];
+    Ok(Singleton(if IrType::QuasiInt.contains(t1) {
+        t1
+    } else {
+        IrType::Float
+    }))
+}
+
+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; operator_round; t }
diff --git a/src/instructions/pen.rs b/src/instructions/pen.rs
index c2bf2ed3..43311219 100644
--- a/src/instructions/pen.rs
+++ b/src/instructions/pen.rs
@@ -1,3 +1,4 @@
+pub mod changecolorparamby;
 pub mod clear;
 pub mod pendown;
 pub mod penup;
diff --git a/src/instructions/pen/changecolorparamby.rs b/src/instructions/pen/changecolorparamby.rs
new file mode 100644
index 00000000..19f6c0ae
--- /dev/null
+++ b/src/instructions/pen/changecolorparamby.rs
@@ -0,0 +1,148 @@
+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};
+
+pub fn wasm(func: &StepFunc, _inputs: Rc<[IrType]>) -> HQResult<Vec<InternalInstruction>> {
+    let StepTarget::Sprite(wasm_target_index) = func.target() else {
+        hq_bad_proj!("looks_setsizeto called in stage")
+    };
+    let mem_pos =
+        mem_layout::stage::BLOCK_SIZE + wasm_target_index * mem_layout::sprite::BLOCK_SIZE;
+    let hsv2rgb_func = func
+        .registries()
+        .static_functions()
+        .register::<UpdatePenColorFromHSV, _>()?;
+    let param_local = func.local(ValType::EXTERNREF)?;
+    let value_local = func.local(ValType::F32)?;
+    Ok(
+        wasm![F32DemoteF64, LocalSet(value_local), LocalTee(param_local),]
+            .into_iter()
+            .chain(IrOpcode::hq_text(HqTextFields("color".into())).wasm(func, Rc::from([]))?)
+            .chain(
+                IrOpcode::operator_equals
+                    .wasm(func, Rc::from([IrType::String, IrType::StringNan]))?,
+            )
+            .chain(wasm![
+                If(WasmBlockType::Empty),
+                I32Const(0),
+                LocalGet(value_local),
+                I32Const(0),
+                F32Load(MemArg {
+                    offset: (mem_pos + mem_layout::sprite::PEN_COLOR).into(),
+                    align: 2,
+                    memory_index: 0
+                }),
+                F32Add,
+                F32Store(MemArg {
+                    offset: (mem_pos + mem_layout::sprite::PEN_COLOR).into(),
+                    align: 2,
+                    memory_index: 0
+                }),
+                Else,
+                LocalGet(param_local),
+            ])
+            .chain(IrOpcode::hq_text(HqTextFields("saturation".into())).wasm(func, Rc::from([]))?)
+            .chain(
+                IrOpcode::operator_equals
+                    .wasm(func, Rc::from([IrType::String, IrType::StringNan]))?,
+            )
+            .chain(wasm![
+                If(WasmBlockType::Empty),
+                I32Const(0),
+                LocalGet(value_local),
+                I32Const(0),
+                F32Load(MemArg {
+                    offset: (mem_pos + mem_layout::sprite::PEN_SATURATION).into(),
+                    align: 2,
+                    memory_index: 0
+                }),
+                F32Add,
+                F32Store(MemArg {
+                    offset: (mem_pos + mem_layout::sprite::PEN_SATURATION).into(),
+                    align: 2,
+                    memory_index: 0
+                }),
+                Else,
+                LocalGet(param_local),
+            ])
+            .chain(IrOpcode::hq_text(HqTextFields("brightness".into())).wasm(func, Rc::from([]))?)
+            .chain(
+                IrOpcode::operator_equals
+                    .wasm(func, Rc::from([IrType::String, IrType::StringNan]))?,
+            )
+            .chain(wasm![
+                If(WasmBlockType::Empty),
+                I32Const(0),
+                LocalGet(value_local),
+                I32Const(0),
+                F32Load(MemArg {
+                    offset: (mem_pos + mem_layout::sprite::PEN_BRIGHTNESS).into(),
+                    align: 2,
+                    memory_index: 0
+                }),
+                F32Add,
+                F32Store(MemArg {
+                    offset: (mem_pos + mem_layout::sprite::PEN_BRIGHTNESS).into(),
+                    align: 2,
+                    memory_index: 0
+                }),
+                Else,
+                LocalGet(param_local),
+            ])
+            .chain(IrOpcode::hq_text(HqTextFields("transparency".into())).wasm(func, Rc::from([]))?)
+            .chain(
+                IrOpcode::operator_equals
+                    .wasm(func, Rc::from([IrType::String, IrType::StringNan]))?,
+            )
+            .chain(wasm![
+                If(WasmBlockType::Empty),
+                I32Const(0),
+                LocalGet(value_local),
+                I32Const(0),
+                F32Load(MemArg {
+                    offset: (mem_pos + mem_layout::sprite::PEN_TRANSPARENCY).into(),
+                    align: 2,
+                    memory_index: 0
+                }),
+                F32Add,
+                F32Store(MemArg {
+                    offset: (mem_pos + mem_layout::sprite::PEN_TRANSPARENCY).into(),
+                    align: 2,
+                    memory_index: 0
+                }),
+                End,
+                End,
+                End,
+                End,
+                I32Const(
+                    wasm_target_index
+                        .try_into()
+                        .map_err(|_| make_hq_bug!("target index out of bounds"))?
+                ),
+                #StaticFunctionCall(hsv2rgb_func),
+            ])
+            .collect(),
+    )
+}
+
+pub fn acceptable_inputs() -> HQResult<Rc<[IrType]>> {
+    Ok(Rc::from([IrType::String, IrType::Float]))
+}
+
+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_colour; pen_changecolorparamby; t1, t2 }
diff --git a/src/instructions/sensing.rs b/src/instructions/sensing.rs
index afa8c348..ae723488 100644
--- a/src/instructions/sensing.rs
+++ b/src/instructions/sensing.rs
@@ -1,3 +1,8 @@
+pub mod answer;
+pub mod askandwait;
 pub mod dayssince2000;
+pub mod mousedown;
+pub mod mousex;
+pub mod mousey;
 pub mod reset_timer;
 pub mod timer;
diff --git a/src/instructions/sensing/answer.rs b/src/instructions/sensing/answer.rs
new file mode 100644
index 00000000..e8827639
--- /dev/null
+++ b/src/instructions/sensing/answer.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 empty_string_index = func.registries().strings().register_default("".into())?;
+    let global_index = func.registries().globals().register(
+        "sensing_answer".into(),
+        (
+            ValType::EXTERNREF,
+            ConstExpr::global_get(empty_string_index),
+            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::String))
+}
+
+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_answer; ;}
diff --git a/src/instructions/sensing/askandwait.rs b/src/instructions/sensing/askandwait.rs
new file mode 100644
index 00000000..86ec46fa
--- /dev/null
+++ b/src/instructions/sensing/askandwait.rs
@@ -0,0 +1,98 @@
+use wasm_encoder::{FieldType, HeapType, StorageType};
+
+use super::super::prelude::*;
+use crate::ir::StepIndex;
+use crate::wasm::StepFunc;
+use crate::wasm::registries::functions::static_functions::{MarkWaitingFlag, SpawnThreadInStack};
+
+#[derive(Clone, Debug)]
+pub struct Fields {
+    pub poll_step: StepIndex,
+    pub next_step: StepIndex,
+}
+
+impl fmt::Display for Fields {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(
+            f,
+            r#"{{
+        "poll_step": {},
+        "next_step": {}
+    }}"#,
+            self.poll_step.0, self.next_step.0,
+        )
+    }
+}
+
+pub fn wasm(
+    func: &StepFunc,
+    _inputs: Rc<[IrType]>,
+    Fields {
+        poll_step,
+        next_step,
+    }: &Fields,
+) -> HQResult<Vec<InternalInstruction>> {
+    let i8_struct_type = func.registries().types().struct_(vec![FieldType {
+        element_type: StorageType::I8,
+        mutable: true,
+    }])?;
+    let struct_valtype = ValType::Ref(RefType {
+        nullable: false,
+        heap_type: HeapType::Concrete(i8_struct_type),
+    });
+    let struct_local = func.local(struct_valtype)?;
+
+    let spawn_thread_func = func
+        .registries()
+        .static_functions()
+        .register::<SpawnThreadInStack, _>()?;
+
+    let queue_ask = func.registries().external_functions().register(
+        ("sensing", "queue_ask".into()),
+        (vec![ValType::EXTERNREF, struct_valtype], vec![]),
+    )?;
+
+    // register the exported function that is called by JS,
+    // otherwise it won't be registered and thus will be undefined!
+    func.registries()
+        .static_functions()
+        .register::<MarkWaitingFlag, usize>()?;
+
+    Ok(wasm![
+        LocalGet(
+            (func.params().len() - 2)
+                .try_into()
+                .map_err(|_| make_hq_bug!("local index out of bounds"))?
+        ),
+        #LazyStepRef(*poll_step),
+        StructNewDefault(i8_struct_type),
+        LocalTee(struct_local),
+        #LazyStepRef(*next_step),
+        #StaticFunctionCall(spawn_thread_func),
+        LocalGet(struct_local),
+        Call(queue_ask),
+    ])
+}
+
+pub fn acceptable_inputs(_fields: &Fields) -> HQResult<Rc<[IrType]>> {
+    Ok(Rc::from([IrType::String]))
+}
+
+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)
+}
+
+// crate::instructions_test! { tests; sensing_askandwait; t @ super::Fields {
+//     poll_step: super::StepIndex(0),
+//     next_step: super::StepIndex(0),
+// }}
diff --git a/src/instructions/sensing/mousedown.rs b/src/instructions/sensing/mousedown.rs
new file mode 100644
index 00000000..f6c46e82
--- /dev/null
+++ b/src/instructions/sensing/mousedown.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(
+        "mouseDown".into(),
+        (
+            ValType::I32,
+            ConstExpr::i32_const(0),
+            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::Boolean))
+}
+
+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_mousedown; ;}
diff --git a/src/instructions/sensing/mousex.rs b/src/instructions/sensing/mousex.rs
new file mode 100644
index 00000000..3b738091
--- /dev/null
+++ b/src/instructions/sensing/mousex.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(
+        "mouseX".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_mousex; ;}
diff --git a/src/instructions/sensing/mousey.rs b/src/instructions/sensing/mousey.rs
new file mode 100644
index 00000000..9272fbdc
--- /dev/null
+++ b/src/instructions/sensing/mousey.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(
+        "mouseY".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_mousey; ;}
diff --git a/src/instructions/tests.rs b/src/instructions/tests.rs
index 58fbb6fc..3430966a 100644
--- a/src/instructions/tests.rs
+++ b/src/instructions/tests.rs
@@ -68,7 +68,7 @@ macro_rules! instructions_test {
                 for ($($type_arg,)*) in types_iter(true) {
                     let output_type_result = output_type(Rc::from([$($type_arg,)*]), $(&$fields)?);
                     let registries = Rc::new(Registries::default());
-                    let step_func = StepFunc::new(Rc::clone(&registries), flags(), StepTarget::Sprite(0), 0);
+                    let step_func = StepFunc::new(Rc::clone(&registries), flags(), StepTarget::Sprite(0), 0, Rc::new(vec![]));
                     let wasm_result = wasm(&step_func, Rc::from([$($type_arg,)*]), $(&$fields)?);
                     match (output_type_result.clone(), wasm_result.clone()) {
                         (Err(..), Ok(..)) | (Ok(..), Err(..)) => panic!("output_type result doesn't match wasm result for type(s) {:?}:\noutput_type: {:?},\nwasm: {:?}", ($($type_arg,)*), output_type_result, wasm_result),
@@ -100,7 +100,7 @@ macro_rules! instructions_test {
                         ReturnType::MultiValue(outputs) => outputs.iter().copied().map(WasmProject::ir_type_to_wasm).collect::<HQResult<_>>()?,
                         ReturnType::None => vec![],
                     };
-                    let step_func = StepFunc::new_with_types(params.into(), result.into(), Rc::clone(&registries), flags(), StepTarget::Sprite(0), 0);
+                    let step_func = StepFunc::new_with_types(params.into(), result.into(), Rc::clone(&registries), flags(), StepTarget::Sprite(0), 0, Rc::new(vec![]));
                     let Ok(wasm) = wasm(&step_func, Rc::from([$($type_arg,)*]), $(&$fields)?) else {
                         println!("skipping failed wasm");
                         continue;
@@ -142,7 +142,7 @@ macro_rules! instructions_test {
                         ReturnType::None => vec![],
                     };
                     println!("{result:?}");
-                    let step_func = StepFunc::new_with_types(params.into(), result.into(), Rc::clone(&registries), flags(), StepTarget::Sprite(0), 0);
+                    let step_func = StepFunc::new_with_types(params.into(), result.into(), Rc::clone(&registries), flags(), StepTarget::Sprite(0), 0, Rc::new(vec![]));
                     let wasm = match $crate::instructions::wrap_instruction(&step_func, Rc::from([$($type_arg,)*]), &$crate::instructions::IrOpcode::$opcode$(($fields))?) {
                         Ok(a) => a,
                         Err(e) => {
diff --git a/src/ir.rs b/src/ir.rs
index 7f60ef06..5a9de866 100644
--- a/src/ir.rs
+++ b/src/ir.rs
@@ -18,4 +18,4 @@ pub use step::{InlinedStep, MaybeInlinedStep, Step, StepIndex};
 pub use target::Target;
 use thread::Thread;
 pub use types::{ReturnType, Type, base_types, var_val_instruction, var_val_type};
-pub use variable::{RcList, RcVar, used_vars};
+pub use variable::{IrMonitor, RcList, RcVar, used_vars};
diff --git a/src/ir/blocks.rs b/src/ir/blocks.rs
index fd266c18..f625c699 100644
--- a/src/ir/blocks.rs
+++ b/src/ir/blocks.rs
@@ -10,10 +10,10 @@ use crate::instructions::{
     DataDeletealloflistFields, DataDeleteoflistFields, DataInsertatlistFields,
     DataItemoflistFields, DataLengthoflistFields, DataListcontentsFields,
     DataReplaceitemoflistFields, DataSetvariabletoFields, DataTeevariableFields,
-    DataVariableFields, EventBroadcastAndWaitFields, EventBroadcastFields, HqBooleanFields,
-    HqCastFields, HqColorRgbFields, HqFloatFields, HqIntegerFields, HqTextFields, HqYieldFields,
-    IrOpcode, LooksSayFields, LooksThinkFields, ProceduresArgumentFields,
-    ProceduresCallNonwarpFields, ProceduresCallWarpFields, YieldMode,
+    DataVariableFields, DataVisvariableFields, EventBroadcastAndWaitFields, EventBroadcastFields,
+    HqBooleanFields, HqCastFields, HqColorRgbFields, HqFloatFields, HqIntegerFields, HqTextFields,
+    HqYieldFields, IrOpcode, LooksSayFields, LooksThinkFields, ProceduresArgumentFields,
+    ProceduresCallNonwarpFields, ProceduresCallWarpFields, SensingAskandwaitFields, YieldMode,
 };
 use crate::ir::{InlinedStep, MaybeInlinedStep, RcList, ReturnType, StepIndex};
 use crate::prelude::*;
@@ -129,7 +129,7 @@ pub fn insert_casts(
             }
         }
 
-        if recurse && let Some(inline_steps) = block.inline_steps() {
+        if recurse && let Some(inline_steps) = block.inline_steps(false) {
             for inline_step in inline_steps {
                 insert_casts(
                     inline_step.try_borrow_mut()?.opcodes_mut(),
@@ -229,7 +229,7 @@ pub fn input_names(block_info: &BlockInfo, context: &StepContext) -> HQResult<Ve
             | BlockOpcode::operator_subtract
             | BlockOpcode::operator_multiply
             | BlockOpcode::operator_mod => vec!["NUM1", "NUM2"],
-            BlockOpcode::operator_mathop => vec!["NUM"],
+            BlockOpcode::operator_mathop | BlockOpcode::operator_round => vec!["NUM"],
             BlockOpcode::operator_lt
             | BlockOpcode::operator_gt
             | BlockOpcode::operator_equals
@@ -240,6 +240,7 @@ pub fn input_names(block_info: &BlockInfo, context: &StepContext) -> HQResult<Ve
             }
             BlockOpcode::operator_letter_of => vec!["LETTER", "STRING"],
             BlockOpcode::motion_gotoxy => vec!["X", "Y"],
+            BlockOpcode::motion_movesteps => vec!["STEPS"],
             BlockOpcode::motion_pointindirection => vec!["DIRECTION"],
             BlockOpcode::motion_turnleft | BlockOpcode::motion_turnright => vec!["DEGREES"],
             BlockOpcode::sensing_dayssince2000
@@ -250,6 +251,7 @@ pub fn input_names(block_info: &BlockInfo, context: &StepContext) -> HQResult<Ve
             | BlockOpcode::looks_size
             | BlockOpcode::looks_nextcostume
             | BlockOpcode::looks_costumenumbername
+            | BlockOpcode::looks_backdrops
             | BlockOpcode::looks_hide
             | BlockOpcode::looks_show
             | BlockOpcode::pen_penDown
@@ -264,14 +266,29 @@ pub fn input_names(block_info: &BlockInfo, context: &StepContext) -> HQResult<Ve
             | BlockOpcode::control_stop
             | BlockOpcode::event_broadcast_menu
             | BlockOpcode::sensing_timer
-            | BlockOpcode::sensing_resettimer => vec![],
+            | BlockOpcode::sensing_resettimer
+            | BlockOpcode::sensing_answer
+            | BlockOpcode::looks_backdropnumbername
+            | BlockOpcode::looks_nextbackdrop
+            | BlockOpcode::data_showvariable
+            | BlockOpcode::data_hidevariable
+            | BlockOpcode::sensing_mousex
+            | BlockOpcode::sensing_mousey
+            | BlockOpcode::sensing_mousedown
+            | BlockOpcode::motion_xposition
+            | BlockOpcode::motion_yposition => vec![],
+            BlockOpcode::sensing_askandwait => vec!["QUESTION"],
             BlockOpcode::event_broadcast | BlockOpcode::event_broadcastandwait => {
                 vec!["BROADCAST_INPUT"]
             }
             BlockOpcode::control_wait => vec!["DURATION"],
-            BlockOpcode::data_setvariableto | BlockOpcode::data_changevariableby => vec!["VALUE"],
+            BlockOpcode::data_setvariableto
+            | BlockOpcode::data_changevariableby
+            | BlockOpcode::control_for_each => vec!["VALUE"],
             BlockOpcode::operator_random => vec!["FROM", "TO"],
-            BlockOpcode::pen_setPenColorParamTo => vec!["COLOR_PARAM", "VALUE"],
+            BlockOpcode::pen_setPenColorParamTo | BlockOpcode::pen_changePenColorParamBy => {
+                vec!["COLOR_PARAM", "VALUE"]
+            }
             BlockOpcode::control_if
             | BlockOpcode::control_if_else
             | BlockOpcode::control_repeat_until
@@ -281,15 +298,22 @@ pub fn input_names(block_info: &BlockInfo, context: &StepContext) -> HQResult<Ve
             BlockOpcode::control_repeat => vec!["TIMES"],
             BlockOpcode::operator_length => vec!["STRING"],
             BlockOpcode::looks_switchcostumeto => vec!["COSTUME"],
+            BlockOpcode::looks_switchbackdropto => vec!["BACKDROP"],
             BlockOpcode::looks_setsizeto | BlockOpcode::pen_setPenSizeTo => vec!["SIZE"],
             BlockOpcode::looks_changesizeby => vec!["CHANGE"],
             BlockOpcode::pen_setPenColorToColor => vec!["COLOR"],
-            BlockOpcode::data_addtolist => vec!["ITEM"],
+            BlockOpcode::data_addtolist
+            | BlockOpcode::data_itemnumoflist
+            | BlockOpcode::data_listcontainsitem => vec!["ITEM"],
             BlockOpcode::data_itemoflist | BlockOpcode::data_deleteoflist => vec!["INDEX"],
             BlockOpcode::data_replaceitemoflist | BlockOpcode::data_insertatlist => {
                 vec!["INDEX", "ITEM"]
             }
-            BlockOpcode::procedures_call => {
+            BlockOpcode::motion_changexby => vec!["DX"],
+            BlockOpcode::motion_changeyby => vec!["DY"],
+            BlockOpcode::motion_setx => vec!["X"],
+            BlockOpcode::motion_sety => vec!["Y"],
+            BlockOpcode::procedures_call => 'proc_block: {
                 let serde_json::Value::String(proccode) = block_info
                     .mutation
                     .mutations
@@ -299,7 +323,7 @@ pub fn input_names(block_info: &BlockInfo, context: &StepContext) -> HQResult<Ve
                     hq_bad_proj!("non-string proccode on procedures_call");
                 };
                 let Some(proc) = procs.get(proccode.as_str()) else {
-                    hq_bad_proj!("procedures_call proccode doesn't exist")
+                    break 'proc_block vec![];
                 };
                 proc.arg_ids().iter().map(|b| &**b).collect()
             }
@@ -415,21 +439,35 @@ fn procedure_argument(
     )])
 }
 
+/// Generates the next step to go to, based off of the block info, and the `NextBlocks`
+/// passed to it.
+///
+/// Returns a `MaybeInlinedStep` along with a `bool` indicating if the step should yield
+/// first.
 fn generate_next_step(
     block_info: &BlockInfo,
     blocks: &BTreeMap<Box<str>, Block>,
     context: &StepContext,
     final_next_blocks: NextBlocks,
     flags: &WasmFlags,
-) -> HQResult<MaybeInlinedStep> {
-    let (next_block, outer_next_blocks) = if let Some(ref next_block) = block_info.next {
-        (Some(NextBlock::ID(next_block.clone())), final_next_blocks)
+) -> HQResult<(MaybeInlinedStep, bool)> {
+    let (next_block, yield_first, outer_next_blocks) = if let Some(ref next_block) = block_info.next
+    {
+        (
+            Some(NextBlock::ID(next_block.clone())),
+            false,
+            final_next_blocks,
+        )
     } else if let (Some(next_block_info), popped_next_blocks) =
         final_next_blocks.clone().pop_inner()
     {
-        (Some(next_block_info.block), popped_next_blocks)
+        (
+            Some(next_block_info.block),
+            next_block_info.yield_first,
+            popped_next_blocks,
+        )
     } else {
-        (None, final_next_blocks)
+        (None, false, final_next_blocks)
     };
     let next_step = match next_block {
         Some(NextBlock::ID(id)) => {
@@ -455,7 +493,7 @@ fn generate_next_step(
             false,
         )),
     };
-    Ok(next_step)
+    Ok((next_step, yield_first))
 }
 
 fn generate_next_step_inlined(
@@ -465,10 +503,39 @@ fn generate_next_step_inlined(
     final_next_blocks: NextBlocks,
     flags: &WasmFlags,
 ) -> HQResult<InlinedStep> {
-    Ok(
-        match generate_next_step(block_info, blocks, context, final_next_blocks, flags)? {
-            MaybeInlinedStep::Inlined(step) => step,
-            MaybeInlinedStep::NonInlined(step_index) => {
+    let (next_step, yield_first) =
+        generate_next_step(block_info, blocks, context, final_next_blocks, flags)?;
+    Ok(match next_step {
+        MaybeInlinedStep::Inlined(step) => {
+            if yield_first {
+                let next_step_index = step
+                    .try_borrow()?
+                    .clone_to_non_inlined(&context.target().project())?;
+                Rc::new(RefCell::new(Step::new(
+                    None,
+                    context.clone(),
+                    vec![IrOpcode::hq_yield(HqYieldFields {
+                        mode: YieldMode::Schedule(next_step_index),
+                    })],
+                    context.target().project(),
+                    false,
+                )))
+            } else {
+                step
+            }
+        }
+        MaybeInlinedStep::NonInlined(step_index) => {
+            if yield_first {
+                Rc::new(RefCell::new(Step::new(
+                    None,
+                    context.clone(),
+                    vec![IrOpcode::hq_yield(HqYieldFields {
+                        mode: YieldMode::Schedule(step_index),
+                    })],
+                    context.target().project(),
+                    false,
+                )))
+            } else {
                 let mut step = context
                     .project()?
                     .steps()
@@ -480,14 +547,30 @@ fn generate_next_step_inlined(
                 step.make_inlined();
                 Rc::new(RefCell::new(step))
             }
-            MaybeInlinedStep::Undetermined(mut step) => {
+        }
+        MaybeInlinedStep::Undetermined(mut step) => {
+            if yield_first {
+                let step_index = step.clone_to_non_inlined(&context.target().project())?;
+                Rc::new(RefCell::new(Step::new(
+                    None,
+                    context.clone(),
+                    vec![IrOpcode::hq_yield(HqYieldFields {
+                        mode: YieldMode::Schedule(step_index),
+                    })],
+                    context.target().project(),
+                    false,
+                )))
+            } else {
                 step.make_inlined();
                 Rc::new(RefCell::new(step))
             }
-        },
-    )
+        }
+    })
 }
 
+/// Generates a `StepIndex` for the next step of the given block, based on the
+/// block info and the given `NextSteps`. The generated step must not be inlined
+/// at a later stage, as it may cause reference cycles.
 fn generate_next_step_non_inlined(
     block_info: &BlockInfo,
     blocks: &BTreeMap<Box<str>, Block>,
@@ -495,7 +578,9 @@ fn generate_next_step_non_inlined(
     final_next_blocks: NextBlocks,
     flags: &WasmFlags,
 ) -> HQResult<StepIndex> {
-    match generate_next_step(block_info, blocks, context, final_next_blocks, flags)? {
+    let (next_step, _yield_first) =
+        generate_next_step(block_info, blocks, context, final_next_blocks, flags)?;
+    match next_step {
         MaybeInlinedStep::Inlined(step) => step
             .try_borrow()?
             .clone_to_non_inlined(&context.target().project()),
@@ -517,6 +602,7 @@ fn generate_loop(
     final_next_blocks: NextBlocks,
     first_condition_instructions: Option<Vec<IrOpcode>>,
     condition_instructions: Vec<IrOpcode>,
+    pre_body_instructions: Option<Vec<IrOpcode>>,
     flip_if: bool,
     setup_instructions: Vec<IrOpcode>,
     flags: &WasmFlags,
@@ -580,12 +666,22 @@ fn generate_loop(
                 false,
             )))
         });
+        let pre_body_step = pre_body_instructions.map(|instrs| {
+            Rc::new(RefCell::new(Step::new(
+                None,
+                context.clone(),
+                instrs,
+                context.target().project(),
+                false,
+            )))
+        });
         Ok(setup_instructions
             .into_iter()
             .chain(vec![IrOpcode::control_loop(ControlLoopFields {
                 first_condition: first_condition_step,
                 condition: condition_step,
                 body: substack_step,
+                pre_body: pre_body_step,
                 flip_if,
             })])
             .collect())
@@ -615,6 +711,12 @@ fn generate_loop(
                 branch_else: Rc::clone(if flip_if { &substack_step } else { &next_step }),
             }));
         let condition_step_index = project.new_owned_step(condition_step)?;
+        if let Some(pre_body_blocks) = pre_body_instructions {
+            substack_step
+                .try_borrow_mut()?
+                .opcodes_mut()
+                .extend(pre_body_blocks);
+        }
         if let Some(block) = substack_block {
             let substack_blocks = from_block(
                 block,
@@ -671,219 +773,223 @@ fn generate_if_else(
     //     )
     //     .as_str(),
     // );
-    let this_project = context.project()?;
-    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,
-        context.target().variables().clone(),
-        context.target().lists().clone(),
-        Rc::downgrade(&dummy_project),
-        RefCell::new(context.target().procedures()?.clone()),
-        0,
-        context.target().costumes().into(),
-    ));
-    dummy_project
-        .targets()
-        .try_borrow_mut()
-        .map_err(|_| make_hq_bug!("couldn't mutably borrow cell"))?
-        .insert("".into(), Rc::clone(&dummy_target));
-    let dummy_context = StepContext {
-        target: Rc::clone(&dummy_target),
-        ..context.clone()
-    };
-    let dummy_if_step = Step::from_block(
-        if_block.0,
-        if_block.1.clone(),
-        blocks,
-        &dummy_context,
-        &Rc::downgrade(&dummy_project),
-        NextBlocks::new(false),
-        false,
-        flags,
-    )?;
-    let dummy_else_step = if let Some((else_block, else_block_id)) = maybe_else_block.clone() {
-        Step::from_block(
-            else_block,
-            else_block_id,
+
+    // 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 {
+        let this_project = context.project()?;
+        let dummy_project = Rc::new(IrProject::new(
+            this_project.global_variables().clone(),
+            this_project.global_lists().clone(),
+            Box::from(this_project.broadcasts()),
+            0,
+            vec![],
+        ));
+        let dummy_target = Rc::new(Target::new(
+            false,
+            context.target().variables().clone(),
+            context.target().lists().clone(),
+            Rc::downgrade(&dummy_project),
+            RefCell::new(context.target().procedures()?.clone()),
+            0,
+            context.target().costumes().into(),
+        ));
+        dummy_project
+            .targets()
+            .try_borrow_mut()
+            .map_err(|_| make_hq_bug!("couldn't mutably borrow cell"))?
+            .insert("".into(), Rc::clone(&dummy_target));
+        let dummy_context = StepContext {
+            target: Rc::clone(&dummy_target),
+            ..context.clone()
+        };
+        let dummy_if_step = Step::from_block(
+            if_block.0,
+            if_block.1.clone(),
             blocks,
             &dummy_context,
             &Rc::downgrade(&dummy_project),
             NextBlocks::new(false),
             false,
             flags,
-        )?
-    } else {
-        Step::new_empty(
-            Rc::downgrade(&dummy_project),
-            false,
-            Rc::clone(&dummy_target),
-        )
-    };
-    // 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()) {
-        // 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.
-        #[expect(
-            clippy::option_if_let_else,
-            reason = "map_or_else alternative is too complex"
-        )]
-        let (next_block, next_blocks) = if let Some(ref next_block) = block_info.next {
-            // crate::log("got next block from block_info.next");
-            (
-                Some(NextBlock::ID(next_block.clone())),
-                final_next_blocks.extend_with_inner(NextBlockInfo {
-                    yield_first: false,
-                    block: NextBlock::ID(next_block.clone()),
-                }),
-            )
-        } else if let (Some(next_block_info), _) = final_next_blocks.clone().pop_inner() {
-            // crate::log("got next block from popping from final_next_blocks");
-            (Some(next_block_info.block), final_next_blocks.clone())
-        } else {
-            // crate::log("no next block found");
-            (
-                None,
-                final_next_blocks.clone(), // preserve termination behaviour
-            )
-        };
-        let final_if_step = {
-            Step::from_block(
-                if_block.0,
-                if_block.1,
-                blocks,
-                context,
-                &context.target().project(),
-                next_blocks.clone(),
-                false,
-                flags,
-            )?
-            // crate::log("recompiled if_step with correct next blocks");
-        };
-        let final_else_step = if let Some((else_block, else_block_id)) = maybe_else_block {
+        )?;
+        let dummy_else_step = if let Some((else_block, else_block_id)) = maybe_else_block.clone() {
             Step::from_block(
                 else_block,
                 else_block_id,
                 blocks,
-                context,
-                &context.target().project(),
-                next_blocks,
+                &dummy_context,
+                &Rc::downgrade(&dummy_project),
+                NextBlocks::new(false),
                 false,
                 flags,
             )?
-            // crate::log("recompiled else step with correct next blocks");
         } else {
-            let opcode = match next_block {
-                Some(NextBlock::ID(id)) => {
-                    let next_block = blocks
-                        .get(&id)
-                        .ok_or_else(|| make_hq_bad_proj!("missing next block"))?;
-                    // crate::log(
-                    //     format!("got NextBlock::Id({id:?}), creating step from_block").as_str(),
-                    // );
-                    vec![IrOpcode::hq_yield(HqYieldFields {
-                        mode: YieldMode::Inline(Rc::new(RefCell::new(Step::from_block(
-                            next_block,
-                            id.clone(),
-                            blocks,
-                            context,
-                            &context.target().project(),
-                            next_blocks,
-                            false,
-                            flags,
-                        )?))),
-                    })]
-                }
-                Some(NextBlock::Step(mut step)) => {
-                    step.make_inlined();
-                    // crate::log(format!("got NextBlock::Step({:?})", rcstep.id()).as_str());
+            Step::new_empty(
+                Rc::downgrade(&dummy_project),
+                false,
+                Rc::clone(&dummy_target),
+            )
+        };
+        if 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.
+            #[expect(
+                clippy::option_if_let_else,
+                reason = "map_or_else alternative is too complex"
+            )]
+            let (next_block, next_blocks) = if let Some(ref next_block) = block_info.next {
+                // crate::log("got next block from block_info.next");
+                (
+                    Some(NextBlock::ID(next_block.clone())),
+                    final_next_blocks.extend_with_inner(NextBlockInfo {
+                        yield_first: false,
+                        block: NextBlock::ID(next_block.clone()),
+                    }),
+                )
+            } else if let (Some(next_block_info), _) = final_next_blocks.clone().pop_inner() {
+                // crate::log("got next block from popping from final_next_blocks");
+                (Some(next_block_info.block), final_next_blocks.clone())
+            } else {
+                // crate::log("no next block found");
+                (
+                    None,
+                    final_next_blocks.clone(), // preserve termination behaviour
+                )
+            };
+            let final_if_step = {
+                Step::from_block(
+                    if_block.0,
+                    if_block.1,
+                    blocks,
+                    context,
+                    &context.target().project(),
+                    next_blocks.clone(),
+                    false,
+                    flags,
+                )?
+                // crate::log("recompiled if_step with correct next blocks");
+            };
+            let final_else_step = if let Some((else_block, else_block_id)) = maybe_else_block {
+                Step::from_block(
+                    else_block,
+                    else_block_id,
+                    blocks,
+                    context,
+                    &context.target().project(),
+                    next_blocks,
+                    false,
+                    flags,
+                )?
+                // crate::log("recompiled else step with correct next blocks");
+            } else {
+                let opcode = match next_block {
+                    Some(NextBlock::ID(id)) => {
+                        let next_block = blocks
+                            .get(&id)
+                            .ok_or_else(|| make_hq_bad_proj!("missing next block"))?;
+                        // crate::log(
+                        //     format!("got NextBlock::Id({id:?}), creating step from_block").as_str(),
+                        // );
+                        vec![IrOpcode::hq_yield(HqYieldFields {
+                            mode: YieldMode::Inline(Rc::new(RefCell::new(Step::from_block(
+                                next_block,
+                                id.clone(),
+                                blocks,
+                                context,
+                                &context.target().project(),
+                                next_blocks,
+                                false,
+                                flags,
+                            )?))),
+                        })]
+                    }
+                    Some(NextBlock::Step(mut step)) => {
+                        step.make_inlined();
+                        // crate::log(format!("got NextBlock::Step({:?})", rcstep.id()).as_str());
 
-                    vec![IrOpcode::hq_yield(HqYieldFields {
-                        mode: YieldMode::Inline(Rc::new(RefCell::new(step))),
-                    })]
-                }
-                Some(NextBlock::StepIndex(step_index)) => {
-                    let mut step = context
-                        .project()?
-                        .steps()
-                        .try_borrow()?
-                        .get(step_index.0)
-                        .ok_or_else(|| make_hq_bug!("step index out of bounds"))?
-                        .try_borrow()?
-                        .clone();
-                    step.make_inlined();
-                    vec![IrOpcode::hq_yield(HqYieldFields {
-                        mode: YieldMode::Inline(Rc::new(RefCell::new(step))),
-                    })]
-                }
-                None => {
-                    // crate::log("no next block after if!");
-                    if next_blocks.terminating() {
-                        // crate::log("terminating after if/else\n");
                         vec![IrOpcode::hq_yield(HqYieldFields {
-                            mode: YieldMode::None,
+                            mode: YieldMode::Inline(Rc::new(RefCell::new(step))),
                         })]
-                    } else {
-                        // crate::log("not terminating, at end of if/else");
-                        vec![]
                     }
-                }
+                    Some(NextBlock::StepIndex(step_index)) => {
+                        let mut step = context
+                            .project()?
+                            .steps()
+                            .try_borrow()?
+                            .get(step_index.0)
+                            .ok_or_else(|| make_hq_bug!("step index out of bounds"))?
+                            .try_borrow()?
+                            .clone();
+                        step.make_inlined();
+                        vec![IrOpcode::hq_yield(HqYieldFields {
+                            mode: YieldMode::Inline(Rc::new(RefCell::new(step))),
+                        })]
+                    }
+                    None => {
+                        // crate::log("no next block after if!");
+                        if next_blocks.terminating() {
+                            // crate::log("terminating after if/else\n");
+                            vec![IrOpcode::hq_yield(HqYieldFields {
+                                mode: YieldMode::None,
+                            })]
+                        } else {
+                            // crate::log("not terminating, at end of if/else");
+                            vec![]
+                        }
+                    }
+                };
+                Step::new(
+                    None,
+                    context.clone(),
+                    opcode,
+                    context.target().project(),
+                    false,
+                )
             };
-            Step::new(
-                None,
-                context.clone(),
-                opcode,
-                context.target().project(),
-                false,
-            )
-        };
-        *should_break = true;
-        Ok(vec![IrOpcode::control_if_else(ControlIfElseFields {
-            branch_if: Rc::new(RefCell::new(final_if_step)),
-            branch_else: Rc::new(RefCell::new(final_else_step)),
-        })])
-    } else {
-        let final_if_step = Step::from_block(
-            if_block.0,
-            if_block.1,
+            *should_break = true;
+            return Ok(vec![IrOpcode::control_if_else(ControlIfElseFields {
+                branch_if: Rc::new(RefCell::new(final_if_step)),
+                branch_else: Rc::new(RefCell::new(final_else_step)),
+            })]);
+        }
+    }
+    let final_if_step = Step::from_block(
+        if_block.0,
+        if_block.1,
+        blocks,
+        context,
+        &context.target().project(),
+        NextBlocks::new(false),
+        false,
+        flags,
+    )?;
+    let final_else_step = if let Some((else_block, else_block_id)) = maybe_else_block {
+        Step::from_block(
+            else_block,
+            else_block_id,
             blocks,
             context,
             &context.target().project(),
             NextBlocks::new(false),
             false,
             flags,
-        )?;
-        let final_else_step = if let Some((else_block, else_block_id)) = maybe_else_block {
-            Step::from_block(
-                else_block,
-                else_block_id,
-                blocks,
-                context,
-                &context.target().project(),
-                NextBlocks::new(false),
-                false,
-                flags,
-            )?
-        } else {
-            Step::new(
-                None,
-                context.clone(),
-                vec![],
-                context.target().project(),
-                false,
-            )
-        };
-        Ok(vec![IrOpcode::control_if_else(ControlIfElseFields {
-            branch_if: Rc::new(RefCell::new(final_if_step)),
-            branch_else: Rc::new(RefCell::new(final_else_step)),
-        })])
-    }
+        )?
+    } else {
+        Step::new(
+            None,
+            context.clone(),
+            vec![],
+            context.target().project(),
+            false,
+        )
+    };
+    Ok(vec![IrOpcode::control_if_else(ControlIfElseFields {
+        branch_if: Rc::new(RefCell::new(final_if_step)),
+        branch_else: Rc::new(RefCell::new(final_else_step)),
+    })])
 }
 
 fn generate_list_index_op<B>(
@@ -898,8 +1004,8 @@ fn generate_list_index_op<B>(
 where
     B: Fn() -> IrOpcode,
 {
-    let text_var = RcVar::new(IrType::String, VarVal::String("".into()))?;
-    let int_var = RcVar::new(IrType::Int, VarVal::Int(0))?;
+    let text_var = RcVar::new(IrType::String, VarVal::String("".into()), None)?;
+    let int_var = RcVar::new(IrType::Int, VarVal::Int(0), None)?;
     let extra_var = RcVar::new_empty();
     let result_var = RcVar::new_empty();
 
@@ -1143,7 +1249,7 @@ where
     S: Into<Box<str>> + Clone,
     F: Fn(Box<str>) -> IrOpcode,
 {
-    let var = RcVar::new(IrType::String, VarVal::String("".into()))?;
+    let var = RcVar::new(IrType::String, VarVal::String("".into()), None)?;
     Ok(vec![
         IrOpcode::hq_cast(HqCastFields(IrType::String)),
         IrOpcode::data_setvariableto(DataSetvariabletoFields {
@@ -1226,6 +1332,40 @@ fn from_normal_block(
                         BlockOpcode::operator_divide => vec![IrOpcode::operator_divide],
                         BlockOpcode::operator_mod => vec![IrOpcode::operator_modulo],
                         BlockOpcode::motion_gotoxy => vec![IrOpcode::motion_gotoxy],
+                        BlockOpcode::motion_setx => vec![IrOpcode::motion_setx],
+                        BlockOpcode::motion_sety => vec![IrOpcode::motion_sety],
+                        BlockOpcode::motion_xposition => vec![IrOpcode::motion_xposition],
+                        BlockOpcode::motion_yposition => vec![IrOpcode::motion_yposition],
+                        BlockOpcode::motion_changexby => vec![
+                            IrOpcode::motion_xposition,
+                            IrOpcode::operator_add,
+                            IrOpcode::motion_setx,
+                        ],
+                        BlockOpcode::motion_changeyby => vec![
+                            IrOpcode::motion_yposition,
+                            IrOpcode::operator_add,
+                            IrOpcode::motion_sety,
+                        ],
+                        BlockOpcode::motion_movesteps => vec![
+                            // this is a really lazy implementation but wasm-opt should optimise it
+                            IrOpcode::hq_dup,
+                            IrOpcode::hq_float(HqFloatFields(90.0)),
+                            IrOpcode::motion_direction,
+                            IrOpcode::operator_subtract,
+                            IrOpcode::operator_cos,
+                            IrOpcode::operator_multiply,
+                            IrOpcode::motion_xposition,
+                            IrOpcode::operator_add,
+                            IrOpcode::hq_swap,
+                            IrOpcode::hq_float(HqFloatFields(90.0)),
+                            IrOpcode::motion_direction,
+                            IrOpcode::operator_subtract,
+                            IrOpcode::operator_sin,
+                            IrOpcode::operator_multiply,
+                            IrOpcode::motion_yposition,
+                            IrOpcode::operator_add,
+                            IrOpcode::motion_gotoxy,
+                        ],
                         BlockOpcode::motion_direction => vec![IrOpcode::motion_direction],
                         BlockOpcode::motion_pointindirection => {
                             vec![IrOpcode::motion_pointindirection]
@@ -1256,6 +1396,10 @@ fn from_normal_block(
                         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_mousex => vec![IrOpcode::sensing_mousex],
+                        BlockOpcode::sensing_mousey => vec![IrOpcode::sensing_mousey],
+                        BlockOpcode::sensing_mousedown => vec![IrOpcode::sensing_mousedown],
+                        BlockOpcode::sensing_answer => vec![IrOpcode::sensing_answer],
                         BlockOpcode::sensing_resettimer => vec![IrOpcode::sensing_reset_timer],
                         BlockOpcode::operator_lt => vec![IrOpcode::operator_lt],
                         BlockOpcode::operator_gt => vec![IrOpcode::operator_gt],
@@ -1263,6 +1407,7 @@ fn from_normal_block(
                         BlockOpcode::operator_not => vec![IrOpcode::operator_not],
                         BlockOpcode::operator_and => vec![IrOpcode::operator_and],
                         BlockOpcode::operator_or => vec![IrOpcode::operator_or],
+                        BlockOpcode::operator_round => vec![IrOpcode::operator_round],
                         BlockOpcode::operator_mathop => {
                             let (sb3::Field::Value((Some(val),))
                             | sb3::Field::ValueId(Some(val), _)) =
@@ -1364,6 +1509,65 @@ fn from_normal_block(
                                 project,
                             )?
                         }
+                        BlockOpcode::sensing_askandwait => {
+                            let poll_step =
+                                context
+                                    .project()?
+                                    .new_owned_step(Step::new_poll_waiting_event(
+                                        context.clone(),
+                                        Weak::clone(project),
+                                    ))?;
+                            should_break = true;
+                            if context.target().is_stage() {
+                                let next_step = generate_next_step_non_inlined(
+                                    block_info,
+                                    blocks,
+                                    context,
+                                    final_next_blocks.clone(),
+                                    flags,
+                                )?;
+                                vec![IrOpcode::sensing_askandwait(SensingAskandwaitFields {
+                                    poll_step,
+                                    next_step,
+                                })]
+                            } else {
+                                let next_step = generate_next_step_inlined(
+                                    block_info,
+                                    blocks,
+                                    context,
+                                    final_next_blocks.clone(),
+                                    flags,
+                                )?;
+                                let real_next_step = Step::new(
+                                    None,
+                                    context.clone(),
+                                    vec![
+                                        IrOpcode::hq_text(HqTextFields("".into())),
+                                        IrOpcode::looks_say(LooksSayFields {
+                                            debug: false,
+                                            target_idx: context.target().index(),
+                                        }),
+                                        IrOpcode::hq_yield(HqYieldFields {
+                                            mode: YieldMode::Inline(next_step),
+                                        }),
+                                    ],
+                                    Weak::clone(project),
+                                    true,
+                                )
+                                .clone_to_non_inlined(project)?;
+                                vec![
+                                    IrOpcode::looks_say(LooksSayFields {
+                                        debug: false,
+                                        target_idx: context.target().index(),
+                                    }),
+                                    IrOpcode::hq_text(HqTextFields("".into())),
+                                    IrOpcode::sensing_askandwait(SensingAskandwaitFields {
+                                        poll_step,
+                                        next_step: real_next_step,
+                                    }),
+                                ]
+                            }
+                        }
                         BlockOpcode::control_wait => {
                             let poll_step = context.project()?.new_owned_step(
                                 Step::new_poll_timer(context.clone(), Weak::clone(project)),
@@ -1505,39 +1709,127 @@ fn from_normal_block(
                                 local_read: RefCell::new(false),
                             })]
                         }
-                        BlockOpcode::data_deletealloflist => {
+                        BlockOpcode::data_showvariable => {
                             let sb3::Field::ValueId(_val, maybe_id) =
-                                block_info.fields.get("LIST").ok_or_else(|| {
-                                    make_hq_bad_proj!("invalid project.json - missing field LIST")
+                                block_info.fields.get("VARIABLE").ok_or_else(|| {
+                                    make_hq_bad_proj!(
+                                        "invalid project.json - missing field VARIABLE"
+                                    )
                                 })?
                             else {
                                 hq_bad_proj!(
-                                    "invalid project.json - missing variable id for LIST field"
+                                    "invalid project.json - missing variable id for VARIABLE field"
                                 );
                             };
                             let id = maybe_id.clone().ok_or_else(|| {
                                 make_hq_bad_proj!(
-                                    "invalid project.json - null variable id for LIST field"
+                                    "invalid project.json - null variable id for VARIABLE field"
                                 )
                             })?;
                             let target = context.target();
-                            let list = if let Some(list) = target.lists().get(&id) {
-                                list.clone()
-                            } else if let Some(list) = context
+                            let variable = if let Some(var) = target.variables().get(&id) {
+                                var.clone()
+                            } else if let Some(var) = context
                                 .target()
                                 .project()
                                 .upgrade()
                                 .ok_or_else(|| make_hq_bug!("couldn't upgrade Weak<Project>"))?
-                                .global_lists()
+                                .global_variables()
                                 .get(&id)
                             {
-                                list.clone()
+                                var.clone()
                             } else {
-                                hq_bad_proj!("list not found")
+                                hq_bad_proj!("variable not found")
                             };
-                            *list.is_used.try_borrow_mut()? = true;
-                            *list.list.length_mutable().try_borrow_mut()? = true;
-                            // crate::log!("marked variable {:?} as used", id);
+                            *variable.is_used.try_borrow_mut()? = true;
+                            let Some(monitor) = variable.var.monitor().as_ref() else {
+                                hq_bad_proj!(
+                                    "tried to change visibility of variable without monitor"
+                                );
+                            };
+                            *monitor.is_ever_visible.try_borrow_mut()? = true;
+                            // crate::log!("marked variable {:?} as used", id);
+                            vec![IrOpcode::data_visvariable(DataVisvariableFields {
+                                var: RefCell::new(variable.var.clone()),
+                                visible: true,
+                            })]
+                        }
+                        BlockOpcode::data_hidevariable => {
+                            let sb3::Field::ValueId(_val, maybe_id) =
+                                block_info.fields.get("VARIABLE").ok_or_else(|| {
+                                    make_hq_bad_proj!(
+                                        "invalid project.json - missing field VARIABLE"
+                                    )
+                                })?
+                            else {
+                                hq_bad_proj!(
+                                    "invalid project.json - missing variable id for VARIABLE field"
+                                );
+                            };
+                            let id = maybe_id.clone().ok_or_else(|| {
+                                make_hq_bad_proj!(
+                                    "invalid project.json - null variable id for VARIABLE field"
+                                )
+                            })?;
+                            let target = context.target();
+                            let variable = if let Some(var) = target.variables().get(&id) {
+                                var.clone()
+                            } else if let Some(var) = context
+                                .target()
+                                .project()
+                                .upgrade()
+                                .ok_or_else(|| make_hq_bug!("couldn't upgrade Weak<Project>"))?
+                                .global_variables()
+                                .get(&id)
+                            {
+                                var.clone()
+                            } else {
+                                hq_bad_proj!("variable not found")
+                            };
+                            *variable.is_used.try_borrow_mut()? = true;
+                            hq_assert!(
+                                variable.var.monitor().is_some(),
+                                "tried to change visibility of variable without monitor"
+                            );
+                            // crate::log!("marked variable {:?} as used", id);
+                            vec![IrOpcode::data_visvariable(DataVisvariableFields {
+                                var: RefCell::new(variable.var.clone()),
+                                visible: false,
+                            })]
+                        }
+                        BlockOpcode::data_deletealloflist => {
+                            let sb3::Field::ValueId(_val, maybe_id) =
+                                block_info.fields.get("LIST").ok_or_else(|| {
+                                    make_hq_bad_proj!("invalid project.json - missing field LIST")
+                                })?
+                            else {
+                                hq_bad_proj!(
+                                    "invalid project.json - missing variable id for LIST field"
+                                );
+                            };
+                            let id = maybe_id.clone().ok_or_else(|| {
+                                make_hq_bad_proj!(
+                                    "invalid project.json - null variable id for LIST field"
+                                )
+                            })?;
+                            let target = context.target();
+                            let list = if let Some(list) = target.lists().get(&id) {
+                                list.clone()
+                            } else if let Some(list) = context
+                                .target()
+                                .project()
+                                .upgrade()
+                                .ok_or_else(|| make_hq_bug!("couldn't upgrade Weak<Project>"))?
+                                .global_lists()
+                                .get(&id)
+                            {
+                                list.clone()
+                            } else {
+                                hq_bad_proj!("list not found")
+                            };
+                            *list.is_used.try_borrow_mut()? = true;
+                            *list.list.length_mutable().try_borrow_mut()? = true;
+                            // crate::log!("marked variable {:?} as used", id);
                             vec![IrOpcode::data_deletealloflist(DataDeletealloflistFields {
                                 list: list.list.clone(),
                             })]
@@ -1579,6 +1871,253 @@ fn from_normal_block(
                                 list: list.list.clone(),
                             })]
                         }
+                        BlockOpcode::data_itemnumoflist => {
+                            let sb3::Field::ValueId(_val, maybe_id) =
+                                block_info.fields.get("LIST").ok_or_else(|| {
+                                    make_hq_bad_proj!("invalid project.json - missing field LIST")
+                                })?
+                            else {
+                                hq_bad_proj!(
+                                    "invalid project.json - missing variable id for LIST field"
+                                );
+                            };
+                            let id = maybe_id.clone().ok_or_else(|| {
+                                make_hq_bad_proj!(
+                                    "invalid project.json - null variable id for LIST field"
+                                )
+                            })?;
+                            let target = context.target();
+                            let list = if let Some(list) = target.lists().get(&id) {
+                                list.clone()
+                            } else if let Some(list) = context
+                                .target()
+                                .project()
+                                .upgrade()
+                                .ok_or_else(|| make_hq_bug!("couldn't upgrade Weak<Project>"))?
+                                .global_lists()
+                                .get(&id)
+                            {
+                                list.clone()
+                            } else {
+                                hq_bad_proj!("list not found")
+                            };
+                            *list.is_used.try_borrow_mut()? = true;
+                            let item = RcVar::new_empty();
+                            let ret = RcVar::new(
+                                IrType::IntPos.or(IrType::IntZero),
+                                VarVal::Int(0),
+                                None,
+                            )?;
+                            let i = RcVar::new(
+                                IrType::IntPos.or(IrType::IntZero),
+                                VarVal::Int(0),
+                                None,
+                            )?;
+                            let condition = Rc::new(RefCell::new(Step::new(
+                                None,
+                                context.clone(),
+                                vec![
+                                    IrOpcode::data_variable(DataVariableFields {
+                                        var: RefCell::new(ret.clone()),
+                                        local_read: RefCell::new(true),
+                                    }),
+                                    IrOpcode::hq_integer(HqIntegerFields(0)),
+                                    IrOpcode::operator_equals,
+                                    IrOpcode::operator_not,
+                                    IrOpcode::data_variable(DataVariableFields {
+                                        var: RefCell::new(i.clone()),
+                                        local_read: RefCell::new(true),
+                                    }),
+                                    IrOpcode::hq_integer(HqIntegerFields(1)),
+                                    IrOpcode::operator_add,
+                                    IrOpcode::data_teevariable(DataTeevariableFields {
+                                        var: RefCell::new(i.clone()),
+                                        local_read_write: RefCell::new(true),
+                                    }),
+                                    IrOpcode::data_lengthoflist(DataLengthoflistFields {
+                                        list: list.list.clone(),
+                                    }),
+                                    IrOpcode::operator_gt,
+                                    IrOpcode::operator_or,
+                                ],
+                                Weak::clone(project),
+                                false,
+                            )));
+                            let body = Rc::new(RefCell::new(Step::new(
+                                None,
+                                context.clone(),
+                                vec![
+                                    IrOpcode::data_variable(DataVariableFields {
+                                        var: RefCell::new(i.clone()),
+                                        local_read: RefCell::new(true),
+                                    }),
+                                    IrOpcode::data_itemoflist(DataItemoflistFields {
+                                        list: list.list.clone(),
+                                    }),
+                                    IrOpcode::data_variable(DataVariableFields {
+                                        var: RefCell::new(item.clone()),
+                                        local_read: RefCell::new(true),
+                                    }),
+                                    IrOpcode::operator_equals,
+                                    IrOpcode::data_variable(DataVariableFields {
+                                        var: RefCell::new(i.clone()),
+                                        local_read: RefCell::new(true),
+                                    }),
+                                    IrOpcode::operator_multiply,
+                                    IrOpcode::data_setvariableto(DataSetvariabletoFields {
+                                        var: RefCell::new(ret.clone()),
+                                        local_write: RefCell::new(true),
+                                    }),
+                                ],
+                                Weak::clone(project),
+                                false,
+                            )));
+                            vec![
+                                IrOpcode::data_setvariableto(DataSetvariabletoFields {
+                                    var: RefCell::new(item.clone()),
+                                    local_write: RefCell::new(true),
+                                }),
+                                IrOpcode::hq_integer(HqIntegerFields(0)),
+                                IrOpcode::data_setvariableto(DataSetvariabletoFields {
+                                    var: RefCell::new(i.clone()),
+                                    local_write: RefCell::new(true),
+                                }),
+                                IrOpcode::hq_integer(HqIntegerFields(0)),
+                                IrOpcode::data_setvariableto(DataSetvariabletoFields {
+                                    var: RefCell::new(ret.clone()),
+                                    local_write: RefCell::new(true),
+                                }),
+                                IrOpcode::control_loop(ControlLoopFields {
+                                    first_condition: None,
+                                    condition,
+                                    body,
+                                    pre_body: None,
+                                    flip_if: true,
+                                }),
+                                IrOpcode::data_variable(DataVariableFields {
+                                    var: RefCell::new(ret.clone()),
+                                    local_read: RefCell::new(true),
+                                }),
+                            ]
+                        }
+                        BlockOpcode::data_listcontainsitem => {
+                            let sb3::Field::ValueId(_val, maybe_id) =
+                                block_info.fields.get("LIST").ok_or_else(|| {
+                                    make_hq_bad_proj!("invalid project.json - missing field LIST")
+                                })?
+                            else {
+                                hq_bad_proj!(
+                                    "invalid project.json - missing variable id for LIST field"
+                                );
+                            };
+                            let id = maybe_id.clone().ok_or_else(|| {
+                                make_hq_bad_proj!(
+                                    "invalid project.json - null variable id for LIST field"
+                                )
+                            })?;
+                            let target = context.target();
+                            let list = if let Some(list) = target.lists().get(&id) {
+                                list.clone()
+                            } else if let Some(list) = context
+                                .target()
+                                .project()
+                                .upgrade()
+                                .ok_or_else(|| make_hq_bug!("couldn't upgrade Weak<Project>"))?
+                                .global_lists()
+                                .get(&id)
+                            {
+                                list.clone()
+                            } else {
+                                hq_bad_proj!("list not found")
+                            };
+                            *list.is_used.try_borrow_mut()? = true;
+                            let item = RcVar::new_empty();
+                            let ret = RcVar::new(IrType::Boolean, VarVal::Bool(false), None)?;
+                            let i = RcVar::new(
+                                IrType::IntPos.or(IrType::IntZero),
+                                VarVal::Int(0),
+                                None,
+                            )?;
+                            let condition = Rc::new(RefCell::new(Step::new(
+                                None,
+                                context.clone(),
+                                vec![
+                                    IrOpcode::data_variable(DataVariableFields {
+                                        var: RefCell::new(ret.clone()),
+                                        local_read: RefCell::new(true),
+                                    }),
+                                    IrOpcode::operator_not,
+                                    IrOpcode::data_variable(DataVariableFields {
+                                        var: RefCell::new(i.clone()),
+                                        local_read: RefCell::new(true),
+                                    }),
+                                    IrOpcode::hq_integer(HqIntegerFields(1)),
+                                    IrOpcode::operator_add,
+                                    IrOpcode::data_teevariable(DataTeevariableFields {
+                                        var: RefCell::new(i.clone()),
+                                        local_read_write: RefCell::new(true),
+                                    }),
+                                    IrOpcode::data_lengthoflist(DataLengthoflistFields {
+                                        list: list.list.clone(),
+                                    }),
+                                    IrOpcode::operator_gt,
+                                    IrOpcode::operator_or,
+                                ],
+                                Weak::clone(project),
+                                false,
+                            )));
+                            let body = Rc::new(RefCell::new(Step::new(
+                                None,
+                                context.clone(),
+                                vec![
+                                    IrOpcode::data_variable(DataVariableFields {
+                                        var: RefCell::new(i.clone()),
+                                        local_read: RefCell::new(true),
+                                    }),
+                                    IrOpcode::data_itemoflist(DataItemoflistFields {
+                                        list: list.list.clone(),
+                                    }),
+                                    IrOpcode::data_variable(DataVariableFields {
+                                        var: RefCell::new(item.clone()),
+                                        local_read: RefCell::new(true),
+                                    }),
+                                    IrOpcode::operator_equals,
+                                    IrOpcode::data_setvariableto(DataSetvariabletoFields {
+                                        var: RefCell::new(ret.clone()),
+                                        local_write: RefCell::new(true),
+                                    }),
+                                ],
+                                Weak::clone(project),
+                                false,
+                            )));
+                            vec![
+                                IrOpcode::data_setvariableto(DataSetvariabletoFields {
+                                    var: RefCell::new(item.clone()),
+                                    local_write: RefCell::new(true),
+                                }),
+                                IrOpcode::hq_integer(HqIntegerFields(0)),
+                                IrOpcode::data_setvariableto(DataSetvariabletoFields {
+                                    var: RefCell::new(i.clone()),
+                                    local_write: RefCell::new(true),
+                                }),
+                                IrOpcode::hq_boolean(HqBooleanFields(false)),
+                                IrOpcode::data_setvariableto(DataSetvariabletoFields {
+                                    var: RefCell::new(ret.clone()),
+                                    local_write: RefCell::new(true),
+                                }),
+                                IrOpcode::control_loop(ControlLoopFields {
+                                    first_condition: None,
+                                    condition,
+                                    body,
+                                    pre_body: None,
+                                    flip_if: true,
+                                }),
+                                IrOpcode::data_variable(DataVariableFields {
+                                    var: RefCell::new(ret.clone()),
+                                    local_read: RefCell::new(true),
+                                }),
+                            ]
+                        }
                         BlockOpcode::data_insertatlist => {
                             let sb3::Field::ValueId(_val, maybe_id) =
                                 block_info.fields.get("LIST").ok_or_else(|| {
@@ -1856,7 +2395,7 @@ fn from_normal_block(
                                 )
                             };
                             match operator.to_lowercase().as_str() {
-                                "all" => hq_todo!("control_stop all"),
+                                "all" => vec![IrOpcode::control_stop_all],
                                 "this script" => vec![IrOpcode::hq_yield(HqYieldFields {
                                     mode: if context.warp {
                                         YieldMode::Return
@@ -1953,13 +2492,14 @@ fn from_normal_block(
                                 final_next_blocks.clone(),
                                 first_condition_instructions,
                                 condition_instructions,
+                                None,
                                 false,
                                 vec![],
                                 flags,
                             )?
                         }
                         BlockOpcode::control_repeat => {
-                            let variable = RcVar::new(IrType::Int, sb3::VarVal::Int(0))?;
+                            let variable = RcVar::new(IrType::Int, sb3::VarVal::Int(0), None)?;
                             let local = context.warp;
                             let condition_instructions = vec![
                                 IrOpcode::data_variable(DataVariableFields {
@@ -1994,6 +2534,115 @@ fn from_normal_block(
                                 final_next_blocks.clone(),
                                 first_condition_instructions,
                                 condition_instructions,
+                                None,
+                                false,
+                                setup_instructions,
+                                flags,
+                            )?
+                        }
+                        BlockOpcode::control_for_each => {
+                            let sb3::Field::ValueId(_val, maybe_id) =
+                                block_info.fields.get("VARIABLE").ok_or_else(|| {
+                                    make_hq_bad_proj!(
+                                        "invalid project.json - missing field VARIABLE"
+                                    )
+                                })?
+                            else {
+                                hq_bad_proj!(
+                                    "invalid project.json - missing variable id for VARIABLE field"
+                                );
+                            };
+                            let id = maybe_id.clone().ok_or_else(|| {
+                                make_hq_bad_proj!(
+                                    "invalid project.json - null variable id for VARIABLE field"
+                                )
+                            })?;
+                            let target = context.target();
+                            let variable = if let Some(var) = target.variables().get(&id) {
+                                var.clone()
+                            } else if let Some(var) = context
+                                .target()
+                                .project()
+                                .upgrade()
+                                .ok_or_else(|| make_hq_bug!("couldn't upgrade Weak<Project>"))?
+                                .global_variables()
+                                .get(&id)
+                            {
+                                var.clone()
+                            } else {
+                                hq_bad_proj!("variable not found")
+                            };
+                            *variable.is_used.try_borrow_mut()? = true;
+                            let counter = RcVar::new(IrType::Int, sb3::VarVal::Int(0), None)?;
+                            let local = context.warp;
+                            let condition_instructions = vec![
+                                IrOpcode::data_variable(DataVariableFields {
+                                    var: RefCell::new(counter.clone()),
+                                    local_read: RefCell::new(local),
+                                }),
+                                IrOpcode::hq_integer(HqIntegerFields(1)),
+                                IrOpcode::operator_add,
+                                IrOpcode::data_teevariable(DataTeevariableFields {
+                                    var: RefCell::new(counter.clone()),
+                                    local_read_write: RefCell::new(local),
+                                }),
+                            ]
+                            .into_iter()
+                            .chain(inputs(
+                                block_info,
+                                blocks,
+                                context,
+                                &context.target().project(),
+                                flags,
+                            )?)
+                            .chain(vec![IrOpcode::operator_lt])
+                            .collect();
+                            let first_condition_instructions = Some(
+                                vec![IrOpcode::data_variable(DataVariableFields {
+                                    var: RefCell::new(counter.clone()),
+                                    local_read: RefCell::new(local),
+                                })]
+                                .into_iter()
+                                .chain(inputs(
+                                    block_info,
+                                    blocks,
+                                    context,
+                                    &context.target().project(),
+                                    flags,
+                                )?)
+                                .chain(vec![IrOpcode::operator_lt])
+                                .collect(),
+                            );
+                            let setup_instructions = vec![
+                                IrOpcode::hq_drop,
+                                IrOpcode::hq_integer(HqIntegerFields(0)),
+                                IrOpcode::data_setvariableto(DataSetvariabletoFields {
+                                    var: RefCell::new(counter.clone()),
+                                    local_write: RefCell::new(local),
+                                }),
+                            ];
+                            let pre_body_instructions = Some(vec![
+                                IrOpcode::data_variable(DataVariableFields {
+                                    var: RefCell::new(counter),
+                                    local_read: RefCell::new(local),
+                                }),
+                                IrOpcode::hq_integer(HqIntegerFields(1)),
+                                IrOpcode::operator_add,
+                                IrOpcode::data_setvariableto(DataSetvariabletoFields {
+                                    var: RefCell::new(variable.var.clone()),
+                                    local_write: RefCell::new(false),
+                                }),
+                            ]);
+                            generate_loop(
+                                context.warp,
+                                &mut should_break,
+                                block_info,
+                                blocks,
+                                context,
+                                final_next_blocks.clone(),
+                                first_condition_instructions,
+                                condition_instructions,
+                                pre_body_instructions,
                                 false,
                                 setup_instructions,
                                 flags,
@@ -2018,6 +2667,7 @@ fn from_normal_block(
                                 final_next_blocks.clone(),
                                 first_condition_instructions,
                                 condition_instructions,
+                                None,
                                 true,
                                 setup_instructions,
                                 flags,
@@ -2042,12 +2692,13 @@ fn from_normal_block(
                                 final_next_blocks.clone(),
                                 first_condition_instructions,
                                 condition_instructions,
+                                None,
                                 false,
                                 setup_instructions,
                                 flags,
                             )?
                         }
-                        BlockOpcode::procedures_call => {
+                        BlockOpcode::procedures_call => 'proc_block: {
                             let target = context.target();
                             let procs = target.procedures()?;
                             let serde_json::Value::String(proccode) = block_info
@@ -2060,9 +2711,9 @@ fn from_normal_block(
                             else {
                                 hq_bad_proj!("non-string proccode on procedures_call")
                             };
-                            let proc = procs.get(proccode.as_str()).ok_or_else(|| {
-                                make_hq_bad_proj!("non-existant proccode on procedures_call")
-                            })?;
+                            let Some(proc) = procs.get(proccode.as_str()) else {
+                                break 'proc_block vec![];
+                            };
                             let warp = context.warp || proc.always_warped();
                             if warp {
                                 proc.compile_warped(blocks, flags)?;
@@ -2108,6 +2759,9 @@ fn from_normal_block(
                         BlockOpcode::pen_setPenColorToColor => {
                             vec![IrOpcode::pen_setpencolortocolor]
                         }
+                        BlockOpcode::pen_changePenColorParamBy => {
+                            vec![IrOpcode::pen_changecolorparamby]
+                        }
                         BlockOpcode::pen_setPenColorParamTo => {
                             vec![IrOpcode::pen_setpencolorparamto]
                         }
@@ -2140,6 +2794,9 @@ fn from_normal_block(
                             IrOpcode::looks_setsizeto,
                         ],
                         BlockOpcode::looks_switchcostumeto => vec![IrOpcode::looks_switchcostumeto],
+                        BlockOpcode::looks_switchbackdropto => {
+                            vec![IrOpcode::looks_switchbackdropto]
+                        }
                         BlockOpcode::looks_costumenumbername => {
                             let (sb3::Field::Value((val,)) | sb3::Field::ValueId(val, _)) =
                                 block_info.fields.get("NUMBER_NAME").ok_or_else(|| {
@@ -2162,15 +2819,94 @@ fn from_normal_block(
                             };
                             match &*number_name {
                                 "number" => vec![IrOpcode::looks_costumenumber],
-                                "name" => hq_todo!("costume name"),
+                                "name" => vec![IrOpcode::looks_costumename],
                                 _ => hq_bad_proj!("invalid value for NUMBER_NAME field"),
                             }
                         }
-                        BlockOpcode::looks_nextcostume => vec![
-                            IrOpcode::looks_costumenumber,
-                            IrOpcode::hq_integer(HqIntegerFields(1)),
-                            IrOpcode::looks_switchcostumeto,
-                        ],
+                        BlockOpcode::looks_backdropnumbername => {
+                            let (sb3::Field::Value((val,)) | sb3::Field::ValueId(val, _)) =
+                                block_info.fields.get("NUMBER_NAME").ok_or_else(|| {
+                                    make_hq_bad_proj!(
+                                        "invalid project.json - missing field NUMBER_NAME"
+                                    )
+                                })?;
+                            let sb3::VarVal::String(number_name) =
+                                val.clone().ok_or_else(|| {
+                                    make_hq_bad_proj!(
+                                        "invalid project.json - null backdrop name for \
+                                         NUMBER_NAME field"
+                                    )
+                                })?
+                            else {
+                                hq_bad_proj!(
+                                    "invalid project.json - NUMBER_NAME field is not of type \
+                                     String"
+                                );
+                            };
+                            match &*number_name {
+                                "number" => vec![IrOpcode::looks_backdropnumber],
+                                "name" => hq_todo!("backdrop name"),
+                                _ => hq_bad_proj!("invalid value for NUMBER_NAME field"),
+                            }
+                        }
+                        BlockOpcode::looks_backdrops => {
+                            let (sb3::Field::Value((val,)) | sb3::Field::ValueId(val, _)) =
+                                block_info.fields.get("BACKDROP").ok_or_else(|| {
+                                    make_hq_bad_proj!(
+                                        "invalid project.json - missing field BACKDROP"
+                                    )
+                                })?;
+                            let sb3::VarVal::String(backdrop_name) =
+                                val.clone().ok_or_else(|| {
+                                    make_hq_bad_proj!(
+                                        "invalid project.json - null backdrop name for BACKROP \
+                                         field"
+                                    )
+                                })?
+                            else {
+                                hq_bad_proj!(
+                                    "invalid project.json - BACKDROP field is not of type String"
+                                );
+                            };
+                            let backdrop_index: i32 = context
+                                .project()?
+                                .backdrops()
+                                .iter()
+                                .find_position(|costume| costume.name == backdrop_name)
+                                .ok_or_else(|| make_hq_bug!("backdrop index not found"))?
+                                .0
+                                .try_into()
+                                .map_err(|_| make_hq_bug!("backdrop index out of bounds"))?;
+                            vec![IrOpcode::hq_integer(HqIntegerFields(backdrop_index))]
+                        }
+                        BlockOpcode::looks_nextcostume => {
+                            vec![
+                                IrOpcode::looks_costumenumber,
+                                IrOpcode::hq_integer(HqIntegerFields(1)),
+                                IrOpcode::operator_add,
+                                IrOpcode::hq_integer(HqIntegerFields(
+                                    context.target().costumes().len().try_into().map_err(|_| {
+                                        make_hq_bug!("costumes length out of bounds")
+                                    })?,
+                                )),
+                                IrOpcode::operator_modulo,
+                                IrOpcode::looks_switchcostumeto,
+                            ]
+                        }
+                        BlockOpcode::looks_nextbackdrop => {
+                            vec![
+                                IrOpcode::looks_backdropnumber,
+                                IrOpcode::hq_integer(HqIntegerFields(1)),
+                                IrOpcode::operator_add,
+                                IrOpcode::hq_integer(HqIntegerFields(
+                                    context.project()?.backdrops().len().try_into().map_err(
+                                        |_| make_hq_bug!("backdrops length out of bounds"),
+                                    )?,
+                                )),
+                                IrOpcode::operator_modulo,
+                                IrOpcode::looks_switchbackdropto,
+                            ]
+                        }
                         BlockOpcode::looks_costume => {
                             let (sb3::Field::Value((val,)) | sb3::Field::ValueId(val, _)) =
                                 block_info.fields.get("COSTUME").ok_or_else(|| {
diff --git a/src/ir/event.rs b/src/ir/event.rs
index b6c59d59..5633c992 100644
--- a/src/ir/event.rs
+++ b/src/ir/event.rs
@@ -1,6 +1,7 @@
 // Ord is required to be used in a BTreeMap; Ord requires PartialOrd, Eq and PartialEq
 #[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord)]
 pub enum Event {
-    FlagCLicked,
+    FlagClicked,
     Broadcast(Box<str>),
+    SpriteClicked(u32),
 }
diff --git a/src/ir/proc.rs b/src/ir/proc.rs
index becab28f..04733f36 100644
--- a/src/ir/proc.rs
+++ b/src/ir/proc.rs
@@ -98,7 +98,7 @@ impl Proc {
     }
 }
 
-static ARG_REGEX: Lazy<Regex> = lazy_regex!(r#"[^\\]%[nbs]"#);
+static ARG_REGEX: Lazy<Regex> = lazy_regex!(r#"([^\\]|^)%[nbs]"#);
 
 fn arg_vars_from_proccode(proccode: &str) -> Rc<RefCell<Vec<RcVar>>> {
     // based off of https://github.com/scratchfoundation/scratch-blocks/blob/abbfe9/blocks_vertical/procedures.js#L207-L215
diff --git a/src/ir/project.rs b/src/ir/project.rs
index f1224341..0300c78e 100644
--- a/src/ir/project.rs
+++ b/src/ir/project.rs
@@ -21,6 +21,8 @@ pub struct IrProject {
     global_lists: TargetLists,
     broadcasts: Box<[Box<str>]>,
     targets: RefCell<IndexMap<Box<str>, Rc<Target>>>,
+    stage_index: usize,
+    backdrops: Vec<IrCostume>,
 }
 
 impl IrProject {
@@ -48,11 +50,21 @@ impl IrProject {
         &self.broadcasts
     }
 
+    pub const fn stage_index(&self) -> usize {
+        self.stage_index
+    }
+
+    pub const fn backdrops(&self) -> &Vec<IrCostume> {
+        &self.backdrops
+    }
+
     #[must_use]
     pub fn new(
         global_variables: TargetVars,
         global_lists: TargetLists,
         broadcasts: Box<[Box<str>]>,
+        stage_index: usize,
+        backdrops: Vec<IrCostume>,
     ) -> Self {
         Self {
             threads: RefCell::new(Box::new([])),
@@ -61,6 +73,8 @@ impl IrProject {
             global_lists,
             broadcasts,
             targets: RefCell::new(IndexMap::default()),
+            stage_index,
+            backdrops,
         }
     }
 
@@ -78,6 +92,7 @@ impl IrProject {
                 .iter()
                 .find(|target| target.is_stage)
                 .ok_or_else(|| make_hq_bad_proj!("missing stage target"))?,
+            &sb3.monitors,
         )?;
 
         let global_lists = lists_from_target(
@@ -95,7 +110,32 @@ impl IrProject {
             .cloned()
             .collect();
 
-        let project = Rc::new(Self::new(global_variables, global_lists, broadcasts));
+        let (stage_index, stage_target) = sb3
+            .targets
+            .iter()
+            .find_position(|target| target.is_stage)
+            .ok_or_else(|| make_hq_bug!("couldn't find stage target"))?;
+
+        let backdrops: Vec<_> = stage_target
+            .costumes
+            .iter()
+            .map(|costume| {
+                IrCostume {
+                    name: costume.name.clone(),
+                    data_format: costume.data_format,
+                    md5ext: costume.md5ext.clone(),
+                    //data: load_asset(costume.md5ext.as_str()),
+                }
+            })
+            .collect();
+
+        let project = Rc::new(Self::new(
+            global_variables,
+            global_lists,
+            broadcasts,
+            stage_index,
+            backdrops,
+        ));
 
         let (threads_vec, targets): (Vec<_>, Vec<_>) = sb3
             .targets
@@ -105,7 +145,7 @@ impl IrProject {
                 let variables = if target.is_stage {
                     BTreeMap::new()
                 } else {
-                    variables_from_target(target)?
+                    variables_from_target(target, &sb3.monitors)?
                 };
                 let lists = if target.is_stage {
                     BTreeMap::new()
@@ -177,8 +217,9 @@ impl IrProject {
         for target in project.targets().try_borrow()?.values() {
             fixup_proc_types(target)?;
         }
+        let fixed_proc_calls = &mut BTreeSet::new();
         for step in project.steps().try_borrow()?.iter() {
-            fixup_proc_calls(step)?;
+            fixup_proc_calls(step, fixed_proc_calls)?;
         }
         Ok(project)
     }
@@ -208,7 +249,7 @@ where
             );
             has_return = true;
         }
-        if let Some(inline_steps) = opcode.inline_steps() {
+        if let Some(inline_steps) = opcode.inline_steps(true) {
             inline_steps.iter().try_for_each(|inline_step| {
                 add_proc_return_vars_before_return(
                     Rc::clone(inline_step),
@@ -297,15 +338,27 @@ fn fixup_proc_types(target: &Rc<Target>) -> HQResult<()> {
 }
 
 /// Pass variables into procedure calls, and read them on return
-fn fixup_proc_calls<S>(step: S) -> HQResult<()>
+fn fixup_proc_calls<S>(step: S, visited_steps: &mut BTreeSet<Box<str>>) -> HQResult<()>
 where
     S: Deref<Target = RefCell<Step>>,
 {
+    if visited_steps.contains(step.try_borrow()?.id()) {
+        return Ok(());
+    }
+
+    visited_steps.insert(step.try_borrow()?.id().into());
+
     let mut call_indices = vec![];
     for (index, opcode) in step.try_borrow()?.opcodes().iter().enumerate() {
         if matches!(opcode, IrOpcode::procedures_call_warp(_)) {
             call_indices.push(index);
         }
+
+        if let Some(inline_steps) = opcode.inline_steps(true) {
+            inline_steps.iter().try_for_each(|inline_step| {
+                fixup_proc_calls(Rc::clone(inline_step), visited_steps)
+            })?;
+        }
     }
 
     let globally_scoped_variables_num = step.try_borrow()?.globally_scoped_variables_num()?;
diff --git a/src/ir/step.rs b/src/ir/step.rs
index 3d158f47..f7e3c55b 100644
--- a/src/ir/step.rs
+++ b/src/ir/step.rs
@@ -133,6 +133,33 @@ impl Step {
         )
     }
 
+    #[must_use]
+    pub fn new_poll_waiting_event(context: StepContext, project: Weak<IrProject>) -> Self {
+        Self::new(
+            None,
+            context.clone(),
+            vec![
+                IrOpcode::hq_poll_waiting_event,
+                IrOpcode::control_if_else(ControlIfElseFields {
+                    branch_else: Rc::new(RefCell::new(Self::new(
+                        None,
+                        context.clone(),
+                        vec![],
+                        Weak::clone(&project),
+                        false,
+                    ))),
+                    branch_if: Rc::new(RefCell::new(Self::new_terminating(
+                        context,
+                        Weak::clone(&project),
+                        false,
+                    ))),
+                }),
+            ],
+            project,
+            true,
+        )
+    }
+
     #[must_use]
     pub fn new_poll_timer(context: StepContext, project: Weak<IrProject>) -> Self {
         Self::new(
@@ -250,7 +277,7 @@ impl Step {
                 return true;
             }
             if opcode
-                .inline_steps()
+                .inline_steps(true)
                 .is_some_and(|steps| steps.iter().any(|step| RefCell::borrow(step).does_yield()))
             {
                 return true;
diff --git a/src/ir/thread.rs b/src/ir/thread.rs
index 58da3388..606330be 100644
--- a/src/ir/thread.rs
+++ b/src/ir/thread.rs
@@ -36,7 +36,7 @@ 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_whenflagclicked => Event::FlagClicked,
             BlockOpcode::event_whenbroadcastreceived => {
                 let sb3::Field::ValueId(val, _id) =
                     block_info.fields.get("BROADCAST_OPTION").ok_or_else(|| {
@@ -57,11 +57,12 @@ impl Thread {
                 };
                 Event::Broadcast(name)
             }
+            BlockOpcode::event_whenthisspriteclicked | BlockOpcode::event_whenstageclicked => {
+                Event::SpriteClicked(target.index())
+            }
             BlockOpcode::event_whenbackdropswitchesto
             | BlockOpcode::event_whengreaterthan
             | BlockOpcode::event_whenkeypressed
-            | BlockOpcode::event_whenstageclicked
-            | BlockOpcode::event_whenthisspriteclicked
             | BlockOpcode::event_whentouchingobject => {
                 hq_todo!("unimplemented event {:?}", block_info.opcode)
             }
diff --git a/src/ir/variable.rs b/src/ir/variable.rs
index 588a4fa8..9a60223e 100644
--- a/src/ir/variable.rs
+++ b/src/ir/variable.rs
@@ -6,7 +6,7 @@ use uuid::Uuid;
 use super::Type;
 use crate::ir::types::var_val_type;
 use crate::prelude::*;
-use crate::sb3::{Target as Sb3Target, VarVal};
+use crate::sb3::{Monitor as Sb3Monitor, Target as Sb3Target, VarVal};
 use crate::wasm::WasmFlags;
 use crate::wasm::flags::Switch;
 
@@ -15,17 +15,25 @@ struct Variable {
     possible_types: RefCell<Type>,
     initial_value: VarVal,
     id: String,
+    monitor: Option<IrMonitor>,
 }
 
 #[derive(Clone, Debug)]
 pub struct RcVar(Rc<Variable>);
 
+#[derive(Debug)]
+pub struct IrMonitor {
+    pub id: Box<str>,
+    pub is_ever_visible: RefCell<bool>,
+}
+
 impl RcVar {
-    pub fn new(ty: Type, initial_value: VarVal) -> HQResult<Self> {
+    pub fn new(ty: Type, initial_value: VarVal, monitor: Option<IrMonitor>) -> HQResult<Self> {
         Ok(Self(Rc::new(Variable {
             possible_types: RefCell::new(ty.or(var_val_type(&initial_value)?)),
             initial_value,
             id: Uuid::new_v4().to_string(),
+            monitor,
         })))
     }
 
@@ -36,6 +44,7 @@ impl RcVar {
             possible_types: RefCell::new(Type::none()),
             initial_value: VarVal::Bool(false), // arbitrary value
             id: Uuid::new_v4().to_string(),
+            monitor: None,
         }))
     }
 
@@ -58,6 +67,11 @@ impl RcVar {
     pub fn id(&self) -> &str {
         &self.0.id
     }
+
+    #[must_use]
+    pub fn monitor(&self) -> &Option<IrMonitor> {
+        &self.0.monitor
+    }
 }
 
 impl PartialEq for RcVar {
@@ -128,11 +142,20 @@ pub type TargetVars = BTreeMap<Box<str>, Rc<TargetVar>>;
 
 pub type TargetLists = BTreeMap<Box<str>, Rc<TargetList>>;
 
-pub fn variables_from_target(target: &Sb3Target) -> HQResult<TargetVars> {
+pub fn variables_from_target(target: &Sb3Target, monitors: &[Sb3Monitor]) -> HQResult<TargetVars> {
     target
         .variables
         .iter()
         .map(|(id, var_info)| {
+            let monitor = monitors
+                .iter()
+                .find(|monitor| monitor.id() == Some(id))
+                .and_then(|monitor| {
+                    Some(IrMonitor {
+                        is_ever_visible: RefCell::new(*monitor.visible()?),
+                        id: id.clone(),
+                    })
+                });
             Ok((
                 id.clone(),
                 Rc::new(TargetVar {
@@ -143,6 +166,7 @@ pub fn variables_from_target(target: &Sb3Target) -> HQResult<TargetVars> {
                             reason = "this field exists on all variants"
                         )]
                         var_info.get_1().unwrap().clone(),
+                        monitor,
                     )?,
                     is_used: RefCell::new(false),
                 }),
diff --git a/src/optimisation/const_folding.rs b/src/optimisation/const_folding.rs
index 7b250cca..4a79031a 100644
--- a/src/optimisation/const_folding.rs
+++ b/src/optimisation/const_folding.rs
@@ -54,6 +54,20 @@ pub struct ConstFoldState {
     pub vars: BTreeMap<Box<str>, ConstFoldItem>,
 }
 
+impl ConstFoldState {
+    fn merge(&mut self, other: Self) {
+        for (var, _) in other.vars {
+            self.vars.insert(
+                var,
+                ConstFoldItem::Unknown {
+                    possible_types: IrType::none(), // this is ok because the unknown value is never actually used
+                    opcodes: Rc::from([]),
+                },
+            );
+        }
+    }
+}
+
 fn const_fold_step<S>(step: S, state: &mut ConstFoldState) -> HQResult<()>
 where
     S: Deref<Target = RefCell<Step>>,
@@ -85,26 +99,42 @@ where
             first_condition,
             body,
             flip_if,
+            pre_body,
         }) = opcode
         {
-            let body_mut = Rc::new(Rc::unwrap_or_clone(body));
-            let condition_mut = Rc::new(Rc::unwrap_or_clone(condition));
-            const_fold_step(Rc::clone(&body_mut), &mut ConstFoldState::default())?;
-            const_fold_step(Rc::clone(&condition_mut), &mut ConstFoldState::default())?;
             let first_condition_mut = first_condition
                 .map(|first_cond_step| -> HQResult<_> {
                     let first_cond_mut = Rc::new(Rc::unwrap_or_clone(first_cond_step));
-                    const_fold_step(Rc::clone(&first_cond_mut), &mut ConstFoldState::default())?;
+                    const_fold_step(Rc::clone(&first_cond_mut), state)?;
 
                     Ok(first_cond_mut)
                 })
                 .transpose()?;
+            let body_mut = Rc::new(Rc::unwrap_or_clone(body));
+            let condition_mut = Rc::new(Rc::unwrap_or_clone(condition));
+            let pre_body_mut = pre_body
+                .as_ref()
+                .map(|pre_body_real| -> HQResult<_> {
+                    let pre_body_mut = Rc::new(Rc::unwrap_or_clone(Rc::clone(pre_body_real)));
+                    let mut pre_body_state = ConstFoldState::default();
+                    const_fold_step(Rc::clone(&pre_body_mut), &mut pre_body_state)?;
+                    state.merge(pre_body_state);
+                    Ok(pre_body_mut)
+                })
+                .transpose()?;
+            let mut body_state = ConstFoldState::default();
+            const_fold_step(Rc::clone(&body_mut), &mut body_state)?;
+            state.merge(body_state);
+            let mut condition_state = ConstFoldState::default();
+            const_fold_step(Rc::clone(&condition_mut), &mut condition_state)?;
+            state.merge(condition_state);
 
             opcode = IrOpcode::control_loop(ControlLoopFields {
                 body: body_mut,
                 condition: condition_mut,
                 first_condition: first_condition_mut,
                 flip_if,
+                pre_body: pre_body_mut,
             });
         }
 
diff --git a/src/optimisation/loop_unrolling.rs b/src/optimisation/loop_unrolling.rs
index 99773bde..c8f69aba 100644
--- a/src/optimisation/loop_unrolling.rs
+++ b/src/optimisation/loop_unrolling.rs
@@ -12,7 +12,7 @@ where
     let mut loops = vec![];
 
     for (i, opcode) in step.try_borrow()?.opcodes().iter().enumerate().rev() {
-        if let Some(inline_steps) = opcode.inline_steps() {
+        if let Some(inline_steps) = opcode.inline_steps(true) {
             inline_steps
                 .iter()
                 .cloned()
@@ -31,6 +31,7 @@ where
             condition,
             ref body,
             flip_if,
+            pre_body,
         },
     ) in loops
     {
@@ -51,15 +52,20 @@ where
                 branch_if: Rc::new(RefCell::new(Step::new(
                     None,
                     step.try_borrow()?.context().clone(),
-                    body.try_borrow()?
-                        .opcodes()
-                        .clone()
+                    pre_body
+                        .as_ref()
+                        .map_or_else(
+                            || -> HQResult<_> { Ok(vec![]) },
+                            |pb| Ok(pb.try_borrow()?.opcodes().clone()),
+                        )?
                         .into_iter()
+                        .chain(body.try_borrow()?.opcodes().clone())
                         .chain([IrOpcode::control_loop(ControlLoopFields {
                             first_condition: None,
                             condition: condition.clone(),
                             body: Rc::clone(body),
                             flip_if,
+                            pre_body: pre_body.clone(),
                         })])
                         .collect(),
                     step.try_borrow()?.project(),
diff --git a/src/optimisation/ssa.rs b/src/optimisation/ssa.rs
index 318cbee6..ed4fff03 100644
--- a/src/optimisation/ssa.rs
+++ b/src/optimisation/ssa.rs
@@ -8,6 +8,7 @@
 //!   written to inside that procedure yet
 //! - Assign the narrowest type possible to each variable
 //! - Reinsert casts to account for newly assigned variable types.
+//! - Box procedure returns if needed
 //!
 //! This will create a lot of unnecessary variables; this is ok, as wasm-opt does local merging
 //! and should remove unnecessary tees etc. But this might be an area in which performance could
@@ -75,7 +76,7 @@
 //!
 //! A note on naming: I call this SSA, but it is not strictly true. In SSA, each variable is assigned to
 //! exactly once, and at a dominance frontier, SSAs from preceding blocks are merged into one using a 'phi node'
-//! or 'phi function', why picks the correct variable to read based on which branch was just taken. Carrying
+//! or 'phi function', which picks the correct variable to read based on which branch was just taken. Carrying
 //! around additional information about which block was just taken isn't something that I want to do, so our
 //! 'phi function' actually inserts the relevant assignment into the preceding blocks directly. This does mean
 //! that some variables can be written to from different blocks, especially where loops are concerned (as the
@@ -92,10 +93,8 @@ use alloc::collections::btree_map::Entry;
 use core::convert::identity;
 use core::hash::{Hash, Hasher};
 use core::marker::PhantomData;
-use core::mem;
 use core::ops::Deref;
 
-// use petgraph::dot::Dot;
 use petgraph::graph::{EdgeIndex, NodeIndex};
 use petgraph::stable_graph::StableDiGraph;
 use petgraph::visit::EdgeRef;
@@ -114,13 +113,11 @@ use crate::ir::{
 use crate::prelude::*;
 
 #[derive(Clone, Debug)]
-enum StackElement {
+enum StackOperation {
     Drop,
-    Var(RcVar),
-    List(RcList),
-    // for things where we can guarantee the output type. e.g. for constants (int, float, string)
-    Type(IrType),
-    /// this shouldn't be anything that branches or mutates anything in any way,
+    Push(VarTarget),
+    Pop(VarTarget),
+    /// this shouldn't be anything that branches or mutates variables in any way,
     /// i.e. not loop, if/else, yield, set variable, etc
     Opcode(IrOpcode),
 }
@@ -129,16 +126,13 @@ enum StackElement {
 enum VarTarget {
     Var(RcVar),
     List(RcList),
-    Drop,
 }
 
 impl VarTarget {
-    /// SAFETY: do not call with `VarTarget::Drop`
     fn possible_types(&self) -> core::cell::Ref<'_, IrType> {
         match self {
             Self::Var(var) => var.possible_types(),
             Self::List(list) => list.possible_types(),
-            Self::Drop => unreachable!(),
         }
     }
 
@@ -146,7 +140,6 @@ impl VarTarget {
         match self {
             Self::Var(var) => var.add_type(ty),
             Self::List(list) => list.add_type(ty),
-            Self::Drop => (),
         }
     }
 }
@@ -161,7 +154,7 @@ enum EdgeType {
     BackLink,
 }
 
-type NodeWeight = Option<(Vec<VarTarget>, Vec<StackElement>)>;
+type NodeWeight = Option<StackOperation>;
 
 #[derive(Debug)]
 struct BaseVarGraph {
@@ -247,6 +240,13 @@ impl VarGraph {
         self.graph().borrow_mut().add_node(weight)
     }
 
+    fn add_node_at_end(&self, weight: NodeWeight) {
+        let new_node = self.add_node(weight);
+        let end_node = *self.exit_node().borrow();
+        self.add_edge(end_node, new_node, EdgeType::Forward);
+        *self.exit_node().borrow_mut() = new_node;
+    }
+
     fn add_edge(&self, a: NodeIndex, b: NodeIndex, weight: EdgeType) -> EdgeIndex {
         self.graph().borrow_mut().add_edge(a, b, weight)
     }
@@ -257,7 +257,6 @@ impl VarGraph {
         step: S,
         variable_maps: &mut VariableMaps<'_>,
         graphs: &mut BTreeMap<Box<str>, MaybeGraph>,
-        type_stack: &mut Vec<StackElement>,
         next_steps: &mut Vec<StepIndex>,
     ) -> HQResult<()>
     where
@@ -311,15 +310,17 @@ impl VarGraph {
                     let already_local = *locality.try_borrow()?;
                     if already_local {
                         if var.try_borrow()?.possible_types().is_none() {
-                            let new_node = self.add_node(Some((
-                                vec![VarTarget::Var(var.try_borrow()?.clone())],
-                                mem::take(type_stack),
+                            let pop_node = self.add_node(Some(StackOperation::Pop(
+                                VarTarget::Var(var.try_borrow()?.clone()),
                             )));
                             let last_node = *self.exit_node().borrow();
-                            self.add_edge(last_node, new_node, EdgeType::Forward);
-                            *self.exit_node().borrow_mut() = new_node;
+                            self.add_edge(last_node, pop_node, EdgeType::Forward);
+                            *self.exit_node().borrow_mut() = pop_node;
                         } else {
-                            type_stack.push(StackElement::Drop);
+                            let drop_node = self.add_node(Some(StackOperation::Drop));
+                            let last_node = *self.exit_node().borrow();
+                            self.add_edge(last_node, drop_node, EdgeType::Forward);
+                            *self.exit_node().borrow_mut() = drop_node;
                         }
                         continue 'opcode_loop;
                     }
@@ -331,34 +332,12 @@ impl VarGraph {
                     }
                     *var.try_borrow_mut()? = new_variable;
                     *locality.try_borrow_mut()? = true;
-                    if type_stack.is_empty() {
-                        let mut graph = self.graph().borrow_mut();
-                        let Some(Some((vars, _))) =
-                            graph.node_weight_mut(*self.exit_node().borrow())
-                        else {
-                            hq_bug!("")
-                        };
-                        vars.push(VarTarget::Var(var.try_borrow()?.clone()));
-                    } else if !type_stack.is_empty() {
-                        let new_node = self.add_node(Some((
-                            vec![VarTarget::Var(var.try_borrow()?.clone())],
-                            mem::take(type_stack),
-                        )));
-                        let last_node = *self.exit_node().borrow();
-                        self.add_edge(last_node, new_node, EdgeType::Forward);
-                        *self.exit_node().borrow_mut() = new_node;
-                    }
-                    //     crate::log!(
-                    //         "{:?}exit node: {:?}",
-                    //         Dot::with_config(
-                    //             &*self.graph().borrow(),
-                    //             &[
-                    // //DotConfig::NodeIndexLabel
-                    // ]
-                    //         ),
-                    //         *self.exit_node().borrow()
-                    //     );
-                    // crate::log!("type stack: {type_stack:?}");
+                    let pop_node = self.add_node(Some(StackOperation::Pop(VarTarget::Var(
+                        var.try_borrow()?.clone(),
+                    ))));
+                    let last_node = *self.exit_node().borrow();
+                    self.add_edge(last_node, pop_node, EdgeType::Forward);
+                    *self.exit_node().borrow_mut() = pop_node;
                 }
                 IrOpcode::data_teevariable(DataTeevariableFields {
                     var,
@@ -367,7 +346,9 @@ impl VarGraph {
                     // crate::log("found a variable tee operation");
                     let already_local = *locality.try_borrow()?;
                     if already_local {
-                        *type_stack = vec![StackElement::Var(var.try_borrow()?.clone())];
+                        self.add_node_at_end(Some(StackOperation::Push(VarTarget::Var(
+                            var.try_borrow()?.clone(),
+                        ))));
                         continue 'opcode_loop;
                     }
                     let new_variable = RcVar::new_empty();
@@ -378,27 +359,25 @@ impl VarGraph {
                     }
                     *var.try_borrow_mut()? = new_variable;
                     *locality.try_borrow_mut()? = true;
-                    // TODO: do we need to consider the case where the stack is empty,
-                    // as with setvariableto?
-                    let new_node = self.add_node(Some((
-                        vec![VarTarget::Var(var.try_borrow()?.clone())],
-                        mem::take(type_stack),
-                    )));
-                    let last_node = *self.exit_node().borrow();
-                    self.add_edge(last_node, new_node, EdgeType::Forward);
-                    *self.exit_node().borrow_mut() = new_node;
-                    type_stack.push(StackElement::Var(var.try_borrow()?.clone()));
+                    self.add_node_at_end(Some(StackOperation::Pop(VarTarget::Var(
+                        var.try_borrow()?.clone(),
+                    ))));
+                    self.add_node_at_end(Some(StackOperation::Push(VarTarget::Var(
+                        var.try_borrow()?.clone(),
+                    ))));
                 }
                 IrOpcode::data_variable(DataVariableFields { var, local_read }) => {
                     // crate::log("found a variable read operation");
                     if *local_read.try_borrow()? {
-                        type_stack.push(StackElement::Var(var.try_borrow()?.clone()));
+                        self.add_node_at_end(Some(StackOperation::Push(VarTarget::Var(
+                            var.try_borrow()?.clone(),
+                        ))));
                         // crate::log("variable is already local; skipping");
                         continue;
                     }
                     let gvar = &var.try_borrow()?.clone();
                     let mut var_mut = var.try_borrow_mut()?;
-                    type_stack.push(StackElement::Var(
+                    self.add_node_at_end(Some(StackOperation::Push(VarTarget::Var(
                         variable_maps.use_current_ssa_for_global::<_, _, _, HQResult<_>>(
                             gvar,
                             |current_ssa_var| {
@@ -430,40 +409,27 @@ impl VarGraph {
                             },
                             || Ok(gvar.clone()),
                         )?,
-                    ));
-                    // crate::log!("stack: {type_stack:?}");
+                    ))));
                 }
                 IrOpcode::data_itemoflist(DataItemoflistFields { list }) => {
-                    type_stack.push(StackElement::Drop);
-                    type_stack.push(StackElement::List(list.clone()));
+                    self.add_node_at_end(Some(StackOperation::Drop));
+                    self.add_node_at_end(Some(StackOperation::Push(VarTarget::List(list.clone()))));
                 }
                 IrOpcode::data_addtolist(DataAddtolistFields { list }) => {
-                    // crate::log!("type stack at data_addtolist: {type_stack:?}");
-                    let new_node = self.add_node(Some((
-                        vec![VarTarget::List(list.clone())],
-                        mem::take(type_stack),
-                    )));
-                    let last_node = *self.exit_node().borrow();
-                    self.add_edge(last_node, new_node, EdgeType::Forward);
-                    *self.exit_node().borrow_mut() = new_node;
+                    self.add_node_at_end(Some(StackOperation::Pop(VarTarget::List(list.clone()))));
                 }
                 IrOpcode::data_replaceitemoflist(DataReplaceitemoflistFields { list })
                 | IrOpcode::data_insertatlist(DataInsertatlistFields { list }) => {
-                    // crate::log!("type stack at replaceitemof/insertatlist: {type_stack:?}");
-                    let new_node = self.add_node(Some((
-                        vec![VarTarget::List(list.clone()), VarTarget::Drop],
-                        mem::take(type_stack),
-                    )));
-                    let last_node = *self.exit_node().borrow();
-                    self.add_edge(last_node, new_node, EdgeType::Forward);
-                    *self.exit_node().borrow_mut() = new_node;
+                    self.add_node_at_end(Some(StackOperation::Drop));
+                    self.add_node_at_end(Some(StackOperation::Pop(VarTarget::List(list.clone()))));
                 }
                 IrOpcode::control_if_else(ControlIfElseFields {
                     branch_if,
                     branch_else,
                 }) => {
                     // crate::log("found control_if_else");
-                    type_stack.clear(); // the top item on the stack should be consumed by control_if_else
+                    // the top item on the stack should be consumed by control_if_else
+                    self.add_node_at_end(Some(StackOperation::Drop));
                     let last_node = *self.exit_node().borrow();
 
                     let branch_if_mut = Rc::new(Rc::unwrap_or_clone(Rc::clone(branch_if)));
@@ -475,7 +441,6 @@ impl VarGraph {
                         Rc::clone(&branch_if_mut),
                         &mut branch_if_variable_maps,
                         graphs,
-                        type_stack,
                         next_steps,
                     )?;
                     graphs.insert(branch_if_mut.try_borrow()?.id().into(), MaybeGraph::Inlined);
@@ -491,7 +456,6 @@ impl VarGraph {
                         Rc::clone(&branch_else_mut),
                         &mut branch_else_variable_maps,
                         graphs,
-                        type_stack,
                         next_steps,
                     )?;
                     graphs.insert(
@@ -529,13 +493,13 @@ impl VarGraph {
                     let exit_node = *self.exit_node().borrow();
                     self.add_edge(if_branch_exit, exit_node, EdgeType::Forward);
                     self.add_edge(else_branch_exit, exit_node, EdgeType::Forward);
-                    type_stack.clear();
                 }
                 IrOpcode::control_loop(ControlLoopFields {
                     first_condition,
                     condition,
                     body,
                     flip_if,
+                    pre_body,
                 }) => {
                     let new_var_map: BTreeMap<_, _> = step
                         .try_borrow()?
@@ -593,13 +557,16 @@ impl VarGraph {
                                             ))
                                         },
                                     )?;
-                                let new_node = self.add_node(Some((
-                                    vec![VarTarget::Var(new_var.clone())],
-                                    vec![StackElement::Var(accessed_var)],
+                                let push_node = self.add_node(Some(StackOperation::Push(
+                                    VarTarget::Var(accessed_var),
+                                )));
+                                let pop_node = self.add_node(Some(StackOperation::Pop(
+                                    VarTarget::Var(new_var.clone()),
                                 )));
                                 let exit_node = *self.exit_node().borrow();
-                                self.add_edge(exit_node, new_node, EdgeType::Forward);
-                                *self.exit_node().borrow_mut() = new_node;
+                                self.add_edge(exit_node, push_node, EdgeType::Forward);
+                                self.add_edge(push_node, pop_node, EdgeType::Forward);
+                                *self.exit_node().borrow_mut() = pop_node;
                                 variable_maps
                                     .ssa
                                     .insert(global_var.clone(), new_var.clone());
@@ -628,20 +595,46 @@ impl VarGraph {
                             // we don't need to keep track of this map as no variables should be set in the first condition
                             &mut variable_maps.clone(),
                             graphs,
-                            type_stack,
                             next_steps,
                         )?;
                         graphs.insert(
                             first_condition_mut.try_borrow()?.id().into(),
                             MaybeGraph::Inlined,
                         );
-                        type_stack.clear(); // we consume the top item on the type stack as an i32.eqz
-                        let first_cond_exit = *self.exit_node().borrow();
+                        let drop_node = self.add_node(Some(StackOperation::Drop)); // we consume the top item on the type stack as an i32.eqz
+                        let end_node = *self.exit_node().borrow();
+                        self.add_edge(end_node, drop_node, EdgeType::Forward);
+                        *self.exit_node().borrow_mut() = drop_node;
+                        let first_cond_exit = drop_node;
 
                         let header_node = self.add_node(None);
                         self.add_edge(first_cond_exit, header_node, EdgeType::Forward);
                         *self.exit_node().borrow_mut() = header_node;
 
+                        let pre_body_mut = pre_body
+                            .as_ref()
+                            .map(|pre_body_real| -> HQResult<_> {
+                                let pre_body_mut =
+                                    Rc::new(Rc::unwrap_or_clone(Rc::clone(pre_body_real)));
+                                let mut pre_body_variable_maps = variable_maps.clone();
+                                graphs.insert(
+                                    pre_body_mut.try_borrow()?.id().into(),
+                                    MaybeGraph::Started,
+                                );
+                                self.visit_step(
+                                    Rc::clone(&pre_body_mut),
+                                    &mut pre_body_variable_maps,
+                                    graphs,
+                                    next_steps,
+                                )?;
+                                graphs.insert(
+                                    pre_body_mut.try_borrow()?.id().into(),
+                                    MaybeGraph::Inlined,
+                                );
+                                Ok(pre_body_mut)
+                            })
+                            .transpose()?;
+
                         let body_mut = Rc::new(Rc::unwrap_or_clone(Rc::clone(body)));
                         let mut body_variable_maps = variable_maps.clone();
                         graphs.insert(body_mut.try_borrow()?.id().into(), MaybeGraph::Started);
@@ -649,7 +642,6 @@ impl VarGraph {
                             Rc::clone(&body_mut),
                             &mut body_variable_maps,
                             graphs,
-                            type_stack,
                             next_steps,
                         )?;
                         graphs.insert(body_mut.try_borrow()?.id().into(), MaybeGraph::Inlined);
@@ -661,12 +653,14 @@ impl VarGraph {
                             Rc::clone(&condition_mut),
                             &mut body_variable_maps,
                             graphs,
-                            type_stack,
                             next_steps,
                         )?;
                         graphs.insert(condition_mut.try_borrow()?.id().into(), MaybeGraph::Inlined);
-                        type_stack.clear();
-                        let mut cond_exit = *self.exit_node().borrow();
+                        let drop_node = self.add_node(Some(StackOperation::Drop));
+                        let end_node = *self.exit_node().borrow();
+                        self.add_edge(end_node, drop_node, EdgeType::Forward);
+                        *self.exit_node().borrow_mut() = drop_node;
+                        let mut cond_exit = drop_node;
 
                         self.ssa_phi(
                             vec![(&condition_mut, body_variable_maps.ssa, &mut cond_exit)],
@@ -681,6 +675,7 @@ impl VarGraph {
                                 first_condition: Some(first_condition_mut),
                                 flip_if: *flip_if,
                                 condition: condition_mut,
+                                pre_body: pre_body_mut,
                             }),
                         ));
 
@@ -699,11 +694,37 @@ impl VarGraph {
                             Rc::clone(&condition_mut),
                             &mut body_variable_maps,
                             graphs,
-                            type_stack,
                             next_steps,
                         )?;
                         graphs.insert(condition_mut.try_borrow()?.id().into(), MaybeGraph::Inlined);
-                        type_stack.clear();
+                        let drop_node = self.add_node(Some(StackOperation::Drop));
+                        let end_node = *self.exit_node().borrow();
+                        self.add_edge(end_node, drop_node, EdgeType::Forward);
+                        *self.exit_node().borrow_mut() = drop_node;
+
+                        let pre_body_mut = pre_body
+                            .as_ref()
+                            .map(|pre_body_real| -> HQResult<_> {
+                                let pre_body_mut =
+                                    Rc::new(Rc::unwrap_or_clone(Rc::clone(pre_body_real)));
+                                let mut pre_body_variable_maps = variable_maps.clone();
+                                graphs.insert(
+                                    pre_body_mut.try_borrow()?.id().into(),
+                                    MaybeGraph::Started,
+                                );
+                                self.visit_step(
+                                    Rc::clone(&pre_body_mut),
+                                    &mut pre_body_variable_maps,
+                                    graphs,
+                                    next_steps,
+                                )?;
+                                graphs.insert(
+                                    pre_body_mut.try_borrow()?.id().into(),
+                                    MaybeGraph::Inlined,
+                                );
+                                Ok(pre_body_mut)
+                            })
+                            .transpose()?;
 
                         let body_mut = Rc::new(Rc::unwrap_or_clone(Rc::clone(body)));
                         graphs.insert(body_mut.try_borrow()?.id().into(), MaybeGraph::Started);
@@ -711,7 +732,6 @@ impl VarGraph {
                             Rc::clone(&body_mut),
                             &mut body_variable_maps,
                             graphs,
-                            type_stack,
                             next_steps,
                         )?;
                         graphs.insert(body_mut.try_borrow()?.id().into(), MaybeGraph::Inlined);
@@ -733,6 +753,7 @@ impl VarGraph {
                                 body: body_mut,
                                 first_condition: None,
                                 condition: condition_mut,
+                                pre_body: pre_body_mut,
                             }),
                         ));
                     }
@@ -743,35 +764,40 @@ impl VarGraph {
                 }
                 IrOpcode::procedures_argument(ProceduresArgumentFields { arg_var, .. }) => {
                     // crate::log("found proc argument.");
-                    type_stack.push(StackElement::Var(arg_var.clone()));
+                    self.add_node_at_end(Some(StackOperation::Push(VarTarget::Var(
+                        arg_var.clone(),
+                    ))));
                 }
                 IrOpcode::procedures_call_warp(ProceduresCallWarpFields { proc }) => {
                     // crate::log!("found proc call. type stack: {type_stack:?}");
                     let Some(warped_specific_proc) = &*proc.warped_specific_proc() else {
                         hq_bug!("tried to call_warp with no warped proc")
                     };
-                    let entry_node = self.add_node(Some((
-                        warped_specific_proc
-                            .arg_vars()
-                            .try_borrow()?
-                            .iter()
-                            .rev()
-                            .cloned()
-                            .map(VarTarget::Var)
-                            .collect(),
-                        mem::take(type_stack),
-                    )));
-                    let last_node = *self.exit_node().borrow();
-                    self.add_edge(last_node, entry_node, EdgeType::Forward);
-                    *self.exit_node().borrow_mut() = entry_node;
-                    type_stack.extend(
-                        warped_specific_proc
-                            .return_vars()
-                            .try_borrow()?
-                            .iter()
-                            .map(|var| StackElement::Var(var.clone())),
-                    );
-                    // crate::log!("type stack after proc call: {type_stack:?}");
+                    for arg_var in warped_specific_proc
+                        .arg_vars()
+                        .try_borrow()?
+                        .iter()
+                        .rev()
+                        .cloned()
+                    {
+                        let pop_node =
+                            self.add_node(Some(StackOperation::Pop(VarTarget::Var(arg_var))));
+                        let last_node = *self.exit_node().borrow();
+                        self.add_edge(last_node, pop_node, EdgeType::Forward);
+                        *self.exit_node().borrow_mut() = pop_node;
+                    }
+                    for ret_var in warped_specific_proc
+                        .return_vars()
+                        .try_borrow()?
+                        .iter()
+                        .cloned()
+                    {
+                        let push_node =
+                            self.add_node(Some(StackOperation::Push(VarTarget::Var(ret_var))));
+                        let last_node = *self.exit_node().borrow();
+                        self.add_edge(last_node, push_node, EdgeType::Forward);
+                        *self.exit_node().borrow_mut() = push_node;
+                    }
                 }
                 IrOpcode::procedures_call_nonwarp(ProceduresCallNonwarpFields {
                     proc,
@@ -781,20 +807,19 @@ impl VarGraph {
                     let Some(nonwarped_specific_proc) = &*proc.nonwarped_specific_proc() else {
                         hq_bug!("tried to call_nonwarp with no non-warped proc")
                     };
-                    let entry_node = self.add_node(Some((
-                        nonwarped_specific_proc
-                            .arg_vars()
-                            .try_borrow()?
-                            .iter()
-                            .rev()
-                            .cloned()
-                            .map(VarTarget::Var)
-                            .collect(),
-                        mem::take(type_stack),
-                    )));
-                    let last_node = *self.exit_node().borrow();
-                    self.add_edge(last_node, entry_node, EdgeType::Forward);
-                    *self.exit_node().borrow_mut() = entry_node;
+                    for arg_var in nonwarped_specific_proc
+                        .arg_vars()
+                        .try_borrow()?
+                        .iter()
+                        .rev()
+                        .cloned()
+                    {
+                        let pop_node =
+                            self.add_node(Some(StackOperation::Pop(VarTarget::Var(arg_var))));
+                        let last_node = *self.exit_node().borrow();
+                        self.add_edge(last_node, pop_node, EdgeType::Forward);
+                        *self.exit_node().borrow_mut() = pop_node;
+                    }
                     next_steps.push(*next_step);
                     should_propagate_ssa = true;
                     break 'opcode_loop;
@@ -805,13 +830,7 @@ impl VarGraph {
                         // crate::log("found inline step to visit");
                         let step_mut = Rc::new(Rc::unwrap_or_clone(Rc::clone(step)));
                         graphs.insert(step_mut.try_borrow()?.id().into(), MaybeGraph::Started);
-                        self.visit_step(
-                            Rc::clone(&step_mut),
-                            variable_maps,
-                            graphs,
-                            type_stack,
-                            next_steps,
-                        )?;
+                        self.visit_step(Rc::clone(&step_mut), variable_maps, graphs, next_steps)?;
                         graphs.insert(step_mut.try_borrow()?.id().into(), MaybeGraph::Inlined);
                     }
                     YieldMode::None | YieldMode::Return => {
@@ -823,31 +842,10 @@ impl VarGraph {
                     YieldMode::Schedule(_) => (), // handled at bottom of loop
                 },
                 _ => {
-                    let inputs_len = opcode.acceptable_inputs()?.len();
-                    let output = opcode
-                        .output_type(core::iter::repeat_n(IrType::Any, inputs_len).collect())?;
-                    match output {
-                        ReturnType::Singleton(output_ty) => {
-                            // crate::log("other opcode; has output type");
-                            if inputs_len == 0 {
-                                type_stack.push(StackElement::Type(output_ty));
-                                // crate::log("no inputs so pushing type");
-                                // crate::log!("stack: {type_stack:?}");
-                            } else {
-                                type_stack.push(StackElement::Opcode(opcode.clone()));
-                                // crate::log("inputs so pushing op");
-                                // crate::log!("stack: {type_stack:?}");
-                            }
-                        }
-                        ReturnType::MultiValue(outputs) => {
-                            if inputs_len == 0 {
-                                type_stack.extend(outputs.iter().copied().map(StackElement::Type));
-                            } else {
-                                type_stack.push(StackElement::Opcode(opcode.clone()));
-                            }
-                        }
-                        ReturnType::None => type_stack.clear(),
-                    }
+                    let opcode_node = self.add_node(Some(StackOperation::Opcode(opcode.clone())));
+                    let last_node = *self.exit_node().borrow();
+                    self.add_edge(last_node, opcode_node, EdgeType::Forward);
+                    *self.exit_node().borrow_mut() = opcode_node;
                 }
             }
             if let Some(next_step) = opcode.yields_to_next_step() {
@@ -857,32 +855,24 @@ impl VarGraph {
             }
         }
 
-        if !type_stack.is_empty()
-            && (step.try_borrow()?.used_non_inline() || step_ended_on_stop)
+        if (step.try_borrow()?.used_non_inline() || step_ended_on_stop)
             && step.try_borrow()?.context().warp
             && let Some(proc_context) = maybe_proc_context.as_ref()
         {
-            crate::log!(
-                "found spare items on type stack at end of step visit, in warped proc: \
-                 {type_stack:?}"
-            );
+            // crate::log!(
+            //     "found spare items on type stack at end of step visit, in warped proc: \
+            //      {type_stack:?}"
+            // );
             // crate::log!(
             //     "return vars: {}",
             //     proc_context.return_vars().try_borrow()?.len()
             // );
-            let new_node = self.add_node(Some((
-                (*proc_context.ret_vars)
-                    .borrow()
-                    .iter()
-                    .rev()
-                    .cloned()
-                    .map(VarTarget::Var)
-                    .collect(),
-                mem::take(type_stack),
-            )));
-            let last_node = *self.exit_node().borrow();
-            self.add_edge(last_node, new_node, EdgeType::Forward);
-            *self.exit_node().borrow_mut() = new_node;
+            for ret_var in (*proc_context.ret_vars).borrow().iter().rev().cloned() {
+                let pop_node = self.add_node(Some(StackOperation::Pop(VarTarget::Var(ret_var))));
+                let last_node = *self.exit_node().borrow();
+                self.add_edge(last_node, pop_node, EdgeType::Forward);
+                *self.exit_node().borrow_mut() = pop_node;
+            }
         }
 
         {
@@ -923,14 +913,15 @@ impl VarGraph {
                 None
             };
             for (global_var, ssa_var) in &variable_maps.ssa {
-                let this_type_stack = vec![StackElement::Var(ssa_var.clone())];
-                let new_node = self.add_node(Some((
-                    vec![VarTarget::Var(global_var.clone())],
-                    this_type_stack,
-                )));
+                let push_node =
+                    self.add_node(Some(StackOperation::Push(VarTarget::Var(ssa_var.clone()))));
+                let pop_node = self.add_node(Some(StackOperation::Pop(VarTarget::Var(
+                    global_var.clone(),
+                ))));
                 let last_node = *self.exit_node().borrow();
-                self.add_edge(last_node, new_node, EdgeType::Forward);
-                *self.exit_node().borrow_mut() = new_node;
+                self.add_edge(last_node, push_node, EdgeType::Forward);
+                self.add_edge(push_node, pop_node, EdgeType::Forward);
+                *self.exit_node().borrow_mut() = pop_node;
                 // crate::log("adding outer variable writes");
                 opcodes.extend([
                     IrOpcode::data_variable(DataVariableFields {
@@ -1022,12 +1013,13 @@ impl VarGraph {
             ) {
                 opcodes.reserve_exact(var_writes.len() * 2);
                 for ((var_read, read_local), var_write) in var_writes {
-                    let new_node = self.add_node(Some((
-                        vec![VarTarget::Var(var_write.clone())],
-                        vec![StackElement::Var(var_read.clone())],
-                    )));
-                    self.add_edge(***block_exit, new_node, EdgeType::Forward);
-                    ***block_exit = new_node;
+                    let push_node =
+                        self.add_node(Some(StackOperation::Push(VarTarget::Var(var_read.clone()))));
+                    let pop_node =
+                        self.add_node(Some(StackOperation::Pop(VarTarget::Var(var_write.clone()))));
+                    self.add_edge(***block_exit, push_node, EdgeType::Forward);
+                    self.add_edge(push_node, pop_node, EdgeType::Forward);
+                    ***block_exit = pop_node;
 
                     opcodes.append(&mut vec![
                         IrOpcode::data_variable(DataVariableFields {
@@ -1073,7 +1065,6 @@ fn visit_step_recursively(
                 next_step,
                 &mut VariableMaps::new_with_proc_args(proc_args),
                 graphs,
-                &mut vec![],
                 next_steps,
             )?;
             graphs.insert(
@@ -1153,36 +1144,58 @@ fn split_variables_and_make_graphs(
     Ok(graphs)
 }
 
-fn evaluate_type_stack(type_stack: &Vec<StackElement>) -> HQResult<Vec<IrType>> {
-    let mut stack = vec![];
+fn evaluate_type_stack(
+    type_stack: &[IrType],
+    stack_op: &StackOperation,
+    changed_vars: &mut BTreeSet<VarTarget>,
+) -> HQResult<Vec<IrType>> {
     // crate::log!("type stack: {type_stack:?}");
-    for el in type_stack {
-        match el {
-            StackElement::Opcode(op) => {
-                let inputs_len = op.acceptable_inputs()?.len();
-                // crate::log!("opcode: {op}");
-                // crate::log!("stack length: {}, inputs len: {}", stack.len(), inputs_len);
-                // crate::log!("stack: {:?}", stack);
-                let inputs: Rc<[_]> = stack
-                    .splice((stack.len() - inputs_len).., [])
-                    .map(|ty: IrType| if ty.is_none() { IrType::Any } else { ty })
-                    .collect();
-                let output = op.output_type(inputs)?;
-                match output {
-                    ReturnType::Singleton(ty) => stack.push(ty),
-                    ReturnType::MultiValue(tys) => stack.extend(tys.iter().copied()),
-                    ReturnType::None => (),
-                }
+    Ok(match stack_op {
+        StackOperation::Opcode(op) => {
+            let mut local_stack = Vec::from(type_stack);
+            let inputs_len = op.acceptable_inputs()?.len();
+            // crate::log!("opcode: {op}");
+            // crate::log!("stack length: {}, inputs len: {}", stack.len(), inputs_len);
+            // crate::log!("stack: {:?}", stack);
+            hq_assert!(
+                local_stack.len() >= inputs_len,
+                "can't pop {} elements from stack of length {}",
+                inputs_len,
+                local_stack.len()
+            );
+            let inputs: Rc<[_]> = local_stack
+                .splice((local_stack.len() - inputs_len).., [])
+                .map(|ty: IrType| if ty.is_none() { IrType::Any } else { ty })
+                .collect();
+            let output = op.output_type(inputs)?;
+            match output {
+                ReturnType::Singleton(ty) => local_stack.push(ty),
+                ReturnType::MultiValue(tys) => local_stack.extend(tys.iter().copied()),
+                ReturnType::None => (),
             }
-            StackElement::Drop => {
-                stack.pop();
+            local_stack
+        }
+        StackOperation::Drop => {
+            hq_assert!(!type_stack.is_empty(), "can't drop from empty stack");
+            Vec::from(&type_stack[0..type_stack.len() - 1])
+        }
+        StackOperation::Push(var_target) => {
+            let mut local_stack = Vec::from(type_stack);
+            local_stack.push(*var_target.possible_types());
+            local_stack
+        }
+        StackOperation::Pop(target) => {
+            hq_assert!(!type_stack.is_empty(), "can't pop from empty stack");
+            let mut local_stack = Vec::from(type_stack);
+            #[expect(clippy::unwrap_used, reason = "checked non-empty")]
+            let popped = local_stack.pop().unwrap();
+            if !target.possible_types().contains(popped) {
+                changed_vars.insert(target.clone());
             }
-            StackElement::Type(ty) => stack.push(*ty),
-            StackElement::Var(var) => stack.push(*var.possible_types()),
-            StackElement::List(list) => stack.push(*list.possible_types()),
+            target.add_type(popped);
+            local_stack
         }
-    }
-    Ok(stack)
+    })
 }
 
 fn visit_node(
@@ -1190,28 +1203,16 @@ fn visit_node(
     node: NodeIndex,
     changed_vars: &mut BTreeSet<VarTarget>,
     stop_at: NodeIndex,
+    base_stack: &Vec<IrType>,
 ) -> HQResult<()> {
-    // crate::log!("node index: {node:?}");
-    if let Some(Some((vars, type_stack))) = graph.graph().try_borrow()?.node_weight(node) {
-        // crate::log!("vars: {vars:?}");
-        let reduced_stack = evaluate_type_stack(type_stack)?;
-        // crate::log!("stack: {type_stack:?}\nreduced stack: {reduced_stack:?}");
-        hq_assert_eq!(
-            vars.len(),
-            reduced_stack.len(),
-            "variables stack should have the same length as the corresponding type stack"
-        );
-        for (var, new_type) in vars.iter().rev().zip(reduced_stack) {
-            if matches!(var, VarTarget::Drop) {
-                continue;
-            }
-            if !var.possible_types().contains(new_type) {
-                changed_vars.insert(var.clone());
-            }
-            var.add_type(new_type);
-        }
-    }
+    // crate::log!("node index: {node:?}; stack size {}", base_stack.len());
+    let new_stack = if let Some(Some(stack_op)) = graph.graph().try_borrow()?.node_weight(node) {
+        &evaluate_type_stack(base_stack, stack_op, changed_vars)?
+    } else {
+        base_stack
+    };
     if node == stop_at {
+        // crate::log("stopping!");
         return Ok(());
     }
     let inner_graph = graph.graph().try_borrow()?;
@@ -1222,42 +1223,63 @@ fn visit_node(
         backlinks.len() <= 1,
         "Each node should have at most 1 backlink"
     );
+    // crate::log("loopy loop (backlink)");
     if let Some(backlink) = backlinks.first() {
         loop {
             let mut loop_changed_vars = BTreeSet::new();
-            visit_node(graph, backlink.target(), &mut loop_changed_vars, node)?;
+            visit_node(
+                graph,
+                backlink.target(),
+                &mut loop_changed_vars,
+                node,
+                base_stack,
+            )?;
+            crate::log!(
+                "at backlink from node {:?}, changed {} vars (isEmpty: {})",
+                node,
+                loop_changed_vars.len(),
+                loop_changed_vars.is_empty()
+            );
             if loop_changed_vars.is_empty() {
                 break;
             }
         }
     }
+    // crate::log("forward links!");
     for forlink in forlinks {
-        visit_node(graph, forlink.target(), changed_vars, stop_at)?;
+        visit_node(graph, forlink.target(), changed_vars, stop_at, new_stack)?;
     }
+    crate::log!(
+        "finished node {:?}, changed {} vars",
+        node,
+        changed_vars.len()
+    );
+    // crate::log("ok.");
     Ok(())
 }
 
 fn iterate_graphs<'a, I>(graphs: &'a I) -> HQResult<()>
 where
-    I: Iterator<Item = &'a VarGraph> + Clone,
+    I: Iterator<Item = (&'a VarGraph, Box<str>)> + Clone,
 {
     loop {
         let mut changed_vars: BTreeSet<VarTarget> = BTreeSet::new();
         for graph in graphs.clone() {
-            use petgraph::dot::Dot;
-            crate::log!(
-                "{:?}exit node: {:?}",
-                Dot::with_config(
-                    &*graph.graph().borrow(),
-                    &[
-                    //DotConfig::NodeIndexLabel
-                    ]
-                ),
-                *graph.exit_node().borrow()
-            );
+            crate::log!("visiting graph for step {}", graph.1);
+            // use petgraph::dot::Dot;
+            // crate::log!(
+            //     "{:?}exit node: {:?}",
+            //     Dot::with_config(
+            //         &*graph.graph().borrow(),
+            //         &[
+            //         //DotConfig::NodeIndexLabel
+            //         ]
+            //     ),
+            //     *graph.exit_node().borrow()
+            // );
             hq_assert!(
                 {
-                    let inner_graph = graph.graph().try_borrow()?;
+                    let inner_graph = graph.0.graph().try_borrow()?;
                     let mut externals = inner_graph.externals(EdgeIn);
                     externals.next().is_some_and(|e| e == NodeIndex::new(0))
                         && externals.next().is_none()
@@ -1266,10 +1288,11 @@ where
             );
             let first_node = NodeIndex::new(0);
             visit_node(
-                graph,
+                graph.0,
                 first_node,
                 &mut changed_vars,
-                *graph.exit_node().try_borrow()?,
+                *graph.0.exit_node().try_borrow()?,
+                &vec![],
             )?;
         }
         // this must eventually converge, because the sequence of types for each variable at each
@@ -1303,7 +1326,7 @@ where
             .opcodes()
             .get(i)
             .ok_or_else(|| make_hq_bug!("opcode index out of bounds"))?
-            .inline_steps();
+            .inline_steps(true);
         if let Some(inline_steps) = inlined_steps {
             let new_inline_steps = inline_steps
                 .iter()
@@ -1318,7 +1341,7 @@ where
                 .opcodes_mut()
                 .get_mut(i)
                 .ok_or_else(|| make_hq_bug!("opcode index out of bounds"))?
-                .inline_steps_mut()
+                .inline_steps_mut(true)
                 .ok_or_else(|| {
                     make_hq_bug!("inline_steps_mut was None when inline_steps was Some")
                 })?
@@ -1426,7 +1449,7 @@ pub fn optimise_variables(project: &Rc<IrProject>) -> HQResult<SSAToken> {
         .filter_map_ok(identity)
         .collect::<HQResult<BTreeMap<_, _>>>()?;
     // crate::log!("graphs num: {}", graphs.len());
-    iterate_graphs(&graphs.values().copied())?;
+    iterate_graphs(&graphs.iter().map(|(s, g)| (*g, (*s).clone())))?;
     for step in project.steps().try_borrow()?.iter() {
         // crate::log!("inserting casts for step {}", step.id());
         insert_casts(step.try_borrow_mut()?.opcodes_mut(), false, true)?;
diff --git a/src/registry.rs b/src/registry.rs
index 858e1550..69f8312b 100644
--- a/src/registry.rs
+++ b/src/registry.rs
@@ -114,6 +114,10 @@ pub trait Registry: Sized + RegistryType {
         )
         .map_err(|_| make_hq_bug!("registry item index out of bounds"))
     }
+
+    // TODO: register_override_ifexists or similar - for things like mark_waiting_flag,
+    // which need to be overriden if they are registered, but don't actually need to be
+    // registered always.
 }
 
 pub trait RegistryDefault: Registry<Value: Default> {
@@ -227,6 +231,7 @@ where
         self.0.registry()
     }
 
+    /// Registers a `NamedRegistryItem` using its key function and its `const VALUE`
     pub fn register<T, N>(&self) -> HQResult<N>
     where
         N: TryFrom<usize>,
@@ -236,6 +241,28 @@ where
         self.0.register(R::name::<T>(), T::VALUE)
     }
 
+    /// Registers a runtime key-value pair; just calls `register` on the underlying
+    /// `Registry`
+    pub fn register_dyn<N>(&self, key: R::Key, value: R::Value) -> HQResult<N>
+    where
+        N: TryFrom<usize>,
+        <N as TryFrom<usize>>::Error: fmt::Debug,
+    {
+        self.0.register(key, value)
+    }
+
+    /// Override a runtime key-value pair with a runtime value; just calls
+    /// `register_override` on the underlying `Registry`
+    pub fn register_dyn_override<N>(&self, key: R::Key, value: R::Value) -> HQResult<N>
+    where
+        N: TryFrom<usize>,
+        <N as TryFrom<usize>>::Error: fmt::Debug,
+    {
+        self.0.register_override(key, value)
+    }
+
+    /// Overrides a `NamedRegistryItem` entry using the override argument types
+    /// associated with the corresponding `NamedRegistryItemOverride`
     pub fn register_override<T, N, A>(&self, override_arg: A) -> HQResult<N>
     where
         N: TryFrom<usize>,
@@ -246,6 +273,8 @@ where
             .register_override(R::name::<T>(), T::r#override(override_arg))
     }
 
+    /// Tries to override a `NamedRegistryItem` entry using the override argument
+    /// types associated with the corresponding `TryNamedRegistryItemOverride`
     pub fn try_register_override<T, N, A>(&self, override_arg: A) -> HQResult<N>
     where
         N: TryFrom<usize>,
diff --git a/src/wasm/func.rs b/src/wasm/func.rs
index dd0866b3..8678adde 100644
--- a/src/wasm/func.rs
+++ b/src/wasm/func.rs
@@ -228,6 +228,7 @@ pub struct StepFunc {
     target: StepTarget,
     // the actual target index, for interfacing with js
     target_index: u32,
+    costume_names: Rc<Vec<Vec<Box<str>>>>,
 }
 
 impl StepFunc {
@@ -255,6 +256,10 @@ impl StepFunc {
         self.target_index
     }
 
+    pub const fn costume_names(&self) -> &Rc<Vec<Vec<Box<str>>>> {
+        &self.costume_names
+    }
+
     /// creates a new step function, with one paramter
     #[must_use]
     pub fn new(
@@ -262,6 +267,7 @@ impl StepFunc {
         flags: WasmFlags,
         target: StepTarget,
         target_index: u32,
+        costume_names: Rc<Vec<Vec<Box<str>>>>,
     ) -> Self {
         Self {
             locals: RefCell::new(vec![]),
@@ -273,6 +279,7 @@ impl StepFunc {
             local_variables: RefCell::new(BTreeMap::default()),
             target,
             target_index,
+            costume_names,
         }
     }
 
@@ -286,6 +293,7 @@ impl StepFunc {
         flags: WasmFlags,
         target: StepTarget,
         target_index: u32,
+        costume_names: Rc<Vec<Vec<Box<str>>>>,
     ) -> Self {
         Self {
             locals: RefCell::new(vec![]),
@@ -297,6 +305,7 @@ impl StepFunc {
             local_variables: RefCell::new(BTreeMap::default()),
             target,
             target_index,
+            costume_names,
         }
     }
 
@@ -407,6 +416,7 @@ impl StepFunc {
         steps: &Rc<RefCell<Vec<Self>>>,
         registries: Rc<Registries>,
         flags: WasmFlags,
+        costume_names: Rc<Vec<Vec<Box<str>>>>,
     ) -> HQResult<Self> {
         hq_assert!(
             step.try_borrow()?.used_non_inline(),
@@ -454,9 +464,17 @@ impl StepFunc {
             } else {
                 Box::from([])
             };
-            Self::new_with_types(params, outputs, registries, flags, target, target_index)
+            Self::new_with_types(
+                params,
+                outputs,
+                registries,
+                flags,
+                target,
+                target_index,
+                costume_names,
+            )
         } else {
-            Self::new(registries, flags, target, target_index)
+            Self::new(registries, flags, target, target_index, costume_names)
         };
         if let Some(ref proc_context) = step.try_borrow()?.context().proc_context
             && !step.try_borrow()?.context().warp
diff --git a/src/wasm/project.rs b/src/wasm/project.rs
index 964534d7..b962e831 100644
--- a/src/wasm/project.rs
+++ b/src/wasm/project.rs
@@ -2,16 +2,18 @@ use itertools::Itertools;
 use wasm_bindgen::prelude::*;
 use wasm_encoder::{
     AbstractHeapType, BlockType as WasmBlockType, CodeSection, ConstExpr, DataCountSection,
-    DataSection, ElementSection, Elements, ExportKind, ExportSection, Function, FunctionSection,
-    GlobalSection, HeapType, ImportSection, Instruction, MemorySection, MemoryType, Module,
-    RefType, StartSection, TableSection, TypeSection, ValType,
+    DataSection, ElementSection, Elements, ExportKind, ExportSection, FieldType, Function,
+    FunctionSection, GlobalSection, HeapType, ImportSection, Instruction, MemorySection,
+    MemoryType, Module, RefType, StartSection, StorageType, TableSection, TypeSection, ValType,
 };
 use wasm_gen::wasm;
 
 use super::{ExternalEnvironment, GlobalExportable, GlobalMutable, Registries};
 use crate::ir::{Event, IrProject, StepIndex, Type as IrType};
 use crate::prelude::*;
-use crate::wasm::registries::functions::static_functions::{SpawnNewThread, SpawnThreadInStack};
+use crate::wasm::registries::functions::static_functions::{
+    MarkWaitingFlag, SpawnNewThread, SpawnThreadInStack,
+};
 use crate::wasm::{StepFunc, StringsTable, ThreadsTable, WasmFlags};
 
 /// A respresentation of a WASM representation of a project. Cannot be created directly;
@@ -26,6 +28,7 @@ pub struct WasmProject {
     events: BTreeMap<Event, Vec<u32>>,
     registries: Rc<Registries>,
     target_names: Vec<Box<str>>,
+    costume_names: Rc<Vec<Vec<Box<str>>>>,
     environment: ExternalEnvironment,
 }
 
@@ -44,6 +47,7 @@ impl WasmProject {
             environment,
             registries: Rc::new(Registries::default()),
             target_names: vec![],
+            costume_names: Rc::new(vec![]),
         }
     }
 
@@ -153,10 +157,21 @@ impl WasmProject {
                 self.threads_table_index()?,
             ))?;
 
+        self.registries()
+            .static_functions()
+            .register_override::<MarkWaitingFlag, usize, _>(self.registries().types().struct_(
+                vec![FieldType {
+                    element_type: StorageType::I8,
+                    mutable: true,
+                }],
+            )?)?;
+
         self.registries().static_functions().clone().finish(
             &mut functions,
+            &mut exports,
             &mut codes,
             self.registries.types(),
+            self.imported_func_count()?,
         )?;
 
         for step_func in self.steps().try_borrow()?.iter().cloned() {
@@ -205,6 +220,61 @@ impl WasmProject {
 
         Rc::unwrap_or_clone(self.registries().types().clone()).finish(&mut types);
 
+        // TODO: make an elements registry to deal with this at the site of the block
+        for (table_index, table_name) in self
+            .registries()
+            .tables()
+            .registry()
+            .try_borrow()?
+            .keys()
+            .enumerate()
+        {
+            if table_name.starts_with("costume_names_") {
+                #[expect(
+                    clippy::unwrap_used,
+                    reason = "checked immediately before that this is a prefix of the table name"
+                )]
+                let target_index: u32 = table_name
+                    .strip_prefix("costume_names_")
+                    .unwrap()
+                    .parse()
+                    .map_err(|_| make_hq_bug!("couldn't parse target index from table name"))?;
+                let costume_names = self
+                    .costume_names
+                    .get(target_index as usize)
+                    .ok_or_else(|| make_hq_bug!("target index out of bounds for costume names"))?;
+                let name_globals = costume_names
+                    .iter()
+                    .map(|costume_name| {
+                        Ok(ConstExpr::global_get(
+                            u32::try_from(
+                                self.registries()
+                                    .strings()
+                                    .registry()
+                                    .try_borrow()?
+                                    .get_index_of(costume_name)
+                                    .ok_or_else(|| {
+                                        make_hq_bug!(
+                                            "couldn't find costume name string in strings registry"
+                                        )
+                                    })?,
+                            )
+                            .map_err(|_| make_hq_bug!("string index out of bounds"))?,
+                        ))
+                    })
+                    .collect::<HQResult<Box<[_]>>>()?;
+                elements.active(
+                    Some(
+                        table_index
+                            .try_into()
+                            .map_err(|_| make_hq_bug!("table index out of bounds"))?,
+                    ),
+                    &ConstExpr::i32_const(0),
+                    Elements::Expressions(RefType::EXTERNREF, Cow::Borrowed(&*name_globals)),
+                );
+            }
+        }
+
         self.registries()
             .tables()
             .clone()
@@ -360,14 +430,15 @@ impl WasmProject {
         )
     }
 
+    #[expect(clippy::needless_pass_by_value, reason = "annoying to borrow a box")]
     fn finish_event(
         &self,
-        export_name: &str,
+        export_name: Box<str>,
         indices: &[u32],
         funcs: &mut FunctionSection,
         codes: &mut CodeSection,
         exports: &mut ExportSection,
-    ) -> HQResult<()> {
+    ) -> HQResult<u32> {
         let mut func = Function::new(vec![]);
 
         let threads_count = self.threads_count_global()?;
@@ -432,12 +503,12 @@ impl WasmProject {
         funcs.function(self.registries().types().function(vec![], vec![])?);
         codes.function(&func);
         exports.export(
-            export_name,
+            &export_name,
             ExportKind::Func,
             self.imported_func_count()? + funcs.len() - 1,
         );
 
-        Ok(())
+        Ok(self.imported_func_count()? + funcs.len() - 1)
     }
 
     fn finish_events(
@@ -446,17 +517,98 @@ impl WasmProject {
         codes: &mut CodeSection,
         exports: &mut ExportSection,
     ) -> HQResult<()> {
-        for (event, indices) in &self.events {
-            self.finish_event(
-                match event {
-                    Event::FlagCLicked => "flag_clicked",
-                    Event::Broadcast(_) => continue, // broadcasts handled in the sender blocks
-                },
-                indices,
-                funcs,
-                codes,
-                exports,
-            )?;
+        let event_funcs = self
+            .events
+            .iter()
+            .map(|(event, indices)| {
+                Ok(Some((
+                    event,
+                    self.finish_event(
+                        match event {
+                            Event::FlagClicked => "flag_clicked".into(),
+                            Event::Broadcast(_) => return Ok(None), // broadcasts handled in the sender blocks
+                            Event::SpriteClicked(index) => {
+                                format!("spriteClicked{index}").into_boxed_str()
+                            }
+                        },
+                        indices,
+                        funcs,
+                        codes,
+                        exports,
+                    )?,
+                )))
+            })
+            .collect::<HQResult<Box<[_]>>>()?
+            .into_iter()
+            .flatten()
+            .collect::<BTreeMap<_, _>>();
+        let sprite_clicked_indices: Box<[i32]> = self
+            .events
+            .keys()
+            .filter_map(|e| {
+                #[expect(clippy::redundant_else, reason = "false positive")]
+                if let Event::SpriteClicked(index) = e {
+                    Some(
+                        i32::try_from(*index)
+                            .map_err(|_| make_hq_bug!("target index out of bounds")),
+                    )
+                } else {
+                    None
+                }
+            })
+            .collect::<HQResult<_>>()?;
+        if !sprite_clicked_indices.is_empty() {
+            let mut sprite_clicked_func = Function::new([]);
+            let sprite_clicked_instrs: Vec<_> = sprite_clicked_indices
+                .iter()
+                .flat_map(|index| {
+                    wasm![
+                        LocalGet(0),
+                        I32Const(*index),
+                        I32Eq,
+                        If(WasmBlockType::Empty),
+                        Call(
+                            event_funcs[&Event::SpriteClicked(
+                                #[expect(
+                                    clippy::unwrap_used,
+                                    reason = "guaranteed to succeed because i32 was originally a \
+                                              u32"
+                                )]
+                                (*index).try_into().unwrap()
+                            )]
+                        ),
+                        Return,
+                        End,
+                    ]
+                })
+                .chain(wasm![End])
+                .collect();
+            for instruction in sprite_clicked_instrs {
+                for real_instruction in instruction.eval(
+                    &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()?,
+                )? {
+                    sprite_clicked_func.instruction(&real_instruction);
+                }
+            }
+            funcs.function(
+                self.registries()
+                    .types()
+                    .function(vec![ValType::I32], vec![])?,
+            );
+            codes.function(&sprite_clicked_func);
+            exports.export(
+                "trigger_sprite_clicked",
+                ExportKind::Func,
+                self.imported_func_count()? + funcs.len() - 1,
+            );
         }
 
         Ok(())
@@ -586,6 +738,20 @@ impl WasmProject {
         let steps = Rc::new(RefCell::new(Vec::new()));
         let registries = Rc::new(Registries::default());
         let mut events: BTreeMap<Event, Vec<u32>> = BTreeMap::default();
+        let costume_names = Rc::new(
+            ir_project
+                .targets()
+                .try_borrow()?
+                .values()
+                .map(|target| {
+                    target
+                        .costumes()
+                        .iter()
+                        .map(|costume| costume.name.clone())
+                        .collect()
+                })
+                .collect(),
+        );
         // StepFunc::compile_step(
         //     Rc::new(Step::new_empty(
         //         Rc::downgrade(ir_project),
@@ -606,7 +772,14 @@ impl WasmProject {
         // )?;
         // compile every step
         for (i, step) in ir_project.steps().try_borrow()?.iter().enumerate() {
-            StepFunc::compile_step(step, StepIndex(i), &steps, Rc::clone(&registries), flags)?;
+            StepFunc::compile_step(
+                step,
+                StepIndex(i),
+                &steps,
+                Rc::clone(&registries),
+                flags,
+                Rc::clone(&costume_names),
+            )?;
         }
         // add thread event handlers for them
         for thread in ir_project.threads().try_borrow()?.iter() {
@@ -622,6 +795,7 @@ impl WasmProject {
             registries,
             environment: ExternalEnvironment::WebBrowser,
             target_names: ir_project.targets().try_borrow()?.keys().cloned().collect(),
+            costume_names,
         })
     }
 }
@@ -660,6 +834,7 @@ mod tests {
             environment: ExternalEnvironment::WebBrowser,
             registries,
             target_names: vec![],
+            costume_names: Rc::new(vec![]),
         };
         let wasm_bytes = project.finish().unwrap().wasm_bytes;
         if let Err(err) = wasmparser::validate(&wasm_bytes) {
diff --git a/src/wasm/registries/functions.rs b/src/wasm/registries/functions.rs
index 8a61cde7..886e9851 100644
--- a/src/wasm/registries/functions.rs
+++ b/src/wasm/registries/functions.rs
@@ -1,8 +1,8 @@
 #![allow(clippy::cast_possible_wrap, reason = "can't use try_into in const")]
 
 use wasm_encoder::{
-    CodeSection, EntityType, Function, FunctionSection, ImportSection, Instruction as WInstruction,
-    ValType,
+    CodeSection, EntityType, ExportKind, ExportSection, Function, FunctionSection, ImportSection,
+    Instruction as WInstruction, ValType,
 };
 
 use super::TypeRegistry;
@@ -28,8 +28,18 @@ pub struct StaticFunction {
     pub params: Box<[ValType]>,
     pub returns: Box<[ValType]>,
     pub locals: Box<[ValType]>,
+    pub export: Option<Box<str>>,
 }
 
+/// A `const`-able representation of a static function.
+///
+/// `maybe_populate` should return a `Some(StaticFunction)` if the function instructions
+/// are known at compile-time;
+/// `static_function` should be overriden to a `Some(StaticFunction)` if the function
+/// is overriden.
+///
+/// It is not possible to populate `static_function` in a `const` context, hence the existence
+/// of the `maybe_populate` field.
 #[derive(Clone)]
 pub struct MaybeStaticFunction {
     pub static_function: Option<StaticFunction>,
@@ -46,8 +56,10 @@ impl StaticFunctionRegistry {
     pub fn finish(
         self,
         functions: &mut FunctionSection,
+        exports: &mut ExportSection,
         codes: &mut CodeSection,
         type_registry: &TypeRegistry,
+        imported_func_count: u32,
     ) -> HQResult<()> {
         for (
             _name,
@@ -62,6 +74,7 @@ impl StaticFunctionRegistry {
                 params,
                 returns,
                 locals,
+                export,
             }) = static_function.map_or_else(maybe_populate, Some)
             else {
                 hq_bug!(
@@ -76,6 +89,13 @@ impl StaticFunctionRegistry {
                 func.instruction(&instruction);
             }
             codes.function(&func);
+            if let Some(export_name) = export {
+                exports.export(
+                    &export_name,
+                    ExportKind::Func,
+                    imported_func_count + functions.len() - 1,
+                );
+            }
         }
         Ok(())
     }
@@ -92,6 +112,48 @@ pub mod static_functions {
     use crate::prelude::*;
     use crate::wasm::{f32_to_ieeef32, mem_layout};
 
+    /// Mark a waiting flag as done.
+    ///
+    /// This is designed to be exported (as `"mark_waiting_flag"`) and called by JS.
+    ///
+    /// Takes 1 parameter:
+    /// - A nonnull struct with a single i8 field.
+    ///
+    /// Override with one u32, the single-field i8 struct type index
+    pub struct MarkWaitingFlag;
+    impl NamedRegistryItem<MaybeStaticFunction> for MarkWaitingFlag {
+        const VALUE: MaybeStaticFunction = MaybeStaticFunction {
+            static_function: None,
+            maybe_populate: || None,
+        };
+    }
+    pub type MarkWaitingFlagOverride = u32;
+    impl NamedRegistryItemOverride<MaybeStaticFunction, MarkWaitingFlagOverride> for MarkWaitingFlag {
+        fn r#override(i8_struct_ty: u32) -> MaybeStaticFunction {
+            MaybeStaticFunction {
+                static_function: Some(StaticFunction {
+                    export: Some("mark_waiting_flag".into()),
+                    instructions: Box::from(wasm_const![
+                        LocalGet(0),
+                        I32Const(1),
+                        StructSet {
+                            struct_type_index: i8_struct_ty,
+                            field_index: 0
+                        },
+                        End,
+                    ] as &[_]),
+                    params: Box::new([ValType::Ref(RefType {
+                        nullable: false,
+                        heap_type: HeapType::Concrete(i8_struct_ty),
+                    })]),
+                    returns: Box::new([]),
+                    locals: Box::new([]),
+                }),
+                maybe_populate: || None,
+            }
+        }
+    }
+
     /// Spawns a new thread in the same stack (i.e. a thread that yields back to the current
     /// thread once it completes.)
     ///
@@ -100,6 +162,13 @@ pub mod static_functions {
     /// - step funcref - the step to spawn
     /// - structref - the structref to pass to the step being spawned
     /// - step funcref - the step to return to after
+    ///
+    /// Override with:
+    /// - u32 - the index of the step func type
+    /// - u32 - the index of the stack struct type
+    /// - u32 - the index of the stack array type
+    /// - u32 - the index of the thread struct type
+    /// - u32 - the index of the threads table
     pub struct SpawnThreadInStack;
     impl NamedRegistryItem<MaybeStaticFunction> for SpawnThreadInStack {
         const VALUE: MaybeStaticFunction = MaybeStaticFunction {
@@ -116,6 +185,7 @@ pub mod static_functions {
         ) -> MaybeStaticFunction {
             MaybeStaticFunction {
                 static_function: Some(StaticFunction {
+                    export: None,
                     instructions: Box::from(wasm_const![
                         LocalGet(1),
                         LocalGet(2),
@@ -204,6 +274,19 @@ pub mod static_functions {
         }
     }
 
+    /// Spawn a new thread with the provided step function. This does not call it
+    /// immediately, instead leaving that for the scheduler or calling function to do so.
+    ///
+    /// Takes 2 parameters:
+    /// - step funcref - the step to spawn
+    /// - ref null struct - the stack struct to spawn it with
+    ///
+    /// Override with:
+    /// - u32 - the index of the step func type
+    /// - u32 - the index of the stack struct type
+    /// - u32 - the index of the stack array type
+    /// - u32 - the index of the thread struct type
+    /// - u32 - the index of the threads table
     pub struct SpawnNewThread;
     impl NamedRegistryItem<MaybeStaticFunction> for SpawnNewThread {
         const VALUE: MaybeStaticFunction = MaybeStaticFunction {
@@ -218,6 +301,7 @@ pub mod static_functions {
         ) -> MaybeStaticFunction {
             MaybeStaticFunction {
                 static_function: Some(StaticFunction {
+                    export: None,
                     params: Box::from([
                         ValType::Ref(RefType {
                             nullable: false,
@@ -275,12 +359,18 @@ pub mod static_functions {
         VAL_F
     }
 
+    /// Updates the stored RGBA pen colour from the HSV colour.
+    ///
+    /// Takes 1 paramter, an i32 corresponding to the target index
+    ///
+    /// Not overridable.
     pub struct UpdatePenColorFromHSV;
     impl NamedRegistryItem<MaybeStaticFunction> for UpdatePenColorFromHSV {
         const VALUE: MaybeStaticFunction = MaybeStaticFunction {
             static_function: None,
             maybe_populate: || {
                 Some(StaticFunction {
+                    export: None,
                     params: Box::from([ValType::I32]),
                     returns: Box::from([]),
                     locals: Box::from({
@@ -548,12 +638,18 @@ pub mod static_functions {
         HUE SAT
     }
 
+    /// Updates the stored HSV pen colour from the RGBA colour.
+    ///
+    /// Takes one parameter, an i32 corresponding to the target index.
+    ///
+    /// Not overridable.
     pub struct UpdatePenColorFromRGB;
     impl NamedRegistryItem<MaybeStaticFunction> for UpdatePenColorFromRGB {
         const VALUE: MaybeStaticFunction = MaybeStaticFunction {
             static_function: None,
             maybe_populate: || {
                 Some(StaticFunction {
+                    export: None,
                     params: Box::from([ValType::I32]),
                     returns: Box::from([]),
                     locals: Box::from({
diff --git a/test/fixtures/execute/hq-52-nonyielding-nested-loop-compiles.sb3 b/test/fixtures/execute/hq-52-nonyielding-nested-loop-compiles.sb3
new file mode 100644
index 00000000..f9c352be
Binary files /dev/null and b/test/fixtures/execute/hq-52-nonyielding-nested-loop-compiles.sb3 differ
diff --git a/test/fixtures/execute/hq-53-warped-proc-after-loop-compiles.sb3 b/test/fixtures/execute/hq-53-warped-proc-after-loop-compiles.sb3
new file mode 100644
index 00000000..e8e05577
Binary files /dev/null and b/test/fixtures/execute/hq-53-warped-proc-after-loop-compiles.sb3 differ
diff --git a/test/integration/turbowarp-integration-execute.test.mjs b/test/integration/turbowarp-integration-execute.test.mjs
index 3bcd31ed..eed78fb7 100644
--- a/test/integration/turbowarp-integration-execute.test.mjs
+++ b/test/integration/turbowarp-integration-execute.test.mjs
@@ -15,7 +15,7 @@ import { describe, test } from "vitest";
 
 import { imports as baseImports } from "../../js/imports.ts";
 import { unpackProject } from "../../playground/lib/project-loader.js";
-import { instantiateProject } from "../../playground/lib/project-runner.js";
+import { ProjectRunner } from "../../playground/lib/project-runner.js";
 import { sb3_to_wasm, WasmFlags } from "../../js/compiler/hyperquark.js";
 import { WasmStringType } from "../../js/no-compiler/hyperquark";
 import { defaultSettings } from "../../playground/lib/settings.js";
@@ -172,7 +172,8 @@ describe("Integration tests", () => {
       // todo: run wasm-opt if specified in flags?
 
       // Run the project and once all threads are complete check the results.
-      const runner = await instantiateProject({
+      const runner = new ProjectRunner();
+      await runner.init({
         wasm_bytes: project_wasm.wasm_bytes,
         target_names: project_wasm.target_names,
         project_json,
@@ -190,9 +191,6 @@ describe("Integration tests", () => {
             },
           },
         ),
-        onTimeout: () => {
-          throw new Error(`Timeout waiting for threads to complete: ${uri}`);
-        },
         importOverrides: {
           looks: {
             say_string: (string) => reportVmResult(string),
@@ -201,6 +199,10 @@ describe("Integration tests", () => {
         makeRenderer: makeTestRenderer,
       });
 
+      runner.addEventListener("timeout", () => {
+        throw new Error(`Timeout waiting for threads to complete: ${uri}`);
+      });
+
       runner.flag_clicked();
 
       await runner.run();
diff --git a/vite.config.js b/vite.config.js
index 02db40a6..bcf7a42e 100644
--- a/vite.config.js
+++ b/vite.config.js
@@ -18,6 +18,10 @@ export default defineConfig({
       },
     }),
   ],
+  worker: {
+    format: "es",
+    plugins: [wasm()],
+  },
   resolve: {
     alias: {
       "@": fileURLToPath(new URL("./playground", import.meta.url)),