diff --git a/.env.example b/.env.example
index d496c03..dd986f0 100644
--- a/.env.example
+++ b/.env.example
@@ -1,19 +1,19 @@
-# Optional CIRCT runtime overrides.
+# Optional MOX runtime overrides.
 # Tool artifacts:
-VITE_CIRCT_VERILOG_JS_URL=/circt/circt-verilog.js
-VITE_CIRCT_VERILOG_WASM_URL=/circt/circt-verilog.wasm
-VITE_CIRCT_SIM_JS_URL=/circt/circt-sim.js
-VITE_CIRCT_SIM_WASM_URL=/circt/circt-sim.wasm
-VITE_CIRCT_BMC_JS_URL=/circt/circt-bmc.js
-VITE_CIRCT_BMC_WASM_URL=/circt/circt-bmc.wasm
-# VPI-capable circt-sim (for cocotb lessons — built with Asyncify + VPI exports):
-VITE_CIRCT_SIM_VPI_JS_URL=/circt/circt-sim-vpi.js
-VITE_CIRCT_SIM_VPI_WASM_URL=/circt/circt-sim-vpi.wasm
+VITE_MOX_VERILOG_JS_URL=/mox/mox-verilog.js
+VITE_MOX_VERILOG_WASM_URL=/mox/mox-verilog.wasm
+VITE_MOX_SIM_JS_URL=/mox/mox-sim.js
+VITE_MOX_SIM_WASM_URL=/mox/mox-sim.wasm
+VITE_MOX_BMC_JS_URL=/mox/mox-bmc.js
+VITE_MOX_BMC_WASM_URL=/mox/mox-bmc.wasm
+# VPI-capable mox-sim (for cocotb lessons — built with Asyncify + VPI exports):
+VITE_MOX_SIM_VPI_JS_URL=/mox/mox-sim-vpi.js
+VITE_MOX_SIM_VPI_WASM_URL=/mox/mox-sim-vpi.wasm
 # Pyodide URL (used by cocotb runner). Default is local: /pyodide/pyodide.js
 # Optional CDN override:
 # VITE_PYODIDE_URL=https://cdn.jsdelivr.net/pyodide/v0.27.0/full/pyodide.js
 #
 # Optional args for each stage (JSON array preferred):
-# VITE_CIRCT_VERILOG_ARGS=[\"--ir-llhd\",\"--timescale\",\"1ns/1ns\",\"--single-unit\"]
-# VITE_CIRCT_SIM_ARGS=[\"--resource-guard=false\"]
-# VITE_CIRCT_BMC_ARGS=[\"--resource-guard=false\",\"-b\",\"3\",\"--module\",\"{top}\",\"--emit-smtlib\",\"-o\",\"-\",\"{input}\"]
+# VITE_MOX_VERILOG_ARGS=[\"--ir-llhd\",\"--timescale\",\"1ns/1ns\",\"--single-unit\"]
+# VITE_MOX_SIM_ARGS=[\"--resource-guard=false\"]
+# VITE_MOX_BMC_ARGS=[\"--resource-guard=false\",\"-b\",\"3\",\"--module\",\"{top}\",\"--emit-smtlib\",\"-o\",\"-\",\"{input}\"]
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index f9f3849..17eaed2 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -36,24 +36,24 @@ jobs:
       - name: Setup Pyodide assets
         run: scripts/setup-pyodide.sh
 
-      - name: Download CIRCT wasm artifacts
-        # WASM artifacts are built locally and published to the circt-wasm release
-        # via: npm run build:circt && npm run publish:circt
+      - name: Download MOX wasm artifacts
+        # WASM artifacts are built locally and published to the mox-wasm release
+        # via: npm run build:mox && npm run publish:mox
         # CI just downloads the pre-built artifacts — no Emscripten build here.
         run: |
-          mkdir -p static/circt
-          if gh release download circt-wasm \
+          mkdir -p static/mox
+          if gh release download mox-wasm \
                --repo "$GITHUB_REPOSITORY" \
-               -D static/circt \
+               -D static/mox \
                --clobber 2>/dev/null; then
-            if [ -f static/circt/uvm-core.tar.gz ]; then
-              rm -rf static/circt/uvm-core
-              tar -xzf static/circt/uvm-core.tar.gz -C static/circt
+            if [ -f static/mox/uvm-core.tar.gz ]; then
+              rm -rf static/mox/uvm-core
+              tar -xzf static/mox/uvm-core.tar.gz -C static/mox
             fi
-            echo "CIRCT artifacts downloaded"
-            ls -lh static/circt/*.js
+            echo "MOX artifacts downloaded"
+            ls -lh static/mox/*.js
           else
-            echo "::warning::No circt-wasm release found — WASM smoke tests will be skipped"
+            echo "::warning::No mox-wasm release found — WASM smoke tests will be skipped"
           fi
         env:
           GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
diff --git a/.github/workflows/deploy.yml b/.github/workflows/deploy.yml
index ebcd6f0..4d85a22 100644
--- a/.github/workflows/deploy.yml
+++ b/.github/workflows/deploy.yml
@@ -39,44 +39,48 @@ jobs:
       - name: Download Pyodide assets
         run: scripts/setup-pyodide.sh
 
-      - name: Download CIRCT wasm artifacts
-        # Artifacts are stored in a GitHub Release named 'circt-wasm'.
+      - name: Download MOX wasm artifacts
+        # Artifacts are stored in a GitHub Release named 'mox-wasm'.
         # To publish them locally, run:
-        #   gh release create circt-wasm --title "CIRCT WASM artifacts" \
-        #     static/circt/circt-{bmc,sim,sim-vpi,verilog,lec}.{js,wasm} \
+        #   gh release create mox-wasm --title "MOX WASM artifacts" \
+        #     static/mox/mox-{bmc,sim,sim-vpi,verilog,lec}.{js,wasm} \
         #     /tmp/uvm-core.tar.gz
         # where /tmp/uvm-core.tar.gz is created by:
-        #   tar -czf /tmp/uvm-core.tar.gz -C static/circt uvm-core
+        #   tar -czf /tmp/uvm-core.tar.gz -C static/mox uvm-core
         # The build proceeds without them; simulation features will be
         # unavailable but the rest of the tutorial still works.
         run: |
-          mkdir -p static/circt
+          mkdir -p static/mox
 
           unpack_uvm_bundle_if_present() {
-            if [ -f static/circt/uvm-core.tar.gz ]; then
-              rm -rf static/circt/uvm-core
-              tar -xzf static/circt/uvm-core.tar.gz -C static/circt
+            # Match uvm-core.tar.gz as well as older mis-named bundles such as
+            # uvm-core.XXXXXX.tar.gz (a past mktemp-template bug), newest first.
+            local bundle
+            bundle="$(ls -t static/mox/uvm-core*.tar.gz 2>/dev/null | head -1)"
+            if [ -n "$bundle" ]; then
+              rm -rf static/mox/uvm-core
+              tar -xzf "$bundle" -C static/mox
             fi
           }
 
           have_uvm_bundle() {
-            [ -f static/circt/uvm-core/uvm-manifest.json ]
+            [ -f static/mox/uvm-core/uvm-manifest.json ]
           }
 
-          if gh release download circt-wasm \
+          if gh release download mox-wasm \
                --repo "$GITHUB_REPOSITORY" \
-               -D static/circt \
+               -D static/mox \
                --clobber 2>/dev/null; then
             unpack_uvm_bundle_if_present
-            echo "CIRCT artifacts downloaded from release 'circt-wasm'"
-            ls -lh static/circt/
+            echo "MOX artifacts downloaded from release 'mox-wasm'"
+            ls -lh static/mox/
             if have_uvm_bundle; then
               echo "UVM runtime bundle found"
             else
               echo "::notice::UVM runtime bundle missing (uvm-manifest.json not found); UVM lessons may fail."
             fi
           else
-            echo "::notice::No 'circt-wasm' release found; simulation features will be unavailable."
+            echo "::notice::No 'mox-wasm' release found; simulation features will be unavailable."
           fi
         env:
           GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
diff --git a/.github/workflows/e2e-waveform.yml b/.github/workflows/e2e-waveform.yml
index 1594ff9..540e20a 100644
--- a/.github/workflows/e2e-waveform.yml
+++ b/.github/workflows/e2e-waveform.yml
@@ -34,16 +34,16 @@ jobs:
       - name: Prepare Surfer assets
         run: scripts/setup-surfer.sh
 
-      - name: Ensure CIRCT wasm artifacts
-        id: circt_artifacts
+      - name: Ensure MOX wasm artifacts
+        id: mox_artifacts
         run: |
-          mkdir -p static/circt
+          mkdir -p static/mox
 
           have_all_artifacts() {
-            [ -f static/circt/circt-verilog.js ] && \
-            [ -f static/circt/circt-verilog.wasm ] && \
-            [ -f static/circt/circt-sim.js ] && \
-            [ -f static/circt/circt-sim.wasm ]
+            [ -f static/mox/mox-verilog.js ] && \
+            [ -f static/mox/mox-verilog.wasm ] && \
+            [ -f static/mox/mox-sim.js ] && \
+            [ -f static/mox/mox-sim.wasm ]
           }
 
           if have_all_artifacts; then
@@ -51,10 +51,10 @@ jobs:
             exit 0
           fi
 
-          echo "Local CIRCT wasm artifacts missing; trying release 'circt-wasm'..."
-          if gh release download circt-wasm \
+          echo "Local MOX wasm artifacts missing; trying release 'mox-wasm'..."
+          if gh release download mox-wasm \
                --repo "$GITHUB_REPOSITORY" \
-               -D static/circt \
+               -D static/mox \
                --clobber 2>/dev/null; then
             if have_all_artifacts; then
               echo "ready=true" >> "$GITHUB_OUTPUT"
@@ -63,28 +63,28 @@ jobs:
           fi
 
           echo "ready=false" >> "$GITHUB_OUTPUT"
-          echo "::notice::Skipping waveform E2E: CIRCT wasm artifacts are missing (expected under static/circt or release circt-wasm)."
+          echo "::notice::Skipping waveform E2E: MOX wasm artifacts are missing (expected under static/mox or release mox-wasm)."
         env:
           GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
 
       - name: Build app
-        if: steps.circt_artifacts.outputs.ready == 'true'
+        if: steps.mox_artifacts.outputs.ready == 'true'
         run: npm run build
 
       - name: Run unit tests
-        if: steps.circt_artifacts.outputs.ready == 'true'
+        if: steps.mox_artifacts.outputs.ready == 'true'
         run: npm test
 
       - name: Install Playwright browser
-        if: steps.circt_artifacts.outputs.ready == 'true'
+        if: steps.mox_artifacts.outputs.ready == 'true'
         run: npx playwright install --with-deps chromium
 
       - name: Run waveform E2E
-        if: steps.circt_artifacts.outputs.ready == 'true'
+        if: steps.mox_artifacts.outputs.ready == 'true'
         run: npm run test:e2e -- e2e/waveform.spec.js
 
       - name: Upload Playwright artifacts
-        if: always() && steps.circt_artifacts.outputs.ready == 'true'
+        if: always() && steps.mox_artifacts.outputs.ready == 'true'
         uses: actions/upload-artifact@v4
         with:
           name: playwright-waveform-${{ github.run_id }}
diff --git a/.github/workflows/uvm-nightly.yml b/.github/workflows/uvm-nightly.yml
index 4eb2a9a..edd868c 100644
--- a/.github/workflows/uvm-nightly.yml
+++ b/.github/workflows/uvm-nightly.yml
@@ -36,37 +36,37 @@ jobs:
       - name: Prepare Pyodide assets
         run: scripts/setup-pyodide.sh
 
-      - name: Download CIRCT wasm artifacts
+      - name: Download MOX wasm artifacts
         env:
           GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
         run: |
-          mkdir -p static/circt
+          mkdir -p static/mox
 
           unpack_uvm_bundle_if_present() {
-            if [ -f static/circt/uvm-core.tar.gz ]; then
-              rm -rf static/circt/uvm-core
-              tar -xzf static/circt/uvm-core.tar.gz -C static/circt
+            if [ -f static/mox/uvm-core.tar.gz ]; then
+              rm -rf static/mox/uvm-core
+              tar -xzf static/mox/uvm-core.tar.gz -C static/mox
             fi
           }
 
           have_all_artifacts() {
-            [ -f static/circt/circt-verilog.js ] && \
-            [ -f static/circt/circt-verilog.wasm ] && \
-            [ -f static/circt/circt-sim.js ] && \
-            [ -f static/circt/circt-sim.wasm ] && \
-            [ -f static/circt/uvm-core/uvm-manifest.json ]
+            [ -f static/mox/mox-verilog.js ] && \
+            [ -f static/mox/mox-verilog.wasm ] && \
+            [ -f static/mox/mox-sim.js ] && \
+            [ -f static/mox/mox-sim.wasm ] && \
+            [ -f static/mox/uvm-core/uvm-manifest.json ]
           }
 
           if ! have_all_artifacts; then
-            gh release download circt-wasm \
+            gh release download mox-wasm \
               --repo "$GITHUB_REPOSITORY" \
-              -D static/circt \
+              -D static/mox \
               --clobber
             unpack_uvm_bundle_if_present
           fi
 
           if ! have_all_artifacts; then
-            echo "::error::CIRCT wasm artifacts are missing after release download."
+            echo "::error::MOX wasm artifacts are missing after release download."
             exit 1
           fi
 
diff --git a/.gitignore b/.gitignore
index 60ff93e..7aa2136 100644
--- a/.gitignore
+++ b/.gitignore
@@ -11,7 +11,7 @@ build.bak.*
 *.swp
 
 # Downloaded/built artifacts (run scripts/setup-*.sh to populate)
-static/circt/
+static/mox/
 static/surfer/
 static/pyodide/
 
diff --git a/AGENT.md b/AGENT.md
index 24c9013..2e2bace 100644
--- a/AGENT.md
+++ b/AGENT.md
@@ -8,7 +8,7 @@
 
 ## Resource Safety
 
-- Treat `ninja`, `circt-sim`, large link steps, and similarly heavy tools as high-risk for local system stability.
+- Treat `ninja`, `mox-sim`, large link steps, and similarly heavy tools as high-risk for local system stability.
 - Always run heavy commands with explicit resource limits (for example: CPU parallelism limits, memory caps, and wall-clock timeouts).
 - Prefer incremental/targeted builds over whole-tree builds when possible.
 - Avoid running multiple heavy builds concurrently.
diff --git a/CLAUDE.md b/CLAUDE.md
index 4cd4311..22a2ec4 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -10,8 +10,8 @@ npm run dev          # Start dev server (Vite)
 npm run build        # Production build
 npm run preview      # Preview production build
 
-scripts/setup-circt.sh          # Clone/update the CIRCT fork into vendor/circt
-scripts/setup-circt.sh <dir>    # Clone into a custom directory
+scripts/setup-mox.sh          # Clone/update the MOX fork into vendor/mox
+scripts/setup-mox.sh <dir>    # Clone into a custom directory
 
 scripts/setup-surfer.sh         # Download Surfer waveform viewer web build into public/surfer
 scripts/setup-surfer.sh <dir>   # Download into a custom directory
@@ -38,41 +38,41 @@ All state lives in the single root component. Key derived values:
 - `completed = filesEqual(workspace, solutionFiles)` — drives the "solve"/"reset" toggle
 - Lesson navigation mutates `lessonIndex`; reactive blocks reset `workspace`, `logs`, and `lastWaveform` on lesson change
 
-### CIRCT WASM Runtime (`src/runtime/`)
+### MOX WASM Runtime (`src/runtime/`)
 
 Two files handle the runtime bridge:
 
-**`circt-config.js`** — reads Vite env vars and resolves runtime configuration:
-- `VITE_CIRCT_WASM_JS_URL` / `VITE_CIRCT_WASM_JS_URLS` — JS artifact URL(s) (comma-separated for fallback)
-- `VITE_CIRCT_WASM_URL` / `VITE_CIRCT_WASM_URLS` — WASM artifact URL(s)
-- `VITE_CIRCT_FACTORY_NAME` — optional Emscripten factory function name
-- `VITE_CIRCT_TOOL_ARGS` — args for `run` (JSON array preferred, space-split fallback)
-- `VITE_CIRCT_SELF_CHECK_ARGS` — args for the self-check smoke test
-- Default JS candidates: `/circt/circt.js`, `/circt/circt-bmc.js`
-- Default WASM candidates: `/circt/circt.wasm`, `/circt/circt-bmc.wasm`
+**`mox-config.js`** — reads Vite env vars and resolves runtime configuration:
+- `VITE_MOX_WASM_JS_URL` / `VITE_MOX_WASM_JS_URLS` — JS artifact URL(s) (comma-separated for fallback)
+- `VITE_MOX_WASM_URL` / `VITE_MOX_WASM_URLS` — WASM artifact URL(s)
+- `VITE_MOX_FACTORY_NAME` — optional Emscripten factory function name
+- `VITE_MOX_TOOL_ARGS` — args for `run` (JSON array preferred, space-split fallback)
+- `VITE_MOX_SELF_CHECK_ARGS` — args for the self-check smoke test
+- Default JS candidates: `/mox/mox.js`, `/mox/mox-bmc.js`
+- Default WASM candidates: `/mox/mox.wasm`, `/mox/mox-bmc.wasm`
 
-**`circt-adapter.js`** — `CirctWasmAdapter` class, lazy-initialized on first `run()` or `selfCheck()`:
+**`mox-adapter.js`** — `MoxWasmAdapter` class, lazy-initialized on first `run()` or `selfCheck()`:
 - Tries each JS candidate URL in order until one loads successfully
 - Detects runtime mode automatically:
-  - **`custom-runtime`**: `window.CIRCT_WASM_RUNTIME` global exposes `{ init, run, selfCheck? }`
-  - **`emscripten-module`**: raw Emscripten output; looks for factory functions (`createCirctBmcModule`, `createModule`, `Module`) then falls back to `window.Module`
+  - **`custom-runtime`**: `window.MOX_WASM_RUNTIME` global exposes `{ init, run, selfCheck? }`
+  - **`emscripten-module`**: raw Emscripten output; looks for factory functions (`createMoxBmcModule`, `createModule`, `Module`) then falls back to `window.Module`
 - In Emscripten mode, files are written into the module's virtual FS under `/workspace/`, and output waveform is read back from `/workspace/out/waves.vcd`
 - Arg templates support `{top}`, `{input}`, `{waveform}` placeholders
 
-### CIRCT WASM Artifacts
+### MOX WASM Artifacts
 
-Place built artifacts from the CIRCT fork (`git@github.com:thomasnormal/circt.git`) at:
-- `public/circt/circt-bmc.js` + `public/circt/circt-bmc.wasm`
-- or custom shim: `public/circt/circt.js` + `public/circt/circt.wasm`
+Place built artifacts from the MOX fork (`git@github.com:normal-computing/mox.git`) at:
+- `public/mox/mox-bmc.js` + `public/mox/mox-bmc.wasm`
+- or custom shim: `public/mox/mox.js` + `public/mox/mox.wasm`
 
-Without these files, the runtime will fail gracefully with a log message directing you to run `scripts/setup-circt.sh`.
+Without these files, the runtime will fail gracefully with a log message directing you to run `scripts/setup-mox.sh`.
 
 ### Surfer Waveform Viewer (`src/lib/components/WaveformViewer.svelte`)
 
 The waveform pane embeds [Surfer](https://surfer-project.org/) via an `<iframe src="/surfer/">`.
 
 - Surfer must be self-hosted (same origin) so that blob URLs created from in-memory VCD data are fetchable by the iframe.
-- When CIRCT produces a VCD string (`lastWaveform.text`), the component creates a `Blob` → `URL.createObjectURL` and sends `{ command: 'LoadUrl', url }` via `postMessage` with progressive retries (0 / 800 / 2200 / 4500 ms) to absorb Surfer's WASM initialization time.
+- When MOX produces a VCD string (`lastWaveform.text`), the component creates a `Blob` → `URL.createObjectURL` and sends `{ command: 'LoadUrl', url }` via `postMessage` with progressive retries (0 / 800 / 2200 / 4500 ms) to absorb Surfer's WASM initialization time.
 - If `/surfer/index.html` is not found (HEAD 404), the component shows a prompt to run `scripts/setup-surfer.sh`.
 
 Install artifacts:
diff --git a/CURRICULUM.md b/CURRICULUM.md
index a922268..94da5bd 100644
--- a/CURRICULUM.md
+++ b/CURRICULUM.md
@@ -122,7 +122,7 @@ Flag numbers identify the weak dimension(s): 1=Concept Focus, 2=Starter Calibrat
 | Slug | Title | Status | Score | Prereqs | Teaches |
 |---|---|---|---|---|---|
 | `sva/implication` | Implication: \|->, \|=> | ✅ | 23/27 ⚠️5,8,9 | `sva/sequence-basics` | `\|->` (overlapping), `\|=>` (non-overlapping), antecedent/consequent |
-| `sva/formal-intro` | Bounded Model Checking | ✅ | 22/27 ⚠️2,4,5,9 | `sva/implication` | BMC, `circt-bmc`, exhaustive proof vs simulation, bounded depth |
+| `sva/formal-intro` | Bounded Model Checking | ✅ | 22/27 ⚠️2,4,5,9 | `sva/implication` | BMC, `mox-bmc`, exhaustive proof vs simulation, bounded depth |
 
 ### Chapter: Core Sequences
 | Slug | Title | Status | Score | Prereqs | Teaches |
@@ -193,7 +193,7 @@ Flag numbers identify the weak dimension(s): 1=Concept Focus, 2=Starter Calibrat
 > match — unlike `|->` / `|=>` which pass vacuously.
 > Exercise: compare the two forms on a burst read; observe the `#=#`
 > failure when the burst never occurs vs the `|=>` silent pass.
-> *Requires circt-bmc for the formal comparison half.*
+> *Requires mox-bmc for the formal comparison half.*
 
 ---
 
diff --git a/README.md b/README.md
index d54db85..f64494e 100644
--- a/README.md
+++ b/README.md
@@ -8,8 +8,8 @@ Pinned versions are centralized in `scripts/toolchain.lock.sh`:
 
 - Node major: `22`
 - Emscripten (emsdk): `4.0.21`
-- CIRCT repo: `https://github.com/thomasnormal/circt.git`
-- CIRCT ref: `8e8ca87dcda1c8abd47103ae7789c8ed261d5de3`
+- MOX repo: `https://github.com/normal-computing/mox.git`
+- MOX ref: `8e8ca87dcda1c8abd47103ae7789c8ed261d5de3`
 - LLVM submodule ref: `972cd847efb20661ea7ee8982dd19730aa040c75`
 
 Host tools:
@@ -38,24 +38,24 @@ Equivalent step-by-step:
 1. `npm ci`
 2. `scripts/setup-surfer.sh`
 3. `npm run setup:pyodide`
-4. `npm run setup:circt`
-5. `npm run build:circt`
-6. `npm run local-publish:circt`
+4. `npm run setup:mox`
+5. `npm run build:mox`
+6. `npm run local-publish:mox`
 7. `npm run build`
 
-The CIRCT wasm build script enforces conservative resource limits by default:
+The MOX wasm build script enforces conservative resource limits by default:
 
-- Ninja parallelism: `CIRCT_WASM_JOBS=4`
-- Configure timeout: `CIRCT_WASM_CONFIGURE_TIMEOUT_MIN=30`
-- Build timeout: `CIRCT_WASM_BUILD_TIMEOUT_MIN=120`
-- Force clean build dir first: `CIRCT_WASM_CLEAN_BUILD=1`
-- Build targets override: `CIRCT_WASM_TARGETS="circt-verilog circt-sim circt-bmc"`
-- Optional virtual memory cap: `CIRCT_WASM_MEMORY_LIMIT_KB=<kb>`
+- Ninja parallelism: `MOX_WASM_JOBS=4`
+- Configure timeout: `MOX_WASM_CONFIGURE_TIMEOUT_MIN=30`
+- Build timeout: `MOX_WASM_BUILD_TIMEOUT_MIN=120`
+- Force clean build dir first: `MOX_WASM_CLEAN_BUILD=1`
+- Build targets override: `MOX_WASM_TARGETS="mox-verilog mox-sim mox-bmc"`
+- Optional virtual memory cap: `MOX_WASM_MEMORY_LIMIT_KB=<kb>`
 
-To also build `circt-sim-vpi` (required for cocotb lessons):
+To also build `mox-sim-vpi` (required for cocotb lessons):
 
 ```
-CIRCT_WASM_TARGETS="circt-verilog circt-sim circt-bmc circt-sim-vpi" npm run build:circt
+MOX_WASM_TARGETS="mox-verilog mox-sim mox-bmc mox-sim-vpi" npm run build:mox
 ```
 
 ## Scripts
@@ -64,27 +64,27 @@ CIRCT_WASM_TARGETS="circt-verilog circt-sim circt-bmc circt-sim-vpi" npm run bui
 - `npm run preview`
 - `npm run test:e2e`
 - `npm run setup:pyodide`
-- `npm run setup:circt`
-- `npm run build:circt`
-- `npm run local-publish:circt`
+- `npm run setup:mox`
+- `npm run build:mox`
+- `npm run local-publish:mox`
 - `npm run bootstrap:repro`
 
 ## Optional Runtime Overrides
 
 In `.env` (copy `.env.example`):
 
-- `VITE_CIRCT_VERILOG_JS_URL`
-- `VITE_CIRCT_VERILOG_WASM_URL`
-- `VITE_CIRCT_SIM_JS_URL`
-- `VITE_CIRCT_SIM_WASM_URL`
-- `VITE_CIRCT_BMC_JS_URL`
-- `VITE_CIRCT_BMC_WASM_URL`
-- `VITE_CIRCT_SIM_VPI_JS_URL` (cocotb lessons)
-- `VITE_CIRCT_SIM_VPI_WASM_URL` (cocotb lessons)
+- `VITE_MOX_VERILOG_JS_URL`
+- `VITE_MOX_VERILOG_WASM_URL`
+- `VITE_MOX_SIM_JS_URL`
+- `VITE_MOX_SIM_WASM_URL`
+- `VITE_MOX_BMC_JS_URL`
+- `VITE_MOX_BMC_WASM_URL`
+- `VITE_MOX_SIM_VPI_JS_URL` (cocotb lessons)
+- `VITE_MOX_SIM_VPI_WASM_URL` (cocotb lessons)
 - `VITE_PYODIDE_URL` (cocotb lessons, default: `/pyodide/pyodide.js`)
-- `VITE_CIRCT_VERILOG_ARGS`
-- `VITE_CIRCT_SIM_ARGS`
-- `VITE_CIRCT_BMC_ARGS`
+- `VITE_MOX_VERILOG_ARGS`
+- `VITE_MOX_SIM_ARGS`
+- `VITE_MOX_BMC_ARGS`
 
 ## Offline Mode
 
@@ -92,13 +92,13 @@ In `.env` (copy `.env.example`):
 - The header includes a "Download offline bundle" button that prefetches and caches runtime assets for offline use.
 - For local/offline cocotb, install Pyodide assets once:
   - `npm run setup:pyodide`
-- Keep runtime URLs same-origin (default `/circt/*`, `/z3/*`, `/surfer/*`, `/pyodide/*`) for robust offline behavior.
+- Keep runtime URLs same-origin (default `/mox/*`, `/z3/*`, `/surfer/*`, `/pyodide/*`) for robust offline behavior.
 
 ## Runtime Notes
 
 - Runtime uses a real 2-stage wasm toolchain by default:
-  - `circt-verilog` lowers SV/SVA/UVM source to MLIR
-  - `circt-sim` executes lowered MLIR and emits VCD for the waveform pane
+  - `mox-verilog` lowers SV/SVA/UVM source to MLIR
+  - `mox-sim` executes lowered MLIR and emits VCD for the waveform pane
 - Tool invocations run in isolated Web Workers to avoid global Emscripten symbol collisions and re-entry issues.
 - UI includes a `self-check` action in the Runtime panel to validate artifact compatibility.
 - Waves tab appears automatically only when a valid VCD is generated.
@@ -110,14 +110,14 @@ In `.env` (copy `.env.example`):
   2. install emsdk 4.0.21
   3. run `scripts/setup-surfer.sh`
   4. run `scripts/setup-pyodide.sh`
-  5. run `scripts/setup-circt.sh` (pinned CIRCT ref)
-  6. run `scripts/build-circt-wasm.sh`
-  7. run `npm run local-publish:circt`
+  5. run `scripts/setup-mox.sh` (pinned MOX ref)
+  6. run `scripts/build-mox-wasm.sh`
+  7. run `npm run local-publish:mox`
   8. run `npm run build`
 
 ## E2E
 
 - `npm run test:e2e -- e2e/waveform.spec.js`
 - Includes:
-  - non-mock pipeline check (`circt-verilog` + `circt-sim`, waveform generated)
+  - non-mock pipeline check (`mox-verilog` + `mox-sim`, waveform generated)
   - Surfer waveform render check when browser WebGL support is available in the test environment
diff --git a/docs/circt-bugs/bug-automatic-task-outer-interface-mlir-region-isolation.md b/docs/mox-bugs/bug-automatic-task-outer-interface-mlir-region-isolation.md
similarity index 100%
rename from docs/circt-bugs/bug-automatic-task-outer-interface-mlir-region-isolation.md
rename to docs/mox-bugs/bug-automatic-task-outer-interface-mlir-region-isolation.md
diff --git a/docs/circt-bugs/bug-bits-hierarchical-parameterized-port.md b/docs/mox-bugs/bug-bits-hierarchical-parameterized-port.md
similarity index 100%
rename from docs/circt-bugs/bug-bits-hierarchical-parameterized-port.md
rename to docs/mox-bugs/bug-bits-hierarchical-parameterized-port.md
diff --git a/docs/circt-bugs/bug-circt-sim-global-state-not-reset-between-callmain.md b/docs/mox-bugs/bug-mox-sim-global-state-not-reset-between-callmain.md
similarity index 100%
rename from docs/circt-bugs/bug-circt-sim-global-state-not-reset-between-callmain.md
rename to docs/mox-bugs/bug-mox-sim-global-state-not-reset-between-callmain.md
diff --git a/docs/circt-bugs/bug-uvm-constraint-mode-unimplemented.md b/docs/mox-bugs/bug-uvm-constraint-mode-unimplemented.md
similarity index 100%
rename from docs/circt-bugs/bug-uvm-constraint-mode-unimplemented.md
rename to docs/mox-bugs/bug-uvm-constraint-mode-unimplemented.md
diff --git a/docs/circt-bugs/bug-uvm-phase-cleanup-hangs-and-factory-override.md b/docs/mox-bugs/bug-uvm-phase-cleanup-hangs-and-factory-override.md
similarity index 100%
rename from docs/circt-bugs/bug-uvm-phase-cleanup-hangs-and-factory-override.md
rename to docs/mox-bugs/bug-uvm-phase-cleanup-hangs-and-factory-override.md
diff --git a/docs/circt-bugs/bug-virtual-if-in-class-method-mlir-region-isolation.md b/docs/mox-bugs/bug-virtual-if-in-class-method-mlir-region-isolation.md
similarity index 100%
rename from docs/circt-bugs/bug-virtual-if-in-class-method-mlir-region-isolation.md
rename to docs/mox-bugs/bug-virtual-if-in-class-method-mlir-region-isolation.md
diff --git a/docs/circt-upstream-ready-bug-report.md b/docs/mox-upstream-ready-bug-report.md
similarity index 69%
rename from docs/circt-upstream-ready-bug-report.md
rename to docs/mox-upstream-ready-bug-report.md
index 851f0a6..5062e30 100644
--- a/docs/circt-upstream-ready-bug-report.md
+++ b/docs/mox-upstream-ready-bug-report.md
@@ -1,26 +1,26 @@
-# Bug Report: `circt-verilog.wasm` aborts on full UVM in browser-like runtime
+# Bug Report: `mox-verilog.wasm` aborts on full UVM in browser-like runtime
 
 ## Title
-`circt-verilog.wasm` aborts compiling full `uvm_pkg` with:
+`mox-verilog.wasm` aborts compiling full `uvm_pkg` with:
 `Malformed attribute storage object` (MLIR `AttributeSupport.h:177`)
 
 ## Date
 February 24, 2026
 
 ## Revisions
-- CIRCT fork: `thomasnormal/circt`
-- CIRCT commit: `20fa81a69add402715db28203335596192ce7c39`
+- MOX fork: `normal-computing/mox`
+- MOX commit: `20fa81a69add402715db28203335596192ce7c39`
 - LLVM submodule: `972cd847efb20661ea7ee8982dd19730aa040c75`
 
 ## Why this report
-This is a clean CIRCT-only repro (no `sv-tutorial` runtime dependency). It reproduces using only CIRCT wasm artifacts + UVM sources from the CIRCT tree.
+This is a clean MOX-only repro (no `sv-tutorial` runtime dependency). It reproduces using only MOX wasm artifacts + UVM sources from the MOX tree.
 
 ## Repro (standalone, browser-like wasm path)
 
 ### Preconditions
-From CIRCT repo root:
-- `build-wasm/bin/circt-verilog.js`
-- `build-wasm/bin/circt-verilog.wasm`
+From MOX repo root:
+- `build-wasm/bin/mox-verilog.js`
+- `build-wasm/bin/mox-verilog.wasm`
 - `lib/Runtime/uvm-core/src/uvm_pkg.sv`
 
 If needed for the browser harness:
@@ -38,7 +38,7 @@ node utils/repro_wasm_uvm_browser_assert.mjs
 ```
 
 ## Expected
-`circt-verilog.wasm` lowers minimal UVM test to MLIR (or emits a normal diagnostic), without aborting.
+`mox-verilog.wasm` lowers minimal UVM test to MLIR (or emits a normal diagnostic), without aborting.
 
 ## Actual
 The run aborts before output MLIR is produced.
@@ -56,9 +56,9 @@ Representative log excerpt:
 ```text
 RuntimeError: Aborted(Assertion failed: abstractAttribute && "Malformed attribute storage object.", at: .../mlir/include/mlir/IR/AttributeSupport.h,177,getAbstractAttribute)
 
-../circt/uvm-core/src/base/uvm_config_db_implementation.svh:375:26: warning: unknown character escape sequence '\.' [-Wunknown-escape-code]
-../circt/uvm-core/src/uvm_pkg.sv:57:2: note: included from here
-../circt/uvm-core/src/base/uvm_base.svh:77:3: note: included from here
+../mox/uvm-core/src/base/uvm_config_db_implementation.svh:375:26: warning: unknown character escape sequence '\.' [-Wunknown-escape-code]
+../mox/uvm-core/src/uvm_pkg.sv:57:2: note: included from here
+../mox/uvm-core/src/base/uvm_base.svh:77:3: note: included from here
 
 Aborted(Assertion failed: abstractAttribute && "Malformed attribute storage object.", ...)
 ```
diff --git a/docs/circt-uvm-browser-worker-repro.md b/docs/mox-uvm-browser-worker-repro.md
similarity index 68%
rename from docs/circt-uvm-browser-worker-repro.md
rename to docs/mox-uvm-browser-worker-repro.md
index 1274a3c..dc97400 100644
--- a/docs/circt-uvm-browser-worker-repro.md
+++ b/docs/mox-uvm-browser-worker-repro.md
@@ -1,16 +1,16 @@
 # Browser-Worker UVM Repro (`Malformed attribute storage object`)
 
-This reproduces the CIRCT wasm UVM failure in the **browser worker** path
+This reproduces the MOX wasm UVM failure in the **browser worker** path
 without using lesson UI clicks.
 
 ## Preconditions
 
-1. `vendor/circt` is checked out and wasm artifacts are built.
-2. Artifacts are synced into `public/circt`:
+1. `vendor/mox` is checked out and wasm artifacts are built.
+2. Artifacts are synced into `public/mox`:
 
 ```bash
-scripts/setup-circt.sh
-npm run local-publish:circt
+scripts/setup-mox.sh
+npm run local-publish:mox
 ```
 
 ## Repro command
@@ -30,11 +30,11 @@ REPRO_BASE_URL=http://127.0.0.1:4174 node scripts/repro-uvm-browser-worker-asser
 
 - starts Vite dev server on `http://127.0.0.1:43173` (`--strictPort`)
 - opens Chromium headless via Playwright
-- imports `createCirctWasmAdapter` from `/src/runtime/circt-adapter.js`
+- imports `createMoxWasmAdapter` from `/src/runtime/mox-adapter.js`
 - runs compile-only (`simulate: false`) on minimal UVM files:
   - `/src/my_test.sv`
   - `/src/tb_top.sv`
-- uses full UVM path (`--uvm-path /circt/uvm-core -I /circt/uvm-core/src`)
+- uses full UVM path (`--uvm-path /mox/uvm-core -I /mox/uvm-core/src`)
 
 ## Expected failure signature
 
@@ -42,7 +42,7 @@ REPRO_BASE_URL=http://127.0.0.1:4174 node scripts/repro-uvm-browser-worker-asser
 - logs include both:
   - `Aborted(`
   - `Malformed attribute storage object`
-- logs do **not** reach `$ circt-sim`
+- logs do **not** reach `$ mox-sim`
 
 If this signature appears, the script exits `0` and prints:
 
diff --git a/docs/circt-uvm-wasm-bug-report.md b/docs/mox-uvm-wasm-bug-report.md
similarity index 69%
rename from docs/circt-uvm-wasm-bug-report.md
rename to docs/mox-uvm-wasm-bug-report.md
index a021191..53dbb4c 100644
--- a/docs/circt-uvm-wasm-bug-report.md
+++ b/docs/mox-uvm-wasm-bug-report.md
@@ -1,16 +1,16 @@
-# circt-verilog.wasm aborts compiling full UVM (`uvm_pkg`)
+# mox-verilog.wasm aborts compiling full UVM (`uvm_pkg`)
 
 ## Title
-`circt-verilog.wasm` aborts compiling full UVM (`uvm_pkg`) with MLIR assert (`Malformed attribute storage object`)
+`mox-verilog.wasm` aborts compiling full UVM (`uvm_pkg`) with MLIR assert (`Malformed attribute storage object`)
 
-## CIRCT Revision
-- Fork: `thomasnormal/circt`
-- CIRCT commit tested: `0246e937a9e11f602c85a80dc2fcb2c69c5e5a84`
+## MOX Revision
+- Fork: `normal-computing/mox`
+- MOX commit tested: `0246e937a9e11f602c85a80dc2fcb2c69c5e5a84`
 - LLVM submodule: `972cd847efb20661ea7ee8982dd19730aa040c75`
 - Date observed: `2026-02-24`
 
 ## Environment
-- wasm build artifacts: `circt-verilog.js` + `circt-verilog.wasm`
+- wasm build artifacts: `mox-verilog.js` + `mox-verilog.wasm`
 - Browser worker execution (NODERAWFS-style, in-memory FS)
 - UVM sources loaded from `uvm-core/src` via manifest
 
@@ -19,8 +19,8 @@
 Command run in app logs:
 
 ```sh
-circt-verilog --resource-guard=false --ir-llhd --timescale 1ns/1ns \
-  --uvm-path /circt/uvm-core -I /circt/uvm-core/src \
+mox-verilog --resource-guard=false --ir-llhd --timescale 1ns/1ns \
+  --uvm-path /mox/uvm-core -I /mox/uvm-core/src \
   --top tb_top -o /workspace/out/design.llhd.mlir /workspace/src/tb_top.sv
 ```
 
@@ -30,8 +30,8 @@ Standalone browser-worker repro in this repo:
 node scripts/repro-uvm-browser-worker-assert.mjs
 ```
 
-This launches a headless Chromium page, imports `createCirctWasmAdapter` from
-`/src/runtime/circt-adapter.js`, runs compile-only (`simulate: false`) on a
+This launches a headless Chromium page, imports `createMoxWasmAdapter` from
+`/src/runtime/mox-adapter.js`, runs compile-only (`simulate: false`) on a
 minimal `tb_top + my_test` UVM input, and reproduces the same assert.
 
 `tb_top.sv`:
@@ -63,12 +63,12 @@ endclass
 ```
 
 ## Actual Result
-- `circt-verilog` aborts before producing MLIR.
+- `mox-verilog` aborts before producing MLIR.
 - Warning emitted first:
   - `uvm_config_db_implementation.svh:375:26: warning: unknown character escape sequence '\.'`
 - Then hard abort:
   - `Aborted(Assertion failed: abstractAttribute && "Malformed attribute storage object.", ... mlir/IR/AttributeSupport.h:177, getAbstractAttribute)`
-- Stack includes wasm frames inside `circt-verilog.wasm`.
+- Stack includes wasm frames inside `mox-verilog.wasm`.
 
 ## Expected Result
 - Successful lowering to LLHD MLIR for UVM input, or at minimum a graceful user-facing diagnostic (not assert/abort).
diff --git a/e2e/cocotb.spec.js b/e2e/cocotb.spec.js
index 997184d..172e010 100644
--- a/e2e/cocotb.spec.js
+++ b/e2e/cocotb.spec.js
@@ -1,5 +1,5 @@
 /**
- * E2E tests for the cocotb runner (circt-verilog → circt-sim + Pyodide).
+ * E2E tests for the cocotb runner (mox-verilog → mox-sim + Pyodide).
  */
 import { test, expect } from '@playwright/test';
 
@@ -32,7 +32,7 @@ test('cocotb: Your First cocotb Test — solution passes all assertions', async
   const logs = page.getByTestId('runtime-logs');
   await expect(logs).toContainText('$ python /workspace/src/test_adder.py', { timeout: 180_000 });
   await expect(logs).toContainText('PASS', { timeout: 180_000 });
-  await expect(logs).toContainText('[circt-sim] Simulation completed', { timeout: 180_000 });
+  await expect(logs).toContainText('[mox-sim] Simulation completed', { timeout: 180_000 });
   await expect(logs).not.toContainText('AssertionError');
   await expect(logs).not.toContainText("Failed to execute 'importScripts'");
   await expect(logs).not.toContainText('is invalid');
@@ -47,7 +47,7 @@ test('cocotb: Clock and Timing — solution passes all assertions', async ({ pag
   const logs = page.getByTestId('runtime-logs');
   await expect(logs).toContainText('$ python /workspace/src/test_counter.py', { timeout: 180_000 });
   await expect(logs).toContainText('PASS', { timeout: 180_000 });
-  await expect(logs).toContainText('[circt-sim] Simulation completed', { timeout: 180_000 });
+  await expect(logs).toContainText('[mox-sim] Simulation completed', { timeout: 180_000 });
   await expect(logs).not.toContainText('AssertionError');
   await expect(logs).not.toContainText("Failed to execute 'importScripts'");
   await expect(logs).not.toContainText('is invalid');
diff --git a/e2e/formal.spec.js b/e2e/formal.spec.js
index d1d36bb..40c773c 100644
--- a/e2e/formal.spec.js
+++ b/e2e/formal.spec.js
@@ -28,10 +28,10 @@ test('BMC: starter code has no assertion → verify does not prove anything', as
   await page.getByTestId('verify-button').click();
 
   const logs = page.getByTestId('runtime-logs');
-  await expect(logs).toContainText('$ circt-verilog', { timeout: 120_000 });
-  await expect(logs).toContainText('$ circt-bmc', { timeout: 120_000 });
+  await expect(logs).toContainText('$ mox-verilog', { timeout: 120_000 });
+  await expect(logs).toContainText('$ mox-bmc', { timeout: 120_000 });
   // No assertion in the module → bmc may exit with 0 but won't say "proved"
-  await expect(logs).not.toContainText('# circt-verilog exit code: 1');
+  await expect(logs).not.toContainText('# mox-verilog exit code: 1');
 });
 
 test('BMC: solution proves all properties within the bound', async ({ page }) => {
@@ -41,11 +41,11 @@ test('BMC: solution proves all properties within the bound', async ({ page }) =>
   await page.getByTestId('verify-button').click();
 
   const logs = page.getByTestId('runtime-logs');
-  await expect(logs).toContainText('$ circt-verilog', { timeout: 120_000 });
-  await expect(logs).toContainText('$ circt-bmc', { timeout: 120_000 });
+  await expect(logs).toContainText('$ mox-verilog', { timeout: 120_000 });
+  await expect(logs).toContainText('$ mox-bmc', { timeout: 120_000 });
   await expect(logs).toContainText('[z3] unsat', { timeout: 120_000 });
-  await expect(logs).not.toContainText('# circt-verilog exit code: 1');
-  await expect(logs).not.toContainText('# circt-bmc exit code: 1');
+  await expect(logs).not.toContainText('# mox-verilog exit code: 1');
+  await expect(logs).not.toContainText('# mox-bmc exit code: 1');
 });
 
 test('BMC: shows only verify button, no run button', async ({ page }) => {
@@ -83,10 +83,10 @@ test('LEC: buggy Impl is detected as NOT equivalent', async ({ page }) => {
   await page.getByTestId('verify-button').click();
 
   const logs = page.getByTestId('runtime-logs');
-  await expect(logs).toContainText('$ circt-verilog', { timeout: 120_000 });
-  await expect(logs).toContainText('$ circt-lec', { timeout: 120_000 });
+  await expect(logs).toContainText('$ mox-verilog', { timeout: 120_000 });
+  await expect(logs).toContainText('$ mox-lec', { timeout: 120_000 });
   await expect(logs).toContainText('sat', { timeout: 120_000 });
-  await expect(logs).not.toContainText('# circt-verilog exit code: 1');
+  await expect(logs).not.toContainText('# mox-verilog exit code: 1');
 });
 
 test('LEC: fixed Impl is proved equivalent to Spec', async ({ page }) => {
@@ -97,6 +97,6 @@ test('LEC: fixed Impl is proved equivalent to Spec', async ({ page }) => {
 
   const logs = page.getByTestId('runtime-logs');
   await expect(logs).toContainText('unsat', { timeout: 120_000 });
-  await expect(logs).not.toContainText('# circt-verilog exit code: 1');
-  await expect(logs).not.toContainText('# circt-lec exit code: 1');
+  await expect(logs).not.toContainText('# mox-verilog exit code: 1');
+  await expect(logs).not.toContainText('# mox-lec exit code: 1');
 });
diff --git a/e2e/ghpages.spec.js b/e2e/ghpages.spec.js
index 188c715..3eb8bdb 100644
--- a/e2e/ghpages.spec.js
+++ b/e2e/ghpages.spec.js
@@ -23,17 +23,17 @@ async function applySolution(page) {
 }
 
 async function expectCleanUvmRun(logs) {
-  await expect(logs).toContainText('$ circt-verilog', { timeout: 45_000 });
-  await expect(logs).toContainText('--uvm-path /circt/uvm-core', { timeout: 10_000 });
+  await expect(logs).toContainText('$ mox-verilog', { timeout: 45_000 });
+  await expect(logs).toContainText('--uvm-path /mox/uvm-core', { timeout: 10_000 });
   await expect.poll(
     async () => (await logs.textContent()) ?? '',
     { timeout: 60_000, intervals: [500, 1000] }
-  ).toMatch(/\$ circt-sim|runtime unavailable|# circt-verilog exit code: 1/);
+  ).toMatch(/\$ mox-sim|runtime unavailable|# mox-verilog exit code: 1/);
 
   const text = await logs.textContent();
-  expect(text).toContain('$ circt-sim');
-  expect(text).not.toContain('# circt-verilog exit code: 1');
-  expect(text).not.toContain('# circt-sim exit code: 1');
+  expect(text).toContain('$ mox-sim');
+  expect(text).not.toContain('# mox-verilog exit code: 1');
+  expect(text).not.toContain('# mox-sim exit code: 1');
   expect(text).not.toContain('runtime unavailable');
 }
 
diff --git a/e2e/lessons.spec.js b/e2e/lessons.spec.js
index 4e2d435..1917f35 100644
--- a/e2e/lessons.spec.js
+++ b/e2e/lessons.spec.js
@@ -1,6 +1,6 @@
 /**
  * Smoke tests for a representative sample of lessons across all parts.
- * Each test applies the solution and runs it, verifying that the CIRCT
+ * Each test applies the solution and runs it, verifying that the MOX
  * pipeline completes without errors.
  */
 import { test, expect } from '@playwright/test';
@@ -67,8 +67,8 @@ test('Welcome: run outputs Hello World', async ({ page }) => {
   await page.getByTestId('run-button').click();
 
   const logs = page.getByTestId('runtime-logs');
-  await expect(logs).toContainText('$ circt-verilog', { timeout: 120_000 });
-  await expect(logs).toContainText('$ circt-sim', { timeout: 120_000 });
+  await expect(logs).toContainText('$ mox-verilog', { timeout: 120_000 });
+  await expect(logs).toContainText('$ mox-sim', { timeout: 120_000 });
   await expectInterpretMode(logs);
   await expect(logs).not.toContainText('exit code: 1');
 });
@@ -80,8 +80,8 @@ test('Up-Counter: solution simulates and produces a waveform', async ({ page })
   await page.getByTestId('run-button').click();
 
   const logs = page.getByTestId('runtime-logs');
-  await expect(logs).toContainText('$ circt-verilog', { timeout: 120_000 });
-  await expect(logs).toContainText('$ circt-sim', { timeout: 120_000 });
+  await expect(logs).toContainText('$ mox-verilog', { timeout: 120_000 });
+  await expect(logs).toContainText('$ mox-sim', { timeout: 120_000 });
   await expectInterpretMode(logs);
   await expect(page.getByTestId('runtime-tab-waves')).toBeVisible({ timeout: 120_000 });
   await expect(logs).not.toContainText('exit code: 1');
@@ -107,7 +107,7 @@ test('Modules and Ports: waveform renders after solve and run', async ({ page })
   await page.getByTestId('run-button').click();
 
   const logs = page.getByTestId('runtime-logs');
-  await expect(logs).toContainText('$ circt-sim', { timeout: 120_000 });
+  await expect(logs).toContainText('$ mox-sim', { timeout: 120_000 });
   await expect(logs).not.toContainText('exit code: 1');
 
   // Waves tab must appear and clicking it must show rendered waveform data.
@@ -127,7 +127,7 @@ test('immediate-assert: solution passes assertions', async ({ page }) => {
   await page.getByTestId('verify-button').click();
 
   const logs = page.getByTestId('runtime-logs');
-  await expect(logs).toContainText('$ circt-bmc', { timeout: 120_000 });
+  await expect(logs).toContainText('$ mox-bmc', { timeout: 120_000 });
   await expect(logs).not.toContainText('exit code: 1');
 });
 
@@ -138,6 +138,6 @@ test('sequence-basics: solution runs without errors', async ({ page }) => {
   await page.getByTestId('verify-button').click();
 
   const logs = page.getByTestId('runtime-logs');
-  await expect(logs).toContainText('$ circt-bmc', { timeout: 120_000 });
+  await expect(logs).toContainText('$ mox-bmc', { timeout: 120_000 });
   await expect(logs).not.toContainText('exit code: 1');
 });
diff --git a/e2e/live-smoke.spec.js b/e2e/live-smoke.spec.js
index 45566cb..422caa5 100644
--- a/e2e/live-smoke.spec.js
+++ b/e2e/live-smoke.spec.js
@@ -39,7 +39,7 @@ test('[sim] Welcome — run button produces output, no compile error', async ({
   await page.getByTestId('solve-button').click();
   await page.getByTestId('run-button').click();
   const logs = page.getByTestId('runtime-logs');
-  await expect(logs).not.toContainText('# circt-verilog exit code: 1', { timeout: COMPILE_TIMEOUT });
+  await expect(logs).not.toContainText('# mox-verilog exit code: 1', { timeout: COMPILE_TIMEOUT });
 });
 
 test('[sim] Concurrent Assertions — runtime assertions chapter visible, assertionFail produced', async ({ page }) => {
@@ -48,7 +48,7 @@ test('[sim] Concurrent Assertions — runtime assertions chapter visible, assert
   await page.getByTestId('solve-button').click();
   await page.getByTestId('run-button').click();
   const logs = page.getByTestId('runtime-logs');
-  await expect(logs).not.toContainText('# circt-verilog exit code: 1', { timeout: COMPILE_TIMEOUT });
+  await expect(logs).not.toContainText('# mox-verilog exit code: 1', { timeout: COMPILE_TIMEOUT });
   await expect(logs).toContainText('SVA assertion failed', { timeout: COMPILE_TIMEOUT });
 });
 
@@ -58,8 +58,8 @@ test('[bmc] Immediate Assertions — verify runs z3', async ({ page }) => {
   await page.getByTestId('solve-button').click();
   await page.getByTestId('verify-button').click();
   const logs = page.getByTestId('runtime-logs');
-  await expect(logs).not.toContainText('# circt-verilog exit code: 1', { timeout: COMPILE_TIMEOUT });
-  await expect(logs).not.toContainText('# circt-bmc exit code: 1', { timeout: COMPILE_TIMEOUT });
+  await expect(logs).not.toContainText('# mox-verilog exit code: 1', { timeout: COMPILE_TIMEOUT });
+  await expect(logs).not.toContainText('# mox-bmc exit code: 1', { timeout: COMPILE_TIMEOUT });
   await expect(logs).toContainText('[z3]', { timeout: Z3_TIMEOUT });
 });
 
@@ -69,8 +69,8 @@ test('[bmc] Implication — verify runs z3', async ({ page }) => {
   await page.getByTestId('solve-button').click();
   await page.getByTestId('verify-button').click();
   const logs = page.getByTestId('runtime-logs');
-  await expect(logs).not.toContainText('# circt-verilog exit code: 1', { timeout: COMPILE_TIMEOUT });
-  await expect(logs).not.toContainText('# circt-bmc exit code: 1', { timeout: COMPILE_TIMEOUT });
+  await expect(logs).not.toContainText('# mox-verilog exit code: 1', { timeout: COMPILE_TIMEOUT });
+  await expect(logs).not.toContainText('# mox-bmc exit code: 1', { timeout: COMPILE_TIMEOUT });
   await expect(logs).toContainText('[z3]', { timeout: Z3_TIMEOUT });
 });
 
@@ -80,7 +80,7 @@ test('[lec] Logical Equivalence Checking — z3 proves unsat', async ({ page })
   await page.getByTestId('solve-button').click();
   await page.getByTestId('verify-button').click();
   const logs = page.getByTestId('runtime-logs');
-  await expect(logs).not.toContainText('# circt-verilog exit code: 1', { timeout: COMPILE_TIMEOUT });
-  await expect(logs).not.toContainText('# circt-lec exit code: 1', { timeout: COMPILE_TIMEOUT });
+  await expect(logs).not.toContainText('# mox-verilog exit code: 1', { timeout: COMPILE_TIMEOUT });
+  await expect(logs).not.toContainText('# mox-lec exit code: 1', { timeout: COMPILE_TIMEOUT });
   await expect(logs).toContainText('[z3] unsat', { timeout: Z3_TIMEOUT });
 });
diff --git a/e2e/mlir-run.spec.js b/e2e/mlir-run.spec.js
index d7c9786..72b9e44 100644
--- a/e2e/mlir-run.spec.js
+++ b/e2e/mlir-run.spec.js
@@ -1,13 +1,13 @@
 import { test, expect } from '@playwright/test';
 
-test('MLIR intro: run executes via circt-sim without SV-source error', async ({ page }) => {
+test('MLIR intro: run executes via mox-sim without SV-source error', async ({ page }) => {
   await page.goto('/lesson/mlir/intro');
   await expect(page.getByTestId('lesson-title')).toHaveText('What is MLIR?');
 
   await page.getByTestId('run-button').click();
 
   const logs = page.getByTestId('runtime-logs');
-  await expect(logs).toContainText('$ circt-sim', { timeout: 120_000 });
+  await expect(logs).toContainText('$ mox-sim', { timeout: 120_000 });
   await expect(logs).toContainText('# using MLIR source: /src/adder.mlir', { timeout: 120_000 });
   await expect(logs).not.toContainText('# no SystemVerilog source files found in workspace');
   await expect(logs).not.toContainText('# no SystemVerilog or MLIR source files found in workspace');
diff --git a/e2e/offline-cocotb.spec.js b/e2e/offline-cocotb.spec.js
index 82a843f..7f3bc0c 100644
--- a/e2e/offline-cocotb.spec.js
+++ b/e2e/offline-cocotb.spec.js
@@ -49,9 +49,9 @@ test.describe('offline cocotb runtime', () => {
     await page.getByTestId('run-button').click();
 
     const logs = page.getByTestId('runtime-logs');
-    await expect(logs).toContainText('$ circt-verilog', { timeout: 240_000 });
+    await expect(logs).toContainText('$ mox-verilog', { timeout: 240_000 });
     await expect(logs).toContainText('$ python /workspace/src/test_adder.py', { timeout: 240_000 });
-    await expect(logs).toContainText('$ circt-sim', { timeout: 240_000 });
+    await expect(logs).toContainText('$ mox-sim', { timeout: 240_000 });
     await expect(logs).toContainText('PASS  adder_test', { timeout: 240_000 });
     await expect(logs).not.toContainText("Failed to execute 'importScripts'");
     await expect(logs).not.toContainText('is invalid');
diff --git a/e2e/qa-all-lessons.spec.js b/e2e/qa-all-lessons.spec.js
index f6a0276..cf880e2 100644
--- a/e2e/qa-all-lessons.spec.js
+++ b/e2e/qa-all-lessons.spec.js
@@ -101,14 +101,14 @@ for (const [index, lesson] of LESSONS.entries()) {
       await page.getByTestId('run-button').click();
       await expect(logs).not.toContainText('exit code: 1', { timeout: 120_000 });
       // Confirm a simulation tool actually executed
-      await expect(logs).toContainText('$ circt', { timeout: 120_000 });
+      await expect(logs).toContainText('$ mox', { timeout: 120_000 });
     }
 
     // Run formal / LEC (bmc / lec / both)
     if (lesson.runner === 'bmc' || lesson.runner === 'lec' || lesson.runner === 'both') {
       await page.getByTestId('verify-button').click();
       await expect(logs).not.toContainText('exit code: 1', { timeout: 120_000 });
-      await expect(logs).toContainText('$ circt', { timeout: 120_000 });
+      await expect(logs).toContainText('$ mox', { timeout: 120_000 });
     }
   });
 }
diff --git a/e2e/qa-ghpages.spec.js b/e2e/qa-ghpages.spec.js
index 8739316..f5ff25c 100644
--- a/e2e/qa-ghpages.spec.js
+++ b/e2e/qa-ghpages.spec.js
@@ -32,7 +32,7 @@ async function waitForSimStart(page, { timeout = 60_000 } = {}) {
   await expect.poll(
     async () => (await logs.textContent()) ?? '',
     { timeout, intervals: [500, 1000] }
-  ).toMatch(/\$ circt-sim|runtime unavailable|# circt-verilog exit code:/);
+  ).toMatch(/\$ mox-sim|runtime unavailable|# mox-verilog exit code:/);
 }
 
 /** Close the options menu by clicking the backdrop overlay. */
@@ -209,7 +209,7 @@ test('SV: welcome lesson compiles and prints Hello output', async ({ page }) =>
   await goTo(page, '/lesson/sv/welcome');
   await page.getByTestId('run-button').click();
   const logs = page.getByTestId('runtime-logs');
-  await expect(logs).toContainText('$ circt-verilog', { timeout: 45_000 });
+  await expect(logs).toContainText('$ mox-verilog', { timeout: 45_000 });
   await waitForRunDone(page);
   const text = await logs.textContent();
   expect(text).not.toContain('exit code: 1');
@@ -221,10 +221,10 @@ test('SV: always-ff solution compiles and simulates cleanly', async ({ page }) =
   await applySolution(page);
   await page.getByTestId('run-button').click();
   const logs = page.getByTestId('runtime-logs');
-  await expect(logs).toContainText('$ circt-verilog', { timeout: 45_000 });
+  await expect(logs).toContainText('$ mox-verilog', { timeout: 45_000 });
   await waitForRunDone(page, { timeout: 120_000 });
   const text = await logs.textContent();
-  expect(text).not.toContain('# circt-verilog exit code: 1');
+  expect(text).not.toContain('# mox-verilog exit code: 1');
   expect(text).not.toContain('runtime unavailable');
   expect(text).toContain('PASS');
 });
@@ -235,7 +235,7 @@ test('SV: starter code with TODO shows simulation failures', async ({ page }) =>
   // Starter always_ff body is incomplete — simulation should print FAIL lines
   await page.getByTestId('run-button').click();
   const logs = page.getByTestId('runtime-logs');
-  await expect(logs).toContainText('$ circt-verilog', { timeout: 45_000 });
+  await expect(logs).toContainText('$ mox-verilog', { timeout: 45_000 });
   await waitForRunDone(page, { timeout: 120_000 });
   const text = await logs.textContent();
   expect(text).toContain('FAIL');
@@ -245,7 +245,7 @@ test('Ctrl+Enter triggers run', async ({ page }) => {
   await goTo(page, '/lesson/sv/welcome');
   await page.keyboard.press('Control+Enter');
   const logs = page.getByTestId('runtime-logs');
-  await expect(logs).toContainText('$ circt-verilog', { timeout: 45_000 });
+  await expect(logs).toContainText('$ mox-verilog', { timeout: 45_000 });
 });
 
 test('SVA: concurrent simulation lesson runs cleanly', async ({ page }) => {
@@ -253,7 +253,7 @@ test('SVA: concurrent simulation lesson runs cleanly', async ({ page }) => {
   await applySolution(page);
   await page.getByTestId('run-button').click();
   const logs = page.getByTestId('runtime-logs');
-  await expect(logs).toContainText('$ circt-verilog', { timeout: 45_000 });
+  await expect(logs).toContainText('$ mox-verilog', { timeout: 45_000 });
   await waitForRunDone(page);
   const text = await logs.textContent();
   expect(text).not.toContain('runtime unavailable');
@@ -264,13 +264,13 @@ test('UVM: driver lesson compiles and simulates', async ({ page }) => {
   await applySolution(page);
   await page.getByTestId('run-button').click();
   const logs = page.getByTestId('runtime-logs');
-  await expect(logs).toContainText('$ circt-verilog', { timeout: 45_000 });
+  await expect(logs).toContainText('$ mox-verilog', { timeout: 45_000 });
   await expect.poll(
     async () => (await logs.textContent()) ?? '',
     { timeout: 90_000, intervals: [500, 1000] }
-  ).toMatch(/\$ circt-sim|runtime unavailable|# circt-verilog exit code: 1/);
+  ).toMatch(/\$ mox-sim|runtime unavailable|# mox-verilog exit code: 1/);
   const text = await logs.textContent();
-  expect(text).not.toContain('# circt-verilog exit code: 1');
+  expect(text).not.toContain('# mox-verilog exit code: 1');
   expect(text).not.toContain('runtime unavailable');
 });
 
@@ -334,7 +334,7 @@ test('vim mode: toggles on and off without breaking editor', async ({ page }) =>
   await closeOptionsMenu(page);
   // Run still works
   await page.getByTestId('run-button').click();
-  await expect(page.getByTestId('runtime-logs')).toContainText('$ circt-verilog', { timeout: 45_000 });
+  await expect(page.getByTestId('runtime-logs')).toContainText('$ mox-verilog', { timeout: 45_000 });
 });
 
 test('dark mode: toggle changes color scheme', async ({ page }) => {
diff --git a/e2e/solutions-live.spec.js b/e2e/solutions-live.spec.js
index 79f91da..f24dd38 100644
--- a/e2e/solutions-live.spec.js
+++ b/e2e/solutions-live.spec.js
@@ -31,7 +31,7 @@ const COMPILE_TIMEOUT = 90_000;
 const Z3_TIMEOUT      = 120_000;
 
 function assertNoCompileError(logs) {
-  return expect(logs).not.toContainText('# circt-verilog exit code: 1', { timeout: COMPILE_TIMEOUT });
+  return expect(logs).not.toContainText('# mox-verilog exit code: 1', { timeout: COMPILE_TIMEOUT });
 }
 
 // Selected lessons covering all runner types
@@ -62,13 +62,13 @@ for (const lesson of LESSONS) {
     if (lesson.runner === 'lec') {
       await page.getByTestId('verify-button').click();
       await assertNoCompileError(logs);
-      await expect(logs).not.toContainText('# circt-lec exit code: 1', { timeout: COMPILE_TIMEOUT });
+      await expect(logs).not.toContainText('# mox-lec exit code: 1', { timeout: COMPILE_TIMEOUT });
       await expect(logs).toContainText('[z3] unsat', { timeout: Z3_TIMEOUT });
 
     } else if (lesson.runner === 'bmc' || lesson.runner === 'both') {
       await page.getByTestId('verify-button').click();
       await assertNoCompileError(logs);
-      await expect(logs).not.toContainText('# circt-bmc exit code: 1', { timeout: COMPILE_TIMEOUT });
+      await expect(logs).not.toContainText('# mox-bmc exit code: 1', { timeout: COMPILE_TIMEOUT });
       await expect(logs).toContainText('[z3]', { timeout: Z3_TIMEOUT });
       if (lesson.expectUnsat) {
         await expect(logs).toContainText('[z3] unsat', { timeout: Z3_TIMEOUT });
diff --git a/e2e/solutions.spec.js b/e2e/solutions.spec.js
index c13fc16..7c263f9 100644
--- a/e2e/solutions.spec.js
+++ b/e2e/solutions.spec.js
@@ -12,7 +12,7 @@
  * expectUnsat: true  — additionally asserts [z3] unsat.
  *   Only set for lessons whose solution module has real design logic that
  *   enforces the properties (formal-intro counter, formal-assume FSM, lec
- *   equivalence check). These are the only cases where circt-bmc can prove
+ *   equivalence check). These are the only cases where mox-bmc can prove
  *   unsat because the design itself rules out counterexamples.
  *
  * expectUnsat: false — only checks that [z3] ran and exit codes are 0.
@@ -69,7 +69,7 @@ async function goToLesson(page, chapterName, lessonName) {
 // runner: 'lec' → logical equivalence check (verify button; expects [z3] unsat)
 // runner: 'cocotb' → cocotb Python tests (run/test button)
 //
-// expectUnsat: true  → module has design logic; circt-bmc should prove unsat.
+// expectUnsat: true  → module has design logic; mox-bmc should prove unsat.
 // expectUnsat: false → property-only module; [z3] sat is expected and OK.
 
 const LESSONS = [
@@ -145,7 +145,7 @@ const COMPILE_TIMEOUT = 90_000;
 const Z3_TIMEOUT      = 120_000;
 
 function assertNoCompileError(logs) {
-  return expect(logs).not.toContainText('# circt-verilog exit code: 1', { timeout: COMPILE_TIMEOUT });
+  return expect(logs).not.toContainText('# mox-verilog exit code: 1', { timeout: COMPILE_TIMEOUT });
 }
 
 // ── Tests ─────────────────────────────────────────────────────────────────────
@@ -163,13 +163,13 @@ for (const lesson of LESSONS) {
     if (lesson.runner === 'lec') {
       await page.getByTestId('verify-button').click();
       await assertNoCompileError(logs);
-      await expect(logs).not.toContainText('# circt-lec exit code: 1', { timeout: COMPILE_TIMEOUT });
+      await expect(logs).not.toContainText('# mox-lec exit code: 1', { timeout: COMPILE_TIMEOUT });
       await expect(logs).toContainText('unsat', { timeout: Z3_TIMEOUT });
 
     } else if (lesson.runner === 'bmc' || lesson.runner === 'both') {
       await page.getByTestId('verify-button').click();
       await assertNoCompileError(logs);
-      await expect(logs).not.toContainText('# circt-bmc exit code: 1', { timeout: COMPILE_TIMEOUT });
+      await expect(logs).not.toContainText('# mox-bmc exit code: 1', { timeout: COMPILE_TIMEOUT });
       await expect(logs).toContainText('[z3]', { timeout: Z3_TIMEOUT });
       if (lesson.expectUnsat) {
         await expect(logs).toContainText('[z3] unsat', { timeout: Z3_TIMEOUT });
diff --git a/e2e/uvm.spec.js b/e2e/uvm.spec.js
index 127f1e2..351a395 100644
--- a/e2e/uvm.spec.js
+++ b/e2e/uvm.spec.js
@@ -1,5 +1,5 @@
 /**
- * E2E tests for all UVM lessons (circt-verilog -> circt-sim with full UVM).
+ * E2E tests for all UVM lessons (mox-verilog -> mox-sim with full UVM).
  */
 import { test, expect } from '@playwright/test';
 
@@ -40,19 +40,19 @@ async function applySolution(page) {
 }
 
 async function expectCleanUvmRun(logs) {
-  await expect(logs).toContainText('$ circt-verilog', { timeout: 45_000 });
-  await expect(logs).toContainText('--uvm-path /circt/uvm-core', { timeout: 45_000 });
+  await expect(logs).toContainText('$ mox-verilog', { timeout: 45_000 });
+  await expect(logs).toContainText('--uvm-path /mox/uvm-core', { timeout: 45_000 });
   await expect.poll(
     async () => (await logs.textContent()) ?? '',
     { timeout: 45_000, intervals: [250, 500, 1000] }
-  ).toMatch(/\$ circt-sim|runtime unavailable|# circt-verilog exit code: 1/);
+  ).toMatch(/\$ mox-sim|runtime unavailable|# mox-verilog exit code: 1/);
 
   const text = (await logs.textContent()) ?? '';
-  expect(text).toContain('$ circt-sim');
+  expect(text).toContain('$ mox-sim');
   expect(text).toContain('--mode interpret');
   expect(text).not.toContain('--compiled');
-  expect(text).not.toContain('# circt-verilog exit code: 1');
-  expect(text).not.toContain('# circt-sim exit code: 1');
+  expect(text).not.toContain('# mox-verilog exit code: 1');
+  expect(text).not.toContain('# mox-sim exit code: 1');
   expect(text).not.toContain('runtime unavailable');
   expect(text).not.toContain('uvm-lite compatibility shim');
   expect(text).not.toContain("unknown package 'uvm_pkg'");
diff --git a/e2e/waveform.spec.js b/e2e/waveform.spec.js
index dc79b00..d9d665b 100644
--- a/e2e/waveform.spec.js
+++ b/e2e/waveform.spec.js
@@ -13,8 +13,8 @@ test('welcome lesson executes simulation output', async ({ page }) => {
 
   await page.getByTestId('run-button').click();
 
-  await expect(logs).toContainText('$ circt-verilog', { timeout: 120_000 });
-  await expect(logs).toContainText('$ circt-sim', { timeout: 120_000 });
+  await expect(logs).toContainText('$ mox-verilog', { timeout: 120_000 });
+  await expect(logs).toContainText('$ mox-sim', { timeout: 120_000 });
   await expectInterpretMode(logs);
   await expect(logs).not.toContainText('exit code: 0');
 });
@@ -35,12 +35,12 @@ async function runModulesAndPorts(page) {
   await page.getByTestId('solve-button').click();
   await page.getByTestId('run-button').click();
 
-  await expect(logs).toContainText('$ circt-verilog', { timeout: 120_000 });
-  await expect(logs).toContainText('$ circt-sim', { timeout: 120_000 });
+  await expect(logs).toContainText('$ mox-verilog', { timeout: 120_000 });
+  await expect(logs).toContainText('$ mox-sim', { timeout: 120_000 });
   await expectInterpretMode(logs);
   await expect(logs).not.toContainText('exit code: 0');
   await expect(page.getByTestId('runtime-tab-waves')).toBeVisible({ timeout: 120_000 });
-  await expect(logs).not.toContainText('[circt-mock]');
+  await expect(logs).not.toContainText('[mox-mock]');
 
   return { logs, consoleLines };
 }
@@ -248,9 +248,9 @@ test('concurrent-sim SVA assertion signal appears in VCD', async ({ page }) => {
   await page.getByTestId('run-button').click();
 
   // The testbench has a missing-grant scenario that fires the assertion.
-  // circt-sim exits with code 1 on assertion failure — that is expected and correct.
+  // mox-sim exits with code 1 on assertion failure — that is expected and correct.
   await expect(logs).toContainText('SVA assertion failed', { timeout: 90_000 });
-  await expect(logs).not.toContainText('# circt-verilog exit code: 1');
+  await expect(logs).not.toContainText('# mox-verilog exit code: 1');
 
   // The Waves tab should appear (VCD was produced).
   await expect(page.getByTestId('runtime-tab-waves')).toBeVisible();
diff --git a/package.json b/package.json
index 581c809..8fc6ffd 100644
--- a/package.json
+++ b/package.json
@@ -10,12 +10,12 @@
     "check:req": "./scripts/check-requirements.sh",
     "check:req:wasm": "./scripts/check-requirements.sh --with-wasm",
     "setup:pyodide": "./scripts/setup-pyodide.sh",
-    "setup:circt": "./scripts/setup-circt.sh",
-    "build:circt": "./scripts/build-circt-wasm.sh",
+    "setup:mox": "./scripts/setup-mox.sh",
+    "build:mox": "./scripts/build-mox-wasm.sh",
     "bootstrap:repro": "./scripts/bootstrap-repro.sh",
     "repro:vpi:node": "node scripts/repro-cocotb-vpi-put-value.mjs",
-    "local-publish:circt": "./scripts/sync-circt-wasm.sh",
-    "publish:circt": "./scripts/sync-circt-wasm.sh --publish",
+    "local-publish:mox": "./scripts/sync-mox-wasm.sh",
+    "publish:mox": "./scripts/sync-mox-wasm.sh --publish",
     "test": "vitest run",
     "test:e2e": "playwright test"
   },
diff --git a/scripts/bootstrap-repro.sh b/scripts/bootstrap-repro.sh
index 50d1d74..bd5a3ae 100755
--- a/scripts/bootstrap-repro.sh
+++ b/scripts/bootstrap-repro.sh
@@ -9,9 +9,9 @@ scripts/check-requirements.sh
 npm ci
 scripts/setup-surfer.sh
 scripts/setup-pyodide.sh
-scripts/setup-circt.sh
-scripts/build-circt-wasm.sh
-npm run local-publish:circt
+scripts/setup-mox.sh
+scripts/build-mox-wasm.sh
+npm run local-publish:mox
 npm run build
 
 echo "Bootstrap complete."
diff --git a/scripts/build-circt-wasm.sh b/scripts/build-circt-wasm.sh
deleted file mode 100755
index adbd8f8..0000000
--- a/scripts/build-circt-wasm.sh
+++ /dev/null
@@ -1,100 +0,0 @@
-#!/usr/bin/env bash
-set -euo pipefail
-
-ROOT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
-source "$ROOT_DIR/scripts/toolchain.lock.sh"
-
-CIRCT_DIR="${1:-vendor/circt}"
-BUILD_DIR="${BUILD_DIR:-$CIRCT_DIR/build-wasm}"
-JOBS="${CIRCT_WASM_JOBS:-4}"
-CONFIGURE_TIMEOUT_MIN="${CIRCT_WASM_CONFIGURE_TIMEOUT_MIN:-30}"
-BUILD_TIMEOUT_MIN="${CIRCT_WASM_BUILD_TIMEOUT_MIN:-120}"
-MEMORY_LIMIT_KB="${CIRCT_WASM_MEMORY_LIMIT_KB:-0}"
-SKIP_BUILD="${CIRCT_WASM_SKIP_BUILD:-0}"
-TARGETS_RAW="${CIRCT_WASM_TARGETS:-circt-verilog circt-sim circt-bmc}"
-CLEAN_BUILD="${CIRCT_WASM_CLEAN_BUILD:-0}"
-AUTO_RETRY_CLEAN="${CIRCT_WASM_AUTO_RETRY_CLEAN:-1}"
-
-if [[ ! "$JOBS" =~ ^[1-9][0-9]*$ ]]; then
-  echo "CIRCT_WASM_JOBS must be a positive integer (got $JOBS)" >&2
-  exit 1
-fi
-
-run_configure() {
-  echo "Configuring wasm build in $BUILD_DIR"
-  run_with_timeout "$CONFIGURE_TIMEOUT_MIN" \
-    nice -n 10 env BUILD_DIR="$BUILD_DIR" \
-    "$CIRCT_DIR/utils/configure_wasm_build.sh"
-}
-
-run_build() {
-  echo "Building targets: ${targets[*]} (jobs=$JOBS)"
-  run_with_timeout "$BUILD_TIMEOUT_MIN" \
-    nice -n 10 ninja -C "$BUILD_DIR" -j"$JOBS" "${targets[@]}"
-}
-
-run_with_timeout() {
-  local minutes="$1"
-  shift
-  if command -v timeout >/dev/null 2>&1; then
-    timeout --preserve-status "${minutes}m" "$@"
-    return
-  fi
-  if command -v gtimeout >/dev/null 2>&1; then
-    gtimeout --preserve-status "${minutes}m" "$@"
-    return
-  fi
-  echo "Warning: timeout/gtimeout not found; running without wall-clock guard." >&2
-  "$@"
-}
-
-if [[ "$MEMORY_LIMIT_KB" != "0" ]]; then
-  if ulimit -v "$MEMORY_LIMIT_KB" >/dev/null 2>&1; then
-    echo "Applied virtual memory limit: ${MEMORY_LIMIT_KB} KB"
-  else
-    echo "Warning: unable to apply ulimit -v=$MEMORY_LIMIT_KB on this shell/platform." >&2
-  fi
-fi
-
-STRICT_NODE_VERSION=0 "$ROOT_DIR/scripts/check-requirements.sh" --with-wasm
-
-if [[ ! -d "$CIRCT_DIR" ]]; then
-  echo "Missing CIRCT checkout: $CIRCT_DIR" >&2
-  echo "Run scripts/setup-circt.sh first." >&2
-  exit 1
-fi
-
-read -r -a targets <<< "$TARGETS_RAW"
-if ((${#targets[@]} == 0)); then
-  echo "CIRCT_WASM_TARGETS resolved to an empty target list." >&2
-  exit 1
-fi
-
-if [[ "$CLEAN_BUILD" == "1" && -d "$BUILD_DIR" ]]; then
-  echo "Cleaning build directory: $BUILD_DIR"
-  cmake -E rm -rf "$BUILD_DIR"
-fi
-
-run_configure
-
-if [[ "$SKIP_BUILD" == "1" ]]; then
-  echo "Skipping ninja build because CIRCT_WASM_SKIP_BUILD=1"
-  exit 0
-fi
-
-if ! run_build; then
-  if [[ "$AUTO_RETRY_CLEAN" == "1" && "$CLEAN_BUILD" != "1" ]]; then
-    echo "Initial build failed; retrying once from a clean build directory."
-    cmake -E rm -rf "$BUILD_DIR"
-    run_configure
-    run_build
-  else
-    exit 1
-  fi
-fi
-
-echo "Built CIRCT wasm artifacts in: $BUILD_DIR/bin"
-ls -lh \
-  "$BUILD_DIR/bin/circt-verilog.js" "$BUILD_DIR/bin/circt-verilog.wasm" \
-  "$BUILD_DIR/bin/circt-sim.js" "$BUILD_DIR/bin/circt-sim.wasm" \
-  "$BUILD_DIR/bin/circt-bmc.js" "$BUILD_DIR/bin/circt-bmc.wasm"
diff --git a/scripts/build-mox-wasm.sh b/scripts/build-mox-wasm.sh
new file mode 100755
index 0000000..61f7b4b
--- /dev/null
+++ b/scripts/build-mox-wasm.sh
@@ -0,0 +1,136 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+ROOT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
+source "$ROOT_DIR/scripts/toolchain.lock.sh"
+
+MOX_DIR="${1:-vendor/mox}"
+BUILD_DIR="${BUILD_DIR:-$MOX_DIR/build-wasm}"
+JOBS="${MOX_WASM_JOBS:-6}"
+CONFIGURE_TIMEOUT_MIN="${MOX_WASM_CONFIGURE_TIMEOUT_MIN:-30}"
+BUILD_TIMEOUT_MIN="${MOX_WASM_BUILD_TIMEOUT_MIN:-120}"
+MEMORY_LIMIT_KB="${MOX_WASM_MEMORY_LIMIT_KB:-0}"
+SKIP_BUILD="${MOX_WASM_SKIP_BUILD:-0}"
+# MOX_WASM_TARGETS — space-separated ninja targets to build. Set this to
+# narrow rebuilds when iterating on a single tool, e.g.:
+#   MOX_WASM_TARGETS=mox-sim scripts/build-mox-wasm.sh
+TARGETS_RAW="${MOX_WASM_TARGETS:-mox-verilog mox-sim mox-bmc mox-lec}"
+CLEAN_BUILD="${MOX_WASM_CLEAN_BUILD:-0}"
+AUTO_RETRY_CLEAN="${MOX_WASM_AUTO_RETRY_CLEAN:-1}"
+# Compiler launcher caches emcc invocations; ~5-10x speedup on incremental
+# rebuilds after warmup. Pass CCACHE=0 to disable.
+USE_CCACHE="${CCACHE:-1}"
+CCACHE_BIN="$(command -v ccache 2>/dev/null || true)"
+
+if [[ ! "$JOBS" =~ ^[1-9][0-9]*$ ]]; then
+  echo "MOX_WASM_JOBS must be a positive integer (got $JOBS)" >&2
+  exit 1
+fi
+
+run_configure() {
+  echo "Configuring wasm build in $BUILD_DIR"
+  # - Tcl bindings default ON in upstream CMakeLists.txt and require tcl.h,
+  #   which is not part of a typical wasm/emsdk toolchain. Not used by any
+  #   sv-tutorial lesson.
+  # - LLVM examples/benchmarks are not needed for our wasm targets; the
+  #   examples tree in the upstream fork is also missing
+  #   examples/Kaleidoscope/BuildingAJIT, so leaving them ON fails configure.
+  local extra_args=(
+    -DMOX_BINDINGS_TCL_ENABLED=OFF
+    -DLLVM_INCLUDE_EXAMPLES=OFF
+    -DLLVM_BUILD_EXAMPLES=OFF
+    -DLLVM_INCLUDE_BENCHMARKS=OFF
+    -DLLVM_BUILD_BENCHMARKS=OFF
+  )
+  if [[ "$USE_CCACHE" == "1" && -n "$CCACHE_BIN" ]]; then
+    echo "  using ccache launcher: $CCACHE_BIN"
+    # PCH compiles (~90% of LLVM/MOX cxx work) are uncacheable by default
+    # because ccache doesn't trust __DATE__/__TIME__/PCH mtimes. The
+    # sloppiness flags below let ccache cache them. CCACHE_BASEDIR rewrites
+    # absolute paths in compile commands to relative form so hits survive
+    # across worktrees and across configure runs that pick different build
+    # dirs.
+    export CCACHE_SLOPPINESS="${CCACHE_SLOPPINESS:-pch_defines,time_macros,include_file_mtime,include_file_ctime}"
+    export CCACHE_BASEDIR="${CCACHE_BASEDIR:-$HOME}"
+    extra_args+=(
+      "-DCMAKE_C_COMPILER_LAUNCHER=$CCACHE_BIN"
+      "-DCMAKE_CXX_COMPILER_LAUNCHER=$CCACHE_BIN"
+    )
+  fi
+  run_with_timeout "$CONFIGURE_TIMEOUT_MIN" \
+    nice -n 10 env BUILD_DIR="$BUILD_DIR" \
+    "$MOX_DIR/utils/configure_wasm_build.sh" \
+    "${extra_args[@]}"
+}
+
+run_build() {
+  echo "Building targets: ${targets[*]} (jobs=$JOBS)"
+  run_with_timeout "$BUILD_TIMEOUT_MIN" \
+    nice -n 10 ninja -C "$BUILD_DIR" -j"$JOBS" "${targets[@]}"
+}
+
+run_with_timeout() {
+  local minutes="$1"
+  shift
+  if command -v timeout >/dev/null 2>&1; then
+    timeout --preserve-status "${minutes}m" "$@"
+    return
+  fi
+  if command -v gtimeout >/dev/null 2>&1; then
+    gtimeout --preserve-status "${minutes}m" "$@"
+    return
+  fi
+  echo "Warning: timeout/gtimeout not found; running without wall-clock guard." >&2
+  "$@"
+}
+
+if [[ "$MEMORY_LIMIT_KB" != "0" ]]; then
+  if ulimit -v "$MEMORY_LIMIT_KB" >/dev/null 2>&1; then
+    echo "Applied virtual memory limit: ${MEMORY_LIMIT_KB} KB"
+  else
+    echo "Warning: unable to apply ulimit -v=$MEMORY_LIMIT_KB on this shell/platform." >&2
+  fi
+fi
+
+STRICT_NODE_VERSION=0 "$ROOT_DIR/scripts/check-requirements.sh" --with-wasm
+
+if [[ ! -d "$MOX_DIR" ]]; then
+  echo "Missing MOX checkout: $MOX_DIR" >&2
+  echo "Run scripts/setup-mox.sh first." >&2
+  exit 1
+fi
+
+read -r -a targets <<< "$TARGETS_RAW"
+if ((${#targets[@]} == 0)); then
+  echo "MOX_WASM_TARGETS resolved to an empty target list." >&2
+  exit 1
+fi
+
+if [[ "$CLEAN_BUILD" == "1" && -d "$BUILD_DIR" ]]; then
+  echo "Cleaning build directory: $BUILD_DIR"
+  cmake -E rm -rf "$BUILD_DIR"
+fi
+
+run_configure
+
+if [[ "$SKIP_BUILD" == "1" ]]; then
+  echo "Skipping ninja build because MOX_WASM_SKIP_BUILD=1"
+  exit 0
+fi
+
+if ! run_build; then
+  if [[ "$AUTO_RETRY_CLEAN" == "1" && "$CLEAN_BUILD" != "1" ]]; then
+    echo "Initial build failed; retrying once from a clean build directory."
+    cmake -E rm -rf "$BUILD_DIR"
+    run_configure
+    run_build
+  else
+    exit 1
+  fi
+fi
+
+echo "Built MOX wasm artifacts in: $BUILD_DIR/bin"
+ls -lh \
+  "$BUILD_DIR/bin/mox-verilog.js" "$BUILD_DIR/bin/mox-verilog.wasm" \
+  "$BUILD_DIR/bin/mox-sim.js" "$BUILD_DIR/bin/mox-sim.wasm" \
+  "$BUILD_DIR/bin/mox-bmc.js" "$BUILD_DIR/bin/mox-bmc.wasm"
diff --git a/scripts/check-circt-issues.sh b/scripts/check-mox-issues.sh
similarity index 91%
rename from scripts/check-circt-issues.sh
rename to scripts/check-mox-issues.sh
index f73a978..a20dce6 100755
--- a/scripts/check-circt-issues.sh
+++ b/scripts/check-mox-issues.sh
@@ -1,6 +1,6 @@
 #!/usr/bin/env bash
-# Polls thomasnormal/circt issues blocking tutorial lessons for state changes.
-# Usage: ./scripts/check-circt-issues.sh [--loop]
+# Polls normal-computing/mox issues blocking tutorial lessons for state changes.
+# Usage: ./scripts/check-mox-issues.sh [--loop]
 #   --loop  : run every 5 minutes until interrupted (default: check once)
 #
 # Tracked issues (open):
@@ -48,16 +48,16 @@
 
 set -uo pipefail
 
-BASELINE_FILE="${XDG_CACHE_HOME:-$HOME/.cache}/circt-issue-baseline.txt"
+BASELINE_FILE="${XDG_CACHE_HOME:-$HOME/.cache}/mox-issue-baseline.txt"
 
 fetch_state() {
-  gh api repos/thomasnormal/circt/issues \
+  gh api repos/normal-computing/mox/issues \
     --jq '.[] | select(.number | IN(14,20,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,59,61,64,65)) | "\(.number)|\(.state)|\(.comments)|\(.updated_at)"' \
     2>/dev/null | grep -v '^$' | sort -t'|' -k1,1n
 }
 
 print_issues() {
-  gh api repos/thomasnormal/circt/issues \
+  gh api repos/normal-computing/mox/issues \
     --jq '.[] | select(.number | IN(14,20,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,59,61,64,65)) | "#\(.number) [\(.state)] \(.title)  (comments:\(.comments), updated:\(.updated_at))"' \
     2>/dev/null | sort -t'#' -k2,2n
 }
@@ -66,7 +66,7 @@ check_once() {
   local current
   current=$(fetch_state)
 
-  echo "=== thomasnormal/circt open issues (blocking tutorial) ==="
+  echo "=== normal-computing/mox open issues (blocking tutorial) ==="
   print_issues
   echo
 
@@ -90,7 +90,7 @@ check_once() {
 }
 
 if [[ "${1:-}" == "--loop" ]]; then
-  echo "Monitoring circt issues #14,#20,#24-#52,#53,#59,#61,#64-#65 (every 5 min, Ctrl+C to stop)…"
+  echo "Monitoring mox issues #14,#20,#24-#52,#53,#59,#61,#64-#65 (every 5 min, Ctrl+C to stop)…"
   while true; do
     echo
     echo "[$(date '+%H:%M:%S')]"
diff --git a/scripts/repro-cocotb-vpi-put-value.mjs b/scripts/repro-cocotb-vpi-put-value.mjs
index f3cad4d..88ba873 100644
--- a/scripts/repro-cocotb-vpi-put-value.mjs
+++ b/scripts/repro-cocotb-vpi-put-value.mjs
@@ -18,10 +18,10 @@ import {
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 const ROOT = path.resolve(__dirname, '..');
-const CIRCT_DIR = path.join(ROOT, 'public', 'circt');
-const VERILOG_JS = path.join(CIRCT_DIR, 'circt-verilog.js');
-const SIM_VPI_JS = path.join(CIRCT_DIR, 'circt-sim-vpi.js');
-const SIM_VPI_WASM = path.join(CIRCT_DIR, 'circt-sim-vpi.wasm');
+const MOX_DIR = path.join(ROOT, 'public', 'mox');
+const VERILOG_JS = path.join(MOX_DIR, 'mox-verilog.js');
+const SIM_VPI_JS = path.join(MOX_DIR, 'mox-sim-vpi.js');
+const SIM_VPI_WASM = path.join(MOX_DIR, 'mox-sim-vpi.wasm');
 const DEFAULT_SOURCE = path.join(ROOT, 'src', 'lessons', 'cocotb', 'first-test', 'adder.sol.sv');
 const DEFAULT_TOP = 'adder';
 
@@ -264,7 +264,7 @@ async function compileToMlir({ sourcePath, top, outMlirPath }) {
   if (code !== 0) {
     throw new Error(
       [
-        `circt-verilog failed (exit=${code})`,
+        `mox-verilog failed (exit=${code})`,
         stdout.trim(),
         stderr.trim()
       ].filter(Boolean).join('\n')
@@ -321,7 +321,7 @@ async function loadSimModule() {
   while (!ready && Date.now() - start < 30_000) {
     await new Promise((resolve) => setTimeout(resolve, 20));
   }
-  if (!ready) throw new Error('timed out waiting for circt-sim-vpi runtime initialization');
+  if (!ready) throw new Error('timed out waiting for mox-sim-vpi runtime initialization');
 
   const M = context.Module;
   ensureSimModuleHelpers(M, context);
@@ -391,7 +391,7 @@ async function main() {
       debug.notes.push('sim module has no _vpi_startup_register export');
     }
 
-    context.circtSimVpiYieldHook = async (cbFuncPtr, cbDataPtr) => {
+    context.moxSimVpiYieldHook = async (cbFuncPtr, cbDataPtr) => {
       const reason = M.getValue(cbDataPtr + 0, 'i32') | 0;
       debug.cbFuncPtr = cbFuncPtr | 0;
       if (reason !== VPI.cbStartOfSimulation) return;
diff --git a/scripts/repro-uvm-browser-worker-assert.mjs b/scripts/repro-uvm-browser-worker-assert.mjs
index 33f2c85..39cf25b 100755
--- a/scripts/repro-uvm-browser-worker-assert.mjs
+++ b/scripts/repro-uvm-browser-worker-assert.mjs
@@ -19,11 +19,11 @@ const REPO_ROOT = path.resolve(__dirname, '..');
 const UVM_LESSON_DIR = path.join(REPO_ROOT, 'src', 'lessons', 'uvm');
 
 const REQUIRED_FILES = [
-  'static/circt/circt-verilog.js',
-  'static/circt/circt-verilog.wasm',
-  'static/circt/circt-sim.js',
-  'static/circt/circt-sim.wasm',
-  'static/circt/uvm-core/uvm-manifest.json'
+  'static/mox/mox-verilog.js',
+  'static/mox/mox-verilog.wasm',
+  'static/mox/mox-sim.js',
+  'static/mox/mox-sim.wasm',
+  'static/mox/uvm-core/uvm-manifest.json'
 ];
 
 const UVM_FILES = {
@@ -156,7 +156,7 @@ async function requireArtifacts() {
     } catch {
       throw new Error(
         `missing required artifact: ${relPath}\n` +
-        'run scripts/setup-circt.sh && npm run sync:circt before repro'
+        'run scripts/setup-mox.sh && npm run sync:mox before repro'
       );
     }
   }
@@ -242,11 +242,11 @@ async function runBrowserWorkerCompile(baseUrl, files, simulate) {
 
     const runEvaluate = async () =>
       page.evaluate(async ({ files, simulate }) => {
-        const { createCirctWasmAdapter } = await import('/src/runtime/circt-adapter.js');
-        const circt = createCirctWasmAdapter();
+        const { createMoxWasmAdapter } = await import('/src/runtime/mox-adapter.js');
+        const mox = createMoxWasmAdapter();
 
         const streamed = [];
-        const result = await circt.run({
+        const result = await mox.run({
           files,
           top: 'tb_top',
           simulate,
@@ -304,7 +304,7 @@ function analyzeLogs(payload) {
   const merged = [...payload.streamed, ...payload.resultLogs].join('\n');
   const hasMalformed = /Malformed attribute storage object/.test(merged);
   const hasAbort = /Aborted\(/.test(merged);
-  const hasSim = /\$ circt-sim\b/.test(merged);
+  const hasSim = /\$ mox-sim\b/.test(merged);
 
   return {
     ok: payload.ok,
@@ -332,7 +332,7 @@ function analyzeLogs(payload) {
       console.log(`# Using existing dev server at ${baseUrl}`);
     }
 
-    console.log('# Running minimal browser-worker UVM compile via createCirctWasmAdapter');
+    console.log('# Running minimal browser-worker UVM compile via createMoxWasmAdapter');
     console.log(`# mode: expect-${options.expect}, simulate=${options.simulate}`);
     const payload = await runBrowserWorkerCompile(baseUrl, files, options.simulate);
     const analysis = analyzeLogs(payload);
diff --git a/scripts/setup-circt.sh b/scripts/setup-circt.sh
deleted file mode 100755
index 0c41214..0000000
--- a/scripts/setup-circt.sh
+++ /dev/null
@@ -1,71 +0,0 @@
-#!/usr/bin/env bash
-set -euo pipefail
-
-ROOT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
-source "$ROOT_DIR/scripts/toolchain.lock.sh"
-
-CIRCT_REPO="${CIRCT_REPO:-$CIRCT_REPO_LOCKED}"
-CIRCT_REF="${CIRCT_REF:-$CIRCT_REF_LOCKED}"
-CIRCT_LLVM_SUBMODULE_REF="${CIRCT_LLVM_SUBMODULE_REF:-$CIRCT_LLVM_SUBMODULE_REF_LOCKED}"
-TARGET_DIR="${1:-vendor/circt}"
-ALLOW_DIRTY="${ALLOW_DIRTY:-0}"
-
-require_clean_worktree() {
-  local repo_dir="$1"
-  if [[ "$ALLOW_DIRTY" == "1" ]]; then
-    return 0
-  fi
-  if [[ -n "$(git -C "$repo_dir" status --porcelain)" ]]; then
-    echo "Refusing to update dirty checkout: $repo_dir" >&2
-    echo "Set ALLOW_DIRTY=1 to override." >&2
-    exit 1
-  fi
-}
-
-if [ -d "$TARGET_DIR/.git" ]; then
-  echo "Updating existing CIRCT checkout in $TARGET_DIR"
-  require_clean_worktree "$TARGET_DIR"
-  git -C "$TARGET_DIR" remote set-url origin "$CIRCT_REPO"
-  git -C "$TARGET_DIR" fetch --tags origin
-else
-  echo "Cloning CIRCT fork from $CIRCT_REPO into $TARGET_DIR"
-  git clone "$CIRCT_REPO" "$TARGET_DIR"
-fi
-
-git -C "$TARGET_DIR" fetch --tags origin "$CIRCT_REF"
-git -C "$TARGET_DIR" checkout --detach "$CIRCT_REF"
-git -C "$TARGET_DIR" submodule sync --recursive
-git -C "$TARGET_DIR" submodule update --init --recursive --checkout
-
-if [ -n "$CIRCT_LLVM_SUBMODULE_REF" ]; then
-  actual_llvm_ref="$(git -C "$TARGET_DIR/llvm" rev-parse HEAD)"
-  if [[ "$actual_llvm_ref" != "$CIRCT_LLVM_SUBMODULE_REF" ]]; then
-    echo "LLVM submodule ref mismatch in $TARGET_DIR/llvm" >&2
-    echo "Expected: $CIRCT_LLVM_SUBMODULE_REF" >&2
-    echo "Actual:   $actual_llvm_ref" >&2
-    exit 1
-  fi
-fi
-
-cat <<MSG
-
-CIRCT fork checkout is ready.
-Pinned repo: $CIRCT_REPO
-Pinned ref:  $CIRCT_REF
-LLVM ref:    $CIRCT_LLVM_SUBMODULE_REF
-
-Next:
-1. Build wasm artifacts from the fork checkout.
-   Standard tools (circt-verilog, circt-sim, circt-bmc):
-     cmake ... -DCIRCT_SIM_WASM=ON -DCIRCT_BMC_WASM=ON
-   VPI-capable sim for cocotb lessons (additional build target):
-     cmake ... -DCIRCT_SIM_WASM_VPI=ON
-2. Run npm run local-publish:circt (or publish:circt to also push to GitHub Release).
-   (The script also patches browser-compatibility issues in circt-sim.js.)
-3. Optionally override artifact URLs with VITE_* env vars in .env:
-   VITE_CIRCT_VERILOG_JS_URL / VITE_CIRCT_VERILOG_WASM_URL
-   VITE_CIRCT_SIM_JS_URL / VITE_CIRCT_SIM_WASM_URL
-   VITE_CIRCT_BMC_JS_URL / VITE_CIRCT_BMC_WASM_URL
-   VITE_CIRCT_SIM_VPI_JS_URL / VITE_CIRCT_SIM_VPI_WASM_URL
-
-MSG
diff --git a/scripts/setup-mox.sh b/scripts/setup-mox.sh
new file mode 100755
index 0000000..012009e
--- /dev/null
+++ b/scripts/setup-mox.sh
@@ -0,0 +1,126 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+ROOT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
+source "$ROOT_DIR/scripts/toolchain.lock.sh"
+
+MOX_REPO="${MOX_REPO:-$MOX_REPO_LOCKED}"
+MOX_REF="${MOX_REF:-$MOX_REF_LOCKED}"
+MOX_LLVM_SUBMODULE_REF="${MOX_LLVM_SUBMODULE_REF:-$MOX_LLVM_SUBMODULE_REF_LOCKED}"
+TARGET_DIR="${1:-vendor/mox}"
+ALLOW_DIRTY="${ALLOW_DIRTY:-0}"
+
+require_clean_worktree() {
+  local repo_dir="$1"
+  if [[ "$ALLOW_DIRTY" == "1" ]]; then
+    return 0
+  fi
+  if [[ -n "$(git -C "$repo_dir" status --porcelain)" ]]; then
+    echo "Refusing to update dirty checkout: $repo_dir" >&2
+    echo "Set ALLOW_DIRTY=1 to override." >&2
+    exit 1
+  fi
+}
+
+if [ -d "$TARGET_DIR/.git" ]; then
+  echo "Updating existing MOX checkout in $TARGET_DIR"
+  require_clean_worktree "$TARGET_DIR"
+  git -C "$TARGET_DIR" remote set-url origin "$MOX_REPO"
+  # Skip --tags here: the upstream fork carries many third-party tags
+  # (sifive/*, firtool-*, ESIRuntime-*, llvm/*) that frequently conflict
+  # with what's already local. Branches are enough to resolve $MOX_REF.
+  git -C "$TARGET_DIR" fetch origin
+else
+  echo "Cloning MOX from $MOX_REPO into $TARGET_DIR"
+  git clone "$MOX_REPO" "$TARGET_DIR"
+fi
+
+git -C "$TARGET_DIR" fetch origin "$MOX_REF"
+
+# If the previous HEAD had llvm/uvm-core as submodules but the target ref
+# stores them as committed trees, deinit the affected submodules first so
+# `git checkout` can replace the gitlink with the tree files cleanly.
+if git -C "$TARGET_DIR" rev-parse --verify -q HEAD >/dev/null; then
+  prev_ref="$(git -C "$TARGET_DIR" rev-parse HEAD)"
+  for sm_path in llvm lib/Runtime/uvm-core; do
+    prev_mode="$(git -C "$TARGET_DIR" ls-tree "$prev_ref" "$sm_path" 2>/dev/null | awk '{print $1}')"
+    new_mode="$(git -C "$TARGET_DIR" ls-tree "$MOX_REF" "$sm_path" 2>/dev/null | awk '{print $1}')"
+    if [[ "$prev_mode" == "160000" && "$new_mode" == "040000" ]]; then
+      echo "Transitioning $sm_path from submodule to tree; deiniting first."
+      git -C "$TARGET_DIR" submodule deinit -f "$sm_path" 2>&1 | sed 's/^/  /' || true
+    fi
+  done
+fi
+
+git -C "$TARGET_DIR" checkout --detach "$MOX_REF"
+
+# Recent commits on the upstream main branch committed the llvm and
+# uvm-core sources directly into the tree instead of leaving them as
+# submodule gitlinks. Detect which layout this ref uses before running
+# any submodule commands.
+llvm_mode="$(git -C "$TARGET_DIR" ls-tree HEAD llvm | awk '{print $1}')"
+
+if [[ "$llvm_mode" == "160000" ]]; then
+  # Submodule layout: sync and check out llvm + uvm-core as gitlinks.
+  git -C "$TARGET_DIR" submodule sync --recursive
+  git -C "$TARGET_DIR" submodule update --init --recursive --checkout
+
+  if [ -n "$MOX_LLVM_SUBMODULE_REF" ]; then
+    actual_llvm_ref="$(git -C "$TARGET_DIR/llvm" rev-parse HEAD)"
+    if [[ "$actual_llvm_ref" != "$MOX_LLVM_SUBMODULE_REF" ]]; then
+      echo "LLVM submodule ref mismatch in $TARGET_DIR/llvm" >&2
+      echo "Expected: $MOX_LLVM_SUBMODULE_REF" >&2
+      echo "Actual:   $actual_llvm_ref" >&2
+      exit 1
+    fi
+  fi
+elif [[ "$llvm_mode" == "040000" ]]; then
+  # Tree layout: llvm sources are committed directly. Init only any
+  # submodules that still exist as gitlinks at this ref.
+  remaining_submodules=()
+  while IFS= read -r path; do
+    [ -n "$path" ] && remaining_submodules+=("$path")
+  done < <(git -C "$TARGET_DIR" ls-tree -r HEAD | awk '$2=="commit" {print $4}')
+
+  if [ "${#remaining_submodules[@]}" -gt 0 ]; then
+    git -C "$TARGET_DIR" submodule sync --recursive
+    git -C "$TARGET_DIR" submodule update --init --recursive --checkout \
+      "${remaining_submodules[@]}"
+  fi
+
+  if [ -n "$MOX_LLVM_SUBMODULE_REF" ]; then
+    echo "Note: llvm is committed as a tree at $MOX_REF; ignoring MOX_LLVM_SUBMODULE_REF override." >&2
+  fi
+else
+  echo "Unexpected llvm tree mode at $MOX_REF: ${llvm_mode:-<missing>}" >&2
+  exit 1
+fi
+
+if [[ "$llvm_mode" == "160000" ]]; then
+  llvm_ref_msg="$MOX_LLVM_SUBMODULE_REF"
+else
+  llvm_ref_msg="(committed in tree at this ref)"
+fi
+
+cat <<MSG
+
+MOX checkout is ready.
+Pinned repo: $MOX_REPO
+Pinned ref:  $MOX_REF
+LLVM ref:    $llvm_ref_msg
+
+Next:
+1. Build wasm artifacts from the checkout.
+   Standard tools (mox-verilog, mox-sim, mox-bmc):
+     cmake ... -DMOX_SIM_WASM=ON -DMOX_BMC_WASM=ON
+   VPI-capable sim for cocotb lessons (additional build target):
+     cmake ... -DMOX_SIM_WASM_VPI=ON
+2. Run npm run local-publish:mox (or publish:mox to also push to GitHub Release).
+   (The script also patches browser-compatibility issues in mox-sim.js.)
+3. Optionally override artifact URLs with VITE_* env vars in .env:
+   VITE_MOX_VERILOG_JS_URL / VITE_MOX_VERILOG_WASM_URL
+   VITE_MOX_SIM_JS_URL / VITE_MOX_SIM_WASM_URL
+   VITE_MOX_BMC_JS_URL / VITE_MOX_BMC_WASM_URL
+   VITE_MOX_SIM_VPI_JS_URL / VITE_MOX_SIM_VPI_WASM_URL
+
+MSG
diff --git a/scripts/sync-circt-wasm.sh b/scripts/sync-mox-wasm.sh
similarity index 83%
rename from scripts/sync-circt-wasm.sh
rename to scripts/sync-mox-wasm.sh
index 7f23c6e..7529077 100755
--- a/scripts/sync-circt-wasm.sh
+++ b/scripts/sync-mox-wasm.sh
@@ -10,16 +10,16 @@ for arg in "$@"; do
   esac
 done
 
-SRC_DIR="${POSITIONAL[0]:-vendor/circt/build-wasm/bin}"
-DST_DIR="${POSITIONAL[1]:-static/circt}"
-UVM_SRC_DIR="${POSITIONAL[2]:-vendor/circt/lib/Runtime/uvm-core/src}"
+SRC_DIR="${POSITIONAL[0]:-vendor/mox/build-wasm/bin}"
+DST_DIR="${POSITIONAL[1]:-static/mox}"
+UVM_SRC_DIR="${POSITIONAL[2]:-vendor/mox/lib/Runtime/uvm-core/src}"
 UVM_DST_DIR="$DST_DIR/uvm-core/src"
 UVM_MANIFEST_PATH="$DST_DIR/uvm-core/uvm-manifest.json"
 
-TOOLS=("circt-bmc" "circt-sim" "circt-verilog")
+TOOLS=("mox-bmc" "mox-sim" "mox-verilog" "mox-lec")
 # VPI-capable sim is a separate build target (Asyncify + VPI exports).
 # It is optional — warn if missing but do not abort.
-VPI_TOOL="circt-sim-vpi"
+VPI_TOOL="mox-sim-vpi"
 missing=()
 
 for tool in "${TOOLS[@]}"; do
@@ -32,7 +32,7 @@ for tool in "${TOOLS[@]}"; do
 done
 
 if [ "${#missing[@]}" -ne 0 ]; then
-  echo "Missing CIRCT wasm artifacts in $SRC_DIR" >&2
+  echo "Missing MOX wasm artifacts in $SRC_DIR" >&2
   echo "Missing files: ${missing[*]}" >&2
   exit 1
 fi
@@ -73,18 +73,18 @@ for tool in "${TOOLS[@]}"; do
   patch_callmain_export "$DST_DIR/$tool.js"
 done
 
-# Sync VPI-capable sim. circt-sim already includes Asyncify + VPI exports
+# Sync VPI-capable sim. mox-sim already includes Asyncify + VPI exports
 # unconditionally in Emscripten builds, so use it as the VPI binary when a
-# separately-named circt-sim-vpi build is not present in the source dir.
+# separately-named mox-sim-vpi build is not present in the source dir.
 if [ -f "$SRC_DIR/$VPI_TOOL.js" ] && [ -f "$SRC_DIR/$VPI_TOOL.wasm" ]; then
   cp -f "$SRC_DIR/$VPI_TOOL.js" "$DST_DIR/$VPI_TOOL.js"
   cp -f "$SRC_DIR/$VPI_TOOL.wasm" "$DST_DIR/$VPI_TOOL.wasm"
-elif [ -f "$SRC_DIR/circt-sim.js" ] && [ -f "$SRC_DIR/circt-sim.wasm" ]; then
-  echo "Note: $VPI_TOOL not in $SRC_DIR — using circt-sim as VPI-capable fallback" >&2
-  cp -f "$SRC_DIR/circt-sim.js" "$DST_DIR/$VPI_TOOL.js"
-  cp -f "$SRC_DIR/circt-sim.wasm" "$DST_DIR/$VPI_TOOL.wasm"
+elif [ -f "$SRC_DIR/mox-sim.js" ] && [ -f "$SRC_DIR/mox-sim.wasm" ]; then
+  echo "Note: $VPI_TOOL not in $SRC_DIR — using mox-sim as VPI-capable fallback" >&2
+  cp -f "$SRC_DIR/mox-sim.js" "$DST_DIR/$VPI_TOOL.js"
+  cp -f "$SRC_DIR/mox-sim.wasm" "$DST_DIR/$VPI_TOOL.wasm"
 else
-  echo "Note: $VPI_TOOL not found and no circt-sim fallback — skipping (cocotb lessons will be unavailable)" >&2
+  echo "Note: $VPI_TOOL not found and no mox-sim fallback — skipping (cocotb lessons will be unavailable)" >&2
   HAVE_VPI=0
 fi
 if [ "${HAVE_VPI:-}" != "0" ]; then
@@ -128,7 +128,7 @@ function walk(dir, acc = []) {
 
 const files = walk(srcDir).sort();
 const manifest = {
-  rootPath: '/circt/uvm-core/src',
+  rootPath: '/mox/uvm-core/src',
   files
 };
 
@@ -139,13 +139,13 @@ NODE
 
 # Remove legacy mock shim artifacts so the runtime cannot silently pick stale
 # files from earlier experiments.
-rm -f "$DST_DIR/circt.js" "$DST_DIR/circt.wasm"
+rm -f "$DST_DIR/mox.js" "$DST_DIR/mox.wasm"
 rm -f "$DST_DIR/uvm-core/uvm-source-map.json"
 
-# Browser compatibility shim for circt-sim builds linked with NODERAWFS.
+# Browser compatibility shim for mox-sim builds linked with NODERAWFS.
 # Upstream sim wasm artifacts may include Node-only glue even when consumed
 # from a web worker. Patch those sections to keep the tutorial runtime web-safe.
-node - "$DST_DIR/circt-sim.js" <<'NODE'
+node - "$DST_DIR/mox-sim.js" <<'NODE'
 const fs = require('fs');
 
 const simPath = process.argv[2];
@@ -165,7 +165,7 @@ const replaceExact = (regex, replacement, label) => {
     console.log(`Skipped patch (${label}): already applied`);
     return;
   }
-  throw new Error(`failed to patch circt-sim.js (${label})`);
+  throw new Error(`failed to patch mox-sim.js (${label})`);
 };
 
 replaceExact(
@@ -190,9 +190,9 @@ fs.writeFileSync(simPath, source);
 console.log(`Patched browser compatibility in ${simPath}`);
 NODE
 
-# Apply the same browser compatibility patch to circt-sim-vpi.js if present.
+# Apply the same browser compatibility patch to mox-sim-vpi.js if present.
 if [ "$HAVE_VPI" -eq 1 ]; then
-node - "$DST_DIR/circt-sim-vpi.js" <<'NODE'
+node - "$DST_DIR/mox-sim-vpi.js" <<'NODE'
 const fs = require('fs');
 
 const simPath = process.argv[2];
@@ -212,7 +212,7 @@ const replaceExact = (regex, replacement, label) => {
     console.log(`Skipped patch (${label}): already applied`);
     return;
   }
-  throw new Error(`failed to patch circt-sim-vpi.js (${label})`);
+  throw new Error(`failed to patch mox-sim-vpi.js (${label})`);
 };
 
 replaceExact(
@@ -243,7 +243,7 @@ replaceExact(
 );
 
 // Fix instrumentWasmImports: the Emscripten stub detects async imports but
-// never wraps them.  Without this patch, _circt_vpi_wasm_yield is called as
+// never wraps them.  Without this patch, _mox_vpi_wasm_yield is called as
 // a plain async function from WASM, returns a Promise that gets coerced to 0,
 // and Asyncify never triggers (simulation runs synchronously with no VPI).
 replaceExact(
@@ -263,7 +263,7 @@ cat >"$DST_DIR/package.json" <<'EOF'
 }
 EOF
 
-echo "Synced CIRCT wasm artifacts:"
+echo "Synced MOX wasm artifacts:"
 for tool in "${TOOLS[@]}"; do
   ls -lh "$DST_DIR/$tool.js" "$DST_DIR/$tool.wasm"
 done
@@ -275,42 +275,48 @@ echo "Synced full UVM source files:"
 echo "  source dir: $UVM_DST_DIR"
 echo "  manifest: $UVM_MANIFEST_PATH"
 
-# --publish: upload artifacts to the circt-wasm GitHub release and update the
+# --publish: upload artifacts to the mox-wasm GitHub release and update the
 # toolchain lock so CI rebuilds from the same commit.
 if [ "$PUBLISH" -eq 1 ]; then
   ROOT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
   source "$ROOT_DIR/scripts/toolchain.lock.sh"
 
-  CIRCT_COMMIT="$(git -C "${CIRCT_DIR:-vendor/circt}" rev-parse HEAD 2>/dev/null || true)"
-  if [ -z "$CIRCT_COMMIT" ]; then
-    echo "--publish: could not determine CIRCT commit from ${CIRCT_DIR:-vendor/circt}" >&2
+  MOX_COMMIT="$(git -C "${MOX_DIR:-vendor/mox}" rev-parse HEAD 2>/dev/null || true)"
+  if [ -z "$MOX_COMMIT" ]; then
+    echo "--publish: could not determine MOX commit from ${MOX_DIR:-vendor/mox}" >&2
     exit 1
   fi
 
-  # Bundle UVM sources for the release asset.
-  UVM_BUNDLE="$(mktemp /tmp/uvm-core.XXXXXX.tar.gz)"
+  # Bundle UVM sources for the release asset. The release asset name is the
+  # file's basename, and the deploy workflow looks for `uvm-core.tar.gz`, so the
+  # bundle must be named exactly that. Build it inside a mktemp -d directory for
+  # uniqueness instead of embedding Xs in the filename (mktemp only substitutes
+  # *trailing* Xs, so `uvm-core.XXXXXX.tar.gz` yields a literal-`XXXXXX` name).
+  UVM_BUNDLE_DIR="$(mktemp -d)"
+  UVM_BUNDLE="$UVM_BUNDLE_DIR/uvm-core.tar.gz"
   tar -czf "$UVM_BUNDLE" -C "$DST_DIR" uvm-core
   echo "Created UVM bundle: $UVM_BUNDLE"
 
   # Upload all artifacts, replacing existing assets on the release.
   RELEASE_ASSETS=(
-    "$DST_DIR/circt-bmc.js"   "$DST_DIR/circt-bmc.wasm"
-    "$DST_DIR/circt-sim.js"   "$DST_DIR/circt-sim.wasm"
-    "$DST_DIR/circt-verilog.js" "$DST_DIR/circt-verilog.wasm"
+    "$DST_DIR/mox-bmc.js"   "$DST_DIR/mox-bmc.wasm"
+    "$DST_DIR/mox-sim.js"   "$DST_DIR/mox-sim.wasm"
+    "$DST_DIR/mox-verilog.js" "$DST_DIR/mox-verilog.wasm"
+    "$DST_DIR/mox-lec.js"   "$DST_DIR/mox-lec.wasm"
     "$UVM_BUNDLE"
   )
   if [ "$HAVE_VPI" -eq 1 ]; then
     RELEASE_ASSETS+=("$DST_DIR/$VPI_TOOL.js" "$DST_DIR/$VPI_TOOL.wasm")
   fi
 
-  echo "Uploading to GitHub release 'circt-wasm'..."
-  gh release upload circt-wasm "${RELEASE_ASSETS[@]}" --clobber
-  rm -f "$UVM_BUNDLE"
+  echo "Uploading to GitHub release 'mox-wasm'..."
+  gh release upload mox-wasm "${RELEASE_ASSETS[@]}" --clobber
+  rm -rf "$UVM_BUNDLE_DIR"
   echo "GitHub release updated."
 
-  # Update toolchain lock to the current CIRCT commit.
+  # Update toolchain lock to the current MOX commit.
   LOCK_FILE="$ROOT_DIR/scripts/toolchain.lock.sh"
-  sed -i.bak "s|^readonly CIRCT_REF_LOCKED=.*|readonly CIRCT_REF_LOCKED=\"$CIRCT_COMMIT\"|" "$LOCK_FILE"
+  sed -i.bak "s|^readonly MOX_REF_LOCKED=.*|readonly MOX_REF_LOCKED=\"$MOX_COMMIT\"|" "$LOCK_FILE"
   rm -f "$LOCK_FILE.bak"
-  echo "Updated CIRCT_REF_LOCKED to $CIRCT_COMMIT in $LOCK_FILE"
+  echo "Updated MOX_REF_LOCKED to $MOX_COMMIT in $LOCK_FILE"
 fi
diff --git a/scripts/test-all-lessons.mjs b/scripts/test-all-lessons.mjs
index d89d6d7..8f33421 100644
--- a/scripts/test-all-lessons.mjs
+++ b/scripts/test-all-lessons.mjs
@@ -7,25 +7,25 @@
  *   • starter files (incomplete) → must NOT indicate success
  *
  * Runners:
- *   sv/, sva/ sim  — circt-verilog (LLHD IR) + fresh circt-sim per lesson
- *   uvm/           — circt-verilog (LLHD IR + --uvm-path) + fresh circt-sim (includes VPI)
- *   sva/ bmc       — circt-verilog (HW IR, no --ir-llhd) + circt-bmc
+ *   sv/, sva/ sim  — mox-verilog (LLHD IR) + fresh mox-sim per lesson
+ *   uvm/           — mox-verilog (LLHD IR + --uvm-path) + fresh mox-sim (includes VPI)
+ *   sva/ bmc       — mox-verilog (HW IR, no --ir-llhd) + mox-bmc
  *                    (exit-code check only; Z3 not bundled so sat/unsat unknown)
  *   cocotb/        — cocotb_test.simulator.run with icarus (Python subprocess)
  *                    requires: pip3 install cocotb cocotb-test  +  iverilog
  *
- *   mlir/           — circt-sim parse/run validation (no solution files; display-only lessons)
+ *   mlir/           — mox-sim parse/run validation (no solution files; display-only lessons)
  * Skipped: sva/lec (LEC tool)
  *
  * Design notes:
- *   - circt-verilog is loaded once and reused (compilation is stateless).
- *   - circt-sim is reloaded per lesson — global state leaks
+ *   - mox-verilog is loaded once and reused (compilation is stateless).
+ *   - mox-sim is reloaded per lesson — global state leaks
  *     between callMain invocations; V8 caches the WASM binary so subsequent
  *     loads are fast (~1-3 s after the first cold load of ~30 s).
  *   - UVM lessons: all source files are staged to a temp dir with canonical
  *     names (stripping .sol) so that `include "foo.sv"` in tb_top.sv finds the
  *     staged solution version. Only the staged files are passed to the compiler.
- *   - BMC lessons: compiled without --ir-llhd so circt-bmc receives HW IR
+ *   - BMC lessons: compiled without --ir-llhd so mox-bmc receives HW IR
  *     (hw.module), not LLHD entities. tb.sv is excluded from BMC inputs.
  *   - cocotb lessons: compiled with icarus via cocotb_test.simulator.run;
  *     a _timescale.v preamble sets `timescale 1ns/1ps for all lessons.
@@ -37,21 +37,22 @@ import os from 'node:os';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { createRequire } from 'node:module';
+import { Worker, isMainThread, parentPort, workerData } from 'node:worker_threads';
 import { spawnSync } from 'node:child_process';
 
 const REPO_ROOT   = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
-const CIRCT_DIR   = path.join(REPO_ROOT, 'static/circt');
+const MOX_DIR   = path.join(REPO_ROOT, 'static/mox');
 const LESSONS_DIR = path.join(REPO_ROOT, 'src/lessons');
 
-const UVM_CORE_PATH = path.join(CIRCT_DIR, 'uvm-core');
+const UVM_CORE_PATH = path.join(MOX_DIR, 'uvm-core');
 const UVM_SRC_PATH  = path.join(UVM_CORE_PATH, 'src');
 
 // ─── WASM tool loader ──────────────────────────────────────────────────────────
 
 async function loadTool(toolName, { initTimeout = 60_000 } = {}) {
-  const jsPath = path.join(CIRCT_DIR, `${toolName}.js`);
+  const jsPath = path.join(MOX_DIR, `${toolName}.js`);
   if (!fs.existsSync(jsPath)) {
-    throw new Error(`WASM artifact not found: ${jsPath}\nRun: npm run sync:circt`);
+    throw new Error(`WASM artifact not found: ${jsPath}\nRun: npm run sync:mox`);
   }
   const source  = fs.readFileSync(jsPath, 'utf8');
   const capture = { out: '', err: '' };
@@ -88,14 +89,14 @@ async function loadTool(toolName, { initTimeout = 60_000 } = {}) {
     process, console, Buffer, URL, WebAssembly,
     TextDecoder, TextEncoder, setTimeout, clearTimeout,
     setInterval, clearInterval, performance,
-    __dirname: CIRCT_DIR,
+    __dirname: MOX_DIR,
     __filename: jsPath,
   };
   context.globalThis = context;
   context.self       = context;
   context.Module = {
     noInitialRun: true,
-    locateFile: (f) => path.join(CIRCT_DIR, f),
+    locateFile: (f) => path.join(MOX_DIR, f),
     print:    (s) => { capture.out += s + '\n'; },
     printErr: (s) => { capture.err += s + '\n'; },
   };
@@ -224,10 +225,10 @@ function hasPass(output) {
 
 // ─── compile + simulate / bmc ─────────────────────────────────────────────────
 
-// Flags for LLHD IR (simulation): circt-sim consumes LLHD (includes VPI for UVM).
+// Flags for LLHD IR (simulation): mox-sim consumes LLHD (includes VPI for UVM).
 const SIM_VERILOG_FLAGS = ['--ir-llhd', '--timescale', '1ns/1ns', '--single-unit'];
 
-// Flags for HW IR (BMC): circt-bmc consumes hw.module, not llhd.entity.
+// Flags for HW IR (BMC): mox-bmc consumes hw.module, not llhd.entity.
 const BMC_VERILOG_FLAGS = ['--timescale', '1ns/1ns', '--single-unit'];
 
 const BMC_FLAGS = ['--assume-known-inputs', '-b', '20'];
@@ -257,7 +258,7 @@ function simulate(sim, mlirPath, { top = 'tb', extraArgs = [] } = {}) {
   return { ok: exitCode === 0, output: stdout + stderr, exitCode };
 }
 
-// Run circt-bmc (NODERAWFS — uses real filesystem paths).
+// Run mox-bmc (NODERAWFS — uses real filesystem paths).
 function runBmc(bmc, work, label, mlirPath, topModule) {
   if (!fs.existsSync(mlirPath)) {
     return { ok: false, smtPath: null, output: 'MLIR output not written' };
@@ -293,7 +294,7 @@ function runZ3(z3Path, smtPath) {
   return null;
 }
 
-// ─── mlir validator (circt-sim parse/run check) ───────────────────────────────
+// ─── mlir validator (mox-sim parse/run check) ───────────────────────────────
 
 async function runMlirLesson({ sim, slug, lessonDir, work, results }) {
   const label = `mlir/${slug}`;
@@ -351,13 +352,13 @@ async function runMlirLesson({ sim, slug, lessonDir, work, results }) {
       results.fail++;
     } else {
       console.log(`  ${R}FAIL${X}`);
-      results.failures.push({ label: fileLabel, mode: 'mlir', reason: 'circt-sim error', output });
+      results.failures.push({ label: fileLabel, mode: 'mlir', reason: 'mox-sim error', output });
       results.fail++;
     }
   }
 }
 
-// ─── LEC runner (circt-lec + Z3) ─────────────────────────────────────────────
+// ─── LEC runner (mox-lec + Z3) ─────────────────────────────────────────────
 
 const LEC_FLAGS = ['--assume-known-inputs'];
 
@@ -381,8 +382,8 @@ async function runLecLesson({ verilog, lec, z3Path, work, slug, lessonDir, resul
 
   process.stdout.write(`  ${label.padEnd(34)}`);
 
-  // circt-lec takes MLIR (hw dialect) as input — compile SV to MLIR first.
-  // circt-lec uses MEMFS in Node.js builds: write MLIR to virtual FS, read
+  // mox-lec takes MLIR (hw dialect) as input — compile SV to MLIR first.
+  // mox-lec uses MEMFS in Node.js builds: write MLIR to virtual FS, read
   // SMT output back from virtual FS, then persist to native for Z3.
   function invokeLec(svFile, label, nativeOutPath) {
     const mlirCompile = compile(verilog, work, label, [svFile], { forBmc: true });
@@ -413,7 +414,7 @@ async function runLecLesson({ verilog, lec, z3Path, work, slug, lessonDir, resul
   const solLec = invokeLec(solFile, `lec-${slug}-sol`, solSmt);
   if (solLec.exitCode !== 0) {
     process.stdout.write(`  ${R}sol=LEC_ERROR${X}\n`);
-    results.failures.push({ label, mode: 'solution', reason: 'circt-lec error', output: solLec.stdout + solLec.stderr });
+    results.failures.push({ label, mode: 'solution', reason: 'mox-lec error', output: solLec.stdout + solLec.stderr });
     results.fail++;
     return;
   }
@@ -563,15 +564,15 @@ const G = '\x1b[32m', R = '\x1b[31m', Y = '\x1b[33m', D = '\x1b[2m', X = '\x1b[0
 // working SRAM test (prints PASS); the student adds coverpoints on top of the passing design.
 //
 // UVM lessons below are ones where the starter still passes despite incompleteness:
-// - uvm/covergroup: empty covergroup returns 100% coverage in CIRCT (no bins → trivially covered)
+// - uvm/covergroup: empty covergroup returns 100% coverage in MOX (no bins → trivially covered)
 // - uvm/cross-coverage: basic bins reach 100% without cross; cannot distinguish starter/solution
-// - uvm/constrained-random: inline constraints still not applied by CIRCT (#69)
+// - uvm/constrained-random: inline constraints still not applied by MOX (#69)
 const SKIP_START_CHECK = new Set([
   'sva/concurrent-sim', 'sva/vacuous-pass',
   'uvm/constrained-random',  // inline constraints now work; starter (no inline) also passes via class constraints
-  'uvm/covergroup',          // empty covergroup returns 100% in CIRCT; cannot distinguish starter
+  'uvm/covergroup',          // empty covergroup returns 100% in MOX; cannot distinguish starter
   'uvm/cross-coverage',      // basic bins reach 100% without cross; starter appears to pass
-  'uvm/coverage-driven',     // uvm_subscriber::report_phase virtual dispatch fails in CIRCT; $fatal never propagates
+  'uvm/coverage-driven',     // uvm_subscriber::report_phase virtual dispatch fails in MOX; $fatal never propagates
   // BMC starters that can't be distinguished from solutions via Z3:
   'sva-bmc/disable-iff',     // req|=>ack is sat both with and without disable iff (both have counterexamples)
 ]);
@@ -583,12 +584,12 @@ const SKIP_SOL_PASS = new Set([
   'sv/welcome',
 ]);
 
-// Known CIRCT bugs that block solution verification.
+// Known MOX bugs that block solution verification.
 // When a bug is fixed, the test auto-promotes to PASS (XPASS is treated as pass).
 // Format: lesson-label → short reason string for display.
 //
-// Bug report files live in docs/circt-bugs/.
-// GitHub issues: https://github.com/thomasnormal/circt/issues
+// Bug report files live in docs/mox-bugs/.
+// GitHub issues: https://github.com/normal-computing/mox/issues
 //
 // Previously fixed (XPASS):
 // sv/parameters (#9 AllowHierarchicalConst): fixed in e1ea916d1.
@@ -597,14 +598,13 @@ const SKIP_SOL_PASS = new Set([
 // combinational SRAM read in UVM lesson SRAMs (eliminates monitor/scoreboard
 // misalignment caused by registered-read 1-cycle latency with 2-cycle driver).
 // 10 of 11 UVM lessons now XPASS; only constrained-random remains.
-const CIRCT_XFAIL = new Map([
+const MOX_XFAIL = new Map([
   // randomize() with {...} inline constraints not respected: weighted_c stays
   // active and boundary writes land at wrong addresses (#69).
   ['uvm/constrained-random', 'inline randomize() with{} constraints not applied (#69)'],
   // Factory type override (set_type_override) not applied at runtime (#74).
-  ['uvm/factory-override', 'type_id::set_type_override not applied by CIRCT UVM factory (#74)'],
-  // Queue pop_front() does not remove the element from the queue — infinite loop (#75).
-  ['sv/queues-arrays', 'queue pop_front() does not dequeue element in new CIRCT build (#75)'],
+  ['uvm/factory-override', 'type_id::set_type_override not applied by MOX UVM factory (#74)'],
+  // sv/queues-arrays (#75 pop_front) was XPASS'd by upstream MOX — no longer XFAIL.
 ]);
 
 async function runLesson({ verilog, bmc, z3Path, work, category, slug, lessonDir, results, meta }) {
@@ -672,7 +672,7 @@ async function runLesson({ verilog, bmc, z3Path, work, category, slug, lessonDir
       const bmcResult = runBmc(bmc, work, `sva-bmc-${slug}-sol`, solCompile.mlirPath, topModule);
       if (!bmcResult.ok) {
         process.stdout.write(`  ${R}sol=BMC_ERROR${X}\n`);
-        results.failures.push({ label, mode: 'solution', reason: 'circt-bmc error', output: bmcResult.output });
+        results.failures.push({ label, mode: 'solution', reason: 'mox-bmc error', output: bmcResult.output });
         results.fail++;
       } else {
         solZ3Result = runZ3(z3Path, bmcResult.smtPath);
@@ -683,7 +683,7 @@ async function runLesson({ verilog, bmc, z3Path, work, category, slug, lessonDir
           process.stdout.write(`  ${G}sol=SAT${X}`);  // cover-property lessons expect sat
           results.pass++;
         } else {
-          // Z3 unavailable — just check that circt-bmc succeeded
+          // Z3 unavailable — just check that mox-bmc succeeded
           process.stdout.write(`  ${G}sol=BMC_OK${X}`);
           results.pass++;
         }
@@ -704,7 +704,7 @@ async function runLesson({ verilog, bmc, z3Path, work, category, slug, lessonDir
         results.pass++;
       } else {
         // Check for negated property assertions in the SMT output.
-        // circt-bmc encodes assertions as (assert (not ...)); a module with no
+        // mox-bmc encodes assertions as (assert (not ...)); a module with no
         // assertions only emits (check-sat) which Z3 trivially proves unsat.
         const smtContent = startBmc.smtPath ? fs.readFileSync(startBmc.smtPath, 'utf8') : '';
         if (!smtContent.includes('(assert (not')) {
@@ -733,8 +733,8 @@ async function runLesson({ verilog, bmc, z3Path, work, category, slug, lessonDir
 
   // ─────────────────────────────────────────────────────────────────────────────
   // Simulation path (sv, sva-sim, uvm)
-  // The new circt-sim.js includes VPI support; use it for all lessons.
-  const simTool  = 'circt-sim';
+  // The new mox-sim.js includes VPI support; use it for all lessons.
+  const simTool  = 'mox-sim';
   const topName  = metaTop ?? (isUvm ? 'tb_top' : 'tb');
   // Default UVM ceiling: 10 ns (enough for delta-cycle-only tests like
   // factory-override/ral/sequence/seq-item that complete at t=0).
@@ -772,7 +772,7 @@ async function runLesson({ verilog, bmc, z3Path, work, category, slug, lessonDir
   const sim = await loadTool(simTool);
 
   // ── Solution ─────────────────────────────────────────────────────────────────
-  const xfailReason = CIRCT_XFAIL.get(label);
+  const xfailReason = MOX_XFAIL.get(label);
 
   if (!solCompile.ok) {
     if (xfailReason) {
@@ -789,9 +789,9 @@ async function runLesson({ verilog, bmc, z3Path, work, category, slug, lessonDir
   } else if (skipSolPass) {
     // Observation lesson: verify the solution runs without crashing, no PASS expected.
     // Accept non-zero exit codes if the simulation produced output (e.g. UVM_FATAL in
-    // phase cleanup is a known CIRCT regression that doesn't affect the lesson itself).
+    // phase cleanup is a known MOX regression that doesn't affect the lesson itself).
     const solSim = simulate(sim, solCompile.mlirPath, { top: topName, extraArgs: simExtra });
-    const simRan = solSim.ok || solSim.output.includes('[circt-sim]');
+    const simRan = solSim.ok || solSim.output.includes('[mox-sim]');
     if (simRan) {
       process.stdout.write(`  ${Y}sol=RAN${X}`);  // neutral — no PASS expected
       results.skip++;
@@ -855,8 +855,13 @@ async function loadMeta() {
 
 async function main() {
   const work = fs.mkdtempSync(path.join(os.tmpdir(), 'sv-lesson-test-'));
+  if (!isMainThread) {
+    await workerLoop(work);
+    await new Promise(() => {});
+    return;
+  }
   try {
-    await run(work);
+    await orchestrate(work);
   } finally {
     fs.rmSync(work, { recursive: true, force: true });
   }
@@ -866,87 +871,169 @@ async function main() {
 const FILTER = process.argv.slice(2).filter(a => !a.startsWith('--'));
 const shouldRun = (label) => FILTER.length === 0 || FILTER.includes(label);
 
-async function run(work) {
-  const meta = await loadMeta();
+// Parallelism config (override via env or CLI):
+//   MOX_TEST_JOBS=N        — number of worker threads (default: 4)
+//   MOX_TEST_TIMEOUT_MS=MS — per-task wall-clock cap (default: 3000)
+const ENV_JOBS = parseInt(process.env.MOX_TEST_JOBS ?? '', 10);
+const ENV_TIMEOUT_MS = parseInt(process.env.MOX_TEST_TIMEOUT_MS ?? '', 10);
+const JOBS = Number.isFinite(ENV_JOBS) && ENV_JOBS > 0 ? ENV_JOBS : 4;
+const TIMEOUT_MS = Number.isFinite(ENV_TIMEOUT_MS) && ENV_TIMEOUT_MS > 0 ? ENV_TIMEOUT_MS : 3000;
+
+function listLessonDirs(sub) {
+  return fs.readdirSync(path.join(LESSONS_DIR, sub), { withFileTypes: true })
+    .filter(d => d.isDirectory()).map(d => d.name).sort();
+}
 
-  console.log('\nLoading circt-verilog…');
-  const verilog = await loadTool('circt-verilog');
-  console.log('Loading circt-bmc…');
-  const bmc = await loadTool('circt-bmc');
-  console.log('Loading circt-lec…');
-  const lec = await loadTool('circt-lec');
+function discoverTasks(meta) {
+  const tasks = [];
+  for (const slug of listLessonDirs('sv')) {
+    tasks.push({ type: 'lesson', category: 'sv', slug });
+  }
+  for (const slug of listLessonDirs('sva')) {
+    const runner = meta[`sva/${slug}`]?.runner;
+    if (runner === 'lec') {
+      tasks.push({ type: 'lec', category: 'sva-lec', slug });
+    } else {
+      const category = (runner === 'bmc' || runner === 'both') ? 'sva-bmc' : 'sva-sim';
+      tasks.push({ type: 'lesson', category, slug });
+    }
+  }
+  if (fs.existsSync(UVM_CORE_PATH)) {
+    for (const slug of listLessonDirs('uvm')) {
+      tasks.push({ type: 'lesson', category: 'uvm', slug });
+    }
+  }
+  for (const slug of listLessonDirs('mlir')) {
+    tasks.push({ type: 'mlir', category: 'mlir', slug });
+  }
+  for (const slug of listLessonDirs('cocotb')) {
+    tasks.push({ type: 'cocotb', category: 'cocotb', slug });
+  }
+  return tasks;
+}
 
-  const z3Path = findZ3();
-  if (z3Path) console.log(`Z3 found: ${z3Path}`);
-  else         console.log('Z3 not found — BMC/LEC sat/unsat checks disabled');
+function taskLabel(t) {
+  return `${t.category}/${t.slug}`;
+}
+
+function mergeResults(into, from) {
+  into.pass += from.pass;
+  into.fail += from.fail;
+  into.xfail += from.xfail;
+  into.xpass += from.xpass;
+  into.skip += from.skip;
+  if (from.failures) into.failures.push(...from.failures);
+}
 
-  console.log('Ready.\n');
+async function orchestrate(workDir) {
+  const meta = await loadMeta();
 
+  // Pre-check optional deps and pre-emit skips for unrunnable categories.
   const results = { pass: 0, fail: 0, xfail: 0, xpass: 0, skip: 0, failures: [] };
+  const uvmReady = fs.existsSync(UVM_CORE_PATH);
+  if (!uvmReady) {
+    console.log(`\n${D}Skipping uvm/ — UVM library not found at ${UVM_CORE_PATH}${X}`);
+    console.log(`${D}Run: npm run sync:mox${X}\n`);
+  }
+  const cocotbDeps = checkCocotbDeps();
+  if (!cocotbDeps.ok && FILTER.length === 0) {
+    console.log(`\n${D}Skipping cocotb/ — ${cocotbDeps.reason}${X}\n`);
+    for (const _ of listLessonDirs('cocotb')) results.skip++;
+  }
 
-  const listDir = (sub) =>
-    fs.readdirSync(path.join(LESSONS_DIR, sub), { withFileTypes: true })
-      .filter(d => d.isDirectory()).map(d => d.name).sort();
+  let tasks = discoverTasks(meta).filter(t => shouldRun(taskLabel(t)));
+  if (!cocotbDeps.ok) tasks = tasks.filter(t => t.type !== 'cocotb');
 
-  // ── sv/ ─────────────────────────────────────────────────────────────────────
-  for (const slug of listDir('sv')) {
-    if (!shouldRun(`sv/${slug}`)) continue;
-    await runLesson({ verilog, bmc, z3Path, work, category: 'sv', slug, lessonDir: path.join(LESSONS_DIR, 'sv', slug), results, meta });
+  if (tasks.length === 0) {
+    console.log('(no tasks selected)');
+    summarize(results);
+    return;
   }
 
-  // ── sva/ ────────────────────────────────────────────────────────────────────
-  for (const slug of listDir('sva')) {
-    const runner = meta[`sva/${slug}`]?.runner;
-
-    if (runner === 'lec') {
-      if (!shouldRun(`sva/${slug}`)) continue;
-      await runLecLesson({ verilog, lec, z3Path, work, slug, lessonDir: path.join(LESSONS_DIR, 'sva', slug), results, meta });
-      continue;
-    }
+  const z3Path = findZ3();
+  console.log(`Running ${tasks.length} tasks across ${JOBS} workers, per-task cap ${TIMEOUT_MS}ms`);
+  if (z3Path) console.log(`Z3 found: ${z3Path}`);
+  else        console.log('Z3 not found — BMC/LEC sat/unsat checks disabled');
+  console.log('');
+
+  // Worker pool with per-task timeout monitor.
+  const queue = [...tasks];
+  let remaining = tasks.length;
+  const workers = new Array(JOBS).fill(null);
+
+  const assignNext = (slot) => {
+    if (queue.length === 0) return;
+    const t = queue.shift();
+    workers[slot].currentTask = t;
+    workers[slot].taskStart = Date.now();
+    workers[slot].postMessage({ task: t, meta });
+  };
 
-    // 'bmc' or 'both' → BMC path; null/undefined → sim
-    const category = (runner === 'bmc' || runner === 'both') ? 'sva-bmc' : 'sva-sim';
-    if (!shouldRun(`${category}/${slug}`)) continue;
-    await runLesson({ verilog, bmc, z3Path, work, category, slug, lessonDir: path.join(LESSONS_DIR, 'sva', slug), results, meta });
-  }
+  const spawnWorker = (slot) => {
+    const w = new Worker(fileURLToPath(import.meta.url));
+    w.currentTask = null;
+    w.taskStart = 0;
+    workers[slot] = w;
+    w.on('message', (msg) => {
+      if (msg.type === 'ready') {
+        assignNext(slot);
+        return;
+      }
+      if (msg.type === 'result') {
+        if (msg.output) process.stdout.write(msg.output);
+        mergeResults(results, msg.results);
+        workers[slot].currentTask = null;
+        remaining--;
+        assignNext(slot);
+      }
+    });
+    w.on('error', (e) => {
+      const t = workers[slot]?.currentTask;
+      const label = t ? taskLabel(t) : `<worker ${slot}>`;
+      console.log(`${R}WORKER ERROR${X} ${label}: ${e.message ?? e}`);
+      if (t) {
+        results.fail++;
+        results.failures.push({ label, mode: 'solution', reason: `worker error: ${e.message ?? e}`, output: '' });
+        remaining--;
+      }
+      try { workers[slot].terminate(); } catch {}
+      spawnWorker(slot);
+    });
+  };
 
-  // ── uvm/ ────────────────────────────────────────────────────────────────────
-  if (!fs.existsSync(UVM_CORE_PATH)) {
-    console.log(`\n${D}Skipping uvm/ — UVM library not found at ${UVM_CORE_PATH}${X}`);
-    console.log(`${D}Run: npm run sync:circt${X}\n`);
-  } else {
-    for (const slug of listDir('uvm')) {
-      if (!shouldRun(`uvm/${slug}`)) continue;
-      await runLesson({ verilog, bmc, z3Path, work, category: 'uvm', slug, lessonDir: path.join(LESSONS_DIR, 'uvm', slug), results, meta });
+  for (let i = 0; i < JOBS; i++) spawnWorker(i);
+
+  // Per-task timeout monitor.
+  const monitor = setInterval(() => {
+    for (let i = 0; i < workers.length; i++) {
+      const w = workers[i];
+      if (!w || !w.currentTask) continue;
+      if (Date.now() - w.taskStart > TIMEOUT_MS) {
+        const t = w.currentTask;
+        const label = taskLabel(t);
+        console.log(`${R}TIMEOUT${X} ${label} [solution]: exceeded ${TIMEOUT_MS}ms`);
+        results.fail++;
+        results.failures.push({ label, mode: 'solution', reason: `timeout (${TIMEOUT_MS}ms)`, output: '' });
+        try { w.terminate(); } catch {}
+        workers[i] = null;
+        remaining--;
+        spawnWorker(i);
+      }
     }
-  }
+  }, 250);
 
-  // ── mlir/ ────────────────────────────────────────────────────────────────────
-  // MLIR lessons are read-only display lessons (no exercises, no solution files).
-  // We validate that each .mlir file parses and runs without error via circt-sim.
-  {
-    const mlirSim = await loadTool('circt-sim');
-    for (const slug of listDir('mlir')) {
-      if (!shouldRun(`mlir/${slug}`)) continue;
-      await runMlirLesson({ sim: mlirSim, slug, lessonDir: path.join(LESSONS_DIR, 'mlir', slug), work, results });
-    }
-  }
+  // Wait until queue drained and all workers idle.
+  while (remaining > 0) await new Promise(r => setTimeout(r, 50));
 
-  // ── cocotb/ ─────────────────────────────────────────────────────────────────
-  const cocotbDeps = checkCocotbDeps();
-  if (!cocotbDeps.ok) {
-    if (FILTER.length === 0) {
-      console.log(`\n${D}Skipping cocotb/ — ${cocotbDeps.reason}${X}\n`);
-      for (const slug of listDir('cocotb')) results.skip++;
-    }
-  } else {
-    for (const slug of listDir('cocotb')) {
-      if (!shouldRun(`cocotb/${slug}`)) continue;
-      await runCocotbLesson({ slug, lessonDir: path.join(LESSONS_DIR, 'cocotb', slug), results, work });
-    }
+  clearInterval(monitor);
+  for (const w of workers) {
+    if (w) { try { await w.terminate(); } catch {} }
   }
 
-  // ── summary ──────────────────────────────────────────────────────────────────
+  summarize(results);
+}
+
+function summarize(results) {
   const { pass, fail, xfail, xpass, skip, failures } = results;
 
   if (failures.length > 0) {
@@ -958,16 +1045,16 @@ async function run(work) {
   }
 
   if (xfail > 0) {
-    console.log('\n── known CIRCT bugs (xfail) ─────────────────────');
-    for (const [label, reason] of CIRCT_XFAIL) {
+    console.log('\n── known MOX bugs (xfail) ─────────────────────');
+    for (const [label, reason] of MOX_XFAIL) {
       console.log(`  ${Y}XFAIL${X} ${label}: ${reason}`);
     }
   }
 
   const bar = '─────────────────────────────────────';
   console.log(`\n${bar}`);
-  const xpassNote = xpass > 0 ? `, ${xpass} XPASS (CIRCT bug fixed!)` : '';
-  const xfailNote = xfail > 0 ? `, ${xfail} xfail (known CIRCT bugs)` : '';
+  const xpassNote = xpass > 0 ? `, ${xpass} XPASS (MOX bug fixed!)` : '';
+  const xfailNote = xfail > 0 ? `, ${xfail} xfail (known MOX bugs)` : '';
   if (fail === 0) {
     console.log(`${G}ALL PASS${X}  ${pass} checks passed${xpassNote}${xfailNote}, ${skip} skipped`);
   } else {
@@ -978,4 +1065,51 @@ async function run(work) {
   if (fail > 0) process.exit(1);
 }
 
+// ── worker thread entry ────────────────────────────────────────────────────────
+// Each worker loads its own tool instances (wasm Module state isn't thread-safe)
+// and processes tasks sequentially from the main thread's queue.
+async function workerLoop(work) {
+  const verilog = await loadTool('mox-verilog');
+  const bmc     = await loadTool('mox-bmc');
+  const lec     = await loadTool('mox-lec');
+  const z3Path  = findZ3();
+  let mlirSim   = null;  // lazy-loaded on first mlir/* task
+
+  parentPort.postMessage({ type: 'ready' });
+
+  parentPort.on('message', async ({ task, meta }) => {
+    const localResults = { pass: 0, fail: 0, xfail: 0, xpass: 0, skip: 0, failures: [] };
+    const captured = [];
+    const origWrite = process.stdout.write.bind(process.stdout);
+    process.stdout.write = (data) => {
+      captured.push(typeof data === 'string' ? data : data.toString('utf8'));
+      return true;
+    };
+    try {
+      const { type, category, slug } = task;
+      const lessonDir = type === 'lec'
+        ? path.join(LESSONS_DIR, 'sva', slug)
+        : path.join(LESSONS_DIR, category === 'sva-bmc' || category === 'sva-sim' ? 'sva' : category, slug);
+
+      if (type === 'lesson') {
+        await runLesson({ verilog, bmc, z3Path, work, category, slug, lessonDir, results: localResults, meta });
+      } else if (type === 'lec') {
+        await runLecLesson({ verilog, lec, z3Path, work, slug, lessonDir, results: localResults, meta });
+      } else if (type === 'mlir') {
+        if (!mlirSim) mlirSim = await loadTool('mox-sim');
+        await runMlirLesson({ sim: mlirSim, slug, lessonDir, work, results: localResults });
+      } else if (type === 'cocotb') {
+        await runCocotbLesson({ slug, lessonDir, results: localResults, work });
+      }
+    } catch (e) {
+      const label = taskLabel(task);
+      localResults.fail++;
+      localResults.failures.push({ label, mode: 'solution', reason: `runner error: ${e?.message ?? e}`, output: '' });
+    } finally {
+      process.stdout.write = origWrite;
+    }
+    parentPort.postMessage({ type: 'result', task, output: captured.join(''), results: localResults });
+  });
+}
+
 main().catch(e => { console.error(e); process.exit(1); });
diff --git a/scripts/test-sv-lessons.mjs b/scripts/test-sv-lessons.mjs
index 7c91f45..a85946e 100755
--- a/scripts/test-sv-lessons.mjs
+++ b/scripts/test-sv-lessons.mjs
@@ -2,17 +2,17 @@
 /**
  * test-sv-lessons.mjs
  *
- * Compiles and simulates every SV lesson through the WASM circt tools, checking:
+ * Compiles and simulates every SV lesson through the WASM mox tools, checking:
  *   • solution files (.sol.sv substituted for the corresponding .sv)
  *       → simulation output must contain a line starting with "PASS"
  *   • starter files (unmodified .sv, incomplete implementations)
  *       → simulation output must NOT contain such a line
  *
- * Requires static/circt/ to be populated (run `npm run sync:circt` first).
+ * Requires static/mox/ to be populated (run `npm run sync:mox` first).
  *
  * Design notes:
- *   - circt-verilog is loaded once and reused (compilation is stateless).
- *   - circt-sim is reloaded for each lesson because callMain does not fully
+ *   - mox-verilog is loaded once and reused (compilation is stateless).
+ *   - mox-sim is reloaded for each lesson because callMain does not fully
  *     reset global simulation state between invocations. After the first load
  *     V8 caches the compiled WASM binary, so subsequent loads are fast (~1-3s).
  */
@@ -25,21 +25,21 @@ import { fileURLToPath } from 'node:url';
 import { createRequire } from 'node:module';
 
 const REPO_ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
-const CIRCT_DIR = path.join(REPO_ROOT, 'static/circt');
+const MOX_DIR = path.join(REPO_ROOT, 'static/mox');
 const LESSONS_DIR = path.join(REPO_ROOT, 'src/lessons/sv');
 
 // ─── WASM tool loader ─────────────────────────────────────────────────────────
 
 async function loadTool(toolName, { initTimeout = 60_000 } = {}) {
-  const jsPath = path.join(CIRCT_DIR, `${toolName}.js`);
+  const jsPath = path.join(MOX_DIR, `${toolName}.js`);
   if (!fs.existsSync(jsPath)) {
-    throw new Error(`WASM artifact not found: ${jsPath}\nRun: npm run sync:circt`);
+    throw new Error(`WASM artifact not found: ${jsPath}\nRun: npm run sync:mox`);
   }
   const source = fs.readFileSync(jsPath, 'utf8');
   const capture = { out: '', err: '' };
 
   // Intercept require('fs') so that NODERAWFS fd=1/2 writes are captured.
-  // (circt-verilog.js uses NODERAWFS and calls fs.writeSync(1,...) for stdout.)
+  // (mox-verilog.js uses NODERAWFS and calls fs.writeSync(1,...) for stdout.)
   const realRequire = createRequire(jsPath);
   const patchedRequire = (id) => {
     const mod = realRequire(id);
@@ -73,14 +73,14 @@ async function loadTool(toolName, { initTimeout = 60_000 } = {}) {
     process, console, Buffer, URL, WebAssembly,
     TextDecoder, TextEncoder, setTimeout, clearTimeout,
     setInterval, clearInterval, performance,
-    __dirname: CIRCT_DIR,
+    __dirname: MOX_DIR,
     __filename: jsPath,
   };
   context.globalThis = context;
   context.self = context;
   context.Module = {
     noInitialRun: true,
-    locateFile: (f) => path.join(CIRCT_DIR, f),
+    locateFile: (f) => path.join(MOX_DIR, f),
     print:    (s) => { capture.out += s + '\n'; },
     printErr: (s) => { capture.err += s + '\n'; },
   };
@@ -195,8 +195,8 @@ async function main() {
 }
 
 async function run(work) {
-  console.log(`\nLoading circt-verilog…`);
-  const verilog = await loadTool('circt-verilog');
+  console.log(`\nLoading mox-verilog…`);
+  const verilog = await loadTool('mox-verilog');
   console.log('Ready.\n');
 
   const lessons = getLessonNames();
@@ -225,11 +225,11 @@ async function run(work) {
     const solCompile   = compile(verilog, work, `${lesson}-sol`,   buildSolutionFiles(starterFiles, lessonDir));
     const startCompile = compile(verilog, work, `${lesson}-start`, starterFiles);
 
-    // ── load a FRESH circt-sim for this lesson ───────────────────────────────
-    // circt-sim doesn't reset all global state between callMain calls, so we
+    // ── load a FRESH mox-sim for this lesson ───────────────────────────────
+    // mox-sim doesn't reset all global state between callMain calls, so we
     // create a new instance per lesson. After the first load V8 caches the
     // compiled WASM binary and subsequent loads take ~1-3s.
-    const sim = await loadTool('circt-sim');
+    const sim = await loadTool('mox-sim');
 
     // ── solution ─────────────────────────────────────────────────────────────
     if (!solCompile.ok) {
diff --git a/scripts/test-sv-lessons.sh b/scripts/test-sv-lessons.sh
index 1a41d34..2500580 100755
--- a/scripts/test-sv-lessons.sh
+++ b/scripts/test-sv-lessons.sh
@@ -3,25 +3,25 @@
 #   • the solution files produce PASS output, and
 #   • the starter (incomplete) files do NOT produce PASS output.
 #
-# Requirements: native circt-verilog and circt-sim binaries.
-# Default location: vendor/circt/build-native/bin/
-# Override: CIRCT_VERILOG=/path/to/circt-verilog CIRCT_SIM=/path/to/circt-sim
+# Requirements: native mox-verilog and mox-sim binaries.
+# Default location: vendor/mox/build-native/bin/
+# Override: MOX_VERILOG=/path/to/mox-verilog MOX_SIM=/path/to/mox-sim
 set -euo pipefail
 
 REPO_ROOT="$(cd "$(dirname "$0")/.." && pwd)"
 LESSONS_DIR="$REPO_ROOT/src/lessons/sv"
 
-CIRCT_VERILOG="${CIRCT_VERILOG:-$REPO_ROOT/vendor/circt/build-native/bin/circt-verilog}"
-CIRCT_SIM="${CIRCT_SIM:-$REPO_ROOT/vendor/circt/build-native/bin/circt-sim}"
+MOX_VERILOG="${MOX_VERILOG:-$REPO_ROOT/vendor/mox/build-native/bin/mox-verilog}"
+MOX_SIM="${MOX_SIM:-$REPO_ROOT/vendor/mox/build-native/bin/mox-sim}"
 
-if [[ ! -x "$CIRCT_VERILOG" ]]; then
-  echo "ERROR: circt-verilog not found: $CIRCT_VERILOG"
-  echo "Build native tools first, or set CIRCT_VERILOG=/path/to/binary"
+if [[ ! -x "$MOX_VERILOG" ]]; then
+  echo "ERROR: mox-verilog not found: $MOX_VERILOG"
+  echo "Build native tools first, or set MOX_VERILOG=/path/to/binary"
   exit 1
 fi
-if [[ ! -x "$CIRCT_SIM" ]]; then
-  echo "ERROR: circt-sim not found: $CIRCT_SIM"
-  echo "Build native tools first, or set CIRCT_SIM=/path/to/binary"
+if [[ ! -x "$MOX_SIM" ]]; then
+  echo "ERROR: mox-sim not found: $MOX_SIM"
+  echo "Build native tools first, or set MOX_SIM=/path/to/binary"
   exit 1
 fi
 
@@ -48,14 +48,14 @@ compile_and_sim() {
   local mlir="$WORK/${label}.mlir"
   local compile_log="$WORK/${label}.compile.log"
 
-  if ! "$CIRCT_VERILOG" "${VERILOG_FLAGS[@]}" "$@" -o "$mlir" \
+  if ! "$MOX_VERILOG" "${VERILOG_FLAGS[@]}" "$@" -o "$mlir" \
        >"$compile_log" 2>&1; then
     printf 'COMPILE_ERROR\n'
     cat "$compile_log"
     return 0
   fi
 
-  "$CIRCT_SIM" --top tb "$mlir" 2>&1 || true
+  "$MOX_SIM" --top tb "$mlir" 2>&1 || true
 }
 
 # has_pass <output>  — true if any line starts with "PASS"
@@ -63,7 +63,7 @@ has_pass() { echo "$1" | grep -q "^PASS"; }
 
 # ─── main loop ────────────────────────────────────────────────────────────────
 
-printf '\n%s\n' "$(dim "circt: $CIRCT_VERILOG")"
+printf '\n%s\n' "$(dim "mox: $MOX_VERILOG")"
 printf '%s\n\n' "$(dim "lessons: $LESSONS_DIR")"
 
 for lesson_dir in "$LESSONS_DIR"/*/; do
diff --git a/scripts/toolchain.lock.sh b/scripts/toolchain.lock.sh
index 0c8d3d5..39fe1df 100755
--- a/scripts/toolchain.lock.sh
+++ b/scripts/toolchain.lock.sh
@@ -6,9 +6,15 @@
 readonly NODE_MAJOR_VERSION_LOCKED="22"
 readonly EMSDK_VERSION_LOCKED="4.0.21"
 
-readonly CIRCT_REPO_LOCKED="https://github.com/thomasnormal/circt.git"
-readonly CIRCT_REF_LOCKED="a10b92ffd771fd458184278d26f6b980f71aa970"
-readonly CIRCT_LLVM_SUBMODULE_REF_LOCKED="aa3d6b37c7945bfb4c261dd994689de2a2de25bf"
+readonly MOX_REPO_LOCKED="https://github.com/normal-computing/mox.git"
+readonly MOX_REF_LOCKED="805b42d2d2a95c98e954bddd2071bd52f1ced0b4"
+readonly MOX_LLVM_SUBMODULE_REF_LOCKED="aa3d6b37c7945bfb4c261dd994689de2a2de25bf"
 
-readonly SURFER_ARTIFACT_URL_LOCKED="https://gitlab.com/surfer-project/surfer/-/jobs/artifacts/main/download?job=pages_build"
-readonly SURFER_ARTIFACT_SHA256_LOCKED="abf8d4c3415d445bf86edb39dda9ec9f37d20ccddf4069ec925acb608dcb661b"
+# Mirrored from gitlab.com/surfer-project/surfer pages_build (main pipeline
+# 2625476633, job 15008633862, commit 98287107b9, 2026-06-24). We host our own
+# copy because GitLab only keeps the *latest* pipeline's artifacts, so the
+# upstream "latest main" URL is a moving target that breaks the pinned SHA, and
+# job-ID URLs 404 once the artifacts expire. To refresh: download the new
+# pages_build zip, upload it to the 'surfer-web' release, and update both lines.
+readonly SURFER_ARTIFACT_URL_LOCKED="https://github.com/thomasnormal/sv-tutorial/releases/download/surfer-web/surfer-pages_build.zip"
+readonly SURFER_ARTIFACT_SHA256_LOCKED="8ab484d373120ac3a49592ebe87eaa8a9dc22714eb6c9dded0de495314a1df44"
diff --git a/src/app.html b/src/app.html
index ed2fa00..e9b660a 100644
--- a/src/app.html
+++ b/src/app.html
@@ -5,7 +5,7 @@
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
     <title>SV Tutorial</title>
     <link rel="icon" href="%sveltekit.assets%/favicon.svg" type="image/svg+xml" />
-    <meta name="description" content="Interactive SystemVerilog tutorial with in-browser simulation, powered by CIRCT." />
+    <meta name="description" content="Interactive SystemVerilog tutorial with in-browser simulation, powered by MOX." />
     <meta property="og:site_name" content="SV Tutorial" />
     <meta property="og:type" content="website" />
     <meta property="og:image" content="https://thomasnormal.github.io/sv-tutorial/favicon.svg" />
diff --git a/src/lessons/index.js b/src/lessons/index.js
index d024481..b11cbba 100644
--- a/src/lessons/index.js
+++ b/src/lessons/index.js
@@ -127,7 +127,7 @@ export const parts = [
     ],
   },
   {
-    title: 'MLIR & CIRCT',
+    title: 'MLIR & MOX',
     chapters: [
       {
         title: 'Inside the Compiler',
diff --git a/src/lessons/meta.js b/src/lessons/meta.js
index 661bd32..5ee7bc5 100644
--- a/src/lessons/meta.js
+++ b/src/lessons/meta.js
@@ -75,7 +75,7 @@ export default {
   'rtl/rtl-to-gates':        { title: 'RTL to Gates',                                focus: '/src/mux_reg.sv' },
   'rtl/synthesis-gotchas':   { title: 'Synthesis Gotchas',                           focus: '/src/decoder.sv' },
 
-  // ── MLIR & CIRCT ──────────────────────────────────────────────────────────
+  // ── MLIR & MOX ──────────────────────────────────────────────────────────
   'mlir/intro':    { title: 'What is MLIR?',                    focus: '/src/adder.mlir' },
   'mlir/comb':     { title: 'The comb Dialect',                 focus: '/src/priority_enc.mlir' },
   'mlir/seq':      { title: 'The seq Dialect: Registers',       focus: '/src/sram_core.mlir' },
diff --git a/src/lessons/mlir/comb/description.html b/src/lessons/mlir/comb/description.html
index abc1dd7..d4fb668 100644
--- a/src/lessons/mlir/comb/description.html
+++ b/src/lessons/mlir/comb/description.html
@@ -1,4 +1,4 @@
-<p>The <dfn data-card="The comb dialect represents purely combinational logic in CIRCT MLIR. Operations in comb are stateless: same inputs always produce the same outputs, and there is no clock. This makes them easy to analyse and optimise independently of sequential state. comb is deliberately not tied to any language — the same IR represents SystemVerilog assign, VHDL concurrent signal assignment, or Chisel combinational operators.">comb dialect</dfn> represents <strong>purely combinational logic</strong> — stateless operations where the same inputs always produce the same output. There is no clock and no side effects.</p>
+<p>The <dfn data-card="The comb dialect represents purely combinational logic in MOX MLIR. Operations in comb are stateless: same inputs always produce the same outputs, and there is no clock. This makes them easy to analyse and optimise independently of sequential state. comb is deliberately not tied to any language — the same IR represents SystemVerilog assign, VHDL concurrent signal assignment, or Chisel combinational operators.">comb dialect</dfn> represents <strong>purely combinational logic</strong> — stateless operations where the same inputs always produce the same output. There is no clock and no side effects.</p>
 
 <h2>Key operations</h2>
 <pre>
@@ -20,4 +20,4 @@ <h2>No implicit conversions</h2>
 <p>Every operand and result has an explicit type and all operands must match. There are no implicit zero-extensions or sign-extensions. This strictness makes the IR unambiguous — a tool can rely on the types without guessing.</p>
 
 <h2>comb is language-neutral</h2>
-<p>The same <code>comb.mux</code> might originate from a SystemVerilog ternary <code>a ? b : c</code>, a Chisel <code>Mux()</code>, or an HLS tool. CIRCT analyses and optimises the <code>comb</code> IR before it knows — or cares — which language produced it.</p>
+<p>The same <code>comb.mux</code> might originate from a SystemVerilog ternary <code>a ? b : c</code>, a Chisel <code>Mux()</code>, or an HLS tool. MOX analyses and optimises the <code>comb</code> IR before it knows — or cares — which language produced it.</p>
diff --git a/src/lessons/mlir/comb/priority_enc.mlir b/src/lessons/mlir/comb/priority_enc.mlir
index a288e26..c5fdc98 100644
--- a/src/lessons/mlir/comb/priority_enc.mlir
+++ b/src/lessons/mlir/comb/priority_enc.mlir
@@ -1,4 +1,4 @@
-// priority_enc.sv — rewritten as CIRCT MLIR.
+// priority_enc.sv — rewritten as MOX MLIR.
 //
 // The comb dialect represents purely combinational logic:
 // no state, no clock, no side effects.
diff --git a/src/lessons/mlir/comb/priority_enc_tb.mlir b/src/lessons/mlir/comb/priority_enc_tb.mlir
index ec05040..e210205 100644
--- a/src/lessons/mlir/comb/priority_enc_tb.mlir
+++ b/src/lessons/mlir/comb/priority_enc_tb.mlir
@@ -1,6 +1,6 @@
 // Testbench: instantiate @priority_enc with req=0b0010; verify grant==1, valid==1.
 //
-// Uses LLHD dialect for signal-driven simulation compatible with circt-sim.
+// Uses LLHD dialect for signal-driven simulation compatible with mox-sim.
 hw.module @tb() {
   %c0_i2 = hw.constant 0 : i2
   %c0_i1 = hw.constant false
diff --git a/src/lessons/mlir/intro/adder.mlir b/src/lessons/mlir/intro/adder.mlir
index 187759e..53042f1 100644
--- a/src/lessons/mlir/intro/adder.mlir
+++ b/src/lessons/mlir/intro/adder.mlir
@@ -1,4 +1,4 @@
-// The adder from Part 1 — expressed as CIRCT MLIR.
+// The adder from Part 1 — expressed as MOX MLIR.
 //
 // Every MLIR file is a sequence of operations.
 // Here there is one top-level operation: hw.module.
diff --git a/src/lessons/mlir/intro/adder_tb.mlir b/src/lessons/mlir/intro/adder_tb.mlir
index 43a7167..e6d425e 100644
--- a/src/lessons/mlir/intro/adder_tb.mlir
+++ b/src/lessons/mlir/intro/adder_tb.mlir
@@ -1,6 +1,6 @@
 // Testbench: instantiate @adder with a=5, b=3 and verify sum==8.
 //
-// Uses LLHD dialect for signal-driven simulation compatible with circt-sim.
+// Uses LLHD dialect for signal-driven simulation compatible with mox-sim.
 // The hw.instance output is driven onto a signal so the check process can
 // probe it after epsilon time, then print PASS or FAIL.
 hw.module @tb() {
diff --git a/src/lessons/mlir/intro/description.html b/src/lessons/mlir/intro/description.html
index 9a7dec9..0618f76 100644
--- a/src/lessons/mlir/intro/description.html
+++ b/src/lessons/mlir/intro/description.html
@@ -1,4 +1,4 @@
-<p>Every time you clicked <strong>Run</strong> or <strong>Verify</strong> in this tutorial, your SystemVerilog was parsed by <dfn data-card="CIRCT (Circuit IR Compilers and Tools) is an open-source LLVM/MLIR project that applies compiler infrastructure to hardware design and verification. It ingests SystemVerilog, Chisel output (FIRRTL), or hand-written MLIR, and can lower it to optimised SystemVerilog, run bounded model checking, or export netlists.">CIRCT</dfn> and converted into <dfn data-card="MLIR (Multi-Level Intermediate Representation) is a compiler infrastructure developed inside LLVM. Unlike traditional compilers that have a single fixed IR, MLIR allows many IRs — called dialects — to coexist and interoperate. Hardware design needs this because the same circuit exists at many levels: behavioural, RTL, gate-level, netlist.">MLIR</dfn> before anything else happened. This part lifts the lid on that representation.</p>
+<p>Every time you clicked <strong>Run</strong> or <strong>Verify</strong> in this tutorial, your SystemVerilog was parsed by <dfn data-card="MOX (Circuit IR Compilers and Tools) is an open-source LLVM/MLIR project that applies compiler infrastructure to hardware design and verification. It ingests SystemVerilog, Chisel output (FIRRTL), or hand-written MLIR, and can lower it to optimised SystemVerilog, run bounded model checking, or export netlists.">MOX</dfn> and converted into <dfn data-card="MLIR (Multi-Level Intermediate Representation) is a compiler infrastructure developed inside LLVM. Unlike traditional compilers that have a single fixed IR, MLIR allows many IRs — called dialects — to coexist and interoperate. Hardware design needs this because the same circuit exists at many levels: behavioural, RTL, gate-level, netlist.">MLIR</dfn> before anything else happened. This part lifts the lid on that representation.</p>
 
 <h2>What is an IR?</h2>
 <p>An <strong>Intermediate Representation</strong> is the compiler's internal language — somewhere between your source code and the final output. You never write it by hand in normal use, but reading it is a superpower for understanding what tools actually do with your design.</p>
@@ -17,9 +17,9 @@ <h2>Operations, values, and types</h2>
 <ul>
   <li><strong>Operation</strong> — a named computation: <code>dialect.opname operands : type</code></li>
   <li><strong>Value</strong> — the result of an operation, written <code>%name</code>. Each value is produced exactly once (<dfn data-card="SSA (Static Single Assignment) form means every value is defined exactly once. If you need to update a variable you create a new value. This property makes data-flow analysis trivial: follow the use-def chain upward to find where any value comes from, without worrying about aliasing or mutation.">SSA form</dfn>) but can be used as many times as needed.</li>
-  <li><strong>Type</strong> — attached to every value. CIRCT uses <code>i1</code>, <code>i8</code>, <code>i32</code> etc. for signless integers of N bits.</li>
+  <li><strong>Type</strong> — attached to every value. MOX uses <code>i1</code>, <code>i8</code>, <code>i32</code> etc. for signless integers of N bits.</li>
 </ul>
-<p>Open <code>adder.mlir</code> — it is the 8-bit adder from Part 1 written in CIRCT's textual format. Every line is annotated. The entire module is one <code>hw.module</code> operation containing two inner operations: <code>comb.add</code> and <code>hw.output</code>.</p>
+<p>Open <code>adder.mlir</code> — it is the 8-bit adder from Part 1 written in MOX's textual format. Every line is annotated. The entire module is one <code>hw.module</code> operation containing two inner operations: <code>comb.add</code> and <code>hw.output</code>.</p>
 
 <h2>Dialects</h2>
 <p>The prefix before the dot — <code>hw</code>, <code>comb</code>, <code>seq</code> — is the <dfn data-card="A dialect is a namespace for a coherent set of operations, types, and attributes in MLIR. Each dialect targets one abstraction level or domain. Dialects can be mixed freely in the same file: a hw.module can contain comb.add and seq.compreg side by side. This composability is MLIR's key advantage over single-level IRs.">dialect</dfn>. Think of it as a namespace for a coherent set of operations at one abstraction level:</p>
diff --git a/src/lessons/mlir/lowering/description.html b/src/lessons/mlir/lowering/description.html
index 9ddcb13..5acdd60 100644
--- a/src/lessons/mlir/lowering/description.html
+++ b/src/lessons/mlir/lowering/description.html
@@ -1,4 +1,4 @@
-<p>CIRCT does not convert SystemVerilog to its output in one step. It runs a <strong>pipeline of lowering passes</strong>, each transforming the IR one level closer to the target. Open <code>lowering.mlir</code> — it shows the same D flip-flop at each stage.</p>
+<p>MOX does not convert SystemVerilog to its output in one step. It runs a <strong>pipeline of lowering passes</strong>, each transforming the IR one level closer to the target. Open <code>lowering.mlir</code> — it shows the same D flip-flop at each stage.</p>
 
 <h2>The two output paths</h2>
 <pre>
@@ -15,7 +15,7 @@ <h2>The two output paths</h2>
 <p>The left branch is used when you click <strong>Run</strong>. The right branch is used when you click <strong>Verify</strong>. Both start from the same hw/comb/seq IR.</p>
 
 <h2>The sv dialect: one step from text</h2>
-<p>The <dfn data-card="The sv dialect in CIRCT is an AST-level representation of SystemVerilog. Its operations map one-to-one onto SV constructs: sv.reg → reg declaration, sv.always → always block, sv.passign → non-blocking assignment, sv.assign → continuous assign. Because it mirrors the SV grammar directly, the ExportVerilog pass can print it to text with almost no logic.">sv dialect</dfn> is an AST-level mirror of SystemVerilog. Each operation maps directly onto a SV construct:</p>
+<p>The <dfn data-card="The sv dialect in MOX is an AST-level representation of SystemVerilog. Its operations map one-to-one onto SV constructs: sv.reg → reg declaration, sv.always → always block, sv.passign → non-blocking assignment, sv.assign → continuous assign. Because it mirrors the SV grammar directly, the ExportVerilog pass can print it to text with almost no logic.">sv dialect</dfn> is an AST-level mirror of SystemVerilog. Each operation maps directly onto a SV construct:</p>
 <pre>
   sv.reg     name "q" : !hw.inout&lt;i8&gt;   →  reg [7:0] q;
   sv.always  posedge %clk { … }          →  always @(posedge clk) begin … end
@@ -25,8 +25,8 @@ <h2>The sv dialect: one step from text</h2>
 <p>The <code>LowerSeqToSV</code> pass converts every <code>seq.compreg</code> into an <code>sv.reg</code> plus an <code>sv.always</code> block. After that, <code>ExportVerilog</code> is essentially a pretty-printer.</p>
 
 <h2>The formal path: SMTLIB and Z3</h2>
-<p>For bounded model checking, CIRCT takes a different route. The <code>LowerHWtoBMC</code> pass unrolls the design for N clock cycles and encodes it as a <dfn data-card="SMT (Satisfiability Modulo Theories) is a generalisation of SAT solving. Where SAT works with boolean variables, SMT adds theories for integers, bit-vectors, arrays, and more. An SMT solver like Z3 takes a formula and either finds an assignment that satisfies it (SAT — a counterexample) or proves no such assignment exists (UNSAT — the property holds for all inputs).">SAT/SMT</dfn> formula. If any input sequence in those N cycles can violate a <code>verif.assert</code>, Z3 finds it and returns a counterexample. If Z3 proves no such sequence exists, the assertion is proved for that bound.</p>
+<p>For bounded model checking, MOX takes a different route. The <code>LowerHWtoBMC</code> pass unrolls the design for N clock cycles and encodes it as a <dfn data-card="SMT (Satisfiability Modulo Theories) is a generalisation of SAT solving. Where SAT works with boolean variables, SMT adds theories for integers, bit-vectors, arrays, and more. An SMT solver like Z3 takes a formula and either finds an assignment that satisfies it (SAT — a counterexample) or proves no such assignment exists (UNSAT — the property holds for all inputs).">SAT/SMT</dfn> formula. If any input sequence in those N cycles can violate a <code>verif.assert</code>, Z3 finds it and returns a counterexample. If Z3 proves no such sequence exists, the assertion is proved for that bound.</p>
 <p>This is why formal verification is stronger than simulation: instead of checking the testbench inputs you wrote, it checks <em>every possible input sequence</em> up to the bound.</p>
 
 <h2>Passes are composable</h2>
-<p>A CIRCT pipeline is just a list of pass names. You can run only some passes, inspect the IR in between, or insert your own custom passes. This is MLIR's core promise: the framework handles the plumbing so tool builders can focus on the transformations.</p>
+<p>A MOX pipeline is just a list of pass names. You can run only some passes, inspect the IR in between, or insert your own custom passes. This is MLIR's core promise: the framework handles the plumbing so tool builders can focus on the transformations.</p>
diff --git a/src/lessons/mlir/lowering/lowering.mlir b/src/lessons/mlir/lowering/lowering.mlir
index 4e5320d..19252e7 100644
--- a/src/lessons/mlir/lowering/lowering.mlir
+++ b/src/lessons/mlir/lowering/lowering.mlir
@@ -1,6 +1,6 @@
 // The lowering pipeline — before and after.
 //
-// CIRCT transforms hardware IR through a sequence of passes.
+// MOX transforms hardware IR through a sequence of passes.
 // Each pass lowers one dialect level closer to SystemVerilog text.
 //
 // ─────────────────────────────────────────────────────────────────────────
@@ -51,9 +51,9 @@ hw.module @dff_after(in %d : i8, in %clk : i1, out q : i8) {
 
 
 // ─────────────────────────────────────────────────────────────────────────
-// BONUS: the formal verification path (what circt-bmc does)
+// BONUS: the formal verification path (what mox-bmc does)
 //
-// Instead of going to sv + ExportVerilog, circt-bmc takes the
+// Instead of going to sv + ExportVerilog, mox-bmc takes the
 // hw + comb + seq IR and lowers it to SMT (Satisfiability Modulo Theories):
 //
 //   hw.module + verif.assert
@@ -64,6 +64,6 @@ hw.module @dff_after(in %d : i8, in %clk : i1, out q : i8) {
 //        ↓  ExportSMTLIB
 //   SMTLIB text  →  Z3 solver  →  sat / unsat
 //
-// This is why circt-bmc can exhaustively check all input combinations
+// This is why mox-bmc can exhaustively check all input combinations
 // rather than just the ones your testbench happened to try.
 // ─────────────────────────────────────────────────────────────────────────
diff --git a/src/lessons/mlir/lowering/lowering_tb.mlir b/src/lessons/mlir/lowering/lowering_tb.mlir
index 5bad311..c92b1e7 100644
--- a/src/lessons/mlir/lowering/lowering_tb.mlir
+++ b/src/lessons/mlir/lowering/lowering_tb.mlir
@@ -2,7 +2,7 @@
 // Drive D=0xAA, apply one posedge, confirm Q==0xAA.
 //
 // Note: @dff_after uses sv.reg + sv.always posedge which requires SV-to-LLHD
-// lowering passes not run by circt-sim in standalone mode.  The testbench
+// lowering passes not run by mox-sim in standalone mode.  The testbench
 // therefore exercises only @dff_before (which uses seq.compreg directly).
 hw.module @tb() {
   %false   = hw.constant false
diff --git a/src/lessons/mlir/seq/description.html b/src/lessons/mlir/seq/description.html
index 624e68a..d822cdf 100644
--- a/src/lessons/mlir/seq/description.html
+++ b/src/lessons/mlir/seq/description.html
@@ -1,4 +1,4 @@
-<p>The <dfn data-card="The seq dialect represents sequential (stateful) logic in CIRCT MLIR. Unlike comb, seq operations depend on time: a register remembers its value across clock cycles. seq is deliberately clock-agnostic — the same seq.compreg can describe a flip-flop in a 1 GHz or 10 MHz design. Clock domain crossing, reset insertion, and scan chains are handled as later transformation passes.">seq dialect</dfn> adds <strong>state</strong>. Where comb operations are timeless, seq operations have memory — they remember values across clock cycles.</p>
+<p>The <dfn data-card="The seq dialect represents sequential (stateful) logic in MOX MLIR. Unlike comb, seq operations depend on time: a register remembers its value across clock cycles. seq is deliberately clock-agnostic — the same seq.compreg can describe a flip-flop in a 1 GHz or 10 MHz design. Clock domain crossing, reset insertion, and scan chains are handled as later transformation passes.">seq dialect</dfn> adds <strong>state</strong>. Where comb operations are timeless, seq operations have memory — they remember values across clock cycles.</p>
 
 <h2>seq.compreg — the D flip-flop</h2>
 <p>The core operation is <code>seq.compreg</code>:</p>
diff --git a/src/lessons/mlir/seq/sram_core.mlir b/src/lessons/mlir/seq/sram_core.mlir
index b3d50ae..dd04f97 100644
--- a/src/lessons/mlir/seq/sram_core.mlir
+++ b/src/lessons/mlir/seq/sram_core.mlir
@@ -1,4 +1,4 @@
-// sram_core.sv — rewritten as CIRCT MLIR.
+// sram_core.sv — rewritten as MOX MLIR.
 //
 // The seq dialect represents sequential (stateful) logic.
 // Its key operation is seq.compreg — an abstract D flip-flop:
diff --git a/src/lessons/mlir/seq/sram_core_tb.mlir b/src/lessons/mlir/seq/sram_core_tb.mlir
index 0a6eb67..8bf8e6d 100644
--- a/src/lessons/mlir/seq/sram_core_tb.mlir
+++ b/src/lessons/mlir/seq/sram_core_tb.mlir
@@ -3,7 +3,7 @@
 // confirm Q==0x42 on the output.
 //
 // Note: @sram_core uses seq.hlmem which requires lowering passes not run by
-// circt-sim in standalone mode, so we test the simpler @dff example here.
+// mox-sim in standalone mode, so we test the simpler @dff example here.
 //
 // Uses LLHD dialect for clock generation and time-driven simulation:
 //   llhd.sig / llhd.prb / llhd.drv  — signals and drives
diff --git a/src/lessons/sv/events/event_sync.sol.sv b/src/lessons/sv/events/event_sync.sol.sv
index 8777f63..2527557 100644
--- a/src/lessons/sv/events/event_sync.sol.sv
+++ b/src/lessons/sv/events/event_sync.sol.sv
@@ -5,6 +5,7 @@ module event_sync;
 
   logic [7:0] mem [0:3];
   int         errors = 0;
+  bit         reader_ran = 0;
 
   initial begin
     #10;
@@ -17,13 +18,14 @@ module event_sync;
     @(write_done);
     if (mem[0] !== 8'd10 || mem[1] !== 8'd20) errors++;
     if (mem[2] !== 8'd30 || mem[3] !== 8'd40) errors++;
+    reader_ran = 1;
     $display("reader: %0d error(s)", errors);
     -> read_done;
   end
 
   initial begin
     @(read_done);
-    if (errors == 0) $display("PASS");
+    if (reader_ran && errors == 0) $display("PASS");
     $finish;
   end
 
diff --git a/src/lessons/sv/events/event_sync.sv b/src/lessons/sv/events/event_sync.sv
index 8b2eecd..70e2eb9 100644
--- a/src/lessons/sv/events/event_sync.sv
+++ b/src/lessons/sv/events/event_sync.sv
@@ -7,6 +7,7 @@ module event_sync;
 
   logic [7:0] mem [0:3];
   int         errors = 0;
+  bit         reader_ran = 0;  // set by the reader; checker must observe
 
   // ── Writer ────────────────────────────────────────────────────────────────
   // Fills the array after 10 time units, then signals it is done.
@@ -23,6 +24,7 @@ module event_sync;
     // TODO: wait for write_done before reading
     if (mem[0] !== 8'd10 || mem[1] !== 8'd20) errors++;
     if (mem[2] !== 8'd30 || mem[3] !== 8'd40) errors++;
+    reader_ran = 1;
     $display("reader: %0d error(s)", errors);
     // TODO: post read_done so the checker can report
   end
@@ -31,7 +33,7 @@ module event_sync;
   // Must wait for the reader before declaring the result.
   initial begin
     // TODO: wait for read_done before reporting
-    if (errors == 0) $display("PASS");
+    if (reader_ran && errors == 0) $display("PASS");
     $finish;
   end
 
diff --git a/src/lessons/sva/immediate-assert/description.html b/src/lessons/sva/immediate-assert/description.html
index a095d22..4804c51 100644
--- a/src/lessons/sva/immediate-assert/description.html
+++ b/src/lessons/sva/immediate-assert/description.html
@@ -24,7 +24,7 @@
 <p>The <code>else $error("...")</code> clause prints an automatic timestamp, file name, and line number — far more useful than a bare <code>$display</code>.</p>
 
 <h2>Formal verification with BMC</h2>
-<p>Immediate assertions inside <code>always</code> blocks are also recognized by CIRCT's <dfn data-card="BMC (Bounded Model Checking) unrolls the circuit's behavior for N time steps and encodes it as a SAT/SMT formula. The solver then searches for an assignment of inputs that makes an assertion fail. If no such assignment exists within N steps, the property is proved for that bound.">bounded model checker</dfn>. Instead of running a testbench, BMC exhaustively searches all possible input combinations. If an assertion can be violated, BMC produces a counterexample — without you having to write a single test vector.</p>
+<p>Immediate assertions inside <code>always</code> blocks are also recognized by MOX's <dfn data-card="BMC (Bounded Model Checking) unrolls the circuit's behavior for N time steps and encodes it as a SAT/SMT formula. The solver then searches for an assignment of inputs that makes an assertion fail. If no such assignment exists within N steps, the property is proved for that bound.">bounded model checker</dfn>. Instead of running a testbench, BMC exhaustively searches all possible input combinations. If an assertion can be violated, BMC produces a counterexample — without you having to write a single test vector.</p>
 
 <h2>Exercise</h2>
 <p>Open <code>fifo_checker.sv</code>. The module receives four FIFO status signals and must prevent four illegal conditions. Inside the <code>always @(posedge clk)</code> block, add four immediate assertions:</p>
diff --git a/src/lessons/uvm/ral/description.html b/src/lessons/uvm/ral/description.html
index 276471d..73622d4 100644
--- a/src/lessons/uvm/ral/description.html
+++ b/src/lessons/uvm/ral/description.html
@@ -51,7 +51,7 @@ <h2>UVM RAL hierarchy</h2>
               </svg>
 
               <h2>The starter model</h2>
-              <p>This lesson ships a hand-rolled register model that already compiles and simulates in CIRCT. Study how it maps to the skeleton above before converting it:</p>
+              <p>This lesson ships a hand-rolled register model that already compiles and simulates in MOX. Study how it maps to the skeleton above before converting it:</p>
               <ul>
                 <li><strong>Fields as class members</strong> — <code>logic enable</code> and <code>logic [1:0] mode</code> are plain variables; <code>uvm_reg_field</code> replaces them</li>
                 <li><strong><code>to_data()</code></strong> — packs fields by hand: <code>{5'b0, mode, enable}</code>; <code>uvm_reg::get()</code> does this automatically using the <code>lsb_pos</code> from <code>configure()</code></li>
diff --git a/src/lib/circt.js b/src/lib/circt.js
deleted file mode 100644
index 07de4df..0000000
--- a/src/lib/circt.js
+++ /dev/null
@@ -1 +0,0 @@
-export { getCirctWasmAdapter, createCirctWasmAdapter } from '../runtime/circt-adapter.js';
diff --git a/src/lib/mox.js b/src/lib/mox.js
new file mode 100644
index 0000000..bd170e5
--- /dev/null
+++ b/src/lib/mox.js
@@ -0,0 +1 @@
+export { getMoxWasmAdapter, createMoxWasmAdapter } from '../runtime/mox-adapter.js';
diff --git a/src/lib/offline-cache.js b/src/lib/offline-cache.js
index 9fa93b3..781b330 100644
--- a/src/lib/offline-cache.js
+++ b/src/lib/offline-cache.js
@@ -3,7 +3,7 @@ export const OFFLINE_RUNTIME_CACHE = 'svt-runtime-v1';
 export const OFFLINE_STATE_KEY = 'svt:offline-ready-v1';
 export const OFFLINE_READY_SENTINEL_RELATIVE_PATH = '__offline__/ready';
 
-export const HEAVY_STATIC_PREFIXES = ['circt/', 'surfer/', 'z3/', 'pyodide/'];
+export const HEAVY_STATIC_PREFIXES = ['mox/', 'surfer/', 'z3/', 'pyodide/'];
 
 export const SURFER_RUNTIME_PATHS = [
   'surfer/index.html',
@@ -15,24 +15,24 @@ export const SURFER_RUNTIME_PATHS = [
 ];
 
 export const LOCAL_RUNTIME_PATHS = [
-  'circt/circt-verilog.js',
-  'circt/circt-verilog.wasm',
-  'circt/circt-sim.js',
-  'circt/circt-sim.wasm',
-  'circt/circt-bmc.js',
-  'circt/circt-bmc.wasm',
-  'circt/circt-sim-vpi.js',
-  'circt/circt-sim-vpi.wasm',
-  'circt/circt-lec.js',
-  'circt/circt-lec.wasm',
-  'circt/uvm-core/uvm-manifest.json',
+  'mox/mox-verilog.js',
+  'mox/mox-verilog.wasm',
+  'mox/mox-sim.js',
+  'mox/mox-sim.wasm',
+  'mox/mox-bmc.js',
+  'mox/mox-bmc.wasm',
+  'mox/mox-sim-vpi.js',
+  'mox/mox-sim-vpi.wasm',
+  'mox/mox-lec.js',
+  'mox/mox-lec.wasm',
+  'mox/uvm-core/uvm-manifest.json',
   'z3/z3-built.js',
   'z3/z3-built.wasm',
   ...SURFER_RUNTIME_PATHS,
 ];
 
 export const PYODIDE_MANIFEST_RELATIVE_PATH = 'pyodide/pyodide-manifest.json';
-export const UVM_MANIFEST_RELATIVE_PATH = 'circt/uvm-core/uvm-manifest.json';
+export const UVM_MANIFEST_RELATIVE_PATH = 'mox/uvm-core/uvm-manifest.json';
 
 export const PYODIDE_COMPANION_FILES = [
   'pyodide.js',
diff --git a/src/lib/offline-cache.test.js b/src/lib/offline-cache.test.js
index ea4b767..25bf777 100644
--- a/src/lib/offline-cache.test.js
+++ b/src/lib/offline-cache.test.js
@@ -16,7 +16,7 @@ describe('offline-cache helpers', () => {
     expect(normalizeBasePath('')).toBe('/');
     expect(normalizeBasePath('/sv-tutorial')).toBe('/sv-tutorial/');
     expect(normalizeBasePath('sv-tutorial')).toBe('/sv-tutorial/');
-    expect(joinBasePath('/sv-tutorial', '/circt/circt-sim.js')).toBe('/sv-tutorial/circt/circt-sim.js');
+    expect(joinBasePath('/sv-tutorial', '/mox/mox-sim.js')).toBe('/sv-tutorial/mox/mox-sim.js');
   });
 
   it('dedupes string values', () => {
diff --git a/src/routes/+layout.svelte b/src/routes/+layout.svelte
index afbba94..3ab97bc 100644
--- a/src/routes/+layout.svelte
+++ b/src/routes/+layout.svelte
@@ -5,7 +5,7 @@
   import { browser } from '$app/environment';
   import { onMount, untrack } from 'svelte';
   import '../app.css';
-  import { getCirctRuntimeConfig, Z3_SCRIPT_URL } from '../runtime/circt-config.js';
+  import { getMoxRuntimeConfig, Z3_SCRIPT_URL } from '../runtime/mox-config.js';
   import {
     OFFLINE_APP_CACHE_PREFIX,
     OFFLINE_RUNTIME_CACHE,
@@ -267,7 +267,7 @@
 
     try {
       await ensureOfflineServiceWorker();
-      const config = getCirctRuntimeConfig();
+      const config = getMoxRuntimeConfig();
       const allUrls = await resolveOfflineAssetUrls(config);
       const urls = allUrls.filter((url) => isSameOriginAssetUrl(url));
       const skippedCrossOrigin = allUrls.length - urls.length;
diff --git a/src/routes/lesson/[part]/[name]/+page.svelte b/src/routes/lesson/[part]/[name]/+page.svelte
index 76795fb..0bf0097 100644
--- a/src/routes/lesson/[part]/[name]/+page.svelte
+++ b/src/routes/lesson/[part]/[name]/+page.svelte
@@ -3,7 +3,7 @@
   import { browser } from '$app/environment';
   import { beforeNavigate, goto } from '$app/navigation';
   import { base } from '$app/paths';
-  import { getCirctWasmAdapter } from '$lib/circt.js';
+  import { getMoxWasmAdapter } from '$lib/mox.js';
   import { darkMode, vimMode } from '$lib/stores/settings.js';
   import { completedSlugs } from '$lib/stores/completed.js';
   import { cloneFiles, mergeFiles, filesEqual, topNameFromFocus } from '$lib/lesson-utils.js';
@@ -38,7 +38,7 @@
   let showCopyModal = $state(false);
   let copyEnableChecked = $state(false);
   let didAnnounceTrimThisRun = $state(false);
-  let circt = $state(null);
+  let mox = $state(null);
   let glossaryCard = $state(null); // { body, top, left }
   let waveformRef = $state(null);
   let waveSignalsReady = $state(false);
@@ -131,7 +131,7 @@
   }
 
   onMount(() => {
-    circt = getCirctWasmAdapter();
+    mox = getMoxWasmAdapter();
     if (browser && sessionStorage.getItem('copyEnabled') === 'true') copyEnabled = true;
     _currentSlug = lesson.slug;
     _loadWorkspace(lesson);
@@ -347,7 +347,7 @@
   }
 
   async function runSim(mode = 'sim') {
-    if (running || !circt) return;
+    if (running || !mox) return;
     running = true;
     runMode = mode;
     runPhase = 'compiling';
@@ -374,7 +374,7 @@
       };
 
       if (lesson.runner === 'cocotb') {
-        const result = await circt.runCocotb({
+        const result = await mox.runCocotb({
           files: workspace,
           top: topNameFromFocus(lesson.focus),
           onStatus, onLog
@@ -382,7 +382,7 @@
         if (streamedEntries === 0) for (const entry of result.logs || []) appendLogEntry(entry);
         else mergeNonStreamResultLogs(result.logs);
       } else if (useLec) {
-        const result = await circt.runLec({
+        const result = await mox.runLec({
           files: workspace,
           module1: lesson.module1 || 'Spec',
           module2: lesson.module2 || 'Impl',
@@ -391,7 +391,7 @@
         if (streamedEntries === 0) for (const entry of result.logs || []) appendLogEntry(entry);
         else mergeNonStreamResultLogs(result.logs);
       } else if (useBmc) {
-        const result = await circt.runBmc({
+        const result = await mox.runBmc({
           files: workspace,
           top: topNameFromFocus(lesson.focus),
           onStatus, onLog
@@ -399,7 +399,7 @@
         if (streamedEntries === 0) for (const entry of result.logs || []) appendLogEntry(entry);
         else mergeNonStreamResultLogs(result.logs);
       } else {
-        const result = await circt.run({
+        const result = await mox.run({
           files: workspace,
           top: topNameFromFocus(lesson.focus),
           simulate: lesson.simulate,
@@ -418,8 +418,8 @@
   }
 
   function cancelRun() {
-    if (!running || !circt) return;
-    circt.cancel();
+    if (!running || !mox) return;
+    mox.cancel();
     appendLogEntry('# run cancelled');
   }
 
diff --git a/src/runtime/circt-config.js b/src/runtime/circt-config.js
deleted file mode 100644
index 85e4b69..0000000
--- a/src/runtime/circt-config.js
+++ /dev/null
@@ -1,139 +0,0 @@
-export const CIRCT_FORK_REPO = 'git@github.com:thomasnormal/circt.git';
-
-function normalizeBaseUrl(raw) {
-  const base = String(raw || '').trim();
-  if (!base || base === '.' || base === './') return '/';
-
-  // Normalize optional leading "./" used by static builds.
-  const noDotPrefix = base.startsWith('./') ? base.slice(1) : base;
-  const withLeadingSlash = noDotPrefix.startsWith('/') ? noDotPrefix : `/${noDotPrefix}`;
-  const withTrailingSlash = withLeadingSlash.endsWith('/')
-    ? withLeadingSlash
-    : `${withLeadingSlash}/`;
-
-  // Remove "/./" segments so "/./circt" becomes "/circt".
-  return withTrailingSlash.replace(/\/\.\//g, '/');
-}
-
-const BASE = normalizeBaseUrl(import.meta.env.VITE_BASE || import.meta.env.BASE_URL);
-
-export function getRuntimeBasePath() {
-  return BASE;
-}
-
-export const Z3_SCRIPT_URL = `${BASE}z3/z3-built.js`;
-const DEFAULT_TOOLCHAIN = {
-  verilog: {
-    js: `${BASE}circt/circt-verilog.js`,
-    wasm: `${BASE}circt/circt-verilog.wasm`
-  },
-  sim: {
-    js: `${BASE}circt/circt-sim.js`,
-    wasm: `${BASE}circt/circt-sim.wasm`
-  },
-  bmc: {
-    js: `${BASE}circt/circt-bmc.js`,
-    wasm: `${BASE}circt/circt-bmc.wasm`
-  },
-  simVpi: {
-    js: `${BASE}circt/circt-sim-vpi.js`,
-    wasm: `${BASE}circt/circt-sim-vpi.wasm`
-  },
-  lec: {
-    js: `${BASE}circt/circt-lec.js`,
-    wasm: `${BASE}circt/circt-lec.wasm`
-  }
-};
-
-const DEFAULT_VERILOG_ARGS = ['--resource-guard=false', '--ir-llhd', '--timescale', '1ns/1ns', '--single-unit'];
-const DEFAULT_LEC_VERILOG_ARGS = ['--resource-guard=false', '--ir-hw', '--single-unit'];
-const DEFAULT_LEC_ARGS = [
-  '--resource-guard=false',
-  '--assume-known-inputs',
-  '-c1', '{module1}',
-  '-c2', '{module2}',
-  '--emit-smtlib',
-  '-o', '/workspace/out/check.smt2',
-  '{input}'
-];
-const DEFAULT_SIM_ARGS = ['--resource-guard=false'];
-const DEFAULT_BMC_ARGS = [
-  '--resource-guard=false',
-  '--assume-known-inputs',
-  '-b',
-  '20',
-  '--module',
-  '{top}',
-  '--emit-smtlib',
-  '-o',
-  '/workspace/out/check.smt2',
-  '{input}'
-];
-
-function parseArgs(raw, fallback) {
-  if (!raw) return fallback;
-  try {
-    const parsed = JSON.parse(raw);
-    if (Array.isArray(parsed) && parsed.every((v) => typeof v === 'string')) {
-      return parsed;
-    }
-  } catch {
-    // Fallback to a simple shell-like split for convenience.
-  }
-  return raw
-    .split(' ')
-    .map((s) => s.trim())
-    .filter(Boolean);
-}
-
-function pickUrlFromEnv(primary, fallback) {
-  return primary || fallback;
-}
-
-export function getCirctRuntimeConfig() {
-  return {
-    toolchain: {
-      verilog: {
-        js: pickUrlFromEnv(import.meta.env.VITE_CIRCT_VERILOG_JS_URL, DEFAULT_TOOLCHAIN.verilog.js),
-        wasm: pickUrlFromEnv(import.meta.env.VITE_CIRCT_VERILOG_WASM_URL, DEFAULT_TOOLCHAIN.verilog.wasm)
-      },
-      sim: {
-        js: pickUrlFromEnv(import.meta.env.VITE_CIRCT_SIM_JS_URL, DEFAULT_TOOLCHAIN.sim.js),
-        wasm: pickUrlFromEnv(import.meta.env.VITE_CIRCT_SIM_WASM_URL, DEFAULT_TOOLCHAIN.sim.wasm)
-      },
-      bmc: {
-        js: pickUrlFromEnv(import.meta.env.VITE_CIRCT_BMC_JS_URL, DEFAULT_TOOLCHAIN.bmc.js),
-        wasm: pickUrlFromEnv(import.meta.env.VITE_CIRCT_BMC_WASM_URL, DEFAULT_TOOLCHAIN.bmc.wasm)
-      },
-      simVpi: {
-        js: pickUrlFromEnv(import.meta.env.VITE_CIRCT_SIM_VPI_JS_URL, DEFAULT_TOOLCHAIN.simVpi.js),
-        wasm: pickUrlFromEnv(import.meta.env.VITE_CIRCT_SIM_VPI_WASM_URL, DEFAULT_TOOLCHAIN.simVpi.wasm)
-      },
-      lec: {
-        js: pickUrlFromEnv(import.meta.env.VITE_CIRCT_LEC_JS_URL, DEFAULT_TOOLCHAIN.lec.js),
-        wasm: pickUrlFromEnv(import.meta.env.VITE_CIRCT_LEC_WASM_URL, DEFAULT_TOOLCHAIN.lec.wasm)
-      }
-    },
-    pyodideUrl: import.meta.env.VITE_PYODIDE_URL || `${BASE}pyodide/pyodide.js`,
-    verilogArgs: parseArgs(import.meta.env.VITE_CIRCT_VERILOG_ARGS, DEFAULT_VERILOG_ARGS),
-    simArgs: parseArgs(import.meta.env.VITE_CIRCT_SIM_ARGS, DEFAULT_SIM_ARGS),
-    bmcArgs: parseArgs(import.meta.env.VITE_CIRCT_BMC_ARGS, DEFAULT_BMC_ARGS),
-    lecVerilogArgs: parseArgs(import.meta.env.VITE_CIRCT_LEC_VERILOG_ARGS, DEFAULT_LEC_VERILOG_ARGS),
-    lecArgs: parseArgs(import.meta.env.VITE_CIRCT_LEC_ARGS, DEFAULT_LEC_ARGS),
-    note: import.meta.env.VITE_CIRCT_NOTE || ''
-  };
-}
-
-export function getRuntimeEnvDoc() {
-  return {
-    VITE_CIRCT_VERILOG_JS_URL: 'circt-verilog JS artifact URL.',
-    VITE_CIRCT_VERILOG_WASM_URL: 'circt-verilog WASM artifact URL.',
-    VITE_CIRCT_SIM_JS_URL: 'circt-sim JS artifact URL.',
-    VITE_CIRCT_SIM_WASM_URL: 'circt-sim WASM artifact URL.',
-    VITE_CIRCT_BMC_JS_URL: 'circt-bmc JS artifact URL.',
-    VITE_CIRCT_BMC_WASM_URL: 'circt-bmc WASM artifact URL.',
-    VITE_CIRCT_VERILOG_ARGS: 'JSON array or space-separated args passed before source files.',
-    VITE_CIRCT_SIM_ARGS: 'JSON array or space-separated args passed before MLIR input.',
-    VITE_CIRCT_BMC_ARGS: 'JSON array or space-separated args for BMC fallback.'
-  };
-}
diff --git a/src/runtime/cocotb-shim.py b/src/runtime/cocotb-shim.py
index c73abe0..e10b5db 100644
--- a/src/runtime/cocotb-shim.py
+++ b/src/runtime/cocotb-shim.py
@@ -1,5 +1,5 @@
 """
-Minimal cocotb-compatible API for in-browser simulation via Pyodide + CIRCT WASM VPI.
+Minimal cocotb-compatible API for in-browser simulation via Pyodide + MOX WASM VPI.
 
 User-facing API (matches real cocotb):
     import cocotb
diff --git a/src/runtime/cocotb-worker-source.js b/src/runtime/cocotb-worker-source.js
index 72bb657..b292a8c 100644
--- a/src/runtime/cocotb-worker-source.js
+++ b/src/runtime/cocotb-worker-source.js
@@ -375,7 +375,7 @@ self.onmessage = async function(event) {
   }
 
   try {
-    // ── 1. Load the VPI circt-sim WASM ───────────────────────────────────────
+    // ── 1. Load the VPI mox-sim WASM ───────────────────────────────────────
     // Fetch the JS source first so we can detect NODERAWFS=1 (recognisable by
     // the unconditional require('path') / require('fs') calls at module level).
     var simInMemFS = null;
@@ -387,7 +387,7 @@ self.onmessage = async function(event) {
       printErr: function(line) { onLog(String(line)); },
       locateFile: function(path) { return path.endsWith('.wasm') ? simWasmUrl : path; },
       instantiateWasm: function(imports, callback) {
-        // Wrap _circt_vpi_wasm_yield (import 'r') with Asyncify.handleAsync so
+        // Wrap _mox_vpi_wasm_yield (import 'r') with Asyncify.handleAsync so
         // WASM calls to the yield import trigger Asyncify unwind/rewind instead
         // of running synchronously (instrumentWasmImports is never called by the
         // compiled artifact's createWasm(), so we must wrap here ourselves).
@@ -443,7 +443,7 @@ self.onmessage = async function(event) {
     });
 
     // ── 1b. Patch Module to expose Emscripten internals needed by VPI helpers ─
-    // circt-sim-vpi.js assigns _malloc/_free to module-level globals but not to
+    // mox-sim-vpi.js assigns _malloc/_free to module-level globals but not to
     // Module["_malloc"] / Module["_free"].  setValue/getValue and HEAPU8 are
     // absent from EXPORTED_RUNTIME_METHODS for this build.  After importScripts
     // (or indirect eval) these become worker-scope globals we can forward.
@@ -536,7 +536,7 @@ self.onmessage = async function(event) {
     // ── 7. Create a no-op cb_rtn function pointer for VPI callbacks ──────────
     // VPIRuntime::registerCb rejects null cb_rtn (returns 0 without storing).
     // We need a valid WASM (i32)->i32 function pointer for the cb_rtn field.
-    // Compile a tiny WASM module and insert its export into circt-sim's table.
+    // Compile a tiny WASM module and insert its export into mox-sim's table.
     // Fallback to WebAssembly.Function (Chrome 97+) or placeholder value 1.
     var noopCbPtr = wsAddFunctionToTable(WS_NOOP_CB_WASM);
     if (!noopCbPtr) { try {
@@ -544,7 +544,7 @@ self.onmessage = async function(event) {
       var tbl = wasmTable; var s = tbl.length; tbl.grow(1); tbl.set(s, cFn); noopCbPtr = s;
     } catch(_) {} }
     // Last resort: value 1 — registerCb only checks non-zero; the patched
-    // _circt_vpi_wasm_yield wraps the table call in try-catch.
+    // _mox_vpi_wasm_yield wraps the table call in try-catch.
     var cbRtn = noopCbPtr || 1;
 
     // ── 8. Install a VPI startup routine in the WASM function table ──────────
@@ -553,7 +553,7 @@ self.onmessage = async function(event) {
     //
     // Fix: compile a tiny WASM module (type ()->()) that imports one JS function
     // "r" and calls it. Insert the export into a null slot in the WASM table,
-    // then call _vpi_startup_register(slot). circt-sim invokes startup routines
+    // then call _vpi_startup_register(slot). mox-sim invokes startup routines
     // via invoke_v(slot) inside callMain once active=true, so "r" runs and can
     // call _vpi_register_cb successfully to register cbStartOfSimulation.
     //
@@ -604,12 +604,12 @@ self.onmessage = async function(event) {
     }
 
     // ── 9. Set up the Asyncify yield hook ─────────────────────────────────────
-    // _circt_vpi_wasm_yield (in circt-sim-vpi.js) calls:
-    //   await globalThis.circtSimVpiYieldHook(cbFuncPtr, cbDataPtr)
+    // _mox_vpi_wasm_yield (in mox-sim-vpi.js) calls:
+    //   await globalThis.moxSimVpiYieldHook(cbFuncPtr, cbDataPtr)
     //   try { wasmTable.get(cbFuncPtr)(cbDataPtr) } catch(e) {}  [patched]
     // Our hook handles all Python dispatch; cbRtn is always non-zero, which
     // satisfies registerCb's cb_rtn check. The wasmTable callback is wrapped.
-    self.circtSimVpiYieldHook = async function(_cbFuncPtr, cbDataPtr) {
+    self.moxSimVpiYieldHook = async function(_cbFuncPtr, cbDataPtr) {
       var reason    = simModule.getValue(cbDataPtr +  0, 'i32');
       var triggerId = simModule.getValue(cbDataPtr + 24, 'i32');
 
@@ -675,7 +675,7 @@ self.onmessage = async function(event) {
       '--top', topModule,
       mlirPath
     ];
-    onLog('$ ' + ['circt-sim'].concat(simArgs).map(wsShellQuote).join(' '));
+    onLog('$ ' + ['mox-sim'].concat(simArgs).map(wsShellQuote).join(' '));
     try {
       simModule.callMain(simArgs);
     } catch(e) {
diff --git a/src/runtime/lec-model.test.js b/src/runtime/lec-model.test.js
index b861582..8d01b90 100644
--- a/src/runtime/lec-model.test.js
+++ b/src/runtime/lec-model.test.js
@@ -1,7 +1,7 @@
 /**
  * Unit tests for LEC counterexample extraction.
  *
- * These tests exercise the same C API calls that circt-adapter.js uses in the
+ * These tests exercise the same C API calls that mox-adapter.js uses in the
  * browser (Z3_mk_config / Z3_mk_context / Z3_eval_smtlib2_string / Z3_del_context)
  * but run them in Node.js via the z3-solver package — the same WASM binary that
  * gets served to the browser at /z3/z3-built.js.
@@ -23,7 +23,7 @@ beforeAll(async () => {
   ({ em } = await init());
 }, 30_000);
 
-// Mirror the evalSmtlib function from circt-adapter.js exactly.
+// Mirror the evalSmtlib function from mox-adapter.js exactly.
 function evalSmtlib(smtlibText, { produceModels = false, em: emOverride = null } = {}) {
   const mod = emOverride ?? em;
   const cfg = mod.ccall('Z3_mk_config', 'number', [], []);
@@ -39,7 +39,7 @@ function evalSmtlib(smtlibText, { produceModels = false, em: emOverride = null }
   }
 }
 
-// Mirror the model parsing from circt-adapter.js exactly.
+// Mirror the model parsing from mox-adapter.js exactly.
 function parseModel(modelOut) {
   const modelFlat = (modelOut || '').replace(/\s+/g, ' ');
   const assignments = [];
diff --git a/src/runtime/circt-adapter.js b/src/runtime/mox-adapter.js
similarity index 93%
rename from src/runtime/circt-adapter.js
rename to src/runtime/mox-adapter.js
index ef930d8..cc8294e 100644
--- a/src/runtime/circt-adapter.js
+++ b/src/runtime/mox-adapter.js
@@ -1,4 +1,4 @@
-import { CIRCT_FORK_REPO, getCirctRuntimeConfig, getRuntimeBasePath, Z3_SCRIPT_URL } from './circt-config.js';
+import { MOX_FORK_REPO, getMoxRuntimeConfig, getRuntimeBasePath, Z3_SCRIPT_URL } from './mox-config.js';
 import COCOTB_SHIM from './cocotb-shim.py?raw';
 import { COCOTB_WORKER_SOURCE } from './cocotb-worker-source.js';
 import { WORKER_RUNTIME_HELPERS_SOURCE } from './worker-runtime-helpers-source.js';
@@ -164,7 +164,7 @@ function needsUvmLibrary(files) {
   );
 }
 
-// circt-sim inlines child-instance ports as dotted names (e.g. "dut.sum") into
+// mox-sim inlines child-instance ports as dotted names (e.g. "dut.sum") into
 // the parent scope alongside the parent wire ("result"). Strip those duplicates
 // so the waveform viewer only shows the canonical wire name.
 function removeInlinedPortsFromVcd(vcd) {
@@ -202,7 +202,7 @@ function removeInlinedPortsFromVcd(vcd) {
   }).join('\n');
 }
 
-// CIRCT/LLHD encodes every 4-state `logic` bit as a 2-bit pair in VCD:
+// MOX/LLHD encodes every 4-state `logic` bit as a 2-bit pair in VCD:
 //   high bit = value (0 or 1)
 //   low bit  = 4-state flag (0 = known, 1 = x or z)
 // This doubles the declared width of every logic signal, so Surfer displays the
@@ -265,8 +265,8 @@ function fixLlhdVcdEncoding(vcd) {
 
 function addMissingLlhdSignalNames(mlirText) {
   if (typeof mlirText !== 'string') return null;
-  // Add name attributes to llhd.sig ops that lack them so circt-sim's VCD
-  // writer can emit $var entries. circt-verilog only sets name on module
+  // Add name attributes to llhd.sig ops that lack them so mox-sim's VCD
+  // writer can emit $var entries. mox-verilog only sets name on module
   // port connections; testbench-level logic signals get no name attribute.
   // We use the SSA result identifier (%clk -> name "clk") as the signal name.
   return mlirText.replace(
@@ -348,7 +348,7 @@ function isRetryableVerilogCrashText(text) {
   return /memory access out of bounds|Malformed attribute storage object|Aborted\(/i.test(value);
 }
 
-const UVM_FS_ROOT = '/circt/uvm-core';
+const UVM_FS_ROOT = '/mox/uvm-core';
 const UVM_INCLUDE_ROOT = `${UVM_FS_ROOT}/src`;
 const UVM_SIM_MAX_TIME_FS = '1000000';
 
@@ -472,7 +472,7 @@ function readWorkspaceFiles(FS, paths) {
 
 ${WORKER_RUNTIME_HELPERS_SOURCE}
 
-// In-memory filesystem for Emscripten NODERAWFS builds (like circt-sim.js).
+// In-memory filesystem for Emscripten NODERAWFS builds (like mox-sim.js).
 // NODERAWFS replaces the entire Emscripten FS layer with direct Node.js fs calls.
 // We provide a fake require('fs') that stores data in memory so that
 // module.FS.writeFile / callMain / module.FS.readFile all share the same store.
@@ -486,9 +486,9 @@ function makeInMemFS(onStdoutChunk = null, onStderrChunk = null) {
     '/workspace',
     '/workspace/src',
     '/workspace/out',
-    '/circt',
-    '/circt/uvm-core',
-    '/circt/uvm-core/src'
+    '/mox',
+    '/mox/uvm-core',
+    '/mox/uvm-core/src'
   ]);
   var fds = {};
   var nextFd = 3;
@@ -739,7 +739,7 @@ function makeInMemFS(onStdoutChunk = null, onStderrChunk = null) {
   };
 }
 
-var circtWorkerRuntimeReady = false;
+var moxWorkerRuntimeReady = false;
 
 function getModuleValue(module, name) {
   if (!module) return null;
@@ -791,7 +791,7 @@ function waitForRuntime(timeoutMs = 45000) {
         const fsApi = resolveFS(module);
 
         if (
-          circtWorkerRuntimeReady &&
+          moxWorkerRuntimeReady &&
           module &&
           !!callMain &&
           !!main &&
@@ -854,8 +854,8 @@ self.onmessage = async (event) => {
     self.Module = {
       noInitialRun: true,
       onRuntimeInitialized: () => {
-        console.log('[circt-worker] onRuntimeInitialized fired');
-        circtWorkerRuntimeReady = true;
+        console.log('[mox-worker] onRuntimeInitialized fired');
+        moxWorkerRuntimeReady = true;
       },
       print: (line) => appendStreamLine('stdout', line),
       printErr: (line) => appendStreamLine('stderr', line),
@@ -865,23 +865,23 @@ self.onmessage = async (event) => {
       },
       // Use streaming WASM compilation for all tools to avoid slow sync readBinary path.
       instantiateWasm: function(imports, callback) {
-        console.log('[circt-worker] instantiateWasm called for', req.wasmUrl);
+        console.log('[mox-worker] instantiateWasm called for', req.wasmUrl);
         WebAssembly.instantiateStreaming(fetch(req.wasmUrl), imports)
           .then(function(result) {
-            console.log('[circt-worker] instantiateStreaming succeeded');
+            console.log('[mox-worker] instantiateStreaming succeeded');
             callback(result.instance, result.module);
           })
           .catch(function(streamErr) {
-            console.log('[circt-worker] instantiateStreaming failed, trying ArrayBuffer fallback:', String(streamErr));
+            console.log('[mox-worker] instantiateStreaming failed, trying ArrayBuffer fallback:', String(streamErr));
             return fetch(req.wasmUrl)
               .then(function(r) { return r.arrayBuffer(); })
               .then(function(buf) { return WebAssembly.instantiate(buf, imports); })
               .then(function(result) {
-                console.log('[circt-worker] ArrayBuffer instantiate succeeded');
+                console.log('[mox-worker] ArrayBuffer instantiate succeeded');
                 callback(result.instance, result.module);
               })
               .catch(function(abErr) {
-                console.error('[circt-worker] both WASM instantiation paths failed:', String(abErr));
+                console.error('[mox-worker] both WASM instantiation paths failed:', String(abErr));
               });
           });
         return {};
@@ -895,7 +895,7 @@ self.onmessage = async (event) => {
       makeFs: function() {
         // NODERAWFS builds call require('path') / require('fs') at module scope.
         // Provide a Node-like fs backed by memory so tool I/O stays in-worker.
-        console.log('[circt-worker] NODERAWFS detected, setting up Node.js emulation');
+        console.log('[mox-worker] NODERAWFS detected, setting up Node.js emulation');
         inMemFS = makeInMemFS(
           (text) => appendStreamText('stdout', text),
           (text) => appendStreamText('stderr', text)
@@ -904,11 +904,11 @@ self.onmessage = async (event) => {
       },
       onStdout: function(s) { appendStreamText('stdout', s); },
       onStderr: function(s) { appendStreamText('stderr', s); },
-      beforeEval: function() { console.log('[circt-worker] starting eval of tool script'); },
-      afterEval: function() { console.log('[circt-worker] eval complete'); }
+      beforeEval: function() { console.log('[mox-worker] starting eval of tool script'); },
+      afterEval: function() { console.log('[mox-worker] eval complete'); }
     });
 
-    console.log('[circt-worker] waiting for runtime...');
+    console.log('[mox-worker] waiting for runtime...');
     const module = await waitForRuntime();
     const fsApi = resolveFS(module);
     if (!fsApi) {
@@ -962,7 +962,7 @@ self.onmessage = async (event) => {
 
       const rootPath = (manifest && typeof manifest.rootPath === 'string' && manifest.rootPath.length > 0)
         ? manifest.rootPath
-        : '/circt/uvm-core/src';
+        : '/mox/uvm-core/src';
       const relPaths = Array.isArray(manifest && manifest.files) ? manifest.files : [];
       const srcBaseUrl = new URL('src/', manifestUrl).href;
       for (const relRaw of relPaths) {
@@ -1001,7 +1001,7 @@ self.onmessage = async (event) => {
         }
       }
     }
-    console.log('[circt-worker] runtime ready, writing files');
+    console.log('[mox-worker] runtime ready, writing files');
     if (inMemFS) {
       for (const [path, content] of Object.entries(req.files || {})) {
         inMemFS.writeTextFile(String(path), content);
@@ -1016,12 +1016,12 @@ self.onmessage = async (event) => {
       }
     }
 
-    console.log('[circt-worker] calling callMain with args:', req.args);
+    console.log('[mox-worker] calling callMain with args:', req.args);
     let exitCode = 0;
     try {
       const callMain = resolveCallMain(module);
       if (!callMain) {
-        throw new Error('CIRCT runtime is missing callMain entrypoint');
+        throw new Error('MOX runtime is missing callMain entrypoint');
       }
       const ret = callMain(Array.isArray(req.args) ? req.args : []);
       if (typeof ret === 'number' && Number.isFinite(ret)) {
@@ -1031,7 +1031,7 @@ self.onmessage = async (event) => {
       if (!isExitException(error)) throw error;
       exitCode = extractExitCode(error);
     }
-    console.log('[circt-worker] callMain done, exitCode:', exitCode);
+    console.log('[mox-worker] callMain done, exitCode:', exitCode);
 
     flushStreamRemainders();
     const files = inMemFS
@@ -1233,18 +1233,18 @@ function toAbsoluteUrl(rawUrl) {
 }
 
 function getUvmManifestUrl() {
-  return toAbsoluteUrl(`${getRuntimeBasePath()}circt/uvm-core/uvm-manifest.json`);
+  return toAbsoluteUrl(`${getRuntimeBasePath()}mox/uvm-core/uvm-manifest.json`);
 }
 
 // ── Cocotb worker ─────────────────────────────────────────────────────────────
 // Self-contained Web Worker source for running cocotb tests via Pyodide +
-// a VPI-capable, Asyncify-transformed circt-sim WASM.
+// a VPI-capable, Asyncify-transformed mox-sim WASM.
 //
-// circt-sim-vpi may be built with NODERAWFS=1 (the Emscripten default).
+// mox-sim-vpi may be built with NODERAWFS=1 (the Emscripten default).
 // In that case importScripts() fails immediately because the script calls
 // require('path') at module level.  We detect this and fall back to eval()
 // with a fake Node.js environment backed by an in-memory filesystem, exactly
-// like WORKER_SOURCE does for the regular circt-sim.
+// like WORKER_SOURCE does for the regular mox-sim.
 
 let cocotbWorkerBlobUrl = null;
 
@@ -1328,10 +1328,10 @@ function runCocotbInWorker({
   });
 }
 
-export class CirctWasmAdapter {
+export class MoxWasmAdapter {
   constructor() {
-    this.repo = CIRCT_FORK_REPO;
-    this.config = getCirctRuntimeConfig();
+    this.repo = MOX_FORK_REPO;
+    this.config = getMoxRuntimeConfig();
     this.ready = false;
     this._runController = null;
   }
@@ -1350,7 +1350,7 @@ export class CirctWasmAdapter {
     });
 
     if (missing.length) {
-      throw new Error(`CIRCT toolchain is incomplete in config: ${missing.join(', ')}`);
+      throw new Error(`MOX toolchain is incomplete in config: ${missing.join(', ')}`);
     }
 
     this.ready = true;
@@ -1361,7 +1361,7 @@ export class CirctWasmAdapter {
     { args, files = {}, readFiles = [], createDirs = [], uvmManifestUrl = null, onOutput = null }
   ) {
     const tool = this.config.toolchain[toolName];
-    if (!tool) throw new Error(`Unknown CIRCT tool: ${toolName}`);
+    if (!tool) throw new Error(`Unknown MOX tool: ${toolName}`);
 
     return runToolInWorker({
       jsUrl: toAbsoluteUrl(tool.js),
@@ -1382,17 +1382,17 @@ export class CirctWasmAdapter {
     try {
       await this.init();
 
-      logs.push(formatCommand('circt-verilog', ['--help']));
+      logs.push(formatCommand('mox-verilog', ['--help']));
       const verilogHelp = await this._invokeTool('verilog', {
         args: ['--help']
       });
-      appendNonZeroExit(logs, 'circt-verilog', verilogHelp.exitCode);
+      appendNonZeroExit(logs, 'mox-verilog', verilogHelp.exitCode);
 
-      logs.push(formatCommand('circt-sim', ['--help']));
+      logs.push(formatCommand('mox-sim', ['--help']));
       const simHelp = await this._invokeTool('sim', {
         args: ['--help']
       });
-      appendNonZeroExit(logs, 'circt-sim', simHelp.exitCode);
+      appendNonZeroExit(logs, 'mox-sim', simHelp.exitCode);
 
       const ok = verilogHelp.exitCode === 0 && simHelp.exitCode === 0;
       if (verilogHelp.stderr) logs.push(`[stderr] ${verilogHelp.stderr}`);
@@ -1495,7 +1495,7 @@ export class CirctWasmAdapter {
         for (let attempt = 0; attempt < compilePlans.length; attempt += 1) {
           const plan = compilePlans[attempt];
           if (attempt > 0) {
-            emitLog(`# circt-verilog: retrying in ${plan.label}`);
+            emitLog(`# mox-verilog: retrying in ${plan.label}`);
           }
           if (plan.bundledCompile.bundled) {
             emitLog(
@@ -1503,7 +1503,7 @@ export class CirctWasmAdapter {
               'for stable UVM compilation'
             );
           }
-          emitLog(formatCommand('circt-verilog', plan.compileArgs));
+          emitLog(formatCommand('mox-verilog', plan.compileArgs));
 
           const compileStream = makeToolOutputHandler();
           let attemptCompile;
@@ -1519,7 +1519,7 @@ export class CirctWasmAdapter {
           } catch (error) {
             const text = String(error?.message || error || '');
             if (useFullUvm && text.includes('Aborted(OOM)')) {
-              emitLog('# circt-verilog: out of memory compiling UVM — rebuild wasm with larger heap');
+              emitLog('# mox-verilog: out of memory compiling UVM — rebuild wasm with larger heap');
               if (typeof onStatus === 'function') onStatus('done');
               return { ok: false, logs, waveform: null };
             }
@@ -1531,7 +1531,7 @@ export class CirctWasmAdapter {
             if (attemptCompile.stdout) emitLog(`[stdout] ${attemptCompile.stdout}`);
             if (attemptCompile.stderr) emitLog(`[stderr] ${attemptCompile.stderr}`);
           }
-          appendNonZeroExit(logs, 'circt-verilog', attemptCompile.exitCode, emitLog);
+          appendNonZeroExit(logs, 'mox-verilog', attemptCompile.exitCode, emitLog);
 
           const rawMlir = attemptCompile.files?.[mlirPath] || null;
           const attemptLoweredMlir = addMissingLlhdSignalNames(rawMlir);
@@ -1595,7 +1595,7 @@ export class CirctWasmAdapter {
         if (withTraceAll) simArgs.push('--trace-all');
         simArgs.push(mlirPath);
 
-        emitLog(formatCommand('circt-sim', simArgs));
+        emitLog(formatCommand('mox-sim', simArgs));
         const sim = await this._invokeTool('sim', {
           args: simArgs,
           files: {
@@ -1606,7 +1606,7 @@ export class CirctWasmAdapter {
           onOutput: simStream.onOutput
         });
         if (sim.exitCode !== 0 && isRetryableSimAbortText(sim.stderr)) {
-          throw new Error(String(sim.stderr || `circt-sim exited ${sim.exitCode}`));
+          throw new Error(String(sim.stderr || `mox-sim exited ${sim.exitCode}`));
         }
         return { sim, withVcd };
       };
@@ -1617,13 +1617,13 @@ export class CirctWasmAdapter {
       } catch (error) {
         const retryable = isRetryableSimAbortText(error?.message || error);
         if (!retryable) throw error;
-        emitLog('# circt-sim: runtime abort with --trace-all; retrying without --trace-all');
+        emitLog('# mox-sim: runtime abort with --trace-all; retrying without --trace-all');
         try {
           simResult = await runSimAttempt({ withTraceAll: false, withVcd: true });
         } catch (retryError) {
           const retryableNoTrace = isRetryableSimAbortText(retryError?.message || retryError);
           if (!retryableNoTrace) throw retryError;
-          emitLog('# circt-sim: runtime abort while writing VCD; retrying without waveform capture');
+          emitLog('# mox-sim: runtime abort while writing VCD; retrying without waveform capture');
           simResult = await runSimAttempt({ withTraceAll: false, withVcd: false });
         }
       }
@@ -1634,7 +1634,7 @@ export class CirctWasmAdapter {
         if (sim.stdout) emitLog(`[stdout] ${sim.stdout}`);
         if (sim.stderr) emitLog(`[stderr] ${sim.stderr}`);
       }
-      appendNonZeroExit(logs, 'circt-sim', sim.exitCode, emitLog);
+      appendNonZeroExit(logs, 'mox-sim', sim.exitCode, emitLog);
 
       const rawVcdText = simResult.withVcd ? sim.files?.[wavePath] || null : null;
       const vcdText = fixLlhdVcdEncoding(removeInlinedPortsFromVcd(rawVcdText));
@@ -1657,11 +1657,11 @@ export class CirctWasmAdapter {
         ok: false,
         logs: [
           `# runtime unavailable: ${error.message}`,
-          `# circt-verilog js: ${this.config.toolchain.verilog.js}`,
-          `# circt-verilog wasm: ${this.config.toolchain.verilog.wasm}`,
-          `# circt-sim js: ${this.config.toolchain.sim.js}`,
-          `# circt-sim wasm: ${this.config.toolchain.sim.wasm}`,
-          '# run scripts/setup-circt.sh and npm run sync:circt to refresh artifacts'
+          `# mox-verilog js: ${this.config.toolchain.verilog.js}`,
+          `# mox-verilog wasm: ${this.config.toolchain.verilog.wasm}`,
+          `# mox-sim js: ${this.config.toolchain.sim.js}`,
+          `# mox-sim wasm: ${this.config.toolchain.sim.wasm}`,
+          '# run scripts/setup-mox.sh and npm run sync:mox to refresh artifacts'
         ],
         waveform: null
       };
@@ -1735,7 +1735,7 @@ export class CirctWasmAdapter {
           'for stable UVM compilation'
         );
       }
-      emitLog(formatCommand('circt-verilog', compileArgs));
+      emitLog(formatCommand('mox-verilog', compileArgs));
 
       if (typeof onStatus === 'function') onStatus('compiling');
       let compile;
@@ -1754,7 +1754,7 @@ export class CirctWasmAdapter {
       } catch (error) {
         const text = String(error?.message || error || '');
         if (useFullUvm && text.includes('Aborted(OOM)')) {
-          emitLog('# circt-verilog: out of memory compiling UVM — rebuild wasm with larger heap');
+          emitLog('# mox-verilog: out of memory compiling UVM — rebuild wasm with larger heap');
           if (typeof onStatus === 'function') onStatus('done');
           return { ok: false, logs };
         }
@@ -1764,7 +1764,7 @@ export class CirctWasmAdapter {
         if (compile.stdout) emitLog(`[stdout] ${compile.stdout}`);
         if (compile.stderr) emitLog(`[stderr] ${compile.stderr}`);
       }
-      appendNonZeroExit(logs, 'circt-verilog', compile.exitCode, emitLog);
+      appendNonZeroExit(logs, 'mox-verilog', compile.exitCode, emitLog);
 
       const mlirText = compile.files?.[mlirPath] || null;
       if (compile.exitCode !== 0 || !mlirText) {
@@ -1779,7 +1779,7 @@ export class CirctWasmAdapter {
         arg.replace('{top}', topModule).replace('{input}', mlirPath)
       );
 
-      emitLog(formatCommand('circt-bmc', bmcArgs));
+      emitLog(formatCommand('mox-bmc', bmcArgs));
 
       if (typeof onStatus === 'function') onStatus('running');
       const bmcStream = makeToolOutputHandler();
@@ -1799,7 +1799,7 @@ export class CirctWasmAdapter {
         .join('\n')
         .trim();
       if (!bmcStream.sawStream() && bmcStderr) emitLog(`[stderr] ${bmcStderr}`);
-      appendNonZeroExit(logs, 'circt-bmc', bmc.exitCode, emitLog);
+      appendNonZeroExit(logs, 'mox-bmc', bmc.exitCode, emitLog);
 
       const smtlibText = bmc.files?.[smtPath] || null;
       if (!smtlibText) {
@@ -1829,9 +1829,9 @@ export class CirctWasmAdapter {
         ok: false,
         logs: [
           `# runtime unavailable: ${error.message}`,
-          `# circt-bmc js: ${this.config.toolchain.bmc.js}`,
-          `# circt-bmc wasm: ${this.config.toolchain.bmc.wasm}`,
-          '# run scripts/setup-circt.sh to refresh artifacts'
+          `# mox-bmc js: ${this.config.toolchain.bmc.js}`,
+          `# mox-bmc wasm: ${this.config.toolchain.bmc.wasm}`,
+          '# run scripts/setup-mox.sh to refresh artifacts'
         ]
       };
     }
@@ -1888,7 +1888,7 @@ export class CirctWasmAdapter {
           sawStream: () => sawStream
         };
       };
-      emitLog(formatCommand('circt-verilog', compileArgs));
+      emitLog(formatCommand('mox-verilog', compileArgs));
 
       if (typeof onStatus === 'function') onStatus('compiling');
       const compileStream = makeToolOutputHandler();
@@ -1905,7 +1905,7 @@ export class CirctWasmAdapter {
         if (compile.stdout) emitLog(`[stdout] ${compile.stdout}`);
         if (compile.stderr) emitLog(`[stderr] ${compile.stderr}`);
       }
-      appendNonZeroExit(logs, 'circt-verilog', compile.exitCode, emitLog);
+      appendNonZeroExit(logs, 'mox-verilog', compile.exitCode, emitLog);
 
       const mlirText = compile.files?.[mlirPath] || null;
       if (compile.exitCode !== 0 || !mlirText) {
@@ -1925,8 +1925,8 @@ export class CirctWasmAdapter {
       // Check that the VPI sim is configured.
       const simVpi = this.config.toolchain.simVpi;
       if (!simVpi?.js || !simVpi?.wasm) {
-        emitLog('# VPI-capable circt-sim not configured');
-        emitLog('# set VITE_CIRCT_SIM_VPI_JS_URL and VITE_CIRCT_SIM_VPI_WASM_URL in .env');
+        emitLog('# VPI-capable mox-sim not configured');
+        emitLog('# set VITE_MOX_SIM_VPI_JS_URL and VITE_MOX_SIM_VPI_WASM_URL in .env');
         if (typeof onStatus === 'function') onStatus('done');
         return { ok: false, logs };
       }
@@ -2010,7 +2010,7 @@ export class CirctWasmAdapter {
           sawStream: () => sawStream
         };
       };
-      emitLog(formatCommand('circt-verilog', compileArgs));
+      emitLog(formatCommand('mox-verilog', compileArgs));
 
       if (typeof onStatus === 'function') onStatus('compiling');
       const compileStream = makeToolOutputHandler();
@@ -2027,7 +2027,7 @@ export class CirctWasmAdapter {
         if (compile.stdout) emitLog(`[stdout] ${compile.stdout}`);
         if (compile.stderr) emitLog(`[stderr] ${compile.stderr}`);
       }
-      appendNonZeroExit(logs, 'circt-verilog', compile.exitCode, emitLog);
+      appendNonZeroExit(logs, 'mox-verilog', compile.exitCode, emitLog);
 
       const mlirText = compile.files?.[mlirPath] || null;
       if (compile.exitCode !== 0 || !mlirText) {
@@ -2042,7 +2042,7 @@ export class CirctWasmAdapter {
            .replace('{input}', mlirPath)
       );
 
-      emitLog(formatCommand('circt-lec', lecArgs));
+      emitLog(formatCommand('mox-lec', lecArgs));
 
       if (typeof onStatus === 'function') onStatus('running');
       const lecStream = makeToolOutputHandler();
@@ -2061,7 +2061,7 @@ export class CirctWasmAdapter {
         .join('\n')
         .trim();
       if (!lecStream.sawStream() && lecStderr) emitLog(`[stderr] ${lecStderr}`);
-      appendNonZeroExit(logs, 'circt-lec', lec.exitCode, emitLog);
+      appendNonZeroExit(logs, 'mox-lec', lec.exitCode, emitLog);
 
       const smtlibText = lec.files?.[smtPath] || null;
       if (!smtlibText) {
@@ -2090,7 +2090,7 @@ export class CirctWasmAdapter {
         try {
           emitLog(`$ z3 -model ${smtPath} | grep define-fun`);
           const freshEm = await getFreshZ3Module();
-          // Insert (get-model) before (reset) — circt-lec SMT-LIB ends with
+          // Insert (get-model) before (reset) — mox-lec SMT-LIB ends with
           // (reset) which clears solver state; appending after it loses the model.
           const resetIdx = smtlibText.lastIndexOf('(reset)');
           const smtWithModel = resetIdx >= 0
@@ -2111,7 +2111,7 @@ export class CirctWasmAdapter {
             if (/^c\d+_/.test(name)) continue;
             const width = parseInt(widthStr, 10);
             const raw = val.startsWith('#x') ? parseInt(val.slice(2), 16) : parseInt(val.slice(2), 2);
-            // CIRCT encodes N-bit SV signals as 2N-bit SMT bitvectors: the lower N
+            // MOX encodes N-bit SV signals as 2N-bit SMT bitvectors: the lower N
             // bits are "unknown" flags and the upper N bits are the logic values.
             // Decode to the plain N-bit value when all unknown bits are zero.
             let displayVal = raw;
@@ -2149,21 +2149,21 @@ export class CirctWasmAdapter {
         ok: false,
         logs: [
           `# runtime unavailable: ${error.message}`,
-          `# circt-lec js: ${this.config.toolchain.lec?.js}`,
-          `# circt-lec wasm: ${this.config.toolchain.lec?.wasm}`,
-          '# run scripts/setup-circt.sh to refresh artifacts'
+          `# mox-lec js: ${this.config.toolchain.lec?.js}`,
+          `# mox-lec wasm: ${this.config.toolchain.lec?.wasm}`,
+          '# run scripts/setup-mox.sh to refresh artifacts'
         ]
       };
     }
   }
 }
 
-export function createCirctWasmAdapter() {
-  return new CirctWasmAdapter();
+export function createMoxWasmAdapter() {
+  return new MoxWasmAdapter();
 }
 
 let _adapter = null;
-export function getCirctWasmAdapter() {
-  _adapter ??= createCirctWasmAdapter();
+export function getMoxWasmAdapter() {
+  _adapter ??= createMoxWasmAdapter();
   return _adapter;
 }
diff --git a/src/runtime/circt-adapter.test.js b/src/runtime/mox-adapter.test.js
similarity index 93%
rename from src/runtime/circt-adapter.test.js
rename to src/runtime/mox-adapter.test.js
index 5c37ce7..c6e420e 100644
--- a/src/runtime/circt-adapter.test.js
+++ b/src/runtime/mox-adapter.test.js
@@ -1,8 +1,8 @@
 import { describe, expect, it } from 'vitest';
-import { CirctWasmAdapter } from './circt-adapter.js';
+import { MoxWasmAdapter } from './mox-adapter.js';
 
 function createAdapterWithInvokeTool(invokeTool) {
-  const adapter = new CirctWasmAdapter();
+  const adapter = new MoxWasmAdapter();
   adapter.init = async () => {
     adapter.ready = true;
   };
@@ -10,7 +10,7 @@ function createAdapterWithInvokeTool(invokeTool) {
   return adapter;
 }
 
-describe('CirctWasmAdapter.run with MLIR workspace input', () => {
+describe('MoxWasmAdapter.run with MLIR workspace input', () => {
   it('simulates MLIR input directly without requiring SystemVerilog files', async () => {
     const calls = [];
     const adapter = createAdapterWithInvokeTool(async (toolName, request) => {
diff --git a/src/runtime/mox-config.js b/src/runtime/mox-config.js
new file mode 100644
index 0000000..4a3436c
--- /dev/null
+++ b/src/runtime/mox-config.js
@@ -0,0 +1,139 @@
+export const MOX_FORK_REPO = 'git@github.com:normal-computing/mox.git';
+
+function normalizeBaseUrl(raw) {
+  const base = String(raw || '').trim();
+  if (!base || base === '.' || base === './') return '/';
+
+  // Normalize optional leading "./" used by static builds.
+  const noDotPrefix = base.startsWith('./') ? base.slice(1) : base;
+  const withLeadingSlash = noDotPrefix.startsWith('/') ? noDotPrefix : `/${noDotPrefix}`;
+  const withTrailingSlash = withLeadingSlash.endsWith('/')
+    ? withLeadingSlash
+    : `${withLeadingSlash}/`;
+
+  // Remove "/./" segments so "/./mox" becomes "/mox".
+  return withTrailingSlash.replace(/\/\.\//g, '/');
+}
+
+const BASE = normalizeBaseUrl(import.meta.env.VITE_BASE || import.meta.env.BASE_URL);
+
+export function getRuntimeBasePath() {
+  return BASE;
+}
+
+export const Z3_SCRIPT_URL = `${BASE}z3/z3-built.js`;
+const DEFAULT_TOOLCHAIN = {
+  verilog: {
+    js: `${BASE}mox/mox-verilog.js`,
+    wasm: `${BASE}mox/mox-verilog.wasm`
+  },
+  sim: {
+    js: `${BASE}mox/mox-sim.js`,
+    wasm: `${BASE}mox/mox-sim.wasm`
+  },
+  bmc: {
+    js: `${BASE}mox/mox-bmc.js`,
+    wasm: `${BASE}mox/mox-bmc.wasm`
+  },
+  simVpi: {
+    js: `${BASE}mox/mox-sim-vpi.js`,
+    wasm: `${BASE}mox/mox-sim-vpi.wasm`
+  },
+  lec: {
+    js: `${BASE}mox/mox-lec.js`,
+    wasm: `${BASE}mox/mox-lec.wasm`
+  }
+};
+
+const DEFAULT_VERILOG_ARGS = ['--resource-guard=false', '--ir-llhd', '--timescale', '1ns/1ns', '--single-unit'];
+const DEFAULT_LEC_VERILOG_ARGS = ['--resource-guard=false', '--ir-hw', '--single-unit'];
+const DEFAULT_LEC_ARGS = [
+  '--resource-guard=false',
+  '--assume-known-inputs',
+  '-c1', '{module1}',
+  '-c2', '{module2}',
+  '--emit-smtlib',
+  '-o', '/workspace/out/check.smt2',
+  '{input}'
+];
+const DEFAULT_SIM_ARGS = ['--resource-guard=false'];
+const DEFAULT_BMC_ARGS = [
+  '--resource-guard=false',
+  '--assume-known-inputs',
+  '-b',
+  '20',
+  '--module',
+  '{top}',
+  '--emit-smtlib',
+  '-o',
+  '/workspace/out/check.smt2',
+  '{input}'
+];
+
+function parseArgs(raw, fallback) {
+  if (!raw) return fallback;
+  try {
+    const parsed = JSON.parse(raw);
+    if (Array.isArray(parsed) && parsed.every((v) => typeof v === 'string')) {
+      return parsed;
+    }
+  } catch {
+    // Fallback to a simple shell-like split for convenience.
+  }
+  return raw
+    .split(' ')
+    .map((s) => s.trim())
+    .filter(Boolean);
+}
+
+function pickUrlFromEnv(primary, fallback) {
+  return primary || fallback;
+}
+
+export function getMoxRuntimeConfig() {
+  return {
+    toolchain: {
+      verilog: {
+        js: pickUrlFromEnv(import.meta.env.VITE_MOX_VERILOG_JS_URL, DEFAULT_TOOLCHAIN.verilog.js),
+        wasm: pickUrlFromEnv(import.meta.env.VITE_MOX_VERILOG_WASM_URL, DEFAULT_TOOLCHAIN.verilog.wasm)
+      },
+      sim: {
+        js: pickUrlFromEnv(import.meta.env.VITE_MOX_SIM_JS_URL, DEFAULT_TOOLCHAIN.sim.js),
+        wasm: pickUrlFromEnv(import.meta.env.VITE_MOX_SIM_WASM_URL, DEFAULT_TOOLCHAIN.sim.wasm)
+      },
+      bmc: {
+        js: pickUrlFromEnv(import.meta.env.VITE_MOX_BMC_JS_URL, DEFAULT_TOOLCHAIN.bmc.js),
+        wasm: pickUrlFromEnv(import.meta.env.VITE_MOX_BMC_WASM_URL, DEFAULT_TOOLCHAIN.bmc.wasm)
+      },
+      simVpi: {
+        js: pickUrlFromEnv(import.meta.env.VITE_MOX_SIM_VPI_JS_URL, DEFAULT_TOOLCHAIN.simVpi.js),
+        wasm: pickUrlFromEnv(import.meta.env.VITE_MOX_SIM_VPI_WASM_URL, DEFAULT_TOOLCHAIN.simVpi.wasm)
+      },
+      lec: {
+        js: pickUrlFromEnv(import.meta.env.VITE_MOX_LEC_JS_URL, DEFAULT_TOOLCHAIN.lec.js),
+        wasm: pickUrlFromEnv(import.meta.env.VITE_MOX_LEC_WASM_URL, DEFAULT_TOOLCHAIN.lec.wasm)
+      }
+    },
+    pyodideUrl: import.meta.env.VITE_PYODIDE_URL || `${BASE}pyodide/pyodide.js`,
+    verilogArgs: parseArgs(import.meta.env.VITE_MOX_VERILOG_ARGS, DEFAULT_VERILOG_ARGS),
+    simArgs: parseArgs(import.meta.env.VITE_MOX_SIM_ARGS, DEFAULT_SIM_ARGS),
+    bmcArgs: parseArgs(import.meta.env.VITE_MOX_BMC_ARGS, DEFAULT_BMC_ARGS),
+    lecVerilogArgs: parseArgs(import.meta.env.VITE_MOX_LEC_VERILOG_ARGS, DEFAULT_LEC_VERILOG_ARGS),
+    lecArgs: parseArgs(import.meta.env.VITE_MOX_LEC_ARGS, DEFAULT_LEC_ARGS),
+    note: import.meta.env.VITE_MOX_NOTE || ''
+  };
+}
+
+export function getRuntimeEnvDoc() {
+  return {
+    VITE_MOX_VERILOG_JS_URL: 'mox-verilog JS artifact URL.',
+    VITE_MOX_VERILOG_WASM_URL: 'mox-verilog WASM artifact URL.',
+    VITE_MOX_SIM_JS_URL: 'mox-sim JS artifact URL.',
+    VITE_MOX_SIM_WASM_URL: 'mox-sim WASM artifact URL.',
+    VITE_MOX_BMC_JS_URL: 'mox-bmc JS artifact URL.',
+    VITE_MOX_BMC_WASM_URL: 'mox-bmc WASM artifact URL.',
+    VITE_MOX_VERILOG_ARGS: 'JSON array or space-separated args passed before source files.',
+    VITE_MOX_SIM_ARGS: 'JSON array or space-separated args passed before MLIR input.',
+    VITE_MOX_BMC_ARGS: 'JSON array or space-separated args for BMC fallback.'
+  };
+}
diff --git a/src/runtime/circt-wasm-smoke.test.js b/src/runtime/mox-wasm-smoke.test.js
similarity index 77%
rename from src/runtime/circt-wasm-smoke.test.js
rename to src/runtime/mox-wasm-smoke.test.js
index e21c562..f4e3aaa 100644
--- a/src/runtime/circt-wasm-smoke.test.js
+++ b/src/runtime/mox-wasm-smoke.test.js
@@ -1,9 +1,9 @@
 /**
- * Integration tests that load and run the real CIRCT WASM artifacts via Node.js.
- * These tests require `static/circt/` to be populated (run `npm run sync:circt` first).
+ * Integration tests that load and run the real MOX WASM artifacts via Node.js.
+ * These tests require `static/mox/` to be populated (run `npm run sync:mox` first).
  *
- * circt-verilog.js uses NODERAWFS (real filesystem in Node.js), so we use a real
- * temp directory as the workspace. circt-sim.js is patched to use MEMFS, so it
+ * mox-verilog.js uses NODERAWFS (real filesystem in Node.js), so we use a real
+ * temp directory as the workspace. mox-sim.js is patched to use MEMFS, so it
  * works with any virtual path.
  */
 import { describe, it, expect, beforeAll, afterAll } from 'vitest';
@@ -14,21 +14,21 @@ import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { createRequire } from 'node:module';
 
-const CIRCT_DIR = path.resolve(
+const MOX_DIR = path.resolve(
   path.dirname(fileURLToPath(import.meta.url)),
-  '../../static/circt'
+  '../../static/mox'
 );
 
-const artifactsPresent = fs.existsSync(path.join(CIRCT_DIR, 'circt-verilog.js'));
+const artifactsPresent = fs.existsSync(path.join(MOX_DIR, 'mox-verilog.js'));
 
 /**
- * Load a CIRCT WASM tool into an isolated vm context.
+ * Load a MOX WASM tool into an isolated vm context.
  * Returns an object with `invoke(inputFiles, args)` that resets output capture per call.
  */
 async function loadTool(toolName, { initTimeout = 45_000 } = {}) {
-  const jsPath = path.join(CIRCT_DIR, `${toolName}.js`);
+  const jsPath = path.join(MOX_DIR, `${toolName}.js`);
   if (!fs.existsSync(jsPath)) {
-    throw new Error(`WASM artifact not found: ${jsPath}\nRun: npm run sync:circt`);
+    throw new Error(`WASM artifact not found: ${jsPath}\nRun: npm run sync:mox`);
   }
   const source = fs.readFileSync(jsPath, 'utf8');
 
@@ -36,7 +36,7 @@ async function loadTool(toolName, { initTimeout = 45_000 } = {}) {
   const capture = { out: '', err: '' };
 
   // Custom require that intercepts `require('fs')` to capture fd=1/2 writes.
-  // circt-verilog uses NODERAWFS which calls fs.writeSync(1, ...) for stdout,
+  // mox-verilog uses NODERAWFS which calls fs.writeSync(1, ...) for stdout,
   // bypassing Emscripten's `out` function and Module.print entirely.
   const realRequire = createRequire(jsPath);
   const patchedFsRequire = (id) => {
@@ -81,7 +81,7 @@ async function loadTool(toolName, { initTimeout = 45_000 } = {}) {
     setInterval,
     clearInterval,
     performance,
-    __dirname: CIRCT_DIR,
+    __dirname: MOX_DIR,
     __filename: jsPath,
   };
   context.globalThis = context;
@@ -91,7 +91,7 @@ async function loadTool(toolName, { initTimeout = 45_000 } = {}) {
   // instead of console.log / console.error.
   context.Module = {
     noInitialRun: true,
-    locateFile: (f) => path.join(CIRCT_DIR, f),
+    locateFile: (f) => path.join(MOX_DIR, f),
     print:    (s) => { capture.out += s + '\n'; },
     printErr: (s) => { capture.err += s + '\n'; },
   };
@@ -152,17 +152,17 @@ function waitForReady(context, ms) {
 
 // ---------------------------------------------------------------------------
 
-describe.skipIf(!artifactsPresent)('CIRCT WASM smoke tests', { timeout: 90_000 }, () => {
+describe.skipIf(!artifactsPresent)('MOX WASM smoke tests', { timeout: 90_000 }, () => {
   let verilog;
   let sim;
-  // Real temp directory — required because circt-verilog uses NODERAWFS (real fs).
+  // Real temp directory — required because mox-verilog uses NODERAWFS (real fs).
   let WORK;
 
   beforeAll(async () => {
-    WORK = fs.mkdtempSync(path.join(os.tmpdir(), 'circt-smoke-'));
+    WORK = fs.mkdtempSync(path.join(os.tmpdir(), 'mox-smoke-'));
     [verilog, sim] = await Promise.all([
-      loadTool('circt-verilog'),
-      loadTool('circt-sim'),
+      loadTool('mox-verilog'),
+      loadTool('mox-sim'),
     ]);
   }, 60_000);
 
@@ -170,15 +170,15 @@ describe.skipIf(!artifactsPresent)('CIRCT WASM smoke tests', { timeout: 90_000 }
     fs.rmSync(WORK, { recursive: true, force: true });
   });
 
-  // -- circt-verilog --
+  // -- mox-verilog --
 
-  it('circt-verilog --version exits 0', () => {
+  it('mox-verilog --version exits 0', () => {
     const { exitCode, stdout, stderr } = verilog.invoke({}, ['--version']);
     expect(exitCode).toBe(0);
-    expect(stdout + stderr).toMatch(/circt|CIRCT/i);
+    expect(stdout + stderr).toMatch(/mox|MOX/i);
   });
 
-  it('circt-verilog compiles a simple combinational module', () => {
+  it('mox-verilog compiles a simple combinational module', () => {
     const sv = `
 module top (input logic a, b, output logic y);
   assign y = a & b;
@@ -195,24 +195,24 @@ endmodule
     expect(mlir).toContain('hw.module @top');
   });
 
-  // -- circt-sim --
+  // -- mox-sim --
 
-  it('circt-sim --version exits 0', () => {
+  it('mox-sim --version exits 0', () => {
     const { exitCode, stdout, stderr } = sim.invoke({}, ['--version']);
     expect(exitCode).toBe(0);
-    expect(stdout + stderr).toMatch(/circt|CIRCT/i);
+    expect(stdout + stderr).toMatch(/mox|MOX/i);
   });
 
-  it('circt-sim simulates a minimal testbench end-to-end', () => {
+  it('mox-sim simulates a minimal testbench end-to-end', () => {
     const sv = `
 module tb;
   initial begin
-    $display("circt-sim-ok");
+    $display("mox-sim-ok");
     $finish;
   end
 endmodule
 `;
-    // Compile SV → MLIR via circt-verilog (NODERAWFS → real filesystem)
+    // Compile SV → MLIR via mox-verilog (NODERAWFS → real filesystem)
     const svPath   = `${WORK}/tb.sv`;
     const mlirPath = `${WORK}/tb.mlir`;
     const { exitCode: compileExit } = verilog.invoke(
@@ -222,12 +222,12 @@ endmodule
     expect(compileExit).toBe(0);
     const mlir = verilog.readFile(mlirPath);
 
-    // Simulate MLIR via circt-sim (MEMFS — NODERAWFS was patched out)
+    // Simulate MLIR via mox-sim (MEMFS — NODERAWFS was patched out)
     const { exitCode, stdout, stderr } = sim.invoke(
       { '/workspace/tb.mlir': mlir },
       ['--top', 'tb', '/workspace/tb.mlir'],
     );
     expect(exitCode).toBe(0);
-    expect(stdout + stderr).toContain('circt-sim-ok');
+    expect(stdout + stderr).toContain('mox-sim-ok');
   });
 });
diff --git a/src/runtime/vpi-abi.js b/src/runtime/vpi-abi.js
index f650bb2..63d4f53 100644
--- a/src/runtime/vpi-abi.js
+++ b/src/runtime/vpi-abi.js
@@ -1,5 +1,5 @@
 /**
- * Shared VPI ABI constants/helpers for wasm32 circt-sim bridges.
+ * Shared VPI ABI constants/helpers for wasm32 mox-sim bridges.
  *
  * Keep this as the single source of truth for:
  * - VPI enum values used by JS <-> wasm calls
diff --git a/src/runtime/vpi-abi.test.js b/src/runtime/vpi-abi.test.js
index 70c6e12..92a340e 100644
--- a/src/runtime/vpi-abi.test.js
+++ b/src/runtime/vpi-abi.test.js
@@ -41,7 +41,7 @@ function makeMockModule(bytes = 1024) {
 }
 
 describe('vpi-abi constants', () => {
-  it('matches CIRCT VPI value/time enums', () => {
+  it('matches MOX VPI value/time enums', () => {
     expect(VPI.vpiIntVal).toBe(6);
     expect(VPI.vpiScalarVal).toBe(5);
     expect(VPI.vpiVectorVal).toBe(9);
diff --git a/src/runtime/worker-shim.test.js b/src/runtime/worker-shim.test.js
index d496c67..3d9c985 100644
--- a/src/runtime/worker-shim.test.js
+++ b/src/runtime/worker-shim.test.js
@@ -1,6 +1,6 @@
 /**
  * Unit tests for the NODERAWFS process shim used in WORKER_SOURCE and
- * COCOTB_WORKER_SOURCE inside circt-adapter.js.
+ * COCOTB_WORKER_SOURCE inside mox-adapter.js.
  *
  * Emscripten tools compiled with NODERAWFS call process.version.match(/v(\d+)/)
  * to detect the Node.js major version.  Before the fix, the shim set
diff --git a/vite.config.js b/vite.config.js
index fe66663..e31141a 100644
--- a/vite.config.js
+++ b/vite.config.js
@@ -94,7 +94,7 @@ export default defineConfig({
     target: 'esnext',
     minify: 'esbuild',
     sourcemap: true,
-    // Single chunk is ~218 kB gzipped (CodeMirror + Svelte + CIRCT adapter).
+    // Single chunk is ~218 kB gzipped (CodeMirror + Svelte + MOX adapter).
     // The raw size exceeds Rollup's 500 kB default but gzip makes it fine.
     chunkSizeWarningLimit: 800,
     rollupOptions: {